using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Pool;
using UnityEngine.Rendering;
using UnityEngine.Serialization;
using UnityEngine.Sprites;
using UnityEngine.Tilemaps;
using UnityEngine.U2D;
using UnityEngine.UI;
using UnityEngine.UI.Collections;
using UnityEngine.UI.CoroutineTween;
using UnityEngine.UIElements;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("guisystem")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Microsoft")]
[assembly: AssemblyProduct("guisystem")]
[assembly: AssemblyCopyright("Copyright © Microsoft 2013")]
[assembly: AssemblyTrademark("")]
[assembly: InternalsVisibleTo("UnityEngine.UI.Tests")]
[assembly: ComVisible(false)]
[assembly: Guid("d4f464c7-9b15-460d-b4bc-2cacd1c1df73")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace UnityEngine.UI
{
	[Serializable]
	public class AnimationTriggers
	{
		private const string kDefaultNormalAnimName = "Normal";

		private const string kDefaultHighlightedAnimName = "Highlighted";

		private const string kDefaultPressedAnimName = "Pressed";

		private const string kDefaultSelectedAnimName = "Selected";

		private const string kDefaultDisabledAnimName = "Disabled";

		[FormerlySerializedAs("normalTrigger")]
		[SerializeField]
		private string m_NormalTrigger = "Normal";

		[FormerlySerializedAs("highlightedTrigger")]
		[SerializeField]
		private string m_HighlightedTrigger = "Highlighted";

		[FormerlySerializedAs("pressedTrigger")]
		[SerializeField]
		private string m_PressedTrigger = "Pressed";

		[FormerlySerializedAs("m_HighlightedTrigger")]
		[SerializeField]
		private string m_SelectedTrigger = "Selected";

		[FormerlySerializedAs("disabledTrigger")]
		[SerializeField]
		private string m_DisabledTrigger = "Disabled";

		public string normalTrigger
		{
			get
			{
				return m_NormalTrigger;
			}
			set
			{
				m_NormalTrigger = value;
			}
		}

		public string highlightedTrigger
		{
			get
			{
				return m_HighlightedTrigger;
			}
			set
			{
				m_HighlightedTrigger = value;
			}
		}

		public string pressedTrigger
		{
			get
			{
				return m_PressedTrigger;
			}
			set
			{
				m_PressedTrigger = value;
			}
		}

		public string selectedTrigger
		{
			get
			{
				return m_SelectedTrigger;
			}
			set
			{
				m_SelectedTrigger = value;
			}
		}

		public string disabledTrigger
		{
			get
			{
				return m_DisabledTrigger;
			}
			set
			{
				m_DisabledTrigger = value;
			}
		}
	}
	[AddComponentMenu("UI/Button", 30)]
	public class Button : Selectable, IPointerClickHandler, IEventSystemHandler, ISubmitHandler
	{
		[Serializable]
		public class ButtonClickedEvent : UnityEvent
		{
		}

		[FormerlySerializedAs("onClick")]
		[SerializeField]
		private ButtonClickedEvent m_OnClick = new ButtonClickedEvent();

		public ButtonClickedEvent onClick
		{
			get
			{
				return m_OnClick;
			}
			set
			{
				m_OnClick = value;
			}
		}

		protected Button()
		{
		}

		private void Press()
		{
			if (IsActive() && IsInteractable())
			{
				UISystemProfilerApi.AddMarker("Button.onClick", (Object)(object)this);
				((UnityEvent)m_OnClick).Invoke();
			}
		}

		public virtual void OnPointerClick(PointerEventData eventData)
		{
			if (eventData.button == PointerEventData.InputButton.Left)
			{
				Press();
			}
		}

		public virtual void OnSubmit(BaseEventData eventData)
		{
			Press();
			if (IsActive() && IsInteractable())
			{
				DoStateTransition(SelectionState.Pressed, instant: false);
				((MonoBehaviour)this).StartCoroutine(OnFinishSubmit());
			}
		}

		private IEnumerator OnFinishSubmit()
		{
			float fadeTime = base.colors.fadeDuration;
			float elapsedTime = 0f;
			while (elapsedTime < fadeTime)
			{
				elapsedTime += Time.unscaledDeltaTime;
				yield return null;
			}
			DoStateTransition(base.currentSelectionState, instant: false);
		}
	}
	public enum CanvasUpdate
	{
		Prelayout,
		Layout,
		PostLayout,
		PreRender,
		LatePreRender,
		MaxUpdateValue
	}
	public interface ICanvasElement
	{
		Transform transform { get; }

		void Rebuild(CanvasUpdate executing);

		void LayoutComplete();

		void GraphicUpdateComplete();

		bool IsDestroyed();
	}
	public class CanvasUpdateRegistry
	{
		private static CanvasUpdateRegistry s_Instance;

		private bool m_PerformingLayoutUpdate;

		private bool m_PerformingGraphicUpdate;

		private string[] m_CanvasUpdateProfilerStrings = new string[5] { "CanvasUpdate.Prelayout", "CanvasUpdate.Layout", "CanvasUpdate.PostLayout", "CanvasUpdate.PreRender", "CanvasUpdate.LatePreRender" };

		private const string m_CullingUpdateProfilerString = "ClipperRegistry.Cull";

		private readonly IndexedSet<ICanvasElement> m_LayoutRebuildQueue = new IndexedSet<ICanvasElement>();

		private readonly IndexedSet<ICanvasElement> m_GraphicRebuildQueue = new IndexedSet<ICanvasElement>();

		private static readonly Comparison<ICanvasElement> s_SortLayoutFunction = SortLayoutList;

		public static CanvasUpdateRegistry instance
		{
			get
			{
				if (s_Instance == null)
				{
					s_Instance = new CanvasUpdateRegistry();
				}
				return s_Instance;
			}
		}

		protected CanvasUpdateRegistry()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			Canvas.willRenderCanvases += new WillRenderCanvases(PerformUpdate);
		}

		private bool ObjectValidForUpdate(ICanvasElement element)
		{
			bool result = element != null;
			if (element is Object)
			{
				result = (Object)((element is Object) ? element : null) != (Object)null;
			}
			return result;
		}

		private void CleanInvalidItems()
		{
			for (int num = m_LayoutRebuildQueue.Count - 1; num >= 0; num--)
			{
				ICanvasElement canvasElement = m_LayoutRebuildQueue[num];
				if (canvasElement == null)
				{
					m_LayoutRebuildQueue.RemoveAt(num);
				}
				else if (canvasElement.IsDestroyed())
				{
					m_LayoutRebuildQueue.RemoveAt(num);
					canvasElement.LayoutComplete();
				}
			}
			for (int num2 = m_GraphicRebuildQueue.Count - 1; num2 >= 0; num2--)
			{
				ICanvasElement canvasElement2 = m_GraphicRebuildQueue[num2];
				if (canvasElement2 == null)
				{
					m_GraphicRebuildQueue.RemoveAt(num2);
				}
				else if (canvasElement2.IsDestroyed())
				{
					m_GraphicRebuildQueue.RemoveAt(num2);
					canvasElement2.GraphicUpdateComplete();
				}
			}
		}

		private void PerformUpdate()
		{
			UISystemProfilerApi.BeginSample((SampleType)0);
			CleanInvalidItems();
			m_PerformingLayoutUpdate = true;
			m_LayoutRebuildQueue.Sort(s_SortLayoutFunction);
			for (int i = 0; i <= 2; i++)
			{
				for (int j = 0; j < m_LayoutRebuildQueue.Count; j++)
				{
					ICanvasElement canvasElement = m_LayoutRebuildQueue[j];
					try
					{
						if (ObjectValidForUpdate(canvasElement))
						{
							canvasElement.Rebuild((CanvasUpdate)i);
						}
					}
					catch (Exception ex)
					{
						Debug.LogException(ex, (Object)(object)canvasElement.transform);
					}
				}
			}
			for (int k = 0; k < m_LayoutRebuildQueue.Count; k++)
			{
				m_LayoutRebuildQueue[k].LayoutComplete();
			}
			m_LayoutRebuildQueue.Clear();
			m_PerformingLayoutUpdate = false;
			UISystemProfilerApi.EndSample((SampleType)0);
			UISystemProfilerApi.BeginSample((SampleType)1);
			ClipperRegistry.instance.Cull();
			m_PerformingGraphicUpdate = true;
			for (int l = 3; l < 5; l++)
			{
				for (int m = 0; m < m_GraphicRebuildQueue.Count; m++)
				{
					try
					{
						ICanvasElement canvasElement2 = m_GraphicRebuildQueue[m];
						if (ObjectValidForUpdate(canvasElement2))
						{
							canvasElement2.Rebuild((CanvasUpdate)l);
						}
					}
					catch (Exception ex2)
					{
						Debug.LogException(ex2, (Object)(object)m_GraphicRebuildQueue[m].transform);
					}
				}
			}
			for (int n = 0; n < m_GraphicRebuildQueue.Count; n++)
			{
				m_GraphicRebuildQueue[n].GraphicUpdateComplete();
			}
			m_GraphicRebuildQueue.Clear();
			m_PerformingGraphicUpdate = false;
			UISystemProfilerApi.EndSample((SampleType)1);
		}

		private static int ParentCount(Transform child)
		{
			if ((Object)(object)child == (Object)null)
			{
				return 0;
			}
			Transform parent = child.parent;
			int num = 0;
			while ((Object)(object)parent != (Object)null)
			{
				num++;
				parent = parent.parent;
			}
			return num;
		}

		private static int SortLayoutList(ICanvasElement x, ICanvasElement y)
		{
			Transform transform = x.transform;
			Transform transform2 = y.transform;
			return ParentCount(transform) - ParentCount(transform2);
		}

		public static void RegisterCanvasElementForLayoutRebuild(ICanvasElement element)
		{
			instance.InternalRegisterCanvasElementForLayoutRebuild(element);
		}

		public static bool TryRegisterCanvasElementForLayoutRebuild(ICanvasElement element)
		{
			return instance.InternalRegisterCanvasElementForLayoutRebuild(element);
		}

		private bool InternalRegisterCanvasElementForLayoutRebuild(ICanvasElement element)
		{
			if (m_LayoutRebuildQueue.Contains(element))
			{
				return false;
			}
			return m_LayoutRebuildQueue.AddUnique(element);
		}

		public static void RegisterCanvasElementForGraphicRebuild(ICanvasElement element)
		{
			instance.InternalRegisterCanvasElementForGraphicRebuild(element);
		}

		public static bool TryRegisterCanvasElementForGraphicRebuild(ICanvasElement element)
		{
			return instance.InternalRegisterCanvasElementForGraphicRebuild(element);
		}

		private bool InternalRegisterCanvasElementForGraphicRebuild(ICanvasElement element)
		{
			if (m_PerformingGraphicUpdate)
			{
				Debug.LogError((object)$"Trying to add {element} for graphic rebuild while we are already inside a graphic rebuild loop. This is not supported.");
				return false;
			}
			return m_GraphicRebuildQueue.AddUnique(element);
		}

		public static void UnRegisterCanvasElementForRebuild(ICanvasElement element)
		{
			instance.InternalUnRegisterCanvasElementForLayoutRebuild(element);
			instance.InternalUnRegisterCanvasElementForGraphicRebuild(element);
		}

		public static void DisableCanvasElementForRebuild(ICanvasElement element)
		{
			instance.InternalDisableCanvasElementForLayoutRebuild(element);
			instance.InternalDisableCanvasElementForGraphicRebuild(element);
		}

		private void InternalUnRegisterCanvasElementForLayoutRebuild(ICanvasElement element)
		{
			if (m_PerformingLayoutUpdate)
			{
				Debug.LogError((object)$"Trying to remove {element} from rebuild list while we are already inside a rebuild loop. This is not supported.");
				return;
			}
			element.LayoutComplete();
			instance.m_LayoutRebuildQueue.Remove(element);
		}

		private void InternalUnRegisterCanvasElementForGraphicRebuild(ICanvasElement element)
		{
			if (m_PerformingGraphicUpdate)
			{
				Debug.LogError((object)$"Trying to remove {element} from rebuild list while we are already inside a rebuild loop. This is not supported.");
				return;
			}
			element.GraphicUpdateComplete();
			instance.m_GraphicRebuildQueue.Remove(element);
		}

		private void InternalDisableCanvasElementForLayoutRebuild(ICanvasElement element)
		{
			if (m_PerformingLayoutUpdate)
			{
				Debug.LogError((object)$"Trying to remove {element} from rebuild list while we are already inside a rebuild loop. This is not supported.");
				return;
			}
			element.LayoutComplete();
			instance.m_LayoutRebuildQueue.DisableItem(element);
		}

		private void InternalDisableCanvasElementForGraphicRebuild(ICanvasElement element)
		{
			if (m_PerformingGraphicUpdate)
			{
				Debug.LogError((object)$"Trying to remove {element} from rebuild list while we are already inside a rebuild loop. This is not supported.");
				return;
			}
			element.GraphicUpdateComplete();
			instance.m_GraphicRebuildQueue.DisableItem(element);
		}

		public static bool IsRebuildingLayout()
		{
			return instance.m_PerformingLayoutUpdate;
		}

		public static bool IsRebuildingGraphics()
		{
			return instance.m_PerformingGraphicUpdate;
		}
	}
	[Serializable]
	public struct ColorBlock : IEquatable<ColorBlock>
	{
		[FormerlySerializedAs("normalColor")]
		[SerializeField]
		private Color m_NormalColor;

		[FormerlySerializedAs("highlightedColor")]
		[SerializeField]
		private Color m_HighlightedColor;

		[FormerlySerializedAs("pressedColor")]
		[SerializeField]
		private Color m_PressedColor;

		[FormerlySerializedAs("m_HighlightedColor")]
		[SerializeField]
		private Color m_SelectedColor;

		[FormerlySerializedAs("disabledColor")]
		[SerializeField]
		private Color m_DisabledColor;

		[Range(1f, 5f)]
		[SerializeField]
		private float m_ColorMultiplier;

		[FormerlySerializedAs("fadeDuration")]
		[SerializeField]
		private float m_FadeDuration;

		public static ColorBlock defaultColorBlock;

		public Color normalColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_NormalColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_NormalColor = value;
			}
		}

		public Color highlightedColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_HighlightedColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_HighlightedColor = value;
			}
		}

		public Color pressedColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_PressedColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_PressedColor = value;
			}
		}

		public Color selectedColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_SelectedColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_SelectedColor = value;
			}
		}

		public Color disabledColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_DisabledColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_DisabledColor = value;
			}
		}

		public float colorMultiplier
		{
			get
			{
				return m_ColorMultiplier;
			}
			set
			{
				m_ColorMultiplier = value;
			}
		}

		public float fadeDuration
		{
			get
			{
				return m_FadeDuration;
			}
			set
			{
				m_FadeDuration = value;
			}
		}

		static ColorBlock()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//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_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)
			//IL_004d: 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_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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			defaultColorBlock = new ColorBlock
			{
				m_NormalColor = Color32.op_Implicit(new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue)),
				m_HighlightedColor = Color32.op_Implicit(new Color32((byte)245, (byte)245, (byte)245, byte.MaxValue)),
				m_PressedColor = Color32.op_Implicit(new Color32((byte)200, (byte)200, (byte)200, byte.MaxValue)),
				m_SelectedColor = Color32.op_Implicit(new Color32((byte)245, (byte)245, (byte)245, byte.MaxValue)),
				m_DisabledColor = Color32.op_Implicit(new Color32((byte)200, (byte)200, (byte)200, (byte)128)),
				colorMultiplier = 1f,
				fadeDuration = 0.1f
			};
		}

		public override bool Equals(object obj)
		{
			if (!(obj is ColorBlock))
			{
				return false;
			}
			return Equals((ColorBlock)obj);
		}

		public bool Equals(ColorBlock other)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0030: 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_0044: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			if (normalColor == other.normalColor && highlightedColor == other.highlightedColor && pressedColor == other.pressedColor && selectedColor == other.selectedColor && disabledColor == other.disabledColor && colorMultiplier == other.colorMultiplier)
			{
				return fadeDuration == other.fadeDuration;
			}
			return false;
		}

		public static bool operator ==(ColorBlock point1, ColorBlock point2)
		{
			return point1.Equals(point2);
		}

		public static bool operator !=(ColorBlock point1, ColorBlock point2)
		{
			return !point1.Equals(point2);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}
	}
	public class ClipperRegistry
	{
		private static ClipperRegistry s_Instance;

		private readonly IndexedSet<IClipper> m_Clippers = new IndexedSet<IClipper>();

		public static ClipperRegistry instance
		{
			get
			{
				if (s_Instance == null)
				{
					s_Instance = new ClipperRegistry();
				}
				return s_Instance;
			}
		}

		protected ClipperRegistry()
		{
		}

		public void Cull()
		{
			int count = m_Clippers.Count;
			for (int i = 0; i < count; i++)
			{
				m_Clippers[i].PerformClipping();
			}
		}

		public static void Register(IClipper c)
		{
			if (c != null)
			{
				instance.m_Clippers.AddUnique(c);
			}
		}

		public static void Unregister(IClipper c)
		{
			instance.m_Clippers.Remove(c);
		}

		public static void Disable(IClipper c)
		{
			instance.m_Clippers.DisableItem(c);
		}
	}
	public static class Clipping
	{
		public static Rect FindCullAndClipWorldRect(List<RectMask2D> rectMaskParents, out bool validRect)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0037: 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_0055: 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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			if (rectMaskParents.Count == 0)
			{
				validRect = false;
				return default(Rect);
			}
			Rect canvasRect = rectMaskParents[0].canvasRect;
			Vector4 padding = rectMaskParents[0].padding;
			float num = ((Rect)(ref canvasRect)).xMin + padding.x;
			float num2 = ((Rect)(ref canvasRect)).xMax - padding.z;
			float num3 = ((Rect)(ref canvasRect)).yMin + padding.y;
			float num4 = ((Rect)(ref canvasRect)).yMax - padding.w;
			int count = rectMaskParents.Count;
			for (int i = 1; i < count; i++)
			{
				canvasRect = rectMaskParents[i].canvasRect;
				padding = rectMaskParents[i].padding;
				if (num < ((Rect)(ref canvasRect)).xMin + padding.x)
				{
					num = ((Rect)(ref canvasRect)).xMin + padding.x;
				}
				if (num3 < ((Rect)(ref canvasRect)).yMin + padding.y)
				{
					num3 = ((Rect)(ref canvasRect)).yMin + padding.y;
				}
				if (num2 > ((Rect)(ref canvasRect)).xMax - padding.z)
				{
					num2 = ((Rect)(ref canvasRect)).xMax - padding.z;
				}
				if (num4 > ((Rect)(ref canvasRect)).yMax - padding.w)
				{
					num4 = ((Rect)(ref canvasRect)).yMax - padding.w;
				}
			}
			validRect = num2 > num && num4 > num3;
			if (!validRect)
			{
				return default(Rect);
			}
			return new Rect(num, num3, num2 - num, num4 - num3);
		}
	}
	public interface IClipper
	{
		void PerformClipping();
	}
	public interface IClippable
	{
		GameObject gameObject { get; }

		RectTransform rectTransform { get; }

		void RecalculateClipping();

		void Cull(Rect clipRect, bool validRect);

		void SetClipRect(Rect value, bool validRect);

		void SetClipSoftness(Vector2 clipSoftness);
	}
	internal class RectangularVertexClipper
	{
		private readonly Vector3[] m_WorldCorners = (Vector3[])(object)new Vector3[4];

		private readonly Vector3[] m_CanvasCorners = (Vector3[])(object)new Vector3[4];

		public Rect GetCanvasRect(RectTransform t, Canvas c)
		{
			//IL_000b: 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_0039: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c == (Object)null)
			{
				return default(Rect);
			}
			t.GetWorldCorners(m_WorldCorners);
			Transform component = ((Component)c).GetComponent<Transform>();
			for (int i = 0; i < 4; i++)
			{
				m_CanvasCorners[i] = component.InverseTransformPoint(m_WorldCorners[i]);
			}
			return new Rect(m_CanvasCorners[0].x, m_CanvasCorners[0].y, m_CanvasCorners[2].x - m_CanvasCorners[0].x, m_CanvasCorners[2].y - m_CanvasCorners[0].y);
		}
	}
	public static class DefaultControls
	{
		public interface IFactoryControls
		{
			GameObject CreateGameObject(string name, params Type[] components);
		}

		private class DefaultRuntimeFactory : IFactoryControls
		{
			public static IFactoryControls Default = new DefaultRuntimeFactory();

			public GameObject CreateGameObject(string name, params Type[] components)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				return new GameObject(name, components);
			}
		}

		public struct Resources
		{
			public Sprite standard;

			public Sprite background;

			public Sprite inputField;

			public Sprite knob;

			public Sprite checkmark;

			public Sprite dropdown;

			public Sprite mask;
		}

		private static IFactoryControls m_CurrentFactory = DefaultRuntimeFactory.Default;

		private const float kWidth = 160f;

		private const float kThickHeight = 30f;

		private const float kThinHeight = 20f;

		private static Vector2 s_ThickElementSize = new Vector2(160f, 30f);

		private static Vector2 s_ThinElementSize = new Vector2(160f, 20f);

		private static Vector2 s_ImageElementSize = new Vector2(100f, 100f);

		private static Color s_DefaultSelectableColor = new Color(1f, 1f, 1f, 1f);

		private static Color s_PanelColor = new Color(1f, 1f, 1f, 0.392f);

		private static Color s_TextColor = new Color(10f / 51f, 10f / 51f, 10f / 51f, 1f);

		public static IFactoryControls factory => m_CurrentFactory;

		private static GameObject CreateUIElementRoot(string name, Vector2 size, params Type[] components)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = factory.CreateGameObject(name, components);
			obj.GetComponent<RectTransform>().sizeDelta = size;
			return obj;
		}

		private static GameObject CreateUIObject(string name, GameObject parent, params Type[] components)
		{
			GameObject obj = factory.CreateGameObject(name, components);
			SetParentAndAlign(obj, parent);
			return obj;
		}

		private static void SetDefaultTextValues(Text lbl)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			lbl.color = s_TextColor;
			if ((Object)(object)lbl.font == (Object)null)
			{
				lbl.AssignDefaultFont();
			}
		}

		private static void SetDefaultColorTransitionValues(Selectable slider)
		{
			//IL_0018: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock colors = slider.colors;
			colors.highlightedColor = new Color(0.882f, 0.882f, 0.882f);
			colors.pressedColor = new Color(0.698f, 0.698f, 0.698f);
			colors.disabledColor = new Color(0.521f, 0.521f, 0.521f);
		}

		private static void SetParentAndAlign(GameObject child, GameObject parent)
		{
			if (!((Object)(object)parent == (Object)null))
			{
				child.transform.SetParent(parent.transform, false);
				SetLayerRecursively(child, parent.layer);
			}
		}

		private static void SetLayerRecursively(GameObject go, int layer)
		{
			go.layer = layer;
			Transform transform = go.transform;
			for (int i = 0; i < transform.childCount; i++)
			{
				SetLayerRecursively(((Component)transform.GetChild(i)).gameObject, layer);
			}
		}

		public static GameObject CreatePanel(Resources resources)
		{
			//IL_0005: 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_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_0049: 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)
			GameObject obj = CreateUIElementRoot("Panel", s_ThickElementSize, typeof(Image));
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = Vector2.zero;
			Image component2 = obj.GetComponent<Image>();
			component2.sprite = resources.background;
			component2.type = Image.Type.Sliced;
			component2.color = s_PanelColor;
			return obj;
		}

		public static GameObject CreateButton(Resources resources)
		{
			//IL_0005: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIElementRoot("Button (Legacy)", s_ThickElementSize, typeof(Image), typeof(Button));
			GameObject obj = CreateUIObject("Text (Legacy)", val, typeof(Text));
			Image component = val.GetComponent<Image>();
			component.sprite = resources.standard;
			component.type = Image.Type.Sliced;
			component.color = s_DefaultSelectableColor;
			SetDefaultColorTransitionValues(val.GetComponent<Button>());
			Text component2 = obj.GetComponent<Text>();
			component2.text = "Button";
			component2.alignment = (TextAnchor)4;
			SetDefaultTextValues(component2);
			RectTransform component3 = obj.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.sizeDelta = Vector2.zero;
			return val;
		}

		public static GameObject CreateText(Resources resources)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateUIElementRoot("Text (Legacy)", s_ThickElementSize, typeof(Text));
			Text component = obj.GetComponent<Text>();
			component.text = "New Text";
			SetDefaultTextValues(component);
			return obj;
		}

		public static GameObject CreateImage(Resources resources)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return CreateUIElementRoot("Image", s_ImageElementSize, typeof(Image));
		}

		public static GameObject CreateRawImage(Resources resources)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return CreateUIElementRoot("RawImage", s_ImageElementSize, typeof(RawImage));
		}

		public static GameObject CreateSlider(Resources resources)
		{
			//IL_0005: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIElementRoot("Slider", s_ThinElementSize, typeof(Slider));
			GameObject val2 = CreateUIObject("Background", val, typeof(Image));
			GameObject val3 = CreateUIObject("Fill Area", val, typeof(RectTransform));
			GameObject val4 = CreateUIObject("Fill", val3, typeof(Image));
			GameObject val5 = CreateUIObject("Handle Slide Area", val, typeof(RectTransform));
			GameObject val6 = CreateUIObject("Handle", val5, typeof(Image));
			Image component = val2.GetComponent<Image>();
			component.sprite = resources.background;
			component.type = Image.Type.Sliced;
			component.color = s_DefaultSelectableColor;
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0.25f);
			component2.anchorMax = new Vector2(1f, 0.75f);
			component2.sizeDelta = new Vector2(0f, 0f);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0.25f);
			component3.anchorMax = new Vector2(1f, 0.75f);
			component3.anchoredPosition = new Vector2(-5f, 0f);
			component3.sizeDelta = new Vector2(-20f, 0f);
			Image component4 = val4.GetComponent<Image>();
			component4.sprite = resources.standard;
			component4.type = Image.Type.Sliced;
			component4.color = s_DefaultSelectableColor;
			val4.GetComponent<RectTransform>().sizeDelta = new Vector2(10f, 0f);
			RectTransform component5 = val5.GetComponent<RectTransform>();
			component5.sizeDelta = new Vector2(-20f, 0f);
			component5.anchorMin = new Vector2(0f, 0f);
			component5.anchorMax = new Vector2(1f, 1f);
			Image component6 = val6.GetComponent<Image>();
			component6.sprite = resources.knob;
			component6.color = s_DefaultSelectableColor;
			val6.GetComponent<RectTransform>().sizeDelta = new Vector2(20f, 0f);
			Slider component7 = val.GetComponent<Slider>();
			component7.fillRect = val4.GetComponent<RectTransform>();
			component7.handleRect = val6.GetComponent<RectTransform>();
			component7.targetGraphic = component6;
			component7.direction = Slider.Direction.LeftToRight;
			SetDefaultColorTransitionValues(component7);
			return val;
		}

		public static GameObject CreateScrollbar(Resources resources)
		{
			//IL_0005: 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_00ab: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIElementRoot("Scrollbar", s_ThinElementSize, typeof(Image), typeof(Scrollbar));
			GameObject val2 = CreateUIObject("Sliding Area", val, typeof(RectTransform));
			GameObject obj = CreateUIObject("Handle", val2, typeof(Image));
			Image component = val.GetComponent<Image>();
			component.sprite = resources.background;
			component.type = Image.Type.Sliced;
			component.color = s_DefaultSelectableColor;
			Image component2 = obj.GetComponent<Image>();
			component2.sprite = resources.standard;
			component2.type = Image.Type.Sliced;
			component2.color = s_DefaultSelectableColor;
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.sizeDelta = new Vector2(-20f, -20f);
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			RectTransform component4 = obj.GetComponent<RectTransform>();
			component4.sizeDelta = new Vector2(20f, 20f);
			Scrollbar component5 = val.GetComponent<Scrollbar>();
			component5.handleRect = component4;
			component5.targetGraphic = component2;
			SetDefaultColorTransitionValues(component5);
			return val;
		}

		public static GameObject CreateToggle(Resources resources)
		{
			//IL_0005: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_0146: 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_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIElementRoot("Toggle", s_ThinElementSize, typeof(Toggle));
			GameObject val2 = CreateUIObject("Background", val, typeof(Image));
			GameObject val3 = CreateUIObject("Checkmark", val2, typeof(Image));
			GameObject obj = CreateUIObject("Label", val, typeof(Text));
			Toggle component = val.GetComponent<Toggle>();
			component.isOn = true;
			Image component2 = val2.GetComponent<Image>();
			component2.sprite = resources.standard;
			component2.type = Image.Type.Sliced;
			component2.color = s_DefaultSelectableColor;
			Image component3 = val3.GetComponent<Image>();
			component3.sprite = resources.checkmark;
			Text component4 = obj.GetComponent<Text>();
			component4.text = "Toggle";
			SetDefaultTextValues(component4);
			component.graphic = component3;
			component.targetGraphic = component2;
			SetDefaultColorTransitionValues(component);
			RectTransform component5 = val2.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(0f, 1f);
			component5.anchorMax = new Vector2(0f, 1f);
			component5.anchoredPosition = new Vector2(10f, -10f);
			component5.sizeDelta = new Vector2(20f, 20f);
			RectTransform component6 = val3.GetComponent<RectTransform>();
			component6.anchorMin = new Vector2(0.5f, 0.5f);
			component6.anchorMax = new Vector2(0.5f, 0.5f);
			component6.anchoredPosition = Vector2.zero;
			component6.sizeDelta = new Vector2(20f, 20f);
			RectTransform component7 = obj.GetComponent<RectTransform>();
			component7.anchorMin = new Vector2(0f, 0f);
			component7.anchorMax = new Vector2(1f, 1f);
			component7.offsetMin = new Vector2(23f, 1f);
			component7.offsetMax = new Vector2(-5f, -2f);
			return val;
		}

		public static GameObject CreateInputField(Resources resources)
		{
			//IL_0005: 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_00d9: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIElementRoot("InputField (Legacy)", s_ThickElementSize, typeof(Image), typeof(InputField));
			GameObject val2 = CreateUIObject("Placeholder", val, typeof(Text));
			GameObject obj = CreateUIObject("Text (Legacy)", val, typeof(Text));
			Image component = val.GetComponent<Image>();
			component.sprite = resources.inputField;
			component.type = Image.Type.Sliced;
			component.color = s_DefaultSelectableColor;
			InputField component2 = val.GetComponent<InputField>();
			SetDefaultColorTransitionValues(component2);
			Text component3 = obj.GetComponent<Text>();
			component3.text = "";
			component3.supportRichText = false;
			SetDefaultTextValues(component3);
			Text component4 = val2.GetComponent<Text>();
			component4.text = "Enter text...";
			component4.fontStyle = (FontStyle)2;
			Color color = component3.color;
			color.a *= 0.5f;
			component4.color = color;
			RectTransform component5 = obj.GetComponent<RectTransform>();
			component5.anchorMin = Vector2.zero;
			component5.anchorMax = Vector2.one;
			component5.sizeDelta = Vector2.zero;
			component5.offsetMin = new Vector2(10f, 6f);
			component5.offsetMax = new Vector2(-10f, -7f);
			RectTransform component6 = val2.GetComponent<RectTransform>();
			component6.anchorMin = Vector2.zero;
			component6.anchorMax = Vector2.one;
			component6.sizeDelta = Vector2.zero;
			component6.offsetMin = new Vector2(10f, 6f);
			component6.offsetMax = new Vector2(-10f, -7f);
			component2.textComponent = component3;
			component2.placeholder = component4;
			return val;
		}

		public static GameObject CreateDropdown(Resources resources)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0555: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_059a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0630: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_065f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0674: Unknown result type (might be due to invalid IL or missing references)
			//IL_0688: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIElementRoot("Dropdown (Legacy)", s_ThickElementSize, typeof(Image), typeof(Dropdown));
			GameObject val2 = CreateUIObject("Label", val, typeof(Text));
			GameObject val3 = CreateUIObject("Arrow", val, typeof(Image));
			GameObject val4 = CreateUIObject("Template", val, typeof(Image), typeof(ScrollRect));
			GameObject val5 = CreateUIObject("Viewport", val4, typeof(Image), typeof(Mask));
			GameObject val6 = CreateUIObject("Content", val5, typeof(RectTransform));
			GameObject val7 = CreateUIObject("Item", val6, typeof(Toggle));
			GameObject val8 = CreateUIObject("Item Background", val7, typeof(Image));
			GameObject val9 = CreateUIObject("Item Checkmark", val7, typeof(Image));
			GameObject obj = CreateUIObject("Item Label", val7, typeof(Text));
			GameObject obj2 = CreateScrollbar(resources);
			((Object)obj2).name = "Scrollbar";
			SetParentAndAlign(obj2, val4);
			Scrollbar component = obj2.GetComponent<Scrollbar>();
			component.SetDirection(Scrollbar.Direction.BottomToTop, includeRectLayouts: true);
			RectTransform component2 = obj2.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.right;
			component2.anchorMax = Vector2.one;
			component2.pivot = Vector2.one;
			component2.sizeDelta = new Vector2(component2.sizeDelta.x, 0f);
			Text component3 = obj.GetComponent<Text>();
			SetDefaultTextValues(component3);
			component3.alignment = (TextAnchor)3;
			Image component4 = val8.GetComponent<Image>();
			component4.color = Color32.op_Implicit(new Color32((byte)245, (byte)245, (byte)245, byte.MaxValue));
			Image component5 = val9.GetComponent<Image>();
			component5.sprite = resources.checkmark;
			Toggle component6 = val7.GetComponent<Toggle>();
			component6.targetGraphic = component4;
			component6.graphic = component5;
			component6.isOn = true;
			Image component7 = val4.GetComponent<Image>();
			component7.sprite = resources.standard;
			component7.type = Image.Type.Sliced;
			ScrollRect component8 = val4.GetComponent<ScrollRect>();
			component8.content = val6.GetComponent<RectTransform>();
			component8.viewport = val5.GetComponent<RectTransform>();
			component8.horizontal = false;
			component8.movementType = ScrollRect.MovementType.Clamped;
			component8.verticalScrollbar = component;
			component8.verticalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
			component8.verticalScrollbarSpacing = -3f;
			val5.GetComponent<Mask>().showMaskGraphic = false;
			Image component9 = val5.GetComponent<Image>();
			component9.sprite = resources.mask;
			component9.type = Image.Type.Sliced;
			Text component10 = val2.GetComponent<Text>();
			SetDefaultTextValues(component10);
			component10.alignment = (TextAnchor)3;
			val3.GetComponent<Image>().sprite = resources.dropdown;
			Image component11 = val.GetComponent<Image>();
			component11.sprite = resources.standard;
			component11.color = s_DefaultSelectableColor;
			component11.type = Image.Type.Sliced;
			Dropdown component12 = val.GetComponent<Dropdown>();
			component12.targetGraphic = component11;
			SetDefaultColorTransitionValues(component12);
			component12.template = val4.GetComponent<RectTransform>();
			component12.captionText = component10;
			component12.itemText = component3;
			component3.text = "Option A";
			component12.options.Add(new Dropdown.OptionData
			{
				text = "Option A"
			});
			component12.options.Add(new Dropdown.OptionData
			{
				text = "Option B"
			});
			component12.options.Add(new Dropdown.OptionData
			{
				text = "Option C"
			});
			component12.RefreshShownValue();
			RectTransform component13 = val2.GetComponent<RectTransform>();
			component13.anchorMin = Vector2.zero;
			component13.anchorMax = Vector2.one;
			component13.offsetMin = new Vector2(10f, 6f);
			component13.offsetMax = new Vector2(-25f, -7f);
			RectTransform component14 = val3.GetComponent<RectTransform>();
			component14.anchorMin = new Vector2(1f, 0.5f);
			component14.anchorMax = new Vector2(1f, 0.5f);
			component14.sizeDelta = new Vector2(20f, 20f);
			component14.anchoredPosition = new Vector2(-15f, 0f);
			RectTransform component15 = val4.GetComponent<RectTransform>();
			component15.anchorMin = new Vector2(0f, 0f);
			component15.anchorMax = new Vector2(1f, 0f);
			component15.pivot = new Vector2(0.5f, 1f);
			component15.anchoredPosition = new Vector2(0f, 2f);
			component15.sizeDelta = new Vector2(0f, 150f);
			RectTransform component16 = val5.GetComponent<RectTransform>();
			component16.anchorMin = new Vector2(0f, 0f);
			component16.anchorMax = new Vector2(1f, 1f);
			component16.sizeDelta = new Vector2(-18f, 0f);
			component16.pivot = new Vector2(0f, 1f);
			RectTransform component17 = val6.GetComponent<RectTransform>();
			component17.anchorMin = new Vector2(0f, 1f);
			component17.anchorMax = new Vector2(1f, 1f);
			component17.pivot = new Vector2(0.5f, 1f);
			component17.anchoredPosition = new Vector2(0f, 0f);
			component17.sizeDelta = new Vector2(0f, 28f);
			RectTransform component18 = val7.GetComponent<RectTransform>();
			component18.anchorMin = new Vector2(0f, 0.5f);
			component18.anchorMax = new Vector2(1f, 0.5f);
			component18.sizeDelta = new Vector2(0f, 20f);
			RectTransform component19 = val8.GetComponent<RectTransform>();
			component19.anchorMin = Vector2.zero;
			component19.anchorMax = Vector2.one;
			component19.sizeDelta = Vector2.zero;
			RectTransform component20 = val9.GetComponent<RectTransform>();
			component20.anchorMin = new Vector2(0f, 0.5f);
			component20.anchorMax = new Vector2(0f, 0.5f);
			component20.sizeDelta = new Vector2(20f, 20f);
			component20.anchoredPosition = new Vector2(10f, 0f);
			RectTransform component21 = obj.GetComponent<RectTransform>();
			component21.anchorMin = Vector2.zero;
			component21.anchorMax = Vector2.one;
			component21.offsetMin = new Vector2(20f, 1f);
			component21.offsetMax = new Vector2(-10f, -2f);
			val4.SetActive(false);
			return val;
		}

		public static GameObject CreateScrollView(Resources resources)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00cc: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIElementRoot("Scroll View", new Vector2(200f, 200f), typeof(Image), typeof(ScrollRect));
			GameObject val2 = CreateUIObject("Viewport", val, typeof(Image), typeof(Mask));
			GameObject obj = CreateUIObject("Content", val2, typeof(RectTransform));
			GameObject val3 = CreateScrollbar(resources);
			((Object)val3).name = "Scrollbar Horizontal";
			SetParentAndAlign(val3, val);
			RectTransform component = val3.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.right;
			component.pivot = Vector2.zero;
			component.sizeDelta = new Vector2(0f, component.sizeDelta.y);
			GameObject val4 = CreateScrollbar(resources);
			((Object)val4).name = "Scrollbar Vertical";
			SetParentAndAlign(val4, val);
			val4.GetComponent<Scrollbar>().SetDirection(Scrollbar.Direction.BottomToTop, includeRectLayouts: true);
			RectTransform component2 = val4.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.right;
			component2.anchorMax = Vector2.one;
			component2.pivot = Vector2.one;
			component2.sizeDelta = new Vector2(component2.sizeDelta.x, 0f);
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.sizeDelta = Vector2.zero;
			component3.pivot = Vector2.up;
			RectTransform component4 = obj.GetComponent<RectTransform>();
			component4.anchorMin = Vector2.up;
			component4.anchorMax = Vector2.one;
			component4.sizeDelta = new Vector2(0f, 300f);
			component4.pivot = Vector2.up;
			ScrollRect component5 = val.GetComponent<ScrollRect>();
			component5.content = component4;
			component5.viewport = component3;
			component5.horizontalScrollbar = val3.GetComponent<Scrollbar>();
			component5.verticalScrollbar = val4.GetComponent<Scrollbar>();
			component5.horizontalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
			component5.verticalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
			component5.horizontalScrollbarSpacing = -3f;
			component5.verticalScrollbarSpacing = -3f;
			Image component6 = val.GetComponent<Image>();
			component6.sprite = resources.background;
			component6.type = Image.Type.Sliced;
			component6.color = s_PanelColor;
			val2.GetComponent<Mask>().showMaskGraphic = false;
			Image component7 = val2.GetComponent<Image>();
			component7.sprite = resources.mask;
			component7.type = Image.Type.Sliced;
			return val;
		}
	}
	[AddComponentMenu("UI/Legacy/Dropdown", 102)]
	[RequireComponent(typeof(RectTransform))]
	public class Dropdown : Selectable, IPointerClickHandler, IEventSystemHandler, ISubmitHandler, ICancelHandler
	{
		protected internal class DropdownItem : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, ICancelHandler
		{
			[SerializeField]
			private Text m_Text;

			[SerializeField]
			private Image m_Image;

			[SerializeField]
			private RectTransform m_RectTransform;

			[SerializeField]
			private Toggle m_Toggle;

			public Text text
			{
				get
				{
					return m_Text;
				}
				set
				{
					m_Text = value;
				}
			}

			public Image image
			{
				get
				{
					return m_Image;
				}
				set
				{
					m_Image = value;
				}
			}

			public RectTransform rectTransform
			{
				get
				{
					return m_RectTransform;
				}
				set
				{
					m_RectTransform = value;
				}
			}

			public Toggle toggle
			{
				get
				{
					return m_Toggle;
				}
				set
				{
					m_Toggle = value;
				}
			}

			public virtual void OnPointerEnter(PointerEventData eventData)
			{
				EventSystem.current.SetSelectedGameObject(((Component)this).gameObject);
			}

			public virtual void OnCancel(BaseEventData eventData)
			{
				Dropdown componentInParent = ((Component)this).GetComponentInParent<Dropdown>();
				if (Object.op_Implicit((Object)(object)componentInParent))
				{
					componentInParent.Hide();
				}
			}
		}

		[Serializable]
		public class OptionData
		{
			[SerializeField]
			private string m_Text;

			[SerializeField]
			private Sprite m_Image;

			public string text
			{
				get
				{
					return m_Text;
				}
				set
				{
					m_Text = value;
				}
			}

			public Sprite image
			{
				get
				{
					return m_Image;
				}
				set
				{
					m_Image = value;
				}
			}

			public OptionData()
			{
			}

			public OptionData(string text)
			{
				this.text = text;
			}

			public OptionData(Sprite image)
			{
				this.image = image;
			}

			public OptionData(string text, Sprite image)
			{
				this.text = text;
				this.image = image;
			}
		}

		[Serializable]
		public class OptionDataList
		{
			[SerializeField]
			private List<OptionData> m_Options;

			public List<OptionData> options
			{
				get
				{
					return m_Options;
				}
				set
				{
					m_Options = value;
				}
			}

			public OptionDataList()
			{
				options = new List<OptionData>();
			}
		}

		[Serializable]
		public class DropdownEvent : UnityEvent<int>
		{
		}

		[SerializeField]
		private RectTransform m_Template;

		[SerializeField]
		private Text m_CaptionText;

		[SerializeField]
		private Image m_CaptionImage;

		[Space]
		[SerializeField]
		private Text m_ItemText;

		[SerializeField]
		private Image m_ItemImage;

		[Space]
		[SerializeField]
		private int m_Value;

		[Space]
		[SerializeField]
		private OptionDataList m_Options = new OptionDataList();

		[Space]
		[SerializeField]
		private DropdownEvent m_OnValueChanged = new DropdownEvent();

		[SerializeField]
		private float m_AlphaFadeSpeed = 0.15f;

		private GameObject m_Dropdown;

		private GameObject m_Blocker;

		private List<DropdownItem> m_Items = new List<DropdownItem>();

		private TweenRunner<FloatTween> m_AlphaTweenRunner;

		private bool validTemplate;

		private const int kHighSortingLayer = 30000;

		private static OptionData s_NoOptionData = new OptionData();

		public RectTransform template
		{
			get
			{
				return m_Template;
			}
			set
			{
				m_Template = value;
				RefreshShownValue();
			}
		}

		public Text captionText
		{
			get
			{
				return m_CaptionText;
			}
			set
			{
				m_CaptionText = value;
				RefreshShownValue();
			}
		}

		public Image captionImage
		{
			get
			{
				return m_CaptionImage;
			}
			set
			{
				m_CaptionImage = value;
				RefreshShownValue();
			}
		}

		public Text itemText
		{
			get
			{
				return m_ItemText;
			}
			set
			{
				m_ItemText = value;
				RefreshShownValue();
			}
		}

		public Image itemImage
		{
			get
			{
				return m_ItemImage;
			}
			set
			{
				m_ItemImage = value;
				RefreshShownValue();
			}
		}

		public List<OptionData> options
		{
			get
			{
				return m_Options.options;
			}
			set
			{
				m_Options.options = value;
				RefreshShownValue();
			}
		}

		public DropdownEvent onValueChanged
		{
			get
			{
				return m_OnValueChanged;
			}
			set
			{
				m_OnValueChanged = value;
			}
		}

		public float alphaFadeSpeed
		{
			get
			{
				return m_AlphaFadeSpeed;
			}
			set
			{
				m_AlphaFadeSpeed = value;
			}
		}

		public int value
		{
			get
			{
				return m_Value;
			}
			set
			{
				Set(value);
			}
		}

		public void SetValueWithoutNotify(int input)
		{
			Set(input, sendCallback: false);
		}

		private void Set(int value, bool sendCallback = true)
		{
			if (!Application.isPlaying || (value != m_Value && options.Count != 0))
			{
				m_Value = Mathf.Clamp(value, 0, options.Count - 1);
				RefreshShownValue();
				if (sendCallback)
				{
					UISystemProfilerApi.AddMarker("Dropdown.value", (Object)(object)this);
					((UnityEvent<int>)m_OnValueChanged).Invoke(m_Value);
				}
			}
		}

		protected Dropdown()
		{
		}

		protected override void Awake()
		{
			if (Object.op_Implicit((Object)(object)m_CaptionImage))
			{
				((Behaviour)m_CaptionImage).enabled = (Object)(object)m_CaptionImage.sprite != (Object)null;
			}
			if (Object.op_Implicit((Object)(object)m_Template))
			{
				((Component)m_Template).gameObject.SetActive(false);
			}
		}

		protected override void Start()
		{
			m_AlphaTweenRunner = new TweenRunner<FloatTween>();
			m_AlphaTweenRunner.Init((MonoBehaviour)(object)this);
			base.Start();
			RefreshShownValue();
		}

		protected override void OnDisable()
		{
			ImmediateDestroyDropdownList();
			if ((Object)(object)m_Blocker != (Object)null)
			{
				DestroyBlocker(m_Blocker);
			}
			m_Blocker = null;
			base.OnDisable();
		}

		public void RefreshShownValue()
		{
			OptionData optionData = s_NoOptionData;
			if (options.Count > 0)
			{
				optionData = options[Mathf.Clamp(m_Value, 0, options.Count - 1)];
			}
			if (Object.op_Implicit((Object)(object)m_CaptionText))
			{
				if (optionData != null && optionData.text != null)
				{
					m_CaptionText.text = optionData.text;
				}
				else
				{
					m_CaptionText.text = "";
				}
			}
			if (Object.op_Implicit((Object)(object)m_CaptionImage))
			{
				if (optionData != null)
				{
					m_CaptionImage.sprite = optionData.image;
				}
				else
				{
					m_CaptionImage.sprite = null;
				}
				((Behaviour)m_CaptionImage).enabled = (Object)(object)m_CaptionImage.sprite != (Object)null;
			}
		}

		public void AddOptions(List<OptionData> options)
		{
			this.options.AddRange(options);
			RefreshShownValue();
		}

		public void AddOptions(List<string> options)
		{
			int count = options.Count;
			for (int i = 0; i < count; i++)
			{
				this.options.Add(new OptionData(options[i]));
			}
			RefreshShownValue();
		}

		public void AddOptions(List<Sprite> options)
		{
			int count = options.Count;
			for (int i = 0; i < count; i++)
			{
				this.options.Add(new OptionData(options[i]));
			}
			RefreshShownValue();
		}

		public void ClearOptions()
		{
			options.Clear();
			m_Value = 0;
			RefreshShownValue();
		}

		private void SetupTemplate(Canvas rootCanvas)
		{
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			validTemplate = false;
			if (!Object.op_Implicit((Object)(object)m_Template))
			{
				Debug.LogError((object)"The dropdown template is not assigned. The template needs to be assigned and must have a child GameObject with a Toggle component serving as the item.", (Object)(object)this);
				return;
			}
			GameObject gameObject = ((Component)m_Template).gameObject;
			gameObject.SetActive(true);
			Toggle componentInChildren = ((Component)m_Template).GetComponentInChildren<Toggle>();
			validTemplate = true;
			if (!Object.op_Implicit((Object)(object)componentInChildren) || (Object)(object)((Component)componentInChildren).transform == (Object)(object)template)
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The template must have a child GameObject with a Toggle component serving as the item.", (Object)(object)template);
			}
			else if (!(((Component)componentInChildren).transform.parent is RectTransform))
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The child GameObject with a Toggle component (the item) must have a RectTransform on its parent.", (Object)(object)template);
			}
			else if ((Object)(object)itemText != (Object)null && !((Component)itemText).transform.IsChildOf(((Component)componentInChildren).transform))
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The Item Text must be on the item GameObject or children of it.", (Object)(object)template);
			}
			else if ((Object)(object)itemImage != (Object)null && !((Component)itemImage).transform.IsChildOf(((Component)componentInChildren).transform))
			{
				validTemplate = false;
				Debug.LogError((object)"The dropdown template is not valid. The Item Image must be on the item GameObject or children of it.", (Object)(object)template);
			}
			if (!validTemplate)
			{
				gameObject.SetActive(false);
				return;
			}
			DropdownItem dropdownItem = ((Component)componentInChildren).gameObject.AddComponent<DropdownItem>();
			dropdownItem.text = m_ItemText;
			dropdownItem.image = m_ItemImage;
			dropdownItem.toggle = componentInChildren;
			dropdownItem.rectTransform = (RectTransform)((Component)componentInChildren).transform;
			Canvas val = null;
			Transform parent = ((Transform)m_Template).parent;
			while ((Object)(object)parent != (Object)null)
			{
				val = ((Component)parent).GetComponent<Canvas>();
				if ((Object)(object)val != (Object)null)
				{
					break;
				}
				parent = parent.parent;
			}
			Canvas val2 = default(Canvas);
			if (!gameObject.TryGetComponent<Canvas>(ref val2))
			{
				Canvas obj = gameObject.AddComponent<Canvas>();
				obj.overrideSorting = true;
				obj.sortingOrder = 30000;
				obj.sortingLayerID = rootCanvas.sortingLayerID;
			}
			if ((Object)(object)val != (Object)null)
			{
				Component[] components = (Component[])(object)((Component)val).GetComponents<BaseRaycaster>();
				Component[] array = components;
				for (int i = 0; i < array.Length; i++)
				{
					Type type = ((object)array[i]).GetType();
					if ((Object)(object)gameObject.GetComponent(type) == (Object)null)
					{
						gameObject.AddComponent(type);
					}
				}
			}
			else
			{
				GetOrAddComponent<GraphicRaycaster>(gameObject);
			}
			GetOrAddComponent<CanvasGroup>(gameObject);
			gameObject.SetActive(false);
			validTemplate = true;
		}

		private static T GetOrAddComponent<T>(GameObject go) where T : Component
		{
			T val = go.GetComponent<T>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = go.AddComponent<T>();
			}
			return val;
		}

		public virtual void OnPointerClick(PointerEventData eventData)
		{
			Show();
		}

		public virtual void OnSubmit(BaseEventData eventData)
		{
			Show();
		}

		public virtual void OnCancel(BaseEventData eventData)
		{
			Hide();
		}

		public void Show()
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Unknown result type (might be due to invalid IL or missing references)
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_0571: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0582: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			if (!IsActive() || !IsInteractable() || (Object)(object)m_Dropdown != (Object)null)
			{
				return;
			}
			List<Canvas> list = CollectionPool<List<Canvas>, Canvas>.Get();
			((Component)this).gameObject.GetComponentsInParent<Canvas>(false, list);
			if (list.Count == 0)
			{
				return;
			}
			int count = list.Count;
			Canvas val = list[count - 1];
			for (int i = 0; i < count; i++)
			{
				if (list[i].isRootCanvas || list[i].overrideSorting)
				{
					val = list[i];
					break;
				}
			}
			CollectionPool<List<Canvas>, Canvas>.Release(list);
			if (!validTemplate)
			{
				SetupTemplate(val);
				if (!validTemplate)
				{
					return;
				}
			}
			((Component)m_Template).gameObject.SetActive(true);
			m_Dropdown = CreateDropdownList(((Component)m_Template).gameObject);
			((Object)m_Dropdown).name = "Dropdown List";
			m_Dropdown.SetActive(true);
			Transform transform = m_Dropdown.transform;
			RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			((Transform)val2).SetParent(((Component)m_Template).transform.parent, false);
			DropdownItem componentInChildren = m_Dropdown.GetComponentInChildren<DropdownItem>();
			Transform transform2 = ((Component)((Transform)componentInChildren.rectTransform).parent).gameObject.transform;
			RectTransform val3 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			((Component)componentInChildren.rectTransform).gameObject.SetActive(true);
			Rect rect = val3.rect;
			Rect rect2 = componentInChildren.rectTransform.rect;
			Vector2 val4 = ((Rect)(ref rect2)).min - ((Rect)(ref rect)).min + Vector2.op_Implicit(((Transform)componentInChildren.rectTransform).localPosition);
			Vector2 val5 = ((Rect)(ref rect2)).max - ((Rect)(ref rect)).max + Vector2.op_Implicit(((Transform)componentInChildren.rectTransform).localPosition);
			Vector2 size = ((Rect)(ref rect2)).size;
			m_Items.Clear();
			Toggle toggle = null;
			int count2 = options.Count;
			for (int j = 0; j < count2; j++)
			{
				OptionData data = options[j];
				DropdownItem item = AddItem(data, value == j, componentInChildren, m_Items);
				if (!((Object)(object)item == (Object)null))
				{
					item.toggle.isOn = value == j;
					((UnityEvent<bool>)item.toggle.onValueChanged).AddListener((UnityAction<bool>)delegate
					{
						OnSelectItem(item.toggle);
					});
					if (item.toggle.isOn)
					{
						item.toggle.Select();
					}
					if ((Object)(object)toggle != (Object)null)
					{
						Navigation navigation = toggle.navigation;
						Navigation navigation2 = item.toggle.navigation;
						navigation.mode = Navigation.Mode.Explicit;
						navigation2.mode = Navigation.Mode.Explicit;
						navigation.selectOnDown = item.toggle;
						navigation.selectOnRight = item.toggle;
						navigation2.selectOnLeft = toggle;
						navigation2.selectOnUp = toggle;
						toggle.navigation = navigation;
						item.toggle.navigation = navigation2;
					}
					toggle = item.toggle;
				}
			}
			Vector2 sizeDelta = val3.sizeDelta;
			sizeDelta.y = size.y * (float)m_Items.Count + val4.y - val5.y;
			val3.sizeDelta = sizeDelta;
			Rect rect3 = val2.rect;
			float height = ((Rect)(ref rect3)).height;
			rect3 = val3.rect;
			float num = height - ((Rect)(ref rect3)).height;
			if (num > 0f)
			{
				val2.sizeDelta = new Vector2(val2.sizeDelta.x, val2.sizeDelta.y - num);
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			val2.GetWorldCorners(array);
			Transform transform3 = ((Component)val).transform;
			RectTransform val6 = (RectTransform)(object)((transform3 is RectTransform) ? transform3 : null);
			Rect rect4 = val6.rect;
			for (int num2 = 0; num2 < 2; num2++)
			{
				bool flag = false;
				for (int num3 = 0; num3 < 4; num3++)
				{
					Vector3 val7 = ((Transform)val6).InverseTransformPoint(array[num3]);
					float num4 = ((Vector3)(ref val7))[num2];
					Vector2 val8 = ((Rect)(ref rect4)).min;
					if (num4 < ((Vector2)(ref val8))[num2])
					{
						float num5 = ((Vector3)(ref val7))[num2];
						val8 = ((Rect)(ref rect4)).min;
						if (!Mathf.Approximately(num5, ((Vector2)(ref val8))[num2]))
						{
							goto IL_0496;
						}
					}
					float num6 = ((Vector3)(ref val7))[num2];
					val8 = ((Rect)(ref rect4)).max;
					if (!(num6 > ((Vector2)(ref val8))[num2]))
					{
						continue;
					}
					float num7 = ((Vector3)(ref val7))[num2];
					val8 = ((Rect)(ref rect4)).max;
					if (Mathf.Approximately(num7, ((Vector2)(ref val8))[num2]))
					{
						continue;
					}
					goto IL_0496;
					IL_0496:
					flag = true;
					break;
				}
				if (flag)
				{
					RectTransformUtility.FlipLayoutOnAxis(val2, num2, false, false);
				}
			}
			int count3 = m_Items.Count;
			for (int num8 = 0; num8 < count3; num8++)
			{
				RectTransform rectTransform = m_Items[num8].rectTransform;
				rectTransform.anchorMin = new Vector2(rectTransform.anchorMin.x, 0f);
				rectTransform.anchorMax = new Vector2(rectTransform.anchorMax.x, 0f);
				rectTransform.anchoredPosition = new Vector2(rectTransform.anchoredPosition.x, val4.y + size.y * (float)(count3 - 1 - num8) + size.y * rectTransform.pivot.y);
				rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, size.y);
			}
			AlphaFadeList(m_AlphaFadeSpeed, 0f, 1f);
			((Component)m_Template).gameObject.SetActive(false);
			((Component)componentInChildren).gameObject.SetActive(false);
			m_Blocker = CreateBlocker(val);
		}

		protected virtual GameObject CreateBlocker(Canvas rootCanvas)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//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)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			GameObject val = new GameObject("Blocker");
			RectTransform obj = val.AddComponent<RectTransform>();
			((Transform)obj).SetParent(((Component)rootCanvas).transform, false);
			obj.anchorMin = Vector2.op_Implicit(Vector3.zero);
			obj.anchorMax = Vector2.op_Implicit(Vector3.one);
			obj.sizeDelta = Vector2.zero;
			Canvas obj2 = val.AddComponent<Canvas>();
			obj2.overrideSorting = true;
			Canvas component = m_Dropdown.GetComponent<Canvas>();
			obj2.sortingLayerID = component.sortingLayerID;
			obj2.sortingOrder = component.sortingOrder - 1;
			Canvas val2 = null;
			Transform parent = ((Transform)m_Template).parent;
			while ((Object)(object)parent != (Object)null)
			{
				val2 = ((Component)parent).GetComponent<Canvas>();
				if ((Object)(object)val2 != (Object)null)
				{
					break;
				}
				parent = parent.parent;
			}
			if ((Object)(object)val2 != (Object)null)
			{
				Component[] components = (Component[])(object)((Component)val2).GetComponents<BaseRaycaster>();
				Component[] array = components;
				for (int i = 0; i < array.Length; i++)
				{
					Type type = ((object)array[i]).GetType();
					if ((Object)(object)val.GetComponent(type) == (Object)null)
					{
						val.AddComponent(type);
					}
				}
			}
			else
			{
				GetOrAddComponent<GraphicRaycaster>(val);
			}
			val.AddComponent<Image>().color = Color.clear;
			((UnityEvent)val.AddComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			return val;
		}

		protected virtual void DestroyBlocker(GameObject blocker)
		{
			Object.Destroy((Object)(object)blocker);
		}

		protected virtual GameObject CreateDropdownList(GameObject template)
		{
			return Object.Instantiate<GameObject>(template);
		}

		protected virtual void DestroyDropdownList(GameObject dropdownList)
		{
			Object.Destroy((Object)(object)dropdownList);
		}

		protected virtual DropdownItem CreateItem(DropdownItem itemTemplate)
		{
			return Object.Instantiate<DropdownItem>(itemTemplate);
		}

		protected virtual void DestroyItem(DropdownItem item)
		{
		}

		private DropdownItem AddItem(OptionData data, bool selected, DropdownItem itemTemplate, List<DropdownItem> items)
		{
			DropdownItem dropdownItem = CreateItem(itemTemplate);
			((Transform)dropdownItem.rectTransform).SetParent(((Transform)itemTemplate.rectTransform).parent, false);
			((Component)dropdownItem).gameObject.SetActive(true);
			((Object)((Component)dropdownItem).gameObject).name = "Item " + items.Count + ((data.text != null) ? (": " + data.text) : "");
			if ((Object)(object)dropdownItem.toggle != (Object)null)
			{
				dropdownItem.toggle.isOn = false;
			}
			if (Object.op_Implicit((Object)(object)dropdownItem.text))
			{
				dropdownItem.text.text = data.text;
			}
			if (Object.op_Implicit((Object)(object)dropdownItem.image))
			{
				dropdownItem.image.sprite = data.image;
				((Behaviour)dropdownItem.image).enabled = (Object)(object)dropdownItem.image.sprite != (Object)null;
			}
			items.Add(dropdownItem);
			return dropdownItem;
		}

		private void AlphaFadeList(float duration, float alpha)
		{
			CanvasGroup component = m_Dropdown.GetComponent<CanvasGroup>();
			AlphaFadeList(duration, component.alpha, alpha);
		}

		private void AlphaFadeList(float duration, float start, float end)
		{
			if (!end.Equals(start))
			{
				FloatTween info = new FloatTween
				{
					duration = duration,
					startValue = start,
					targetValue = end
				};
				info.AddOnChangedCallback(SetAlpha);
				info.ignoreTimeScale = true;
				m_AlphaTweenRunner.StartTween(info);
			}
		}

		private void SetAlpha(float alpha)
		{
			if (Object.op_Implicit((Object)(object)m_Dropdown))
			{
				m_Dropdown.GetComponent<CanvasGroup>().alpha = alpha;
			}
		}

		public void Hide()
		{
			if ((Object)(object)m_Dropdown != (Object)null)
			{
				AlphaFadeList(m_AlphaFadeSpeed, 0f);
				if (IsActive())
				{
					((MonoBehaviour)this).StartCoroutine(DelayedDestroyDropdownList(m_AlphaFadeSpeed));
				}
			}
			if ((Object)(object)m_Blocker != (Object)null)
			{
				DestroyBlocker(m_Blocker);
			}
			m_Blocker = null;
			Select();
		}

		private IEnumerator DelayedDestroyDropdownList(float delay)
		{
			yield return (object)new WaitForSecondsRealtime(delay);
			ImmediateDestroyDropdownList();
		}

		private void ImmediateDestroyDropdownList()
		{
			int count = m_Items.Count;
			for (int i = 0; i < count; i++)
			{
				if ((Object)(object)m_Items[i] != (Object)null)
				{
					DestroyItem(m_Items[i]);
				}
			}
			m_Items.Clear();
			if ((Object)(object)m_Dropdown != (Object)null)
			{
				DestroyDropdownList(m_Dropdown);
			}
			m_Dropdown = null;
		}

		private void OnSelectItem(Toggle toggle)
		{
			if (!toggle.isOn)
			{
				toggle.isOn = true;
			}
			int num = -1;
			Transform transform = ((Component)toggle).transform;
			Transform parent = transform.parent;
			for (int i = 0; i < parent.childCount; i++)
			{
				if ((Object)(object)parent.GetChild(i) == (Object)(object)transform)
				{
					num = i - 1;
					break;
				}
			}
			if (num >= 0)
			{
				value = num;
				Hide();
			}
		}
	}
	[Serializable]
	public class FontData : ISerializationCallbackReceiver
	{
		[SerializeField]
		[FormerlySerializedAs("font")]
		private Font m_Font;

		[SerializeField]
		[FormerlySerializedAs("fontSize")]
		private int m_FontSize;

		[SerializeField]
		[FormerlySerializedAs("fontStyle")]
		private FontStyle m_FontStyle;

		[SerializeField]
		private bool m_BestFit;

		[SerializeField]
		private int m_MinSize;

		[SerializeField]
		private int m_MaxSize;

		[SerializeField]
		[FormerlySerializedAs("alignment")]
		private TextAnchor m_Alignment;

		[SerializeField]
		private bool m_AlignByGeometry;

		[SerializeField]
		[FormerlySerializedAs("richText")]
		private bool m_RichText;

		[SerializeField]
		private HorizontalWrapMode m_HorizontalOverflow;

		[SerializeField]
		private VerticalWrapMode m_VerticalOverflow;

		[SerializeField]
		private float m_LineSpacing;

		public static FontData defaultFontData => new FontData
		{
			m_FontSize = 14,
			m_LineSpacing = 1f,
			m_FontStyle = (FontStyle)0,
			m_BestFit = false,
			m_MinSize = 10,
			m_MaxSize = 40,
			m_Alignment = (TextAnchor)0,
			m_HorizontalOverflow = (HorizontalWrapMode)0,
			m_VerticalOverflow = (VerticalWrapMode)0,
			m_RichText = true,
			m_AlignByGeometry = false
		};

		public Font font
		{
			get
			{
				return m_Font;
			}
			set
			{
				m_Font = value;
			}
		}

		public int fontSize
		{
			get
			{
				return m_FontSize;
			}
			set
			{
				m_FontSize = value;
			}
		}

		public FontStyle fontStyle
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_FontStyle;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_FontStyle = value;
			}
		}

		public bool bestFit
		{
			get
			{
				return m_BestFit;
			}
			set
			{
				m_BestFit = value;
			}
		}

		public int minSize
		{
			get
			{
				return m_MinSize;
			}
			set
			{
				m_MinSize = value;
			}
		}

		public int maxSize
		{
			get
			{
				return m_MaxSize;
			}
			set
			{
				m_MaxSize = value;
			}
		}

		public TextAnchor alignment
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_Alignment;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_Alignment = value;
			}
		}

		public bool alignByGeometry
		{
			get
			{
				return m_AlignByGeometry;
			}
			set
			{
				m_AlignByGeometry = value;
			}
		}

		public bool richText
		{
			get
			{
				return m_RichText;
			}
			set
			{
				m_RichText = value;
			}
		}

		public HorizontalWrapMode horizontalOverflow
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_HorizontalOverflow;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_HorizontalOverflow = value;
			}
		}

		public VerticalWrapMode verticalOverflow
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_VerticalOverflow;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_VerticalOverflow = value;
			}
		}

		public float lineSpacing
		{
			get
			{
				return m_LineSpacing;
			}
			set
			{
				m_LineSpacing = value;
			}
		}

		void ISerializationCallbackReceiver.OnBeforeSerialize()
		{
		}

		void ISerializationCallbackReceiver.OnAfterDeserialize()
		{
			m_FontSize = Mathf.Clamp(m_FontSize, 0, 300);
			m_MinSize = Mathf.Clamp(m_MinSize, 0, m_FontSize);
			m_MaxSize = Mathf.Clamp(m_MaxSize, m_FontSize, 300);
		}
	}
	public static class FontUpdateTracker
	{
		private static Dictionary<Font, HashSet<Text>> m_Tracked = new Dictionary<Font, HashSet<Text>>();

		public static void TrackText(Text t)
		{
			if ((Object)(object)t.font == (Object)null)
			{
				return;
			}
			m_Tracked.TryGetValue(t.font, out var value);
			if (value == null)
			{
				if (m_Tracked.Count == 0)
				{
					Font.textureRebuilt += RebuildForFont;
				}
				value = new HashSet<Text>();
				m_Tracked.Add(t.font, value);
			}
			value.Add(t);
		}

		private static void RebuildForFont(Font f)
		{
			m_Tracked.TryGetValue(f, out var value);
			if (value == null)
			{
				return;
			}
			foreach (Text item in value)
			{
				item.FontTextureChanged();
			}
		}

		public static void UntrackText(Text t)
		{
			if ((Object)(object)t.font == (Object)null)
			{
				return;
			}
			m_Tracked.TryGetValue(t.font, out var value);
			if (value == null)
			{
				return;
			}
			value.Remove(t);
			if (value.Count == 0)
			{
				m_Tracked.Remove(t.font);
				if (m_Tracked.Count == 0)
				{
					Font.textureRebuilt -= RebuildForFont;
				}
			}
		}
	}
	[DisallowMultipleComponent]
	[RequireComponent(typeof(RectTransform))]
	[ExecuteAlways]
	public abstract class Graphic : UIBehaviour, ICanvasElement
	{
		protected static Material s_DefaultUI = null;

		protected static Texture2D s_WhiteTexture = null;

		[FormerlySerializedAs("m_Mat")]
		[SerializeField]
		protected Material m_Material;

		[SerializeField]
		private Color m_Color = Color.white;

		[NonSerialized]
		protected bool m_SkipLayoutUpdate;

		[NonSerialized]
		protected bool m_SkipMaterialUpdate;

		[SerializeField]
		private bool m_RaycastTarget = true;

		private bool m_RaycastTargetCache = true;

		[SerializeField]
		private Vector4 m_RaycastPadding;

		[NonSerialized]
		private RectTransform m_RectTransform;

		[NonSerialized]
		private CanvasRenderer m_CanvasRenderer;

		[NonSerialized]
		private Canvas m_Canvas;

		[NonSerialized]
		private bool m_VertsDirty;

		[NonSerialized]
		private bool m_MaterialDirty;

		[NonSerialized]
		protected UnityAction m_OnDirtyLayoutCallback;

		[NonSerialized]
		protected UnityAction m_OnDirtyVertsCallback;

		[NonSerialized]
		protected UnityAction m_OnDirtyMaterialCallback;

		[NonSerialized]
		protected static Mesh s_Mesh;

		[NonSerialized]
		private static readonly VertexHelper s_VertexHelper = new VertexHelper();

		[NonSerialized]
		protected Mesh m_CachedMesh;

		[NonSerialized]
		protected Vector2[] m_CachedUvs;

		[NonSerialized]
		private readonly TweenRunner<ColorTween> m_ColorTweenRunner;

		public static Material defaultGraphicMaterial
		{
			get
			{
				if ((Object)(object)s_DefaultUI == (Object)null)
				{
					s_DefaultUI = Canvas.GetDefaultCanvasMaterial();
				}
				return s_DefaultUI;
			}
		}

		public virtual Color color
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_Color;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				if (SetPropertyUtility.SetColor(ref m_Color, value))
				{
					SetVerticesDirty();
				}
			}
		}

		public virtual bool raycastTarget
		{
			get
			{
				return m_RaycastTarget;
			}
			set
			{
				if (value != m_RaycastTarget)
				{
					if (m_RaycastTarget)
					{
						GraphicRegistry.UnregisterRaycastGraphicForCanvas(canvas, this);
					}
					m_RaycastTarget = value;
					if (m_RaycastTarget && ((Behaviour)this).isActiveAndEnabled)
					{
						GraphicRegistry.RegisterRaycastGraphicForCanvas(canvas, this);
					}
				}
				m_RaycastTargetCache = value;
			}
		}

		public Vector4 raycastPadding
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_RaycastPadding;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_RaycastPadding = value;
			}
		}

		protected bool useLegacyMeshGeneration { get; set; }

		public int depth => canvasRenderer.absoluteDepth;

		public RectTransform rectTransform
		{
			get
			{
				if (m_RectTransform == null)
				{
					m_RectTransform = ((Component)this).GetComponent<RectTransform>();
				}
				return m_RectTransform;
			}
		}

		public Canvas canvas
		{
			get
			{
				if ((Object)(object)m_Canvas == (Object)null)
				{
					CacheCanvas();
				}
				return m_Canvas;
			}
		}

		public CanvasRenderer canvasRenderer
		{
			get
			{
				if (m_CanvasRenderer == null)
				{
					m_CanvasRenderer = ((Component)this).GetComponent<CanvasRenderer>();
					if (m_CanvasRenderer == null)
					{
						m_CanvasRenderer = ((Component)this).gameObject.AddComponent<CanvasRenderer>();
					}
				}
				return m_CanvasRenderer;
			}
		}

		public virtual Material defaultMaterial => defaultGraphicMaterial;

		public virtual Material material
		{
			get
			{
				if (!((Object)(object)m_Material != (Object)null))
				{
					return defaultMaterial;
				}
				return m_Material;
			}
			set
			{
				if (!((Object)(object)m_Material == (Object)(object)value))
				{
					m_Material = value;
					SetMaterialDirty();
				}
			}
		}

		public virtual Material materialForRendering
		{
			get
			{
				List<Component> list = CollectionPool<List<Component>, Component>.Get();
				((Component)this).GetComponents(typeof(IMaterialModifier), list);
				Material modifiedMaterial = material;
				for (int i = 0; i < list.Count; i++)
				{
					modifiedMaterial = (list[i] as IMaterialModifier).GetModifiedMaterial(modifiedMaterial);
				}
				CollectionPool<List<Component>, Component>.Release(list);
				return modifiedMaterial;
			}
		}

		public virtual Texture mainTexture => (Texture)(object)s_WhiteTexture;

		protected static Mesh workerMesh
		{
			get
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				if ((Object)(object)s_Mesh == (Object)null)
				{
					s_Mesh = new Mesh();
					((Object)s_Mesh).name = "Shared UI Mesh";
					((Object)s_Mesh).hideFlags = (HideFlags)61;
				}
				return s_Mesh;
			}
		}

		protected Graphic()
		{
			//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)
			if (m_ColorTweenRunner == null)
			{
				m_ColorTweenRunner = new TweenRunner<ColorTween>();
			}
			m_ColorTweenRunner.Init((MonoBehaviour)(object)this);
			useLegacyMeshGeneration = true;
		}

		public virtual void SetAllDirty()
		{
			if (m_SkipLayoutUpdate)
			{
				m_SkipLayoutUpdate = false;
			}
			else
			{
				SetLayoutDirty();
			}
			if (m_SkipMaterialUpdate)
			{
				m_SkipMaterialUpdate = false;
			}
			else
			{
				SetMaterialDirty();
			}
			SetVerticesDirty();
			SetRaycastDirty();
		}

		public virtual void SetLayoutDirty()
		{
			if (IsActive())
			{
				LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
				if (m_OnDirtyLayoutCallback != null)
				{
					m_OnDirtyLayoutCallback.Invoke();
				}
			}
		}

		public virtual void SetVerticesDirty()
		{
			if (IsActive())
			{
				m_VertsDirty = true;
				CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild(this);
				if (m_OnDirtyVertsCallback != null)
				{
					m_OnDirtyVertsCallback.Invoke();
				}
			}
		}

		public virtual void SetMaterialDirty()
		{
			if (IsActive())
			{
				m_MaterialDirty = true;
				CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild(this);
				if (m_OnDirtyMaterialCallback != null)
				{
					m_OnDirtyMaterialCallback.Invoke();
				}
			}
		}

		public void SetRaycastDirty()
		{
			if (m_RaycastTargetCache != m_RaycastTarget)
			{
				if (m_RaycastTarget && ((Behaviour)this).isActiveAndEnabled)
				{
					GraphicRegistry.RegisterRaycastGraphicForCanvas(canvas, this);
				}
				else if (!m_RaycastTarget)
				{
					GraphicRegistry.UnregisterRaycastGraphicForCanvas(canvas, this);
				}
			}
			m_RaycastTargetCache = m_RaycastTarget;
		}

		protected override void OnRectTransformDimensionsChange()
		{
			if (((Component)this).gameObject.activeInHierarchy)
			{
				if (CanvasUpdateRegistry.IsRebuildingLayout())
				{
					SetVerticesDirty();
					return;
				}
				SetVerticesDirty();
				SetLayoutDirty();
			}
		}

		protected override void OnBeforeTransformParentChanged()
		{
			GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
			LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
		}

		protected override void OnTransformParentChanged()
		{
			base.OnTransformParentChanged();
			m_Canvas = null;
			if (IsActive())
			{
				CacheCanvas();
				GraphicRegistry.RegisterGraphicForCanvas(canvas, this);
				SetAllDirty();
			}
		}

		private void CacheCanvas()
		{
			List<Canvas> list = CollectionPool<List<Canvas>, Canvas>.Get();
			((Component)this).gameObject.GetComponentsInParent<Canvas>(false, list);
			if (list.Count > 0)
			{
				for (int i = 0; i < list.Count; i++)
				{
					if (((Behaviour)list[i]).isActiveAndEnabled)
					{
						m_Canvas = list[i];
						break;
					}
					if (i == list.Count - 1)
					{
						m_Canvas = null;
					}
				}
			}
			else
			{
				m_Canvas = null;
			}
			CollectionPool<List<Canvas>, Canvas>.Release(list);
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			CacheCanvas();
			GraphicRegistry.RegisterGraphicForCanvas(canvas, this);
			if ((Object)(object)s_WhiteTexture == (Object)null)
			{
				s_WhiteTexture = Texture2D.whiteTexture;
			}
			SetAllDirty();
		}

		protected override void OnDisable()
		{
			GraphicRegistry.DisableGraphicForCanvas(canvas, this);
			CanvasUpdateRegistry.DisableCanvasElementForRebuild(this);
			if ((Object)(object)canvasRenderer != (Object)null)
			{
				canvasRenderer.Clear();
			}
			LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
			base.OnDisable();
		}

		protected override void OnDestroy()
		{
			GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
			CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild(this);
			if (Object.op_Implicit((Object)(object)m_CachedMesh))
			{
				Object.Destroy((Object)(object)m_CachedMesh);
			}
			m_CachedMesh = null;
			base.OnDestroy();
		}

		protected override void OnCanvasHierarchyChanged()
		{
			Canvas val = m_Canvas;
			m_Canvas = null;
			if (!IsActive())
			{
				GraphicRegistry.UnregisterGraphicForCanvas(val, this);
				return;
			}
			CacheCanvas();
			if ((Object)(object)val != (Object)(object)m_Canvas)
			{
				GraphicRegistry.UnregisterGraphicForCanvas(val, this);
				if (IsActive())
				{
					GraphicRegistry.RegisterGraphicForCanvas(canvas, this);
				}
			}
		}

		public virtual void OnCullingChanged()
		{
			if (!canvasRenderer.cull && (m_VertsDirty || m_MaterialDirty))
			{
				CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild(this);
			}
		}

		public virtual void Rebuild(CanvasUpdate update)
		{
			if (!((Object)(object)canvasRenderer == (Object)null) && !canvasRenderer.cull && update == CanvasUpdate.PreRender)
			{
				if (m_VertsDirty)
				{
					UpdateGeometry();
					m_VertsDirty = false;
				}
				if (m_MaterialDirty)
				{
					UpdateMaterial();
					m_MaterialDirty = false;
				}
			}
		}

		public virtual void LayoutComplete()
		{
		}

		public virtual void GraphicUpdateComplete()
		{
		}

		protected virtual void UpdateMaterial()
		{
			if (IsActive())
			{
				canvasRenderer.materialCount = 1;
				canvasRenderer.SetMaterial(materialForRendering, 0);
				canvasRenderer.SetTexture(mainTexture);
			}
		}

		protected virtual void UpdateGeometry()
		{
			if (useLegacyMeshGeneration)
			{
				DoLegacyMeshGeneration();
			}
			else
			{
				DoMeshGeneration();
			}
		}

		private void DoMeshGeneration()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rectTransform != (Object)null)
			{
				Rect rect = rectTransform.rect;
				if (((Rect)(ref rect)).width >= 0f)
				{
					rect = rectTransform.rect;
					if (((Rect)(ref rect)).height >= 0f)
					{
						OnPopulateMesh(s_VertexHelper);
						goto IL_0059;
					}
				}
			}
			s_VertexHelper.Clear();
			goto IL_0059;
			IL_0059:
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			((Component)this).GetComponents(typeof(IMeshModifier), list);
			for (int i = 0; i < list.Count; i++)
			{
				((IMeshModifier)list[i]).ModifyMesh(s_VertexHelper);
			}
			CollectionPool<List<Component>, Component>.Release(list);
			s_VertexHelper.FillMesh(workerMesh);
			canvasRenderer.SetMesh(workerMesh);
		}

		private void DoLegacyMeshGeneration()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rectTransform != (Object)null)
			{
				Rect rect = rectTransform.rect;
				if (((Rect)(ref rect)).width >= 0f)
				{
					rect = rectTransform.rect;
					if (((Rect)(ref rect)).height >= 0f)
					{
						OnPopulateMesh(workerMesh);
						goto IL_0059;
					}
				}
			}
			workerMesh.Clear();
			goto IL_0059;
			IL_0059:
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			((Component)this).GetComponents(typeof(IMeshModifier), list);
			for (int i = 0; i < list.Count; i++)
			{
				((IMeshModifier)list[i]).ModifyMesh(workerMesh);
			}
			CollectionPool<List<Component>, Component>.Release(list);
			canvasRenderer.SetMesh(workerMesh);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Use OnPopulateMesh instead.", true)]
		protected virtual void OnFillVBO(List<UIVertex> vbo)
		{
		}

		[Obsolete("Use OnPopulateMesh(VertexHelper vh) instead.", false)]
		protected virtual void OnPopulateMesh(Mesh m)
		{
			OnPopulateMesh(s_VertexHelper);
			s_VertexHelper.FillMesh(m);
		}

		protected virtual void OnPopulateMesh(VertexHelper vh)
		{
			//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_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_0045: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_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_0095: 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_00a5: 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_00b1: 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_00c1: 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_00d7: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			Rect pixelAdjustedRect = GetPixelAdjustedRect();
			Vector4 val = default(Vector4);
			((Vector4)(ref val))..ctor(((Rect)(ref pixelAdjustedRect)).x, ((Rect)(ref pixelAdjustedRect)).y, ((Rect)(ref pixelAdjustedRect)).x + ((Rect)(ref pixelAdjustedRect)).width, ((Rect)(ref pixelAdjustedRect)).y + ((Rect)(ref pixelAdjustedRect)).height);
			Color32 val2 = Color32.op_Implicit(color);
			vh.Clear();
			vh.AddVert(new Vector3(val.x, val.y), val2, Vector4.op_Implicit(new Vector2(0f, 0f)));
			vh.AddVert(new Vector3(val.x, val.w), val2, Vector4.op_Implicit(new Vector2(0f, 1f)));
			vh.AddVert(new Vector3(val.z, val.w), val2, Vector4.op_Implicit(new Vector2(1f, 1f)));
			vh.AddVert(new Vector3(val.z, val.y), val2, Vector4.op_Implicit(new Vector2(1f, 0f)));
			vh.AddTriangle(0, 1, 2);
			vh.AddTriangle(2, 3, 0);
		}

		protected override void OnDidApplyAnimationProperties()
		{
			SetAllDirty();
		}

		public virtual void SetNativeSize()
		{
		}

		public virtual bool Raycast(Vector2 sp, Camera eventCamera)
		{
			//IL_00b8: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Behaviour)this).isActiveAndEnabled)
			{
				return false;
			}
			Transform val = ((Component)this).transform;
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			bool flag = false;
			bool flag2 = true;
			while ((Object)(object)val != (Object)null)
			{
				((Component)val).GetComponents<Component>(list);
				for (int i = 0; i < list.Count; i++)
				{
					Component obj = list[i];
					Canvas val2 = (Canvas)(object)((obj is Canvas) ? obj : null);
					if ((Object)(object)val2 != (Object)null && val2.overrideSorting)
					{
						flag2 = false;
					}
					Component obj2 = list[i];
					ICanvasRaycastFilter val3 = (ICanvasRaycastFilter)(object)((obj2 is ICanvasRaycastFilter) ? obj2 : null);
					if (val3 == null)
					{
						continue;
					}
					bool flag3 = true;
					Component obj3 = list[i];
					CanvasGroup val4 = (CanvasGroup)(object)((obj3 is CanvasGroup) ? obj3 : null);
					if ((Object)(object)val4 != (Object)null)
					{
						if (!((Behaviour)val4).enabled)
						{
							continue;
						}
						if (!flag && val4.ignoreParentGroups)
						{
							flag = true;
							flag3 = val3.IsRaycastLocationValid(sp, eventCamera);
						}
						else if (!flag)
						{
							flag3 = val3.IsRaycastLocationValid(sp, eventCamera);
						}
					}
					else
					{
						flag3 = val3.IsRaycastLocationValid(sp, eventCamera);
					}
					if (!flag3)
					{
						CollectionPool<List<Component>, Component>.Release(list);
						return false;
					}
				}
				val = (flag2 ? val.parent : null);
			}
			CollectionPool<List<Component>, Component>.Release(list);
			return true;
		}

		public Vector2 PixelAdjustPoint(Vector2 point)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_003c: 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)
			if (!Object.op_Implicit((Object)(object)canvas) || (int)canvas.renderMode == 2 || canvas.scaleFactor == 0f || !canvas.pixelPerfect)
			{
				return point;
			}
			return RectTransformUtility.PixelAdjustPoint(point, ((Component)this).transform, canvas);
		}

		public Rect GetPixelAdjustedRect()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)canvas) || (int)canvas.renderMode == 2 || canvas.scaleFactor == 0f || !canvas.pixelPerfect)
			{
				return rectTransform.rect;
			}
			return RectTransformUtility.PixelAdjustRect(rectTransform, canvas);
		}

		public virtual void CrossFadeColor(Color targetColor, float duration, bool ignoreTimeScale, bool useAlpha)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			CrossFadeColor(targetColor, duration, ignoreTimeScale, useAlpha, useRGB: true);
		}

		public virtual void CrossFadeColor(Color targetColor, float duration, bool ignoreTimeScale, bool useAlpha, bool useRGB)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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)
			if (!((Object)(object)canvasRenderer == (Object)null) && (useRGB || useAlpha))
			{
				Color val = canvasRenderer.GetColor();
				if (((Color)(ref val)).Equals(targetColor))
				{
					m_ColorTweenRunner.StopTween();
					return;
				}
				ColorTween.ColorTweenMode tweenMode = ((!(useRGB && useAlpha)) ? (useRGB ? ColorTween.ColorTweenMode.RGB : ColorTween.ColorTweenMode.Alpha) : ColorTween.ColorTweenMode.All);
				ColorTween info = new ColorTween
				{
					duration = duration,
					startColor = canvasRenderer.GetColor(),
					targetColor = targetColor
				};
				info.AddOnChangedCallback(canvasRenderer.SetColor);
				info.ignoreTimeScale = ignoreTimeScale;
				info.tweenMode = tweenMode;
				m_ColorTweenRunner.StartTween(info);
			}
		}

		private static Color CreateColorFromAlpha(float alpha)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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)
			Color black = Color.black;
			black.a = alpha;
			return black;
		}

		public virtual void CrossFadeAlpha(float alpha, float duration, bool ignoreTimeScale)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			CrossFadeColor(CreateColorFromAlpha(alpha), duration, ignoreTimeScale, useAlpha: true, useRGB: false);
		}

		public void RegisterDirtyLayoutCallback(UnityAction action)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			m_OnDirtyLayoutCallback = (UnityAction)Delegate.Combine((Delegate?)(object)m_OnDirtyLayoutCallback, (Delegate?)(object)action);
		}

		public void UnregisterDirtyLayoutCallback(UnityAction action)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			m_OnDirtyLayoutCallback = (UnityAction)Delegate.Remove((Delegate?)(object)m_OnDirtyLayoutCallback, (Delegate?)(object)action);
		}

		public void RegisterDirtyVerticesCallback(UnityAction action)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			m_OnDirtyVertsCallback = (UnityAction)Delegate.Combine((Delegate?)(object)m_OnDirtyVertsCallback, (Delegate?)(object)action);
		}

		public void UnregisterDirtyVerticesCallback(UnityAction action)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			m_OnDirtyVertsCallback = (UnityAction)Delegate.Remove((Delegate?)(object)m_OnDirtyVertsCallback, (Delegate?)(object)action);
		}

		public void RegisterDirtyMaterialCallback(UnityAction action)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			m_OnDirtyMaterialCallback = (UnityAction)Delegate.Combine((Delegate?)(object)m_OnDirtyMaterialCallback, (Delegate?)(object)action);
		}

		public void UnregisterDirtyMaterialCallback(UnityAction action)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			m_OnDirtyMaterialCallback = (UnityAction)Delegate.Remove((Delegate?)(object)m_OnDirtyMaterialCallback, (Delegate?)(object)action);
		}

		[SpecialName]
		Transform ICanvasElement.get_transform()
		{
			return ((Component)this).transform;
		}
	}
	[AddComponentMenu("Event/Graphic Raycaster")]
	[RequireComponent(typeof(Canvas))]
	public class GraphicRaycaster : BaseRaycaster
	{
		public enum BlockingObjects
		{
			None,
			TwoD,
			ThreeD,
			All
		}

		protected const int kNoEventMaskSet = -1;

		[FormerlySerializedAs("ignoreReversedGraphics")]
		[SerializeField]
		private bool m_IgnoreReversedGraphics = true;

		[FormerlySerializedAs("blockingObjects")]
		[SerializeField]
		private BlockingObjects m_BlockingObjects;

		[SerializeField]
		protected LayerMask m_BlockingMask = LayerMask.op_Implicit(-1);

		private Canvas m_Canvas;

		[NonSerialized]
		private List<Graphic> m_RaycastResults = new List<Graphic>();

		[NonSerialized]
		private static readonly List<Graphic> s_SortedGraphics = new List<Graphic>();

		public override int sortOrderPriority
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				if ((int)canvas.renderMode == 0)
				{
					return canvas.sortingOrder;
				}
				return base.sortOrderPriority;
			}
		}

		public override int renderOrderPriority
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				if ((int)canvas.renderMode == 0)
				{
					return canvas.rootCanvas.renderOrder;
				}
				return base.renderOrderPriority;
			}
		}

		public bool ignoreReversedGraphics
		{
			get
			{
				return m_IgnoreReversedGraphics;
			}
			set
			{
				m_IgnoreReversedGraphics = value;
			}
		}

		public BlockingObjects blockingObjects
		{
			get
			{
				return m_BlockingObjects;
			}
			set
			{
				m_BlockingObjects = value;
			}
		}

		public LayerMask blockingMask
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_BlockingMask;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_BlockingMask = value;
			}
		}

		private Canvas canvas
		{
			get
			{
				if ((Object)(object)m_Canvas != (Object)null)
				{
					return m_Canvas;
				}
				m_Canvas = ((Component)this).GetComponent<Canvas>();
				return m_Canvas;
			}
		}

		public override Camera eventCamera
		{
			get
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: 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_0013: Invalid comparison between Unknown and I4
				Canvas val = canvas;
				RenderMode renderMode = val.renderMode;
				if ((int)renderMode == 0 || ((int)renderMode == 1 && (Object)(object)val.worldCamera == (Object)null))
				{
					return null;
				}
				return val.worldCamera ?? Camera.main;
			}
		}

		protected GraphicRaycaster()
		{
		}//IL_0009: 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)


		public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)canvas == (Object)null)
			{
				return;
			}
			IList<Graphic> raycastableGraphicsForCanvas = GraphicRegistry.GetRaycastableGraphicsForCanvas(canvas);
			if (raycastableGraphicsForCanvas == null || raycastableGraphicsForCanvas.Count == 0)
			{
				return;
			}
			Camera val = eventCamera;
			int num = (((int)canvas.renderMode != 0 && !((Object)(object)val == (Object)null)) ? val.targetDisplay : canvas.targetDisplay);
			Vector3 val2 = MultipleDisplayUtilities.RelativeMouseAtScaled(eventData.position);
			if (val2 != Vector3.zero)
			{
				if ((int)val2.z != num)
				{
					return;
				}
			}
			else
			{
				val2 = Vector2.op_Implicit(eventData.position);
			}
			Vector2 val3 = default(Vector2);
			if ((Object)(object)val == (Object)null)
			{
				float num2 = Screen.width;
				float num3 = Screen.height;
				if (num > 0 && num < Display.displays.Length)
				{
					num2 = Display.displays[num].systemWidth;
					num3 = Display.displays[num].systemHeight;
				}
				((Vector2)(ref val3))..ctor(val2.x / num2, val2.y / num3);
			}
			else
			{
				val3 = Vector2.op_Implicit(val.ScreenToViewportPoint(val2));
			}
			if (val3.x < 0f || val3.x > 1f || val3.y < 0f || val3.y > 1f)
			{
				return;
			}
			float num4 = float.MaxValue;
			Ray r = default(Ray);
			if ((Object)(object)val != (Object)null)
			{
				r = val.ScreenPointToRay(val2);
			}
			if ((int)canvas.renderMode != 0 && blockingObjects != BlockingObjects.None)
			{
				float f = 100f;
				if ((Object)(object)val != (Object)null)
				{
					float z = ((Ray)(ref r)).direction.z;
					f = (Mathf.Approximately(0f, z) ? float.PositiveInfinity : Mathf.Abs((val.farClipPlane - val.nearClipPlane) / z));
				}
				if ((blockingObjects == BlockingObjects.ThreeD || blockingObjects == BlockingObjects.All) && ReflectionMethodsCache.Singleton.raycast3D != null)
				{
					RaycastHit[] array = ReflectionMethodsCache.Singleton.raycast3DAll(r, f, LayerMask.op_Implicit(m_BlockingMask));
					if (array.Length != 0)
					{
						num4 = ((RaycastHit)(ref array[0])).distance;
					}
				}
				if ((blockingObjects == BlockingObjects.TwoD || blockingObjects == BlockingObjects.All) && ReflectionMethodsCache.Singleton.raycast2D != null)
				{
					RaycastHit2D[] array2 = ReflectionMethodsCache.Singleton.getRayIntersectionAll(r, f, LayerMask.op_Implicit(m_BlockingMask));
					if (array2.Length != 0)
					{
						num4 = ((RaycastHit2D)(ref array2[0])).distance;
					}
				}
			}
			m_RaycastResults.Clear();
			Raycast(canvas, val, Vector2.op_Implicit(val2), raycastableGraphicsForCanvas, m_RaycastResults);
			int count = m_RaycastResults.Count;
			for (int i = 0; i < count; i++)
			{
				GameObject gameObject = ((Component)m_RaycastResults[i]).gameObject;
				bool flag = true;
				if (ignoreReversedGraphics)
				{
					if ((Object)(object)val == (Object)null)
					{
						Vector3 val4 = gameObject.transform.rotation * Vector3.forward;
						flag = Vector3.Dot(Vector3.forward, val4) > 0f;
					}
					else
					{
						Vector3 val5 = ((Component)val).transform.rotation * Vector3.forward * val.nearClipPlane;
						flag = Vector3.Dot(gameObject.transform.position - ((Component)val).transform.position - val5, gameObject.transform.forward) >= 0f;
					}
				}
				if (!flag)
				{
					continue;
				}
				float num5 = 0f;
				Transform transform = gameObject.transform;
				Vector3 forward = transform.forward;
				if ((Object)(object)val == (Object)null || (int)canvas.renderMode == 0)
				{
					num5 = 0f;
				}
				else
				{
					num5 = Vector3.Dot(forward, transform.position - ((Ray)(ref r)).origin) / Vector3.Dot(forward, ((Ray)(ref r)).direction);
					if (num5 < 0f)
					{
						continue;
					}
				}
				if (!(num5 >= num4))
				{
					RaycastResult item = new RaycastResult
					{
						gameObject = gameObject,
						module = this,
						distance = num5,
						screenPosition = Vector2.op_Implicit(val2),
						displayIndex = num,
						index = resultAppendList.Count,
						depth = m_RaycastResults[i].depth,
						sortingLayer = canvas.sortingLayerID,
						sortingOrder = canvas.sortingOrder,
						worldPosition = ((Ray)(ref r)).origin + ((Ray)(ref r)).direction * num5,
						worldNormal = -forward
					};
					resultAppendList.Add(item);
				}
			}
		}

		private static void Raycast(Canvas canvas, Camera eventCamera, Vector2 pointerPosition, IList<Graphic> foundGraphics, List<Graphic> results)
		{
			//IL_0037: 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_006e: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			int count = foundGraphics.Count;
			for (int i = 0; i < count; i++)
			{
				Graphic graphic = foundGraphics[i];
				if (graphic.raycastTarget && !graphic.canvasRenderer.cull && graphic.depth != -1 && RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, pointerPosition, eventCamera, graphic.raycastPadding) && (!((Object)(object)eventCamera != (Object)null) || !(eventCamera.WorldToScreenPoint(((Transform)graphic.rectTransform).position).z > eventCamera.farClipPlane)) && graphic.Raycast(pointerPosition, eventCamera))
				{
					s_SortedGraphics.Add(graphic);
				}
			}
			s_SortedGraphics.Sort((Graphic g1, Graphic g2) => g2.depth.CompareTo(g1.depth));
			count = s_SortedGraphics.Count;
			for (int num = 0; num < count; num++)
			{
				results.Add(s_SortedGraphics[num]);
			}
			s_SortedGraphics.Clear();
		}
	}
	public class GraphicRegistry
	{
		private static GraphicRegistry s_Instance;

		private readonly Dictionary<Canvas, IndexedSet<Graphic>> m_Graphics = new Dictionary<Canvas, IndexedSet<Graphic>>();

		private readonly Dictionary<Canvas, IndexedSet<Graphic>> m_RaycastableGraphics = new Dictionary<Canvas, IndexedSet<Graphic>>();

		private static readonly List<Graphic> s_EmptyList = new List<Graphic>();

		public static GraphicRegistry instance
		{
			get
			{
				if (s_Instance == null)
				{
					s_Instance = new GraphicRegistry();
				}
				return s_Instance;
			}
		}

		protected GraphicRegistry()
		{
			GC.KeepAlive(new Dictionary<Graphic, int>());
			GC.KeepAlive(new Dictionary<ICanvasElement, int>());
			GC.KeepAlive(new Dictionary<IClipper, int>());
		}

		public static void RegisterGraphicForCanvas(Canvas c, Graphic graphic)
		{
			if (!((Object)(object)c == (Object)null) && !((Object)(object)graphic == (Object)null))
			{
				instance.m_Graphics.TryGetValue(c, out var value);
				if (value != null)
				{
					value.AddUnique(graphic);
					RegisterRaycastGraphicForCanvas(c, graphic);
					return;
				}
				value = new IndexedSet<Graphic>();
				value.Add(graphic);
				instance.m_Graphics.Add(c, value);
				RegisterRaycastGraphicForCanvas(c, graphic);
			}
		}

		public static void RegisterRaycastGraphicForCanvas(Canvas c, Graphic graphic)
		{
			if (!((Object)(object)c == (Object)null) && !((Object)(object)graphic == (Object)null) && graphic.raycastTarget)
			{
				instance.m_RaycastableGraphics.TryGetValue(c, out var value);
				if (value != null)
				{
					value.AddUnique(graphic);
					return;
				}
				value = new IndexedSet<Graphic>();
				value.Add(graphic);
				instance.m_RaycastableGraphics.Add(c, value);
			}
		}

		public static void UnregisterGraphicForCanvas(Canvas c, Graphic graphic)
		{
			if (!((Object)(object)c == (Object)null) && !((Object)(object)graphic == (Object)null) && instance.m_Graphics.TryGetValue(c, out var value))
			{
				value.Remove(graphic);
				if (value.Capacity == 0)
				{
					instance.m_Graphics.Remove(c);
				}
				UnregisterRaycastGraphicForCanvas(c, graphic);
			}
		}

		public static void UnregisterRaycastGraphicForCanvas(Canvas c, Graphic graphic)
		{
			if (!((Object)(object)c == (Object)null) && !((Object)(object)graphic == (Object)null) && instance.m_RaycastableGraphics.TryGetValue(c, out var value))
			{
				value.Remove(graphic);
				if (value.Count == 0)
				{
					instance.m_RaycastableGraphics.Remove(c);
				}
			}
		}

		public static void DisableGraphicForCanvas(Canvas c, Graphic graphic)
		{
			if (!((Object)(object)c == (Object)null) && instance.m_Graphics.TryGetValue(c, out var value))
			{
				value.DisableItem(graphic);
				if (value.Capacity == 0)
				{
					instance.m_Graphics.Remove(c);
				}
				DisableRaycastGraphicForCanvas(c, graphic);
			}
		}

		public static void DisableRaycastGraphicForCanvas(Canvas c, Graphic graphic)
		{
			if (!((Object)(object)c == (Object)null) && graphic.raycastTarget && instance.m_RaycastableGraphics.TryGetValue(c, out var value))
			{
				value.DisableItem(graphic);
				if (value.Capacity == 0)
				{
					instance.m_RaycastableGraphics.Remove(c);
				}
			}
		}

		public static IList<Graphic> GetGraphicsForCanvas(Canvas canvas)
		{
			if (instance.m_Graphics.TryGetValue(canvas, out var value))
			{
				return value;
			}
			return s_EmptyList;
		}

		public static IList<Graphic> GetRaycastableGraphicsForCanvas(Canvas canvas)
		{
			if (instance.m_RaycastableGraphics.TryGetValue(canvas, out var value))
			{
				return value;
			}
			return s_EmptyList;
		}
	}
	[Obsolete("Not supported anymore")]
	internal interface IGraphicEnabledDisabled
	{
		void OnSiblingGraphicEnabledDisabled();
	}
	[RequireComponent(typeof(CanvasRenderer))]
	[AddComponentMenu("UI/Image", 11)]
	public class Image : MaskableGraphic, ISerializationCallbackReceiver, ILayoutElement, ICanvasRaycastFilter
	{
		public enum Type
		{
			Simple,
			Sliced,
			Tiled,
			Filled
		}

		public enum FillMethod
		{
			Horizontal,
			Vertical,
			Radial90,
			Radial180,
			Radial360
		}

		public enum OriginHorizontal
		{
			Left,
			Right
		}

		public enum OriginVertical
		{
			Bottom,
			Top
		}

		public enum Origin90
		{
			BottomLeft,
			TopLeft,
			TopRight,
			BottomRight
		}

		public enum Origin180
		{
			Bottom,
			Left,
			Top,
			Right
		}

		public enum Origin360
		{
			Bottom,
			Right,
			Top,
			Left
		}

		protected static Material s_ETC1DefaultUI = null;

		[FormerlySerializedAs("m_Frame")]
		[SerializeField]
		private Sprite m_Sprite;

		[NonSerialized]
		private Sprite m_OverrideSprite;

		[SerializeField]
		private Type m_Type;

		[SerializeField]
		private bool m_PreserveAspect;

		[SerializeField]
		private bool m_FillCenter = true;

		[SerializeField]
		private FillMethod m_FillMethod = FillMethod.Radial360;

		[Range(0f, 1f)]
		[SerializeField]
		private float m_FillAmount = 1f;

		[SerializeField]
		private bool m_FillClockwise = true;

		[SerializeField]
		private int m_FillOrigin;

		private float m_AlphaHitTestMinimumThreshold;

		private bool m_Tracked;

		[SerializeField]
		private bool m_UseSpriteMesh;

		[SerializeField]
		private float m_PixelsPerUnitMultiplier = 1f;

		private float m_CachedReferencePixelsPerUnit = 100f;

		private static readonly Vector2[] s_VertScratch = (Vector2[])(object)new Vector2[4];

		private static readonly Vector2[] s_UVScratch = (Vector2[])(object)new Vector2[4];

		private static readonly Vector3[] s_Xy = (Vector3[])(object)new Vector3[4];

		private static readonly Vector3[] s_Uv = (Vector3[])(object)new Vector3[4];

		private static List<Image> m_TrackedTexturelessImages = new List<Image>();

		private static bool s_Initialized;

		public Sprite sprite
		{
			get
			{
				return m_Sprite;
			}
			set
			{
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: 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_0051: 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)
				Rect rect;
				if ((Object)(object)m_Sprite != (Object)null)
				{
					if ((Object)(object)m_Sprite != (Object)(object)value)
					{
						rect = m_Sprite.rect;
						Vector2 size = ((Rect)(ref rect)).size;
						Vector2 val;
						if (!Object.op_Implicit((Object)(object)value))
						{
							val = Vector2.zero;
						}
						else
						{
							rect = value.rect;
							val = ((Rect)(ref rect)).size;
						}
						m_SkipLayoutUpdate = ((Vector2)(ref size)).Equals(val);
						m_SkipMaterialUpdate = (Object)(object)m_Sprite.texture == (Object)(object)(Object.op_Implicit((Object)(object)value) ? value.texture : null);
						m_Sprite = value;
						SetAllDirty();
						TrackSprite();
					}
				}
				else if ((Object)(object)value != (Object)null)
				{
					rect = value.rect;
					m_SkipLayoutUpdate = ((Rect)(ref rect)).size == Vector2.zero;
					m_SkipMaterialUpdate = (Object)(object)value.texture == (Object)null;
					m_Sprite = value;
					SetAllDirty();
					TrackSprite();
				}
			}
		}

		public Sprite overrideSprite
		{
			get
			{
				return activeSprite;
			}
			set
			{
				if (SetPropertyUtility.SetClass(ref m_OverrideSprite, value))
				{
					SetAllDirty();
					TrackSprite();
				}
			}
		}

		private Sprite activeSprite
		{
			get
			{
				if (!((Object)(object)m_OverrideSprite != (Object)null))
				{
					return sprite;
				}
				return m_OverrideSprite;
			}
		}

		public Type type
		{
			get
			{
				return m_Type;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_Type, value))
				{
					SetVerticesDirty();
				}
			}
		}

		public bool preserveAspect
		{
			get
			{
				return m_PreserveAspect;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_PreserveAspect, value))
				{
					SetVerticesDirty();
				}
			}
		}

		public bool fillCenter
		{
			get
			{
				return m_FillCenter;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_FillCenter, value))
				{
					SetVerticesDirty();
				}
			}
		}

		public FillMethod fillMethod
		{
			get
			{
				return m_FillMethod;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_FillMethod, value))
				{
					SetVerticesDirty();
					m_FillOrigin = 0;
				}
			}
		}

		public float fillAmount
		{
			get
			{
				return m_FillAmount;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_FillAmount, Mathf.Clamp01(value)))
				{
					SetVerticesDirty();
				}
			}
		}

		public bool fillClockwise
		{
			get
			{
				return m_FillClockwise;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_FillClockwise, value))
				{
					SetVerticesDirty();
				}
			}
		}

		public int fillOrigin
		{
			get
			{
				return m_FillOrigin;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_FillOrigin, value))
				{
					SetVerticesDirty();
				}
			}
		}

		[Obsolete("eventAlphaThreshold has been deprecated. Use eventMinimumAlphaThreshold instead (UnityUpgradable) -> alphaHitTestMinimumThreshold")]
		public float eventAlphaThreshold
		{
			get
			{
				return 1f - alphaHitTestMinimumThreshold;
			}
			set
			{
				alphaHitTestMinimumThreshold = 1f - value;
			}
		}

		public float alphaHitTestMinimumThreshold
		{
			get
			{
				return m_AlphaHitTestMinimumThreshold;
			}
			set
			{
				m_AlphaHitTestMinimumThreshold = value;
			}
		}

		public bool useSpriteMesh
		{
			get
			{
				return m_UseSpriteMesh;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_UseSpriteMesh, value))
				{
					SetVerticesDirty();
				}
			}
		}

		public static Material defaultETC1GraphicMaterial
		{
			get
			{
				if ((Object)(object)s_ETC1DefaultUI == (Object)null)
				{
					s_ETC1DefaultUI = Canvas.GetETC1SupportedCanvasMaterial();
				}
				return s_ETC1DefaultUI;
			}
		}

		public override Texture mainTexture
		{
			get
			{
				if ((Object)(object)activeSprite == (Object)null)
				{
					if ((Object)(object)material != (Object)null && (Object)(object)material.mainTexture != (Object)null)
					{
						return material.mainTexture;
					}
					return (Texture)(object)Graphic.s_WhiteTexture;
				}
				return (Texture)(object)activeSprite.texture;
			}
		}

		public bool hasBorder
		{
			get
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)activeSprite != (Object)null)
				{
					Vector4 border = activeSprite.border;
					return ((Vector4)(ref border)).sqrMagnitude > 0f;
				}
				return false;
			}
		}

		public float pixelsPerUnitMultiplier
		{
			get
			{
				return m_PixelsPerUnitMultiplier;
			}
			set
			{
				m_PixelsPerUnitMultiplier = Mathf.Max(0.01f, value);
				SetVerticesDirty();
			}
		}

		public float pixelsPerUnit
		{
			get
			{
				float num = 100f;
				if (Object.op_Implicit((Object)(object)activeSprite))
				{
					num = activeSprite.pixelsPerUnit;
				}
				if (Object.op_Implicit((Object)(object)base.canvas))
				{
					m_CachedReferencePixelsPerUnit = base.canvas.referencePixelsPerUnit;
				}
				return num / m_CachedReferencePixelsPerUnit;
			}
		}

		protected float multipliedPixelsPerUnit => pixelsPerUnit * m_PixelsPerUnitMultiplier;

		public override Material material
		{
			get
			{
				if ((Object)(object)m_Material != (Object)null)
				{
					return m_Material;
				}
				if (Object.op_Implicit((Object)(object)activeSprite) && (Object)(object)activeSprite.associatedAlphaSplitTexture != (Object)null)
				{
					return defaultETC1GraphicMaterial;
				}
				return defaultMaterial;
			}
			set
			{
				base.material = value;
			}
		}

		public virtual float minWidth => 0f;

		public virtual float preferredWidth
		{
			get
			{
				//IL_002c: 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_0049: 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)
				if ((Object)(object)activeSprite == (Object)null)
				{
					return 0f;
				}
				if (type == Type.Sliced || type == Type.Tiled)
				{
					return DataUtility.GetMinSize(activeSprite).x / pixelsPerUnit;
				}
				Rect rect = activeSprite.rect;
				return ((Rect)(ref rect)).size.x / pixelsPerUnit;
			}
		}

		public virtual float flexibleWidth => -1f;

		public virtual float minHeight => 0f;

		public virtual float preferredHeight
		{
			get
			{
				//IL_002c: 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_0049: 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)
				if ((Object)(object)activeSprite == (Object)null)
				{
					return 0f;
				}
				if (type == Type.Sliced || type == Type.Tiled)
				{
					return DataUtility.GetMinSize(activeSprite).y / pixelsPerUnit;
				}
				Rect rect = activeSprite.rect;
				return ((Rect)(ref rect)).size.y / pixelsPerUnit;
			}
		}

		public virtual float flexibleHeight => -1f;

		public virtual int layoutPriority => 0;

		public void DisableSpriteOptimizations()
		{
			m_SkipLayoutUpdate = false;
			m_SkipMaterialUpdate = false;
		}

		protected Image()
		{
			base.useLegacyMeshGeneration = false;
		}

		public virtual void OnBeforeSerialize()
		{
		}

		public virtual void OnAfterDeserialize()
		{
			if (m_FillOrigin < 0)
			{
				m_FillOrigin = 0;
			}
			else if (m_FillMethod == FillMethod.Horizontal && m_FillOrigin > 1)
			{
				m_FillOrigin = 0;
			}
			else if (m_FillMethod == FillMethod.Vertical && m_FillOrigin > 1)
			{
				m_FillOrigin = 0;
			}
			else if (m_FillOrigin > 3)
			{
				m_FillOrigin = 0;
			}
			m_FillAmount = Mathf.Clamp(m_FillAmount, 0f, 1f);
		}

		private void PreserveSpriteAspectRatio(ref Rect rect, Vector2 spriteSize)
		{
			//IL_0000: 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_008c: 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)
			float num = spriteSize.x / spriteSize.y;
			float num2 = ((Rect)(ref rect)).width / ((Rect)(ref rect)).height;
			if (num > num2)
			{
				float height = ((Rect)(ref rect)).height;
				((Rect)(ref rect)).height = ((Rect)(ref rect)).width * (1f / num);
				((Rect)(ref rect)).y = ((Rect)(ref rect)).y + (height - ((Rect)(ref rect)).height) * base.rectTransform.pivot.y;
			}
			else
			{
				float width = ((Rect)(ref rect)).width;
				((Rect)(ref rect)).width = ((Rect)(ref rect)).height * num;
				((Rect)(ref rect)).x = ((Rect)(ref rect)).x + (width - ((Rect)(ref rect)).width) * base.rectTransform.pivot.x;
			}
		}

		private Vector4 GetDrawingDimensions(bool shouldPreserveAspect)
		{
			//IL_001b: 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)
			//IL_0020: 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_0035: 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_0049: 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_0057: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0086: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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)
			Vector4 val = (((Object)(object)activeSprite == (Object)null) ? Vector4.zero : DataUtility.GetPadding(activeSprite));
			? val2;
			if (!((Object)(object)activeSprite == (Object)null))
			{
				Rect rect = activeSprite.rect;
				float width = ((Rect)(ref rect)).width;
				rect = activeSprite.rect;
				val2 = new Vector2(width, ((Rect)(ref rect)).height);
			}
			else
			{
				val2 = Vector2.zero;
			}
			Vector2 val3 = (Vector2)val2;
			Rect rect2 = GetPixelAdjustedRect();
			int num = Mathf.RoundToInt(val3.x);
			int num2 = Mathf.RoundToInt(val3.y);
			Vector4 val4 = default(Vector4);
			((Vector4)(ref val4))..ctor(val.x / (float)num, val.y / (float)num2, ((float)num - val.z) / (float)num, ((float)num2 - val.w) / (float)num2);
			if (shouldPreserveAspect && ((Vector2)(ref val3)).sqrMagnitude > 0f)
			{
				PreserveSpriteAspectRatio(ref rect2, val3);
			}
			((Vector4)(ref val4))..ctor(((Rect)(ref rect2)).x + ((Rect)(ref rect2)).width * val4.x, ((Rect)(ref rect2)).y + ((Rect)(ref rect2)).height * val4.y, ((Rect)(ref rect2)).x + ((Rect)(ref rect2)).width * val4.z, ((Rect)(ref rect2)).y + ((Rect)(ref rect2)).height * val4.w);
			return val4;
		}

		public override void SetNativeSize()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_0034: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)activeSprite != (Object)null)
			{
				Rect rect = activeSprite.rect;
				float num = ((Rect)(ref rect)).width / pixelsPerUnit;
				rect = activeSprite.rect;
				float num2 = ((Rect)(ref rect)).height / pixelsPerUnit;
				base.rectTransform.anchorMax = base.rectTransform.anchorMin;
				base.rectTransform.sizeDelta = new Vector2(num, num2);
				SetAllDirty();
			}
		}

		protected override void OnPopulateMesh(VertexHelper toFill)
		{
			if ((Object)(object)activeSprite == (Object)null)
			{
				base.OnPopulateMesh(toFill);
				return;
			}
			switch (type)
			{
			case Type.Simple:
				if (!useSpriteMesh)
				{
					GenerateSimpleSprite(toFill, m_PreserveAspect);
				}
				else
				{
					GenerateSprite(toFill, m_PreserveAspect);
				}
				break;
			case Type.Sliced:
				GenerateSlicedSprite(toFill);
				break;
			case Type.Tiled:
				GenerateTiledSprite(toFill);
				break;
			case Type.Filled:
				GenerateFilledSprite(toFill, m_PreserveAspect);
				break;
			}
		}

		private void TrackSprite()
		{
			if ((Object)(object)activeSprite != (Object)null && (Object)(object)activeSprite.texture == (Object)null)
			{
				TrackImage(this);
				m_Tracked = true;
			}
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			TrackSprite();
		}

		protected override void OnDisable()
		{
			base.OnDisable();
			if (m_Tracked)
			{
				UnTrackImage(this);
			}
		}

		protected override void UpdateMaterial()
		{
			base.UpdateMaterial();
			if ((Object)(object)activeSprite == (Object)null)
			{
				base.canvasRenderer.SetAlphaTexture((Texture)null);
				return;
			}
			Texture2D associatedAlphaSplitTexture = activeSprite.associatedAlphaSplitTexture;
			if ((Object)(object)associatedAlphaSplitTexture != (Object)null)
			{
				base.canvasRenderer.SetAlphaTexture((Texture)(object)associatedAlphaSplitTexture);
			}
		}

		protected override void OnCanvasHierarchyChanged()
		{
			base.OnCanvasHierarchyChanged();
			if ((Object)(object)base.canvas == (Object)null)
			{
				m_CachedReferencePixelsPerUnit = 100f;
			}
			else if (base.canvas.referencePixelsPerUnit != m_CachedReferencePixelsPerUnit)
			{
				m_CachedReferencePixelsPerUnit = base.canvas.referencePixelsPerUnit;
				if (type == Type.Sliced || type == Type.Tiled)
				{
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		private void GenerateSimpleSprite(VertexHelper vh, bool lPreserveAspect)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_002f: 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: 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)
			//IL_0049: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			Vector4 drawingDimensions = GetDrawingDimensions(lPreserveAspect);
			Vector4 val = (((Object)(object)activeSprite != (Object)null) ? DataUtility.GetOuterUV(activeSprite) : Vector4.zero);
			Color val2 = color;
			vh.Clear();
			vh.AddVert(new Vector3(drawingDimensions.x, drawingDimensions.y), Color32.op_Implicit(val2), Vector4.op_Implicit(new Vector2(val.x, val.y)));
			vh.AddVert(new Vector3(drawingDimensions.x, drawingDimensions.w), Color32.op_Implicit(val2), Vector4.op_Implicit(new Vector2(val.x, val.w)));
			vh.AddVert(new Vector3(drawingDimensions.z, drawingDimensions.w), Color32.op_Implicit(val2), Vector4.op_Implicit(new Vector2(val.z, val.w)));
			vh.AddVert(new Vector3(drawingDimensions.z, drawingDimensions.y), Color32.op_Implicit(val2), Vector4.op_Implicit(new Vector2(val.z, val.y)));
			vh.AddTriangle(0, 1, 2);
			vh.AddTriangle(2, 3, 0);
		}

		private void GenerateSprite(VertexHelper vh, bool lPreserveAspect)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0035: 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_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_0047: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: 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_014a: 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)
			Rect rect = activeSprite.rect;
			float width = ((Rect)(ref rect)).width;
			rect = activeSprite.rect;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(width, ((Rect)(ref rect)).height);
			Vector2 val2 = activeSprite.pivot / val;
			Vector2 pivot = base.rectTransform.pivot;
			Rect rect2 = GetPixelAdjustedRect();
			if (lPreserveAspect & (((Vector2)(ref val)).sqrMagnitude > 0f))
			{
				PreserveSpriteAspectRatio(ref rect2, val);
			}
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(((Rect)(ref rect2)).width, ((Rect)(ref rect2)).height);
			Bounds bounds = activeSprite.bounds;
			Vector3 size = ((Bounds)(ref bounds)).size;
			Vector2 val4 = (pivot - val2) * val3;
			Color val5 = color;
			vh.Clear();
			Vector2[] vertices = activeSprite.vertices;
			Vector2[] uv = activeSprite.uv;
			for (int i = 0; i < vertices.Length; i++)
			{
				vh.AddVert(new Vector3(vertices[i].x / size.x * val3.x - val4.x, vertices[i].y / size.y * val3.y - val4.y), Color32.op_Implicit(val5), Vector4.op_Implicit(new Vector2(uv[i].x, uv[i].y)));
			}
			ushort[] triangles = activeSprite.triangles;
			for (int j = 0; j < triangles.Length; j += 3)
			{
				vh.AddTriangle(triangles[j], triangles[j + 1], triangles[j + 2]);
			}
		}

		private void GenerateSlicedSprite(VertexHelper toFill)
		{
			//IL_0051: 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_0057: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: 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_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			if (!hasBorder)
			{
				GenerateSimpleSprite(toFill, lPreserveAspect: false);
				return;
			}
			Vector4 val;
			Vector4 val2;
			Vector4 val4;
			Vector4 val3;
			if ((Object)(object)activeSprite != (Object)null)
			{
				val = DataUtility.GetOuterUV(activeSprite);
				val2 = DataUtility.GetInnerUV(activeSprite);
				val3 = DataUtility.GetPadding(activeSprite);
				val4 = activeSprite.border;
			}
			else
			{
				val = Vector4.zero;
				val2 = Vector4.zero;
				val3 = Vector4.zero;
				val4 = Vector4.zero;
			}
			Rect pixelAdjustedRect = GetPixelAdjustedRect();
			Vector4 adjustedBorders = GetAdjustedBorders(val4 / multipliedPixelsPerUnit, pixelAdjustedRect);
			val3 /= multipliedPixelsPerUnit;
			s_VertScratch[0] = new Vector2(val3.x, val3.y);
			s_VertScratch[3] = new Vector2(((Rect)(ref pixelAdjustedRect)).width - val3.z, ((Rect)(ref pixelAdjustedRect)).height - val3.w);
			s_VertScratch[1].x = adjustedBorders.x;
			s_VertScratch[1].y = adjustedBorders.y;
			s_VertScratch[2].x = ((Rect)(ref pixelAdjustedRect)).width - adjustedBorders.z;
			s_VertScratch[2].y = ((Rect)(ref pixelAdjustedRect)).height - adjustedBorders.w;
			for (int i = 0; i < 4; i++)
			{
				s_VertScratch[i].x += ((Rect)(ref pixelAdjustedRect)).x;
				s_VertScratch[i].y += ((Rect)(ref pixelAdjustedRect)).y;
			}
			s_UVScratch[0] = new Vector2(val.x, val.y);
			s_UVScratch[1] = new Vector2(val2.x, val2.y);
			s_UVScratch[2] = new Vector2(val2.z, val2.w);
			s_UVScratch[3] = new Vector2(val.z, val.w);
			toFill.Clear();
			for (int j = 0; j < 3; j++)
			{
				int num = j + 1;
				for (int k = 0; k < 3; k++)
				{
					if (m_FillCenter || j != 1 || k != 1)
					{
						int num2 = k + 1;
						AddQuad(toFill, new Vector2(s_VertScratch[j].x, s_VertScratch[k].y), new Vector2(s_VertScratch[num].x, s_VertScratch[num2].y), Color32.op_Implicit(color), new Vector2(s_UVScratch[j].x, s_UVScratch[k].y), new Vector2(s_UVScratch[num].x, s_UVScratch[num2].y));
					}
				}
			}
		}

		private void GenerateTiledSprite(VertexHelper toFill)
		{
			//IL_0049: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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_005a: 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_006a: 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)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0038: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0916: Unknown result type (might be due to invalid IL or missing references)
			//IL_091d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0922: Unknown result type (might be due to invalid IL or missing references)
			//IL_092b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0932: Unknown result type (might be due to invalid IL or missing references)
			//IL_0937: Unknown result type (might be due to invalid IL or missing references)
			//IL_093d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0942: Unknown result type (might be due to invalid IL or missing references)
			//IL_0947: Unknown result type (might be due to invalid IL or missing references)
			//IL_0949: Unknown result type (might be due to invalid IL or missing references)
			//IL_094b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0950: Unknown result type (might be due to invalid IL or missing references)
			//IL_0952: Unknown result type (might be due to invalid IL or missing references)
			//IL_0954: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0623: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_055a: Unknown result type (might be due to invalid IL or missing references)
			//IL_055f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0568: Unknown result type (might be due to invalid IL or missing references)
			//IL_056f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			//IL_058a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0591: Unknown result type (might be due to invalid IL or missing references)
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05df: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_0609: Unknown result type (might be due to invalid IL or missing references)
			//IL_051f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Unknown result type (might be due to invalid IL or missing references)
			//IL_052d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0760: Unknown result type (might be due to invalid IL or missing references)
			//IL_0767: Unknown result type (might be due to invalid IL or missing references)
			//IL_076c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0775: Unknown result type (might be due to invalid IL or missing references)
			//IL_077c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0781: Unknown result type (might be due to invalid IL or missing references)
			//IL_0787: Unknown result type (might be due to invalid IL or missing references)
			//IL_078c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0791: Unknown result type (might be due to invalid IL or missing references)
			//IL_0797: Unknown result type (might be due to invalid IL or missing references)
			//IL_079d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_07dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0805: Unknown result type (might be due to invalid IL or missing references)
			//IL_080a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0810: Unknown result type (might be due to invalid IL or missing references)
			//IL_0817: Unknown result type (might be due to invalid IL or missing references)
			//IL_0829: Unknown result type (might be due to invalid IL or missing references)
			//IL_0830: Unknown result type (might be due to invalid IL or missing references)
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_0843: Unknown result type (might be due to invalid IL or missing references)
			//IL_084a: Unknown result type (might be due to invalid IL or missing references)
			//IL_084f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0855: Unknown result type (might be due to invalid IL or missing references)
			//IL_085a: Unknown result type (might be due to invalid IL or missing references)
			//IL_085f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0865: Unknown result type (might be due to invalid IL or missing references)
			//IL_086c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0871: Unknown result type (might be due to invalid IL or missing references)
			//IL_0878: Unknown result type (might be due to invalid IL or missing references)
			//IL_087e: Unknown result type (might be due to invalid IL or missing references)
			//IL_088d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0894: Unknown result type (might be due to invalid IL or missing references)
			//IL_0899: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08be: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08db: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_068c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0691: Unknown result type (might be due to invalid IL or missing references)
			//IL_069a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0706: Unknown result type (might be due to invalid IL or missing references)
			//IL_070b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0711: Unknown result type (might be due to invalid IL or missing references)
			//IL_0716: Unknown result type (might be due to invalid IL or missing references)
			//IL_071b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0722: Unknown result type (might be due to invalid IL or missing references)
			//IL_0729: Unknown result type (might be due to invalid IL or missing references)
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0735: Unknown result type (might be due to invalid IL or missing references)
			//IL_073b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0651: Unknown result type (might be due to invalid IL or missing references)
			//IL_0658: Unknown result type (might be due to invalid IL or missing references)
			//IL_065f: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			Vector4 val;
			Vector4 val2;
			Vector2 val4;
			Vector4 val3;
			if ((Object)(object)activeSprite != (Object)null)
			{
				val = DataUtility.GetOuterUV(activeSprite);
				val2 = DataUtility.GetInnerUV(activeSprite);
				val3 = activeSprite.border;
				Rect rect = activeSprite.rect;
				val4 = ((Rect)(ref rect)).size;
			}
			else
			{
				val = Vector4.zero;
				val2 = Vector4.zero;
				val3 = Vector4.zero;
				val4 = Vector2.one * 100f;
			}
			Rect pixelAdjustedRect = GetPixelAdjustedRect();
			float num = (val4.x - val3.x - val3.z) / multipliedPixelsPerUnit;
			float num2 = (val4.y - val3.y - val3.w) / multipliedPixelsPerUnit;
			val3 = GetAdjustedBorders(val3 / multipliedPixelsPerUnit, pixelAdjustedRect);
			Vector2 val5 = default(Vector2);
			((Vector2)(ref val5))..ctor(val2.x, val2.y);
			Vector2 val6 = default(Vector2);
			((Vector2)(ref val6))..ctor(val2.z, val2.w);
			float x = val3.x;
			float num3 = ((Rect)(ref pixelAdjustedRect)).width - val3.z;
			float y = val3.y;
			float num4 = ((Rect)(ref pixelAdjustedRect)).height - val3.w;
			toFill.Clear();
			Vector2 uvMax = val6;
			if (num <= 0f)
			{
				num = num3 - x;
			}
			if (num2 <= 0f)
			{
				num2 = num4 - y;
			}
			if ((Object)(object)activeSprite != (Object)null && (hasBorder || activeSprite.packed || ((Object)(object)activeSprite.texture != (Object)null && (int)((Texture)activeSprite.texture).wrapMode != 0)))
			{
				long num5 = 0L;
				long num6 = 0L;
				if (m_FillCenter)
				{
					num5 = (long)Math.Ceiling((num3 - x) / num);
					num6 = (long)Math.Ceiling((num4 - y) / num2);
					double num7 = 0.0;
					num7 = ((!hasBorder) ? ((double)(num5 * num6) * 4.0) : (((double)num5 + 2.0) * ((double)num6 + 2.0) * 4.0));
					if (num7 > 65000.0)
					{
						Debug.LogError((object)("Too many sprite tiles on Image \"" + ((Object)this).name + "\". The tile size will be increased. To remove the limit on the number of tiles, set the Wrap mode to Repeat in the Image Import Settings"), (Object)(object)this);
						double num8 = ((!hasBorder) ? ((double)num5 / (double)num6) : (((double)num5 + 2.0) / ((double)num6 + 2.0)));
						double num9 = Math.Sqrt(16250.0 / num8);
						double num10 = num9 * num8;
						if (hasBorder)
						{
							num9 -= 2.0;
							num10 -= 2.0;
						}
						num5 = (long)Math.Floor(num9);
						num6 = (long)Math.Floor(num10);
						num = (num3 - x) / (float)num5;
						num2 = (num4 - y) / (float)num6;
					}
				}
				else if (hasBorder)
				{
					num5 = (long)Math.Ceiling((num3 - x) / num);
					num6 = (long)Math.Ceiling((num4 - y) / num2);
					if (((double)(num6 + num5) + 2.0) * 2.0 * 4.0 > 65000.0)
					{
						Debug.LogError((object)("Too many sprite tiles on Image \"" + ((Object)this).name + "\". The tile size will be increased. To remove the limit on the number of tiles, set the Wrap mode to Repeat in the Image Import Settings"), (Object)(object)this);
						double num11 = (double)num5 / (double)num6;
						double num12 = (16250.0 - 4.0) / (2.0 * (1.0 + num11));
						double d = num12 * num11;
						num5 = (long)Math.Floor(num12);
						num6 = (long)Math.Floor(d);
						num = (num3 - x) / (float)num5;
						num2 = (num4 - y) / (float)num6;
					}
				}
				else
				{
					num6 = (num5 = 0L);
				}
				if (m_FillCenter)
				{
					for (long num13 = 0L; num13 < num6; num13++)
					{
						float num14 = y + (float)num13 * num2;
						float num15 = y + (float)(num13 + 1) * num2;
						if (num15 > num4)
						{
							uvMax.y = val5.y + (val6.y - val5.y) * (num4 - num14) / (num15 - num14);
							num15 = num4;
						}
						uvMax.x = val6.x;
						for (long num16 = 0L; num16 < num5; num16++)
						{
							float num17 = x + (float)num16 * num;
							float num18 = x + (float)(num16 + 1) * num;
							if (num18 > num3)
							{
								uvMax.x = val5.x + (val6.x - val5.x) * (num3 - num17) / (num18 - num17);
								num18 = num3;
							}
							AddQuad(toFill, new Vector2(num17, num14) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(num18, num15) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), val5, uvMax);
						}
					}
				}
				if (!hasBorder)
				{
					return;
				}
				uvMax = val6;
				for (long num19 = 0L; num19 < num6; num19++)
				{
					float num20 = y + (float)num19 * num2;
					float num21 = y + (float)(num19 + 1) * num2;
					if (num21 > num4)
					{
						uvMax.y = val5.y + (val6.y - val5.y) * (num4 - num20) / (num21 - num20);
						num21 = num4;
					}
					AddQuad(toFill, new Vector2(0f, num20) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(x, num21) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), new Vector2(val.x, val5.y), new Vector2(val5.x, uvMax.y));
					AddQuad(toFill, new Vector2(num3, num20) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(((Rect)(ref pixelAdjustedRect)).width, num21) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), new Vector2(val6.x, val5.y), new Vector2(val.z, uvMax.y));
				}
				uvMax = val6;
				for (long num22 = 0L; num22 < num5; num22++)
				{
					float num23 = x + (float)num22 * num;
					float num24 = x + (float)(num22 + 1) * num;
					if (num24 > num3)
					{
						uvMax.x = val5.x + (val6.x - val5.x) * (num3 - num23) / (num24 - num23);
						num24 = num3;
					}
					AddQuad(toFill, new Vector2(num23, 0f) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(num24, y) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), new Vector2(val5.x, val.y), new Vector2(uvMax.x, val5.y));
					AddQuad(toFill, new Vector2(num23, num4) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(num24, ((Rect)(ref pixelAdjustedRect)).height) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), new Vector2(val5.x, val6.y), new Vector2(uvMax.x, val.w));
				}
				AddQuad(toFill, new Vector2(0f, 0f) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(x, y) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), new Vector2(val.x, val.y), new Vector2(val5.x, val5.y));
				AddQuad(toFill, new Vector2(num3, 0f) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(((Rect)(ref pixelAdjustedRect)).width, y) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), new Vector2(val6.x, val.y), new Vector2(val.z, val5.y));
				AddQuad(toFill, new Vector2(0f, num4) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(x, ((Rect)(ref pixelAdjustedRect)).height) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), new Vector2(val.x, val6.y), new Vector2(val5.x, val.w));
				AddQuad(toFill, new Vector2(num3, num4) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(((Rect)(ref pixelAdjustedRect)).width, ((Rect)(ref pixelAdjustedRect)).height) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), new Vector2(val6.x, val6.y), new Vector2(val.z, val.w));
			}
			else
			{
				Vector2 val7 = default(Vector2);
				((Vector2)(ref val7))..ctor((num3 - x) / num, (num4 - y) / num2);
				if (m_FillCenter)
				{
					AddQuad(toFill, new Vector2(x, y) + ((Rect)(ref pixelAdjustedRect)).position, new Vector2(num3, num4) + ((Rect)(ref pixelAdjustedRect)).position, Color32.op_Implicit(color), Vector2.Scale(val5, val7), Vector2.Scale(val6, val7));
				}
			}
		}

		private static void AddQuad(VertexHelper vertexHelper, Vector3[] quadPositions, Color32 color, Vector3[] quadUVs)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			int currentVertCount = vertexHelper.currentVertCount;
			for (int i = 0; i < 4; i++)
			{
				vertexHelper.AddVert(quadPositions[i], color, Vector4.op_Implicit(quadUVs[i]));
			}
			vertexHelper.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 2);
			vertexHelper.AddTriangle(currentVertCount + 2, currentVertCount + 3, currentVertCount);
		}

		private static void AddQuad(VertexHelper vertexHelper, Vector2 posMin, Vector2 posMax, Color32 color, Vector2 uvMin, Vector2 uvMax)
		{
			//IL_0008: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0088: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d1: Unknown result type (might be due to invalid IL or missing references)
			int currentVertCount = vertexHelper.currentVertCount;
			vertexHelper.AddVert(new Vector3(posMin.x, posMin.y, 0f), color, Vector4.op_Implicit(new Vector2(uvMin.x, uvMin.y)));
			vertexHelper.AddVert(new Vector3(posMin.x, posMax.y, 0f), color, Vector4.op_Implicit(new Vector2(uvMin.x, uvMax.y)));
			vertexHelper.AddVert(new Vector3(posMax.x, posMax.y, 0f), color, Vector4.op_Implicit(new Vector2(uvMax.x, uvMax.y)));
			vertexHelper.AddVert(new Vector3(posMax.x, posMin.y, 0f), color, Vector4.op_Implicit(new Vector2(uvMax.x, uvMin.y)));
			vertexHelper.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 2);
			vertexHelper.AddTriangle(currentVertCount + 2, currentVertCount + 3, currentVertCount);
		}

		private Vector4 GetAdjustedBorders(Vector4 border, Rect adjustedRect)
		{
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_00b9: 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)
			Rect rect = base.rectTransform.rect;
			for (int i = 0; i <= 1; i++)
			{
				Vector2 size = ((Rect)(ref rect)).size;
				if (((Vector2)(ref size))[i] != 0f)
				{
					size = ((Rect)(ref adjustedRect)).size;
					float num = ((Vector2)(ref size))[i];
					size = ((Rect)(ref rect)).size;
					float num2 = num / ((Vector2)(ref size))[i];
					ref Vector4 reference = ref border;
					int num3 = i;
					((Vector4)(ref reference))[num3] = ((Vector4)(ref reference))[num3] * num2;
					reference = ref border;
					num3 = i + 2;
					((Vector4)(ref reference))[num3] = ((Vector4)(ref reference))[num3] * num2;
				}
				float num4 = ((Vector4)(ref border))[i] + ((Vector4)(ref border))[i + 2];
				size = ((Rect)(ref adjustedRect)).size;
				if (((Vector2)(ref size))[i] < num4 && num4 != 0f)
				{
					size = ((Rect)(ref adjustedRect)).size;
					float num2 = ((Vector2)(ref size))[i] / num4;
					ref Vector4 reference = ref border;
					int num3 = i;
					((Vector4)(ref reference))[num3] = ((Vector4)(ref reference))[num3] * num2;
					reference = ref border;
					num3 = i + 2;
					((Vector4)(ref reference))[num3] = ((Vector4)(ref reference))[num3] * num2;
				}
			}
			return border;
		}

		private void GenerateFilledSprite(VertexHelper toFill, bool preserveAspect)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: 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_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_00a5: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_011b: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_063b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_067e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0684: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_088f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0894: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b4: Unknown result type (might be due to invalid IL or missing references)
			toFill.Clear();
			if (m_FillAmount < 0.001f)
			{
				return;
			}
			Vector4 drawingDimensions = GetDrawingDimensions(preserveAspect);
			Vector4 val = (((Object)(object)activeSprite != (Object)null) ? DataUtility.GetOuterUV(activeSprite) : Vector4.zero);
			UIVertex simpleVert = UIVertex.simpleVert;
			simpleVert.color = Color32.op_Implicit(color);
			float num = val.x;
			float num2 = val.y;
			float num3 = val.z;
			float num4 = val.w;
			if (m_FillMethod == FillMethod.Horizontal || m_FillMethod == FillMethod.Vertical)
			{
				if (fillMethod == FillMethod.Horizontal)
				{
					float num5 = (num3 - num) * m_FillAmount;
					if (m_FillOrigin == 1)
					{
						drawingDimensions.x = drawingDimensions.z - (drawingDimensions.z - drawingDimensions.x) * m_FillAmount;
						num = num3 - num5;
					}
					else
					{
						drawingDimensions.z = drawingDimensions.x + (drawingDimensions.z - drawingDimensions.x) * m_FillAmount;
						num3 = num + num5;
					}
				}
				else if (fillMethod == FillMethod.Vertical)
				{
					float num6 = (num4 - num2) * m_FillAmount;
					if (m_FillOrigin == 1)
					{
						drawingDimensions.y = drawingDimensions.w - (drawingDimensions.w - drawingDimensions.y) * m_FillAmount;
						num2 = num4 - num6;
					}
					else
					{
						drawingDimensions.w = drawingDimensions.y + (drawingDimensions.w - drawingDimensions.y) * m_FillAmount;
						num4 = num2 + num6;
					}
				}
			}
			s_Xy[0] = Vector2.op_Implicit(new Vector2(drawingDimensions.x, drawingDimensions.y));
			s_Xy[1] = Vector2.op_Implicit(new Vector2(drawingDimensions.x, drawingDimensions.w));
			s_Xy[2] = Vector2.op_Implicit(new Vector2(drawingDimensions.z, drawingDimensions.w));
			s_Xy[3] = Vector2.op_Implicit(new Vector2(drawingDimensions.z, drawingDimensions.y));
			s_Uv[0] = Vector2.op_Implicit(new Vector2(num, num2));
			s_Uv[1] = Vector2.op_Implicit(new Vector2(num, num4));
			s_Uv[2] = Vector2.op_Implicit(new Vector2(num3, num4));
			s_Uv[3] = Vector2.op_Implicit(new Vector2(num3, num2));
			if (m_FillAmount < 1f && m_FillMethod != FillMethod.Horizontal && m_FillMethod != FillMethod.Vertical)
			{
				if (fillMethod == FillMethod.Radial90)
				{
					if (RadialCut(s_Xy, s_Uv, m_FillAmount, m_FillClockwise, m_FillOrigin))
					{
						AddQuad(toFill, s_Xy, Color32.op_Implicit(color), s_Uv);
					}
				}
				else if (fillMethod == FillMethod.Radial180)
				{
					for (int i = 0; i < 2; i++)
					{
						int num7 = ((m_FillOrigin > 1) ? 1 : 0);
						float num8;
						float num9;
						float num10;
						float num11;
						if (m_FillOrigin == 0 || m_FillOrigin == 2)
						{
							num8 = 0f;
							num9 = 1f;
							if (i == num7)
							{
								num10 = 0f;
								num11 = 0.5f;
							}
							else
							{
								num10 = 0.5f;
								num11 = 1f;
							}
						}
						else
						{
							num10 = 0f;
							num11 = 1f;
							if (i == num7)
							{
								num8 = 0.5f;
								num9 = 1f;
							}
							else
							{
								num8 = 0f;
								num9 = 0.5f;
							}
						}
						s_Xy[0].x = Mathf.Lerp(drawingDimensions.x, drawingDimensions.z, num10);
						s_Xy[1].x = s_Xy[0].x;
						s_Xy[2].x = Mathf.Lerp(drawingDimensions.x, drawingDimensions.z, num11);
						s_Xy[3].x = s_Xy[2].x;
						s_Xy[0].y = Mathf.Lerp(drawingDimensions.y, drawingDimensions.w, num8);
						s_Xy[1].y = Mathf.Lerp(drawingDimensions.y, drawingDimensions.w, num9);
						s_Xy[2].y = s_Xy[1].y;
						s_Xy[3].y = s_Xy[0].y;
						s_Uv[0].x = Mathf.Lerp(num, num3, num10);
						s_Uv[1].x = s_Uv[0].x;
						s_Uv[2].x = Mathf.Lerp(num, num3, num11);
						s_Uv[3].x = s_Uv[2].x;
						s_Uv[0].y = Mathf.Lerp(num2, num4, num8);
						s_Uv[1].y = Mathf.Lerp(num2, num4, num9);
						s_Uv[2].y = s_Uv[1].y;
						s_Uv[3].y = s_Uv[0].y;
						float num12 = (m_FillClockwise ? (fillAmount * 2f - (float)i) : (m_FillAmount * 2f - (float)(1 - i)));
						if (RadialCut(s_Xy, s_Uv, Mathf.Clamp01(num12), m_FillClockwise, (i + m_FillOrigin + 3) % 4))
						{
							AddQuad(toFill, s_Xy, Color32.op_Implicit(color), s_Uv);
						}
					}
				}
				else
				{
					if (fillMethod != FillMethod.Radial360)
					{
						return;
					}
					for (int j = 0; j < 4; j++)
					{
						float num13;
						float num14;
						if (j < 2)
						{
							num13 = 0f;
							num14 = 0.5f;
						}
						else
						{
							num13 = 0.5f;
							num14 = 1f;
						}
						float num15;
						float num16;
						if (j == 0 || j == 3)
						{
							num15 = 0f;
							num16 = 0.5f;
						}
						else
						{
							num15 = 0.5f;
							num16 = 1f;
						}
						s_Xy[0].x = Mathf.Lerp(drawingDimensions.x, drawingDimensions.z, num13);
						s_Xy[1].x = s_Xy[0].x;
						s_Xy[2].x = Mathf.Lerp(drawingDimensions.x, drawingDimensions.z, num14);
						s_Xy[3].x = s_Xy[2].x;
						s_Xy[0].y = Mathf.Lerp(drawingDimensions.y, drawingDimensions.w, num15);
						s_Xy[1].y = Mathf.Lerp(drawingDimensions.y, drawingDimensions.w, num16);
						s_Xy[2].y = s_Xy[1].y;
						s_Xy[3].y = s_Xy[0].y;
						s_Uv[0].x = Mathf.Lerp(num, num3, num13);
						s_Uv[1].x = s_Uv[0].x;
						s_Uv[2].x = Mathf.Lerp(num, num3, num14);
						s_Uv[3].x = s_Uv[2].x;
						s_Uv[0].y = Mathf.Lerp(num2, num4, num15);
						s_Uv[1].y = Mathf.Lerp(num2, num4, num16);
						s_Uv[2].y = s_Uv[1].y;
						s_Uv[3].y = s_Uv[0].y;
						float num17 = (m_FillClockwise ? (m_FillAmount * 4f - (float)((j + m_FillOrigin) % 4)) : (m_FillAmount * 4f - (float)(3 - (j + m_FillOrigin) % 4)));
						if (RadialCut(s_Xy, s_Uv, Mathf.Clamp01(num17), m_FillClockwise, (j + 2) % 4))
						{
							AddQuad(toFill, s_Xy, Color32.op_Implicit(color), s_Uv);
						}
					}
				}
			}
			else
			{
				AddQuad(toFill, s_Xy, Color32.op_Implicit(color), s_Uv);
			}
		}

		private static bool RadialCut(Vector3[] xy, Vector3[] uv, float fill, bool invert, int corner)
		{
			if (fill < 0.001f)
			{
				return false;
			}
			if ((corner & 1) == 1)
			{
				invert = !invert;
			}
			if (!invert && fill > 0.999f)
			{
				return true;
			}
			float num = Mathf.Clamp01(fill);
			if (invert)
			{
				num = 1f - num;
			}
			num *= (float)Math.PI / 2f;
			float cos = Mathf.Cos(num);
			float sin = Mathf.Sin(num);
			RadialCut(xy, cos, sin, invert, corner);
			RadialCut(uv, cos, sin, invert, corner);
			return true;
		}

		private static void RadialCut(Vector3[] xy, float cos, float sin, bool invert, int corner)
		{
			int num = (corner + 1) % 4;
			int num2 = (corner + 2) % 4;
			int num3 = (corner + 3) % 4;
			if ((corner & 1) == 1)
			{
				if (sin > cos)
				{
					cos /= sin;
					sin = 1f;
					if (invert)
					{
						xy[num].x = Mathf.Lerp(xy[corner].x, xy[num2].x, cos);
						xy[num2].x = xy[num].x;
					}
				}
				else if (cos > sin)
				{
					sin /= cos;
					cos = 1f;
					if (!invert)
					{
						xy[num2].y = Mathf.Lerp(xy[corner].y, xy[num2].y, sin);
						xy[num3].y = xy[num2].y;
					}
				}
				else
				{
					cos = 1f;
					sin = 1f;
				}
				if (!invert)
				{
					xy[num3].x = Mathf.Lerp(xy[corner].x, xy[num2].x, cos);
				}
				else
				{
					xy[num].y = Mathf.Lerp(xy[corner].y, xy[num2].y, sin);
				}
				return;
			}
			if (cos > sin)
			{
				sin /= cos;
				cos = 1f;
				if (!invert)
				{
					xy[num].y = Mathf.Lerp(xy[corner].y, xy[num2].y, sin);
					xy[num2].y = xy[num].y;
				}
			}
			else if (sin > cos)
			{
				cos /= sin;
				sin = 1f;
				if (invert)
				{
					xy[num2].x = Mathf.Lerp(xy[corner].x, xy[num2].x, cos);
					xy[num3].x = xy[num2].x;
				}
			}
			else
			{
				cos = 1f;
				sin = 1f;
			}
			if (invert)
			{
				xy[num3].y = Mathf.Lerp(xy[corner].y, xy[num2].y, sin);
			}
			else
			{
				xy[num].x = Mathf.Lerp(xy[corner].x, xy[num2].x, cos);
			}
		}

		public virtual void CalculateLayoutInputHorizontal()
		{
		}

		public virtual void CalculateLayoutInputVertical()
		{
		}

		public virtual bool IsRaycastLocationValid(Vector2 screenPoint, Camera eventCamera)
		{
			//IL_010f: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_007a: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			if (alphaHitTestMinimumThreshold <= 0f)
			{
				return true;
			}
			if (alphaHitTestMinimumThreshold > 1f)
			{
				return false;
			}
			if ((Object)(object)activeSprite == (Object)null)
			{
				return true;
			}
			Vector2 local = default(Vector2);
			if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(base.rectTransform, screenPoint, eventCamera, ref local))
			{
				return false;
			}
			Rect pixelAdjustedRect = GetPixelAdjustedRect();
			local.x += base.rectTransform.pivot.x * ((Rect)(ref pixelAdjustedRect)).width;
			local.y += base.rectTransform.pivot.y * ((Rect)(ref pixelAdjustedRect)).height;
			local = MapCoordinate(local, pixelAdjustedRect);
			Rect textureRect = activeSprite.textureRect;
			float num = (((Rect)(ref textureRect)).x + local.x) / (float)((Texture)activeSprite.texture).width;
			float num2 = (((Rect)(ref textureRect)).y + local.y) / (float)((Texture)activeSprite.texture).height;
			try
			{
				return activeSprite.texture.GetPixelBilinear(num, num2).a >= alphaHitTestMinimumThreshold;
			}
			catch (UnityException ex)
			{
				UnityException ex2 = ex;
				Debug.LogError((object)("Using alphaHitTestMinimumThreshold greater than 0 on Image whose sprite texture cannot be read. " + ((Exception)(object)ex2).Message + " Also make sure to disable sprite packing for this sprite."), (Object)(object)this);
				return true;
			}
		}

		private Vector2 MapCoordinate(Vector2 local, Rect rect)
		{
			//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_001d: 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_0049: 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_005a: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			Rect rect2 = activeSprite.rect;
			if (type == Type.Simple || type == Type.Filled)
			{
				return new Vector2(local.x * ((Rect)(ref rect2)).width / ((Rect)(ref rect)).width, local.y * ((Rect)(ref rect2)).height / ((Rect)(ref rect)).height);
			}
			Vector4 border = activeSprite.border;
			Vector4 adjustedBorders = GetAdjustedBorders(border / pixelsPerUnit, rect);
			for (int i = 0; i < 2; i++)
			{
				if (!(((Vector2)(ref local))[i] <= ((Vector4)(ref adjustedBorders))[i]))
				{
					Vector2 size = ((Rect)(ref rect)).size;
					if (((Vector2)(ref size))[i] - ((Vector2)(ref local))[i] <= ((Vector4)(ref adjustedBorders))[i + 2])
					{
						ref Vector2 reference = ref local;
						int num = i;
						ref Vector2 reference2 = ref reference;
						int num2 = num;
						float num3 = ((Vector2)(ref reference))[num];
						size = ((Rect)(ref rect)).size;
						float num4 = ((Vector2)(ref size))[i];
						size = ((Rect)(ref rect2)).size;
						((Vector2)(ref reference2))[num2] = num3 - (num4 - ((Vector2)(ref size))[i]);
					}
					else if (type == Type.Sliced)
					{
						float num5 = ((Vector4)(ref adjustedBorders))[i];
						size = ((Rect)(ref rect)).size;
						float num6 = Mathf.InverseLerp(num5, ((Vector2)(ref size))[i] - ((Vector4)(ref adjustedBorders))[i + 2], ((Vector2)(ref local))[i]);
						int num7 = i;
						float num8 = ((Vector4)(ref border))[i];
						size = ((Rect)(ref rect2)).size;
						((Vector2)(ref local))[num7] = Mathf.Lerp(num8, ((Vector2)(ref size))[i] - ((Vector4)(ref border))[i + 2], num6);
					}
					else
					{
						ref Vector2 reference = ref local;
						int num = i;
						((Vector2)(ref reference))[num] = ((Vector2)(ref reference))[num] - ((Vector4)(ref adjustedBorders))[i];
						int num9 = i;
						float num10 = ((Vector2)(ref local))[i];
						size = ((Rect)(ref rect2)).size;
						((Vector2)(ref local))[num9] = Mathf.Repeat(num10, ((Vector2)(ref size))[i] - ((Vector4)(ref border))[i] - ((Vector4)(ref border))[i + 2]);
						reference = ref local;
						num = i;
						((Vector2)(ref reference))[num] = ((Vector2)(ref reference))[num] + ((Vector4)(ref border))[i];
					}
				}
			}
			return local;
		}

		private static void RebuildImage(SpriteAtlas spriteAtlas)
		{
			for (int num = m_TrackedTexturelessImages.Count - 1; num >= 0; num--)
			{
				Image image = m_TrackedTexturelessImages[num];
				if ((Object)null != (Object)(object)image.activeSprite && spriteAtlas.CanBindTo(image.activeSprite))
				{
					image.SetAllDirty();
					m_TrackedTexturelessImages.RemoveAt(num);
				}
			}
		}

		private static void TrackImage(Image g)
		{
			if (!s_Initialized)
			{
				SpriteAtlasManager.atlasRegistered += RebuildImage;
				s_Initialized = true;
			}
			m_TrackedTexturelessImages.Add(g);
		}

		private static void UnTrackImage(Image g)
		{
			m_TrackedTexturelessImages.Remove(g);
		}

		protected override void OnDidApplyAnimationProperties()
		{
			SetMaterialDirty();
			SetVerticesDirty();
			SetRaycastDirty();
		}
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[Obsolete("Not supported anymore.", true)]
	public interface IMask
	{
		RectTransform rectTransform { get; }

		bool Enabled();
	}
	public interface IMaskable
	{
		void RecalculateMasking();
	}
	[AddComponentMenu("UI/Legacy/Input Field", 103)]
	public class InputField : Selectable, IUpdateSelectedHandler, IEventSystemHandler, IBeginDragHandler, IDragHandler, IEndDragHandler, IPointerClickHandler, ISubmitHandler, ICanvasElement, ILayoutElement
	{
		public enum ContentType
		{
			Standard,
			Autocorrected,
			IntegerNumber,
			DecimalNumber,
			Alphanumeric,
			Name,
			EmailAddress,
			Password,
			Pin,
			Custom
		}

		public enum InputType
		{
			Standard,
			AutoCorrect,
			Password
		}

		public enum CharacterValidation
		{
			None,
			Integer,
			Decimal,
			Alphanumeric,
			Name,
			EmailAddress
		}

		public enum LineType
		{
			SingleLine,
			MultiLineSubmit,
			MultiLineNewline
		}

		public delegate char OnValidateInput(string text, int charIndex, char addedChar);

		[Serializable]
		public class SubmitEvent : UnityEvent<string>
		{
		}

		[Serializable]
		public class EndEditEvent : UnityEvent<string>
		{
		}

		[Serializable]
		public class OnChangeEvent : UnityEvent<string>
		{
		}

		protected enum EditState
		{
			Continue,
			Finish
		}

		protected TouchScreenKeyboard m_Keyboard;

		private static readonly char[] kSeparators = new char[6] { ' ', '.', ',', '\t', '\r', '\n' };

		private static bool s_IsQuestDevice = false;

		[SerializeField]
		[FormerlySerializedAs("text")]
		protected Text m_TextComponent;

		[SerializeField]
		protected Graphic m_Placeholder;

		[SerializeField]
		private ContentType m_ContentType;

		[FormerlySerializedAs("inputType")]
		[SerializeField]
		private InputType m_InputType;

		[FormerlySerializedAs("asteriskChar")]
		[SerializeField]
		private char m_AsteriskChar = '*';

		[FormerlySerializedAs("keyboardType")]
		[SerializeField]
		private TouchScreenKeyboardType m_KeyboardType;

		[SerializeField]
		private LineType m_LineType;

		[FormerlySerializedAs("hideMobileInput")]
		[SerializeField]
		private bool m_HideMobileInput;

		[FormerlySerializedAs("validation")]
		[SerializeField]
		private CharacterValidation m_CharacterValidation;

		[FormerlySerializedAs("characterLimit")]
		[SerializeField]
		private int m_CharacterLimit;

		[FormerlySerializedAs("onSubmit")]
		[FormerlySerializedAs("m_OnSubmit")]
		[FormerlySerializedAs("m_EndEdit")]
		[FormerlySerializedAs("m_OnEndEdit")]
		[SerializeField]
		private SubmitEvent m_OnSubmit = new SubmitEvent();

		[SerializeField]
		private EndEditEvent m_OnDidEndEdit = new EndEditEvent();

		[FormerlySerializedAs("onValueChange")]
		[FormerlySerializedAs("m_OnValueChange")]
		[SerializeField]
		private OnChangeEvent m_OnValueChanged = new OnChangeEvent();

		[FormerlySerializedAs("onValidateInput")]
		[SerializeField]
		private OnValidateInput m_OnValidateInput;

		[FormerlySerializedAs("selectionColor")]
		[SerializeField]
		private Color m_CaretColor = new Color(10f / 51f, 10f / 51f, 10f / 51f, 1f);

		[SerializeField]
		private bool m_CustomCaretColor;

		[SerializeField]
		private Color m_SelectionColor = new Color(56f / 85f, 0.80784315f, 1f, 64f / 85f);

		[SerializeField]
		[Multiline]
		[FormerlySerializedAs("mValue")]
		protected string m_Text = string.Empty;

		[SerializeField]
		[Range(0f, 4f)]
		private float m_CaretBlinkRate = 0.85f;

		[SerializeField]
		[Range(1f, 5f)]
		private int m_CaretWidth = 1;

		[SerializeField]
		private bool m_ReadOnly;

		[SerializeField]
		private bool m_ShouldActivateOnSelect = true;

		protected int m_CaretPosition;

		protected int m_CaretSelectPosition;

		private RectTransform caretRectTrans;

		protected UIVertex[] m_CursorVerts;

		private TextGenerator m_InputTextCache;

		private CanvasRenderer m_CachedInputRenderer;

		private bool m_PreventFontCallback;

		[NonSerialized]
		protected Mesh m_Mesh;

		private bool m_AllowInput;

		private bool m_ShouldActivateNextUpdate;

		private bool m_UpdateDrag;

		private bool m_DragPositionOutOfBounds;

		private const float kHScrollSpeed = 0.05f;

		private const float kVScrollSpeed = 0.1f;

		protected bool m_CaretVisible;

		private Coroutine m_BlinkCoroutine;

		private float m_BlinkStartTime;

		protected int m_DrawStart;

		protected int m_DrawEnd;

		private Coroutine m_DragCoroutine;

		private string m_OriginalText = "";

		private bool m_WasCanceled;

		private bool m_HasDoneFocusTransition;

		private WaitForSecondsRealtime m_WaitForSecondsRealtime;

		private bool m_TouchKeyboardAllowsInPlaceEditing;

		private bool m_IsCompositionActive;

		private const string kEmailSpecialCharacters = "!#$%&'*+-/=?^_`{|}~";

		private const string kOculusQuestDeviceModel = "Oculus Quest";

		private Event m_ProcessingEvent = new Event();

		private const int k_MaxTextLength = 16382;

		private BaseInput input
		{
			get
			{
				if (Object.op_Implicit((Object)(object)EventSystem.current) && Object.op_Implicit((Object)(object)EventSystem.current.currentInputModule))
				{
					return EventSystem.current.currentInputModule.input;
				}
				return null;
			}
		}

		private string compositionString
		{
			get
			{
				if (!((Object)(object)input != (Object)null))
				{
					return Input.compositionString;
				}
				return input.compositionString;
			}
		}

		protected Mesh mesh
		{
			get
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				if ((Object)(object)m_Mesh == (Object)null)
				{
					m_Mesh = new Mesh();
				}
				return m_Mesh;
			}
		}

		protected TextGenerator cachedInputTextGenerator
		{
			get
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Expected O, but got Unknown
				if (m_InputTextCache == null)
				{
					m_InputTextCache = new TextGenerator();
				}
				return m_InputTextCache;
			}
		}

		public bool shouldHideMobileInput
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//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_0008: Invalid comparison between Unknown and I4
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Invalid comparison between Unknown and I4
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Invalid comparison between Unknown and I4
				RuntimePlatform platform = Application.platform;
				if ((int)platform == 8 || (int)platform == 11 || (int)platform == 31)
				{
					return m_HideMobileInput;
				}
				return true;
			}
			set
			{
				SetPropertyUtility.SetStruct(ref m_HideMobileInput, value);
			}
		}

		public virtual bool shouldActivateOnSelect
		{
			get
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Invalid comparison between Unknown and I4
				if (m_ShouldActivateOnSelect)
				{
					return (int)Application.platform != 31;
				}
				return false;
			}
			set
			{
				m_ShouldActivateOnSelect = value;
			}
		}

		public string text
		{
			get
			{
				return m_Text;
			}
			set
			{
				SetText(value);
			}
		}

		public bool isFocused => m_AllowInput;

		public float caretBlinkRate
		{
			get
			{
				return m_CaretBlinkRate;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_CaretBlinkRate, value) && m_AllowInput)
				{
					SetCaretActive();
				}
			}
		}

		public int caretWidth
		{
			get
			{
				return m_CaretWidth;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_CaretWidth, value))
				{
					MarkGeometryAsDirty();
				}
			}
		}

		public Text textComponent
		{
			get
			{
				return m_TextComponent;
			}
			set
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected O, but got Unknown
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Expected O, but got Unknown
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Expected O, but got Unknown
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected O, but got Unknown
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Expected O, but got Unknown
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Expected O, but got Unknown
				if ((Object)(object)m_TextComponent != (Object)null)
				{
					m_TextComponent.UnregisterDirtyVerticesCallback(new UnityAction(MarkGeometryAsDirty));
					m_TextComponent.UnregisterDirtyVerticesCallback(new UnityAction(UpdateLabel));
					m_TextComponent.UnregisterDirtyMaterialCallback(new UnityAction(UpdateCaretMaterial));
				}
				if (SetPropertyUtility.SetClass(ref m_TextComponent, value))
				{
					EnforceTextHOverflow();
					if ((Object)(object)m_TextComponent != (Object)null)
					{
						m_TextComponent.RegisterDirtyVerticesCallback(new UnityAction(MarkGeometryAsDirty));
						m_TextComponent.RegisterDirtyVerticesCallback(new UnityAction(UpdateLabel));
						m_TextComponent.RegisterDirtyMaterialCallback(new UnityAction(UpdateCaretMaterial));
					}
				}
			}
		}

		public Graphic placeholder
		{
			get
			{
				return m_Placeholder;
			}
			set
			{
				SetPropertyUtility.SetClass(ref m_Placeholder, value);
			}
		}

		public Color caretColor
		{
			get
			{
				//IL_0015: 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)
				if (!customCaretColor)
				{
					return textComponent.color;
				}
				return m_CaretColor;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				if (SetPropertyUtility.SetColor(ref m_CaretColor, value))
				{
					MarkGeometryAsDirty();
				}
			}
		}

		public bool customCaretColor
		{
			get
			{
				return m_CustomCaretColor;
			}
			set
			{
				if (m_CustomCaretColor != value)
				{
					m_CustomCaretColor = value;
					MarkGeometryAsDirty();
				}
			}
		}

		public Color selectionColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_SelectionColor;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				if (SetPropertyUtility.SetColor(ref m_SelectionColor, value))
				{
					MarkGeometryAsDirty();
				}
			}
		}

		public EndEditEvent onEndEdit
		{
			get
			{
				return m_OnDidEndEdit;
			}
			set
			{
				SetPropertyUtility.SetClass(ref m_OnDidEndEdit, value);
			}
		}

		public SubmitEvent onSubmit
		{
			get
			{
				return m_OnSubmit;
			}
			set
			{
				SetPropertyUtility.SetClass(ref m_OnSubmit, value);
			}
		}

		[Obsolete("onValueChange has been renamed to onValueChanged")]
		public OnChangeEvent onValueChange
		{
			get
			{
				return onValueChanged;
			}
			set
			{
				onValueChanged = value;
			}
		}

		public OnChangeEvent onValueChanged
		{
			get
			{
				return m_OnValueChanged;
			}
			set
			{
				SetPropertyUtility.SetClass(ref m_OnValueChanged, value);
			}
		}

		public OnValidateInput onValidateInput
		{
			get
			{
				return m_OnValidateInput;
			}
			set
			{
				SetPropertyUtility.SetClass(ref m_OnValidateInput, value);
			}
		}

		public int characterLimit
		{
			get
			{
				return m_CharacterLimit;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_CharacterLimit, Math.Max(0, value)))
				{
					UpdateLabel();
					if (m_Keyboard != null)
					{
						m_Keyboard.characterLimit = value;
					}
				}
			}
		}

		public ContentType contentType
		{
			get
			{
				return m_ContentType;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_ContentType, value))
				{
					EnforceContentType();
				}
			}
		}

		public LineType lineType
		{
			get
			{
				return m_LineType;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_LineType, value))
				{
					SetToCustomIfContentTypeIsNot(ContentType.Standard, ContentType.Autocorrected);
					EnforceTextHOverflow();
				}
			}
		}

		public InputType inputType
		{
			get
			{
				return m_InputType;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_InputType, value))
				{
					SetToCustom();
				}
			}
		}

		public TouchScreenKeyboard touchScreenKeyboard => m_Keyboard;

		public TouchScreenKeyboardType keyboardType
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_KeyboardType;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				if (SetPropertyUtility.SetStruct<TouchScreenKeyboardType>(ref m_KeyboardType, value))
				{
					SetToCustom();
				}
			}
		}

		public CharacterValidation characterValidation
		{
			get
			{
				return m_CharacterValidation;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_CharacterValidation, value))
				{
					SetToCustom();
				}
			}
		}

		public bool readOnly
		{
			get
			{
				return m_ReadOnly;
			}
			set
			{
				m_ReadOnly = value;
			}
		}

		public bool multiLine
		{
			get
			{
				if (m_LineType != LineType.MultiLineNewline)
				{
					return lineType == LineType.MultiLineSubmit;
				}
				return true;
			}
		}

		public char asteriskChar
		{
			get
			{
				return m_AsteriskChar;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_AsteriskChar, value))
				{
					UpdateLabel();
				}
			}
		}

		public bool wasCanceled => m_WasCanceled;

		protected int caretPositionInternal
		{
			get
			{
				return m_CaretPosition + compositionString.Length;
			}
			set
			{
				m_CaretPosition = value;
				ClampPos(ref m_CaretPosition);
			}
		}

		protected int caretSelectPositionInternal
		{
			get
			{
				return m_CaretSelectPosition + compositionString.Length;
			}
			set
			{
				m_CaretSelectPosition = value;
				ClampPos(ref m_CaretSelectPosition);
			}
		}

		private bool hasSelection => caretPositionInternal != caretSelectPositionInternal;

		public int caretPosition
		{
			get
			{
				return m_CaretSelectPosition + compositionString.Length;
			}
			set
			{
				selectionAnchorPosition = value;
				selectionFocusPosition = value;
			}
		}

		public int selectionAnchorPosition
		{
			get
			{
				return m_CaretPosition + compositionString.Length;
			}
			set
			{
				if (compositionString.Length == 0)
				{
					m_CaretPosition = value;
					ClampPos(ref m_CaretPosition);
				}
			}
		}

		public int selectionFocusPosition
		{
			get
			{
				return m_CaretSelectPosition + compositionString.Length;
			}
			set
			{
				if (compositionString.Length == 0)
				{
					m_CaretSelectPosition = value;
					ClampPos(ref m_CaretSelectPosition);
				}
			}
		}

		private static string clipboard
		{
			get
			{
				return GUIUtility.systemCopyBuffer;
			}
			set
			{
				GUIUtility.systemCopyBuffer = value;
			}
		}

		public virtual float minWidth => 0f;

		public virtual float preferredWidth
		{
			get
			{
				//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_0024: 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)
				if ((Object)(object)textComponent == (Object)null)
				{
					return 0f;
				}
				TextGenerationSettings generationSettings = textComponent.GetGenerationSettings(Vector2.zero);
				return textComponent.cachedTextGeneratorForLayout.GetPreferredWidth(m_Text, generationSettings) / textComponent.pixelsPerUnit;
			}
		}

		public virtual float flexibleWidth => -1f;

		public virtual float minHeight => 0f;

		public virtual float preferredHeight
		{
			get
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: 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_0046: 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)
				if ((Object)(object)textComponent == (Object)null)
				{
					return 0f;
				}
				Text obj = textComponent;
				Rect rect = textComponent.rectTransform.rect;
				TextGenerationSettings generationSettings = obj.GetGenerationSettings(new Vector2(((Rect)(ref rect)).size.x, 0f));
				return textComponent.cachedTextGeneratorForLayout.GetPreferredHeight(m_Text, generationSettings) / textComponent.pixelsPerUnit;
			}
		}

		public virtual float flexibleHeight => -1f;

		public virtual int layoutPriority => 1;

		protected InputField()
		{
			//IL_003e: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			EnforceTextHOverflow();
		}

		public void SetTextWithoutNotify(string input)
		{
			SetText(input, sendCallback: false);
		}

		private void SetText(string value, bool sendCallback = true)
		{
			if (text == value)
			{
				return;
			}
			if (value == null)
			{
				value = "";
			}
			value = value.Replace("\0", string.Empty);
			if (m_LineType == LineType.SingleLine)
			{
				value = value.Replace("\n", "").Replace("\t", "");
			}
			if (this.onValidateInput != null || characterValidation != CharacterValidation.None)
			{
				m_Text = "";
				OnValidateInput onValidateInput = this.onValidateInput ?? new OnValidateInput(Validate);
				m_CaretPosition = (m_CaretSelectPosition = value.Length);
				int num = ((characterLimit > 0) ? Math.Min(characterLimit, value.Length) : value.Length);
				for (int i = 0; i < num; i++)
				{
					char c = onValidateInput(m_Text, m_Text.Length, value[i]);
					if (c != 0)
					{
						m_Text += c;
					}
				}
			}
			else
			{
				m_Text = ((characterLimit > 0 && value.Length > characterLimit) ? value.Substring(0, characterLimit) : value);
			}
			if (m_Keyboard != null)
			{
				m_Keyboard.text = m_Text;
			}
			if (m_CaretPosition > m_Text.Length)
			{
				m_CaretPosition = (m_CaretSelectPosition = m_Text.Length);
			}
			else if (m_CaretSelectPosition > m_Text.Length)
			{
				m_CaretSelectPosition = m_Text.Length;
			}
			if (sendCallback)
			{
				SendOnValueChanged();
			}
			UpdateLabel();
		}

		protected void ClampPos(ref int pos)
		{
			if (pos < 0)
			{
				pos = 0;
			}
			else if (pos > text.Length)
			{
				pos = text.Length;
			}
		}

		protected override void OnEnable()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			base.OnEnable();
			if (m_Text == null)
			{
				m_Text = string.Empty;
			}
			m_DrawStart = 0;
			m_DrawEnd = m_Text.Length;
			if ((Object)(object)m_CachedInputRenderer != (Object)null)
			{
				m_CachedInputRenderer.SetMaterial(m_TextComponent.GetModifiedMaterial(Graphic.defaultGraphicMaterial), (Texture)(object)Texture2D.whiteTexture);
			}
			if ((Object)(object)m_TextComponent != (Object)null)
			{
				m_TextComponent.RegisterDirtyVerticesCallback(new UnityAction(MarkGeometryAsDirty));
				m_TextComponent.RegisterDirtyVerticesCallback(new UnityAction(UpdateLabel));
				m_TextComponent.RegisterDirtyMaterialCallback(new UnityAction(UpdateCaretMaterial));
				UpdateLabel();
			}
		}

		protected override void OnDisable()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			m_BlinkCoroutine = null;
			DeactivateInputField();
			if ((Object)(object)m_TextComponent != (Object)null)
			{
				m_TextComponent.UnregisterDirtyVerticesCallback(new UnityAction(MarkGeometryAsDirty));
				m_TextComponent.UnregisterDirtyVerticesCallback(new UnityAction(UpdateLabel));
				m_TextComponent.UnregisterDirtyMaterialCallback(new UnityAction(UpdateCaretMaterial));
			}
			CanvasUpdateRegistry.DisableCanvasElementForRebuild(this);
			if ((Object)(object)m_CachedInputRenderer != (Object)null)
			{
				m_CachedInputRenderer.Clear();
			}
			if ((Object)(object)m_Mesh != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)m_Mesh);
			}
			m_Mesh = null;
			base.OnDisable();
		}

		protected override void OnDestroy()
		{
			CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild(this);
			base.OnDestroy();
		}

		private IEnumerator CaretBlink()
		{
			m_CaretVisible = true;
			yield return null;
			while (isFocused && m_CaretBlinkRate > 0f)
			{
				float num = 1f / m_CaretBlinkRate;
				bool flag = (Time.unscaledTime - m_BlinkStartTime) % num < num / 2f;
				if (m_CaretVisible != flag)
				{
					m_CaretVisible = flag;
					if (!hasSelection)
					{
						MarkGeometryAsDirty();
					}
				}
				yield return null;
			}
			m_BlinkCoroutine = null;
		}

		private void SetCaretVisible()
		{
			if (m_AllowInput)
			{
				m_CaretVisible = true;
				m_BlinkStartTime = Time.unscaledTime;
				SetCaretActive();
			}
		}

		private void SetCaretActive()
		{
			if (!m_AllowInput)
			{
				return;
			}
			if (m_CaretBlinkRate > 0f)
			{
				if (m_BlinkCoroutine == null)
				{
					m_BlinkCoroutine = ((MonoBehaviour)this).StartCoroutine(CaretBlink());
				}
			}
			else
			{
				m_CaretVisible = true;
			}
		}

		private void UpdateCaretMaterial()
		{
			if ((Object)(object)m_TextComponent != (Object)null && (Object)(object)m_CachedInputRenderer != (Object)null)
			{
				m_CachedInputRenderer.SetMaterial(m_TextComponent.GetModifiedMaterial(Graphic.defaultGraphicMaterial), (Texture)(object)Texture2D.whiteTexture);
			}
		}

		protected void OnFocus()
		{
			SelectAll();
		}

		protected void SelectAll()
		{
			caretPositionInternal = text.Length;
			caretSelectPositionInternal = 0;
		}

		public void MoveTextEnd(bool shift)
		{
			int length = text.Length;
			if (shift)
			{
				caretSelectPositionInternal = length;
			}
			else
			{
				caretPositionInternal = length;
				caretSelectPositionInternal = caretPositionInternal;
			}
			UpdateLabel();
		}

		public void MoveTextStart(bool shift)
		{
			int num = 0;
			if (shift)
			{
				caretSelectPositionInternal = num;
			}
			else
			{
				caretPositionInternal = num;
				caretSelectPositionInternal = caretPositionInternal;
			}
			UpdateLabel();
		}

		private bool TouchScreenKeyboardShouldBeUsed()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)Application.platform == 11)
			{
				if (s_IsQuestDevice)
				{
					return TouchScreenKeyboard.isSupported;
				}
				return !TouchScreenKeyboard.isInPlaceEditingAllowed;
			}
			return TouchScreenKeyboard.isSupported;
		}

		private bool InPlaceEditing()
		{
			if (TouchScreenKeyboard.isSupported)
			{
				return m_TouchKeyboardAllowsInPlaceEditing;
			}
			return true;
		}

		private bool InPlaceEditingChanged()
		{
			if (!s_IsQuestDevice)
			{
				return m_TouchKeyboardAllowsInPlaceEditing != TouchScreenKeyboard.isInPlaceEditingAllowed;
			}
			return false;
		}

		private void UpdateCaretFromKeyboard()
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			RangeInt selection = m_Keyboard.selection;
			int start = selection.start;
			int end = ((RangeInt)(ref selection)).end;
			bool flag = false;
			if (caretPositionInternal != start)
			{
				flag = true;
				caretPositionInternal = start;
			}
			if (caretSelectPositionInternal != end)
			{
				caretSelectPositionInternal = end;
				flag = true;
			}
			if (flag)
			{
				m_BlinkStartTime = Time.unscaledTime;
				UpdateLabel();
			}
		}

		protected virtual void LateUpdate()
		{
			//IL_009d: 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_00d1: Invalid comparison between Unknown and I4
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Invalid comparison between Unknown and I4
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Invalid comparison between Unknown and I4
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Invalid comparison between Unknown and I4
			if (m_ShouldActivateNextUpdate)
			{
				if (!isFocused)
				{
					ActivateInputFieldInternal();
					m_ShouldActivateNextUpdate = false;
					return;
				}
				m_ShouldActivateNextUpdate = false;
			}
			AssignPositioningIfNeeded();
			if (isFocused && InPlaceEditingChanged())
			{
				if ((Object)(object)m_CachedInputRenderer != (Object)null)
				{
					using (VertexHelper vertexHelper = new VertexHelper())
					{
						vertexHelper.FillMesh(mesh);
					}
					m_CachedInputRenderer.SetMesh(mesh);
				}
				DeactivateInputField();
			}
			if (!isFocused || InPlaceEditing())
			{
				return;
			}
			if (m_Keyboard == null || (int)m_Keyboard.status != 0)
			{
				if (m_Keyboard != null)
				{
					if (!m_ReadOnly)
					{
						this.text = m_Keyboard.text;
					}
					if ((int)m_Keyboard.status == 2)
					{
						m_WasCanceled = true;
					}
					else if ((int)m_Keyboard.status == 1)
					{
						SendOnSubmit();
					}
				}
				OnDeselect(null);
				return;
			}
			string text = m_Keyboard.text;
			if (m_Text != text)
			{
				if (m_ReadOnly)
				{
					m_Keyboard.text = m_Text;
				}
				else
				{
					m_Text = "";
					for (int i = 0; i < text.Length; i++)
					{
						char c = text[i];
						if (c == '\r' || c == '\u0003')
						{
							c = '\n';
						}
						if (onValidateInput != null)
						{
							c = onValidateInput(m_Text, m_Text.Length, c);
						}
						else if (characterValidation != CharacterValidation.None)
						{
							c = Validate(m_Text, m_Text.Length, c);
						}
						if (lineType == LineType.MultiLineSubmit && c == '\n')
						{
							m_Keyboard.text = m_Text;
							SendOnSubmit();
							OnDeselect(null);
							return;
						}
						if (c != 0)
						{
							m_Text += c;
						}
					}
					if (characterLimit > 0 && m_Text.Length > characterLimit)
					{
						m_Text = m_Text.Substring(0, characterLimit);
					}
					if (m_Keyboard.canGetSelection)
					{
						UpdateCaretFromKeyboard();
					}
					else
					{
						int num = (caretSelectPositionInternal = m_Text.Length);
						caretPositionInternal = num;
					}
					if (m_Text != text)
					{
						m_Keyboard.text = m_Text;
					}
					SendOnValueChangedAndUpdateLabel();
				}
			}
			else if (m_HideMobileInput && m_Keyboard.canSetSelection)
			{
				int num2 = Mathf.Min(caretSelectPositionInternal, caretPositionInternal);
				int num3 = Mathf.Abs(caretSelectPositionInternal - caretPositionInternal);
				m_Keyboard.selection = new RangeInt(num2, num3);
			}
			else if (m_Keyboard.canGetSelection && !m_HideMobileInput)
			{
				UpdateCaretFromKeyboard();
			}
			if ((int)m_Keyboard.status != 0)
			{
				if ((int)m_Keyboard.status == 2)
				{
					m_WasCanceled = true;
				}
				else if ((int)m_Keyboard.status == 1)
				{
					SendOnSubmit();
				}
				OnDeselect(null);
			}
		}

		[Obsolete("This function is no longer used. Please use RectTransformUtility.ScreenPointToLocalPointInRectangle() instead.")]
		public Vector2 ScreenToLocal(Vector2 screen)
		{
			//IL_0017: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			Canvas canvas = m_TextComponent.canvas;
			if ((Object)(object)canvas == (Object)null)
			{
				return screen;
			}
			Vector3 val = Vector3.zero;
			if ((int)canvas.renderMode == 0)
			{
				val = ((Component)m_TextComponent).transform.InverseTransformPoint(Vector2.op_Implicit(screen));
			}
			else if ((Object)(object)canvas.worldCamera != (Object)null)
			{
				Ray val2 = canvas.worldCamera.ScreenPointToRay(Vector2.op_Implicit(screen));
				Plane val3 = default(Plane);
				((Plane)(ref val3))..ctor(((Component)m_TextComponent).transform.forward, ((Component)m_TextComponent).transform.position);
				float num = default(float);
				((Plane)(ref val3)).Raycast(val2, ref num);
				val = ((Component)m_TextComponent).transform.InverseTransformPoint(((Ray)(ref val2)).GetPoint(num));
			}
			return new Vector2(val.x, val.y);
		}

		private int GetUnclampedCharacterLineFromPosition(Vector2 pos, TextGenerator generator)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!multiLine)
			{
				return 0;
			}
			float num = pos.y * m_TextComponent.pixelsPerUnit;
			float num2 = 0f;
			for (int i = 0; i < generator.lineCount; i++)
			{
				float topY = generator.lines[i].topY;
				float num3 = topY - (float)generator.lines[i].height;
				if (num > topY)
				{
					float num4 = topY - num2;
					if (num > topY - 0.5f * num4)
					{
						return i - 1;
					}
					return i;
				}
				if (num > num3)
				{
					return i;
				}
				num2 = num3;
			}
			return generator.lineCount;
		}

		protected int GetCharacterIndexFromPosition(Vector2 pos)
		{
			//IL_0017: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			TextGenerator cachedTextGenerator = m_TextComponent.cachedTextGenerator;
			if (cachedTextGenerator.lineCount == 0)
			{
				return 0;
			}
			int unclampedCharacterLineFromPosition = GetUnclampedCharacterLineFromPosition(pos, cachedTextGenerator);
			if (unclampedCharacterLineFromPosition < 0)
			{
				return 0;
			}
			if (unclampedCharacterLineFromPosition >= cachedTextGenerator.lineCount)
			{
				return cachedTextGenerator.characterCountVisible;
			}
			int startCharIdx = cachedTextGenerator.lines[unclampedCharacterLineFromPosition].startCharIdx;
			int lineEndPosition = GetLineEndPosition(cachedTextGenerator, unclampedCharacterLineFromPosition);
			for (int i = startCharIdx; i < lineEndPosition && i < cachedTextGenerator.characterCountVisible; i++)
			{
				UICharInfo val = cachedTextGenerator.characters[i];
				Vector2 val2 = val.cursorPos / m_TextComponent.pixelsPerUnit;
				float num = pos.x - val2.x;
				float num2 = val2.x + val.charWidth / m_TextComponent.pixelsPerUnit - pos.x;
				if (num < num2)
				{
					return i;
				}
			}
			return lineEndPosition;
		}

		private bool MayDrag(PointerEventData eventData)
		{
			if (IsActive() && IsInteractable() && eventData.button == PointerEventData.InputButton.Left && (Object)(object)m_TextComponent != (Object)null)
			{
				if (!InPlaceEditing())
				{
					return m_HideMobileInput;
				}
				return true;
			}
			return false;
		}

		public virtual void OnBeginDrag(PointerEventData eventData)
		{
			if (MayDrag(eventData))
			{
				m_UpdateDrag = true;
			}
		}

		public virtual void OnDrag(PointerEventData eventData)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!MayDrag(eventData))
			{
				return;
			}
			Vector2 position = Vector2.zero;
			if (MultipleDisplayUtilities.GetRelativeMousePositionForDrag(eventData, ref position))
			{
				Vector2 pos = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(textComponent.rectTransform, position, eventData.pressEventCamera, ref pos);
				caretSelectPositionInternal = GetCharacterIndexFromPosition(pos) + m_DrawStart;
				MarkGeometryAsDirty();
				m_DragPositionOutOfBounds = !RectTransformUtility.RectangleContainsScreenPoint(textComponent.rectTransform, eventData.position, eventData.pressEventCamera);
				if (m_DragPositionOutOfBounds && m_DragCoroutine == null)
				{
					m_DragCoroutine = ((MonoBehaviour)this).StartCoroutine(MouseDragOutsideRect(eventData));
				}
				eventData.Use();
			}
		}

		private IEnumerator MouseDragOutsideRect(PointerEventData eventData)
		{
			Vector2 val = default(Vector2);
			while (m_UpdateDrag && m_DragPositionOutOfBounds)
			{
				Vector2 position = Vector2.zero;
				if (!MultipleDisplayUtilities.GetRelativeMousePositionForDrag(eventData, ref position))
				{
					break;
				}
				RectTransformUtility.ScreenPointToLocalPointInRectangle(textComponent.rectTransform, position, eventData.pressEventCamera, ref val);
				Rect rect = textComponent.rectTransform.rect;
				if (multiLine)
				{
					if (val.y > ((Rect)(ref rect)).yMax)
					{
						MoveUp(shift: true, goToFirstChar: true);
					}
					else if (val.y < ((Rect)(ref rect)).yMin)
					{
						MoveDown(shift: true, goToLastChar: true);
					}
				}
				else if (val.x < ((Rect)(ref rect)).xMin)
				{
					MoveLeft(shift: true, ctrl: false);
				}
				else if (val.x > ((Rect)(ref rect)).xMax)
				{
					MoveRight(shift: true, ctrl: false);
				}
				UpdateLabel();
				float num = (multiLine ? 0.1f : 0.05f);
				if (m_WaitForSecondsRealtime == null)
				{
					m_WaitForSecondsRealtime = new WaitForSecondsRealtime(num);
				}
				else
				{
					m_WaitForSecondsRealtime.waitTime = num;
				}
				yield return m_WaitForSecondsRealtime;
			}
			m_DragCoroutine = null;
		}

		public virtual void OnEndDrag(PointerEventData eventData)
		{
			if (MayDrag(eventData))
			{
				m_UpdateDrag = false;
			}
		}

		public override void OnPointerDown(PointerEventData eventData)
		{
			//IL_0062: 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)
			if (!MayDrag(eventData))
			{
				return;
			}
			EventSystem.current.SetSelectedGameObject(((Component)this).gameObject, eventData);
			bool allowInput = m_AllowInput;
			base.OnPointerDown(eventData);
			if (!InPlaceEditing() && (m_Keyboard == null || !m_Keyboard.active))
			{
				OnSelect(eventData);
				return;
			}
			if (allowInput)
			{
				Vector2 pos = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(textComponent.rectTransform, eventData.pointerPressRaycast.screenPosition, eventData.pressEventCamera, ref pos);
				int num = (caretPositionInternal = GetCharacterIndexFromPosition(pos) + m_DrawStart);
				caretSelectPositionInternal = num;
			}
			UpdateLabel();
			eventData.Use();
		}

		protected EditState KeyPressed(Event evt)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_000f: 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_0013: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_0025: 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_0029: Invalid comparison between Unknown and I4
			//IL_004b: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Invalid comparison between Unknown and I4
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Invalid comparison between Unknown and I4
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Invalid comparison between Unknown and I4
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Invalid comparison between Unknown and I4
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Invalid comparison between Unknown and I4
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Invalid comparison between Unknown and I4
			//IL_00b7: 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_00e8: Expected I4, but got Unknown
			EventModifiers modifiers = evt.modifiers;
			bool flag = (((int)SystemInfo.operatingSystemFamily == 1) ? ((modifiers & 8) > 0) : ((modifiers & 2) > 0));
			bool flag2 = (modifiers & 1) > 0;
			bool flag3 = (modifiers & 4) > 0;
			bool flag4 = flag && !flag3 && !flag2;
			bool flag5 = flag2 && !flag && !flag3;
			KeyCode keyCode = evt.keyCode;
			if ((int)keyCode <= 97)
			{
				if ((int)keyCode <= 13)
				{
					if ((int)keyCode == 8)
					{
						Backspace();
						return EditState.Continue;
					}
					if ((int)keyCode == 13)
					{
						goto IL_01ff;
					}
				}
				else
				{
					if ((int)keyCode == 27)
					{
						m_WasCanceled = true;
						return EditState.Finish;
					}
					if ((int)keyCode == 97 && flag4)
					{
						SelectAll();
						return EditState.Continue;
					}
				}
			}
			else if ((int)keyCode <= 118)
			{
				if ((int)keyCode != 99)
				{
					if ((int)keyCode == 118 && flag4)
					{
						Append(clipboard);
						UpdateLabel();
						return EditState.Continue;
					}
				}
				else if (flag4)
				{
					if (inputType != InputType.Password)
					{
						clipboard = GetSelectedString();
					}
					else
					{
						clipboard = "";
					}
					return EditState.Continue;
				}
			}
			else if ((int)keyCode != 120)
			{
				if ((int)keyCode == 127)
				{
					ForwardSpace();
					return EditState.Continue;
				}
				switch (keyCode - 271)
				{
				case 7:
					MoveTextStart(flag2);
					return EditState.Continue;
				case 8:
					MoveTextEnd(flag2);
					return EditState.Continue;
				case 6:
					break;
				case 5:
					MoveLeft(flag2, flag);
					return EditState.Continue;
				case 4:
					MoveRight(flag2, flag);
					return EditState.Continue;
				case 2:
					MoveUp(flag2);
					return EditState.Continue;
				case 3:
					MoveDown(flag2);
					return EditState.Continue;
				case 0:
					goto IL_01ff;
				default:
					goto IL_0213;
				}
				if (flag4)
				{
					if (inputType != InputType.Password)
					{
						clipboard = GetSelectedString();
					}
					else
					{
						clipboard = "";
					}
					return EditState.Continue;
				}
				if (flag5)
				{
					Append(clipboard);
					UpdateLabel();
					return EditState.Continue;
				}
			}
			else if (flag4)
			{
				if (inputType != InputType.Password)
				{
					clipboard = GetSelectedString();
				}
				else
				{
					clipboard = "";
				}
				Delete();
				UpdateTouchKeyboardFromEditChanges();
				SendOnValueChangedAndUpdateLabel();
				return EditState.Continue;
			}
			goto IL_0213;
			IL_0213:
			char c = evt.character;
			if (!multiLine && (c == '\t' || c == '\r' || c == '\n'))
			{
				return EditState.Continue;
			}
			if (c == '\r' || c == '\u0003')
			{
				c = '\n';
			}
			if (IsValidChar(c))
			{
				Append(c);
			}
			if (c == '\0' && compositionString.Length > 0)
			{
				UpdateLabel();
			}
			return EditState.Continue;
			IL_01ff:
			if (lineType != LineType.MultiLineNewline)
			{
				return EditState.Finish;
			}
			goto IL_0213;
		}

		private bool IsValidChar(char c)
		{
			switch (c)
			{
			case '\0':
				return false;
			case '\u007f':
				return false;
			case '\t':
			case '\n':
				return true;
			default:
				return m_TextComponent.font.HasCharacter(c);
			}
		}

		public void ProcessEvent(Event e)
		{
			KeyPressed(e);
		}

		public virtual void OnUpdateSelected(BaseEventData eventData)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_0080: 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_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_008b: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!isFocused)
			{
				return;
			}
			bool flag = false;
			while (Event.PopEvent(m_ProcessingEvent))
			{
				if ((int)m_ProcessingEvent.rawType == 4)
				{
					flag = true;
					if (m_IsCompositionActive && compositionString.Length == 0 && m_ProcessingEvent.character == '\0' && (int)m_ProcessingEvent.modifiers == 0)
					{
						continue;
					}
					if (KeyPressed(m_ProcessingEvent) == EditState.Finish)
					{
						if (!m_WasCanceled)
						{
							SendOnSubmit();
						}
						DeactivateInputField();
						continue;
					}
					UpdateLabel();
				}
				EventType type = m_ProcessingEvent.type;
				if (type - 13 <= 1 && m_ProcessingEvent.commandName == "SelectAll")
				{
					SelectAll();
					flag = true;
				}
			}
			if (flag)
			{
				UpdateLabel();
			}
			eventData.Use();
		}

		private string GetSelectedString()
		{
			if (!hasSelection)
			{
				return "";
			}
			int num = caretPositionInternal;
			int num2 = caretSelectPositionInternal;
			if (num > num2)
			{
				int num3 = num;
				num = num2;
				num2 = num3;
			}
			return text.Substring(num, num2 - num);
		}

		private int FindtNextWordBegin()
		{
			if (caretSelectPositionInternal + 1 >= text.Length)
			{
				return text.Length;
			}
			int num = text.IndexOfAny(kSeparators, caretSelectPositionInternal + 1);
			if (num == -1)
			{
				return text.Length;
			}
			return num + 1;
		}

		private void MoveRight(bool shift, bool ctrl)
		{
			int num;
			if (hasSelection && !shift)
			{
				num = (caretSelectPositionInternal = Mathf.Max(caretPositionInternal, caretSelectPositionInternal));
				caretPositionInternal = num;
				return;
			}
			int num3 = ((!ctrl) ? (caretSelectPositionInternal + 1) : FindtNextWordBegin());
			if (shift)
			{
				caretSelectPositionInternal = num3;
				return;
			}
			num = (caretPositionInternal = num3);
			caretSelectPositionInternal = num;
		}

		private int FindtPrevWordBegin()
		{
			if (caretSelectPositionInternal - 2 < 0)
			{
				return 0;
			}
			int num = text.LastIndexOfAny(kSeparators, caretSelectPositionInternal - 2);
			if (num == -1)
			{
				return 0;
			}
			return num + 1;
		}

		private void MoveLeft(bool shift, bool ctrl)
		{
			int num;
			if (hasSelection && !shift)
			{
				num = (caretSelectPositionInternal = Mathf.Min(caretPositionInternal, caretSelectPositionInternal));
				caretPositionInternal = num;
				return;
			}
			int num3 = ((!ctrl) ? (caretSelectPositionInternal - 1) : FindtPrevWordBegin());
			if (shift)
			{
				caretSelectPositionInternal = num3;
				return;
			}
			num = (caretPositionInternal = num3);
			caretSelectPositionInternal = num;
		}

		private int DetermineCharacterLine(int charPos, TextGenerator generator)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < generator.lineCount - 1; i++)
			{
				if (generator.lines[i + 1].startCharIdx > charPos)
				{
					return i;
				}
			}
			return generator.lineCount - 1;
		}

		private int LineUpCharacterPosition(int originalPos, bool goToFirstChar)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0080: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (originalPos >= cachedInputTextGenerator.characters.Count)
			{
				return 0;
			}
			UICharInfo val = cachedInputTextGenerator.characters[originalPos];
			int num = DetermineCharacterLine(originalPos, cachedInputTextGenerator);
			if (num <= 0)
			{
				if (!goToFirstChar)
				{
					return originalPos;
				}
				return 0;
			}
			int num2 = cachedInputTextGenerator.lines[num].startCharIdx - 1;
			for (int i = cachedInputTextGenerator.lines[num - 1].startCharIdx; i < num2; i++)
			{
				if (cachedInputTextGenerator.characters[i].cursorPos.x >= val.cursorPos.x)
				{
					return i;
				}
			}
			return num2;
		}

		private int LineDownCharacterPosition(int originalPos, bool goToLastChar)
		{
			//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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (originalPos >= cachedInputTextGenerator.characterCountVisible)
			{
				return text.Length;
			}
			UICharInfo val = cachedInputTextGenerator.characters[originalPos];
			int num = DetermineCharacterLine(originalPos, cachedInputTextGenerator);
			if (num + 1 >= cachedInputTextGenerator.lineCount)
			{
				if (!goToLastChar)
				{
					return originalPos;
				}
				return text.Length;
			}
			int lineEndPosition = GetLineEndPosition(cachedInputTextGenerator, num + 1);
			for (int i = cachedInputTextGenerator.lines[num + 1].startCharIdx; i < lineEndPosition; i++)
			{
				if (cachedInputTextGenerator.characters[i].cursorPos.x >= val.cursorPos.x)
				{
					return i;
				}
			}
			return lineEndPosition;
		}

		private void MoveDown(bool shift)
		{
			MoveDown(shift, goToLastChar: true);
		}

		private void MoveDown(bool shift, bool goToLastChar)
		{
			int num;
			if (hasSelection && !shift)
			{
				num = (caretSelectPositionInternal = Mathf.Max(caretPositionInternal, caretSelectPositionInternal));
				caretPositionInternal = num;
			}
			int num3 = (multiLine ? LineDownCharacterPosition(caretSelectPositionInternal, goToLastChar) : text.Length);
			if (shift)
			{
				caretSelectPositionInternal = num3;
				return;
			}
			num = (caretSelectPositionInternal = num3);
			caretPositionInternal = num;
		}

		private void MoveUp(bool shift)
		{
			MoveUp(shift, goToFirstChar: true);
		}

		private void MoveUp(bool shift, bool goToFirstChar)
		{
			int num;
			if (hasSelection && !shift)
			{
				num = (caretSelectPositionInternal = Mathf.Min(caretPositionInternal, caretSelectPositionInternal));
				caretPositionInternal = num;
			}
			int num3 = (multiLine ? LineUpCharacterPosition(caretSelectPositionInternal, goToFirstChar) : 0);
			if (shift)
			{
				caretSelectPositionInternal = num3;
				return;
			}
			num = (caretPositionInternal = num3);
			caretSelectPositionInternal = num;
		}

		private void Delete()
		{
			if (!m_ReadOnly && caretPositionInternal != caretSelectPositionInternal)
			{
				if (caretPositionInternal < caretSelectPositionInternal)
				{
					m_Text = text.Substring(0, caretPositionInternal) + text.Substring(caretSelectPositionInternal, text.Length - caretSelectPositionInternal);
					caretSelectPositionInternal = caretPositionInternal;
				}
				else
				{
					m_Text = text.Substring(0, caretSelectPositionInternal) + text.Substring(caretPositionInternal, text.Length - caretPositionInternal);
					caretPositionInternal = caretSelectPositionInternal;
				}
			}
		}

		private void ForwardSpace()
		{
			if (!m_ReadOnly)
			{
				if (hasSelection)
				{
					Delete();
					UpdateTouchKeyboardFromEditChanges();
					SendOnValueChangedAndUpdateLabel();
				}
				else if (caretPositionInternal < text.Length)
				{
					m_Text = text.Remove(caretPositionInternal, 1);
					UpdateTouchKeyboardFromEditChanges();
					SendOnValueChangedAndUpdateLabel();
				}
			}
		}

		private void Backspace()
		{
			if (!m_ReadOnly)
			{
				if (hasSelection)
				{
					Delete();
					UpdateTouchKeyboardFromEditChanges();
					SendOnValueChangedAndUpdateLabel();
				}
				else if (caretPositionInternal > 0 && caretPositionInternal - 1 < text.Length)
				{
					m_Text = text.Remove(caretPositionInternal - 1, 1);
					caretSelectPositionInternal = --caretPositionInternal;
					UpdateTouchKeyboardFromEditChanges();
					SendOnValueChangedAndUpdateLabel();
				}
			}
		}

		private void Insert(char c)
		{
			if (!m_ReadOnly)
			{
				string text = c.ToString();
				Delete();
				if (characterLimit <= 0 || this.text.Length < characterLimit)
				{
					m_Text = this.text.Insert(m_CaretPosition, text);
					caretSelectPositionInternal = (caretPositionInternal += text.Length);
					UpdateTouchKeyboardFromEditChanges();
					SendOnValueChanged();
				}
			}
		}

		private void UpdateTouchKeyboardFromEditChanges()
		{
			if (m_Keyboard != null && InPlaceEditing())
			{
				m_Keyboard.text = m_Text;
			}
		}

		private void SendOnValueChangedAndUpdateLabel()
		{
			SendOnValueChanged();
			UpdateLabel();
		}

		private void SendOnValueChanged()
		{
			UISystemProfilerApi.AddMarker("InputField.value", (Object)(object)this);
			if (onValueChanged != null)
			{
				((UnityEvent<string>)onValueChanged).Invoke(text);
			}
		}

		protected void SendOnEndEdit()
		{
			UISystemProfilerApi.AddMarker("InputField.onEndEdit", (Object)(object)this);
			if (onEndEdit != null)
			{
				((UnityEvent<string>)onEndEdit).Invoke(m_Text);
			}
		}

		protected void SendOnSubmit()
		{
			UISystemProfilerApi.AddMarker("InputField.onSubmit", (Object)(object)this);
			if (onSubmit != null)
			{
				((UnityEvent<string>)onSubmit).Invoke(m_Text);
			}
		}

		protected virtual void Append(string input)
		{
			if (m_ReadOnly || !InPlaceEditing())
			{
				return;
			}
			int i = 0;
			for (int length = input.Length; i < length; i++)
			{
				char c = input[i];
				if (c >= ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\n')
				{
					Append(c);
				}
			}
		}

		protected virtual void Append(char input)
		{
			if (!char.IsSurrogate(input) && !m_ReadOnly && this.text.Length < 16382 && InPlaceEditing())
			{
				int num = Math.Min(selectionFocusPosition, selectionAnchorPosition);
				string text = this.text;
				if (selectionFocusPosition != selectionAnchorPosition)
				{
					text = ((caretPositionInternal >= caretSelectPositionInternal) ? (this.text.Substring(0, caretSelectPositionInternal) + this.text.Substring(caretPositionInternal, this.text.Length - caretPositionInternal)) : (this.text.Substring(0, caretPositionInternal) + this.text.Substring(caretSelectPositionInternal, this.text.Length - caretSelectPositionInternal)));
				}
				if (onValidateInput != null)
				{
					input = onValidateInput(text, num, input);
				}
				else if (characterValidation != CharacterValidation.None)
				{
					input = Validate(text, num, input);
				}
				if (input != 0)
				{
					Insert(input);
				}
			}
		}

		protected void UpdateLabel()
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_TextComponent != (Object)null && (Object)(object)m_TextComponent.font != (Object)null && !m_PreventFontCallback)
			{
				m_PreventFontCallback = true;
				string text;
				if ((Object)(object)EventSystem.current != (Object)null && (Object)(object)((Component)this).gameObject == (Object)(object)EventSystem.current.currentSelectedGameObject && compositionString.Length > 0)
				{
					m_IsCompositionActive = true;
					text = this.text.Substring(0, m_CaretPosition) + compositionString + this.text.Substring(m_CaretPosition);
				}
				else
				{
					m_IsCompositionActive = false;
					text = this.text;
				}
				string text2 = ((inputType != InputType.Password) ? text : new string(asteriskChar, text.Length));
				bool flag = string.IsNullOrEmpty(text);
				if ((Object)(object)m_Placeholder != (Object)null)
				{
					((Behaviour)m_Placeholder).enabled = flag;
				}
				if (!m_AllowInput)
				{
					m_DrawStart = 0;
					m_DrawEnd = m_Text.Length;
				}
				if (!flag)
				{
					Rect rect = m_TextComponent.rectTransform.rect;
					Vector2 size = ((Rect)(ref rect)).size;
					TextGenerationSettings generationSettings = m_TextComponent.GetGenerationSettings(size);
					generationSettings.generateOutOfBounds = true;
					cachedInputTextGenerator.PopulateWithErrors(text2, generationSettings, ((Component)this).gameObject);
					SetDrawRangeToContainCaretPosition(caretSelectPositionInternal);
					text2 = text2.Substring(m_DrawStart, Mathf.Min(m_DrawEnd, text2.Length) - m_DrawStart);
					SetCaretVisible();
				}
				m_TextComponent.text = text2;
				MarkGeometryAsDirty();
				m_PreventFontCallback = false;
			}
		}

		private bool IsSelectionVisible()
		{
			if (m_DrawStart > caretPositionInternal || m_DrawStart > caretSelectPositionInternal)
			{
				return false;
			}
			if (m_DrawEnd < caretPositionInternal || m_DrawEnd < caretSelectPositionInternal)
			{
				return false;
			}
			return true;
		}

		private static int GetLineStartPosition(TextGenerator gen, int line)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			line = Mathf.Clamp(line, 0, gen.lines.Count - 1);
			return gen.lines[line].startCharIdx;
		}

		private static int GetLineEndPosition(TextGenerator gen, int line)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			line = Mathf.Max(line, 0);
			if (line + 1 < gen.lines.Count)
			{
				return gen.lines[line + 1].startCharIdx - 1;
			}
			return gen.characterCountVisible;
		}

		private void SetDrawRangeToContainCaretPosition(int caretPos)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0112: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			if (cachedInputTextGenerator.lineCount <= 0)
			{
				return;
			}
			Rect rectExtents = cachedInputTextGenerator.rectExtents;
			Vector2 size = ((Rect)(ref rectExtents)).size;
			if (multiLine)
			{
				IList<UILineInfo> lines = cachedInputTextGenerator.lines;
				int num = DetermineCharacterLine(caretPos, cachedInputTextGenerator);
				if (caretPos > m_DrawEnd)
				{
					m_DrawEnd = GetLineEndPosition(cachedInputTextGenerator, num);
					float num2 = lines[num].topY - (float)lines[num].height;
					if (num == lines.Count - 1)
					{
						num2 += lines[num].leading;
					}
					int num3 = num;
					while (num3 > 0 && !(lines[num3 - 1].topY - num2 > size.y))
					{
						num3--;
					}
					m_DrawStart = GetLineStartPosition(cachedInputTextGenerator, num3);
					return;
				}
				if (caretPos < m_DrawStart)
				{
					m_DrawStart = GetLineStartPosition(cachedInputTextGenerator, num);
				}
				int num4 = DetermineCharacterLine(m_DrawStart, cachedInputTextGenerator);
				int i = num4;
				float topY = lines[num4].topY;
				float num5 = lines[i].topY - (float)lines[i].height;
				if (i == lines.Count - 1)
				{
					num5 += lines[i].leading;
				}
				for (; i < lines.Count - 1; i++)
				{
					num5 = lines[i + 1].topY - (float)lines[i + 1].height;
					if (i + 1 == lines.Count - 1)
					{
						num5 += lines[i + 1].leading;
					}
					if (topY - num5 > size.y)
					{
						break;
					}
				}
				m_DrawEnd = GetLineEndPosition(cachedInputTextGenerator, i);
				while (num4 > 0)
				{
					topY = lines[num4 - 1].topY;
					if (topY - num5 > size.y)
					{
						break;
					}
					num4--;
				}
				m_DrawStart = GetLineStartPosition(cachedInputTextGenerator, num4);
				return;
			}
			IList<UICharInfo> characters = cachedInputTextGenerator.characters;
			if (m_DrawEnd > cachedInputTextGenerator.characterCountVisible)
			{
				m_DrawEnd = cachedInputTextGenerator.characterCountVisible;
			}
			float num6 = 0f;
			if (caretPos > m_DrawEnd || (caretPos == m_DrawEnd && m_DrawStart > 0))
			{
				m_DrawEnd = caretPos;
				m_DrawStart = m_DrawEnd - 1;
				while (m_DrawStart >= 0 && !(num6 + characters[m_DrawStart].charWidth > size.x))
				{
					num6 += characters[m_DrawStart].charWidth;
					m_DrawStart--;
				}
				m_DrawStart++;
			}
			else
			{
				if (caretPos < m_DrawStart)
				{
					m_DrawStart = caretPos;
				}
				m_DrawEnd = m_DrawStart;
			}
			while (m_DrawEnd < cachedInputTextGenerator.characterCountVisible)
			{
				num6 += characters[m_DrawEnd].charWidth;
				if (!(num6 > size.x))
				{
					m_DrawEnd++;
					continue;
				}
				break;
			}
		}

		public void ForceLabelUpdate()
		{
			UpdateLabel();
		}

		private void MarkGeometryAsDirty()
		{
			CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild(this);
		}

		public virtual void Rebuild(CanvasUpdate update)
		{
			if (update == CanvasUpdate.LatePreRender)
			{
				UpdateGeometry();
			}
		}

		public virtual void LayoutComplete()
		{
		}

		public virtual void GraphicUpdateComplete()
		{
		}

		private void UpdateGeometry()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			if (InPlaceEditing() || shouldHideMobileInput)
			{
				if ((Object)(object)m_CachedInputRenderer == (Object)null && (Object)(object)m_TextComponent != (Object)null)
				{
					GameObject val = new GameObject(((Object)((Component)this).transform).name + " Input Caret", new Type[2]
					{
						typeof(RectTransform),
						typeof(CanvasRenderer)
					});
					((Object)val).hideFlags = (HideFlags)52;
					val.transform.SetParent(((Component)m_TextComponent).transform.parent);
					val.transform.SetAsFirstSibling();
					val.layer = ((Component)this).gameObject.layer;
					caretRectTrans = val.GetComponent<RectTransform>();
					m_CachedInputRenderer = val.GetComponent<CanvasRenderer>();
					m_CachedInputRenderer.SetMaterial(m_TextComponent.GetModifiedMaterial(Graphic.defaultGraphicMaterial), (Texture)(object)Texture2D.whiteTexture);
					val.AddComponent<LayoutElement>().ignoreLayout = true;
					AssignPositioningIfNeeded();
				}
				if (!((Object)(object)m_CachedInputRenderer == (Object)null))
				{
					OnFillVBO(mesh);
					m_CachedInputRenderer.SetMesh(mesh);
				}
			}
		}

		private void AssignPositioningIfNeeded()
		{
			//IL_0028: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: 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_005d: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00cc: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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)
			//IL_0122: 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)
			if ((Object)(object)m_TextComponent != (Object)null && (Object)(object)caretRectTrans != (Object)null && (((Transform)caretRectTrans).localPosition != ((Transform)m_TextComponent.rectTransform).localPosition || ((Transform)caretRectTrans).localRotation != ((Transform)m_TextComponent.rectTransform).localRotation || ((Transform)caretRectTrans).localScale != ((Transform)m_TextComponent.rectTransform).localScale || caretRectTrans.anchorMin != m_TextComponent.rectTransform.anchorMin || caretRectTrans.anchorMax != m_TextComponent.rectTransform.anchorMax || caretRectTrans.anchoredPosition != m_TextComponent.rectTransform.anchoredPosition || caretRectTrans.sizeDelta != m_TextComponent.rectTransform.sizeDelta || caretRectTrans.pivot != m_TextComponent.rectTransform.pivot))
			{
				((Transform)caretRectTrans).localPosition = ((Transform)m_TextComponent.rectTransform).localPosition;
				((Transform)caretRectTrans).localRotation = ((Transform)m_TextComponent.rectTransform).localRotation;
				((Transform)caretRectTrans).localScale = ((Transform)m_TextComponent.rectTransform).localScale;
				caretRectTrans.anchorMin = m_TextComponent.rectTransform.anchorMin;
				caretRectTrans.anchorMax = m_TextComponent.rectTransform.anchorMax;
				caretRectTrans.anchoredPosition = m_TextComponent.rectTransform.anchoredPosition;
				caretRectTrans.sizeDelta = m_TextComponent.rectTransform.sizeDelta;
				caretRectTrans.pivot = m_TextComponent.rectTransform.pivot;
			}
		}

		private void OnFillVBO(Mesh vbo)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			using VertexHelper vertexHelper = new VertexHelper();
			if (!isFocused)
			{
				vertexHelper.FillMesh(vbo);
				return;
			}
			Vector2 roundingOffset = m_TextComponent.PixelAdjustPoint(Vector2.zero);
			if (!hasSelection)
			{
				GenerateCaret(vertexHelper, roundingOffset);
			}
			else
			{
				GenerateHighlight(vertexHelper, roundingOffset);
			}
			vertexHelper.FillMesh(vbo);
		}

		private void GenerateCaret(VertexHelper vbo, Vector2 roundingOffset)
		{
			//IL_004c: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_006c: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: 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_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: 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_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: 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_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			if (!m_CaretVisible)
			{
				return;
			}
			if (m_CursorVerts == null)
			{
				CreateCursorVerts();
			}
			float num = m_CaretWidth;
			int num2 = Mathf.Max(0, caretPositionInternal - m_DrawStart);
			TextGenerator cachedTextGenerator = m_TextComponent.cachedTextGenerator;
			if (cachedTextGenerator == null || cachedTextGenerator.lineCount == 0)
			{
				return;
			}
			Vector2 zero = Vector2.zero;
			if (num2 < cachedTextGenerator.characters.Count)
			{
				UICharInfo val = cachedTextGenerator.characters[num2];
				zero.x = val.cursorPos.x;
			}
			zero.x /= m_TextComponent.pixelsPerUnit;
			float x = zero.x;
			Rect rect = m_TextComponent.rectTransform.rect;
			if (x > ((Rect)(ref rect)).xMax)
			{
				rect = m_TextComponent.rectTransform.rect;
				zero.x = ((Rect)(ref rect)).xMax;
			}
			int index = DetermineCharacterLine(num2, cachedTextGenerator);
			zero.y = cachedTextGenerator.lines[index].topY / m_TextComponent.pixelsPerUnit;
			float num3 = (float)cachedTextGenerator.lines[index].height / m_TextComponent.pixelsPerUnit;
			for (int i = 0; i < m_CursorVerts.Length; i++)
			{
				m_CursorVerts[i].color = Color32.op_Implicit(caretColor);
			}
			m_CursorVerts[0].position = new Vector3(zero.x, zero.y - num3, 0f);
			m_CursorVerts[1].position = new Vector3(zero.x + num, zero.y - num3, 0f);
			m_CursorVerts[2].position = new Vector3(zero.x + num, zero.y, 0f);
			m_CursorVerts[3].position = new Vector3(zero.x, zero.y, 0f);
			if (roundingOffset != Vector2.zero)
			{
				for (int j = 0; j < m_CursorVerts.Length; j++)
				{
					UIVertex val2 = m_CursorVerts[j];
					val2.position.x += roundingOffset.x;
					val2.position.y += roundingOffset.y;
				}
			}
			vbo.AddUIVertexQuad(m_CursorVerts);
			int num4 = Screen.height;
			int targetDisplay = m_TextComponent.canvas.targetDisplay;
			if (targetDisplay > 0 && targetDisplay < Display.displays.Length)
			{
				num4 = Display.displays[targetDisplay].renderingHeight;
			}
			Camera val3 = (((int)m_TextComponent.canvas.renderMode != 0) ? m_TextComponent.canvas.worldCamera : null);
			Vector3 val4 = ((Component)m_CachedInputRenderer).gameObject.transform.TransformPoint(m_CursorVerts[0].position);
			Vector2 val5 = RectTransformUtility.WorldToScreenPoint(val3, val4);
			val5.y = (float)num4 - val5.y;
			if ((Object)(object)input != (Object)null)
			{
				input.compositionCursorPos = val5;
			}
		}

		private void CreateCursorVerts()
		{
			//IL_0017: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			m_CursorVerts = (UIVertex[])(object)new UIVertex[4];
			for (int i = 0; i < m_CursorVerts.Length; i++)
			{
				m_CursorVerts[i] = UIVertex.simpleVert;
				m_CursorVerts[i].uv0 = Vector4.op_Implicit(Vector2.zero);
			}
		}

		private void GenerateHighlight(VertexHelper vbo, Vector2 roundingOffset)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_007c: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: 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_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(0, caretPositionInternal - m_DrawStart);
			int num2 = Mathf.Max(0, caretSelectPositionInternal - m_DrawStart);
			if (num > num2)
			{
				int num3 = num;
				num = num2;
				num2 = num3;
			}
			num2--;
			TextGenerator cachedTextGenerator = m_TextComponent.cachedTextGenerator;
			if (cachedTextGenerator.lineCount <= 0)
			{
				return;
			}
			int num4 = DetermineCharacterLine(num, cachedTextGenerator);
			int lineEndPosition = GetLineEndPosition(cachedTextGenerator, num4);
			UIVertex simpleVert = UIVertex.simpleVert;
			simpleVert.uv0 = Vector4.op_Implicit(Vector2.zero);
			simpleVert.color = Color32.op_Implicit(selectionColor);
			Vector2 val3 = default(Vector2);
			Vector2 val4 = default(Vector2);
			for (int i = num; i <= num2 && i < cachedTextGenerator.characterCount; i++)
			{
				if (i != lineEndPosition && i != num2)
				{
					continue;
				}
				UICharInfo val = cachedTextGenerator.characters[num];
				UICharInfo val2 = cachedTextGenerator.characters[i];
				((Vector2)(ref val3))..ctor(val.cursorPos.x / m_TextComponent.pixelsPerUnit, cachedTextGenerator.lines[num4].topY / m_TextComponent.pixelsPerUnit);
				((Vector2)(ref val4))..ctor((val2.cursorPos.x + val2.charWidth) / m_TextComponent.pixelsPerUnit, val3.y - (float)cachedTextGenerator.lines[num4].height / m_TextComponent.pixelsPerUnit);
				float x = val4.x;
				Rect rect = m_TextComponent.rectTransform.rect;
				if (!(x > ((Rect)(ref rect)).xMax))
				{
					float x2 = val4.x;
					rect = m_TextComponent.rectTransform.rect;
					if (!(x2 < ((Rect)(ref rect)).xMin))
					{
						goto IL_01a6;
					}
				}
				rect = m_TextComponent.rectTransform.rect;
				val4.x = ((Rect)(ref rect)).xMax;
				goto IL_01a6;
				IL_01a6:
				int currentVertCount = vbo.currentVertCount;
				simpleVert.position = new Vector3(val3.x, val4.y, 0f) + Vector2.op_Implicit(roundingOffset);
				vbo.AddVert(simpleVert);
				simpleVert.position = new Vector3(val4.x, val4.y, 0f) + Vector2.op_Implicit(roundingOffset);
				vbo.AddVert(simpleVert);
				simpleVert.position = new Vector3(val4.x, val3.y, 0f) + Vector2.op_Implicit(roundingOffset);
				vbo.AddVert(simpleVert);
				simpleVert.position = new Vector3(val3.x, val3.y, 0f) + Vector2.op_Implicit(roundingOffset);
				vbo.AddVert(simpleVert);
				vbo.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 2);
				vbo.AddTriangle(currentVertCount + 2, currentVertCount + 3, currentVertCount);
				num = i + 1;
				num4++;
				lineEndPosition = GetLineEndPosition(cachedTextGenerator, num4);
			}
		}

		protected char Validate(string text, int pos, char ch)
		{
			if (characterValidation == CharacterValidation.None || !((Behaviour)this).enabled)
			{
				return ch;
			}
			if (characterValidation == CharacterValidation.Integer || characterValidation == CharacterValidation.Decimal)
			{
				bool num = pos == 0 && text.Length > 0 && text[0] == '-';
				bool flag = text.Length > 0 && text[0] == '-' && ((caretPositionInternal == 0 && caretSelectPositionInternal > 0) || (caretSelectPositionInternal == 0 && caretPositionInternal > 0));
				bool flag2 = caretPositionInternal == 0 || caretSelectPositionInternal == 0;
				if (!num || flag)
				{
					if (ch >= '0' && ch <= '9')
					{
						return ch;
					}
					if (ch == '-' && (pos == 0 || flag2))
					{
						return ch;
					}
					if ((ch == '.' || ch == ',') && characterValidation == CharacterValidation.Decimal && text.IndexOfAny(new char[2] { '.', ',' }) == -1)
					{
						return ch;
					}
				}
			}
			else if (characterValidation == CharacterValidation.Alphanumeric)
			{
				if (ch >= 'A' && ch <= 'Z')
				{
					return ch;
				}
				if (ch >= 'a' && ch <= 'z')
				{
					return ch;
				}
				if (ch >= '0' && ch <= '9')
				{
					return ch;
				}
			}
			else if (characterValidation == CharacterValidation.Name)
			{
				if (char.IsLetter(ch))
				{
					if (char.IsLower(ch) && (pos == 0 || text[pos - 1] == ' ' || text[pos - 1] == '-'))
					{
						return char.ToUpper(ch);
					}
					if (char.IsUpper(ch) && pos > 0 && text[pos - 1] != ' ' && text[pos - 1] != '\'' && text[pos - 1] != '-')
					{
						return char.ToLower(ch);
					}
					return ch;
				}
				if (ch == '\'' && !text.Contains("'") && (pos <= 0 || (text[pos - 1] != ' ' && text[pos - 1] != '\'' && text[pos - 1] != '-')) && (pos >= text.Length || (text[pos] != ' ' && text[pos] != '\'' && text[pos] != '-')))
				{
					return ch;
				}
				if ((ch == ' ' || ch == '-') && pos != 0 && (pos <= 0 || (text[pos - 1] != ' ' && text[pos - 1] != '\'' && text[pos - 1] != '-')) && (pos >= text.Length || (text[pos] != ' ' && text[pos] != '\'' && text[pos - 1] != '-')))
				{
					return ch;
				}
			}
			else if (characterValidation == CharacterValidation.EmailAddress)
			{
				if (ch >= 'A' && ch <= 'Z')
				{
					return ch;
				}
				if (ch >= 'a' && ch <= 'z')
				{
					return ch;
				}
				if (ch >= '0' && ch <= '9')
				{
					return ch;
				}
				if (ch == '@' && text.IndexOf('@') == -1)
				{
					return ch;
				}
				if ("!#$%&'*+-/=?^_`{|}~".IndexOf(ch) != -1)
				{
					return ch;
				}
				if (ch == '.')
				{
					char num2 = ((text.Length > 0) ? text[Mathf.Clamp(pos, 0, text.Length - 1)] : ' ');
					char c = ((text.Length > 0) ? text[Mathf.Clamp(pos + 1, 0, text.Length - 1)] : '\n');
					if (num2 != '.' && c != '.')
					{
						return ch;
					}
				}
			}
			return '\0';
		}

		public void ActivateInputField()
		{
			if (!((Object)(object)m_TextComponent == (Object)null) && !((Object)(object)m_TextComponent.font == (Object)null) && IsActive() && IsInteractable())
			{
				if (isFocused && m_Keyboard != null && !m_Keyboard.active)
				{
					m_Keyboard.active = true;
					m_Keyboard.text = m_Text;
				}
				m_ShouldActivateNextUpdate = true;
			}
		}

		private void ActivateInputFieldInternal()
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)EventSystem.current == (Object)null)
			{
				return;
			}
			if ((Object)(object)EventSystem.current.currentSelectedGameObject != (Object)(object)((Component)this).gameObject)
			{
				EventSystem.current.SetSelectedGameObject(((Component)this).gameObject);
			}
			m_TouchKeyboardAllowsInPlaceEditing = !s_IsQuestDevice && TouchScreenKeyboard.isInPlaceEditingAllowed;
			if (TouchScreenKeyboardShouldBeUsed())
			{
				if ((Object)(object)input != (Object)null && input.touchSupported)
				{
					TouchScreenKeyboard.hideInput = shouldHideMobileInput;
				}
				m_Keyboard = ((inputType == InputType.Password) ? TouchScreenKeyboard.Open(m_Text, keyboardType, false, multiLine, true, false, "", characterLimit) : TouchScreenKeyboard.Open(m_Text, keyboardType, inputType == InputType.AutoCorrect, multiLine, false, false, "", characterLimit));
				if (!m_TouchKeyboardAllowsInPlaceEditing)
				{
					MoveTextEnd(shift: false);
				}
			}
			if (!TouchScreenKeyboard.isSupported || m_TouchKeyboardAllowsInPlaceEditing)
			{
				if ((Object)(object)input != (Object)null)
				{
					input.imeCompositionMode = (IMECompositionMode)1;
				}
				OnFocus();
			}
			m_AllowInput = true;
			m_OriginalText = text;
			m_WasCanceled = false;
			SetCaretVisible();
			UpdateLabel();
		}

		public override void OnSelect(BaseEventData eventData)
		{
			base.OnSelect(eventData);
			if (shouldActivateOnSelect)
			{
				ActivateInputField();
			}
		}

		public virtual void OnPointerClick(PointerEventData eventData)
		{
			if (eventData.button == PointerEventData.InputButton.Left)
			{
				ActivateInputField();
			}
		}

		public void DeactivateInputField()
		{
			if (!m_AllowInput)
			{
				return;
			}
			m_HasDoneFocusTransition = false;
			m_AllowInput = false;
			if ((Object)(object)m_Placeholder != (Object)null)
			{
				((Behaviour)m_Placeholder).enabled = string.IsNullOrEmpty(m_Text);
			}
			if ((Object)(object)m_TextComponent != (Object)null && IsInteractable())
			{
				if (m_WasCanceled)
				{
					text = m_OriginalText;
				}
				SendOnEndEdit();
				if (m_Keyboard != null)
				{
					m_Keyboard.active = false;
					m_Keyboard = null;
				}
				m_CaretPosition = (m_CaretSelectPosition = 0);
				if ((Object)(object)input != (Object)null)
				{
					input.imeCompositionMode = (IMECompositionMode)0;
				}
			}
			MarkGeometryAsDirty();
		}

		public override void OnDeselect(BaseEventData eventData)
		{
			DeactivateInputField();
			base.OnDeselect(eventData);
		}

		public virtual void OnSubmit(BaseEventData eventData)
		{
			if (IsActive() && IsInteractable() && !isFocused)
			{
				m_ShouldActivateNextUpdate = true;
			}
		}

		private void EnforceContentType()
		{
			//IL_003f: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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)
			switch (contentType)
			{
			case ContentType.Standard:
				m_InputType = InputType.Standard;
				m_KeyboardType = (TouchScreenKeyboardType)0;
				m_CharacterValidation = CharacterValidation.None;
				break;
			case ContentType.Autocorrected:
				m_InputType = InputType.AutoCorrect;
				m_KeyboardType = (TouchScreenKeyboardType)0;
				m_CharacterValidation = CharacterValidation.None;
				break;
			case ContentType.IntegerNumber:
				m_LineType = LineType.SingleLine;
				m_InputType = InputType.Standard;
				m_KeyboardType = (TouchScreenKeyboardType)4;
				m_CharacterValidation = CharacterValidation.Integer;
				break;
			case ContentType.DecimalNumber:
				m_LineType = LineType.SingleLine;
				m_InputType = InputType.Standard;
				m_KeyboardType = (TouchScreenKeyboardType)2;
				m_CharacterValidation = CharacterValidation.Decimal;
				break;
			case ContentType.Alphanumeric:
				m_LineType = LineType.SingleLine;
				m_InputType = InputType.Standard;
				m_KeyboardType = (TouchScreenKeyboardType)1;
				m_CharacterValidation = CharacterValidation.Alphanumeric;
				break;
			case ContentType.Name:
				m_LineType = LineType.SingleLine;
				m_InputType = InputType.Standard;
				m_KeyboardType = (TouchScreenKeyboardType)6;
				m_CharacterValidation = CharacterValidation.Name;
				break;
			case ContentType.EmailAddress:
				m_LineType = LineType.SingleLine;
				m_InputType = InputType.Standard;
				m_KeyboardType = (TouchScreenKeyboardType)7;
				m_CharacterValidation = CharacterValidation.EmailAddress;
				break;
			case ContentType.Password:
				m_LineType = LineType.SingleLine;
				m_InputType = InputType.Password;
				m_KeyboardType = (TouchScreenKeyboardType)0;
				m_CharacterValidation = CharacterValidation.None;
				break;
			case ContentType.Pin:
				m_LineType = LineType.SingleLine;
				m_InputType = InputType.Password;
				m_KeyboardType = (TouchScreenKeyboardType)4;
				m_CharacterValidation = CharacterValidation.Integer;
				break;
			}
			EnforceTextHOverflow();
		}

		private void EnforceTextHOverflow()
		{
			if ((Object)(object)m_TextComponent != (Object)null)
			{
				if (multiLine)
				{
					m_TextComponent.horizontalOverflow = (HorizontalWrapMode)0;
				}
				else
				{
					m_TextComponent.horizontalOverflow = (HorizontalWrapMode)1;
				}
			}
		}

		private void SetToCustomIfContentTypeIsNot(params ContentType[] allowedContentTypes)
		{
			if (contentType == ContentType.Custom)
			{
				return;
			}
			for (int i = 0; i < allowedContentTypes.Length; i++)
			{
				if (contentType == allowedContentTypes[i])
				{
					return;
				}
			}
			contentType = ContentType.Custom;
		}

		private void SetToCustom()
		{
			if (contentType != ContentType.Custom)
			{
				contentType = ContentType.Custom;
			}
		}

		protected override void DoStateTransition(SelectionState state, bool instant)
		{
			if (m_HasDoneFocusTransition)
			{
				state = SelectionState.Selected;
			}
			else if (state == SelectionState.Pressed)
			{
				m_HasDoneFocusTransition = true;
			}
			base.DoStateTransition(state, instant);
		}

		public virtual void CalculateLayoutInputHorizontal()
		{
		}

		public virtual void CalculateLayoutInputVertical()
		{
		}

		[SpecialName]
		Transform ICanvasElement.get_transform()
		{
			return ((Component)this).transform;
		}
	}
	[AddComponentMenu("Layout/Aspect Ratio Fitter", 142)]
	[ExecuteAlways]
	[RequireComponent(typeof(RectTransform))]
	[DisallowMultipleComponent]
	public class AspectRatioFitter : UIBehaviour, ILayoutSelfController, ILayoutController
	{
		public enum AspectMode
		{
			None,
			WidthControlsHeight,
			HeightControlsWidth,
			FitInParent,
			EnvelopeParent
		}

		[SerializeField]
		private AspectMode m_AspectMode;

		[SerializeField]
		private float m_AspectRatio = 1f;

		[NonSerialized]
		private RectTransform m_Rect;

		private bool m_DelayedSetDirty;

		private bool m_DoesParentExist;

		private DrivenRectTransformTracker m_Tracker;

		public AspectMode aspectMode
		{
			get
			{
				return m_AspectMode;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_AspectMode, value))
				{
					SetDirty();
				}
			}
		}

		public float aspectRatio
		{
			get
			{
				return m_AspectRatio;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_AspectRatio, value))
				{
					SetDirty();
				}
			}
		}

		private RectTransform rectTransform
		{
			get
			{
				if ((Object)(object)m_Rect == (Object)null)
				{
					m_Rect = ((Component)this).GetComponent<RectTransform>();
				}
				return m_Rect;
			}
		}

		protected AspectRatioFitter()
		{
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			m_DoesParentExist = (Object.op_Implicit((Object)(object)((Transform)rectTransform).parent) ? true : false);
			SetDirty();
		}

		protected override void Start()
		{
			base.Start();
			if (!IsComponentValidOnObject() || !IsAspectModeValid())
			{
				((Behaviour)this).enabled = false;
			}
		}

		protected override void OnDisable()
		{
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
			base.OnDisable();
		}

		protected override void OnTransformParentChanged()
		{
			base.OnTransformParentChanged();
			m_DoesParentExist = (Object.op_Implicit((Object)(object)((Transform)rectTransform).parent) ? true : false);
			SetDirty();
		}

		protected virtual void Update()
		{
			if (m_DelayedSetDirty)
			{
				m_DelayedSetDirty = false;
				SetDirty();
			}
		}

		protected override void OnRectTransformDimensionsChange()
		{
			UpdateRect();
		}

		private void UpdateRect()
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_0065: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			if (!IsActive() || !IsComponentValidOnObject())
			{
				return;
			}
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			Rect rect;
			switch (m_AspectMode)
			{
			case AspectMode.HeightControlsWidth:
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, rectTransform, (DrivenTransformProperties)4096);
				RectTransform obj = rectTransform;
				rect = rectTransform.rect;
				obj.SetSizeWithCurrentAnchors((Axis)0, ((Rect)(ref rect)).height * m_AspectRatio);
				break;
			}
			case AspectMode.WidthControlsHeight:
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, rectTransform, (DrivenTransformProperties)8192);
				RectTransform obj2 = rectTransform;
				rect = rectTransform.rect;
				obj2.SetSizeWithCurrentAnchors((Axis)1, ((Rect)(ref rect)).width / m_AspectRatio);
				break;
			}
			case AspectMode.FitInParent:
			case AspectMode.EnvelopeParent:
				if (DoesParentExists())
				{
					((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, rectTransform, (DrivenTransformProperties)16134);
					rectTransform.anchorMin = Vector2.zero;
					rectTransform.anchorMax = Vector2.one;
					rectTransform.anchoredPosition = Vector2.zero;
					Vector2 zero = Vector2.zero;
					Vector2 parentSize = GetParentSize();
					if ((parentSize.y * aspectRatio < parentSize.x) ^ (m_AspectMode == AspectMode.FitInParent))
					{
						zero.y = GetSizeDeltaToProduceSize(parentSize.x / aspectRatio, 1);
					}
					else
					{
						zero.x = GetSizeDeltaToProduceSize(parentSize.y * aspectRatio, 0);
					}
					rectTransform.sizeDelta = zero;
				}
				break;
			}
		}

		private float GetSizeDeltaToProduceSize(float size, int axis)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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)
			Vector2 val = GetParentSize();
			float num = ((Vector2)(ref val))[axis];
			val = rectTransform.anchorMax;
			float num2 = ((Vector2)(ref val))[axis];
			val = rectTransform.anchorMin;
			return size - num * (num2 - ((Vector2)(ref val))[axis]);
		}

		private Vector2 GetParentSize()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Transform)rectTransform).parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				Rect rect = val.rect;
				return ((Rect)(ref rect)).size;
			}
			return Vector2.zero;
		}

		public virtual void SetLayoutHorizontal()
		{
		}

		public virtual void SetLayoutVertical()
		{
		}

		protected void SetDirty()
		{
			UpdateRect();
		}

		public bool IsComponentValidOnObject()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			Canvas component = ((Component)this).gameObject.GetComponent<Canvas>();
			if (Object.op_Implicit((Object)(object)component) && component.isRootCanvas && (int)component.renderMode != 2)
			{
				return false;
			}
			return true;
		}

		public bool IsAspectModeValid()
		{
			if (!DoesParentExists() && (aspectMode == AspectMode.EnvelopeParent || aspectMode == AspectMode.FitInParent))
			{
				return false;
			}
			return true;
		}

		private bool DoesParentExists()
		{
			return m_DoesParentExist;
		}
	}
	[RequireComponent(typeof(Canvas))]
	[ExecuteAlways]
	[AddComponentMenu("Layout/Canvas Scaler", 101)]
	[DisallowMultipleComponent]
	public class CanvasScaler : UIBehaviour
	{
		public enum ScaleMode
		{
			ConstantPixelSize,
			ScaleWithScreenSize,
			ConstantPhysicalSize
		}

		public enum ScreenMatchMode
		{
			MatchWidthOrHeight,
			Expand,
			Shrink
		}

		public enum Unit
		{
			Centimeters,
			Millimeters,
			Inches,
			Points,
			Picas
		}

		[Tooltip("Determines how UI elements in the Canvas are scaled.")]
		[SerializeField]
		private ScaleMode m_UiScaleMode;

		[Tooltip("If a sprite has this 'Pixels Per Unit' setting, then one pixel in the sprite will cover one unit in the UI.")]
		[SerializeField]
		protected float m_ReferencePixelsPerUnit = 100f;

		[Tooltip("Scales all UI elements in the Canvas by this factor.")]
		[SerializeField]
		protected float m_ScaleFactor = 1f;

		[Tooltip("The resolution the UI layout is designed for. If the screen resolution is larger, the UI will be scaled up, and if it's smaller, the UI will be scaled down. This is done in accordance with the Screen Match Mode.")]
		[SerializeField]
		protected Vector2 m_ReferenceResolution = new Vector2(800f, 600f);

		[Tooltip("A mode used to scale the canvas area if the aspect ratio of the current resolution doesn't fit the reference resolution.")]
		[SerializeField]
		protected ScreenMatchMode m_ScreenMatchMode;

		[Tooltip("Determines if the scaling is using the width or height as reference, or a mix in between.")]
		[Range(0f, 1f)]
		[SerializeField]
		protected float m_MatchWidthOrHeight;

		private const float kLogBase = 2f;

		[Tooltip("The physical unit to specify positions and sizes in.")]
		[SerializeField]
		protected Unit m_PhysicalUnit = Unit.Points;

		[Tooltip("The DPI to assume if the screen DPI is not known.")]
		[SerializeField]
		protected float m_FallbackScreenDPI = 96f;

		[Tooltip("The pixels per inch to use for sprites that have a 'Pixels Per Unit' setting that matches the 'Reference Pixels Per Unit' setting.")]
		[SerializeField]
		protected float m_DefaultSpriteDPI = 96f;

		[Tooltip("The amount of pixels per unit to use for dynamically created bitmaps in the UI, such as Text.")]
		[SerializeField]
		protected float m_DynamicPixelsPerUnit = 1f;

		private Canvas m_Canvas;

		[NonSerialized]
		private float m_PrevScaleFactor = 1f;

		[NonSerialized]
		private float m_PrevReferencePixelsPerUnit = 100f;

		[SerializeField]
		protected bool m_PresetInfoIsWorld;

		public ScaleMode uiScaleMode
		{
			get
			{
				return m_UiScaleMode;
			}
			set
			{
				m_UiScaleMode = value;
			}
		}

		public float referencePixelsPerUnit
		{
			get
			{
				return m_ReferencePixelsPerUnit;
			}
			set
			{
				m_ReferencePixelsPerUnit = value;
			}
		}

		public float scaleFactor
		{
			get
			{
				return m_ScaleFactor;
			}
			set
			{
				m_ScaleFactor = Mathf.Max(0.01f, value);
			}
		}

		public Vector2 referenceResolution
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_ReferenceResolution;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_ReferenceResolution = value;
				if (m_ReferenceResolution.x > -1E-05f && m_ReferenceResolution.x < 1E-05f)
				{
					m_ReferenceResolution.x = 1E-05f * Mathf.Sign(m_ReferenceResolution.x);
				}
				if (m_ReferenceResolution.y > -1E-05f && m_ReferenceResolution.y < 1E-05f)
				{
					m_ReferenceResolution.y = 1E-05f * Mathf.Sign(m_ReferenceResolution.y);
				}
			}
		}

		public ScreenMatchMode screenMatchMode
		{
			get
			{
				return m_ScreenMatchMode;
			}
			set
			{
				m_ScreenMatchMode = value;
			}
		}

		public float matchWidthOrHeight
		{
			get
			{
				return m_MatchWidthOrHeight;
			}
			set
			{
				m_MatchWidthOrHeight = value;
			}
		}

		public Unit physicalUnit
		{
			get
			{
				return m_PhysicalUnit;
			}
			set
			{
				m_PhysicalUnit = value;
			}
		}

		public float fallbackScreenDPI
		{
			get
			{
				return m_FallbackScreenDPI;
			}
			set
			{
				m_FallbackScreenDPI = value;
			}
		}

		public float defaultSpriteDPI
		{
			get
			{
				return m_DefaultSpriteDPI;
			}
			set
			{
				m_DefaultSpriteDPI = Mathf.Max(1f, value);
			}
		}

		public float dynamicPixelsPerUnit
		{
			get
			{
				return m_DynamicPixelsPerUnit;
			}
			set
			{
				m_DynamicPixelsPerUnit = value;
			}
		}

		protected CanvasScaler()
		{
		}//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)


		protected override void OnEnable()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			base.OnEnable();
			m_Canvas = ((Component)this).GetComponent<Canvas>();
			Handle();
			Canvas.preWillRenderCanvases += new WillRenderCanvases(Canvas_preWillRenderCanvases);
		}

		private void Canvas_preWillRenderCanvases()
		{
			Handle();
		}

		protected override void OnDisable()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			SetScaleFactor(1f);
			SetReferencePixelsPerUnit(100f);
			Canvas.preWillRenderCanvases -= new WillRenderCanvases(Canvas_preWillRenderCanvases);
			base.OnDisable();
		}

		protected virtual void Handle()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			if ((Object)(object)m_Canvas == (Object)null || !m_Canvas.isRootCanvas)
			{
				return;
			}
			if ((int)m_Canvas.renderMode == 2)
			{
				HandleWorldCanvas();
				return;
			}
			switch (m_UiScaleMode)
			{
			case ScaleMode.ConstantPixelSize:
				HandleConstantPixelSize();
				break;
			case ScaleMode.ScaleWithScreenSize:
				HandleScaleWithScreenSize();
				break;
			case ScaleMode.ConstantPhysicalSize:
				HandleConstantPhysicalSize();
				break;
			}
		}

		protected virtual void HandleWorldCanvas()
		{
			SetScaleFactor(m_DynamicPixelsPerUnit);
			SetReferencePixelsPerUnit(m_ReferencePixelsPerUnit);
		}

		protected virtual void HandleConstantPixelSize()
		{
			SetScaleFactor(m_ScaleFactor);
			SetReferencePixelsPerUnit(m_ReferencePixelsPerUnit);
		}

		protected virtual void HandleScaleWithScreenSize()
		{
			//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_0069: 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_00c1: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			Vector2 renderingDisplaySize = m_Canvas.renderingDisplaySize;
			int targetDisplay = m_Canvas.targetDisplay;
			if (targetDisplay > 0 && targetDisplay < Display.displays.Length)
			{
				Display val = Display.displays[targetDisplay];
				((Vector2)(ref renderingDisplaySize))..ctor((float)val.renderingWidth, (float)val.renderingHeight);
			}
			float num = 0f;
			switch (m_ScreenMatchMode)
			{
			case ScreenMatchMode.MatchWidthOrHeight:
			{
				float num2 = Mathf.Log(renderingDisplaySize.x / m_ReferenceResolution.x, 2f);
				float num3 = Mathf.Log(renderingDisplaySize.y / m_ReferenceResolution.y, 2f);
				float num4 = Mathf.Lerp(num2, num3, m_MatchWidthOrHeight);
				num = Mathf.Pow(2f, num4);
				break;
			}
			case ScreenMatchMode.Expand:
				num = Mathf.Min(renderingDisplaySize.x / m_ReferenceResolution.x, renderingDisplaySize.y / m_ReferenceResolution.y);
				break;
			case ScreenMatchMode.Shrink:
				num = Mathf.Max(renderingDisplaySize.x / m_ReferenceResolution.x, renderingDisplaySize.y / m_ReferenceResolution.y);
				break;
			}
			SetScaleFactor(num);
			SetReferencePixelsPerUnit(m_ReferencePixelsPerUnit);
		}

		protected virtual void HandleConstantPhysicalSize()
		{
			float dpi = Screen.dpi;
			float num = ((dpi == 0f) ? m_FallbackScreenDPI : dpi);
			float num2 = 1f;
			switch (m_PhysicalUnit)
			{
			case Unit.Centimeters:
				num2 = 2.54f;
				break;
			case Unit.Millimeters:
				num2 = 25.4f;
				break;
			case Unit.Inches:
				num2 = 1f;
				break;
			case Unit.Points:
				num2 = 72f;
				break;
			case Unit.Picas:
				num2 = 6f;
				break;
			}
			SetScaleFactor(num / num2);
			SetReferencePixelsPerUnit(m_ReferencePixelsPerUnit * num2 / m_DefaultSpriteDPI);
		}

		protected void SetScaleFactor(float scaleFactor)
		{
			if (scaleFactor != m_PrevScaleFactor)
			{
				m_Canvas.scaleFactor = scaleFactor;
				m_PrevScaleFactor = scaleFactor;
			}
		}

		protected void SetReferencePixelsPerUnit(float referencePixelsPerUnit)
		{
			if (referencePixelsPerUnit != m_PrevReferencePixelsPerUnit)
			{
				m_Canvas.referencePixelsPerUnit = referencePixelsPerUnit;
				m_PrevReferencePixelsPerUnit = referencePixelsPerUnit;
			}
		}
	}
	[AddComponentMenu("Layout/Content Size Fitter", 141)]
	[ExecuteAlways]
	[RequireComponent(typeof(RectTransform))]
	public class ContentSizeFitter : UIBehaviour, ILayoutSelfController, ILayoutController
	{
		public enum FitMode
		{
			Unconstrained,
			MinSize,
			PreferredSize
		}

		[SerializeField]
		protected FitMode m_HorizontalFit;

		[SerializeField]
		protected FitMode m_VerticalFit;

		[NonSerialized]
		private RectTransform m_Rect;

		private DrivenRectTransformTracker m_Tracker;

		public FitMode horizontalFit
		{
			get
			{
				return m_HorizontalFit;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_HorizontalFit, value))
				{
					SetDirty();
				}
			}
		}

		public FitMode verticalFit
		{
			get
			{
				return m_VerticalFit;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_VerticalFit, value))
				{
					SetDirty();
				}
			}
		}

		private RectTransform rectTransform
		{
			get
			{
				if ((Object)(object)m_Rect == (Object)null)
				{
					m_Rect = ((Component)this).GetComponent<RectTransform>();
				}
				return m_Rect;
			}
		}

		protected ContentSizeFitter()
		{
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			SetDirty();
		}

		protected override void OnDisable()
		{
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
			base.OnDisable();
		}

		protected override void OnRectTransformDimensionsChange()
		{
			SetDirty();
		}

		private void HandleSelfFittingAlongAxis(int axis)
		{
			FitMode fitMode = ((axis == 0) ? horizontalFit : verticalFit);
			if (fitMode == FitMode.Unconstrained)
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, rectTransform, (DrivenTransformProperties)0);
				return;
			}
			((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, rectTransform, (DrivenTransformProperties)((axis == 0) ? 4096 : 8192));
			if (fitMode == FitMode.MinSize)
			{
				rectTransform.SetSizeWithCurrentAnchors((Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
			}
			else
			{
				rectTransform.SetSizeWithCurrentAnchors((Axis)axis, LayoutUtility.GetPreferredSize(m_Rect, axis));
			}
		}

		public virtual void SetLayoutHorizontal()
		{
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			HandleSelfFittingAlongAxis(0);
		}

		public virtual void SetLayoutVertical()
		{
			HandleSelfFittingAlongAxis(1);
		}

		protected void SetDirty()
		{
			if (IsActive())
			{
				LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
			}
		}
	}
	[AddComponentMenu("Layout/Grid Layout Group", 152)]
	public class GridLayoutGroup : LayoutGroup
	{
		public enum Corner
		{
			UpperLeft,
			UpperRight,
			LowerLeft,
			LowerRight
		}

		public enum Axis
		{
			Horizontal,
			Vertical
		}

		public enum Constraint
		{
			Flexible,
			FixedColumnCount,
			FixedRowCount
		}

		[SerializeField]
		protected Corner m_StartCorner;

		[SerializeField]
		protected Axis m_StartAxis;

		[SerializeField]
		protected Vector2 m_CellSize = new Vector2(100f, 100f);

		[SerializeField]
		protected Vector2 m_Spacing = Vector2.zero;

		[SerializeField]
		protected Constraint m_Constraint;

		[SerializeField]
		protected int m_ConstraintCount = 2;

		public Corner startCorner
		{
			get
			{
				return m_StartCorner;
			}
			set
			{
				SetProperty(ref m_StartCorner, value);
			}
		}

		public Axis startAxis
		{
			get
			{
				return m_StartAxis;
			}
			set
			{
				SetProperty(ref m_StartAxis, value);
			}
		}

		public Vector2 cellSize
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_CellSize;
			}
			set
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				SetProperty(ref m_CellSize, value);
			}
		}

		public Vector2 spacing
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_Spacing;
			}
			set
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				SetProperty(ref m_Spacing, value);
			}
		}

		public Constraint constraint
		{
			get
			{
				return m_Constraint;
			}
			set
			{
				SetProperty(ref m_Constraint, value);
			}
		}

		public int constraintCount
		{
			get
			{
				return m_ConstraintCount;
			}
			set
			{
				SetProperty(ref m_ConstraintCount, Mathf.Max(1, value));
			}
		}

		protected GridLayoutGroup()
		{
		}//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)


		public override void CalculateLayoutInputHorizontal()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			base.CalculateLayoutInputHorizontal();
			int num = 0;
			int num2 = 0;
			if (m_Constraint == Constraint.FixedColumnCount)
			{
				num = (num2 = m_ConstraintCount);
			}
			else if (m_Constraint == Constraint.FixedRowCount)
			{
				num = (num2 = Mathf.CeilToInt((float)base.rectChildren.Count / (float)m_ConstraintCount - 0.001f));
			}
			else
			{
				num = 1;
				num2 = Mathf.CeilToInt(Mathf.Sqrt((float)base.rectChildren.Count));
			}
			SetLayoutInputForAxis((float)base.padding.horizontal + (cellSize.x + spacing.x) * (float)num - spacing.x, (float)base.padding.horizontal + (cellSize.x + spacing.x) * (float)num2 - spacing.x, -1f, 0);
		}

		public override void CalculateLayoutInputVertical()
		{
			//IL_0048: 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_0067: 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_00bd: 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)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			if (m_Constraint == Constraint.FixedColumnCount)
			{
				num = Mathf.CeilToInt((float)base.rectChildren.Count / (float)m_ConstraintCount - 0.001f);
			}
			else if (m_Constraint == Constraint.FixedRowCount)
			{
				num = m_ConstraintCount;
			}
			else
			{
				Rect rect = base.rectTransform.rect;
				float width = ((Rect)(ref rect)).width;
				int num2 = Mathf.Max(1, Mathf.FloorToInt((width - (float)base.padding.horizontal + spacing.x + 0.001f) / (cellSize.x + spacing.x)));
				num = Mathf.CeilToInt((float)base.rectChildren.Count / (float)num2);
			}
			float num3 = (float)base.padding.vertical + (cellSize.y + spacing.y) * (float)num - spacing.y;
			SetLayoutInputForAxis(num3, num3, -1f, 1);
		}

		public override void SetLayoutHorizontal()
		{
			SetCellsAlongAxis(0);
		}

		public override void SetLayoutVertical()
		{
			SetCellsAlongAxis(1);
		}

		private void SetCellsAlongAxis(int axis)
		{
			//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_0076: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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_0044: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			int count = base.rectChildren.Count;
			if (axis == 0)
			{
				for (int i = 0; i < count; i++)
				{
					RectTransform val = base.rectChildren[i];
					((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, val, (DrivenTransformProperties)16134);
					val.anchorMin = Vector2.up;
					val.anchorMax = Vector2.up;
					val.sizeDelta = cellSize;
				}
				return;
			}
			Rect rect = base.rectTransform.rect;
			float x = ((Rect)(ref rect)).size.x;
			rect = base.rectTransform.rect;
			float y = ((Rect)(ref rect)).size.y;
			int num = 1;
			int num2 = 1;
			if (m_Constraint == Constraint.FixedColumnCount)
			{
				num = m_ConstraintCount;
				if (count > num)
				{
					num2 = count / num + ((count % num > 0) ? 1 : 0);
				}
			}
			else if (m_Constraint != Constraint.FixedRowCount)
			{
				num = ((!(cellSize.x + spacing.x <= 0f)) ? Mathf.Max(1, Mathf.FloorToInt((x - (float)base.padding.horizontal + spacing.x + 0.001f) / (cellSize.x + spacing.x))) : int.MaxValue);
				num2 = ((!(cellSize.y + spacing.y <= 0f)) ? Mathf.Max(1, Mathf.FloorToInt((y - (float)base.padding.vertical + spacing.y + 0.001f) / (cellSize.y + spacing.y))) : int.MaxValue);
			}
			else
			{
				num2 = m_ConstraintCount;
				if (count > num2)
				{
					num = count / num2 + ((count % num2 > 0) ? 1 : 0);
				}
			}
			int num3 = (int)startCorner % 2;
			int num4 = (int)startCorner / 2;
			int num5;
			int num6;
			int num7;
			if (startAxis == Axis.Horizontal)
			{
				num5 = num;
				num6 = Mathf.Clamp(num, 1, count);
				num7 = Mathf.Clamp(num2, 1, Mathf.CeilToInt((float)count / (float)num5));
			}
			else
			{
				num5 = num2;
				num7 = Mathf.Clamp(num2, 1, count);
				num6 = Mathf.Clamp(num, 1, Mathf.CeilToInt((float)count / (float)num5));
			}
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor((float)num6 * cellSize.x + (float)(num6 - 1) * spacing.x, (float)num7 * cellSize.y + (float)(num7 - 1) * spacing.y);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(GetStartOffset(0, val2.x), GetStartOffset(1, val2.y));
			for (int j = 0; j < count; j++)
			{
				int num8;
				int num9;
				if (startAxis == Axis.Horizontal)
				{
					num8 = j % num5;
					num9 = j / num5;
				}
				else
				{
					num8 = j / num5;
					num9 = j % num5;
				}
				if (num3 == 1)
				{
					num8 = num6 - 1 - num8;
				}
				if (num4 == 1)
				{
					num9 = num7 - 1 - num9;
				}
				RectTransform rect2 = base.rectChildren[j];
				float x2 = val3.x;
				Vector2 val4 = cellSize;
				float num10 = ((Vector2)(ref val4))[0];
				val4 = spacing;
				float pos = x2 + (num10 + ((Vector2)(ref val4))[0]) * (float)num8;
				val4 = cellSize;
				SetChildAlongAxis(rect2, 0, pos, ((Vector2)(ref val4))[0]);
				RectTransform rect3 = base.rectChildren[j];
				float y2 = val3.y;
				val4 = cellSize;
				float num11 = ((Vector2)(ref val4))[1];
				val4 = spacing;
				float pos2 = y2 + (num11 + ((Vector2)(ref val4))[1]) * (float)num9;
				val4 = cellSize;
				SetChildAlongAxis(rect3, 1, pos2, ((Vector2)(ref val4))[1]);
			}
		}
	}
	[AddComponentMenu("Layout/Horizontal Layout Group", 150)]
	public class HorizontalLayoutGroup : HorizontalOrVerticalLayoutGroup
	{
		protected HorizontalLayoutGroup()
		{
		}

		public override void CalculateLayoutInputHorizontal()
		{
			base.CalculateLayoutInputHorizontal();
			CalcAlongAxis(0, isVertical: false);
		}

		public override void CalculateLayoutInputVertical()
		{
			CalcAlongAxis(1, isVertical: false);
		}

		public override void SetLayoutHorizontal()
		{
			SetChildrenAlongAxis(0, isVertical: false);
		}

		public override void SetLayoutVertical()
		{
			SetChildrenAlongAxis(1, isVertical: false);
		}
	}
	[ExecuteAlways]
	public abstract class HorizontalOrVerticalLayoutGroup : LayoutGroup
	{
		[SerializeField]
		protected float m_Spacing;

		[SerializeField]
		protected bool m_ChildForceExpandWidth = true;

		[SerializeField]
		protected bool m_ChildForceExpandHeight = true;

		[SerializeField]
		protected bool m_ChildControlWidth = true;

		[SerializeField]
		protected bool m_ChildControlHeight = true;

		[SerializeField]
		protected bool m_ChildScaleWidth;

		[SerializeField]
		protected bool m_ChildScaleHeight;

		[SerializeField]
		protected bool m_ReverseArrangement;

		public float spacing
		{
			get
			{
				return m_Spacing;
			}
			set
			{
				SetProperty(ref m_Spacing, value);
			}
		}

		public bool childForceExpandWidth
		{
			get
			{
				return m_ChildForceExpandWidth;
			}
			set
			{
				SetProperty(ref m_ChildForceExpandWidth, value);
			}
		}

		public bool childForceExpandHeight
		{
			get
			{
				return m_ChildForceExpandHeight;
			}
			set
			{
				SetProperty(ref m_ChildForceExpandHeight, value);
			}
		}

		public bool childControlWidth
		{
			get
			{
				return m_ChildControlWidth;
			}
			set
			{
				SetProperty(ref m_ChildControlWidth, value);
			}
		}

		public bool childControlHeight
		{
			get
			{
				return m_ChildControlHeight;
			}
			set
			{
				SetProperty(ref m_ChildControlHeight, value);
			}
		}

		public bool childScaleWidth
		{
			get
			{
				return m_ChildScaleWidth;
			}
			set
			{
				SetProperty(ref m_ChildScaleWidth, value);
			}
		}

		public bool childScaleHeight
		{
			get
			{
				return m_ChildScaleHeight;
			}
			set
			{
				SetProperty(ref m_ChildScaleHeight, value);
			}
		}

		public bool reverseArrangement
		{
			get
			{
				return m_ReverseArrangement;
			}
			set
			{
				SetProperty(ref m_ReverseArrangement, value);
			}
		}

		protected void CalcAlongAxis(int axis, bool isVertical)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			float num = ((axis == 0) ? base.padding.horizontal : base.padding.vertical);
			bool controlSize = ((axis == 0) ? m_ChildControlWidth : m_ChildControlHeight);
			bool flag = ((axis == 0) ? m_ChildScaleWidth : m_ChildScaleHeight);
			bool childForceExpand = ((axis == 0) ? m_ChildForceExpandWidth : m_ChildForceExpandHeight);
			float num2 = num;
			float num3 = num;
			float num4 = 0f;
			bool flag2 = isVertical ^ (axis == 1);
			int count = base.rectChildren.Count;
			for (int i = 0; i < count; i++)
			{
				RectTransform val = base.rectChildren[i];
				GetChildSizes(val, axis, controlSize, childForceExpand, out var min, out var preferred, out var flexible);
				if (flag)
				{
					Vector3 localScale = ((Transform)val).localScale;
					float num5 = ((Vector3)(ref localScale))[axis];
					min *= num5;
					preferred *= num5;
					flexible *= num5;
				}
				if (flag2)
				{
					num2 = Mathf.Max(min + num, num2);
					num3 = Mathf.Max(preferred + num, num3);
					num4 = Mathf.Max(flexible, num4);
				}
				else
				{
					num2 += min + spacing;
					num3 += preferred + spacing;
					num4 += flexible;
				}
			}
			if (!flag2 && base.rectChildren.Count > 0)
			{
				num2 -= spacing;
				num3 -= spacing;
			}
			num3 = Mathf.Max(num2, num3);
			SetLayoutInputForAxis(num2, num3, num4, axis);
		}

		protected void SetChildrenAlongAxis(int axis, bool isVertical)
		{
			//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_000f: 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)
			//IL_00fe: 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_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: 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)
			Rect rect = base.rectTransform.rect;
			Vector2 val = ((Rect)(ref rect)).size;
			float num = ((Vector2)(ref val))[axis];
			bool flag = ((axis == 0) ? m_ChildControlWidth : m_ChildControlHeight);
			bool flag2 = ((axis == 0) ? m_ChildScaleWidth : m_ChildScaleHeight);
			bool childForceExpand = ((axis == 0) ? m_ChildForceExpandWidth : m_ChildForceExpandHeight);
			float alignmentOnAxis = GetAlignmentOnAxis(axis);
			bool num2 = isVertical ^ (axis == 1);
			int num3 = (m_ReverseArrangement ? (base.rectChildren.Count - 1) : 0);
			int num4 = ((!m_ReverseArrangement) ? base.rectChildren.Count : 0);
			int num5 = ((!m_ReverseArrangement) ? 1 : (-1));
			Vector3 localScale;
			if (num2)
			{
				float num6 = num - (float)((axis == 0) ? base.padding.horizontal : base.padding.vertical);
				for (int i = num3; m_ReverseArrangement ? (i >= num4) : (i < num4); i += num5)
				{
					RectTransform val2 = base.rectChildren[i];
					GetChildSizes(val2, axis, flag, childForceExpand, out var min, out var preferred, out var flexible);
					float num7;
					if (!flag2)
					{
						num7 = 1f;
					}
					else
					{
						localScale = ((Transform)val2).localScale;
						num7 = ((Vector3)(ref localScale))[axis];
					}
					float num8 = num7;
					float num9 = Mathf.Clamp(num6, min, (flexible > 0f) ? num : preferred);
					float startOffset = GetStartOffset(axis, num9 * num8);
					if (flag)
					{
						SetChildAlongAxisWithScale(val2, axis, startOffset, num9, num8);
						continue;
					}
					val = val2.sizeDelta;
					float num10 = (num9 - ((Vector2)(ref val))[axis]) * alignmentOnAxis;
					SetChildAlongAxisWithScale(val2, axis, startOffset + num10, num8);
				}
				return;
			}
			float num11 = ((axis == 0) ? base.padding.left : base.padding.top);
			float num12 = 0f;
			float num13 = num - GetTotalPreferredSize(axis);
			if (num13 > 0f)
			{
				if (GetTotalFlexibleSize(axis) == 0f)
				{
					num11 = GetStartOffset(axis, GetTotalPreferredSize(axis) - (float)((axis == 0) ? base.padding.horizontal : base.padding.vertical));
				}
				else if (GetTotalFlexibleSize(axis) > 0f)
				{
					num12 = num13 / GetTotalFlexibleSize(axis);
				}
			}
			float num14 = 0f;
			if (GetTotalMinSize(axis) != GetTotalPreferredSize(axis))
			{
				num14 = Mathf.Clamp01((num - GetTotalMinSize(axis)) / (GetTotalPreferredSize(axis) - GetTotalMinSize(axis)));
			}
			for (int j = num3; m_ReverseArrangement ? (j >= num4) : (j < num4); j += num5)
			{
				RectTransform val3 = base.rectChildren[j];
				GetChildSizes(val3, axis, flag, childForceExpand, out var min2, out var preferred2, out var flexible2);
				float num15;
				if (!flag2)
				{
					num15 = 1f;
				}
				else
				{
					localScale = ((Transform)val3).localScale;
					num15 = ((Vector3)(ref localScale))[axis];
				}
				float num16 = num15;
				float num17 = Mathf.Lerp(min2, preferred2, num14);
				num17 += flexible2 * num12;
				if (flag)
				{
					SetChildAlongAxisWithScale(val3, axis, num11, num17, num16);
				}
				else
				{
					float num18 = num17;
					val = val3.sizeDelta;
					float num19 = (num18 - ((Vector2)(ref val))[axis]) * alignmentOnAxis;
					SetChildAlongAxisWithScale(val3, axis, num11 + num19, num16);
				}
				num11 += num17 * num16 + spacing;
			}
		}

		private void GetChildSizes(RectTransform child, int axis, bool controlSize, bool childForceExpand, out float min, out float preferred, out float flexible)
		{
			//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)
			if (!controlSize)
			{
				Vector2 sizeDelta = child.sizeDelta;
				min = ((Vector2)(ref sizeDelta))[axis];
				preferred = min;
				flexible = 0f;
			}
			else
			{
				min = LayoutUtility.GetMinSize(child, axis);
				preferred = LayoutUtility.GetPreferredSize(child, axis);
				flexible = LayoutUtility.GetFlexibleSize(child, axis);
			}
			if (childForceExpand)
			{
				flexible = Mathf.Max(flexible, 1f);
			}
		}
	}
	public interface ILayoutElement
	{
		float minWidth { get; }

		float preferredWidth { get; }

		float flexibleWidth { get; }

		float minHeight { get; }

		float preferredHeight { get; }

		float flexibleHeight { get; }

		int layoutPriority { get; }

		void CalculateLayoutInputHorizontal();

		void CalculateLayoutInputVertical();
	}
	public interface ILayoutController
	{
		void SetLayoutHorizontal();

		void SetLayoutVertical();
	}
	public interface ILayoutGroup : ILayoutController
	{
	}
	public interface ILayoutSelfController : ILayoutController
	{
	}
	public interface ILayoutIgnorer
	{
		bool ignoreLayout { get; }
	}
	[AddComponentMenu("Layout/Layout Element", 140)]
	[RequireComponent(typeof(RectTransform))]
	[ExecuteAlways]
	public class LayoutElement : UIBehaviour, ILayoutElement, ILayoutIgnorer
	{
		[SerializeField]
		private bool m_IgnoreLayout;

		[SerializeField]
		private float m_MinWidth = -1f;

		[SerializeField]
		private float m_MinHeight = -1f;

		[SerializeField]
		private float m_PreferredWidth = -1f;

		[SerializeField]
		private float m_PreferredHeight = -1f;

		[SerializeField]
		private float m_FlexibleWidth = -1f;

		[SerializeField]
		private float m_FlexibleHeight = -1f;

		[SerializeField]
		private int m_LayoutPriority = 1;

		public virtual bool ignoreLayout
		{
			get
			{
				return m_IgnoreLayout;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_IgnoreLayout, value))
				{
					SetDirty();
				}
			}
		}

		public virtual float minWidth
		{
			get
			{
				return m_MinWidth;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_MinWidth, value))
				{
					SetDirty();
				}
			}
		}

		public virtual float minHeight
		{
			get
			{
				return m_MinHeight;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_MinHeight, value))
				{
					SetDirty();
				}
			}
		}

		public virtual float preferredWidth
		{
			get
			{
				return m_PreferredWidth;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_PreferredWidth, value))
				{
					SetDirty();
				}
			}
		}

		public virtual float preferredHeight
		{
			get
			{
				return m_PreferredHeight;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_PreferredHeight, value))
				{
					SetDirty();
				}
			}
		}

		public virtual float flexibleWidth
		{
			get
			{
				return m_FlexibleWidth;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_FlexibleWidth, value))
				{
					SetDirty();
				}
			}
		}

		public virtual float flexibleHeight
		{
			get
			{
				return m_FlexibleHeight;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_FlexibleHeight, value))
				{
					SetDirty();
				}
			}
		}

		public virtual int layoutPriority
		{
			get
			{
				return m_LayoutPriority;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_LayoutPriority, value))
				{
					SetDirty();
				}
			}
		}

		public virtual void CalculateLayoutInputHorizontal()
		{
		}

		public virtual void CalculateLayoutInputVertical()
		{
		}

		protected LayoutElement()
		{
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			SetDirty();
		}

		protected override void OnTransformParentChanged()
		{
			SetDirty();
		}

		protected override void OnDisable()
		{
			SetDirty();
			base.OnDisable();
		}

		protected override void OnDidApplyAnimationProperties()
		{
			SetDirty();
		}

		protected override void OnBeforeTransformParentChanged()
		{
			SetDirty();
		}

		protected void SetDirty()
		{
			if (IsActive())
			{
				Transform transform = ((Component)this).transform;
				LayoutRebuilder.MarkLayoutForRebuild((RectTransform)(object)((transform is RectTransform) ? transform : null));
			}
		}
	}
	[DisallowMultipleComponent]
	[ExecuteAlways]
	[RequireComponent(typeof(RectTransform))]
	public abstract class LayoutGroup : UIBehaviour, ILayoutElement, ILayoutGroup, ILayoutController
	{
		[SerializeField]
		protected RectOffset m_Padding = new RectOffset();

		[SerializeField]
		protected TextAnchor m_ChildAlignment;

		[NonSerialized]
		private RectTransform m_Rect;

		protected DrivenRectTransformTracker m_Tracker;

		private Vector2 m_TotalMinSize = Vector2.zero;

		private Vector2 m_TotalPreferredSize = Vector2.zero;

		private Vector2 m_TotalFlexibleSize = Vector2.zero;

		[NonSerialized]
		private List<RectTransform> m_RectChildren = new List<RectTransform>();

		public RectOffset padding
		{
			get
			{
				return m_Padding;
			}
			set
			{
				SetProperty(ref m_Padding, value);
			}
		}

		public TextAnchor childAlignment
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_ChildAlignment;
			}
			set
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				SetProperty(ref m_ChildAlignment, value);
			}
		}

		protected RectTransform rectTransform
		{
			get
			{
				if ((Object)(object)m_Rect == (Object)null)
				{
					m_Rect = ((Component)this).GetComponent<RectTransform>();
				}
				return m_Rect;
			}
		}

		protected List<RectTransform> rectChildren => m_RectChildren;

		public virtual float minWidth => GetTotalMinSize(0);

		public virtual float preferredWidth => GetTotalPreferredSize(0);

		public virtual float flexibleWidth => GetTotalFlexibleSize(0);

		public virtual float minHeight => GetTotalMinSize(1);

		public virtual float preferredHeight => GetTotalPreferredSize(1);

		public virtual float flexibleHeight => GetTotalFlexibleSize(1);

		public virtual int layoutPriority => 0;

		private bool isRootLayoutGroup
		{
			get
			{
				if ((Object)(object)((Component)this).transform.parent == (Object)null)
				{
					return true;
				}
				return (Object)(object)((Component)((Component)this).transform.parent).GetComponent(typeof(ILayoutGroup)) == (Object)null;
			}
		}

		public virtual void CalculateLayoutInputHorizontal()
		{
			m_RectChildren.Clear();
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			for (int i = 0; i < ((Transform)rectTransform).childCount; i++)
			{
				Transform child = ((Transform)rectTransform).GetChild(i);
				RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
				if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy)
				{
					continue;
				}
				((Component)val).GetComponents(typeof(ILayoutIgnorer), list);
				if (list.Count == 0)
				{
					m_RectChildren.Add(val);
					continue;
				}
				for (int j = 0; j < list.Count; j++)
				{
					if (!((ILayoutIgnorer)list[j]).ignoreLayout)
					{
						m_RectChildren.Add(val);
						break;
					}
				}
			}
			CollectionPool<List<Component>, Component>.Release(list);
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
		}

		public abstract void CalculateLayoutInputVertical();

		public abstract void SetLayoutHorizontal();

		public abstract void SetLayoutVertical();

		protected LayoutGroup()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//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_0017: 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)
			//IL_0027: 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_0050: Expected O, but got Unknown
			if (m_Padding == null)
			{
				m_Padding = new RectOffset();
			}
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			SetDirty();
		}

		protected override void OnDisable()
		{
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
			base.OnDisable();
		}

		protected override void OnDidApplyAnimationProperties()
		{
			SetDirty();
		}

		protected float GetTotalMinSize(int axis)
		{
			return ((Vector2)(ref m_TotalMinSize))[axis];
		}

		protected float GetTotalPreferredSize(int axis)
		{
			return ((Vector2)(ref m_TotalPreferredSize))[axis];
		}

		protected float GetTotalFlexibleSize(int axis)
		{
			return ((Vector2)(ref m_TotalFlexibleSize))[axis];
		}

		protected float GetStartOffset(int axis, float requiredSpaceWithoutPadding)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			float num = requiredSpaceWithoutPadding + (float)((axis == 0) ? padding.horizontal : padding.vertical);
			Rect rect = rectTransform.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			float num2 = ((Vector2)(ref size))[axis] - num;
			float alignmentOnAxis = GetAlignmentOnAxis(axis);
			return (float)((axis == 0) ? padding.left : padding.top) + num2 * alignmentOnAxis;
		}

		protected float GetAlignmentOnAxis(int axis)
		{
			//IL_0014: 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_0004: 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)
			if (axis == 0)
			{
				return (float)(childAlignment % 3) * 0.5f;
			}
			return (float)(childAlignment / 3) * 0.5f;
		}

		protected void SetLayoutInputForAxis(float totalMin, float totalPreferred, float totalFlexible, int axis)
		{
			((Vector2)(ref m_TotalMinSize))[axis] = totalMin;
			((Vector2)(ref m_TotalPreferredSize))[axis] = totalPreferred;
			((Vector2)(ref m_TotalFlexibleSize))[axis] = totalFlexible;
		}

		protected void SetChildAlongAxis(RectTransform rect, int axis, float pos)
		{
			if (!((Object)(object)rect == (Object)null))
			{
				SetChildAlongAxisWithScale(rect, axis, pos, 1f);
			}
		}

		protected void SetChildAlongAxisWithScale(RectTransform rect, int axis, float pos, float scaleFactor)
		{
			//IL_0025: 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_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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rect == (Object)null))
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, rect, (DrivenTransformProperties)(0xF00 | ((axis == 0) ? 2 : 4)));
				rect.anchorMin = Vector2.up;
				rect.anchorMax = Vector2.up;
				Vector2 anchoredPosition = rect.anchoredPosition;
				Vector2 val;
				float num3;
				if (axis != 0)
				{
					float num = 0f - pos;
					val = rect.sizeDelta;
					float num2 = ((Vector2)(ref val))[axis];
					val = rect.pivot;
					num3 = num - num2 * (1f - ((Vector2)(ref val))[axis]) * scaleFactor;
				}
				else
				{
					val = rect.sizeDelta;
					float num4 = ((Vector2)(ref val))[axis];
					val = rect.pivot;
					num3 = pos + num4 * ((Vector2)(ref val))[axis] * scaleFactor;
				}
				((Vector2)(ref anchoredPosition))[axis] = num3;
				rect.anchoredPosition = anchoredPosition;
			}
		}

		protected void SetChildAlongAxis(RectTransform rect, int axis, float pos, float size)
		{
			if (!((Object)(object)rect == (Object)null))
			{
				SetChildAlongAxisWithScale(rect, axis, pos, size, 1f);
			}
		}

		protected void SetChildAlongAxisWithScale(RectTransform rect, int axis, float pos, float size, float scaleFactor)
		{
			//IL_002d: 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_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)
			//IL_0054: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rect == (Object)null))
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, rect, (DrivenTransformProperties)(0xF00 | ((axis == 0) ? 4098 : 8196)));
				rect.anchorMin = Vector2.up;
				rect.anchorMax = Vector2.up;
				Vector2 sizeDelta = rect.sizeDelta;
				((Vector2)(ref sizeDelta))[axis] = size;
				rect.sizeDelta = sizeDelta;
				Vector2 anchoredPosition = rect.anchoredPosition;
				Vector2 pivot;
				float num2;
				if (axis != 0)
				{
					float num = 0f - pos;
					pivot = rect.pivot;
					num2 = num - size * (1f - ((Vector2)(ref pivot))[axis]) * scaleFactor;
				}
				else
				{
					pivot = rect.pivot;
					num2 = pos + size * ((Vector2)(ref pivot))[axis] * scaleFactor;
				}
				((Vector2)(ref anchoredPosition))[axis] = num2;
				rect.anchoredPosition = anchoredPosition;
			}
		}

		protected override void OnRectTransformDimensionsChange()
		{
			base.OnRectTransformDimensionsChange();
			if (isRootLayoutGroup)
			{
				SetDirty();
			}
		}

		protected virtual void OnTransformChildrenChanged()
		{
			SetDirty();
		}

		protected void SetProperty<T>(ref T currentValue, T newValue)
		{
			if (currentValue == null && newValue == null)
			{
				return;
			}
			if (currentValue != null)
			{
				object obj = newValue;
				if (currentValue.Equals(obj))
				{
					return;
				}
			}
			currentValue = newValue;
			SetDirty();
		}

		protected void SetDirty()
		{
			if (IsActive())
			{
				if (!CanvasUpdateRegistry.IsRebuildingLayout())
				{
					LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
				}
				else
				{
					((MonoBehaviour)this).StartCoroutine(DelayedSetDirty(rectTransform));
				}
			}
		}

		private IEnumerator DelayedSetDirty(RectTransform rectTransform)
		{
			yield return null;
			LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
		}
	}
	public class LayoutRebuilder : ICanvasElement
	{
		private RectTransform m_ToRebuild;

		private int m_CachedHashFromTransform;

		private static ObjectPool<LayoutRebuilder> s_Rebuilders;

		public Transform transform => (Transform)(object)m_ToRebuild;

		private void Initialize(RectTransform controller)
		{
			m_ToRebuild = controller;
			m_CachedHashFromTransform = ((object)controller).GetHashCode();
		}

		private void Clear()
		{
			m_ToRebuild = null;
			m_CachedHashFromTransform = 0;
		}

		static LayoutRebuilder()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			s_Rebuilders = new ObjectPool<LayoutRebuilder>((Func<LayoutRebuilder>)(() => new LayoutRebuilder()), (Action<LayoutRebuilder>)null, (Action<LayoutRebuilder>)delegate(LayoutRebuilder x)
			{
				x.Clear();
			}, (Action<LayoutRebuilder>)null, true, 10, 10000);
			RectTransform.reapplyDrivenProperties += new ReapplyDrivenProperties(ReapplyDrivenProperties);
		}

		private static void ReapplyDrivenProperties(RectTransform driven)
		{
			MarkLayoutForRebuild(driven);
		}

		public bool IsDestroyed()
		{
			return (Object)(object)m_ToRebuild == (Object)null;
		}

		private static void StripDisabledBehavioursFromList(List<Component> components)
		{
			components.RemoveAll((Component e) => e is Behaviour && !((Behaviour)e).isActiveAndEnabled);
		}

		public static void ForceRebuildLayoutImmediate(RectTransform layoutRoot)
		{
			LayoutRebuilder layoutRebuilder = s_Rebuilders.Get();
			layoutRebuilder.Initialize(layoutRoot);
			layoutRebuilder.Rebuild(CanvasUpdate.Layout);
			s_Rebuilders.Release(layoutRebuilder);
		}

		public void Rebuild(CanvasUpdate executing)
		{
			if (executing == CanvasUpdate.Layout)
			{
				PerformLayoutCalculation(m_ToRebuild, delegate(Component e)
				{
					(e as ILayoutElement).CalculateLayoutInputHorizontal();
				});
				PerformLayoutControl(m_ToRebuild, delegate(Component e)
				{
					(e as ILayoutController).SetLayoutHorizontal();
				});
				PerformLayoutCalculation(m_ToRebuild, delegate(Component e)
				{
					(e as ILayoutElement).CalculateLayoutInputVertical();
				});
				PerformLayoutControl(m_ToRebuild, delegate(Component e)
				{
					(e as ILayoutController).SetLayoutVertical();
				});
			}
		}

		private void PerformLayoutControl(RectTransform rect, UnityAction<Component> action)
		{
			if ((Object)(object)rect == (Object)null)
			{
				return;
			}
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			((Component)rect).GetComponents(typeof(ILayoutController), list);
			StripDisabledBehavioursFromList(list);
			if (list.Count > 0)
			{
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i] is ILayoutSelfController)
					{
						action.Invoke(list[i]);
					}
				}
				for (int j = 0; j < list.Count; j++)
				{
					if (list[j] is ILayoutSelfController)
					{
						continue;
					}
					Component val = list[j];
					if (Object.op_Implicit((Object)(object)val) && val is ScrollRect)
					{
						if ((Object)(object)((ScrollRect)(object)val).content != (Object)(object)rect)
						{
							action.Invoke(list[j]);
						}
					}
					else
					{
						action.Invoke(list[j]);
					}
				}
				for (int k = 0; k < ((Transform)rect).childCount; k++)
				{
					Transform child = ((Transform)rect).GetChild(k);
					PerformLayoutControl((RectTransform)(object)((child is RectTransform) ? child : null), action);
				}
			}
			CollectionPool<List<Component>, Component>.Release(list);
		}

		private void PerformLayoutCalculation(RectTransform rect, UnityAction<Component> action)
		{
			if ((Object)(object)rect == (Object)null)
			{
				return;
			}
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			((Component)rect).GetComponents(typeof(ILayoutElement), list);
			StripDisabledBehavioursFromList(list);
			if (list.Count > 0 || Object.op_Implicit((Object)(object)((Component)rect).GetComponent(typeof(ILayoutGroup))))
			{
				for (int i = 0; i < ((Transform)rect).childCount; i++)
				{
					Transform child = ((Transform)rect).GetChild(i);
					PerformLayoutCalculation((RectTransform)(object)((child is RectTransform) ? child : null), action);
				}
				for (int j = 0; j < list.Count; j++)
				{
					action.Invoke(list[j]);
				}
			}
			CollectionPool<List<Component>, Component>.Release(list);
		}

		public static void MarkLayoutForRebuild(RectTransform rect)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect == (Object)null || (Object)(object)((Component)rect).gameObject == (Object)null)
			{
				return;
			}
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			bool flag = true;
			RectTransform val = rect;
			Transform parent = ((Transform)val).parent;
			RectTransform val2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			while (flag && !((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).gameObject == (Object)null))
			{
				flag = false;
				((Component)val2).GetComponents(typeof(ILayoutGroup), list);
				for (int i = 0; i < list.Count; i++)
				{
					Component val3 = list[i];
					if ((Object)(object)val3 != (Object)null && val3 is Behaviour && ((Behaviour)val3).isActiveAndEnabled)
					{
						flag = true;
						val = val2;
						break;
					}
				}
				Transform parent2 = ((Transform)val2).parent;
				val2 = (RectTransform)(object)((parent2 is RectTransform) ? parent2 : null);
			}
			if ((Object)(object)val == (Object)(object)rect && !ValidController(val, list))
			{
				CollectionPool<List<Component>, Component>.Release(list);
				return;
			}
			MarkLayoutRootForRebuild(val);
			CollectionPool<List<Component>, Component>.Release(list);
		}

		private static bool ValidController(RectTransform layoutRoot, List<Component> comps)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)layoutRoot == (Object)null || (Object)(object)((Component)layoutRoot).gameObject == (Object)null)
			{
				return false;
			}
			((Component)layoutRoot).GetComponents(typeof(ILayoutController), comps);
			for (int i = 0; i < comps.Count; i++)
			{
				Component val = comps[i];
				if ((Object)(object)val != (Object)null && val is Behaviour && ((Behaviour)val).isActiveAndEnabled)
				{
					return true;
				}
			}
			return false;
		}

		private static void MarkLayoutRootForRebuild(RectTransform controller)
		{
			if (!((Object)(object)controller == (Object)null))
			{
				LayoutRebuilder layoutRebuilder = s_Rebuilders.Get();
				layoutRebuilder.Initialize(controller);
				if (!CanvasUpdateRegistry.TryRegisterCanvasElementForLayoutRebuild(layoutRebuilder))
				{
					s_Rebuilders.Release(layoutRebuilder);
				}
			}
		}

		public void LayoutComplete()
		{
			s_Rebuilders.Release(this);
		}

		public void GraphicUpdateComplete()
		{
		}

		public override int GetHashCode()
		{
			return m_CachedHashFromTransform;
		}

		public override bool Equals(object obj)
		{
			return obj.GetHashCode() == GetHashCode();
		}

		public override string ToString()
		{
			return "(Layout Rebuilder for) " + (object)m_ToRebuild;
		}
	}
	public static class LayoutUtility
	{
		public static float GetMinSize(RectTransform rect, int axis)
		{
			if (axis != 0)
			{
				return GetMinHeight(rect);
			}
			return GetMinWidth(rect);
		}

		public static float GetPreferredSize(RectTransform rect, int axis)
		{
			if (axis != 0)
			{
				return GetPreferredHeight(rect);
			}
			return GetPreferredWidth(rect);
		}

		public static float GetFlexibleSize(RectTransform rect, int axis)
		{
			if (axis != 0)
			{
				return GetFlexibleHeight(rect);
			}
			return GetFlexibleWidth(rect);
		}

		public static float GetMinWidth(RectTransform rect)
		{
			return GetLayoutProperty(rect, (ILayoutElement e) => e.minWidth, 0f);
		}

		public static float GetPreferredWidth(RectTransform rect)
		{
			return Mathf.Max(GetLayoutProperty(rect, (ILayoutElement e) => e.minWidth, 0f), GetLayoutProperty(rect, (ILayoutElement e) => e.preferredWidth, 0f));
		}

		public static float GetFlexibleWidth(RectTransform rect)
		{
			return GetLayoutProperty(rect, (ILayoutElement e) => e.flexibleWidth, 0f);
		}

		public static float GetMinHeight(RectTransform rect)
		{
			return GetLayoutProperty(rect, (ILayoutElement e) => e.minHeight, 0f);
		}

		public static float GetPreferredHeight(RectTransform rect)
		{
			return Mathf.Max(GetLayoutProperty(rect, (ILayoutElement e) => e.minHeight, 0f), GetLayoutProperty(rect, (ILayoutElement e) => e.preferredHeight, 0f));
		}

		public static float GetFlexibleHeight(RectTransform rect)
		{
			return GetLayoutProperty(rect, (ILayoutElement e) => e.flexibleHeight, 0f);
		}

		public static float GetLayoutProperty(RectTransform rect, Func<ILayoutElement, float> property, float defaultValue)
		{
			ILayoutElement source;
			return GetLayoutProperty(rect, property, defaultValue, out source);
		}

		public static float GetLayoutProperty(RectTransform rect, Func<ILayoutElement, float> property, float defaultValue, out ILayoutElement source)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			source = null;
			if ((Object)(object)rect == (Object)null)
			{
				return 0f;
			}
			float num = defaultValue;
			int num2 = int.MinValue;
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			((Component)rect).GetComponents(typeof(ILayoutElement), list);
			int count = list.Count;
			for (int i = 0; i < count; i++)
			{
				ILayoutElement layoutElement = list[i] as ILayoutElement;
				if (layoutElement is Behaviour && !((Behaviour)layoutElement).isActiveAndEnabled)
				{
					continue;
				}
				int layoutPriority = layoutElement.layoutPriority;
				if (layoutPriority < num2)
				{
					continue;
				}
				float num3 = property(layoutElement);
				if (!(num3 < 0f))
				{
					if (layoutPriority > num2)
					{
						num = num3;
						num2 = layoutPriority;
						source = layoutElement;
					}
					else if (num3 > num)
					{
						num = num3;
						source = layoutElement;
					}
				}
			}
			CollectionPool<List<Component>, Component>.Release(list);
			return num;
		}
	}
	[AddComponentMenu("Layout/Vertical Layout Group", 151)]
	public class VerticalLayoutGroup : HorizontalOrVerticalLayoutGroup
	{
		protected VerticalLayoutGroup()
		{
		}

		public override void CalculateLayoutInputHorizontal()
		{
			base.CalculateLayoutInputHorizontal();
			CalcAlongAxis(0, isVertical: true);
		}

		public override void CalculateLayoutInputVertical()
		{
			CalcAlongAxis(1, isVertical: true);
		}

		public override void SetLayoutHorizontal()
		{
			SetChildrenAlongAxis(0, isVertical: true);
		}

		public override void SetLayoutVertical()
		{
			SetChildrenAlongAxis(1, isVertical: true);
		}
	}
	[AddComponentMenu("UI/Mask", 13)]
	[ExecuteAlways]
	[RequireComponent(typeof(RectTransform))]
	[DisallowMultipleComponent]
	public class Mask : UIBehaviour, ICanvasRaycastFilter, IMaterialModifier
	{
		[NonSerialized]
		private RectTransform m_RectTransform;

		[SerializeField]
		private bool m_ShowMaskGraphic = true;

		[NonSerialized]
		private Graphic m_Graphic;

		[NonSerialized]
		private Material m_MaskMaterial;

		[NonSerialized]
		private Material m_UnmaskMaterial;

		public RectTransform rectTransform => m_RectTransform ?? (m_RectTransform = ((Component)this).GetComponent<RectTransform>());

		public bool showMaskGraphic
		{
			get
			{
				return m_ShowMaskGraphic;
			}
			set
			{
				if (m_ShowMaskGraphic != value)
				{
					m_ShowMaskGraphic = value;
					if ((Object)(object)graphic != (Object)null)
					{
						graphic.SetMaterialDirty();
					}
				}
			}
		}

		public Graphic graphic => m_Graphic ?? (m_Graphic = ((Component)this).GetComponent<Graphic>());

		protected Mask()
		{
		}

		public virtual bool MaskEnabled()
		{
			if (IsActive())
			{
				return (Object)(object)graphic != (Object)null;
			}
			return false;
		}

		[Obsolete("Not used anymore.")]
		public virtual void OnSiblingGraphicEnabledDisabled()
		{
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			if ((Object)(object)graphic != (Object)null)
			{
				graphic.canvasRenderer.hasPopInstruction = true;
				graphic.SetMaterialDirty();
				if (graphic is MaskableGraphic)
				{
					(graphic as MaskableGraphic).isMaskingGraphic = true;
				}
			}
			MaskUtilities.NotifyStencilStateChanged((Component)(object)this);
		}

		protected override void OnDisable()
		{
			base.OnDisable();
			if ((Object)(object)graphic != (Object)null)
			{
				graphic.SetMaterialDirty();
				graphic.canvasRenderer.hasPopInstruction = false;
				graphic.canvasRenderer.popMaterialCount = 0;
				if (graphic is MaskableGraphic)
				{
					(graphic as MaskableGraphic).isMaskingGraphic = false;
				}
			}
			StencilMaterial.Remove(m_MaskMaterial);
			m_MaskMaterial = null;
			StencilMaterial.Remove(m_UnmaskMaterial);
			m_UnmaskMaterial = null;
			MaskUtilities.NotifyStencilStateChanged((Component)(object)this);
		}

		public virtual bool IsRaycastLocationValid(Vector2 sp, Camera eventCamera)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!((Behaviour)this).isActiveAndEnabled)
			{
				return true;
			}
			return RectTransformUtility.RectangleContainsScreenPoint(rectTransform, sp, eventCamera);
		}

		public virtual Material GetModifiedMaterial(Material baseMaterial)
		{
			if (!MaskEnabled())
			{
				return baseMaterial;
			}
			Transform stopAfter = MaskUtilities.FindRootSortOverrideCanvas(((Component)this).transform);
			int stencilDepth = MaskUtilities.GetStencilDepth(((Component)this).transform, stopAfter);
			if (stencilDepth >= 8)
			{
				Debug.LogWarning((object)"Attempting to use a stencil mask with depth > 8", (Object)(object)((Component)this).gameObject);
				return baseMaterial;
			}
			int num = 1 << stencilDepth;
			if (num == 1)
			{
				Material maskMaterial = StencilMaterial.Add(baseMaterial, 1, (StencilOp)2, (CompareFunction)8, (ColorWriteMask)(m_ShowMaskGraphic ? 15 : 0));
				StencilMaterial.Remove(m_MaskMaterial);
				m_MaskMaterial = maskMaterial;
				Material unmaskMaterial = StencilMaterial.Add(baseMaterial, 1, (StencilOp)1, (CompareFunction)8, (ColorWriteMask)0);
				StencilMaterial.Remove(m_UnmaskMaterial);
				m_UnmaskMaterial = unmaskMaterial;
				graphic.canvasRenderer.popMaterialCount = 1;
				graphic.canvasRenderer.SetPopMaterial(m_UnmaskMaterial, 0);
				return m_MaskMaterial;
			}
			Material maskMaterial2 = StencilMaterial.Add(baseMaterial, num | (num - 1), (StencilOp)2, (CompareFunction)3, (ColorWriteMask)(m_ShowMaskGraphic ? 15 : 0), num - 1, num | (num - 1));
			StencilMaterial.Remove(m_MaskMaterial);
			m_MaskMaterial = maskMaterial2;
			graphic.canvasRenderer.hasPopInstruction = true;
			Material unmaskMaterial2 = StencilMaterial.Add(baseMaterial, num - 1, (StencilOp)2, (CompareFunction)3, (ColorWriteMask)0, num - 1, num | (num - 1));
			StencilMaterial.Remove(m_UnmaskMaterial);
			m_UnmaskMaterial = unmaskMaterial2;
			graphic.canvasRenderer.popMaterialCount = 1;
			graphic.canvasRenderer.SetPopMaterial(m_UnmaskMaterial, 0);
			return m_MaskMaterial;
		}
	}
	public abstract class MaskableGraphic : Graphic, IClippable, IMaskable, IMaterialModifier
	{
		[Serializable]
		public class CullStateChangedEvent : UnityEvent<bool>
		{
		}

		[NonSerialized]
		protected bool m_ShouldRecalculateStencil = true;

		[NonSerialized]
		protected Material m_MaskMaterial;

		[NonSerialized]
		private RectMask2D m_ParentMask;

		[SerializeField]
		private bool m_Maskable = true;

		private bool m_IsMaskingGraphic;

		[NonSerialized]
		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Not used anymore.", true)]
		protected bool m_IncludeForMasking;

		[SerializeField]
		private CullStateChangedEvent m_OnCullStateChanged = new CullStateChangedEvent();

		[NonSerialized]
		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Not used anymore", true)]
		protected bool m_ShouldRecalculate = true;

		[NonSerialized]
		protected int m_StencilValue;

		private readonly Vector3[] m_Corners = (Vector3[])(object)new Vector3[4];

		public CullStateChangedEvent onCullStateChanged
		{
			get
			{
				return m_OnCullStateChanged;
			}
			set
			{
				m_OnCullStateChanged = value;
			}
		}

		public bool maskable
		{
			get
			{
				return m_Maskable;
			}
			set
			{
				if (value != m_Maskable)
				{
					m_Maskable = value;
					m_ShouldRecalculateStencil = true;
					SetMaterialDirty();
				}
			}
		}

		public bool isMaskingGraphic
		{
			get
			{
				return m_IsMaskingGraphic;
			}
			set
			{
				if (value != m_IsMaskingGraphic)
				{
					m_IsMaskingGraphic = value;
				}
			}
		}

		private Rect rootCanvasRect
		{
			get
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: 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_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_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_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: 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)
				base.rectTransform.GetWorldCorners(m_Corners);
				if (Object.op_Implicit((Object)(object)base.canvas))
				{
					Matrix4x4 worldToLocalMatrix = ((Component)base.canvas.rootCanvas).transform.worldToLocalMatrix;
					for (int i = 0; i < 4; i++)
					{
						m_Corners[i] = ((Matrix4x4)(ref worldToLocalMatrix)).MultiplyPoint(m_Corners[i]);
					}
				}
				Vector2 val = Vector2.op_Implicit(m_Corners[0]);
				Vector2 val2 = Vector2.op_Implicit(m_Corners[0]);
				for (int j = 1; j < 4; j++)
				{
					val.x = Mathf.Min(m_Corners[j].x, val.x);
					val.y = Mathf.Min(m_Corners[j].y, val.y);
					val2.x = Mathf.Max(m_Corners[j].x, val2.x);
					val2.y = Mathf.Max(m_Corners[j].y, val2.y);
				}
				return new Rect(val, val2 - val);
			}
		}

		public virtual Material GetModifiedMaterial(Material baseMaterial)
		{
			Material val = baseMaterial;
			if (m_ShouldRecalculateStencil)
			{
				if (maskable)
				{
					Transform stopAfter = MaskUtilities.FindRootSortOverrideCanvas(((Component)this).transform);
					m_StencilValue = MaskUtilities.GetStencilDepth(((Component)this).transform, stopAfter);
				}
				else
				{
					m_StencilValue = 0;
				}
				m_ShouldRecalculateStencil = false;
			}
			if (m_StencilValue > 0 && !isMaskingGraphic)
			{
				Material maskMaterial = StencilMaterial.Add(val, (1 << m_StencilValue) - 1, (StencilOp)0, (CompareFunction)3, (ColorWriteMask)15, (1 << m_StencilValue) - 1, 0);
				StencilMaterial.Remove(m_MaskMaterial);
				m_MaskMaterial = maskMaterial;
				val = m_MaskMaterial;
			}
			return val;
		}

		public virtual void Cull(Rect clipRect, bool validRect)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			bool cull = !validRect || !((Rect)(ref clipRect)).Overlaps(rootCanvasRect, true);
			UpdateCull(cull);
		}

		private void UpdateCull(bool cull)
		{
			if (base.canvasRenderer.cull != cull)
			{
				base.canvasRenderer.cull = cull;
				UISystemProfilerApi.AddMarker("MaskableGraphic.cullingChanged", (Object)(object)this);
				((UnityEvent<bool>)m_OnCullStateChanged).Invoke(cull);
				OnCullingChanged();
			}
		}

		public virtual void SetClipRect(Rect clipRect, bool validRect)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (validRect)
			{
				base.canvasRenderer.EnableRectClipping(clipRect);
			}
			else
			{
				base.canvasRenderer.DisableRectClipping();
			}
		}

		public virtual void SetClipSoftness(Vector2 clipSoftness)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			base.canvasRenderer.clippingSoftness = clipSoftness;
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			m_ShouldRecalculateStencil = true;
			UpdateClipParent();
			SetMaterialDirty();
			if (isMaskingGraphic)
			{
				MaskUtilities.NotifyStencilStateChanged((Component)(object)this);
			}
		}

		protected override void OnDisable()
		{
			base.OnDisable();
			m_ShouldRecalculateStencil = true;
			SetMaterialDirty();
			UpdateClipParent();
			StencilMaterial.Remove(m_MaskMaterial);
			m_MaskMaterial = null;
			if (isMaskingGraphic)
			{
				MaskUtilities.NotifyStencilStateChanged((Component)(object)this);
			}
		}

		protected override void OnTransformParentChanged()
		{
			base.OnTransformParentChanged();
			if (((Behaviour)this).isActiveAndEnabled)
			{
				m_ShouldRecalculateStencil = true;
				UpdateClipParent();
				SetMaterialDirty();
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Not used anymore.", true)]
		public virtual void ParentMaskStateChanged()
		{
		}

		protected override void OnCanvasHierarchyChanged()
		{
			base.OnCanvasHierarchyChanged();
			if (((Behaviour)this).isActiveAndEnabled)
			{
				m_ShouldRecalculateStencil = true;
				UpdateClipParent();
				SetMaterialDirty();
			}
		}

		private void UpdateClipParent()
		{
			RectMask2D rectMask2D = ((maskable && IsActive()) ? MaskUtilities.GetRectMaskForClippable(this) : null);
			if ((Object)(object)m_ParentMask != (Object)null && ((Object)(object)rectMask2D != (Object)(object)m_ParentMask || !rectMask2D.IsActive()))
			{
				m_ParentMask.RemoveClippable(this);
				UpdateCull(cull: false);
			}
			if ((Object)(object)rectMask2D != (Object)null && rectMask2D.IsActive())
			{
				rectMask2D.AddClippable(this);
			}
			m_ParentMask = rectMask2D;
		}

		public virtual void RecalculateClipping()
		{
			UpdateClipParent();
		}

		public virtual void RecalculateMasking()
		{
			StencilMaterial.Remove(m_MaskMaterial);
			m_MaskMaterial = null;
			m_ShouldRecalculateStencil = true;
			SetMaterialDirty();
		}

		[SpecialName]
		GameObject IClippable.get_gameObject()
		{
			return ((Component)this).gameObject;
		}
	}
	public class MaskUtilities
	{
		public static void Notify2DMaskStateChanged(Component mask)
		{
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			mask.GetComponentsInChildren<Component>(list);
			for (int i = 0; i < list.Count; i++)
			{
				if (!((Object)(object)list[i] == (Object)null) && !((Object)(object)list[i].gameObject == (Object)(object)mask.gameObject) && list[i] is IClippable clippable)
				{
					clippable.RecalculateClipping();
				}
			}
			CollectionPool<List<Component>, Component>.Release(list);
		}

		public static void NotifyStencilStateChanged(Component mask)
		{
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			mask.GetComponentsInChildren<Component>(list);
			for (int i = 0; i < list.Count; i++)
			{
				if (!((Object)(object)list[i] == (Object)null) && !((Object)(object)list[i].gameObject == (Object)(object)mask.gameObject) && list[i] is IMaskable maskable)
				{
					maskable.RecalculateMasking();
				}
			}
			CollectionPool<List<Component>, Component>.Release(list);
		}

		public static Transform FindRootSortOverrideCanvas(Transform start)
		{
			List<Canvas> list = CollectionPool<List<Canvas>, Canvas>.Get();
			((Component)start).GetComponentsInParent<Canvas>(false, list);
			Canvas val = null;
			for (int i = 0; i < list.Count; i++)
			{
				val = list[i];
				if (val.overrideSorting)
				{
					break;
				}
			}
			CollectionPool<List<Canvas>, Canvas>.Release(list);
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).transform;
		}

		public static int GetStencilDepth(Transform transform, Transform stopAfter)
		{
			int num = 0;
			if ((Object)(object)transform == (Object)(object)stopAfter)
			{
				return num;
			}
			Transform parent = transform.parent;
			List<Mask> list = CollectionPool<List<Mask>, Mask>.Get();
			while ((Object)(object)parent != (Object)null)
			{
				((Component)parent).GetComponents<Mask>(list);
				for (int i = 0; i < list.Count; i++)
				{
					if ((Object)(object)list[i] != (Object)null && list[i].MaskEnabled() && list[i].graphic.IsActive())
					{
						num++;
						break;
					}
				}
				if ((Object)(object)parent == (Object)(object)stopAfter)
				{
					break;
				}
				parent = parent.parent;
			}
			CollectionPool<List<Mask>, Mask>.Release(list);
			return num;
		}

		public static bool IsDescendantOrSelf(Transform father, Transform child)
		{
			if ((Object)(object)father == (Object)null || (Object)(object)child == (Object)null)
			{
				return false;
			}
			if ((Object)(object)father == (Object)(object)child)
			{
				return true;
			}
			while ((Object)(object)child.parent != (Object)null)
			{
				if ((Object)(object)child.parent == (Object)(object)father)
				{
					return true;
				}
				child = child.parent;
			}
			return false;
		}

		public static RectMask2D GetRectMaskForClippable(IClippable clippable)
		{
			List<RectMask2D> list = CollectionPool<List<RectMask2D>, RectMask2D>.Get();
			List<Canvas> list2 = CollectionPool<List<Canvas>, Canvas>.Get();
			RectMask2D rectMask2D = null;
			clippable.gameObject.GetComponentsInParent<RectMask2D>(false, list);
			if (list.Count > 0)
			{
				for (int i = 0; i < list.Count; i++)
				{
					rectMask2D = list[i];
					if ((Object)(object)((Component)rectMask2D).gameObject == (Object)(object)clippable.gameObject)
					{
						rectMask2D = null;
						continue;
					}
					if (!((Behaviour)rectMask2D).isActiveAndEnabled)
					{
						rectMask2D = null;
						continue;
					}
					clippable.gameObject.GetComponentsInParent<Canvas>(false, list2);
					for (int num = list2.Count - 1; num >= 0; num--)
					{
						if (!IsDescendantOrSelf(((Component)list2[num]).transform, ((Component)rectMask2D).transform) && list2[num].overrideSorting)
						{
							rectMask2D = null;
							break;
						}
					}
					break;
				}
			}
			CollectionPool<List<RectMask2D>, RectMask2D>.Release(list);
			CollectionPool<List<Canvas>, Canvas>.Release(list2);
			return rectMask2D;
		}

		public static void GetRectMasksForClip(RectMask2D clipper, List<RectMask2D> masks)
		{
			masks.Clear();
			List<Canvas> list = CollectionPool<List<Canvas>, Canvas>.Get();
			List<RectMask2D> list2 = CollectionPool<List<RectMask2D>, RectMask2D>.Get();
			((Component)((Component)clipper).transform).GetComponentsInParent<RectMask2D>(false, list2);
			if (list2.Count > 0)
			{
				((Component)((Component)clipper).transform).GetComponentsInParent<Canvas>(false, list);
				for (int num = list2.Count - 1; num >= 0; num--)
				{
					if (list2[num].IsActive())
					{
						bool flag = true;
						for (int num2 = list.Count - 1; num2 >= 0; num2--)
						{
							if (!IsDescendantOrSelf(((Component)list[num2]).transform, ((Component)list2[num]).transform) && list[num2].overrideSorting)
							{
								flag = false;
								break;
							}
						}
						if (flag)
						{
							masks.Add(list2[num]);
						}
					}
				}
			}
			CollectionPool<List<RectMask2D>, RectMask2D>.Release(list2);
			CollectionPool<List<Canvas>, Canvas>.Release(list);
		}
	}
	public interface IMaterialModifier
	{
		Material GetModifiedMaterial(Material baseMaterial);
	}
	internal static class Misc
	{
		public static void Destroy(Object obj)
		{
			if (!(obj != (Object)null))
			{
				return;
			}
			if (Application.isPlaying)
			{
				if (obj is GameObject)
				{
					((GameObject)((obj is GameObject) ? obj : null)).transform.parent = null;
				}
				Object.Destroy(obj);
			}
			else
			{
				Object.DestroyImmediate(obj);
			}
		}

		public static void DestroyImmediate(Object obj)
		{
			if (obj != (Object)null)
			{
				if (Application.isEditor)
				{
					Object.DestroyImmediate(obj);
				}
				else
				{
					Object.Destroy(obj);
				}
			}
		}
	}
	internal static class MultipleDisplayUtilities
	{
		public static bool GetRelativeMousePositionForDrag(PointerEventData eventData, ref Vector2 position)
		{
			//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)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0031: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			int displayIndex = eventData.pointerPressRaycast.displayIndex;
			Vector3 val = RelativeMouseAtScaled(eventData.position);
			if ((int)val.z != displayIndex)
			{
				return false;
			}
			position = ((displayIndex != 0) ? Vector2.op_Implicit(val) : eventData.position);
			return true;
		}

		public static Vector3 RelativeMouseAtScaled(Vector2 position)
		{
			//IL_0064: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: 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)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_011d: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: 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_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: 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_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			if (Display.main.renderingWidth != Display.main.systemWidth || Display.main.renderingHeight != Display.main.systemHeight)
			{
				float num = (float)Display.main.systemWidth / (float)Display.main.systemHeight;
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor((float)Display.main.renderingWidth, (float)Display.main.renderingHeight);
				Vector2 zero = Vector2.zero;
				if (Screen.fullScreen)
				{
					float num2 = (float)Screen.width / (float)Screen.height;
					if ((float)Display.main.systemHeight * num2 < (float)Display.main.systemWidth)
					{
						val.x = (float)Display.main.renderingHeight * num;
						zero.x = (val.x - (float)Display.main.renderingWidth) * 0.5f;
					}
					else
					{
						val.y = (float)Display.main.renderingWidth / num;
						zero.y = (val.y - (float)Display.main.renderingHeight) * 0.5f;
					}
				}
				Vector2 val2 = val - zero;
				if (position.y < 0f - zero.y || position.y > val2.y || position.x < 0f - zero.x || position.x > val2.x)
				{
					Vector2 val3 = position;
					if (!Screen.fullScreen)
					{
						val3.x -= (float)(Display.main.renderingWidth - Display.main.systemWidth) * 0.5f;
						val3.y -= (float)(Display.main.renderingHeight - Display.main.systemHeight) * 0.5f;
					}
					else
					{
						val3 += zero;
						val3.x *= (float)Display.main.systemWidth / val.x;
						val3.y *= (float)Display.main.systemHeight / val.y;
					}
					Vector3 val4 = Display.RelativeMouseAt(Vector2.op_Implicit(val3));
					if (val4.z != 0f)
					{
						return val4;
					}
				}
				return new Vector3(position.x, position.y, 0f);
			}
			return Display.RelativeMouseAt(Vector2.op_Implicit(position));
		}
	}
	[Serializable]
	public struct Navigation : IEquatable<Navigation>
	{
		[Flags]
		public enum Mode
		{
			None = 0,
			Horizontal = 1,
			Vertical = 2,
			Automatic = 3,
			Explicit = 4
		}

		[SerializeField]
		private Mode m_Mode;

		[Tooltip("Enables navigation to wrap around from last to first or first to last element. Does not work for automatic grid navigation")]
		[SerializeField]
		private bool m_WrapAround;

		[SerializeField]
		private Selectable m_SelectOnUp;

		[SerializeField]
		private Selectable m_SelectOnDown;

		[SerializeField]
		private Selectable m_SelectOnLeft;

		[SerializeField]
		private Selectable m_SelectOnRight;

		public Mode mode
		{
			get
			{
				return m_Mode;
			}
			set
			{
				m_Mode = value;
			}
		}

		public bool wrapAround
		{
			get
			{
				return m_WrapAround;
			}
			set
			{
				m_WrapAround = value;
			}
		}

		public Selectable selectOnUp
		{
			get
			{
				return m_SelectOnUp;
			}
			set
			{
				m_SelectOnUp = value;
			}
		}

		public Selectable selectOnDown
		{
			get
			{
				return m_SelectOnDown;
			}
			set
			{
				m_SelectOnDown = value;
			}
		}

		public Selectable selectOnLeft
		{
			get
			{
				return m_SelectOnLeft;
			}
			set
			{
				m_SelectOnLeft = value;
			}
		}

		public Selectable selectOnRight
		{
			get
			{
				return m_SelectOnRight;
			}
			set
			{
				m_SelectOnRight = value;
			}
		}

		public static Navigation defaultNavigation => new Navigation
		{
			m_Mode = Mode.Automatic,
			m_WrapAround = false
		};

		public bool Equals(Navigation other)
		{
			if (mode == other.mode && (Object)(object)selectOnUp == (Object)(object)other.selectOnUp && (Object)(object)selectOnDown == (Object)(object)other.selectOnDown && (Object)(object)selectOnLeft == (Object)(object)other.selectOnLeft)
			{
				return (Object)(object)selectOnRight == (Object)(object)other.selectOnRight;
			}
			return false;
		}
	}
	[RequireComponent(typeof(CanvasRenderer))]
	[AddComponentMenu("UI/Raw Image", 12)]
	public class RawImage : MaskableGraphic
	{
		[FormerlySerializedAs("m_Tex")]
		[SerializeField]
		private Texture m_Texture;

		[SerializeField]
		private Rect m_UVRect = new Rect(0f, 0f, 1f, 1f);

		public override Texture mainTexture
		{
			get
			{
				if ((Object)(object)m_Texture == (Object)null)
				{
					if ((Object)(object)material != (Object)null && (Object)(object)material.mainTexture != (Object)null)
					{
						return material.mainTexture;
					}
					return (Texture)(object)Graphic.s_WhiteTexture;
				}
				return m_Texture;
			}
		}

		public Texture texture
		{
			get
			{
				return m_Texture;
			}
			set
			{
				if (!((Object)(object)m_Texture == (Object)(object)value))
				{
					m_Texture = value;
					SetVerticesDirty();
					SetMaterialDirty();
				}
			}
		}

		public Rect uvRect
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_UVRect;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				if (!(m_UVRect == value))
				{
					m_UVRect = value;
					SetVerticesDirty();
				}
			}
		}

		protected RawImage()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			base.useLegacyMeshGeneration = false;
		}

		public override void SetNativeSize()
		{
			//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_0034: 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_0054: 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)
			Texture val = mainTexture;
			if ((Object)(object)val != (Object)null)
			{
				float num = val.width;
				Rect val2 = uvRect;
				int num2 = Mathf.RoundToInt(num * ((Rect)(ref val2)).width);
				float num3 = val.height;
				val2 = uvRect;
				int num4 = Mathf.RoundToInt(num3 * ((Rect)(ref val2)).height);
				base.rectTransform.anchorMax = base.rectTransform.anchorMin;
				base.rectTransform.sizeDelta = new Vector2((float)num2, (float)num4);
			}
		}

		protected override void OnPopulateMesh(VertexHelper vh)
		{
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: 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_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			Texture val = mainTexture;
			vh.Clear();
			if ((Object)(object)val != (Object)null)
			{
				Rect pixelAdjustedRect = GetPixelAdjustedRect();
				Vector4 val2 = default(Vector4);
				((Vector4)(ref val2))..ctor(((Rect)(ref pixelAdjustedRect)).x, ((Rect)(ref pixelAdjustedRect)).y, ((Rect)(ref pixelAdjustedRect)).x + ((Rect)(ref pixelAdjustedRect)).width, ((Rect)(ref pixelAdjustedRect)).y + ((Rect)(ref pixelAdjustedRect)).height);
				float num = (float)val.width * val.texelSize.x;
				float num2 = (float)val.height * val.texelSize.y;
				Color val3 = color;
				vh.AddVert(new Vector3(val2.x, val2.y), Color32.op_Implicit(val3), Vector4.op_Implicit(new Vector2(((Rect)(ref m_UVRect)).xMin * num, ((Rect)(ref m_UVRect)).yMin * num2)));
				vh.AddVert(new Vector3(val2.x, val2.w), Color32.op_Implicit(val3), Vector4.op_Implicit(new Vector2(((Rect)(ref m_UVRect)).xMin * num, ((Rect)(ref m_UVRect)).yMax * num2)));
				vh.AddVert(new Vector3(val2.z, val2.w), Color32.op_Implicit(val3), Vector4.op_Implicit(new Vector2(((Rect)(ref m_UVRect)).xMax * num, ((Rect)(ref m_UVRect)).yMax * num2)));
				vh.AddVert(new Vector3(val2.z, val2.y), Color32.op_Implicit(val3), Vector4.op_Implicit(new Vector2(((Rect)(ref m_UVRect)).xMax * num, ((Rect)(ref m_UVRect)).yMin * num2)));
				vh.AddTriangle(0, 1, 2);
				vh.AddTriangle(2, 3, 0);
			}
		}

		protected override void OnDidApplyAnimationProperties()
		{
			SetMaterialDirty();
			SetVerticesDirty();
			SetRaycastDirty();
		}
	}
	[AddComponentMenu("UI/Rect Mask 2D", 14)]
	[ExecuteAlways]
	[DisallowMultipleComponent]
	[RequireComponent(typeof(RectTransform))]
	public class RectMask2D : UIBehaviour, IClipper, ICanvasRaycastFilter
	{
		[NonSerialized]
		private readonly RectangularVertexClipper m_VertexClipper = new RectangularVertexClipper();

		[NonSerialized]
		private RectTransform m_RectTransform;

		[NonSerialized]
		private HashSet<MaskableGraphic> m_MaskableTargets = new HashSet<MaskableGraphic>();

		[NonSerialized]
		private HashSet<IClippable> m_ClipTargets = new HashSet<IClippable>();

		[NonSerialized]
		private bool m_ShouldRecalculateClipRects;

		[NonSerialized]
		private List<RectMask2D> m_Clippers = new List<RectMask2D>();

		[NonSerialized]
		private Rect m_LastClipRectCanvasSpace;

		[NonSerialized]
		private bool m_ForceClip;

		[SerializeField]
		private Vector4 m_Padding;

		[SerializeField]
		private Vector2Int m_Softness;

		[NonSerialized]
		private Canvas m_Canvas;

		private Vector3[] m_Corners = (Vector3[])(object)new Vector3[4];

		public Vector4 padding
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_Padding;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_Padding = value;
				MaskUtilities.Notify2DMaskStateChanged((Component)(object)this);
			}
		}

		public Vector2Int softness
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_Softness;
			}
			set
			{
				((Vector2Int)(ref m_Softness)).x = Mathf.Max(0, ((Vector2Int)(ref value)).x);
				((Vector2Int)(ref m_Softness)).y = Mathf.Max(0, ((Vector2Int)(ref value)).y);
				MaskUtilities.Notify2DMaskStateChanged((Component)(object)this);
			}
		}

		internal Canvas Canvas
		{
			get
			{
				if ((Object)(object)m_Canvas == (Object)null)
				{
					List<Canvas> list = CollectionPool<List<Canvas>, Canvas>.Get();
					((Component)this).gameObject.GetComponentsInParent<Canvas>(false, list);
					if (list.Count > 0)
					{
						m_Canvas = list[list.Count - 1];
					}
					else
					{
						m_Canvas = null;
					}
					CollectionPool<List<Canvas>, Canvas>.Release(list);
				}
				return m_Canvas;
			}
		}

		public Rect canvasRect => m_VertexClipper.GetCanvasRect(rectTransform, Canvas);

		public RectTransform rectTransform => m_RectTransform ?? (m_RectTransform = ((Component)this).GetComponent<RectTransform>());

		private Rect rootCanvasRect
		{
			get
			{
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				rectTransform.GetWorldCorners(m_Corners);
				if (Canvas != null)
				{
					Canvas rootCanvas = Canvas.rootCanvas;
					for (int i = 0; i < 4; i++)
					{
						m_Corners[i] = ((Component)rootCanvas).transform.InverseTransformPoint(m_Corners[i]);
					}
				}
				return new Rect(m_Corners[0].x, m_Corners[0].y, m_Corners[2].x - m_Corners[0].x, m_Corners[2].y - m_Corners[0].y);
			}
		}

		protected RectMask2D()
		{
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			m_ShouldRecalculateClipRects = true;
			ClipperRegistry.Register(this);
			MaskUtilities.Notify2DMaskStateChanged((Component)(object)this);
		}

		protected override void OnDisable()
		{
			base.OnDisable();
			m_ClipTargets.Clear();
			m_MaskableTargets.Clear();
			m_Clippers.Clear();
			ClipperRegistry.Disable(this);
			MaskUtilities.Notify2DMaskStateChanged((Component)(object)this);
		}

		protected override void OnDestroy()
		{
			ClipperRegistry.Unregister(this);
			base.OnDestroy();
		}

		public virtual bool IsRaycastLocationValid(Vector2 sp, Camera eventCamera)
		{
			//IL_0010: 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)
			if (!((Behaviour)this).isActiveAndEnabled)
			{
				return true;
			}
			return RectTransformUtility.RectangleContainsScreenPoint(rectTransform, sp, eventCamera, m_Padding);
		}

		public virtual void PerformClipping()
		{
			//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_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)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_004f: 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_006a: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			if (Canvas == null)
			{
				return;
			}
			if (m_ShouldRecalculateClipRects)
			{
				MaskUtilities.GetRectMasksForClip(this, m_Clippers);
				m_ShouldRecalculateClipRects = false;
			}
			bool validRect = true;
			Rect val = Clipping.FindCullAndClipWorldRect(m_Clippers, out validRect);
			RenderMode renderMode = Canvas.rootCanvas.renderMode;
			if (((int)renderMode == 1 || (int)renderMode == 0) && !((Rect)(ref val)).Overlaps(rootCanvasRect, true))
			{
				val = Rect.zero;
				validRect = false;
			}
			if (val != m_LastClipRectCanvasSpace)
			{
				foreach (IClippable clipTarget in m_ClipTargets)
				{
					clipTarget.SetClipRect(val, validRect);
				}
				foreach (MaskableGraphic maskableTarget in m_MaskableTargets)
				{
					maskableTarget.SetClipRect(val, validRect);
					maskableTarget.Cull(val, validRect);
				}
			}
			else if (m_ForceClip)
			{
				foreach (IClippable clipTarget2 in m_ClipTargets)
				{
					clipTarget2.SetClipRect(val, validRect);
				}
				foreach (MaskableGraphic maskableTarget2 in m_MaskableTargets)
				{
					maskableTarget2.SetClipRect(val, validRect);
					if (maskableTarget2.canvasRenderer.hasMoved)
					{
						maskableTarget2.Cull(val, validRect);
					}
				}
			}
			else
			{
				foreach (MaskableGraphic maskableTarget3 in m_MaskableTargets)
				{
					maskableTarget3.Cull(val, validRect);
				}
			}
			m_LastClipRectCanvasSpace = val;
			m_ForceClip = false;
			UpdateClipSoftness();
		}

		public virtual void UpdateClipSoftness()
		{
			//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)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (Canvas == null)
			{
				return;
			}
			foreach (IClippable clipTarget in m_ClipTargets)
			{
				clipTarget.SetClipSoftness(Vector2Int.op_Implicit(m_Softness));
			}
			foreach (MaskableGraphic maskableTarget in m_MaskableTargets)
			{
				maskableTarget.SetClipSoftness(Vector2Int.op_Implicit(m_Softness));
			}
		}

		public void AddClippable(IClippable clippable)
		{
			if (clippable != null)
			{
				m_ShouldRecalculateClipRects = true;
				MaskableGraphic maskableGraphic = clippable as MaskableGraphic;
				if ((Object)(object)maskableGraphic == (Object)null)
				{
					m_ClipTargets.Add(clippable);
				}
				else
				{
					m_MaskableTargets.Add(maskableGraphic);
				}
				m_ForceClip = true;
			}
		}

		public void RemoveClippable(IClippable clippable)
		{
			//IL_000e: 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 (clippable != null)
			{
				m_ShouldRecalculateClipRects = true;
				clippable.SetClipRect(default(Rect), validRect: false);
				MaskableGraphic maskableGraphic = clippable as MaskableGraphic;
				if ((Object)(object)maskableGraphic == (Object)null)
				{
					m_ClipTargets.Remove(clippable);
				}
				else
				{
					m_MaskableTargets.Remove(maskableGraphic);
				}
				m_ForceClip = true;
			}
		}

		protected override void OnTransformParentChanged()
		{
			m_Canvas = null;
			base.OnTransformParentChanged();
			m_ShouldRecalculateClipRects = true;
		}

		protected override void OnCanvasHierarchyChanged()
		{
			m_Canvas = null;
			base.OnCanvasHierarchyChanged();
			m_ShouldRecalculateClipRects = true;
		}
	}
	[AddComponentMenu("UI/Scrollbar", 36)]
	[ExecuteAlways]
	[RequireComponent(typeof(RectTransform))]
	public class Scrollbar : Selectable, IBeginDragHandler, IEventSystemHandler, IDragHandler, IInitializePotentialDragHandler, ICanvasElement
	{
		public enum Direction
		{
			LeftToRight,
			RightToLeft,
			BottomToTop,
			TopToBottom
		}

		[Serializable]
		public class ScrollEvent : UnityEvent<float>
		{
		}

		private enum Axis
		{
			Horizontal,
			Vertical
		}

		[SerializeField]
		private RectTransform m_HandleRect;

		[SerializeField]
		private Direction m_Direction;

		[Range(0f, 1f)]
		[SerializeField]
		private float m_Value;

		[Range(0f, 1f)]
		[SerializeField]
		private float m_Size = 0.2f;

		[Range(0f, 11f)]
		[SerializeField]
		private int m_NumberOfSteps;

		[Space(6f)]
		[SerializeField]
		private ScrollEvent m_OnValueChanged = new ScrollEvent();

		private RectTransform m_ContainerRect;

		private Vector2 m_Offset = Vector2.zero;

		private DrivenRectTransformTracker m_Tracker;

		private Coroutine m_PointerDownRepeat;

		private bool isPointerDownAndNotDragging;

		private bool m_DelayedUpdateVisuals;

		public RectTransform handleRect
		{
			get
			{
				return m_HandleRect;
			}
			set
			{
				if (SetPropertyUtility.SetClass(ref m_HandleRect, value))
				{
					UpdateCachedReferences();
					UpdateVisuals();
				}
			}
		}

		public Direction direction
		{
			get
			{
				return m_Direction;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_Direction, value))
				{
					UpdateVisuals();
				}
			}
		}

		public float value
		{
			get
			{
				float num = m_Value;
				if (m_NumberOfSteps > 1)
				{
					num = Mathf.Round(num * (float)(m_NumberOfSteps - 1)) / (float)(m_NumberOfSteps - 1);
				}
				return num;
			}
			set
			{
				Set(value);
			}
		}

		public float size
		{
			get
			{
				return m_Size;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_Size, Mathf.Clamp01(value)))
				{
					UpdateVisuals();
				}
			}
		}

		public int numberOfSteps
		{
			get
			{
				return m_NumberOfSteps;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_NumberOfSteps, value))
				{
					Set(m_Value);
					UpdateVisuals();
				}
			}
		}

		public ScrollEvent onValueChanged
		{
			get
			{
				return m_OnValueChanged;
			}
			set
			{
				m_OnValueChanged = value;
			}
		}

		private float stepSize
		{
			get
			{
				if (m_NumberOfSteps <= 1)
				{
					return 0.1f;
				}
				return 1f / (float)(m_NumberOfSteps - 1);
			}
		}

		private Axis axis
		{
			get
			{
				if (m_Direction != Direction.LeftToRight && m_Direction != Direction.RightToLeft)
				{
					return Axis.Vertical;
				}
				return Axis.Horizontal;
			}
		}

		private bool reverseValue
		{
			get
			{
				if (m_Direction != Direction.RightToLeft)
				{
					return m_Direction == Direction.TopToBottom;
				}
				return true;
			}
		}

		protected Scrollbar()
		{
		}//IL_0017: 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)


		public virtual void SetValueWithoutNotify(float input)
		{
			Set(input, sendCallback: false);
		}

		public virtual void Rebuild(CanvasUpdate executing)
		{
		}

		public virtual void LayoutComplete()
		{
		}

		public virtual void GraphicUpdateComplete()
		{
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			UpdateCachedReferences();
			Set(m_Value, sendCallback: false);
			UpdateVisuals();
		}

		protected override void OnDisable()
		{
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			base.OnDisable();
		}

		protected virtual void Update()
		{
			if (m_DelayedUpdateVisuals)
			{
				m_DelayedUpdateVisuals = false;
				UpdateVisuals();
			}
		}

		private void UpdateCachedReferences()
		{
			if (Object.op_Implicit((Object)(object)m_HandleRect) && (Object)(object)((Transform)m_HandleRect).parent != (Object)null)
			{
				m_ContainerRect = ((Component)((Transform)m_HandleRect).parent).GetComponent<RectTransform>();
			}
			else
			{
				m_ContainerRect = null;
			}
		}

		private void Set(float input, bool sendCallback = true)
		{
			float num = m_Value;
			m_Value = input;
			if (num != value)
			{
				UpdateVisuals();
				if (sendCallback)
				{
					UISystemProfilerApi.AddMarker("Scrollbar.value", (Object)(object)this);
					((UnityEvent<float>)m_OnValueChanged).Invoke(value);
				}
			}
		}

		protected override void OnRectTransformDimensionsChange()
		{
			base.OnRectTransformDimensionsChange();
			if (IsActive())
			{
				UpdateVisuals();
			}
		}

		private void UpdateVisuals()
		{
			//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_0039: 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_00ba: 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)
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			if ((Object)(object)m_ContainerRect != (Object)null)
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, m_HandleRect, (DrivenTransformProperties)3840);
				Vector2 zero = Vector2.zero;
				Vector2 one = Vector2.one;
				float num = Mathf.Clamp01(value) * (1f - size);
				if (reverseValue)
				{
					((Vector2)(ref zero))[(int)axis] = 1f - num - size;
					((Vector2)(ref one))[(int)axis] = 1f - num;
				}
				else
				{
					((Vector2)(ref zero))[(int)axis] = num;
					((Vector2)(ref one))[(int)axis] = num + size;
				}
				m_HandleRect.anchorMin = zero;
				m_HandleRect.anchorMax = one;
			}
		}

		private void UpdateDrag(PointerEventData eventData)
		{
			//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_002f: 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_0042: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_006b: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (eventData.button != PointerEventData.InputButton.Left || (Object)(object)m_ContainerRect == (Object)null)
			{
				return;
			}
			Vector2 position = Vector2.zero;
			Vector2 val = default(Vector2);
			if (MultipleDisplayUtilities.GetRelativeMousePositionForDrag(eventData, ref position) && RectTransformUtility.ScreenPointToLocalPointInRectangle(m_ContainerRect, position, eventData.pressEventCamera, ref val))
			{
				Vector2 val2 = val - m_Offset;
				Rect rect = m_ContainerRect.rect;
				Vector2 val3 = val2 - ((Rect)(ref rect)).position;
				rect = m_HandleRect.rect;
				Vector2 handleCorner = val3 - (((Rect)(ref rect)).size - m_HandleRect.sizeDelta) * 0.5f;
				float num;
				if (axis != Axis.Horizontal)
				{
					rect = m_ContainerRect.rect;
					num = ((Rect)(ref rect)).height;
				}
				else
				{
					rect = m_ContainerRect.rect;
					num = ((Rect)(ref rect)).width;
				}
				float num2 = num * (1f - size);
				if (!(num2 <= 0f))
				{
					DoUpdateDrag(handleCorner, num2);
				}
			}
		}

		private void DoUpdateDrag(Vector2 handleCorner, float remainingSize)
		{
			//IL_001f: 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_004f: 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)
			switch (m_Direction)
			{
			case Direction.LeftToRight:
				Set(Mathf.Clamp01(handleCorner.x / remainingSize));
				break;
			case Direction.RightToLeft:
				Set(Mathf.Clamp01(1f - handleCorner.x / remainingSize));
				break;
			case Direction.BottomToTop:
				Set(Mathf.Clamp01(handleCorner.y / remainingSize));
				break;
			case Direction.TopToBottom:
				Set(Mathf.Clamp01(1f - handleCorner.y / remainingSize));
				break;
			}
		}

		private bool MayDrag(PointerEventData eventData)
		{
			if (IsActive() && IsInteractable())
			{
				return eventData.button == PointerEventData.InputButton.Left;
			}
			return false;
		}

		public virtual void OnBeginDrag(PointerEventData eventData)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			isPointerDownAndNotDragging = false;
			if (MayDrag(eventData) && !((Object)(object)m_ContainerRect == (Object)null))
			{
				m_Offset = Vector2.zero;
				Vector2 val = default(Vector2);
				if (RectTransformUtility.RectangleContainsScreenPoint(m_HandleRect, eventData.pointerPressRaycast.screenPosition, eventData.enterEventCamera) && RectTransformUtility.ScreenPointToLocalPointInRectangle(m_HandleRect, eventData.pointerPressRaycast.screenPosition, eventData.pressEventCamera, ref val))
				{
					Vector2 val2 = val;
					Rect rect = m_HandleRect.rect;
					m_Offset = val2 - ((Rect)(ref rect)).center;
				}
			}
		}

		public virtual void OnDrag(PointerEventData eventData)
		{
			if (MayDrag(eventData) && (Object)(object)m_ContainerRect != (Object)null)
			{
				UpdateDrag(eventData);
			}
		}

		public override void OnPointerDown(PointerEventData eventData)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (MayDrag(eventData))
			{
				base.OnPointerDown(eventData);
				isPointerDownAndNotDragging = true;
				m_PointerDownRepeat = ((MonoBehaviour)this).StartCoroutine(ClickRepeat(eventData.pointerPressRaycast.screenPosition, eventData.enterEventCamera));
			}
		}

		protected IEnumerator ClickRepeat(PointerEventData eventData)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return ClickRepeat(eventData.pointerPressRaycast.screenPosition, eventData.enterEventCamera);
		}

		protected IEnumerator ClickRepeat(Vector2 screenPosition, Camera camera)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			while (isPointerDownAndNotDragging)
			{
				if (!RectTransformUtility.RectangleContainsScreenPoint(m_HandleRect, screenPosition, camera) && RectTransformUtility.ScreenPointToLocalPointInRectangle(m_HandleRect, screenPosition, camera, ref val))
				{
					float num = ((((axis == Axis.Horizontal) ? val.x : val.y) < 0f) ? size : (0f - size));
					value += (reverseValue ? num : (0f - num));
					value = Mathf.Clamp01(value);
					value = Mathf.Round(value * 10000f) / 10000f;
				}
				yield return (object)new WaitForEndOfFrame();
			}
			((MonoBehaviour)this).StopCoroutine(m_PointerDownRepeat);
		}

		public override void OnPointerUp(PointerEventData eventData)
		{
			base.OnPointerUp(eventData);
			isPointerDownAndNotDragging = false;
		}

		public override void OnMove(AxisEventData eventData)
		{
			if (!IsActive() || !IsInteractable())
			{
				base.OnMove(eventData);
				return;
			}
			switch (eventData.moveDir)
			{
			case MoveDirection.Left:
				if (axis == Axis.Horizontal && (Object)(object)FindSelectableOnLeft() == (Object)null)
				{
					Set(Mathf.Clamp01(reverseValue ? (value + stepSize) : (value - stepSize)));
				}
				else
				{
					base.OnMove(eventData);
				}
				break;
			case MoveDirection.Right:
				if (axis == Axis.Horizontal && (Object)(object)FindSelectableOnRight() == (Object)null)
				{
					Set(Mathf.Clamp01(reverseValue ? (value - stepSize) : (value + stepSize)));
				}
				else
				{
					base.OnMove(eventData);
				}
				break;
			case MoveDirection.Up:
				if (axis == Axis.Vertical && (Object)(object)FindSelectableOnUp() == (Object)null)
				{
					Set(Mathf.Clamp01(reverseValue ? (value - stepSize) : (value + stepSize)));
				}
				else
				{
					base.OnMove(eventData);
				}
				break;
			case MoveDirection.Down:
				if (axis == Axis.Vertical && (Object)(object)FindSelectableOnDown() == (Object)null)
				{
					Set(Mathf.Clamp01(reverseValue ? (value + stepSize) : (value - stepSize)));
				}
				else
				{
					base.OnMove(eventData);
				}
				break;
			}
		}

		public override Selectable FindSelectableOnLeft()
		{
			if (base.navigation.mode == Navigation.Mode.Automatic && axis == Axis.Horizontal)
			{
				return null;
			}
			return base.FindSelectableOnLeft();
		}

		public override Selectable FindSelectableOnRight()
		{
			if (base.navigation.mode == Navigation.Mode.Automatic && axis == Axis.Horizontal)
			{
				return null;
			}
			return base.FindSelectableOnRight();
		}

		public override Selectable FindSelectableOnUp()
		{
			if (base.navigation.mode == Navigation.Mode.Automatic && axis == Axis.Vertical)
			{
				return null;
			}
			return base.FindSelectableOnUp();
		}

		public override Selectable FindSelectableOnDown()
		{
			if (base.navigation.mode == Navigation.Mode.Automatic && axis == Axis.Vertical)
			{
				return null;
			}
			return base.FindSelectableOnDown();
		}

		public virtual void OnInitializePotentialDrag(PointerEventData eventData)
		{
			eventData.useDragThreshold = false;
		}

		public void SetDirection(Direction direction, bool includeRectLayouts)
		{
			Axis axis = this.axis;
			bool flag = reverseValue;
			this.direction = direction;
			if (includeRectLayouts)
			{
				if (this.axis != axis)
				{
					Transform transform = ((Component)this).transform;
					RectTransformUtility.FlipLayoutAxes((RectTransform)(object)((transform is RectTransform) ? transform : null), true, true);
				}
				if (reverseValue != flag)
				{
					Transform transform2 = ((Component)this).transform;
					RectTransformUtility.FlipLayoutOnAxis((RectTransform)(object)((transform2 is RectTransform) ? transform2 : null), (int)this.axis, true, true);
				}
			}
		}

		[SpecialName]
		Transform ICanvasElement.get_transform()
		{
			return ((Component)this).transform;
		}
	}
	[AddComponentMenu("UI/Scroll Rect", 37)]
	[SelectionBase]
	[ExecuteAlways]
	[DisallowMultipleComponent]
	[RequireComponent(typeof(RectTransform))]
	public class ScrollRect : UIBehaviour, IInitializePotentialDragHandler, IEventSystemHandler, IBeginDragHandler, IEndDragHandler, IDragHandler, IScrollHandler, ICanvasElement, ILayoutElement, ILayoutGroup, ILayoutController
	{
		public enum MovementType
		{
			Unrestricted,
			Elastic,
			Clamped
		}

		public enum ScrollbarVisibility
		{
			Permanent,
			AutoHide,
			AutoHideAndExpandViewport
		}

		[Serializable]
		public class ScrollRectEvent : UnityEvent<Vector2>
		{
		}

		[SerializeField]
		private RectTransform m_Content;

		[SerializeField]
		private bool m_Horizontal = true;

		[SerializeField]
		private bool m_Vertical = true;

		[SerializeField]
		private MovementType m_MovementType = MovementType.Elastic;

		[SerializeField]
		private float m_Elasticity = 0.1f;

		[SerializeField]
		private bool m_Inertia = true;

		[SerializeField]
		private float m_DecelerationRate = 0.135f;

		[SerializeField]
		private float m_ScrollSensitivity = 1f;

		[SerializeField]
		private RectTransform m_Viewport;

		[SerializeField]
		private Scrollbar m_HorizontalScrollbar;

		[SerializeField]
		private Scrollbar m_VerticalScrollbar;

		[SerializeField]
		private ScrollbarVisibility m_HorizontalScrollbarVisibility;

		[SerializeField]
		private ScrollbarVisibility m_VerticalScrollbarVisibility;

		[SerializeField]
		private float m_HorizontalScrollbarSpacing;

		[SerializeField]
		private float m_VerticalScrollbarSpacing;

		[SerializeField]
		private ScrollRectEvent m_OnValueChanged = new ScrollRectEvent();

		private Vector2 m_PointerStartLocalCursor = Vector2.zero;

		protected Vector2 m_ContentStartPosition = Vector2.zero;

		private RectTransform m_ViewRect;

		protected Bounds m_ContentBounds;

		private Bounds m_ViewBounds;

		private Vector2 m_Velocity;

		private bool m_Dragging;

		private bool m_Scrolling;

		private Vector2 m_PrevPosition = Vector2.zero;

		private Bounds m_PrevContentBounds;

		private Bounds m_PrevViewBounds;

		[NonSerialized]
		private bool m_HasRebuiltLayout;

		private bool m_HSliderExpand;

		private bool m_VSliderExpand;

		private float m_HSliderHeight;

		private float m_VSliderWidth;

		[NonSerialized]
		private RectTransform m_Rect;

		private RectTransform m_HorizontalScrollbarRect;

		private RectTransform m_VerticalScrollbarRect;

		private DrivenRectTransformTracker m_Tracker;

		private readonly Vector3[] m_Corners = (Vector3[])(object)new Vector3[4];

		public RectTransform content
		{
			get
			{
				return m_Content;
			}
			set
			{
				m_Content = value;
			}
		}

		public bool horizontal
		{
			get
			{
				return m_Horizontal;
			}
			set
			{
				m_Horizontal = value;
			}
		}

		public bool vertical
		{
			get
			{
				return m_Vertical;
			}
			set
			{
				m_Vertical = value;
			}
		}

		public MovementType movementType
		{
			get
			{
				return m_MovementType;
			}
			set
			{
				m_MovementType = value;
			}
		}

		public float elasticity
		{
			get
			{
				return m_Elasticity;
			}
			set
			{
				m_Elasticity = value;
			}
		}

		public bool inertia
		{
			get
			{
				return m_Inertia;
			}
			set
			{
				m_Inertia = value;
			}
		}

		public float decelerationRate
		{
			get
			{
				return m_DecelerationRate;
			}
			set
			{
				m_DecelerationRate = value;
			}
		}

		public float scrollSensitivity
		{
			get
			{
				return m_ScrollSensitivity;
			}
			set
			{
				m_ScrollSensitivity = value;
			}
		}

		public RectTransform viewport
		{
			get
			{
				return m_Viewport;
			}
			set
			{
				m_Viewport = value;
				SetDirtyCaching();
			}
		}

		public Scrollbar horizontalScrollbar
		{
			get
			{
				return m_HorizontalScrollbar;
			}
			set
			{
				if (Object.op_Implicit((Object)(object)m_HorizontalScrollbar))
				{
					((UnityEvent<float>)m_HorizontalScrollbar.onValueChanged).RemoveListener((UnityAction<float>)SetHorizontalNormalizedPosition);
				}
				m_HorizontalScrollbar = value;
				if (Object.op_Implicit((Object)(object)m_HorizontalScrollbar))
				{
					((UnityEvent<float>)m_HorizontalScrollbar.onValueChanged).AddListener((UnityAction<float>)SetHorizontalNormalizedPosition);
				}
				SetDirtyCaching();
			}
		}

		public Scrollbar verticalScrollbar
		{
			get
			{
				return m_VerticalScrollbar;
			}
			set
			{
				if (Object.op_Implicit((Object)(object)m_VerticalScrollbar))
				{
					((UnityEvent<float>)m_VerticalScrollbar.onValueChanged).RemoveListener((UnityAction<float>)SetVerticalNormalizedPosition);
				}
				m_VerticalScrollbar = value;
				if (Object.op_Implicit((Object)(object)m_VerticalScrollbar))
				{
					((UnityEvent<float>)m_VerticalScrollbar.onValueChanged).AddListener((UnityAction<float>)SetVerticalNormalizedPosition);
				}
				SetDirtyCaching();
			}
		}

		public ScrollbarVisibility horizontalScrollbarVisibility
		{
			get
			{
				return m_HorizontalScrollbarVisibility;
			}
			set
			{
				m_HorizontalScrollbarVisibility = value;
				SetDirtyCaching();
			}
		}

		public ScrollbarVisibility verticalScrollbarVisibility
		{
			get
			{
				return m_VerticalScrollbarVisibility;
			}
			set
			{
				m_VerticalScrollbarVisibility = value;
				SetDirtyCaching();
			}
		}

		public float horizontalScrollbarSpacing
		{
			get
			{
				return m_HorizontalScrollbarSpacing;
			}
			set
			{
				m_HorizontalScrollbarSpacing = value;
				SetDirty();
			}
		}

		public float verticalScrollbarSpacing
		{
			get
			{
				return m_VerticalScrollbarSpacing;
			}
			set
			{
				m_VerticalScrollbarSpacing = value;
				SetDirty();
			}
		}

		public ScrollRectEvent onValueChanged
		{
			get
			{
				return m_OnValueChanged;
			}
			set
			{
				m_OnValueChanged = value;
			}
		}

		protected RectTransform viewRect
		{
			get
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				if ((Object)(object)m_ViewRect == (Object)null)
				{
					m_ViewRect = m_Viewport;
				}
				if ((Object)(object)m_ViewRect == (Object)null)
				{
					m_ViewRect = (RectTransform)((Component)this).transform;
				}
				return m_ViewRect;
			}
		}

		public Vector2 velocity
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_Velocity;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_Velocity = value;
			}
		}

		private RectTransform rectTransform
		{
			get
			{
				if ((Object)(object)m_Rect == (Object)null)
				{
					m_Rect = ((Component)this).GetComponent<RectTransform>();
				}
				return m_Rect;
			}
		}

		public Vector2 normalizedPosition
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				return new Vector2(horizontalNormalizedPosition, verticalNormalizedPosition);
			}
			set
			{
				//IL_0001: 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)
				SetNormalizedPosition(value.x, 0);
				SetNormalizedPosition(value.y, 1);
			}
		}

		public float horizontalNormalizedPosition
		{
			get
			{
				//IL_000c: 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_0055: 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_002e: 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_007d: 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_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				UpdateBounds();
				if (((Bounds)(ref m_ContentBounds)).size.x <= ((Bounds)(ref m_ViewBounds)).size.x || Mathf.Approximately(((Bounds)(ref m_ContentBounds)).size.x, ((Bounds)(ref m_ViewBounds)).size.x))
				{
					return (((Bounds)(ref m_ViewBounds)).min.x > ((Bounds)(ref m_ContentBounds)).min.x) ? 1 : 0;
				}
				return (((Bounds)(ref m_ViewBounds)).min.x - ((Bounds)(ref m_ContentBounds)).min.x) / (((Bounds)(ref m_ContentBounds)).size.x - ((Bounds)(ref m_ViewBounds)).size.x);
			}
			set
			{
				SetNormalizedPosition(value, 0);
			}
		}

		public float verticalNormalizedPosition
		{
			get
			{
				//IL_000c: 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_0055: 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_002e: 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_007d: 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_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				UpdateBounds();
				if (((Bounds)(ref m_ContentBounds)).size.y <= ((Bounds)(ref m_ViewBounds)).size.y || Mathf.Approximately(((Bounds)(ref m_ContentBounds)).size.y, ((Bounds)(ref m_ViewBounds)).size.y))
				{
					return (((Bounds)(ref m_ViewBounds)).min.y > ((Bounds)(ref m_ContentBounds)).min.y) ? 1 : 0;
				}
				return (((Bounds)(ref m_ViewBounds)).min.y - ((Bounds)(ref m_ContentBounds)).min.y) / (((Bounds)(ref m_ContentBounds)).size.y - ((Bounds)(ref m_ViewBounds)).size.y);
			}
			set
			{
				SetNormalizedPosition(value, 1);
			}
		}

		private bool hScrollingNeeded
		{
			get
			{
				//IL_000d: 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)
				if (Application.isPlaying)
				{
					return ((Bounds)(ref m_ContentBounds)).size.x > ((Bounds)(ref m_ViewBounds)).size.x + 0.01f;
				}
				return true;
			}
		}

		private bool vScrollingNeeded
		{
			get
			{
				//IL_000d: 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)
				if (Application.isPlaying)
				{
					return ((Bounds)(ref m_ContentBounds)).size.y > ((Bounds)(ref m_ViewBounds)).size.y + 0.01f;
				}
				return true;
			}
		}

		public virtual float minWidth => -1f;

		public virtual float preferredWidth => -1f;

		public virtual float flexibleWidth => -1f;

		public virtual float minHeight => -1f;

		public virtual float preferredHeight => -1f;

		public virtual float flexibleHeight => -1f;

		public virtual int layoutPriority => -1;

		protected ScrollRect()
		{
		}//IL_0049: 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_0054: 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_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)


		public virtual void Rebuild(CanvasUpdate executing)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (executing == CanvasUpdate.Prelayout)
			{
				UpdateCachedData();
			}
			if (executing == CanvasUpdate.PostLayout)
			{
				UpdateBounds();
				UpdateScrollbars(Vector2.zero);
				UpdatePrevData();
				m_HasRebuiltLayout = true;
			}
		}

		public virtual void LayoutComplete()
		{
		}

		public virtual void GraphicUpdateComplete()
		{
		}

		private void UpdateCachedData()
		{
			//IL_0108: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).transform;
			m_HorizontalScrollbarRect = (RectTransform)(((Object)(object)m_HorizontalScrollbar == (Object)null) ? null : /*isinst with value type is only supported in some contexts*/);
			m_VerticalScrollbarRect = (RectTransform)(((Object)(object)m_VerticalScrollbar == (Object)null) ? null : /*isinst with value type is only supported in some contexts*/);
			bool num = (Object)(object)((Transform)viewRect).parent == (Object)(object)transform;
			bool flag = !Object.op_Implicit((Object)(object)m_HorizontalScrollbarRect) || (Object)(object)((Transform)m_HorizontalScrollbarRect).parent == (Object)(object)transform;
			bool flag2 = !Object.op_Implicit((Object)(object)m_VerticalScrollbarRect) || (Object)(object)((Transform)m_VerticalScrollbarRect).parent == (Object)(object)transform;
			bool flag3 = num && flag && flag2;
			m_HSliderExpand = flag3 && Object.op_Implicit((Object)(object)m_HorizontalScrollbarRect) && horizontalScrollbarVisibility == ScrollbarVisibility.AutoHideAndExpandViewport;
			m_VSliderExpand = flag3 && Object.op_Implicit((Object)(object)m_VerticalScrollbarRect) && verticalScrollbarVisibility == ScrollbarVisibility.AutoHideAndExpandViewport;
			Rect rect;
			float hSliderHeight;
			if (!((Object)(object)m_HorizontalScrollbarRect == (Object)null))
			{
				rect = m_HorizontalScrollbarRect.rect;
				hSliderHeight = ((Rect)(ref rect)).height;
			}
			else
			{
				hSliderHeight = 0f;
			}
			m_HSliderHeight = hSliderHeight;
			float vSliderWidth;
			if (!((Object)(object)m_VerticalScrollbarRect == (Object)null))
			{
				rect = m_VerticalScrollbarRect.rect;
				vSliderWidth = ((Rect)(ref rect)).width;
			}
			else
			{
				vSliderWidth = 0f;
			}
			m_VSliderWidth = vSliderWidth;
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			if (Object.op_Implicit((Object)(object)m_HorizontalScrollbar))
			{
				((UnityEvent<float>)m_HorizontalScrollbar.onValueChanged).AddListener((UnityAction<float>)SetHorizontalNormalizedPosition);
			}
			if (Object.op_Implicit((Object)(object)m_VerticalScrollbar))
			{
				((UnityEvent<float>)m_VerticalScrollbar.onValueChanged).AddListener((UnityAction<float>)SetVerticalNormalizedPosition);
			}
			CanvasUpdateRegistry.RegisterCanvasElementForLayoutRebuild(this);
			SetDirty();
		}

		protected override void OnDisable()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild(this);
			if (Object.op_Implicit((Object)(object)m_HorizontalScrollbar))
			{
				((UnityEvent<float>)m_HorizontalScrollbar.onValueChanged).RemoveListener((UnityAction<float>)SetHorizontalNormalizedPosition);
			}
			if (Object.op_Implicit((Object)(object)m_VerticalScrollbar))
			{
				((UnityEvent<float>)m_VerticalScrollbar.onValueChanged).RemoveListener((UnityAction<float>)SetVerticalNormalizedPosition);
			}
			m_Dragging = false;
			m_Scrolling = false;
			m_HasRebuiltLayout = false;
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			m_Velocity = Vector2.zero;
			LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
			base.OnDisable();
		}

		public override bool IsActive()
		{
			if (base.IsActive())
			{
				return (Object)(object)m_Content != (Object)null;
			}
			return false;
		}

		private void EnsureLayoutHasRebuilt()
		{
			if (!m_HasRebuiltLayout && !CanvasUpdateRegistry.IsRebuildingLayout())
			{
				Canvas.ForceUpdateCanvases();
			}
		}

		public virtual void StopMovement()
		{
			//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)
			m_Velocity = Vector2.zero;
		}

		public virtual void OnScroll(PointerEventData data)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_00c3: 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)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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_0088: 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_0104: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if (!IsActive())
			{
				return;
			}
			EnsureLayoutHasRebuilt();
			UpdateBounds();
			Vector2 scrollDelta = data.scrollDelta;
			scrollDelta.y *= -1f;
			if (vertical && !horizontal)
			{
				if (Mathf.Abs(scrollDelta.x) > Mathf.Abs(scrollDelta.y))
				{
					scrollDelta.y = scrollDelta.x;
				}
				scrollDelta.x = 0f;
			}
			if (horizontal && !vertical)
			{
				if (Mathf.Abs(scrollDelta.y) > Mathf.Abs(scrollDelta.x))
				{
					scrollDelta.x = scrollDelta.y;
				}
				scrollDelta.y = 0f;
			}
			if (data.IsScrolling())
			{
				m_Scrolling = true;
			}
			Vector2 anchoredPosition = m_Content.anchoredPosition;
			anchoredPosition += scrollDelta * m_ScrollSensitivity;
			if (m_MovementType == MovementType.Clamped)
			{
				anchoredPosition += CalculateOffset(anchoredPosition - m_Content.anchoredPosition);
			}
			SetContentAnchoredPosition(anchoredPosition);
			UpdateBounds();
		}

		public virtual void OnInitializePotentialDrag(PointerEventData eventData)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (eventData.button == PointerEventData.InputButton.Left)
			{
				m_Velocity = Vector2.zero;
			}
		}

		public virtual void OnBeginDrag(PointerEventData eventData)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (eventData.button == PointerEventData.InputButton.Left && IsActive())
			{
				UpdateBounds();
				m_PointerStartLocalCursor = Vector2.zero;
				RectTransformUtility.ScreenPointToLocalPointInRectangle(viewRect, eventData.position, eventData.pressEventCamera, ref m_PointerStartLocalCursor);
				m_ContentStartPosition = m_Content.anchoredPosition;
				m_Dragging = true;
			}
		}

		public virtual void OnEndDrag(PointerEventData eventData)
		{
			if (eventData.button == PointerEventData.InputButton.Left)
			{
				m_Dragging = false;
			}
		}

		public virtual void OnDrag(PointerEventData eventData)
		{
			//IL_0022: 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_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)
			//IL_0049: 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_0050: 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_0056: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: 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_00b6: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			if (!m_Dragging || eventData.button != PointerEventData.InputButton.Left || !IsActive() || !RectTransformUtility.ScreenPointToLocalPointInRectangle(viewRect, eventData.position, eventData.pressEventCamera, ref val))
			{
				return;
			}
			UpdateBounds();
			Vector2 val2 = val - m_PointerStartLocalCursor;
			Vector2 val3 = m_ContentStartPosition + val2;
			Vector2 val4 = CalculateOffset(val3 - m_Content.anchoredPosition);
			val3 += val4;
			if (m_MovementType == MovementType.Elastic)
			{
				if (val4.x != 0f)
				{
					val3.x -= RubberDelta(val4.x, ((Bounds)(ref m_ViewBounds)).size.x);
				}
				if (val4.y != 0f)
				{
					val3.y -= RubberDelta(val4.y, ((Bounds)(ref m_ViewBounds)).size.y);
				}
			}
			SetContentAnchoredPosition(val3);
		}

		protected virtual void SetContentAnchoredPosition(Vector2 position)
		{
			//IL_0010: 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_0045: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			if (!m_Horizontal)
			{
				position.x = m_Content.anchoredPosition.x;
			}
			if (!m_Vertical)
			{
				position.y = m_Content.anchoredPosition.y;
			}
			if (position != m_Content.anchoredPosition)
			{
				m_Content.anchoredPosition = position;
				UpdateBounds();
			}
		}

		protected virtual void LateUpdate()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: 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_00c6: 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_00db: 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)
			if (!Object.op_Implicit((Object)(object)m_Content))
			{
				return;
			}
			EnsureLayoutHasRebuilt();
			UpdateBounds();
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			Vector2 val = CalculateOffset(Vector2.zero);
			if (unscaledDeltaTime > 0f)
			{
				if (!m_Dragging && (val != Vector2.zero || m_Velocity != Vector2.zero))
				{
					Vector2 val2 = m_Content.anchoredPosition;
					for (int i = 0; i < 2; i++)
					{
						if (m_MovementType == MovementType.Elastic && ((Vector2)(ref val))[i] != 0f)
						{
							float num = ((Vector2)(ref m_Velocity))[i];
							float num2 = m_Elasticity;
							if (m_Scrolling)
							{
								num2 *= 3f;
							}
							int num3 = i;
							Vector2 anchoredPosition = m_Content.anchoredPosition;
							float num4 = ((Vector2)(ref anchoredPosition))[i];
							anchoredPosition = m_Content.anchoredPosition;
							((Vector2)(ref val2))[num3] = Mathf.SmoothDamp(num4, ((Vector2)(ref anchoredPosition))[i] + ((Vector2)(ref val))[i], ref num, num2, float.PositiveInfinity, unscaledDeltaTime);
							if (Mathf.Abs(num) < 1f)
							{
								num = 0f;
							}
							((Vector2)(ref m_Velocity))[i] = num;
						}
						else if (m_Inertia)
						{
							ref Vector2 reference = ref m_Velocity;
							int num5 = i;
							((Vector2)(ref reference))[num5] = ((Vector2)(ref reference))[num5] * Mathf.Pow(m_DecelerationRate, unscaledDeltaTime);
							if (Mathf.Abs(((Vector2)(ref m_Velocity))[i]) < 1f)
							{
								((Vector2)(ref m_Velocity))[i] = 0f;
							}
							reference = ref val2;
							num5 = i;
							((Vector2)(ref reference))[num5] = ((Vector2)(ref reference))[num5] + ((Vector2)(ref m_Velocity))[i] * unscaledDeltaTime;
						}
						else
						{
							((Vector2)(ref m_Velocity))[i] = 0f;
						}
					}
					if (m_MovementType == MovementType.Clamped)
					{
						val = CalculateOffset(val2 - m_Content.anchoredPosition);
						val2 += val;
					}
					SetContentAnchoredPosition(val2);
				}
				if (m_Dragging && m_Inertia)
				{
					Vector3 val3 = Vector2.op_Implicit((m_Content.anchoredPosition - m_PrevPosition) / unscaledDeltaTime);
					m_Velocity = Vector2.op_Implicit(Vector3.Lerp(Vector2.op_Implicit(m_Velocity), val3, unscaledDeltaTime * 10f));
				}
			}
			if (m_ViewBounds != m_PrevViewBounds || m_ContentBounds != m_PrevContentBounds || m_Content.anchoredPosition != m_PrevPosition)
			{
				UpdateScrollbars(val);
				UISystemProfilerApi.AddMarker("ScrollRect.value", (Object)(object)this);
				((UnityEvent<Vector2>)m_OnValueChanged).Invoke(normalizedPosition);
				UpdatePrevData();
			}
			UpdateScrollbarVisibility();
			m_Scrolling = false;
		}

		protected void UpdatePrevData()
		{
			//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_000f: 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)
			//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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_Content == (Object)null)
			{
				m_PrevPosition = Vector2.zero;
			}
			else
			{
				m_PrevPosition = m_Content.anchoredPosition;
			}
			m_PrevViewBounds = m_ViewBounds;
			m_PrevContentBounds = m_ContentBounds;
		}

		private void UpdateScrollbars(Vector2 offset)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)m_HorizontalScrollbar))
			{
				if (((Bounds)(ref m_ContentBounds)).size.x > 0f)
				{
					m_HorizontalScrollbar.size = Mathf.Clamp01((((Bounds)(ref m_ViewBounds)).size.x - Mathf.Abs(offset.x)) / ((Bounds)(ref m_ContentBounds)).size.x);
				}
				else
				{
					m_HorizontalScrollbar.size = 1f;
				}
				m_HorizontalScrollbar.value = horizontalNormalizedPosition;
			}
			if (Object.op_Implicit((Object)(object)m_VerticalScrollbar))
			{
				if (((Bounds)(ref m_ContentBounds)).size.y > 0f)
				{
					m_VerticalScrollbar.size = Mathf.Clamp01((((Bounds)(ref m_ViewBounds)).size.y - Mathf.Abs(offset.y)) / ((Bounds)(ref m_ContentBounds)).size.y);
				}
				else
				{
					m_VerticalScrollbar.size = 1f;
				}
				m_VerticalScrollbar.value = verticalNormalizedPosition;
			}
		}

		private void SetHorizontalNormalizedPosition(float value)
		{
			SetNormalizedPosition(value, 0);
		}

		private void SetVerticalNormalizedPosition(float value)
		{
			SetNormalizedPosition(value, 1);
		}

		protected virtual void SetNormalizedPosition(float value, int axis)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_002c: 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_0043: 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_006f: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			EnsureLayoutHasRebuilt();
			UpdateBounds();
			Vector3 val = ((Bounds)(ref m_ContentBounds)).size;
			float num = ((Vector3)(ref val))[axis];
			val = ((Bounds)(ref m_ViewBounds)).size;
			float num2 = num - ((Vector3)(ref val))[axis];
			val = ((Bounds)(ref m_ViewBounds)).min;
			float num3 = ((Vector3)(ref val))[axis] - value * num2;
			Vector2 anchoredPosition = m_Content.anchoredPosition;
			float num4 = ((Vector2)(ref anchoredPosition))[axis] + num3;
			val = ((Bounds)(ref m_ContentBounds)).min;
			float num5 = num4 - ((Vector3)(ref val))[axis];
			Vector3 val2 = Vector2.op_Implicit(m_Content.anchoredPosition);
			if (Mathf.Abs(((Vector3)(ref val2))[axis] - num5) > 0.01f)
			{
				((Vector3)(ref val2))[axis] = num5;
				m_Content.anchoredPosition = Vector2.op_Implicit(val2);
				((Vector2)(ref m_Velocity))[axis] = 0f;
				UpdateBounds();
			}
		}

		private static float RubberDelta(float overStretching, float viewSize)
		{
			return (1f - 1f / (Mathf.Abs(overStretching) * 0.55f / viewSize + 1f)) * viewSize * Mathf.Sign(overStretching);
		}

		protected override void OnRectTransformDimensionsChange()
		{
			SetDirty();
		}

		public virtual void CalculateLayoutInputHorizontal()
		{
		}

		public virtual void CalculateLayoutInputVertical()
		{
		}

		public virtual void SetLayoutHorizontal()
		{
			//IL_0041: 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_0061: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_01a8: 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_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			UpdateCachedData();
			Rect rect;
			if (m_HSliderExpand || m_VSliderExpand)
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, viewRect, (DrivenTransformProperties)16134);
				viewRect.anchorMin = Vector2.zero;
				viewRect.anchorMax = Vector2.one;
				viewRect.sizeDelta = Vector2.zero;
				viewRect.anchoredPosition = Vector2.zero;
				LayoutRebuilder.ForceRebuildLayoutImmediate(content);
				rect = viewRect.rect;
				Vector3 val = Vector2.op_Implicit(((Rect)(ref rect)).center);
				rect = viewRect.rect;
				m_ViewBounds = new Bounds(val, Vector2.op_Implicit(((Rect)(ref rect)).size));
				m_ContentBounds = GetBounds();
			}
			if (m_VSliderExpand && vScrollingNeeded)
			{
				viewRect.sizeDelta = new Vector2(0f - (m_VSliderWidth + m_VerticalScrollbarSpacing), viewRect.sizeDelta.y);
				LayoutRebuilder.ForceRebuildLayoutImmediate(content);
				rect = viewRect.rect;
				Vector3 val2 = Vector2.op_Implicit(((Rect)(ref rect)).center);
				rect = viewRect.rect;
				m_ViewBounds = new Bounds(val2, Vector2.op_Implicit(((Rect)(ref rect)).size));
				m_ContentBounds = GetBounds();
			}
			if (m_HSliderExpand && hScrollingNeeded)
			{
				viewRect.sizeDelta = new Vector2(viewRect.sizeDelta.x, 0f - (m_HSliderHeight + m_HorizontalScrollbarSpacing));
				rect = viewRect.rect;
				Vector3 val3 = Vector2.op_Implicit(((Rect)(ref rect)).center);
				rect = viewRect.rect;
				m_ViewBounds = new Bounds(val3, Vector2.op_Implicit(((Rect)(ref rect)).size));
				m_ContentBounds = GetBounds();
			}
			if (m_VSliderExpand && vScrollingNeeded && viewRect.sizeDelta.x == 0f && viewRect.sizeDelta.y < 0f)
			{
				viewRect.sizeDelta = new Vector2(0f - (m_VSliderWidth + m_VerticalScrollbarSpacing), viewRect.sizeDelta.y);
			}
		}

		public virtual void SetLayoutVertical()
		{
			//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)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			UpdateScrollbarLayout();
			Rect rect = viewRect.rect;
			Vector3 val = Vector2.op_Implicit(((Rect)(ref rect)).center);
			rect = viewRect.rect;
			m_ViewBounds = new Bounds(val, Vector2.op_Implicit(((Rect)(ref rect)).size));
			m_ContentBounds = GetBounds();
		}

		private void UpdateScrollbarVisibility()
		{
			UpdateOneScrollbarVisibility(vScrollingNeeded, m_Vertical, m_VerticalScrollbarVisibility, m_VerticalScrollbar);
			UpdateOneScrollbarVisibility(hScrollingNeeded, m_Horizontal, m_HorizontalScrollbarVisibility, m_HorizontalScrollbar);
		}

		private static void UpdateOneScrollbarVisibility(bool xScrollingNeeded, bool xAxisEnabled, ScrollbarVisibility scrollbarVisibility, Scrollbar scrollbar)
		{
			if (!Object.op_Implicit((Object)(object)scrollbar))
			{
				return;
			}
			if (scrollbarVisibility == ScrollbarVisibility.Permanent)
			{
				if (((Component)scrollbar).gameObject.activeSelf != xAxisEnabled)
				{
					((Component)scrollbar).gameObject.SetActive(xAxisEnabled);
				}
			}
			else if (((Component)scrollbar).gameObject.activeSelf != xScrollingNeeded)
			{
				((Component)scrollbar).gameObject.SetActive(xScrollingNeeded);
			}
		}

		private void UpdateScrollbarLayout()
		{
			//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_0068: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			if (m_VSliderExpand && Object.op_Implicit((Object)(object)m_HorizontalScrollbar))
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, m_HorizontalScrollbarRect, (DrivenTransformProperties)5378);
				m_HorizontalScrollbarRect.anchorMin = new Vector2(0f, m_HorizontalScrollbarRect.anchorMin.y);
				m_HorizontalScrollbarRect.anchorMax = new Vector2(1f, m_HorizontalScrollbarRect.anchorMax.y);
				m_HorizontalScrollbarRect.anchoredPosition = new Vector2(0f, m_HorizontalScrollbarRect.anchoredPosition.y);
				if (vScrollingNeeded)
				{
					m_HorizontalScrollbarRect.sizeDelta = new Vector2(0f - (m_VSliderWidth + m_VerticalScrollbarSpacing), m_HorizontalScrollbarRect.sizeDelta.y);
				}
				else
				{
					m_HorizontalScrollbarRect.sizeDelta = new Vector2(0f, m_HorizontalScrollbarRect.sizeDelta.y);
				}
			}
			if (m_HSliderExpand && Object.op_Implicit((Object)(object)m_VerticalScrollbar))
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, m_VerticalScrollbarRect, (DrivenTransformProperties)10756);
				m_VerticalScrollbarRect.anchorMin = new Vector2(m_VerticalScrollbarRect.anchorMin.x, 0f);
				m_VerticalScrollbarRect.anchorMax = new Vector2(m_VerticalScrollbarRect.anchorMax.x, 1f);
				m_VerticalScrollbarRect.anchoredPosition = new Vector2(m_VerticalScrollbarRect.anchoredPosition.x, 0f);
				if (hScrollingNeeded)
				{
					m_VerticalScrollbarRect.sizeDelta = new Vector2(m_VerticalScrollbarRect.sizeDelta.x, 0f - (m_HSliderHeight + m_HorizontalScrollbarSpacing));
				}
				else
				{
					m_VerticalScrollbarRect.sizeDelta = new Vector2(m_VerticalScrollbarRect.sizeDelta.x, 0f);
				}
			}
		}

		protected void UpdateBounds()
		{
			//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_000f: 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)
			//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)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0074: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = viewRect.rect;
			Vector3 val = Vector2.op_Implicit(((Rect)(ref rect)).center);
			rect = viewRect.rect;
			m_ViewBounds = new Bounds(val, Vector2.op_Implicit(((Rect)(ref rect)).size));
			m_ContentBounds = GetBounds();
			if ((Object)(object)m_Content == (Object)null)
			{
				return;
			}
			Vector3 contentSize = ((Bounds)(ref m_ContentBounds)).size;
			Vector3 contentPos = ((Bounds)(ref m_ContentBounds)).center;
			Vector2 contentPivot = m_Content.pivot;
			AdjustBounds(ref m_ViewBounds, ref contentPivot, ref contentSize, ref contentPos);
			((Bounds)(ref m_ContentBounds)).size = contentSize;
			((Bounds)(ref m_ContentBounds)).center = contentPos;
			if (movementType != MovementType.Clamped)
			{
				return;
			}
			Vector2 zero = Vector2.zero;
			if (((Bounds)(ref m_ViewBounds)).max.x > ((Bounds)(ref m_ContentBounds)).max.x)
			{
				zero.x = Math.Min(((Bounds)(ref m_ViewBounds)).min.x - ((Bounds)(ref m_ContentBounds)).min.x, ((Bounds)(ref m_ViewBounds)).max.x - ((Bounds)(ref m_ContentBounds)).max.x);
			}
			else if (((Bounds)(ref m_ViewBounds)).min.x < ((Bounds)(ref m_ContentBounds)).min.x)
			{
				zero.x = Math.Max(((Bounds)(ref m_ViewBounds)).min.x - ((Bounds)(ref m_ContentBounds)).min.x, ((Bounds)(ref m_ViewBounds)).max.x - ((Bounds)(ref m_ContentBounds)).max.x);
			}
			if (((Bounds)(ref m_ViewBounds)).min.y < ((Bounds)(ref m_ContentBounds)).min.y)
			{
				zero.y = Math.Max(((Bounds)(ref m_ViewBounds)).min.y - ((Bounds)(ref m_ContentBounds)).min.y, ((Bounds)(ref m_ViewBounds)).max.y - ((Bounds)(ref m_ContentBounds)).max.y);
			}
			else if (((Bounds)(ref m_ViewBounds)).max.y > ((Bounds)(ref m_ContentBounds)).max.y)
			{
				zero.y = Math.Min(((Bounds)(ref m_ViewBounds)).min.y - ((Bounds)(ref m_ContentBounds)).min.y, ((Bounds)(ref m_ViewBounds)).max.y - ((Bounds)(ref m_ContentBounds)).max.y);
			}
			if (((Vector2)(ref zero)).sqrMagnitude > float.Epsilon)
			{
				contentPos = Vector2.op_Implicit(m_Content.anchoredPosition + zero);
				if (!m_Horizontal)
				{
					contentPos.x = m_Content.anchoredPosition.x;
				}
				if (!m_Vertical)
				{
					contentPos.y = m_Content.anchoredPosition.y;
				}
				AdjustBounds(ref m_ViewBounds, ref contentPivot, ref contentSize, ref contentPos);
			}
		}

		internal static void AdjustBounds(ref Bounds viewBounds, ref Vector2 contentPivot, ref Vector3 contentSize, ref Vector3 contentPos)
		{
			//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_0012: 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_0027: 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_0062: 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)
			Vector3 val = ((Bounds)(ref viewBounds)).size - contentSize;
			if (val.x > 0f)
			{
				contentPos.x -= val.x * (contentPivot.x - 0.5f);
				contentSize.x = ((Bounds)(ref viewBounds)).size.x;
			}
			if (val.y > 0f)
			{
				contentPos.y -= val.y * (contentPivot.y - 0.5f);
				contentSize.y = ((Bounds)(ref viewBounds)).size.y;
			}
		}

		private Bounds GetBounds()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m_Content == (Object)null)
			{
				return default(Bounds);
			}
			m_Content.GetWorldCorners(m_Corners);
			Matrix4x4 viewWorldToLocalMatrix = ((Transform)viewRect).worldToLocalMatrix;
			return InternalGetBounds(m_Corners, ref viewWorldToLocalMatrix);
		}

		internal static Bounds InternalGetBounds(Vector3[] corners, ref Matrix4x4 viewWorldToLocalMatrix)
		{
			//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_003d: 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_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)
			//IL_0045: 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_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_0057: 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)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(float.MaxValue, float.MaxValue, float.MaxValue);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(float.MinValue, float.MinValue, float.MinValue);
			for (int i = 0; i < 4; i++)
			{
				Vector3 val3 = ((Matrix4x4)(ref viewWorldToLocalMatrix)).MultiplyPoint3x4(corners[i]);
				val = Vector3.Min(val3, val);
				val2 = Vector3.Max(val3, val2);
			}
			Bounds result = default(Bounds);
			((Bounds)(ref result))..ctor(val, Vector3.zero);
			((Bounds)(ref result)).Encapsulate(val2);
			return result;
		}

		private Vector2 CalculateOffset(Vector2 delta)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return InternalCalculateOffset(ref m_ViewBounds, ref m_ContentBounds, m_Horizontal, m_Vertical, m_MovementType, ref delta);
		}

		internal static Vector2 InternalCalculateOffset(ref Bounds viewBounds, ref Bounds contentBounds, bool horizontal, bool vertical, MovementType movementType, ref Vector2 delta)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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)
			//IL_004c: 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_005f: 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_010b: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			Vector2 zero = Vector2.zero;
			if (movementType == MovementType.Unrestricted)
			{
				return zero;
			}
			Vector2 val = Vector2.op_Implicit(((Bounds)(ref contentBounds)).min);
			Vector2 val2 = Vector2.op_Implicit(((Bounds)(ref contentBounds)).max);
			if (horizontal)
			{
				val.x += delta.x;
				val2.x += delta.x;
				float num = ((Bounds)(ref viewBounds)).max.x - val2.x;
				float num2 = ((Bounds)(ref viewBounds)).min.x - val.x;
				if (num2 < -0.001f)
				{
					zero.x = num2;
				}
				else if (num > 0.001f)
				{
					zero.x = num;
				}
			}
			if (vertical)
			{
				val.y += delta.y;
				val2.y += delta.y;
				float num3 = ((Bounds)(ref viewBounds)).max.y - val2.y;
				float num4 = ((Bounds)(ref viewBounds)).min.y - val.y;
				if (num3 > 0.001f)
				{
					zero.y = num3;
				}
				else if (num4 < -0.001f)
				{
					zero.y = num4;
				}
			}
			return zero;
		}

		protected void SetDirty()
		{
			if (IsActive())
			{
				LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
			}
		}

		protected void SetDirtyCaching()
		{
			if (IsActive())
			{
				CanvasUpdateRegistry.RegisterCanvasElementForLayoutRebuild(this);
				LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
				m_ViewRect = null;
			}
		}

		[SpecialName]
		Transform ICanvasElement.get_transform()
		{
			return ((Component)this).transform;
		}
	}
	[AddComponentMenu("UI/Selectable", 35)]
	[ExecuteAlways]
	[SelectionBase]
	[DisallowMultipleComponent]
	public class Selectable : UIBehaviour, IMoveHandler, IEventSystemHandler, IPointerDownHandler, IPointerUpHandler, IPointerEnterHandler, IPointerExitHandler, ISelectHandler, IDeselectHandler
	{
		public enum Transition
		{
			None,
			ColorTint,
			SpriteSwap,
			Animation
		}

		protected enum SelectionState
		{
			Normal,
			Highlighted,
			Pressed,
			Selected,
			Disabled
		}

		protected static Selectable[] s_Selectables = new Selectable[10];

		protected static int s_SelectableCount = 0;

		private bool m_EnableCalled;

		[FormerlySerializedAs("navigation")]
		[SerializeField]
		private Navigation m_Navigation = Navigation.defaultNavigation;

		[FormerlySerializedAs("transition")]
		[SerializeField]
		private Transition m_Transition = Transition.ColorTint;

		[FormerlySerializedAs("colors")]
		[SerializeField]
		private ColorBlock m_Colors = ColorBlock.defaultColorBlock;

		[FormerlySerializedAs("spriteState")]
		[SerializeField]
		private SpriteState m_SpriteState;

		[FormerlySerializedAs("animationTriggers")]
		[SerializeField]
		private AnimationTriggers m_AnimationTriggers = new AnimationTriggers();

		[Tooltip("Can the Selectable be interacted with?")]
		[SerializeField]
		private bool m_Interactable = true;

		[FormerlySerializedAs("highlightGraphic")]
		[FormerlySerializedAs("m_HighlightGraphic")]
		[SerializeField]
		private Graphic m_TargetGraphic;

		private bool m_GroupsAllowInteraction = true;

		protected int m_CurrentIndex = -1;

		private readonly List<CanvasGroup> m_CanvasGroupCache = new List<CanvasGroup>();

		public static Selectable[] allSelectablesArray
		{
			get
			{
				Selectable[] array = new Selectable[s_SelectableCount];
				Array.Copy(s_Selectables, array, s_SelectableCount);
				return array;
			}
		}

		public static int allSelectableCount => s_SelectableCount;

		[Obsolete("Replaced with allSelectablesArray to have better performance when disabling a element", false)]
		public static List<Selectable> allSelectables => new List<Selectable>(allSelectablesArray);

		public Navigation navigation
		{
			get
			{
				return m_Navigation;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_Navigation, value))
				{
					OnSetProperty();
				}
			}
		}

		public Transition transition
		{
			get
			{
				return m_Transition;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_Transition, value))
				{
					OnSetProperty();
				}
			}
		}

		public ColorBlock colors
		{
			get
			{
				return m_Colors;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_Colors, value))
				{
					OnSetProperty();
				}
			}
		}

		public SpriteState spriteState
		{
			get
			{
				return m_SpriteState;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_SpriteState, value))
				{
					OnSetProperty();
				}
			}
		}

		public AnimationTriggers animationTriggers
		{
			get
			{
				return m_AnimationTriggers;
			}
			set
			{
				if (SetPropertyUtility.SetClass(ref m_AnimationTriggers, value))
				{
					OnSetProperty();
				}
			}
		}

		public Graphic targetGraphic
		{
			get
			{
				return m_TargetGraphic;
			}
			set
			{
				if (SetPropertyUtility.SetClass(ref m_TargetGraphic, value))
				{
					OnSetProperty();
				}
			}
		}

		public bool interactable
		{
			get
			{
				return m_Interactable;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_Interactable, value))
				{
					if (!m_Interactable && (Object)(object)EventSystem.current != (Object)null && (Object)(object)EventSystem.current.currentSelectedGameObject == (Object)(object)((Component)this).gameObject)
					{
						EventSystem.current.SetSelectedGameObject(null);
					}
					OnSetProperty();
				}
			}
		}

		private bool isPointerInside { get; set; }

		private bool isPointerDown { get; set; }

		private bool hasSelection { get; set; }

		public Image image
		{
			get
			{
				return m_TargetGraphic as Image;
			}
			set
			{
				m_TargetGraphic = value;
			}
		}

		public Animator animator => ((Component)this).GetComponent<Animator>();

		protected SelectionState currentSelectionState
		{
			get
			{
				if (!IsInteractable())
				{
					return SelectionState.Disabled;
				}
				if (isPointerDown)
				{
					return SelectionState.Pressed;
				}
				if (hasSelection)
				{
					return SelectionState.Selected;
				}
				if (isPointerInside)
				{
					return SelectionState.Highlighted;
				}
				return SelectionState.Normal;
			}
		}

		public static int AllSelectablesNoAlloc(Selectable[] selectables)
		{
			int num = ((selectables.Length < s_SelectableCount) ? selectables.Length : s_SelectableCount);
			Array.Copy(s_Selectables, selectables, num);
			return num;
		}

		protected Selectable()
		{
		}

		protected override void Awake()
		{
			if ((Object)(object)m_TargetGraphic == (Object)null)
			{
				m_TargetGraphic = ((Component)this).GetComponent<Graphic>();
			}
		}

		protected override void OnCanvasGroupChanged()
		{
			bool flag = ParentGroupAllowsInteraction();
			if (flag != m_GroupsAllowInteraction)
			{
				m_GroupsAllowInteraction = flag;
				OnSetProperty();
			}
		}

		private bool ParentGroupAllowsInteraction()
		{
			Transform val = ((Component)this).transform;
			while ((Object)(object)val != (Object)null)
			{
				((Component)val).GetComponents<CanvasGroup>(m_CanvasGroupCache);
				for (int i = 0; i < m_CanvasGroupCache.Count; i++)
				{
					if (((Behaviour)m_CanvasGroupCache[i]).enabled && !m_CanvasGroupCache[i].interactable)
					{
						return false;
					}
					if (m_CanvasGroupCache[i].ignoreParentGroups)
					{
						return true;
					}
				}
				val = val.parent;
			}
			return true;
		}

		public virtual bool IsInteractable()
		{
			if (m_GroupsAllowInteraction)
			{
				return m_Interactable;
			}
			return false;
		}

		protected override void OnDidApplyAnimationProperties()
		{
			OnSetProperty();
		}

		protected override void OnEnable()
		{
			if (!m_EnableCalled)
			{
				base.OnEnable();
				if (s_SelectableCount == s_Selectables.Length)
				{
					Selectable[] destinationArray = new Selectable[s_Selectables.Length * 2];
					Array.Copy(s_Selectables, destinationArray, s_Selectables.Length);
					s_Selectables = destinationArray;
				}
				if (Object.op_Implicit((Object)(object)EventSystem.current) && (Object)(object)EventSystem.current.currentSelectedGameObject == (Object)(object)((Component)this).gameObject)
				{
					hasSelection = true;
				}
				m_CurrentIndex = s_SelectableCount;
				s_Selectables[m_CurrentIndex] = this;
				s_SelectableCount++;
				isPointerDown = false;
				m_GroupsAllowInteraction = ParentGroupAllowsInteraction();
				DoStateTransition(currentSelectionState, instant: true);
				m_EnableCalled = true;
			}
		}

		protected override void OnTransformParentChanged()
		{
			base.OnTransformParentChanged();
			OnCanvasGroupChanged();
		}

		private void OnSetProperty()
		{
			DoStateTransition(currentSelectionState, instant: false);
		}

		protected override void OnDisable()
		{
			if (m_EnableCalled)
			{
				s_SelectableCount--;
				s_Selectables[s_SelectableCount].m_CurrentIndex = m_CurrentIndex;
				s_Selectables[m_CurrentIndex] = s_Selectables[s_SelectableCount];
				s_Selectables[s_SelectableCount] = null;
				InstantClearState();
				base.OnDisable();
				m_EnableCalled = false;
			}
		}

		private void OnApplicationFocus(bool hasFocus)
		{
			if (!hasFocus && IsPressed())
			{
				InstantClearState();
			}
		}

		protected virtual void InstantClearState()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			string normalTrigger = m_AnimationTriggers.normalTrigger;
			isPointerInside = false;
			isPointerDown = false;
			hasSelection = false;
			switch (m_Transition)
			{
			case Transition.ColorTint:
				StartColorTween(Color.white, instant: true);
				break;
			case Transition.SpriteSwap:
				DoSpriteSwap(null);
				break;
			case Transition.Animation:
				TriggerAnimation(normalTrigger);
				break;
			}
		}

		protected virtual void DoStateTransition(SelectionState state, bool instant)
		{
			//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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_00a1: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (((Component)this).gameObject.activeInHierarchy)
			{
				Color val;
				Sprite newSprite;
				string triggername;
				switch (state)
				{
				case SelectionState.Normal:
					val = m_Colors.normalColor;
					newSprite = null;
					triggername = m_AnimationTriggers.normalTrigger;
					break;
				case SelectionState.Highlighted:
					val = m_Colors.highlightedColor;
					newSprite = m_SpriteState.highlightedSprite;
					triggername = m_AnimationTriggers.highlightedTrigger;
					break;
				case SelectionState.Pressed:
					val = m_Colors.pressedColor;
					newSprite = m_SpriteState.pressedSprite;
					triggername = m_AnimationTriggers.pressedTrigger;
					break;
				case SelectionState.Selected:
					val = m_Colors.selectedColor;
					newSprite = m_SpriteState.selectedSprite;
					triggername = m_AnimationTriggers.selectedTrigger;
					break;
				case SelectionState.Disabled:
					val = m_Colors.disabledColor;
					newSprite = m_SpriteState.disabledSprite;
					triggername = m_AnimationTriggers.disabledTrigger;
					break;
				default:
					val = Color.black;
					newSprite = null;
					triggername = string.Empty;
					break;
				}
				switch (m_Transition)
				{
				case Transition.ColorTint:
					StartColorTween(val * m_Colors.colorMultiplier, instant);
					break;
				case Transition.SpriteSwap:
					DoSpriteSwap(newSprite);
					break;
				case Transition.Animation:
					TriggerAnimation(triggername);
					break;
				}
			}
		}

		public Selectable FindSelectable(Vector3 dir)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0037: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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_0104: 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_010f: 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)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			dir = ((Vector3)(ref dir)).normalized;
			Vector3 val = Quaternion.Inverse(((Component)this).transform.rotation) * dir;
			? val2 = ((Component)this).transform;
			Transform transform = ((Component)this).transform;
			Vector3 val3 = ((Transform)val2).TransformPoint(GetPointOnRectEdge((RectTransform)(object)((transform is RectTransform) ? transform : null), Vector2.op_Implicit(val)));
			float num = float.NegativeInfinity;
			float num2 = float.NegativeInfinity;
			float num3 = 0f;
			bool flag = navigation.wrapAround && (m_Navigation.mode == Navigation.Mode.Vertical || m_Navigation.mode == Navigation.Mode.Horizontal);
			Selectable selectable = null;
			Selectable result = null;
			for (int i = 0; i < s_SelectableCount; i++)
			{
				Selectable selectable2 = s_Selectables[i];
				if ((Object)(object)selectable2 == (Object)(object)this || !selectable2.IsInteractable() || selectable2.navigation.mode == Navigation.Mode.None)
				{
					continue;
				}
				Transform transform2 = ((Component)selectable2).transform;
				RectTransform val4 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
				Vector3 val5;
				if (!((Object)(object)val4 != (Object)null))
				{
					val5 = Vector3.zero;
				}
				else
				{
					Rect rect = val4.rect;
					val5 = Vector2.op_Implicit(((Rect)(ref rect)).center);
				}
				Vector3 val6 = val5;
				Vector3 val7 = ((Component)selectable2).transform.TransformPoint(val6) - val3;
				float num4 = Vector3.Dot(dir, val7);
				if (flag && num4 < 0f)
				{
					num3 = (0f - num4) * ((Vector3)(ref val7)).sqrMagnitude;
					if (num3 > num2)
					{
						num2 = num3;
						result = selectable2;
					}
				}
				else if (!(num4 <= 0f))
				{
					num3 = num4 / ((Vector3)(ref val7)).sqrMagnitude;
					if (num3 > num)
					{
						num = num3;
						selectable = selectable2;
					}
				}
			}
			if (flag && (Object)null == (Object)(object)selectable)
			{
				return result;
			}
			return selectable;
		}

		private static Vector3 GetPointOnRectEdge(RectTransform rect, Vector2 dir)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0045: 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)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0073: 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_001d: 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_0038: 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)
			if ((Object)(object)rect == (Object)null)
			{
				return Vector3.zero;
			}
			if (dir != Vector2.zero)
			{
				dir /= Mathf.Max(Mathf.Abs(dir.x), Mathf.Abs(dir.y));
			}
			Rect rect2 = rect.rect;
			Vector2 center = ((Rect)(ref rect2)).center;
			rect2 = rect.rect;
			dir = center + Vector2.Scale(((Rect)(ref rect2)).size, dir * 0.5f);
			return Vector2.op_Implicit(dir);
		}

		private void Navigate(AxisEventData eventData, Selectable sel)
		{
			if ((Object)(object)sel != (Object)null && sel.IsActive())
			{
				eventData.selectedObject = ((Component)sel).gameObject;
			}
		}

		public virtual Selectable FindSelectableOnLeft()
		{
			//IL_0030: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			if (m_Navigation.mode == Navigation.Mode.Explicit)
			{
				return m_Navigation.selectOnLeft;
			}
			if ((m_Navigation.mode & Navigation.Mode.Horizontal) != Navigation.Mode.None)
			{
				return FindSelectable(((Component)this).transform.rotation * Vector3.left);
			}
			return null;
		}

		public virtual Selectable FindSelectableOnRight()
		{
			//IL_0030: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			if (m_Navigation.mode == Navigation.Mode.Explicit)
			{
				return m_Navigation.selectOnRight;
			}
			if ((m_Navigation.mode & Navigation.Mode.Horizontal) != Navigation.Mode.None)
			{
				return FindSelectable(((Component)this).transform.rotation * Vector3.right);
			}
			return null;
		}

		public virtual Selectable FindSelectableOnUp()
		{
			//IL_0030: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			if (m_Navigation.mode == Navigation.Mode.Explicit)
			{
				return m_Navigation.selectOnUp;
			}
			if ((m_Navigation.mode & Navigation.Mode.Vertical) != Navigation.Mode.None)
			{
				return FindSelectable(((Component)this).transform.rotation * Vector3.up);
			}
			return null;
		}

		public virtual Selectable FindSelectableOnDown()
		{
			//IL_0030: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			if (m_Navigation.mode == Navigation.Mode.Explicit)
			{
				return m_Navigation.selectOnDown;
			}
			if ((m_Navigation.mode & Navigation.Mode.Vertical) != Navigation.Mode.None)
			{
				return FindSelectable(((Component)this).transform.rotation * Vector3.down);
			}
			return null;
		}

		public virtual void OnMove(AxisEventData eventData)
		{
			switch (eventData.moveDir)
			{
			case MoveDirection.Right:
				Navigate(eventData, FindSelectableOnRight());
				break;
			case MoveDirection.Up:
				Navigate(eventData, FindSelectableOnUp());
				break;
			case MoveDirection.Left:
				Navigate(eventData, FindSelectableOnLeft());
				break;
			case MoveDirection.Down:
				Navigate(eventData, FindSelectableOnDown());
				break;
			}
		}

		private void StartColorTween(Color targetColor, bool instant)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)m_TargetGraphic == (Object)null))
			{
				m_TargetGraphic.CrossFadeColor(targetColor, instant ? 0f : m_Colors.fadeDuration, ignoreTimeScale: true, useAlpha: true);
			}
		}

		private void DoSpriteSwap(Sprite newSprite)
		{
			if (!((Object)(object)image == (Object)null))
			{
				image.overrideSprite = newSprite;
			}
		}

		private void TriggerAnimation(string triggername)
		{
			if (transition == Transition.Animation && !((Object)(object)animator == (Object)null) && ((Behaviour)animator).isActiveAndEnabled && animator.hasBoundPlayables && !string.IsNullOrEmpty(triggername))
			{
				animator.ResetTrigger(m_AnimationTriggers.normalTrigger);
				animator.ResetTrigger(m_AnimationTriggers.highlightedTrigger);
				animator.ResetTrigger(m_AnimationTriggers.pressedTrigger);
				animator.ResetTrigger(m_AnimationTriggers.selectedTrigger);
				animator.ResetTrigger(m_AnimationTriggers.disabledTrigger);
				animator.SetTrigger(triggername);
			}
		}

		protected bool IsHighlighted()
		{
			if (!IsActive() || !IsInteractable())
			{
				return false;
			}
			if (isPointerInside && !isPointerDown)
			{
				return !hasSelection;
			}
			return false;
		}

		protected bool IsPressed()
		{
			if (!IsActive() || !IsInteractable())
			{
				return false;
			}
			return isPointerDown;
		}

		private void EvaluateAndTransitionToSelectionState()
		{
			if (IsActive() && IsInteractable())
			{
				DoStateTransition(currentSelectionState, instant: false);
			}
		}

		public virtual void OnPointerDown(PointerEventData eventData)
		{
			if (eventData.button == PointerEventData.InputButton.Left)
			{
				if (IsInteractable() && navigation.mode != Navigation.Mode.None && (Object)(object)EventSystem.current != (Object)null)
				{
					EventSystem.current.SetSelectedGameObject(((Component)this).gameObject, eventData);
				}
				isPointerDown = true;
				EvaluateAndTransitionToSelectionState();
			}
		}

		public virtual void OnPointerUp(PointerEventData eventData)
		{
			if (eventData.button == PointerEventData.InputButton.Left)
			{
				isPointerDown = false;
				EvaluateAndTransitionToSelectionState();
			}
		}

		public virtual void OnPointerEnter(PointerEventData eventData)
		{
			isPointerInside = true;
			EvaluateAndTransitionToSelectionState();
		}

		public virtual void OnPointerExit(PointerEventData eventData)
		{
			isPointerInside = false;
			EvaluateAndTransitionToSelectionState();
		}

		public virtual void OnSelect(BaseEventData eventData)
		{
			hasSelection = true;
			EvaluateAndTransitionToSelectionState();
		}

		public virtual void OnDeselect(BaseEventData eventData)
		{
			hasSelection = false;
			EvaluateAndTransitionToSelectionState();
		}

		public virtual void Select()
		{
			if (!((Object)(object)EventSystem.current == (Object)null) && !EventSystem.current.alreadySelecting)
			{
				EventSystem.current.SetSelectedGameObject(((Component)this).gameObject);
			}
		}
	}
	internal static class SetPropertyUtility
	{
		public static bool SetColor(ref Color currentValue, Color newValue)
		{
			//IL_0006: 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_003c: 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)
			//IL_0022: 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)
			if (currentValue.r == newValue.r && currentValue.g == newValue.g && currentValue.b == newValue.b && currentValue.a == newValue.a)
			{
				return false;
			}
			currentValue = newValue;
			return true;
		}

		public static bool SetStruct<T>(ref T currentValue, T newValue) where T : struct
		{
			if (EqualityComparer<T>.Default.Equals(currentValue, newValue))
			{
				return false;
			}
			currentValue = newValue;
			return true;
		}

		public static bool SetClass<T>(ref T currentValue, T newValue) where T : class
		{
			if ((currentValue == null && newValue == null) || (currentValue != null && currentValue.Equals(newValue)))
			{
				return false;
			}
			currentValue = newValue;
			return true;
		}
	}
	[AddComponentMenu("UI/Slider", 34)]
	[ExecuteAlways]
	[RequireComponent(typeof(RectTransform))]
	public class Slider : Selectable, IDragHandler, IEventSystemHandler, IInitializePotentialDragHandler, ICanvasElement
	{
		public enum Direction
		{
			LeftToRight,
			RightToLeft,
			BottomToTop,
			TopToBottom
		}

		[Serializable]
		public class SliderEvent : UnityEvent<float>
		{
		}

		private enum Axis
		{
			Horizontal,
			Vertical
		}

		[SerializeField]
		private RectTransform m_FillRect;

		[SerializeField]
		private RectTransform m_HandleRect;

		[Space]
		[SerializeField]
		private Direction m_Direction;

		[SerializeField]
		private float m_MinValue;

		[SerializeField]
		private float m_MaxValue = 1f;

		[SerializeField]
		private bool m_WholeNumbers;

		[SerializeField]
		protected float m_Value;

		[Space]
		[SerializeField]
		private SliderEvent m_OnValueChanged = new SliderEvent();

		private Image m_FillImage;

		private Transform m_FillTransform;

		private RectTransform m_FillContainerRect;

		private Transform m_HandleTransform;

		private RectTransform m_HandleContainerRect;

		private Vector2 m_Offset = Vector2.zero;

		private DrivenRectTransformTracker m_Tracker;

		private bool m_DelayedUpdateVisuals;

		public RectTransform fillRect
		{
			get
			{
				return m_FillRect;
			}
			set
			{
				if (SetPropertyUtility.SetClass(ref m_FillRect, value))
				{
					UpdateCachedReferences();
					UpdateVisuals();
				}
			}
		}

		public RectTransform handleRect
		{
			get
			{
				return m_HandleRect;
			}
			set
			{
				if (SetPropertyUtility.SetClass(ref m_HandleRect, value))
				{
					UpdateCachedReferences();
					UpdateVisuals();
				}
			}
		}

		public Direction direction
		{
			get
			{
				return m_Direction;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_Direction, value))
				{
					UpdateVisuals();
				}
			}
		}

		public float minValue
		{
			get
			{
				return m_MinValue;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_MinValue, value))
				{
					Set(m_Value);
					UpdateVisuals();
				}
			}
		}

		public float maxValue
		{
			get
			{
				return m_MaxValue;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_MaxValue, value))
				{
					Set(m_Value);
					UpdateVisuals();
				}
			}
		}

		public bool wholeNumbers
		{
			get
			{
				return m_WholeNumbers;
			}
			set
			{
				if (SetPropertyUtility.SetStruct(ref m_WholeNumbers, value))
				{
					Set(m_Value);
					UpdateVisuals();
				}
			}
		}

		public virtual float value
		{
			get
			{
				if (!wholeNumbers)
				{
					return m_Value;
				}
				return Mathf.Round(m_Value);
			}
			set
			{
				Set(value);
			}
		}

		public float normalizedValue
		{
			get
			{
				if (Mathf.Approximately(minValue, maxValue))
				{
					return 0f;
				}
				return Mathf.InverseLerp(minValue, maxValue, value);
			}
			set
			{
				this.value = Mathf.Lerp(minValue, maxValue, value);
			}
		}

		public SliderEvent onValueChanged
		{
			get
			{
				return m_OnValueChanged;
			}
			set
			{
				m_OnValueChanged = value;
			}
		}

		private float stepSize
		{
			get
			{
				if (!wholeNumbers)
				{
					return (maxValue - minValue) * 0.1f;
				}
				return 1f;
			}
		}

		private Axis axis
		{
			get
			{
				if (m_Direction != Direction.LeftToRight && m_Direction != Direction.RightToLeft)
				{
					return Axis.Vertical;
				}
				return Axis.Horizontal;
			}
		}

		private bool reverseValue
		{
			get
			{
				if (m_Direction != Direction.RightToLeft)
				{
					return m_Direction == Direction.TopToBottom;
				}
				return true;
			}
		}

		public virtual void SetValueWithoutNotify(float input)
		{
			Set(input, sendCallback: false);
		}

		protected Slider()
		{
		}//IL_0017: 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)


		public virtual void Rebuild(CanvasUpdate executing)
		{
		}

		public virtual void LayoutComplete()
		{
		}

		public virtual void GraphicUpdateComplete()
		{
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			UpdateCachedReferences();
			Set(m_Value, sendCallback: false);
			UpdateVisuals();
		}

		protected override void OnDisable()
		{
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			base.OnDisable();
		}

		protected virtual void Update()
		{
			if (m_DelayedUpdateVisuals)
			{
				m_DelayedUpdateVisuals = false;
				Set(m_Value, sendCallback: false);
				UpdateVisuals();
			}
		}

		protected override void OnDidApplyAnimationProperties()
		{
			//IL_00d5: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			m_Value = ClampValue(m_Value);
			float num = normalizedValue;
			Vector2 val;
			if ((Object)(object)m_FillContainerRect != (Object)null)
			{
				if ((Object)(object)m_FillImage != (Object)null && m_FillImage.type == Image.Type.Filled)
				{
					num = m_FillImage.fillAmount;
				}
				else
				{
					float num2;
					if (!reverseValue)
					{
						val = m_FillRect.anchorMax;
						num2 = ((Vector2)(ref val))[(int)axis];
					}
					else
					{
						val = m_FillRect.anchorMin;
						num2 = 1f - ((Vector2)(ref val))[(int)axis];
					}
					num = num2;
				}
			}
			else if ((Object)(object)m_HandleContainerRect != (Object)null)
			{
				float num3;
				if (!reverseValue)
				{
					val = m_HandleRect.anchorMin;
					num3 = ((Vector2)(ref val))[(int)axis];
				}
				else
				{
					val = m_HandleRect.anchorMin;
					num3 = 1f - ((Vector2)(ref val))[(int)axis];
				}
				num = num3;
			}
			UpdateVisuals();
			if (num != normalizedValue)
			{
				UISystemProfilerApi.AddMarker("Slider.value", (Object)(object)this);
				((UnityEvent<float>)onValueChanged).Invoke(m_Value);
			}
			base.OnDidApplyAnimationProperties();
		}

		private void UpdateCachedReferences()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)m_FillRect) && (Object)(object)m_FillRect != (Object)(RectTransform)((Component)this).transform)
			{
				m_FillTransform = ((Component)m_FillRect).transform;
				m_FillImage = ((Component)m_FillRect).GetComponent<Image>();
				if ((Object)(object)m_FillTransform.parent != (Object)null)
				{
					m_FillContainerRect = ((Component)m_FillTransform.parent).GetComponent<RectTransform>();
				}
			}
			else
			{
				m_FillRect = null;
				m_FillContainerRect = null;
				m_FillImage = null;
			}
			if (Object.op_Implicit((Object)(object)m_HandleRect) && (Object)(object)m_HandleRect != (Object)(RectTransform)((Component)this).transform)
			{
				m_HandleTransform = ((Component)m_HandleRect).transform;
				if ((Object)(object)m_HandleTransform.parent != (Object)null)
				{
					m_HandleContainerRect = ((Component)m_HandleTransform.parent).GetComponent<RectTransform>();
				}
			}
			else
			{
				m_HandleRect = null;
				m_HandleContainerRect = null;
			}
		}

		private float ClampValue(float input)
		{
			float num = Mathf.Clamp(input, minValue, maxValue);
			if (wholeNumbers)
			{
				num = Mathf.Round(num);
			}
			return num;
		}

		protected virtual void Set(float input, bool sendCallback = true)
		{
			float num = ClampValue(input);
			if (m_Value != num)
			{
				m_Value = num;
				UpdateVisuals();
				if (sendCallback)
				{
					UISystemProfilerApi.AddMarker("Slider.value", (Object)(object)this);
					((UnityEvent<float>)m_OnValueChanged).Invoke(num);
				}
			}
		}

		protected override void OnRectTransformDimensionsChange()
		{
			base.OnRectTransformDimensionsChange();
			if (IsActive())
			{
				UpdateVisuals();
			}
		}

		private void UpdateVisuals()
		{
			//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_0039: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			((DrivenRectTransformTracker)(ref m_Tracker)).Clear();
			if ((Object)(object)m_FillContainerRect != (Object)null)
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, m_FillRect, (DrivenTransformProperties)3840);
				Vector2 zero = Vector2.zero;
				Vector2 one = Vector2.one;
				if ((Object)(object)m_FillImage != (Object)null && m_FillImage.type == Image.Type.Filled)
				{
					m_FillImage.fillAmount = normalizedValue;
				}
				else if (reverseValue)
				{
					((Vector2)(ref zero))[(int)axis] = 1f - normalizedValue;
				}
				else
				{
					((Vector2)(ref one))[(int)axis] = normalizedValue;
				}
				m_FillRect.anchorMin = zero;
				m_FillRect.anchorMax = one;
			}
			if ((Object)(object)m_HandleContainerRect != (Object)null)
			{
				((DrivenRectTransformTracker)(ref m_Tracker)).Add((Object)(object)this, m_HandleRect, (DrivenTransformProperties)3840);
				Vector2 zero2 = Vector2.zero;
				Vector2 one2 = Vector2.one;
				Axis num = axis;
				float num2 = (((Vector2)(ref one2))[(int)axis] = (reverseValue ? (1f - normalizedValue) : normalizedValue));
				((Vector2)(ref zero2))[(int)num] = num2;
				m_HandleRect.anchorMin = zero2;
				m_HandleRect.anchorMax = one2;
			}
		}

		private void UpdateDrag(PointerEventData eventData, Camera cam)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_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)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = m_HandleContainerRect ?? m_FillContainerRect;
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			Rect rect = val.rect;
			Vector2 val2 = ((Rect)(ref rect)).size;
			if (((Vector2)(ref val2))[(int)axis] > 0f)
			{
				Vector2 position = Vector2.zero;
				Vector2 val3 = default(Vector2);
				if (MultipleDisplayUtilities.GetRelativeMousePositionForDrag(eventData, ref position) && RectTransformUtility.ScreenPointToLocalPointInRectangle(val, position, cam, ref val3))
				{
					Vector2 val4 = val3;
					rect = val.rect;
					val3 = val4 - ((Rect)(ref rect)).position;
					val2 = val3 - m_Offset;
					float num = ((Vector2)(ref val2))[(int)axis];
					rect = val.rect;
					val2 = ((Rect)(ref rect)).size;
					float num2 = Mathf.Clamp01(num / ((Vector2)(ref val2))[(int)axis]);
					normalizedValue = (reverseValue ? (1f - num2) : num2);
				}
			}
		}

		private bool MayDrag(PointerEventData eventData)
		{
			if (IsActive() && IsInteractable())
			{
				return eventData.button == PointerEventData.InputButton.Left;
			}
			return false;
		}

		public override void OnPointerDown(PointerEventData eventData)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0054: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!MayDrag(eventData))
			{
				return;
			}
			base.OnPointerDown(eventData);
			m_Offset = Vector2.zero;
			if ((Object)(object)m_HandleContainerRect != (Object)null && RectTransformUtility.RectangleContainsScreenPoint(m_HandleRect, eventData.pointerPressRaycast.screenPosition, eventData.enterEventCamera))
			{
				Vector2 offset = default(Vector2);
				if (RectTransformUtility.ScreenPointToLocalPointInRectangle(m_HandleRect, eventData.pointerPressRaycast.screenPosition, eventData.pressEventCamera, ref offset))
				{
					m_Offset = offset;
				}
			}
			else
			{
				UpdateDrag(eventData, eventData.pressEventCamera);
			}
		}

		public virtual void OnDrag(PointerEventData eventData)
		{
			if (MayDrag(eventData))
			{
				UpdateDrag(eventData, eventData.pressEventCamera);
			}
		}

		public override void OnMove(AxisEventData eventData)
		{
			if (!IsActive() || !IsInteractable())
			{
				base.OnMove(eventData);
				return;
			}
			switch (eventData.moveDir)
			{
			case MoveDirection.Left:
				if (axis == Axis.Horizontal && (Object)(object)FindSelectableOnLeft() == (Object)null)
				{
					Set(reverseValue ? (value + stepSize) : (value - stepSize));
				}
				else
				{
					base.OnMove(eventData);
				}
				break;
			case MoveDirection.Right:
				if (axis == Axis.Horizontal && (Object)(object)FindSelectableOnRight() == (Object)null)
				{
					Set(reverseValue ? (value - stepSize) : (value + stepSize));
				}
				else
				{
					base.OnMove(eventData);
				}
				break;
			case MoveDirection.Up:
				if (axis == Axis.Vertical && (Object)(object)FindSelectableOnUp() == (Object)null)
				{
					Set(reverseValue ? (value - stepSize) : (value + stepSize));
				}
				else
				{
					base.OnMove(eventData);
				}
				break;
			case MoveDirection.Down:
				if (axis == Axis.Vertical && (Object)(object)FindSelectableOnDown() == (Object)null)
				{
					Set(reverseValue ? (value + stepSize) : (value - stepSize));
				}
				else
				{
					base.OnMove(eventData);
				}
				break;
			}
		}

		public override Selectable FindSelectableOnLeft()
		{
			if (base.navigation.mode == Navigation.Mode.Automatic && axis == Axis.Horizontal)
			{
				return null;
			}
			return base.FindSelectableOnLeft();
		}

		public override Selectable FindSelectableOnRight()
		{
			if (base.navigation.mode == Navigation.Mode.Automatic && axis == Axis.Horizontal)
			{
				return null;
			}
			return base.FindSelectableOnRight();
		}

		public override Selectable FindSelectableOnUp()
		{
			if (base.navigation.mode == Navigation.Mode.Automatic && axis == Axis.Vertical)
			{
				return null;
			}
			return base.FindSelectableOnUp();
		}

		public override Selectable FindSelectableOnDown()
		{
			if (base.navigation.mode == Navigation.Mode.Automatic && axis == Axis.Vertical)
			{
				return null;
			}
			return base.FindSelectableOnDown();
		}

		public virtual void OnInitializePotentialDrag(PointerEventData eventData)
		{
			eventData.useDragThreshold = false;
		}

		public void SetDirection(Direction direction, bool includeRectLayouts)
		{
			Axis axis = this.axis;
			bool flag = reverseValue;
			this.direction = direction;
			if (includeRectLayouts)
			{
				if (this.axis != axis)
				{
					Transform transform = ((Component)this).transform;
					RectTransformUtility.FlipLayoutAxes((RectTransform)(object)((transform is RectTransform) ? transform : null), true, true);
				}
				if (reverseValue != flag)
				{
					Transform transform2 = ((Component)this).transform;
					RectTransformUtility.FlipLayoutOnAxis((RectTransform)(object)((transform2 is RectTransform) ? transform2 : null), (int)this.axis, true, true);
				}
			}
		}

		[SpecialName]
		Transform ICanvasElement.get_transform()
		{
			return ((Component)this).transform;
		}
	}
	[Serializable]
	public struct SpriteState : IEquatable<SpriteState>
	{
		[SerializeField]
		private Sprite m_HighlightedSprite;

		[SerializeField]
		private Sprite m_PressedSprite;

		[FormerlySerializedAs("m_HighlightedSprite")]
		[SerializeField]
		private Sprite m_SelectedSprite;

		[SerializeField]
		private Sprite m_DisabledSprite;

		public Sprite highlightedSprite
		{
			get
			{
				return m_HighlightedSprite;
			}
			set
			{
				m_HighlightedSprite = value;
			}
		}

		public Sprite pressedSprite
		{
			get
			{
				return m_PressedSprite;
			}
			set
			{
				m_PressedSprite = value;
			}
		}

		public Sprite selectedSprite
		{
			get
			{
				return m_SelectedSprite;
			}
			set
			{
				m_SelectedSprite = value;
			}
		}

		public Sprite disabledSprite
		{
			get
			{
				return m_DisabledSprite;
			}
			set
			{
				m_DisabledSprite = value;
			}
		}

		public bool Equals(SpriteState other)
		{
			if ((Object)(object)highlightedSprite == (Object)(object)other.highlightedSprite && (Object)(object)pressedSprite == (Object)(object)other.pressedSprite && (Object)(object)selectedSprite == (Object)(object)other.selectedSprite)
			{
				return (Object)(object)disabledSprite == (Object)(object)other.disabledSprite;
			}
			return false;
		}
	}
	public static class StencilMaterial
	{
		private class MatEntry
		{
			public Material baseMat;

			public Material customMat;

			public int count;

			public int stencilId;

			public StencilOp operation;

			public CompareFunction compareFunction = (CompareFunction)8;

			public int readMask;

			public int writeMask;

			public bool useAlphaClip;

			public ColorWriteMask colorMask;
		}

		private static List<MatEntry> m_List = new List<MatEntry>();

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Use Material.Add instead.", true)]
		public static Material Add(Material baseMat, int stencilID)
		{
			return null;
		}

		public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return Add(baseMat, stencilID, operation, compareFunction, colorWriteMask, 255, 255);
		}

		private static void LogWarningWhenNotInBatchmode(string warning, Object context)
		{
			if (!Application.isBatchMode)
			{
				Debug.LogWarning((object)warning, context);
			}
		}

		public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask, int readMask, int writeMask)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: 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_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			if ((stencilID <= 0 && (int)colorWriteMask == 15) || (Object)(object)baseMat == (Object)null)
			{
				return baseMat;
			}
			if (!baseMat.HasProperty("_Stencil"))
			{
				LogWarningWhenNotInBatchmode("Material " + ((Object)baseMat).name + " doesn't have _Stencil property", (Object)(object)baseMat);
				return baseMat;
			}
			if (!baseMat.HasProperty("_StencilOp"))
			{
				LogWarningWhenNotInBatchmode("Material " + ((Object)baseMat).name + " doesn't have _StencilOp property", (Object)(object)baseMat);
				return baseMat;
			}
			if (!baseMat.HasProperty("_StencilComp"))
			{
				LogWarningWhenNotInBatchmode("Material " + ((Object)baseMat).name + " doesn't have _StencilComp property", (Object)(object)baseMat);
				return baseMat;
			}
			if (!baseMat.HasProperty("_StencilReadMask"))
			{
				LogWarningWhenNotInBatchmode("Material " + ((Object)baseMat).name + " doesn't have _StencilReadMask property", (Object)(object)baseMat);
				return baseMat;
			}
			if (!baseMat.HasProperty("_StencilWriteMask"))
			{
				LogWarningWhenNotInBatchmode("Material " + ((Object)baseMat).name + " doesn't have _StencilWriteMask property", (Object)(object)baseMat);
				return baseMat;
			}
			if (!baseMat.HasProperty("_ColorMask"))
			{
				LogWarningWhenNotInBatchmode("Material " + ((Object)baseMat).name + " doesn't have _ColorMask property", (Object)(object)baseMat);
				return baseMat;
			}
			int count = m_List.Count;
			for (int i = 0; i < count; i++)
			{
				MatEntry matEntry = m_List[i];
				if ((Object)(object)matEntry.baseMat == (Object)(object)baseMat && matEntry.stencilId == stencilID && matEntry.operation == operation && matEntry.compareFunction == compareFunction && matEntry.readMask == readMask && matEntry.writeMask == writeMask && matEntry.colorMask == colorWriteMask)
				{
					matEntry.count++;
					return matEntry.customMat;
				}
			}
			MatEntry matEntry2 = new MatEntry();
			matEntry2.count = 1;
			matEntry2.baseMat = baseMat;
			matEntry2.customMat = new Material(baseMat);
			((Object)matEntry2.customMat).hideFlags = (HideFlags)61;
			matEntry2.stencilId = stencilID;
			matEntry2.operation = operation;
			matEntry2.compareFunction = compareFunction;
			matEntry2.readMask = readMask;
			matEntry2.writeMask = writeMask;
			matEntry2.colorMask = colorWriteMask;
			matEntry2.useAlphaClip = (int)operation != 0 && writeMask > 0;
			((Object)matEntry2.customMat).name = $"Stencil Id:{stencilID}, Op:{operation}, Comp:{compareFunction}, WriteMask:{writeMask}, ReadMask:{readMask}, ColorMask:{colorWriteMask} AlphaClip:{matEntry2.useAlphaClip} ({((Object)baseMat).name})";
			matEntry2.customMat.SetFloat("_Stencil", (float)stencilID);
			matEntry2.customMat.SetFloat("_StencilOp", (float)operation);
			matEntry2.customMat.SetFloat("_StencilComp", (float)compareFunction);
			matEntry2.customMat.SetFloat("_StencilReadMask", (float)readMask);
			matEntry2.customMat.SetFloat("_StencilWriteMask", (float)writeMask);
			matEntry2.customMat.SetFloat("_ColorMask", (float)colorWriteMask);
			matEntry2.customMat.SetFloat("_UseUIAlphaClip", matEntry2.useAlphaClip ? 1f : 0f);
			if (matEntry2.useAlphaClip)
			{
				matEntry2.customMat.EnableKeyword("UNITY_UI_ALPHACLIP");
			}
			else
			{
				matEntry2.customMat.DisableKeyword("UNITY_UI_ALPHACLIP");
			}
			m_List.Add(matEntry2);
			return matEntry2.customMat;
		}

		public static void Remove(Material customMat)
		{
			if ((Object)(object)customMat == (Object)null)
			{
				return;
			}
			int count = m_List.Count;
			for (int i = 0; i < count; i++)
			{
				MatEntry matEntry = m_List[i];
				if (!((Object)(object)matEntry.customMat != (Object)(object)customMat))
				{
					if (--matEntry.count == 0)
					{
						Misc.DestroyImmediate((Object)(object)matEntry.customMat);
						matEntry.baseMat = null;
						m_List.RemoveAt(i);
					}
					break;
				}
			}
		}

		public static void ClearAll()
		{
			int count = m_List.Count;
			for (int i = 0; i < count; i++)
			{
				MatEntry matEntry = m_List[i];
				Misc.DestroyImmediate((Object)(object)matEntry.customMat);
				matEntry.baseMat = null;
			}
			m_List.Clear();
		}
	}
	[RequireComponent(typeof(CanvasRenderer))]
	[AddComponentMenu("UI/Legacy/Text", 100)]
	public class Text : MaskableGraphic, ILayoutElement
	{
		[SerializeField]
		private FontData m_FontData = FontData.defaultFontData;

		[TextArea(3, 10)]
		[SerializeField]
		protected string m_Text = string.Empty;

		private TextGenerator m_TextCache;

		private TextGenerator m_TextCacheForLayout;

		protected static Material s_DefaultText;

		[NonSerialized]
		protected bool m_DisableFontTextureRebuiltCallback;

		private readonly UIVertex[] m_TempVerts = (UIVertex[])(object)new UIVertex[4];

		public TextGenerator cachedTextGenerator
		{
			get
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: 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_0031: Expected O, but got Unknown
				//IL_0036: Expected O, but got Unknown
				TextGenerator obj = m_TextCache;
				if (obj == null)
				{
					TextGenerator val = ((m_Text.Length != 0) ? new TextGenerator(m_Text.Length) : new TextGenerator());
					TextGenerator val2 = val;
					m_TextCache = val;
					obj = val2;
				}
				return obj;
			}
		}

		public TextGenerator cachedTextGeneratorForLayout
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_0017: Expected O, but got Unknown
				TextGenerator obj = m_TextCacheForLayout;
				if (obj == null)
				{
					TextGenerator val = new TextGenerator();
					TextGenerator val2 = val;
					m_TextCacheForLayout = val;
					obj = val2;
				}
				return obj;
			}
		}

		public override Texture mainTexture
		{
			get
			{
				if ((Object)(object)font != (Object)null && (Object)(object)font.material != (Object)null && (Object)(object)font.material.mainTexture != (Object)null)
				{
					return font.material.mainTexture;
				}
				if ((Object)(object)m_Material != (Object)null)
				{
					return m_Material.mainTexture;
				}
				return base.mainTexture;
			}
		}

		public Font font
		{
			get
			{
				return m_FontData.font;
			}
			set
			{
				if (!((Object)(object)m_FontData.font == (Object)(object)value))
				{
					if (((Behaviour)this).isActiveAndEnabled)
					{
						FontUpdateTracker.UntrackText(this);
					}
					m_FontData.font = value;
					if (((Behaviour)this).isActiveAndEnabled)
					{
						FontUpdateTracker.TrackText(this);
					}
					SetAllDirty();
				}
			}
		}

		public virtual string text
		{
			get
			{
				return m_Text;
			}
			set
			{
				if (string.IsNullOrEmpty(value))
				{
					if (!string.IsNullOrEmpty(m_Text))
					{
						m_Text = "";
						SetVerticesDirty();
					}
				}
				else if (m_Text != value)
				{
					m_Text = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public bool supportRichText
		{
			get
			{
				return m_FontData.richText;
			}
			set
			{
				if (m_FontData.richText != value)
				{
					m_FontData.richText = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public bool resizeTextForBestFit
		{
			get
			{
				return m_FontData.bestFit;
			}
			set
			{
				if (m_FontData.bestFit != value)
				{
					m_FontData.bestFit = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public int resizeTextMinSize
		{
			get
			{
				return m_FontData.minSize;
			}
			set
			{
				if (m_FontData.minSize != value)
				{
					m_FontData.minSize = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public int resizeTextMaxSize
		{
			get
			{
				return m_FontData.maxSize;
			}
			set
			{
				if (m_FontData.maxSize != value)
				{
					m_FontData.maxSize = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public TextAnchor alignment
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return m_FontData.alignment;
			}
			set
			{
				//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_0015: Unknown result type (might be due to invalid IL or missing references)
				if (m_FontData.alignment != value)
				{
					m_FontData.alignment = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public bool alignByGeometry
		{
			get
			{
				return m_FontData.alignByGeometry;
			}
			set
			{
				if (m_FontData.alignByGeometry != value)
				{
					m_FontData.alignByGeometry = value;
					SetVerticesDirty();
				}
			}
		}

		public int fontSize
		{
			get
			{
				return m_FontData.fontSize;
			}
			set
			{
				if (m_FontData.fontSize != value)
				{
					m_FontData.fontSize = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public HorizontalWrapMode horizontalOverflow
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return m_FontData.horizontalOverflow;
			}
			set
			{
				//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_0015: Unknown result type (might be due to invalid IL or missing references)
				if (m_FontData.horizontalOverflow != value)
				{
					m_FontData.horizontalOverflow = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public VerticalWrapMode verticalOverflow
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return m_FontData.verticalOverflow;
			}
			set
			{
				//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_0015: Unknown result type (might be due to invalid IL or missing references)
				if (m_FontData.verticalOverflow != value)
				{
					m_FontData.verticalOverflow = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public float lineSpacing
		{
			get
			{
				return m_FontData.lineSpacing;
			}
			set
			{
				if (m_FontData.lineSpacing != value)
				{
					m_FontData.lineSpacing = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public FontStyle fontStyle
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return m_FontData.fontStyle;
			}
			set
			{
				//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_0015: Unknown result type (might be due to invalid IL or missing references)
				if (m_FontData.fontStyle != value)
				{
					m_FontData.fontStyle = value;
					SetVerticesDirty();
					SetLayoutDirty();
				}
			}
		}

		public float pixelsPerUnit
		{
			get
			{
				Canvas val = base.canvas;
				if (!Object.op_Implicit((Object)(object)val))
				{
					return 1f;
				}
				if (!Object.op_Implicit((Object)(object)font) || font.dynamic)
				{
					return val.scaleFactor;
				}
				if (m_FontData.fontSize <= 0 || font.fontSize <= 0)
				{
					return 1f;
				}
				return (float)font.fontSize / (float)m_FontData.fontSize;
			}
		}

		public virtual float minWidth => 0f;

		public virtual float preferredWidth
		{
			get
			{
				//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_0018: Unknown result type (might be due to invalid IL or missing references)
				TextGenerationSettings generationSettings = GetGenerationSettings(Vector2.zero);
				return cachedTextGeneratorForLayout.GetPreferredWidth(m_Text, generationSettings) / pixelsPerUnit;
			}
		}

		public virtual float flexibleWidth => -1f;

		public virtual float minHeight => 0f;

		public virtual float preferredHeight
		{
			get
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: 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)
				Rect pixelAdjustedRect = GetPixelAdjustedRect();
				TextGenerationSettings generationSettings = GetGenerationSettings(new Vector2(((Rect)(ref pixelAdjustedRect)).size.x, 0f));
				return cachedTextGeneratorForLayout.GetPreferredHeight(m_Text, generationSettings) / pixelsPerUnit;
			}
		}

		public virtual float flexibleHeight => -1f;

		public virtual int layoutPriority => 0;

		protected Text()
		{
			base.useLegacyMeshGeneration = false;
		}

		public void FontTextureChanged()
		{
			if (!Object.op_Implicit((Object)(object)this) || m_DisableFontTextureRebuiltCallback)
			{
				return;
			}
			cachedTextGenerator.Invalidate();
			if (IsActive())
			{
				if (CanvasUpdateRegistry.IsRebuildingGraphics() || CanvasUpdateRegistry.IsRebuildingLayout())
				{
					UpdateGeometry();
				}
				else
				{
					SetAllDirty();
				}
			}
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			cachedTextGenerator.Invalidate();
			FontUpdateTracker.TrackText(this);
		}

		protected override void OnDisable()
		{
			FontUpdateTracker.UntrackText(this);
			base.OnDisable();
		}

		protected override void UpdateGeometry()
		{
			if ((Object)(object)font != (Object)null)
			{
				base.UpdateGeometry();
			}
		}

		internal void AssignDefaultFont()
		{
			font = Resources.GetBuiltinResource<Font>("Arial.ttf");
		}

		internal void AssignDefaultFontIfNecessary()
		{
			if ((Object)(object)font == (Object)null)
			{
				font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			}
		}

		public TextGenerationSettings GetGenerationSettings(Vector2 extents)
		{
			//IL_0002: 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)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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)
			TextGenerationSettings result = new TextGenerationSettings
			{
				generationExtents = extents
			};
			if ((Object)(object)font != (Object)null && font.dynamic)
			{
				result.fontSize = m_FontData.fontSize;
				result.resizeTextMinSize = m_FontData.minSize;
				result.resizeTextMaxSize = m_FontData.maxSize;
			}
			result.textAnchor = m_FontData.alignment;
			result.alignByGeometry = m_FontData.alignByGeometry;
			result.scaleFactor = pixelsPerUnit;
			result.color = color;
			result.font = font;
			result.pivot = base.rectTransform.pivot;
			result.richText = m_FontData.richText;
			result.lineSpacing = m_FontData.lineSpacing;
			result.fontStyle = m_FontData.fontStyle;
			result.resizeTextForBestFit = m_FontData.bestFit;
			result.updateBounds = false;
			result.horizontalOverflow = m_FontData.horizontalOverflow;
			result.verticalOverflow = m_FontData.verticalOverflow;
			return result;
		}

		public static Vector2 GetTextAnchorPivot(TextAnchor anchor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected I4, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_0079: 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_0039: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			return (Vector2)((int)anchor switch
			{
				6 => new Vector2(0f, 0f), 
				7 => new Vector2(0.5f, 0f), 
				8 => new Vector2(1f, 0f), 
				3 => new Vector2(0f, 0.5f), 
				4 => new Vector2(0.5f, 0.5f), 
				5 => new Vector2(1f, 0.5f), 
				0 => new Vector2(0f, 1f), 
				1 => new Vector2(0.5f, 1f), 
				2 => new Vector2(1f, 1f), 
				_ => Vector2.zero, 
			});
		}

		protected override void OnPopulateMesh(VertexHelper toFill)
		{
			//IL_001c: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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_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_00bf: 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)
			//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_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)font == (Object)null)
			{
				return;
			}
			m_DisableFontTextureRebuiltCallback = true;
			Rect rect = base.rectTransform.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			TextGenerationSettings generationSettings = GetGenerationSettings(size);
			cachedTextGenerator.PopulateWithErrors(text, generationSettings, ((Component)this).gameObject);
			IList<UIVertex> verts = cachedTextGenerator.verts;
			float num = 1f / pixelsPerUnit;
			int count = verts.Count;
			if (count <= 0)
			{
				toFill.Clear();
				return;
			}
			Vector2 val = new Vector2(verts[0].position.x, verts[0].position.y) * num;
			val = PixelAdjustPoint(val) - val;
			toFill.Clear();
			if (val != Vector2.zero)
			{
				for (int i = 0; i < count; i++)
				{
					int num2 = i & 3;
					m_TempVerts[num2] = verts[i];
					ref Vector3 position = ref m_TempVerts[num2].position;
					position *= num;
					m_TempVerts[num2].position.x += val.x;
					m_TempVerts[num2].position.y += val.y;
					if (num2 == 3)
					{
						toFill.AddUIVertexQuad(m_TempVerts);
					}
				}
			}
			else
			{
				for (int j = 0; j < count; j++)
				{
					int num3 = j & 3;
					m_TempVerts[num3] = verts[j];
					ref Vector3 position2 = ref m_TempVerts[num3].position;
					position2 *= num;
					if (num3 == 3)
					{
						toFill.AddUIVertexQuad(m_TempVerts);
					}
				}
			}
			m_DisableFontTextureRebuiltCallback = false;
		}

		public virtual void CalculateLayoutInputHorizontal()
		{
		}

		public virtual void CalculateLayoutInputVertical()
		{
		}
	}
	[AddComponentMenu("UI/Toggle", 30)]
	[RequireComponent(typeof(RectTransform))]
	public class Toggle : Selectable, IPointerClickHandler, IEventSystemHandler, ISubmitHandler, ICanvasElement
	{
		public enum ToggleTransition
		{
			None,
			Fade
		}

		[Serializable]
		public class ToggleEvent : UnityEvent<bool>
		{
		}

		public ToggleTransition toggleTransition = ToggleTransition.Fade;

		public Graphic graphic;

		[SerializeField]
		private ToggleGroup m_Group;

		public ToggleEvent onValueChanged = new ToggleEvent();

		[Tooltip("Is the toggle currently on or off?")]
		[SerializeField]
		private bool m_IsOn;

		public ToggleGroup group
		{
			get
			{
				return m_Group;
			}
			set
			{
				SetToggleGroup(value, setMemberValue: true);
				PlayEffect(instant: true);
			}
		}

		public bool isOn
		{
			get
			{
				return m_IsOn;
			}
			set
			{
				Set(value);
			}
		}

		protected Toggle()
		{
		}

		public virtual void Rebuild(CanvasUpdate executing)
		{
		}

		public virtual void LayoutComplete()
		{
		}

		public virtual void GraphicUpdateComplete()
		{
		}

		protected override void OnDestroy()
		{
			if ((Object)(object)m_Group != (Object)null)
			{
				m_Group.EnsureValidState();
			}
			base.OnDestroy();
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			SetToggleGroup(m_Group, setMemberValue: false);
			PlayEffect(instant: true);
		}

		protected override void OnDisable()
		{
			SetToggleGroup(null, setMemberValue: false);
			base.OnDisable();
		}

		protected override void OnDidApplyAnimationProperties()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)graphic != (Object)null)
			{
				bool flag = !Mathf.Approximately(graphic.canvasRenderer.GetColor().a, 0f);
				if (m_IsOn != flag)
				{
					m_IsOn = flag;
					Set(!flag);
				}
			}
			base.OnDidApplyAnimationProperties();
		}

		private void SetToggleGroup(ToggleGroup newGroup, bool setMemberValue)
		{
			if ((Object)(object)m_Group != (Object)null)
			{
				m_Group.UnregisterToggle(this);
			}
			if (setMemberValue)
			{
				m_Group = newGroup;
			}
			if ((Object)(object)newGroup != (Object)null && IsActive())
			{
				newGroup.RegisterToggle(this);
			}
			if ((Object)(object)newGroup != (Object)null && isOn && IsActive())
			{
				newGroup.NotifyToggleOn(this);
			}
		}

		public void SetIsOnWithoutNotify(bool value)
		{
			Set(value, sendCallback: false);
		}

		private void Set(bool value, bool sendCallback = true)
		{
			if (m_IsOn != value)
			{
				m_IsOn = value;
				if ((Object)(object)m_Group != (Object)null && ((Behaviour)m_Group).isActiveAndEnabled && IsActive() && (m_IsOn || (!m_Group.AnyTogglesOn() && !m_Group.allowSwitchOff)))
				{
					m_IsOn = true;
					m_Group.NotifyToggleOn(this, sendCallback);
				}
				PlayEffect(toggleTransition == ToggleTransition.None);
				if (sendCallback)
				{
					UISystemProfilerApi.AddMarker("Toggle.value", (Object)(object)this);
					((UnityEvent<bool>)onValueChanged).Invoke(m_IsOn);
				}
			}
		}

		private void PlayEffect(bool instant)
		{
			if (!((Object)(object)graphic == (Object)null))
			{
				graphic.CrossFadeAlpha(m_IsOn ? 1f : 0f, instant ? 0f : 0.1f, ignoreTimeScale: true);
			}
		}

		protected override void Start()
		{
			PlayEffect(instant: true);
		}

		private void InternalToggle()
		{
			if (IsActive() && IsInteractable())
			{
				isOn = !isOn;
			}
		}

		public virtual void OnPointerClick(PointerEventData eventData)
		{
			if (eventData.button == PointerEventData.InputButton.Left)
			{
				InternalToggle();
			}
		}

		public virtual void OnSubmit(BaseEventData eventData)
		{
			InternalToggle();
		}

		[SpecialName]
		Transform ICanvasElement.get_transform()
		{
			return ((Component)this).transform;
		}
	}
	[AddComponentMenu("UI/Toggle Group", 31)]
	[DisallowMultipleComponent]
	public class ToggleGroup : UIBehaviour
	{
		[SerializeField]
		private bool m_AllowSwitchOff;

		protected List<Toggle> m_Toggles = new List<Toggle>();

		public bool allowSwitchOff
		{
			get
			{
				return m_AllowSwitchOff;
			}
			set
			{
				m_AllowSwitchOff = value;
			}
		}

		protected ToggleGroup()
		{
		}

		protected override void Start()
		{
			EnsureValidState();
			base.Start();
		}

		protected override void OnEnable()
		{
			EnsureValidState();
			base.OnEnable();
		}

		private void ValidateToggleIsInGroup(Toggle toggle)
		{
			if ((Object)(object)toggle == (Object)null || !m_Toggles.Contains(toggle))
			{
				throw new ArgumentException(string.Format("Toggle {0} is not part of ToggleGroup {1}", new object[2] { toggle, this }));
			}
		}

		public void NotifyToggleOn(Toggle toggle, bool sendCallback = true)
		{
			ValidateToggleIsInGroup(toggle);
			for (int i = 0; i < m_Toggles.Count; i++)
			{
				if (!((Object)(object)m_Toggles[i] == (Object)(object)toggle))
				{
					if (sendCallback)
					{
						m_Toggles[i].isOn = false;
					}
					else
					{
						m_Toggles[i].SetIsOnWithoutNotify(value: false);
					}
				}
			}
		}

		public void UnregisterToggle(Toggle toggle)
		{
			if (m_Toggles.Contains(toggle))
			{
				m_Toggles.Remove(toggle);
			}
		}

		public void RegisterToggle(Toggle toggle)
		{
			if (!m_Toggles.Contains(toggle))
			{
				m_Toggles.Add(toggle);
			}
		}

		public void EnsureValidState()
		{
			if (!allowSwitchOff && !AnyTogglesOn() && m_Toggles.Count != 0)
			{
				m_Toggles[0].isOn = true;
				NotifyToggleOn(m_Toggles[0]);
			}
			IEnumerable<Toggle> enumerable = ActiveToggles();
			if (enumerable.Count() <= 1)
			{
				return;
			}
			Toggle firstActiveToggle = GetFirstActiveToggle();
			foreach (Toggle item in enumerable)
			{
				if (!((Object)(object)item == (Object)(object)firstActiveToggle))
				{
					item.isOn = false;
				}
			}
		}

		public bool AnyTogglesOn()
		{
			return (Object)(object)m_Toggles.Find((Toggle x) => x.isOn) != (Object)null;
		}

		public IEnumerable<Toggle> ActiveToggles()
		{
			return m_Toggles.Where((Toggle x) => x.isOn);
		}

		public Toggle GetFirstActiveToggle()
		{
			IEnumerable<Toggle> source = ActiveToggles();
			if (source.Count() <= 0)
			{
				return null;
			}
			return source.First();
		}

		public void SetAllTogglesOff(bool sendCallback = true)
		{
			bool flag = m_AllowSwitchOff;
			m_AllowSwitchOff = true;
			if (sendCallback)
			{
				for (int i = 0; i < m_Toggles.Count; i++)
				{
					m_Toggles[i].isOn = false;
				}
			}
			else
			{
				for (int j = 0; j < m_Toggles.Count; j++)
				{
					m_Toggles[j].SetIsOnWithoutNotify(value: false);
				}
			}
			m_AllowSwitchOff = flag;
		}
	}
	internal class ReflectionMethodsCache
	{
		public delegate bool Raycast3DCallback(Ray r, out RaycastHit hit, float f, int i);

		public delegate RaycastHit[] RaycastAllCallback(Ray r, float f, int i);

		public delegate int GetRaycastNonAllocCallback(Ray r, RaycastHit[] results, float f, int i);

		public delegate RaycastHit2D Raycast2DCallback(Vector2 p1, Vector2 p2, float f, int i);

		public delegate RaycastHit2D[] GetRayIntersectionAllCallback(Ray r, float f, int i);

		public delegate int GetRayIntersectionAllNonAllocCallback(Ray r, RaycastHit2D[] results, float f, int i);

		public Raycast3DCallback raycast3D;

		public RaycastAllCallback raycast3DAll;

		public GetRaycastNonAllocCallback getRaycastNonAlloc;

		public Raycast2DCallback raycast2D;

		public GetRayIntersectionAllCallback getRayIntersectionAll;

		public GetRayIntersectionAllNonAllocCallback getRayIntersectionAllNonAlloc;

		private static ReflectionMethodsCache s_ReflectionMethodsCache;

		public static ReflectionMethodsCache Singleton
		{
			get
			{
				if (s_ReflectionMethodsCache == null)
				{
					s_ReflectionMethodsCache = new ReflectionMethodsCache();
				}
				return s_ReflectionMethodsCache;
			}
		}

		public ReflectionMethodsCache()
		{
			MethodInfo method = typeof(Physics).GetMethod("Raycast", new Type[4]
			{
				typeof(Ray),
				typeof(RaycastHit).MakeByRefType(),
				typeof(float),
				typeof(int)
			});
			if (method != null)
			{
				raycast3D = (Raycast3DCallback)Delegate.CreateDelegate(typeof(Raycast3DCallback), method);
			}
			MethodInfo method2 = typeof(Physics).GetMethod("RaycastAll", new Type[3]
			{
				typeof(Ray),
				typeof(float),
				typeof(int)
			});
			if (method2 != null)
			{
				raycast3DAll = (RaycastAllCallback)Delegate.CreateDelegate(typeof(RaycastAllCallback), method2);
			}
			MethodInfo method3 = typeof(Physics).GetMethod("RaycastNonAlloc", new Type[4]
			{
				typeof(Ray),
				typeof(RaycastHit[]),
				typeof(float),
				typeof(int)
			});
			if (method3 != null)
			{
				getRaycastNonAlloc = (GetRaycastNonAllocCallback)Delegate.CreateDelegate(typeof(GetRaycastNonAllocCallback), method3);
			}
			MethodInfo method4 = typeof(Physics2D).GetMethod("Raycast", new Type[4]
			{
				typeof(Vector2),
				typeof(Vector2),
				typeof(float),
				typeof(int)
			});
			if (method4 != null)
			{
				raycast2D = (Raycast2DCallback)Delegate.CreateDelegate(typeof(Raycast2DCallback), method4);
			}
			MethodInfo method5 = typeof(Physics2D).GetMethod("GetRayIntersectionAll", new Type[3]
			{
				typeof(Ray),
				typeof(float),
				typeof(int)
			});
			if (method5 != null)
			{
				getRayIntersectionAll = (GetRayIntersectionAllCallback)Delegate.CreateDelegate(typeof(GetRayIntersectionAllCallback), method5);
			}
			MethodInfo method6 = typeof(Physics2D).GetMethod("GetRayIntersectionNonAlloc", new Type[4]
			{
				typeof(Ray),
				typeof(RaycastHit2D[]),
				typeof(float),
				typeof(int)
			});
			if (method6 != null)
			{
				getRayIntersectionAllNonAlloc = (GetRayIntersectionAllNonAllocCallback)Delegate.CreateDelegate(typeof(GetRayIntersectionAllNonAllocCallback), method6);
			}
		}
	}
	public class VertexHelper : IDisposable
	{
		private List<Vector3> m_Positions;

		private List<Color32> m_Colors;

		private List<Vector4> m_Uv0S;

		private List<Vector4> m_Uv1S;

		private List<Vector4> m_Uv2S;

		private List<Vector4> m_Uv3S;

		private List<Vector3> m_Normals;

		private List<Vector4> m_Tangents;

		private List<int> m_Indices;

		private static readonly Vector4 s_DefaultTangent = new Vector4(1f, 0f, 0f, -1f);

		private static readonly Vector3 s_DefaultNormal = Vector3.back;

		private bool m_ListsInitalized;

		public int currentVertCount
		{
			get
			{
				if (m_Positions == null)
				{
					return 0;
				}
				return m_Positions.Count;
			}
		}

		public int currentIndexCount
		{
			get
			{
				if (m_Indices == null)
				{
					return 0;
				}
				return m_Indices.Count;
			}
		}

		public VertexHelper()
		{
		}

		public VertexHelper(Mesh m)
		{
			InitializeListIfRequired();
			m_Positions.AddRange(m.vertices);
			m_Colors.AddRange(m.colors32);
			List<Vector4> list = new List<Vector4>();
			m.GetUVs(0, list);
			m_Uv0S.AddRange(list);
			m.GetUVs(1, list);
			m_Uv1S.AddRange(list);
			m.GetUVs(2, list);
			m_Uv2S.AddRange(list);
			m.GetUVs(3, list);
			m_Uv3S.AddRange(list);
			m_Normals.AddRange(m.normals);
			m_Tangents.AddRange(m.tangents);
			m_Indices.AddRange(m.GetIndices(0));
		}

		private void InitializeListIfRequired()
		{
			if (!m_ListsInitalized)
			{
				m_Positions = CollectionPool<List<Vector3>, Vector3>.Get();
				m_Colors = CollectionPool<List<Color32>, Color32>.Get();
				m_Uv0S = CollectionPool<List<Vector4>, Vector4>.Get();
				m_Uv1S = CollectionPool<List<Vector4>, Vector4>.Get();
				m_Uv2S = CollectionPool<List<Vector4>, Vector4>.Get();
				m_Uv3S = CollectionPool<List<Vector4>, Vector4>.Get();
				m_Normals = CollectionPool<List<Vector3>, Vector3>.Get();
				m_Tangents = CollectionPool<List<Vector4>, Vector4>.Get();
				m_Indices = CollectionPool<List<int>, int>.Get();
				m_ListsInitalized = true;
			}
		}

		public void Dispose()
		{
			if (m_ListsInitalized)
			{
				CollectionPool<List<Vector3>, Vector3>.Release(m_Positions);
				CollectionPool<List<Color32>, Color32>.Release(m_Colors);
				CollectionPool<List<Vector4>, Vector4>.Release(m_Uv0S);
				CollectionPool<List<Vector4>, Vector4>.Release(m_Uv1S);
				CollectionPool<List<Vector4>, Vector4>.Release(m_Uv2S);
				CollectionPool<List<Vector4>, Vector4>.Release(m_Uv3S);
				CollectionPool<List<Vector3>, Vector3>.Release(m_Normals);
				CollectionPool<List<Vector4>, Vector4>.Release(m_Tangents);
				CollectionPool<List<int>, int>.Release(m_Indices);
				m_Positions = null;
				m_Colors = null;
				m_Uv0S = null;
				m_Uv1S = null;
				m_Uv2S = null;
				m_Uv3S = null;
				m_Normals = null;
				m_Tangents = null;
				m_Indices = null;
				m_ListsInitalized = false;
			}
		}

		public void Clear()
		{
			if (m_ListsInitalized)
			{
				m_Positions.Clear();
				m_Colors.Clear();
				m_Uv0S.Clear();
				m_Uv1S.Clear();
				m_Uv2S.Clear();
				m_Uv3S.Clear();
				m_Normals.Clear();
				m_Tangents.Clear();
				m_Indices.Clear();
			}
		}

		public void PopulateUIVertex(ref UIVertex vertex, int i)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0044: 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_0056: 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_0068: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			InitializeListIfRequired();
			vertex.position = m_Positions[i];
			vertex.color = m_Colors[i];
			vertex.uv0 = m_Uv0S[i];
			vertex.uv1 = m_Uv1S[i];
			vertex.uv2 = m_Uv2S[i];
			vertex.uv3 = m_Uv3S[i];
			vertex.normal = m_Normals[i];
			vertex.tangent = m_Tangents[i];
		}

		public void SetUIVertex(UIVertex vertex, int i)
		{
			//IL_000d: 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_001f: 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_0031: 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_0043: 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_0055: 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_0068: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			InitializeListIfRequired();
			m_Positions[i] = vertex.position;
			m_Colors[i] = vertex.color;
			m_Uv0S[i] = vertex.uv0;
			m_Uv1S[i] = vertex.uv1;
			m_Uv2S[i] = vertex.uv2;
			m_Uv3S[i] = vertex.uv3;
			m_Normals[i] = vertex.normal;
			m_Tangents[i] = vertex.tangent;
		}

		public void FillMesh(Mesh mesh)
		{
			InitializeListIfRequired();
			mesh.Clear();
			if (m_Positions.Count >= 65000)
			{
				throw new ArgumentException("Mesh can not have more than 65000 vertices");
			}
			mesh.SetVertices(m_Positions);
			mesh.SetColors(m_Colors);
			mesh.SetUVs(0, m_Uv0S);
			mesh.SetUVs(1, m_Uv1S);
			mesh.SetUVs(2, m_Uv2S);
			mesh.SetUVs(3, m_Uv3S);
			mesh.SetNormals(m_Normals);
			mesh.SetTangents(m_Tangents);
			mesh.SetTriangles(m_Indices, 0);
			mesh.RecalculateBounds();
		}

		public void AddVert(Vector3 position, Color32 color, Vector4 uv0, Vector4 uv1, Vector4 uv2, Vector4 uv3, Vector3 normal, Vector4 tangent)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0030: 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_004a: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			InitializeListIfRequired();
			m_Positions.Add(position);
			m_Colors.Add(color);
			m_Uv0S.Add(uv0);
			m_Uv1S.Add(uv1);
			m_Uv2S.Add(uv2);
			m_Uv3S.Add(uv3);
			m_Normals.Add(normal);
			m_Tangents.Add(tangent);
		}

		public void AddVert(Vector3 position, Color32 color, Vector4 uv0, Vector4 uv1, Vector3 normal, Vector4 tangent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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_0010: 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)
			AddVert(position, color, uv0, uv1, Vector4.zero, Vector4.zero, normal, tangent);
		}

		public void AddVert(Vector3 position, Color32 color, Vector4 uv0)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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)
			AddVert(position, color, uv0, Vector4.zero, s_DefaultNormal, s_DefaultTangent);
		}

		public void AddVert(UIVertex v)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002c: Unknown result type (might be due to invalid IL or missing references)
			AddVert(v.position, v.color, v.uv0, v.uv1, v.uv2, v.uv3, v.normal, v.tangent);
		}

		public void AddTriangle(int idx0, int idx1, int idx2)
		{
			InitializeListIfRequired();
			m_Indices.Add(idx0);
			m_Indices.Add(idx1);
			m_Indices.Add(idx2);
		}

		public void AddUIVertexQuad(UIVertex[] verts)
		{
			//IL_0013: 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_0037: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			int num = currentVertCount;
			for (int i = 0; i < 4; i++)
			{
				AddVert(verts[i].position, verts[i].color, verts[i].uv0, verts[i].uv1, verts[i].normal, verts[i].tangent);
			}
			AddTriangle(num, num + 1, num + 2);
			AddTriangle(num + 2, num + 3, num);
		}

		public void AddUIVertexStream(List<UIVertex> verts, List<int> indices)
		{
			InitializeListIfRequired();
			if (verts != null)
			{
				CanvasRenderer.AddUIVertexStream(verts, m_Positions, m_Colors, m_Uv0S, m_Uv1S, m_Uv2S, m_Uv3S, m_Normals, m_Tangents);
			}
			if (indices != null)
			{
				m_Indices.AddRange(indices);
			}
		}

		public void AddUIVertexTriangleStream(List<UIVertex> verts)
		{
			if (verts != null)
			{
				InitializeListIfRequired();
				CanvasRenderer.SplitUIVertexStreams(verts, m_Positions, m_Colors, m_Uv0S, m_Uv1S, m_Uv2S, m_Uv3S, m_Normals, m_Tangents, m_Indices);
			}
		}

		public void GetUIVertexStream(List<UIVertex> stream)
		{
			if (stream != null)
			{
				InitializeListIfRequired();
				CanvasRenderer.CreateUIVertexStream(stream, m_Positions, m_Colors, m_Uv0S, m_Uv1S, m_Uv2S, m_Uv3S, m_Normals, m_Tangents, m_Indices);
			}
		}
	}
	[Obsolete("Use BaseMeshEffect instead", true)]
	public abstract class BaseVertexEffect
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Use BaseMeshEffect.ModifyMeshes instead", true)]
		public abstract void ModifyVertices(List<UIVertex> vertices);
	}
	[ExecuteAlways]
	public abstract class BaseMeshEffect : UIBehaviour, IMeshModifier
	{
		[NonSerialized]
		private Graphic m_Graphic;

		protected Graphic graphic
		{
			get
			{
				if ((Object)(object)m_Graphic == (Object)null)
				{
					m_Graphic = ((Component)this).GetComponent<Graphic>();
				}
				return m_Graphic;
			}
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			if ((Object)(object)graphic != (Object)null)
			{
				graphic.SetVerticesDirty();
			}
		}

		protected override void OnDisable()
		{
			if ((Object)(object)graphic != (Object)null)
			{
				graphic.SetVerticesDirty();
			}
			base.OnDisable();
		}

		protected override void OnDidApplyAnimationProperties()
		{
			if ((Object)(object)graphic != (Object)null)
			{
				graphic.SetVerticesDirty();
			}
			base.OnDidApplyAnimationProperties();
		}

		public virtual void ModifyMesh(Mesh mesh)
		{
			using VertexHelper vertexHelper = new VertexHelper(mesh);
			ModifyMesh(vertexHelper);
			vertexHelper.FillMesh(mesh);
		}

		public abstract void ModifyMesh(VertexHelper vh);
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[Obsolete("Use IMeshModifier instead", true)]
	public interface IVertexModifier
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("use IMeshModifier.ModifyMesh (VertexHelper verts)  instead", true)]
		void ModifyVertices(List<UIVertex> verts);
	}
	public interface IMeshModifier
	{
		[Obsolete("use IMeshModifier.ModifyMesh (VertexHelper verts) instead", false)]
		void ModifyMesh(Mesh mesh);

		void ModifyMesh(VertexHelper verts);
	}
	[AddComponentMenu("UI/Effects/Outline", 81)]
	public class Outline : Shadow
	{
		protected Outline()
		{
		}

		public override void ModifyMesh(VertexHelper vh)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0070: 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)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00b9: 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_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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (IsActive())
			{
				List<UIVertex> list = CollectionPool<List<UIVertex>, UIVertex>.Get();
				vh.GetUIVertexStream(list);
				int num = list.Count * 5;
				if (list.Capacity < num)
				{
					list.Capacity = num;
				}
				int start = 0;
				int count = list.Count;
				ApplyShadowZeroAlloc(list, Color32.op_Implicit(base.effectColor), start, list.Count, base.effectDistance.x, base.effectDistance.y);
				start = count;
				int count2 = list.Count;
				ApplyShadowZeroAlloc(list, Color32.op_Implicit(base.effectColor), start, list.Count, base.effectDistance.x, 0f - base.effectDistance.y);
				start = count2;
				int count3 = list.Count;
				ApplyShadowZeroAlloc(list, Color32.op_Implicit(base.effectColor), start, list.Count, 0f - base.effectDistance.x, base.effectDistance.y);
				start = count3;
				_ = list.Count;
				ApplyShadowZeroAlloc(list, Color32.op_Implicit(base.effectColor), start, list.Count, 0f - base.effectDistance.x, 0f - base.effectDistance.y);
				vh.Clear();
				vh.AddUIVertexTriangleStream(list);
				CollectionPool<List<UIVertex>, UIVertex>.Release(list);
			}
		}
	}
	[AddComponentMenu("UI/Effects/Position As UV1", 82)]
	public class PositionAsUV1 : BaseMeshEffect
	{
		protected PositionAsUV1()
		{
		}

		public override void ModifyMesh(VertexHelper vh)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			UIVertex vertex = default(UIVertex);
			for (int i = 0; i < vh.currentVertCount; i++)
			{
				vh.PopulateUIVertex(ref vertex, i);
				vertex.uv1 = Vector4.op_Implicit(new Vector2(vertex.position.x, vertex.position.y));
				vh.SetUIVertex(vertex, i);
			}
		}
	}
	[AddComponentMenu("UI/Effects/Shadow", 80)]
	public class Shadow : BaseMeshEffect
	{
		[SerializeField]
		private Color m_EffectColor = new Color(0f, 0f, 0f, 0.5f);

		[SerializeField]
		private Vector2 m_EffectDistance = new Vector2(1f, -1f);

		[SerializeField]
		private bool m_UseGraphicAlpha = true;

		private const float kMaxEffectDistance = 600f;

		public Color effectColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_EffectColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_EffectColor = value;
				if ((Object)(object)base.graphic != (Object)null)
				{
					base.graphic.SetVerticesDirty();
				}
			}
		}

		public Vector2 effectDistance
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_EffectDistance;
			}
			set
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: 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_004b: 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_006a: 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_0075: Unknown result type (might be due to invalid IL or missing references)
				if (value.x > 600f)
				{
					value.x = 600f;
				}
				if (value.x < -600f)
				{
					value.x = -600f;
				}
				if (value.y > 600f)
				{
					value.y = 600f;
				}
				if (value.y < -600f)
				{
					value.y = -600f;
				}
				if (!(m_EffectDistance == value))
				{
					m_EffectDistance = value;
					if ((Object)(object)base.graphic != (Object)null)
					{
						base.graphic.SetVerticesDirty();
					}
				}
			}
		}

		public bool useGraphicAlpha
		{
			get
			{
				return m_UseGraphicAlpha;
			}
			set
			{
				m_UseGraphicAlpha = value;
				if ((Object)(object)base.graphic != (Object)null)
				{
					base.graphic.SetVerticesDirty();
				}
			}
		}

		protected Shadow()
		{
		}//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: 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)


		protected void ApplyShadowZeroAlloc(List<UIVertex> verts, Color32 color, int start, int end, float x, float y)
		{
			//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_0029: 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_0030: 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_0052: 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_0058: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_006e: 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)
			int num = verts.Count + end - start;
			if (verts.Capacity < num)
			{
				verts.Capacity = num;
			}
			for (int i = start; i < end; i++)
			{
				UIVertex val = verts[i];
				verts.Add(val);
				Vector3 position = val.position;
				position.x += x;
				position.y += y;
				val.position = position;
				Color32 val2 = color;
				if (m_UseGraphicAlpha)
				{
					val2.a = (byte)(val2.a * verts[i].color.a / 255);
				}
				val.color = val2;
				verts[i] = val;
			}
		}

		protected void ApplyShadow(List<UIVertex> verts, Color32 color, int start, int end, float x, float y)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			ApplyShadowZeroAlloc(verts, color, start, end, x, y);
		}

		public override void ModifyMesh(VertexHelper vh)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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)
			if (IsActive())
			{
				List<UIVertex> list = CollectionPool<List<UIVertex>, UIVertex>.Get();
				vh.GetUIVertexStream(list);
				ApplyShadow(list, Color32.op_Implicit(effectColor), 0, list.Count, effectDistance.x, effectDistance.y);
				vh.Clear();
				vh.AddUIVertexTriangleStream(list);
				CollectionPool<List<UIVertex>, UIVertex>.Release(list);
			}
		}
	}
}
namespace UnityEngine.UI.Collections
{
	internal class IndexedSet<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
	{
		private readonly List<T> m_List = new List<T>();

		private Dictionary<T, int> m_Dictionary = new Dictionary<T, int>();

		private int m_EnabledObjectCount;

		public int Count => m_EnabledObjectCount;

		public int Capacity => m_List.Count;

		public bool IsReadOnly => false;

		public T this[int index]
		{
			get
			{
				if ((uint)index >= (uint)m_EnabledObjectCount)
				{
					throw new IndexOutOfRangeException();
				}
				return m_List[index];
			}
			set
			{
				T key = m_List[index];
				m_Dictionary.Remove(key);
				m_List[index] = value;
				m_Dictionary.Add(value, index);
			}
		}

		public void Add(T item)
		{
			Add(item, isActive: true);
		}

		public void Add(T item, bool isActive)
		{
			m_List.Add(item);
			m_Dictionary.Add(item, m_List.Count - 1);
			if (isActive)
			{
				EnableItem(item);
			}
		}

		public bool AddUnique(T item, bool isActive = true)
		{
			if (m_Dictionary.ContainsKey(item))
			{
				if (isActive)
				{
					EnableItem(item);
				}
				else
				{
					DisableItem(item);
				}
				return false;
			}
			Add(item, isActive);
			return true;
		}

		public bool EnableItem(T item)
		{
			if (!m_Dictionary.TryGetValue(item, out var value))
			{
				return false;
			}
			if (value < m_EnabledObjectCount)
			{
				return true;
			}
			if (value > m_EnabledObjectCount)
			{
				Swap(m_EnabledObjectCount, value);
			}
			m_EnabledObjectCount++;
			return true;
		}

		public bool DisableItem(T item)
		{
			if (!m_Dictionary.TryGetValue(item, out var value))
			{
				return false;
			}
			if (value >= m_EnabledObjectCount)
			{
				return true;
			}
			if (value < m_EnabledObjectCount - 1)
			{
				Swap(value, m_EnabledObjectCount - 1);
			}
			m_EnabledObjectCount--;
			return true;
		}

		public bool Remove(T item)
		{
			int value = -1;
			if (!m_Dictionary.TryGetValue(item, out value))
			{
				return false;
			}
			RemoveAt(value);
			return true;
		}

		public IEnumerator<T> GetEnumerator()
		{
			throw new NotImplementedException();
		}

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

		public void Clear()
		{
			m_List.Clear();
			m_Dictionary.Clear();
			m_EnabledObjectCount = 0;
		}

		public bool Contains(T item)
		{
			return m_Dictionary.ContainsKey(item);
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			m_List.CopyTo(array, arrayIndex);
		}

		public int IndexOf(T item)
		{
			int value = -1;
			if (m_Dictionary.TryGetValue(item, out value))
			{
				return value;
			}
			return -1;
		}

		public void Insert(int index, T item)
		{
			throw new NotSupportedException("Random Insertion is semantically invalid, since this structure does not guarantee ordering.");
		}

		public void RemoveAt(int index)
		{
			T key = m_List[index];
			if (index == m_List.Count - 1)
			{
				if (m_EnabledObjectCount == m_List.Count)
				{
					m_EnabledObjectCount--;
				}
				m_List.RemoveAt(index);
			}
			else
			{
				int num = m_List.Count - 1;
				if (index < m_EnabledObjectCount - 1)
				{
					Swap(--m_EnabledObjectCount, index);
					index = m_EnabledObjectCount;
				}
				else if (index == m_EnabledObjectCount - 1)
				{
					m_EnabledObjectCount--;
				}
				Swap(num, index);
				m_List.RemoveAt(num);
			}
			m_Dictionary.Remove(key);
		}

		private void Swap(int index1, int index2)
		{
			if (index1 != index2)
			{
				T val = m_List[index1];
				T val2 = m_List[index2];
				m_List[index1] = val2;
				m_List[index2] = val;
				m_Dictionary[val2] = index1;
				m_Dictionary[val] = index2;
			}
		}

		public void RemoveAll(Predicate<T> match)
		{
			int num = 0;
			while (num < m_List.Count)
			{
				T val = m_List[num];
				if (match(val))
				{
					Remove(val);
				}
				else
				{
					num++;
				}
			}
		}

		public void Sort(Comparison<T> sortLayoutFunction)
		{
			m_List.Sort(sortLayoutFunction);
			for (int i = 0; i < m_List.Count; i++)
			{
				T key = m_List[i];
				m_Dictionary[key] = i;
			}
		}
	}
}
namespace UnityEngine.UI.CoroutineTween
{
	internal interface ITweenValue
	{
		bool ignoreTimeScale { get; }

		float duration { get; }

		void TweenValue(float floatPercentage);

		bool ValidTarget();
	}
	internal struct ColorTween : ITweenValue
	{
		public enum ColorTweenMode
		{
			All,
			RGB,
			Alpha
		}

		public class ColorTweenCallback : UnityEvent<Color>
		{
		}

		private ColorTweenCallback m_Target;

		private Color m_StartColor;

		private Color m_TargetColor;

		private ColorTweenMode m_TweenMode;

		private float m_Duration;

		private bool m_IgnoreTimeScale;

		public Color startColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_StartColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_StartColor = value;
			}
		}

		public Color targetColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_TargetColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_TargetColor = value;
			}
		}

		public ColorTweenMode tweenMode
		{
			get
			{
				return m_TweenMode;
			}
			set
			{
				m_TweenMode = value;
			}
		}

		public float duration
		{
			get
			{
				return m_Duration;
			}
			set
			{
				m_Duration = value;
			}
		}

		public bool ignoreTimeScale
		{
			get
			{
				return m_IgnoreTimeScale;
			}
			set
			{
				m_IgnoreTimeScale = value;
			}
		}

		public void TweenValue(float floatPercentage)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (ValidTarget())
			{
				Color val = Color.Lerp(m_StartColor, m_TargetColor, floatPercentage);
				if (m_TweenMode == ColorTweenMode.Alpha)
				{
					val.r = m_StartColor.r;
					val.g = m_StartColor.g;
					val.b = m_StartColor.b;
				}
				else if (m_TweenMode == ColorTweenMode.RGB)
				{
					val.a = m_StartColor.a;
				}
				((UnityEvent<Color>)m_Target).Invoke(val);
			}
		}

		public void AddOnChangedCallback(UnityAction<Color> callback)
		{
			if (m_Target == null)
			{
				m_Target = new ColorTweenCallback();
			}
			((UnityEvent<Color>)m_Target).AddListener(callback);
		}

		public bool GetIgnoreTimescale()
		{
			return m_IgnoreTimeScale;
		}

		public float GetDuration()
		{
			return m_Duration;
		}

		public bool ValidTarget()
		{
			return m_Target != null;
		}
	}
	internal struct FloatTween : ITweenValue
	{
		public class FloatTweenCallback : UnityEvent<float>
		{
		}

		private FloatTweenCallback m_Target;

		private float m_StartValue;

		private float m_TargetValue;

		private float m_Duration;

		private bool m_IgnoreTimeScale;

		public float startValue
		{
			get
			{
				return m_StartValue;
			}
			set
			{
				m_StartValue = value;
			}
		}

		public float targetValue
		{
			get
			{
				return m_TargetValue;
			}
			set
			{
				m_TargetValue = value;
			}
		}

		public float duration
		{
			get
			{
				return m_Duration;
			}
			set
			{
				m_Duration = value;
			}
		}

		public bool ignoreTimeScale
		{
			get
			{
				return m_IgnoreTimeScale;
			}
			set
			{
				m_IgnoreTimeScale = value;
			}
		}

		public void TweenValue(float floatPercentage)
		{
			if (ValidTarget())
			{
				float num = Mathf.Lerp(m_StartValue, m_TargetValue, floatPercentage);
				((UnityEvent<float>)m_Target).Invoke(num);
			}
		}

		public void AddOnChangedCallback(UnityAction<float> callback)
		{
			if (m_Target == null)
			{
				m_Target = new FloatTweenCallback();
			}
			((UnityEvent<float>)m_Target).AddListener(callback);
		}

		public bool GetIgnoreTimescale()
		{
			return m_IgnoreTimeScale;
		}

		public float GetDuration()
		{
			return m_Duration;
		}

		public bool ValidTarget()
		{
			return m_Target != null;
		}
	}
	internal class TweenRunner<T> where T : struct, ITweenValue
	{
		protected MonoBehaviour m_CoroutineContainer;

		protected IEnumerator m_Tween;

		private static IEnumerator Start(T tweenInfo)
		{
			if (tweenInfo.ValidTarget())
			{
				float elapsedTime = 0f;
				while (elapsedTime < tweenInfo.duration)
				{
					elapsedTime += (tweenInfo.ignoreTimeScale ? Time.unscaledDeltaTime : Time.deltaTime);
					float floatPercentage = Mathf.Clamp01(elapsedTime / tweenInfo.duration);
					tweenInfo.TweenValue(floatPercentage);
					yield return null;
				}
				tweenInfo.TweenValue(1f);
			}
		}

		public void Init(MonoBehaviour coroutineContainer)
		{
			m_CoroutineContainer = coroutineContainer;
		}

		public void StartTween(T info)
		{
			if ((Object)(object)m_CoroutineContainer == (Object)null)
			{
				Debug.LogWarning((object)"Coroutine container not configured... did you forget to call Init?");
				return;
			}
			StopTween();
			if (!((Component)m_CoroutineContainer).gameObject.activeInHierarchy)
			{
				info.TweenValue(1f);
				return;
			}
			m_Tween = Start(info);
			m_CoroutineContainer.StartCoroutine(m_Tween);
		}

		public void StopTween()
		{
			if (m_Tween != null)
			{
				m_CoroutineContainer.StopCoroutine(m_Tween);
				m_Tween = null;
			}
		}
	}
}
namespace UnityEngine.UIElements
{
	[AddComponentMenu("UI Toolkit/Panel Event Handler (UI Toolkit)")]
	public class PanelEventHandler : UIBehaviour, IPointerMoveHandler, IEventSystemHandler, IPointerUpHandler, IPointerDownHandler, ISubmitHandler, ICancelHandler, IMoveHandler, IScrollHandler, ISelectHandler, IDeselectHandler, IPointerExitHandler, IPointerEnterHandler, IRuntimePanelComponent
	{
		private enum PointerEventType
		{
			Default,
			Down,
			Up
		}

		private class PointerEvent : IPointerEvent
		{
			public int pointerId { get; private set; }

			public string pointerType { get; private set; }

			public bool isPrimary { get; private set; }

			public int button { get; private set; }

			public int pressedButtons { get; private set; }

			public Vector3 position { get; private set; }

			public Vector3 localPosition { get; private set; }

			public Vector3 deltaPosition { get; private set; }

			public float deltaTime { get; private set; }

			public int clickCount { get; private set; }

			public float pressure { get; private set; }

			public float tangentialPressure { get; private set; }

			public float altitudeAngle { get; private set; }

			public float azimuthAngle { get; private set; }

			public float twist { get; private set; }

			public Vector2 radius { get; private set; }

			public Vector2 radiusVariance { get; private set; }

			public EventModifiers modifiers { get; private set; }

			public bool shiftKey => (modifiers & 1) > 0;

			public bool ctrlKey => (modifiers & 2) > 0;

			public bool commandKey => (modifiers & 8) > 0;

			public bool altKey => (modifiers & 4) > 0;

			public bool actionKey
			{
				get
				{
					//IL_0000: 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_000d: Invalid comparison between Unknown and I4
					if ((int)Application.platform != 0 && (int)Application.platform != 1)
					{
						return ctrlKey;
					}
					return commandKey;
				}
			}

			public void Read(PanelEventHandler self, PointerEventData eventData, PointerEventType eventType)
			{
				//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_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: 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)
				//IL_0122: 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_0124: 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_0133: 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_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: 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)
				pointerId = self.eventSystem.currentInputModule.ConvertUIToolkitPointerId(eventData);
				pointerType = (InRange(pointerId, PointerId.touchPointerIdBase, PointerId.touchPointerCount) ? PointerType.touch : (InRange(pointerId, PointerId.penPointerIdBase, PointerId.penPointerCount) ? PointerType.pen : PointerType.mouse));
				isPrimary = pointerId == PointerId.mousePointerId || pointerId == PointerId.touchPointerIdBase || pointerId == PointerId.penPointerIdBase;
				button = (int)eventData.button;
				clickCount = eventData.clickCount;
				int num = Screen.height;
				Vector3 val = Display.RelativeMouseAt(Vector2.op_Implicit(eventData.position));
				if (val != Vector3.zero)
				{
					int num2 = (int)val.z;
					if (num2 > 0 && num2 < Display.displays.Length)
					{
						num = Display.displays[num2].systemHeight;
					}
				}
				else
				{
					val = Vector2.op_Implicit(eventData.position);
				}
				Vector2 delta = eventData.delta;
				val.y = (float)num - val.y;
				delta.y = 0f - delta.y;
				Vector3 val2 = (position = val);
				localPosition = val2;
				deltaPosition = Vector2.op_Implicit(delta);
				deltaTime = 0f;
				pressure = eventData.pressure;
				tangentialPressure = eventData.tangentialPressure;
				altitudeAngle = eventData.altitudeAngle;
				azimuthAngle = eventData.azimuthAngle;
				twist = eventData.twist;
				radius = eventData.radius;
				radiusVariance = eventData.radiusVariance;
				modifiers = s_Modifiers;
				if (eventType == PointerEventType.Default)
				{
					button = -1;
					clickCount = 0;
				}
				else
				{
					button = ((button >= 0) ? button : 0);
					clickCount = Mathf.Max(1, clickCount);
					switch (eventType)
					{
					case PointerEventType.Down:
						PointerDeviceState.PressButton(pointerId, button);
						break;
					case PointerEventType.Up:
						PointerDeviceState.ReleaseButton(pointerId, button);
						break;
					}
				}
				pressedButtons = PointerDeviceState.GetPressedButtons(pointerId);
				static bool InRange(int i, int start, int count)
				{
					if (i >= start)
					{
						return i < start + count;
					}
					return false;
				}
			}

			public void SetPosition(Vector3 positionOverride, Vector3 deltaOverride)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0004: 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)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = (position = positionOverride);
				localPosition = val;
				deltaPosition = deltaOverride;
			}
		}

		private BaseRuntimePanel m_Panel;

		private readonly PointerEvent m_PointerEvent = new PointerEvent();

		private bool m_Selecting;

		private Event m_Event = new Event();

		private static EventModifiers s_Modifiers;

		public IPanel panel
		{
			get
			{
				return (IPanel)(object)m_Panel;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				BaseRuntimePanel val = (BaseRuntimePanel)value;
				if (m_Panel != val)
				{
					UnregisterCallbacks();
					m_Panel = val;
					RegisterCallbacks();
				}
			}
		}

		private GameObject selectableGameObject
		{
			get
			{
				BaseRuntimePanel obj = m_Panel;
				if (obj == null)
				{
					return null;
				}
				return obj.selectableGameObject;
			}
		}

		private EventSystem eventSystem => UIElementsRuntimeUtility.activeEventSystem as EventSystem;

		protected override void OnEnable()
		{
			base.OnEnable();
			RegisterCallbacks();
		}

		protected override void OnDisable()
		{
			base.OnDisable();
			UnregisterCallbacks();
		}

		private void RegisterCallbacks()
		{
			if (m_Panel != null)
			{
				m_Panel.destroyed += OnPanelDestroyed;
				((CallbackEventHandler)((BaseVisualElementPanel)m_Panel).visualTree).RegisterCallback<FocusEvent>((EventCallback<FocusEvent>)OnElementFocus, (TrickleDown)1);
				((CallbackEventHandler)((BaseVisualElementPanel)m_Panel).visualTree).RegisterCallback<BlurEvent>((EventCallback<BlurEvent>)OnElementBlur, (TrickleDown)1);
			}
		}

		private void UnregisterCallbacks()
		{
			if (m_Panel != null)
			{
				m_Panel.destroyed -= OnPanelDestroyed;
				((CallbackEventHandler)((BaseVisualElementPanel)m_Panel).visualTree).UnregisterCallback<FocusEvent>((EventCallback<FocusEvent>)OnElementFocus, (TrickleDown)1);
				((CallbackEventHandler)((BaseVisualElementPanel)m_Panel).visualTree).UnregisterCallback<BlurEvent>((EventCallback<BlurEvent>)OnElementBlur, (TrickleDown)1);
			}
		}

		private void OnPanelDestroyed()
		{
			panel = null;
		}

		private void OnElementFocus(FocusEvent e)
		{
			if (!m_Selecting && (Object)(object)eventSystem != (Object)null)
			{
				eventSystem.SetSelectedGameObject(selectableGameObject);
			}
		}

		private void OnElementBlur(BlurEvent e)
		{
		}

		public void OnSelect(BaseEventData eventData)
		{
			m_Selecting = true;
			try
			{
				BaseRuntimePanel obj = m_Panel;
				if (obj != null)
				{
					((Panel)obj).Focus();
				}
			}
			finally
			{
				m_Selecting = false;
			}
		}

		public void OnDeselect(BaseEventData eventData)
		{
			BaseRuntimePanel obj = m_Panel;
			if (obj != null)
			{
				((Panel)obj).Blur();
			}
		}

		public void OnPointerMove(PointerEventData eventData)
		{
			if (m_Panel == null || !ReadPointerData(m_PointerEvent, eventData))
			{
				return;
			}
			PointerMoveEvent pooled = PointerEventBase<PointerMoveEvent>.GetPooled((IPointerEvent)(object)m_PointerEvent);
			try
			{
				SendEvent((EventBase)(object)pooled, (BaseEventData)eventData);
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		public void OnPointerUp(PointerEventData eventData)
		{
			if (m_Panel == null || !ReadPointerData(m_PointerEvent, eventData, PointerEventType.Up))
			{
				return;
			}
			PointerUpEvent pooled = PointerEventBase<PointerUpEvent>.GetPooled((IPointerEvent)(object)m_PointerEvent);
			try
			{
				SendEvent((EventBase)(object)pooled, (BaseEventData)eventData);
				if (((PointerEventBase<PointerUpEvent>)(object)pooled).pressedButtons == 0)
				{
					PointerDeviceState.SetPlayerPanelWithSoftPointerCapture(((PointerEventBase<PointerUpEvent>)(object)pooled).pointerId, (IPanel)null);
				}
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		public void OnPointerDown(PointerEventData eventData)
		{
			if (m_Panel == null || !ReadPointerData(m_PointerEvent, eventData, PointerEventType.Down))
			{
				return;
			}
			if ((Object)(object)eventSystem != (Object)null)
			{
				eventSystem.SetSelectedGameObject(selectableGameObject);
			}
			PointerDownEvent pooled = PointerEventBase<PointerDownEvent>.GetPooled((IPointerEvent)(object)m_PointerEvent);
			try
			{
				SendEvent((EventBase)(object)pooled, (BaseEventData)eventData);
				PointerDeviceState.SetPlayerPanelWithSoftPointerCapture(((PointerEventBase<PointerDownEvent>)(object)pooled).pointerId, (IPanel)(object)m_Panel);
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (m_Panel == null || !ReadPointerData(m_PointerEvent, eventData))
			{
				return;
			}
			if ((Object)(object)eventData.pointerCurrentRaycast.gameObject == (Object)(object)((Component)this).gameObject && (Object)(object)eventData.pointerPressRaycast.gameObject != (Object)(object)((Component)this).gameObject && m_PointerEvent.pointerId != PointerId.mousePointerId)
			{
				PointerCancelEvent pooled = PointerEventBase<PointerCancelEvent>.GetPooled((IPointerEvent)(object)m_PointerEvent);
				try
				{
					SendEvent((EventBase)(object)pooled, (BaseEventData)eventData);
				}
				finally
				{
					((IDisposable)pooled)?.Dispose();
				}
			}
			m_Panel.PointerLeavesPanel(m_PointerEvent.pointerId, Vector2.op_Implicit(m_PointerEvent.position));
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			//IL_0030: 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)
			if (m_Panel != null && ReadPointerData(m_PointerEvent, eventData))
			{
				m_Panel.PointerEntersPanel(m_PointerEvent.pointerId, Vector2.op_Implicit(m_PointerEvent.position));
			}
		}

		public void OnSubmit(BaseEventData eventData)
		{
			if (m_Panel == null)
			{
				return;
			}
			ProcessImguiEvents(isSelected: true);
			NavigationSubmitEvent pooled = EventBase<NavigationSubmitEvent>.GetPooled();
			try
			{
				SendEvent((EventBase)(object)pooled, eventData);
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		public void OnCancel(BaseEventData eventData)
		{
			if (m_Panel == null)
			{
				return;
			}
			ProcessImguiEvents(isSelected: true);
			NavigationCancelEvent pooled = EventBase<NavigationCancelEvent>.GetPooled();
			try
			{
				SendEvent((EventBase)(object)pooled, eventData);
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		public void OnMove(AxisEventData eventData)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (m_Panel == null)
			{
				return;
			}
			ProcessImguiEvents(isSelected: true);
			NavigationMoveEvent pooled = NavigationMoveEvent.GetPooled(eventData.moveVector);
			try
			{
				SendEvent((EventBase)(object)pooled, (BaseEventData)eventData);
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		public void OnScroll(PointerEventData eventData)
		{
			//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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			if (m_Panel == null || !ReadPointerData(m_PointerEvent, eventData))
			{
				return;
			}
			Vector2 scrollDelta = eventData.scrollDelta;
			scrollDelta.y = 0f - scrollDelta.y;
			scrollDelta /= 20f;
			WheelEvent pooled = WheelEvent.GetPooled(Vector2.op_Implicit(scrollDelta), (IPointerEvent)(object)m_PointerEvent);
			try
			{
				SendEvent((EventBase)(object)pooled, (BaseEventData)eventData);
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		private void SendEvent(EventBase e, BaseEventData sourceEventData)
		{
			((BaseVisualElementPanel)m_Panel).SendEvent(e, (DispatchMode)1);
			if (e.isPropagationStopped)
			{
				sourceEventData.Use();
			}
		}

		private void SendEvent(EventBase e, Event sourceEvent)
		{
			((BaseVisualElementPanel)m_Panel).SendEvent(e, (DispatchMode)1);
			if (e.isPropagationStopped)
			{
				sourceEvent.Use();
			}
		}

		private void Update()
		{
			if (m_Panel != null && (Object)(object)eventSystem != (Object)null && (Object)(object)eventSystem.currentSelectedGameObject == (Object)(object)selectableGameObject)
			{
				ProcessImguiEvents(isSelected: true);
			}
		}

		private void LateUpdate()
		{
			ProcessImguiEvents(isSelected: false);
		}

		private void ProcessImguiEvents(bool isSelected)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_0073: Invalid comparison between Unknown and I4
			bool flag = true;
			while (Event.PopEvent(m_Event))
			{
				if ((int)m_Event.type == 11 || (int)m_Event.type == 7 || (int)m_Event.type == 8)
				{
					continue;
				}
				s_Modifiers = (EventModifiers)(flag ? m_Event.modifiers : (s_Modifiers | m_Event.modifiers));
				flag = false;
				if (isSelected)
				{
					ProcessKeyboardEvent(m_Event);
					if ((int)m_Event.type != 12)
					{
						ProcessTabEvent(m_Event);
					}
				}
			}
		}

		private void ProcessKeyboardEvent(Event e)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			if ((int)e.type == 5)
			{
				SendKeyUpEvent(e);
			}
			else if ((int)e.type == 4)
			{
				SendKeyDownEvent(e);
			}
		}

		private void ProcessTabEvent(Event e)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)e.type == 4 && e.character == '\t')
			{
				SendTabEvent(e, (!e.shift) ? 1 : (-1));
			}
		}

		private void SendTabEvent(Event e, int direction)
		{
			NavigationTabEvent pooled = NavigationTabEvent.GetPooled(direction);
			try
			{
				SendEvent((EventBase)(object)pooled, e);
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		private void SendKeyUpEvent(Event e)
		{
			//IL_0002: 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)
			KeyUpEvent pooled = KeyboardEventBase<KeyUpEvent>.GetPooled('\0', e.keyCode, e.modifiers);
			try
			{
				SendEvent((EventBase)(object)pooled, e);
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		private void SendKeyDownEvent(Event e)
		{
			//IL_0007: 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)
			KeyDownEvent pooled = KeyboardEventBase<KeyDownEvent>.GetPooled(e.character, e.keyCode, e.modifiers);
			try
			{
				SendEvent((EventBase)(object)pooled, e);
			}
			finally
			{
				((IDisposable)pooled)?.Dispose();
			}
		}

		private bool ReadPointerData(PointerEvent pe, PointerEventData eventData, PointerEventType eventType = PointerEventType.Default)
		{
			//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_003e: 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_0054: 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_005a: 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)
			if ((Object)(object)eventSystem == (Object)null || (Object)(object)eventSystem.currentInputModule == (Object)null)
			{
				return false;
			}
			pe.Read(this, eventData, eventType);
			Vector2 val = default(Vector2);
			Vector2 val2 = default(Vector2);
			m_Panel.ScreenToPanel(Vector2.op_Implicit(pe.position), Vector2.op_Implicit(pe.deltaPosition), ref val, ref val2, true);
			pe.SetPosition(Vector2.op_Implicit(val), Vector2.op_Implicit(val2));
			return true;
		}
	}
	[AddComponentMenu("UI Toolkit/Panel Raycaster (UI Toolkit)")]
	public class PanelRaycaster : BaseRaycaster, IRuntimePanelComponent
	{
		[StructLayout(LayoutKind.Explicit, Size = 4)]
		private struct FloatIntBits
		{
			[FieldOffset(0)]
			public float f;

			[FieldOffset(0)]
			public int i;
		}

		private BaseRuntimePanel m_Panel;

		public IPanel panel
		{
			get
			{
				return (IPanel)(object)m_Panel;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				BaseRuntimePanel val = (BaseRuntimePanel)value;
				if (m_Panel != val)
				{
					UnregisterCallbacks();
					m_Panel = val;
					RegisterCallbacks();
				}
			}
		}

		private GameObject selectableGameObject
		{
			get
			{
				BaseRuntimePanel obj = m_Panel;
				if (obj == null)
				{
					return null;
				}
				return obj.selectableGameObject;
			}
		}

		public override int sortOrderPriority
		{
			get
			{
				BaseRuntimePanel obj = m_Panel;
				return (int)((obj != null) ? obj.sortingPriority : 0f);
			}
		}

		public override int renderOrderPriority
		{
			get
			{
				BaseRuntimePanel obj = m_Panel;
				return ConvertFloatBitsToInt((obj != null) ? obj.sortingPriority : 0f);
			}
		}

		public override Camera eventCamera => null;

		private void RegisterCallbacks()
		{
			if (m_Panel != null)
			{
				m_Panel.destroyed += OnPanelDestroyed;
			}
		}

		private void UnregisterCallbacks()
		{
			if (m_Panel != null)
			{
				m_Panel.destroyed -= OnPanelDestroyed;
			}
		}

		private void OnPanelDestroyed()
		{
			panel = null;
		}

		public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_0027: 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)
			//IL_0049: 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_004a: 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_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_007c: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			if (m_Panel == null)
			{
				return;
			}
			Vector3 val = Display.RelativeMouseAt(Vector2.op_Implicit(eventData.position));
			int targetDisplay = m_Panel.targetDisplay;
			if (val != Vector3.zero)
			{
				if ((int)val.z != targetDisplay)
				{
					return;
				}
			}
			else
			{
				val = Vector2.op_Implicit(eventData.position);
			}
			Vector3 val2 = val;
			Vector2 delta = eventData.delta;
			float num = Screen.height;
			if (targetDisplay > 0 && targetDisplay < Display.displays.Length)
			{
				num = Display.displays[targetDisplay].systemHeight;
			}
			val2.y = num - val2.y;
			delta.y = 0f - delta.y;
			EventSystem eventSystem = UIElementsRuntimeUtility.activeEventSystem as EventSystem;
			if ((Object)(object)eventSystem == (Object)null || (Object)(object)eventSystem.currentInputModule == (Object)null)
			{
				return;
			}
			int num2 = eventSystem.currentInputModule.ConvertUIToolkitPointerId(eventData);
			IEventHandler capturingElement = PointerCaptureHelper.GetCapturingElement((IPanel)(object)m_Panel, num2);
			VisualElement val3 = (VisualElement)(object)((capturingElement is VisualElement) ? capturingElement : null);
			if (val3 == null || (object)val3.panel == m_Panel)
			{
				IPanel val4 = ((PointerDeviceState.GetPressedButtons(num2) != 0) ? PointerDeviceState.GetPlayerPanelWithSoftPointerCapture(num2) : null);
				Vector2 val5 = default(Vector2);
				Vector2 val6 = default(Vector2);
				if ((val4 == null || (object)val4 == m_Panel) && (capturingElement != null || val4 != null || (m_Panel.ScreenToPanel(Vector2.op_Implicit(val2), delta, ref val5, ref val6, false) && ((BaseVisualElementPanel)m_Panel).Pick(val5) != null)))
				{
					resultAppendList.Add(new RaycastResult
					{
						gameObject = selectableGameObject,
						module = this,
						screenPosition = Vector2.op_Implicit(val),
						displayIndex = m_Panel.targetDisplay
					});
				}
			}
		}

		private static int ConvertFloatBitsToInt(float f)
		{
			FloatIntBits floatIntBits = new FloatIntBits
			{
				f = f
			};
			return floatIntBits.i;
		}
	}
}
namespace UnityEngine.EventSystems
{
	public class AxisEventData : BaseEventData
	{
		public Vector2 moveVector { get; set; }

		public MoveDirection moveDir { get; set; }

		public AxisEventData(EventSystem eventSystem)
			: base(eventSystem)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			moveVector = Vector2.zero;
			moveDir = MoveDirection.None;
		}
	}
	public abstract class AbstractEventData
	{
		protected bool m_Used;

		public virtual bool used => m_Used;

		public virtual void Reset()
		{
			m_Used = false;
		}

		public virtual void Use()
		{
			m_Used = true;
		}
	}
	public class BaseEventData : AbstractEventData
	{
		private readonly EventSystem m_EventSystem;

		public BaseInputModule currentInputModule => m_EventSystem.currentInputModule;

		public GameObject selectedObject
		{
			get
			{
				return m_EventSystem.currentSelectedGameObject;
			}
			set
			{
				m_EventSystem.SetSelectedGameObject(value, this);
			}
		}

		public BaseEventData(EventSystem eventSystem)
		{
			m_EventSystem = eventSystem;
		}
	}
	public class PointerEventData : BaseEventData
	{
		public enum InputButton
		{
			Left,
			Right,
			Middle
		}

		public enum FramePressState
		{
			Pressed,
			Released,
			PressedAndReleased,
			NotChanged
		}

		private GameObject m_PointerPress;

		public List<GameObject> hovered = new List<GameObject>();

		public GameObject pointerEnter { get; set; }

		public GameObject lastPress { get; private set; }

		public GameObject rawPointerPress { get; set; }

		public GameObject pointerDrag { get; set; }

		public GameObject pointerClick { get; set; }

		public RaycastResult pointerCurrentRaycast { get; set; }

		public RaycastResult pointerPressRaycast { get; set; }

		public bool eligibleForClick { get; set; }

		public int pointerId { get; set; }

		public Vector2 position { get; set; }

		public Vector2 delta { get; set; }

		public Vector2 pressPosition { get; set; }

		[Obsolete("Use either pointerCurrentRaycast.worldPosition or pointerPressRaycast.worldPosition")]
		public Vector3 worldPosition { get; set; }

		[Obsolete("Use either pointerCurrentRaycast.worldNormal or pointerPressRaycast.worldNormal")]
		public Vector3 worldNormal { get; set; }

		public float clickTime { get; set; }

		public int clickCount { get; set; }

		public Vector2 scrollDelta { get; set; }

		public bool useDragThreshold { get; set; }

		public bool dragging { get; set; }

		public InputButton button { get; set; }

		public float pressure { get; set; }

		public float tangentialPressure { get; set; }

		public float altitudeAngle { get; set; }

		public float azimuthAngle { get; set; }

		public float twist { get; set; }

		public Vector2 radius { get; set; }

		public Vector2 radiusVariance { get; set; }

		public bool fullyExited { get; set; }

		public bool reentered { get; set; }

		public Camera enterEventCamera
		{
			get
			{
				if (!((Object)(object)pointerCurrentRaycast.module == (Object)null))
				{
					return pointerCurrentRaycast.module.eventCamera;
				}
				return null;
			}
		}

		public Camera pressEventCamera
		{
			get
			{
				if (!((Object)(object)pointerPressRaycast.module == (Object)null))
				{
					return pointerPressRaycast.module.eventCamera;
				}
				return null;
			}
		}

		public GameObject pointerPress
		{
			get
			{
				return m_PointerPress;
			}
			set
			{
				if (!((Object)(object)m_PointerPress == (Object)(object)value))
				{
					lastPress = m_PointerPress;
					m_PointerPress = value;
				}
			}
		}

		public PointerEventData(EventSystem eventSystem)
			: base(eventSystem)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			eligibleForClick = false;
			pointerId = -1;
			position = Vector2.zero;
			delta = Vector2.zero;
			pressPosition = Vector2.zero;
			clickTime = 0f;
			clickCount = 0;
			scrollDelta = Vector2.zero;
			useDragThreshold = true;
			dragging = false;
			button = InputButton.Left;
			pressure = 0f;
			tangentialPressure = 0f;
			altitudeAngle = 0f;
			azimuthAngle = 0f;
			twist = 0f;
			radius = Vector2.zero;
			radiusVariance = Vector2.zero;
		}

		public bool IsPointerMoving()
		{
			//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)
			Vector2 val = delta;
			return ((Vector2)(ref val)).sqrMagnitude > 0f;
		}

		public bool IsScrolling()
		{
			//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)
			Vector2 val = scrollDelta;
			return ((Vector2)(ref val)).sqrMagnitude > 0f;
		}

		public override string ToString()
		{
			//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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("<b>Position</b>: " + ((object)position/*cast due to .constrained prefix*/).ToString());
			stringBuilder.AppendLine("<b>delta</b>: " + ((object)delta/*cast due to .constrained prefix*/).ToString());
			stringBuilder.AppendLine("<b>eligibleForClick</b>: " + eligibleForClick);
			stringBuilder.AppendLine("<b>pointerEnter</b>: " + (object)pointerEnter);
			stringBuilder.AppendLine("<b>pointerPress</b>: " + (object)pointerPress);
			stringBuilder.AppendLine("<b>lastPointerPress</b>: " + (object)lastPress);
			stringBuilder.AppendLine("<b>pointerDrag</b>: " + (object)pointerDrag);
			stringBuilder.AppendLine("<b>Use Drag Threshold</b>: " + useDragThreshold);
			stringBuilder.AppendLine("<b>Current Raycast:</b>");
			stringBuilder.AppendLine(pointerCurrentRaycast.ToString());
			stringBuilder.AppendLine("<b>Press Raycast:</b>");
			stringBuilder.AppendLine(pointerPressRaycast.ToString());
			stringBuilder.AppendLine("<b>pressure</b>: " + pressure);
			stringBuilder.AppendLine("<b>tangentialPressure</b>: " + tangentialPressure);
			stringBuilder.AppendLine("<b>altitudeAngle</b>: " + altitudeAngle);
			stringBuilder.AppendLine("<b>azimuthAngle</b>: " + azimuthAngle);
			stringBuilder.AppendLine("<b>twist</b>: " + twist);
			stringBuilder.AppendLine("<b>radius</b>: " + ((object)radius/*cast due to .constrained prefix*/).ToString());
			stringBuilder.AppendLine("<b>radiusVariance</b>: " + ((object)radiusVariance/*cast due to .constrained prefix*/).ToString());
			return stringBuilder.ToString();
		}
	}
	[Flags]
	public enum EventHandle
	{
		Unused = 0,
		Used = 1
	}
	public interface IEventSystemHandler
	{
	}
	public interface IPointerMoveHandler : IEventSystemHandler
	{
		void OnPointerMove(PointerEventData eventData);
	}
	public interface IPointerEnterHandler : IEventSystemHandler
	{
		void OnPointerEnter(PointerEventData eventData);
	}
	public interface IPointerExitHandler : IEventSystemHandler
	{
		void OnPointerExit(PointerEventData eventData);
	}
	public interface IPointerDownHandler : IEventSystemHandler
	{
		void OnPointerDown(PointerEventData eventData);
	}
	public interface IPointerUpHandler : IEventSystemHandler
	{
		void OnPointerUp(PointerEventData eventData);
	}
	public interface IPointerClickHandler : IEventSystemHandler
	{
		void OnPointerClick(PointerEventData eventData);
	}
	public interface IBeginDragHandler : IEventSystemHandler
	{
		void OnBeginDrag(PointerEventData eventData);
	}
	public interface IInitializePotentialDragHandler : IEventSystemHandler
	{
		void OnInitializePotentialDrag(PointerEventData eventData);
	}
	public interface IDragHandler : IEventSystemHandler
	{
		void OnDrag(PointerEventData eventData);
	}
	public interface IEndDragHandler : IEventSystemHandler
	{
		void OnEndDrag(PointerEventData eventData);
	}
	public interface IDropHandler : IEventSystemHandler
	{
		void OnDrop(PointerEventData eventData);
	}
	public interface IScrollHandler : IEventSystemHandler
	{
		void OnScroll(PointerEventData eventData);
	}
	public interface IUpdateSelectedHandler : IEventSystemHandler
	{
		void OnUpdateSelected(BaseEventData eventData);
	}
	public interface ISelectHandler : IEventSystemHandler
	{
		void OnSelect(BaseEventData eventData);
	}
	public interface IDeselectHandler : IEventSystemHandler
	{
		void OnDeselect(BaseEventData eventData);
	}
	public interface IMoveHandler : IEventSystemHandler
	{
		void OnMove(AxisEventData eventData);
	}
	public interface ISubmitHandler : IEventSystemHandler
	{
		void OnSubmit(BaseEventData eventData);
	}
	public interface ICancelHandler : IEventSystemHandler
	{
		void OnCancel(BaseEventData eventData);
	}
	[AddComponentMenu("Event/Event System")]
	[DisallowMultipleComponent]
	public class EventSystem : UIBehaviour
	{
		private struct UIToolkitOverrideConfig
		{
			public EventSystem activeEventSystem;

			public bool sendEvents;

			public bool createPanelGameObjectsOnStart;
		}

		private List<BaseInputModule> m_SystemInputModules = new List<BaseInputModule>();

		private BaseInputModule m_CurrentInputModule;

		private static List<EventSystem> m_EventSystems = new List<EventSystem>();

		[SerializeField]
		[FormerlySerializedAs("m_Selected")]
		private GameObject m_FirstSelected;

		[SerializeField]
		private bool m_sendNavigationEvents = true;

		[SerializeField]
		private int m_DragThreshold = 10;

		private GameObject m_CurrentSelected;

		private bool m_HasFocus = true;

		private bool m_SelectionGuard;

		private BaseEventData m_DummyData;

		private static readonly Comparison<RaycastResult> s_RaycastComparer = RaycastComparer;

		private static UIToolkitOverrideConfig s_UIToolkitOverride = new UIToolkitOverrideConfig
		{
			activeEventSystem = null,
			sendEvents = true,
			createPanelGameObjectsOnStart = true
		};

		public static EventSystem current
		{
			get
			{
				if (m_EventSystems.Count <= 0)
				{
					return null;
				}
				return m_EventSystems[0];
			}
			set
			{
				int num = m_EventSystems.IndexOf(value);
				if (num > 0)
				{
					m_EventSystems.RemoveAt(num);
					m_EventSystems.Insert(0, value);
				}
				else if (num < 0)
				{
					Debug.LogError((object)("Failed setting EventSystem.current to unknown EventSystem " + (object)value));
				}
			}
		}

		public bool sendNavigationEvents
		{
			get
			{
				return m_sendNavigationEvents;
			}
			set
			{
				m_sendNavigationEvents = value;
			}
		}

		public int pixelDragThreshold
		{
			get
			{
				return m_DragThreshold;
			}
			set
			{
				m_DragThreshold = value;
			}
		}

		public BaseInputModule currentInputModule => m_CurrentInputModule;

		public GameObject firstSelectedGameObject
		{
			get
			{
				return m_FirstSelected;
			}
			set
			{
				m_FirstSelected = value;
			}
		}

		public GameObject currentSelectedGameObject => m_CurrentSelected;

		[Obsolete("lastSelectedGameObject is no longer supported")]
		public GameObject lastSelectedGameObject => null;

		public bool isFocused => m_HasFocus;

		public bool alreadySelecting => m_SelectionGuard;

		private BaseEventData baseEventDataCache
		{
			get
			{
				if (m_DummyData == null)
				{
					m_DummyData = new BaseEventData(this);
				}
				return m_DummyData;
			}
		}

		private bool isUIToolkitActiveEventSystem
		{
			get
			{
				if (!((Object)(object)s_UIToolkitOverride.activeEventSystem == (Object)(object)this))
				{
					return (Object)(object)s_UIToolkitOverride.activeEventSystem == (Object)null;
				}
				return true;
			}
		}

		private bool sendUIToolkitEvents
		{
			get
			{
				if (s_UIToolkitOverride.sendEvents)
				{
					return isUIToolkitActiveEventSystem;
				}
				return false;
			}
		}

		private bool createUIToolkitPanelGameObjectsOnStart
		{
			get
			{
				if (s_UIToolkitOverride.createPanelGameObjectsOnStart)
				{
					return isUIToolkitActiveEventSystem;
				}
				return false;
			}
		}

		protected EventSystem()
		{
		}

		public void UpdateModules()
		{
			((Component)this).GetComponents<BaseInputModule>(m_SystemInputModules);
			for (int num = m_SystemInputModules.Count - 1; num >= 0; num--)
			{
				if (!Object.op_Implicit((Object)(object)m_SystemInputModules[num]) || !m_SystemInputModules[num].IsActive())
				{
					m_SystemInputModules.RemoveAt(num);
				}
			}
		}

		public void SetSelectedGameObject(GameObject selected, BaseEventData pointer)
		{
			if (m_SelectionGuard)
			{
				Debug.LogError((object)("Attempting to select " + ((object)selected)?.ToString() + "while already selecting an object."));
				return;
			}
			m_SelectionGuard = true;
			if ((Object)(object)selected == (Object)(object)m_CurrentSelected)
			{
				m_SelectionGuard = false;
				return;
			}
			ExecuteEvents.Execute(m_CurrentSelected, pointer, ExecuteEvents.deselectHandler);
			m_CurrentSelected = selected;
			ExecuteEvents.Execute(m_CurrentSelected, pointer, ExecuteEvents.selectHandler);
			m_SelectionGuard = false;
		}

		public void SetSelectedGameObject(GameObject selected)
		{
			SetSelectedGameObject(selected, baseEventDataCache);
		}

		private static int RaycastComparer(RaycastResult lhs, RaycastResult rhs)
		{
			if ((Object)(object)lhs.module != (Object)(object)rhs.module)
			{
				Camera eventCamera = lhs.module.eventCamera;
				Camera eventCamera2 = rhs.module.eventCamera;
				if ((Object)(object)eventCamera != (Object)null && (Object)(object)eventCamera2 != (Object)null && eventCamera.depth != eventCamera2.depth)
				{
					if (eventCamera.depth < eventCamera2.depth)
					{
						return 1;
					}
					if (eventCamera.depth == eventCamera2.depth)
					{
						return 0;
					}
					return -1;
				}
				if (lhs.module.sortOrderPriority != rhs.module.sortOrderPriority)
				{
					return rhs.module.sortOrderPriority.CompareTo(lhs.module.sortOrderPriority);
				}
				if (lhs.module.renderOrderPriority != rhs.module.renderOrderPriority)
				{
					return rhs.module.renderOrderPriority.CompareTo(lhs.module.renderOrderPriority);
				}
			}
			if (lhs.sortingLayer != rhs.sortingLayer)
			{
				int layerValueFromID = SortingLayer.GetLayerValueFromID(rhs.sortingLayer);
				int layerValueFromID2 = SortingLayer.GetLayerValueFromID(lhs.sortingLayer);
				return layerValueFromID.CompareTo(layerValueFromID2);
			}
			if (lhs.sortingOrder != rhs.sortingOrder)
			{
				return rhs.sortingOrder.CompareTo(lhs.sortingOrder);
			}
			if (lhs.depth != rhs.depth && (Object)(object)lhs.module.rootRaycaster == (Object)(object)rhs.module.rootRaycaster)
			{
				return rhs.depth.CompareTo(lhs.depth);
			}
			if (lhs.distance != rhs.distance)
			{
				return lhs.distance.CompareTo(rhs.distance);
			}
			if (lhs.sortingGroupID != SortingGroup.invalidSortingGroupID && rhs.sortingGroupID != SortingGroup.invalidSortingGroupID)
			{
				if (lhs.sortingGroupID != rhs.sortingGroupID)
				{
					return lhs.sortingGroupID.CompareTo(rhs.sortingGroupID);
				}
				if (lhs.sortingGroupOrder != rhs.sortingGroupOrder)
				{
					return rhs.sortingGroupOrder.CompareTo(lhs.sortingGroupOrder);
				}
			}
			return lhs.index.CompareTo(rhs.index);
		}

		public void RaycastAll(PointerEventData eventData, List<RaycastResult> raycastResults)
		{
			raycastResults.Clear();
			List<BaseRaycaster> raycasters = RaycasterManager.GetRaycasters();
			int count = raycasters.Count;
			for (int i = 0; i < count; i++)
			{
				BaseRaycaster baseRaycaster = raycasters[i];
				if (!((Object)(object)baseRaycaster == (Object)null) && baseRaycaster.IsActive())
				{
					baseRaycaster.Raycast(eventData, raycastResults);
				}
			}
			raycastResults.Sort(s_RaycastComparer);
		}

		public bool IsPointerOverGameObject()
		{
			return IsPointerOverGameObject(-1);
		}

		public bool IsPointerOverGameObject(int pointerId)
		{
			if ((Object)(object)m_CurrentInputModule != (Object)null)
			{
				return m_CurrentInputModule.IsPointerOverGameObject(pointerId);
			}
			return false;
		}

		public static void SetUITookitEventSystemOverride(EventSystem activeEventSystem, bool sendEvents = true, bool createPanelGameObjectsOnStart = true)
		{
			UIElementsRuntimeUtility.UnregisterEventSystem(UIElementsRuntimeUtility.activeEventSystem);
			s_UIToolkitOverride = new UIToolkitOverrideConfig
			{
				activeEventSystem = activeEventSystem,
				sendEvents = sendEvents,
				createPanelGameObjectsOnStart = createPanelGameObjectsOnStart
			};
			if (sendEvents && ((Behaviour)(((Object)(object)activeEventSystem != (Object)null) ? activeEventSystem : current)).isActiveAndEnabled)
			{
				UIElementsRuntimeUtility.RegisterEventSystem((Object)(object)activeEventSystem);
			}
		}

		private void CreateUIToolkitPanelGameObject(BaseRuntimePanel panel)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			if ((Object)(object)panel.selectableGameObject == (Object)null)
			{
				GameObject go = new GameObject(((Panel)panel).name, new Type[2]
				{
					typeof(PanelEventHandler),
					typeof(PanelRaycaster)
				});
				go.transform.SetParent(((Component)this).transform);
				panel.selectableGameObject = go;
				panel.destroyed += delegate
				{
					Object.DestroyImmediate((Object)(object)go);
				};
			}
		}

		protected override void Start()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			base.Start();
			if (!createUIToolkitPanelGameObjectsOnStart)
			{
				return;
			}
			foreach (BaseRuntimePanel sortedPlayerPanel in UIElementsRuntimeUtility.GetSortedPlayerPanels())
			{
				BaseRuntimePanel panel = sortedPlayerPanel;
				CreateUIToolkitPanelGameObject(panel);
			}
			UIElementsRuntimeUtility.onCreatePanel += CreateUIToolkitPanelGameObject;
		}

		protected override void OnDestroy()
		{
			UIElementsRuntimeUtility.onCreatePanel -= CreateUIToolkitPanelGameObject;
			base.OnDestroy();
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			m_EventSystems.Add(this);
			if (sendUIToolkitEvents)
			{
				UIElementsRuntimeUtility.RegisterEventSystem((Object)(object)this);
			}
		}

		protected override void OnDisable()
		{
			UIElementsRuntimeUtility.UnregisterEventSystem((Object)(object)this);
			if ((Object)(object)m_CurrentInputModule != (Object)null)
			{
				m_CurrentInputModule.DeactivateModule();
				m_CurrentInputModule = null;
			}
			m_EventSystems.Remove(this);
			base.OnDisable();
		}

		private void TickModules()
		{
			int count = m_SystemInputModules.Count;
			for (int i = 0; i < count; i++)
			{
				if ((Object)(object)m_SystemInputModules[i] != (Object)null)
				{
					m_SystemInputModules[i].UpdateModule();
				}
			}
		}

		protected virtual void OnApplicationFocus(bool hasFocus)
		{
			m_HasFocus = hasFocus;
			if (!m_HasFocus)
			{
				TickModules();
			}
		}

		protected virtual void Update()
		{
			if ((Object)(object)current != (Object)(object)this)
			{
				return;
			}
			TickModules();
			bool flag = false;
			int count = m_SystemInputModules.Count;
			for (int i = 0; i < count; i++)
			{
				BaseInputModule baseInputModule = m_SystemInputModules[i];
				if (baseInputModule.IsModuleSupported() && baseInputModule.ShouldActivateModule())
				{
					if ((Object)(object)m_CurrentInputModule != (Object)(object)baseInputModule)
					{
						ChangeEventModule(baseInputModule);
						flag = true;
					}
					break;
				}
			}
			if ((Object)(object)m_CurrentInputModule == (Object)null)
			{
				for (int j = 0; j < count; j++)
				{
					BaseInputModule baseInputModule2 = m_SystemInputModules[j];
					if (baseInputModule2.IsModuleSupported())
					{
						ChangeEventModule(baseInputModule2);
						flag = true;
						break;
					}
				}
			}
			if (!flag && (Object)(object)m_CurrentInputModule != (Object)null)
			{
				m_CurrentInputModule.Process();
			}
		}

		private void ChangeEventModule(BaseInputModule module)
		{
			if (!((Object)(object)m_CurrentInputModule == (Object)(object)module))
			{
				if ((Object)(object)m_CurrentInputModule != (Object)null)
				{
					m_CurrentInputModule.DeactivateModule();
				}
				if ((Object)(object)module != (Object)null)
				{
					module.ActivateModule();
				}
				m_CurrentInputModule = module;
			}
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("<b>Selected:</b>" + (object)currentSelectedGameObject);
			stringBuilder.AppendLine();
			stringBuilder.AppendLine();
			stringBuilder.AppendLine(((Object)(object)m_CurrentInputModule != (Object)null) ? ((object)m_CurrentInputModule).ToString() : "No module");
			return stringBuilder.ToString();
		}
	}
	[AddComponentMenu("Event/Event Trigger")]
	public class EventTrigger : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, IPointerDownHandler, IPointerUpHandler, IPointerClickHandler, IInitializePotentialDragHandler, IBeginDragHandler, IDragHandler, IEndDragHandler, IDropHandler, IScrollHandler, IUpdateSelectedHandler, ISelectHandler, IDeselectHandler, IMoveHandler, ISubmitHandler, ICancelHandler
	{
		[Serializable]
		public class TriggerEvent : UnityEvent<BaseEventData>
		{
		}

		[Serializable]
		public class Entry
		{
			public EventTriggerType eventID = EventTriggerType.PointerClick;

			public TriggerEvent callback = new TriggerEvent();
		}

		[FormerlySerializedAs("delegates")]
		[SerializeField]
		private List<Entry> m_Delegates;

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Please use triggers instead (UnityUpgradable) -> triggers", true)]
		public List<Entry> delegates
		{
			get
			{
				return triggers;
			}
			set
			{
				triggers = value;
			}
		}

		public List<Entry> triggers
		{
			get
			{
				if (m_Delegates == null)
				{
					m_Delegates = new List<Entry>();
				}
				return m_Delegates;
			}
			set
			{
				m_Delegates = value;
			}
		}

		protected EventTrigger()
		{
		}

		private void Execute(EventTriggerType id, BaseEventData eventData)
		{
			_ = triggers.Count;
			int i = 0;
			for (int count = triggers.Count; i < count; i++)
			{
				Entry entry = triggers[i];
				if (entry.eventID == id && entry.callback != null)
				{
					((UnityEvent<BaseEventData>)entry.callback).Invoke(eventData);
				}
			}
		}

		public virtual void OnPointerEnter(PointerEventData eventData)
		{
			Execute(EventTriggerType.PointerEnter, eventData);
		}

		public virtual void OnPointerExit(PointerEventData eventData)
		{
			Execute(EventTriggerType.PointerExit, eventData);
		}

		public virtual void OnDrag(PointerEventData eventData)
		{
			Execute(EventTriggerType.Drag, eventData);
		}

		public virtual void OnDrop(PointerEventData eventData)
		{
			Execute(EventTriggerType.Drop, eventData);
		}

		public virtual void OnPointerDown(PointerEventData eventData)
		{
			Execute(EventTriggerType.PointerDown, eventData);
		}

		public virtual void OnPointerUp(PointerEventData eventData)
		{
			Execute(EventTriggerType.PointerUp, eventData);
		}

		public virtual void OnPointerClick(PointerEventData eventData)
		{
			Execute(EventTriggerType.PointerClick, eventData);
		}

		public virtual void OnSelect(BaseEventData eventData)
		{
			Execute(EventTriggerType.Select, eventData);
		}

		public virtual void OnDeselect(BaseEventData eventData)
		{
			Execute(EventTriggerType.Deselect, eventData);
		}

		public virtual void OnScroll(PointerEventData eventData)
		{
			Execute(EventTriggerType.Scroll, eventData);
		}

		public virtual void OnMove(AxisEventData eventData)
		{
			Execute(EventTriggerType.Move, eventData);
		}

		public virtual void OnUpdateSelected(BaseEventData eventData)
		{
			Execute(EventTriggerType.UpdateSelected, eventData);
		}

		public virtual void OnInitializePotentialDrag(PointerEventData eventData)
		{
			Execute(EventTriggerType.InitializePotentialDrag, eventData);
		}

		public virtual void OnBeginDrag(PointerEventData eventData)
		{
			Execute(EventTriggerType.BeginDrag, eventData);
		}

		public virtual void OnEndDrag(PointerEventData eventData)
		{
			Execute(EventTriggerType.EndDrag, eventData);
		}

		public virtual void OnSubmit(BaseEventData eventData)
		{
			Execute(EventTriggerType.Submit, eventData);
		}

		public virtual void OnCancel(BaseEventData eventData)
		{
			Execute(EventTriggerType.Cancel, eventData);
		}
	}
	public enum EventTriggerType
	{
		PointerEnter,
		PointerExit,
		PointerDown,
		PointerUp,
		PointerClick,
		Drag,
		Drop,
		Scroll,
		UpdateSelected,
		Select,
		Deselect,
		Move,
		InitializePotentialDrag,
		BeginDrag,
		EndDrag,
		Submit,
		Cancel
	}
	public static class ExecuteEvents
	{
		public delegate void EventFunction<T1>(T1 handler, BaseEventData eventData);

		private static readonly EventFunction<IPointerMoveHandler> s_PointerMoveHandler = Execute;

		private static readonly EventFunction<IPointerEnterHandler> s_PointerEnterHandler = Execute;

		private static readonly EventFunction<IPointerExitHandler> s_PointerExitHandler = Execute;

		private static readonly EventFunction<IPointerDownHandler> s_PointerDownHandler = Execute;

		private static readonly EventFunction<IPointerUpHandler> s_PointerUpHandler = Execute;

		private static readonly EventFunction<IPointerClickHandler> s_PointerClickHandler = Execute;

		private static readonly EventFunction<IInitializePotentialDragHandler> s_InitializePotentialDragHandler = Execute;

		private static readonly EventFunction<IBeginDragHandler> s_BeginDragHandler = Execute;

		private static readonly EventFunction<IDragHandler> s_DragHandler = Execute;

		private static readonly EventFunction<IEndDragHandler> s_EndDragHandler = Execute;

		private static readonly EventFunction<IDropHandler> s_DropHandler = Execute;

		private static readonly EventFunction<IScrollHandler> s_ScrollHandler = Execute;

		private static readonly EventFunction<IUpdateSelectedHandler> s_UpdateSelectedHandler = Execute;

		private static readonly EventFunction<ISelectHandler> s_SelectHandler = Execute;

		private static readonly EventFunction<IDeselectHandler> s_DeselectHandler = Execute;

		private static readonly EventFunction<IMoveHandler> s_MoveHandler = Execute;

		private static readonly EventFunction<ISubmitHandler> s_SubmitHandler = Execute;

		private static readonly EventFunction<ICancelHandler> s_CancelHandler = Execute;

		private static readonly List<Transform> s_InternalTransformList = new List<Transform>(30);

		public static EventFunction<IPointerMoveHandler> pointerMoveHandler => s_PointerMoveHandler;

		public static EventFunction<IPointerEnterHandler> pointerEnterHandler => s_PointerEnterHandler;

		public static EventFunction<IPointerExitHandler> pointerExitHandler => s_PointerExitHandler;

		public static EventFunction<IPointerDownHandler> pointerDownHandler => s_PointerDownHandler;

		public static EventFunction<IPointerUpHandler> pointerUpHandler => s_PointerUpHandler;

		public static EventFunction<IPointerClickHandler> pointerClickHandler => s_PointerClickHandler;

		public static EventFunction<IInitializePotentialDragHandler> initializePotentialDrag => s_InitializePotentialDragHandler;

		public static EventFunction<IBeginDragHandler> beginDragHandler => s_BeginDragHandler;

		public static EventFunction<IDragHandler> dragHandler => s_DragHandler;

		public static EventFunction<IEndDragHandler> endDragHandler => s_EndDragHandler;

		public static EventFunction<IDropHandler> dropHandler => s_DropHandler;

		public static EventFunction<IScrollHandler> scrollHandler => s_ScrollHandler;

		public static EventFunction<IUpdateSelectedHandler> updateSelectedHandler => s_UpdateSelectedHandler;

		public static EventFunction<ISelectHandler> selectHandler => s_SelectHandler;

		public static EventFunction<IDeselectHandler> deselectHandler => s_DeselectHandler;

		public static EventFunction<IMoveHandler> moveHandler => s_MoveHandler;

		public static EventFunction<ISubmitHandler> submitHandler => s_SubmitHandler;

		public static EventFunction<ICancelHandler> cancelHandler => s_CancelHandler;

		public static T ValidateEventData<T>(BaseEventData data) where T : class
		{
			if (data as T == null)
			{
				throw new ArgumentException($"Invalid type: {data.GetType()} passed to event expecting {typeof(T)}");
			}
			return data as T;
		}

		private static void Execute(IPointerMoveHandler handler, BaseEventData eventData)
		{
			handler.OnPointerMove(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IPointerEnterHandler handler, BaseEventData eventData)
		{
			handler.OnPointerEnter(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IPointerExitHandler handler, BaseEventData eventData)
		{
			handler.OnPointerExit(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IPointerDownHandler handler, BaseEventData eventData)
		{
			handler.OnPointerDown(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IPointerUpHandler handler, BaseEventData eventData)
		{
			handler.OnPointerUp(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IPointerClickHandler handler, BaseEventData eventData)
		{
			handler.OnPointerClick(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IInitializePotentialDragHandler handler, BaseEventData eventData)
		{
			handler.OnInitializePotentialDrag(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IBeginDragHandler handler, BaseEventData eventData)
		{
			handler.OnBeginDrag(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IDragHandler handler, BaseEventData eventData)
		{
			handler.OnDrag(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IEndDragHandler handler, BaseEventData eventData)
		{
			handler.OnEndDrag(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IDropHandler handler, BaseEventData eventData)
		{
			handler.OnDrop(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IScrollHandler handler, BaseEventData eventData)
		{
			handler.OnScroll(ValidateEventData<PointerEventData>(eventData));
		}

		private static void Execute(IUpdateSelectedHandler handler, BaseEventData eventData)
		{
			handler.OnUpdateSelected(eventData);
		}

		private static void Execute(ISelectHandler handler, BaseEventData eventData)
		{
			handler.OnSelect(eventData);
		}

		private static void Execute(IDeselectHandler handler, BaseEventData eventData)
		{
			handler.OnDeselect(eventData);
		}

		private static void Execute(IMoveHandler handler, BaseEventData eventData)
		{
			handler.OnMove(ValidateEventData<AxisEventData>(eventData));
		}

		private static void Execute(ISubmitHandler handler, BaseEventData eventData)
		{
			handler.OnSubmit(eventData);
		}

		private static void Execute(ICancelHandler handler, BaseEventData eventData)
		{
			handler.OnCancel(eventData);
		}

		private static void GetEventChain(GameObject root, IList<Transform> eventChain)
		{
			eventChain.Clear();
			if (!((Object)(object)root == (Object)null))
			{
				Transform val = root.transform;
				while ((Object)(object)val != (Object)null)
				{
					eventChain.Add(val);
					val = val.parent;
				}
			}
		}

		public static bool Execute<T>(GameObject target, BaseEventData eventData, EventFunction<T> functor) where T : IEventSystemHandler
		{
			List<IEventSystemHandler> list = CollectionPool<List<IEventSystemHandler>, IEventSystemHandler>.Get();
			GetEventList<T>(target, list);
			int count = list.Count;
			for (int i = 0; i < count; i++)
			{
				T handler;
				try
				{
					handler = (T)list[i];
				}
				catch (Exception innerException)
				{
					IEventSystemHandler eventSystemHandler = list[i];
					Debug.LogException(new Exception($"Type {typeof(T).Name} expected {eventSystemHandler.GetType().Name} received.", innerException));
					continue;
				}
				try
				{
					functor(handler, eventData);
				}
				catch (Exception ex)
				{
					Debug.LogException(ex);
				}
			}
			int count2 = list.Count;
			CollectionPool<List<IEventSystemHandler>, IEventSystemHandler>.Release(list);
			return count2 > 0;
		}

		public static GameObject ExecuteHierarchy<T>(GameObject root, BaseEventData eventData, EventFunction<T> callbackFunction) where T : IEventSystemHandler
		{
			GetEventChain(root, s_InternalTransformList);
			int count = s_InternalTransformList.Count;
			for (int i = 0; i < count; i++)
			{
				Transform val = s_InternalTransformList[i];
				if (Execute(((Component)val).gameObject, eventData, callbackFunction))
				{
					return ((Component)val).gameObject;
				}
			}
			return null;
		}

		private static bool ShouldSendToComponent<T>(Component component) where T : IEventSystemHandler
		{
			if (!(component is T))
			{
				return false;
			}
			Behaviour val = (Behaviour)(object)((component is Behaviour) ? component : null);
			if ((Object)(object)val != (Object)null)
			{
				return val.isActiveAndEnabled;
			}
			return true;
		}

		private static void GetEventList<T>(GameObject go, IList<IEventSystemHandler> results) where T : IEventSystemHandler
		{
			if (results == null)
			{
				throw new ArgumentException("Results array is null", "results");
			}
			if ((Object)(object)go == (Object)null || !go.activeInHierarchy)
			{
				return;
			}
			List<Component> list = CollectionPool<List<Component>, Component>.Get();
			go.GetComponents<Component>(list);
			int count = list.Count;
			for (int i = 0; i < count; i++)
			{
				if (ShouldSendToComponent<T>(list[i]))
				{
					results.Add(list[i] as IEventSystemHandler);
				}
			}
			CollectionPool<List<Component>, Component>.Release(list);
		}

		public static bool CanHandleEvent<T>(GameObject go) where T : IEventSystemHandler
		{
			List<IEventSystemHandler> list = CollectionPool<List<IEventSystemHandler>, IEventSystemHandler>.Get();
			GetEventList<T>(go, list);
			int count = list.Count;
			CollectionPool<List<IEventSystemHandler>, IEventSystemHandler>.Release(list);
			return count != 0;
		}

		public static GameObject GetEventHandler<T>(GameObject root) where T : IEventSystemHandler
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Transform val = root.transform;
			while ((Object)(object)val != (Object)null)
			{
				if (CanHandleEvent<T>(((Component)val).gameObject))
				{
					return ((Component)val).gameObject;
				}
				val = val.parent;
			}
			return null;
		}
	}
	public class BaseInput : UIBehaviour
	{
		public virtual string compositionString => Input.compositionString;

		public virtual IMECompositionMode imeCompositionMode
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return Input.imeCompositionMode;
			}
			set
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				Input.imeCompositionMode = value;
			}
		}

		public virtual Vector2 compositionCursorPos
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return Input.compositionCursorPos;
			}
			set
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				Input.compositionCursorPos = value;
			}
		}

		public virtual bool mousePresent => Input.mousePresent;

		public virtual Vector2 mousePosition => Vector2.op_Implicit(Input.mousePosition);

		public virtual Vector2 mouseScrollDelta => Input.mouseScrollDelta;

		public virtual bool touchSupported => Input.touchSupported;

		public virtual int touchCount => Input.touchCount;

		public virtual bool GetMouseButtonDown(int button)
		{
			return Input.GetMouseButtonDown(button);
		}

		public virtual bool GetMouseButtonUp(int button)
		{
			return Input.GetMouseButtonUp(button);
		}

		public virtual bool GetMouseButton(int button)
		{
			return Input.GetMouseButton(button);
		}

		public virtual Touch GetTouch(int index)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Input.GetTouch(index);
		}

		public virtual float GetAxisRaw(string axisName)
		{
			return Input.GetAxisRaw(axisName);
		}

		public virtual bool GetButtonDown(string buttonName)
		{
			return Input.GetButtonDown(buttonName);
		}
	}
	[RequireComponent(typeof(EventSystem))]
	public abstract class BaseInputModule : UIBehaviour
	{
		[NonSerialized]
		protected List<RaycastResult> m_RaycastResultCache = new List<RaycastResult>();

		[SerializeField]
		private bool m_SendPointerHoverToParent = true;

		private AxisEventData m_AxisEventData;

		private EventSystem m_EventSystem;

		private BaseEventData m_BaseEventData;

		protected BaseInput m_InputOverride;

		private BaseInput m_DefaultInput;

		internal bool sendPointerHoverToParent
		{
			get
			{
				return m_SendPointerHoverToParent;
			}
			set
			{
				m_SendPointerHoverToParent = value;
			}
		}

		public BaseInput input
		{
			get
			{
				if ((Object)(object)m_InputOverride != (Object)null)
				{
					return m_InputOverride;
				}
				if ((Object)(object)m_DefaultInput == (Object)null)
				{
					BaseInput[] components = ((Component)this).GetComponents<BaseInput>();
					foreach (BaseInput baseInput in components)
					{
						if ((Object)(object)baseInput != (Object)null && ((object)baseInput).GetType() == typeof(BaseInput))
						{
							m_DefaultInput = baseInput;
							break;
						}
					}
					if ((Object)(object)m_DefaultInput == (Object)null)
					{
						m_DefaultInput = ((Component)this).gameObject.AddComponent<BaseInput>();
					}
				}
				return m_DefaultInput;
			}
		}

		public BaseInput inputOverride
		{
			get
			{
				return m_InputOverride;
			}
			set
			{
				m_InputOverride = value;
			}
		}

		protected EventSystem eventSystem => m_EventSystem;

		protected override void OnEnable()
		{
			base.OnEnable();
			m_EventSystem = ((Component)this).GetComponent<EventSystem>();
			m_EventSystem.UpdateModules();
		}

		protected override void OnDisable()
		{
			m_EventSystem.UpdateModules();
			base.OnDisable();
		}

		public abstract void Process();

		protected static RaycastResult FindFirstRaycast(List<RaycastResult> candidates)
		{
			int count = candidates.Count;
			for (int i = 0; i < count; i++)
			{
				if (!((Object)(object)candidates[i].gameObject == (Object)null))
				{
					return candidates[i];
				}
			}
			return default(RaycastResult);
		}

		protected static MoveDirection DetermineMoveDirection(float x, float y)
		{
			return DetermineMoveDirection(x, y, 0.6f);
		}

		protected static MoveDirection DetermineMoveDirection(float x, float y, float deadZone)
		{
			//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)
			Vector2 val = new Vector2(x, y);
			if (((Vector2)(ref val)).sqrMagnitude < deadZone * deadZone)
			{
				return MoveDirection.None;
			}
			if (Mathf.Abs(x) > Mathf.Abs(y))
			{
				if (!(x > 0f))
				{
					return MoveDirection.Left;
				}
				return MoveDirection.Right;
			}
			if (!(y > 0f))
			{
				return MoveDirection.Down;
			}
			return MoveDirection.Up;
		}

		protected static GameObject FindCommonRoot(GameObject g1, GameObject g2)
		{
			if ((Object)(object)g1 == (Object)null || (Object)(object)g2 == (Object)null)
			{
				return null;
			}
			Transform val = g1.transform;
			while ((Object)(object)val != (Object)null)
			{
				Transform val2 = g2.transform;
				while ((Object)(object)val2 != (Object)null)
				{
					if ((Object)(object)val == (Object)(object)val2)
					{
						return ((Component)val).gameObject;
					}
					val2 = val2.parent;
				}
				val = val.parent;
			}
			return null;
		}

		protected void HandlePointerExitAndEnter(PointerEventData currentPointerData, GameObject newEnterTarget)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)newEnterTarget == (Object)null || (Object)(object)currentPointerData.pointerEnter == (Object)null)
			{
				int count = currentPointerData.hovered.Count;
				for (int i = 0; i < count; i++)
				{
					currentPointerData.fullyExited = true;
					ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerMoveHandler);
					ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerExitHandler);
				}
				currentPointerData.hovered.Clear();
				if ((Object)(object)newEnterTarget == (Object)null)
				{
					currentPointerData.pointerEnter = null;
					return;
				}
			}
			if ((Object)(object)currentPointerData.pointerEnter == (Object)(object)newEnterTarget && Object.op_Implicit((Object)(object)newEnterTarget))
			{
				if (currentPointerData.IsPointerMoving())
				{
					int count2 = currentPointerData.hovered.Count;
					for (int j = 0; j < count2; j++)
					{
						ExecuteEvents.Execute(currentPointerData.hovered[j], currentPointerData, ExecuteEvents.pointerMoveHandler);
					}
				}
				return;
			}
			GameObject val = FindCommonRoot(currentPointerData.pointerEnter, newEnterTarget);
			Component val2 = (Component)newEnterTarget.GetComponentInParent<IPointerExitHandler>();
			GameObject val3 = (((int)val2 != 0) ? val2.gameObject : null);
			if ((Object)(object)currentPointerData.pointerEnter != (Object)null)
			{
				Transform val4 = currentPointerData.pointerEnter.transform;
				while ((Object)(object)val4 != (Object)null && (!m_SendPointerHoverToParent || !((Object)(object)val != (Object)null) || !((Object)(object)val.transform == (Object)(object)val4)) && (m_SendPointerHoverToParent || !((Object)(object)val3 == (Object)(object)((Component)val4).gameObject)))
				{
					currentPointerData.fullyExited = (Object)(object)((Component)val4).gameObject != (Object)(object)val && (Object)(object)currentPointerData.pointerEnter != (Object)(object)newEnterTarget;
					ExecuteEvents.Execute(((Component)val4).gameObject, currentPointerData, ExecuteEvents.pointerMoveHandler);
					ExecuteEvents.Execute(((Component)val4).gameObject, currentPointerData, ExecuteEvents.pointerExitHandler);
					currentPointerData.hovered.Remove(((Component)val4).gameObject);
					if (m_SendPointerHoverToParent)
					{
						val4 = val4.parent;
					}
					if ((Object)(object)val != (Object)null && (Object)(object)val.transform == (Object)(object)val4)
					{
						break;
					}
					if (!m_SendPointerHoverToParent)
					{
						val4 = val4.parent;
					}
				}
			}
			GameObject pointerEnter = currentPointerData.pointerEnter;
			currentPointerData.pointerEnter = newEnterTarget;
			if (!((Object)(object)newEnterTarget != (Object)null))
			{
				return;
			}
			Transform val5 = newEnterTarget.transform;
			while ((Object)(object)val5 != (Object)null)
			{
				currentPointerData.reentered = (Object)(object)((Component)val5).gameObject == (Object)(object)val && (Object)(object)((Component)val5).gameObject != (Object)(object)pointerEnter;
				if (!m_SendPointerHoverToParent || !currentPointerData.reentered)
				{
					ExecuteEvents.Execute(((Component)val5).gameObject, currentPointerData, ExecuteEvents.pointerEnterHandler);
					ExecuteEvents.Execute(((Component)val5).gameObject, currentPointerData, ExecuteEvents.pointerMoveHandler);
					currentPointerData.hovered.Add(((Component)val5).gameObject);
					if (m_SendPointerHoverToParent || ((Component)val5).gameObject.GetComponent<IPointerEnterHandler>() == null)
					{
						if (m_SendPointerHoverToParent)
						{
							val5 = val5.parent;
						}
						if (!((Object)(object)val != (Object)null) || !((Object)(object)val.transform == (Object)(object)val5))
						{
							if (!m_SendPointerHoverToParent)
							{
								val5 = val5.parent;
							}
							continue;
						}
						break;
					}
					break;
				}
				break;
			}
		}

		protected virtual AxisEventData GetAxisEventData(float x, float y, float moveDeadZone)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (m_AxisEventData == null)
			{
				m_AxisEventData = new AxisEventData(eventSystem);
			}
			m_AxisEventData.Reset();
			m_AxisEventData.moveVector = new Vector2(x, y);
			m_AxisEventData.moveDir = DetermineMoveDirection(x, y, moveDeadZone);
			return m_AxisEventData;
		}

		protected virtual BaseEventData GetBaseEventData()
		{
			if (m_BaseEventData == null)
			{
				m_BaseEventData = new BaseEventData(eventSystem);
			}
			m_BaseEventData.Reset();
			return m_BaseEventData;
		}

		public virtual bool IsPointerOverGameObject(int pointerId)
		{
			return false;
		}

		public virtual bool ShouldActivateModule()
		{
			if (((Behaviour)this).enabled)
			{
				return ((Component)this).gameObject.activeInHierarchy;
			}
			return false;
		}

		public virtual void DeactivateModule()
		{
		}

		public virtual void ActivateModule()
		{
		}

		public virtual void UpdateModule()
		{
		}

		public virtual bool IsModuleSupported()
		{
			return true;
		}

		public virtual int ConvertUIToolkitPointerId(PointerEventData sourcePointerData)
		{
			if (sourcePointerData.pointerId >= 0)
			{
				return PointerId.touchPointerIdBase + sourcePointerData.pointerId;
			}
			return PointerId.mousePointerId;
		}
	}
	public abstract class PointerInputModule : BaseInputModule
	{
		protected class ButtonState
		{
			private PointerEventData.InputButton m_Button;

			private MouseButtonEventData m_EventData;

			public MouseButtonEventData eventData
			{
				get
				{
					return m_EventData;
				}
				set
				{
					m_EventData = value;
				}
			}

			public PointerEventData.InputButton button
			{
				get
				{
					return m_Button;
				}
				set
				{
					m_Button = value;
				}
			}
		}

		protected class MouseState
		{
			private List<ButtonState> m_TrackedButtons = new List<ButtonState>();

			public bool AnyPressesThisFrame()
			{
				int count = m_TrackedButtons.Count;
				for (int i = 0; i < count; i++)
				{
					if (m_TrackedButtons[i].eventData.PressedThisFrame())
					{
						return true;
					}
				}
				return false;
			}

			public bool AnyReleasesThisFrame()
			{
				int count = m_TrackedButtons.Count;
				for (int i = 0; i < count; i++)
				{
					if (m_TrackedButtons[i].eventData.ReleasedThisFrame())
					{
						return true;
					}
				}
				return false;
			}

			public ButtonState GetButtonState(PointerEventData.InputButton button)
			{
				ButtonState buttonState = null;
				int count = m_TrackedButtons.Count;
				for (int i = 0; i < count; i++)
				{
					if (m_TrackedButtons[i].button == button)
					{
						buttonState = m_TrackedButtons[i];
						break;
					}
				}
				if (buttonState == null)
				{
					buttonState = new ButtonState
					{
						button = button,
						eventData = new MouseButtonEventData()
					};
					m_TrackedButtons.Add(buttonState);
				}
				return buttonState;
			}

			public void SetButtonState(PointerEventData.InputButton button, PointerEventData.FramePressState stateForMouseButton, PointerEventData data)
			{
				ButtonState buttonState = GetButtonState(button);
				buttonState.eventData.buttonState = stateForMouseButton;
				buttonState.eventData.buttonData = data;
			}
		}

		public class MouseButtonEventData
		{
			public PointerEventData.FramePressState buttonState;

			public PointerEventData buttonData;

			public bool PressedThisFrame()
			{
				if (buttonState != PointerEventData.FramePressState.Pressed)
				{
					return buttonState == PointerEventData.FramePressState.PressedAndReleased;
				}
				return true;
			}

			public bool ReleasedThisFrame()
			{
				if (buttonState != PointerEventData.FramePressState.Released)
				{
					return buttonState == PointerEventData.FramePressState.PressedAndReleased;
				}
				return true;
			}
		}

		public const int kMouseLeftId = -1;

		public const int kMouseRightId = -2;

		public const int kMouseMiddleId = -3;

		public const int kFakeTouchesId = -4;

		protected Dictionary<int, PointerEventData> m_PointerData = new Dictionary<int, PointerEventData>();

		private readonly MouseState m_MouseState = new MouseState();

		protected bool GetPointerData(int id, out PointerEventData data, bool create)
		{
			if (!m_PointerData.TryGetValue(id, out data) && create)
			{
				data = new PointerEventData(base.eventSystem)
				{
					pointerId = id
				};
				m_PointerData.Add(id, data);
				return true;
			}
			return false;
		}

		protected void RemovePointerData(PointerEventData data)
		{
			m_PointerData.Remove(data.pointerId);
		}

		protected PointerEventData GetTouchPointerEventData(Touch input, out bool pressed, out bool released)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Invalid comparison between Unknown and I4
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			PointerEventData data;
			bool pointerData = GetPointerData(((Touch)(ref input)).fingerId, out data, create: true);
			data.Reset();
			pressed = pointerData || (int)((Touch)(ref input)).phase == 0;
			released = (int)((Touch)(ref input)).phase == 4 || (int)((Touch)(ref input)).phase == 3;
			if (pointerData)
			{
				data.position = ((Touch)(ref input)).position;
			}
			if (pressed)
			{
				data.delta = Vector2.zero;
			}
			else
			{
				data.delta = ((Touch)(ref input)).position - data.position;
			}
			data.position = ((Touch)(ref input)).position;
			data.button = PointerEventData.InputButton.Left;
			if ((int)((Touch)(ref input)).phase == 4)
			{
				data.pointerCurrentRaycast = default(RaycastResult);
			}
			else
			{
				base.eventSystem.RaycastAll(data, m_RaycastResultCache);
				RaycastResult pointerCurrentRaycast = BaseInputModule.FindFirstRaycast(m_RaycastResultCache);
				data.pointerCurrentRaycast = pointerCurrentRaycast;
				m_RaycastResultCache.Clear();
			}
			data.pressure = ((Touch)(ref input)).pressure;
			data.altitudeAngle = ((Touch)(ref input)).altitudeAngle;
			data.azimuthAngle = ((Touch)(ref input)).azimuthAngle;
			data.radius = Vector2.one * ((Touch)(ref input)).radius;
			data.radiusVariance = Vector2.one * ((Touch)(ref input)).radiusVariance;
			return data;
		}

		protected void CopyFromTo(PointerEventData from, PointerEventData to)
		{
			//IL_0002: 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)
			//IL_007a: 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)
			to.position = from.position;
			to.delta = from.delta;
			to.scrollDelta = from.scrollDelta;
			to.pointerCurrentRaycast = from.pointerCurrentRaycast;
			to.pointerEnter = from.pointerEnter;
			to.pressure = from.pressure;
			to.tangentialPressure = from.tangentialPressure;
			to.altitudeAngle = from.altitudeAngle;
			to.azimuthAngle = from.azimuthAngle;
			to.twist = from.twist;
			to.radius = from.radius;
			to.radiusVariance = from.radiusVariance;
		}

		protected PointerEventData.FramePressState StateForMouseButton(int buttonId)
		{
			bool mouseButtonDown = base.input.GetMouseButtonDown(buttonId);
			bool mouseButtonUp = base.input.GetMouseButtonUp(buttonId);
			if (mouseButtonDown && mouseButtonUp)
			{
				return PointerEventData.FramePressState.PressedAndReleased;
			}
			if (mouseButtonDown)
			{
				return PointerEventData.FramePressState.Pressed;
			}
			if (mouseButtonUp)
			{
				return PointerEventData.FramePressState.Released;
			}
			return PointerEventData.FramePressState.NotChanged;
		}

		protected virtual MouseState GetMousePointerEventData()
		{
			return GetMousePointerEventData(0);
		}

		protected virtual MouseState GetMousePointerEventData(int id)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0019: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			PointerEventData data;
			bool pointerData = GetPointerData(-1, out data, create: true);
			data.Reset();
			if (pointerData)
			{
				data.position = base.input.mousePosition;
			}
			Vector2 mousePosition = base.input.mousePosition;
			if ((int)Cursor.lockState == 1)
			{
				data.position = new Vector2(-1f, -1f);
				data.delta = Vector2.zero;
			}
			else
			{
				data.delta = mousePosition - data.position;
				data.position = mousePosition;
			}
			data.scrollDelta = base.input.mouseScrollDelta;
			data.button = PointerEventData.InputButton.Left;
			base.eventSystem.RaycastAll(data, m_RaycastResultCache);
			RaycastResult pointerCurrentRaycast = BaseInputModule.FindFirstRaycast(m_RaycastResultCache);
			data.pointerCurrentRaycast = pointerCurrentRaycast;
			m_RaycastResultCache.Clear();
			GetPointerData(-2, out var data2, create: true);
			data2.Reset();
			CopyFromTo(data, data2);
			data2.button = PointerEventData.InputButton.Right;
			GetPointerData(-3, out var data3, create: true);
			data3.Reset();
			CopyFromTo(data, data3);
			data3.button = PointerEventData.InputButton.Middle;
			m_MouseState.SetButtonState(PointerEventData.InputButton.Left, StateForMouseButton(0), data);
			m_MouseState.SetButtonState(PointerEventData.InputButton.Right, StateForMouseButton(1), data2);
			m_MouseState.SetButtonState(PointerEventData.InputButton.Middle, StateForMouseButton(2), data3);
			return m_MouseState;
		}

		protected PointerEventData GetLastPointerEventData(int id)
		{
			GetPointerData(id, out var data, create: false);
			return data;
		}

		private static bool ShouldStartDrag(Vector2 pressPos, Vector2 currentPos, float threshold, bool useDragThreshold)
		{
			//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_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)
			if (!useDragThreshold)
			{
				return true;
			}
			Vector2 val = pressPos - currentPos;
			return ((Vector2)(ref val)).sqrMagnitude >= threshold * threshold;
		}

		protected virtual void ProcessMove(PointerEventData pointerEvent)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			GameObject newEnterTarget = (((int)Cursor.lockState == 1) ? null : pointerEvent.pointerCurrentRaycast.gameObject);
			HandlePointerExitAndEnter(pointerEvent, newEnterTarget);
		}

		protected virtual void ProcessDrag(PointerEventData pointerEvent)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!pointerEvent.IsPointerMoving() || (int)Cursor.lockState == 1 || (Object)(object)pointerEvent.pointerDrag == (Object)null)
			{
				return;
			}
			if (!pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
			{
				ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
				pointerEvent.dragging = true;
			}
			if (pointerEvent.dragging)
			{
				if ((Object)(object)pointerEvent.pointerPress != (Object)(object)pointerEvent.pointerDrag)
				{
					ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
					pointerEvent.eligibleForClick = false;
					pointerEvent.pointerPress = null;
					pointerEvent.rawPointerPress = null;
				}
				ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
			}
		}

		public override bool IsPointerOverGameObject(int pointerId)
		{
			PointerEventData lastPointerEventData = GetLastPointerEventData(pointerId);
			if (lastPointerEventData != null)
			{
				return (Object)(object)lastPointerEventData.pointerEnter != (Object)null;
			}
			return false;
		}

		protected void ClearSelection()
		{
			BaseEventData baseEventData = GetBaseEventData();
			foreach (PointerEventData value in m_PointerData.Values)
			{
				HandlePointerExitAndEnter(value, null);
			}
			m_PointerData.Clear();
			base.eventSystem.SetSelectedGameObject(null, baseEventData);
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder("<b>Pointer Input Module of type: </b>" + ((object)this).GetType());
			stringBuilder.AppendLine();
			foreach (KeyValuePair<int, PointerEventData> pointerDatum in m_PointerData)
			{
				if (pointerDatum.Value != null)
				{
					stringBuilder.AppendLine("<B>Pointer:</b> " + pointerDatum.Key);
					stringBuilder.AppendLine(pointerDatum.Value.ToString());
				}
			}
			return stringBuilder.ToString();
		}

		protected void DeselectIfSelectionChanged(GameObject currentOverGo, BaseEventData pointerEvent)
		{
			if ((Object)(object)ExecuteEvents.GetEventHandler<ISelectHandler>(currentOverGo) != (Object)(object)base.eventSystem.currentSelectedGameObject)
			{
				base.eventSystem.SetSelectedGameObject(null, pointerEvent);
			}
		}
	}
	[AddComponentMenu("Event/Standalone Input Module")]
	public class StandaloneInputModule : PointerInputModule
	{
		[Obsolete("Mode is no longer needed on input module as it handles both mouse and keyboard simultaneously.", false)]
		public enum InputMode
		{
			Mouse,
			Buttons
		}

		private float m_PrevActionTime;

		private Vector2 m_LastMoveVector;

		private int m_ConsecutiveMoveCount;

		private Vector2 m_LastMousePosition;

		private Vector2 m_MousePosition;

		private GameObject m_CurrentFocusedGameObject;

		private PointerEventData m_InputPointerEvent;

		[SerializeField]
		private string m_HorizontalAxis = "Horizontal";

		[SerializeField]
		private string m_VerticalAxis = "Vertical";

		[SerializeField]
		private string m_SubmitButton = "Submit";

		[SerializeField]
		private string m_CancelButton = "Cancel";

		[SerializeField]
		private float m_InputActionsPerSecond = 10f;

		[SerializeField]
		private float m_RepeatDelay = 0.5f;

		[SerializeField]
		[FormerlySerializedAs("m_AllowActivationOnMobileDevice")]
		[HideInInspector]
		private bool m_ForceModuleActive;

		[Obsolete("Mode is no longer needed on input module as it handles both mouse and keyboard simultaneously.", false)]
		public InputMode inputMode => InputMode.Mouse;

		[Obsolete("allowActivationOnMobileDevice has been deprecated. Use forceModuleActive instead (UnityUpgradable) -> forceModuleActive")]
		public bool allowActivationOnMobileDevice
		{
			get
			{
				return m_ForceModuleActive;
			}
			set
			{
				m_ForceModuleActive = value;
			}
		}

		[Obsolete("forceModuleActive has been deprecated. There is no need to force the module awake as StandaloneInputModule works for all platforms")]
		public bool forceModuleActive
		{
			get
			{
				return m_ForceModuleActive;
			}
			set
			{
				m_ForceModuleActive = value;
			}
		}

		public float inputActionsPerSecond
		{
			get
			{
				return m_InputActionsPerSecond;
			}
			set
			{
				m_InputActionsPerSecond = value;
			}
		}

		public float repeatDelay
		{
			get
			{
				return m_RepeatDelay;
			}
			set
			{
				m_RepeatDelay = value;
			}
		}

		public string horizontalAxis
		{
			get
			{
				return m_HorizontalAxis;
			}
			set
			{
				m_HorizontalAxis = value;
			}
		}

		public string verticalAxis
		{
			get
			{
				return m_VerticalAxis;
			}
			set
			{
				m_VerticalAxis = value;
			}
		}

		public string submitButton
		{
			get
			{
				return m_SubmitButton;
			}
			set
			{
				m_SubmitButton = value;
			}
		}

		public string cancelButton
		{
			get
			{
				return m_CancelButton;
			}
			set
			{
				m_CancelButton = value;
			}
		}

		protected StandaloneInputModule()
		{
		}

		private bool ShouldIgnoreEventsOnNoFocus()
		{
			return true;
		}

		public override void UpdateModule()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (!base.eventSystem.isFocused && ShouldIgnoreEventsOnNoFocus())
			{
				if (m_InputPointerEvent != null && (Object)(object)m_InputPointerEvent.pointerDrag != (Object)null && m_InputPointerEvent.dragging)
				{
					ReleaseMouse(m_InputPointerEvent, m_InputPointerEvent.pointerCurrentRaycast.gameObject);
				}
				m_InputPointerEvent = null;
			}
			else
			{
				m_LastMousePosition = m_MousePosition;
				m_MousePosition = base.input.mousePosition;
			}
		}

		private void ReleaseMouse(PointerEventData pointerEvent, GameObject currentOverGo)
		{
			ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
			GameObject eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
			if ((Object)(object)pointerEvent.pointerClick == (Object)(object)eventHandler && pointerEvent.eligibleForClick)
			{
				ExecuteEvents.Execute(pointerEvent.pointerClick, pointerEvent, ExecuteEvents.pointerClickHandler);
			}
			if ((Object)(object)pointerEvent.pointerDrag != (Object)null && pointerEvent.dragging)
			{
				ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.dropHandler);
			}
			pointerEvent.eligibleForClick = false;
			pointerEvent.pointerPress = null;
			pointerEvent.rawPointerPress = null;
			pointerEvent.pointerClick = null;
			if ((Object)(object)pointerEvent.pointerDrag != (Object)null && pointerEvent.dragging)
			{
				ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
			}
			pointerEvent.dragging = false;
			pointerEvent.pointerDrag = null;
			if ((Object)(object)currentOverGo != (Object)(object)pointerEvent.pointerEnter)
			{
				HandlePointerExitAndEnter(pointerEvent, null);
				HandlePointerExitAndEnter(pointerEvent, currentOverGo);
			}
			m_InputPointerEvent = pointerEvent;
		}

		public override bool ShouldActivateModule()
		{
			//IL_007d: 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_0088: 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)
			if (!base.ShouldActivateModule())
			{
				return false;
			}
			bool flag = m_ForceModuleActive;
			flag |= base.input.GetButtonDown(m_SubmitButton);
			flag |= base.input.GetButtonDown(m_CancelButton);
			flag |= !Mathf.Approximately(base.input.GetAxisRaw(m_HorizontalAxis), 0f);
			flag |= !Mathf.Approximately(base.input.GetAxisRaw(m_VerticalAxis), 0f);
			bool num = flag;
			Vector2 val = m_MousePosition - m_LastMousePosition;
			flag = num | (((Vector2)(ref val)).sqrMagnitude > 0f);
			flag |= base.input.GetMouseButtonDown(0);
			if (base.input.touchCount > 0)
			{
				flag = true;
			}
			return flag;
		}

		public override void ActivateModule()
		{
			//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_0034: 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)
			if (base.eventSystem.isFocused || !ShouldIgnoreEventsOnNoFocus())
			{
				base.ActivateModule();
				m_MousePosition = base.input.mousePosition;
				m_LastMousePosition = base.input.mousePosition;
				GameObject val = base.eventSystem.currentSelectedGameObject;
				if ((Object)(object)val == (Object)null)
				{
					val = base.eventSystem.firstSelectedGameObject;
				}
				base.eventSystem.SetSelectedGameObject(val, GetBaseEventData());
			}
		}

		public override void DeactivateModule()
		{
			base.DeactivateModule();
			ClearSelection();
		}

		public override void Process()
		{
			if (!base.eventSystem.isFocused && ShouldIgnoreEventsOnNoFocus())
			{
				return;
			}
			bool flag = SendUpdateEventToSelectedObject();
			if (!ProcessTouchEvents() && base.input.mousePresent)
			{
				ProcessMouseEvent();
			}
			if (base.eventSystem.sendNavigationEvents)
			{
				if (!flag)
				{
					flag |= SendMoveEventToSelectedObject();
				}
				if (!flag)
				{
					SendSubmitEventToSelectedObject();
				}
			}
		}

		private bool ProcessTouchEvents()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < base.input.touchCount; i++)
			{
				Touch touch = base.input.GetTouch(i);
				if ((int)((Touch)(ref touch)).type != 1)
				{
					bool pressed;
					bool released;
					PointerEventData touchPointerEventData = GetTouchPointerEventData(touch, out pressed, out released);
					ProcessTouchPress(touchPointerEventData, pressed, released);
					if (!released)
					{
						ProcessMove(touchPointerEventData);
						ProcessDrag(touchPointerEventData);
					}
					else
					{
						RemovePointerData(touchPointerEventData);
					}
				}
			}
			return base.input.touchCount > 0;
		}

		protected void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released)
		{
			//IL_001d: 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)
			GameObject gameObject = pointerEvent.pointerCurrentRaycast.gameObject;
			if (pressed)
			{
				pointerEvent.eligibleForClick = true;
				pointerEvent.delta = Vector2.zero;
				pointerEvent.dragging = false;
				pointerEvent.useDragThreshold = true;
				pointerEvent.pressPosition = pointerEvent.position;
				pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast;
				DeselectIfSelectionChanged(gameObject, pointerEvent);
				if ((Object)(object)pointerEvent.pointerEnter != (Object)(object)gameObject)
				{
					HandlePointerExitAndEnter(pointerEvent, gameObject);
					pointerEvent.pointerEnter = gameObject;
				}
				GameObject val = ExecuteEvents.ExecuteHierarchy(gameObject, pointerEvent, ExecuteEvents.pointerDownHandler);
				GameObject eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject);
				if ((Object)(object)val == (Object)null)
				{
					val = eventHandler;
				}
				float unscaledTime = Time.unscaledTime;
				if ((Object)(object)val == (Object)(object)pointerEvent.lastPress)
				{
					if (unscaledTime - pointerEvent.clickTime < 0.3f)
					{
						int clickCount = pointerEvent.clickCount + 1;
						pointerEvent.clickCount = clickCount;
					}
					else
					{
						pointerEvent.clickCount = 1;
					}
					pointerEvent.clickTime = unscaledTime;
				}
				else
				{
					pointerEvent.clickCount = 1;
				}
				pointerEvent.pointerPress = val;
				pointerEvent.rawPointerPress = gameObject;
				pointerEvent.pointerClick = eventHandler;
				pointerEvent.clickTime = unscaledTime;
				pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(gameObject);
				if ((Object)(object)pointerEvent.pointerDrag != (Object)null)
				{
					ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
				}
			}
			if (released)
			{
				ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
				GameObject eventHandler2 = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject);
				if ((Object)(object)pointerEvent.pointerClick == (Object)(object)eventHandler2 && pointerEvent.eligibleForClick)
				{
					ExecuteEvents.Execute(pointerEvent.pointerClick, pointerEvent, ExecuteEvents.pointerClickHandler);
				}
				if ((Object)(object)pointerEvent.pointerDrag != (Object)null && pointerEvent.dragging)
				{
					ExecuteEvents.ExecuteHierarchy(gameObject, pointerEvent, ExecuteEvents.dropHandler);
				}
				pointerEvent.eligibleForClick = false;
				pointerEvent.pointerPress = null;
				pointerEvent.rawPointerPress = null;
				pointerEvent.pointerClick = null;
				if ((Object)(object)pointerEvent.pointerDrag != (Object)null && pointerEvent.dragging)
				{
					ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
				}
				pointerEvent.dragging = false;
				pointerEvent.pointerDrag = null;
				ExecuteEvents.ExecuteHierarchy(pointerEvent.pointerEnter, pointerEvent, ExecuteEvents.pointerExitHandler);
				pointerEvent.pointerEnter = null;
			}
			m_InputPointerEvent = pointerEvent;
		}

		protected bool SendSubmitEventToSelectedObject()
		{
			if ((Object)(object)base.eventSystem.currentSelectedGameObject == (Object)null)
			{
				return false;
			}
			BaseEventData baseEventData = GetBaseEventData();
			if (base.input.GetButtonDown(m_SubmitButton))
			{
				ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, baseEventData, ExecuteEvents.submitHandler);
			}
			if (base.input.GetButtonDown(m_CancelButton))
			{
				ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, baseEventData, ExecuteEvents.cancelHandler);
			}
			return baseEventData.used;
		}

		private Vector2 GetRawMoveVector()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			Vector2 zero = Vector2.zero;
			zero.x = base.input.GetAxisRaw(m_HorizontalAxis);
			zero.y = base.input.GetAxisRaw(m_VerticalAxis);
			if (base.input.GetButtonDown(m_HorizontalAxis))
			{
				if (zero.x < 0f)
				{
					zero.x = -1f;
				}
				if (zero.x > 0f)
				{
					zero.x = 1f;
				}
			}
			if (base.input.GetButtonDown(m_VerticalAxis))
			{
				if (zero.y < 0f)
				{
					zero.y = -1f;
				}
				if (zero.y > 0f)
				{
					zero.y = 1f;
				}
			}
			return zero;
		}

		protected bool SendMoveEventToSelectedObject()
		{
			//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_000d: 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_003c: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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)
			float unscaledTime = Time.unscaledTime;
			Vector2 rawMoveVector = GetRawMoveVector();
			if (Mathf.Approximately(rawMoveVector.x, 0f) && Mathf.Approximately(rawMoveVector.y, 0f))
			{
				m_ConsecutiveMoveCount = 0;
				return false;
			}
			bool flag = Vector2.Dot(rawMoveVector, m_LastMoveVector) > 0f;
			if (flag && m_ConsecutiveMoveCount == 1)
			{
				if (unscaledTime <= m_PrevActionTime + m_RepeatDelay)
				{
					return false;
				}
			}
			else if (unscaledTime <= m_PrevActionTime + 1f / m_InputActionsPerSecond)
			{
				return false;
			}
			AxisEventData axisEventData = GetAxisEventData(rawMoveVector.x, rawMoveVector.y, 0.6f);
			if (axisEventData.moveDir != MoveDirection.None)
			{
				ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, axisEventData, ExecuteEvents.moveHandler);
				if (!flag)
				{
					m_ConsecutiveMoveCount = 0;
				}
				m_ConsecutiveMoveCount++;
				m_PrevActionTime = unscaledTime;
				m_LastMoveVector = rawMoveVector;
			}
			else
			{
				m_ConsecutiveMoveCount = 0;
			}
			return axisEventData.used;
		}

		protected void ProcessMouseEvent()
		{
			ProcessMouseEvent(0);
		}

		[Obsolete("This method is no longer checked, overriding it with return true does nothing!")]
		protected virtual bool ForceAutoSelect()
		{
			return false;
		}

		protected void ProcessMouseEvent(int id)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			MouseState mousePointerEventData = GetMousePointerEventData(id);
			MouseButtonEventData eventData = mousePointerEventData.GetButtonState(PointerEventData.InputButton.Left).eventData;
			m_CurrentFocusedGameObject = eventData.buttonData.pointerCurrentRaycast.gameObject;
			ProcessMousePress(eventData);
			ProcessMove(eventData.buttonData);
			ProcessDrag(eventData.buttonData);
			ProcessMousePress(mousePointerEventData.GetButtonState(PointerEventData.InputButton.Right).eventData);
			ProcessDrag(mousePointerEventData.GetButtonState(PointerEventData.InputButton.Right).eventData.buttonData);
			ProcessMousePress(mousePointerEventData.GetButtonState(PointerEventData.InputButton.Middle).eventData);
			ProcessDrag(mousePointerEventData.GetButtonState(PointerEventData.InputButton.Middle).eventData.buttonData);
			Vector2 scrollDelta = eventData.buttonData.scrollDelta;
			if (!Mathf.Approximately(((Vector2)(ref scrollDelta)).sqrMagnitude, 0f))
			{
				ExecuteEvents.ExecuteHierarchy(ExecuteEvents.GetEventHandler<IScrollHandler>(eventData.buttonData.pointerCurrentRaycast.gameObject), eventData.buttonData, ExecuteEvents.scrollHandler);
			}
		}

		protected bool SendUpdateEventToSelectedObject()
		{
			if ((Object)(object)base.eventSystem.currentSelectedGameObject == (Object)null)
			{
				return false;
			}
			BaseEventData baseEventData = GetBaseEventData();
			ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, baseEventData, ExecuteEvents.updateSelectedHandler);
			return baseEventData.used;
		}

		protected void ProcessMousePress(MouseButtonEventData data)
		{
			//IL_0029: 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)
			PointerEventData buttonData = data.buttonData;
			GameObject gameObject = buttonData.pointerCurrentRaycast.gameObject;
			if (data.PressedThisFrame())
			{
				buttonData.eligibleForClick = true;
				buttonData.delta = Vector2.zero;
				buttonData.dragging = false;
				buttonData.useDragThreshold = true;
				buttonData.pressPosition = buttonData.position;
				buttonData.pointerPressRaycast = buttonData.pointerCurrentRaycast;
				DeselectIfSelectionChanged(gameObject, buttonData);
				GameObject val = ExecuteEvents.ExecuteHierarchy(gameObject, buttonData, ExecuteEvents.pointerDownHandler);
				GameObject eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject);
				if ((Object)(object)val == (Object)null)
				{
					val = eventHandler;
				}
				float unscaledTime = Time.unscaledTime;
				if ((Object)(object)val == (Object)(object)buttonData.lastPress)
				{
					if (unscaledTime - buttonData.clickTime < 0.3f)
					{
						int clickCount = buttonData.clickCount + 1;
						buttonData.clickCount = clickCount;
					}
					else
					{
						buttonData.clickCount = 1;
					}
					buttonData.clickTime = unscaledTime;
				}
				else
				{
					buttonData.clickCount = 1;
				}
				buttonData.pointerPress = val;
				buttonData.rawPointerPress = gameObject;
				buttonData.pointerClick = eventHandler;
				buttonData.clickTime = unscaledTime;
				buttonData.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(gameObject);
				if ((Object)(object)buttonData.pointerDrag != (Object)null)
				{
					ExecuteEvents.Execute(buttonData.pointerDrag, buttonData, ExecuteEvents.initializePotentialDrag);
				}
				m_InputPointerEvent = buttonData;
			}
			if (data.ReleasedThisFrame())
			{
				ReleaseMouse(buttonData, gameObject);
			}
		}

		protected GameObject GetCurrentFocusedGameObject()
		{
			return m_CurrentFocusedGameObject;
		}
	}
	[Obsolete("TouchInputModule is no longer required as Touch input is now handled in StandaloneInputModule.")]
	[AddComponentMenu("Event/Touch Input Module")]
	public class TouchInputModule : PointerInputModule
	{
		private Vector2 m_LastMousePosition;

		private Vector2 m_MousePosition;

		private PointerEventData m_InputPointerEvent;

		[SerializeField]
		[FormerlySerializedAs("m_AllowActivationOnStandalone")]
		private bool m_ForceModuleActive;

		[Obsolete("allowActivationOnStandalone has been deprecated. Use forceModuleActive instead (UnityUpgradable) -> forceModuleActive")]
		public bool allowActivationOnStandalone
		{
			get
			{
				return m_ForceModuleActive;
			}
			set
			{
				m_ForceModuleActive = value;
			}
		}

		public bool forceModuleActive
		{
			get
			{
				return m_ForceModuleActive;
			}
			set
			{
				m_ForceModuleActive = value;
			}
		}

		protected TouchInputModule()
		{
		}

		public override void UpdateModule()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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)
			if (!base.eventSystem.isFocused)
			{
				if (m_InputPointerEvent != null && (Object)(object)m_InputPointerEvent.pointerDrag != (Object)null && m_InputPointerEvent.dragging)
				{
					ExecuteEvents.Execute(m_InputPointerEvent.pointerDrag, m_InputPointerEvent, ExecuteEvents.endDragHandler);
				}
				m_InputPointerEvent = null;
			}
			m_LastMousePosition = m_MousePosition;
			m_MousePosition = base.input.mousePosition;
		}

		public override bool IsModuleSupported()
		{
			if (!forceModuleActive)
			{
				return base.input.touchSupported;
			}
			return true;
		}

		public override bool ShouldActivateModule()
		{
			//IL_0029: 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_0034: 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)
			if (!base.ShouldActivateModule())
			{
				return false;
			}
			if (m_ForceModuleActive)
			{
				return true;
			}
			if (UseFakeInput())
			{
				bool mouseButtonDown = base.input.GetMouseButtonDown(0);
				Vector2 val = m_MousePosition - m_LastMousePosition;
				return mouseButtonDown | (((Vector2)(ref val)).sqrMagnitude > 0f);
			}
			return base.input.touchCount > 0;
		}

		private bool UseFakeInput()
		{
			return !base.input.touchSupported;
		}

		public override void Process()
		{
			if (UseFakeInput())
			{
				FakeTouches();
			}
			else
			{
				ProcessTouchEvents();
			}
		}

		private void FakeTouches()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			MouseButtonEventData eventData = GetMousePointerEventData(0).GetButtonState(PointerEventData.InputButton.Left).eventData;
			if (eventData.PressedThisFrame())
			{
				eventData.buttonData.delta = Vector2.zero;
			}
			ProcessTouchPress(eventData.buttonData, eventData.PressedThisFrame(), eventData.ReleasedThisFrame());
			if (base.input.GetMouseButton(0))
			{
				ProcessMove(eventData.buttonData);
				ProcessDrag(eventData.buttonData);
			}
		}

		private void ProcessTouchEvents()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < base.input.touchCount; i++)
			{
				Touch touch = base.input.GetTouch(i);
				if ((int)((Touch)(ref touch)).type != 1)
				{
					bool pressed;
					bool released;
					PointerEventData touchPointerEventData = GetTouchPointerEventData(touch, out pressed, out released);
					ProcessTouchPress(touchPointerEventData, pressed, released);
					if (!released)
					{
						ProcessMove(touchPointerEventData);
						ProcessDrag(touchPointerEventData);
					}
					else
					{
						RemovePointerData(touchPointerEventData);
					}
				}
			}
		}

		protected void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released)
		{
			//IL_001d: 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)
			GameObject gameObject = pointerEvent.pointerCurrentRaycast.gameObject;
			if (pressed)
			{
				pointerEvent.eligibleForClick = true;
				pointerEvent.delta = Vector2.zero;
				pointerEvent.dragging = false;
				pointerEvent.useDragThreshold = true;
				pointerEvent.pressPosition = pointerEvent.position;
				pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast;
				DeselectIfSelectionChanged(gameObject, pointerEvent);
				if ((Object)(object)pointerEvent.pointerEnter != (Object)(object)gameObject)
				{
					HandlePointerExitAndEnter(pointerEvent, gameObject);
					pointerEvent.pointerEnter = gameObject;
				}
				GameObject val = ExecuteEvents.ExecuteHierarchy(gameObject, pointerEvent, ExecuteEvents.pointerDownHandler);
				if ((Object)(object)val == (Object)null)
				{
					val = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject);
				}
				float unscaledTime = Time.unscaledTime;
				if ((Object)(object)val == (Object)(object)pointerEvent.lastPress)
				{
					if (unscaledTime - pointerEvent.clickTime < 0.3f)
					{
						int clickCount = pointerEvent.clickCount + 1;
						pointerEvent.clickCount = clickCount;
					}
					else
					{
						pointerEvent.clickCount = 1;
					}
					pointerEvent.clickTime = unscaledTime;
				}
				else
				{
					pointerEvent.clickCount = 1;
				}
				pointerEvent.pointerPress = val;
				pointerEvent.rawPointerPress = gameObject;
				pointerEvent.clickTime = unscaledTime;
				pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(gameObject);
				if ((Object)(object)pointerEvent.pointerDrag != (Object)null)
				{
					ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
				}
				m_InputPointerEvent = pointerEvent;
			}
			if (released)
			{
				ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
				GameObject eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject);
				if ((Object)(object)pointerEvent.pointerPress == (Object)(object)eventHandler && pointerEvent.eligibleForClick)
				{
					ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler);
				}
				else if ((Object)(object)pointerEvent.pointerDrag != (Object)null && pointerEvent.dragging)
				{
					ExecuteEvents.ExecuteHierarchy(gameObject, pointerEvent, ExecuteEvents.dropHandler);
				}
				pointerEvent.eligibleForClick = false;
				pointerEvent.pointerPress = null;
				pointerEvent.rawPointerPress = null;
				if ((Object)(object)pointerEvent.pointerDrag != (Object)null && pointerEvent.dragging)
				{
					ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
				}
				pointerEvent.dragging = false;
				pointerEvent.pointerDrag = null;
				ExecuteEvents.ExecuteHierarchy(pointerEvent.pointerEnter, pointerEvent, ExecuteEvents.pointerExitHandler);
				pointerEvent.pointerEnter = null;
				m_InputPointerEvent = pointerEvent;
			}
		}

		public override void DeactivateModule()
		{
			base.DeactivateModule();
			ClearSelection();
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(UseFakeInput() ? "Input: Faked" : "Input: Touch");
			if (UseFakeInput())
			{
				PointerEventData lastPointerEventData = GetLastPointerEventData(-1);
				if (lastPointerEventData != null)
				{
					stringBuilder.AppendLine(lastPointerEventData.ToString());
				}
			}
			else
			{
				foreach (KeyValuePair<int, PointerEventData> pointerDatum in m_PointerData)
				{
					stringBuilder.AppendLine(pointerDatum.ToString());
				}
			}
			return stringBuilder.ToString();
		}
	}
	public enum MoveDirection
	{
		Left,
		Up,
		Right,
		Down,
		None
	}
	internal static class RaycasterManager
	{
		private static readonly List<BaseRaycaster> s_Raycasters = new List<BaseRaycaster>();

		public static void AddRaycaster(BaseRaycaster baseRaycaster)
		{
			if (!s_Raycasters.Contains(baseRaycaster))
			{
				s_Raycasters.Add(baseRaycaster);
			}
		}

		public static List<BaseRaycaster> GetRaycasters()
		{
			return s_Raycasters;
		}

		public static void RemoveRaycasters(BaseRaycaster baseRaycaster)
		{
			if (s_Raycasters.Contains(baseRaycaster))
			{
				s_Raycasters.Remove(baseRaycaster);
			}
		}
	}
	public abstract class BaseRaycaster : UIBehaviour
	{
		private BaseRaycaster m_RootRaycaster;

		public abstract Camera eventCamera { get; }

		[Obsolete("Please use sortOrderPriority and renderOrderPriority", false)]
		public virtual int priority => 0;

		public virtual int sortOrderPriority => int.MinValue;

		public virtual int renderOrderPriority => int.MinValue;

		public BaseRaycaster rootRaycaster
		{
			get
			{
				if ((Object)(object)m_RootRaycaster == (Object)null)
				{
					BaseRaycaster[] componentsInParent = ((Component)this).GetComponentsInParent<BaseRaycaster>();
					if (componentsInParent.Length != 0)
					{
						m_RootRaycaster = componentsInParent[^1];
					}
				}
				return m_RootRaycaster;
			}
		}

		public abstract void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList);

		public override string ToString()
		{
			return "Name: " + ((object)((Component)this).gameObject)?.ToString() + "\neventCamera: " + ((object)eventCamera)?.ToString() + "\nsortOrderPriority: " + sortOrderPriority + "\nrenderOrderPriority: " + renderOrderPriority;
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			RaycasterManager.AddRaycaster(this);
		}

		protected override void OnDisable()
		{
			RaycasterManager.RemoveRaycasters(this);
			base.OnDisable();
		}

		protected override void OnCanvasHierarchyChanged()
		{
			base.OnCanvasHierarchyChanged();
			m_RootRaycaster = null;
		}

		protected override void OnTransformParentChanged()
		{
			base.OnTransformParentChanged();
			m_RootRaycaster = null;
		}
	}
	[AddComponentMenu("Event/Physics 2D Raycaster")]
	[RequireComponent(typeof(Camera))]
	public class Physics2DRaycaster : PhysicsRaycaster
	{
		private RaycastHit2D[] m_Hits;

		protected Physics2DRaycaster()
		{
		}

		public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//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_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			Ray ray = default(Ray);
			float distanceToClipPlane = 0f;
			int eventDisplayIndex = 0;
			if (!ComputeRayAndDistance(eventData, ref ray, ref eventDisplayIndex, ref distanceToClipPlane))
			{
				return;
			}
			int num = 0;
			if (base.maxRayIntersections == 0)
			{
				if (ReflectionMethodsCache.Singleton.getRayIntersectionAll == null)
				{
					return;
				}
				m_Hits = ReflectionMethodsCache.Singleton.getRayIntersectionAll(ray, distanceToClipPlane, base.finalEventMask);
				num = m_Hits.Length;
			}
			else
			{
				if (ReflectionMethodsCache.Singleton.getRayIntersectionAllNonAlloc == null)
				{
					return;
				}
				if (m_LastMaxRayIntersections != m_MaxRayIntersections)
				{
					m_Hits = (RaycastHit2D[])(object)new RaycastHit2D[base.maxRayIntersections];
					m_LastMaxRayIntersections = m_MaxRayIntersections;
				}
				num = ReflectionMethodsCache.Singleton.getRayIntersectionAllNonAlloc(ray, m_Hits, distanceToClipPlane, base.finalEventMask);
			}
			if (num == 0)
			{
				return;
			}
			int i = 0;
			for (int num2 = num; i < num2; i++)
			{
				Renderer val = null;
				Renderer component = ((Component)((RaycastHit2D)(ref m_Hits[i])).collider).gameObject.GetComponent<Renderer>();
				if ((Object)(object)component != (Object)null)
				{
					if (component is SpriteRenderer)
					{
						val = component;
					}
					if (component is TilemapRenderer)
					{
						val = component;
					}
					if (component is SpriteShapeRenderer)
					{
						val = component;
					}
				}
				RaycastResult item = new RaycastResult
				{
					gameObject = ((Component)((RaycastHit2D)(ref m_Hits[i])).collider).gameObject,
					module = this,
					distance = Vector3.Distance(((Component)eventCamera).transform.position, Vector2.op_Implicit(((RaycastHit2D)(ref m_Hits[i])).point)),
					worldPosition = Vector2.op_Implicit(((RaycastHit2D)(ref m_Hits[i])).point),
					worldNormal = Vector2.op_Implicit(((RaycastHit2D)(ref m_Hits[i])).normal),
					screenPosition = eventData.position,
					displayIndex = eventDisplayIndex,
					index = resultAppendList.Count,
					sortingGroupID = (((Object)(object)val != (Object)null) ? val.sortingGroupID : SortingGroup.invalidSortingGroupID),
					sortingGroupOrder = (((Object)(object)val != (Object)null) ? val.sortingGroupOrder : 0),
					sortingLayer = (((Object)(object)val != (Object)null) ? val.sortingLayerID : 0),
					sortingOrder = (((Object)(object)val != (Object)null) ? val.sortingOrder : 0)
				};
				if (item.sortingGroupID != SortingGroup.invalidSortingGroupID)
				{
					SortingGroup sortingGroupByIndex = SortingGroup.GetSortingGroupByIndex(val.sortingGroupID);
					if (sortingGroupByIndex != null)
					{
						item.distance = Vector3.Distance(((Component)sortingGroupByIndex).transform.position, ((Ray)(ref ray)).origin);
						item.sortingLayer = sortingGroupByIndex.sortingLayerID;
						item.sortingOrder = sortingGroupByIndex.sortingOrder;
					}
				}
				resultAppendList.Add(item);
			}
		}
	}
	[AddComponentMenu("Event/Physics Raycaster")]
	[RequireComponent(typeof(Camera))]
	public class PhysicsRaycaster : BaseRaycaster
	{
		private class RaycastHitComparer : IComparer<RaycastHit>
		{
			public static RaycastHitComparer instance = new RaycastHitComparer();

			public int Compare(RaycastHit x, RaycastHit y)
			{
				return ((RaycastHit)(ref x)).distance.CompareTo(((RaycastHit)(ref y)).distance);
			}
		}

		protected const int kNoEventMaskSet = -1;

		protected Camera m_EventCamera;

		[SerializeField]
		protected LayerMask m_EventMask = LayerMask.op_Implicit(-1);

		[SerializeField]
		protected int m_MaxRayIntersections;

		protected int m_LastMaxRayIntersections;

		private RaycastHit[] m_Hits;

		public override Camera eventCamera
		{
			get
			{
				if ((Object)(object)m_EventCamera == (Object)null)
				{
					m_EventCamera = ((Component)this).GetComponent<Camera>();
				}
				return m_EventCamera ?? Camera.main;
			}
		}

		public virtual int depth
		{
			get
			{
				if (!((Object)(object)eventCamera != (Object)null))
				{
					return 16777215;
				}
				return (int)eventCamera.depth;
			}
		}

		public int finalEventMask
		{
			get
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)eventCamera != (Object)null))
				{
					return -1;
				}
				return eventCamera.cullingMask & LayerMask.op_Implicit(m_EventMask);
			}
		}

		public LayerMask eventMask
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return m_EventMask;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				m_EventMask = value;
			}
		}

		public int maxRayIntersections
		{
			get
			{
				return m_MaxRayIntersections;
			}
			set
			{
				m_MaxRayIntersections = value;
			}
		}

		protected PhysicsRaycaster()
		{
		}//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)


		protected bool ComputeRayAndDistance(PointerEventData eventData, ref Ray ray, ref int eventDisplayIndex, ref float distanceToClipPlane)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0044: 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_004e: 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_0055: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)eventCamera == (Object)null)
			{
				return false;
			}
			Vector3 val = MultipleDisplayUtilities.RelativeMouseAtScaled(eventData.position);
			if (val != Vector3.zero)
			{
				eventDisplayIndex = (int)val.z;
				if (eventDisplayIndex != eventCamera.targetDisplay)
				{
					return false;
				}
			}
			else
			{
				val = Vector2.op_Implicit(eventData.position);
			}
			Rect pixelRect = eventCamera.pixelRect;
			if (!((Rect)(ref pixelRect)).Contains(val))
			{
				return false;
			}
			ray = eventCamera.ScreenPointToRay(val);
			float z = ((Ray)(ref ray)).direction.z;
			distanceToClipPlane = (Mathf.Approximately(0f, z) ? float.PositiveInfinity : Mathf.Abs((eventCamera.farClipPlane - eventCamera.nearClipPlane) / z));
			return true;
		}

		public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			Ray ray = default(Ray);
			int eventDisplayIndex = 0;
			float distanceToClipPlane = 0f;
			if (!ComputeRayAndDistance(eventData, ref ray, ref eventDisplayIndex, ref distanceToClipPlane))
			{
				return;
			}
			int num = 0;
			if (m_MaxRayIntersections == 0)
			{
				if (ReflectionMethodsCache.Singleton.raycast3DAll == null)
				{
					return;
				}
				m_Hits = ReflectionMethodsCache.Singleton.raycast3DAll(ray, distanceToClipPlane, finalEventMask);
				num = m_Hits.Length;
			}
			else
			{
				if (ReflectionMethodsCache.Singleton.getRaycastNonAlloc == null)
				{
					return;
				}
				if (m_LastMaxRayIntersections != m_MaxRayIntersections)
				{
					m_Hits = (RaycastHit[])(object)new RaycastHit[m_MaxRayIntersections];
					m_LastMaxRayIntersections = m_MaxRayIntersections;
				}
				num = ReflectionMethodsCache.Singleton.getRaycastNonAlloc(ray, m_Hits, distanceToClipPlane, finalEventMask);
			}
			if (num != 0)
			{
				if (num > 1)
				{
					Array.Sort(m_Hits, 0, num, RaycastHitComparer.instance);
				}
				int i = 0;
				for (int num2 = num; i < num2; i++)
				{
					RaycastResult item = new RaycastResult
					{
						gameObject = ((Component)((RaycastHit)(ref m_Hits[i])).collider).gameObject,
						module = this,
						distance = ((RaycastHit)(ref m_Hits[i])).distance,
						worldPosition = ((RaycastHit)(ref m_Hits[i])).point,
						worldNormal = ((RaycastHit)(ref m_Hits[i])).normal,
						screenPosition = eventData.position,
						displayIndex = eventDisplayIndex,
						index = resultAppendList.Count,
						sortingLayer = 0,
						sortingOrder = 0
					};
					resultAppendList.Add(item);
				}
			}
		}
	}
	public struct RaycastResult
	{
		private GameObject m_GameObject;

		public BaseRaycaster module;

		public float distance;

		public float index;

		public int depth;

		public int sortingGroupID;

		public int sortingGroupOrder;

		public int sortingLayer;

		public int sortingOrder;

		public Vector3 worldPosition;

		public Vector3 worldNormal;

		public Vector2 screenPosition;

		public int displayIndex;

		public GameObject gameObject
		{
			get
			{
				return m_GameObject;
			}
			set
			{
				m_GameObject = value;
			}
		}

		public bool isValid
		{
			get
			{
				if ((Object)(object)module != (Object)null)
				{
					return (Object)(object)gameObject != (Object)null;
				}
				return false;
			}
		}

		public void Clear()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			gameObject = null;
			module = null;
			distance = 0f;
			index = 0f;
			depth = 0;
			sortingLayer = 0;
			sortingOrder = 0;
			worldNormal = Vector3.up;
			worldPosition = Vector3.zero;
			screenPosition = Vector2.op_Implicit(Vector3.zero);
		}

		public unsafe override string ToString()
		{
			//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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			if (!isValid)
			{
				return "";
			}
			string[] obj = new string[24]
			{
				"Name: ",
				((object)gameObject)?.ToString(),
				"\nmodule: ",
				((object)module)?.ToString(),
				"\ndistance: ",
				distance.ToString(),
				"\nindex: ",
				index.ToString(),
				"\ndepth: ",
				depth.ToString(),
				"\nworldNormal: ",
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null
			};
			Vector3 val = worldNormal;
			obj[11] = ((object)(*(Vector3*)(&val))/*cast due to .constrained prefix*/).ToString();
			obj[12] = "\nworldPosition: ";
			val = worldPosition;
			obj[13] = ((object)(*(Vector3*)(&val))/*cast due to .constrained prefix*/).ToString();
			obj[14] = "\nscreenPosition: ";
			Vector2 val2 = screenPosition;
			obj[15] = ((object)(*(Vector2*)(&val2))/*cast due to .constrained prefix*/).ToString();
			obj[16] = "\nmodule.sortOrderPriority: ";
			obj[17] = module.sortOrderPriority.ToString();
			obj[18] = "\nmodule.renderOrderPriority: ";
			obj[19] = module.renderOrderPriority.ToString();
			obj[20] = "\nsortingLayer: ";
			obj[21] = sortingLayer.ToString();
			obj[22] = "\nsortingOrder: ";
			obj[23] = sortingOrder.ToString();
			return string.Concat(obj);
		}
	}
	public abstract class UIBehaviour : MonoBehaviour
	{
		protected virtual void Awake()
		{
		}

		protected virtual void OnEnable()
		{
		}

		protected virtual void Start()
		{
		}

		protected virtual void OnDisable()
		{
		}

		protected virtual void OnDestroy()
		{
		}

		public virtual bool IsActive()
		{
			return ((Behaviour)this).isActiveAndEnabled;
		}

		protected virtual void OnRectTransformDimensionsChange()
		{
		}

		protected virtual void OnBeforeTransformParentChanged()
		{
		}

		protected virtual void OnTransformParentChanged()
		{
		}

		protected virtual void OnDidApplyAnimationProperties()
		{
		}

		protected virtual void OnCanvasGroupChanged()
		{
		}

		protected virtual void OnCanvasHierarchyChanged()
		{
		}

		public bool IsDestroyed()
		{
			return (Object)(object)this == (Object)null;
		}
	}
}