using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ComfyLib;
using GUIFramework;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Pinnacle")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Pinnacle")]
[assembly: AssemblyCopyright("Copyright © 2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("8d534f00-8286-4b0e-b2bc-a7669730bbca")]
[assembly: AssemblyFileVersion("1.16.1")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = "")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.16.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[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 Pinnacle
{
	public static class PluginConfig
	{
		public static ConfigFile CurrentConfig { get; private set; }

		public static ConfigEntry<bool> IsModEnabled { get; private set; }

		public static ConfigEntry<float> CenterMapLerpDuration { get; private set; }

		public static ConfigEntry<KeyboardShortcut> PinListPanelToggleShortcut { get; private set; }

		public static ConfigEntry<bool> PinListPanelShowPinPosition { get; private set; }

		public static ConfigEntry<Vector2> PinListPanelPosition { get; private set; }

		public static ConfigEntry<Vector2> PinListPanelSizeDelta { get; private set; }

		public static ConfigEntry<Color> PinListPanelBackgroundColor { get; private set; }

		public static ConfigEntry<MovementType> PinListPanelScrollRectMovementType { get; private set; }

		public static ConfigEntry<float> PinListPanelScrollRectScrollSensitivity { get; private set; }

		public static ConfigEntry<bool> PinListPanelEditPinOnRowClick { get; private set; }

		public static ConfigEntry<Vector2> PinEditPanelDefaultPosition { get; private set; }

		public static ConfigEntry<float> PinEditPanelToggleLerpDuration { get; private set; }

		public static ConfigEntry<Vector2> PinFilterPanelPosition { get; private set; }

		public static ConfigEntry<float> PinFilterPanelGridIconSize { get; private set; }

		public static ConfigEntry<string> PinFont { get; private set; }

		public static ConfigEntry<int> PinFontSize { get; private set; }

		public static ConfigEntry<KeyboardShortcut> AddPinAtMouseShortcut { get; private set; }

		public static ConfigEntry<bool> ProcessPinIconColorTags { get; private set; }

		public static ConfigEntry<bool> ProcessPinIconSpriteTags { get; private set; }

		public static ConfigEntry<bool> ProcessPinIconScaleTags { get; private set; }

		public static ConfigEntry<bool> StripPinIconColorTagText { get; private set; }

		public static ConfigEntry<bool> StripPinIconSpriteTagText { get; private set; }

		public static ConfigEntry<bool> StripPinIconScaleTagText { get; private set; }

		public static ConfigEntry<string> QuickMapPinDefaultName { get; private set; }

		public static ConfigEntry<PinType> QuickMapPinDefaultPinType { get; private set; }

		public static ConfigEntry<KeyboardShortcut> QuickMapPinShortcut { get; private set; }

		public static void BindConfig(ConfigFile config)
		{
			CurrentConfig = config;
			IsModEnabled = config.BindInOrder("_Global", "isModEnabled", defaultValue: true, "Globally enable or disable this mod.");
			IsModEnabled.OnSettingChanged<bool>(PinnacleUtils.TogglePinnacle);
			IsModEnabled.OnSettingChanged<bool>(ComfyCommandUtils.ToggleCommands);
			CenterMapLerpDuration = config.BindInOrder("CenterMap", "lerpDuration", 1f, "Duration (in seconds) for the CenterMap lerp.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f));
			BindPinListPanelConfig(config);
			BindPinEditPanelConfig(config);
			BindPinFilterPanelConfig(config);
			BindPinIconConfig(config);
			BindQuickMapPinConfig(config);
			LateBindConfigQueue.Reset(config);
			LateBindConfigQueue.Enqueue(BindMinimapConfig);
		}

		public static void BindPinListPanelConfig(ConfigFile config)
		{
			//IL_0012: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			PinListPanelToggleShortcut = config.BindInOrder<KeyboardShortcut>("PinListPanel", "pinListPanelToggleShortcut", new KeyboardShortcut((KeyCode)9, Array.Empty<KeyCode>()), "Keyboard shortcut to toggle the PinListPanel on/off.");
			PinListPanelShowPinPosition = config.BindInOrder("PinListPanel.Columns", "pinListPanelShowPinPosition", defaultValue: true, "Show the Pin.Position columns in the PinListPanel.");
			PinListPanelPosition = config.BindInOrder<Vector2>("PinListPanel.Panel", "pinListPanelPosition", new Vector2(25f, 0f), "The value for the PinListPanel.Panel position (relative to pivot/anchors).");
			PinListPanelPosition.OnSettingChanged((Action<Vector2>)PinListPanelController.SetPanelPosition);
			PinListPanelSizeDelta = config.BindInOrder<Vector2>("PinListPanel.Panel", "pinListPanelSizeDelta", new Vector2(400f, 400f), "The value for the PinListPanel.Panel sizeDelta (width/height in pixels).");
			PinListPanelSizeDelta.OnSettingChanged((Action<Vector2>)PinListPanelController.SetPanelSize);
			PinListPanelBackgroundColor = config.BindInOrder<Color>("PinListPanel.Panel", "pinListPanelBackgroundColor", new Color(0f, 0f, 0f, 0.9f), "The value for the PinListPanel.Panel background color.");
			PinListPanelBackgroundColor.OnSettingChanged((Action<Color>)PinListPanelController.SetBackgroundColor);
			PinListPanelScrollRectMovementType = config.BindInOrder<MovementType>("PinListPanel.ScrollRect", "movementType", (MovementType)2, "Determines how the PinListPanel scrolling should behave.", (AcceptableValueBase)(object)new AcceptableValueEnumList<MovementType>((MovementType)2, (MovementType)1));
			PinListPanelScrollRectMovementType.OnSettingChanged((Action<MovementType>)PinListPanelController.SetScrollRectMovementType);
			PinListPanelScrollRectScrollSensitivity = config.BindInOrder("PinListPanel.ScrollRect", "scrollSensitivity", 3600f, "PinListPanel scroll-sensitivity when using the mouse-wheel.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 7200f));
			PinListPanelScrollRectScrollSensitivity.OnSettingChanged<float>(PinListPanelController.SetScrollRectScrollSensitivity);
			PinListPanelEditPinOnRowClick = config.BindInOrder("PinListPanel.Behaviour", "pinListPanelEditPinOnRowClick", defaultValue: true, "If set, will show the PinEditPanel when a row is selected in the PinListPanel.");
		}

		public static void BindPinEditPanelConfig(ConfigFile config)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			PinEditPanelDefaultPosition = config.BindInOrder<Vector2>("PinEditPanel", "pinEditPanelDefaultPosition", new Vector2(0f, 25f), "PinEditPanel position, relative to the bottom-center of the Minimap.");
			PinEditPanelToggleLerpDuration = config.BindInOrder("PinEditPanel.Toggle", "pinEditPanelToggleLerpDuration", 0.25f, "Duration (in seconds) for the PinEditPanel.Toggle on/off lerp.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f));
		}

		public static void BindPinFilterPanelConfig(ConfigFile config)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			PinFilterPanelPosition = config.BindInOrder<Vector2>("PinFilterPanel.Panel", "pinFilterPanelPanelPosition", new Vector2(-25f, 0f), "The value for the PinFilterPanel.Panel position (relative to pivot/anchors).");
			PinFilterPanelGridIconSize = config.BindInOrder("PinFilterPanel.Grid", "pinFilterPanelGridIconSize", 30f, "The size of the PinFilterPanel.Grid icons.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 100f));
			PinFilterPanelGridIconSize.OnSettingChanged<float>(PinFilterPanelController.UpdateStyle);
		}

		public static void BindMinimapConfig(ConfigFile config)
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			string valheimNorseFont = UIResources.ValheimNorseFont;
			List<string> list = new List<string>();
			list.AddRange(from f in Resources.FindObjectsOfTypeAll<TMP_FontAsset>()
				select ((Object)f).name into f
				orderby f
				select f);
			PinFont = config.BindInOrder("Minimap", "Pin.Font", valheimNorseFont, "The font for the Pin text on the Minimap.", (AcceptableValueBase)(object)new AcceptableValueList<string>(list.ToArray()));
			PinFontSize = config.BindInOrder("Minimap", "Pin.FontSize", 18, "The font size for the Pin text on the Minimap.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 26));
			PinFont.OnSettingChanged<string>(PinMarkerUtils.SetPinNameFont);
			PinFontSize.OnSettingChanged<int>(PinMarkerUtils.SetPinNameFontSize);
			AddPinAtMouseShortcut = config.BindInOrder<KeyboardShortcut>("Minimap.Actions", "addPinAtMouseShortcut", KeyboardShortcut.Empty, "Keyboard shortcut to add a Minimap.Pin at the mouse position.");
		}

		private static void BindPinIconConfig(ConfigFile config)
		{
			ProcessPinIconColorTags = config.BindInOrder("PinIcon.Tags", "processPinIconColorTags", defaultValue: true, "If set, will process pin-icon-color tags: [#ff00ff]");
			ProcessPinIconSpriteTags = config.BindInOrder("PinIcon.Tags", "processPinIconSpriteTags", defaultValue: true, "If set, will process pin-icon-sprite tags: [:sprite_name]");
			ProcessPinIconScaleTags = config.BindInOrder("PinIcon.Tags", "processPinIconScaleTags", defaultValue: true, "If set, will process pin-icon-scale tags: [150%]");
			StripPinIconColorTagText = config.BindInOrder("PinIcon.Tags", "stripPinIconColorTagText", defaultValue: true, "If set, will strip pin-icon-color tags from the pin-text.");
			StripPinIconSpriteTagText = config.BindInOrder("PinIcon.Tags", "stripPinIconSpriteTagText", defaultValue: true, "If set, will strip pin-icon-sprite tags from the pin-text.");
			StripPinIconScaleTagText = config.BindInOrder("PinIcon.Tags", "stripPinIconScaleTagText", defaultValue: true, "If set, will strip pin-icon-scale tags from the pin-text.");
		}

		private static void BindQuickMapPinConfig(ConfigFile config)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			QuickMapPinDefaultName = config.BindInOrder("QuickMapPin", "quickMapPinDefaultName", "QuickPin", "Default pin-name to use for a quick-map-pin.");
			QuickMapPinDefaultPinType = config.BindInOrder<PinType>("QuickMapPin", "quickMapPinDefaultPinType", (PinType)3, "Default pin-type to use for a quick-map-pin.");
			QuickMapPinShortcut = config.BindInOrder<KeyboardShortcut>("QuickMapPin", "quickMapPinShortcut", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), "Shortcut to add a quick-map-pin at current position with the Minimap is open.");
		}
	}
	public static class LateBindConfigQueue
	{
		[HarmonyPatch(typeof(FejdStartup))]
		private static class FejdStartupPatch
		{
			[HarmonyPostfix]
			[HarmonyPatch("Awake")]
			private static void AwakePostfix()
			{
				while (_queue.Count > 0)
				{
					_queue.Dequeue()(_currentConfig);
				}
			}
		}

		private static ConfigFile _currentConfig = null;

		private static readonly Queue<Action<ConfigFile>> _queue = new Queue<Action<ConfigFile>>();

		public static void Reset(ConfigFile currentConfig)
		{
			_currentConfig = currentConfig;
			_queue.Clear();
		}

		public static void Enqueue(Action<ConfigFile> bindConfigAction)
		{
			_queue.Enqueue(bindConfigAction);
		}
	}
	public static class CenterMapHelper
	{
		private static Coroutine _centerMapCoroutine;

		public static void CenterMapOnPosition(Vector3 targetPosition)
		{
			//IL_0034: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Minimap.instance) && Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				if (_centerMapCoroutine != null)
				{
					((MonoBehaviour)Minimap.instance).StopCoroutine(_centerMapCoroutine);
				}
				_centerMapCoroutine = ((MonoBehaviour)Minimap.instance).StartCoroutine(CenterMapCoroutine(targetPosition - ((Component)Player.m_localPlayer).transform.position, PluginConfig.CenterMapLerpDuration.Value));
			}
		}

		private static IEnumerator CenterMapCoroutine(Vector3 targetPosition, float lerpDuration)
		{
			//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)
			float timeElapsed = 0f;
			Vector3 startPosition = Minimap.instance.m_mapOffset;
			while (timeElapsed < lerpDuration)
			{
				float num = timeElapsed / lerpDuration;
				num = num * num * (3f - 2f * num);
				Minimap.instance.m_mapOffset = Vector3.Lerp(startPosition, targetPosition, num);
				timeElapsed += Time.deltaTime;
				yield return null;
			}
			Minimap.instance.m_mapOffset = targetPosition;
		}
	}
	public static class AddMapPinCommand
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ConsoleEventFailable <0>__Run;
		}

		[ComfyCommand]
		public static ConsoleCommand Register()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//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_0025: Expected O, but got Unknown
			object obj = <>O.<0>__Run;
			if (obj == null)
			{
				ConsoleEventFailable val = Run;
				<>O.<0>__Run = val;
				obj = (object)val;
			}
			return new ConsoleCommand("add-map-pin", "(Pinnacle) add-map-pin [--position=<x,y,z>] [--pin-name=<string>] [--pin-type=<enum>] [--log]", (ConsoleEventFailable)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		public static object Run(ConsoleEventArgs args)
		{
			return Run(new ComfyArgs(args));
		}

		public static bool Run(ComfyArgs args)
		{
			//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)
			//IL_0076: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			Minimap instance = Minimap.instance;
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)instance) || !Object.op_Implicit((Object)(object)localPlayer))
			{
				return false;
			}
			Vector3 value = ((Component)localPlayer).transform.position;
			if (args.TryGetValue("position", "pos", out var argValue) && !argValue.TryParseVector3(out value))
			{
				Pinnacle.LogWarning("Unable to parse --position: " + argValue);
				return false;
			}
			if (!args.TryGetValue("pin-name", "name", out var argValue2))
			{
				argValue2 = string.Empty;
			}
			PinType value2 = (PinType)3;
			if (args.TryGetValue("pin-type", "type", out var argValue3) && !argValue3.TryParseValue<PinType>(out value2))
			{
				Pinnacle.LogWarning("Unable to parse --pin-type: " + argValue3);
				return false;
			}
			PinData val = instance.AddPin(value, value2, argValue2, true, false, 0L, default(PlatformUserID));
			if (args.TryGetValue("log", out bool argValue4) && argValue4)
			{
				Pinnacle.LogInfo($"Added new pin... Position: {val.m_pos:F0}, Type: {value2:F}, Name: {argValue2}");
			}
			return true;
		}
	}
	public static class ExportPinsCommand
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ConsoleEventFailable <0>__ExportPinsToBinaryFile;

			public static ConsoleEventFailable <1>__ExportPinsToTextFile;
		}

		[ComfyCommand]
		public static IEnumerable<ConsoleCommand> Register()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0022: 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_002d: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//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)
			//IL_0064: Expected O, but got Unknown
			ConsoleCommand[] array = new ConsoleCommand[2];
			object obj = <>O.<0>__ExportPinsToBinaryFile;
			if (obj == null)
			{
				ConsoleEventFailable val = ExportPinsToBinaryFile;
				<>O.<0>__ExportPinsToBinaryFile = val;
				obj = (object)val;
			}
			array[0] = new ConsoleCommand("pinnacle-exportpins-binary", "<filename> [name-filter-regex] -- export pins to a file in binary format.", (ConsoleEventFailable)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj2 = <>O.<1>__ExportPinsToTextFile;
			if (obj2 == null)
			{
				ConsoleEventFailable val2 = ExportPinsToTextFile;
				<>O.<1>__ExportPinsToTextFile = val2;
				obj2 = (object)val2;
			}
			array[1] = new ConsoleCommand("pinnacle-exportpins-text", "<filename> [name-filter-regex] -- export pins to a file in plain text format.", (ConsoleEventFailable)obj2, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			return new <>z__ReadOnlyArray<ConsoleCommand>((ConsoleCommand[])(object)array);
		}

		public static object ExportPinsToBinaryFile(ConsoleEventArgs args)
		{
			PinImportExport.ExportPinsToFile(args, PinImportExport.PinFileFormat.Binary);
			return true;
		}

		public static object ExportPinsToTextFile(ConsoleEventArgs args)
		{
			PinImportExport.ExportPinsToFile(args, PinImportExport.PinFileFormat.PlainText);
			return true;
		}
	}
	public static class ImportPinsCommand
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ConsoleEvent <0>__ImportPinsFromBinaryFile;
		}

		[ComfyCommand]
		public static ConsoleCommand Register()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//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_0025: Expected O, but got Unknown
			object obj = <>O.<0>__ImportPinsFromBinaryFile;
			if (obj == null)
			{
				ConsoleEvent val = PinImportExport.ImportPinsFromBinaryFile;
				<>O.<0>__ImportPinsFromBinaryFile = val;
				obj = (object)val;
			}
			return new ConsoleCommand("pinnacle-importpins-binary", "<filename> [name-filter-regex] -- import pins in binary format from file.", (ConsoleEvent)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}
	}
	public static class RemoveAllPinsCommand
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ConsoleEventFailable <0>__Run;
		}

		[ComfyCommand]
		public static ConsoleCommand Register()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//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_0025: Expected O, but got Unknown
			object obj = <>O.<0>__Run;
			if (obj == null)
			{
				ConsoleEventFailable val = Run;
				<>O.<0>__Run = val;
				obj = (object)val;
			}
			return new ConsoleCommand("pinnacle-remove-all-pins", "(Pinnacle) Removes ALL pins.", (ConsoleEventFailable)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		public static object Run(ConsoleEventArgs args)
		{
			if (!Object.op_Implicit((Object)(object)Minimap.instance))
			{
				return false;
			}
			int num = Minimap.instance.m_pins.RemoveAll((PinData pin) => pin.m_save);
			args.Context.AddString($"Removed {num} pins.");
			return true;
		}
	}
	public static class PinEditPanelController
	{
		public static PinEditPanel PinEditPanel { get; private set; }

		public static void TogglePanel(PinData pinToEdit = null)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (!IsValid())
			{
				PinEditPanel = new PinEditPanel(Minimap.instance.m_largeRoot.transform);
				PinEditPanel.RectTransform.SetAnchorMin(new Vector2(0.5f, 0f)).SetAnchorMax(new Vector2(0.5f, 0f)).SetPivot(new Vector2(0.5f, 0f))
					.SetPosition(new Vector2(0f, 25f))
					.SetSizeDelta(new Vector2(200f, 200f));
			}
			if (pinToEdit == null)
			{
				PinEditPanel.SetTargetPin(null);
				PinEditPanel.SetActive(toggle: false);
				return;
			}
			CenterMapHelper.CenterMapOnPosition(pinToEdit.m_pos);
			PinEditPanel.RectTransform.SetPosition(PluginConfig.PinEditPanelDefaultPosition.Value);
			PinEditPanel.SetTargetPin(pinToEdit);
			PinEditPanel.SetActive(toggle: true);
		}

		public static bool IsValid()
		{
			if (PinEditPanel != null)
			{
				return Object.op_Implicit((Object)(object)PinEditPanel.Panel);
			}
			return false;
		}

		public static bool HasFocus()
		{
			if (PinEditPanel != null && Object.op_Implicit((Object)(object)PinEditPanel.Panel) && PinEditPanel.Panel.activeSelf)
			{
				return PinEditPanel.HasFocus();
			}
			return false;
		}
	}
	public static class PinFilterPanelController
	{
		private static PinFilterPanel _currentPanel;

		public static void TogglePanel(bool toggleOn)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			if (!IsValid())
			{
				_currentPanel = new PinFilterPanel(Minimap.instance.m_largeRoot.transform);
				_currentPanel.RectTransform.SetAnchorMin(new Vector2(1f, 0.5f)).SetAnchorMax(new Vector2(1f, 0.5f)).SetPivot(new Vector2(1f, 0.5f))
					.SetPosition(PluginConfig.PinFilterPanelPosition.Value);
				_currentPanel.PanelDragger.OnPanelEndDrag += SavePanelPosition;
			}
			_currentPanel.Panel.SetActive(toggleOn);
		}

		private static void SavePanelPosition(object sender, Vector3 position)
		{
			//IL_0005: 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)
			PluginConfig.PinFilterPanelPosition.Value = Vector2.op_Implicit(position);
		}

		public static bool IsValid()
		{
			if (_currentPanel != null)
			{
				return Object.op_Implicit((Object)(object)_currentPanel.Panel);
			}
			return false;
		}

		public static void UpdateIconFilters()
		{
			if (IsValid())
			{
				_currentPanel.UpdatePinIconFilters();
			}
		}

		public static void UpdateStyle()
		{
			if (IsValid())
			{
				_currentPanel.SetPanelStyle();
			}
		}
	}
	public static class PinListPanelController
	{
		public static PinListPanel PinListPanel { get; private set; }

		public static void TogglePanel()
		{
			PinListPanel pinListPanel = PinListPanel;
			bool? obj;
			if (pinListPanel == null)
			{
				obj = null;
			}
			else
			{
				GameObject obj2 = pinListPanel.Panel.Ref<GameObject>();
				obj = ((obj2 != null) ? new bool?(!obj2.activeSelf) : ((bool?)null));
			}
			bool? flag = obj;
			TogglePanel(flag == true);
		}

		public static void TogglePanel(bool toggleOn)
		{
			//IL_0048: 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_0070: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)PinListPanel?.Panel))
			{
				PinListPanel = new PinListPanel(Minimap.instance.m_largeRoot.transform);
				PinListPanel.RectTransform.SetAnchorMin(new Vector2(0f, 0.5f)).SetAnchorMax(new Vector2(0f, 0.5f)).SetPivot(new Vector2(0f, 0.5f))
					.SetPosition(PluginConfig.PinListPanelPosition.Value)
					.SetSizeDelta(PluginConfig.PinListPanelSizeDelta.Value);
				PinListPanel.PanelDragger.OnPanelEndDrag += OnPanelDragEnd;
				PinListPanel.PanelResizer.OnPanelEndResize += OnPanelResizeEnd;
			}
			if (toggleOn)
			{
				PinListPanel.Panel.SetActive(true);
				PinListPanel.SetTargetPins();
			}
			else
			{
				PinListPanel.PinNameFilter.InputField.DeactivateInputField(false);
				PinListPanel.Panel.SetActive(false);
			}
		}

		public static bool IsPanelValid()
		{
			return Object.op_Implicit((Object)(object)PinListPanel?.Panel);
		}

		public static bool HasFocus()
		{
			if (PinListPanel != null)
			{
				return PinListPanel.HasFocus();
			}
			return false;
		}

		public static void SetBackgroundColor(Color color)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (IsPanelValid())
			{
				((Graphic)PinListPanel.Background).color = color;
			}
		}

		public static void SetPanelPosition(Vector2 position)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (IsPanelValid())
			{
				PinListPanel.RectTransform.anchoredPosition = position;
			}
		}

		public static void SetPanelSize(Vector2 sizeDelta)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (IsPanelValid())
			{
				PinListPanel.RectTransform.sizeDelta = sizeDelta;
				PinListPanel.SetTargetPins();
			}
		}

		public static void SetScrollRectMovementType(MovementType movementType)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (IsPanelValid())
			{
				PinListPanel.ScrollRect.movementType = movementType;
			}
		}

		public static void SetScrollRectScrollSensitivity(float scrollSensitivity)
		{
			if (IsPanelValid())
			{
				PinListPanel.ScrollRect.scrollSensitivity = scrollSensitivity;
			}
		}

		private static void OnPanelDragEnd(object sender, Vector3 position)
		{
			//IL_0005: 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)
			PluginConfig.PinListPanelPosition.Value = Vector2.op_Implicit(position);
		}

		private static void OnPanelResizeEnd(object sender, Vector2 sizeDelta)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			PluginConfig.PinListPanelSizeDelta.Value = sizeDelta;
		}
	}
	public static class PinIconManager
	{
		public static Regex IconColorTagRegex = new Regex(".*\\[(#[0-9a-fA-F]{6})\\].*", RegexOptions.Compiled | RegexOptions.CultureInvariant, TimeSpan.FromMilliseconds(100.0));

		public static Regex IconSpriteTagRegex = new Regex(".*\\[:(\\w{3,})\\].*", RegexOptions.Compiled | RegexOptions.CultureInvariant, TimeSpan.FromMilliseconds(100.0));

		public static Regex IconScaleTagRegex = new Regex(".*\\[(\\d{2,3})%\\]", RegexOptions.Compiled | RegexOptions.CultureInvariant, TimeSpan.FromMilliseconds(100.0));

		public static void ProcessIconTagsCreated(PinData pinData)
		{
			if ((0u | ((PluginConfig.ProcessPinIconColorTags.Value && TryProcessIconColorTag(pinData)) ? 1u : 0u) | ((PluginConfig.ProcessPinIconSpriteTags.Value && TryProcessIconSpriteTag(pinData)) ? 1u : 0u) | ((PluginConfig.ProcessPinIconScaleTags.Value && TryProcessIconScaleTag(pinData)) ? 1u : 0u)) != 0)
			{
				pinData.m_worldSize = 0f;
			}
		}

		public static void ProcessIconTagsModified(PinData pinData)
		{
			bool flag = HasIconTagFlag(pinData);
			bool flag2 = false;
			if (PluginConfig.ProcessPinIconColorTags.Value && TryProcessIconColorTag(pinData))
			{
				flag2 = true;
			}
			else if (flag)
			{
				ResetIconColor(pinData);
			}
			if (PluginConfig.ProcessPinIconSpriteTags.Value && TryProcessIconSpriteTag(pinData))
			{
				flag2 = true;
			}
			else if (flag)
			{
				ResetIconSprite(pinData);
			}
			if (PluginConfig.ProcessPinIconScaleTags.Value && TryProcessIconScaleTag(pinData))
			{
				flag2 = true;
			}
			else if (flag)
			{
				ResetIconScale(pinData);
			}
			if (flag2)
			{
				RemoveIconTagText(pinData.m_NamePinData);
				pinData.m_worldSize = 0f;
			}
			else if (flag)
			{
				pinData.m_worldSize = 0f;
			}
		}

		public static bool IsValidIconTagName(string pinName)
		{
			if (pinName != null && pinName.Length > 0)
			{
				return pinName[pinName.Length - 1] == ']';
			}
			return false;
		}

		public static bool HasIconTagFlag(PinData pinData)
		{
			return pinData.m_worldSize == 0f;
		}

		public static void RemoveIconTagText(PinNameData pinNameData)
		{
			string text = pinNameData.PinNameText.text;
			if (IsValidIconTagName(text))
			{
				if (PluginConfig.StripPinIconColorTagText.Value)
				{
					text = RemoveIconColorTagText(text);
				}
				if (PluginConfig.StripPinIconSpriteTagText.Value)
				{
					text = RemoveIconSpriteTagText(text);
				}
				if (PluginConfig.StripPinIconScaleTagText.Value)
				{
					text = RemoveIconScaleTagText(text);
				}
				pinNameData.PinNameText.text = text;
			}
		}

		public static bool TryProcessIconColorTag(PinData pinData)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			string name = pinData.m_name;
			if (name.Length >= 9)
			{
				Match match = IconColorTagRegex.Match(name);
				Color color = default(Color);
				if (match.Success && ColorUtility.TryParseHtmlString(match.Groups[1].Value, ref color))
				{
					((Graphic)pinData.m_iconElement).color = color;
					return true;
				}
			}
			return false;
		}

		public static void ResetIconColor(PinData pinData)
		{
			//IL_001a: 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)
			((Graphic)pinData.m_iconElement).color = ((pinData.m_ownerID == 0L) ? Color.white : GetIconFadeColor(Minimap.instance));
		}

		public static Color GetIconFadeColor(Minimap minimap)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return new Color(0.7f, 0.7f, 0.7f, 0.8f * minimap.m_sharedMapDataFade);
		}

		public static string RemoveIconColorTagText(string nameText)
		{
			if (nameText.Length >= 9)
			{
				Match match = IconColorTagRegex.Match(nameText);
				if (match.Success)
				{
					Group obj = match.Groups[1];
					return nameText.Remove(obj.Index - 1, obj.Length + 2);
				}
			}
			return nameText;
		}

		public static bool TryProcessIconSpriteTag(PinData pinData)
		{
			string name = pinData.m_name;
			if (name.Length >= 6)
			{
				Match match = IconSpriteTagRegex.Match(name);
				if (match.Success && UIResources.SpriteCache.TryGetResource(match.Groups[1].Value, out var cachedResource))
				{
					pinData.m_iconElement.sprite = cachedResource;
					return true;
				}
			}
			return false;
		}

		public static void ResetIconSprite(PinData pinData)
		{
			pinData.m_iconElement.sprite = pinData.m_icon;
		}

		public static string RemoveIconSpriteTagText(string nameText)
		{
			if (nameText.Length >= 6)
			{
				Match match = IconSpriteTagRegex.Match(nameText);
				if (match.Success)
				{
					Group obj = match.Groups[1];
					return nameText.Remove(obj.Index - 2, obj.Length + 3);
				}
			}
			return nameText;
		}

		public static bool TryProcessIconScaleTag(PinData pinData)
		{
			string name = pinData.m_name;
			if (name.Length >= 4)
			{
				Match match = IconScaleTagRegex.Match(name);
				if (match.Success && int.TryParse(match.Groups[1].Value, out var result))
				{
					float num = (float)Mathf.Clamp(result, 50, 200) * 0.01f * GetIconDefaultSize(Minimap.instance);
					pinData.m_uiElement.SetSizeWithCurrentAnchors((Axis)0, num);
					pinData.m_uiElement.SetSizeWithCurrentAnchors((Axis)1, num);
					return true;
				}
			}
			return false;
		}

		public static void ResetIconScale(PinData pinData)
		{
			RectTransform uiElement = pinData.m_uiElement;
			float iconDefaultSize = GetIconDefaultSize(Minimap.instance);
			uiElement.SetSizeWithCurrentAnchors((Axis)0, iconDefaultSize);
			uiElement.SetSizeWithCurrentAnchors((Axis)1, iconDefaultSize);
		}

		public static string RemoveIconScaleTagText(string nameText)
		{
			if (nameText.Length >= 4)
			{
				Match match = IconScaleTagRegex.Match(nameText);
				if (match.Success)
				{
					Group obj = match.Groups[1];
					return nameText.Remove(obj.Index - 1, obj.Length + 3);
				}
			}
			return nameText;
		}

		public static float GetIconDefaultSize(Minimap minimap)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)minimap.m_mode != 2)
			{
				return minimap.m_pinSizeSmall;
			}
			return minimap.m_pinSizeLarge;
		}
	}
	public static class PinImportExport
	{
		public enum PinFileFormat
		{
			Binary,
			PlainText
		}

		public static void ExportPinsToFile(ConsoleEventArgs args, PinFileFormat exportFormat)
		{
			if (Object.op_Implicit((Object)(object)Minimap.instance))
			{
				object arg = ((args.Length >= 2) ? args[1] : DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString());
				object arg2 = 8;
				string text = string.Format("Pinnacle/{0}.v{1}.{2}", arg, arg2, exportFormat switch
				{
					PinFileFormat.Binary => "pins", 
					PinFileFormat.PlainText => "pins.txt", 
					_ => string.Empty, 
				});
				Directory.CreateDirectory(Path.GetDirectoryName(text));
				IReadOnlyCollection<PinData> readOnlyCollection = FilterPins(Minimap.instance.m_pins, (args.Length >= 3) ? args[2] : string.Empty);
				Pinnacle.LogInfo($"Exporting {readOnlyCollection.Count} pins to file: {text}");
				Pinnacle.LogInfo($"Exported {exportFormat switch
				{
					PinFileFormat.Binary => ExportPinsToBinaryFile(readOnlyCollection, text), 
					PinFileFormat.PlainText => ExportPinsToTextFile(readOnlyCollection, text), 
					_ => 0, 
				}} pins to file: {text} ");
			}
		}

		private static int ExportPinsToBinaryFile(IReadOnlyCollection<PinData> pins, string filename)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected I4, but got Unknown
			using FileStream output = new FileStream(filename, FileMode.CreateNew);
			using BinaryWriter binaryWriter = new BinaryWriter(output);
			int num = 0;
			binaryWriter.Write(pins.Count);
			foreach (PinData pin in pins)
			{
				if (pin.m_save)
				{
					binaryWriter.Write(pin.m_name);
					binaryWriter.Write(pin.m_pos.x);
					binaryWriter.Write(pin.m_pos.y);
					binaryWriter.Write(pin.m_pos.z);
					binaryWriter.Write((int)pin.m_type);
					binaryWriter.Write(pin.m_checked);
					binaryWriter.Write(pin.m_ownerID);
					binaryWriter.Write(((object)Unsafe.As<PlatformUserID, PlatformUserID>(ref pin.m_author)/*cast due to .constrained prefix*/).ToString());
					num++;
				}
			}
			return num;
		}

		private static int ExportPinsToTextFile(IReadOnlyCollection<PinData> pins, string filename)
		{
			//IL_0091: 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)
			using StreamWriter streamWriter = File.CreateText(filename);
			int num = 0;
			foreach (PinData pin in pins)
			{
				if (pin.m_save)
				{
					streamWriter.Write("\"" + pin.m_name + "\",");
					streamWriter.Write($"{pin.m_pos.x},{pin.m_pos.y},{pin.m_pos.z},");
					streamWriter.Write($"{pin.m_type},{pin.m_checked},{pin.m_ownerID},{pin.m_author}");
					streamWriter.WriteLine();
					num++;
				}
			}
			return num;
		}

		public static void ImportPinsFromBinaryFile(ConsoleEventArgs args)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00e8: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: 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_0140: 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_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Minimap.instance) || args.Length < 2)
			{
				return;
			}
			string text = "Pinnacle/" + args[1];
			if (!File.Exists(text))
			{
				args.Context.AddString("Could not find file: " + text);
				return;
			}
			Dictionary<PinType, Sprite> dictionary = Minimap.instance.m_icons.ToDictionary((SpriteData data) => data.m_name, (SpriteData data) => data.m_icon);
			using FileStream input = new FileStream(text, FileMode.Open);
			using BinaryReader binaryReader = new BinaryReader(input);
			int num = binaryReader.ReadInt32();
			List<PinData> list = new List<PinData>(num);
			Pinnacle.LogInfo($"Reading {num} pins from file: {text}");
			for (int num2 = 0; num2 < num; num2++)
			{
				PinData val = new PinData
				{
					m_name = binaryReader.ReadString(),
					m_pos = new Vector3
					{
						x = binaryReader.ReadSingle(),
						y = binaryReader.ReadSingle(),
						z = binaryReader.ReadSingle()
					},
					m_type = (PinType)binaryReader.ReadInt32(),
					m_checked = binaryReader.ReadBoolean(),
					m_ownerID = binaryReader.ReadInt64(),
					m_author = new PlatformUserID(binaryReader.ReadString()),
					m_save = true
				};
				dictionary.TryGetValue(val.m_type, out val.m_icon);
				list.Add(val);
			}
			if (args.Length >= 3)
			{
				list = FilterPins(list, args[2]);
			}
			Pinnacle.LogInfo($"Imported {list.Count} pins from file: {text}");
			Minimap.instance.m_pins.AddRange(list);
		}

		private static List<PinData> FilterPins(IReadOnlyCollection<PinData> pins, string nameRegexPattern)
		{
			if (nameRegexPattern.Length > 0)
			{
				Pinnacle.LogInfo($"Filtering {pins.Count} pins by pin.name with regex: {nameRegexPattern}");
				Regex regex = new Regex(nameRegexPattern, RegexOptions.CultureInvariant, TimeSpan.FromSeconds(1.0));
				return pins.Where((PinData pin) => pin.m_save && regex.Match(pin.m_name).Success).ToList();
			}
			return pins.Where((PinData pin) => pin.m_save).ToList();
		}
	}
	public static class PinMarkerUtils
	{
		public static void SetupPinNamePrefab(Minimap minimap)
		{
			TMP_Text componentInChildren = minimap.m_pinNamePrefab.GetComponentInChildren<TMP_Text>();
			componentInChildren.enableAutoSizing = false;
			componentInChildren.richText = true;
			SetPinNameFont();
			SetPinNameFontSize();
		}

		public static void SetPinNameFont()
		{
			if (!Object.op_Implicit((Object)(object)Minimap.instance))
			{
				return;
			}
			TMP_FontAsset fontAssetByName = UIResources.GetFontAssetByName(PluginConfig.PinFont.Value);
			foreach (TMP_Text pinNameLabel in GetPinNameLabels(Minimap.instance))
			{
				pinNameLabel.font = fontAssetByName;
			}
		}

		public static void SetPinNameFontSize()
		{
			if (!Object.op_Implicit((Object)(object)Minimap.instance))
			{
				return;
			}
			float fontSize = PluginConfig.PinFontSize.Value;
			foreach (TMP_Text pinNameLabel in GetPinNameLabels(Minimap.instance))
			{
				pinNameLabel.fontSize = fontSize;
			}
		}

		private static IEnumerable<TMP_Text> GetPinNameLabels(Minimap minimap)
		{
			TMP_Text[] componentsInChildren = minimap.m_pinNamePrefab.GetComponentsInChildren<TMP_Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				yield return componentsInChildren[i];
			}
			componentsInChildren = ((Component)minimap.m_pinNameRootLarge).GetComponentsInChildren<TMP_Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				yield return componentsInChildren[i];
			}
		}
	}
	public static class PinnacleUtils
	{
		public static void TogglePinnacle(bool toggleOn)
		{
			if (Object.op_Implicit((Object)(object)Minimap.instance) && Object.op_Implicit((Object)(object)Minimap.instance.m_largeRoot))
			{
				PinEditPanelController.TogglePanel();
				PinListPanelController.TogglePanel(toggleOn: false);
				PinFilterPanelController.TogglePanel(toggleOn);
				ToggleVanillaIconPanels(!toggleOn);
			}
		}

		public static void ToggleVanillaIconPanels(bool toggleOn)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)Minimap.instance) || !Object.op_Implicit((Object)(object)Minimap.instance.m_largeRoot))
			{
				return;
			}
			foreach (Transform item in Minimap.instance.m_largeRoot.transform)
			{
				Transform val = item;
				if (((Object)val).name.StartsWith("IconPanel", StringComparison.InvariantCulture))
				{
					((Component)val).gameObject.SetActive(toggleOn);
				}
			}
		}

		public static void CenterMapOnOrTeleportTo(PinData targetPin)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (PluginConfig.IsModEnabled.Value && ((Terminal)Console.m_instance).IsCheatsEnabled() && Object.op_Implicit((Object)(object)Player.m_localPlayer) && ZInput.GetKey((KeyCode)304, true))
			{
				TeleportTo(targetPin);
				return;
			}
			PinEditPanelController.TogglePanel(PluginConfig.PinListPanelEditPinOnRowClick.Value ? targetPin : null);
			CenterMapHelper.CenterMapOnPosition(targetPin.m_pos);
		}

		public static void TeleportTo(PinData targetPin)
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0028: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			Vector3 targetPosition = targetPin.m_pos;
			if ((int)targetPin.m_type == 10 && !targetPin.m_save && !targetPin.m_checked)
			{
				targetPosition = GetPlayerInfoPosition(targetPin);
			}
			TeleportTo(targetPosition);
		}

		public static Vector3 GetPlayerInfoPosition(PinData targetPin)
		{
			//IL_001b: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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)
			//IL_003c: 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)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_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_008b: Unknown result type (might be due to invalid IL or missing references)
			string name = targetPin.m_name;
			foreach (PlayerInfo player in ZNet.m_instance.m_players)
			{
				if (player.m_name == name && player.m_publicPosition)
				{
					Pinnacle.LogInfo($"Found PlayerInfo for {player.m_name}: {targetPin.m_pos:F0} -> {player.m_position:F0}");
					return player.m_position;
				}
			}
			return targetPin.m_pos;
		}

		public static void TeleportTo(Vector3 targetPosition)
		{
			//IL_0019: 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)
			//IL_004d: 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_0065: 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)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer))
			{
				Pinnacle.LogWarning("No local Player found.");
				return;
			}
			if (Mathf.Approximately(targetPosition.y, 0f))
			{
				targetPosition.y = GetHeight(targetPosition);
			}
			Pinnacle.LogInfo($"Teleporting player from {((Component)localPlayer).transform.position:F0} to {targetPosition:F0}.");
			((Character)localPlayer).TeleportTo(targetPosition, ((Component)localPlayer).transform.rotation, true);
			Minimap.instance.SetMapMode((MapMode)1);
		}

		public static float GetHeight(Vector3 targetPosition)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			float num = default(float);
			if (!Heightmap.GetHeight(targetPosition, ref num))
			{
				num = GetHeightmapData(targetPosition).m_baseHeights[0];
			}
			return Mathf.Max(0f, num);
		}

		public static HMBuildData GetHeightmapData(Vector3 targetPosition)
		{
			//IL_0000: 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)
			//IL_0013: Expected O, but got Unknown
			HMBuildData val = new HMBuildData(targetPosition, 1, 1f, false, WorldGenerator.m_instance);
			HeightmapBuilder.m_instance.Build(val);
			return val;
		}

		public static PinData AddNewPin(Minimap minimap, Vector3 targetPosition)
		{
			//IL_0000: 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_0022: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (Mathf.Approximately(targetPosition.y, 0f))
			{
				targetPosition.y = GetHeight(targetPosition);
			}
			return minimap.AddPin(targetPosition, minimap.m_selectedType, string.Empty, true, false, 0L, default(PlatformUserID));
		}

		public static PinData AddQuickMapPin(Minimap minimap, Vector3 targetPosition)
		{
			//IL_0001: 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_001c: 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)
			return minimap.AddPin(targetPosition, PluginConfig.QuickMapPinDefaultPinType.Value, PluginConfig.QuickMapPinDefaultName.Value, true, false, 0L, default(PlatformUserID));
		}
	}
	public sealed class LabelButton
	{
		public GameObject Container { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public TextMeshProUGUI Label { get; private set; }

		public Button Button { get; private set; }

		public LabelButton(Transform parentTransform)
		{
			Container = CreateContainer(parentTransform);
			RectTransform = Container.GetComponent<RectTransform>();
			Label = CreateLabel(Container.transform);
			Button = CreateButton(Container);
		}

		private static GameObject CreateContainer(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_0092: 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_00b2: Expected O, but got Unknown
			GameObject val = new GameObject("Button", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UIResources.GetSprite("button"))
				.SetColor(Color.white);
			val.GetComponent<RectTransform>().SetAnchorMin(new Vector2(0.5f, 0.5f)).SetAnchorMax(new Vector2(0.5f, 0.5f))
				.SetPivot(new Vector2(0.5f, 0.5f))
				.SetPosition(Vector2.zero)
				.SetSizeDelta(new Vector2(120f, 45f));
			return val;
		}

		private static TextMeshProUGUI CreateLabel(Transform parentTransform)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0053: 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)
			TextMeshProUGUI obj = UIBuilder.CreateTMPLabel(parentTransform);
			((TMP_Text)obj.SetFontSize<TextMeshProUGUI>(16f).SetAlignment<TextMeshProUGUI>((TextAlignmentOptions)514)).SetText("Button");
			((TMP_Text)obj).rectTransform.SetAnchorMin(Vector2.zero).SetAnchorMax(Vector2.one).SetPivot(new Vector2(0.5f, 0.5f))
				.SetPosition(Vector2.zero)
				.SetSizeDelta(Vector2.zero);
			return obj;
		}

		private static Button CreateButton(GameObject container)
		{
			//IL_000f: 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)
			Button obj = container.AddComponent<Button>();
			Button selectable = obj.SetTransition<Button>((Transition)2);
			SpriteState spriteState = default(SpriteState);
			((SpriteState)(ref spriteState)).disabledSprite = UIResources.GetSprite("button_disabled");
			((SpriteState)(ref spriteState)).highlightedSprite = UIResources.GetSprite("button_highlight");
			((SpriteState)(ref spriteState)).pressedSprite = UIResources.GetSprite("button_pressed");
			((SpriteState)(ref spriteState)).selectedSprite = UIResources.GetSprite("button_highlight");
			selectable.SetSpriteState<Button>(spriteState);
			return obj;
		}
	}
	public sealed class LabelCell
	{
		public GameObject Container { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public Image Background { get; private set; }

		public TextMeshProUGUI Label { get; private set; }

		public LabelCell(Transform parentTransform)
		{
			Container = CreateContainer(parentTransform);
			RectTransform = Container.GetComponent<RectTransform>();
			Background = Container.GetComponent<Image>();
			Label = CreateLabel(Container.transform);
		}

		private static GameObject CreateContainer(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0080: 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_00bb: 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_0106: Expected O, but got Unknown
			GameObject val = new GameObject("Container", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<HorizontalLayoutGroup>().SetChildControl<HorizontalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<HorizontalLayoutGroup>((bool?)false, (bool?)false)
				.SetPadding<HorizontalLayoutGroup>((int?)4, (int?)4, (int?)4, (int?)4)
				.SetSpacing<HorizontalLayoutGroup>(4f)
				.SetChildAlignment<HorizontalLayoutGroup>((TextAnchor)4);
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UISpriteBuilder.CreateRoundedCornerSprite(64, 64, 8, (FilterMode)1))
				.SetColor(new Color(0.2f, 0.2f, 0.2f, 0.5f));
			val.AddComponent<ContentSizeFitter>().SetHorizontalFit((FitMode)0).SetVerticalFit((FitMode)2);
			val.AddComponent<LayoutElement>().SetPreferred(150f, null).SetFlexible(1f);
			return val;
		}

		private static TextMeshProUGUI CreateLabel(Transform parentTransform)
		{
			TextMeshProUGUI obj = UIBuilder.CreateTMPLabel(parentTransform);
			((TMP_Text)obj.SetName<TextMeshProUGUI>("Label").SetAlignment<TextMeshProUGUI>((TextAlignmentOptions)513)).SetText("Label");
			((Component)obj).gameObject.AddComponent<LayoutElement>().SetFlexible(1f);
			return obj;
		}
	}
	public sealed class LabelRow
	{
		public GameObject Row { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public TextMeshProUGUI Label { get; private set; }

		public LabelRow(Transform parentTransform)
		{
			Row = CreateRow(parentTransform);
			RectTransform = Row.GetComponent<RectTransform>();
			Label = CreateLabel(Row.transform);
		}

		private static GameObject CreateRow(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0081: Expected O, but got Unknown
			GameObject val = new GameObject("Row", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<HorizontalLayoutGroup>().SetChildControl<HorizontalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<HorizontalLayoutGroup>((bool?)false, (bool?)false)
				.SetPadding<HorizontalLayoutGroup>((int?)8, (int?)8, (int?)2, (int?)2)
				.SetSpacing<HorizontalLayoutGroup>(12f)
				.SetChildAlignment<HorizontalLayoutGroup>((TextAnchor)4);
			return val;
		}

		private static TextMeshProUGUI CreateLabel(Transform parentTransform)
		{
			TextMeshProUGUI obj = UIBuilder.CreateTMPLabel(parentTransform);
			((TMP_Text)obj.SetName<TextMeshProUGUI>("Label").SetAlignment<TextMeshProUGUI>((TextAlignmentOptions)513)).SetText("Label");
			((Component)obj).gameObject.AddComponent<LayoutElement>();
			return obj;
		}
	}
	public sealed class LabelValueRow
	{
		public GameObject Row { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public TextMeshProUGUI Label { get; private set; }

		public ValueCell Value { get; private set; }

		public LabelValueRow(Transform parentTransform)
		{
			Row = CreateRow(parentTransform);
			RectTransform = Row.GetComponent<RectTransform>();
			Label = CreateLabel(Row.transform);
			Value = new ValueCell(Row.transform);
		}

		private static GameObject CreateRow(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0081: Expected O, but got Unknown
			GameObject val = new GameObject("Row", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<HorizontalLayoutGroup>().SetChildControl<HorizontalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<HorizontalLayoutGroup>((bool?)false, (bool?)false)
				.SetPadding<HorizontalLayoutGroup>((int?)8, (int?)8, (int?)2, (int?)2)
				.SetSpacing<HorizontalLayoutGroup>(12f)
				.SetChildAlignment<HorizontalLayoutGroup>((TextAnchor)4);
			return val;
		}

		private static TextMeshProUGUI CreateLabel(Transform parentTransform)
		{
			TextMeshProUGUI obj = UIBuilder.CreateTMPLabel(parentTransform);
			((TMP_Text)obj.SetName<TextMeshProUGUI>("Label").SetAlignment<TextMeshProUGUI>((TextAlignmentOptions)513)).SetText("Label");
			((Component)obj).gameObject.AddComponent<LayoutElement>().SetPreferred(75f, null);
			return obj;
		}
	}
	public sealed class ToggleCell
	{
		private static readonly Lazy<ColorBlock> ToggleColorBlock = new Lazy<ColorBlock>((Func<ColorBlock>)delegate
		{
			//IL_0002: 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_0039: 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_0074: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock result = default(ColorBlock);
			((ColorBlock)(ref result)).normalColor = new Color(1f, 1f, 1f, 0.9f);
			((ColorBlock)(ref result)).highlightedColor = new Color(0.565f, 0.792f, 0.976f);
			((ColorBlock)(ref result)).disabledColor = new Color(0.2f, 0.2f, 0.2f, 0.8f);
			((ColorBlock)(ref result)).pressedColor = new Color(0.647f, 0.839f, 0.655f);
			((ColorBlock)(ref result)).selectedColor = new Color(1f, 0.878f, 0.51f);
			((ColorBlock)(ref result)).colorMultiplier = 1f;
			((ColorBlock)(ref result)).fadeDuration = 0.25f;
			return result;
		});

		public GameObject Container { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public TextMeshProUGUI Label { get; private set; }

		public Image Checkbox { get; private set; }

		public Image Checkmark { get; private set; }

		public Toggle Toggle { get; private set; }

		public ToggleCell(Transform parentTransform)
		{
			//IL_00a2: 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)
			Container = CreateContainer(parentTransform);
			RectTransform = Container.GetComponent<RectTransform>();
			Label = CreateLabel(Container.transform);
			Checkbox = CreateCheckbox(Container.transform).Image();
			Checkmark = CreateCheckmark(((Component)Checkbox).transform).Image();
			Toggle = Container.AddComponent<Toggle>();
			Toggle.SetTransition<Toggle>((Transition)1).SetNavigationMode<Toggle>((Mode)0).SetTargetGraphic<Toggle>((Graphic)(object)Checkbox)
				.SetColors<Toggle>(ToggleColorBlock.Value);
			Toggle.graphic = (Graphic)(object)Checkmark;
			Toggle.toggleTransition = (ToggleTransition)1;
		}

		private static GameObject CreateContainer(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0080: 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_00bb: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			GameObject val = new GameObject("Toggle", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<HorizontalLayoutGroup>().SetChildControl<HorizontalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<HorizontalLayoutGroup>((bool?)false, (bool?)false)
				.SetPadding<HorizontalLayoutGroup>((int?)8, (int?)8, (int?)4, (int?)4)
				.SetSpacing<HorizontalLayoutGroup>(8f)
				.SetChildAlignment<HorizontalLayoutGroup>((TextAnchor)4);
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UISpriteBuilder.CreateRoundedCornerSprite(64, 64, 8, (FilterMode)1))
				.SetColor(new Color(0.5f, 0.5f, 0.5f, 0.5f));
			val.AddComponent<Shadow>().SetEffectDistance(new Vector2(2f, -2f));
			val.AddComponent<ContentSizeFitter>().SetHorizontalFit((FitMode)2).SetVerticalFit((FitMode)2);
			return val;
		}

		private static GameObject CreateCheckbox(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0026: 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_0068: 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_0093: 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_00f4: Expected O, but got Unknown
			GameObject val = new GameObject("Checkbox", new Type[1] { typeof(RectTransform) });
			GameObjectExtensions.SetParent(val, parentTransform);
			val.AddComponent<Image>().SetType((Type)3).SetSprite(UISpriteBuilder.CreateRoundedCornerSprite(64, 64, 10, (FilterMode)1))
				.SetColor(new Color(0.5f, 0.5f, 0.5f, 0.9f))
				.SetPreserveAspect(preserveAspect: true);
			val.AddComponent<Shadow>().SetEffectDistance(new Vector2(1f, -1f));
			val.AddComponent<GridLayoutGroup>().SetCellSize(new Vector2(12f, 12f)).SetPadding<GridLayoutGroup>((int?)4, (int?)4, (int?)4, (int?)4)
				.SetConstraint((Constraint)1)
				.SetConstraintCount(1)
				.SetStartAxis((Axis)0)
				.SetStartCorner((Corner)0);
			val.AddComponent<LayoutElement>().SetPreferred(16f, 16f);
			return val;
		}

		private static GameObject CreateCheckmark(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_0077: 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_00a3: Expected O, but got Unknown
			GameObject val = new GameObject("Checkmark", new Type[1] { typeof(RectTransform) });
			GameObjectExtensions.SetParent(val, parentTransform);
			val.AddComponent<Image>().SetType((Type)3).SetSprite(UISpriteBuilder.CreateRoundedCornerSprite(64, 64, 6, (FilterMode)1))
				.SetColor(new Color(0.565f, 0.792f, 0.976f, 0.9f))
				.SetPreserveAspect(preserveAspect: true);
			val.AddComponent<Shadow>().SetEffectDistance(new Vector2(1f, -1f));
			val.AddComponent<LayoutElement>().SetFlexible(1f, 1f);
			return val;
		}

		private static TextMeshProUGUI CreateLabel(Transform parentTransform)
		{
			TextMeshProUGUI obj = UIBuilder.CreateTMPLabel(parentTransform);
			((TMP_Text)obj.SetName<TextMeshProUGUI>("Label").SetAlignment<TextMeshProUGUI>((TextAlignmentOptions)514)).SetText("Toggle");
			return obj;
		}
	}
	public sealed class ValueCell
	{
		private static readonly Lazy<ColorBlock> InputFieldColorBlock = new Lazy<ColorBlock>((Func<ColorBlock>)delegate
		{
			//IL_0002: 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_0039: 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_0074: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock result = default(ColorBlock);
			((ColorBlock)(ref result)).normalColor = new Color(1f, 1f, 1f, 0.9f);
			((ColorBlock)(ref result)).highlightedColor = new Color(0.565f, 0.792f, 0.976f);
			((ColorBlock)(ref result)).disabledColor = new Color(0.2f, 0.2f, 0.2f, 0.8f);
			((ColorBlock)(ref result)).pressedColor = new Color(0.647f, 0.839f, 0.655f);
			((ColorBlock)(ref result)).selectedColor = new Color(1f, 0.878f, 0.51f);
			((ColorBlock)(ref result)).colorMultiplier = 1f;
			((ColorBlock)(ref result)).fadeDuration = 0.25f;
			return result;
		});

		public GameObject Container { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public LayoutElement LayoutElement { get; private set; }

		public Image Background { get; private set; }

		public TMP_InputField InputField { get; private set; }

		public ValueCell(Transform parentTransform)
		{
			Container = CreateContainer(parentTransform);
			RectTransform = Container.GetComponent<RectTransform>();
			LayoutElement = Container.GetComponent<LayoutElement>();
			Background = Container.GetComponent<Image>();
			InputField = CreateValueInputField(Container.transform);
			InputField.SetTargetGraphic<TMP_InputField>((Graphic)(object)Background);
		}

		private static GameObject CreateContainer(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_005a: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			GameObject val = new GameObject("Value", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UISpriteBuilder.CreateRoundedCornerSprite(64, 64, 8, (FilterMode)1))
				.SetColor(new Color(0.5f, 0.5f, 0.5f, 0.5f));
			val.AddComponent<RectMask2D>();
			val.AddComponent<LayoutElement>();
			return val;
		}

		private TMP_InputField CreateValueInputField(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_002d: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InputField", new Type[1] { typeof(RectTransform) });
			val.SetParent(parentTransform);
			val.GetComponent<RectTransform>().SetAnchorMin(Vector2.zero).SetAnchorMax(Vector2.one)
				.SetSizeDelta(Vector2.zero)
				.SetPosition(Vector2.zero);
			TextMeshProUGUI val2 = UIBuilder.CreateTMPLabel(val.transform);
			((TMP_Text)val2.SetName<TextMeshProUGUI>("Label").SetRichText<TextMeshProUGUI>(richText: false).SetAlignment<TextMeshProUGUI>((TextAlignmentOptions)513)).SetText("Label");
			TMP_InputField obj = ((Component)parentTransform).gameObject.AddComponent<TMP_InputField>();
			obj.SetTextComponent<TMP_InputField>((TMP_Text)(object)val2).SetTextViewport<TMP_InputField>(val.GetComponent<RectTransform>()).SetOnFocusSelectAll<TMP_InputField>(onFocusSelectAll: false)
				.SetDoubleClickDelay<TMP_InputField>(0.2f);
			obj.SetTransition<TMP_InputField>((Transition)1).SetColors<TMP_InputField>(InputFieldColorBlock.Value).SetNavigationMode<TMP_InputField>((Mode)0);
			return obj;
		}
	}
	public sealed class VectorCell
	{
		public GameObject Container { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public TextMeshProUGUI XLabel { get; private set; }

		public ValueCell XValue { get; private set; }

		public TextMeshProUGUI YLabel { get; private set; }

		public ValueCell YValue { get; private set; }

		public TextMeshProUGUI ZLabel { get; private set; }

		public ValueCell ZValue { get; private set; }

		public VectorCell(Transform parentTransform)
		{
			//IL_00d1: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: 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_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			Container = CreateContainer(parentTransform);
			RectTransform = Container.GetComponent<RectTransform>();
			XValue = new ValueCell(Container.transform);
			XLabel = UIBuilder.CreateTMPLabel(XValue.Container.transform);
			((TMP_Text)XLabel).transform.SetAsFirstSibling();
			((TMP_Text)XLabel).alignment = (TextAlignmentOptions)513;
			((TMP_Text)XLabel).SetText("X");
			XValue.InputField.textComponent.alignment = (TextAlignmentOptions)516;
			XValue.Container.GetComponent<LayoutElement>().SetFlexible(1f).SetPreferred(((TMP_Text)XLabel).GetPreferredValues("-99999") + new Vector2(0f, 8f));
			YValue = new ValueCell(Container.transform);
			YLabel = UIBuilder.CreateTMPLabel(YValue.Container.transform);
			((TMP_Text)YLabel).transform.SetAsFirstSibling();
			((TMP_Text)YLabel).alignment = (TextAlignmentOptions)513;
			((TMP_Text)YLabel).SetText("Y");
			YValue.InputField.textComponent.alignment = (TextAlignmentOptions)516;
			YValue.Container.GetComponent<LayoutElement>().SetFlexible(1f).SetPreferred(((TMP_Text)YLabel).GetPreferredValues("-99999") + new Vector2(0f, 8f));
			ZValue = new ValueCell(Container.transform);
			ZLabel = UIBuilder.CreateTMPLabel(ZValue.Container.transform);
			((TMP_Text)ZLabel).transform.SetAsFirstSibling();
			((TMP_Text)ZLabel).alignment = (TextAlignmentOptions)513;
			((TMP_Text)ZLabel).SetText("Z");
			ZValue.InputField.textComponent.alignment = (TextAlignmentOptions)516;
			ZValue.Container.GetComponent<LayoutElement>().SetFlexible(1f).SetPreferred(((TMP_Text)ZLabel).GetPreferredValues("-99999") + new Vector2(0f, 8f));
		}

		private static GameObject CreateContainer(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0064: Expected O, but got Unknown
			GameObject val = new GameObject("Vector3", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<HorizontalLayoutGroup>().SetChildControl<HorizontalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<HorizontalLayoutGroup>((bool?)false, (bool?)false)
				.SetSpacing<HorizontalLayoutGroup>(8f)
				.SetChildAlignment<HorizontalLayoutGroup>((TextAnchor)4);
			return val;
		}
	}
	public sealed class DisableHighlightOnSelect : MonoBehaviour, ISelectHandler, IEventSystemHandler
	{
		private InputField _inputField;

		private void Start()
		{
			_inputField = ((Component)this).GetComponent<InputField>();
		}

		public void OnSelect(BaseEventData eventData)
		{
			((MonoBehaviour)this).StartCoroutine(DisableHighlight());
		}

		private IEnumerator DisableHighlight()
		{
			Color original = _inputField.selectionColor;
			_inputField.selectionColor = Color.clear;
			yield return null;
			_inputField.MoveTextEnd(false);
			_inputField.selectionColor = original;
		}
	}
	public sealed class PanelDragger : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler, IEndDragHandler
	{
		private Vector2 _lastMousePosition;

		public RectTransform TargetRectTransform;

		public event EventHandler<Vector3> OnPanelEndDrag;

		public void OnBeginDrag(PointerEventData eventData)
		{
			//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)
			_lastMousePosition = eventData.position;
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0001: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_005d: 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)
			//IL_002b: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//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)
			Vector2 val = eventData.position - _lastMousePosition;
			if (Object.op_Implicit((Object)(object)TargetRectTransform))
			{
				RectTransform targetRectTransform = TargetRectTransform;
				((Transform)targetRectTransform).position = ((Transform)targetRectTransform).position + new Vector3(val.x, val.y, ((Transform)TargetRectTransform).position.z);
			}
			_lastMousePosition = eventData.position;
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)TargetRectTransform))
			{
				this.OnPanelEndDrag?.Invoke(this, Vector2.op_Implicit(TargetRectTransform.anchoredPosition));
			}
		}
	}
	public sealed class PanelResizer : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, IBeginDragHandler, IDragHandler, IEndDragHandler
	{
		private CanvasGroup _canvasGroup;

		private float _targetAlpha;

		private Vector2 _lastMousePosition;

		private Coroutine _lerpAlphaCoroutine;

		public RectTransform TargetRectTransform;

		public event EventHandler<Vector2> OnPanelEndResize;

		private void Awake()
		{
			_canvasGroup = ((Component)this).GetComponent<CanvasGroup>();
		}

		private void SetCanvasGroupAlpha(float alpha)
		{
			if (_lerpAlphaCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_lerpAlphaCoroutine);
				_lerpAlphaCoroutine = null;
			}
			if (_canvasGroup.alpha != alpha)
			{
				_lerpAlphaCoroutine = ((MonoBehaviour)this).StartCoroutine(LerpCanvasGroupAlpha(alpha, 0.25f));
			}
		}

		private IEnumerator LerpCanvasGroupAlpha(float targetAlpha, float lerpDuration)
		{
			float timeElapsed = 0f;
			float sourceAlpha = _canvasGroup.alpha;
			while (timeElapsed < lerpDuration)
			{
				float num = timeElapsed / lerpDuration;
				num = num * num * (3f - 2f * num);
				_canvasGroup.SetAlpha(Mathf.Lerp(sourceAlpha, targetAlpha, num));
				timeElapsed += Time.deltaTime;
				yield return null;
			}
			_canvasGroup.SetAlpha(targetAlpha);
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			_targetAlpha = 1f;
			SetCanvasGroupAlpha(_targetAlpha);
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			_targetAlpha = 0f;
			if (!eventData.dragging)
			{
				SetCanvasGroupAlpha(_targetAlpha);
			}
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			SetCanvasGroupAlpha(1f);
			_lastMousePosition = eventData.position;
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0001: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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)
			//IL_008a: 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)
			//IL_0035: 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_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_005c: 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_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)
			Vector2 val = _lastMousePosition - eventData.position;
			if (Object.op_Implicit((Object)(object)TargetRectTransform))
			{
				RectTransform targetRectTransform = TargetRectTransform;
				targetRectTransform.anchoredPosition += new Vector2(0f, -0.5f * val.y);
				RectTransform targetRectTransform2 = TargetRectTransform;
				targetRectTransform2.sizeDelta += new Vector2(-1f * val.x, val.y);
			}
			SetCanvasGroupAlpha(1f);
			_lastMousePosition = eventData.position;
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			SetCanvasGroupAlpha(_targetAlpha);
			this.OnPanelEndResize?.Invoke(this, TargetRectTransform.sizeDelta);
		}
	}
	public sealed class ParentSizeFitter : MonoBehaviour
	{
		private RectTransform _parentRectTransform;

		private RectTransform _rectTransform;

		private void Awake()
		{
			_parentRectTransform = ((Component)((Component)this).transform.parent).GetComponent<RectTransform>();
			_rectTransform = ((Component)this).GetComponent<RectTransform>();
		}

		private void OnRectTransformDimensionsChange()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_parentRectTransform))
			{
				_parentRectTransform = ((Component)((Component)this).transform.parent).GetComponent<RectTransform>();
			}
			if (!Object.op_Implicit((Object)(object)_rectTransform))
			{
				_rectTransform = ((Component)this).GetComponent<RectTransform>();
			}
			if (Object.op_Implicit((Object)(object)_rectTransform) && Object.op_Implicit((Object)(object)_parentRectTransform))
			{
				_rectTransform.SetSizeWithCurrentAnchors((Axis)0, _parentRectTransform.sizeDelta.x);
			}
		}
	}
	public sealed class PointerState : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public bool IsPointerHovered { get; private set; }

		public void OnPointerEnter(PointerEventData eventData)
		{
			IsPointerHovered = true;
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			IsPointerHovered = false;
		}
	}
	public sealed class PinEditPanel
	{
		public const long DefaultSharedPinOwnerId = long.MaxValue;

		private readonly List<TextMeshProUGUI> _rowLabels = new List<TextMeshProUGUI>();

		private readonly HashSet<GameObject> _selectables = new HashSet<GameObject>();

		private Coroutine _setActiveCoroutine;

		public GameObject Panel { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public CanvasGroup CanvasGroup { get; private set; }

		public LabelValueRow PinNameRow { get; private set; }

		public LabelRow PinIconSelectorRow { get; private set; }

		public PinIconSelector PinIconSelector { get; private set; }

		public LabelValueRow PinTypeRow { get; private set; }

		public LabelRow PinModifierRow { get; private set; }

		public ToggleCell PinCheckedToggle { get; private set; }

		public ToggleCell PinSharedToggle { get; private set; }

		public LabelRow PinPositionRow { get; private set; }

		public VectorCell PinPosition { get; private set; }

		public PinData TargetPin { get; private set; }

		public PinEditPanel(Transform parentTransform)
		{
			Panel = CreatePanel(parentTransform);
			RectTransform = Panel.GetComponent<RectTransform>();
			CanvasGroup = Panel.GetComponent<CanvasGroup>();
			PinNameRow = CreatePinNameRow(Panel.transform);
			PinIconSelectorRow = CreatePinIconSelectorRow(Panel.transform);
			PinIconSelector = CreatePinIconSelector(PinIconSelectorRow.Row.transform);
			PinTypeRow = CreatePinTypeRow(Panel.transform);
			PinModifierRow = CreatePinModifierRow(Panel.transform);
			PinCheckedToggle = CreatePinCheckedToggle(PinModifierRow.Row.transform);
			PinSharedToggle = CreatePinSharedToggle(PinModifierRow.Row.transform);
			PinPositionRow = CreatePinPositionRow(Panel.transform);
			PinPosition = CreatePinPosition(PinPositionRow.Row.transform);
			CacheSelectables();
			CacheRowLabels();
			SetupPanelStyle();
		}

		private void CacheSelectables()
		{
			Selectable[] componentsInChildren = Panel.GetComponentsInChildren<Selectable>();
			foreach (Selectable val in componentsInChildren)
			{
				_selectables.Add(((Component)val).gameObject);
			}
		}

		private void CacheRowLabels()
		{
			_rowLabels.Add(PinNameRow.Label);
			_rowLabels.Add(PinIconSelectorRow.Label);
			_rowLabels.Add(PinTypeRow.Label);
			_rowLabels.Add(PinModifierRow.Label);
			_rowLabels.Add(PinPositionRow.Label);
		}

		public void SetActive(bool toggle)
		{
			if (_setActiveCoroutine != null)
			{
				((MonoBehaviour)Minimap.instance).StopCoroutine(_setActiveCoroutine);
			}
			_setActiveCoroutine = ((MonoBehaviour)Minimap.instance).StartCoroutine(LerpCanvasGroupAlpha(CanvasGroup, toggle ? 1f : 0f, PluginConfig.PinEditPanelToggleLerpDuration.Value));
		}

		private static IEnumerator LerpCanvasGroupAlpha(CanvasGroup canvasGroup, float targetAlpha, float lerpDuration)
		{
			float timeElapsed = 0f;
			float sourceAlpha = canvasGroup.alpha;
			canvasGroup.SetBlocksRaycasts(targetAlpha > 0f);
			while (timeElapsed < lerpDuration)
			{
				float num = timeElapsed / lerpDuration;
				num = num * num * (3f - 2f * num);
				canvasGroup.SetAlpha(Mathf.Lerp(sourceAlpha, targetAlpha, num));
				timeElapsed += Time.deltaTime;
				yield return null;
			}
			canvasGroup.SetAlpha(targetAlpha);
		}

		public void SetupPanelStyle()
		{
			float num = 0f;
			foreach (TextMeshProUGUI rowLabel in _rowLabels)
			{
				if (((TMP_Text)rowLabel).preferredWidth > num)
				{
					num = ((TMP_Text)rowLabel).preferredWidth;
				}
			}
			foreach (TextMeshProUGUI rowLabel2 in _rowLabels)
			{
				((TMP_Text)rowLabel2).layoutElement.SetPreferred(num, null);
			}
			PinNameRow.Value.LayoutElement.SetPreferred(200f, null);
			PinTypeRow.Value.LayoutElement.SetPreferred(200f, null);
		}

		public bool HasFocus()
		{
			GameObject currentSelectedGameObject = EventSystem.current.currentSelectedGameObject;
			if (Object.op_Implicit((Object)(object)currentSelectedGameObject) && _selectables.Contains(currentSelectedGameObject))
			{
				InputField val = default(InputField);
				if (currentSelectedGameObject.TryGetComponent<InputField>(ref val) && !val.isFocused)
				{
					return ZInput.GetKeyDown((KeyCode)13, true);
				}
				return true;
			}
			return false;
		}

		public void SetTargetPin(PinData pin)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			TargetPin = pin;
			if (pin != null)
			{
				PinNameRow.Value.InputField.SetTextWithoutNotify(pin.m_name);
				PinIconSelector.UpdateIcons(pin.m_type);
				PinTypeRow.Value.InputField.text = ((object)Unsafe.As<PinType, PinType>(ref pin.m_type)/*cast due to .constrained prefix*/).ToString();
				PinCheckedToggle.Toggle.SetIsOnWithoutNotify(pin.m_checked);
				PinSharedToggle.Toggle.SetIsOnWithoutNotify(pin.m_ownerID != 0);
				PinPosition.XValue.InputField.text = $"{pin.m_pos.x:F0}";
				PinPosition.YValue.InputField.text = $"{pin.m_pos.y:F0}";
				PinPosition.ZValue.InputField.text = $"{pin.m_pos.z:F0}";
			}
		}

		public void ActivatePinNameInputField()
		{
			PinNameRow.Value.InputField.ActivateInputField();
		}

		private void OnPinNameValueChange(string name)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if (TargetPin != null)
			{
				TargetPin.m_name = name;
				if (TargetPin.m_NamePinData == null)
				{
					TargetPin.m_NamePinData = new PinNameData(TargetPin);
					Minimap.instance.CreateMapNamePin(TargetPin, Minimap.instance.m_pinNameRootLarge);
				}
				TargetPin.m_NamePinData.PinNameText.SetText(name);
				PinIconManager.ProcessIconTagsModified(TargetPin);
			}
		}

		private unsafe void OnPinTypeValueChange(PinType pinType)
		{
			//IL_0005: 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_001a: 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_002b: 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)
			Minimap.instance.m_selectedType = pinType;
			if (TargetPin != null)
			{
				TargetPin.m_type = pinType;
				TargetPin.m_icon = Minimap.instance.GetSprite(pinType);
				TargetPin.m_iconElement.SetSprite(TargetPin.m_icon);
				PinIconSelector.UpdateIcons(pinType);
				PinTypeRow.Value.InputField.text = ((object)(*(PinType*)(&pinType))/*cast due to .constrained prefix*/).ToString();
			}
		}

		private void OnPinCheckedChange(bool pinChecked)
		{
			if (TargetPin != null)
			{
				TargetPin.m_checked = pinChecked;
				TargetPin.m_checkedElement.SetActive(pinChecked);
			}
		}

		private void OnPinSharedChange(bool pinShared)
		{
			if (TargetPin != null)
			{
				TargetPin.m_ownerID = ((TargetPin.m_ownerID == 0L) ? long.MaxValue : 0);
			}
		}

		private void OnPinPositionValueChange(string value)
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			if (TargetPin == null)
			{
				return;
			}
			if (!float.TryParse(PinPosition.XValue.InputField.text, out var result) || !float.TryParse(PinPosition.YValue.InputField.text, out var result2) || !float.TryParse(PinPosition.ZValue.InputField.text, out var result3))
			{
				PinPosition.XValue.InputField.text = $"{TargetPin.m_pos.x:F0}";
				PinPosition.YValue.InputField.text = $"{TargetPin.m_pos.y:F0}";
				PinPosition.ZValue.InputField.text = $"{TargetPin.m_pos.z:F0}";
				return;
			}
			TargetPin.m_pos = new Vector3(result, result2, result3);
			Vector2 mapImagePosition = GetMapImagePosition(TargetPin.m_pos);
			TargetPin.m_uiElement.SetPosition(mapImagePosition);
			PinNameData namePinData = TargetPin.m_NamePinData;
			if (namePinData != null)
			{
				namePinData.PinNameRectTransform.SetPosition(mapImagePosition);
			}
			CenterMapHelper.CenterMapOnPosition(TargetPin.m_pos);
		}

		private static Vector2 GetMapImagePosition(Vector3 mapPosition)
		{
			//IL_0005: 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)
			float num = default(float);
			float num2 = default(float);
			Minimap.instance.WorldToMapPoint(mapPosition, ref num, ref num2);
			return Minimap.instance.MapPointToLocalGuiPos(num, num2, Minimap.instance.m_mapImageLarge);
		}

		private static GameObject CreatePanel(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_007a: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			GameObject val = new GameObject("PinEditPanel", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<VerticalLayoutGroup>().SetChildControl<VerticalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<VerticalLayoutGroup>((bool?)false, (bool?)false)
				.SetPadding<VerticalLayoutGroup>((int?)2, (int?)2, (int?)8, (int?)8)
				.SetSpacing<VerticalLayoutGroup>(4f);
			val.AddComponent<ContentSizeFitter>().SetHorizontalFit((FitMode)2).SetVerticalFit((FitMode)2);
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UISpriteBuilder.CreateSuperellipse(200, 200, 10f))
				.SetColor(new Color(0f, 0f, 0f, 0.9f));
			val.AddComponent<Canvas>();
			val.AddComponent<GraphicRaycaster>();
			val.AddComponent<CanvasGroup>().SetBlocksRaycasts(blocksRaycasts: true);
			return val;
		}

		private LabelValueRow CreatePinNameRow(Transform parentTransform)
		{
			LabelValueRow labelValueRow = new LabelValueRow(parentTransform);
			((TMP_Text)labelValueRow.Label).SetText("Name");
			LayoutElement layoutElement = labelValueRow.Value.LayoutElement.SetFlexible(1f);
			float? height = labelValueRow.Value.InputField.preferredHeight + 8f;
			layoutElement.SetPreferred(null, height);
			((UnityEvent<string>)(object)labelValueRow.Value.InputField.onEndEdit).AddListener((UnityAction<string>)OnPinNameValueChange);
			return labelValueRow;
		}

		private static LabelRow CreatePinIconSelectorRow(Transform parentTransform)
		{
			LabelRow labelRow = new LabelRow(parentTransform);
			((TMP_Text)labelRow.Label.SetAlignment<TextMeshProUGUI>((TextAlignmentOptions)257)).SetText("Icon");
			return labelRow;
		}

		private PinIconSelector CreatePinIconSelector(Transform parentTransform)
		{
			PinIconSelector pinIconSelector = new PinIconSelector(parentTransform);
			pinIconSelector.OnPinIconClick.AddListener((UnityAction<PinType>)OnPinTypeValueChange);
			return pinIconSelector;
		}

		private static LabelValueRow CreatePinTypeRow(Transform parentTransform)
		{
			LabelValueRow labelValueRow = new LabelValueRow(parentTransform);
			((TMP_Text)labelValueRow.Label).SetText("Type");
			labelValueRow.Value.InputField.SetInteractable<TMP_InputField>(interactable: false);
			return labelValueRow;
		}

		private static LabelRow CreatePinModifierRow(Transform parentTransform)
		{
			LabelRow labelRow = new LabelRow(parentTransform);
			((TMP_Text)labelRow.Label).SetText("Modifier");
			return labelRow;
		}

		private ToggleCell CreatePinCheckedToggle(Transform parentTransform)
		{
			ToggleCell toggleCell = new ToggleCell(parentTransform);
			((TMP_Text)toggleCell.Label).SetText("Checked");
			((UnityEvent<bool>)(object)toggleCell.Toggle.onValueChanged).AddListener((UnityAction<bool>)OnPinCheckedChange);
			return toggleCell;
		}

		private ToggleCell CreatePinSharedToggle(Transform parentTransform)
		{
			ToggleCell toggleCell = new ToggleCell(parentTransform);
			((TMP_Text)toggleCell.Label).SetText("Shared");
			((UnityEvent<bool>)(object)toggleCell.Toggle.onValueChanged).AddListener((UnityAction<bool>)OnPinSharedChange);
			return toggleCell;
		}

		private static LabelRow CreatePinPositionRow(Transform parentTransform)
		{
			LabelRow labelRow = new LabelRow(parentTransform);
			((TMP_Text)labelRow.Label).SetText("Position");
			return labelRow;
		}

		private VectorCell CreatePinPosition(Transform parentTransform)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			VectorCell vectorCell = new VectorCell(parentTransform);
			SetupPinPositionValueInputField(vectorCell.XValue.InputField, new Color(1f, 0.878f, 0.51f));
			SetupPinPositionValueInputField(vectorCell.YValue.InputField, new Color(0.565f, 0.792f, 0.976f));
			SetupPinPositionValueInputField(vectorCell.ZValue.InputField, new Color(0.647f, 0.839f, 0.655f));
			return vectorCell;
		}

		private void SetupPinPositionValueInputField(TMP_InputField inputField, Color textColor)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)inputField.textComponent).color = textColor;
			inputField.contentType = (ContentType)3;
			inputField.characterValidation = (CharacterValidation)3;
			((UnityEvent<string>)(object)inputField.onEndEdit).AddListener((UnityAction<string>)OnPinPositionValueChange);
		}
	}
	public sealed class PinFilterPanel
	{
		public GameObject Panel { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public PanelDragger PanelDragger { get; private set; }

		public PinIconSelector PinIconSelector { get; private set; }

		public PinFilterPanel(Transform parentTransform)
		{
			Panel = CreatePanel(parentTransform);
			RectTransform = Panel.GetComponent<RectTransform>();
			PanelDragger = CreateDragger(Panel.transform).AddComponent<PanelDragger>();
			PanelDragger.TargetRectTransform = RectTransform;
			PinIconSelector = new PinIconSelector(Panel.transform);
			PinIconSelector.GridLayoutGroup.SetConstraint((Constraint)1).SetConstraintCount(2).SetStartAxis((Axis)1);
			PinIconSelector.OnPinIconClick.AddListener((UnityAction<PinType>)ProcessOnPinIconClick);
			SetPanelStyle();
		}

		private void ProcessOnPinIconClick(PinType pinType)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Minimap obj = Minimap.instance.Ref<Minimap>();
			if (obj != null)
			{
				obj.ToggleIconFilter(pinType);
			}
		}

		public void SetPanelStyle()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			PinIconSelector.GridLayoutGroup.SetCellSize(new Vector2(PluginConfig.PinFilterPanelGridIconSize.Value, PluginConfig.PinFilterPanelGridIconSize.Value));
		}

		public void UpdatePinIconFilters()
		{
			//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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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)
			foreach (PinType key in PinIconSelector.IconsByType.Keys)
			{
				PinIconSelector.IconsByType[key].Image().Ref<Image>()?.SetColor(Minimap.instance.m_visibleIconTypes[key] ? Color.white : Color.gray);
			}
		}

		private static GameObject CreatePanel(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_007a: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			GameObject val = new GameObject("PinFilterPanel", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<VerticalLayoutGroup>().SetChildControl<VerticalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<VerticalLayoutGroup>((bool?)false, (bool?)false)
				.SetPadding<VerticalLayoutGroup>((int?)8, (int?)8, (int?)8, (int?)8)
				.SetSpacing<VerticalLayoutGroup>(4f);
			val.AddComponent<ContentSizeFitter>().SetHorizontalFit((FitMode)2).SetVerticalFit((FitMode)2);
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UISpriteBuilder.CreateSuperellipse(200, 200, 10f))
				.SetColor(new Color(0f, 0f, 0f, 0.9f));
			val.AddComponent<Canvas>();
			val.AddComponent<GraphicRaycaster>();
			val.AddComponent<CanvasGroup>().SetBlocksRaycasts(blocksRaycasts: true);
			return val;
		}

		private static GameObject CreateDragger(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0082: Expected O, but got Unknown
			GameObject val = new GameObject("Dragger", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<LayoutElement>().SetIgnoreLayout(ignoreLayout: true);
			GameObjectExtensions.RectTransform(val).SetAnchorMin(Vector2.zero).SetAnchorMax(Vector2.one)
				.SetPivot(new Vector2(0.5f, 0.5f))
				.SetSizeDelta(Vector2.zero);
			val.AddComponent<Image>().SetColor(Color.clear);
			return val;
		}
	}
	public sealed class PinIconSelector
	{
		private static readonly Lazy<ColorBlock> ButtonColorBlock = new Lazy<ColorBlock>((Func<ColorBlock>)delegate
		{
			//IL_0002: 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_0039: 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_0074: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock result = default(ColorBlock);
			((ColorBlock)(ref result)).normalColor = new Color(1f, 1f, 1f, 0.8f);
			((ColorBlock)(ref result)).highlightedColor = new Color(0.565f, 0.792f, 0.976f);
			((ColorBlock)(ref result)).disabledColor = new Color(0f, 0f, 0f, 0.5f);
			((ColorBlock)(ref result)).pressedColor = new Color(0.647f, 0.839f, 0.655f);
			((ColorBlock)(ref result)).selectedColor = new Color(1f, 0.878f, 0.51f);
			((ColorBlock)(ref result)).colorMultiplier = 1f;
			((ColorBlock)(ref result)).fadeDuration = 0.25f;
			return result;
		});

		public UnityEvent<PinType> OnPinIconClick { get; private set; } = new UnityEvent<PinType>();

		public GameObject Grid { get; private set; }

		public GridLayoutGroup GridLayoutGroup { get; private set; }

		public List<GameObject> Icons { get; } = new List<GameObject>();

		public Dictionary<PinType, GameObject> IconsByType { get; } = new Dictionary<PinType, GameObject>();

		public PinIconSelector(Transform parentTransform)
		{
			Grid = CreateChildGrid(parentTransform);
			GridLayoutGroup = Grid.GetComponent<GridLayoutGroup>();
			CreateIcons(Grid.transform);
		}

		private void CreateIcons(Transform parentTransform)
		{
			//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)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			foreach (PinType pinType in Enum.GetValues(typeof(PinType)))
			{
				Sprite sprite = Minimap.instance.GetSprite(pinType);
				if (Object.op_Implicit((Object)(object)sprite))
				{
					GameObject val = CreateChildIcon(parentTransform);
					Icons.Add(val);
					IconsByType[pinType] = val;
					val.Image().SetSprite(sprite);
					((UnityEvent)val.AddComponent<Button>().SetNavigationMode<Button>((Mode)0).SetTargetGraphic<Button>((Graphic)(object)val.Image())
						.SetTransition<Button>((Transition)1)
						.SetColors<Button>(ButtonColorBlock.Value)
						.onClick).AddListener((UnityAction)delegate
					{
						//IL_000c: Unknown result type (might be due to invalid IL or missing references)
						OnPinIconClick.Invoke(pinType);
					});
				}
			}
		}

		public void UpdateIcons(PinType pinType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_0089: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			Sprite obj = Minimap.instance.GetSprite(pinType).Ref<Sprite>();
			string text = ((obj != null) ? ((Object)obj).name : null);
			foreach (Image item in Icons.Select((GameObject i) => i.Image()))
			{
				ColorBlock value;
				Color color;
				if (!(((Object)item.sprite).name == text))
				{
					value = ButtonColorBlock.Value;
					color = ((ColorBlock)(ref value)).normalColor;
				}
				else
				{
					value = ButtonColorBlock.Value;
					color = ((ColorBlock)(ref value)).selectedColor;
				}
				item.SetColor(color);
			}
		}

		public void SetIconSize(Vector2 sizeDelta)
		{
			//IL_0038: 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)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			foreach (LayoutElement item in Icons.Select((GameObject icon) => icon.LayoutElement()))
			{
				item.SetFlexible(sizeDelta.x, sizeDelta.y);
			}
			Grid.GetComponent<GridLayoutGroup>().SetCellSize(sizeDelta);
		}

		private GameObject CreateChildGrid(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0026: 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_004a: 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_008d: Expected O, but got Unknown
			GameObject val = new GameObject("PinIconSelector.Grid", new Type[1] { typeof(RectTransform) });
			GameObjectExtensions.SetParent(val, parentTransform);
			val.AddComponent<GridLayoutGroup>().SetCellSize(new Vector2(25f, 25f)).SetSpacing(new Vector2(8f, 8f))
				.SetConstraint((Constraint)2)
				.SetConstraintCount(2)
				.SetStartAxis((Axis)0)
				.SetStartCorner((Corner)0);
			val.AddComponent<LayoutElement>().SetFlexible(1f);
			return val;
		}

		private GameObject CreateChildIcon(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			GameObject val = new GameObject("Icon", new Type[1] { typeof(RectTransform) });
			GameObjectExtensions.SetParent(val, parentTransform);
			val.AddComponent<Image>().SetType((Type)0).SetPreserveAspect(preserveAspect: true);
			val.AddComponent<LayoutElement>().SetPreferred(25f, 25f);
			return val;
		}
	}
	public sealed class PinListPanel
	{
		private readonly PointerState _pointerState;

		public readonly List<PinData> TargetPins = new List<PinData>();

		private readonly List<PinListRow> _rowCache = new List<PinListRow>();

		private int _visibleRows;

		private float _rowPreferredHeight;

		private LayoutElement _bufferBlock;

		private bool _isRefreshing;

		private int _previousRowIndex = -1;

		public GameObject Panel { get; private set; }

		public RectTransform RectTransform { get; private set; }

		public CanvasGroup CanvasGroup { get; private set; }

		public Image Background { get; private set; }

		public ValueCell PinNameFilter { get; private set; }

		public GameObject Viewport { get; private set; }

		public GameObject Content { get; private set; }

		public ScrollRect ScrollRect { get; private set; }

		public LabelCell PinStats { get; private set; }

		public LabelButton RefreshButton { get; private set; }

		public PanelDragger PanelDragger { get; private set; }

		public PanelResizer PanelResizer { get; private set; }

		public PinListPanel(Transform parentTransform)
		{
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			Panel = CreatePanel(parentTransform);
			RectTransform = Panel.GetComponent<RectTransform>();
			CanvasGroup = Panel.GetComponent<CanvasGroup>();
			Background = Panel.GetComponent<Image>();
			PanelDragger = CreateDragger(Panel.transform).AddComponent<PanelDragger>();
			PanelDragger.TargetRectTransform = RectTransform;
			PanelResizer = CreateResizer(Panel.transform).AddComponent<PanelResizer>();
			PanelResizer.TargetRectTransform = RectTransform;
			PinNameFilter = new ValueCell(Panel.transform);
			LayoutElement layoutElement = PinNameFilter.Container.LayoutElement().SetFlexible(1f);
			float? height = 30f;
			layoutElement.SetPreferred(null, height);
			((UnityEvent<string>)(object)PinNameFilter.InputField.onValueChanged).AddListener((UnityAction<string>)SetTargetPins);
			Viewport = CreateViewport(Panel.transform);
			Content = CreateContent(Viewport.transform);
			ScrollRect = CreateScrollRect(Panel, Viewport, Content);
			PinStats = new LabelCell(Panel.transform);
			PinStats.Container.GetComponent<HorizontalLayoutGroup>().SetPadding<HorizontalLayoutGroup>((int?)8, (int?)8, (int?)2, (int?)2);
			PinStats.Background.SetColor(new Color(0.5f, 0.5f, 0.5f, 0.1f));
			PinStats.Container.AddComponent<Outline>().SetEffectDistance(new Vector2(2f, -2f));
			RefreshButton = CreateRefreshButton(PinStats.Container.transform);
			((UnityEvent)RefreshButton.Button.onClick).AddListener(new UnityAction(RefreshTargetPins));
			_pointerState = Panel.AddComponent<PointerState>();
		}

		public bool HasFocus()
		{
			if (Object.op_Implicit((Object)(object)Panel) && Panel.activeInHierarchy)
			{
				return _pointerState.IsPointerHovered;
			}
			return false;
		}

		private static bool IsPinNameValid(PinData pin, string filter)
		{
			if (filter.Length != 0)
			{
				if (pin.m_name.Length > 0)
				{
					return pin.m_name.IndexOf(filter, 0, StringComparison.InvariantCultureIgnoreCase) >= 0;
				}
				return false;
			}
			return true;
		}

		public void RefreshTargetPins()
		{
			SetTargetPins();
		}

		public void SetTargetPins()
		{
			SetTargetPins(PinNameFilter.InputField.text);
		}

		public void SetTargetPins(string filter)
		{
			SetTargetPins(Minimap.instance.m_pins.Where((PinData pin) => IsPinNameValid(pin, filter)).ToList());
		}

		public void SetTargetPins(List<PinData> pins)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			TargetPins.Clear();
			TargetPins.AddRange(from p in pins
				orderby p.m_type, p.m_name
				select p);
			foreach (PinData item in pins.Where((PinData p) => Mathf.Approximately(p.m_pos.y, 0f)))
			{
				item.m_pos.y = PinnacleUtils.GetHeight(item.m_pos);
			}
			RefreshPinListRows();
			((TMP_Text)PinStats.Label).SetText($"{TargetPins.Count} pins.");
		}

		private void RefreshPinListRows()
		{
			//IL_0022: 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_00a0: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			_isRefreshing = true;
			((UnityEventBase)ScrollRect.onValueChanged).RemoveAllListeners();
			Content.RectTransform().SetPosition(Vector2.zero);
			ScrollRect.SetVerticalScrollPosition<ScrollRect>(1f);
			_previousRowIndex = -1;
			_rowCache.Clear();
			foreach (GameObject item in Content.Children())
			{
				Object.Destroy((Object)(object)item);
			}
			GameObject val = new GameObject("Block", new Type[1] { typeof(RectTransform) });
			val.SetParent(Content.transform);
			_bufferBlock = val.AddComponent<LayoutElement>();
			LayoutElement bufferBlock = _bufferBlock;
			float? height = 0f;
			bufferBlock.SetPreferred(null, height);
			PinListRow pinListRow = new PinListRow(Content.transform);
			LayoutRebuilder.ForceRebuildLayoutImmediate(Panel.RectTransform());
			_rowPreferredHeight = LayoutUtility.GetPreferredHeight(pinListRow.Row.RectTransform());
			_visibleRows = Mathf.CeilToInt(Viewport.RectTransform().sizeDelta.y / _rowPreferredHeight);
			Object.Destroy((Object)(object)pinListRow.Row);
			Content.RectTransform().SetSizeDelta(new Vector2(Viewport.RectTransform().sizeDelta.x, _rowPreferredHeight * (float)TargetPins.Count));
			for (int i = 0; i < Mathf.Min(TargetPins.Count, _visibleRows); i++)
			{
				pinListRow = new PinListRow(Content.transform);
				pinListRow.TogglePinPosition(PluginConfig.PinListPanelShowPinPosition.Value);
				pinListRow.SetRowContent(TargetPins[i]);
				_rowCache.Add(pinListRow);
			}
			_previousRowIndex = -1;
			ScrollRect.SetVerticalScrollPosition<ScrollRect>(1f);
			((UnityEvent<Vector2>)(object)ScrollRect.onValueChanged).AddListener((UnityAction<Vector2>)OnVerticalScroll);
			_isRefreshing = false;
		}

		private void OnVerticalScroll(Vector2 scroll)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (_isRefreshing || TargetPins.Count == 0 || _rowCache.Count == 0)
			{
				return;
			}
			int num = Mathf.Clamp(Mathf.CeilToInt(Content.RectTransform().anchoredPosition.y / _rowPreferredHeight), 0, TargetPins.Count - _rowCache.Count);
			if (num != _previousRowIndex)
			{
				if (num > _previousRowIndex)
				{
					PinListRow pinListRow = _rowCache[0];
					_rowCache.RemoveAt(0);
					((Transform)pinListRow.Row.RectTransform()).SetAsLastSibling();
					int index = Mathf.Clamp(num + _rowCache.Count, 0, TargetPins.Count - 1);
					pinListRow.SetRowContent(TargetPins[index]);
					_rowCache.Add(pinListRow);
				}
				else
				{
					PinListRow pinListRow2 = _rowCache[_rowCache.Count - 1];
					_rowCache.RemoveAt(_rowCache.Count - 1);
					((Transform)pinListRow2.Row.RectTransform()).SetSiblingIndex(1);
					pinListRow2.SetRowContent(TargetPins[num]);
					_rowCache.Insert(0, pinListRow2);
				}
				LayoutElement bufferBlock = _bufferBlock;
				float? height = (float)num * _rowPreferredHeight;
				bufferBlock.SetPreferred(null, height);
				_previousRowIndex = num;
			}
		}

		private static GameObject CreatePanel(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_007a: 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_00be: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			GameObject val = new GameObject("PinListPanel", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<VerticalLayoutGroup>().SetChildControl<VerticalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<VerticalLayoutGroup>((bool?)false, (bool?)false)
				.SetPadding<VerticalLayoutGroup>((int?)8, (int?)8, (int?)8, (int?)8)
				.SetSpacing<VerticalLayoutGroup>(8f);
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UISpriteBuilder.CreateSuperellipse(400, 400, 15f))
				.SetColor(new Color(0f, 0f, 0f, 0.9f));
			val.AddComponent<Canvas>();
			val.AddComponent<GraphicRaycaster>();
			val.AddComponent<CanvasGroup>().SetBlocksRaycasts(blocksRaycasts: true);
			return val;
		}

		private static GameObject CreateViewport(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			GameObject val = new GameObject("Viewport", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<RectMask2D>();
			val.AddComponent<LayoutElement>().SetFlexible(1f, 1f);
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UISpriteBuilder.CreateRoundedCornerSprite(128, 128, 8, (FilterMode)1))
				.SetColor(new Color(0.5f, 0.5f, 0.5f, 0.1f));
			val.AddComponent<Outline>().SetEffectDistance(new Vector2(2f, -2f));
			return val;
		}

		private static GameObject CreateContent(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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)
			//IL_004f: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			GameObject val = new GameObject("Content", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.GetComponent<RectTransform>().SetAnchorMin(Vector2.up).SetAnchorMax(Vector2.up)
				.SetPivot(Vector2.up);
			val.AddComponent<VerticalLayoutGroup>().SetChildControl<VerticalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<VerticalLayoutGroup>((bool?)false, (bool?)false)
				.SetSpacing<VerticalLayoutGroup>(0f);
			val.AddComponent<Image>().SetColor(Color.clear).SetRaycastTarget(raycastTarget: true);
			return val;
		}

		private static ScrollRect CreateScrollRect(GameObject panel, GameObject viewport, GameObject content)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			return panel.AddComponent<ScrollRect>().SetViewport<ScrollRect>(viewport.RectTransform()).SetContent<ScrollRect>(content.RectTransform())
				.SetHorizontal<ScrollRect>(horizontal: false)
				.SetVertical<ScrollRect>(vertical: true)
				.SetMovementType<ScrollRect>(PluginConfig.PinListPanelScrollRectMovementType.Value)
				.SetScrollSensitivity<ScrollRect>(PluginConfig.PinListPanelScrollRectScrollSensitivity.Value);
		}

		private static GameObject CreateDragger(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0082: Expected O, but got Unknown
			GameObject val = new GameObject("Dragger", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<LayoutElement>().SetIgnoreLayout(ignoreLayout: true);
			GameObjectExtensions.RectTransform(val).SetAnchorMin(Vector2.zero).SetAnchorMax(Vector2.one)
				.SetPivot(new Vector2(0.5f, 0.5f))
				.SetSizeDelta(Vector2.zero);
			val.AddComponent<Image>().SetColor(Color.clear);
			return val;
		}

		private static GameObject CreateResizer(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0079: 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_00b3: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			GameObject val = new GameObject("Resizer", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parentTransform, false);
			val.AddComponent<LayoutElement>().SetIgnoreLayout(ignoreLayout: true);
			GameObjectExtensions.RectTransform(val).SetAnchorMin(Vector2.right).SetAnchorMax(Vector2.right)
				.SetPivot(Vector2.right)
				.SetSizeDelta(new Vector2(42.5f, 42.5f))
				.SetPosition(new Vector2(15f, -15f));
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UIResources.GetSprite("button"))
				.SetColor(new Color(1f, 1f, 1f, 0.95f));
			val.AddComponent<CanvasGroup>().SetAlpha(0f);
			TextMeshProUGUI obj = UIBuilder.CreateTMPLabel(val.transform);
			((TMP_Text)(object)obj).SetName<TMP_Text>("Icon");
			((Component)obj).gameObject.AddComponent<LayoutElement>().SetIgnoreLayout(ignoreLayout: true);
			((Component)obj).gameObject.RectTransform().SetAnchorMin(Vector2.zero).SetAnchorMax(Vector2.one)
				.SetPivot(new Vector2(0.5f, 0.5f))
				.SetSizeDelta(Vector2.zero);
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			((TMP_Text)obj).fontSize = 24f;
			((TMP_Text)obj).text = "<rotate=-45>↔</rotate>";
			return val;
		}

		private static LabelButton CreateRefreshButton(Transform parentTransform)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			LabelButton labelButton = new LabelButton(parentTransform);
			labelButton.RectTransform.SetSizeDelta(new Vector2(100f, 35f));
			labelButton.Container.AddComponent<LayoutElement>().SetPreferred(100f, 35f);
			((TMP_Text)labelButton.Label.SetFontSize<TextMeshProUGUI>(14f)).SetText("Refresh");
			labelButton.Button.SetNavigationMode<Button>((Mode)0);
			return labelButton;
		}
	}
	public sealed class PinListRow
	{
		private PinData _targetPin;

		private static readonly Lazy<ColorBlock> ButtonColorBlock = new Lazy<ColorBlock>((Func<ColorBlock>)delegate
		{
			//IL_0002: 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_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_0060: 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_009f: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock result = default(ColorBlock);
			((ColorBlock)(ref result)).normalColor = new Color(0f, 0f, 0f, 0.01f);
			((ColorBlock)(ref result)).highlightedColor = Color32.op_Implicit(new Color32((byte)50, (byte)161, (byte)217, (byte)128));
			((ColorBlock)(ref result)).disabledColor = new Color(0f, 0f, 0f, 0.1f);
			((ColorBlock)(ref result)).pressedColor = Color32.op_Implicit(new Color32((byte)50, (byte)161, (byte)217, (byte)192));
			((ColorBlock)(ref result)).selectedColor = Color32.op_Implicit(new Color32((byte)50, (byte)161, (byte)217, (byte)248));
			((ColorBlock)(ref result)).colorMultiplier = 1f;
			((ColorBlock)(ref result)).fadeDuration = 0f;
			return result;
		});

		public GameObject Row { get; private set; }

		public Image PinIcon { get; private set; }

		public TMP_Text PinName { get; private set; }

		public TMP_Text PositionX { get; private set; }

		public TMP_Text PositionY { get; private set; }

		public TMP_Text PositionZ { get; private set; }

		public PinListRow(Transform parentTransform)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_00a4: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			Row = CreateChildRow(parentTransform);
			((UnityEvent)Row.Button().onClick).AddListener(new UnityAction(OnRowClick));
			PinIcon = CreateChildPinIcon(Row.transform).Image();
			PinName = CreateChildPinName(Row.transform);
			UIBuilder.CreateRowSpacer(Row.transform);
			PositionX = CreateChildPinPositionValue(Row.transform);
			((Graphic)PositionX).color = new Color(1f, 0.878f, 0.51f);
			PositionY = CreateChildPinPositionValue(Row.transform);
			((Graphic)PositionY).color = new Color(0.565f, 0.792f, 0.976f);
			PositionZ = CreateChildPinPositionValue(Row.transform);
			((Graphic)PositionZ).color = new Color(0.647f, 0.839f, 0.655f);
		}

		private void OnRowClick()
		{
			PinnacleUtils.CenterMapOnOrTeleportTo(_targetPin);
		}

		public PinListRow SetRowContent(PinData pin)
		{
			_targetPin = pin;
			PinIcon.SetSprite(pin.m_icon);
			PinName.SetText(GetLocalizedPinName(pin));
			PositionX.SetText($"{pin.m_pos.x:F0}");
			PositionY.SetText($"{pin.m_pos.y:F0}");
			PositionZ.SetText($"{pin.m_pos.z:F0}");
			return this;
		}

		private string GetLocalizedPinName(PinData pin)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (pin.m_name.Length <= 0)
			{
				return $"<i>{pin.m_type}</i>";
			}
			if (pin.m_name[0] == '$')
			{
				return Localization.m_instance.Localize(pin.m_name);
			}
			return pin.m_name;
		}

		public void TogglePinPosition(bool toggleOn)
		{
			((Component)PositionX).gameObject.SetActive(toggleOn);
			((Component)PositionY).gameObject.SetActive(toggleOn);
			((Component)PositionZ).gameObject.SetActive(toggleOn);
		}

		private GameObject CreateChildRow(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("PinList.Row", new Type[1] { typeof(RectTransform) });
			val.SetParent(parentTransform);
			val.AddComponent<HorizontalLayoutGroup>().SetChildControl<HorizontalLayoutGroup>((bool?)true, (bool?)true).SetChildForceExpand<HorizontalLayoutGroup>((bool?)false, (bool?)false)
				.SetChildAlignment<HorizontalLayoutGroup>((TextAnchor)4)
				.SetPadding<HorizontalLayoutGroup>((int?)5, (int?)10, (int?)4, (int?)4)
				.SetSpacing<HorizontalLayoutGroup>(2.5f);
			val.AddComponent<Image>().SetType((Type)1).SetSprite(UISpriteBuilder.CreateRoundedCornerSprite(400, 400, 5, (FilterMode)1));
			val.AddComponent<Button>().SetNavigationMode<Button>((Mode)0).SetTargetGraphic<Button>((Graphic)(object)val.Image())
				.SetColors<Button>(ButtonColorBlock.Value);
			val.AddComponent<ContentSizeFitter>().SetHorizontalFit((FitMode)0).SetVerticalFit((FitMode)2);
			val.AddComponent<ParentSizeFitter>();
			return val;
		}

		private GameObject CreateChildPinIcon(Transform parentTransform)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0026: 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_0054: Expected O, but got Unknown
			GameObject val = new GameObject("Pin.Icon", new Type[1] { typeof(RectTransform) });
			GameObjectExtensions.SetParent(val, parentTransform);
			val.AddComponent<LayoutElement>().SetPreferred(20f, 20f);
			val.AddComponent<Image>().SetType((Type)0);
			return val;
		}

		private TMP_Text CreateChildPinName(Transform parentTransform)
		{
			TextMeshProUGUI obj = UIBuilder.CreateTMPLabel(parentTransform);
			((TMP_Text)(object)obj).SetName<TMP_Text>("Pin.Name");
			((TMP_Text)obj).alignment = (TextAlignmentOptions)513;
			((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
			((TMP_Text)obj).fontSize = 16f;
			return (TMP_Text)(object)obj;
		}

		private TMP_Text CreateChildPinPositionValue(Transform parentTransform)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			TMP_Text val = (TMP_Text)(object)UIBuilder.CreateTMPLabel(parentTransform);
			val.SetName<TMP_Text>("Pin.Position.Value");
			val.alignment = (TextAlignmentOptions)516;
			val.text = "-99999";
			val.textWrappingMode = (TextWrappingModes)0;
			val.overflowMode = (TextOverflowModes)1;
			val.fontSize = 14f;
			((Component)val).gameObject.AddComponent<LayoutElement>().SetPreferred(val.GetPreferredValues().x, null);
			return val;
		}
	}
	[HarmonyPatch(typeof(Game))]
	internal static class GamePatch
	{
		[HarmonyTranspiler]
		[HarmonyPatch("UpdateNoMap")]
		private static IEnumerable<CodeInstruction> UpdateNoMapTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0026: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).Start().MatchStartForward((CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Br, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Minimap), "SetMapMode", (Type[])null, (Type[])null), (string)null)
			}).ThrowIfInvalid("Could not patch Game.UpdateNoMap()! (set-map-mode)")
				.Advance(1)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(GamePatch), "SetMapModeDelegate", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}

		private static MapMode SetMapModeDelegate(MapMode mapMode)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			if (PluginConfig.IsModEnabled.Value && !Game.m_noMap && Object.op_Implicit((Object)(object)Minimap.instance) && (int)Minimap.instance.m_mode == 2)
			{
				return (MapMode)2;
			}
			return mapMode;
		}
	}
	[HarmonyPatch(typeof(Minimap))]
	internal static class MinimapPatch
	{
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(Minimap __instance)
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				PinMarkerUtils.SetupPinNamePrefab(__instance);
				PinEditPanelController.TogglePanel();
				PinListPanelController.TogglePanel(toggleOn: false);
				PinFilterPanelController.TogglePanel(toggleOn: true);
				PinnacleUtils.ToggleVanillaIconPanels(toggleOn: false);
				PinFilterPanelController.UpdateIconFilters();
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch("OnMapDblClick")]
		private static IEnumerable<CodeInstruction> OnMapDblClickTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0039: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).Start().MatchStartForward((CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(Minimap), "m_selectedType"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_4, (object)null, (string)null)
			}).ThrowIfInvalid("Could not patch Minimap.OnMapDblClick()! (m-selected-type)")
				.Advance(2)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MinimapPatch), "OnMapDblClickSelectedTypeDelegate", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}

		private static int OnMapDblClickSelectedTypeDelegate(int pinTypeDeath)
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				return -1;
			}
			return pinTypeDeath;
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnMapLeftClick")]
		private static bool OnMapLeftClickPrefix(Minimap __instance)
		{
			if (PluginConfig.IsModEnabled.Value && ((Terminal)Console.m_instance).IsCheatsEnabled() && Object.op_Implicit((Object)(object)Player.m_localPlayer) && ZInput.GetKey((KeyCode)304, true))
			{
				ProcessMapLeftClickTeleport(__instance);
				return false;
			}
			return true;
		}

		private static void ProcessMapLeftClickTeleport(Minimap minimap)
		{
			//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_000b: 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)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = minimap.ScreenToWorldPoint(ZInput.pointerPosition);
			PinData closestPin = minimap.GetClosestPin(val, minimap.m_removeRadius * minimap.m_largeZoom * 2f, true);
			minimap.SetMapMode((MapMode)1);
			minimap.m_smallRoot.SetActive(true);
			if (closestPin == null)
			{
				PinnacleUtils.TeleportTo(val);
			}
			else
			{
				PinnacleUtils.TeleportTo(closestPin);
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch("OnMapLeftClick")]
		private static IEnumerable<CodeInstruction> OnMapLeftClickTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).Start().MatchStartForward((CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Minimap), "GetClosestPin", (Type[])null, (Type[])null), (string)null),
				new CodeMatch((OpCode?)OpCodes.Stloc_1, (object)null, (string)null)
			}).ThrowIfInvalid("Could not patch Minimap.OnMapLeftClick()! (get-closest-pin)")
				.Advance(1)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MinimapPatch), "GetClosestPinDelegate", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}

		private static PinData GetClosestPinDelegate(PinData closestPin)
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				PinEditPanelController.TogglePanel(closestPin);
				return null;
			}
			return closestPin;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("Update")]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).Start().MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Minimap), "InTextInput", (Type[])null, (Type[])null), (string)null)
			}).ThrowIfInvalid("Could not patch Minimap.Update()! (in-text-input)")
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MinimapPatch), "InTextInputPreDelegate", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}

		private static void InTextInputPreDelegate(Minimap minimap)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			if (PluginConfig.IsModEnabled.Value && (int)minimap.m_mode == 2)
			{
				KeyboardShortcut value = PluginConfig.PinListPanelToggleShortcut.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					PinListPanelController.TogglePanel();
				}
				value = PluginConfig.AddPinAtMouseShortcut.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					minimap.OnMapDblClick();
				}
				value = PluginConfig.QuickMapPinShortcut.Value;
				if (((KeyboardShortcut)(ref value)).IsDown() && Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					PinnacleUtils.AddQuickMapPin(minimap, ((Component)Player.m_localPlayer).transform.position);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("InTextInput")]
		private static void InTextInputPostfix(ref bool __result)
		{
			if (PluginConfig.IsModEnabled.Value && !__result && (PinEditPanelController.HasFocus() || PinListPanelController.HasFocus()))
			{
				__result = true;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("UpdateMap")]
		private static void UpdateMapPrefix(ref bool takeInput)
		{
			if (PluginConfig.IsModEnabled.Value && PinListPanelController.HasFocus())
			{
				takeInput = false;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("RemovePin", new Type[] { typeof(PinData) })]
		private static void RemovePinPrefix(ref PinData pin)
		{
			if (PluginConfig.IsModEnabled.Value && PinEditPanelController.PinEditPanel?.TargetPin == pin)
			{
				PinEditPanelController.TogglePanel();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetMapMode")]
		private static void SetMapModePrefix(ref Minimap __instance, ref MapMode mode, ref MapMode __state)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected I4, but got Unknown
			if (PluginConfig.IsModEnabled.Value && Object.op_Implicit((Object)(object)PinListPanelController.PinListPanel?.Panel) && PinListPanelController.PinListPanel.Panel.activeSelf)
			{
				__state = (MapMode)(int)__instance.m_mode;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetMapMode")]
		private static void SetMapModePostfix(ref MapMode mode, ref MapMode __state)
		{
			if (PluginConfig.IsModEnabled.Value && (int)mode != 2)
			{
				if (Object.op_Implicit((Object)(object)PinEditPanelController.PinEditPanel?.Panel))
				{
					PinEditPanelController.TogglePanel();
				}
				if (Object.op_Implicit((Object)(object)PinListPanelController.PinListPanel?.Panel))
				{
					PinListPanelController.PinListPanel.PinNameFilter.InputField.DeactivateInputField(false);
				}
			}
			if (PluginConfig.IsModEnabled.Value && (int)mode == 2 && (int)__state != (int)mode && PinListPanelController.IsPanelValid())
			{
				PinListPanelController.PinListPanel.SetTargetPins();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("ShowPinNameInput")]
		private static bool ShowPinNameInputPrefix(Minimap __instance, Vector3 pos)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (PluginConfig.IsModEnabled.Value)
			{
				__instance.m_namePin = null;
				PinEditPanelController.TogglePanel(PinnacleUtils.AddNewPin(__instance, pos));
				PinEditPanelController.PinEditPanel?.ActivatePinNameInputField();
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("SelectIcon")]
		private static void SelectIconPostfix()
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				PinFilterPanelController.UpdateIconFilters();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("ToggleIconFilter")]
		private static void ToggleIconFilterPostfix()
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				PinFilterPanelController.UpdateIconFilters();
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch("UpdatePins")]
		private static IEnumerable<CodeInstruction> UpdatePinsTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0002: 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_0026: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Expected O, but got Unknown
			object operand;
			Label label;
			return new CodeMatcher(instructions, generator).Start().MatchStartForward((CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PinData), "m_icon"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Image), "sprite"), (string)null)
			}).ThrowIfInvalid("Could not patch Minimap.UpdatePins()! (pin-icon-element-set-sprite)")
				.SaveOperand(out operand)
				.MatchStartForward((CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(GameObject), "transform"), (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"Checked", (string)null)
				})
				.ThrowIfInvalid("Could not patch Minimap.UpdatePins()! (pin-icon-find-checked)")
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldloc_S, operand),
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MinimapPatch), "SetIconElementSpriteDelegate", (Type[])null, (Type[])null))
				})
				.MatchStartForward((CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PinData), "m_iconElement"), (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertySetter(typeof(Graphic), "color"), (string)null)
				})
				.ThrowIfInvalid("Could not ptach Minimap.UpdatePins()! (set-icon-element-color)")
				.CreateLabelOffset(4, out label)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldloc_S, operand),
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PinIconManager), "HasIconTagFlag", (Type[])null, (Type[])null)),
					new CodeInstruction(OpCodes.Brtrue, (object)label)
				})
				.InstructionEnumeration();
		}

		private static void SetIconElementSpriteDelegate(PinData pinData)
		{
			if (PluginConfig.IsModEnabled.Value && PinIconManager.IsValidIconTagName(pinData.m_name))
			{
				PinIconManager.ProcessIconTagsCreated(pinData);
			}
		}
	}
	[HarmonyPatch(typeof(PinNameData))]
	internal static class PinNameDataPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetTextAndGameObject")]
		private static void SetTextAndGameObjectPostfix(PinNameData __instance)
		{
			if (PluginConfig.IsModEnabled.Value)
			{
				PinIconManager.RemoveIconTagText(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	internal static class TerminalPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("InitTerminal")]
		private static void InitTerminalPrefix(ref bool __state)
		{
			__state = Terminal.m_terminalInitialized;
		}

		[HarmonyPostfix]
		[HarmonyPatch("InitTerminal")]
		private static void InitTerminalPostfix(bool __state)
		{
			if (!__state)
			{
				ComfyCommandUtils.ToggleCommands(PluginConfig.IsModEnabled.Value);
			}
			if (PluginConfig.IsModEnabled.Value)
			{
				ModifyResetMapCommand();
			}
		}

		private static void ModifyResetMapCommand()
		{
			if (Terminal.commands.TryGetValue("resetmap", out var value))
			{
				value.IsCheat = false;
				value.OnlyServer = false;
				Pinnacle.Log((LogLevel)16, "Modified 'resetmap' command: IsCheat = false, OnlyServer = false.");
			}
		}
	}
	[BepInPlugin("redseiko.valheim.pinnacle", "Pinnacle", "1.16.1")]
	public sealed class Pinnacle : BaseUnityPlugin
	{
		public const string PluginGuid = "redseiko.valheim.pinnacle";

		public const string PluginName = "Pinnacle";

		public const string PluginVersion = "1.16.1";

		private static ManualLogSource _logger;

		private void Awake()
		{
			_logger = ((BaseUnityPlugin)this).Logger;
			PluginConfig.BindConfig(((BaseUnityPlugin)this).Config);
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "redseiko.valheim.pinnacle");
		}

		public static void Log(LogLevel logLevel, object o)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			_logger.Log(logLevel, (object)$"[{DateTime.Now.ToString(DateTimeFormatInfo.InvariantInfo)}] {o}");
		}

		public static void LogInfo(object obj)
		{
			_logger.LogInfo((object)$"[{DateTime.Now.ToString(DateTimeFormatInfo.InvariantInfo)}] {obj}");
			Chat.m_instance.AddMessage(obj);
		}

		public static void LogWarning(object obj)
		{
			_logger.LogWarning((object)$"[{DateTime.Now.ToString(DateTimeFormatInfo.InvariantInfo)}] {obj}");
			Chat.m_instance.AddMessage(obj);
		}
	}
}
namespace ComfyLib
{
	public sealed class ComfyArgs
	{
		public static readonly Regex CommandRegex = new Regex("^(?<command>\\w[\\w-]*)(\\s+--((?<arg>\\w[\\w-]*)=(\"(?<value>[^\"]*?)\"|'(?<value>[^']*?)'|(?<value>\\S+))|no(?<argfalse>\\w[\\w-]*)|(?<argtrue>\\w[\\w-]*)))*", RegexOptions.ExplicitCapture | RegexOptions.Compiled | RegexOptions.CultureInvariant, TimeSpan.FromMilliseconds(500.0));

