using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Lightbug.CharacterControllerPro.Core;
using Lightbug.CharacterControllerPro.Implementation;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.UI;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.UI;
using UnityEngine.UIElements;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ControllerSupport")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ff1bbba8d38aea5c762f8f77f4aacb1f7c8d74ae")]
[assembly: AssemblyProduct("ControllerSupport")]
[assembly: AssemblyTitle("ControllerSupport")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ControllerSupport
{
	[BepInPlugin("com.ttr.controllersupport", "ControllerSupport", "1.7.86")]
	[DefaultExecutionOrder(-100)]
	public class ControllerSupportPlugin : BaseUnityPlugin
	{
		public enum ResponseCurveType
		{
			Linear,
			Exponential,
			Aggressive,
			Smooth
		}

		internal enum ListType
		{
			None,
			Papyrus,
			DeadTied
		}

		private enum StockpileNavArea
		{
			Items,
			Footer
		}

		private class StockpileItemData
		{
			public VisualElement Item;

			public Button TakeButton;
		}

		internal class NavGrid
		{
			public List<List<Selectable>> columns = new List<List<Selectable>>();

			public NavGrid(List<Selectable> selectables)
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				if (selectables.Count == 0)
				{
					return;
				}
				List<Selectable> list = selectables.OrderBy((Selectable s) => GetScreenPos(s).x).ToList();
				List<Selectable> list2 = new List<Selectable>();
				float num = GetScreenPos(list[0]).x;
				foreach (Selectable item in list)
				{
					float x = GetScreenPos(item).x;
					if (Mathf.Abs(x - num) > 200f && list2.Count > 0)
					{
						columns.Add(list2);
						list2 = new List<Selectable>();
					}
					list2.Add(item);
					num = x;
				}
				if (list2.Count > 0)
				{
					columns.Add(list2);
				}
				foreach (List<Selectable> column in columns)
				{
					column.Sort(delegate(Selectable a, Selectable b)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						//IL_0006: Unknown result type (might be due to invalid IL or missing references)
						//IL_000f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0025: Unknown result type (might be due to invalid IL or missing references)
						//IL_002a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0033: Unknown result type (might be due to invalid IL or missing references)
						int num3 = GetScreenPos(b).y.CompareTo(GetScreenPos(a).y);
						return (num3 != 0) ? num3 : GetScreenPos(a).x.CompareTo(GetScreenPos(b).x);
					});
				}
				for (int num2 = 0; num2 < columns.Count; num2++)
				{
					List<Selectable> list3 = columns[num2];
					list3.Average((Selectable s) => GetScreenPos(s).x);
					foreach (Selectable item2 in list3)
					{
						GetScreenPos(item2);
					}
				}
			}

			public Selectable FindNeighbor(Selectable current, int dx, int dy)
			{
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				int num = -1;
				int num2 = -1;
				for (int i = 0; i < columns.Count; i++)
				{
					for (int j = 0; j < columns[i].Count; j++)
					{
						if ((Object)(object)columns[i][j] == (Object)(object)current)
						{
							num = i;
							num2 = j;
							break;
						}
					}
					if (num >= 0)
					{
						break;
					}
				}
				if (num < 0)
				{
					return null;
				}
				if (dy != 0)
				{
					int num3 = num2 + ((dy <= 0) ? 1 : (-1));
					if (num3 >= 0 && num3 < columns[num].Count)
					{
						return columns[num][num3];
					}
				}
				if (dx != 0)
				{
					int num4 = num + dx;
					if (num4 < 0 || num4 >= columns.Count)
					{
						return null;
					}
					int count = columns[num4].Count;
					if (count == 0)
					{
						return null;
					}
					float y = GetScreenPos(current).y;
					Selectable result = null;
					float num5 = float.MaxValue;
					int index = Math.Min(num2, count - 1);
					Selectable val = columns[num4][index];
					float num6 = Mathf.Abs(GetScreenPos(val).y - y);
					if (num6 < 150f)
					{
						result = val;
						num5 = num6;
					}
					else
					{
						string text = "";
						foreach (Selectable item in columns[num4])
						{
							float num7 = Mathf.Abs(GetScreenPos(item).y - y);
							text += $"{((Object)item).name}[Y={GetScreenPos(item).y:F1},delta={num7:F1}] ";
							if (num7 < num5)
							{
								num5 = num7;
								result = item;
							}
						}
					}
					return result;
				}
				return null;
			}

			public int GetColumnForX(float x)
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				float num = float.MaxValue;
				int result = -1;
				for (int i = 0; i < columns.Count; i++)
				{
					if (columns[i].Count == 0)
					{
						continue;
					}
					float num2 = 0f;
					int num3 = 0;
					for (int j = 0; j < columns[i].Count; j++)
					{
						Selectable val = columns[i][j];
						if ((Object)(object)val != (Object)null && Object.op_Implicit((Object)(object)val))
						{
							num2 += GetScreenPos(val).x;
							num3++;
						}
					}
					if (num3 != 0)
					{
						num2 /= (float)num3;
						float num4 = Mathf.Abs(num2 - x);
						if (num4 < num)
						{
							num = num4;
							result = i;
						}
					}
				}
				return result;
			}

			public Selectable FindYClosestInColumn(float currentY, int colIdx)
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				if (colIdx < 0 || colIdx >= columns.Count)
				{
					return null;
				}
				Selectable result = null;
				float num = float.MaxValue;
				foreach (Selectable item in columns[colIdx])
				{
					if (!((Object)(object)item == (Object)null) && Object.op_Implicit((Object)(object)item))
					{
						float num2 = Mathf.Abs(GetScreenPos(item).y - currentY);
						if (num2 < num)
						{
							num = num2;
							result = item;
						}
					}
				}
				return result;
			}
		}

		private enum WellNavArea
		{
			RecipeList,
			RightPanel,
			MapList,
			HomeCards
		}

		private class HomeCardData
		{
			public VisualElement Card;

			public List<VisualElement> Elements = new List<VisualElement>();
		}

		public const string PluginGuid = "com.ttr.controllersupport";

		public const string PluginName = "ControllerSupport";

		public const string PluginVersion = "1.7.86";

		internal static ManualLogSource Logger;

		internal static InputAction _jumpAction = null;

		internal static bool _papyrusOpen = false;

		private static InputAction _lookAction = null;

		private static bool _lookActionDisabled = false;

		private static InputAction _cameraAction = null;

		private static bool _cameraActionDisabled = false;

		internal static ConfigEntry<float> LeftStickDeadzone;

		internal static ConfigEntry<float> RightStickDeadzone;

		internal static ConfigEntry<float> LeftTriggerDeadzone;

		internal static ConfigEntry<ResponseCurveType> LeftStickCurve;

		internal static ConfigEntry<ResponseCurveType> RightStickCurve;

		internal static ConfigEntry<float> LeftStickExponent;

		internal static ConfigEntry<float> RightStickExponent;

		internal static ConfigEntry<float> LookSensitivity;

		internal static ConfigEntry<float> MovementSensitivity;

		internal static ConfigEntry<bool> ToggleCrouch;

		internal static ConfigEntry<bool> ToggleSprint;

		internal static ConfigEntry<bool> InvertLookY;

		private static bool actionsInjected = false;

		internal static bool CrouchToggled = false;

		internal static bool SprintToggled = false;

		private static bool prevCrouchButton = false;

		private static bool prevSprintButton = false;

		private static bool _blockCrouchToggleUntilRelease = false;

		internal static readonly (string action, string path)[] DefaultBindings = new(string, string)[17]
		{
			("Movement", "<Gamepad>/leftStick"),
			("Run", "<Gamepad>/leftStickPress"),
			("Look", "<Gamepad>/rightStick"),
			("Jump", "<Gamepad>/buttonSouth"),
			("Crouch", "<Gamepad>/buttonEast"),
			("Interact", "<Gamepad>/buttonWest"),
			("Push To Talk", "<Gamepad>/buttonNorth"),
			("Ragdoll", "<Gamepad>/leftShoulder"),
			("Drop", "<Gamepad>/rightShoulder"),
			("Push", "<Gamepad>/leftTrigger"),
			("Attack", "<Gamepad>/rightTrigger"),
			("Inventory", "<Gamepad>/select"),
			("Pause", "<Gamepad>/start"),
			("Item1", "<Gamepad>/dpad/up"),
			("Item2", "<Gamepad>/dpad/right"),
			("Item3", "<Gamepad>/dpad/down"),
			("Item4", "<Gamepad>/dpad/left")
		};

		internal static readonly Dictionary<string, string> RuntimeBindings = new Dictionary<string, string>();

		private static float lastProcessorUpdateTime = -1f;

		private const float PROCESSOR_UPDATE_INTERVAL = 0.3f;

		private static bool processorUpdatePending = false;

		private static float _nextInjectRetryTime = 0f;

		private static bool _wasUiOpen = false;

		internal static object _cachedPlayerController = null;

		private static object _cachedMenuController = null;

		internal static FieldInfo _isUiOpenField;

		internal static bool _pcSearched = false;

		private static float _nextPlayerControllerSearchTime = 0f;

		internal static int _uiPanelOpenCount = 0;

		internal static float _prevSprintMoveMag = 0f;

		internal static bool _movedSinceSprintToggle = false;

		internal static Slider _selectedSlider = null;

		internal static bool _sliderEditMode = false;

		private static float _sliderNavRepeatTimer = 0f;

		private static float _lastSliderHoriz = 0f;

		private static float _sliderOriginalValue = 0f;

		private static Color _sliderOriginalHandleColor;

		private static bool _sliderColorStored = false;

		private static float _sliderEditAccum = 0f;

		private static bool _sliderTypeLogged = false;

		internal static int _sliderSetGuardCount = 0;

		internal static int _sliderSetValueGuardCount = 0;

		internal static float _sliderEditStepCooldown = 0f;

		internal static bool _sliderOriginalWholeNumbers = false;

		internal static bool _sliderForceFractional = false;

		internal static Selectable _pendingNavFocus = null;

		internal static float _pendingNavTimer = 0f;

		internal static Canvas _rebindOverlayCanvas = null;

		internal static int _pendingNavDx = 0;

		internal static int _pendingNavDy = 0;

		internal static int _voiceChatGuardFrames = 0;

		internal static MonoBehaviour _disabledVoiceChatComponent = null;

		internal static Type _voiceChatOptionsButtonType = null;

		private static Type _wellPanelModeEnum;

		private static Array _wellPanelModeValues;

		private static int _currentWellTab = 0;

		private static bool _wellPanelModeResolved = false;

		private static MethodInfo _changeWellPanelMethod;

		private static float _autoFocusRetryTimer = 0f;

		internal static int _bButtonConsumedFrames = 0;

		internal static bool _suppressNextDescriptionDisableClose = false;

		internal static bool _uiWasOpenLastFrame = false;

		private static bool _serverListReadyForFocus = false;

		private static bool _serverListAutoFocused = false;

		private static bool _serverListPanelWasActive = false;

		private static float _serverListScrollAccum = 0f;

		private static float _overlayScrollAccum = 0f;

		private static List<Selectable> _cachedServerElements = new List<Selectable>();

		private static int _cachedServerElementIdx = -1;

		private static int _serverListLastFocusFrame = -5;

		private static bool _serverListNavHeldDown = false;

		private static bool _serverListNavRepeatPhase = false;

		private static float _serverListNavLastStepTime = -1f;

		internal static ListType _currentListType = ListType.None;

		internal static bool _taskListOpen = false;

		internal static int _taskListSelectedIndex = -1;

		private static bool _taskListNavHeldDown = false;

		private static bool _taskListNavRepeatPhase = false;

		private static float _taskListNavLastStepTime = -1f;

		internal static FieldInfo _taskPanelField = null;

		internal static FieldInfo _taskPapyrusField = null;

		internal static FieldInfo _taskElementParentField = null;

		internal static FieldInfo _buttonGraphicField = null;

		internal static FieldInfo _taskTextField = null;

		internal static Color _origTaskTextColor = Color.white;

		internal static TaskListUI _cachedTaskListUI = null;

		internal static List<(PlayerTaskElement element, Image graphic, Image buttonGraphic, GameObject highlightChild, Component mmUiEventListener)> _cachedTaskElements = new List<(PlayerTaskElement, Image, Image, GameObject, Component)>();

		private static Color _origHighlightColor = new Color(1f, 1f, 1f, 0f);

		private static Color _origElementGraphicColor = new Color(1f, 1f, 1f, 0f);

		private static bool _origElementGraphicColorCaptured = false;

		private static readonly Color _selectedHighlightColor = new Color(0f, 1f, 0.3f, 1f);

		private static readonly Color _selectedButtonGraphicColor = new Color(1f, 1f, 1f, 0.35f);

		internal static Color _origFoldoutTitleColor = Color.white;

		private static bool _graphicFallbackLogged = false;

		private static bool _textFallbackLogged = false;

		private static bool _highlightDiagLogged = false;

		private static bool _overlayDiagLogged = false;

		private static bool _feedbackDiagLogged = false;

		private static bool _diagDumpLogged = false;

		internal static bool _lateUpdaterDiagLogged = false;

		internal static bool _lateUpdaterActiveDiagLogged = false;

		private static int _highlightCallCount = 0;

		private static bool? _cursorPreviouslyVisible = null;

		internal static bool _inactiveElementsLogged = false;

		internal static GraphicRaycaster _disabledRaycaster = null;

		internal static bool _prevTaskPanelActive = false;

		internal static PropertyInfo _tiedOrDeadPropInfo = null;

		internal static bool _deadTiedCleanupPending = false;

		internal static bool _lastInputWasGamepad = false;

		private static float _lastMouseMoveTime = 0f;

		private static Vector2 _lastMousePos = Vector2.zero;

		private static float _lastGamepadInputTime = -10f;

		private const float GAMEPAD_INPUT_TIMEOUT = 0.25f;

		private static int _papyrusCacheRetryCount = 0;

		private const int MAX_PAPYRUS_CACHE_RETRIES = 60;

		private static int _deadTiedCacheRetryCount = 0;

		private const int MAX_DEADTIED_CACHE_RETRIES = 60;

		private static FieldInfo _mmEnterFeedbackField = null;

		private static FieldInfo _mmExitFeedbackField = null;

		private static MethodInfo _mmPlayFeedbacksMethod = null;

		private static FieldInfo _foldoutTitleField = null;

		private static FieldInfo _foldoutObjectField = null;

		private static Sprite _highlightSprite = null;

		private static Texture2D _highlightTex = null;

		internal static bool _overlayClosedByRelease = false;

		internal static bool _mouseOpenedInfoOverlay = false;

		internal static bool _infoOverlayOpen = false;

		internal static int _infoFoldoutIndex = -1;

		private static bool _infoFoldoutNavHeldDown = false;

		private static bool _infoFoldoutNavRepeatPhase = false;

		private static float _infoFoldoutNavLastStepTime = -1f;

		private static bool _overlayStickDiagLogged = false;

		internal static int _papyrusAPressFrame = -1;

		internal static bool _sideEffectCloseDetected = false;

		internal static FieldInfo _descToggleField = null;

		internal static DescriptionDisplayer _cachedDescriptionDisplayer = null;

		internal static FieldInfo _descriptionContainerField = null;

		internal static List<(DescriptionElement element, Toggle toggle)> _cachedFoldouts = new List<(DescriptionElement, Toggle)>();

		internal static ScrollRect _foldoutScrollRect = null;

		private static float _deferredScrollTopTimer = -1f;

		private static int _deferredScrollTopIdx = -1;

		internal static bool _suppressManualNavThisFrame = false;

		internal static float _lastControllerInputTime = -10f;

		internal static bool _controllerModeActive = false;

		private static float _lastFoldoutCacheLogTime = -1f;

		private static int _lastFoldoutCacheCount = -1;

		internal static bool _lastSettingsVisible = false;

		private static bool _wasSettingsOpen = false;

		private static bool _wasPlayerMenuOpen = false;

		private static GameObject _lastLoggedPlayerMenuPanel = null;

		internal static List<Selectable> _cachedSelectables = null;

		internal static bool _cacheNeedsRebuild = true;

		private static FieldInfo _netFieldCache;

		private static FieldInfo _brainFieldCache;

		private static PropertyInfo _scPropCache;

		private static PropertyInfo _netStateControllerPropCache;

		private static PropertyInfo _currentStatePropCache;

		private static float _wallSlideCheckTimer = 0f;

		private static bool _wallSlideCachedResult = false;

		private static FieldInfo _wcpFieldCache;

		private static FieldInfo _homeUpgradePanelFieldCache;

		private static FieldInfo _mapPanelFieldCache;

		private static FieldInfo _equipmentCraftingPanelFieldCache;

		private static FieldInfo _furnitureCraftingPanelFieldCache;

		private static FieldInfo _potionCraftingPanelFieldCache;

		private static VisualElement _cachedStockpilePanel = null;

		private static VisualElement _cachedStockpileDisplay = null;

		private static ScrollView _cachedStockpileScrollView = null;

		private static Button _cachedStockpileDepositButton = null;

		private static Button _cachedStockpileCloseButton = null;

		private static readonly List<StockpileItemData> _cachedStockpileItems = new List<StockpileItemData>();

		private static readonly List<Button> _cachedStockpileFooterButtons = new List<Button>();

		private static StockpileNavArea _stockpileNavArea = StockpileNavArea.Items;

		private static int _stockpileNavIndex = 0;

		private static int _stockpileNavColumn = 1;

		private static float _stockpileScrollAccum = 0f;

		private static float _stockpileLastNavX = 0f;

		private static float _stockpileLastNavY = 0f;

		private static bool _stockpileNavActive = false;

		private static FieldInfo _descDispFieldCache;

		private static FieldInfo _ingameMenuFieldCache;

		private static FieldInfo _settingsPanelFieldCache;

		private static FieldInfo[] _playerUiPanelFieldCache;

		private static Vector2 _lastNavStick;

		internal static float _navRepeatTimer;

		private const float NAV_INITIAL_DELAY = 0.4f;

		private const float NAV_REPEAT_RATE = 0.25f;

		internal static NavGrid _navGrid;

		private static int _wellNavIndex = 0;

		private static float _wellScrollAccum = 0f;

		private static float _wellLastDPadY = 0f;

		private static float _wellLastDPadX = 0f;

		private static VisualElement _cachedRootVE = null;

		private static ListView _cachedRecipeList = null;

		private static Button _cachedCraftBtn = null;

		private static List<Button> _cachedCostBtns = null;

		private static List<Button> _cachedMapBtns = null;

		private static List<List<HomeCardData>> _homeGrid = new List<List<HomeCardData>>();

		private static int _homeGridColumns = 0;

		private static int _homeCurrentRow = 0;

		private static int _homeCurrentCol = 0;

		private static int _homeElementIndex = 0;

		private static WellNavArea _wellNavArea = WellNavArea.RecipeList;

		private static bool _wellNavActive = false;

		private static Type _pcTypeCached = null;

		private static VisualElement _wellVisualFocusElement = null;

		private static StyleFloat _wellVisualFocusBorderTop;

		private static StyleFloat _wellVisualFocusBorderRight;

		private static StyleFloat _wellVisualFocusBorderBottom;

		private static StyleFloat _wellVisualFocusBorderLeft;

		private static StyleColor _wellVisualFocusBorderTopColor;

		private static StyleColor _wellVisualFocusBorderRightColor;

		private static StyleColor _wellVisualFocusBorderBottomColor;

		private static StyleColor _wellVisualFocusBorderLeftColor;

		private static StyleColor _wellVisualFocusBackground;

		private static object _handControllerInstance = null;

		private static MethodInfo _changeHandTargetDistanceMethod = null;

		private static MethodInfo _serverManagerGetLocalPlayerMethod = null;

		private static PropertyInfo _localPlayerHandControllerProperty = null;

		private static bool _handControllerSearched = false;

		private static float _nextHandControllerSearchTime = 0f;

		private const float HAND_CONTROLLER_SEARCH_COOLDOWN = 2f;

		private static float _handRangeStep = 0.5f;

		private static float _handRangeRepeatDelay = 0.3f;

		private static float _handRangeRepeatRate = 0.08f;

		private static float _lbHoldTime = -1f;

		private static float _rbHoldTime = -1f;

		private static object _inputHandlerInstance = null;

		private static MethodInfo _inputHandlerGetBool = null;

		private static bool _inputHandlerSearched = false;

		private static bool? _gloveRangeAdjustChecked;

		private static FieldInfo _gloveRangeActiveField;

		private static FieldInfo _glovePressingField;

		internal static string BindingsFilePath => Path.Combine(Paths.ConfigPath, "controller-bindings.json");

		private static void LoadBindings()
		{
			try
			{
				if (File.Exists(BindingsFilePath))
				{
					string[] array = File.ReadAllLines(BindingsFilePath);
					for (int i = 0; i < array.Length; i++)
					{
						string text = array[i].Trim();
						if (!string.IsNullOrEmpty(text) && !text.StartsWith("#"))
						{
							int num = text.IndexOf('|');
							if (num > 0 && num < text.Length - 1)
							{
								string key = text.Substring(0, num).Trim();
								string value = text.Substring(num + 1).Trim();
								RuntimeBindings[key] = value;
							}
						}
					}
				}
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"[ControllerSupport] Failed to load bindings: {arg}");
			}
			(string, string)[] defaultBindings = DefaultBindings;
			for (int i = 0; i < defaultBindings.Length; i++)
			{
				var (key2, value2) = defaultBindings[i];
				if (!RuntimeBindings.ContainsKey(key2))
				{
					RuntimeBindings[key2] = value2;
				}
			}
		}

		internal static void SaveBindings()
		{
			try
			{
				List<string> list = new List<string> { "# Controller bindings - format: action|path" };
				foreach (KeyValuePair<string, string> runtimeBinding in RuntimeBindings)
				{
					list.Add(runtimeBinding.Key + "|" + runtimeBinding.Value);
				}
				File.WriteAllLines(BindingsFilePath, list);
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"[ControllerSupport] Failed to save bindings: {arg}");
			}
		}

		private void Awake()
		{
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			LeftStickDeadzone = ((BaseUnityPlugin)this).Config.Bind<float>("Deadzones", "LeftStick", 0.05f, "Deadzone for left stick (0.00-0.30). Values below this are zeroed.");
			RightStickDeadzone = ((BaseUnityPlugin)this).Config.Bind<float>("Deadzones", "RightStick", 0.05f, "Deadzone for right stick (0.00-0.30). Values below this are zeroed.");
			LeftTriggerDeadzone = ((BaseUnityPlugin)this).Config.Bind<float>("Deadzones", "LeftTrigger", 0.1f, "Deadzone for left trigger (0-0.5).");
			LeftStickCurve = ((BaseUnityPlugin)this).Config.Bind<ResponseCurveType>("Response", "LeftStickCurve", ResponseCurveType.Linear, "Response curve for left stick (movement).");
			RightStickCurve = ((BaseUnityPlugin)this).Config.Bind<ResponseCurveType>("Response", "RightStickCurve", ResponseCurveType.Linear, "Response curve for right stick (camera).");
			LeftStickExponent = ((BaseUnityPlugin)this).Config.Bind<float>("Response", "LeftStickExponent", 2f, "Exponent for exponential/aggressive curves.");
			RightStickExponent = ((BaseUnityPlugin)this).Config.Bind<float>("Response", "RightStickExponent", 2f, "Exponent for right stick curves.");
			LookSensitivity = ((BaseUnityPlugin)this).Config.Bind<float>("Input", "LookSensitivity", 1f, "Camera look sensitivity multiplier.");
			MovementSensitivity = ((BaseUnityPlugin)this).Config.Bind<float>("Input", "MovementSensitivity", 1f, "Movement input sensitivity multiplier.");
			ToggleCrouch = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "ToggleCrouch", false, "Toggle crouch instead of hold.");
			ToggleSprint = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "ToggleSprint", false, "Toggle sprint instead of hold.");
			InvertLookY = ((BaseUnityPlugin)this).Config.Bind<bool>("Input", "InvertLookY", false, "Invert vertical camera look.");
			InputSystem.settings.defaultDeadzoneMin = 0f;
			LoadBindings();
			Harmony.CreateAndPatchAll(typeof(InputPatches), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(ToggleActionPatches), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(WallSlideCrouchReleasePatch), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(DescriptionDisplayerPatch), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(UIPatches), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(CameraCurvePatch), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(SelectableOnMovePatch), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(SliderOnMovePatch), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(SliderSetPatch), "com.ttr.controllersupport");
			DerivedSliderPatches.InitializeDerivedSliderPatching();
			ExecuteMoveHandlerPatch.Initialize();
			Harmony.CreateAndPatchAll(typeof(OptionsButtonUpdatePatch), "com.ttr.controllersupport");
			try
			{
				Harmony.CreateAndPatchAll(typeof(EventSystemFocusPatch), "com.ttr.controllersupport");
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("[ControllerSupport] Could not patch EventSystem.SetSelectedGameObject: " + ex.Message));
			}
			Harmony.CreateAndPatchAll(typeof(InputSystemHandlerReadyPatch), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(StaminaPatches), "com.ttr.controllersupport");
			try
			{
				Harmony.CreateAndPatchAll(typeof(PlayerRevivedPatch), "com.ttr.controllersupport");
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"[ControllerSupport] PlayerRevivedPatch registration FAILED: {arg}");
			}
			try
			{
				Harmony.CreateAndPatchAll(typeof(PlayerUntiedPatch), "com.ttr.controllersupport");
			}
			catch (Exception arg2)
			{
				Logger.LogError((object)$"[ControllerSupport] PlayerUntiedPatch registration FAILED: {arg2}");
			}
			Harmony.CreateAndPatchAll(typeof(ToggleTaskListPatch), "com.ttr.controllersupport");
			try
			{
				Harmony.CreateAndPatchAll(typeof(RefreshMouseStatePatch), "com.ttr.controllersupport");
			}
			catch (Exception arg3)
			{
				Logger.LogError((object)$"[ControllerSupport] RefreshMouseStatePatch registration FAILED: {arg3}");
			}
			Harmony.CreateAndPatchAll(typeof(ProcessJumpPatch), "com.ttr.controllersupport");
			Harmony.CreateAndPatchAll(typeof(TogglePapyrusRpcPatch), "com.ttr.controllersupport");
			try
			{
				Harmony.CreateAndPatchAll(typeof(TaskElementClickPatch), "com.ttr.controllersupport");
			}
			catch (Exception ex2)
			{
				Logger.LogWarning((object)("[ControllerSupport] Could not patch PlayerTaskElement.OnPointerClick: " + ex2.Message));
			}
			Logger.LogInfo((object)"ControllerSupport v1.7.86 loaded!");
			GameObject val = new GameObject("TaskHighlightLateUpdater");
			Object.DontDestroyOnLoad((Object)val);
			val.AddComponent<TaskHighlightLateUpdater>();
			TaskHighlightLateUpdater.Init(Logger);
		}

		private void Update()
		{
			TrackInputDevice();
			if (!actionsInjected && Time.unscaledTime >= _nextInjectRetryTime)
			{
				if (TryInjectBindings())
				{
					_nextInjectRetryTime = 0f;
				}
				else
				{
					_nextInjectRetryTime = Time.unscaledTime + 1.5f;
				}
			}
			Gamepad current = Gamepad.current;
			if (current == null)
			{
				object playerController = GetPlayerController();
				if (playerController != null)
				{
					if (_taskPanelField == null)
					{
						_taskPanelField = AccessTools.Field(playerController.GetType(), "taskPanel");
					}
					if (_taskPapyrusField == null)
					{
						_taskPapyrusField = AccessTools.Field(playerController.GetType(), "taskPapyrusList");
					}
					bool flag = false;
					bool flag2 = false;
					if (_taskPanelField != null)
					{
						object? value = _taskPanelField.GetValue(playerController);
						GameObject val = (GameObject)((value is GameObject) ? value : null);
						flag = (Object)(object)val != (Object)null && val.activeInHierarchy;
					}
					if (_taskPapyrusField != null)
					{
						object? value2 = _taskPapyrusField.GetValue(playerController);
						GameObject val2 = (GameObject)((value2 is GameObject) ? value2 : null);
						flag2 = (Object)(object)val2 != (Object)null && val2.activeInHierarchy;
					}
					if (!flag && !flag2)
					{
						EnableLookAndCameraActions();
						ClearAllTaskAndFoldoutState();
					}
					else if (flag)
					{
						Cursor.visible = true;
						Cursor.lockState = (CursorLockMode)0;
						if (_currentListType != ListType.DeadTied)
						{
							_currentListType = ListType.DeadTied;
						}
						_taskListOpen = true;
					}
				}
				UpdateLookActionState();
				return;
			}
			try
			{
				HandleUINavigation(current);
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"[ControllerSupport] HandleUINavigation: {arg}");
			}
			if (_bButtonConsumedFrames > 0)
			{
				_bButtonConsumedFrames--;
			}
			if (processorUpdatePending && Time.unscaledTime - lastProcessorUpdateTime >= 0.3f)
			{
				processorUpdatePending = false;
				lastProcessorUpdateTime = Time.unscaledTime;
				try
				{
					UpdateBindingProcessorsInternal();
				}
				catch (Exception arg2)
				{
					Logger.LogError((object)$"[ControllerSupport] UpdateBindingProcessors: {arg2}");
				}
			}
			_uiWasOpenLastFrame = IsGameplayBlockingUiOpen();
			try
			{
				HandleHandRange(current);
			}
			catch (Exception arg3)
			{
				Logger.LogError((object)$"[ControllerSupport] HandleHandRange: {arg3}");
			}
		}

		internal static bool TryInjectBindings()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (actionsInjected)
			{
				return true;
			}
			InputActionAsset[] array = Resources.FindObjectsOfTypeAll<InputActionAsset>();
			if (array == null || array.Length == 0)
			{
				return false;
			}
			InputActionAsset val = null;
			InputActionAsset[] array2 = array;
			foreach (InputActionAsset val2 in array2)
			{
				if (val2.actionMaps.Count > 0)
				{
					val = val2;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				InjectGamepadBindings(val);
				actionsInjected = true;
				return true;
			}
			catch (InvalidOperationException ex)
			{
				Logger.LogWarning((object)("[ControllerSupport] Gamepad binding injection deferred/failed: " + ex.Message));
				return false;
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"[ControllerSupport] Gamepad binding injection failed: {arg}");
				return false;
			}
		}

		private static void InjectGamepadBindings(InputActionAsset asset)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			bool enabled = asset.enabled;
			asset.Disable();
			Enumerator<InputActionMap> enumerator = asset.actionMaps.GetEnumerator();
			InputBinding val;
			BindingSyntax val2;
			try
			{
				while (enumerator.MoveNext())
				{
					Enumerator<InputAction> enumerator2 = enumerator.Current.actions.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							InputAction current = enumerator2.Current;
							ReadOnlyArray<InputBinding> bindings = current.bindings;
							for (int num = bindings.Count - 1; num >= 0; num--)
							{
								val = bindings[num];
								if (((InputBinding)(ref val)).groups != null)
								{
									val = bindings[num];
									if (((InputBinding)(ref val)).groups.Contains("Gamepad"))
									{
										val2 = InputActionSetupExtensions.ChangeBinding(current, num);
										((BindingSyntax)(ref val2)).Erase();
									}
								}
							}
						}
					}
					finally
					{
						((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			bool flag = false;
			Enumerator<InputControlScheme> enumerator3 = asset.controlSchemes.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					InputControlScheme current2 = enumerator3.Current;
					if (((InputControlScheme)(ref current2)).name == "Gamepad")
					{
						flag = true;
						break;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
			}
			if (!flag)
			{
				InputControlScheme val3 = InputActionSetupExtensions.WithRequiredDevice(new InputControlScheme("Gamepad", (IEnumerable<DeviceRequirement>)null, (string)null), "<Gamepad>");
				InputActionSetupExtensions.AddControlScheme(asset, val3);
			}
			(string, string)[] defaultBindings = DefaultBindings;
			for (int i = 0; i < defaultBindings.Length; i++)
			{
				(string, string) tuple = defaultBindings[i];
				string item = tuple.Item1;
				string item2 = tuple.Item2;
				InputAction val4 = asset.FindAction(item, false);
				if (val4 != null)
				{
					string value;
					string text = (RuntimeBindings.TryGetValue(item, out value) ? value : item2);
					val = default(InputBinding);
					val2 = InputActionSetupExtensions.AddBinding(val4, val);
					val2 = ((BindingSyntax)(ref val2)).WithPath(text);
					BindingSyntax val5 = ((BindingSyntax)(ref val2)).WithGroup("Gamepad");
					if (item == "Movement")
					{
						float value2 = LeftStickDeadzone.Value;
						float value3 = MovementSensitivity.Value;
						((BindingSyntax)(ref val5)).WithProcessor($"StickDeadzone(min={value2:F3},max=1.000),ScaleVector2(x={value3:F3},y={value3:F3})");
					}
					else if (item == "Look")
					{
						float value4 = RightStickDeadzone.Value;
						((BindingSyntax)(ref val5)).WithProcessor($"StickDeadzone(min={value4:F3},max=1.000)");
					}
				}
				else
				{
					Logger.LogDebug((object)("[ControllerSupport] Action '" + item + "' not found in asset."));
				}
			}
			if (enabled)
			{
				asset.Enable();
			}
			CacheLookAction(asset);
		}

		private static void CacheLookAction(InputActionAsset asset)
		{
			if (_lookAction != null)
			{
				return;
			}
			_lookAction = asset.FindAction("Look", false);
			if (_lookAction == null)
			{
				Logger.LogWarning((object)"[ControllerSupport] Could not find 'Look' InputAction in asset — camera block will not work");
			}
			if (_cameraAction == null)
			{
				_cameraAction = asset.FindAction("Camera", false);
				if (_cameraAction == null)
				{
					Logger.LogWarning((object)"[ControllerSupport] Could not find 'Camera' InputAction in asset — M&K mouse look block will not work");
				}
			}
		}

		internal static void EnableLookAndCameraActions()
		{
			if (_lookAction != null && !_lookAction.enabled)
			{
				_lookAction.Enable();
			}
			if (_cameraAction != null && !_cameraAction.enabled)
			{
				_cameraAction.Enable();
			}
		}

		internal static void UpdateLookActionState()
		{
			bool flag = _currentListType == ListType.DeadTied && (_infoOverlayOpen || _taskListOpen);
			if (_lookAction != null)
			{
				if (flag && !_lookActionDisabled)
				{
					if (_lookAction.enabled)
					{
						_lookAction.Disable();
					}
					_lookActionDisabled = true;
				}
				else if (!flag && _lookActionDisabled)
				{
					if (!_lookAction.enabled)
					{
						_lookAction.Enable();
					}
					_lookActionDisabled = false;
				}
			}
			if (_cameraAction == null)
			{
				return;
			}
			if (flag && !_cameraActionDisabled)
			{
				if (_cameraAction.enabled)
				{
					_cameraAction.Disable();
				}
				_cameraActionDisabled = true;
			}
			else if (!flag && _cameraActionDisabled)
			{
				if (!_cameraAction.enabled)
				{
					_cameraAction.Enable();
				}
				_cameraActionDisabled = false;
			}
		}

		internal static void UpdateBindingProcessors()
		{
			processorUpdatePending = true;
		}

		internal static void UpdateBindingProcessorsInternal()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			InputActionAsset[] array = Resources.FindObjectsOfTypeAll<InputActionAsset>();
			if (array == null || array.Length == 0)
			{
				return;
			}
			InputActionAsset val = null;
			InputActionAsset[] array2 = array;
			foreach (InputActionAsset val2 in array2)
			{
				if (val2.actionMaps.Count > 0)
				{
					val = val2;
					break;
				}
			}
			if (!((Object)(object)val == (Object)null))
			{
				InputAction val3 = val.FindAction("Movement", false);
				if (val3 != null)
				{
					float value = LeftStickDeadzone.Value;
					float value2 = MovementSensitivity.Value;
					UpdateActionGamepadProcessors(val3, $"StickDeadzone(min={value:F3},max=1.000),ScaleVector2(x={value2:F3},y={value2:F3})");
				}
				InputAction val4 = val.FindAction("Look", false);
				if (val4 != null)
				{
					float value3 = RightStickDeadzone.Value;
					UpdateActionGamepadProcessors(val4, $"StickDeadzone(min={value3:F3},max=1.000)");
				}
			}
		}

		private static void UpdateActionGamepadProcessors(InputAction action, string processorsString)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			ReadOnlyArray<InputBinding> bindings = action.bindings;
			for (int i = 0; i < bindings.Count; i++)
			{
				InputBinding val = bindings[i];
				if (((InputBinding)(ref val)).groups != null)
				{
					val = bindings[i];
					if (((InputBinding)(ref val)).groups.Contains("Gamepad"))
					{
						BindingSyntax val2 = InputActionSetupExtensions.ChangeBinding(action, i);
						((BindingSyntax)(ref val2)).WithProcessors(processorsString);
						break;
					}
				}
			}
		}

		private static void AutoUnlatchSprintIfStopped()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!ToggleSprint.Value || !SprintToggled)
			{
				return;
			}
			Gamepad current = Gamepad.current;
			if (current != null)
			{
				Vector2 val = ((InputControl<Vector2>)(object)current.leftStick).ReadValue();
				if (((Vector2)(ref val)).magnitude < 0.01f)
				{
					SprintToggled = false;
				}
			}
		}

		internal static Selectable FindOverlayNeighbor(Selectable source, int dx, int dy)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_rebindOverlayCanvas == (Object)null || (Object)(object)source == (Object)null)
			{
				return null;
			}
			GameObject gameObject = ((Component)_rebindOverlayCanvas).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				return null;
			}
			Vector2 screenPos = GetScreenPos(source);
			Selectable result = null;
			float num = float.MaxValue;
			Selectable[] allSelectablesArray = Selectable.allSelectablesArray;
			foreach (Selectable val in allSelectablesArray)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)source)
				{
					continue;
				}
				try
				{
					if (!((UIBehaviour)val).IsActive() || !val.IsInteractable())
					{
						continue;
					}
					goto IL_008d;
				}
				catch
				{
				}
				continue;
				IL_008d:
				if (!((Component)val).transform.IsChildOf(gameObject.transform) || (Object)(object)((Component)val).GetComponent<Button>() == (Object)null || (Object)(object)((Component)val).transform == (Object)(object)gameObject.transform)
				{
					continue;
				}
				Vector2 screenPos2 = GetScreenPos(val);
				float num2 = screenPos2.x - screenPos.x;
				float num3 = screenPos2.y - screenPos.y;
				if ((dx == 0 || ((int)Mathf.Sign(num2) == dx && !(Mathf.Abs(num2) < 5f) && !(Mathf.Abs(num3) > 2000f))) && (dy == 0 || ((int)Mathf.Sign(num3) == dy && !(Mathf.Abs(num3) < 5f) && !(Mathf.Abs(num2) > 2000f))))
				{
					float num4 = ((dx != 0) ? Mathf.Abs(num2) : Mathf.Abs(num3));
					float num5 = ((dx != 0) ? Mathf.Abs(num3) : Mathf.Abs(num2));
					float num6 = num4 + num5 * 2f;
					if (num6 < num)
					{
						num = num6;
						result = val;
					}
				}
			}
			return result;
		}

		internal static bool IsOverlayActive()
		{
			if ((Object)(object)_rebindOverlayCanvas != (Object)null && (Object)(object)((Component)_rebindOverlayCanvas).gameObject != (Object)null)
			{
				return ((Component)_rebindOverlayCanvas).gameObject.activeInHierarchy;
			}
			return false;
		}

		internal static void DisableVoiceChatComponent(GameObject go)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			if (!((Object)(object)_disabledVoiceChatComponent != (Object)null) && !((Object)(object)go == (Object)null) && !(_voiceChatOptionsButtonType == null))
			{
				Component component = go.GetComponent(_voiceChatOptionsButtonType);
				if ((Object)(object)component != (Object)null)
				{
					MonoBehaviour val = (MonoBehaviour)component;
					((Behaviour)val).enabled = false;
					_disabledVoiceChatComponent = val;
				}
			}
		}

		internal static void ReenableVoiceChatComponent()
		{
			if (!((Object)(object)_disabledVoiceChatComponent == (Object)null))
			{
				((Behaviour)_disabledVoiceChatComponent).enabled = true;
				_disabledVoiceChatComponent = null;
			}
		}

		internal static bool IsVoiceChatGameObject(GameObject go)
		{
			if ((Object)(object)go != (Object)null)
			{
				if (!((Object)go).name.Contains("voiceChat"))
				{
					return ((Object)go).name.Contains("VoiceChat");
				}
				return true;
			}
			return false;
		}

		private static void EnsureHighlightResources()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_highlightTex == (Object)null)
			{
				_highlightTex = new Texture2D(1, 1);
				_highlightTex.SetPixel(0, 0, Color.white);
				_highlightTex.Apply();
				((Object)_highlightTex).hideFlags = (HideFlags)61;
				_highlightSprite = Sprite.Create(_highlightTex, new Rect(0f, 0f, 1f, 1f), Vector2.zero);
				((Object)_highlightSprite).hideFlags = (HideFlags)61;
			}
		}

		internal static void RequestCacheRebuild()
		{
			_cacheNeedsRebuild = true;
		}

		internal static IEnumerator DelayedRebuild(float delay)
		{
			yield return (object)new WaitForSeconds(delay);
			RequestCacheRebuild();
		}

		internal static void OnGameRestarted()
		{
			actionsInjected = false;
			if (_lookAction != null && !_lookAction.enabled)
			{
				_lookAction.Enable();
			}
			_lookAction = null;
			_lookActionDisabled = false;
			if (_cameraAction != null && !_cameraAction.enabled)
			{
				_cameraAction.Enable();
			}
			_cameraAction = null;
			_cameraActionDisabled = false;
			_cachedPlayerController = null;
			_cachedMenuController = null;
			_pcSearched = false;
			_isUiOpenField = null;
			_cachedSelectables = null;
			_cacheNeedsRebuild = true;
			_navGrid = null;
			_wasUiOpen = false;
			_wasSettingsOpen = false;
			_wasPlayerMenuOpen = false;
			_lastLoggedPlayerMenuPanel = null;
			_serverListReadyForFocus = true;
			_lastSettingsVisible = false;
			_wcpFieldCache = null;
			_homeUpgradePanelFieldCache = null;
			_mapPanelFieldCache = null;
			_equipmentCraftingPanelFieldCache = null;
			_furnitureCraftingPanelFieldCache = null;
			_potionCraftingPanelFieldCache = null;
			_wellPanelModeResolved = false;
			_cachedStockpilePanel = null;
			_cachedStockpileDepositButton = null;
			_cachedStockpileCloseButton = null;
			_stockpileNavActive = false;
			ResetWellNavCache();
			_ingameMenuFieldCache = null;
			_settingsPanelFieldCache = null;
			_playerUiPanelFieldCache = null;
			_descDispFieldCache = null;
			_wallSlideCachedResult = false;
			_wallSlideCheckTimer = 0f;
			UIPatches.lastMenuPanel = null;
			UIPatches.lastPlayerPanel = null;
			_blockCrouchToggleUntilRelease = false;
			if (_sliderEditMode)
			{
				ExitSliderEditMode(confirm: true);
			}
			_sliderEditAccum = 0f;
			_selectedSlider = null;
			_sliderEditMode = false;
			ClearAllTaskAndFoldoutState();
			_taskPanelField = null;
			_taskPapyrusField = null;
			_taskElementParentField = null;
			_buttonGraphicField = null;
			_origElementGraphicColorCaptured = false;
			_highlightDiagLogged = false;
			_feedbackDiagLogged = false;
			_diagDumpLogged = false;
			_lateUpdaterDiagLogged = false;
			_lateUpdaterActiveDiagLogged = false;
			_inactiveElementsLogged = false;
			_highlightCallCount = 0;
			_prevTaskPanelActive = false;
			_deadTiedCleanupPending = false;
			_taskListNavHeldDown = false;
			_taskListNavLastStepTime = -1f;
			_cachedTaskListUI = null;
			_infoFoldoutNavHeldDown = false;
			_infoFoldoutNavLastStepTime = -1f;
			_descToggleField = null;
			_descriptionContainerField = null;
			if (_cursorPreviouslyVisible.HasValue)
			{
				Cursor.visible = _cursorPreviouslyVisible.Value;
				Cursor.lockState = (CursorLockMode)0;
				_cursorPreviouslyVisible = null;
			}
			_nextInjectRetryTime = 0f;
			GetPlayerController();
		}

		internal static void RegisterMenuController(MenuController menuController)
		{
			if (!((Object)(object)menuController == (Object)null))
			{
				_cachedMenuController = menuController;
			}
		}

		internal static object GetPlayerController()
		{
			if (_pcSearched && IsUnityObjectAlive(_cachedPlayerController) && IsLocalPlayerController(_cachedPlayerController))
			{
				return _cachedPlayerController;
			}
			if (_pcSearched && _cachedPlayerController == null && Time.unscaledTime < _nextPlayerControllerSearchTime)
			{
				return null;
			}
			Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
			{
				try
				{
					return a.GetTypes();
				}
				catch
				{
					return new Type[0];
				}
			}).FirstOrDefault((Type t) => t.Name == "PlayerController");
			if (type == null)
			{
				return null;
			}
			_cachedPlayerController = ResolveLocalPlayerController(type);
			_pcSearched = true;
			if (_cachedPlayerController == null)
			{
				_nextPlayerControllerSearchTime = Time.unscaledTime + 1f;
			}
			if (_isUiOpenField == null)
			{
				_isUiOpenField = AccessTools.Field(type, "isUiOpen");
			}
			return _cachedPlayerController;
		}

		private static object ResolveLocalPlayerController(Type pcType)
		{
			try
			{
				if (_serverManagerGetLocalPlayerMethod == null)
				{
					_serverManagerGetLocalPlayerMethod = AccessTools.Method(AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
					{
						try
						{
							return a.GetTypes();
						}
						catch
						{
							return new Type[0];
						}
					}).FirstOrDefault((Type t) => t.Name == "ServerManager"), "GetLocalPlayer", (Type[])null, (Type[])null);
				}
				object obj = _serverManagerGetLocalPlayerMethod?.Invoke(null, null);
				if (IsUnityObjectAlive(obj))
				{
					object obj2 = AccessTools.Property(obj.GetType(), "Controller")?.GetValue(obj, null);
					if (IsUnityObjectAlive(obj2))
					{
						return obj2;
					}
				}
			}
			catch
			{
			}
			try
			{
				MethodInfo method = typeof(Object).GetMethod("FindObjectsOfType", new Type[0]);
				if (method == null)
				{
					return null;
				}
				if (!(method.MakeGenericMethod(pcType).Invoke(null, null) is Array array))
				{
					return null;
				}
				foreach (object item in array)
				{
					if (IsUnityObjectAlive(item) && IsLocalPlayerController(item))
					{
						return item;
					}
				}
				foreach (object item2 in array)
				{
					if (IsUnityObjectAlive(item2))
					{
						return item2;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static bool IsLocalPlayerController(object controller)
		{
			if (!IsUnityObjectAlive(controller))
			{
				return false;
			}
			try
			{
				if (IsLocalPlayer(controller) || IsNetworkOwner(controller))
				{
					return true;
				}
				object obj = AccessTools.Field(controller.GetType(), "networking")?.GetValue(controller);
				return IsUnityObjectAlive(obj) && (IsLocalPlayer(obj) || IsNetworkOwner(obj));
			}
			catch
			{
				return false;
			}
		}

		internal static bool IsWallSliding()
		{
			if (Time.time - _wallSlideCheckTimer < 0.1f)
			{
				return _wallSlideCachedResult;
			}
			_wallSlideCheckTimer = Time.time;
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				_wallSlideCachedResult = false;
				return false;
			}
			if (_netFieldCache == null)
			{
				_netFieldCache = AccessTools.Field(playerController.GetType(), "networking");
			}
			if (_netFieldCache == null)
			{
				_wallSlideCachedResult = false;
				return false;
			}
			object value = _netFieldCache.GetValue(playerController);
			if (value == null)
			{
				_wallSlideCachedResult = false;
				return false;
			}
			if (_netStateControllerPropCache == null)
			{
				_netStateControllerPropCache = value.GetType().GetProperty("StateController");
			}
			object obj = _netStateControllerPropCache?.GetValue(value);
			if (obj == null)
			{
				if (_brainFieldCache == null)
				{
					_brainFieldCache = AccessTools.Field(playerController.GetType(), "brain");
				}
				object obj2 = _brainFieldCache?.GetValue(playerController);
				if (obj2 != null)
				{
					if (_scPropCache == null)
					{
						_scPropCache = obj2.GetType().GetProperty("CharacterStateController");
					}
					obj = _scPropCache?.GetValue(obj2);
				}
			}
			if (obj == null)
			{
				_wallSlideCachedResult = false;
				return false;
			}
			if (_currentStatePropCache == null)
			{
				_currentStatePropCache = obj.GetType().GetProperty("CurrentState");
			}
			if (_currentStatePropCache == null)
			{
				_wallSlideCachedResult = false;
				return false;
			}
			object value2 = _currentStatePropCache.GetValue(obj);
			if (value2 == null)
			{
				_wallSlideCachedResult = false;
				return false;
			}
			_wallSlideCachedResult = value2.GetType().Name == "WallSlide";
			return _wallSlideCachedResult;
		}

		internal static bool IsUiOpen()
		{
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				return false;
			}
			if (_isUiOpenField == null)
			{
				_isUiOpenField = AccessTools.Field(playerController.GetType(), "isUiOpen");
			}
			bool flag = false;
			if (_isUiOpenField != null)
			{
				flag = (bool)_isUiOpenField.GetValue(playerController);
			}
			if (_uiPanelOpenCount > 0)
			{
				if (flag)
				{
					return true;
				}
				_uiPanelOpenCount = 0;
			}
			if (!flag && IsInGameMenuOpen(playerController))
			{
				flag = true;
			}
			if (!flag)
			{
				GameObject playerSettingsPanel = GetPlayerSettingsPanel(playerController);
				if ((Object)(object)playerSettingsPanel != (Object)null && playerSettingsPanel.activeInHierarchy)
				{
					flag = true;
				}
			}
			return flag;
		}

		private static bool IsInGameMenuOpen(object pc = null)
		{
			pc = pc ?? GetPlayerController();
			if (pc == null)
			{
				return false;
			}
			GameObject rawInGameMenuPanel = GetRawInGameMenuPanel(pc);
			if ((Object)(object)rawInGameMenuPanel != (Object)null)
			{
				return rawInGameMenuPanel.activeInHierarchy;
			}
			return false;
		}

		private static GameObject GetPlayerSettingsPanel(object pc = null)
		{
			pc = pc ?? GetPlayerController();
			if (pc == null)
			{
				return null;
			}
			if (_settingsPanelFieldCache == null)
			{
				_settingsPanelFieldCache = AccessTools.Field(pc.GetType(), "settingsPanel");
			}
			object? obj = _settingsPanelFieldCache?.GetValue(pc);
			return (GameObject)((obj is GameObject) ? obj : null);
		}

		private static GameObject GetInGameMenuPanel(object pc = null)
		{
			return GetRawInGameMenuPanel(pc);
		}

		private static GameObject GetRawInGameMenuPanel(object pc = null)
		{
			pc = pc ?? GetPlayerController();
			if (pc == null)
			{
				return null;
			}
			if (_ingameMenuFieldCache == null)
			{
				_ingameMenuFieldCache = AccessTools.Field(pc.GetType(), "ingameMenu");
			}
			object? obj = _ingameMenuFieldCache?.GetValue(pc);
			return (GameObject)((obj is GameObject) ? obj : null);
		}

		private static GameObject FindActivePlayerUiPanel(object pc = null, bool includeSettings = true)
		{
			pc = pc ?? GetPlayerController();
			if (pc == null)
			{
				return null;
			}
			Type type = pc.GetType();
			if (_playerUiPanelFieldCache == null)
			{
				_playerUiPanelFieldCache = (from f in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
					where typeof(GameObject).IsAssignableFrom(f.FieldType)
					select f).ToArray();
			}
			GameObject result = null;
			int num = 0;
			FieldInfo[] playerUiPanelFieldCache = _playerUiPanelFieldCache;
			foreach (FieldInfo fieldInfo in playerUiPanelFieldCache)
			{
				if (!includeSettings && fieldInfo.Name.IndexOf("settings", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					continue;
				}
				object? value = fieldInfo.GetValue(pc);
				GameObject val = (GameObject)((value is GameObject) ? value : null);
				if (IsNavigablePlayerPanel(val))
				{
					int num3 = val.GetComponentsInChildren<Selectable>(false).Count((Selectable s) => (Object)(object)s != (Object)null && ((UIBehaviour)s).IsActive() && s.IsInteractable());
					string text = (fieldInfo.Name + " " + ((Object)val).name).ToLowerInvariant();
					if (text.Contains("menu") || text.Contains("pause") || text.Contains("setting"))
					{
						num3 += 1000;
					}
					if (num3 > num)
					{
						num = num3;
						result = val;
					}
				}
			}
			return result;
		}

		private static bool IsNavigablePlayerPanel(GameObject panel)
		{
			if ((Object)(object)panel == (Object)null || !panel.activeInHierarchy)
			{
				return false;
			}
			try
			{
				return panel.GetComponentsInChildren<Selectable>(false).Any((Selectable s) => (Object)(object)s != (Object)null && ((UIBehaviour)s).IsActive() && s.IsInteractable());
			}
			catch
			{
				return false;
			}
		}

		private static void LogPlayerMenuPanelState(GameObject panel)
		{
			if (!((Object)(object)panel == (Object)null) && !((Object)(object)panel == (Object)(object)_lastLoggedPlayerMenuPanel))
			{
				_lastLoggedPlayerMenuPanel = panel;
			}
		}

		private static bool IsElementDisplayed(VisualElement element)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			if (element == null)
			{
				return false;
			}
			for (VisualElement val = element; val != null; val = val.parent)
			{
				try
				{
					if (!val.visible)
					{
						return false;
					}
				}
				catch
				{
				}
				try
				{
					if ((int)val.resolvedStyle.display == 1)
					{
						return false;
					}
				}
				catch
				{
				}
				try
				{
					StyleEnum<DisplayStyle> display = val.style.display;
					if ((int)display.keyword != 1 && (int)display.value == 1)
					{
						return false;
					}
				}
				catch
				{
				}
			}
			return true;
		}

		internal static bool IsGameplayBlockingUiOpen()
		{
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				return false;
			}
			if (!IsUiOpen() && !IsWellUiOpen(playerController) && !IsStockpileUiOpen())
			{
				return IsDescriptionOverlayOpen();
			}
			return true;
		}

		internal static bool IsWellUiOpen(object pc = null)
		{
			pc = pc ?? GetPlayerController();
			if (pc == null)
			{
				return false;
			}
			Type type = pc.GetType();
			if (_wcpFieldCache == null)
			{
				_wcpFieldCache = AccessTools.Field(type, "wellCraftingPanel");
			}
			object? obj = _wcpFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj is VisualElement) ? obj : null)))
			{
				return true;
			}
			if (_homeUpgradePanelFieldCache == null)
			{
				_homeUpgradePanelFieldCache = AccessTools.Field(type, "homeUpgradePanel");
			}
			object? obj2 = _homeUpgradePanelFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj2 is VisualElement) ? obj2 : null)))
			{
				return true;
			}
			if (_mapPanelFieldCache == null)
			{
				_mapPanelFieldCache = AccessTools.Field(type, "mapPanel");
			}
			object? obj3 = _mapPanelFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj3 is VisualElement) ? obj3 : null)))
			{
				return true;
			}
			if (_equipmentCraftingPanelFieldCache == null)
			{
				_equipmentCraftingPanelFieldCache = AccessTools.Field(type, "equipmentCraftingPanel");
			}
			object? obj4 = _equipmentCraftingPanelFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj4 is VisualElement) ? obj4 : null)))
			{
				return true;
			}
			if (_furnitureCraftingPanelFieldCache == null)
			{
				_furnitureCraftingPanelFieldCache = AccessTools.Field(type, "furnitureCraftingPanel");
			}
			object? obj5 = _furnitureCraftingPanelFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj5 is VisualElement) ? obj5 : null)))
			{
				return true;
			}
			if (_potionCraftingPanelFieldCache == null)
			{
				_potionCraftingPanelFieldCache = AccessTools.Field(type, "potionCraftingPanel");
			}
			object? obj6 = _potionCraftingPanelFieldCache?.GetValue(pc);
			return IsElementDisplayed((VisualElement)((obj6 is VisualElement) ? obj6 : null));
		}

		internal static bool IsStockpileUiOpen()
		{
			CacheWellRoot();
			if (_cachedRootVE == null)
			{
				return false;
			}
			_cachedStockpilePanel = UQueryExtensions.Q<VisualElement>(_cachedRootVE, "Stockpile", (string)null);
			return IsElementDisplayed(_cachedStockpilePanel);
		}

		private static void ResetStockpileNavCache()
		{
			ClearWellControllerHighlight();
			_cachedStockpilePanel = null;
			_cachedStockpileDisplay = null;
			_cachedStockpileScrollView = null;
			_cachedStockpileDepositButton = null;
			_cachedStockpileCloseButton = null;
			_cachedStockpileItems.Clear();
			_cachedStockpileFooterButtons.Clear();
			_stockpileNavArea = StockpileNavArea.Items;
			_stockpileNavIndex = 0;
			_stockpileNavColumn = 1;
			_stockpileScrollAccum = 0f;
			_stockpileLastNavX = 0f;
			_stockpileLastNavY = 0f;
			_stockpileNavActive = false;
		}

		private static void CacheStockpileElements()
		{
			CacheWellRoot();
			if (_cachedRootVE != null)
			{
				_cachedStockpilePanel = UQueryExtensions.Q<VisualElement>(_cachedRootVE, "Stockpile", (string)null);
				if (_cachedStockpilePanel != null)
				{
					_cachedStockpileDisplay = UQueryExtensions.Q<VisualElement>(_cachedStockpilePanel, "StockpileDisplay", (string)null);
					_cachedStockpileScrollView = ((_cachedStockpileDisplay != null) ? UQueryExtensions.Q<ScrollView>(_cachedStockpileDisplay, (string)null, (string)null) : null);
					CacheStockpileItems();
					CacheStockpileFooterButtons();
				}
			}
		}

		private static void CacheStockpileItems()
		{
			_cachedStockpileItems.Clear();
			ScrollView cachedStockpileScrollView = _cachedStockpileScrollView;
			VisualElement val = ((cachedStockpileScrollView != null) ? ((VisualElement)cachedStockpileScrollView).contentContainer : null);
			if (val == null)
			{
				return;
			}
			foreach (VisualElement item in val.Children())
			{
				if (IsElementDisplayed(item) && (item.ClassListContains("item-display") || !(((object)item).GetType().Name != "ItemDisplayView")))
				{
					Button val2 = FindDescendantButtonWithClass(item, "item-display__button_take");
					if (val2 != null && IsElementDisplayed((VisualElement)(object)val2))
					{
						_cachedStockpileItems.Add(new StockpileItemData
						{
							Item = item,
							TakeButton = val2
						});
					}
				}
			}
		}

		private static void CacheStockpileFooterButtons()
		{
			_cachedStockpileFooterButtons.Clear();
			_cachedStockpileDepositButton = UQueryExtensions.Q<Button>(_cachedStockpilePanel, "DepositResources", (string)null);
			_cachedStockpileCloseButton = UQueryExtensions.Q<Button>(_cachedStockpilePanel, "CloseMenu", (string)null);
			if (_cachedStockpileDepositButton != null && IsElementDisplayed((VisualElement)(object)_cachedStockpileDepositButton))
			{
				_cachedStockpileFooterButtons.Add(_cachedStockpileDepositButton);
			}
			if (_cachedStockpileCloseButton != null && IsElementDisplayed((VisualElement)(object)_cachedStockpileCloseButton))
			{
				_cachedStockpileFooterButtons.Add(_cachedStockpileCloseButton);
			}
		}

		private static Button FindDescendantButtonWithClass(VisualElement root, string className)
		{
			if (root == null)
			{
				return null;
			}
			Button val = (Button)(object)((root is Button) ? root : null);
			if (val != null && ((VisualElement)val).ClassListContains(className))
			{
				return val;
			}
			foreach (VisualElement item in root.Children())
			{
				Button val2 = FindDescendantButtonWithClass(item, className);
				if (val2 != null)
				{
					return val2;
				}
			}
			return null;
		}

		private static void RefreshStockpileCache()
		{
			CacheStockpileElements();
			if (_stockpileNavArea == StockpileNavArea.Items && _cachedStockpileItems.Count == 0)
			{
				_stockpileNavArea = StockpileNavArea.Footer;
			}
			if (_stockpileNavArea == StockpileNavArea.Footer && _cachedStockpileFooterButtons.Count == 0 && _cachedStockpileItems.Count > 0)
			{
				_stockpileNavArea = StockpileNavArea.Items;
			}
			if (_stockpileNavArea == StockpileNavArea.Items)
			{
				_stockpileNavIndex = Mathf.Clamp(_stockpileNavIndex, 0, _cachedStockpileItems.Count - 1);
				_stockpileNavColumn = Mathf.Clamp(_stockpileNavColumn, 0, 1);
			}
			else
			{
				_stockpileNavIndex = Mathf.Clamp(_stockpileNavIndex, 0, Mathf.Max(0, _cachedStockpileFooterButtons.Count - 1));
				_stockpileNavColumn = 0;
			}
		}

		private static VisualElement GetCurrentStockpileElement()
		{
			if (_stockpileNavArea == StockpileNavArea.Items)
			{
				if (_stockpileNavIndex < 0 || _stockpileNavIndex >= _cachedStockpileItems.Count)
				{
					return null;
				}
				StockpileItemData stockpileItemData = _cachedStockpileItems[_stockpileNavIndex];
				if (_stockpileNavColumn != 0)
				{
					return (VisualElement)(object)stockpileItemData.TakeButton;
				}
				return stockpileItemData.Item;
			}
			if (_stockpileNavIndex < 0 || _stockpileNavIndex >= _cachedStockpileFooterButtons.Count)
			{
				return null;
			}
			return (VisualElement)(object)_cachedStockpileFooterButtons[_stockpileNavIndex];
		}

		private static void FocusStockpileElement()
		{
			VisualElement currentStockpileElement = GetCurrentStockpileElement();
			if (currentStockpileElement != null)
			{
				try
				{
					((Focusable)currentStockpileElement).Focus();
				}
				catch
				{
				}
				EnsureStockpileSelectionVisible(currentStockpileElement);
				SetWellControllerHighlight(currentStockpileElement);
			}
		}

		private static void EnsureStockpileSelectionVisible(VisualElement focusedElement)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			ScrollView cachedStockpileScrollView = _cachedStockpileScrollView;
			if (cachedStockpileScrollView == null || cachedStockpileScrollView.verticalScroller == null || focusedElement == null)
			{
				return;
			}
			VisualElement val = focusedElement;
			if (_stockpileNavArea == StockpileNavArea.Items && _stockpileNavIndex >= 0 && _stockpileNavIndex < _cachedStockpileItems.Count)
			{
				val = _cachedStockpileItems[_stockpileNavIndex].Item ?? focusedElement;
			}
			if (val == null)
			{
				return;
			}
			VisualElement val2 = (VisualElement)(((object)cachedStockpileScrollView.contentViewport) ?? ((object)cachedStockpileScrollView));
			Rect worldBound;
			Rect worldBound2;
			try
			{
				worldBound = val2.worldBound;
				worldBound2 = val.worldBound;
			}
			catch
			{
				return;
			}
			if (((Rect)(ref worldBound)).height <= 0f || ((Rect)(ref worldBound2)).height <= 0f)
			{
				return;
			}
			float highValue = cachedStockpileScrollView.verticalScroller.highValue;
			if (highValue <= 0f)
			{
				return;
			}
			VisualElement val3 = ((VisualElement)cachedStockpileScrollView).contentContainer ?? cachedStockpileScrollView.contentViewport;
			Rect worldBound3;
			try
			{
				worldBound3 = val3.worldBound;
			}
			catch
			{
				return;
			}
			float num = ((Rect)(ref worldBound)).y - ((Rect)(ref worldBound3)).y;
			float num2 = ((Rect)(ref worldBound2)).y - ((Rect)(ref worldBound3)).y;
			float num3 = num2 + ((Rect)(ref worldBound2)).height;
			float num4 = num + 8f;
			float num5 = num + ((Rect)(ref worldBound)).height - 8f;
			float y = cachedStockpileScrollView.scrollOffset.y;
			if (num2 < num4)
			{
				y -= num4 - num2;
			}
			else
			{
				if (!(num3 > num5))
				{
					return;
				}
				y += num3 - num5;
			}
			cachedStockpileScrollView.scrollOffset = new Vector2(cachedStockpileScrollView.scrollOffset.x, Mathf.Clamp(y, 0f, highValue));
		}

		private static void NavigateStockpileVertical(int dir)
		{
			RefreshStockpileCache();
			if (_stockpileNavArea == StockpileNavArea.Items)
			{
				if (_cachedStockpileItems.Count == 0)
				{
					if (_cachedStockpileFooterButtons.Count > 0)
					{
						_stockpileNavArea = StockpileNavArea.Footer;
						_stockpileNavIndex = 0;
						_stockpileNavColumn = 0;
						FocusStockpileElement();
					}
					return;
				}
				int num = _stockpileNavIndex + dir;
				if (num >= 0 && num < _cachedStockpileItems.Count)
				{
					_stockpileNavIndex = num;
				}
				else
				{
					if (dir <= 0 || _cachedStockpileFooterButtons.Count <= 0)
					{
						return;
					}
					_stockpileNavArea = StockpileNavArea.Footer;
					_stockpileNavIndex = Mathf.Min(_stockpileNavColumn, _cachedStockpileFooterButtons.Count - 1);
					_stockpileNavColumn = 0;
				}
				FocusStockpileElement();
			}
			else if (dir < 0 && _cachedStockpileItems.Count > 0)
			{
				_stockpileNavArea = StockpileNavArea.Items;
				_stockpileNavIndex = _cachedStockpileItems.Count - 1;
				_stockpileNavColumn = 1;
				FocusStockpileElement();
			}
		}

		private static void NavigateStockpileHorizontal(int dir)
		{
			RefreshStockpileCache();
			if (_stockpileNavArea == StockpileNavArea.Items)
			{
				int num = Mathf.Clamp(_stockpileNavColumn + dir, 0, 1);
				if (num != _stockpileNavColumn)
				{
					_stockpileNavColumn = num;
					FocusStockpileElement();
				}
			}
			else if (_cachedStockpileFooterButtons.Count > 1)
			{
				int num2 = Mathf.Clamp(_stockpileNavIndex + dir, 0, _cachedStockpileFooterButtons.Count - 1);
				if (num2 != _stockpileNavIndex)
				{
					_stockpileNavIndex = num2;
					FocusStockpileElement();
				}
			}
		}

		private static void ScrollStockpile(Gamepad gp)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			float num = ((InputControl<float>)(object)((Vector2Control)gp.rightStick).y).ReadValue();
			if (Mathf.Abs(num) <= 0.3f)
			{
				_stockpileScrollAccum = 0f;
				return;
			}
			ScrollView cachedStockpileScrollView = _cachedStockpileScrollView;
			if (cachedStockpileScrollView == null || cachedStockpileScrollView.verticalScroller == null)
			{
				return;
			}
			float highValue = cachedStockpileScrollView.verticalScroller.highValue;
			if (!(highValue <= 0f))
			{
				_stockpileScrollAccum += (0f - num) * Time.deltaTime * 550f;
				if (!(Mathf.Abs(_stockpileScrollAccum) <= 10f))
				{
					float num2 = cachedStockpileScrollView.scrollOffset.y + _stockpileScrollAccum;
					_stockpileScrollAccum = 0f;
					cachedStockpileScrollView.scrollOffset = new Vector2(cachedStockpileScrollView.scrollOffset.x, Mathf.Clamp(num2, 0f, highValue));
				}
			}
		}

		private static void HandleStockpileNavigation(Gamepad gp)
		{
			if (!IsStockpileUiOpen())
			{
				if (_stockpileNavActive)
				{
					ResetStockpileNavCache();
				}
				return;
			}
			if (IsDescriptionOverlayOpen())
			{
				if (gp.buttonEast.wasPressedThisFrame)
				{
					CloseDescriptionOverlay();
					_bButtonConsumedFrames = 3;
				}
				return;
			}
			if (!_stockpileNavActive)
			{
				_stockpileNavActive = true;
				CacheStockpileElements();
				_stockpileNavArea = ((_cachedStockpileItems.Count <= 0) ? StockpileNavArea.Footer : StockpileNavArea.Items);
				_stockpileNavIndex = 0;
				_stockpileNavColumn = ((_cachedStockpileItems.Count > 0) ? 1 : 0);
				FocusStockpileElement();
			}
			RefreshStockpileCache();
			ScrollStockpile(gp);
			float num = ((InputControl<float>)(object)((Vector2Control)gp.dpad).x).ReadValue();
			float num2 = ((InputControl<float>)(object)((Vector2Control)gp.leftStick).x).ReadValue();
			float num3 = ((InputControl<float>)(object)((Vector2Control)gp.dpad).y).ReadValue();
			float num4 = ((InputControl<float>)(object)((Vector2Control)gp.leftStick).y).ReadValue();
			float num5 = ((Mathf.Abs(num2) > 0.6f) ? num2 : ((Mathf.Abs(num) > 0.5f) ? num : 0f));
			float num6 = ((Mathf.Abs(num4) > 0.6f) ? num4 : ((Mathf.Abs(num3) > 0.5f) ? num3 : 0f));
			if ((num5 != 0f && _stockpileLastNavX == 0f) || (num6 != 0f && _stockpileLastNavY == 0f))
			{
				if (num5 != 0f)
				{
					NavigateStockpileHorizontal((num5 > 0f) ? 1 : (-1));
				}
				else
				{
					NavigateStockpileVertical((num6 < 0f) ? 1 : (-1));
				}
			}
			_stockpileLastNavX = num5;
			_stockpileLastNavY = num6;
			if (gp.buttonSouth.wasPressedThisFrame)
			{
				VisualElement currentStockpileElement = GetCurrentStockpileElement();
				if (currentStockpileElement != null)
				{
					SimulateVEClick(currentStockpileElement);
				}
			}
			if (gp.buttonWest.wasPressedThisFrame && _cachedStockpileDepositButton != null && IsElementDisplayed((VisualElement)(object)_cachedStockpileDepositButton))
			{
				SimulateVEClick((VisualElement)(object)_cachedStockpileDepositButton);
			}
		}

		private static int GetVisibleWellTab(object pc)
		{
			if (pc == null)
			{
				return _currentWellTab;
			}
			Type type = pc.GetType();
			if (_wcpFieldCache == null)
			{
				_wcpFieldCache = AccessTools.Field(type, "wellCraftingPanel");
			}
			object? obj = _wcpFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj is VisualElement) ? obj : null)))
			{
				return 0;
			}
			if (_mapPanelFieldCache == null)
			{
				_mapPanelFieldCache = AccessTools.Field(type, "mapPanel");
			}
			object? obj2 = _mapPanelFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj2 is VisualElement) ? obj2 : null)))
			{
				return 1;
			}
			if (_furnitureCraftingPanelFieldCache == null)
			{
				_furnitureCraftingPanelFieldCache = AccessTools.Field(type, "furnitureCraftingPanel");
			}
			object? obj3 = _furnitureCraftingPanelFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj3 is VisualElement) ? obj3 : null)))
			{
				return 2;
			}
			if (_homeUpgradePanelFieldCache == null)
			{
				_homeUpgradePanelFieldCache = AccessTools.Field(type, "homeUpgradePanel");
			}
			object? obj4 = _homeUpgradePanelFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj4 is VisualElement) ? obj4 : null)))
			{
				return 3;
			}
			if (_potionCraftingPanelFieldCache == null)
			{
				_potionCraftingPanelFieldCache = AccessTools.Field(type, "potionCraftingPanel");
			}
			object? obj5 = _potionCraftingPanelFieldCache?.GetValue(pc);
			if (IsElementDisplayed((VisualElement)((obj5 is VisualElement) ? obj5 : null)))
			{
				return 4;
			}
			return _currentWellTab;
		}

		internal static bool IsPlayerControllerUiOpen(object playerController)
		{
			if (playerController == null)
			{
				return false;
			}
			FieldInfo fieldInfo = _isUiOpenField ?? AccessTools.Field(playerController.GetType(), "isUiOpen");
			if (fieldInfo == null)
			{
				return false;
			}
			_isUiOpenField = fieldInfo;
			try
			{
				return (bool)fieldInfo.GetValue(playerController);
			}
			catch
			{
				return false;
			}
		}

		private static void EnsureEventSystem()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			EventSystem val = EventSystem.current;
			if ((Object)(object)val == (Object)null)
			{
				val = new GameObject("ControllerSupport_EventSystem").AddComponent<EventSystem>();
			}
			val.sendNavigationEvents = false;
			if ((Object)(object)((Component)val).GetComponent<InputSystemUIInputModule>() != (Object)null)
			{
				return;
			}
			try
			{
				((Component)val).gameObject.AddComponent<InputSystemUIInputModule>();
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"[ControllerSupport] InputSystemUIInputModule failed: {arg}");
				if ((Object)(object)((Component)val).GetComponent<StandaloneInputModule>() == (Object)null)
				{
					((Component)val).gameObject.AddComponent<StandaloneInputModule>();
					Logger.LogWarning((object)"[ControllerSupport] Fell back to StandaloneInputModule");
				}
			}
		}

		internal static void RebuildTaskElementCache(bool forPapyrus = true)
		{
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			_cachedTaskElements.Clear();
			if (_buttonGraphicField == null)
			{
				_buttonGraphicField = AccessTools.Field(typeof(PlayerTaskElement), "buttonGraphic");
			}
			if (_taskTextField == null)
			{
				_taskTextField = AccessTools.Field(typeof(PlayerTaskElement), "taskText");
			}
			PlayerTaskElement[] array = Object.FindObjectsOfType<PlayerTaskElement>();
			List<PlayerTaskElement> list = new List<PlayerTaskElement>();
			List<PlayerTaskElement> list2 = new List<PlayerTaskElement>();
			PlayerTaskElement[] array2 = array;
			foreach (PlayerTaskElement val in array2)
			{
				bool flag = false;
				Transform val2 = ((Component)val).transform;
				while ((Object)(object)val2 != (Object)null)
				{
					if (((Object)val2).name == "papyrus" || ((Object)val2).name == "Papyrus")
					{
						flag = true;
						break;
					}
					val2 = val2.parent;
				}
				if (flag)
				{
					list.Add(val);
				}
				else
				{
					list2.Add(val);
				}
			}
			List<PlayerTaskElement> list3 = ((!forPapyrus) ? list2 : ((list.Count > 0) ? list : new List<PlayerTaskElement>(array)));
			list3.Sort(delegate(PlayerTaskElement a, PlayerTaskElement b)
			{
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)((Component)a).transform.parent == (Object)(object)((Component)b).transform.parent)
				{
					return ((Component)a).transform.GetSiblingIndex().CompareTo(((Component)b).transform.GetSiblingIndex());
				}
				float y = ((Component)a).GetComponent<RectTransform>().anchoredPosition.y;
				float y2 = ((Component)b).GetComponent<RectTransform>().anchoredPosition.y;
				return y2.CompareTo(y);
			});
			if (list3.Count > 0)
			{
				for (int num = 0; num < list3.Count; num++)
				{
					PlayerTaskElement val3 = list3[num];
					GameObject gameObject = ((Component)val3).gameObject;
					if (_taskTextField != null && num == 0)
					{
						object? value = _taskTextField.GetValue(val3);
						TMP_Text val4 = (TMP_Text)((value is TMP_Text) ? value : null);
						if ((Object)(object)val4 != (Object)null)
						{
							_origTaskTextColor = ((Graphic)val4).color;
						}
					}
					Image component = ((Component)val3).GetComponent<Image>();
					if (!_origElementGraphicColorCaptured && (Object)(object)component != (Object)null)
					{
						_origElementGraphicColor = ((Graphic)component).color;
						_origElementGraphicColorCaptured = true;
					}
					Image item = null;
					if (_buttonGraphicField != null)
					{
						object? value2 = _buttonGraphicField.GetValue(val3);
						item = (Image)((value2 is Image) ? value2 : null);
					}
					GameObject item2 = CreateHighlightOverlay(gameObject);
					Component component2 = gameObject.GetComponent("MMUiEventListener");
					_cachedTaskElements.Add((val3, component, item, item2, component2));
					if (_mmEnterFeedbackField == null && (Object)(object)component2 != (Object)null)
					{
						Type type = ((object)component2).GetType();
						_mmEnterFeedbackField = type.GetField("onPointerEnterFeedback", BindingFlags.Instance | BindingFlags.NonPublic);
						_mmExitFeedbackField = type.GetField("onPointerExitFeedback", BindingFlags.Instance | BindingFlags.NonPublic);
						Type type2 = _mmEnterFeedbackField?.FieldType;
						if (type2 != null)
						{
							_mmPlayFeedbacksMethod = type2.GetMethod("PlayFeedbacks", Type.EmptyTypes);
						}
					}
					if (!_highlightDiagLogged)
					{
						_highlightDiagLogged = true;
					}
				}
			}
			else
			{
				if ((Object)(object)_cachedTaskListUI == (Object)null)
				{
					return;
				}
				if (_taskElementParentField == null)
				{
					_taskElementParentField = AccessTools.Field(typeof(TaskListUI), "taskElementParent");
				}
				if (_taskElementParentField == null)
				{
					return;
				}
				object? value3 = _taskElementParentField.GetValue(_cachedTaskListUI);
				Transform val5 = (Transform)((value3 is Transform) ? value3 : null);
				if ((Object)(object)val5 == (Object)null)
				{
					return;
				}
				if (_taskTextField != null)
				{
					for (int num2 = 0; num2 < val5.childCount; num2++)
					{
						PlayerTaskElement component3 = ((Component)val5.GetChild(num2)).GetComponent<PlayerTaskElement>();
						if ((Object)(object)component3 != (Object)null)
						{
							object? value4 = _taskTextField.GetValue(component3);
							TMP_Text val6 = (TMP_Text)((value4 is TMP_Text) ? value4 : null);
							if ((Object)(object)val6 != (Object)null)
							{
								_origTaskTextColor = ((Graphic)val6).color;
								break;
							}
						}
					}
				}
				for (int num3 = 0; num3 < val5.childCount; num3++)
				{
					Transform child = val5.GetChild(num3);
					PlayerTaskElement component4 = ((Component)child).GetComponent<PlayerTaskElement>();
					if ((Object)(object)component4 == (Object)null)
					{
						continue;
					}
					Image component5 = ((Component)component4).GetComponent<Image>();
					if (!_origElementGraphicColorCaptured && (Object)(object)component5 != (Object)null)
					{
						_origElementGraphicColor = ((Graphic)component5).color;
						_origElementGraphicColorCaptured = true;
					}
					Image item3 = null;
					if (_buttonGraphicField != null)
					{
						object? value5 = _buttonGraphicField.GetValue(component4);
						item3 = (Image)((value5 is Image) ? value5 : null);
					}
					GameObject item4 = CreateHighlightOverlay(((Component)child).gameObject);
					Component component6 = ((Component)child).GetComponent("MMUiEventListener");
					_cachedTaskElements.Add((component4, component5, item3, item4, component6));
					if (_mmEnterFeedbackField == null && (Object)(object)component6 != (Object)null)
					{
						Type type3 = ((object)component6).GetType();
						_mmEnterFeedbackField = type3.GetField("onPointerEnterFeedback", BindingFlags.Instance | BindingFlags.NonPublic);
						_mmExitFeedbackField = type3.GetField("onPointerExitFeedback", BindingFlags.Instance | BindingFlags.NonPublic);
						Type type4 = _mmEnterFeedbackField?.FieldType;
						if (type4 != null)
						{
							_mmPlayFeedbacksMethod = type4.GetMethod("PlayFeedbacks", Type.EmptyTypes);
						}
					}
				}
			}
		}

		internal static void ClearTaskElementHighlights()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (!_lastInputWasGamepad)
			{
				return;
			}
			foreach (var cachedTaskElement in _cachedTaskElements)
			{
				if ((Object)(object)cachedTaskElement.buttonGraphic != (Object)null)
				{
					((Graphic)cachedTaskElement.buttonGraphic).color = _origHighlightColor;
				}
				PlayMMFeedback(cachedTaskElement.mmUiEventListener, isEnter: false);
				if ((Object)(object)cachedTaskElement.highlightChild != (Object)null)
				{
					cachedTaskElement.highlightChild.SetActive(false);
				}
				if ((Object)(object)cachedTaskElement.element != (Object)null)
				{
					RectTransform component = ((Component)cachedTaskElement.element).GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null)
					{
						((Transform)component).localScale = Vector3.one;
					}
				}
			}
		}

		private static void PlayMMFeedback(Component mmUiEventListener, bool isEnter)
		{
			if ((Object)(object)mmUiEventListener == (Object)null || _mmEnterFeedbackField == null || _mmPlayFeedbacksMethod == null)
			{
				return;
			}
			try
			{
				FieldInfo fieldInfo = (isEnter ? _mmEnterFeedbackField : _mmExitFeedbackField);
				if (fieldInfo == null)
				{
					return;
				}
				object? value = fieldInfo.GetValue(mmUiEventListener);
				Component val = (Component)((value is Component) ? value : null);
				if ((Object)(object)val == (Object)null)
				{
					if (!_feedbackDiagLogged)
					{
						_feedbackDiagLogged = true;
						Logger.LogWarning((object)("[ControllerSupport] PlayMMFeedback(" + (isEnter ? "enter" : "exit") + "): feedback is null!"));
					}
				}
				else
				{
					if (!val.gameObject.activeInHierarchy)
					{
						val.gameObject.SetActive(true);
					}
					_mmPlayFeedbacksMethod.Invoke(val, null);
				}
			}
			catch (Exception ex)
			{
				if (!_feedbackDiagLogged)
				{
					_feedbackDiagLogged = true;
					Logger.LogWarning((object)("[ControllerSupport] PlayMMFeedback(" + (isEnter ? "enter" : "exit") + ") exception: " + ex.Message));
				}
			}
		}

		internal static void HighlightTaskElement(int index)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			if (!_lastInputWasGamepad)
			{
				return;
			}
			ClearTaskElementHighlights();
			if (index < 0 || index >= _cachedTaskElements.Count)
			{
				return;
			}
			(PlayerTaskElement, Image, Image, GameObject, Component) tuple = _cachedTaskElements[index];
			EnsureHighlightResources();
			_highlightCallCount++;
			_ = _highlightCallCount;
			_ = 3;
			if ((Object)(object)tuple.Item3 != (Object)null)
			{
				if (!((Component)tuple.Item3).gameObject.activeSelf)
				{
					((Component)tuple.Item3).gameObject.SetActive(true);
				}
				((Graphic)tuple.Item3).color = new Color(1f, 1f, 1f, 1f);
			}
			if ((Object)(object)tuple.Item1 != (Object)null)
			{
				RectTransform component = ((Component)tuple.Item1).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					((Transform)component).localScale = new Vector3(1.08f, 1.08f, 1.08f);
				}
			}
			PlayMMFeedback(tuple.Item5, isEnter: true);
			if (!((Object)(object)tuple.Item1 != (Object)null) || !((Object)(object)EventSystem.current != (Object)null))
			{
				return;
			}
			try
			{
				PointerEventData val = new PointerEventData(EventSystem.current);
				val.pointerEnter = ((Component)tuple.Item1).gameObject;
				ExecuteEvents.Execute<IPointerEnterHandler>(((Component)tuple.Item1).gameObject, (BaseEventData)(object)val, ExecuteEvents.pointerEnterHandler);
			}
			catch (Exception ex)
			{
				if (_highlightCallCount <= 3)
				{
					Logger.LogWarning((object)("[ControllerSupport] ExecuteEvents.pointerEnterHandler exception: " + ex.Message));
				}
			}
		}

		private static GameObject CreateHighlightOverlay(GameObject taskElement)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			EnsureHighlightResources();
			GameObject val = new GameObject("ControllerHighlightOverlay");
			val.transform.SetParent(taskElement.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			((Transform)obj).SetAsLastSibling();
			Image obj2 = val.AddComponent<Image>();
			obj2.sprite = _highlightSprite;
			((Graphic)obj2).color = new Color(0f, 1f, 0.3f, 0.4f);
			((Graphic)obj2).raycastTarget = false;
			val.AddComponent<LayoutElement>().ignoreLayout = true;
			val.SetActive(false);
			return val;
		}

		internal static void ClearAllTaskAndFoldoutState()
		{
			ClearTaskElementHighlights();
			_taskListSelectedIndex = -1;
			_taskListOpen = false;
			_infoOverlayOpen = false;
			UpdateLookActionState();
			_mouseOpenedInfoOverlay = false;
			_infoFoldoutIndex = -1;
			_cachedTaskElements.Clear();
			_cachedTaskListUI = null;
			_cachedFoldouts.Clear();
			_cachedDescriptionDisplayer = null;
			_lateUpdaterActiveDiagLogged = false;
			_inactiveElementsLogged = false;
			_highlightCallCount = 0;
			_prevTaskPanelActive = false;
			if (_cursorPreviouslyVisible.HasValue)
			{
				Cursor.visible = _cursorPreviouslyVisible.Value;
				Cursor.lockState = (CursorLockMode)0;
				_cursorPreviouslyVisible = null;
			}
			if ((Object)(object)_disabledRaycaster != (Object)null)
			{
				((Behaviour)_disabledRaycaster).enabled = true;
				_disabledRaycaster = null;
			}
			_papyrusCacheRetryCount = 0;
			_deadTiedCacheRetryCount = 0;
			_currentListType = ListType.None;
		}

		private static void RebuildFoldoutCache(bool preserveSelection = false)
		{
			int infoFoldoutIndex = _infoFoldoutIndex;
			_cachedFoldouts.Clear();
			_infoFoldoutIndex = -1;
			if (_descToggleField == null)
			{
				_descToggleField = AccessTools.Field(typeof(DescriptionElement), "toggle");
			}
			if ((Object)(object)_cachedDescriptionDisplayer == (Object)null)
			{
				_cachedDescriptionDisplayer = Object.FindObjectOfType<DescriptionDisplayer>();
				if ((Object)(object)_cachedDescriptionDisplayer == (Object)null)
				{
					return;
				}
				if (_descriptionContainerField == null)
				{
					_descriptionContainerField = AccessTools.Field(typeof(DescriptionDisplayer), "descriptionContainer");
				}
			}
			if (_descriptionContainerField == null)
			{
				return;
			}
			object? value = _descriptionContainerField.GetValue(_cachedDescriptionDisplayer);
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if ((Object)(object)_foldoutScrollRect == (Object)null)
			{
				_foldoutScrollRect = val.GetComponentInParent<ScrollRect>();
			}
			DescriptionElement[] componentsInChildren = val.GetComponentsInChildren<DescriptionElement>(false);
			int num = 0;
			int num2 = 0;
			DescriptionElement[] array = componentsInChildren;
			foreach (DescriptionElement val2 in array)
			{
				Toggle val3 = null;
				if (_descToggleField != null)
				{
					object? value2 = _descToggleField.GetValue(val2);
					val3 = (Toggle)((value2 is Toggle) ? value2 : null);
				}
				if ((Object)(object)val3 == (Object)null)
				{
					num++;
					continue;
				}
				int num3 = 0;
				Transform parent = ((Component)val2).transform.parent;
				while ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)val.transform)
				{
					if ((Object)(object)((Component)parent).GetComponent<DescriptionElement>() != (Object)null)
					{
						num3++;
					}
					parent = parent.parent;
				}
				if (!((Behaviour)val3).enabled)
				{
					num2++;
					continue;
				}
				_cachedFoldouts.Add((val2, val3));
				if (_foldoutTitleField == null)
				{
					_foldoutTitleField = AccessTools.Field(typeof(DescriptionElement), "title");
				}
				if (_foldoutTitleField != null)
				{
					object? value3 = _foldoutTitleField.GetValue(val2);
					TMP_Text val4 = (TMP_Text)((value3 is TMP_Text) ? value3 : null);
					if ((Object)(object)val4 != (Object)null)
					{
						_ = val4.text;
					}
				}
				if (_foldoutObjectField == null)
				{
					_foldoutObjectField = AccessTools.Field(typeof(DescriptionElement), "toggleObject");
				}
				if (_foldoutObjectField != null)
				{
					object? value4 = _foldoutObjectField.GetValue(val2);
					GameObject val5 = (GameObject)((value4 is GameObject) ? value4 : null);
					if ((Object)(object)val5 != (Object)null)
					{
						_ = val5.activeSelf;
					}
				}
				if (num3 != 0)
				{
					_ = $"nested(d{num3})";
				}
			}
			if (_cachedFoldouts.Count != _lastFoldoutCacheCount || Time.unscaledTime - _lastFoldoutCacheLogTime >= 1f)
			{
				_lastFoldoutCacheCount = _cachedFoldouts.Count;
				_lastFoldoutCacheLogTime = Time.unscaledTime;
			}
			if (_cachedFoldouts.Count > 0)
			{
				if (preserveSelection && infoFoldoutIndex >= 0 && infoFoldoutIndex < _cachedFoldouts.Count)
				{
					_infoFoldoutIndex = infoFoldoutIndex;
				}
				else
				{
					_infoFoldoutIndex = 0;
				}
			}
		}

		private static void SelectFoldout(int index)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			ClearFoldoutHighlights();
			if (index < 0 || index >= _cachedFoldouts.Count)
			{
				return;
			}
			Toggle item = _cachedFoldouts[index].toggle;
			DescriptionElement item2 = _cachedFoldouts[index].element;
			if ((Object)(object)item != (Object)null && (Object)(object)EventSystem.current != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject(((Component)item).gameObject);
			}
			if (_foldoutTitleField == null)
			{
				_foldoutTitleField = AccessTools.Field(typeof(DescriptionElement), "title");
			}
			if (!(_foldoutTitleField != null) || !((Object)(object)item2 != (Object)null))
			{
				return;
			}
			object? value = _foldoutTitleField.GetValue(item2);
			TMP_Text val = (TMP_Text)((value is TMP_Text) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				if (_origFoldoutTitleColor == Color.white)
				{
					_origFoldoutTitleColor = ((Graphic)val).color;
				}
				((Graphic)val).color = _selectedHighlightColor;
			}
		}

		private static void ScrollToFoldout(int index)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_foldoutScrollRect == (Object)null || index < 0 || index >= _cachedFoldouts.Count)
			{
				return;
			}
			Toggle item = _cachedFoldouts[index].toggle;
			if ((Object)(object)item == (Object)null || (Object)(object)_foldoutScrollRect.viewport == (Object)null || (Object)(object)_foldoutScrollRect.content == (Object)null)
			{
				return;
			}
			Canvas.ForceUpdateCanvases();
			RectTransform component = ((Component)item).GetComponent<RectTransform>();
			RectTransform viewport = _foldoutScrollRect.viewport;
			RectTransform content = _foldoutScrollRect.content;
			if (!((Object)(object)component == (Object)null))
			{
				Vector2 val = Vector2.op_Implicit(((Transform)viewport).InverseTransformPoint(((Transform)component).position));
				Rect rect = viewport.rect;
				float num = ((Rect)(ref rect)).height / 2f;
				rect = component.rect;
				float num2 = ((Rect)(ref rect)).height / 2f;
				float num3 = val.y + num2;
				float num4 = val.y - num2;
				rect = content.rect;
				float height = ((Rect)(ref rect)).height;
				rect = viewport.rect;
				float num5 = Mathf.Max(1f, height - ((Rect)(ref rect)).height);
				if (num3 > num)
				{
					float num6 = num3 - num;
					_foldoutScrollRect.verticalNormalizedPosition = Mathf.Clamp01(_foldoutScrollRect.verticalNormalizedPosition + num6 / num5);
				}
				else if (num4 < 0f - num)
				{
					float num7 = 0f - num - num4;
					_foldoutScrollRect.verticalNormalizedPosition = Mathf.Clamp01(_foldoutScrollRect.verticalNormalizedPosition - num7 / num5);
				}
			}
		}

		internal static void ClearFoldoutHighlights()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			foreach (var cachedFoldout in _cachedFoldouts)
			{
				if (_foldoutTitleField != null)
				{
					object? value = _foldoutTitleField.GetValue(cachedFoldout.element);
					TMP_Text val = (TMP_Text)((value is TMP_Text) ? value : null);
					if ((Object)(object)val != (Object)null)
					{
						((Graphic)val).color = _origFoldoutTitleColor;
					}
				}
			}
		}

		internal static void CloseOverlayAndPapyrus()
		{
			_infoOverlayOpen = false;
			_overlayClosedByRelease = true;
			_mouseOpenedInfoOverlay = false;
			_papyrusAPressFrame = -1;
			EquipmentController val = Object.FindObjectOfType<EquipmentController>();
			if (val != null)
			{
				try
				{
					AccessTools.Method(typeof(EquipmentController), "TogglePapyrusRpc", (Type[])null, (Type[])null)?.Invoke(val, new object[1] { false });
				}
				catch (Exception ex)
				{
					Logger.LogError((object)("[ControllerSupport] CloseOverlayAndPapyrus: TogglePapyrusRpc failed: " + ex.Message));
				}
			}
			try
			{
				DescriptionDisplayer val2 = Object.FindObjectOfType<DescriptionDisplayer>();
				if ((Object)(object)val2 != (Object)null)
				{
					AccessTools.Method(typeof(DescriptionDisplayer), "DisableTaskList", (Type[])null, (Type[])null)?.Invoke(val2, null);
				}
			}
			catch (Exception ex2)
			{
				Logger.LogError((object)("[ControllerSupport] CloseOverlayAndPapyrus: DisableTaskList failed: " + ex2.Message));
			}
			_infoFoldoutIndex = -1;
			_cachedFoldouts.Clear();
			_cachedDescriptionDisplayer = null;
			_foldoutScrollRect = null;
			ClearFoldoutHighlights();
		}

		internal static void CloseMouseOpenedOverlayForPapyrusRelease()
		{
			_infoOverlayOpen = false;
			_mouseOpenedInfoOverlay = false;
			_overlayClosedByRelease = false;
			_papyrusAPressFrame = -1;
			try
			{
				DescriptionDisplayer val = Object.FindObjectOfType<DescriptionDisplayer>();
				if ((Object)(object)val != (Object)null)
				{
					AccessTools.Method(typeof(DescriptionDisplayer), "DisableTaskList", (Type[])null, (Type[])null)?.Invoke(val, null);
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("[ControllerSupport] CloseMouseOpenedOverlayForPapyrusRelease: DisableTaskList failed: " + ex.Message));
			}
			ClearFoldoutHighlights();
			_infoFoldoutIndex = -1;
			_cachedFoldouts.Clear();
			_cachedDescriptionDisplayer = null;
			_foldoutScrollRect = null;
		}

		internal static bool WasKeyboardMousePapyrusReleaseThisFrame()
		{
			try
			{
				Keyboard current = Keyboard.current;
				if (current != null && ((ButtonControl)current.tabKey).wasReleasedThisFrame)
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				if (Input.GetKeyUp((KeyCode)9))
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static void ClearSideEffectWindow()
		{
			_papyrusAPressFrame = -1;
		}

		private static void KeepPapyrusAlive()
		{
			try
			{
				object playerController = GetPlayerController();
				if (playerController != null && _taskPapyrusField != null)
				{
					object? value = _taskPapyrusField.GetValue(playerController);
					GameObject val = (GameObject)((value is GameObject) ? value : null);
					if ((Object)(object)val != (Object)null && !val.activeInHierarchy)
					{
						val.SetActive(true);
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("[ControllerSupport] KeepPapyrusAlive: " + ex.Message));
			}
		}

		private static void TrackInputDevice()
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			Gamepad current = Gamepad.current;
			bool flag = false;
			if (current != null)
			{
				if (current.selectButton.wasPressedThisFrame || current.buttonSouth.wasPressedThisFrame || current.buttonNorth.wasPressedThisFrame || current.buttonEast.wasPressedThisFrame || current.dpad.up.wasPressedThisFrame || current.dpad.down.wasPressedThisFrame || current.dpad.left.wasPressedThisFrame || current.dpad.right.wasPressedThisFrame)
				{
					flag = true;
				}
				Vector2 val = ((InputControl<Vector2>)(object)current.leftStick).ReadValue();
				float magnitude = ((Vector2)(ref val)).magnitude;
				val = ((InputControl<Vector2>)(object)current.rightStick).ReadValue();
				float magnitude2 = ((Vector2)(ref val)).magnitude;
				if (magnitude > 0.3f || magnitude2 > 0.3f)
				{
					flag = true;
				}
				if (current.selectButton.isPressed || current.buttonSouth.isPressed || current.buttonEast.isPressed || current.buttonNorth.isPressed || current.leftShoulder.isPressed || current.rightShoulder.isPressed || current.leftTrigger.isPressed || current.rightTrigger.isPressed)
				{
					flag = true;
				}
			}
			if (flag)
			{
				_lastGamepadInputTime = Time.time;
			}
			bool lastInputWasGamepad = _lastInputWasGamepad;
			_lastInputWasGamepad = Time.time - _lastGamepadInputTime < 0.25f;
			if (lastInputWasGamepad && !_lastInputWasGamepad && _taskListSelectedIndex >= 0)
			{
				ClearTaskElementHighlights();
				_taskListSelectedIndex = -1;
			}
			Mouse current2 = Mouse.current;
			if (current2 != null)
			{
				Vector2 val2 = ((InputControl<Vector2>)(object)((Pointer)current2).delta).ReadValue();
				if (((Vector2)(ref val2)).magnitude > 0.01f || current2.leftButton.wasPressedThisFrame || current2.rightButton.wasPressedThisFrame || current2.middleButton.wasPressedThisFrame)
				{
					_lastMouseMoveTime = Time.time;
				}
			}
			_ = Time.frameCount % 120;
		}

		private static void ManageGraphicRaycaster(bool papyrusActive)
		{
			if (papyrusActive && _lastInputWasGamepad)
			{
				Canvas val = Object.FindObjectOfType<Canvas>();
				if ((Object)(object)val != (Object)null)
				{
					GraphicRaycaster component = ((Component)val).GetComponent<GraphicRaycaster>();
					if ((Object)(object)component != (Object)null && ((Behaviour)component).enabled)
					{
						((Behaviour)component).enabled = false;
						_disabledRaycaster = component;
					}
				}
			}
			else if ((Object)(object)_disabledRaycaster != (Object)null)
			{
				((Behaviour)_disabledRaycaster).enabled = true;
				_disabledRaycaster = null;
			}
		}

		private static void HandleTaskListAndOverlayNavigation(Gamepad gp)
		{
			//IL_0923: Unknown result type (might be due to invalid IL or missing references)
			//IL_0663: Unknown result type (might be due to invalid IL or missing references)
			//IL_0890: Unknown result type (might be due to invalid IL or missing references)
			//IL_0895: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ec: Expected O, but got Unknown
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				return;
			}
			if (_taskPanelField == null)
			{
				_taskPanelField = AccessTools.Field(playerController.GetType(), "taskPanel");
			}
			if (_taskPanelField == null)
			{
				return;
			}
			if (_taskPapyrusField == null)
			{
				_taskPapyrusField = AccessTools.Field(playerController.GetType(), "taskPapyrusList");
			}
			object? value = _taskPanelField.GetValue(playerController);
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			bool flag = (Object)(object)val != (Object)null && val.activeInHierarchy;
			if (_currentListType == ListType.DeadTied)
			{
				try
				{
					if (_tiedOrDeadPropInfo == null)
					{
						_tiedOrDeadPropInfo = AccessTools.Property(playerController.GetType(), "TiedOrDead");
					}
					if (_tiedOrDeadPropInfo != null && !(bool)_tiedOrDeadPropInfo.GetValue(playerController))
					{
						ClearAllTaskAndFoldoutState();
						EnableLookAndCameraActions();
						_prevTaskPanelActive = false;
						_deadTiedCleanupPending = true;
						return;
					}
				}
				catch (Exception ex)
				{
					Logger.LogWarning((object)("[ControllerSupport] TiedOrDead reflection check failed: " + ex.Message));
				}
			}
			if (_prevTaskPanelActive && !flag && _currentListType == ListType.DeadTied)
			{
				ClearAllTaskAndFoldoutState();
				EnableLookAndCameraActions();
				_prevTaskPanelActive = flag;
				return;
			}
			_prevTaskPanelActive = flag;
			if (_deadTiedCleanupPending && flag)
			{
				return;
			}
			if (_deadTiedCleanupPending && !flag)
			{
				_deadTiedCleanupPending = false;
			}
			GameObject val2 = null;
			bool flag2 = false;
			if (_taskPapyrusField != null)
			{
				object? value2 = _taskPapyrusField.GetValue(playerController);
				val2 = (GameObject)((value2 is GameObject) ? value2 : null);
				flag2 = (Object)(object)val2 != (Object)null && val2.activeInHierarchy;
			}
			if (!(flag || flag2))
			{
				if (_taskListOpen || _infoOverlayOpen || _cachedTaskElements.Count > 0 || _currentListType != ListType.None)
				{
					EnableLookAndCameraActions();
					ClearAllTaskAndFoldoutState();
				}
				UpdateLookActionState();
				_papyrusCacheRetryCount = 0;
				ManageGraphicRaycaster(papyrusActive: false);
				return;
			}
			ManageGraphicRaycaster(flag2 || flag);
			if (!flag && flag2)
			{
				TaskListUI val3 = val2.GetComponentInChildren<TaskListUI>(false);
				if ((Object)(object)val3 == (Object)null)
				{
					val3 = Object.FindObjectOfType<TaskListUI>();
				}
				bool flag3 = false;
				if ((Object)(object)val3 != (Object)null && (Object)(object)val3 != (Object)(object)_cachedTaskListUI)
				{
					_cachedTaskListUI = val3;
					_taskListOpen = false;
					flag3 = true;
				}
				else if ((Object)(object)val3 != (Object)null && _cachedTaskElements.Count == 0)
				{
					flag3 = true;
				}
				if (flag3)
				{
					RebuildTaskElementCache();
					if (_cachedTaskElements.Count > 0 && _taskListSelectedIndex < 0)
					{
						_taskListSelectedIndex = 0;
						_papyrusCacheRetryCount = 0;
						HighlightTaskElement(0);
					}
					else if (_cachedTaskElements.Count == 0 && _papyrusCacheRetryCount < 60)
					{
						_papyrusCacheRetryCount++;
					}
				}
				else if (_cachedTaskElements.Count == 0 && _papyrusCacheRetryCount < 60)
				{
					_papyrusCacheRetryCount++;
					RebuildTaskElementCache();
					if (_cachedTaskElements.Count > 0)
					{
						_papyrusCacheRetryCount = 0;
						_taskListSelectedIndex = 0;
						HighlightTaskElement(0);
					}
				}
			}
			if (flag && !flag2)
			{
				TaskListUI val4 = Object.FindObjectOfType<TaskListUI>();
				bool flag4 = false;
				if (_currentListType != ListType.DeadTied)
				{
					_currentListType = ListType.DeadTied;
					_cachedTaskListUI = val4;
					flag4 = true;
					if ((Object)(object)val4 != (Object)null)
					{
						Canvas componentInParent = ((Component)val4).GetComponentInParent<Canvas>();
						if ((Object)(object)componentInParent != (Object)null && (Object)(object)((Component)componentInParent).GetComponent<GraphicRaycaster>() == (Object)null)
						{
							((Component)componentInParent).gameObject.AddComponent<GraphicRaycaster>();
						}
					}
				}
				else if ((Object)(object)val4 != (Object)null && (Object)(object)val4 != (Object)(object)_cachedTaskListUI)
				{
					_cachedTaskListUI = val4;
					flag4 = true;
				}
				else if (_cachedTaskElements.Count == 0)
				{
					flag4 = true;
				}
				if (flag4)
				{
					RebuildTaskElementCache(forPapyrus: false);
					if (_cachedTaskElements.Count > 0 && _taskListSelectedIndex < 0)
					{
						_deadTiedCacheRetryCount = 0;
						_taskListSelectedIndex = 0;
						HighlightTaskElement(0);
					}
					else if (_cachedTaskElements.Count == 0 && _deadTiedCacheRetryCount < 60)
					{
						_deadTiedCacheRetryCount++;
					}
				}
				else if (_cachedTaskElements.Count == 0 && _deadTiedCacheRetryCount < 60)
				{
					_deadTiedCacheRetryCount++;
					RebuildTaskElementCache(forPapyrus: false);
					if (_cachedTaskElements.Count > 0)
					{
						_deadTiedCacheRetryCount = 0;
						_taskListSelectedIndex = 0;
						HighlightTaskElement(0);
					}
				}
			}
			if (flag2 && !flag && _currentListType != ListType.Papyrus)
			{
				_currentListType = ListType.Papyrus;
				_deadTiedCacheRetryCount = 0;
			}
			if (_cachedTaskElements.Count > 0 && _taskListSelectedIndex < 0)
			{
				_taskListSelectedIndex = 0;
				HighlightTaskElement(0);
			}
			if (_currentListType == ListType.DeadTied && !_lastInputWasGamepad)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
			}
			bool flag5 = IsDescriptionOverlayOpen();
			if (flag5 && !_infoOverlayOpen)
			{
				_infoOverlayOpen = true;
				_papyrusAPressFrame = Time.frameCount;
				_cachedDescriptionDisplayer = null;
				_foldoutScrollRect = null;
				if (_currentListType == ListType.DeadTied && !_lastInputWasGamepad)
				{
					Cursor.visible = true;
					Cursor.lockState = (CursorLockMode)0;
				}
				RebuildFoldoutCache();
				if (_cachedFoldouts.Count > 0)
				{
					SelectFoldout(0);
				}
			}
			else if (flag5 && _infoOverlayOpen && _cachedFoldouts.Count == 0)
			{
				_cachedDescriptionDisplayer = null;
				_foldoutScrollRect = null;
				RebuildFoldoutCache();
				if (_cachedFoldouts.Count > 0)
				{
					SelectFoldout(0);
				}
			}
			else if (flag5 && _infoOverlayOpen && _cachedFoldouts.Count > 0)
			{
				bool flag6 = false;
				for (int i = 0; i < _cachedFoldouts.Count; i++)
				{
					if ((Object)(object)_cachedFoldouts[i].element == (Object)null || (Object)(object)_cachedFoldouts[i].toggle == (Object)null)
					{
						flag6 = true;
						break;
					}
				}
				if (flag6)
				{
					_cachedDescriptionDisplayer = null;
					_foldoutScrollRect = null;
					RebuildFoldoutCache();
					if (_cachedFoldouts.Count > 0)
					{
						SelectFoldout(0);
					}
				}
			}
			else if (!flag5 && _infoOverlayOpen)
			{
				_infoOverlayOpen = false;
				_mouseOpenedInfoOverlay = false;
				ClearFoldoutHighlights();
				_infoFoldoutIndex = -1;
				_cachedFoldouts.Clear();
				_cachedDescriptionDisplayer = null;
				_foldoutScrollRect = null;
				_papyrusAPressFrame = -1;
				if (_taskListSelectedIndex >= 0)
				{
					HighlightTaskElement(_taskListSelectedIndex);
				}
			}
			if (flag5)
			{
				KeepPapyrusAlive();
				if (gp.selectButton.wasReleasedThisFrame)
				{
					CloseOverlayAndPapyrus();
					return;
				}
				Keyboard current = Keyboard.current;
				if (current != null && ((ButtonControl)current.tabKey).wasReleasedThisFrame)
				{
					CloseOverlayAndPapyrus();
					return;
				}
				if (_infoFoldoutIndex < 0 && _cachedFoldouts.Count > 0)
				{
					_infoFoldoutIndex = 0;
					SelectFoldout(0);
				}
				float y = ((InputControl<Vector2>)(object)gp.rightStick).ReadValue().y;
				bool flag7 = Mathf.Abs(y) > 0.5f;
				if (_cachedFoldouts.Count > 0 && flag7)
				{
					float unscaledTime = Time.unscaledTime;
					bool flag8 = false;
					if (!_infoFoldoutNavHeldDown)
					{
						flag8 = true;
						_infoFoldoutNavHeldDown = true;
						_infoFoldoutNavRepeatPhase = false;
						_infoFoldoutNavLastStepTime = unscaledTime;
					}
					else
					{
						float num = unscaledTime - _infoFoldoutNavLastStepTime;
						float num2 = (_infoFoldoutNavRepeatPhase ? 0.25f : 0.4f);
						if (num >= num2)
						{
							flag8 = true;
							_infoFoldoutNavLastStepTime = unscaledTime;
							_infoFoldoutNavRepeatPhase = true;
						}
					}
					if (flag8)
					{
						int num3 = ((!(y > 0f)) ? 1 : (-1));
						int num4 = Mathf.Clamp(_infoFoldoutIndex + num3, 0, _cachedFoldouts.Count - 1);
						if (num4 != _infoFoldoutIndex)
						{
							_infoFoldoutIndex = num4;
							SelectFoldout(_infoFoldoutIndex);
							ScrollToFoldout(_infoFoldoutIndex);
						}
					}
				}
				else if (!flag7)
				{
					_infoFoldoutNavHeldDown = false;
				}
				bool flag9 = gp.buttonSouth.wasPressedThisFrame && _papyrusAPressFrame >= 0 && Time.frameCount == _papyrusAPressFrame;
				if (gp.buttonSouth.wasPressedThisFrame && _infoFoldoutIndex >= 0 && _infoFoldoutIndex < _cachedFoldouts.Count && !flag9)
				{
					Toggle item = _cachedFoldouts[_infoFoldoutIndex].toggle;
					GameObject gameObject = ((Component)item).gameObject;
					if (((Behaviour)item).enabled && (Object)(object)gameObject != (Object)null && (Object)(object)EventSystem.current != (Object)null)
					{
						BaseEventData val5 = new BaseEventData(EventSystem.current);
						ExecuteEvents.Execute<ISubmitHandler>(gameObject, val5, ExecuteEvents.submitHandler);
						RebuildFoldoutCache(preserveSelection: true);
						if (_infoFoldoutIndex >= 0 && _infoFoldoutIndex < _cachedFoldouts.Count)
						{
							SelectFoldout(_infoFoldoutIndex);
						}
					}
				}
				if ((Object)(object)_foldoutScrollRect != (Object)null && (Object)(object)_foldoutScrollRect.content != (Object)null)
				{
					float num5 = 0f;
					if (gp.leftShoulder.wasPressedThisFrame)
					{
						num5 = 100f;
					}
					if (gp.rightShoulder.wasPressedThisFrame)
					{
						num5 = -100f;
					}
					if (num5 != 0f)
					{
						Rect rect = _foldoutScrollRect.content.rect;
						float height = ((Rect)(ref rect)).height;
						rect = _foldoutScrollRect.viewport.rect;
						float num6 = Mathf.Max(1f, height - ((Rect)(ref rect)).height);
						_foldoutScrollRect.verticalNormalizedPosition = Mathf.Clamp01(_foldoutScrollRect.verticalNormalizedPosition + num5 / num6);
					}
				}
				if (gp.buttonEast.wasPressedThisFrame)
				{
					CloseOverlayAndPapyrus();
				}
				if (_infoFoldoutIndex >= 0 && _infoFoldoutIndex < _cachedFoldouts.Count)
				{
					SelectFoldout(_infoFoldoutIndex);
				}
			}
			else
			{
				float y2 = ((InputControl<Vector2>)(object)gp.rightStick).ReadValue().y;
				bool flag10 = Mathf.Abs(y2) > 0.5f;
				if (_cachedTaskElements.Count == 0)
				{
					RebuildTaskElementCache();
				}
				if (_cachedTaskElements.Count > 0 && flag10)
				{
					float unscaledTime2 = Time.unscaledTime;
					bool flag11 = false;
					if (!_taskListNavHeldDown)
					{
						flag11 = true;
						_taskListNavHeldDown = true;
						_taskListNavRepeatPhase = false;
						_taskListNavLastStepTime = unscaledTime2;
					}
					else
					{
						float num7 = unscaledTime2 - _taskListNavLastStepTime;
						float num8 = (_taskListNavRepeatPhase ? 0.25f : 0.4f);
						if (num7 >= num8)
						{
							flag11 = true;
							_taskListNavLastStepTime = unscaledTime2;
							_taskListNavRepeatPhase = true;
						}
					}
					if (flag11)
					{
						int num9 = ((!(y2 > 0f)) ? 1 : (-1));
						int num10 = Mathf.Clamp(_taskListSelectedIndex + num9, 0, _cachedTaskElements.Count - 1);
						if (num10 != _taskListSelectedIndex)
						{
							_taskListSelectedIndex = num10;
							HighlightTaskElement(_taskListSelectedIndex);
						}
					}
				}
				else if (!flag10)
				{
					_taskListNavHeldDown = false;
				}
				if (gp.buttonSouth.wasPressedThisFrame && _taskListSelectedIndex >= 0 && _taskListSelectedIndex < _cachedTaskElements.Count && !_infoOverlayOpen)
				{
					_cachedTaskElements[_taskListSelectedIndex].element.OnPointerClick((PointerEventData)null);
					_infoOverlayOpen = true;
				}
			}
			if (flag2)
			{
				Keyboard current2 = Keyboard.current;
				if (current2 != null && ((ButtonControl)current2.tabKey).wasReleasedThisFrame)
				{
					_infoOverlayOpen = false;
					_overlayClosedByRelease = true;
					_papyrusAPressFrame = -1;
					ClearFoldoutHighlights();
					_infoFoldoutIndex = -1;
					_cachedFoldouts.Clear();
					_cachedDescriptionDisplayer = null;
					_foldoutScrollRect = null;
					EquipmentController val6 = Object.FindObjectOfType<EquipmentController>();
					if (val6 != null)
					{
						try
						{
							AccessTools.Method(typeof(EquipmentController), "TogglePapyrusRpc", (Type[])null, (Type[])null)?.Invoke(val6, new object[1] { false });
						}
						catch (Exception ex2)
						{
							Logger.LogError((object)("[ControllerSupport] Catch-all Tab TogglePapyrusRpc failed: " + ex2.Message));
						}
					}
				}
			}
			if (gp.selectButton.wasReleasedThisFrame && flag2)
			{
				_infoOverlayOpen = false;
				_overlayClosedByRelease = true;
				_papyrusAPressFrame = -1;
				ClearFoldoutHighlights();
				_infoFoldoutIndex = -1;
				_cachedFoldouts.Clear();
				_cachedDescriptionDisplayer = null;
				_foldoutScrollRect = null;
				EquipmentController val7 = Object.FindObjectOfType<EquipmentController>();
				if (val7 != null)
				{
					try
					{
						AccessTools.Method(typeof(EquipmentController), "TogglePapyrusRpc", (Type[])null, (Type[])null)?.Invoke(val7, new object[1] { false });
					}
					catch (Exception ex3)
					{
						Logger.LogError((object)("[ControllerSupport] Catch-all TogglePapyrusRpc failed: " + ex3.Message));
					}
				}
			}
			UpdateLookActionState();
		}

		private static void HandleUINavigation(Gamepad gp)
		{
			//IL_064a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0669: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Expected O, but got Unknown
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Expected O, but got Unknown
			EnsureEventSystem();
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				return;
			}
			bool flag = _cachedPlayerController == null || IsUiOpen();
			bool flag2 = _cachedPlayerController != null && IsWellUiOpen(_cachedPlayerController);
			bool flag3 = _cachedPlayerController != null && IsStockpileUiOpen();
			bool flag4 = _cachedPlayerController != null && IsInGameMenuOpen(_cachedPlayerController);
			bool flag5 = IsSettingsPanelOpen();
			bool flag6 = false;
			bool flag7 = false;
			object playerController = GetPlayerController();
			if (playerController != null)
			{
				if (_taskPanelField == null)
				{
					_taskPanelField = AccessTools.Field(playerController.GetType(), "taskPanel");
				}
				if (_taskPapyrusField == null)
				{
					_taskPapyrusField = AccessTools.Field(playerController.GetType(), "taskPapyrusList");
				}
				if (_taskPanelField != null)
				{
					object? value = _taskPanelField.GetValue(playerController);
					GameObject val = (GameObject)((value is GameObject) ? value : null);
					flag6 = (Object)(object)val != (Object)null && val.activeInHierarchy;
				}
				if (_taskPapyrusField != null)
				{
					object? value2 = _taskPapyrusField.GetValue(playerController);
					GameObject val2 = (GameObject)((value2 is GameObject) ? value2 : null);
					flag7 = (Object)(object)val2 != (Object)null && val2.activeInHierarchy;
				}
			}
			if (flag6 || flag7)
			{
				_papyrusOpen = flag7;
				if (_lastInputWasGamepad)
				{
					Cursor.visible = false;
				}
				try
				{
					HandleTaskListAndOverlayNavigation(gp);
				}
				catch (Exception arg)
				{
					Logger.LogError((object)$"[ControllerSupport] HandleTaskListAndOverlayNavigation: {arg}");
				}
				_wasUiOpen = flag;
				return;
			}
			_papyrusOpen = false;
			if (_lastInputWasGamepad)
			{
				Cursor.visible = true;
			}
			if (!flag && !flag2 && !flag3 && !flag5)
			{
				if ((Object)(object)_selectedSlider != (Object)null)
				{
					if (_sliderEditMode)
					{
						ExitSliderEditMode(confirm: true);
					}
					_selectedSlider = null;
				}
				if (_stockpileNavActive)
				{
					ResetStockpileNavCache();
				}
				_wasUiOpen = flag;
				return;
			}
			if (flag3)
			{
				if (flag != _wasUiOpen)
				{
					ResetStockpileNavCache();
				}
				try
				{
					HandleStockpileNavigation(gp);
				}
				catch (Exception arg2)
				{
					Logger.LogError((object)$"[ControllerSupport] HandleStockpileNavigation: {arg2}");
				}
				try
				{
					HandleBButton(gp);
				}
				catch (Exception arg3)
				{
					Logger.LogError((object)$"[ControllerSupport] HandleBButton: {arg3}");
				}
				_wasUiOpen = flag;
				return;
			}
			if (flag2)
			{
				if (flag != _wasUiOpen)
				{
					ResetWellNavCache();
				}
				try
				{
					HandleTabNavigation(gp);
				}
				catch (Exception arg4)
				{
					Logger.LogError((object)$"[ControllerSupport] HandleTabNavigation: {arg4}");
				}
				try
				{
					HandleWellPanelNavigation(gp);
				}
				catch (Exception arg5)
				{
					Logger.LogError((object)$"[ControllerSupport] HandleWellPanelNavigation: {arg5}");
				}
				try
				{
					HandleBButton(gp);
				}
				catch (Exception arg6)
				{
					Logger.LogError((object)$"[ControllerSupport] HandleBButton: {arg6}");
				}
				_wasUiOpen = flag;
				return;
			}
			if (_cachedMenuController != null && IsMenuPanelActive((MenuController)_cachedMenuController, "serverListPanel"))
			{
				try
				{
					HandleServerListNavigation(gp);
				}
				catch (Exception arg7)
				{
					Logger.LogError((object)$"[ControllerSupport] HandleServerListNavigation: {arg7}");
				}
			}
			else
			{
				_cachedServerElements.Clear();
				_cachedServerElementIdx = -1;
			}
			if (flag5 != _wasSettingsOpen)
			{
				_wasSettingsOpen = flag5;
				_cacheNeedsRebuild = true;
			}
			if (flag4 != _wasPlayerMenuOpen)
			{
				_wasPlayerMenuOpen = flag4;
				_cacheNeedsRebuild = true;
				if (flag4)
				{
					EventSystem current2 = EventSystem.current;
					if (current2 != null)
					{
						current2.SetSelectedGameObject((GameObject)null);
					}
					LogPlayerMenuPanelState(GetInGameMenuPanel(_cachedPlayerController));
					GameObject inGameMenuPanel = GetInGameMenuPanel(_cachedPlayerController);
					if ((Object)(object)inGameMenuPanel != (Object)null)
					{
						Button componentInChildren = inGameMenuPanel.GetComponentInChildren<Button>();
						if ((Object)(object)componentInChildren != (Object)null && ((UIBehaviour)componentInChildren).IsActive() && ((Selectable)componentInChildren).IsInteractable())
						{
							EventSystem current3 = EventSystem.current;
							if (current3 != null)
							{
								current3.SetSelectedGameObject(((Component)componentInChildren).gameObject);
							}
						}
					}
				}
				else
				{
					_lastLoggedPlayerMenuPanel = null;
				}
			}
			bool flag8 = _cacheNeedsRebuild || _cachedSelectables == null;
			if (flag != _wasUiOpen)
			{
				flag8 = true;
			}
			if (flag8)
			{
				_cacheNeedsRebuild = false;
				RebuildSelectableCache();
			}
			bool flag9;
			try
			{
				flag9 = (Object)(object)current.currentSelectedGameObject == (Object)null;
				if (!flag9)
				{
					Selectable component = current.currentSelectedGameObject.GetComponent<Selectable>();
					flag9 = (Object)(object)component == (Object)null || !((UIBehaviour)component).IsActive() || !component.IsInteractable();
				}
			}
			catch
			{
				flag9 = true;
			}
			bool flag10 = _cachedMenuController != null && _serverListReadyForFocus && IsMenuPanelActive((MenuController)_cachedMenuController, "serverListPanel");
			if (flag9 && !flag10)
			{
				Vector2 val3 = ((InputControl<Vector2>)(object)gp.leftStick).ReadValue();
				if (!(((Vector2)(ref val3)).sqrMagnitude > 0.3f))
				{
					val3 = ((InputControl<Vector2>)(object)gp.dpad).ReadValue();
					if (!(((Vector2)(ref val3)).sqrMagnitude > 0.3f))
					{
						goto IL_04ba;
					}
				}
				_autoFocusRetryTimer += Time.deltaTime;
				if (_autoFocusRetryTimer >= 0.05f)
				{
					_autoFocusRetryTimer = 0f;
					TryAutoFocus();
				}
			}
			else
			{
				_autoFocusRetryTimer = 0f;
			}
			goto IL_04ba;
			IL_04ba:
			try
			{
				HandleSliderLock(gp);
			}
			catch (Exception arg8)
			{
				Logger.LogError((object)$"[ControllerSupport] HandleSliderLock: {arg8}");
			}
			try
			{
				HandleOverlayRightStickScroll(gp);
			}
			catch (Exception arg9)
			{
				Logger.LogError((object)$"[ControllerSupport] HandleOverlayRightStickScroll: {arg9}");
			}
			try
			{
				HandleServerListRightStickScroll(gp);
			}
			catch (Exception arg10)
			{
				Logger.LogError((object)$"[ControllerSupport] HandleServerListRightStickScroll: {arg10}");
			}
			if (_voiceChatGuardFrames > 0)
			{
				_voiceChatGuardFrames--;
				if (_voiceChatGuardFrames == 0)
				{
					Gamepad current4 = Gamepad.current;
					if (current4 == null || (!(Mathf.Abs(((InputControl<Vector2>)(object)current4.leftStick).ReadValue().y) > 0.2f) && !(Mathf.Abs(((InputControl<Vector2>)(object)current4.dpad).ReadValue().y) > 0.5f)))
					{
						ReenableVoiceChatComponent();
					}
				}
			}
			try
			{
				HandleManualNavigation(gp);
			}
			catch (Exception arg11)
			{
				Logger.LogError((object)$"[ControllerSupport] HandleManualNavigation: {arg11}");
			}
			try
			{
				HandleSubmitCancel(gp);
			}
			catch (Exception arg12)
			{
				Logger.LogError((object)$"[ControllerSupport] HandleSubmitCancel: {arg12}");
			}
			try
			{
				HandleTabNavigation(gp);
			}
			catch (Exception arg13)
			{
				Logger.LogError((object)$"[ControllerSupport] HandleTabNavigation: {arg13}");
			}
			if (_cachedPlayerController != null)
			{
				try
				{
					HandleWellPanelNavigation(gp);
				}
				catch (Exception arg14)
				{
					Logger.LogError((object)$"[ControllerSupport] HandleWellPanelNavigation: {arg14}");
				}
			}
			try
			{
				HandleBButton(gp);
			}
			catch (Exception arg15)
			{
				Logger.LogError((object)$"[ControllerSupport] HandleBButton: {arg15}");
			}
			if (Mathf.Abs(((InputControl<Vector2>)(object)gp.leftStick).ReadValue().x) > 0.2f || Mathf.Abs(((InputControl<Vector2>)(object)gp.leftStick).ReadValue().y) > 0.2f || Mathf.Abs(((InputControl<Vector2>)(object)gp.dpad).ReadValue().x) > 0.5f || Mathf.Abs(((InputControl<Vector2>)(object)gp.dpad).ReadValue().y) > 0.5f || gp.buttonSouth.wasPressedThisFrame || gp.buttonEast.wasPressedThisFrame || gp.buttonNorth.wasPressedThisFrame || gp.buttonWest.wasPressedThisFrame)
			{
				_lastControllerInputTime = Time.unscaledTime;
			}
			_controllerModeActive = Time.unscaledTime - _lastControllerInputTime < 0.5f;
			_wasUiOpen = flag;
		}

		private static bool IsSettingsPanelOpen()
		{
			if ((Object)(object)UIPatches.lastMenuPanel != (Object)null && UIPatches.lastMenuPanel.activeInHierarchy)
			{
				return true;
			}
			if ((Object)(object)UIPatches.lastPlayerPanel != (Object)null && UIPatches.lastPlayerPanel.activeInHierarchy)
			{
				return true;
			}
			return false;
		}

		private static GameObject GetActiveUiPanel()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			if (_cachedMenuController != null)
			{
				MenuController menuController = (MenuController)_cachedMenuController;
				string[] array = new string[4] { "deletePrompt", "confirmPrompt", "joinGamePrompt", "join_password_prompt" };
				foreach (string fieldName in array)
				{
					GameObject menuPanel = GetMenuPanel(menuController, fieldName);
					if ((Object)(object)menuPanel != (Object)null && menuPanel.activeInHierarchy)
					{
						return menuPanel;
					}
				}
			}
			if ((Object)(object)UIPatches.lastMenuPanel != (Object)null && UIPatches.lastMenuPanel.activeInHierarchy)
			{
				return UIPatches.lastMenuPanel;
			}
			if ((Object)(object)UIPatches.lastPlayerPanel != (Object)null && UIPatches.lastPlayerPanel.activeInHierarchy)
			{
				return UIPatches.lastPlayerPanel;
			}
			return null;
		}

		private static void RebuildSelectableCache()
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			Selectable[] allSelectablesArray = Selectable.allSelectablesArray;
			GameObject activeUiPanel = GetActiveUiPanel();
			_cachedSelectables = new List<Selectable>();
			Selectable[] array = allSelectablesArray;
			foreach (Selectable val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if (!((UIBehaviour)val).IsActive())
					{
						continue;
					}
				}
				catch
				{
					continue;
				}
				try
				{
					if (!val.IsInteractable())
					{
						continue;
					}
				}
				catch
				{
					continue;
				}
				if (!((Component)((Component)val).gameObject.transform.root).gameObject.activeInHierarchy || ((Object)((Component)val).gameObject).name == "ControllerSupport_EventSystem" || (Object)(object)((Component)val).GetComponent<TMP_InputField>() != (Object)null)
				{
					continue;
				}
				if ((Object)(object)activeUiPanel != (Object)null)
				{
					bool flag = false;
					try
					{
						flag = ((Component)val).transform.IsChildOf(activeUiPanel.transform);
					}
					catch
					{
					}
					if (!flag)
					{
						continue;
					}
				}
				EnhanceSelectableForController(val);
				_cachedSelectables.Add(val);
			}
			_navGrid = new NavGrid(_cachedSelectables);
			if (_cachedMenuController != null)
			{
				EnhanceMenuButton((MenuController)_cachedMenuController, "startGameButton", forceColor: true);
			}
			foreach (Selectable cachedSelectable in _cachedSelectables)
			{
				GetScreenPos(cachedSelectable);
				string text = SafeName((Object)(object)cachedSelectable);
				if (text.Length > 50)
				{
					text = text.Substring(0, 50);
				}
			}
			if (IsInGameMenuOpen() && _cachedSelectables.Count == 0)
			{
				LogPlayerMenuPanelState(GetInGameMenuPanel());
			}
		}

		private static void EnhanceSelectableForController(Selectable s, bool forceColor = false)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s == (Object)null)
			{
				return;
			}
			try
			{
				if ((Object)(object)s.targetGraphic == (Object)null)
				{
					Image val = ((Component)s).GetComponent<Image>();
					if ((Object)(object)val == (Object)null)
					{
						val = ((Component)s).GetComponentInChildren<Image>();
					}
					if ((Object)(object)val != (Object)null)
					{
						s.targetGraphic = (Graphic)(object)val;
					}
				}
			}
			catch
			{
			}
			try
			{
				ColorBlock colors = s.colors;
				float num = Mathf.Abs(((ColorBlock)(ref colors)).normalColor.r - ((ColorBlock)(ref colors)).selectedColor.r) + Mathf.Abs(((ColorBlock)(ref colors)).normalColor.g - ((ColorBlock)(ref colors)).selectedColor.g) + Mathf.Abs(((ColorBlock)(ref colors)).normalColor.b - ((ColorBlock)(ref colors)).selectedColor.b);
				if (forceColor || num < 0.25f)
				{
					((ColorBlock)(ref colors)).selectedColor = new Color(0.4f, 0.85f, 1f, 1f);
					((ColorBlock)(ref colors)).highlightedColor = new Color(0.4f, 0.85f, 1f, 0.8f);
					((ColorBlock)(ref colors)).pressedColor = new Color(0.3f, 0.7f, 0.9f, 1f);
					((ColorBlock)(ref colors)).fadeDuration = 0.1f;
					s.colors = colors;
				}
			}
			catch
			{
			}
			if ((Object)(object)((Component)s).GetComponentInParent<ServerListElement>() != (Object)null)
			{
				return;
			}
			try
			{
				for (int i = 0; i < ((Component)s).transform.childCount; i++)
				{
					Transform child = ((Component)s).transform.GetChild(i);
					if (!((Object)(object)child == (Object)null))
					{
						string name = ((Object)child).name;
						if (name.Contains("Outline") || name.Contains("Highlight") || name.Contains("Select") || name.Contains("Border") || name.Contains("Frame"))
						{
							((Component)child).gameObject.SetActive(false);
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void EnhanceMenuButton(MenuController menuController, string fieldName, bool forceColor = false)
		{
			if ((Object)(object)menuController == (Object)null)
			{
				return;
			}
			object? obj = AccessTools.Field(((object)menuController).GetType(), fieldName)?.GetValue(menuController);
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if (!((Object)(object)val == (Object)null))
			{
				Selectable val2 = val.GetComponent<Selectable>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val.GetComponentInChildren<Selectable>(true);
				}
				if (!((Object)(object)val2 == (Object)null))
				{
					EnhanceSelectableForController(val2, forceColor: true);
				}
			}
		}

		private static Vector2 GetScreenPos(Selectable sel)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)sel == (Object)null || !Object.op_Implicit((Object)(object)sel))
			{
				return Vector2.zero;
			}
			Transform transform = ((Component)sel).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)val != (Object)null)
			{
				return RectTransformUtility.WorldToScreenPoint((Camera)null, ((Transform)val).position);
			}
			return new Vector2(((Component)sel).transform.position.x, ((Component)sel).transform.position.y);
		}

		internal static Selectable FindNearestInAdjacentColumn(Selectable source, int dx, NavGrid navGrid)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			if (navGrid == null || _cachedSelectables == null || _cachedSelectables.Count == 0)
			{
				return null;
			}
			Vector2 screenPos = GetScreenPos(source);
			int columnForX = navGrid.GetColumnForX(screenPos.x);
			if (columnForX < 0)
			{
				return null;
			}
			int num = columnForX + dx;
			if (num < 0 || num >= navGrid.columns.Count)
			{
				return null;
			}
			List<Selectable> list = navGrid.columns[num];
			Selectable result = null;
			float num2 = float.MaxValue;
			foreach (Selectable item in list)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item == (Object)(object)source)
				{
					continue;
				}
				try
				{
					if (!((UIBehaviour)item).IsActive() || !item.IsInteractable())
					{
						continue;
					}
					goto IL_00a8;
				}
				catch
				{
				}
				continue;
				IL_00a8:
				Vector2 screenPos2 = GetScreenPos(item);
				float num3 = screenPos2.x - screenPos.x;
				float num4 = screenPos2.y - screenPos.y;
				if ((int)Mathf.Sign(num3) == dx && !(Mathf.Abs(num3) < 5f) && !(Mathf.Abs(num4) > 2000f))
				{
					float num5 = Mathf.Abs(num3) + Mathf.Abs(num4) * 2f;
					if (num5 < num2)
					{
						num2 = num5;
						result = item;
					}
				}
			}
			return result;
		}

		internal static Selectable FindNearestByDirection(Selectable source, int dx, int dy)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (_cachedSelectables == null || _cachedSelectables.Count == 0)
			{
				return null;
			}
			Vector2 screenPos = GetScreenPos(source);
			Selectable result = null;
			float num = float.MaxValue;
			foreach (Selectable cachedSelectable in _cachedSelectables)
			{
				if ((Object)(object)cachedSelectable == (Object)null || (Object)(object)cachedSelectable == (Object)(object)source)
				{
					continue;
				}
				try
				{
					if (!((UIBehaviour)cachedSelectable).IsActive() || !cachedSelectable.IsInteractable())
					{
						continue;
					}
					goto IL_0077;
				}
				catch
				{
				}
				continue;
				IL_0077:
				Vector2 screenPos2 = GetScreenPos(cachedSelectable);
				float num2 = screenPos2.x - screenPos.x;
				float num3 = screenPos2.y - screenPos.y;
				if ((dx == 0 || ((int)Mathf.Sign(num2) == dx && !(Mathf.Abs(num2) < 5f) && !(Mathf.Abs(num3) > 2000f))) && (dy == 0 || ((int)Mathf.Sign(num3) == dy && !(Mathf.Abs(num3) < 5f) && !(Mathf.Abs(num2) > 1200f))))
				{
					float num4 = ((dx != 0) ? Mathf.Abs(num2) : Mathf.Abs(num3));
					float num5 = ((dx != 0) ? Mathf.Abs(num3) : Mathf.Abs(num2));
					float num6 = num4 + num5 * 2f;
					if (num6 < num)
					{
						num = num6;
						result = cachedSelectable;
					}
				}
			}
			return result;
		}

		private static void HandleManualNavigation(Gamepad gp)
		{
			//IL_062c: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_06b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0502: Unknown result type (might be due to invalid IL or missing references)
			//IL_0503: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null || _navGrid == null || _cachedSelectables == null || _cachedSelectables.Count == 0 || (_cachedMenuController != null && IsMenuPanelActive((MenuController)_cachedMenuController, "serverListPanel") && !IsAnyConfirmPromptActive((MenuController)_cachedMenuController)))
			{
				return;
			}
			bool num = _cachedMenuController != null && IsAnyConfirmPromptActive((MenuController)_cachedMenuController);
			GameObject val = null;
			if (num)
			{
				string[] array = new string[4] { "deletePrompt", "confirmPrompt", "joinGamePrompt", "join_password_prompt" };
				foreach (string fieldName in array)
				{
					GameObject menuPanel = GetMenuPanel((MenuController)_cachedMenuController, fieldName);
					if ((Object)(object)menuPanel != (Object)null && menuPanel.activeInHierarchy)
					{
						val = menuPanel;
						break;
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					Transform transform = ((Component)(MenuController)_cachedMenuController).transform;
					for (int j = 0; j < transform.childCount; j++)
					{
						Transform child = transform.GetChild(j);
						if (!((Component)child).gameObject.activeInHierarchy)
						{
							continue;
						}
						string[] obj = new string[5] { "serverListPanel", "hostPanel", "settingsPanel", "creditsPanel", "ExitPrompt" };
						bool flag = false;
						array = obj;
						foreach (string fieldName2 in array)
						{
							GameObject menuPanel2 = GetMenuPanel((MenuController)_cachedMenuController, fieldName2);
							if ((Object)(object)menuPanel2 != (Object)null && (Object)(object)((Component)child).gameObject == (Object)(object)menuPanel2)
							{
								flag = true;
								break;
							}
						}
						if (!flag)
						{
							val = ((Component)child).gameObject;
							break;
						}
					}
				}
			}
			if (_wellNavActive && !_sliderEditMode)
			{
				return;
			}
			Vector2 val2;
			if (_pendingNavTimer > 0f)
			{
				_pendingNavTimer -= Time.deltaTime;
				if (_pendingNavTimer <= 0f)
				{
					_pendingNavFocus = null;
				}
				Vector2 lastNavStick = Vector2.zero;
				val2 = ((InputControl<Vector2>)(object)gp.dpad).ReadValue();
				if (((Vector2)(ref val2)).sqrMagnitude > 0.1f)
				{
					lastNavStick = ((InputControl<Vector2>)(object)gp.dpad).ReadValue();
				}
				else
				{
					val2 = ((InputControl<Vector2>)(object)gp.leftStick).ReadValue();
					if (((Vector2)(ref val2)).sqrMagnitude > 0.5f)
					{
						val2 = ((InputControl<Vector2>)(object)gp.leftStick).ReadValue();
						lastNavStick = ((Vector2)(ref val2)).normalized;
					}
				}
				_lastNavStick = lastNavStick;
				if (((Vector2)(ref lastNavStick)).sqrMagnitude > 0.5f && _navRepeatTimer > 0f)
				{
					_navRepeatTimer -= Time.deltaTime;
				}
				if (!((Object)(object)_pendingNavFocus != (Object)null))
				{
					return;
				}
				try
				{
					if (((UIBehaviour)_pendingNavFocus).IsActive() && ((Behaviour)_pendingNavFocus).isActiveAndEnabled)
					{
						current.SetSelectedGameObject(((Component)_pendingNavFocus).gameObject);
					}
					return;
				}
				catch
				{
					return;
				}
			}
			Vector2 val3 = Vector2.zero;
			val2 = ((InputControl<Vector2>)(object)gp.dpad).ReadValue();
			if (((Vector2)(ref val2)).sqrMagnitude > 0.1f)
			{
				val3 = ((InputControl<Vector2>)(object)gp.dpad).ReadValue();
			}
			else
			{
				val2 = ((InputControl<Vector2>)(object)gp.leftStick).ReadValue();
				if (((Vector2)(ref val2)).sqrMagnitude > 0.5f)
				{
					val2 = ((InputControl<Vector2>)(object)gp.leftStick).ReadValue();
					val3 = ((Vector2)(ref val2)).normalized;
				}
			}
			bool num2 = ((Vector2)(ref val3)).sqrMagnitude > 0.5f;
			bool flag2 = ((Vector2)(ref _lastNavStick)).sqrMagnitude < 0.5f;
			if (!num2)
			{
				_suppressManualNavThisFrame = false;
				_navRepeatTimer = 0f;
				_lastNavStick = val3;
				return;
			}
			if (_suppressManualNavThisFrame)
			{
				_suppressManualNavThisFrame = false;
				_navRepeatTimer = 0.4f;
				_lastNavStick = val3;
				return;
			}
			if (!flag2 && !(_navRepeatTimer <= 0f))
			{
				_navRepeatTimer -= Time.deltaTime;
				_lastNavStick = val3;
				return;
			}
			_navRepeatTimer = (flag2 ? 0.4f : 0.25f);
			int num3 = 0;
			int num4 = 0;
			if (Mathf.Abs(val3.x) > Mathf.Abs(val3.y))
			{
				num3 = ((val3.x > 0f) ? 1 : (-1));
			}
			else
			{
				num4 = ((val3.y > 0f) ? 1 : (-1));
			}
			GameObject currentSelectedGameObject = current.currentSelectedGameObject;
			Selectable val4 = null;
			try
			{
				val4 = ((currentSelectedGameObject != null) ? currentSelectedGameObject.GetComponent<Selectable>() : null);
			}
			catch
			{
				return;
			}
			if ((Object)(object)val4 == (Object)null)
			{
				return;
			}
			if ((Object)(object)_rebindOverlayCanvas != (Object)null)
			{
				Canvas componentInParent = ((Component)val4).GetComponentInParent<Canvas>();
				if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent == (Object)(object)_rebindOverlayCanvas)
				{
					if (num3 != 0 || num4 != 0)
					{
						Selectable val5 = FindOverlayNeighbor(val4, num3, num4);
						if ((Object)(object)val5 != (Object)null)
						{
							_pendingNavFocus = val5;
							_pendingNavTimer = 0.15f;
							_navRepeatTimer = (flag2 ? 0.4f : 0.25f);
							_pendingNavDx = num3;
							_pendingNavDy = num4;
							current.SetSelectedGameObject(((Component)val5).gameObject);
							ScrollOverlayToShowElement(val5);
						}
						else
						{
							current.SetSelectedGameObject(currentSelectedGameObject);
						}
					}
					_lastNavStick = val3;
					return;
				}
			}
			if (_sliderEditMode && (Object)(object)_selectedSlider != (Object)null)
			{
				_lastNavStick = val3;
				return;
			}
			Selectable val6 = FindMenuAwareNeighbor(val4, num3, num4);
			if ((Object)(object)val6 == (Object)null)
			{
				if (num3 != 0)
				{
					val6 = FindNearestInAdjacentColumn(val4, num3, _navGrid);
					if ((Object)(object)val6 == (Object)null)
					{
						val6 = FindNearestByDirection(val4, num3, num4);
					}
				}
				else if (num4 != 0 && _navGrid != null)
				{
					val6 = _navGrid.FindNeighbor(val4, num3, num4);
				}
			}
			if ((Object)(object)val6 == (Object)null && _navGrid != null)
			{
				RebuildSelectableCache();
				if (num4 != 0)
				{
					val6 = _navGrid?.FindNeighbor(val4, num3, num4);
				}
				else if (num3 != 0 && _navGrid != null)
				{
					val6 = FindNearestInAdjacentColumn(val4, num3, _navGrid);
					if ((Object)(object)val6 == (Object)null)
					{
						val6 = FindNearestByDirection(val4, num3, num4);
					}
				}
			}
			if ((Object)(object)val6 != (Object)null)
			{
				(((object)val6).GetType().Name ?? "Unknown").Contains("OptionsButtonConsoleUGUI");
				_ = 0;
				if ((Object)(object)val != (Object)null)
				{
					bool flag3 = false;
					try
					{
						flag3 = ((Component)val6).transform.IsChildOf(val.transform);
					}
					catch
					{
					}
					if (!flag3)
					{
						_lastNavStick = val3;
						return;
					}
				}
				if (IsVoiceChatGameObject(((Component)val4).gameObject) || IsVoiceChatGameObject(((Component)val6).gameObject))
				{
					_voiceChatGuardFrames = 2;
					if (IsVoiceChatGameObject(((Component)val4).gameObject))
					{
						DisableVoiceChatComponent(((Component)val4).gameObject);
					}
					if (IsVoiceChatGameObject(((Component)val6).gameObject))
					{
						DisableVoiceChatComponent(((Component)val6).gameObject);
					}
				}
				current.SetSelectedGameObject(((Component)val6).gameObject);
				if (num3 != 0)
				{
					_pendingNavFocus = val6;
					_pendingNavTimer = 0.15f;
					_pendingNavDx = num3;
					_pendingNavDy = num4;
				}
			}
			_lastNavStick = val3;
		}

		private static void TryAutoFocus(bool force = false)
		{
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null || _cachedSelectables == null || _cachedSelectables.Count == 0)
			{
				return;
			}
			if (!force && (Object)(object)current.currentSelectedGameObject != (Object)null)
			{
				Selectable component = current.currentSelectedGameObject.GetComponent<Selectable>();
				if ((Object)(object)component != (Object)null && ((UIBehaviour)component).IsActive() && component.IsInteractable())
				{
					return;
				}
			}
			Selectable val = null;
			if (_cachedMenuController != null)
			{
				Type type = _cachedMenuController.GetType();
				object? obj = AccessTools.Field(type, "hostPanel")?.GetValue(_cachedMenuController);
				GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
				object? obj2 = AccessTools.Field(type, "serverListPanel")?.GetValue(_cachedMenuController);
				GameObject val3 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				bool flag = (Object)(object)val3 != (Object)null && val3.activeInHierarchy;
				bool flag2 = (Object)(object)val2 != (Object)null && val2.activeInHierarchy;
				if (!flag && !flag2)
				{
					val = GetMenuButtonSelectable(_cachedMenuController, "hostButton");
				}
				else if (flag)
				{
					if (!_serverListReadyForFocus)
					{
						return;
					}
					val = GetTopSelectableFromComponents<ServerListElement>(val3);
					if ((Object)(object)val == (Object)null)
					{
						return;
					}
				}
				else if (flag2)
				{
					val = GetTopSelectableFromComponents<SaveListElement>(val2);
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				foreach (Selectable cachedSelectable in _cachedSelectables)
				{
					if (!((Object)(object)cachedSelectable == (Object)null) && ((UIBehaviour)cachedSelectable).IsActive() && cachedSelectable.IsInteractable() && !((Object)((Component)cachedSelectable).gameObject).name.StartsWith("GamepadRow_") && !(((Object)((Component)cachedSelectable).gameObject).name == "ControllerRebindOverlay"))
					{
						val = cachedSelectable;
						break;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				current.SetSelectedGameObject(((Component)val).gameObject);
				_suppressManualNavThisFrame = true;
			}
		}

		internal static void HandleMenuPanelActivated(MenuController menuController, GameObject panel)
		{
			RegisterMenuController(menuController);
			EnsureEventSystem();
			RebuildSelectableCache();
			bool flag = false;
			if ((Object)(object)panel != (Object)null)
			{
				string[] array = new string[4] { "deletePrompt", "confirmPrompt", "joinGamePrompt", "join_password_prompt" };
				foreach (string fieldName in array)
				{
					GameObject menuPanel = GetMenuPanel(menuController, fieldName);
					if ((Object)(object)menuPanel != (Object)null && (Object)(object)menuPanel == (Object)(object)panel)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					string[] obj = new string[5] { "serverListPanel", "hostPanel", "settingsPanel", "creditsPanel", "ExitPrompt" };
					bool flag2 = false;
					array = obj;
					foreach (string fieldName2 in array)
					{
						GameObject menuPanel2 = GetMenuPanel(menuController, fieldName2);
						if ((Object)(object)menuPanel2 != (Object)null && (Object)(object)menuPanel2 == (Object)(object)panel)
						{
							flag2 = true;
							break;
						}
					}
					flag = !flag2;
				}
			}
			if (IsMenuPanelActive(menuController, "serverListPanel"))
			{
				if (flag || IsAnyConfirmPromptActive(menuController))
				{
					FocusActiveMenuPanel(menuController);
				}
				else if ((Object)(object)panel != (Object)null)
				{
					_cachedServerElements.Clear();
					_cachedServerElementIdx = -1;
					_serverListReadyForFocus = false;
					_serverListAutoFocused = false;
					_serverListLastFocusFrame = -5;
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject((GameObject)null);
					}
				}
			}
			else
			{
				FocusActiveMenuPanel(menuController);
			}
		}

		internal static void HandleServerListPopulated(MenuController menuController)
		{
			RegisterMenuController(menuController);
			EnsureEventSystem();
			_serverListReadyForFocus = false;
			_serverListAutoFocused = false;
			_serverListLastFocusFrame = -5;
			RebuildSelectableCache();
			GameObject menuPanel = GetMenuPanel(menuController, "serverListPanel");
			if ((Object)(object)menuPanel != (Object)null)
			{
				RebuildServerElementsCache(menuPanel);
				ScrollRect componentInChildren = menuPanel.GetComponentInChildren<ScrollRect>(true);
				if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.content != (Object)null)
				{
					ApplyScrollToTop(componentInChildren);
				}
			}
			((MonoBehaviour)menuController).StartCoroutine(DelayedServerListFocus(menuController));
			if (!((Object)(object)menuPanel != (Object)null) || _cachedServerElements.Count <= 0)
			{
				return;
			}
			EventSystem current = EventSystem.current;
			if (!((Object)(object)current != (Object)null))
			{
				return;
			}
			GameObject curSel = current.currentSelectedGameObject;
			if (!((Object)(object)curSel != (Object)null) || !Object.op_Implicit((Object)(object)curSel) || !curSel.transform.IsChildOf(menuPanel.transform) || _cachedServerElements.Any((Selectable e) => (Object)(object)e != (Object)null && Object.op_Implicit((Object)(object)e) && (Object)(object)((Component)e).gameObject == (Object)(object)curSel))
			{
				return;
			}
			_cachedServerElementIdx = 0;
			Selectable val = _cachedServerElements[0];
			if ((Object)(object)val != (Object)null && Object.op_Implicit((Object)(object)val))
			{
				EnhanceSelectableForController(val, forceColor: true);
				EventSystem current2 = EventSystem.current;
				if (current2 != null)
				{
					current2.SetSelectedGameObject(((Component)val).gameObject);
				}
				_serverListAutoFocused = true;
			}
		}

		internal static void HandleServerListRefreshStarted(MenuController menuController)
		{
			RegisterMenuController(menuController);
			_serverListReadyForFocus = false;
			_serverListAutoFocused = false;
			_serverListScrollAccum = 0f;
			_cachedServerElements.Clear();
			_cachedServerElementIdx = -1;
			_serverListLastFocusFrame = -5;
			if (IsMenuPanelActive(menuController, "serverListPanel"))
			{
				EventSystem current = EventSystem.current;
				if (current != null)
				{
					current.SetSelectedGameObject((GameObject)null);
				}
			}
		}

		private static void HandleOverlayRightStickScroll(Gamepad gp)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (!IsOverlayActive())
			{
				_overlayScrollAccum = 0f;
				return;
			}
			float num = ((InputControl<float>)(object)((Vector2Control)gp.rightStick).y).ReadValue();
			if (Mathf.Abs(num) <= 0.3f)
			{
				_overlayScrollAccum = 0f;
				return;
			}
			GameObject gameObject = ((Component)_rebindOverlayCanvas).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			ScrollRect componentInChildren = gameObject.GetComponentInChildren<ScrollRect>(true);
			if ((Object)(object)componentInChildren == (Object)null || (Object)(object)componentInChildren.content == (Object)null)
			{
				return;
			}
			RectTransform val = componentInChildren.viewport;
			if ((Object)(object)val == (Object)null)
			{
				Transform transform = ((Component)componentInChildren).transform;
				val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Rect rect = val.rect;
			float height = ((Rect)(ref rect)).height;
			rect = componentInChildren.content.rect;
			float num2 = ((Rect)(ref rect)).height - height;
			if (!(num2 <= 1f))
			{
				_overlayScrollAccum += num * Time.deltaTime * 650f / num2;
				if (!(Mathf.Abs(_overlayScrollAccum) <= 0.01f))
				{
					componentInChildren.verticalNormalizedPosition = Mathf.Clamp01(componentInChildren.verticalNormalizedPosition + _overlayScrollAccum);
					_overlayScrollAccum = 0f;
				}
			}
		}

		internal static void ScrollOverlayToShowElement(Selectable target)
		{
			if ((Object)(object)target == (Object)null || (Object)(object)_rebindOverlayCanvas == (Object)null)
			{
				return;
			}
			ScrollRect componentInChildren = ((Component)_rebindOverlayCanvas).GetComponentInChildren<ScrollRect>(true);
			if ((Object)(object)componentInChildren == (Object)null || (Object)(object)componentInChildren.content == (Object)null || (Object)(object)componentInChildren.viewport == (Object)null)
			{
				return;
			}
			RectTransform viewport = componentInChildren.viewport;
			RectTransform content = componentInChildren.content;
			Transform transform = ((Component)target).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)viewport == (Object)null || (Object)(object)content == (Object)null || (Object)(object)val == (Object)null)
			{
				return;
			}
			Canvas.ForceUpdateCanvases();
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			viewport.GetWorldCorners(array);
			Vector3[] array2 = (Vector3[])(object)new Vector3[4];
			val.GetWorldCorners(array2);
			float y = array[1].y;
			float y2 = array[0].y;
			float y3 = array2[1].y;
			float y4 = array2[0].y;
			if (y4 >= y2 + 8f && y3 <= y - 8f)
			{
				return;
			}
			Vector3[] array3 = (Vector3[])(object)new Vector3[4];
			content.GetWorldCorners(array3);
			float num = array3[1].y - array3[0].y;
			float num2 = y - y2;
			float num3 = num - num2;
			if (!(num3 <= 1f))
			{
				float verticalNormalizedPosition = componentInChildren.verticalNormalizedPosition;
				if (y4 < y2 + 8f)
				{
					float num4 = Mathf.Min(y2 - y4 + 8f, num3) / num3;
					componentInChildren.verticalNormalizedPosition = Mathf.Clamp01(verticalNormalizedPosition - num4);
				}
				else if (y3 > y - 8f)
				{
					float num5 = Mathf.Min(y3 - y + 8f, num3) / num3;
					componentInChildren.verticalNormalizedPosition = Mathf.Clamp01(verticalNormalizedPosition + num5);
				}
			}
		}

		private static void HandleServerListRightStickScroll(Gamepad gp)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			if (_cachedMenuController == null)
			{
				_serverListScrollAccum = 0f;
				return;
			}
			object cachedMenuController = _cachedMenuController;
			MenuController menuController = (MenuController)((cachedMenuController is MenuController) ? cachedMenuController : null);
			if (!IsMenuPanelActive(menuController, "serverListPanel") || IsAnyConfirmPromptActive(menuController) || IsOverlayActive(menuController))
			{
				_serverListScrollAccum = 0f;
				return;
			}
			float num = ((InputControl<float>)(object)((Vector2Control)gp.rightStick).y).ReadValue();
			if (Mathf.Abs(num) <= 0.3f)
			{
				_serverListScrollAccum = 0f;
				return;
			}
			GameObject menuPanel = GetMenuPanel(menuController, "serverListPanel");
			ScrollRect val = (((Object)(object)menuPanel != (Object)null) ? menuPanel.GetComponentInChildren<ScrollRect>(true) : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val.content == (Object)null || (Object)(object)val.viewport == (Object)null)
			{
				return;
			}
			Rect rect = val.content.rect;
			float height = ((Rect)(ref rect)).height;
			rect = val.viewport.rect;
			float num2 = height - ((Rect)(ref rect)).height;
			if (!(num2 <= 1f))
			{
				_serverListScrollAccum += num * Time.deltaTime * 650f / num2;
				if (!(Mathf.Abs(_serverListScrollAccum) <= 0.01f))
				{
					val.verticalNormalizedPosition = Mathf.Clamp01(val.verticalNormalizedPosition + _serverListScrollAccum);
					_serverListScrollAccum = 0f;
				}
			}
		}

		private static void HandleServerListNavigation(Gamepad gp)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0686: Unknown result type (might be due to invalid IL or missing references)
			//IL_068b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Unknown result type (might be due to invalid IL or missing references)
			//IL_069a: Unknown result type (might be due to invalid IL or missing references)
			if (IsAnyConfirmPromptActive((MenuController)_cachedMenuController) || IsOverlayActive((MenuController)_cachedMenuController))
			{
				return;
			}
			GameObject menuPanel = GetMenuPanel((MenuController)_cachedMenuController, "serverListPanel");
			if ((Object)(object)menuPanel == (Object)null || !menuPanel.activeInHierarchy)
			{
				_serverListPanelWasActive = false;
				return;
			}
			if (!_serverListPanelWasActive)
			{
				_serverListPanelWasActive = true;
				_serverListAutoFocused = false;
				_serverListReadyForFocus = true;
			}
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				return;
			}
			if (_cachedServerElements.Count > 0)
			{
				Selectable val = _cachedServerElements[0];
				if ((Object)(object)val == (Object)null || !Object.op_Implicit((Object)(object)val))
				{
					_cachedServerElements.Clear();
				}
			}
			if (_cachedServerElements.Count == 0)
			{
				RebuildServerElementsCache(menuPanel);
				if (_cachedServerElements.Count == 0)
				{
					return;
				}
			}
			float num = 0f;
			Vector2 val2 = ((InputControl<Vector2>)(object)gp.dpad).ReadValue();
			if (((Vector2)(ref val2)).sqrMagnitude > 0.1f)
			{
				num = ((InputControl<float>)(object)((Vector2Control)gp.dpad).y).ReadValue();
			}
			else
			{
				val2 = ((InputControl<Vector2>)(object)gp.leftStick).ReadValue();
				if (((Vector2)(ref val2)).sqrMagnitude > 0.5f)
				{
					num = ((InputControl<float>)(object)((Vector2Control)gp.leftStick).y).ReadValue();
				}
			}
			bool num2 = Mathf.Abs(num) > 0.5f;
			if (_deferredScrollTopTimer >= 0f)
			{
				_deferredScrollTopTimer -= Time.deltaTime;
				if (_deferredScrollTopTimer <= 0f)
				{
					_deferredScrollTopTimer = -1f;
					if (_cachedServerElementIdx == _deferredScrollTopIdx)
					{
						ScrollRect componentInChildren = menuPanel.GetComponentInChildren<ScrollRect>(true);
						if ((Object)(object)componentInChildren != (Object)null)
						{
							ApplyScrollToTop(componentInChildren);
						}
					}
				}
			}
			bool flag = false;
			float unscaledTime = Time.unscaledTime;
			if (num2)
			{
				if (!_serverListNavHeldDown)
				{
					flag = true;
					_serverListNavHeldDown = true;
					_serverListNavRepeatPhase = false;
					_serverListNavLastStepTime = unscaledTime;
				}
				else
				{
					float num3 = unscaledTime - _serverListNavLastStepTime;
					float num4 = (_serverListNavRepeatPhase ? 0.25f : 0.4f);
					if (num3 >= num4)
					{
						flag = true;
						_serverListNavLastStepTime = unscaledTime;
						_serverListNavRepeatPhase = true;
					}
				}
			}
			else
			{
				_serverListNavHeldDown = false;
			}
			GameObject currentSelectedGameObject = current.currentSelectedGameObject;
			bool flag2 = (Object)(object)currentSelectedGameObject != (Object)null && Object.op_Implicit((Object)(object)currentSelectedGameObject) && currentSelectedGameObject.transform.IsChildOf(menuPanel.transform);
			if (flag2)
			{
				_ = _cachedServerElementIdx;
				for (int i = 0; i < _cachedServerElements.Count; i++)
				{
					Selectable val3 = _cachedServerElements[i];
					if ((Object)(object)val3 != (Object)null && Object.op_Implicit((Object)(object)val3) && (Object)(object)((Component)val3).gameObject == (Object)(object)currentSelectedGameObject)
					{
						_cachedServerElementIdx = i;
						break;
					}
				}
			}
			if (flag)
			{
				int num5 = _cachedServerElementIdx;
				EventSystem current2 = EventSystem.current;
				GameObject curSelNow = (((Object)(object)current2 != (Object)null) ? current2.currentSelectedGameObject : null);
				bool flag3 = (Object)(object)curSelNow != (Object)null && Object.op_Implicit((Object)(object)curSelNow) && curSelNow.transform.IsChildOf(menuPanel.transform) && !_cachedServerElements.Any((Selectable e) => (Object)(object)e != (Object)null && Object.op_Implicit((Object)(object)e) && (Object)(object)((Component)e).gameObject == (Object)(object)curSelNow);
				if (flag3 && num < -0.5f)
				{
					if (_cachedServerElements.Count == 0)
					{
						RebuildServerElementsCache(menuPanel);
					}
					if (_cachedServerElements.Count > 0)
					{
						Selectable val4 = _cachedServerElements[0];
						if ((Object)(object)val4 == (Object)null || !Object.op_Implicit((Object)(object)val4) || !((UIBehaviour)val4).IsActive() || !val4.IsInteractable())
						{
							RebuildServerElementsCache(menuPanel);
							if (_cachedServerElements.Count != 0)
							{
								val4 = _cachedServerElements[0];
							}
						}
						if ((Object)(object)val4 != (Object)null && Object.op_Implicit((Object)(object)val4))
						{
							_cachedServerElementIdx = 0;
							_serverListLastFocusFrame = Time.frameCount;
							EnhanceSelectableForController(val4, forceColor: true);
							EventSystem current3 = EventSystem.current;
							if (current3 != null)
							{
								current3.SetSelectedGameObject(((Component)val4).gameObject);
							}
							ScrollToShowElement(val4, menuPanel);
							return;
						}
					}
				}
				if (num < -0.5f && num5 < _cachedServerElements.Count - 1)
				{
					num5++;
				}
				else if (num > 0.5f && num5 > 0)
				{
					num5--;
				}
				if (num5 != _cachedServerElementIdx)
				{
					Selectable target = _cachedServerElements[num5];
					_cachedServerElementIdx = num5;
					_serverListLastFocusFrame = Time.frameCount;
					FocusSelectable(target, "server list nav");
					ScrollToShowElement(target, menuPanel);
					return;
				}
				if (!flag3 && num5 == 0 && num > 0.5f)
				{
					Selectable val5 = FindNearestSelectableAbove(_cachedServerElements[0], menuPanel);
					if ((Object)(object)val5 != (Object)null)
					{
						EventSystem current4 = EventSystem.current;
						if ((Object)(object)current4 != (Object)null)
						{
							current4.SetSelectedGameObject(((Component)val5).gameObject);
						}
						_serverListAutoFocused = false;
					}
				}
				else if (!flag3 && num5 >= 0 && num5 < _cachedServerElements.Count)
				{
					Selectable val6 = _cachedServerElements[num5];
					if ((Object)(object)val6 != (Object)null && Object.op_Implicit((Object)(object)val6) && ((UIBehaviour)val6).IsActive() && val6.IsInteractable())
					{
						EventSystem current5 = EventSystem.current;
						if ((Object)(object)current5 != (Object)null && (Object)(object)current5.currentSelectedGameObject != (Object)(object)((Component)val6).gameObject)
						{
							GameObject currentSelectedGameObject2 = current5.currentSelectedGameObject;
							if (!((Object)(object)currentSelectedGameObject2 != (Object)null) || !currentSelectedGameObject2.transform.IsChildOf(menuPanel.transform) || !((Object)(object)currentSelectedGameObject2.GetComponent<Selectable>() != (Object)null) || _cachedServerElements.Contains(currentSelectedGameObject2.GetComponent<Selectable>()))
							{
								current5.SetSelectedGameObject(((Component)val6).gameObject);
								ScrollToShowElement(val6, menuPanel);
							}
						}
					}
				}
			}
			if (flag2 || _cachedServerElements.Count <= 0)
			{
				return;
			}
			bool flag4 = !_serverListAutoFocused;
			if (!_serverListAutoFocused)
			{
				_serverListAutoFocused = true;
			}
			_cachedServerElementIdx = Mathf.Clamp(_cachedServerElementIdx, 0, _cachedServerElements.Count - 1);
			Selectable val7 = _cachedServerElements[_cachedServerElementIdx];
			bool flag5 = false;
			if ((Object)(object)val7 == (Object)null || !((UIBehaviour)val7).IsActive() || !val7.IsInteractable())
			{
				RebuildServerElementsCache(menuPanel);
				if (_cachedServerElements.Count == 0)
				{
					return;
				}
				_cachedServerElementIdx = Mathf.Clamp(_cachedServerElementIdx, 0, _cachedServerElements.Count - 1);
				val7 = _cachedServerElements[_cachedServerElementIdx];
				flag5 = true;
			}
			if (flag4 || flag5)
			{
				ScrollRect componentInChildren2 = menuPanel.GetComponentInChildren<ScrollRect>(true);
				if ((Object)(object)componentInChildren2 != (Object)null && (Object)(object)componentInChildren2.content != (Object)null)
				{
					RectTransform content = componentInChildren2.content;
					Rect rect = componentInChildren2.viewport.rect;
					_ = ((Rect)(ref rect)).height;
					rect = content.rect;
					_ = ((Rect)(ref rect)).height;
					ApplyScrollToTop(componentInChildren2);
					if (flag4)
					{
						_deferredScrollTopTimer = 0.1f;
					}
					_deferredScrollTopIdx = _cachedServerElementIdx;
				}
			}
			if ((Object)(object)val7 != (Object)null && Object.op_Implicit((Object)(object)val7) && ((UIBehaviour)val7).IsActive() && val7.IsInteractable())
			{
				_serverListLastFocusFrame = Time.frameCount;
				FocusSelectable(val7, "server list auto");
			}
		}

		private static Selectable FindNearestSelectableAbove(Selectable source, GameObject panel)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || (Object)(object)panel == (Object)null)
			{
				return null;
			}
			Vector3 val = Vector2.op_Implicit(GetScreenPos(source));
			Selectable result = null;
			float num = float.MaxValue;
			Selectable[] componentsInChildren = panel.GetComponentsInChildren<Selectable>(true);
			foreach (Selectable val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2 == (Object)(object)source || !((UIBehaviour)val2).IsActive() || !val2.IsInteractable() || _cachedServerElements.Contains(val2))
				{
					continue;
				}
				Vector3 val3 = Vector2.op_Implicit(GetScreenPos(val2));
				if (!(val3.y <= val.y + 5f))
				{
					float num2 = val3.y - val.y;
					float num3 = Mathf.Abs(val3.x - val.x);
					float num4 = num2 + num3 * 5f;
					if (num4 < num)
					{
						num = num4;
						result = val2;
					}
				}
			}
			return result;
		}

		private static void ApplyScrollToTop(ScrollRect sr)
		{
			if (!((Object)(object)sr == (Object)null) && !((Object)(object)sr.content == (Object)null))
			{
				Canvas.ForceUpdateCanvases();
				sr.verticalNormalizedPosition = 0f;
			}
		}

		private static void ScrollToShowElement(Selectable target, GameObject panel)
		{
			if ((Object)(object)target == (Object)null || (Object)(object)panel == (Object)null)
			{
				return;
			}
			ScrollRect componentInChildren = panel.GetComponentInChildren<ScrollRect>(true);
			if ((Object)(object)componentInChildren == (Object)null || (Object)(object)componentInChildren.content == (Object)null || (Object)(object)componentInChildren.viewport == (Object)null)
			{
				return;
			}
			RectTransform viewport = componentInChildren.viewport;
			RectTransform content = componentInChildren.content;
			Transform transform = ((Component)target).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)viewport == (Object)null || (Object)(object)content == (Object)null || (Object)(object)val == (Object)null || _cachedServerElements.IndexOf(target) < 0 || _cachedServerElements.Count < 2)
			{
				return;
			}
			Canvas.ForceUpdateCanvases();
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			viewport.GetWorldCorners(array);
			Vector3[] array2 = (Vector3[])(object)new Vector3[4];
			val.GetWorldCorners(array2);
			float y = array[1].y;
			float y2 = array[0].y;
			float y3 = array2[1].y;
			float y4 = array2[0].y;
			if (y4 >= y2 + 8f && y3 <= y - 8f)
			{
				return;
			}
			Vector3[] array3 = (Vector3[])(object)new Vector3[4];
			content.GetWorldCorners(array3);
			float num = array3[1].y - array3[0].y;
			float num2 = y - y2;
			float num3 = num - num2;
			if (num3 <= 1f)
			{
				return;
			}
			float verticalNormalizedPosition = componentInChildren.verticalNormalizedPosition;
			if (y4 > y + 8f)
			{
				float num4 = (y4 - y + 8f) / num3;
				float num5 = Mathf.Clamp01(verticalNormalizedPosition + num4);
				if (Mathf.Abs(num5 - verticalNormalizedPosition) > 0.001f)
				{
					componentInChildren.verticalNormalizedPosition = num5;
				}
			}
			else if (y3 < y2 - 8f)
			{
				float num6 = (y2 - y3 + 8f) / num3;
				float num7 = Mathf.Clamp01(verticalNormalizedPosition - num6);
				if (Mathf.Abs(num7 - verticalNormalizedPosition) > 0.001f)
				{
					componentInChildren.verticalNormalizedPosition = num7;
				}
			}
			else if (y4 < y2 - 8f)
			{
				float num8 = (y2 - y4 + 8f) / num3;
				float num9 = Mathf.Clamp01(verticalNormalizedPosition - num8);
				if (Mathf.Abs(num9 - verticalNormalizedPosition) > 0.001f)
				{
					componentInChildren.verticalNormalizedPosition = num9;
				}
			}
			else if (y3 > y + 8f)
			{
				float num10 = (y3 - y + 8f) / num3;
				float num11 = Mathf.Clamp01(verticalNormalizedPosition + num10);
				if (Mathf.Abs(num11 - verticalNormalizedPosition) > 0.001f)
				{
					componentInChildren.verticalNormalizedPosition = num11;
				}
			}
		}

		private static void RebuildServerElementsCache(GameObject panel)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			ServerListElement[] componentsInChildren = panel.GetComponentsInChildren<ServerListElement>(true);
			List<Selectable> list = new List<Selectable>();
			ServerListElement[] array = componentsInChildren;
			foreach (ServerListElement val in array)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					Selectable val2 = ((Component)val).GetComponent<Selectable>();
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = ((Component)val).GetComponentInChildren<Selectable>(true);
					}
					if (!((Object)(object)val2 == (Object)null) && ((UIBehaviour)val2).IsActive() && val2.IsInteractable())
					{
						list.Add(val2);
					}
				}
			}
			list.Sort(delegate(Selectable a, Selectable b)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				bool flag = (Object)(object)a != (Object)null && Object.op_Implicit((Object)(object)a);
				bool num2 = (Object)(object)b != (Object)null && Object.op_Implicit((Object)(object)b);
				float value = (flag ? GetScreenPos(a).y : 0f);
				return (num2 ? GetScreenPos(b).y : 0f).CompareTo(value);
			});
			for (int num = 0; num < list.Count; num++)
			{
				Navigation navigation = list[num].navigation;
				((Navigation)(ref navigation)).mode = (Mode)0;
				list[num].navigation = navigation;
			}
			_cachedServerElements = list;
			if (_cachedServerElements.Count > 0)
			{
				_cachedServerElementIdx = Mathf.Clamp(_cachedServerElementIdx, 0, _cachedServerElements.Count - 1);
			}
			else
			{
				_cachedServerElementIdx = -1;
			}
			if (list.Count > 0)
			{
				_serverListReadyForFocus = true;
			}
		}

		private static bool IsAnyConfirmPromptActive(MenuController menuController)
		{
			if ((Object)(object)menuController == (Object)null)
			{
				return false;
			}
			string[] array = new string[4] { "deletePrompt", "confirmPrompt", "joinGamePrompt", "join_password_prompt" };
			foreach (string fieldName in array)
			{
				GameObject menuPanel = GetMenuPanel(menuController, fieldName);
				if ((Object)(object)menuPanel != (Object)null && menuPanel.activeInHierarchy)
				{
					return true;
				}
			}
			string[] array2 = new string[5] { "serverListPanel", "hostPanel", "settingsPanel", "creditsPanel", "ExitPrompt" };
			Transform transform = ((Component)menuController).transform;
			for (int j = 0; j < transform.childCount; j++)
			{
				Transform child = transform.GetChild(j);
				if (!((Component)child).gameObject.activeInHierarchy)
				{
					continue;
				}
				bool flag = false;
				array = array2;
				foreach (string fieldName2 in array)
				{
					GameObject menuPanel2 = GetMenuPanel(menuController, fieldName2);
					if ((Object)(object)menuPanel2 != (Object)null && (Object)(object)((Component)child).gameObject == (Object)(object)menuPanel2)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsOverlayActive(MenuController menuController)
		{
			if ((Object)(object)menuController == (Object)null)
			{
				return false;
			}
			string[] array = new string[5] { "serverListPanel", "hostPanel", "settingsPanel", "creditsPanel", "ExitPrompt" };
			Transform transform = ((Component)menuController).transform;
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform child = transform.GetChild(i);
				if (!((Component)child).gameObject.activeInHierarchy)
				{
					continue;
				}
				bool flag = false;
				string[] array2 = array;
				foreach (string fieldName in array2)
				{
					GameObject menuPanel = GetMenuPanel(menuController, fieldName);
					if ((Object)(object)menuPanel != (Object)null && (Object)(object)((Component)child).gameObject == (Object)(object)menuPanel)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					continue;
				}
				Selectable[] componentsInChildren = ((Component)child).GetComponentsInChildren<Selectable>(true);
				foreach (Selectable val in componentsInChildren)
				{
					try
					{
						if (((UIBehaviour)val).IsActive() && val.IsInteractable())
						{
							return true;
						}
					}
					catch
					{
					}
				}
			}
			return false;
		}

		private static bool FocusGenericOverlay(MenuController menuController)
		{
			if ((Object)(object)menuController == (Object)null)
			{
				return false;
			}
			string[] array = new string[5] { "serverListPanel", "hostPanel", "settingsPanel", "creditsPanel", "ExitPrompt" };
			Transform transform = ((Component)menuController).transform;
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform child = transform.GetChild(i);
				if (!((Component)child).gameObject.activeInHierarchy)
				{
					continue;
				}
				bool flag = false;
				string[] array2 = array;
				foreach (string fieldName in array2)
				{
					GameObject menuPanel = GetMenuPanel(menuController, fieldName);
					if ((Object)(object)menuPanel != (Object)null && (Object)(object)((Component)child).gameObject == (Object)(object)menuPanel)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					continue;
				}
				Selectable[] componentsInChildren = ((Component)child).GetComponentsInChildren<Selectable>(true);
				foreach (Selectable val in componentsInChildren)
				{
					if (IsSelectableInteractable(val))
					{
						FocusSelectable(val, "overlay (" + ((Object)child).name + ")");
						return true;
					}
				}
			}
			return false;
		}

		internal static IEnumerator WaitForServerListPopulated(MenuController menuController)
		{
			for (int i = 0; i < 50; i++)
			{
				yield return (object)new WaitForSeconds(0.2f);
				if (!IsMenuPanelActive(menuController, "serverListPanel"))
				{
					yield break;
				}
				if (IsAnyConfirmPromptActive(menuController))
				{
					continue;
				}
				GameObject menuPanel = GetMenuPanel(menuController, "serverListPanel");
				if (!((Object)(object)menuPanel == (Object)null) && menuPanel.GetComponentsInChildren<ServerListElement>(true).Length != 0)
				{
					_serverListReadyForFocus = true;
					RebuildSelectableCache();
					RebuildServerElementsCache(menuPanel);
					Selectable val = GetFirstSelectableFromComponents<ServerListElement>(menuPanel);
					if ((Object)(object)val == (Object)null)
					{
						val = GetTopSelectableFromComponents<ServerListElement>(menuPanel);
					}
					if ((Object)(object)val != (Object)null)
					{
						FocusSelectable(val, "server list (populated)");
					}
					yield break;
				}
			}
			Logger.LogWarning((object)"[ControllerSupport] Server list population timeout — no elements after 10s");
		}

		internal static void HandleServerListElementBound(ServerListElement element, MenuController menuController)
		{
			RegisterMenuController(menuController);
			MenuController menuController2 = (MenuController)(((object)menuController) ?? ((object)/*isinst with value type is only supported in some contexts*/));
			if (IsMenuPanelActive(menuController2, "serverListPanel") && !IsAnyConfirmPromptActive(menuController2))
			{
				Selectable val = ((Component)element).GetComponent<Selectable>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)element).GetComponentInChildren<Selectable>(true);
				}
				if ((Object)(object)val != (Object)null)
				{
					EnhanceSelectableForController(val, forceColor: true);
				}
			}
		}

		private static IEnumerator DelayedServerListFocus(MenuController menuController)
		{
			for (int attempt = 0; attempt < 10; attempt++)
			{
				yield return (object)new WaitForSeconds(0.5f);
				if (!IsMenuPanelActive(menuController, "serverListPanel") || IsAnyConfirmPromptActive(menuController))
				{
					yield break;
				}
				if (_serverListReadyForFocus)
				{
					GameObject menuPanel = GetMenuPanel(menuController, "serverListPanel");
					if ((Object)(object)menuPanel != (Object)null)
					{
						Transform transform = menuPanel.transform;
						LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((transform is RectTransform) ? transform : null));
					}
					RebuildSelectableCache();
					Selectable val = GetFirstSelectableFromComponents<ServerListElement>(menuPanel);
					if ((Object)(object)val == (Object)null)
					{
						val = GetTopSelectableFromComponents<ServerListElement>(menuPanel);
					}
					if ((Object)(object)val != (Object)null)
					{
						FocusSelectable(val, $"server list (attempt {attempt + 1})");
						yield break;
					}
				}
			}
			Logger.LogWarning((object)"[ControllerSupport] Server list focus: no elements found after 10 attempts");
		}

		internal static void FocusConfirmPromptDelayed(MenuController menuController, string reason)
		{
			if (!((Object)(object)menuController == (Object)null))
			{
				RegisterMenuController(menuController);
				((MonoBehaviour)menuController).StartCoroutine(DelayedConfirmPromptFocus(menuController, reason));
			}
		}

		private static IEnumerator DelayedConfirmPromptFocus(MenuController menuController, string reason)
		{
			string[] promptFieldNames = new string[4] { "deletePrompt", "confirmPrompt", "joinGamePrompt", "join_password_prompt" };
			for (int attempt = 0; attempt < 15; attempt++)
			{
				yield return (object)new WaitForSeconds(0.25f);
				string[] array = promptFieldNames;
				foreach (string text in array)
				{
					if (IsMenuPanelActive(menuController, text))
					{
						RebuildSelectableCache();
						if (FocusConfirmPrompt(menuController, text))
						{
							yield break;
						}
					}
				}
				if (FocusConfirmPrompt(menuController))
				{
					yield break;
				}
			}
			Logger.LogWarning((object)("[ControllerSupport] Confirm prompt autofocus failed: " + reason + " — no confirm/cancel button found"));
		}

		internal static void HandleSaveListElementBound(SaveListElement element, MenuController menuController)
		{
			RegisterMenuController(menuController);
			if (IsMenuPanelActive(menuController, "hostPanel"))
			{
				EnsureEventSystem();
				RebuildSelectableCache();
				FocusTopSave(menuController, force: true);
			}
		}

		private static void FocusActiveMenuPanel(MenuController menuController)
		{
			if ((Object)(object)menuController == (Object)null)
			{
				return;
			}
			string[] array = new string[4] { "deletePrompt", "confirmPrompt", "joinGamePrompt", "join_password_prompt" };
			foreach (string text in array)
			{
				if (IsMenuPanelActive(menuController, text) && FocusConfirmPrompt(menuController, text))
				{
					return;
				}
			}
			if (FocusGenericOverlay(menuController))
			{
				return;
			}
			if (IsMenuPanelActive(menuController, "serverListPanel"))
			{
				if (_serverListReadyForFocus)
				{
					FocusTopServer(menuController, force: true);
				}
			}
			else if (IsMenuPanelActive(menuController, "hostPanel"))
			{
				FocusTopSave(menuController, force: true);
			}
			else if (!FocusMainMenuPrivateGame(menuController))
			{
				TryAutoFocus(force: true);
			}
		}

		private static bool IsMenuPanelActive(MenuController menuController, string fieldName)
		{
			GameObject menuPanel = GetMenuPanel(menuController, fieldName);
			if ((Object)(object)menuPanel != (Object)null)
			{
				return menuPanel.activeInHierarchy;
			}
			return false;
		}

		private static GameObject GetMenuPanel(MenuController menuController, string fieldName)
		{
			if ((Object)(object)menuController == (Object)null)
			{
				return null;
			}
			object? obj = typeof(MenuController).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(menuController);
			return (GameObject)((obj is GameObject) ? obj : null);
		}

		private static Selectable GetMenuButtonSelectable(object menuController, string fieldName)
		{
			if (menuController == null)
			{
				return null;
			}
			object? obj = AccessTools.Field(menuController.GetType(), fieldName)?.GetValue(menuController);
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if ((Object)(object)val == (Object)null || !val.activeInHierarchy)
			{
				return null;
			}
			Selectable val2 = val.GetComponent<Selectable>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = val.GetComponentInChildren<Selectable>(true);
			}
			try
			{
				if ((Object)(object)val2 == (Object)null || !((UIBehaviour)val2).IsActive() || !val2.IsInteractable())
				{
					return null;
				}
				return val2;
			}
			catch
			{
				return null;
			}
		}

		private static bool CurrentSelectionIsUnder(GameObject root)
		{
			EventSystem current = EventSystem.current;
			GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
			if ((Object)(object)root == (Object)null || (Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				return val.transform.IsChildOf(root.transform);
			}
			catch
			{
				return false;
			}
		}

		private static void FocusTopServer(MenuController menuController, bool force)
		{
			GameObject menuPanel = GetMenuPanel(menuController, "serverListPanel");
			if ((Object)(object)menuPanel == (Object)null || !menuPanel.activeInHierarchy || (!force && CurrentSelectionIsUnder(menuPanel)))
			{
				return;
			}
			if (!_serverListReadyForFocus)
			{
				((MonoBehaviour)menuController).StartCoroutine(DelayedServerListFocus(menuController));
				return;
			}
			Selectable val = GetFirstSelectableFromComponents<ServerListElement>(menuPanel);
			if ((Object)(object)val == (Object)null)
			{
				val = GetTopSelectableFromComponents<ServerListElement>(menuPanel);
			}
			if ((Object)(object)val != (Object)null)
			{
				FocusSelectable(val, "server list");
			}
			else
			{
				((MonoBehaviour)menuController).StartCoroutine(DelayedServerListFocus(menuController));
			}
		}

		private static void FocusTopSave(MenuController menuController, bool force)
		{
			GameObject menuPanel = GetMenuPanel(menuController, "hostPanel");
			if ((Object)(object)menuPanel == (Object)null || !menuPanel.activeInHierarchy)
			{
				return;
			}
			EnhanceMenuButton(menuController, "startGameButton", forceColor: true);
			if (!force && CurrentSelectionIsUnder(menuPanel))
			{
				EventSystem current = EventSystem.current;
				GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
				if ((Object)(object)val != (Object)null && (Object)(object)val.GetComponent<TMP_InputField>() == (Object)null)
				{
					return;
				}
			}
			FocusSelectable(GetTopSelectableFromComponents<SaveListElement>(menuPanel), "save list");
		}

		private static bool FocusMainMenuPrivateGame(MenuController menuController)
		{
			Selectable menuButtonSelectable = GetMenuButtonSelectable(menuController, "hostButton");
			if ((Object)(object)menuButtonSelectable == (Object)null)
			{
				return false;
			}
			FocusSelectable(menuButtonSelectable, "main menu private game");
			return true;
		}

		internal static Selectable FindMenuAwareNeighbor(Selectable source, int dx, int dy)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			if ((Object)(object)source == (Object)null || _cachedMenuController == null)
			{
				return null;
			}
			if (IsMenuPanelActive((MenuController)_cachedMenuController, "hostPanel"))
			{
				if (dy < 0 && (Object)(object)((Component)source).GetComponentInParent<SaveListElement>() != (Object)null)
				{
					Selectable menuButtonSelectable = GetMenuButtonSelectable(_cachedMenuController, "startGameButton");
					if ((Object)(object)menuButtonSelectable != (Object)null && GetScreenPos(menuButtonSelectable).y < GetScreenPos(source).y)
					{
						return menuButtonSelectable;
					}
				}
				Selectable menuButtonSelectable2 = GetMenuButtonSelectable(_cachedMenuController, "startGameButton");
				if (dy > 0 && (Object)(object)menuButtonSelectable2 != (Object)null && (Object)(object)((Component)source).gameObject == (Object)(object)((Component)menuButtonSelectable2).gameObject)
				{
					return GetBottomSelectableFromComponents<SaveListElement>(GetMenuPanel((MenuController)_cachedMenuController, "hostPanel"));
				}
			}
			return null;
		}

		private static Selectable GetTopSelectableFromComponents<T>(GameObject root) where T : Component
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Selectable result = null;
			float num = float.MinValue;
			T[] componentsInChildren = root.GetComponentsInChildren<T>(true);
			foreach (T val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Selectable val2 = ((Component)val).GetComponent<Selectable>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)val).GetComponentInChildren<Selectable>(true);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				try
				{
					if (!((UIBehaviour)val2).IsActive() || !val2.IsInteractable())
					{
						continue;
					}
					goto IL_0085;
				}
				catch
				{
				}
				continue;
				IL_0085:
				float y = GetScreenPos(val2).y;
				if (y > num)
				{
					num = y;
					result = val2;
				}
			}
			return result;
		}

		private static Selectable GetFirstSelectableFromComponents<T>(GameObject root) where T : Component
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			T[] componentsInChildren = root.GetComponentsInChildren<T>(false);
			foreach (T val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || !((Object)((Component)val).gameObject).name.Contains("("))
				{
					continue;
				}
				Selectable val2 = ((Component)val).GetComponent<Selectable>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)val).GetComponentInChildren<Selectable>(false);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				try
				{
					if (!((UIBehaviour)val2).IsActive() || !val2.IsInteractable())
					{
						continue;
					}
					return val2;
				}
				catch
				{
				}
			}
			return null;
		}

		private static Selectable GetBottomSelectableFromComponents<T>(GameObject root) where T : Component
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Selectable result = null;
			float num = float.MaxValue;
			T[] componentsInChildren = root.GetComponentsInChildren<T>(true);
			foreach (T val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Selectable val2 = ((Component)val).GetComponent<Selectable>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)val).GetComponentInChildren<Selectable>(true);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				try
				{
					if (!((UIBehaviour)val2).IsActive() || !val2.IsInteractable())
					{
						continue;
					}
					goto IL_0085;
				}
				catch
				{
				}
				continue;
				IL_0085:
				float y = GetScreenPos(val2).y;
				if (y < num)
				{
					num = y;
					result = val2;
				}
			}
			return result;
		}

		private static bool FocusConfirmPrompt(MenuController menuController, string specificFieldName = null)
		{
			if (!string.IsNullOrEmpty(specificFieldName))
			{
				GameObject menuPanel = GetMenuPanel(menuController, specificFieldName);
				if ((Object)(object)menuPanel != (Object)null && menuPanel.activeInHierarchy)
				{
					Type type = ((object)menuController).GetType();
					object? obj = AccessTools.Field(type, "confirmDeleteSave")?.GetValue(menuController);
					Selectable val = (Selectable)((obj is Selectable) ? obj : null);
					if ((Object)(object)val == (Object)null)
					{
						object? obj2 = AccessTools.Field(type, "confirm")?.GetValue(menuController);
						val = (Selectable)((obj2 is Selectable) ? obj2 : null);
					}
					if ((Object)(object)val == (Object)null)
					{
						object? obj3 = AccessTools.Field(type, "confirmJoinGame")?.GetValue(menuController);
						val = (Selectable)((obj3 is Selectable) ? obj3 : null);
					}
					object? obj4 = AccessTools.Field(type, "cancelDeleteSave")?.GetValue(menuController);
					Selectable val2 = (Selectable)((obj4 is Selectable) ? obj4 : null);
					if ((Object)(object)val2 == (Object)null)
					{
						object? obj5 = AccessTools.Field(type, "cancel")?.GetValue(menuController);
						val2 = (Selectable)((obj5 is Selectable) ? obj5 : null);
					}
					if ((Object)(object)val2 == (Object)null)
					{
						object? obj6 = AccessTools.Field(type, "cancelJoinGame")?.GetValue(menuController);
						val2 = (Selectable)((obj6 is Selectable) ? obj6 : null);
					}
					if ((Object)(object)val != (Object)null && IsSelectableInteractable(val))
					{
						FocusSelectable(val, "confirm prompt (" + specificFieldName + ")");
						return true;
					}
					if ((Object)(object)val2 != (Object)null && IsSelectableInteractable(val2))
					{
						FocusSelectable(val2, "confirm prompt (" + specificFieldName + ")");
						return true;
					}
					Selectable[] componentsInChildren = menuPanel.GetComponentsInChildren<Selectable>(true);
					foreach (Selectable val3 in componentsInChildren)
					{
						if (IsSelectableInteractable(val3))
						{
							FocusSelectable(val3, "confirm prompt (" + specificFieldName + ")");
							return true;
						}
					}
				}
			}
			Transform transform = ((Component)menuController).transform;
			for (int j = 0; j < transform.childCount; j++)
			{
				Transform child = transform.GetChild(j);
				if (!((Component)child).gameObject.activeInHierarchy)
				{
					continue;
				}
				string[] obj7 = new string[5] { "serverListPanel", "hostPanel", "settingsPanel", "creditsPanel", "ExitPrompt" };
				bool flag = false;
				string[] array = obj7;
				foreach (string fieldName in array)
				{
					GameObject menuPanel2 = GetMenuPanel(menuController, fieldName);
					if ((Object)(object)menuPanel2 != (Object)null && (Object)(object)((Component)child).gameObject == (Object)(object)menuPanel2)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					continue;
				}
				Selectable[] componentsInChildren = ((Component)child).GetComponentsInChildren<Selectable>(true);
				foreach (Selectable val4 in componentsInChildren)
				{
					if (IsSelectableInteractable(val4))
					{
						FocusSelectable(val4, "confirm prompt (" + ((Object)child).name + ")");
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsSelectableInteractable(Selectable sel)
		{
			if ((Object)(object)sel == (Object)null)
			{
				return false;
			}
			try
			{
				return ((UIBehaviour)sel).IsActive() && sel.IsInteractable();
			}
			catch
			{
				return false;
			}
		}

		private static void FocusSelectable(Selectable target, string reason)
		{
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null || (Object)(object)target == (Object)null)
			{
				return;
			}
			try
			{
				if (!((UIBehaviour)target).IsActive() || !target.IsInteractable())
				{
					return;
				}
			}
			catch
			{
				return;
			}
			EnhanceSelectableForController(target);
			current.SetSelectedGameObject(((Component)target).gameObject);
		}

		private static void HandleSubmitCancel(Gamepad gp)
		{
			if (Gamepad.current == null)
			{
				return;
			}
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				return;
			}
			GameObject currentSelectedGameObject = current.currentSelectedGameObject;
			if ((Object)(object)currentSelectedGameObject == (Object)null || !gp.buttonSouth.wasPressedThisFrame || (Object)(object)currentSelectedGameObject.GetComponent<Slider>() != (Object)null)
			{
				return;
			}
			if ((((object)currentSelectedGameObject.GetComponent<MonoBehaviour>())?.GetType().Name ?? "").Contains("OptionsButtonConsoleUGUI") && IsOverlayActive() && currentSelectedGameObject.transform.IsChildOf(((Component)_rebindOverlayCanvas).transform))
			{
				if (RebindUI.IsListeningForRebind)
				{
					return;
				}
				Button component = currentSelectedGameObject.GetComponent<Button>();
				if ((Object)(object)component != (Object)null)
				{
					((UnityEvent)component.onClick).Invoke();
					return;
				}
			}
			ExecuteEvents.Execute<ISubmitHandler>(currentSelectedGameObject, (BaseEventData)null, ExecuteEvents.submitHandler);
		}

		private static void HandleSliderLock(Gamepad gp)
		{
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				return;
			}
			GameObject currentSelectedGameObject = current.currentSelectedGameObject;
			Slider val = null;
			if ((Object)(object)currentSelectedGameObject != (Object)null)
			{
				try
				{
					val = currentSelectedGameObject.GetComponent<Slider>();
				}
				catch
				{
					val = null;
				}
			}
			if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)_selectedSlider)
			{
				if ((Object)(object)_selectedSlider != (Object)null && _sliderEditMode)
				{
					ExitSliderEditMode(confirm: true);
				}
				_selectedSlider = val;
				_sliderEditMode = false;
				_sliderTypeLogged = false;
			}
			else if ((Object)(object)val == (Object)null && (Object)(object)_selectedSlider != (Object)null)
			{
				if (_sliderEditMode)
				{
					ExitSliderEditMode(confirm: true);
				}
				_selectedSlider = null;
			}
			if ((Object)(object)_selectedSlider == (Object)null)
			{
				return;
			}
			bool wasPressedThisFrame = gp.buttonSouth.wasPressedThisFrame;
			bool wasPressedThisFrame2 = gp.buttonEast.wasPressedThisFrame;
			if (wasPressedThisFrame)
			{
				if (_sliderEditMode)
				{
					ExitSliderEditMode(confirm: true);
				}
				else
				{
					EnterSliderEditMode();
				}
				_sliderEditAccum = 0f;
			}
			if (wasPressedThisFrame2 && _sliderEditMode)
			{
				ExitSliderEditMode(confirm: false);
				_sliderEditAccum = 0f;
			}
			if (_sliderEditMode && (Object)(object)_selectedSlider != (Object)null)
			{
				_sliderEditStepCooldown -= Time.deltaTime;
				Vector2 val2 = ((InputControl<Vector2>)(object)gp.leftStick).ReadValue();
				Vector2 val3 = ((InputControl<Vector2>)(object)gp.dpad).ReadValue();
				float num = 0f;
				if (Mathf.Abs(val2.x) > 0.3f)
				{
					num = val2.x;
				}
				else if (val3.x > 0.5f)
				{
					num = 1f;
				}
				else if (val3.x < -0.5f)
				{
					num = -1f;
				}
				if (!_sliderTypeLogged)
				{
					_sliderTypeLogged = true;
				}
				if (Mathf.Abs(num) > 0.3f)
				{
					float num2 = _selectedSlider.maxValue - _selectedSlider.minValue;
					_sliderEditAccum += num * Mathf.Max(num2, 2f) * 0.3f * Time.deltaTime;
					_sliderEditAccum = Mathf.Clamp(_sliderEditAccum, 0f - num2, num2);
					float num3 = (_selectedSlider.wholeNumbers ? 1f : Mathf.Max(0.01f, num2 / 100f));
					while (Mathf.Abs(_sliderEditAccum) >= num3 && !(_sliderEditStepCooldown > 0f))
					{
						if (_sliderForceFractional)
						{
							_sliderEditStepCooldown = 0.25f;
						}
						else if (_selectedSlider.wholeNumbers)
						{
							_sliderEditStepCooldown = ((num2 < 100f) ? 0.15f : 0.06f);
						}
						else
						{
							_sliderEditStepCooldown = 0.12f;
						}
						float num4 = Mathf.Sign(_sliderEditAccum) * num3;
						float num5 = _selectedSlider.value + num4;
						num5 = Mathf.Clamp(num5, _selectedSlider.minValue, _selectedSlider.maxValue);
						if (_selectedSlider.wholeNumbers)
						{
							num5 = Mathf.Round(num5);
						}
						_sliderSetGuardCount = 0;
						_sliderSetValueGuardCount = 0;
						_selectedSlider.value = num5;
					}
				}
				else
				{
					_sliderEditAccum = 0f;
				}
			}
			else if ((Object)(object)_selectedSlider != (Object)null && !_sliderEditMode)
			{
				Vector2 val4 = ((InputControl<Vector2>)(object)gp.leftStick).ReadValue();
				Vector2 val5 = ((InputControl<Vector2>)(object)gp.dpad).ReadValue();
				float num6 = 0f;
				if (Mathf.Abs(val4.x) > 0.5f)
				{
					num6 = val4.x;
				}
				else if (val5.x > 0.5f)
				{
					num6 = 1f;
				}
				else if (val5.x < -0.5f)
				{
					num6 = -1f;
				}
				if (Mathf.Abs(num6) > 0.5f)
				{
					_sliderNavRepeatTimer -= Time.deltaTime;
					if (_sliderNavRepeatTimer <= 0f)
					{
						_sliderNavRepeatTimer = ((Mathf.Abs(_lastSliderHoriz) < 0.3f) ? 0.4f : 0.2f);
						int num7 = ((num6 > 0f) ? 1 : (-1));
						Selectable val6 = null;
						if (_navGrid != null)
						{
							val6 = _navGrid.FindNeighbor((Selectable)(object)_selectedSlider, num7, 0);
						}
						if ((Object)(object)val6 == (Object)null)
						{
							val6 = FindNearestByDirection((Selectable)(object)_selectedSlider, num7, 0);
						}
						if ((Object)(object)val6 != (Object)null)
						{
							current.SetSelectedGameObject(((Component)val6).gameObject);
							_pendingNavFocus = val6;
							_pendingNavTimer = 0.15f;
							_pendingNavDx = num7;
							_pendingNavDy = 0;
							_navRepeatTimer = 0.4f;
							_suppressManualNavThisFrame = true;
						}
					}
				}
				else
				{
					_sliderNavRepeatTimer = 0f;
				}
				_lastSliderHoriz = num6;
			}
			else
			{
				_sliderNavRepeatTimer = 0f;
				_lastSliderHoriz = 0f;
			}
		}

		private static void EnterSliderEditMode()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			_sliderEditMode = true;
			_sliderEditStepCooldown = 0f;
			_sliderSetGuardCount = 0;
			_sliderSetValueGuardCount = 0;
			_sliderTypeLogged = false;
			_sliderOriginalValue = _selectedSlider.value;
			_sliderOriginalWholeNumbers = _selectedSlider.wholeNumbers;
			float num = _selectedSlider.maxValue - _selectedSlider.minValue;
			_sliderForceFractional = _sliderOriginalWholeNumbers && num < 50f;
			if ((Object)(object)_selectedSlider.handleRect != (Object)null)
			{
				Image component = ((Component)_selectedSlider.handleRect).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					_sliderOriginalHandleColor = ((Graphic)component).color;
					_sliderColorStored = true;
					((Graphic)component).color = new Color(1f, 0.85f, 0.2f);
				}
			}
		}

		private static void ExitSliderEditMode(bool confirm)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			_sliderSetGuardCount = 0;
			_sliderSetValueGuardCount = 0;
			if (!confirm)
			{
				_selectedSlider.value = _sliderOriginalValue;
			}
			if (_sliderColorStored && (Object)(object)_selectedSlider.handleRect != (Object)null)
			{
				Image component = ((Component)_selectedSlider.handleRect).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = _sliderOriginalHandleColor;
				}
				_sliderColorStored = false;
			}
			_sliderEditMode = false;
			_sliderForceFractional = false;
		}

		private static void HandleTabNavigation(Gamepad gp)
		{
			if (!_wellPanelModeResolved)
			{
				_wellPanelModeResolved = true;
				_wellPanelModeEnum = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
				{
					try
					{
						return a.GetTypes();
					}
					catch
					{
						return new Type[0];
					}
				}).FirstOrDefault((Type t) => t.Name == "WellPanelMode");
				if (_wellPanelModeEnum != null)
				{
					_wellPanelModeValues = Enum.GetValues(_wellPanelModeEnum);
				}
				Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
				{
					try
					{
						return a.GetTypes();
					}
					catch
					{
						return new Type[0];
					}
				}).FirstOrDefault((Type t) => t.Name == "PlayerController");
				if (type != null)
				{
					_changeWellPanelMethod = AccessTools.Method(type, "ChangeWellPanel", (Type[])null, (Type[])null);
				}
			}
			if (_wellPanelModeEnum == null || _changeWellPanelMethod == null)
			{
				return;
			}
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				return;
			}
			FieldInfo fieldInfo = AccessTools.Field(playerController.GetType(), "wellCraftingPanel");
			if (!(fieldInfo == null) && fieldInfo.GetValue(playerController) != null && IsWellUiOpen(playerController))
			{
				string[] array = new string[4] { "CRAFTING", "MAP", "FURNITURE", "HOME" };
				bool wasPressedThisFrame = gp.leftShoulder.wasPressedThisFrame;
				bool wasPressedThisFrame2 = gp.rightShoulder.wasPressedThisFrame;
				if (wasPressedThisFrame || wasPressedThisFrame2)
				{
					int num = (wasPressedThisFrame2 ? 1 : (-1));
					_currentWellTab = (_currentWellTab + num + array.Length) % array.Length;
					object obj = Enum.Parse(_wellPanelModeEnum, array[_currentWellTab]);
					_changeWellPanelMethod.Invoke(playerController, new object[1] { obj });
					ResetWellNavCache();
					_wellLastDPadX = 0f;
					_wellLastDPadY = 0f;
					_wellScrollAccum = 0f;
				}
			}
		}

		private static void CollectFocusableElements(VisualElement root, List<VisualElement> result)
		{
			if (root == null)
			{
				return;
			}
			if (root is Button || ((Focusable)root).focusable)
			{
				result.Add(root);
			}
			foreach (VisualElement item in root.Children())
			{
				CollectFocusableElements(item, result);
			}
		}

		private static void ResetWellNavCache()
		{
			ClearWellControllerHighlight();
			_cachedRootVE = null;
			_cachedRecipeList = null;
			_cachedCraftBtn = null;
			_cachedCostBtns = null;
			_cachedMapBtns = null;
			_homeGrid.Clear();
			_homeGridColumns = 0;
			_homeCurrentRow = 0;
			_homeCurrentCol = 0;
			_homeElementIndex = 0;
			_wellScrollAccum = 0f;
			_wellNavArea = WellNavArea.RecipeList;
			_wellNavIndex = 0;
			_wellNavActive = false;
		}

		private static void CacheWellRoot()
		{
			if (_cachedRootVE != null && _pcTypeCached != null)
			{
				return;
			}
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				return;
			}
			_pcTypeCached = playerController.GetType();
			FieldInfo fieldInfo = AccessTools.Field(_pcTypeCached, "uiDoc");
			if (fieldInfo == null)
			{
				return;
			}
			object value = fieldInfo.GetValue(playerController);
			if (value != null)
			{
				PropertyInfo property = value.GetType().GetProperty("rootVisualElement");
				if (!(property == null))
				{
					object? value2 = property.GetValue(value);
					_cachedRootVE = (VisualElement)((value2 is VisualElement) ? value2 : null);
				}
			}
		}

		private static bool IsDescriptionOverlayOpen()
		{
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				return false;
			}
			if (_descDispFieldCache == null)
			{
				_descDispFieldCache = AccessTools.Field(playerController.GetType(), "descriptionDisplayer");
			}
			if (_descDispFieldCache == null)
			{
				return false;
			}
			object value = _descDispFieldCache.GetValue(playerController);
			if (value == null)
			{
				return false;
			}
			object? obj = AccessTools.Field(value.GetType(), "descriptionPanel")?.GetValue(value);
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if ((Object)(object)val != (Object)null && val.activeInHierarchy)
			{
				return true;
			}
			object? obj2 = AccessTools.Field(value.GetType(), "panelBg")?.GetValue(value);
			GameObject val2 = (GameObject)((obj2 is GameObject) ? obj2 : null);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2.activeInHierarchy;
			}
			return false;
		}

		private static bool CloseDescriptionOverlay()
		{
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				return false;
			}
			bool flag = IsDescriptionOverlayOpen();
			FieldInfo fieldInfo = AccessTools.Field(playerController.GetType(), "descriptionDisplayer");
			if (fieldInfo == null)
			{
				return false;
			}
			object value = fieldInfo.GetValue(playerController);
			if (value == null)
			{
				return false;
			}
			MethodInfo methodInfo = AccessTools.Method(value.GetType(), "DisableTaskList", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				_suppressNextDescriptionDisableClose = true;
				methodInfo.Invoke(value, null);
			}
			ForceHideDescriptionOverlay(playerController, value);
			bool flag2 = !IsDescriptionOverlayOpen();
			if (!(flag && flag2) && flag)
			{
				Logger.LogWarning((object)"[ControllerSupport] Material info overlay still appears open after close attempt");
			}
			return flag && flag2;
		}

		private static void ForceHideDescriptionOverlay(object pc, object descDisp)
		{
			try
			{
				object? obj = AccessTools.Field(descDisp.GetType(), "descriptionPanel")?.GetValue(descDisp);
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(false);
				}
			}
			catch
			{
			}
			try
			{
				object? obj3 = AccessTools.Field(descDisp.GetType(), "panelBg")?.GetValue(descDisp);
				GameObject val2 = (GameObject)((obj3 is GameObject) ? obj3 : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.SetActive(false);
				}
			}
			catch
			{
			}
		}

		private static void HandleWellPanelNavigation(Gamepad gp)
		{
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			if (!IsWellUiOpen())
			{
				if (_wellNavActive)
				{
					ResetWellNavCache();
				}
				return;
			}
			CacheWellRoot();
			if (_cachedRootVE == null || _pcTypeCached == null)
			{
				return;
			}
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				return;
			}
			int visibleWellTab = GetVisibleWellTab(playerController);
			if (visibleWellTab != _currentWellTab)
			{
				_currentWellTab = visibleWellTab;
				ResetWellNavCache();
			}
			if (IsDescriptionOverlayOpen())
			{
				if (gp.buttonEast.wasPressedThisFrame)
				{
					CloseDescriptionOverlay();
					_bButtonConsumedFrames = 3;
				}
				return;
			}
			if (!_wellNavActive)
			{
				_wellNavActive = true;
				_wellNavIndex = 0;
				_wellNavArea = ((_currentWellTab == 1) ? WellNavArea.MapList : ((_currentWellTab == 3) ? WellNavArea.HomeCards : WellNavArea.RecipeList));
				CacheTabElements(playerController);
				if (_currentWellTab == 3)
				{
					MonoBehaviour val = (MonoBehaviour)((playerController is MonoBehaviour) ? playerController : null);
					if ((Object)(object)val != (Object)null)
					{
						val.StartCoroutine(DelayedHomeFocus());
					}
					else
					{
						FocusInitialElement();
					}
				}
				else
				{
					FocusInitialElement();
				}
			}
			float num = ((InputControl<float>)(object)((Vector2Control)gp.dpad).y).ReadValue();
			float num2 = ((InputControl<float>)(object)((Vector2Control)gp.leftStick).y).ReadValue();
			float num3 = ((Mathf.Abs(num2) > 0.6f) ? num2 : ((Mathf.Abs(num) > 0.5f) ? num : 0f));
			if (num3 != 0f && _wellLastDPadY == 0f)
			{
				NavigateVertical((!(num3 > 0f)) ? 1 : (-1));
			}
			_wellLastDPadY = num3;
			float num4 = ((InputControl<float>)(object)((Vector2Control)gp.dpad).x).ReadValue();
			float num5 = ((InputControl<float>)(object)((Vector2Control)gp.leftStick).x).ReadValue();
			float num6 = ((Mathf.Abs(num5) > 0.6f) ? num5 : ((Mathf.Abs(num4) > 0.5f) ? num4 : 0f));
			if (num6 != 0f && _wellLastDPadX == 0f && (_currentWellTab == 0 || _currentWellTab == 2 || _currentWellTab == 3 || _currentWellTab == 4))
			{
				NavigateHorizontal((num6 > 0f) ? 1 : (-1));
			}
			_wellLastDPadX = num6;
			float num7 = ((InputControl<float>)(object)((Vector2Control)gp.rightStick).y).ReadValue();
			if (Mathf.Abs(num7) > 0.3f)
			{
				ScrollView val2 = null;
				if (_cachedRecipeList != null)
				{
					val2 = UQueryExtensions.Q<ScrollView>((VisualElement)(object)_cachedRecipeList, (string)null, (string)null);
				}
				if (val2 == null && _cachedMapBtns != null && _cachedMapBtns.Count > 0)
				{
					for (VisualElement val3 = (VisualElement)(object)_cachedMapBtns[0]; val3 != null; val3 = val3.parent)
					{
						ScrollView val4 = (ScrollView)(object)((val3 is ScrollView) ? val3 : null);
						if (val4 != null)
						{
							val2 = val4;
							break;
						}
					}
				}
				if (val2 != null && val2.verticalScroller != null)
				{
					float highValue = val2.verticalScroller.highValue;
					if (highValue > 0f)
					{
						_wellScrollAccum += (0f - num7) * Time.deltaTime * 500f;
						if (Mathf.Abs(_wellScrollAccum) > 10f)
						{
							float num8 = val2.scrollOffset.y + _wellScrollAccum;
							_wellScrollAccum = 0f;
							val2.scrollOffset = new Vector2(val2.scrollOffset.x, Mathf.Clamp(num8, 0f, highValue));
						}
					}
				}
			}
			else
			{
				_wellScrollAccum = 0f;
			}
			if (gp.buttonSouth.wasPressedThisFrame)
			{
				ActivateWellElement();
			}
		}

		private static int GetRecipeCount()
		{
			if (_cachedRecipeList == null || ((BaseVerticalCollectionView)_cachedRecipeList).itemsSource == null)
			{
				return 0;
			}
			return ((BaseVerticalCollectionView)_cachedRecipeList).itemsSource.Count;
		}

		private static void CacheTabElements(object pc)
		{
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Invalid comparison between Unknown and I4
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			_cachedRecipeList = null;
			_cachedCraftBtn = null;
			_cachedCostBtns = null;
			_cachedMapBtns = null;
			_homeGrid.Clear();
			_homeGridColumns = 0;
			_homeCurrentRow = 0;
			_homeCurrentCol = 0;
			_homeElementIndex = 0;
			switch (_currentWellTab)
			{
			case 0:
			case 2:
			case 4:
			{
				string text2 = ((_currentWellTab == 0) ? "equipmentCraftingPanel" : ((_currentWellTab == 2) ? "furnitureCraftingPanel" : "potionCraftingPanel"));
				FieldInfo fieldInfo3 = AccessTools.Field(_pcTypeCached, text2);
				if (!(fieldInfo3 == null))
				{
					object? value4 = fieldInfo3.GetValue(pc);
					VisualElement val5 = (VisualElement)((value4 is VisualElement) ? value4 : null);
					if (val5 != null)
					{
						_cachedRecipeList = UQueryExtensions.Q<ListView>(val5, "CraftItemList", (string)null);
						_cachedCraftBtn = UQueryExtensions.Q<Button>(val5, "CraftButton", (string)null);
						_cachedCostBtns = new List<Button>();
						CacheVisibleCraftingCostButtons(UQueryExtensions.Q<VisualElement>(val5, "Cost", (string)null), _cachedCostBtns);
					}
				}
				break;
			}
			case 1:
			{
				FieldInfo fieldInfo2 = AccessTools.Field(_pcTypeCached, "mapPanel");
				if (fieldInfo2 == null)
				{
					break;
				}
				object? value2 = fieldInfo2.GetValue(pc);
				VisualElement val2 = (VisualElement)((value2 is VisualElement) ? value2 : null);
				if (val2 == null)
				{
					break;
				}
				_cachedMapBtns = new List<Button>();
				string[] array = new string[3] { "PreviousPlayed", "PlayOptionA", "PlayOptionB" };
				foreach (string text in array)
				{
					VisualElement val3 = UQueryExtensions.Q<VisualElement>(val2, text, (string)null);
					if (val3 == null || !val3.visible)
					{
						continue;
					}
					FieldInfo field = ((object)val3).GetType().GetField("_completed", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field != null && (bool)field.GetValue(val3))
					{
						continue;
					}
					FieldInfo field2 = ((object)val3).GetType().GetField("_clickable", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field2 != null && !(bool)field2.GetValue(val3))
					{
						continue;
					}
					FieldInfo field3 = ((object)val3).GetType().GetField("icon", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field3 != null)
					{
						object? value3 = field3.GetValue(val3);
						Button val4 = (Button)((value3 is Button) ? value3 : null);
						if (val4 != null)
						{
							_cachedMapBtns.Add(val4);
						}
					}
				}
				break;
			}
			case 3:
			{
				FieldInfo fieldInfo = AccessTools.Field(_pcTypeCached, "homeUpgradePanel");
				if (fieldInfo == null)
				{
					break;
				}
				object? value = fieldInfo.GetValue(pc);
				VisualElement val = (VisualElement)((value is VisualElement) ? value : null);
				if (val == null)
				{
					break;
				}
				_homeGrid.Clear();
				_homeCurrentRow = 0;
				_homeCurrentCol = 0;
				_homeElementIndex = 0;
				List<(Vector2, List<VisualElement>)> list = new List<(Vector2, List<VisualElement>)>();
				foreach (VisualElement item2 in val.Children())
				{
					Rect worldBound = item2.worldBound;
					Vector2 center = ((Rect)(ref worldBound)).center;
					List<VisualElement> list2 = new List<VisualElement>();
					CollectFocusableElements(item2, list2);
					if (list2.Count == 0)
					{
						continue;
					}
					bool flag = false;
					bool flag2 = false;
					foreach (VisualElement item3 in list2)
					{
						if (item3.ClassListContains("defaultButton"))
						{
							flag = true;
						}
						if (item3.ClassListContains("crafting-cost-display"))
						{
							flag2 = true;
						}
					}
					if (flag && flag2 && item2.visible && (int)item2.resolvedStyle.display != 1)
					{
						list.Add((center, list2));
					}
				}
				if (list.Count == 0)
				{
					break;
				}
				List<List<(Vector2, List<VisualElement>)>> obj = new List<List<(Vector2, List<VisualElement>)>> { list.ToList() };
				_homeGridColumns = 0;
				{
					foreach (List<(Vector2, List<VisualElement>)> item4 in obj)
					{
						List<HomeCardData> list3 = new List<HomeCardData>();
						foreach (var item5 in item4)
						{
							List<VisualElement> item = item5.Item2;
							HomeCardData homeCardData = new HomeCardData();
							homeCardData.Card = null;
							homeCardData.Elements = item;
							list3.Add(homeCardData);
						}
						_homeGridColumns = Mathf.Max(_homeGridColumns, list3.Count);
						_homeGrid.Add(list3);
					}
					break;
				}
			}
			}
		}

		private static void FocusInitialElement()
		{
			switch (_currentWellTab)
			{
			case 0:
			case 2:
			case 4:
				if (_cachedRecipeList != null)
				{
					_wellNavArea = WellNavArea.RecipeList;
					_wellNavIndex = 0;
					SelectCraftingRecipe(0);
				}
				else if (_cachedCraftBtn != null)
				{
					_wellNavArea = WellNavArea.RightPanel;
					((Focusable)_cachedCraftBtn).Focus();
					SetWellControllerHighlight((VisualElement)(object)_cachedCraftBtn);
				}
				break;
			case 1:
				if (_cachedMapBtns != null && _cachedMapBtns.Count > 0)
				{
					_wellNavIndex = 0;
					((Focusable)_cachedMapBtns[0]).Focus();
					SetWellControllerHighlight((VisualElement)(object)_cachedMapBtns[0]);
				}
				break;
			case 3:
				if (_homeGrid.Count > 0 && _homeGrid[0].Count > 0)
				{
					int elemIdx = ((_homeGrid[0][0].Elements.Count > 1) ? 1 : 0);
					FocusHomeElement(0, 0, elemIdx);
				}
				break;
			}
		}

		private static void NavigateVertical(int dir)
		{
			switch (_currentWellTab)
			{
			case 0:
			case 2:
			case 4:
				if (_wellNavArea == WellNavArea.RecipeList && _cachedRecipeList != null)
				{
					int recipeCount = GetRecipeCount();
					if (recipeCount != 0)
					{
						_wellNavIndex = (_wellNavIndex + dir + recipeCount) % recipeCount;
						SelectCraftingRecipe(_wellNavIndex);
					}
				}
				else if (_wellNavArea == WellNavArea.RightPanel)
				{
					List<VisualElement> craftingRightPanelItems = GetCraftingRightPanelItems();
					if (craftingRightPanelItems.Count != 0)
					{
						_wellNavIndex = Mathf.Clamp(_wellNavIndex + dir, 0, craftingRightPanelItems.Count - 1);
						((Focusable)craftingRightPanelItems[_wellNavIndex]).Focus();
						SetWellControllerHighlight(craftingRightPanelItems[_wellNavIndex]);
					}
				}
				break;
			case 1:
				if (_cachedMapBtns != null && _cachedMapBtns.Count > 0)
				{
					_wellNavIndex = (_wellNavIndex + dir + _cachedMapBtns.Count) % _cachedMapBtns.Count;
					((Focusable)_cachedMapBtns[_wellNavIndex]).Focus();
					SetWellControllerHighlight((VisualElement)(object)_cachedMapBtns[_wellNavIndex]);
				}
				break;
			case 3:
			{
				int count = _homeGrid.Count;
				if (count == 0)
				{
					break;
				}
				_homeCurrentCol = Mathf.Min(_homeCurrentCol, _homeGrid[_homeCurrentRow].Count - 1);
				HomeCardData homeCardData = _homeGrid[_homeCurrentRow][_homeCurrentCol];
				int count2 = homeCardData.Elements.Count;
				if (dir < 0)
				{
					if (_homeElementIndex > 0)
					{
						int num = _homeElementIndex - 1;
						while (num > 0 && homeCardData.Elements[num].ClassListContains("item-display__button_take"))
						{
							num--;
						}
						if (!homeCardData.Elements[num].ClassListContains("item-display__button_take") || num != 0)
						{
							_homeElementIndex = num;
							FocusHomeElement(_homeCurrentRow, _homeCurrentCol, _homeElementIndex);
						}
					}
					else if (_homeCurrentRow > 0)
					{
						_homeCurrentRow--;
						_homeCurrentCol = Mathf.Min(_homeCurrentCol, _homeGrid[_homeCurrentRow].Count - 1);
						_homeElementIndex = Mathf.Min(_homeElementIndex, _homeGrid[_homeCurrentRow][_homeCurrentCol].Elements.Count - 1);
						FocusHomeElement(_homeCurrentRow, _homeCurrentCol, _homeElementIndex);
					}
					else
					{
						int num2 = count2 - 1;
						while (num2 > 0 && homeCardData.Elements[num2].ClassListContains("item-display__button_take"))
						{
							num2--;
						}
						if (num2 != 0 || !homeCardData.Elements[num2].ClassListContains("item-display__button_take"))
						{
							_homeElementIndex = num2;
							FocusHomeElement(_homeCurrentRow, _homeCurrentCol, _homeElementIndex);
						}
					}
				}
				else if (_homeElementIndex < count2 - 1)
				{
					int i;
					for (i = _homeElementIndex + 1; i < count2 - 1 && homeCardData.Elements[i].ClassListContains("item-display__button_take"); i++)
					{
					}
					if (i == count2 - 1 && homeCardData.Elements[i].ClassListContains("item-display__button_take"))
					{
						for (i = 0; i < count2 && homeCardData.Elements[i].ClassListContains("item-display__button_take"); i++)
						{
						}
						if (i >= count2)
						{
							break;
						}
					}
					_homeElementIndex = i;
					FocusHomeElement(_homeCurrentRow, _homeCurrentCol, _homeElementIndex);
				}
				else if (_homeCurrentRow < count - 1)
				{
					_homeCurrentRow++;
					_homeCurrentCol = Mathf.Min(_homeCurrentCol, _homeGrid[_homeCurrentRow].Count - 1);
					_homeElementIndex = Mathf.Min(_homeElementIndex, _homeGrid[_homeCurrentRow][_homeCurrentCol].Elements.Count - 1);
					FocusHomeElement(_homeCurrentRow, _homeCurrentCol, _homeElementIndex);
				}
				break;
			}
			}
		}

		private static VisualElement GetActiveCraftingPanel(object pc)
		{
			if (pc == null || _pcTypeCached == null)
			{
				return null;
			}
			string text = ((_currentWellTab == 0) ? "equipmentCraftingPanel" : ((_currentWellTab == 2) ? "furnitureCraftingPanel" : ((_currentWellTab == 4) ? "potionCraftingPanel" : null)));
			object? obj = AccessTools.Field(_pcTypeCached, text)?.GetValue(pc);
			return (VisualElement)((obj is VisualElement) ? obj : null);
		}

		private static void ClearWellVisualFocus()
		{
			try
			{
				VisualElement cachedRootVE = _cachedRootVE;
				object obj;
				if (cachedRootVE == null)
				{
					obj = null;
				}
				else
				{
					IPanel panel = cachedRootVE.panel;
					if (panel == null)
					{
						obj = null;
					}
					else
					{
						FocusController focusController = panel.focusController;
						obj = ((focusController != null) ? focusController.focusedElement : null);
					}
				}
				if (obj != null)
				{
					((Focusable)obj).Blur();
				}
			}
			catch
			{
			}
		}

		private static void ClearWellControllerHighlight()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (_wellVisualFocusElement != null)
			{
				try
				{
					_wellVisualFocusElement.style.borderTopWidth = _wellVisualFocusBorderTop;
					_wellVisualFocusElement.style.borderRightWidth = _wellVisualFocusBorderRight;
					_wellVisualFocusElement.style.borderBottomWidth = _wellVisualFocusBorderBottom;
					_wellVisualFocusElement.style.borderLeftWidth = _wellVisualFocusBorderLeft;
					_wellVisualFocusElement.style.borderTopColor = _wellVisualFocusBorderTopColor;
					_wellVisualFocusElement.style.borderRightColor = _wellVisualFocusBorderRightColor;
					_wellVisualFocusElement.style.borderBottomColor = _wellVisualFocusBorderBottomColor;
					_wellVisualFocusElement.style.borderLeftColor = _wellVisualFocusBorderLeftColor;
					_wellVisualFocusElement.style.backgroundColor = _wellVisualFocusBackground;
				}
				catch
				{
				}
				_wellVisualFocusElement = null;
			}
		}

		private static void SetWellControllerHighlight(VisualElement el)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			if (el != null && _wellVisualFocusElement != el)
			{
				ClearWellControllerHighlight();
				_wellVisualFocusElement = el;
				_wellVisualFocusBorderTop = el.style.borderTopWidth;
				_wellVisualFocusBorderRight = el.style.borderRightWidth;
				_wellVisualFocusBorderBottom = el.style.borderBottomWidth;
				_wellVisualFocusBorderLeft = el.style.borderLeftWidth;
				_wellVisualFocusBorderTopColor = el.style.borderTopColor;
				_wellVisualFocusBorderRightColor = el.style.borderRightColor;
				_wellVisualFocusBorderBottomColor = el.style.borderBottomColor;
				_wellVisualFocusBorderLeftColor = el.style.borderLeftColor;
				_wellVisualFocusBackground = el.style.backgroundColor;
				Color val = default(Color);
				((Color)(ref val))..ctor(0.25f, 0.68f, 1f, 1f);
				Color val2 = default(Color);
				((Color)(ref val2))..ctor(0.2f, 0.5f, 0.8f, 0.55f);
				el.style.borderTopWidth = StyleFloat.op_Implicit(3f);
				el.style.borderRightWidth = StyleFloat.op_Implicit(3f);
				el.style.borderBottomWidth = StyleFloat.op_Implicit(3f);
				el.style.borderLeftWidth = StyleFloat.op_Implicit(3f);
				el.style.borderTopColor = StyleColor.op_Implicit(val);
				el.style.borderRightColor = StyleColor.op_Implicit(val);
				el.style.borderBottomColor = StyleColor.op_Implicit(val);
				el.style.borderLeftColor = StyleColor.op_Implicit(val);
				el.style.backgroundColor = StyleColor.op_Implicit(val2);
			}
		}

		private static void SelectCraftingRecipe(int index)
		{
			if (_cachedRecipeList == null)
			{
				return;
			}
			((BaseVerticalCollectionView)_cachedRecipeList).SetSelection(index);
			((BaseVerticalCollectionView)_cachedRecipeList).ScrollToItem(index);
			ClearWellVisualFocus();
			SetWellControllerHighlight((VisualElement)(object)_cachedRecipeList);
			VisualElement activeCraftingPanel = GetActiveCraftingPanel(GetPlayerController());
			if (activeCraftingPanel != null)
			{
				FieldInfo fieldInfo = AccessTools.Field(((object)activeCraftingPanel).GetType(), "currentCraftingRecipeIndex");
				MethodInfo methodInfo = AccessTools.Method(((object)activeCraftingPanel).GetType(), "UpdateCraftingPreview", (Type[])null, (Type[])null);
				if (!(fieldInfo == null) && !(methodInfo == null))
				{
					fieldInfo.SetValue(activeCraftingPanel, index);
					methodInfo.Invoke(activeCraftingPanel, null);
					RefreshCostButtons();
				}
			}
		}

		private static void NavigateHorizontal(int dir)
		{
			if (_currentWellTab == 3)
			{
				if (_homeGrid.Count == 0)
				{
					return;
				}
				_homeCurrentCol = Mathf.Min(_homeCurrentCol, _homeGrid[_homeCurrentRow].Count - 1);
				if (dir < 0)
				{
					if (_homeCurrentCol > 0)
					{
						_homeCurrentCol--;
					}
				}
				else if (_homeCurrentCol < _homeGrid[_homeCurrentRow].Count - 1)
				{
					_homeCurrentCol++;
				}
				_homeCurrentCol = Mathf.Min(_homeCurrentCol, _homeGrid[_homeCurrentRow].Count - 1);
				HomeCardData homeCardData = _homeGrid[_homeCurrentRow][_homeCurrentCol];
				_homeElementIndex = Mathf.Min(_homeElementIndex, homeCardData.Elements.Count - 1);
				while (_homeElementIndex < homeCardData.Elements.Count - 1 && homeCardData.Elements[_homeElementIndex].ClassListContains("item-display__button_take"))
				{
					_homeElementIndex++;
				}
				if (_homeElementIndex == homeCardData.Elements.Count - 1 && homeCardData.Elements[_homeElementIndex].ClassListContains("item-display__button_take"))
				{
					while (_homeElementIndex > 0 && homeCardData.Elements[_homeElementIndex].ClassListContains("item-display__button_take"))
					{
						_homeElementIndex--;
					}
				}
				FocusHomeElement(_homeCurrentRow, _homeCurrentCol, _homeElementIndex);
			}
			else if (_wellNavArea == WellNavArea.RecipeList && dir > 0)
			{
				_wellNavArea = WellNavArea.RightPanel;
				List<VisualElement> craftingRightPanelItems = GetCraftingRightPanelItems();
				if (craftingRightPanelItems.Count > 0)
				{
					_wellNavIndex = Mathf.Max(0, craftingRightPanelItems.Count - 1);
					((Focusable)craftingRightPanelItems[_wellNavIndex]).Focus();
					SetWellControllerHighlight(craftingRightPanelItems[_wellNavIndex]);
				}
			}
			else if (_wellNavArea == WellNavArea.RightPanel && dir < 0)
			{
				_wellNavArea = WellNavArea.RecipeList;
				_wellNavIndex = 0;
				if (_cachedRecipeList != null)
				{
					SelectCraftingRecipe(0);
				}
			}
		}

		private static IEnumerator DelayedHomeFocus()
		{
			yield return null;
			yield return null;
			object playerController = GetPlayerController();
			if (playerController != null)
			{
				CacheTabElements(playerController);
			}
			FocusInitialElement();
		}

		private static void FocusHomeElement(int row, int col, int elemIdx)
		{
			if (row >= 0 && row < _homeGrid.Count && col >= 0 && col < _homeGrid[row].Count)
			{
				HomeCardData homeCardData = _homeGrid[row][col];
				if (elemIdx >= 0 && elemIdx < homeCardData.Elements.Count)
				{
					VisualElement obj = homeCardData.Elements[elemIdx];
					((Focusable)obj).Focus();
					SetWellControllerHighlight(obj);
				}
			}
		}

		private static void ActivateWellElement()
		{
			if (_currentWellTab == 0 || _currentWellTab == 2 || _currentWellTab == 4)
			{
				if (_wellNavArea == WellNavArea.RecipeList && _cachedRecipeList != null)
				{
					SelectCraftingRecipe(_wellNavIndex);
				}
				else if (_wellNavArea == WellNavArea.RightPanel)
				{
					List<VisualElement> craftingRightPanelItems = GetCraftingRightPanelItems();
					if (_wellNavIndex >= 0 && _wellNavIndex < craftingRightPanelItems.Count)
					{
						SimulateVEClick(craftingRightPanelItems[_wellNavIndex]);
					}
				}
			}
			else if (_currentWellTab == 1 && _cachedMapBtns != null)
			{
				if (_wellNavIndex >= 0 && _wellNavIndex < _cachedMapBtns.Count)
				{
					SimulateVEClick((VisualElement)(object)_cachedMapBtns[_wellNavIndex]);
				}
			}
			else if (_currentWellTab == 3 && _homeGrid.Count > 0 && _homeCurrentRow < _homeGrid.Count && _homeCurrentCol < _homeGrid[_homeCurrentRow].Count)
			{
				SimulateVEClick(_homeGrid[_homeCurrentRow][_homeCurrentCol].Elements[_homeElementIndex]);
			}
		}

		private static List<VisualElement> GetCraftingRightPanelItems()
		{
			List<VisualElement> list = new List<VisualElement>();
			if (_cachedCostBtns != null)
			{
				list.AddRange((IEnumerable<VisualElement>)_cachedCostBtns);
			}
			if (_cachedCraftBtn != null)
			{
				list.Add((VisualElement)(object)_cachedCraftBtn);
			}
			return list;
		}

		private static void RefreshCostButtons()
		{
			if (_currentWellTab != 0 && _currentWellTab != 2 && _currentWellTab != 4)
			{
				return;
			}
			object playerController = GetPlayerController();
			if (playerController == null)
			{
				return;
			}
			string text = ((_currentWellTab == 0) ? "equipmentCraftingPanel" : ((_currentWellTab == 2) ? "furnitureCraftingPanel" : "potionCraftingPanel"));
			FieldInfo fieldInfo = AccessTools.Field(_pcTypeCached, text);
			if (!(fieldInfo == null))
			{
				object? value = fieldInfo.GetValue(playerController);
				VisualElement val = (VisualElement)((value is VisualElement) ? value : null);
				if (val != null)
				{
					_cachedCostBtns = new List<Button>();
					CacheVisibleCraftingCostButtons(UQueryExtensions.Q<VisualElement>(val, "Cost", (string)null), _cachedCostBtns);
				}
			}
		}

		private static void CacheVisibleCraftingCostButtons(VisualElement costContainer, List<Button> result)
		{
			if (costContainer == null || result == null)
			{
				return;
			}
			foreach (VisualElement item in costContainer.Children())
			{
				if (!IsElementDisplayed(item) || ((object)item).GetType().Name != "ItemDisplayView")
				{
					continue;
				}
				Button val = (Button)(object)((item is Button) ? item : null);
				if (val == null)
				{
					continue;
				}
				try
				{
					if (!((VisualElement)val).enabledInHierarchy)
					{
						continue;
					}
				}
				catch
				{
				}
				result.Add(val);
			}
		}

		private static void SimulateVEClick(VisualElement el)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			if (el == null)
			{
				return;
			}
			try
			{
				((Focusable)el).Focus();
			}
			catch
			{
			}
			try
			{
				VisualElement obj2 = ((el is Button) ? el : null);
				Clickable val = ((obj2 != null) ? ((Button)obj2).clickable : null);
				if (val != null)
				{
					MethodInfo method = ((object)val).GetType().GetMethod("Invoke", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(EventBase) }, null);
					if (method != null)
					{
						method.Invoke(val, new object[1]);
						return;
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("[ControllerSupport] UI Toolkit clickable.Invoke failed for '" + el.name + "': " + ex.Message));
			}
			try
			{
				ClickEvent pooled = EventBase<ClickEvent>.GetPooled();
				try
				{
					((CallbackEventHandler)el).SendEvent((EventBase)(object)pooled);
					return;
				}
				finally
				{
					((IDisposable)pooled)?.Dispose();
				}
			}
			catch (Exception ex2)
			{
				Logger.LogWarning((object)("[ControllerSupport] UI Toolkit ClickEvent failed for '" + el.name + "': " + ex2.Message));
			}
			PointerDownEvent val2 = new PointerDownEvent();
			try
			{
				PointerUpEvent val3 = new PointerUpEvent();
				try
				{
					((CallbackEventHandler)el).SendEvent((EventBase)(object)val2);
					((CallbackEventHandler)el).SendEvent((EventBase)(object)val3);
				}
				finally
				{
					((IDisposable)val3)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
		}

		private static bool ResolveInputHandler()
		{
			if (_inputHandlerSearched)
			{
				return _inputHandlerInstance != null;
			}
			_inputHandlerSearched = true;
			Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
			{
				try
				{
					return a.GetTypes();
				}
				catch
				{
					return new Type[0];
				}
			}).FirstOrDefault((Type t) => t.Name == "InputSystemHandler");
			if (type == null)
			{
				return false;
			}
			_inputHandlerGetBool = AccessTools.Method(type, "GetBool", (Type[])null, (Type[])null);
			return _inputHandlerGetBool != null;
		}

		private static object ResolveInputHandlerInstance()
		{
			object inputHandlerInstance = _inputHandlerInstance;
			Object val = (Object)((inputHandlerInstance is Object) ? inputHandlerInstance : null);
			if (val != null && val != (Object)null)
			{
				return _inputHandlerInstance;
			}
			Type type = _inputHandlerGetBool?.DeclaringType;
			if (type == null)
			{
				return null;
			}
			MethodInfo method = typeof(Object).GetMethod("FindObjectOfType", new Type[0]);
			if (method == null)
			{
				return null;
			}
			_inputHandlerInstance = method.MakeGenericMethod(type).Invoke(null, null);
			return _inputHandlerInstance;
		}

		private static void HandleBButton(Gamepad gp)
		{
			if (_bButtonConsumedFrames <= 0 && gp.buttonEast.wasPressedThisFrame && !((Object)(object)EventSystem.current == (Object)null) && DoHandleBButton(gp))
			{
				_bButtonConsumedFrames = 3;
			}
		}

		private static bool DoHandleBButton(Gamepad gp)
		{
			if (IsOverlayActive() && !RebindUI.IsListeningForRebind)
			{
				if (RebindUI.HasActiveRebind())
				{
					RebindUI.CancelActiveRebind();
				}
				RebindUI.Close();
				return true;
			}
			if (_cachedMenuController != null)
			{
				Type type = _cachedMenuController.GetType();
				FieldInfo fieldInfo = AccessTools.Field(type, "hostPanel");
				if (fieldInfo != null)
				{
					object? value = fieldInfo.GetValue(_cachedMenuController);
					GameObject val = (GameObject)((value is GameObject) ? value : null);
					if ((Object)(object)val != (Object)null && val.activeInHierarchy)
					{
						MethodInfo methodInfo = AccessTools.Method(type, "ActivatePanel", (Type[])null, (Type[])null);
						if (methodInfo != null)
						{
							methodInfo.Invoke(_cachedMenuController, new object[2] { null, true });
						}
						return true;
					}
				}
				FieldInfo fieldInfo2 = AccessTools.Field(type, "serverListPanel");
				if (fieldInfo2 != null)
				{
					object? value2 = fieldInfo2.GetValue(_cachedMenuController);
					GameObject val2 = (GameObject)((value2 is GameObject) ? value2 : null);
					if ((Object)(object)val2 != (Object)null && val2.activeInHierarchy)
					{
						MethodInfo methodInfo2 = AccessTools.Method(type, "ActivatePanel", (Type[])null, (Type[])null);
						if (methodInfo2 != null)
						{
							methodInfo2.Invoke(_cachedMenuController, new object[2] { null, true });
						}
						return true;
					}
				}
				FieldInfo fieldInfo3 = AccessTools.Field(type, "deletePrompt");
				if (fieldInfo3 != null)
				{
					object? value3 = fieldInfo3.GetValue(_cachedMenuController);
					GameObject val3 = (GameObject)((value3 is GameObject) ? value3 : null);
					if ((Object)(object)val3 != (Object)null && val3.activeInHierarchy)
					{
						return true;
					}
				}
			}
			if (_cachedPlayerController != null)
			{
				Type type2 = _cachedPlayerController.GetType();
				bool flag = IsUiOpen();
				bool flag2 = IsWellUiOpen(_cachedPlayerController);
				bool flag3 = IsStockpileUiOpen();
				if (flag || flag2 || flag3)
				{
					if (IsDescriptionOverlayOpen())
					{
						CloseDescriptionOverlay();
						return true;
					}
					FieldInfo fieldInfo4 = AccessTools.Field(type2, "settingsPanel");
					FieldInfo fieldInfo5 = AccessTools.Field(type2, "rebindPanel");
					bool flag4 = false;
					if (fieldInfo4 != null)
					{
						object? value4 = fieldInfo4.GetValue(_cachedPlayerController);
						GameObject val4 = (GameObject)((value4 is GameObject) ? value4 : null);
						if ((Object)(object)val4 != (Object)null && val4.activeInHierarchy)
						{
							flag4 = true;
						}
					}
					if (fieldInfo5 != null)
					{
						object? value5 = fieldInfo5.GetValue(_cachedPlayerController);
						GameObject val5 = (GameObject)((value5 is GameObject) ? value5 : null);
						if ((Object)(object)val5 != (Object)null && val5.activeInHierarchy)
						{
							flag4 = true;
						}
					}
					if (!flag4)
					{
						if (flag2)
						{
							MethodInfo methodInfo3 = AccessTools.Method(type2, "CloseUIPanel", (Type[])null, (Type[])null);
							if (methodInfo3 != null)
							{
								methodInfo3.Invoke(_cachedPlayerController, null);
							}
							ResetWellNavCache();
							return true;
						}
						if (flag3)
						{
							MethodInfo methodInfo4 = AccessTools.Method(type2, "CloseUIPanel", (Type[])null, (Type[])null);
							if (methodInfo4 != null)
							{
								methodInfo4.Invoke(_cachedPlayerController, null);
							}
							ResetStockpileNavCache();
							return true;
						}
						if (flag)
						{
							MethodInfo methodInfo5 = AccessTools.Method(type2, "CloseUIPanel", (Type[])null, (Type[])null);
							if (methodInfo5 != null)
							{
								methodInfo5.Invoke(_cachedPlayerController, null);
							}
							ResetStockpileNavCache();
							_bButtonConsumedFrames = 3;
							return true;
						}
					}
				}
			}
			return false;
		}

		private static void HandleHandRange(Gamepad gp)
		{
			if (!_handControllerSearched)
			{
				_handControllerSearched = true;
				Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
				{
					try
					{
						return a.GetTypes();
					}
					catch
					{
						return new Type[0];
					}
				}).FirstOrDefault((Type t) => t.Name == "PlayerHandController");
				if (type != null)
				{
					_changeHandTargetDistanceMethod = AccessTools.Method(type, "ChangeHandTargetDistance", (Type[])null, (Type[])null);
				}
			}
			if (_changeHandTargetDistanceMethod == null)
			{
				return;
			}
			if (Time.unscaledTime < _nextHandControllerSearchTime)
			{
				if (_handControllerInstance == null || IsUnityObjectAlive(_handControllerInstance))
				{
					return;
				}
				_handControllerInstance = null;
				_nextHandControllerSearchTime = 0f;
			}
			_handControllerInstance = ResolveLocalHandControllerInstance();
			if (_handControllerInstance == null)
			{
				_nextHandControllerSearchTime = Time.unscaledTime + 2f;
				return;
			}
			if (!IsPushHeldForHandRange(gp))
			{
				ResetHandRangeRepeatTimers();
				return;
			}
			bool isPressed = gp.leftShoulder.isPressed;
			bool isPressed2 = gp.rightShoulder.isPressed;
			float unscaledTime = Time.unscaledTime;
			if (isPressed)
			{
				if (_lbHoldTime < 0f)
				{
					_changeHandTargetDistanceMethod.Invoke(_handControllerInstance, new object[1] { 0f - _handRangeStep });
					_lbHoldTime = unscaledTime;
				}
				else if (unscaledTime - _lbHoldTime >= _handRangeRepeatDelay)
				{
					float num = unscaledTime - _lbHoldTime - _handRangeRepeatDelay;
					_ = num / _handRangeRepeatRate;
					float num2 = _lbHoldTime + _handRangeRepeatDelay + (float)(int)(num / _handRangeRepeatRate) * _handRangeRepeatRate;
					if (unscaledTime - num2 >= 0f)
					{
						_changeHandTargetDistanceMethod.Invoke(_handControllerInstance, new object[1] { (0f - _handRangeStep) * 0.3f });
						_lbHoldTime = unscaledTime - _handRangeRepeatDelay - num % _handRangeRepeatRate;
					}
				}
			}
			else
			{
				_lbHoldTime = -1f;
			}
			if (isPressed2)
			{
				if (_rbHoldTime < 0f)
				{
					_changeHandTargetDistanceMethod.Invoke(_handControllerInstance, new object[1] { _handRangeStep });
					_rbHoldTime = unscaledTime;
				}
				else if (unscaledTime - _rbHoldTime >= _handRangeRepeatDelay)
				{
					float num3 = unscaledTime - _rbHoldTime - _handRangeRepeatDelay;
					float num4 = _rbHoldTime + _handRangeRepeatDelay + (float)(int)(num3 / _handRangeRepeatRate) * _handRangeRepeatRate;
					if (unscaledTime - num4 >= 0f)
					{
						_changeHandTargetDistanceMethod.Invoke(_handControllerInstance, new object[1] { _handRangeStep * 0.3f });
						_rbHoldTime = unscaledTime - _handRangeRepeatDelay - num3 % _handRangeRepeatRate;
					}
				}
			}
			else
			{
				_rbHoldTime = -1f;
			}
		}

		private static object ResolveLocalHandControllerInstance()
		{
			Type type = _changeHandTargetDistanceMethod?.DeclaringType;
			if (type == null)
			{
				return null;
			}
			try
			{
				if (_serverManagerGetLocalPlayerMethod == null)
				{
					_serverManagerGetLocalPlayerMethod = AccessTools.Method(AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
					{
						try
						{
							return a.GetTypes();
						}
						catch
						{
							return new Type[0];
						}
					}).FirstOrDefault((Type t) => t.Name == "ServerManager"), "GetLocalPlayer", (Type[])null, (Type[])null);
				}
				object obj = _serverManagerGetLocalPlayerMethod?.Invoke(null, null);
				if (obj != null)
				{
					if ((object)_localPlayerHandControllerProperty == null)
					{
						_localPlayerHandControllerProperty = AccessTools.Property(obj.GetType(), "HandController");
					}
					object obj2 = _localPlayerHandControllerProperty?.GetValue(obj, null);
					if (IsUnityObjectAlive(obj2))
					{
						return obj2;
					}
				}
			}
			catch (Exception ex)
			{
				if (_nextHandControllerSearchTime <= Time.unscaledTime - 1f)
				{
					Logger.LogWarning((object)("[ControllerSupport] HandRange: local player hand lookup failed: " + ex.Message));
				}
			}
			if (IsUnityObjectAlive(_handControllerInstance) && IsNetworkOwner(_handControllerInstance))
			{
				return _handControllerInstance;
			}
			try
			{
				MethodInfo method = typeof(Object).GetMethod("FindObjectsOfType", new Type[0]);
				if (method == null)
				{
					return null;
				}
				if (!(method.MakeGenericMethod(type).Invoke(null, null) is Array array))
				{
					return null;
				}
				foreach (object item in array)
				{
					if (IsUnityObjectAlive(item) && IsNetworkOwner(item))
					{
						return item;
					}
				}
				foreach (object item2 in array)
				{
					if (IsUnityObjectAlive(item2))
					{
						return item2;
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.LogWarning((object)("[ControllerSupport] HandRange: fallback hand lookup failed: " + ex2.Message));
			}
			return null;
		}

		private static bool IsUnityObjectAlive(object obj)
		{
			if (obj == null)
			{
				return false;
			}
			Object val = (Object)((obj is Object) ? obj : null);
			if (val != null)
			{
				return val != (Object)null;
			}
			return true;
		}

		private static string SafeName(Object obj)
		{
			if (obj == (Object)null)
			{
				return "null";
			}
			if (!Object.op_Implicit(obj))
			{
				return "null";
			}
			return obj.name;
		}

		private static bool IsNetworkOwner(object obj)
		{
			try
			{
				PropertyInfo property = obj.GetType().GetProperty("IsOwner", BindingFlags.Instance | BindingFlags.Public);
				return property != null && (bool)property.GetValue(obj, null);
			}
			catch
			{
				return false;
			}
		}

		private static bool IsLocalPlayer(object obj)
		{
			try
			{
				PropertyInfo property = obj.GetType().GetProperty("IsLocalPlayer", BindingFlags.Instance | BindingFlags.Public);
				return property != null && (bool)property.GetValue(obj, null);
			}
			catch
			{
				return false;
			}
		}

		internal static bool IsPushHeldForHandRange(Gamepad gp)
		{
			if (gp != null && ReadBindingPressed(gp, "Push"))
			{
				return true;
			}
			try
			{
				if (!ResolveInputHandler())
				{
					return false;
				}
				object obj = ResolveInputHandlerInstance();
				if (obj == null)
				{
					return false;
				}
				return (bool)_inputHandlerGetBool.Invoke(obj, new object[1] { "Push" });
			}
			catch
			{
				return false;
			}
		}

		internal static bool IsGloveRangeAdjustActive()
		{
			if (_gloveRangeAdjustChecked == false)
			{
				return false;
			}
			if (!_gloveRangeAdjustChecked.HasValue)
			{
				_gloveRangeAdjustChecked = true;
				Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
				{
					try
					{
						return a.GetTypes();
					}
					catch
					{
						return new Type[0];
					}
				}).FirstOrDefault((Type t) => t.Name == "GloveRangeAdjustPlugin");
				if (type == null)
				{
					_gloveRangeAdjustChecked = false;
					return false;
				}
				_gloveRangeActiveField = AccessTools.Field(type, "IsGloveRangeActive");
				_glovePressingField = AccessTools.Field(type, "IsGlovePressing");
				if (_gloveRangeActiveField == null)
				{
					_gloveRangeAdjustChecked = false;
					return false;
				}
			}
			try
			{
				return _gloveRangeActiveField != null && (bool)_gloveRangeActiveField.GetValue(null);
			}
			catch
			{
				return false;
			}
		}

		internal static bool IsGlovePressingActive()
		{
			if (_gloveRangeAdjustChecked == false || _glovePressingField == null)
			{
				return false;
			}
			try
			{
				return (bool)_glovePressingField.GetValue(null);
			}
			catch
			{
				return false;
			}
		}

		private static void ResetHandRangeRepeatTimers()
		{
			_lbHoldTime = -1f;
			_rbHoldTime = -1f;
		}

		internal static bool GetGameBool(string actionName)
		{
			if (!ResolveInputHandler())
			{
				return false;
			}
			object obj = ResolveInputHandlerInstance();
			if (obj == null)
			{
				return false;
			}
			return (bool)_inputHandlerGetBool.Invoke(obj, new object[1] { actionName });
		}

		private static bool DumpInputActionNames()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			Object[] array = Object.FindObjectsOfTypeAll(typeof(InputActionAsset));
			if (array == null || array.Length == 0)
			{
				Logger.LogWarning((object)"[ControllerSupport] DumpInputActionNames: no InputActionAsset found, retrying...");
				return false;
			}
			Object[] array2 = array;
			foreach (Object obj in array2)
			{
				InputActionAsset val = (InputActionAsset)(object)((obj is InputActionAsset) ? obj : null);
				if (val == null)
				{
					continue;
				}
				Enumerator<InputActionMap> enumerator = val.actionMaps.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						Enumerator<InputAction> enumerator2 = enumerator.Current.actions.GetEnumerator();
						try
						{
							while (enumerator2.MoveNext())
							{
								InputAction current = enumerator2.Current;
								string.Join(", ", ((IEnumerable<InputBinding>)(object)current.bindings).Select((InputBinding b) => ((InputBinding)(ref b)).effectivePath));
							}
						}
						finally
						{
							((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
						}
					}
				}
				finally
				{
					((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
			}
			return true;
		}

		private static void DumpUIHierarchy()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)EventSystem.current == (Object)null)
			{
				Logger.LogWarning((object)"[ControllerSupport] DumpUIHierarchy: no EventSystem");
				return;
			}
			Object[] array = Object.FindObjectsOfTypeAll(typeof(Canvas));
			foreach (Object obj in array)
			{
				Canvas val = (Canvas)(object)((obj is Canvas) ? obj : null);
				if (val == null || (Object)(object)val == (Object)null)
				{
					continue;
				}
				Selectable[] componentsInChildren = ((Component)val).GetComponentsInChildren<Selectable>(false);
				foreach (Selectable val2 in componentsInChildren)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						_ = ((object)val2).GetType().Name;
						_ = val2.navigation;
					}
				}
			}
		}

		private static void DumpGameType(string typeName)
		{
			_ = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
			{
				try
				{
					return a.GetTypes();
				}
				catch
				{
					return new Type[0];
				}
			}).FirstOrDefault((Type t) => t.Name == typeName) == null;
		}

		internal static Vector2 ApplyDeadzone(Vector2 input, float deadzone)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			float num = ((Vector2)(ref input)).magnitude;
			if (num <= deadzone)
			{
				return Vector2.zero;
			}
			if (num > 1f)
			{
				num = 1f;
			}
			float num2 = (num - deadzone) / (1f - deadzone);
			return input / num * num2;
		}

		internal static float ApplyResponseCurve(float value, ResponseCurveType curve, float exponent)
		{
			if (Mathf.Approximately(value, 0f))
			{
				return 0f;
			}
			float num = Mathf.Sign(value);
			float num2 = Mathf.Abs(value);
			switch (curve)
			{
			case ResponseCurveType.Linear:
				return value;
			case ResponseCurveType.Exponential:
				return num * Mathf.Pow(num2, exponent);
			case ResponseCurveType.Aggressive:
			{
				float num3 = Mathf.Max(exponent, 2.5f);
				return num * Mathf.Pow(num2, num3);
			}
			case ResponseCurveType.Smooth:
				return num * Mathf.Clamp(num2 * (1f - Mathf.Pow(1f - num2, exponent)), 0f, 1f);
			default:
				return value;
			}
		}

		internal static Vector2 ProcessStick(Vector2 raw, float deadzone, ResponseCurveType curve, float exponent)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = ApplyDeadzone(raw, deadzone);
			return new Vector2(ApplyResponseCurve(val.x, curve, exponent), ApplyResponseCurve(val.y, curve, exponent));
		}

		internal static float ProcessTrigger(float raw, float deadzone)
		{
			if (raw < deadzone)
			{
				return 0f;
			}
			return (raw - deadzone) / (1f - deadzone);
		}

		internal static string StripGamepadPrefix(string path)
		{
			if (path.StartsWith("<Gamepad>/"))
			{
				return path.Substring("<Gamepad>/".Length);
			}
			return path;
		}

		internal static bool WasGamepadButtonPressed(Gamepad gp, string actionName)
		{
			if (!RuntimeBindings.TryGetValue(actionName, out var value))
			{
				return false;
			}
			InputControl childControl = ((InputControl)gp).GetChildControl(StripGamepadPrefix(value));
			ButtonControl val = (ButtonControl)(object)((childControl is ButtonControl) ? childControl : null);
			if (val != null)
			{
				return val.wasPressedThisFrame;
			}
			AxisControl val2 = (AxisControl)(object)((childControl is AxisControl) ? childControl : null);
			if (val2 != null)
			{
				if (((InputControl<float>)(object)val2).ReadValue() > 0.5f)
				{
					return ((InputControl<float>)(object)val2).ReadValueFromPreviousFrame() <= 0.5f;
				}
				return false;
			}
			return false;
		}

		internal static void ResetToggleButtonEdges()
		{
			Gamepad current = Gamepad.current;
			if (current != null)
			{
				prevCrouchButton = ReadBindingPressed(current, "Crouch");
				prevSprintButton = ReadBindingPressed(current, "Run");
			}
			else
			{
				prevCrouchButton = false;
				prevSprintButton = false;
			}
		}

		internal static bool ReadBindingPressed(Gamepad gp, string actionName)
		{
			if (!RuntimeBindings.TryGetValue(actionName, out var value))
			{
				if (actionName == "Crouch")
				{
					return gp.buttonEast.isPressed;
				}
				if (actionName == "Run")
				{
					return gp.leftStickButton.isPressed;
				}
				return false;
			}
			InputControl childControl = ((InputControl)gp).GetChildControl(StripGamepadPrefix(value));
			ButtonControl val = (ButtonControl)(object)((childControl is ButtonControl) ? childControl : null);
			if (val != null)
			{
				return val.isPressed;
			}
			AxisControl val2 = (AxisControl)(object)((childControl is AxisControl) ? childControl : null);
			if (val2 != null)
			{
				return ((InputControl<float>)(object)val2).ReadValue() > 0.5f;
			}
			return false;
		}

		internal static bool IsKeyboardMouseNewerThanGamepad(Gamepad gp)
		{
			if (gp == null)
			{
				return true;
			}
			Keyboard current = Keyboard.current;
			Mouse current2 = Mouse.current;
			double val = ((current != null) ? ((InputDevice)current).lastUpdateTime : 0.0);
			double val2 = ((current2 != null) ? ((InputDevice)current2).lastUpdateTime : 0.0);
			return Math.Max(val, val2) > ((InputDevice)gp).lastUpdateTime;
		}

		internal static bool IsGamepadMovementActive(Gamepad gp)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (gp == null)
			{
				return false;
			}
			float num = ((LeftStickDeadzone != null) ? LeftStickDeadzone.Value : 0.2f);
			Vector2 val = ((InputControl<Vector2>)(object)gp.leftStick).ReadValue();
			return ((Vector2)(ref val)).magnitude > Mathf.Max(0.05f, num);
		}

		internal static void ResetSprintToggleForKeyboardMouse()
		{
			SprintToggled = false;
			_prevSprintMoveMag = 0f;
			_movedSinceSprintToggle = false;
			prevSprintButton = false;
		}

		internal static bool ConsumeTogglePressEdge(Gamepad gp, string actionName)
		{
			if (gp == null)
			{
				return false;
			}
			ref bool reference = ref prevCrouchButton;
			if (actionName == "Run" || actionName == "Sprint")
			{
				reference = ref prevSprintButton;
			}
			bool flag = false;
			if (RuntimeBindings.TryGetValue((actionName == "Sprint") ? "Run" : actionName, out var value))
			{
				InputControl childControl = ((InputControl)gp).GetChildControl(StripGamepadPrefix(value));
				ButtonControl val = (ButtonControl)(object)((childControl is ButtonControl) ? childControl : null);
				if (val != null)
				{
					flag = val.isPressed;
				}
				else
				{
					AxisControl val2 = (AxisControl)(object)((childControl is AxisControl) ? childControl : null);
					if (val2 != null)
					{
						flag = ((InputControl<float>)(object)val2).ReadValue() > 0.5f;
					}
				}
			}
			bool result = flag && !reference;
			reference = flag;
			return result;
		}

		internal static bool ShouldBypassCrouchToggle(Gamepad gp)
		{
			if (gp == null)
			{
				return false;
			}
			bool flag = ReadBindingPressed(gp, "Crouch");
			if (IsWallSliding())
			{
				_blockCrouchToggleUntilRelease = flag;
				prevCrouchButton = flag;
				if (flag)
				{
					CrouchToggled = false;
				}
				return true;
			}
			if (!_blockCrouchToggleUntilRelease)
			{
				return false;
			}
			if (flag)
			{
				prevCrouchButton = true;
				CrouchToggled = false;
				return true;
			}
			_blockCrouchToggleUntilRelease = false;
			prevCrouchButton = false;
			return false;
		}

		internal static void BlockCrouchToggleUntilRelease(Gamepad gp, string reason, bool force = false)
		{
			bool flag = gp != null && ReadBindingPressed(gp, "Crouch");
			if (force)
			{
				flag = true;
			}
			if (flag)
			{
				_ = _blockCrouchToggleUntilRelease;
				_blockCrouchToggleUntilRelease = true;
				prevCrouchButton = true;
				CrouchToggled = false;
			}
		}
	}
	[HarmonyPatch]
	public static class InputSystemHandlerReadyPatch
	{
		private static MethodBase _targetMethod;

		private static bool _methodResolved;

		private static MethodBase TargetMethod()
		{
			if (_methodResolved)
			{
				return _targetMethod;
			}
			_methodResolved = true;
			Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
			{
				try
				{
					return a.GetTypes();
				}
				catch
				{
					return new Type[0];
				}
			}).FirstOrDefault((Type t) => t.Name == "InputSystemHandler");
			if (type == null)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] InputSystemHandlerReadyPatch: InputSystemHandler type not found");
				return null;
			}
			_targetMethod = AccessTools.Method(type, "Awake", (Type[])null, (Type[])null);
			if (!(_targetMethod != null))
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] InputSystemHandlerReadyPatch: Awake not found");
			}
			return _targetMethod;
		}

		[HarmonyPostfix]
		public static void Postfix()
		{
			ControllerSupportPlugin.TryInjectBindings();
		}
	}
	[HarmonyPatch(typeof(PlayerController), "ToggleTaskList")]
	public static class ToggleTaskListPatch
	{
		[HarmonyPostfix]
		public static void Postfix(PlayerController __instance, bool enabled)
		{
			ControllerSupportPlugin._taskListOpen = enabled;
			ControllerSupportPlugin._cachedPlayerController = __instance;
			ControllerSupportPlugin._pcSearched = true;
			if (enabled)
			{
				ControllerSupportPlugin._taskListSelectedIndex = -1;
				ControllerSupportPlugin._infoOverlayOpen = false;
				ControllerSupportPlugin._infoFoldoutIndex = -1;
				ControllerSupportPlugin._cachedFoldouts.Clear();
				ControllerSupportPlugin._currentListType = ControllerSupportPlugin.ListType.DeadTied;
				if ((Object)(object)(ControllerSupportPlugin._cachedTaskListUI = Object.FindObjectOfType<TaskListUI>()) != (Object)null)
				{
					ControllerSupportPlugin.RebuildTaskElementCache(forPapyrus: false);
					if (ControllerSupportPlugin._cachedTaskElements.Count > 0)
					{
						ControllerSupportPlugin._taskListSelectedIndex = 0;
						ControllerSupportPlugin.HighlightTaskElement(0);
					}
					else
					{
						ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] Task list opened but no PlayerTaskElement children found in taskElementParent");
					}
				}
				else
				{
					ControllerSupportPlugin._cachedTaskElements.Clear();
					ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] Could not find TaskListUI when task list opened");
				}
			}
			else
			{
				ControllerSupportPlugin.ClearTaskElementHighlights();
				ControllerSupportPlugin._taskListSelectedIndex = -1;
				ControllerSupportPlugin._infoOverlayOpen = false;
				ControllerSupportPlugin._mouseOpenedInfoOverlay = false;
				ControllerSupportPlugin._infoFoldoutIndex = -1;
				ControllerSupportPlugin._cachedTaskElements.Clear();
				ControllerSupportPlugin._cachedFoldouts.Clear();
				ControllerSupportPlugin._cachedDescriptionDisplayer = null;
				ControllerSupportPlugin._currentListType = ControllerSupportPlugin.ListType.None;
				ControllerSupportPlugin.EnableLookAndCameraActions();
				ControllerSupportPlugin.UpdateLookActionState();
			}
		}
	}
	[HarmonyPatch]
	public static class DescriptionDisplayerPatch
	{
		private static MethodBase _targetMethod;

		private static bool _methodResolved;

		private static MethodBase TargetMethod()
		{
			if (_methodResolved)
			{
				return _targetMethod;
			}
			_methodResolved = true;
			Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
			{
				try
				{
					return a.GetTypes();
				}
				catch
				{
					return new Type[0];
				}
			}).FirstOrDefault((Type t) => t.Name == "DescriptionDisplayer");
			if (type == null)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] DescriptionDisplayerPatch: type not found");
				return null;
			}
			_targetMethod = AccessTools.Method(type, "DisableTaskList", (Type[])null, (Type[])null);
			return _targetMethod;
		}

		[HarmonyPostfix]
		public static void Postfix()
		{
			if (ControllerSupportPlugin._suppressNextDescriptionDisableClose)
			{
				ControllerSupportPlugin._suppressNextDescriptionDisableClose = false;
				ControllerSupportPlugin._bButtonConsumedFrames = Math.Max(ControllerSupportPlugin._bButtonConsumedFrames, 4);
				ControllerSupportPlugin.ResetToggleButtonEdges();
			}
		}
	}
	[HarmonyPatch]
	public static class CameraCurvePatch
	{
		private static MethodBase _targetMethod;

		private static bool _fieldsDumped = false;

		private static Dictionary<object, (float yaw, float pitch, float sens)> _baseSpeeds = new Dictionary<object, (float, float, float)>();

		private static MethodBase TargetMethod()
		{
			if (_targetMethod != null)
			{
				return _targetMethod;
			}
			Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
			{
				try
				{
					return a.GetTypes();
				}
				catch
				{
					return new Type[0];
				}
			}).FirstOrDefault((Type t) => t.Name == "Camera3D" && t.Namespace != null && t.Namespace.Contains("CharacterControllerPro"));
			if (type != null)
			{
				_targetMethod = AccessTools.Method(type, "UpdateCamera", (Type[])null, (Type[])null);
			}
			else
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] Camera3D type not found for curve patch");
			}
			return _targetMethod;
		}

		private static void Prefix(object __instance)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Type type = __instance.GetType();
				if (!_fieldsDumped)
				{
					_fieldsDumped = true;
					type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				FieldInfo fieldInfo = AccessTools.Field(type, "yawSpeed");
				FieldInfo fieldInfo2 = AccessTools.Field(type, "pitchSpeed");
				FieldInfo fieldInfo3 = AccessTools.Field(type, "sensitivity");
				FieldInfo fieldInfo4 = AccessTools.Field(type, "invertY");
				if (fieldInfo == null || fieldInfo2 == null)
				{
					ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] yawSpeed/pitchSpeed fields not found on Camera3D!");
					return;
				}
				if (!_baseSpeeds.ContainsKey(__instance))
				{
					float item = ((fieldInfo3 != null) ? ((float)fieldInfo3.GetValue(__instance)) : 1f);
					_baseSpeeds[__instance] = ((float)fieldInfo.GetValue(__instance), (float)fieldInfo2.GetValue(__instance), item);
				}
				(float yaw, float pitch, float sens) tuple = _baseSpeeds[__instance];
				float item2 = tuple.yaw;
				float item3 = tuple.pitch;
				float item4 = tuple.sens;
				float value = ControllerSupportPlugin.LookSensitivity.Value;
				Gamepad current = Gamepad.current;
				if (current != null)
				{
					Vector2 val = ((InputControl<Vector2>)(object)current.rightStick).ReadValue();
					if (((Vector2)(ref val)).magnitude > 0.01f)
					{
						fieldInfo.SetValue(__instance, item2 * value);
						fieldInfo2.SetValue(__instance, item3 * value);
						if (fieldInfo3 != null)
						{
							fieldInfo3.SetValue(__instance, item4 * value);
						}
						goto IL_019d;
					}
				}
				fieldInfo.SetValue(__instance, item2);
				fieldInfo2.SetValue(__instance, item3);
				if (fieldInfo3 != null)
				{
					fieldInfo3.SetValue(__instance, item4);
				}
				goto IL_019d;
				IL_019d:
				if (fieldInfo4 != null)
				{
					fieldInfo4.SetValue(__instance, ControllerSupportPlugin.InvertLookY.Value);
				}
			}
			catch (Exception ex)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] CameraPatch error: " + ex.Message));
			}
		}
	}
	public static class InputPatches
	{
		private static int _cameraBlockLogFrame = -1;

		[HarmonyPatch(typeof(Input), "GetButton")]
		[HarmonyPostfix]
		public static void GetButtonPostfix(string buttonName, ref bool __result)
		{
			if (!__result && Gamepad.current != null && GetGamepadBool(buttonName))
			{
				__result = true;
			}
		}

		[HarmonyPatch(typeof(Input), "GetAxis")]
		[HarmonyPostfix]
		public static void GetAxisPostfix(string axisName, ref float __result)
		{
			if (IsLookAxis(axisName) && ShouldBlockCameraLook())
			{
				if (Time.frameCount % 60 == 0)
				{
					__result = 0f;
				}
			}
			else
			{
				if (Gamepad.current == null)
				{
					return;
				}
				float gamepadAxis = GetGamepadAxis(axisName);
				if (Mathf.Abs(gamepadAxis) > 0.01f)
				{
					if (IsLookAxis(axisName))
					{
						__result = gamepadAxis;
					}
					else if (Mathf.Abs(__result) < 0.01f)
					{
						__result = gamepadAxis;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Input), "GetAxisRaw")]
		[HarmonyPrefix]
		public static bool GetAxisRawPrefix(string axisName, ref float __result)
		{
			if (IsLookAxis(axisName))
			{
				if (ShouldBlockCameraLook())
				{
					if (Time.frameCount % 60 == 0)
					{
						__result = 0f;
					}
					return false;
				}
				if (Gamepad.current != null)
				{
					__result = GetGamepadAxisRaw(axisName);
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(Input), "GetAxisRaw")]
		[HarmonyPostfix]
		public static void GetAxisRawPostfix(string axisName, ref float __result)
		{
			if (Gamepad.current != null && !IsLookAxis(axisName))
			{
				float gamepadAxisRaw = GetGamepadAxisRaw(axisName);
				if (Mathf.Abs(gamepadAxisRaw) > 0.01f && Mathf.Abs(__result) < 0.01f)
				{
					__result = gamepadAxisRaw;
				}
			}
		}

		[HarmonyPatch(typeof(Input), "GetKey", new Type[] { typeof(KeyCode) })]
		[HarmonyPostfix]
		public static void GetKeyPostfix(KeyCode key, ref bool __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)key == 27)
			{
				Gamepad current = Gamepad.current;
				if (current != null)
				{
					__result |= current.startButton.isPressed;
				}
			}
		}

		[HarmonyPatch(typeof(Input), "GetKeyDown", new Type[] { typeof(KeyCode) })]
		[HarmonyPostfix]
		public static void GetKeyDownPostfix(KeyCode key, ref bool __result)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected I4, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected I4, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Invalid comparison between Unknown and I4
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			if (__result)
			{
				return;
			}
			Gamepad current = Gamepad.current;
			if (current == null)
			{
				return;
			}
			string text = null;
			if ((int)key <= 102)
			{
				if ((int)key <= 27)
				{
					if ((int)key != 9)
					{
						if ((int)key != 27)
						{
							return;
						}
						text = "Pause";
					}
					else
					{
						text = "Inventory";
					}
				}
				else
				{
					switch (key - 49)
					{
					case 0:
						goto IL_00c4;
					case 1:
						goto IL_00cc;
					case 2:
						goto IL_00d4;
					case 3:
						goto IL_00dc;
					}
					if ((int)key != 101)
					{
						if ((int)key != 102)
						{
							return;
						}
						text = "Push";
					}
					else
					{
						text = "Interact";
					}
				}
			}
			else if ((int)key <= 114)
			{
				if ((int)key != 113)
				{
					if ((int)key != 114)
					{
						return;
					}
					text = "Ragdoll";
				}
				else
				{
					text = "Drop";
				}
			}
			else if ((int)key != 118)
			{
				switch (key - 257)
				{
				case 0:
					goto IL_00c4;
				case 1:
					goto IL_00cc;
				case 2:
					goto IL_00d4;
				case 3:
					goto IL_00dc;
				}
				if ((int)key != 323)
				{
					return;
				}
				text = "Attack";
			}
			else
			{
				text = "Push To Talk";
			}
			goto IL_00e2;
			IL_00e2:
			if (text == null || !ControllerSupportPlugin.RuntimeBindings.TryGetValue(text, out var value))
			{
				return;
			}
			InputControl childControl = ((InputControl)current).GetChildControl(ControllerSupportPlugin.StripGamepadPrefix(value));
			ButtonControl val = (ButtonControl)(object)((childControl is ButtonControl) ? childControl : null);
			if (val != null)
			{
				__result |= val.wasPressedThisFrame;
				return;
			}
			AxisControl val2 = (AxisControl)(object)((childControl is AxisControl) ? childControl : null);
			if (val2 != null)
			{
				__result |= ((InputControl<float>)(object)val2).ReadValue() > 0.5f && WasAxisPressed(current, value);
			}
			return;
			IL_00cc:
			text = "Item2";
			goto IL_00e2;
			IL_00c4:
			text = "Item1";
			goto IL_00e2;
			IL_00d4:
			text = "Item3";
			goto IL_00e2;
			IL_00dc:
			text = "Item4";
			goto IL_00e2;
		}

		private static bool WasAxisPressed(Gamepad gp, string path)
		{
			InputControl childControl = ((InputControl)gp).GetChildControl(ControllerSupportPlugin.StripGamepadPrefix(path));
			ButtonControl val = (ButtonControl)(object)((childControl is ButtonControl) ? childControl : null);
			if (val != null)
			{
				return val.wasPressedThisFrame;
			}
			AxisControl val2 = (AxisControl)(object)((childControl is AxisControl) ? childControl : null);
			if (val2 != null)
			{
				if (((InputControl<float>)(object)val2).ReadValue() > 0.5f)
				{
					return ((InputControl<float>)(object)val2).ReadValueFromPreviousFrame() <= 0.5f;
				}
				return false;
			}
			return false;
		}

		[HarmonyPatch(typeof(Input), "GetMouseButtonDown", new Type[] { typeof(int) })]
		[HarmonyPostfix]
		public static void GetMouseButtonDownPostfix(int button, ref bool __result)
		{
			if (__result)
			{
				return;
			}
			Gamepad current = Gamepad.current;
			if (current != null)
			{
				switch (button)
				{
				case 0:
					__result |= current.rightTrigger.wasPressedThisFrame;
					break;
				case 1:
					__result |= current.leftTrigger.wasPressedThisFrame;
					break;
				}
			}
		}

		private static bool IsLookAxis(string axisName)
		{
			switch (axisName)
			{
			default:
				return axisName == "Camera Y";
			case "Mouse X":
			case "Mouse Y":
			case "Look X":
			case "Look Y":
			case "Camera X":
				return true;
			}
		}

		private static bool ShouldBlockCameraLook()
		{
			bool infoOverlayOpen = ControllerSupportPlugin._infoOverlayOpen;
			bool taskListOpen = ControllerSupportPlugin._taskListOpen;
			int num;
			if (ControllerSupportPlugin._currentListType == ControllerSupportPlugin.ListType.DeadTied)
			{
				num = ((infoOverlayOpen || taskListOpen) ? 1 : 0);
				if (num != 0 && Time.frameCount != _cameraBlockLogFrame)
				{
					_cameraBlockLogFrame = Time.frameCount;
				}
			}
			else
			{
				num = 0;
			}
			return (byte)num != 0;
		}

		private static bool GetGamepadBool(string actionName)
		{
			Gamepad current = Gamepad.current;
			if (current == null)
			{
				return false;
			}
			if (actionName == "Run" && ControllerSupportPlugin.ToggleSprint.Value)
			{
				if (ControllerSupportPlugin.IsKeyboardMouseNewerThanGamepad(current))
				{
					ControllerSupportPlugin.ResetSprintToggleForKeyboardMouse();
					return false;
				}
				bool num = ControllerSupportPlugin.ReadBindingPressed(current, "Run");
				bool flag = ControllerSupportPlugin.IsGamepadMovementActive(current);
				if (!num && !flag && !ControllerSupportPlugin.SprintToggled)
				{
					return false;
				}
				return ControllerSupportPlugin.SprintToggled && flag;
			}
			if (actionName == "Crouch" && ControllerSupportPlugin.ToggleCrouch.Value)
			{
				if (ControllerSupportPlugin.ShouldBypassCrouchToggle(current))
				{
					return ControllerSupportPlugin.ReadBindingPressed(current, "Crouch");
				}
				return ControllerSupportPlugin.CrouchToggled;
			}
			if (!ControllerSupportPlugin.RuntimeBindings.TryGetValue(actionName, out var value))
			{
				return false;
			}
			InputControl childControl = ((InputControl)current).GetChildControl(ControllerSupportPlugin.StripGamepadPrefix(value));
			ButtonControl val = (ButtonControl)(object)((childControl is ButtonControl) ? childControl : null);
			if (val != null)
			{
				return val.isPressed;
			}
			AxisControl val2 = (AxisControl)(object)((childControl is AxisControl) ? childControl : null);
			if (val2 != null)
			{
				return ((InputControl<float>)(object)val2).ReadValue() > 0.5f;
			}
			return false;
		}

		private static float GetGamepadAxis(string axisName)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			Gamepad current = Gamepad.current;
			if (current == null)
			{
				return 0f;
			}
			switch (axisName)
			{
			case "Mouse X":
			case "Look X":
				return ControllerSupportPlugin.ProcessStick(((InputControl<Vector2>)(object)current.rightStick).ReadValue(), ControllerSupportPlugin.RightStickDeadzone.Value, ControllerSupportPlugin.RightStickCurve.Value, ControllerSupportPlugin.RightStickExponent.Value).x;
			case "Mouse Y":
			case "Look Y":
				return ControllerSupportPlugin.ProcessStick(((InputControl<Vector2>)(object)current.rightStick).ReadValue(), ControllerSupportPlugin.RightStickDeadzone.Value, ControllerSupportPlugin.RightStickCurve.Value, ControllerSupportPlugin.RightStickExponent.Value).y;
			case "Movement X":
			case "Horizontal":
				return ControllerSupportPlugin.ProcessStick(((InputControl<Vector2>)(object)current.leftStick).ReadValue(), ControllerSupportPlugin.LeftStickDeadzone.Value, ControllerSupportPlugin.LeftStickCurve.Value, ControllerSupportPlugin.LeftStickExponent.Value).x * ControllerSupportPlugin.MovementSensitivity.Value;
			case "Movement Y":
			case "Vertical":
				return ControllerSupportPlugin.ProcessStick(((InputControl<Vector2>)(object)current.leftStick).ReadValue(), ControllerSupportPlugin.LeftStickDeadzone.Value, ControllerSupportPlugin.LeftStickCurve.Value, ControllerSupportPlugin.LeftStickExponent.Value).y * ControllerSupportPlugin.MovementSensitivity.Value;
			default:
				return 0f;
			}
		}

		private static float GetGamepadAxisRaw(string axisName)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			Gamepad current = Gamepad.current;
			if (current == null)
			{
				return 0f;
			}
			switch (axisName)
			{
			case "Camera X":
			case "Mouse X":
			case "Look X":
			case "RightStickJoystick1":
			case "RightStickHorizontal":
				return ControllerSupportPlugin.ProcessStick(((InputControl<Vector2>)(object)current.rightStick).ReadValue(), ControllerSupportPlugin.RightStickDeadzone.Value, ControllerSupportPlugin.RightStickCurve.Value, ControllerSupportPlugin.RightStickExponent.Value).x;
			case "Camera Y":
			case "Mouse Y":
			case "Look Y":
			case "RightStickVertical":
				return ControllerSupportPlugin.ProcessStick(((InputControl<Vector2>)(object)current.rightStick).ReadValue(), ControllerSupportPlugin.RightStickDeadzone.Value, ControllerSupportPlugin.RightStickCurve.Value, ControllerSupportPlugin.RightStickExponent.Value).y;
			case "LeftStickJoystick1":
			case "LeftStickHorizontal":
				return ControllerSupportPlugin.ProcessStick(((InputControl<Vector2>)(object)current.leftStick).ReadValue(), ControllerSupportPlugin.LeftStickDeadzone.Value, ControllerSupportPlugin.LeftStickCurve.Value, ControllerSupportPlugin.LeftStickExponent.Value).x;
			case "LeftStickVertical":
			case "Movement Y":
			case "Vertical":
				return ControllerSupportPlugin.ProcessStick(((InputControl<Vector2>)(object)current.leftStick).ReadValue(), ControllerSupportPlugin.LeftStickDeadzone.Value, ControllerSupportPlugin.LeftStickCurve.Value, ControllerSupportPlugin.LeftStickExponent.Value).y;
			case "Movement X":
			case "Horizontal":
				return ControllerSupportPlugin.ProcessStick(((InputControl<Vector2>)(object)current.leftStick).ReadValue(), ControllerSupportPlugin.LeftStickDeadzone.Value, ControllerSupportPlugin.LeftStickCurve.Value, ControllerSupportPlugin.LeftStickExponent.Value).x;
			case "LeftTriggerJoystick1":
			case "TriggersL1":
				return ControllerSupportPlugin.ProcessTrigger(((InputControl<float>)(object)current.leftTrigger).ReadValue(), ControllerSupportPlugin.LeftTriggerDeadzone.Value);
			case "RightTriggerJoystick1":
			case "TriggersR1":
				return ControllerSupportPlugin.ProcessTrigger(((InputControl<float>)(object)current.rightTrigger).ReadValue(), ControllerSupportPlugin.LeftTriggerDeadzone.Value);
			default:
				return 0f;
			}
		}
	}
	[HarmonyPatch(typeof(Selectable), "OnMove")]
	public static class SelectableOnMovePatch
	{
		[HarmonyPrefix]
		public static bool Prefix(Selectable __instance, AxisEventData eventData)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected I4, but got Unknown
			if (__instance is Slider)
			{
				return true;
			}
			if ((Object)(object)((Component)__instance).GetComponentInParent<ServerListElement>() != (Object)null)
			{
				((BaseEventData)eventData).selectedObject = ((Component)__instance).gameObject;
				((AbstractEventData)eventData).Use();
				return false;
			}
			if (ControllerSupportPlugin._sliderEditMode && __instance is Slider)
			{
				return true;
			}
			string name = ((object)__instance).GetType().Name;
			int num = 0;
			int num2 = 0;
			MoveDirection moveDir = eventData.moveDir;
			switch ((int)moveDir)
			{
			case 0:
				num = -1;
				break;
			case 2:
				num = 1;
				break;
			case 1:
				num2 = 1;
				break;
			case 3:
				num2 = -1;
				break;
			}
			if (name.Contains("OptionsButtonConsoleUGUI") && num != 0 && (Object)(object)((Component)__instance).GetComponent<TMP_Dropdown>() != (Object)null)
			{
				((AbstractEventData)eventData).Use();
				return true;
			}
			if (ControllerSupportPlugin._pendingNavTimer > 0f && (Object)(object)__instance == (Object)(object)ControllerSupportPlugin._pendingNavFocus && num == ControllerSupportPlugin._pendingNavDx && num2 == ControllerSupportPlugin._pendingNavDy)
			{
				((AbstractEventData)eventData).Use();
				return false;
			}
			if (ControllerSupportPlugin._pendingNavTimer > 0f && (Object)(object)__instance == (Object)(object)ControllerSupportPlugin._pendingNavFocus)
			{
				ControllerSupportPlugin._pendingNavTimer = 0f;
				ControllerSupportPlugin._pendingNavFocus = null;
			}
			if ((Object)(object)ControllerSupportPlugin._rebindOverlayCanvas != (Object)null)
			{
				Canvas componentInParent = ((Component)__instance).GetComponentInParent<Canvas>();
				if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent == (Object)(object)ControllerSupportPlugin._rebindOverlayCanvas)
				{
					Selectable val = ControllerSupportPlugin.FindOverlayNeighbor(__instance, num, num2);
					if ((Object)(object)val != (Object)null)
					{
						((BaseEventData)eventData).selectedObject = ((Component)val).gameObject;
						EventSystem current = EventSystem.current;
						if (current != null)
						{
							current.SetSelectedGameObject(((Component)val).gameObject);
						}
						((AbstractEventData)eventData).Use();
						ControllerSupportPlugin.ScrollOverlayToShowElement(val);
						return false;
					}
					((AbstractEventData)eventData).Use();
					return false;
				}
			}
			Selectable val2 = null;
			val2 = ControllerSupportPlugin.FindMenuAwareNeighbor(__instance, num, num2);
			if (ControllerSupportPlugin._navGrid != null)
			{
				val2 = val2 ?? ControllerSupportPlugin._navGrid.FindNeighbor(__instance, num, num2);
			}
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ControllerSupportPlugin.FindNearestByDirection(__instance, num, num2);
			}
			if ((Object)(object)val2 != (Object)null)
			{
				if (ControllerSupportPlugin.IsVoiceChatGameObject(((Component)val2).gameObject))
				{
					ControllerSupportPlugin._voiceChatGuardFrames = 2;
					ControllerSupportPlugin.DisableVoiceChatComponent(((Component)val2).gameObject);
				}
				((BaseEventData)eventData).selectedObject = ((Component)val2).gameObject;
				EventSystem current2 = EventSystem.current;
				if (current2 != null)
				{
					current2.SetSelectedGameObject(((Component)val2).gameObject);
				}
				((AbstractEventData)eventData).Use();
				if (num != 0)
				{
					ControllerSupportPlugin._pendingNavFocus = val2;
					ControllerSupportPlugin._pendingNavTimer = 0.15f;
					ControllerSupportPlugin._navRepeatTimer = 0.4f;
					ControllerSupportPlugin._pendingNavDx = num;
					ControllerSupportPlugin._pendingNavDy = num2;
				}
				return false;
			}
			((AbstractEventData)eventData).Use();
			return false;
		}
	}
	public static class DerivedSliderPatches
	{
		internal static bool DerivedSliderSetValuePrefix(Slider __instance, float value)
		{
			if (ControllerSupportPlugin._sliderEditMode && (Object)(object)__instance == (Object)(object)ControllerSupportPlugin._selectedSlider)
			{
				ControllerSupportPlugin._sliderSetValueGuardCount++;
				if (ControllerSupportPlugin._sliderSetValueGuardCount > 1)
				{
					return false;
				}
			}
			return true;
		}

		internal static void InitializeDerivedSliderPatching()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			try
			{
				Harmony val = new Harmony("com.ttr.controllersupport.derived_sliders");
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					Type[] types = assemblies[i].GetTypes();
					foreach (Type type in types)
					{
						if (!(type == typeof(Slider)) && typeof(Slider).IsAssignableFrom(type))
						{
							MethodInfo method = type.GetMethod("set_value", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);
							if (!(method == null))
							{
								val.Patch((MethodBase)method, new HarmonyMethod(typeof(DerivedSliderPatches).GetMethod("DerivedSliderSetValuePrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] Could not patch derived slider set_value: " + ex.Message));
			}
		}
	}
	internal static class ExecuteMoveHandlerPatch
	{
		private static bool _initialized;

		private static bool _setterPatched;

		internal static void Initialize()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			try
			{
				EventFunction<IMoveHandler> moveHandler = ExecuteEvents.moveHandler;
				if (moveHandler == null)
				{
					ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] ExecuteEvents.moveHandler is null");
					return;
				}
				MethodInfo method = ((Delegate)(object)moveHandler).Method;
				if (method == null)
				{
					ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] moveHandler delegate has no method target");
					return;
				}
				new Harmony("com.ttr.controllersupport.moveHandler").Patch((MethodBase)method, new HarmonyMethod(typeof(ExecuteMoveHandlerPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				PatchVoiceChatSetter();
			}
			catch (Exception ex)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] Could not patch ExecuteEvents moveHandler: " + ex.Message));
			}
		}

		internal static bool Prefix(IMoveHandler handler, BaseEventData eventData)
		{
			if (!(eventData is AxisEventData))
			{
				return true;
			}
			Selectable val = (Selectable)(object)((handler is Selectable) ? handler : null);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			if (!ControllerSupportPlugin.IsVoiceChatGameObject(((Component)val).gameObject))
			{
				return true;
			}
			ControllerSupportPlugin._voiceChatGuardFrames = 2;
			ControllerSupportPlugin.DisableVoiceChatComponent(((Component)val).gameObject);
			((AbstractEventData)eventData).Use();
			return false;
		}

		internal static void PatchVoiceChatSetter()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			if (_setterPatched)
			{
				return;
			}
			try
			{
				Harmony val = new Harmony("com.ttr.controllersupport.voicechat_setter");
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					Type[] types = assemblies[i].GetTypes();
					foreach (Type type in types)
					{
						if (type.Name.Contains("OptionsButtonUGUI"))
						{
							MethodInfo method = type.GetMethod("set_SelectedIndex", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);
							if (method != null)
							{
								val.Patch((MethodBase)method, new HarmonyMethod(typeof(ExecuteMoveHandlerPatch).GetMethod("VoiceChatSelectedIndexPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
								_setterPatched = true;
								ControllerSupportPlugin._voiceChatOptionsButtonType = type;
							}
						}
					}
				}
				if (!_setterPatched)
				{
					ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] Could not find OptionsButtonUGUI type to patch set_SelectedIndex");
				}
			}
			catch (Exception ex)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] Could not patch voice chat setter: " + ex.Message));
			}
		}

		internal static bool VoiceChatSelectedIndexPrefix(int value)
		{
			if (ControllerSupportPlugin._voiceChatGuardFrames > 0)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class OptionsButtonUpdatePatch
	{
		[HarmonyTargetMethod]
		private static MethodBase TargetMethod()
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (type != null)
				{
					break;
				}
				Type[] types = assembly.GetTypes();
				foreach (Type type2 in types)
				{
					if (type2.FullName == "Kamgam.UGUIComponentsForSettings.OptionsButtonUGUI")
					{
						type = type2;
						break;
					}
				}
			}
			if (type == null)
			{
				return null;
			}
			return AccessTools.Method(type, "Update", (Type[])null, (Type[])null);
		}

		[HarmonyPrefix]
		private static bool Prefix(object __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)((Component)__instance).gameObject).name.IndexOf("voiceChat", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				Gamepad current = Gamepad.current;
				if (current != null)
				{
					float num = Mathf.Abs(((InputControl<Vector2>)(object)current.leftStick).ReadValue().x);
					float num2 = Mathf.Abs(((InputControl<Vector2>)(object)current.leftStick).ReadValue().y);
					if (num2 > num * 1.5f && num2 > 0.2f)
					{
						return false;
					}
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EventSystem), "SetSelectedGameObject", new Type[]
	{
		typeof(GameObject),
		typeof(BaseEventData)
	})]
	public static class EventSystemFocusPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(GameObject selected, BaseEventData pointer)
		{
			if (!ControllerSupportPlugin._controllerModeActive)
			{
				return true;
			}
			if (pointer is PointerEventData)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Slider), "Set")]
	public static class SliderSetPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(Slider __instance, float input)
		{
			if (ControllerSupportPlugin._sliderEditMode && (Object)(object)__instance == (Object)(object)ControllerSupportPlugin._selectedSlider)
			{
				ControllerSupportPlugin._sliderSetGuardCount++;
				if (ControllerSupportPlugin._sliderSetGuardCount > 1)
				{
					return false;
				}
				return true;
			}
			if ((Object)(object)__instance == (Object)(object)ControllerSupportPlugin._selectedSlider && !ControllerSupportPlugin._sliderEditMode)
			{
				double num = 0.0;
				if (Keyboard.current != null)
				{
					num = Math.Max(num, ((InputDevice)Keyboard.current).lastUpdateTime);
				}
				if (Mouse.current != null)
				{
					num = Math.Max(num, ((InputDevice)Mouse.current).lastUpdateTime);
				}
				if (Gamepad.current != null && num > ((InputDevice)Gamepad.current).lastUpdateTime)
				{
					return true;
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Slider), "OnMove")]
	public static class SliderOnMovePatch
	{
		[HarmonyPrefix]
		public static bool Prefix(Slider __instance, AxisEventData eventData)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected I4, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected I4, but got Unknown
			if (ControllerSupportPlugin._sliderEditMode)
			{
				((BaseEventData)eventData).selectedObject = ((Component)__instance).gameObject;
				((AbstractEventData)eventData).Use();
				return false;
			}
			MoveDirection moveDir;
			if (ControllerSupportPlugin._pendingNavTimer > 0f && (Object)(object)__instance == (Object)(object)ControllerSupportPlugin._pendingNavFocus)
			{
				int num = 0;
				int num2 = 0;
				moveDir = eventData.moveDir;
				switch ((int)moveDir)
				{
				case 0:
					num = -1;
					break;
				case 2:
					num = 1;
					break;
				case 1:
					num2 = 1;
					break;
				case 3:
					num2 = -1;
					break;
				}
				if (num == ControllerSupportPlugin._pendingNavDx && num2 == ControllerSupportPlugin._pendingNavDy)
				{
					((AbstractEventData)eventData).Use();
					return false;
				}
				ControllerSupportPlugin._pendingNavTimer = 0f;
				ControllerSupportPlugin._pendingNavFocus = null;
			}
			int num3 = 0;
			int num4 = 0;
			moveDir = eventData.moveDir;
			switch ((int)moveDir)
			{
			case 0:
				num3 = -1;
				break;
			case 2:
				num3 = 1;
				break;
			case 1:
				num4 = 1;
				break;
			case 3:
				num4 = -1;
				break;
			}
			Selectable val = null;
			val = ControllerSupportPlugin.FindMenuAwareNeighbor((Selectable)(object)__instance, num3, num4);
			if (ControllerSupportPlugin._navGrid != null)
			{
				val = val ?? ControllerSupportPlugin._navGrid.FindNeighbor((Selectable)(object)__instance, num3, num4);
			}
			if ((Object)(object)val == (Object)null)
			{
				val = ControllerSupportPlugin.FindNearestByDirection((Selectable)(object)__instance, num3, num4);
			}
			if ((Object)(object)val != (Object)null)
			{
				((BaseEventData)eventData).selectedObject = ((Component)val).gameObject;
				EventSystem current = EventSystem.current;
				if (current != null)
				{
					current.SetSelectedGameObject(((Component)val).gameObject);
				}
				((AbstractEventData)eventData).Use();
				if (num3 != 0)
				{
					ControllerSupportPlugin._pendingNavFocus = val;
					ControllerSupportPlugin._pendingNavTimer = 0.15f;
					ControllerSupportPlugin._navRepeatTimer = 0.4f;
					ControllerSupportPlugin._pendingNavDx = num3;
					ControllerSupportPlugin._pendingNavDy = num4;
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ServerListElement), "SetData")]
	public static class ServerListElementSetDataPatch
	{
		[HarmonyPostfix]
		public static void Postfix(ServerListElement __instance)
		{
			MenuController val = Object.FindObjectOfType<MenuController>();
			if ((Object)(object)val != (Object)null)
			{
				ControllerSupportPlugin.HandleServerListElementBound(__instance, val);
			}
		}
	}
	[HarmonyPatch(typeof(MenuController), "OnPlayerWantToJoinLobby")]
	public static class OnPlayerWantToJoinLobbyPatch
	{
		[HarmonyPostfix]
		public static void Postfix(MenuController __instance)
		{
			ControllerSupportPlugin.FocusConfirmPromptDelayed(__instance, "public server join");
		}
	}
	[HarmonyPatch(typeof(MenuController), "OnPlayerConfirmPublicLobbyJoin")]
	public static class OnPlayerConfirmPublicLobbyJoinPatch
	{
		[HarmonyPostfix]
		public static void Postfix(MenuController __instance)
		{
			ControllerSupportPlugin.FocusConfirmPromptDelayed(__instance, "password server join");
		}
	}
	[HarmonyPatch(typeof(MenuController), "RefreshLobbyList")]
	public static class RefreshLobbyListPatch
	{
		[HarmonyPostfix]
		public static void Postfix(MenuController __instance)
		{
			ControllerSupportPlugin.HandleServerListRefreshStarted(__instance);
			((MonoBehaviour)__instance).StartCoroutine(ControllerSupportPlugin.WaitForServerListPopulated(__instance));
		}
	}
	[HarmonyPatch(typeof(SaveListElement), "SetDisplayData")]
	public static class SaveListElementSetDisplayDataPatch
	{
		[HarmonyPostfix]
		public static void Postfix(SaveListElement __instance, MenuController menuController)
		{
			ControllerSupportPlugin.HandleSaveListElementBound(__instance, menuController);
		}
	}
	[HarmonyPatch]
	public static class ToggleActionPatches
	{
		private static MethodBase _targetMethod;

		private static bool _methodResolved;

		private static MethodBase TargetMethod()
		{
			if (_methodResolved)
			{
				return _targetMethod;
			}
			_methodResolved = true;
			Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
			{
				try
				{
					return a.GetTypes();
				}
				catch
				{
					return new Type[0];
				}
			}).FirstOrDefault((Type t) => t.Name == "InputSystemHandler");
			if (type == null)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] InputSystemHandler type not found");
				return null;
			}
			_targetMethod = AccessTools.Method(type, "GetBool", (Type[])null, (Type[])null);
			if (!(_targetMethod != null))
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] InputSystemHandler.GetBool not found");
			}
			return _targetMethod;
		}

		[HarmonyPostfix]
		public static void GetBoolPostfix(string actionName, ref bool __result)
		{
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			Gamepad current = Gamepad.current;
			if (current == null)
			{
				return;
			}
			if (((actionName == "Ragdoll" && current.leftShoulder.isPressed) || (actionName == "Drop" && current.rightShoulder.isPressed)) && (ControllerSupportPlugin.IsGloveRangeAdjustActive() || ControllerSupportPlugin.IsGlovePressingActive() || ControllerSupportPlugin.IsPushHeldForHandRange(current)))
			{
				__result = false;
				return;
			}
			if (ControllerSupportPlugin.IsKeyboardMouseNewerThanGamepad(current))
			{
				ControllerSupportPlugin.ResetSprintToggleForKeyboardMouse();
				return;
			}
			bool num = ControllerSupportPlugin.IsGameplayBlockingUiOpen();
			bool wasPressedThisFrame = current.buttonEast.wasPressedThisFrame;
			bool flag = ControllerSupportPlugin._uiWasOpenLastFrame || ControllerSupportPlugin._bButtonConsumedFrames > 0;
			if (num || ControllerSupportPlugin._bButtonConsumedFrames > 0 || (flag && wasPressedThisFrame && (actionName == "Crouch" || actionName == "Jump")))
			{
				ControllerSupportPlugin.ResetToggleButtonEdges();
				__result = false;
			}
			else if (ControllerSupportPlugin.ToggleCrouch.Value && actionName == "Crouch")
			{
				bool flag2 = ControllerSupportPlugin.ReadBindingPressed(current, "Crouch");
				if (__result && !flag2)
				{
					return;
				}
				if (ControllerSupportPlugin.ShouldBypassCrouchToggle(current))
				{
					__result = ControllerSupportPlugin.ReadBindingPressed(current, "Crouch");
					return;
				}
				if (ControllerSupportPlugin.ConsumeTogglePressEdge(current, "Crouch"))
				{
					ControllerSupportPlugin.CrouchToggled = !ControllerSupportPlugin.CrouchToggled;
				}
				__result = ControllerSupportPlugin.CrouchToggled;
			}
			else
			{
				if (!ControllerSupportPlugin.ToggleSprint.Value || (!(actionName == "Run") && !(actionName == "Sprint")))
				{
					return;
				}
				bool flag3 = ControllerSupportPlugin.ReadBindingPressed(current, "Run");
				bool flag4 = ControllerSupportPlugin.IsGamepadMovementActive(current);
				bool flag5 = ControllerSupportPlugin.ConsumeTogglePressEdge(current, "Run");
				if (!flag3 && !flag5 && !flag4 && !ControllerSupportPlugin.SprintToggled)
				{
					return;
				}
				if (flag5)
				{
					ControllerSupportPlugin.SprintToggled = !ControllerSupportPlugin.SprintToggled;
					ControllerSupportPlugin._movedSinceSprintToggle = false;
				}
				if (ControllerSupportPlugin.SprintToggled)
				{
					Vector2 val = ((InputControl<Vector2>)(object)current.leftStick).ReadValue();
					float magnitude = ((Vector2)(ref val)).magnitude;
					if (magnitude > 0.1f)
					{
						ControllerSupportPlugin._movedSinceSprintToggle = true;
					}
					if (magnitude < 0.05f && ControllerSupportPlugin._prevSprintMoveMag > 0.1f)
					{
						ControllerSupportPlugin.SprintToggled = false;
					}
					if (!flag3 && !ControllerSupportPlugin._movedSinceSprintToggle)
					{
						ControllerSupportPlugin.SprintToggled = false;
					}
					ControllerSupportPlugin._prevSprintMoveMag = magnitude;
				}
				else
				{
					ControllerSupportPlugin._prevSprintMoveMag = 0f;
				}
				__result = __result || (ControllerSupportPlugin.SprintToggled && flag4);
			}
		}
	}
	[HarmonyPatch]
	public static class StaminaPatches
	{
		private static FieldInfo _ranOutField;

		internal static bool _hasMovementInput = true;

		private static FieldInfo RanOutField
		{
			get
			{
				if (_ranOutField == null)
				{
					_ranOutField = AccessTools.Field(typeof(NormalMovement), "ranOutOfStamina");
				}
				return _ranOutField;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(NormalMovement), "ProcessPlanarMovement")]
		public static void ProcessPlanarMovementPrefix(NormalMovement __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 inputMovementReference = ((CharacterState)__instance).CharacterStateController.InputMovementReference;
			_hasMovementInput = ((Vector3)(ref inputMovementReference)).sqrMagnitude >= 0.01f;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(NormalMovement), "ProcessPlanarMovement")]
		public static void ProcessPlanarMovementPostfix(NormalMovement __instance)
		{
			if (ControllerSupportPlugin.ToggleSprint.Value && ControllerSupportPlugin.SprintToggled && ((bool)(RanOutField?.GetValue(__instance) ?? ((object)false)) || ((CharacterState)__instance).CharacterActor.CurrentStamina <= 0f))
			{
				ControllerSupportPlugin.SprintToggled = false;
				ControllerSupportPlugin._movedSinceSprintToggle = false;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CharacterActor), "ExpendStamina")]
		public static bool ExpendStaminaPrefix(CharacterActor __instance)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!_hasMovementInput)
			{
				Vector3 planarVelocity = ((PhysicsActor)__instance).PlanarVelocity;
				if (((Vector3)(ref planarVelocity)).sqrMagnitude < 0.0025f)
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class WallSlideCrouchReleasePatch
	{
		private static MethodBase _targetMethod;

		private static bool _methodResolved;

		private static MethodBase TargetMethod()
		{
			if (_methodResolved)
			{
				return _targetMethod;
			}
			_methodResolved = true;
			Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
			{
				try
				{
					return a.GetTypes();
				}
				catch
				{
					return new Type[0];
				}
			}).FirstOrDefault((Type t) => t.Name == "WallSlide");
			if (type == null)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] WallSlideCrouchReleasePatch: WallSlide type not found");
				return null;
			}
			_targetMethod = AccessTools.Method(type, "CheckExitTransition", (Type[])null, (Type[])null);
			if (!(_targetMethod != null))
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] WallSlideCrouchReleasePatch: CheckExitTransition not found");
			}
			return _targetMethod;
		}

		[HarmonyPrefix]
		public static void Prefix()
		{
			if (ControllerSupportPlugin.ToggleCrouch.Value)
			{
				ControllerSupportPlugin.BlockCrouchToggleUntilRelease(Gamepad.current, "WallSlide.CheckExitTransition", force: true);
			}
		}
	}
	public static class UIPatches
	{
		internal static GameObject lastMenuPanel;

		internal static GameObject lastPlayerPanel;

		private static GameObject lastRebindPanelLogged;

		private static float checkTimer;

		private static void LogTransformTree(Transform t, int depth)
		{
			if (depth > 6)
			{
				return;
			}
			List<string> list = new List<string>();
			Component[] components = ((Component)t).GetComponents<Component>();
			foreach (Component val in components)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((object)val).GetType().Name;
					if (name != "RectTransform" && name != "Transform" && name != "CanvasRenderer")
					{
						list.Add(name);
					}
				}
			}
			for (int j = 0; j < t.childCount; j++)
			{
				LogTransformTree(t.GetChild(j), depth + 1);
			}
		}

		private static void LogAllButtons(Transform t, int depth, int maxDepth)
		{
			if (depth > maxDepth)
			{
				return;
			}
			Button component = ((Component)t).GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				List<string> list = new List<string>();
				Component[] components = ((Component)t).GetComponents<Component>();
				foreach (Component val in components)
				{
					if (!((Object)(object)val == (Object)null))
					{
						string name = ((object)val).GetType().Name;
						if (name != "RectTransform" && name != "Transform" && name != "CanvasRenderer")
						{
							list.Add(name);
						}
					}
				}
				FieldInfo field = typeof(Button).GetField("m_OnClick", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null)
				{
					object? value = field.GetValue(component);
					UnityEvent val2 = (UnityEvent)((value is UnityEvent) ? value : null);
					if (val2 != null)
					{
						FieldInfo field2 = typeof(UnityEventBase).GetField("m_PersistentCalls", BindingFlags.Instance | BindingFlags.NonPublic);
						if (field2 != null)
						{
							object value2 = field2.GetValue(val2);
							PropertyInfo propertyInfo = value2?.GetType().GetProperty("Count");
							int num = ((propertyInfo != null) ? ((int)propertyInfo.GetValue(value2)) : 0);
							_ = $" persistent={num}";
						}
					}
				}
			}
			for (int j = 0; j < t.childCount; j++)
			{
				LogAllButtons(t.GetChild(j), depth + 1, maxDepth);
			}
		}

		private static void ScanForBindingPanels(Transform root)
		{
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				string text = ((Object)child).name.ToLowerInvariant();
				if ((text.Contains("rebind") || text.Contains("binding") || text.Contains("keybind") || text.Contains("remap") || text.Contains("control")) && (Object)(object)child != (Object)(object)lastRebindPanelLogged)
				{
					LogTransformTree(child, 0);
				}
				ScanForBindingPanels(child);
			}
		}

		[HarmonyPatch(typeof(MenuController), "Start")]
		[HarmonyPostfix]
		public static void MenuControllerStartPostfix(MenuController __instance)
		{
			ControllerSupportPlugin.RegisterMenuController(__instance);
			((MonoBehaviour)__instance).StartCoroutine(DelayedMenuFocus(__instance));
			FieldInfo field = typeof(MenuController).GetField("settingsPanel", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				return;
			}
			GameObject panel = default(GameObject);
			ref GameObject reference = ref panel;
			object? value = field.GetValue(__instance);
			reference = (GameObject)((value is GameObject) ? value : null);
			if (!((Object)(object)panel == (Object)null) && !((Object)(object)panel == (Object)(object)lastMenuPanel))
			{
				((MonoBehaviour)__instance).StartCoroutine(DelayedInject(panel, "MenuController", delegate
				{
					lastMenuPanel = panel;
				}, delegate
				{
					ControllerSupportPlugin.HandleMenuPanelActivated(__instance, panel);
				}));
			}
		}

		private static IEnumerator DelayedInject(GameObject panel, string source, Action onComplete, Action afterInject = null)
		{
			yield return null;
			yield return null;
			try
			{
				InjectControllerColumn(panel, source);
				ControllerSupportPlugin.RequestCacheRebuild();
				afterInject?.Invoke();
			}
			catch (Exception arg)
			{
				ControllerSupportPlugin.Logger.LogError((object)$"[ControllerSupport] ({source}) inject failed: {arg}");
			}
			onComplete();
		}

		[HarmonyPatch(typeof(PlayerController), "Update")]
		[HarmonyPostfix]
		public static void PlayerControllerUpdatePostfix(PlayerController __instance)
		{
			checkTimer += Time.deltaTime;
			if (checkTimer < 1f)
			{
				return;
			}
			checkTimer = 0f;
			FieldInfo field = typeof(PlayerController).GetField("settingsPanel", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				return;
			}
			object? value = field.GetValue(__instance);
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			bool activeInHierarchy = val.activeInHierarchy;
			if (activeInHierarchy != ControllerSupportPlugin._lastSettingsVisible)
			{
				ControllerSupportPlugin._lastSettingsVisible = activeInHierarchy;
				ControllerSupportPlugin.RequestCacheRebuild();
			}
			if ((Object)(object)val == (Object)(object)lastPlayerPanel)
			{
				return;
			}
			try
			{
				InjectControllerColumn(val, "PlayerController");
				lastPlayerPanel = val;
				ControllerSupportPlugin.RequestCacheRebuild();
			}
			catch (Exception arg)
			{
				ControllerSupportPlugin.Logger.LogError((object)$"[ControllerSupport] (PlayerController) inject failed: {arg}");
				lastPlayerPanel = val;
			}
		}

		[HarmonyPatch(typeof(MenuController), "ActivatePanel")]
		[HarmonyPostfix]
		public static void ActivatePanelPostfix(MenuController __instance, GameObject panel, bool closeOtherPanels)
		{
			ControllerSupportPlugin.HandleMenuPanelActivated(__instance, panel);
			((MonoBehaviour)__instance).StartCoroutine(DelayedMenuFocus(__instance));
		}

		private static IEnumerator DelayedMenuFocus(MenuController menuController)
		{
			yield return null;
			yield return null;
			ControllerSupportPlugin.HandleMenuPanelActivated(menuController, null);
		}

		[HarmonyPatch(typeof(PlayerController), "OpenUIPanel")]
		[HarmonyPostfix]
		public static void OpenUIPanelPostfix(PlayerController __instance)
		{
			if (ControllerSupportPlugin.IsPlayerControllerUiOpen(__instance))
			{
				ControllerSupportPlugin._uiPanelOpenCount = 1;
				ControllerSupportPlugin.RequestCacheRebuild();
			}
		}

		[HarmonyPatch(typeof(PlayerController), "CloseUIPanel")]
		[HarmonyPostfix]
		public static void CloseUIPanelPostfix(PlayerController __instance)
		{
			ControllerSupportPlugin._uiPanelOpenCount = (ControllerSupportPlugin.IsPlayerControllerUiOpen(__instance) ? Math.Max(0, ControllerSupportPlugin._uiPanelOpenCount - 1) : 0);
			ControllerSupportPlugin.RequestCacheRebuild();
		}

		private static void InjectControllerColumn(GameObject settingsPanel, string source)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Expected O, but got Unknown
			//IL_0861: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Expected O, but got Unknown
			RectTransform component = settingsPanel.GetComponent<RectTransform>();
			Rect rect;
			if ((Object)(object)component != (Object)null)
			{
				rect = component.rect;
				float width = ((Rect)(ref rect)).width;
				float num = 1900f;
				if (width < num && source == "MenuController")
				{
					float num2 = num - width;
					component.sizeDelta = new Vector2(component.sizeDelta.x + num2, component.sizeDelta.y);
					ScrollRect componentInParent = settingsPanel.GetComponentInParent<ScrollRect>(true);
					if ((Object)(object)componentInParent != (Object)null)
					{
						RectTransform component2 = ((Component)componentInParent).GetComponent<RectTransform>();
						if ((Object)(object)component2 != (Object)null)
						{
							rect = component2.rect;
							if (((Rect)(ref rect)).width < num)
							{
								component2.sizeDelta = new Vector2(component2.sizeDelta.x + num2, component2.sizeDelta.y);
							}
						}
					}
					Transform parent = settingsPanel.transform.parent;
					while ((Object)(object)parent != (Object)null)
					{
						RectTransform component3 = ((Component)parent).GetComponent<RectTransform>();
						if ((Object)(object)component3 != (Object)null)
						{
							rect = component3.rect;
							if (((Rect)(ref rect)).width > 0f)
							{
								rect = component3.rect;
								if (((Rect)(ref rect)).width < num && ((Object)(object)((Component)parent).GetComponent<RectMask2D>() != (Object)null || (Object)(object)((Component)parent).GetComponent<Mask>() != (Object)null))
								{
									component3.sizeDelta = new Vector2(component3.sizeDelta.x + num2, component3.sizeDelta.y);
								}
							}
						}
						parent = parent.parent;
					}
				}
			}
			Transform val = null;
			Transform val2 = null;
			int num3 = -1;
			int num4 = -1;
			for (int i = 0; i < settingsPanel.transform.childCount; i++)
			{
				Transform child = settingsPanel.transform.GetChild(i);
				if (((Object)child).name == "VOIP")
				{
					val = child;
					num3 = i;
				}
				if (((Object)child).name == "GameSettings")
				{
					val2 = child;
					num4 = i;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] (" + source + ") VOIP not found."));
				return;
			}
			GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject, settingsPanel.transform);
			((Object)val3).name = "ControllerSettings";
			if (num4 >= 0)
			{
				val3.transform.SetSiblingIndex(num4);
			}
			else if (num3 >= 0)
			{
				val3.transform.SetSiblingIndex(num3 + 1);
			}
			RectTransform component4 = ((Component)val).GetComponent<RectTransform>();
			RectTransform component5 = val3.GetComponent<RectTransform>();
			if ((Object)(object)component4 != (Object)null && (Object)(object)component5 != (Object)null)
			{
				component5.anchorMin = component4.anchorMin;
				component5.anchorMax = component4.anchorMax;
				component5.pivot = component4.pivot;
				component5.sizeDelta = component4.sizeDelta;
				rect = component4.rect;
				float width2 = ((Rect)(ref rect)).width;
				float num5 = 15f;
				component5.anchoredPosition = new Vector2(component4.anchoredPosition.x + width2 + num5, component4.anchoredPosition.y);
			}
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).GetComponent<RectTransform>();
			}
			Transform val4 = val3.transform.Find("Settings");
			if ((Object)(object)val4 == (Object)null && val3.transform.childCount > 0)
			{
				val4 = val3.transform.GetChild(0);
			}
			if ((Object)(object)val4 == (Object)null)
			{
				ControllerSupportPlugin.Logger.LogError((object)("[ControllerSupport] (" + source + ") No content container in cloned VOIP."));
				return;
			}
			Component val5 = null;
			GameObject val6 = null;
			Component val7 = null;
			if ((Object)(object)val2 != (Object)null)
			{
				val5 = FindComponentByTypeName(val2, "ToggleUGUI");
				val7 = FindComponentByTypeName(val2, "SliderUGUI");
				foreach (Transform item in val2)
				{
					Transform val8 = item;
					for (int j = 0; j < val8.childCount && !((Object)val8.GetChild(j)).name.Contains("SGHeadlineUGUI"); j++)
					{
					}
					if ((Object)(object)val6 != (Object)null)
					{
						break;
					}
				}
			}
			if ((Object)(object)val5 == (Object)null)
			{
				val5 = FindComponentByTypeName(val4, "ToggleUGUI");
			}
			if ((Object)(object)val6 == (Object)null)
			{
				for (int k = 0; k < val4.childCount; k++)
				{
					if (((Object)val4.GetChild(k)).name.Contains("SGHeadlineUGUI"))
					{
						val6 = ((Component)val4.GetChild(k)).gameObject;
						break;
					}
				}
			}
			List<GameObject> list = new List<GameObject>();
			for (int l = 0; l < val4.childCount; l++)
			{
				list.Add(((Component)val4.GetChild(l)).gameObject);
			}
			foreach (GameObject item2 in list)
			{
				Object.DestroyImmediate((Object)(object)item2);
			}
			if ((Object)(object)val6 != (Object)null)
			{
				GameObject obj = Object.Instantiate<GameObject>(val6, val4);
				((Object)obj).name = "SGHeadlineUGUI (Controller)";
				StripLocalization(obj);
				TextMeshProUGUI componentInChildren = obj.GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)componentInChildren).text = "Controller";
				}
			}
			if ((Object)(object)val5 != (Object)null)
			{
				AddClonedToggle(val4, val5.gameObject, "Toggle Crouch", ControllerSupportPlugin.ToggleCrouch.Value, delegate(bool value3)
				{
					ControllerSupportPlugin.ToggleCrouch.Value = value3;
					ControllerSupportPlugin.CrouchToggled = false;
				});
				AddClonedToggle(val4, val5.gameObject, "Toggle Sprint", ControllerSupportPlugin.ToggleSprint.Value, delegate(bool value3)
				{
					ControllerSupportPlugin.ToggleSprint.Value = value3;
					ControllerSupportPlugin.SprintToggled = false;
				});
				AddClonedToggle(val4, val5.gameObject, "Invert Look Y", ControllerSupportPlugin.InvertLookY.Value, delegate(bool value3)
				{
					ControllerSupportPlugin.InvertLookY.Value = value3;
					ControllerSupportPlugin.UpdateBindingProcessors();
				});
			}
			if ((Object)(object)val7 != (Object)null)
			{
				AddClonedSlider(val4, val7.gameObject, "Left Stick Deadzone", ControllerSupportPlugin.LeftStickDeadzone.Value, 0f, 0.3f, delegate(float value3)
				{
					ControllerSupportPlugin.LeftStickDeadzone.Value = value3;
					ControllerSupportPlugin.UpdateBindingProcessors();
				}, 0.01f);
				AddClonedSlider(val4, val7.gameObject, "Right Stick Deadzone", ControllerSupportPlugin.RightStickDeadzone.Value, 0f, 0.3f, delegate(float value3)
				{
					ControllerSupportPlugin.RightStickDeadzone.Value = value3;
					ControllerSupportPlugin.UpdateBindingProcessors();
				}, 0.01f);
				AddClonedSlider(val4, val7.gameObject, "Look Sensitivity", ControllerSupportPlugin.LookSensitivity.Value, 0.1f, 10f, delegate(float value3)
				{
					ControllerSupportPlugin.LookSensitivity.Value = value3;
					ControllerSupportPlugin.UpdateBindingProcessors();
				}, 0.1f);
			}
			GameObject val9 = null;
			for (int num6 = 0; num6 < settingsPanel.transform.childCount; num6++)
			{
				Transform child2 = settingsPanel.transform.GetChild(num6);
				if (((Object)child2).name.Contains("BUtton") || ((Object)child2).name.Contains("Button"))
				{
					Button componentInChildren2 = ((Component)child2).GetComponentInChildren<Button>(true);
					if ((Object)(object)componentInChildren2 != (Object)null)
					{
						val9 = ((Component)componentInChildren2).gameObject;
						break;
					}
				}
			}
			if ((Object)(object)val9 != (Object)null)
			{
				GameObject obj2 = Object.Instantiate<GameObject>(val9, val4);
				((Object)obj2).name = "RemapButton";
				StripLocalization(obj2);
				TextMeshProUGUI componentInChildren3 = obj2.GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren3 != (Object)null)
				{
					((TMP_Text)componentInChildren3).text = "REMAP";
				}
				Button componentInChildren4 = obj2.GetComponentInChildren<Button>(true);
				if ((Object)(object)componentInChildren4 != (Object)null)
				{
					FieldInfo field = typeof(Button).GetField("m_OnClick", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field != null)
					{
						object? value = field.GetValue(componentInChildren4);
						UnityEvent val10 = (UnityEvent)((value is UnityEvent) ? value : null);
						if (val10 != null)
						{
							FieldInfo field2 = typeof(UnityEventBase).GetField("m_PersistentCalls", BindingFlags.Instance | BindingFlags.NonPublic);
							if (field2 != null)
							{
								object value2 = field2.GetValue(val10);
								(value2?.GetType().GetMethod("Clear"))?.Invoke(value2, null);
							}
						}
					}
					((UnityEventBase)componentInChildren4.onClick).RemoveAllListeners();
					((UnityEvent)componentInChildren4.onClick).AddListener((UnityAction)delegate
					{
						RebindUI.Show(settingsPanel.transform);
					});
				}
			}
			else
			{
				ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] (" + source + ") No button template found for REMAP button."));
			}
			TMP_Dropdown val11 = null;
			for (int num7 = 0; num7 < settingsPanel.transform.childCount; num7++)
			{
				TMP_Dropdown componentInChildren5 = ((Component)settingsPanel.transform.GetChild(num7)).GetComponentInChildren<TMP_Dropdown>(true);
				if ((Object)(object)componentInChildren5 != (Object)null)
				{
					val11 = componentInChildren5;
					break;
				}
			}
			if ((Object)(object)val11 == (Object)null)
			{
				val11 = settingsPanel.GetComponentInChildren<TMP_Dropdown>(true);
			}
			if ((Object)(object)val11 != (Object)null)
			{
				AddCurveDropdown(val4, ((Component)val11).gameObject, "Right Stick Curve", ControllerSupportPlugin.RightStickCurve.Value, delegate(ControllerSupportPlugin.ResponseCurveType curve)
				{
					ControllerSupportPlugin.RightStickCurve.Value = curve;
				});
			}
			else
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] No TMP_Dropdown template found in settings panel for curve dropdowns.");
			}
		}

		private static void BuildColumnNavigation(Transform colContent)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			List<Selectable> list = new List<Selectable>();
			Selectable[] componentsInChildren = ((Component)colContent).GetComponentsInChildren<Selectable>(true);
			foreach (Selectable val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					list.Add(val);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				Navigation navigation = list[j].navigation;
				((Navigation)(ref navigation)).mode = (Mode)3;
				((Navigation)(ref navigation)).selectOnUp = ((j > 0) ? list[j - 1] : null);
				((Navigation)(ref navigation)).selectOnDown = ((j < list.Count - 1) ? list[j + 1] : null);
				list[j].navigation = navigation;
			}
		}

		private static void StripLocalization(GameObject obj)
		{
			Component[] componentsInChildren = obj.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string text = ((object)val).GetType().Name ?? "";
					if (text.Contains("Localiz") || text.Contains("Resolver"))
					{
						Object.DestroyImmediate((Object)(object)val);
					}
				}
			}
		}

		private static Component FindComponentByTypeName(Transform root, string typeName)
		{
			Component[] componentsInChildren = ((Component)root).GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && ((object)val).GetType().Name == typeName)
				{
					return val;
				}
			}
			return null;
		}

		private static void AddClonedToggle(Transform parent, GameObject template, string label, bool value, Action<bool> onChanged)
		{
			GameObject obj = Object.Instantiate<GameObject>(template, parent);
			((Object)obj).name = "ToggleUGUI (" + label.Replace(" ", "") + ")";
			StripLocalization(obj);
			TextMeshProUGUI componentInChildren = obj.GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((TMP_Text)componentInChildren).text = label;
			}
			Toggle component = obj.GetComponent<Toggle>();
			if ((Object)(object)component != (Object)null)
			{
				component.isOn = value;
				((UnityEventBase)component.onValueChanged).RemoveAllListeners();
				((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)onChanged.Invoke);
			}
		}

		private static void AddClonedSlider(Transform parent, GameObject template, string label, float value, float min, float max, Action<float> onChanged, float step = 0f)
		{
			GameObject obj = Object.Instantiate<GameObject>(template, parent);
			((Object)obj).name = "SliderUGUI (" + label.Replace(" ", "") + ")";
			StripLocalization(obj);
			TextMeshProUGUI[] componentsInChildren = obj.GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (((Object)val).name == "Label" || ((Object)val).name.Contains("Label"))
				{
					((TMP_Text)val).text = label;
					break;
				}
			}
			Slider componentInChildren = obj.GetComponentInChildren<Slider>(true);
			if (!((Object)(object)componentInChildren != (Object)null))
			{
				return;
			}
			if (step > 0f)
			{
				int num = Mathf.RoundToInt((max - min) / step);
				componentInChildren.minValue = 0f;
				componentInChildren.maxValue = num;
				componentInChildren.wholeNumbers = true;
				int num2 = Mathf.RoundToInt((value - min) / step);
				componentInChildren.value = num2;
			}
			else
			{
				componentInChildren.minValue = min;
				componentInChildren.maxValue = max;
				componentInChildren.value = value;
			}
			((UnityEventBase)componentInChildren.onValueChanged).RemoveAllListeners();
			componentsInChildren = obj.GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val2 in componentsInChildren)
			{
				if (((Object)val2).name == "ValueTf" || ((Object)val2).name.Contains("Value"))
				{
					((TMP_Text)val2).text = value.ToString("F2");
					break;
				}
			}
			((UnityEvent<float>)(object)componentInChildren.onValueChanged).AddListener((UnityAction<float>)delegate(float rawVal)
			{
				float obj2 = ((step > 0f) ? (min + Mathf.Round(rawVal) * step) : rawVal);
				onChanged(obj2);
				TextMeshProUGUI[] componentsInChildren2 = obj.GetComponentsInChildren<TextMeshProUGUI>(true);
				foreach (TextMeshProUGUI val3 in componentsInChildren2)
				{
					if (((Object)val3).name == "ValueTf" || ((Object)val3).name.Contains("Value"))
					{
						((TMP_Text)val3).text = obj2.ToString("F2");
						break;
					}
				}
			});
		}

		private static void AddCurveDropdown(Transform parent, GameObject template, string label, ControllerSupportPlugin.ResponseCurveType currentValue, Action<ControllerSupportPlugin.ResponseCurveType> onChanged)
		{
			GameObject val = Object.Instantiate<GameObject>(template, parent);
			((Object)val).name = "CurveDropdown (" + label.Replace(" ", "") + ")";
			StripLocalization(val);
			TMP_Dropdown componentInChildren = val.GetComponentInChildren<TMP_Dropdown>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				ControllerSupportPlugin.Logger.LogError((object)"[ControllerSupport] AddCurveDropdown: no TMP_Dropdown found on cloned object");
				return;
			}
			TextMeshProUGUI val2 = null;
			TextMeshProUGUI val3 = null;
			TextMeshProUGUI[] componentsInChildren = val.GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val4 in componentsInChildren)
			{
				if (((TMP_Text)val4).transform.IsChildOf(((Component)componentInChildren).transform))
				{
					val2 = val4;
				}
				else if (((Object)val4).name.Contains("Label") || ((Object)val4).name.Contains("Text"))
				{
					val3 = val4;
				}
			}
			if ((Object)(object)val3 != (Object)null)
			{
				((TMP_Text)val3).text = label;
			}
			else
			{
				_ = (Object)(object)val2 != (Object)null;
			}
			componentInChildren.ClearOptions();
			string[] names = Enum.GetNames(typeof(ControllerSupportPlugin.ResponseCurveType));
			componentInChildren.AddOptions(new List<string>(names));
			componentInChildren.value = (int)currentValue;
			componentInChildren.RefreshShownValue();
			((UnityEventBase)componentInChildren.onValueChanged).RemoveAllListeners();
			Component[] componentsInChildren2 = val.GetComponentsInChildren<Component>(true);
			foreach (Component val5 in componentsInChildren2)
			{
				if (!((Object)(object)val5 == (Object)null))
				{
					string text = ((object)val5).GetType().Name ?? "";
					if (text.Contains("Localiz") || text.Contains("Resolver") || text.Contains("Translation"))
					{
						Object.DestroyImmediate((Object)(object)val5);
					}
				}
			}
			((UnityEvent<int>)(object)componentInChildren.onValueChanged).AddListener((UnityAction<int>)delegate(int idx)
			{
				onChanged((ControllerSupportPlugin.ResponseCurveType)idx);
			});
		}
	}
	[HarmonyPatch(typeof(NormalMovement), "ProcessJump")]
	public static class ProcessJumpPatch
	{
		[HarmonyPrefix]
		public static bool Prefix()
		{
			if (ControllerSupportPlugin._papyrusOpen)
			{
				Gamepad current = Gamepad.current;
				if (current != null && current.buttonSouth.wasPressedThisFrame && ControllerSupportPlugin._taskListSelectedIndex >= 0 && ControllerSupportPlugin._taskListSelectedIndex < ControllerSupportPlugin._cachedTaskElements.Count && !ControllerSupportPlugin._infoOverlayOpen)
				{
					PlayerTaskElement item = ControllerSupportPlugin._cachedTaskElements[ControllerSupportPlugin._taskListSelectedIndex].element;
					if ((Object)(object)item != (Object)null)
					{
						item.OnPointerClick((PointerEventData)null);
						ControllerSupportPlugin._papyrusAPressFrame = Time.frameCount;
					}
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EquipmentController), "TogglePapyrusRpc")]
	public static class TogglePapyrusRpcPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(bool enabled)
		{
			if (enabled)
			{
				return true;
			}
			int frameCount = Time.frameCount;
			if (ControllerSupportPlugin._papyrusAPressFrame == frameCount && !ControllerSupportPlugin.WasKeyboardMousePapyrusReleaseThisFrame())
			{
				return false;
			}
			if (ControllerSupportPlugin._infoOverlayOpen)
			{
				if (ControllerSupportPlugin.WasKeyboardMousePapyrusReleaseThisFrame())
				{
					ControllerSupportPlugin.CloseMouseOpenedOverlayForPapyrusRelease();
					return true;
				}
				if (!ControllerSupportPlugin._overlayClosedByRelease)
				{
					return false;
				}
			}
			if (ControllerSupportPlugin._overlayClosedByRelease)
			{
				ControllerSupportPlugin._overlayClosedByRelease = false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerTaskElement), "OnPointerClick", new Type[] { typeof(PointerEventData) })]
	public static class TaskElementClickPatch
	{
		[HarmonyPrefix]
		public static void Prefix(PointerEventData eventData)
		{
			ControllerSupportPlugin._papyrusAPressFrame = Time.frameCount;
			ControllerSupportPlugin._mouseOpenedInfoOverlay = eventData != null;
		}
	}
	public static class StockRebindingIntegration
	{
		private static bool gamepadBindingsInjected;

		public static void ToggleStockRebindingPanel(GameObject settingsPanel)
		{
			Transform val = FindChildRecursive(settingsPanel.transform, "Rebinding");
			if ((Object)(object)val == (Object)null)
			{
				val = FindChildRecursive(settingsPanel.transform.root, "Rebinding");
			}
			if ((Object)(object)val == (Object)null)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] Rebinding panel not found anywhere.");
				return;
			}
			if (!gamepadBindingsInjected)
			{
				InjectGamepadBindings(val, settingsPanel);
				gamepadBindingsInjected = true;
			}
			bool activeSelf = ((Component)val).gameObject.activeSelf;
			((Component)val).gameObject.SetActive(!activeSelf);
		}

		private static Transform FindChildRecursive(Transform parent, string namePrefix)
		{
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if (((Object)child).name.StartsWith(namePrefix))
				{
					return child;
				}
				Transform val = FindChildRecursive(child, namePrefix);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static Transform FindContentWithInputBindings(Transform parent)
		{
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				for (int j = 0; j < child.childCount; j++)
				{
					if (((Object)child.GetChild(j)).name.StartsWith("InputBindingUGUI"))
					{
						return child;
					}
				}
				Transform val = FindContentWithInputBindings(child);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static void InjectGamepadBindings(Transform rebindingPanel, GameObject settingsPanel)
		{
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_06a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Expected O, but got Unknown
			for (int i = 0; i < rebindingPanel.childCount; i++)
			{
				Transform child = rebindingPanel.GetChild(i);
				List<string> list = new List<string>();
				Component[] components = ((Component)child).GetComponents<Component>();
				foreach (Component val in components)
				{
					if (!((Object)(object)val == (Object)null))
					{
						list.Add(((object)val).GetType().Name);
					}
				}
			}
			Transform content = FindContentWithInputBindings(rebindingPanel);
			if ((Object)(object)content == (Object)null)
			{
				ControllerSupportPlugin.Logger.LogError((object)"[ControllerSupport] Could not find InputBindingUGUI content container in Rebinding panel.");
				return;
			}
			GameObject val2 = null;
			for (int k = 0; k < content.childCount; k++)
			{
				if (((Object)content.GetChild(k)).name.StartsWith("InputBindingUGUI"))
				{
					val2 = ((Component)content.GetChild(k)).gameObject;
					break;
				}
			}
			if ((Object)(object)val2 == (Object)null)
			{
				ControllerSupportPlugin.Logger.LogError((object)"[ControllerSupport] No InputBindingUGUI template found in Rebinding panel.");
				return;
			}
			GameObject val3 = null;
			Transform val4 = null;
			for (int l = 0; l < settingsPanel.transform.childCount; l++)
			{
				if (((Object)settingsPanel.transform.GetChild(l)).name == "GameSettings")
				{
					val4 = settingsPanel.transform.GetChild(l);
					break;
				}
			}
			if ((Object)(object)val4 != (Object)null)
			{
				foreach (Transform item3 in val4)
				{
					Transform val5 = item3;
					for (int m = 0; m < val5.childCount; m++)
					{
						if (((Object)val5.GetChild(m)).name.Contains("SGHeadlineUGUI"))
						{
							val3 = ((Component)val5.GetChild(m)).gameObject;
							break;
						}
					}
					if ((Object)(object)val3 != (Object)null)
					{
						break;
					}
				}
			}
			if ((Object)(object)val3 != (Object)null)
			{
				GameObject val6 = Object.Instantiate<GameObject>(val3, content);
				((Object)val6).name = "SGHeadlineUGUI (Gamepad)";
				Component[] components = val6.GetComponentsInChildren<Component>(true);
				foreach (Component val7 in components)
				{
					if (!((Object)(object)val7 == (Object)null))
					{
						string text = ((object)val7).GetType().Name ?? "";
						if (text.Contains("Localiz") || text.Contains("Resolver"))
						{
							Object.DestroyImmediate((Object)(object)val7);
						}
					}
				}
				TextMeshProUGUI componentInChildren = val6.GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)componentInChildren).text = "Controller";
				}
			}
			(string, string)[] obj = new(string, string)[14]
			{
				("Jump", "<Gamepad>/buttonSouth"),
				("Crouch", "<Gamepad>/buttonEast"),
				("Interact", "<Gamepad>/buttonWest"),
				("Push To Talk", "<Gamepad>/buttonNorth"),
				("Run", "<Gamepad>/leftStickPress"),
				("Ragdoll", "<Gamepad>/leftShoulder"),
				("Drop", "<Gamepad>/rightShoulder"),
				("Push", "<Gamepad>/leftTrigger"),
				("Attack", "<Gamepad>/rightTrigger"),
				("Inventory", "<Gamepad>/select"),
				("Item1", "<Gamepad>/dpad/up"),
				("Item2", "<Gamepad>/dpad/right"),
				("Item3", "<Gamepad>/dpad/down"),
				("Item4", "<Gamepad>/dpad/left")
			};
			int num = 0;
			(string, string)[] array = obj;
			for (int j = 0; j < array.Length; j++)
			{
				(string, string) tuple = array[j];
				string item = tuple.Item1;
				string item2 = tuple.Item2;
				GameObject row = Object.Instantiate<GameObject>(val2, content);
				((Object)row).name = "InputBindingUGUI (Gamepad_" + item + ")";
				Component[] components = row.GetComponents<Component>();
				foreach (Component val8 in components)
				{
					if (!((Object)(object)val8 == (Object)null))
					{
						string text2 = ((object)val8).GetType().Name ?? "";
						if (text2.Contains("InputBinding") || text2.Contains("Resolver"))
						{
							Object.DestroyImmediate((Object)(object)val8);
						}
					}
				}
				Transform val9 = row.transform.Find("ButtonDefaultUGUI (VisualsOnly)/Label");
				if ((Object)(object)val9 != (Object)null)
				{
					TextMeshProUGUI component = ((Component)val9).GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component != (Object)null)
					{
						((TMP_Text)component).text = item;
					}
				}
				components = row.GetComponentsInChildren<Component>(true);
				foreach (Component val10 in components)
				{
					if (!((Object)(object)val10 == (Object)null) && (((object)val10).GetType().Name ?? "").Contains("Localiz"))
					{
						Object.DestroyImmediate((Object)(object)val10);
					}
				}
				ControllerSupportPlugin.RuntimeBindings.TryGetValue(item, out var value);
				Transform val11 = row.transform.Find("KeyWithTextNormal/KeyNameTf");
				if ((Object)(object)val11 != (Object)null)
				{
					TextMeshProUGUI component2 = ((Component)val11).GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component2 != (Object)null)
					{
						((TMP_Text)component2).text = PrettyGamepadPath(value ?? item2);
					}
				}
				Transform val12 = row.transform.Find("KeyWithTextActive/ActiveTextTf");
				if ((Object)(object)val12 != (Object)null)
				{
					TextMeshProUGUI component3 = ((Component)val12).GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component3 != (Object)null)
					{
						((TMP_Text)component3).text = PrettyGamepadPath(value ?? item2);
					}
				}
				Button component4 = row.GetComponent<Button>();
				if ((Object)(object)component4 != (Object)null)
				{
					FieldInfo field = typeof(Button).GetField("m_OnClick", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field != null)
					{
						object? value2 = field.GetValue(component4);
						UnityEvent val13 = (UnityEvent)((value2 is UnityEvent) ? value2 : null);
						if (val13 != null)
						{
							FieldInfo field2 = typeof(UnityEventBase).GetField("m_PersistentCalls", BindingFlags.Instance | BindingFlags.NonPublic);
							if (field2 != null)
							{
								object value3 = field2.GetValue(val13);
								value3?.GetType().GetMethod("Clear")?.Invoke(value3, null);
							}
						}
					}
					((UnityEventBase)component4.onClick).RemoveAllListeners();
					string capturedAction = item;
					string capturedDefault = item2;
					((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
					{
						RebindUI.StartGamepadRebind(content, capturedAction, capturedDefault, row);
					});
				}
				num++;
			}
		}

		internal static string PrettyGamepadPath(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return "—";
			}
			if (path.StartsWith("<Gamepad>/"))
			{
				path = path.Substring("<Gamepad>/".Length);
			}
			return path switch
			{
				"buttonSouth" => "A", 
				"buttonEast" => "B", 
				"buttonWest" => "X", 
				"buttonNorth" => "Y", 
				"leftShoulder" => "LB", 
				"rightShoulder" => "RB", 
				"leftTrigger" => "LT", 
				"rightTrigger" => "RT", 
				"leftStickPress" => "L3", 
				"rightStickPress" => "R3", 
				"dpad/up" => "D-Up", 
				"dpad/right" => "D-Right", 
				"dpad/down" => "D-Down", 
				"dpad/left" => "D-Left", 
				"select" => "Select", 
				"start" => "Start", 
				_ => path, 
			};
		}
	}
	public static class RebindUI
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<string, bool> <>9__11_0;

			public static UnityAction <>9__11_2;

			public static UnityAction <>9__11_3;

			public static Func<string, bool> <>9__12_0;

			public static Func<string, bool> <>9__18_0;

			public static Func<string, bool> <>9__18_1;

			public static Func<string, bool> <>9__30_0;

			public static Func<string, bool> <>9__32_0;

			internal bool <CreateOverlay>b__11_0(string n)
			{
				return n.Contains("SGButton");
			}

			internal void <CreateOverlay>b__11_2()
			{
				Close();
			}

			internal void <CreateOverlay>b__11_3()
			{
				Close();
			}

			internal bool <FindInputBindingTemplate>b__12_0(string n)
			{
				return n.StartsWith("InputBindingUGUI");
			}

			internal bool <CreateStockStyledRow>b__18_0(string n)
			{
				return n.Contains("ButtonDefaultUGUI");
			}

			internal bool <CreateStockStyledRow>b__18_1(string n)
			{
				return n == "Label";
			}

			internal bool <CreateStockButton>b__30_0(string n)
			{
				if (!(n == "Label") && !(n == "Text"))
				{
					return n == "Label (TMP)";
				}
				return true;
			}

			internal bool <FindRedCloseButton>b__32_0(string n)
			{
				if (!n.ToLowerInvariant().Contains("close"))
				{
					return n.ToLowerInvariant().Contains("back");
				}
				return true;
			}
		}

		private static GameObject overlay;

		private static GameObject listeningOverlay;

		private static int currentRebindingIndex = -1;

		private static IEnumerator rebindCoroutine;

		private static bool _dumpedHierarchy = false;

		internal static bool IsListeningForRebind { get; private set; }

		public static void Show(Transform parent)
		{
			if ((Object)(object)overlay != (Object)null)
			{
				Close();
			}
			else
			{
				CreateOverlay(parent);
			}
		}

		public static void StartGamepadRebind(Transform parent, string actionName, string defaultPath, GameObject row)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			if (rebindCoroutine != null)
			{
				MonoBehaviour val = ((Component)parent).GetComponentInParent<MonoBehaviour>();
				if ((Object)(object)val == (Object)null)
				{
					EventSystem current = EventSystem.current;
					if ((Object)(object)current != (Object)null)
					{
						val = (MonoBehaviour)(object)current;
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					try
					{
						val.StopCoroutine(rebindCoroutine);
					}
					catch
					{
					}
				}
				rebindCoroutine = null;
			}
			TextMeshProUGUI bindingLabel = null;
			Transform val2 = row.transform.Find("KeyWithTextNormal/KeyNameTf");
			if ((Object)(object)val2 != (Object)null)
			{
				bindingLabel = ((Component)val2).GetComponent<TextMeshProUGUI>();
			}
			TextMeshProUGUI activeLabel = null;
			Transform val3 = row.transform.Find("KeyWithTextActive/ActiveTextTf");
			if ((Object)(object)val3 != (Object)null)
			{
				activeLabel = ((Component)val3).GetComponent<TextMeshProUGUI>();
			}
			if ((Object)(object)listeningOverlay != (Object)null)
			{
				Object.Destroy((Object)(object)listeningOverlay);
			}
			listeningOverlay = new GameObject("ListeningOverlay", new Type[1] { typeof(RectTransform) });
			listeningOverlay.transform.SetParent(parent.root, false);
			RectTransform component = listeningOverlay.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(500f, 100f);
			((Graphic)listeningOverlay.AddComponent<Image>()).color = new Color(0.1f, 0.2f, 0.3f, 0.95f);
			GameObject val4 = new GameObject("Text", new Type[1] { typeof(TextMeshProUGUI) });
			val4.transform.SetParent(listeningOverlay.transform, false);
			TextMeshProUGUI component2 = val4.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component2).text = "Press a button for '" + actionName + "'\n(Escape to cancel)";
			((TMP_Text)component2).fontSize = 18f;
			((TMP_Text)component2).alignment = (TextAlignmentOptions)514;
			RectTransform component3 = val4.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.sizeDelta = Vector2.zero;
			MonoBehaviour val5 = ((Component)parent).GetComponentInParent<MonoBehaviour>();
			if ((Object)(object)val5 == (Object)null)
			{
				EventSystem current2 = EventSystem.current;
				if ((Object)(object)current2 != (Object)null)
				{
					val5 = (MonoBehaviour)(object)current2;
				}
			}
			if ((Object)(object)val5 != (Object)null)
			{
				IsListeningForRebind = true;
				rebindCoroutine = ListenForGamepadInput(actionName, bindingLabel, activeLabel);
				val5.StartCoroutine(rebindCoroutine);
			}
		}

		private static IEnumerator ListenForGamepadInput(string actionName, TextMeshProUGUI bindingLabel, TextMeshProUGUI activeLabel)
		{
			float timeout = 10f;
			float elapsed = 0f;
			yield return null;
			yield return null;
			try
			{
				while (elapsed < timeout)
				{
					if (Input.GetKeyDown((KeyCode)27))
					{
						CloseListening();
						break;
					}
					Gamepad current = Gamepad.current;
					if (current != null)
					{
						string pressedControlPath = GetPressedControlPath(current);
						if (pressedControlPath != null)
						{
							ControllerSupportPlugin.RuntimeBindings[actionName] = pressedControlPath;
							ControllerSupportPlugin.SaveBindings();
							UpdateActionAsset(actionName, pressedControlPath);
							foreach (KeyValuePair<string, string> runtimeBinding in ControllerSupportPlugin.RuntimeBindings)
							{
								if (runtimeBinding.Key != actionName && runtimeBinding.Value == pressedControlPath)
								{
									ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] Binding conflict: '" + runtimeBinding.Key + "' was also bound to " + pressedControlPath + ". Clearing it."));
								}
							}
							string text = StockRebindingIntegration.PrettyGamepadPath(pressedControlPath);
							if ((Object)(object)bindingLabel != (Object)null)
							{
								((TMP_Text)bindingLabel).text = text;
							}
							if ((Object)(object)activeLabel != (Object)null)
							{
								((TMP_Text)activeLabel).text = text;
							}
							CloseListening();
							break;
						}
					}
					elapsed += Time.deltaTime;
					yield return null;
				}
			}
			finally
			{
				CloseListening();
			}
		}

		private static void CreateOverlay(Transform parent)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Expected O, but got Unknown
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Expected O, but got Unknown
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_084b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0850: Unknown result type (might be due to invalid IL or missing references)
			//IL_0862: Unknown result type (might be due to invalid IL or missing references)
			//IL_0873: Unknown result type (might be due to invalid IL or missing references)
			//IL_0888: Unknown result type (might be due to invalid IL or missing references)
			//IL_089d: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0913: Unknown result type (might be due to invalid IL or missing references)
			//IL_091d: Expected O, but got Unknown
			//IL_0949: Unknown result type (might be due to invalid IL or missing references)
			//IL_094e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0954: Expected O, but got Unknown
			//IL_098f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0994: Unknown result type (might be due to invalid IL or missing references)
			//IL_099a: Expected O, but got Unknown
			GameObject val = FindInputBindingTemplate(parent);
			overlay = new GameObject("ControllerRebindOverlay", new Type[1] { typeof(RectTransform) });
			Canvas obj = overlay.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.overrideSorting = true;
			ControllerSupportPlugin._rebindOverlayCanvas = obj;
			obj.sortingOrder = 32767;
			overlay.AddComponent<GraphicRaycaster>();
			RectTransform component = overlay.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.sizeDelta = Vector2.zero;
			((Transform)component).SetAsLastSibling();
			Image val2 = overlay.AddComponent<Image>();
			((Graphic)val2).color = new Color(0.05f, 0.05f, 0.08f, 0.95f);
			((Graphic)val2).raycastTarget = true;
			CanvasGroup obj2 = overlay.AddComponent<CanvasGroup>();
			obj2.interactable = true;
			obj2.blocksRaycasts = true;
			GameObject val3 = new GameObject("Panel", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(overlay.transform, false);
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.5f, 0.5f);
			component2.anchorMax = new Vector2(0.5f, 0.5f);
			component2.pivot = new Vector2(0.5f, 0.5f);
			component2.sizeDelta = new Vector2(650f, 600f);
			component2.anchoredPosition = Vector2.zero;
			GameObject val4 = new GameObject("Title", new Type[1] { typeof(TextMeshProUGUI) });
			val4.transform.SetParent(val3.transform, false);
			TextMeshProUGUI component3 = val4.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component3).text = "Controller Bindings";
			((TMP_Text)component3).fontSize = 28f;
			((TMP_Text)component3).alignment = (TextAlignmentOptions)514;
			RectTransform component4 = val4.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0.5f, 1f);
			component4.anchorMax = new Vector2(0.5f, 1f);
			component4.pivot = new Vector2(0.5f, 1f);
			component4.anchoredPosition = new Vector2(0f, -10f);
			component4.sizeDelta = new Vector2(400f, 40f);
			GameObject val5 = new GameObject("Instructions", new Type[1] { typeof(TextMeshProUGUI) });
			val5.transform.SetParent(val3.transform, false);
			TextMeshProUGUI component5 = val5.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component5).text = "Click a row, then press a button on your controller. Escape to cancel.";
			((TMP_Text)component5).fontSize = 13f;
			((TMP_Text)component5).alignment = (TextAlignmentOptions)514;
			RectTransform component6 = val5.GetComponent<RectTransform>();
			component6.anchorMin = new Vector2(0.5f, 1f);
			component6.anchorMax = new Vector2(0.5f, 1f);
			component6.pivot = new Vector2(0.5f, 1f);
			component6.anchoredPosition = new Vector2(0f, -50f);
			component6.sizeDelta = new Vector2(600f, 25f);
			GameObject val6 = new GameObject("ScrollArea", new Type[4]
			{
				typeof(RectTransform),
				typeof(ScrollRect),
				typeof(Mask),
				typeof(Image)
			});
			val6.transform.SetParent(val3.transform, false);
			RectTransform component7 = val6.GetComponent<RectTransform>();
			component7.anchorMin = new Vector2(0.5f, 1f);
			component7.anchorMax = new Vector2(0.5f, 1f);
			component7.pivot = new Vector2(0.5f, 1f);
			component7.anchoredPosition = new Vector2(0f, -85f);
			component7.sizeDelta = new Vector2(600f, 430f);
			((Graphic)val6.GetComponent<Image>()).color = new Color(0.08f, 0.08f, 0.12f, 0.9f);
			ScrollRect component8 = val6.GetComponent<ScrollRect>();
			component8.horizontal = false;
			component8.vertical = true;
			GameObject contentObj = new GameObject("Content", new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			contentObj.transform.SetParent(val6.transform, false);
			RectTransform component9 = contentObj.GetComponent<RectTransform>();
			component9.anchorMin = new Vector2(0f, 1f);
			component9.anchorMax = new Vector2(1f, 1f);
			component9.pivot = new Vector2(0.5f, 1f);
			component9.anchoredPosition = Vector2.zero;
			component9.sizeDelta = new Vector2(0f, 0f);
			VerticalLayoutGroup component10 = contentObj.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component10).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)component10).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component10).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)component10).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component10).childForceExpandHeight = false;
			((LayoutGroup)component10).childAlignment = (TextAnchor)1;
			contentObj.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			component8.content = component9;
			component8.viewport = component7;
			(string, string)[] array = new(string, string)[14]
			{
				("Jump", "<Gamepad>/buttonSouth"),
				("Crouch", "<Gamepad>/buttonEast"),
				("Interact", "<Gamepad>/buttonWest"),
				("Push To Talk", "<Gamepad>/buttonNorth"),
				("Run", "<Gamepad>/leftStickPress"),
				("Ragdoll", "<Gamepad>/leftShoulder"),
				("Drop", "<Gamepad>/rightShoulder"),
				("Push", "<Gamepad>/leftTrigger"),
				("Attack", "<Gamepad>/rightTrigger"),
				("Inventory", "<Gamepad>/select"),
				("Item1", "<Gamepad>/dpad/up"),
				("Item2", "<Gamepad>/dpad/right"),
				("Item3", "<Gamepad>/dpad/down"),
				("Item4", "<Gamepad>/dpad/left")
			};
			for (int i = 0; i < array.Length; i++)
			{
				var (actionName, defaultPath) = array[i];
				if ((Object)(object)val != (Object)null)
				{
					CreateStockStyledRow(contentObj.transform, val, actionName, defaultPath);
				}
				else
				{
					CreateActionRow(contentObj.transform, 0, actionName);
				}
			}
			Transform root = parent.root;
			GameObject val7 = null;
			GameObject val8 = null;
			List<Transform> list = new List<Transform>();
			CollectByName(root, (string n) => n.Contains("SGButton"), list);
			foreach (Transform item in list)
			{
				string text = "";
				TextMeshProUGUI[] componentsInChildren = ((Component)item).GetComponentsInChildren<TextMeshProUGUI>(true);
				int i = 0;
				if (i < componentsInChildren.Length)
				{
					text = ((TMP_Text)componentsInChildren[i]).text;
				}
				string text2 = ((Object)item).name.ToLowerInvariant();
				string text3 = text.ToLowerInvariant();
				if (text2.Contains("close") || text3.Contains("close"))
				{
					val7 = ((Component)item).gameObject;
				}
				else if (text2.Contains("save") || text2.Contains("apply") || text3.Contains("save") || text3.Contains("apply"))
				{
					val8 = val8 ?? ((Component)item).gameObject;
				}
			}
			if ((Object)(object)val7 == (Object)null)
			{
				val7 = FindStockButton(root, "close");
			}
			if ((Object)(object)val8 == (Object)null)
			{
				val8 = FindStockButton(root, "save") ?? FindStockButton(root, "apply");
			}
			GameObject val9 = new GameObject("ButtonRow", new Type[2]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup)
			});
			val9.transform.SetParent(val3.transform, false);
			RectTransform component11 = val9.GetComponent<RectTransform>();
			component11.anchorMin = new Vector2(0.5f, 0f);
			component11.anchorMax = new Vector2(0.5f, 0f);
			component11.pivot = new Vector2(0.5f, 0f);
			component11.anchoredPosition = new Vector2(0f, 10f);
			component11.sizeDelta = new Vector2(500f, 40f);
			HorizontalLayoutGroup component12 = val9.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component12).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)component12).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component12).childForceExpandHeight = false;
			Button obj3 = CreateStockButton(val9.transform, "Reset to Defaults", val8, clearListeners: true);
			SetNavigationAutomatic((Selectable)(object)obj3);
			((UnityEvent)obj3.onClick).AddListener((UnityAction)delegate
			{
				(string, string)[] defaultBindings = ControllerSupportPlugin.DefaultBindings;
				for (int j = 0; j < defaultBindings.Length; j++)
				{
					var (key, value) = defaultBindings[j];
					ControllerSupportPlugin.RuntimeBindings[key] = value;
				}
				ControllerSupportPlugin.SaveBindings();
				for (int k = 0; k < contentObj.transform.childCount; k++)
				{
					Transform child = contentObj.transform.GetChild(k);
					if (((Object)child).name.StartsWith("GamepadRow_"))
					{
						string actionName2 = ((Object)child).name.Substring("GamepadRow_".Length);
						(string, string) tuple3 = Array.Find(ControllerSupportPlugin.DefaultBindings, ((string action, string path) t) => t.action == actionName2);
						if (tuple3.Item1 != null)
						{
							string text4 = StockRebindingIntegration.PrettyGamepadPath(tuple3.Item2);
							Transform val12 = FindChildByName(child, "KeyNameTf");
							if ((Object)(object)val12 != (Object)null)
							{
								TextMeshProUGUI component13 = ((Component)val12).GetComponent<TextMeshProUGUI>();
								if ((Object)(object)component13 != (Object)null)
								{
									((TMP_Text)component13).text = text4;
								}
							}
							Transform val13 = FindChildByName(child, "ActiveTextTf");
							if ((Object)(object)val13 != (Object)null)
							{
								TextMeshProUGUI component14 = ((Component)val13).GetComponent<TextMeshProUGUI>();
								if ((Object)(object)component14 != (Object)null)
								{
									((TMP_Text)component14).text = text4;
								}
							}
						}
					}
				}
			});
			Button obj4 = CreateStockButton(val9.transform, "CLOSE", val7, clearListeners: true);
			ButtonClickedEvent onClick = obj4.onClick;
			object obj5 = <>c.<>9__11_2;
			if (obj5 == null)
			{
				UnityAction val10 = delegate
				{
					Close();
				};
				<>c.<>9__11_2 = val10;
				obj5 = (object)val10;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj5);
			SetNavigationAutomatic((Selectable)(object)obj4);
			((Component)val2).GetComponent<Button>();
			Button obj6 = overlay.AddComponent<Button>();
			((Selectable)obj6).transition = (Transition)0;
			ButtonClickedEvent onClick2 = obj6.onClick;
			object obj7 = <>c.<>9__11_3;
			if (obj7 == null)
			{
				UnityAction val11 = delegate
				{
					Close();
				};
				<>c.<>9__11_3 = val11;
				obj7 = (object)val11;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj7);
			EventSystem current2 = EventSystem.current;
			if ((Object)(object)current2 != (Object)null)
			{
				Button componentInChildren = val3.GetComponentInChildren<Button>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					current2.SetSelectedGameObject(((Component)componentInChildren).gameObject);
				}
			}
			ControllerSupportPlugin._cachedSelectables = null;
		}

		private static GameObject FindInputBindingTemplate(Transform parent)
		{
			Transform obj = FindTransformByName(parent.root, (string n) => n.StartsWith("InputBindingUGUI"));
			if (!((Object)(object)obj != (Object)null))
			{
				ControllerSupportPlugin.Logger.LogWarning((object)"[ControllerSupport] No InputBindingUGUI template found in UI root.");
			}
			if (obj == null)
			{
				return null;
			}
			return ((Component)obj).gameObject;
		}

		private static Transform FindTransformByName(Transform parent, Func<string, bool> match)
		{
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if (match(((Object)child).name))
				{
					return child;
				}
				Transform val = FindTransformByName(child, match);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static Transform FindChildByName(Transform parent, string name)
		{
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if (((Object)child).name == name)
				{
					return child;
				}
				Transform val = FindChildByName(child, name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static void DumpHierarchy(Transform t, string indent)
		{
			Component[] components = ((Component)t).GetComponents<Component>();
			StringBuilder stringBuilder = new StringBuilder();
			Component[] array = components;
			foreach (Component val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					stringBuilder.Append(((object)val).GetType().Name).Append(" ");
				}
			}
			for (int j = 0; j < t.childCount; j++)
			{
				DumpHierarchy(t.GetChild(j), indent + "  ");
			}
		}

		private static Transform FindChildByName(Transform parent, Func<string, bool> match)
		{
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if (match(((Object)child).name))
				{
					return child;
				}
				Transform val = FindChildByName(child, match);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static void CreateStockStyledRow(Transform parent, GameObject template, string actionName, string defaultPath)
		{
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Expected O, but got Unknown
			GameObject row = Object.Instantiate<GameObject>(template, parent);
			((Object)row).name = "GamepadRow_" + actionName;
			if (!_dumpedHierarchy)
			{
				_dumpedHierarchy = true;
				DumpHierarchy(row.transform, "  ");
			}
			List<Component> list = new List<Component>();
			Component[] components = row.GetComponents<Component>();
			foreach (Component val in components)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string text = ((object)val).GetType().Name ?? "";
					if (text.Contains("InputBinding") || text.Contains("Resolver") || text.Contains("Localiz") || text.Contains("LocalizeTmp") || text.Contains("AutoNavigation") || text.Contains("SelectionEventListener") || text.Contains("ScrollIntoView"))
					{
						list.Add(val);
					}
				}
			}
			foreach (Component item in list)
			{
				Object.DestroyImmediate((Object)(object)item);
			}
			components = row.GetComponentsInChildren<Component>(true);
			foreach (Component val2 in components)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					string text2 = ((object)val2).GetType().Name ?? "";
					if (text2.Contains("Localiz") || text2.Contains("LocalizeTmp"))
					{
						Object.DestroyImmediate((Object)(object)val2);
					}
				}
			}
			LayoutElement val3 = row.GetComponent<LayoutElement>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = row.AddComponent<LayoutElement>();
			}
			val3.preferredHeight = 40f;
			val3.minHeight = 35f;
			Transform val4 = null;
			Transform val5 = FindChildByName(row.transform, (string n) => n.Contains("ButtonDefaultUGUI"));
			if ((Object)(object)val5 != (Object)null)
			{
				val4 = val5.Find("Label");
			}
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = FindChildByName(row.transform, (string n) => n == "Label");
			}
			if ((Object)(object)val4 != (Object)null)
			{
				TextMeshProUGUI component = ((Component)val4).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component != (Object)null)
				{
					((TMP_Text)component).text = actionName;
				}
				else
				{
					Text component2 = ((Component)val4).GetComponent<Text>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.text = actionName;
					}
				}
			}
			else
			{
				ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] Row '" + actionName + "': Label not found."));
			}
			ControllerSupportPlugin.RuntimeBindings.TryGetValue(actionName, out var value);
			string text3 = StockRebindingIntegration.PrettyGamepadPath(value ?? defaultPath);
			Transform val6 = FindChildByName(row.transform, "KeyNameTf");
			if ((Object)(object)val6 != (Object)null)
			{
				TextMeshProUGUI component3 = ((Component)val6).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component3 != (Object)null)
				{
					((TMP_Text)component3).text = text3;
				}
			}
			Transform val7 = FindChildByName(row.transform, "ActiveTextTf");
			if ((Object)(object)val7 != (Object)null)
			{
				TextMeshProUGUI component4 = ((Component)val7).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component4 != (Object)null)
				{
					((TMP_Text)component4).text = text3;
				}
			}
			Button val8 = row.GetComponent<Button>();
			if ((Object)(object)val8 == (Object)null)
			{
				val8 = row.GetComponentInChildren<Button>();
			}
			if ((Object)(object)val8 != (Object)null)
			{
				SetNavigationAutomatic((Selectable)(object)val8);
			}
			if ((Object)(object)val8 != (Object)null)
			{
				FieldInfo field = typeof(Button).GetField("m_OnClick", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null)
				{
					object? value2 = field.GetValue(val8);
					UnityEvent val9 = (UnityEvent)((value2 is UnityEvent) ? value2 : null);
					if (val9 != null)
					{
						FieldInfo field2 = typeof(UnityEventBase).GetField("m_PersistentCalls", BindingFlags.Instance | BindingFlags.NonPublic);
						if (field2 != null)
						{
							object value3 = field2.GetValue(val9);
							value3?.GetType().GetMethod("Clear")?.Invoke(value3, null);
						}
					}
				}
				((UnityEventBase)val8.onClick).RemoveAllListeners();
				string capturedAction = actionName;
				string capturedDefault = defaultPath;
				((UnityEvent)val8.onClick).AddListener((UnityAction)delegate
				{
					StartGamepadRebind(parent, capturedAction, capturedDefault, row);
				});
			}
			else
			{
				ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] Row '" + actionName + "': no Button component found."));
			}
		}

		private static void CreateActionRow(Transform parent, int index, string actionName)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Expected O, but got Unknown
			GameObject val = new GameObject("Row_" + actionName, new Type[2]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup)
			});
			val.transform.SetParent(parent, false);
			HorizontalLayoutGroup component = val.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			GameObject val2 = new GameObject("Label", new Type[1] { typeof(TextMeshProUGUI) });
			val2.transform.SetParent(val.transform, false);
			TextMeshProUGUI component2 = val2.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component2).text = PrettyActionName(actionName);
			((TMP_Text)component2).fontSize = 14f;
			((TMP_Text)component2).alignment = (TextAlignmentOptions)513;
			val2.GetComponent<RectTransform>().sizeDelta = new Vector2(150f, 30f);
			GameObject val3 = new GameObject("Binding", new Type[1] { typeof(TextMeshProUGUI) });
			val3.transform.SetParent(val.transform, false);
			TextMeshProUGUI binding = val3.GetComponent<TextMeshProUGUI>();
			ControllerSupportPlugin.RuntimeBindings.TryGetValue(actionName, out var value);
			((TMP_Text)binding).text = PrettyPathName(value);
			((TMP_Text)binding).fontSize = 14f;
			((TMP_Text)binding).alignment = (TextAlignmentOptions)514;
			((Graphic)binding).color = new Color(0.7f, 0.8f, 1f);
			((Object)val3).name = "Binding_" + actionName;
			val3.GetComponent<RectTransform>().sizeDelta = new Vector2(180f, 30f);
			Button obj = CreateButton(val.transform, "Rebind", new Color(0.15f, 0.35f, 0.55f, 1f));
			((Component)obj).GetComponent<RectTransform>().sizeDelta = new Vector2(80f, 30f);
			((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
			{
				StartRebind(parent, index, actionName, binding);
			});
		}

		private static void StartRebind(Transform parent, int index, string actionName, TextMeshProUGUI bindingLabel)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			currentRebindingIndex = index;
			if ((Object)(object)listeningOverlay != (Object)null)
			{
				Object.Destroy((Object)(object)listeningOverlay);
			}
			listeningOverlay = new GameObject("ListeningOverlay", new Type[1] { typeof(RectTransform) });
			listeningOverlay.transform.SetParent(parent.root, false);
			RectTransform component = listeningOverlay.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(500f, 100f);
			((Graphic)listeningOverlay.AddComponent<Image>()).color = new Color(0.1f, 0.2f, 0.3f, 0.95f);
			GameObject val = new GameObject("Text", new Type[1] { typeof(TextMeshProUGUI) });
			val.transform.SetParent(listeningOverlay.transform, false);
			TextMeshProUGUI component2 = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component2).text = "Press a button for '" + PrettyActionName(actionName) + "'\n(Any gamepad input)";
			((TMP_Text)component2).fontSize = 18f;
			((TMP_Text)component2).alignment = (TextAlignmentOptions)514;
			RectTransform component3 = val.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.sizeDelta = Vector2.zero;
			MonoBehaviour componentInParent = ((Component)parent).GetComponentInParent<MonoBehaviour>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				IsListeningForRebind = true;
				rebindCoroutine = ListenForInput(actionName, bindingLabel);
				componentInParent.StartCoroutine(rebindCoroutine);
			}
		}

		private static IEnumerator ListenForInput(string actionName, TextMeshProUGUI bindingLabel)
		{
			float timeout = 10f;
			float elapsed = 0f;
			yield return null;
			yield return null;
			while (elapsed < timeout)
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					CancelRebind();
					yield break;
				}
				Gamepad current = Gamepad.current;
				if (current != null)
				{
					string pressedControlPath = GetPressedControlPath(current);
					if (pressedControlPath != null)
					{
						ControllerSupportPlugin.RuntimeBindings[actionName] = pressedControlPath;
						ControllerSupportPlugin.SaveBindings();
						((TMP_Text)bindingLabel).text = PrettyPathName(pressedControlPath);
						UpdateActionAsset(actionName, pressedControlPath);
						CloseListening();
						currentRebindingIndex = -1;
						yield break;
					}
				}
				elapsed += Time.deltaTime;
				yield return null;
			}
			CancelRebind();
		}

		private static string GetPressedControlPath(Gamepad gp)
		{
			if (gp.buttonSouth.wasPressedThisFrame)
			{
				return "<Gamepad>/buttonSouth";
			}
			if (gp.buttonEast.wasPressedThisFrame)
			{
				return "<Gamepad>/buttonEast";
			}
			if (gp.buttonWest.wasPressedThisFrame)
			{
				return "<Gamepad>/buttonWest";
			}
			if (gp.buttonNorth.wasPressedThisFrame)
			{
				return "<Gamepad>/buttonNorth";
			}
			if (gp.leftShoulder.wasPressedThisFrame)
			{
				return "<Gamepad>/leftShoulder";
			}
			if (gp.rightShoulder.wasPressedThisFrame)
			{
				return "<Gamepad>/rightShoulder";
			}
			if (gp.leftTrigger.wasPressedThisFrame)
			{
				return "<Gamepad>/leftTrigger";
			}
			if (gp.rightTrigger.wasPressedThisFrame)
			{
				return "<Gamepad>/rightTrigger";
			}
			if (gp.selectButton.wasPressedThisFrame)
			{
				return "<Gamepad>/select";
			}
			if (gp.startButton.wasPressedThisFrame)
			{
				return "<Gamepad>/start";
			}
			if (gp.dpad.up.wasPressedThisFrame)
			{
				return "<Gamepad>/dpad/up";
			}
			if (gp.dpad.right.wasPressedThisFrame)
			{
				return "<Gamepad>/dpad/right";
			}
			if (gp.dpad.down.wasPressedThisFrame)
			{
				return "<Gamepad>/dpad/down";
			}
			if (gp.dpad.left.wasPressedThisFrame)
			{
				return "<Gamepad>/dpad/left";
			}
			ButtonControl childControl = ((InputControl)gp).GetChildControl<ButtonControl>("leftStickPress");
			ButtonControl childControl2 = ((InputControl)gp).GetChildControl<ButtonControl>("rightStickPress");
			if (childControl != null && childControl.wasPressedThisFrame)
			{
				return "<Gamepad>/leftStickPress";
			}
			if (childControl2 != null && childControl2.wasPressedThisFrame)
			{
				return "<Gamepad>/rightStickPress";
			}
			return null;
		}

		private static void UpdateActionAsset(string actionName, string newPath)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Object[] array = Resources.FindObjectsOfTypeAll(typeof(InputActionAsset));
				foreach (Object obj in array)
				{
					InputActionAsset val = (InputActionAsset)(object)((obj is InputActionAsset) ? obj : null);
					if (val == null)
					{
						continue;
					}
					InputAction val2 = val.FindAction(actionName, false);
					if (val2 == null)
					{
						continue;
					}
					List<int> list = new List<int>();
					for (int num = val2.bindings.Count - 1; num >= 0; num--)
					{
						InputBinding val3 = val2.bindings[num];
						if (((InputBinding)(ref val3)).groups != null && ((InputBinding)(ref val3)).groups.Contains("Gamepad"))
						{
							list.Add(num);
						}
					}
					BindingSyntax val4;
					if (list.Count > 0)
					{
						val4 = InputActionSetupExtensions.ChangeBindingWithGroup(val2, "Gamepad");
						((BindingSyntax)(ref val4)).Erase();
					}
					val4 = InputActionSetupExtensions.AddBinding(val2, default(InputBinding));
					val4 = ((BindingSyntax)(ref val4)).WithPath(newPath);
					((BindingSyntax)(ref val4)).WithGroup("Gamepad");
					break;
				}
			}
			catch (Exception arg)
			{
				ControllerSupportPlugin.Logger.LogError((object)$"[ControllerSupport] UpdateActionAsset failed for '{actionName}': {arg}");
			}
		}

		private static void CancelRebind()
		{
			CloseListening();
			currentRebindingIndex = -1;
		}

		private static void CloseListening()
		{
			IsListeningForRebind = false;
			if ((Object)(object)listeningOverlay != (Object)null)
			{
				Object.Destroy((Object)(object)listeningOverlay);
				listeningOverlay = null;
			}
		}

		public static void Close()
		{
			CloseListening();
			if ((Object)(object)overlay != (Object)null)
			{
				Object.Destroy((Object)(object)overlay);
				overlay = null;
			}
			_dumpedHierarchy = false;
			currentRebindingIndex = -1;
			rebindCoroutine = null;
			ControllerSupportPlugin._rebindOverlayCanvas = null;
		}

		internal static bool HasActiveRebind()
		{
			if ((Object)(object)listeningOverlay != (Object)null)
			{
				return listeningOverlay.activeInHierarchy;
			}
			return false;
		}

		internal static void CancelActiveRebind()
		{
			if (rebindCoroutine != null)
			{
				CloseListening();
				rebindCoroutine = null;
			}
		}

		private static void SetNavigationAutomatic(Selectable sel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			Navigation navigation = sel.navigation;
			((Navigation)(ref navigation)).mode = (Mode)3;
			sel.navigation = navigation;
			sel.transition = (Transition)1;
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = new Color(0.15f, 0.15f, 0.25f, 1f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.3f, 0.5f, 0.8f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.2f, 0.35f, 0.6f, 1f);
			((ColorBlock)(ref colors)).selectedColor = new Color(0.25f, 0.4f, 0.7f, 1f);
			((ColorBlock)(ref colors)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			sel.colors = colors;
		}

		private static Button CreateStockButton(Transform parent, string text, GameObject template, bool clearListeners)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)template == (Object)null)
			{
				return CreateButton(parent, text, new Color(0.3f, 0.3f, 0.3f, 1f));
			}
			GameObject val = Object.Instantiate<GameObject>(template, parent);
			((Object)val).name = "Btn_" + text;
			RectTransform component = val.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				component.anchorMin = new Vector2(0.5f, 0.5f);
				component.anchorMax = new Vector2(0.5f, 0.5f);
				component.pivot = new Vector2(0.5f, 0.5f);
				component.anchoredPosition = Vector2.zero;
				component.sizeDelta = new Vector2(200f, 40f);
			}
			LayoutElement val2 = val.GetComponent<LayoutElement>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = val.AddComponent<LayoutElement>();
			}
			val2.preferredWidth = 200f;
			val2.preferredHeight = 40f;
			val2.minWidth = 100f;
			val2.minHeight = 35f;
			val2.flexibleWidth = 1f;
			Button val3 = null;
			if (clearListeners)
			{
				val3 = val.GetComponent<Button>();
				if ((Object)(object)val3 != (Object)null)
				{
					FieldInfo field = typeof(Button).GetField("m_OnClick", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field != null)
					{
						object? value = field.GetValue(val3);
						UnityEvent val4 = (UnityEvent)((value is UnityEvent) ? value : null);
						if (val4 != null)
						{
							FieldInfo field2 = typeof(UnityEventBase).GetField("m_PersistentCalls", BindingFlags.Instance | BindingFlags.NonPublic);
							if (field2 != null)
							{
								object value2 = field2.GetValue(val4);
								value2?.GetType().GetMethod("Clear")?.Invoke(value2, null);
							}
						}
					}
					((UnityEventBase)val3.onClick).RemoveAllListeners();
				}
			}
			Image[] componentsInChildren = val.GetComponentsInChildren<Image>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Graphic)componentsInChildren[i]).raycastTarget = true;
			}
			List<Component> list = new List<Component>();
			Component[] componentsInChildren2 = val.GetComponentsInChildren<Component>(true);
			foreach (Component val5 in componentsInChildren2)
			{
				if (!((Object)(object)val5 == (Object)null))
				{
					string text2 = ((object)val5).GetType().Name ?? "";
					if (text2.Contains("Localiz") || text2.Contains("LocalizeTmp"))
					{
						list.Add(val5);
					}
				}
			}
			foreach (Component item in list)
			{
				Object.DestroyImmediate((Object)(object)item);
			}
			bool flag = false;
			Transform val6 = FindChildByName(val.transform, (string n) => n == "Label" || n == "Text" || n == "Label (TMP)");
			if ((Object)(object)val6 != (Object)null)
			{
				TextMeshProUGUI component2 = ((Component)val6).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component2 != (Object)null)
				{
					((TMP_Text)component2).text = text;
					flag = true;
				}
			}
			if (!flag)
			{
				TextMeshProUGUI[] componentsInChildren3 = val.GetComponentsInChildren<TextMeshProUGUI>(true);
				int i = 0;
				if (i < componentsInChildren3.Length)
				{
					((TMP_Text)componentsInChildren3[i]).text = text;
					flag = true;
				}
			}
			if (!flag)
			{
				ControllerSupportPlugin.Logger.LogWarning((object)("[ControllerSupport] Button '" + text + "': no text component found."));
			}
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = val.GetComponent<Button>();
			}
			return val3 ?? val.AddComponent<Button>();
		}

		private static GameObject FindStockButton(Transform root, string namePart)
		{
			Transform val = FindTransformByName(root, (string n) => n.ToLowerInvariant().Contains(namePart.ToLowerInvariant()) && n.ToLowerInvariant().Contains("button"));
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			val = FindTransformByName(root, (string n) => n.ToLowerInvariant().Contains(namePart.ToLowerInvariant()) && n.Contains("SGButton"));
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			return null;
		}

		private static GameObject FindRedCloseButton(Transform root)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			List<Transform> list = new List<Transform>();
			CollectByName(root, (string n) => n.ToLowerInvariant().Contains("close") || n.ToLowerInvariant().Contains("back"), list);
			foreach (Transform item in list)
			{
				if ((Object)(object)((Component)item).GetComponent<Button>() == (Object)null)
				{
					continue;
				}
				Image component = ((Component)item).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					Color color = ((Graphic)component).color;
					if (color.r > color.g + 0.1f || color.r > color.b + 0.1f)
					{
						return ((Component)item).gameObject;
					}
				}
			}
			foreach (Transform item2 in list)
			{
				if ((Object)(object)((Component)item2).GetComponent<Button>() != (Object)null)
				{
					return ((Component)item2).gameObject;
				}
			}
			return null;
		}

		private static void CollectByName(Transform parent, Func<string, bool> match, List<Transform> results)
		{
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if (match(((Object)child).name))
				{
					results.Add(child);
				}
				CollectByName(child, match, results);
			}
		}

		private static Button CreateButton(Transform parent, string text, Color color)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Btn_" + text, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 35f);
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = true;
			Button val2 = val.AddComponent<Button>();
			ColorBlock colors = ((Selectable)val2).colors;
			((ColorBlock)(ref colors)).normalColor = color;
			((ColorBlock)(ref colors)).highlightedColor = new Color(Mathf.Min(color.r + 0.1f, 1f), Mathf.Min(color.g + 0.1f, 1f), Mathf.Min(color.b + 0.1f, 1f), 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(color.r * 0.7f, color.g * 0.7f, color.b * 0.7f, 1f);
			((Selectable)val2).colors = colors;
			GameObject val3 = new GameObject("Text", new Type[1] { typeof(TextMeshProUGUI) });
			val3.transform.SetParent(val.transform, false);
			TextMeshProUGUI component = val3.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = text;
			((TMP_Text)component).fontSize = 14f;
			((TMP_Text)component).alignment = (TextAlignmentOptions)514;
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.sizeDelta = Vector2.zero;
			return val2;
		}

		private static string PrettyActionName(string name)
		{
			return name switch
			{
				"Push To Talk" => "Push To Talk", 
				"Item1" => "Item 1", 
				"Item2" => "Item 2", 
				"Item3" => "Item 3", 
				"Item4" => "Item 4", 
				_ => name, 
			};
		}

		private static string PrettyPathName(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return "—";
			}
			if (path.StartsWith("<Gamepad>/"))
			{
				path = path.Substring("<Gamepad>/".Length);
			}
			return path switch
			{
				"buttonSouth" => "A (South)", 
				"buttonEast" => "B (East)", 
				"buttonWest" => "X (West)", 
				"buttonNorth" => "Y (North)", 
				"leftShoulder" => "LB", 
				"rightShoulder" => "RB", 
				"leftTrigger" => "LT", 
				"rightTrigger" => "RT", 
				"leftStickPress" => "L3 (Stick Click)", 
				"rightStickPress" => "R3 (Stick Click)", 
				"dpad/up" => "D-Pad Up", 
				"dpad/right" => "D-Pad Right", 
				"dpad/down" => "D-Pad Down", 
				"dpad/left" => "D-Pad Left", 
				"select" => "Select (Share)", 
				"start" => "Start (Menu)", 
				"leftStick" => "Left Stick", 
				"rightStick" => "Right Stick", 
				_ => path, 
			};
		}
	}
	[DefaultExecutionOrder(100)]
	internal class TaskHighlightLateUpdater : MonoBehaviour
	{
		private static ManualLogSource _log;

		private float _nextDiagTime;

		private bool _firstFrameEntered;

		private bool _initLogged;

		internal static void Init(ManualLogSource log)
		{
			_log = log;
		}

		private void LateUpdate()
		{
			bool flag = false;
			if (ControllerSupportPlugin._currentListType == ControllerSupportPlugin.ListType.DeadTied && (ControllerSupportPlugin._infoOverlayOpen || ControllerSupportPlugin._taskListOpen))
			{
				flag = true;
			}
			else
			{
				object playerController = ControllerSupportPlugin.GetPlayerController();
				if (playerController != null)
				{
					if (ControllerSupportPlugin._taskPanelField == null)
					{
						ControllerSupportPlugin._taskPanelField = AccessTools.Field(playerController.GetType(), "taskPanel");
					}
					if (ControllerSupportPlugin._taskPanelField != null)
					{
						object? value = ControllerSupportPlugin._taskPanelField.GetValue(playerController);
						GameObject val = (GameObject)((value is GameObject) ? value : null);
						if ((Object)(object)val != (Object)null && val.activeInHierarchy)
						{
							flag = true;
							ControllerSupportPlugin._currentListType = ControllerSupportPlugin.ListType.DeadTied;
						}
					}
				}
			}
			if (flag && !ControllerSupportPlugin._lastInputWasGamepad)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
			}
			if (!ControllerSupportPlugin._lastInputWasGamepad)
			{
				return;
			}
			if (!ControllerSupportPlugin._lateUpdaterDiagLogged && ControllerSupportPlugin.GetPlayerController() != null)
			{
				ControllerSupportPlugin._lateUpdaterDiagLogged = true;
			}
			if (ControllerSupportPlugin._taskListSelectedIndex >= 0 && ControllerSupportPlugin._taskListSelectedIndex < ControllerSupportPlugin._cachedTaskElements.Count && !ControllerSupportPlugin._lateUpdaterActiveDiagLogged)
			{
				ControllerSupportPlugin._lateUpdaterActiveDiagLogged = true;
				_ = ControllerSupportPlugin._cachedTaskElements[ControllerSupportPlugin._taskListSelectedIndex];
			}
			if (ControllerSupportPlugin._taskListSelectedIndex >= 0 && ControllerSupportPlugin._taskListSelectedIndex < ControllerSupportPlugin._cachedTaskElements.Count)
			{
				(PlayerTaskElement, Image, Image, GameObject, Component) tuple = ControllerSupportPlugin._cachedTaskElements[ControllerSupportPlugin._taskListSelectedIndex];
				if ((Object)(object)tuple.Item1 != (Object)null && ((Component)tuple.Item1).gameObject.activeInHierarchy)
				{
					ControllerSupportPlugin.HighlightTaskElement(ControllerSupportPlugin._taskListSelectedIndex);
				}
				else if (!ControllerSupportPlugin._inactiveElementsLogged)
				{
					ControllerSupportPlugin._inactiveElementsLogged = true;
				}
			}
			if (Time.frameCount % 120 == 0)
			{
				_ = ControllerSupportPlugin._currentListType;
				_ = 2;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerHealth), "OnRespawned")]
	public static class PlayerRevivedPatch
	{
		private static FieldInfo _playerField;

		[HarmonyPostfix]
		public static void Postfix(PlayerHealth __instance)
		{
			try
			{
				if (_playerField == null)
				{
					_playerField = AccessTools.Field(typeof(PlayerHealth), "player");
				}
				object obj = _playerField?.GetValue(__instance);
				if (obj != null)
				{
					NetworkBehaviour val = (NetworkBehaviour)((obj is NetworkBehaviour) ? obj : null);
					if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer && (ControllerSupportPlugin._currentListType == ControllerSupportPlugin.ListType.DeadTied || ControllerSupportPlugin._taskListOpen || ControllerSupportPlugin._infoOverlayOpen))
					{
						ControllerSupportPlugin.ClearAllTaskAndFoldoutState();
						Cursor.visible = true;
						Cursor.lockState = (CursorLockMode)0;
					}
				}
			}
			catch (Exception arg)
			{
				ControllerSupportPlugin.Logger.LogError((object)$"[ControllerSupport] PlayerRevivedPatch error: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(StatusEffectHandler), "SetTied")]
	public static class PlayerUntiedPatch
	{
		[HarmonyPostfix]
		public static void Postfix(StatusEffectHandler __instance, bool tied)
		{
			if (tied)
			{
				return;
			}
			try
			{
				if (!((Object)(object)__instance == (Object)null) && ((NetworkBehaviour)__instance).IsLocalPlayer && (ControllerSupportPlugin._currentListType == ControllerSupportPlugin.ListType.DeadTied || ControllerSupportPlugin._taskListOpen || ControllerSupportPlugin._infoOverlayOpen))
				{
					ControllerSupportPlugin.ClearAllTaskAndFoldoutState();
					Cursor.visible = true;
					Cursor.lockState = (CursorLockMode)0;
				}
			}
			catch (Exception arg)
			{
				ControllerSupportPlugin.Logger.LogError((object)$"[ControllerSupport] PlayerUntiedPatch error: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(PlayerController), "RefreshMouseState")]
	public static class RefreshMouseStatePatch
	{
		private static FieldInfo _taskPanelFieldCache;

		[HarmonyPostfix]
		public static void Postfix(PlayerController __instance)
		{
			try
			{
				if (_taskPanelFieldCache == null)
				{
					_taskPanelFieldCache = AccessTools.Field(((object)__instance).GetType(), "taskPanel");
				}
				if (!(_taskPanelFieldCache == null))
				{
					object? value = _taskPanelFieldCache.GetValue(__instance);
					GameObject val = (GameObject)((value is GameObject) ? value : null);
					if (!((Object)(object)val == (Object)null) && val.activeInHierarchy && !ControllerSupportPlugin._lastInputWasGamepad)
					{
						Cursor.visible = true;
						Cursor.lockState = (CursorLockMode)0;
					}
				}
			}
			catch (Exception arg)
			{
				ControllerSupportPlugin.Logger.LogError((object)$"[ControllerSupport] RefreshMouseStatePatch error: {arg}");
			}
		}
	}
}