		public static readonly char[] CommaSeparator = new char[1] { ',' };

		public readonly Dictionary<string, string> ArgsValueByName = new Dictionary<string, string>();

		public ConsoleEventArgs Args { get; }

		public string Command { get; private set; }

		public ComfyArgs(ConsoleEventArgs args)
		{
			Args = args;
			ParseArgs(args.FullLine);
		}

		private void ParseArgs(string line)
		{
			Match match = CommandRegex.Match(line);
			Command = match.Groups["command"].Value;
			foreach (Capture capture3 in match.Groups["argtrue"].Captures)
			{
				ArgsValueByName[capture3.Value] = "true";
			}
			foreach (Capture capture4 in match.Groups["argfalse"].Captures)
			{
				ArgsValueByName[capture4.Value] = "false";
			}
			CaptureCollection captures = match.Groups["arg"].Captures;
			int count = captures.Count;
			CaptureCollection captures2 = match.Groups["value"].Captures;
			int count2 = captures2.Count;
			for (int i = 0; i < count; i++)
			{
				ArgsValueByName[captures[i].Value] = ((i < count2) ? captures2[i].Value : string.Empty);
			}
		}

		public bool TryGetValue(string argName, out string argValue)
		{
			return ArgsValueByName.TryGetValue(argName, out argValue);
		}

		public bool TryGetValue(string argName, string argShortName, out string argValue)
		{
			if (!ArgsValueByName.TryGetValue(argName, out argValue))
			{
				return ArgsValueByName.TryGetValue(argShortName, out argValue);
			}
			return true;
		}

		public bool TryGetValue<T>(string argName, out T argValue)
		{
			argValue = default(T);
			if (ArgsValueByName.TryGetValue(argName, out var value))
			{
				return value.TryParseValue<T>(out argValue);
			}
			return false;
		}

		public bool TryGetValue<T>(string argName, string argShortName, out T argValue)
		{
			argValue = default(T);
			if (ArgsValueByName.TryGetValue(argName, out var value) || ArgsValueByName.TryGetValue(argShortName, out value))
			{
				return value.TryParseValue<T>(out argValue);
			}
			return false;
		}

		public bool TryGetListValue<T>(string argName, out List<T> argListValue)
		{
			if (!ArgsValueByName.TryGetValue(argName, out var value))
			{
				argListValue = null;
				return false;
			}
			return GetListValue(value, out argListValue);
		}

		public bool TryGetListValue<T>(string argName, string argShortName, out List<T> argListValue)
		{
			if (!ArgsValueByName.TryGetValue(argName, out var value) && !ArgsValueByName.TryGetValue(argShortName, out value))
			{
				argListValue = null;
				return false;
			}
			return GetListValue(value, out argListValue);
		}

		private static bool GetListValue<T>(string argStringValue, out List<T> argListValue)
		{
			string[] array = argStringValue.Split(CommaSeparator, StringSplitOptions.RemoveEmptyEntries);
			argListValue = new List<T>(array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				if (!array[i].TryParseValue<T>(out var value))
				{
					return false;
				}
				argListValue.Add(value);
			}
			return true;
		}

		public bool GetOptionalValue<T>(string argName, out T? argValue)
		{
			argValue = default(T);
			if (ArgsValueByName.TryGetValue(argName, out var value))
			{
				return value.TryParseValue<T>(out argValue);
			}
			return true;
		}

		public bool GetOptionalValue<T>(string argName, string argShortName, out T? argValue)
		{
			argValue = default(T);
			if (ArgsValueByName.TryGetValue(argName, out var value) || ArgsValueByName.TryGetValue(argShortName, out value))
			{
				return value.TryParseValue<T>(out argValue);
			}
			return true;
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class ComfyCommand : Attribute
	{
	}
	public static class ComfyCommandUtils
	{
		private static readonly List<ConsoleCommand> _commands = new List<ConsoleCommand>();

		public static void ToggleCommands(bool toggleOn)
		{
			DeregisterCommands(_commands);
			_commands.Clear();
			if (toggleOn)
			{
				_commands.AddRange(RegisterCommands(Assembly.GetExecutingAssembly()));
			}
			UpdateCommandLists();
		}

		private static void UpdateCommandLists()
		{
			Terminal[] array = Object.FindObjectsByType<Terminal>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				array[i].updateCommandList();
			}
		}

		private static void DeregisterCommands(List<ConsoleCommand> commands)
		{
			foreach (ConsoleCommand command in commands)
			{
				if (Terminal.commands[command.Command] == command)
				{
					Terminal.commands.Remove(command.Command);
				}
			}
		}

		private static IEnumerable<ConsoleCommand> RegisterCommands(Assembly assembly)
		{
			return (from method in assembly.GetTypes().SelectMany((Type type) => type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
				where method.GetCustomAttributes(typeof(ComfyCommand), inherit: false).Length != 0
				select method).SelectMany(RegisterCommands);
		}

		private static IEnumerable<ConsoleCommand> RegisterCommands(MethodInfo method)
		{
			if (IsRegisterCommandMethod(method))
			{
				yield return (ConsoleCommand)method.Invoke(null, null);
			}
			else
			{
				if (!IsRegisterCommandsMethod(method))
				{
					yield break;
				}
				foreach (ConsoleCommand item in (IEnumerable<ConsoleCommand>)method.Invoke(null, null))
				{
					yield return item;
				}
			}
		}

		private static bool IsRegisterCommandMethod(MethodInfo method)
		{
			if (method.GetParameters().Length == 0)
			{
				return typeof(ConsoleCommand).IsAssignableFrom(method.ReturnType);
			}
			return false;
		}

		private static bool IsRegisterCommandsMethod(MethodInfo method)
		{
			if (method.GetParameters().Length == 0)
			{
				return typeof(IEnumerable<ConsoleCommand>).IsAssignableFrom(method.ReturnType);
			}
			return false;
		}
	}
	public sealed class AcceptableValueEnumList<T> : AcceptableValueBase where T : Enum
	{
		public T[] AcceptableValues { get; }

		public AcceptableValueEnumList(params T[] acceptableValues)
			: base(typeof(T))
		{
			if (acceptableValues == null)
			{
				throw new ArgumentNullException("acceptableValues");
			}
			if (acceptableValues.Length == 0)
			{
				throw new ArgumentException("At least one acceptable value is needed.", "acceptableValues");
			}
			AcceptableValues = acceptableValues;
		}

		public override object Clamp(object value)
		{
			if (((AcceptableValueBase)this).IsValid(value))
			{
				return value;
			}
			return AcceptableValues[0];
		}

		public override bool IsValid(object value)
		{
			if (!(value is T))
			{
				return false;
			}
			for (int i = 0; i < AcceptableValues.Length; i++)
			{
				if (AcceptableValues[i].Equals(value))
				{
					return true;
				}
			}
			return false;
		}

		public override string ToDescriptionString()
		{
			return "# Acceptable values: " + string.Join(", ", AcceptableValues.Select(GetEnumName));
		}

		public string GetEnumName(T value)
		{
			return Enum.GetName(typeof(T), value);
		}
	}
	public static class CodeMatcherExtensions
	{
		public static CodeMatcher CreateLabelOffset(this CodeMatcher matcher, int offset, out Label label)
		{
			return matcher.CreateLabelAt(matcher.Pos + offset, ref label);
		}

		public static CodeMatcher ExtractLabels(this CodeMatcher matcher, out List<Label> labels)
		{
			List<Label> labels2 = matcher.Labels;
			List<Label> list = new List<Label>(labels2.Count);
			list.AddRange(labels2);
			labels = list;
			matcher.Labels.Clear();
			return matcher;
		}

		public static CodeMatcher SaveOperand(this CodeMatcher matcher, out object operand)
		{
			operand = matcher.Operand;
			return matcher;
		}
	}
	public static class ConfigFileExtensions
	{
		internal sealed class ConfigurationManagerAttributes
		{
			public Action<ConfigEntryBase> CustomDrawer;

			public bool? Browsable;

			public bool? HideDefaultButton;

			public bool? HideSettingName;

			public bool? IsAdvanced;

			public int? Order;

			public bool? ReadOnly;
		}

		private static readonly Dictionary<string, int> _sectionToSettingOrder = new Dictionary<string, int>();

		private static int GetSettingOrder(string section)
		{
			if (!_sectionToSettingOrder.TryGetValue(section, out var value))
			{
				value = 0;
			}
			_sectionToSettingOrder[section] = value - 1;
			return value;
		}

		public static ConfigEntry<T> BindInOrder<T>(this ConfigFile config, string section, string key, T defaultValue, string description, AcceptableValueBase acceptableValues, bool browsable = true, bool hideDefaultButton = false, bool hideSettingName = false, bool isAdvanced = false, bool readOnly = false)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			return config.Bind<T>(section, key, defaultValue, new ConfigDescription(description, acceptableValues, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = browsable,
					CustomDrawer = null,
					HideDefaultButton = hideDefaultButton,
					HideSettingName = hideSettingName,
					IsAdvanced = isAdvanced,
					Order = GetSettingOrder(section),
					ReadOnly = readOnly
				}
			}));
		}

		public static ConfigEntry<T> BindInOrder<T>(this ConfigFile config, string section, string key, T defaultValue, string description, Action<ConfigEntryBase> customDrawer = null, bool browsable = true, bool hideDefaultButton = false, bool hideSettingName = false, bool isAdvanced = false, bool readOnly = false)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			return config.Bind<T>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = browsable,
					CustomDrawer = customDrawer,
					HideDefaultButton = hideDefaultButton,
					HideSettingName = hideSettingName,
					IsAdvanced = isAdvanced,
					Order = GetSettingOrder(section),
					ReadOnly = readOnly
				}
			}));
		}

		public static void OnSettingChanged<T>(this ConfigEntry<T> configEntry, Action settingChangedHandler)
		{
			configEntry.SettingChanged += delegate
			{
				settingChangedHandler();
			};
		}

		public static void OnSettingChanged<T>(this ConfigEntry<T> configEntry, Action<T> settingChangedHandler)
		{
			configEntry.SettingChanged += delegate(object _, EventArgs eventArgs)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				settingChangedHandler((T)((SettingChangedEventArgs)eventArgs).ChangedSetting.BoxedValue);
			};
		}

		public static void OnSettingChanged<T>(this ConfigEntry<T> configEntry, Action<ConfigEntry<T>> settingChangedHandler)
		{
			configEntry.SettingChanged += delegate(object _, EventArgs eventArgs)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				settingChangedHandler((ConfigEntry<T>)(object)((SettingChangedEventArgs)eventArgs).ChangedSetting);
			};
		}
	}
	public static class StringExtensions
	{
		public static readonly char[] CommaSeparator = new char[1] { ',' };

		public static readonly char[] ColonSeparator = new char[1] { ':' };

		public static bool TryParseValue<T>(this string text, out T value)
		{
			//IL_0052: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector2 value2;
				Vector3 value3;
				ZDOID value4;
				if (typeof(T) == typeof(string))
				{
					value = (T)(object)text;
				}
				else if (typeof(T) == typeof(Vector2) && text.TryParseVector2(out value2))
				{
					value = (T)(object)value2;
				}
				else if (typeof(T) == typeof(Vector3) && text.TryParseVector3(out value3))
				{
					value = (T)(object)value3;
				}
				else if (typeof(T) == typeof(ZDOID) && text.TryParseZDOID(out value4))
				{
					value = (T)(object)value4;
				}
				else if (typeof(T).IsEnum)
				{
					value = (T)Enum.Parse(typeof(T), text, ignoreCase: true);
				}
				else
				{
					value = (T)Convert.ChangeType(text, typeof(T));
				}
				return true;
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"Failed to convert value '{text}' to type {typeof(T)}: {arg}");
			}
			value = default(T);
			return false;
		}

		public static bool TryParseVector2(this string text, out Vector2 value)
		{
			//IL_0050: 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)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			string[] array = text.Split(CommaSeparator, 2, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 2 && float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				value = new Vector2(result, result2);
				return true;
			}
			value = default(Vector2);
			return false;
		}

		public static bool TryParseVector3(this string text, out Vector3 value)
		{
			//IL_0067: 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)
			string[] array = text.Split(CommaSeparator, 3, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 3 && float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
			{
				value = new Vector3(result, result2, result3);
				return true;
			}
			value = default(Vector3);
			return false;
		}

		public static bool TryParseZDOID(this string text, out ZDOID value)
		{
			//IL_0048: 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)
			string[] array = text.Split(ColonSeparator, 2, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 2 && long.TryParse(array[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && uint.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				value = new ZDOID(result, result2);
				return true;
			}
			value = default(ZDOID);
			return false;
		}
	}
	public static class ChatExtensions
	{
		public static void AddMessage(this Chat chat, object obj)
		{
			if (Object.op_Implicit((Object)(object)chat))
			{
				((Terminal)chat).AddString(obj.ToString());
				chat.m_hideTimer = 0f;
			}
		}
	}
	public static class GameObjectExtensions
	{
		public static GameObject SetParent(this GameObject gameObject, Transform transform, bool worldPositionStays = false)
		{
			gameObject.transform.SetParent(transform, worldPositionStays);
			return gameObject;
		}

		public static IEnumerable<GameObject> Children(this GameObject gameObject)
		{
			if (!Object.op_Implicit((Object)(object)gameObject))
			{
				return Array.Empty<GameObject>();
			}
			return from Transform t in (IEnumerable)gameObject.transform
				select ((Component)t).gameObject;
		}

		public static Button Button(this GameObject gameObject)
		{
			if (!Object.op_Implicit((Object)(object)gameObject))
			{
				return null;
			}
			return gameObject.GetComponent<Button>();
		}

		public static Image Image(this GameObject gameObject)
		{
			if (!Object.op_Implicit((Object)(object)gameObject))
			{
				return null;
			}
			return gameObject.GetComponent<Image>();
		}

		public static LayoutElement LayoutElement(this GameObject gameObject)
		{
			if (!Object.op_Implicit((Object)(object)gameObject))
			{
				return null;
			}
			return gameObject.GetComponent<LayoutElement>();
		}

		public static RectTransform RectTransform(this GameObject gameObject)
		{
			if (!Object.op_Implicit((Object)(object)gameObject))
			{
				return null;
			}
			return gameObject.GetComponent<RectTransform>();
		}

		public static Text Text(this GameObject gameObject)
		{
			if (!Object.op_Implicit((Object)(object)gameObject))
			{
				return null;
			}
			return gameObject.GetComponent<Text>();
		}
	}
	public static class ObjectExtensions
	{
		public static T FirstByName<T>(this T[] unityObjects, string name) where T : Object
		{
			foreach (T val in unityObjects)
			{
				if (((Object)val).name == name)
				{
					return val;
				}
			}
			return default(T);
		}

		public static T FirstByNameOrThrow<T>(this T[] unityObjects, string name) where T : Object
		{
			foreach (T val in unityObjects)
			{
				if (((Object)val).name == name)
				{
					return val;
				}
			}
			throw new InvalidOperationException($"Could not find Unity object of type {typeof(T)} with name: {name}");
		}

		public static T Ref<T>(this T unityObject) where T : Object
		{
			if (!Object.op_Implicit((Object)(object)unityObject))
			{
				return default(T);
			}
			return unityObject;
		}

		public static T SetName<T>(this T unityObject, string name) where T : Object
		{
			((Object)unityObject).name = name;
			return unityObject;
		}
	}
	public static class UIBuilder
	{
		public static TextMeshProUGUI CreateTMPLabel(Transform parentTransform)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI obj = Object.Instantiate<TextMeshProUGUI>(UnifiedPopup.instance.bodyText, parentTransform, false);
			((TMP_Text)obj.SetName<TextMeshProUGUI>("Label").SetFontSize<TextMeshProUGUI>(16f).SetRichText<TextMeshProUGUI>(richText: true)
				.SetColor<TextMeshProUGUI>(Color.white)
				.SetEnableAutoSizing<TextMeshProUGUI>(enableAutoSizing: false)
				.SetTextWrappingMode<TextMeshProUGUI>((TextWrappingModes)0)
				.SetOverflowMode<TextMeshProUGUI>((TextOverflowModes)0)).SetText(string.Empty);
			return obj;
		}

		public static TextMeshProUGUI CreateTMPHeaderLabel(Transform parentTransform)
		{
			TextMeshProUGUI obj = Object.Instantiate<TextMeshProUGUI>(UnifiedPopup.instance.headerText, parentTransform, false);
			((TMP_Text)obj.SetName<TextMeshProUGUI>("Label").SetFontSize<TextMeshProUGUI>(32f).SetRichText<TextMeshProUGUI>(richText: true)
				.SetEnableAutoSizing<TextMeshProUGUI>(enableAutoSizing: false)
				.SetTextWrappingMode<TextMeshProUGUI>((TextWrappingModes)0)
				.SetOverflowMode<TextMeshProUGUI>((TextOverflowModes)0)).SetText(string.Empty);
			return obj;
		}

		public static GameObject CreateRowSpacer(Transform parentTransform)
		{
			//IL_0023: 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_0030: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			GameObject val = new GameObject(((Object)parentTransform).name + ".Spacer", new Type[1] { typeof(RectTransform) });
			GameObjectExtensions.SetParent(val, parentTransform);
			val.AddComponent<LayoutElement>().SetFlexible(1f);
			return val;
		}

		public static GuiInputField CreateInputField(Transform parentTransform)
		{
			//IL_002d: 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_0055: 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_0073: 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)
			GuiInputField obj = Object.Instantiate<GuiInputField>(TextInput.instance.m_inputField, parentTransform, false);
			obj.SetName<GuiInputField>("Value");
			((Component)obj).GetComponent<RectTransform>().SetAnchorMin(new Vector2(0.5f, 0.5f)).SetAnchorMax(new Vector2(0.5f, 0.5f))
				.SetPivot(new Vector2(0.5f, 0.5f))
				.SetPosition(Vector2.zero)
				.SetSizeDelta(new Vector2(120f, 40f));
			((Component)obj).GetComponentInChildren<RectMask2D>().SetPadding<RectMask2D>(Vector4.zero);
			return obj;
		}
	}
	public static class CanvasGroupExtensions
	{
		public static CanvasGroup SetAlpha(this CanvasGroup canvasGroup, float alpha)
		{
			canvasGroup.alpha = alpha;
			return canvasGroup;
		}

		public static CanvasGroup SetBlocksRaycasts(this CanvasGroup canvasGroup, bool blocksRaycasts)
		{
			canvasGroup.blocksRaycasts = blocksRaycasts;
			return canvasGroup;
		}
	}
	public static class ColorExtensions
	{
		public static Color SetAlpha(this Color color, float alpha)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			color.a = alpha;
			return color;
		}
	}
	public static class ContentSizeFitterExtensions
	{
		public static ContentSizeFitter SetHorizontalFit(this ContentSizeFitter fitter, FitMode fitMode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			fitter.horizontalFit = fitMode;
			return fitter;
		}

		public static ContentSizeFitter SetVerticalFit(this ContentSizeFitter fitter, FitMode fitMode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			fitter.verticalFit = fitMode;
			return fitter;
		}
	}
	public static class GridLayoutGroupExtensions
	{
		public static GridLayoutGroup SetCellSize(this GridLayoutGroup layoutGroup, Vector2 cellSize)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			layoutGroup.cellSize = cellSize;
			return layoutGroup;
		}

		public static GridLayoutGroup SetConstraint(this GridLayoutGroup layoutGroup, Constraint constraint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			layoutGroup.constraint = constraint;
			return layoutGroup;
		}

		public static GridLayoutGroup SetConstraintCount(this GridLayoutGroup layoutGroup, int constraintCount)
		{
			layoutGroup.constraintCount = constraintCount;
			return layoutGroup;
		}

		public static GridLayoutGroup SetStartAxis(this GridLayoutGroup layoutGroup, Axis startAxis)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			layoutGroup.startAxis = startAxis;
			return layoutGroup;
		}

		public static GridLayoutGroup SetStartCorner(this GridLayoutGroup layoutGroup, Corner startCorner)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			layoutGroup.startCorner = startCorner;
			return layoutGroup;
		}

		public static GridLayoutGroup SetSpacing(this GridLayoutGroup layoutGroup, Vector2 spacing)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			layoutGroup.spacing = spacing;
			return layoutGroup;
		}
	}
	public static class LayoutGroupExtensions
	{
		public static T SetChildAlignment<T>(this T layoutGroup, TextAnchor alignment) where T : LayoutGroup
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((LayoutGroup)layoutGroup).childAlignment = alignment;
			return layoutGroup;
		}

		public static T SetChildControl<T>(this T layoutGroup, bool? width = null, bool? height = null) where T : HorizontalOrVerticalLayoutGroup
		{
			if (!width.HasValue && !height.HasValue)
			{
				throw new ArgumentException("Value for width or height must be provided.");
			}
			if (width.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)layoutGroup).childControlWidth = width.Value;
			}
			if (height.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)layoutGroup).childControlHeight = height.Value;
			}
			return layoutGroup;
		}

		public static T SetChildForceExpand<T>(this T layoutGroup, bool? width = null, bool? height = null) where T : HorizontalOrVerticalLayoutGroup
		{
			if (!width.HasValue && !height.HasValue)
			{
				throw new ArgumentException("Value for width or height must be provided.");
			}
			if (width.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)layoutGroup).childForceExpandWidth = width.Value;
			}
			if (height.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)layoutGroup).childForceExpandHeight = height.Value;
			}
			return layoutGroup;
		}

		public static T SetPadding<T>(this T layoutGroup, int? left = null, int? right = null, int? top = null, int? bottom = null) where T : LayoutGroup
		{
			if (!left.HasValue && !right.HasValue && !top.HasValue && !bottom.HasValue)
			{
				throw new ArgumentException("Value for left, right, top or bottom must be provided.");
			}
			if (left.HasValue)
			{
				((LayoutGroup)layoutGroup).padding.left = left.Value;
			}
			if (right.HasValue)
			{
				((LayoutGroup)layoutGroup).padding.right = right.Value;
			}
			if (top.HasValue)
			{
				((LayoutGroup)layoutGroup).padding.top = top.Value;
			}
			if (bottom.HasValue)
			{
				((LayoutGroup)layoutGroup).padding.bottom = bottom.Value;
			}
			return layoutGroup;
		}

		public static T SetSpacing<T>(this T layoutGroup, float spacing) where T : HorizontalOrVerticalLayoutGroup
		{
			((HorizontalOrVerticalLayoutGroup)layoutGroup).spacing = spacing;
			return layoutGroup;
		}
	}
	public static class ImageExtensions
	{
		public static Image SetColor(this Image image, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)image).color = color;
			return image;
		}

		public static Image SetFillAmount(this Image image, float amount)
		{
			image.fillAmount = amount;
			return image;
		}

		public static Image SetFillCenter(this Image image, bool fillCenter)
		{
			image.fillCenter = fillCenter;
			return image;
		}

		public static Image SetFillMethod(this Image image, FillMethod fillMethod)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			image.fillMethod = fillMethod;
			return image;
		}

		public static Image SetFillOrigin(this Image image, OriginHorizontal origin)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected I4, but got Unknown
			image.fillOrigin = (int)origin;
			return image;
		}

		public static Image SetFillOrigin(this Image image, OriginVertical origin)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected I4, but got Unknown
			image.fillOrigin = (int)origin;
			return image;
		}

		public static Image SetMaskable(this Image image, bool maskable)
		{
			((MaskableGraphic)image).maskable = maskable;
			return image;
		}

		public static Image SetMaterial(this Image image, Material material)
		{
			((Graphic)image).material = material;
			return image;
		}

		public static Image SetPixelsPerUnitMultiplier(this Image image, float pixelsPerUnitMultiplier)
		{
			image.pixelsPerUnitMultiplier = pixelsPerUnitMultiplier;
			return image;
		}

		public static Image SetPreserveAspect(this Image image, bool preserveAspect)
		{
			image.preserveAspect = preserveAspect;
			return image;
		}

		public static Image SetRaycastTarget(this Image image, bool raycastTarget)
		{
			((Graphic)image).raycastTarget = raycastTarget;
			return image;
		}

		public static Image SetSprite(this Image image, Sprite sprite)
		{
			image.sprite = sprite;
			return image;
		}

		public static Image SetType(this Image image, Type type)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			image.type = type;
			return image;
		}
	}
	public static class LayoutElementExtensions
	{
		public static LayoutElement SetFlexible(this LayoutElement layoutElement, float? width = null, float? height = null)
		{
			if (!width.HasValue && !height.HasValue)
			{
				throw new ArgumentException("Value for width or height must be provided.");
			}
			if (width.HasValue)
			{
				layoutElement.flexibleWidth = width.Value;
			}
			if (height.HasValue)
			{
				layoutElement.flexibleHeight = height.Value;
			}
			return layoutElement;
		}

		public static LayoutElement SetIgnoreLayout(this LayoutElement layoutElement, bool ignoreLayout)
		{
			layoutElement.ignoreLayout = ignoreLayout;
			return layoutElement;
		}

		public static LayoutElement SetMinimum(this LayoutElement layoutElement, float? width = null, float? height = null)
		{
			if (!width.HasValue && !height.HasValue)
			{
				throw new ArgumentException("Value for width or height must be provided.");
			}
			if (width.HasValue)
			{
				layoutElement.minWidth = width.Value;
			}
			if (height.HasValue)
			{
				layoutElement.minHeight = height.Value;
			}
			return layoutElement;
		}

		public static LayoutElement SetMinimum(this LayoutElement layoutElement, Vector2 minimumDelta)
		{
			//IL_0001: 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)
			layoutElement.minWidth = minimumDelta.x;
			layoutElement.minHeight = minimumDelta.y;
			return layoutElement;
		}

		public static LayoutElement SetPreferred(this LayoutElement layoutElement, float? width = null, float? height = null)
		{
			if (!width.HasValue && !height.HasValue)
			{
				throw new ArgumentException("Value for width or height must be provided.");
			}
			if (width.HasValue)
			{
				layoutElement.preferredWidth = width.Value;
			}
			if (height.HasValue)
			{
				layoutElement.preferredHeight = height.Value;
			}
			return layoutElement;
		}

		public static LayoutElement SetPreferred(this LayoutElement layoutElement, Vector2 preferredDelta)
		{
			//IL_0001: 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)
			layoutElement.preferredWidth = preferredDelta.x;
			layoutElement.preferredHeight = preferredDelta.y;
			return layoutElement;
		}
	}
	public static class MaskExtensions
	{
		public static Mask SetShowMaskGraphic(this Mask mask, bool showMaskGraphic)
		{
			mask.showMaskGraphic = showMaskGraphic;
			return mask;
		}
	}
	public static class OutlineExtensions
	{
		public static Outline SetEffectColor(this Outline outline, Color effectColor)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((Shadow)outline).effectColor = effectColor;
			return outline;
		}

		public static Outline SetEffectDistance(this Outline outline, Vector2 effectDistance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((Shadow)outline).effectDistance = effectDistance;
			return outline;
		}

		public static Outline SetUseGraphicAlpha(this Outline outline, bool useGraphicAlpha)
		{
			((Shadow)outline).useGraphicAlpha = useGraphicAlpha;
			return outline;
		}
	}
	public static class RectMask2DExtensions
	{
		public static T SetPadding<T>(this T rectMask, Vector4 padding) where T : RectMask2D
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((RectMask2D)rectMask).padding = padding;
			return rectMask;
		}

		public static T SetSoftness<T>(this T rectMask, Vector2Int softness) where T : RectMask2D
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((RectMask2D)rectMask).softness = softness;
			return rectMask;
		}
	}
	public static class RectTransformExtensions
	{
		public static RectTransform SetAnchorMin(this RectTransform rectTransform, Vector2 anchorMin)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rectTransform.anchorMin = anchorMin;
			return rectTransform;
		}

		public static RectTransform SetAnchorMax(this RectTransform rectTransform, Vector2 anchorMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rectTransform.anchorMax = anchorMax;
			return rectTransform;
		}

		public static RectTransform SetPivot(this RectTransform rectTransform, Vector2 pivot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rectTransform.pivot = pivot;
			return rectTransform;
		}

		public static RectTransform SetPosition(this RectTransform rectTransform, Vector2 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rectTransform.anchoredPosition = position;
			return rectTransform;
		}

		public static RectTransform SetSizeDelta(this RectTransform rectTransform, Vector2 sizeDelta)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rectTransform.sizeDelta = sizeDelta;
			return rectTransform;
		}
	}
	public static class ScrollbarExtensions
	{
		public static T SetDirection<T>(this T scrollbar, Direction direction) where T : Scrollbar
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Scrollbar)scrollbar).direction = direction;
			return scrollbar;
		}

		public static T SetHandleRect<T>(this T scrollbar, RectTransform handleRect) where T : Scrollbar
		{
			((Scrollbar)scrollbar).handleRect = handleRect;
			return scrollbar;
		}
	}
	public static class SelectableExtensions
	{
		public static T SetColors<T>(this T selectable, ColorBlock colors) where T : Selectable
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Selectable)selectable).colors = colors;
			return selectable;
		}

		public static T SetImage<T>(this T selectable, Image image) where T : Selectable
		{
			((Selectable)selectable).image = image;
			return selectable;
		}

		public static T SetInteractable<T>(this T selectable, bool interactable) where T : Selectable
		{
			((Selectable)selectable).interactable = interactable;
			return selectable;
		}

		public static T SetSpriteState<T>(this T selectable, SpriteState spriteState) where T : Selectable
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Selectable)selectable).spriteState = spriteState;
			return selectable;
		}

		public static T SetTargetGraphic<T>(this T selectable, Graphic graphic) where T : Selectable
		{
			((Selectable)selectable).targetGraphic = graphic;
			return selectable;
		}

		public static T SetTransition<T>(this T selectable, Transition transition) where T : Selectable
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Selectable)selectable).transition = transition;
			return selectable;
		}

		public static T SetNavigationMode<T>(this T selectable, Mode mode) where T : Selectable
		{
			//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)
			//IL_000e: 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)
			Navigation navigation = ((Selectable)selectable).navigation;
			((Navigation)(ref navigation)).mode = mode;
			((Selectable)selectable).navigation = navigation;
			return selectable;
		}
	}
	public static class ShadowExtensions
	{
		public static Shadow SetEffectColor(this Shadow shadow, Color effectColor)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			shadow.effectColor = effectColor;
			return shadow;
		}

		public static Shadow SetEffectDistance(this Shadow shadow, Vector2 effectDistance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			shadow.effectDistance = effectDistance;
			return shadow;
		}
	}
	public static class ScrollRectExtensions
	{
		public static T SetContent<T>(this T scrollRect, RectTransform content) where T : ScrollRect
		{
			((ScrollRect)scrollRect).content = content;
			return scrollRect;
		}

		public static T SetHorizontal<T>(this T scrollRect, bool horizontal) where T : ScrollRect
		{
			((ScrollRect)scrollRect).horizontal = horizontal;
			return scrollRect;
		}

		public static T SetMovementType<T>(this T scrollRect, MovementType movementType) where T : ScrollRect
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((ScrollRect)scrollRect).movementType = movementType;
			return scrollRect;
		}

		public static T SetScrollSensitivity<T>(this T scrollRect, float sensitivity) where T : ScrollRect
		{
			((ScrollRect)scrollRect).scrollSensitivity = sensitivity;
			return scrollRect;
		}

		public static T SetVertical<T>(this T scrollRect, bool vertical) where T : ScrollRect
		{
			((ScrollRect)scrollRect).vertical = vertical;
			return scrollRect;
		}

		public static T SetVerticalScrollbar<T>(this T scrollRect, Scrollbar verticalScrollbar) where T : ScrollRect
		{
			((ScrollRect)scrollRect).verticalScrollbar = verticalScrollbar;
			return scrollRect;
		}

		public static T SetVerticalScrollPosition<T>(this T scrollRect, float position) where T : ScrollRect
		{
			((ScrollRect)scrollRect).verticalNormalizedPosition = position;
			return scrollRect;
		}

		public static T SetVerticalScrollbarVisibility<T>(this T scrollRect, ScrollbarVisibility visibility) where T : ScrollRect
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((ScrollRect)scrollRect).verticalScrollbarVisibility = visibility;
			return scrollRect;
		}

		public static T SetViewport<T>(this T scrollRect, RectTransform viewport) where T : ScrollRect
		{
			((ScrollRect)scrollRect).viewport = viewport;
			return scrollRect;
		}
	}
	public static class SliderExtensions
	{
		public static T SetDirection<T>(this T slider, Direction direction) where T : Slider
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Slider)slider).direction = direction;
			return slider;
		}

		public static T SetFillRect<T>(this T slider, RectTransform fillRect) where T : Slider
		{
			((Slider)slider).fillRect = fillRect;
			return slider;
		}

		public static T SetHandleRect<T>(this T slider, RectTransform handleRect) where T : Slider
		{
			((Slider)slider).handleRect = handleRect;
			return slider;
		}

		public static T SetMaxValue<T>(this T slider, float maxValue) where T : Slider
		{
			((Slider)slider).maxValue = maxValue;
			return slider;
		}

		public static T SetMinValue<T>(this T slider, float minValue) where T : Slider
		{
			((Slider)slider).minValue = minValue;
			return slider;
		}

		public static T SetValue<T>(this T slider, float value) where T : Slider
		{
			((Slider)slider).value = value;
			return slider;
		}

		public static T SetWholeNumbers<T>(this T slider, bool wholeNumbers) where T : Slider
		{
			((Slider)slider).wholeNumbers = wholeNumbers;
			return slider;
		}
	}
	public static class TMPTextExtensions
	{
		public static T SetAlignment<T>(this T tmpText, TextAlignmentOptions alignment) where T : TMP_Text
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)tmpText).alignment = alignment;
			return tmpText;
		}

		public static T SetCharacterSpacing<T>(this T tmpText, float characterSpacing) where T : TMP_Text
		{
			((TMP_Text)tmpText).characterSpacing = characterSpacing;
			return tmpText;
		}

		public static T SetColor<T>(this T tmpText, Color color) where T : TMP_Text
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)(object)tmpText).color = color;
			return tmpText;
		}

		public static T SetEnableAutoSizing<T>(this T tmpText, bool enableAutoSizing) where T : TMP_Text
		{
			((TMP_Text)tmpText).enableAutoSizing = enableAutoSizing;
			return tmpText;
		}

		public static T SetFont<T>(this T tmpText, TMP_FontAsset font) where T : TMP_Text
		{
			((TMP_Text)tmpText).font = font;
			return tmpText;
		}

		public static T SetFontSize<T>(this T tmpText, float fontSize) where T : TMP_Text
		{
			((TMP_Text)tmpText).fontSize = fontSize;
			return tmpText;
		}

		public static T SetFontMaterial<T>(this T tmpText, Material fontMaterial) where T : TMP_Text
		{
			((TMP_Text)tmpText).fontMaterial = fontMaterial;
			return tmpText;
		}

		public static T SetLineSpacing<T>(this T tmpText, float lineSpacing) where T : TMP_Text
		{
			((TMP_Text)tmpText).lineSpacing = lineSpacing;
			return tmpText;
		}

		public static T SetMargin<T>(this T tmpText, Vector4 margin) where T : TMP_Text
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)tmpText).margin = margin;
			return tmpText;
		}

		public static T SetOverflowMode<T>(this T tmpText, TextOverflowModes overflowMode) where T : TMP_Text
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)tmpText).overflowMode = overflowMode;
			return tmpText;
		}

		public static T SetRichText<T>(this T tmpText, bool richText) where T : TMP_Text
		{
			((TMP_Text)tmpText).richText = richText;
			return tmpText;
		}

		public static T SetTextWrappingMode<T>(this T tmpText, TextWrappingModes textWrappingMode) where T : TMP_Text
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)tmpText).textWrappingMode = textWrappingMode;
			return tmpText;
		}
	}
	public static class TMPInputFieldExtensions
	{
		public static T SetDoubleClickDelay<T>(this T tmpInputField, float doubleClickDelay) where T : TMP_InputField
		{
			((TMP_InputField)tmpInputField).m_DoubleClickDelay = doubleClickDelay;
			return tmpInputField;
		}

		public static T SetOnFocusSelectAll<T>(this T tmpInputField, bool onFocusSelectAll) where T : TMP_InputField
		{
			((TMP_InputField)tmpInputField).onFocusSelectAll = onFocusSelectAll;
			return tmpInputField;
		}

		public static T SetTextComponent<T>(this T tmpInputField, TMP_Text textComponent) where T : TMP_InputField
		{
			((TMP_InputField)tmpInputField).textComponent = textComponent;
			return tmpInputField;
		}

		public static T SetTextViewport<T>(this T tmpInputField, RectTransform textViewport) where T : TMP_InputField
		{
			((TMP_InputField)tmpInputField).textViewport = textViewport;
			return tmpInputField;
		}
	}
	public static class Texture2DExtensions
	{
		public static Texture2D SetFilterMode(this Texture2D texture, FilterMode filterMode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((Texture)texture).filterMode = filterMode;
			return texture;
		}

		public static Texture2D SetWrapMode(this Texture2D texture, TextureWrapMode wrapMode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((Texture)texture).wrapMode = wrapMode;
			return texture;
		}
	}
	public static class ToggleExtensions
	{
		public static T SetGraphic<T>(this T toggle, Graphic graphic) where T : Toggle
		{
			((Toggle)toggle).graphic = graphic;
			return toggle;
		}

		public static T SetToggleTransition<T>(this T toggle, ToggleTransition toggleTransition) where T : Toggle
		{
			//IL_0006: 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)
			((Toggle)toggle).toggleTransition = toggleTransition;
			return toggle;
		}
	}
	public static class UIResources
	{
		public static readonly ResourceCache<Sprite> SpriteCache = new ResourceCache<Sprite>();

		public static string ValheimNorseFont = "Valheim-Norse";

		public static string ValheimAveriaSansLibre = "Valheim-AveriaSansLibre";

		public static Dictionary<string, TMP_FontAsset> FontAssetCache { get; private set; } = new Dictionary<string, TMP_FontAsset>();

		public static TMP_FontAsset ValheimNorseFontAsset => ((TMP_Text)Minimap.instance.m_pinNamePrefab.GetComponentInChildren<TextMeshProUGUI>()).font;

		public static TMP_FontAsset ValheimAveriaSansLibreFontAsset => ((TMP_Text)UnifiedPopup.instance.bodyText).font;

		public static Sprite GetSprite(string spriteName)
		{
			return SpriteCache.GetResource(spriteName);
		}

		public static TMP_FontAsset GetFontAssetByName(string fontAssetName)
		{
			if (FontAssetCache.TryGetValue(fontAssetName, out var value))
			{
				return value;
			}
			if (fontAssetName == ValheimNorseFont)
			{
				value = ValheimNorseFontAsset;
				FontAssetCache[fontAssetName] = value;
				return value;
			}
			if (fontAssetName == ValheimAveriaSansLibre)
			{
				value = ValheimAveriaSansLibreFontAsset;
				FontAssetCache[fontAssetName] = value;
				return value;
			}
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val in array)
			{
				FontAssetCache[((Object)val).name] = val;
			}
			return FontAssetCache[fontAssetName];
		}
	}
	public static class UISpriteBuilder
	{
		private static readonly Dictionary<string, Sprite> _spriteCache = new Dictionary<string, Sprite>();

		private static readonly Color32 ColorWhite = Color32.op_Implicit(Color.white);

		private static readonly Color32 ColorClear = Color32.op_Implicit(Color.clear);

		public static Sprite CreateRoundedCornerSprite(int width, int height, int radius, FilterMode filterMode = (FilterMode)1)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0041: 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)
			//IL_00b7: 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_0071: 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_00d8: 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_0108: 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)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			string text = $"RoundedCorner-{width}w-{height}h-{radius}r";
			if (_spriteCache.TryGetValue(text, out var value))
			{
				return value;
			}
			Texture2D val = ObjectExtensions.SetName<Texture2D>(new Texture2D(width, height), text).SetWrapMode((TextureWrapMode)1).SetFilterMode(filterMode);
			Color32[] array = (Color32[])(object)new Color32[width * height];
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					array[i * width + j] = (IsCornerPixel(j, i, width, height, radius) ? ColorClear : ColorWhite);
				}
			}
			val.SetPixels32(array);
			val.Apply();
			int k;
			for (k = 0; k < width && !(Color32.op_Implicit(array[k]) == Color.white); k++)
			{
			}
			int l;
			for (l = 0; l < height && !(Color32.op_Implicit(array[l * width]) == Color.white); l++)
			{
			}
			value = Sprite.Create(val, new Rect(0f, 0f, (float)width, (float)height), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4((float)k, (float)l, (float)k, (float)l)).SetName<Sprite>(text);
			_spriteCache[text] = value;
			return value;
		}

		public static Sprite CreateSuperellipse(int width, int height, float exponent)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_0115: 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)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: 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_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			string text = $"Superellipse-{width}w-{height}h-{exponent}e";
			if (_spriteCache.TryGetValue(text, out var value))
			{
				return value;
			}
			Texture2D val = ObjectExtensions.SetName<Texture2D>(new Texture2D(width, height), text).SetWrapMode((TextureWrapMode)1).SetFilterMode((FilterMode)2);
			Color32[] array = (Color32[])(object)new Color32[width * height];
			int num = width / 2;
			int num2 = height / 2;
			float num3 = 1f * ((float)width / 2f);
			float num4 = 1f * ((float)height / 2f);
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num2; j++)
				{
					Color32 val2 = Color32.op_Implicit((Mathf.Pow(Mathf.Abs((float)i / num3), exponent) + Mathf.Pow(Mathf.Abs((float)j / num4), exponent) > 1f) ? Color.clear : Color.white);
					int x = i + num;
					int x2 = -i + num - 1;
					int y = -j + num2 - 1;
					int y2 = j + num2;
					array[XYToIndex(x, y2)] = val2;
					array[XYToIndex(x, y)] = val2;
					array[XYToIndex(x2, y)] = val2;
					array[XYToIndex(x2, y2)] = val2;
				}
			}
			val.SetPixels32(array);
			val.Apply();
			int k;
			for (k = 0; k < width && !(Color32.op_Implicit(array[k]) == Color.white); k++)
			{
			}
			int l;
			for (l = 0; l < height && !(Color32.op_Implicit(array[l * width]) == Color.white); l++)
			{
			}
			value = Sprite.Create(val, new Rect(0f, 0f, (float)width, (float)height), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4((float)k, (float)l, (float)k, (float)l)).SetName<Sprite>(text);
			_spriteCache[text] = value;
			return value;
			int XYToIndex(int num5, int num6)
			{
				return num5 + num6 * width;
			}
		}

		private static bool IsCornerPixel(int x, int y, int w, int h, int rad)
		{
			if (rad == 0)
			{
				return false;
			}
			int num = Mathf.Min(x, w - x);
			int num2 = Mathf.Min(y, h - y);
			if (num == 0 && num2 == 0)
			{
				return true;
			}
			if (num > rad || num2 > rad)
			{
				return false;
			}
			num = rad - num;
			num2 = rad - num2;
			return Mathf.Round(Mathf.Sqrt((float)(num * num + num2 * num2))) > (float)rad;
		}
	}
	public sealed class ResourceCache<T> where T : Object
	{
		private readonly Dictionary<string, T> _cache = new Dictionary<string, T>();

		public T GetResource(string resourceName)
		{
			if (!_cache.TryGetValue(resourceName, out var value))
			{
				value = Resources.FindObjectsOfTypeAll<T>().FirstByNameOrThrow(resourceName);
				_cache[resourceName] = value;
			}
			return value;
		}

		public bool TryGetResource(string resourceName, out T cachedResource)
		{
			if (!_cache.TryGetValue(resourceName, out cachedResource))
			{
				cachedResource = Resources.FindObjectsOfTypeAll<T>().FirstByName(resourceName);
				_cache[resourceName] = cachedResource;
			}
			return Object.op_Implicit((Object)(object)cachedResource);
		}
	}
}
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}