Decompiled source of StatsPlus v1.1.0

Get the Thunderstore App

Easily install and manage your mods with the Thunderstore App!

Get App

Decompiled source of StatsPlus v1.1.0

StatsMod.dll

Decompiled 2 weeks ago

Download (183.6 KB)

The result has been truncated due to the large size, download it to view full contents!

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using IL.RoR2;
using LeTai.Asset.TranslucentImage;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using Newtonsoft.Json;
using On.RoR2;
using On.RoR2.UI;
using R2API.Networking;
using R2API.Networking.Interfaces;
using RoR2;
using RoR2.ConVar;
using RoR2.Stats;
using RoR2.UI;
using StatsMod.CustomStats;
using TMPro;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace StatsMod
{
	public static class Assets
	{
		public static AssetBundle mainAssetBundle = null;

		internal static string assetBundleName = "statsmodassets";

		internal static string assemblyDir => Path.GetDirectoryName(StatsMod.pluginInfo.Location);

		public static void PopulateAssets()
		{
			mainAssetBundle = AssetBundle.LoadFromFile(Path.Combine(assemblyDir, assetBundleName));
		}
	}
	public class GraphHandler : MonoBehaviour
	{
		public enum MouseActionType
		{
			Move,
			SelectAreaToZoom,
			SelectPoints
		}

		public enum RectangleType
		{
			Free,
			PreserveAspectRatio,
			OriginalAspectRatio
		}

		public enum RectangleSelectionType
		{
			SelectAll,
			SelectUnselect
		}

		public enum RectangleSelectionPhase
		{
			Moving,
			Release
		}

		public enum PointSelectionType
		{
			Select,
			FixZoomPoint
		}

		[Flags]
		public enum UpdateMethod
		{
			UpdatePositionAndScale = 1,
			UpdateOutlines = 2,
			UpdatePointVisuals = 4,
			UpdateContent = 8,
			MouseZoom = 0x10,
			MouseAction = 0x20,
			UpdateGridLines = 0x40,
			All = 0x80
		}

		public bool updateGraph = true;

		private GraphSettings GS;

		[SerializeField]
		private Canvas canvas;

		private RectTransform graph;

		private RectTransform graphContent;

		private Vector2 contentScale = Vector2.zero;

		private List<Vector2> values;

		private List<int> sortedIndices;

		private Vector2Int xAxisRange = new Vector2Int(-1, -1);

		private Vector2Int prevXAxisRange = new Vector2Int(-1, -1);

		public int activePointIndex = -1;

		private Vector2 activePointValue = Vector2.zero;

		private bool pointIsActive = false;

		private List<GameObject> points;

		private List<Image> pointImages;

		private List<RectTransform> pointRects;

		private List<GameObject> pointOutlines;

		private List<RectTransform> pointOutlineRects;

		private List<Image> pointOutlineImages;

		private List<GameObject> lines;

		private List<RectTransform> lineRects;

		private List<Image> lineImages;

		private List<RectTransform> xGridRects;

		private List<Image> xGridImages;

		private List<TextMeshProUGUI> xAxisTexts;

		private List<RectTransform> xAxisTextRects;

		private List<RectTransform> yGridRects;

		private List<Image> yGridImages;

		private List<TextMeshProUGUI> yAxisTexts;

		private List<RectTransform> yAxisTextRects;

		private RectTransform zoomSelectionRectTransform;

		private Image zoomSelectionImage;

		private List<RectTransform> zoomSelectionOutlines;

		private List<Image> zoomSelectionOutlineImages;

		private RectTransform pointSelectionRectTransform;

		private Image pointSelectionImage;

		private List<RectTransform> pointSelectionOutlines;

		private List<Image> pointSelectionOutlineImages;

		private RectTransform maskObj;

		private Image backgroundImage;

		private RectTransform backgroundRect;

		private GameObject pointParent;

		private GameObject lineParent;

		private GameObject gridParent;

		private GameObject outlineParent;

		private List<RectTransform> outlines;

		private List<Image> outlineImages;

		private List<int> lockedHoveredPoints;

		private List<int> lockedPoints;

		private List<int> fixedHoveredPoints;

		public int fixedPointIndex = -1;

		private Vector2 contentOffset = Vector2.zero;

		private Vector2 bottomLeft;

		private Vector2 topRight;

		private Vector2 center;

		public MouseActionType mouseActionType;

		public RectangleType rectangleType;

		public RectangleSelectionType rectangleSelectionType;

		public RectangleSelectionPhase rectangleSelectionPhase;

		public PointSelectionType pointSelectionType;

		private List<int> initialLockedPoints;

		private List<int> recentlyLockedPoints;

		private bool mouseInsideBounds = false;

		private Vector2 mousePos;

		private Vector2 previousMousePos;

		private Vector2 initialMousePos = Vector2.zero;

		private bool initialMouseInsideBounds = false;

		private Vector2 zoomPoint = Vector2.zero;

		private Vector2 absoluteZoomPoint = Vector2.zero;

		public Vector2 targetZoom = new Vector2(1f, 1f);

		private Vector2 zoom = new Vector2(1f, 1f);

		private Vector2 moveOffset;

		public Vector2 targetMoveOffset;

		private Vector2 initialMoveOffset = Vector2.zero;

		private float timeToUpdateMouse = 0f;

		private float timeToUpdateTouch = 0f;

		private float timeToUpdateScroll = 0f;

		private bool error;

		public List<Vector2> Values => values;

		public Vector2Int XAxisRange => xAxisRange;

		public Vector2 ActivePointValue => activePointValue;

		public Vector2 BottomLeft => bottomLeft;

		public Vector2 TopRight => topRight;

		public Vector2 Center => center;

		public void CreatePoint(Vector2 newValue)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			CreatePointInternal(newValue);
		}

		public void ChangePoint(int indexToChange, Vector2 newValue)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			ChangePointInternal(indexToChange, newValue);
		}

		public void SetCornerValues(Vector2 newBottomLeft, Vector2 newTopRight)
		{
			//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)
			SetCornerValuesInternal(newBottomLeft, newTopRight);
		}

		public void UpdateGraph()
		{
			UpdateGraphInternal(UpdateMethod.All);
		}

		public void PlotStat(string statName, int index)
		{
			//IL_0071: 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_0115: Unknown result type (might be due to invalid IL or missing references)
			ResetGraph();
			UpdateGraph();
			List<object> statSeries = RecordHandler.independentDatabase[index].GetStatSeries("timestamps");
			float num = -5f;
			float num2 = 5f;
			List<object> statSeries2 = RecordHandler.independentDatabase[index].GetStatSeries(statName);
			for (int i = 0; i < statSeries.Count; i++)
			{
				float num3 = Convert.ToSingle(statSeries[i]);
				float num4 = Convert.ToSingle(PlayerStatsDatabase.Numberise(statSeries2[i]));
				CreatePoint(new Vector2(num3, num4));
				if (num4 < num)
				{
					num = num4;
				}
				else if (num4 > num2)
				{
					num2 = num4;
				}
			}
			float num5 = Convert.ToSingle(statSeries[statSeries.Count - 1]) * 0.05f;
			float num6 = math.max(math.abs(num), math.abs(num2)) * 0.05f;
			SetCornerValues(new Vector2(0f - num5, num - num6), new Vector2(Convert.ToSingle(statSeries[statSeries.Count - 1]) + num5, num2 + num6));
			UpdateGraph();
		}

		private void ResetGraph()
		{
			Object.Destroy((Object)(object)((Component)maskObj).gameObject);
			Object.Destroy((Object)(object)outlineParent.gameObject);
			AwakeWOHook();
			Start();
		}

		private void Awake()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			ResolutionConVar.SetString += new hook_SetString(ResizeGraph);
			AwakeWOHook();
		}

		private void AwakeWOHook()
		{
			values = new List<Vector2>();
			sortedIndices = new List<int>();
			points = new List<GameObject>();
			pointRects = new List<RectTransform>();
			pointImages = new List<Image>();
			pointOutlines = new List<GameObject>();
			pointOutlineRects = new List<RectTransform>();
			pointOutlineImages = new List<Image>();
			lines = new List<GameObject>();
			lineRects = new List<RectTransform>();
			lineImages = new List<Image>();
			xGridRects = new List<RectTransform>();
			xGridImages = new List<Image>();
			yGridRects = new List<RectTransform>();
			yGridImages = new List<Image>();
			xAxisTexts = new List<TextMeshProUGUI>();
			yAxisTexts = new List<TextMeshProUGUI>();
			xAxisTextRects = new List<RectTransform>();
			yAxisTextRects = new List<RectTransform>();
			zoomSelectionOutlines = new List<RectTransform>();
			zoomSelectionOutlineImages = new List<Image>();
			pointSelectionOutlines = new List<RectTransform>();
			pointSelectionOutlineImages = new List<Image>();
			outlines = new List<RectTransform>();
			outlineImages = new List<Image>();
			lockedHoveredPoints = new List<int>();
			lockedPoints = new List<int>();
			initialLockedPoints = new List<int>();
			recentlyLockedPoints = new List<int>();
			fixedHoveredPoints = new List<int>();
		}

		private void ResizeGraph(orig_SetString orig, BaseConVar self, string newValue)
		{
			//IL_004d: 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)
			orig.Invoke(self, newValue);
			if ((Object)(object)graph != (Object)null)
			{
				string[] array = newValue.Split('x');
				int num = int.Parse(array[0]);
				int num2 = int.Parse(array[1]);
				GS.GraphSize = new Vector2(0.5208f * (float)num, 0.7037f * (float)num2);
				((Transform)graph).localPosition = Vector2.op_Implicit(new Vector2(0.1302f * (float)num, 0.0212f * (float)num2));
				UpdateOutlines();
			}
		}

		private void OnDestroy()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			ResolutionConVar.SetString -= new hook_SetString(ResizeGraph);
		}

		private void Start()
		{
			if (!CheckForErrors())
			{
				GS = ((Component)this).GetComponent<GraphSettings>();
				PrepareGraph();
			}
		}

		private void Update()
		{
			//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_00b6: 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_00c2: 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_00de: 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 (Input.GetKey((KeyCode)304))
			{
				mouseActionType = MouseActionType.SelectAreaToZoom;
			}
			else if (Input.GetKey((KeyCode)306))
			{
				mouseActionType = MouseActionType.SelectPoints;
			}
			else
			{
				mouseActionType = MouseActionType.Move;
			}
			if (!error)
			{
				CheckIfUpdateGraph();
				if (updateGraph)
				{
					UpdateGraphInternal(UpdateMethod.All);
				}
				if (lockedHoveredPoints.Count > 0)
				{
					UpdatePoints();
				}
				if (fixedHoveredPoints.Count > 0)
				{
					UpdatePointOutlines();
				}
				zoom = Vector2.Lerp(zoom, targetZoom, GS.SmoothZoomSpeed * Time.deltaTime);
				moveOffset = Vector2.Lerp(moveOffset, targetMoveOffset, GS.SmoothMoveSpeed * Time.deltaTime);
			}
		}

		private void PrepareGraph()
		{
			//IL_0018: 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_00b9: 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_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)
			//IL_00f3: 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_0107: 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_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: 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_01e3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)canvas == (Object)null)
			{
				canvas = new GameObject("GraphCanvas").AddComponent<Canvas>();
				((Component)canvas).gameObject.SetActive(false);
			}
			canvas.renderMode = (RenderMode)0;
			((Component)canvas).gameObject.AddComponent<GraphicRaycaster>();
			if ((Object)(object)((Component)this).GetComponent<RectTransform>() == (Object)null)
			{
				((Component)this).gameObject.AddComponent<RectTransform>();
			}
			graph = ((Component)this).gameObject.GetComponent<RectTransform>();
			((Transform)graph).SetParent(((Component)canvas).transform);
			graph.anchoredPosition = Vector2.zero;
			graph.sizeDelta = GS.GraphSize;
			RectTransform obj = graph;
			Vector3 localPosition = (((Transform)graph).localPosition = Vector2.op_Implicit(new Vector2(0.1302f * (float)Screen.width, 0.0212f * (float)Screen.height)));
			((Transform)obj).localPosition = localPosition;
			maskObj = new GameObject("MaskObj").AddComponent<RectTransform>();
			((Transform)maskObj).SetParent((Transform)(object)graph);
			maskObj.anchoredPosition = Vector2.zero;
			((Component)maskObj).gameObject.AddComponent<Image>();
			Mask val2 = ((Component)maskObj).gameObject.AddComponent<Mask>();
			val2.showMaskGraphic = false;
			backgroundRect = new GameObject("Background").AddComponent<RectTransform>();
			((Transform)backgroundRect).SetParent((Transform)(object)maskObj);
			backgroundRect.anchoredPosition = Vector2.zero;
			backgroundImage = ((Component)backgroundRect).gameObject.AddComponent<Image>();
			graphContent = new GameObject("GraphContent").AddComponent<RectTransform>();
			((Transform)graphContent).SetParent(((Component)backgroundRect).transform);
			graphContent.sizeDelta = Vector2.zero;
			gridParent = CreateParent("GridParent");
			lineParent = CreateParent("LineParent");
			pointParent = CreateParent("PointParent");
			outlineParent = CreateParent("OutlineParent");
			CreateOutlines();
			outlineParent.transform.SetParent((Transform)(object)graph);
			fixedPointIndex = -1;
			CreateselectionTypes();
			UpdateGraphInternal(UpdateMethod.All);
		}

		private GameObject CreateParent(string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_004b: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent((Transform)(object)((name == "OutlineParent") ? graph : graphContent));
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)val2).raycastTarget = false;
			val.GetComponent<RectTransform>().anchoredPosition = Vector2.zero;
			return val;
		}

		private void CreateOutlines()
		{
			//IL_000b: 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)
			for (int i = 0; i < 4; i++)
			{
				Image val = new GameObject("Outline").AddComponent<Image>();
				RectTransform component = ((Component)val).GetComponent<RectTransform>();
				((Transform)component).SetParent(outlineParent.transform);
				((Graphic)val).color = GS.OutlineColor;
				((Graphic)val).raycastTarget = false;
				outlines.Add(component);
				outlineImages.Add(val);
			}
		}

		private void CreatePointInternal(Vector2 value)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_005a: 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_00b3: 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)
			//IL_0164: Expected O, but got Unknown
			//IL_0276: 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_01c0: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: 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_0237: Unknown result type (might be due to invalid IL or missing references)
			int i = points.Count;
			GameObject val = CreatePointOutline(i);
			GameObject val2 = new GameObject("Point" + i);
			points.Add(val2);
			values.Add(value);
			val2.transform.SetParent(val.transform);
			Image val3 = val2.AddComponent<Image>();
			((Graphic)val3).color = GS.PointColor;
			pointImages.Add(val3);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.sizeDelta = Vector2.one * GS.PointRadius;
			pointRects.Add(component);
			val3.sprite = GS.PointSprite;
			EventTrigger val4 = val2.AddComponent<EventTrigger>();
			var array = new[]
			{
				new
				{
					Type = (EventTriggerType)0,
					Callback = (Action)delegate
					{
						MouseTrigger(i, enter: true);
					}
				},
				new
				{
					Type = (EventTriggerType)1,
					Callback = (Action)delegate
					{
						MouseTrigger(i, enter: false);
					}
				},
				new
				{
					Type = (EventTriggerType)4,
					Callback = (Action)delegate
					{
						PointClicked(i);
					}
				}
			};
			var array2 = array;
			foreach (var eventType in array2)
			{
				Entry val5 = new Entry
				{
					eventID = eventType.Type
				};
				((UnityEvent<BaseEventData>)(object)val5.callback).AddListener((UnityAction<BaseEventData>)delegate
				{
					eventType.Callback();
				});
				val4.triggers.Add(val5);
			}
			if (points.Count > 1)
			{
				GameObject val6 = new GameObject("Line");
				val6.transform.SetParent(lineParent.transform);
				lineImages.Add(val6.AddComponent<Image>());
				((Graphic)val6.GetComponent<Image>()).color = GS.LineColor;
				lineRects.Add(val6.GetComponent<RectTransform>());
				lines.Add(val6);
				if (value.x < bottomLeft.x || value.x > topRight.x)
				{
					val6.SetActive(false);
				}
			}
			lockedHoveredPoints.Add(i);
			SortIndices();
			if (value.x < bottomLeft.x || value.x > topRight.x)
			{
				val.SetActive(false);
			}
		}

		private void ChangePointInternal(int index, Vector2 newValue)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			values[index] = newValue;
			SortIndices();
		}

		private void SortIndices()
		{
			sortedIndices = (from item in values.Select((Vector2 vector, int index) => new { vector, index })
				orderby item.vector.x, item.vector.y
				select item.index).ToList();
		}

		private GameObject CreatePointOutline(int i)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_005e: 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)
			GameObject val = new GameObject("PointOutline" + i);
			pointOutlines.Add(val);
			if ((Object)(object)pointParent != (Object)null)
			{
				val.transform.SetParent(pointParent.transform);
			}
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = GS.PointColor;
			pointOutlineImages.Add(val2);
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(GS.PointRadius, GS.PointRadius);
			pointOutlineRects.Add(component);
			Sprite pointSprite = GS.PointSprite;
			val2.sprite = pointSprite;
			return val;
		}

		private void CreateGridLines(bool createX)
		{
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_012c: 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)
			if (createX)
			{
				GameObject val = new GameObject("xGrid" + xGridRects.Count);
				val.transform.SetParent(gridParent.transform);
				Image val2 = val.AddComponent<Image>();
				((Graphic)val2).raycastTarget = false;
				xGridRects.Add(val.GetComponent<RectTransform>());
				xGridImages.Add(val2);
				if (xGridRects.Count > 1)
				{
					TextMeshProUGUI val3 = new GameObject("xText" + xGridRects.Count).AddComponent<TextMeshProUGUI>();
					RectTransform component = ((Component)val3).gameObject.GetComponent<RectTransform>();
					((Transform)component).SetParent((Transform)(object)val.GetComponent<RectTransform>());
					((TMP_Text)val3).font = GS.GridTextFont;
					((TMP_Text)val3).fontStyle = (FontStyles)1;
					((TMP_Text)val3).fontStyle = (FontStyles)1;
					((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
					((TMP_Text)val3).verticalAlignment = (VerticalAlignmentOptions)512;
					((Graphic)val3).color = GS.XAxisTextColor;
					((TMP_Text)val3).enableAutoSizing = true;
					component.sizeDelta = Vector2.one * GS.XAxisTextSize;
					((Graphic)val3).raycastTarget = false;
					xAxisTexts.Add(val3);
					xAxisTextRects.Add(component);
				}
			}
			else
			{
				GameObject val4 = new GameObject("yGrid" + yGridRects.Count);
				val4.transform.SetParent(gridParent.transform);
				Image val5 = val4.AddComponent<Image>();
				((Graphic)val5).raycastTarget = false;
				yGridRects.Add(val4.GetComponent<RectTransform>());
				yGridImages.Add(val5);
				if (yGridRects.Count > 1)
				{
					TextMeshProUGUI val6 = new GameObject("yText" + yGridRects.Count).AddComponent<TextMeshProUGUI>();
					RectTransform component2 = ((Component)val6).gameObject.GetComponent<RectTransform>();
					((Transform)component2).SetParent((Transform)(object)val4.GetComponent<RectTransform>());
					((TMP_Text)val6).font = GS.GridTextFont;
					((TMP_Text)val6).fontStyle = (FontStyles)1;
					((TMP_Text)val6).alignment = (TextAlignmentOptions)514;
					((TMP_Text)val6).verticalAlignment = (VerticalAlignmentOptions)512;
					((Graphic)val6).color = GS.YAxisTextColor;
					((TMP_Text)val6).enableAutoSizing = true;
					component2.sizeDelta = Vector2.one * GS.YAxisTextSize;
					((Graphic)val6).raycastTarget = false;
					yAxisTexts.Add(val6);
					yAxisTextRects.Add(component2);
				}
			}
		}

		private void CreateselectionTypes()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002e: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SelectionParent");
			val.transform.SetParent((Transform)(object)graphContent);
			val.AddComponent<RectTransform>().anchoredPosition = new Vector2(0f, 0f);
			zoomSelectionImage = new GameObject("ZoomSelection").AddComponent<Image>();
			zoomSelectionRectTransform = ((Component)zoomSelectionImage).GetComponent<RectTransform>();
			((Transform)zoomSelectionRectTransform).SetParent(val.transform);
			for (int i = 0; i < 4; i++)
			{
				Image val2 = new GameObject("Outline").AddComponent<Image>();
				RectTransform component = ((Component)val2).GetComponent<RectTransform>();
				((Transform)component).SetParent((Transform)(object)zoomSelectionRectTransform);
				zoomSelectionOutlineImages.Add(val2);
				zoomSelectionOutlines.Add(component);
			}
			((Component)zoomSelectionRectTransform).gameObject.SetActive(false);
			pointSelectionImage = new GameObject("PointSelection").AddComponent<Image>();
			pointSelectionRectTransform = ((Component)pointSelectionImage).GetComponent<RectTransform>();
			((Transform)pointSelectionRectTransform).SetParent(val.transform);
			for (int j = 0; j < 4; j++)
			{
				Image val3 = new GameObject("Outline").AddComponent<Image>();
				RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
				((Transform)component2).SetParent((Transform)(object)pointSelectionRectTransform);
				pointSelectionOutlineImages.Add(val3);
				pointSelectionOutlines.Add(component2);
			}
			((Component)pointSelectionRectTransform).gameObject.SetActive(false);
		}

		private void CheckIfUpdateGraph()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			CalculateMousePosition();
			if (mouseInsideBounds)
			{
				if (Input.GetMouseButtonDown(0) || Input.GetMouseButton(0) || Input.GetMouseButtonUp(0))
				{
					timeToUpdateMouse = GS.updatePeriod;
				}
				if (Input.touchCount > 0)
				{
					timeToUpdateTouch = GS.updatePeriod;
				}
				if (Input.mouseScrollDelta.y != 0f)
				{
					timeToUpdateScroll = GS.updatePeriod;
				}
			}
			if (timeToUpdateMouse > 0f)
			{
				UpdateGraphInternal(UpdateMethod.UpdatePositionAndScale | UpdateMethod.UpdatePointVisuals | UpdateMethod.UpdateContent | UpdateMethod.MouseAction | UpdateMethod.UpdateGridLines);
			}
			if (timeToUpdateTouch > 0f)
			{
				UpdateGraphInternal(UpdateMethod.UpdatePositionAndScale | UpdateMethod.UpdatePointVisuals | UpdateMethod.UpdateContent | UpdateMethod.MouseZoom | UpdateMethod.MouseAction | UpdateMethod.UpdateGridLines);
			}
			if (timeToUpdateScroll > 0f)
			{
				UpdateGraphInternal(UpdateMethod.UpdatePositionAndScale | UpdateMethod.UpdatePointVisuals | UpdateMethod.UpdateContent | UpdateMethod.MouseZoom | UpdateMethod.UpdateGridLines);
			}
			timeToUpdateMouse -= Time.deltaTime;
			timeToUpdateTouch -= Time.deltaTime;
			timeToUpdateScroll -= Time.deltaTime;
		}

		public void UpdateGraphInternal(UpdateMethod methodsToUpdate)
		{
			if (methodsToUpdate.HasFlag(UpdateMethod.UpdatePositionAndScale) || methodsToUpdate.HasFlag(UpdateMethod.All))
			{
				UpdatePositionAndScale();
			}
			CalculateCornerValues();
			if (methodsToUpdate.HasFlag(UpdateMethod.UpdateOutlines) || methodsToUpdate.HasFlag(UpdateMethod.All))
			{
				UpdateOutlines();
			}
			if (methodsToUpdate.HasFlag(UpdateMethod.UpdateContent) || methodsToUpdate.HasFlag(UpdateMethod.All))
			{
				HandleActiveObjects();
			}
			if (methodsToUpdate.HasFlag(UpdateMethod.UpdatePointVisuals) || methodsToUpdate.HasFlag(UpdateMethod.All))
			{
				UpdatePointVisuals();
			}
			if (methodsToUpdate.HasFlag(UpdateMethod.UpdateContent) || methodsToUpdate.HasFlag(UpdateMethod.All))
			{
				UpdateContent();
			}
			CalculateMousePosition();
			if (methodsToUpdate.HasFlag(UpdateMethod.MouseZoom) || methodsToUpdate.HasFlag(UpdateMethod.All))
			{
				MouseZoom();
			}
			if (methodsToUpdate.HasFlag(UpdateMethod.MouseAction) || methodsToUpdate.HasFlag(UpdateMethod.All))
			{
				MouseAction();
			}
			if (methodsToUpdate.HasFlag(UpdateMethod.UpdateGridLines) || methodsToUpdate.HasFlag(UpdateMethod.All))
			{
				UpdateGridLines();
			}
		}

		private void UpdatePositionAndScale()
		{
			//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_0013: 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_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)
			//IL_003c: 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_004c: 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_005c: 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_007c: 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_009e: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			contentScale = GS.GraphScale * zoom;
			maskObj.sizeDelta = GS.GraphSize;
			contentOffset = absoluteZoomPoint - zoomPoint * contentScale - moveOffset;
			graphContent.anchoredPosition = -GS.GraphSize / 2f + contentOffset;
			graph.sizeDelta = GS.GraphSize;
			backgroundRect.sizeDelta = GS.GraphSize;
			((Graphic)backgroundImage).color = GS.BackgroundColor;
		}

		private void UpdateOutlines()
		{
			//IL_00bb: 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_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_010d: 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_0075: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < outlines.Count; i++)
			{
				if (i % 2 == 0)
				{
					outlines[i].sizeDelta = new Vector2(GS.OutlineWidth, GS.GraphSize.y + GS.OutlineWidth * 2f);
					outlines[i].anchoredPosition = new Vector2((float)((i != 0) ? 1 : (-1)) * (GS.GraphSize.x + GS.OutlineWidth) / 2f, 0f);
				}
				else
				{
					outlines[i].sizeDelta = new Vector2(GS.GraphSize.x + GS.OutlineWidth * 2f, GS.OutlineWidth);
					outlines[i].anchoredPosition = new Vector2(0f, (float)((i != 1) ? 1 : (-1)) * (GS.GraphSize.y + GS.OutlineWidth) / 2f);
				}
				((Graphic)outlineImages[i]).color = GS.OutlineColor;
			}
		}

		private void CalculateCornerValues()
		{
			//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_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_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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_008a: 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: 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_00a6: 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_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)
			topRight = new Vector2(Mathf.Clamp(topRight.x, bottomLeft.x, float.PositiveInfinity), Mathf.Clamp(topRight.y, bottomLeft.y, float.PositiveInfinity));
			bottomLeft = -contentOffset / contentScale;
			topRight = bottomLeft + GS.GraphSize / contentScale;
			center = (topRight - bottomLeft) / 2f + bottomLeft;
		}

		private void UpdateContent()
		{
			//IL_0090: 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_00e0: 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_010c: 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_0102: 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_0149: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: 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_01dc: 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_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_01f2: 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_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)
			if (((Vector2Int)(ref xAxisRange)).x == -1 || ((Vector2Int)(ref xAxisRange)).y == -1)
			{
				return;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(bottomLeft.y, topRight.y);
			for (int i = ((Vector2Int)(ref xAxisRange)).x - 1; i <= ((Vector2Int)(ref xAxisRange)).y + 1; i++)
			{
				if (i < 0 || i > sortedIndices.Count - 1)
				{
					continue;
				}
				int num = sortedIndices[i];
				float y = values[num].y;
				float y2 = values[Mathf.Clamp(num - 1, 0, values.Count - 1)].y;
				float y3 = values[Mathf.Clamp(num + 1, 0, values.Count - 1)].y;
				if ((!(y < val.x) || !(y2 < val.x) || !(y3 < val.x)) && (!(y > val.y) || !(y2 > val.y) || !(y3 > val.y)))
				{
					UpdateAnchoredPosition(pointOutlineRects[num], CalculatePosition(i));
					if (lines.Count > 0 && num < lines.Count)
					{
						Vector2 val2 = CalculatePosition(num);
						Vector2 val3 = CalculatePosition(num + 1);
						float num2 = Vector2.Distance(val2, val3);
						UpdateAnchoredPosition(lineRects[num], (val3 + val2) / 2f);
						UpdateSizeDelta(lineRects[num], new Vector2(num2, GS.LineWidth));
						Vector2 val4 = val3 - val2;
						float num3 = Mathf.Atan2(val4.y, val4.x) * 57.29578f;
						((Transform)lineRects[num]).rotation = Quaternion.AngleAxis(num3, Vector3.forward);
						((Graphic)lineImages[num]).color = GS.LineColor;
					}
				}
			}
		}

		private void HandleActiveObjects()
		{
			//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_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			if (((Vector2Int)(ref prevXAxisRange)).x < ((Vector2Int)(ref xAxisRange)).x)
			{
				for (int i = ((Vector2Int)(ref prevXAxisRange)).x - 1; i < ((Vector2Int)(ref xAxisRange)).x - 1; i++)
				{
					if (i >= 0)
					{
						pointOutlines[sortedIndices[i]].SetActive(false);
						if (i < lines.Count)
						{
							lines[sortedIndices[i]].SetActive(false);
						}
					}
				}
			}
			else if (((Vector2Int)(ref prevXAxisRange)).x > ((Vector2Int)(ref xAxisRange)).x && ((Vector2Int)(ref xAxisRange)).x >= 0)
			{
				for (int j = ((Vector2Int)(ref xAxisRange)).x - 1; j < ((Vector2Int)(ref prevXAxisRange)).x; j++)
				{
					if (j >= 0)
					{
						pointOutlines[sortedIndices[j]].SetActive(true);
						if (j < lines.Count)
						{
							lines[sortedIndices[j]].SetActive(true);
						}
					}
				}
			}
			if (((Vector2Int)(ref prevXAxisRange)).y > ((Vector2Int)(ref xAxisRange)).y)
			{
				for (int k = ((Vector2Int)(ref xAxisRange)).y + 2; k <= ((Vector2Int)(ref prevXAxisRange)).y + 2; k++)
				{
					if (k <= pointOutlines.Count - 1 && k >= 0)
					{
						pointOutlines[sortedIndices[k]].SetActive(false);
						if (k < lines.Count)
						{
							lines[sortedIndices[k]].SetActive(false);
						}
					}
				}
			}
			else if (((Vector2Int)(ref xAxisRange)).y > ((Vector2Int)(ref prevXAxisRange)).y)
			{
				for (int l = ((Vector2Int)(ref prevXAxisRange)).y + 2; l <= ((Vector2Int)(ref xAxisRange)).y + 1; l++)
				{
					if (l <= pointOutlines.Count - 1 && l >= 0)
					{
						pointOutlines[sortedIndices[l]].SetActive(true);
						if (l < lines.Count)
						{
							lines[sortedIndices[l]].SetActive(true);
						}
					}
				}
			}
			prevXAxisRange = xAxisRange;
			xAxisRange = new Vector2Int(MinMaxBinarySearch(findLeft: true), MinMaxBinarySearch(findLeft: false));
		}

		private Vector2 CalculatePosition(int i)
		{
			//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_0013: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			return values[i] * contentScale;
		}

		private void MouseTrigger(int pointIndex, bool enter)
		{
			//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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			fixedHoveredPoints.Add(pointIndex);
			fixedHoveredPoints = fixedHoveredPoints.Distinct().ToList();
			if (enter)
			{
				activePointIndex = pointIndex;
				activePointValue = values[pointIndex];
				pointIsActive = enter;
				if (pointSelectionType == PointSelectionType.Select)
				{
					lockedHoveredPoints.Add(pointIndex);
					lockedHoveredPoints = lockedHoveredPoints.Distinct().ToList();
				}
			}
			else if ((!lockedPoints.Contains(activePointIndex) || pointSelectionType != 0) && (fixedPointIndex != activePointIndex || pointSelectionType != PointSelectionType.FixZoomPoint))
			{
				activePointIndex = pointIndex;
				activePointValue = values[pointIndex];
				pointIsActive = enter;
			}
		}

		private void PointClicked(int pointIndex)
		{
			//IL_002b: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			if (pointSelectionType == PointSelectionType.FixZoomPoint)
			{
				if (fixedPointIndex != -1)
				{
					ChangeZoomPoint(values[pointIndex]);
					fixedHoveredPoints.Add(fixedPointIndex);
				}
				fixedHoveredPoints = fixedHoveredPoints.Distinct().ToList();
				fixedPointIndex = ((fixedPointIndex == pointIndex) ? (-1) : pointIndex);
				ChangeZoomPoint((fixedPointIndex == -1) ? center : values[pointIndex]);
			}
			else if (lockedPoints.Contains(pointIndex))
			{
				lockedPoints.Remove(pointIndex);
			}
			else
			{
				lockedPoints.Add(pointIndex);
			}
		}

		private void UpdatePointVisuals()
		{
			if (((Vector2Int)(ref xAxisRange)).x == -1 || ((Vector2Int)(ref xAxisRange)).y == -1)
			{
				return;
			}
			for (int i = ((Vector2Int)(ref xAxisRange)).x; i <= ((Vector2Int)(ref xAxisRange)).y; i++)
			{
				if (activePointIndex != sortedIndices[i])
				{
					lockedHoveredPoints.Add(sortedIndices[i]);
					fixedHoveredPoints.Add(sortedIndices[i]);
				}
			}
		}

		private void UpdatePoints()
		{
			//IL_0040: 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_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_0103: 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_0110: 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_0142: 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_0163: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0088: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//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_0188: 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_01c4: 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_0220: 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)
			for (int i = 0; i < lockedHoveredPoints.Count; i++)
			{
				int num = lockedHoveredPoints[i];
				bool flag = activePointIndex == num && pointIsActive;
				Vector2 val;
				Color val2;
				float num2;
				if (lockedPoints.Contains(num))
				{
					val = Vector2.one * GS.PointLockedRadius;
					val2 = GS.PointLockedColor;
					num2 = GS.PointLockedSpeed;
				}
				else if (flag && pointSelectionType == PointSelectionType.Select)
				{
					val = Vector2.one * GS.PointHoverRadius;
					val2 = GS.PointHoverColor;
					num2 = GS.PointHoverSpeed;
				}
				else
				{
					val = Vector2.one * GS.PointRadius;
					val2 = GS.PointColor;
					num2 = GS.PointHoverSpeed;
				}
				pointRects[num].sizeDelta = Vector2.Lerp(pointRects[num].sizeDelta, val, Time.deltaTime * num2);
				((Graphic)pointImages[num]).color = Color.Lerp(((Graphic)pointImages[num]).color, val2, Time.deltaTime * num2);
				if (!flag && Vector2.Distance(pointRects[num].sizeDelta, val) < 0.5f && Vector4.Distance(Color.op_Implicit(((Graphic)pointImages[num]).color), Color.op_Implicit(val2)) < 0.5f)
				{
					((Graphic)pointImages[num]).color = val2;
					pointRects[num].sizeDelta = val;
					lockedHoveredPoints.RemoveAt(i);
				}
				else if (!fixedHoveredPoints.Contains(num) && num != fixedPointIndex)
				{
					pointOutlineRects[num].sizeDelta = pointRects[num].sizeDelta + Vector2.one * GS.UnfixedPointOutlineWidth;
				}
			}
			UpdatePointOutlines();
		}

		private void UpdatePointOutlines()
		{
			//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_00fe: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: 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_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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: 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_017f: 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_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			for (int i = 0; i < fixedHoveredPoints.Count; i++)
			{
				int num = fixedHoveredPoints[i];
				bool flag = activePointIndex == num && pointIsActive;
				float num2;
				Color val2;
				if (fixedPointIndex == num)
				{
					((Vector2)(ref val))..ctor(GS.FixedPointOutlineWidth, GS.FixedPointOutlineWidth);
					val2 = GS.FixedPointOutlineColor;
					num2 = GS.FixedPointOutlineSpeed;
				}
				else if (flag && pointSelectionType == PointSelectionType.FixZoomPoint)
				{
					((Vector2)(ref val))..ctor(GS.UnfixedPointOutlineHoverWidth, GS.UnfixedPointOutlineHoverWidth);
					val2 = GS.UnfixedPointOutlineHoverColor;
					num2 = GS.UnfixedPointOutlineHoverSpeed;
				}
				else
				{
					((Vector2)(ref val))..ctor(GS.UnfixedPointOutlineWidth, GS.UnfixedPointOutlineWidth);
					val2 = GS.UnfixedPointOutlineColor;
					num2 = GS.UnfixedPointOutlineHoverSpeed;
				}
				val += pointRects[num].sizeDelta;
				RectTransform val3 = pointOutlineRects[num];
				if (pointSelectionType == PointSelectionType.FixZoomPoint)
				{
					val3.sizeDelta = Vector2.Lerp(val3.sizeDelta, val, Time.deltaTime * num2);
				}
				else
				{
					val3.sizeDelta = val;
				}
				Image val4 = pointOutlineImages[num];
				val2 = Color.Lerp(((Graphic)val4).color, val2, Time.deltaTime * num2);
				((Graphic)val4).color = val2;
				if (!flag && Vector2.Distance(val3.sizeDelta, val) < 0.5f)
				{
					fixedHoveredPoints.RemoveAt(i);
				}
			}
		}

		private void UpdateGridLines()
		{
			//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_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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0075: 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_01cf: 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_01f2: 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_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: 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_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: 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_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: 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_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: 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_0513: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0523: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: 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_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0633: 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_05eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0607: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = CalculateGridSpacing();
			Vector2 val2 = new Vector2(Mathf.Ceil(bottomLeft.x * val.x) / val.x, Mathf.Ceil(bottomLeft.y * val.y) / val.y) * contentScale;
			int2 val3 = default(int2);
			((int2)(ref val3))..ctor(-1, -1);
			int num = Mathf.CeilToInt((topRight.y - bottomLeft.y) * val.y) + 1;
			int num2 = Mathf.CeilToInt((topRight.x - bottomLeft.x) * val.x) + 1;
			while (xGridRects.Count <= num2)
			{
				CreateGridLines(createX: true);
			}
			while (yGridRects.Count <= num)
			{
				CreateGridLines(createX: false);
			}
			for (int i = 0; i < num2; i++)
			{
				RectTransform val4 = xGridRects[i];
				Image val5 = xGridImages[i];
				if (!((Component)val4).gameObject.activeSelf)
				{
					((Component)val4).gameObject.SetActive(true);
				}
				if (i == 0)
				{
					UpdateSizeDelta(val4, new Vector2(GS.XAxisWidth, GS.GraphSize.y * 2f));
					((Graphic)val5).color = GS.XAxisColor;
					UpdateAnchoredPosition(val4, new Vector2(0f, center.y * contentScale.y));
					continue;
				}
				UpdateSizeDelta(val4, new Vector2(GS.XGridWidth, GS.GraphSize.y * 2f));
				((Graphic)val5).color = GS.XGridColor;
				if (Mathf.Round(val2.x + (float)(i + val3.x) / val.x * contentScale.x) == 0f)
				{
					val3.x = 0;
				}
				UpdateAnchoredPosition(val4, new Vector2(val2.x + (float)(i + val3.x) / val.x * contentScale.x, center.y * contentScale.y));
				UpdateSizeDelta(xAxisTextRects[i - 1], new Vector2(1f / val.x * contentScale.x, GS.XAxisTextSize));
				UpdateAnchoredPosition(xAxisTextRects[i - 1], new Vector2(0f, (0f - center.y) * contentScale.y + GS.XAxisTextOffset));
				((TMP_Text)xAxisTexts[i - 1]).text = ((Mathf.Floor(1f / val.x) > 0f) ? Mathf.RoundToInt(val2.x / contentScale.x + (float)(i + val3.x) / val.x).ToString() : (val2.x / contentScale.x + (float)(i + val3.x) / val.x).ToString("R"));
			}
			for (int j = 0; j < num; j++)
			{
				RectTransform val6 = yGridRects[j];
				Image val7 = yGridImages[j];
				if (!((Component)val6).gameObject.activeSelf)
				{
					((Component)val6).gameObject.SetActive(true);
				}
				if (j == 0)
				{
					UpdateSizeDelta(val6, new Vector2(GS.GraphSize.x * 2f, GS.YAxisWidth));
					((Graphic)val7).color = GS.YAxisColor;
					UpdateAnchoredPosition(val6, new Vector2(center.x * contentScale.x, 0f));
					continue;
				}
				UpdateSizeDelta(val6, new Vector2(GS.GraphSize.x * 2f, GS.YGridWidth));
				((Graphic)val7).color = GS.YGridColor;
				if (Mathf.Round(val2.y + (float)(j + val3.y) / val.y * contentScale.y) == 0f)
				{
					val3.y = 0;
				}
				UpdateAnchoredPosition(val6, new Vector2(center.x * contentScale.x, val2.y + (float)(j + val3.y) / val.y * contentScale.y));
				UpdateSizeDelta(yAxisTextRects[j - 1], new Vector2(1f / val.x * contentScale.x, GS.XAxisTextSize));
				UpdateAnchoredPosition(yAxisTextRects[j - 1], new Vector2((0f - center.x) * contentScale.x + GS.YAxisTextOffset, 0f));
				((TMP_Text)yAxisTexts[j - 1]).text = ((Mathf.Floor(1f / val.y) > 0f) ? Mathf.RoundToInt(val2.y / contentScale.y + (float)(j + val3.y) / val.y).ToString() : (val2.y / contentScale.y + (float)(j + val3.y) / val.y).ToString("R"));
			}
			for (int k = num2; k < xGridRects.Count; k++)
			{
				if (((Component)xGridRects[k]).gameObject.activeSelf)
				{
					((Component)xGridRects[k]).gameObject.SetActive(false);
				}
			}
			for (int l = num; l < yGridRects.Count; l++)
			{
				if (((Component)yGridRects[l]).gameObject.activeSelf)
				{
					((Component)yGridRects[l]).gameObject.SetActive(false);
				}
			}
		}

		private Vector2 CalculateGridSpacing()
		{
			//IL_0053: 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_0068: 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)
			int num = Mathf.FloorToInt(Mathf.Log(zoom.x, 2f));
			int num2 = Mathf.FloorToInt(Mathf.Log(zoom.y, 2f));
			float num3 = Mathf.Pow(2f, (float)num);
			float num4 = Mathf.Pow(2f, (float)num2);
			return new Vector2(num3, num4) * GS.GridSpacing;
		}

		private void SetCornerValuesInternal(Vector2 newBottomLeft, Vector2 newTopRight)
		{
			//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_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_0013: 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_001a: 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_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_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_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_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_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_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_0071: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = (newTopRight - newBottomLeft) / 2f + newBottomLeft;
			targetMoveOffset = (val - center) * contentScale + moveOffset;
			ChangeZoomPoint(val);
			targetZoom = GS.GraphSize / GS.GraphScale / (newTopRight - newBottomLeft);
		}

		private void CalculateMousePosition()
		{
			//IL_0002: 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_0016: 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_003b: 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)
			//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)
			mousePos = (new Vector2(Input.mousePosition.x, Input.mousePosition.y) - new Vector2(((Component)graphContent).transform.position.x, ((Component)graphContent).transform.position.y)) / contentScale;
			mouseInsideBounds = mousePos.x > bottomLeft.x && mousePos.y > bottomLeft.y && mousePos.x < topRight.x && mousePos.y < topRight.y;
			mousePos = new Vector2(Mathf.Clamp(mousePos.x, bottomLeft.x, topRight.x), Mathf.Clamp(mousePos.y, bottomLeft.y, topRight.y));
		}

		private void MouseZoom()
		{
			//IL_0010: 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_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_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_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_0036: Unknown result type (might be due to invalid IL or missing references)
			if (mouseInsideBounds && Input.mouseScrollDelta.y != 0f)
			{
				if (fixedPointIndex == -1)
				{
					ChangeZoomPoint(mousePos);
				}
				targetZoom = zoom + Input.mouseScrollDelta.y * zoom * GS.ZoomSpeed / 100f;
			}
		}

		private void ChangeZoomPoint(Vector2 newZoomPoint)
		{
			//IL_0002: 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_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_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_002a: 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)
			absoluteZoomPoint = (newZoomPoint - zoomPoint) * contentScale + absoluteZoomPoint;
			zoomPoint = newZoomPoint;
		}

		private void MouseAction()
		{
			//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_0038: 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_0051: 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_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_0120: 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_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: 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_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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: 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: Invalid comparison between Unknown and I4
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Invalid comparison between Unknown and I4
			//IL_027e: 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_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: 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_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: 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_04bb: Invalid comparison between Unknown and I4
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: 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_040b: 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_041b: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetMouseButtonDown(0))
			{
				initialMouseInsideBounds = mouseInsideBounds;
				if (!mouseInsideBounds)
				{
					return;
				}
				initialMousePos = Vector2.op_Implicit(Input.mousePosition);
				if (mouseActionType == MouseActionType.Move)
				{
					initialMoveOffset = moveOffset;
				}
				else if (mouseActionType == MouseActionType.SelectPoints)
				{
					initialLockedPoints.Clear();
					for (int i = 0; i < lockedPoints.Count; i++)
					{
						initialLockedPoints.Add(lockedPoints[i]);
					}
				}
				return;
			}
			if (Input.GetMouseButton(0) && initialMouseInsideBounds)
			{
				if (Input.GetMouseButtonDown(1))
				{
					initialMouseInsideBounds = false;
					((Component)zoomSelectionRectTransform).gameObject.SetActive(false);
					((Component)pointSelectionRectTransform).gameObject.SetActive(false);
				}
				if (previousMousePos != mousePos)
				{
					Vector2 val = Vector2.op_Implicit(Input.mousePosition);
					if (mouseActionType == MouseActionType.Move)
					{
						targetMoveOffset = initialMousePos - val + initialMoveOffset;
					}
					else if (mouseActionType == MouseActionType.SelectAreaToZoom)
					{
						if (!((Component)zoomSelectionRectTransform).gameObject.activeSelf)
						{
							((Component)zoomSelectionRectTransform).gameObject.SetActive(true);
						}
						SelectAreaToZoom(release: false);
					}
					else if (mouseActionType == MouseActionType.SelectPoints)
					{
						if (!((Component)pointSelectionRectTransform).gameObject.activeSelf)
						{
							((Component)pointSelectionRectTransform).gameObject.SetActive(true);
						}
						SelectPoints(release: false);
					}
				}
				previousMousePos = mousePos;
			}
			else if (Input.GetMouseButtonUp(0) && initialMouseInsideBounds)
			{
				if (mouseActionType == MouseActionType.SelectAreaToZoom)
				{
					SelectAreaToZoom(release: true);
				}
				else if (mouseActionType == MouseActionType.SelectPoints)
				{
					SelectPoints(release: true);
				}
				recentlyLockedPoints.Clear();
			}
			if (Input.touchCount != 1)
			{
				return;
			}
			Touch touch = Input.GetTouch(0);
			if ((int)((Touch)(ref touch)).phase == 0)
			{
				initialMousePos = ((Touch)(ref touch)).position;
				mousePos = (new Vector2(((Touch)(ref touch)).position.x, ((Touch)(ref touch)).position.y) - new Vector2(((Component)graphContent).transform.position.x, ((Component)graphContent).transform.position.y)) / contentScale;
				initialMouseInsideBounds = mousePos.x > bottomLeft.x && mousePos.y > bottomLeft.y && mousePos.x < topRight.x && mousePos.y < topRight.y;
				if (mouseActionType == MouseActionType.Move)
				{
					initialMoveOffset = moveOffset;
				}
				else if (mouseActionType == MouseActionType.SelectPoints)
				{
					initialLockedPoints.Clear();
					for (int j = 0; j < lockedPoints.Count; j++)
					{
						initialLockedPoints.Add(lockedPoints[j]);
					}
				}
			}
			else if ((int)((Touch)(ref touch)).phase == 1 && initialMouseInsideBounds)
			{
				if (mouseActionType == MouseActionType.Move)
				{
					Vector2 position = ((Touch)(ref touch)).position;
					targetMoveOffset = initialMousePos - position + initialMoveOffset;
				}
				else if (mouseActionType == MouseActionType.SelectAreaToZoom)
				{
					if (!((Component)zoomSelectionRectTransform).gameObject.activeSelf)
					{
						((Component)zoomSelectionRectTransform).gameObject.SetActive(true);
					}
					SelectAreaToZoom(release: false);
				}
				else if (mouseActionType == MouseActionType.SelectPoints)
				{
					if (!((Component)pointSelectionRectTransform).gameObject.activeSelf)
					{
						((Component)pointSelectionRectTransform).gameObject.SetActive(true);
					}
					SelectPoints(release: false);
				}
			}
			else if ((int)((Touch)(ref touch)).phase == 3 && initialMouseInsideBounds)
			{
				if (mouseActionType == MouseActionType.SelectAreaToZoom)
				{
					SelectAreaToZoom(release: true);
				}
				else if (mouseActionType == MouseActionType.SelectPoints)
				{
					SelectPoints(release: true);
				}
				recentlyLockedPoints.Clear();
			}
		}

		private void SelectAreaToZoom(bool release)
		{
			//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_003c: 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_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_005b: 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_007a: 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_0098: 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_00df: 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_0109: 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_00fd: 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_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: 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_0146: 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_0158: 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_016a: 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_0175: 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_0182: 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_039c: 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_0248: 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_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: 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_02cc: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = (new Vector2(initialMousePos.x, initialMousePos.y) - new Vector2(((Component)graphContent).transform.position.x, ((Component)graphContent).transform.position.y)) / contentScale;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(mousePos.x, val.y + (mousePos.x - val.x) / GS.GraphSize.x * GS.GraphSize.y * contentScale.x / contentScale.y);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(mousePos.x, val.y + (mousePos.x - val.x));
			Vector2 val4 = ((rectangleType == RectangleType.Free) ? mousePos : ((rectangleType == RectangleType.PreserveAspectRatio) ? val2 : val3));
			if (!release)
			{
				zoomSelectionRectTransform.anchoredPosition = (val + (val4 - val) / 2f) * contentScale;
				Vector2 val5 = new Vector2(Mathf.Abs(val4.x - val.x), Mathf.Abs(val4.y - val.y)) * contentScale;
				zoomSelectionRectTransform.sizeDelta = val5;
				((Graphic)zoomSelectionImage).color = GS.ZoomSelectionColor;
				for (int i = 0; i < zoomSelectionOutlines.Count; i++)
				{
					if (i % 2 == 0)
					{
						zoomSelectionOutlines[i].sizeDelta = new Vector2(GS.ZoomSelectionOutlineWidth, val5.y + GS.ZoomSelectionOutlineWidth * 2f);
						zoomSelectionOutlines[i].anchoredPosition = new Vector2((float)((i != 0) ? 1 : (-1)) * (val5.x + GS.ZoomSelectionOutlineWidth) / 2f, 0f);
					}
					else
					{
						zoomSelectionOutlines[i].sizeDelta = new Vector2(val5.x + GS.ZoomSelectionOutlineWidth * 2f, GS.ZoomSelectionOutlineWidth);
						zoomSelectionOutlines[i].anchoredPosition = new Vector2(0f, (float)((i != 1) ? 1 : (-1)) * (val5.y + GS.ZoomSelectionOutlineWidth) / 2f);
					}
					((Graphic)zoomSelectionOutlineImages[i]).color = GS.ZoomSelectionOutlineColor;
				}
			}
			else
			{
				((Component)zoomSelectionRectTransform).gameObject.SetActive(false);
				Vector2 val6 = default(Vector2);
				((Vector2)(ref val6))..ctor(Mathf.Min(val.x, val4.x), Mathf.Min(val.y, val4.y));
				Vector2 val7 = default(Vector2);
				((Vector2)(ref val7))..ctor(Mathf.Max(val.x, val4.x), Mathf.Max(val.y, val4.y));
				Vector2 val8 = val7 - val6;
				float magnitude = ((Vector2)(ref val8)).magnitude;
				val8 = topRight - bottomLeft;
				if (magnitude > ((Vector2)(ref val8)).magnitude / 16f)
				{
					SetCornerValues(val6, val7);
				}
			}
		}

		private void SelectPoints(bool release)
		{
			//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_003c: 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_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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: 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_0315: 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_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_0075: 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_0077: 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_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_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_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_00c1: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: 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_01bb: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: 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_0289: 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_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: 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_01fb: 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_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = (new Vector2(initialMousePos.x, initialMousePos.y) - new Vector2(((Component)graphContent).transform.position.x, ((Component)graphContent).transform.position.y)) / contentScale;
			if (!release)
			{
				Vector2 val2 = mousePos;
				pointSelectionRectTransform.anchoredPosition = (val + (val2 - val) / 2f) * contentScale;
				Vector2 val3 = new Vector2(Mathf.Abs(val2.x - val.x), Mathf.Abs(val2.y - val.y)) * contentScale;
				pointSelectionRectTransform.sizeDelta = val3;
				((Graphic)pointSelectionImage).color = GS.PointSelectionColor;
				for (int i = 0; i < pointSelectionOutlines.Count; i++)
				{
					if (i % 2 == 0)
					{
						pointSelectionOutlines[i].sizeDelta = new Vector2(GS.PointSelectionOutlineWidth, val3.y + GS.PointSelectionOutlineWidth * 2f);
						pointSelectionOutlines[i].anchoredPosition = new Vector2((float)((i != 0) ? 1 : (-1)) * (val3.x + GS.PointSelectionOutlineWidth) / 2f, 0f);
					}
					else
					{
						pointSelectionOutlines[i].sizeDelta = new Vector2(val3.x + GS.PointSelectionOutlineWidth * 2f, GS.PointSelectionOutlineWidth);
						pointSelectionOutlines[i].anchoredPosition = new Vector2(0f, (float)((i != 1) ? 1 : (-1)) * (val3.y + GS.PointSelectionOutlineWidth) / 2f);
					}
					((Graphic)pointSelectionOutlineImages[i]).color = GS.PointSelectionOutlineColor;
				}
				if (rectangleSelectionPhase == RectangleSelectionPhase.Moving)
				{
					Vector2 newBottomLeft = default(Vector2);
					((Vector2)(ref newBottomLeft))..ctor(Mathf.Min(val.x, mousePos.x), Mathf.Min(val.y, mousePos.y));
					Vector2 newTopRight = default(Vector2);
					((Vector2)(ref newTopRight))..ctor(Mathf.Max(val.x, mousePos.x), Mathf.Max(val.y, mousePos.y));
					PointSelect(moving: true, newBottomLeft, newTopRight);
				}
			}
			else
			{
				((Component)pointSelectionRectTransform).gameObject.SetActive(false);
				Vector2 newBottomLeft2 = default(Vector2);
				((Vector2)(ref newBottomLeft2))..ctor(Mathf.Min(val.x, mousePos.x), Mathf.Min(val.y, mousePos.y));
				Vector2 newTopRight2 = default(Vector2);
				((Vector2)(ref newTopRight2))..ctor(Mathf.Max(val.x, mousePos.x), Mathf.Max(val.y, mousePos.y));
				if (rectangleSelectionPhase == RectangleSelectionPhase.Release)
				{
					PointSelect(moving: false, newBottomLeft2, newTopRight2);
				}
			}
		}

		private void PointSelect(bool moving, Vector2 newBottomLeft, Vector2 newTopRight)
		{
			//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_0026: 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_003c: 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_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_022e: 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_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_023d: 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_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: 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_0262: Unknown result type (might be due to invalid IL or missing references)
			for (int i = ((Vector2Int)(ref xAxisRange)).x; i <= ((Vector2Int)(ref xAxisRange)).y; i++)
			{
				Vector2 val = values[i];
				if (!(val.x >= newBottomLeft.x) || !(val.x <= newTopRight.x) || !(val.y >= newBottomLeft.y) || !(val.y <= newTopRight.y))
				{
					continue;
				}
				if (rectangleSelectionType == RectangleSelectionType.SelectUnselect)
				{
					if (moving)
					{
						if (initialLockedPoints.Contains(i) && lockedPoints.Contains(i))
						{
							lockedPoints.Remove(i);
							recentlyLockedPoints.Add(i);
						}
						else if (!initialLockedPoints.Contains(i) && !lockedPoints.Contains(i))
						{
							lockedPoints.Add(i);
							recentlyLockedPoints.Add(i);
						}
					}
					else if (lockedPoints.Contains(i))
					{
						lockedPoints.Remove(i);
					}
					else
					{
						lockedPoints.Add(i);
					}
				}
				else if (moving)
				{
					if (!initialLockedPoints.Contains(i) && !lockedPoints.Contains(i))
					{
						lockedPoints.Add(i);
						recentlyLockedPoints.Add(i);
					}
				}
				else if (!lockedPoints.Contains(i))
				{
					lockedPoints.Add(i);
				}
				lockedHoveredPoints.Add(i);
				lockedHoveredPoints = lockedHoveredPoints.Distinct().ToList();
				lockedPoints = lockedPoints.Distinct().ToList();
			}
			for (int j = 0; j < recentlyLockedPoints.Count; j++)
			{
				int num = recentlyLockedPoints[j];
				Vector2 val2 = values[num];
				if (!(val2.x >= newBottomLeft.x) || !(val2.x <= newTopRight.x) || !(val2.y >= newBottomLeft.y) || !(val2.y <= newTopRight.y))
				{
					if (initialLockedPoints.Contains(num))
					{
						if (!lockedPoints.Contains(num))
						{
							lockedPoints.Add(num);
						}
					}
					else if (lockedPoints.Contains(num))
					{
						lockedPoints.Remove(num);
					}
				}
				lockedHoveredPoints.Add(num);
				lockedHoveredPoints = lockedHoveredPoints.Distinct().ToList();
				lockedPoints = lockedPoints.Distinct().ToList();
			}
		}

		private int MinMaxBinarySearch(bool findLeft)
		{
			//IL_004f: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			float num = (findLeft ? bottomLeft.x : topRight.x);
			int num2 = 0;
			int num3 = sortedIndices.Count - 1;
			while (num2 <= num3)
			{
				int num4 = num2 + (num3 - num2) / 2;
				float x = values[sortedIndices[num4]].x;
				if (findLeft ? (x >= num) : (x <= num))
				{
					if ((findLeft && (num4 == 0 || values[sortedIndices[num4 - 1]].x < num)) || (!findLeft && (num4 == sortedIndices.Count - 1 || values[sortedIndices[num4 + 1]].x > num)))
					{
						return num4;
					}
					if (findLeft)
					{
						num3 = num4 - 1;
					}
					else
					{
						num2 = num4 + 1;
					}
				}
				else if (findLeft)
				{
					num2 = num4 + 1;
				}
				else
				{
					num3 = num4 - 1;
				}
			}
			return -1;
		}

		private void UpdateSizeDelta(RectTransform rect, Vector2 size)
		{
			//IL_0002: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (Mathf.Abs(rect.sizeDelta.x - size.x) > 0.1f || Mathf.Abs(rect.sizeDelta.y - size.y) > 0.1f)
			{
				rect.sizeDelta = size;
			}
		}

		private void UpdateAnchoredPosition(RectTransform rect, Vector2 position)
		{
			//IL_0002: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (Mathf.Abs(rect.sizeDelta.x - position.x) > 0.1f || Mathf.Abs(rect.sizeDelta.y - position.y) > 0.1f)
			{
				rect.anchoredPosition = position;
			}
		}

		private bool CheckForErrors()
		{
			if ((Object)(object)((Component)this).GetComponent<GraphSettings>() == (Object)null)
			{
				Debug.LogError((object)"This GameObject has no GraphSettings script attached. Attach GraphSettings and restart");
				error = true;
				return true;
			}
			if ((Object)(object)((Component)this).GetComponent<GraphSettings>().GridTextFont == (Object)null)
			{
				Debug.LogError((object)"No font was found. Assign a font for GraphSettings.GridTextFont and restart");
				error = true;
			}
			if ((Object)(object)((Component)this).GetComponent<GraphSettings>().PointSprite == (Object)null)
			{
				Debug.LogError((object)"No point sprite was found. Assign a sprite for GraphSettings.PointSprite and restart");
				error = true;
			}
			if (error)
			{
				return true;
			}
			return false;
		}
	}
	public class GraphSettings : MonoBehaviour
	{
		[Header("Graph Settings")]
		[Space]
		public int updatePeriod = 5;

		[SerializeField]
		private Vector2 graphSize = new Vector2(0.5208f * (float)Screen.width, 0.7037f * (float)Screen.height);

		[SerializeField]
		private Vector2 graphScale = new Vector2(100f, 100f);

		[Space]
		[Header("Graph Visuals")]
		[Space]
		[SerializeField]
		private Color backgroundColor = new Color(0f, 0f, 0f, 1f);

		[SerializeField]
		private float outlineWidth = 5f;

		[SerializeField]
		private Color outlineColor = new Color(1f, 1f, 1f, 1f);

		[Space]
		[SerializeField]
		private float lineWidth = 4f;

		[SerializeField]
		private Color lineColor = new Color(1f, 0.35f, 0f, 1f);

		[Space]
		public Sprite PointSprite = Assets.mainAssetBundle.LoadAsset<Sprite>("cross.png");

		[SerializeField]
		private float pointRadius = 5f;

		[SerializeField]
		private Color pointColor = new Color(1f, 0.35f, 0f, 1f);

		[Space]
		[SerializeField]
		private float pointHoverRadius = 15f;

		public float PointHoverSpeed = 5f;

		[SerializeField]
		private Color pointHoverColor = new Color(1f, 0.6f, 0f, 1f);

		[Space]
		[SerializeField]
		private float pointLockedRadius = 17f;

		public float PointLockedSpeed = 5f;

		[SerializeField]
		private Color pointLockedColor = new Color(1f, 0.8f, 0f, 1f);

		[Space]
		[SerializeField]
		private float unfixedPointOutlineWidth = 10f;

		[SerializeField]
		private Color unfixedPointOutlineColor = new Color(1f, 0.35f, 0f, 1f);

		[Space]
		[SerializeField]
		private float unfixedPointOutlineHoverWidth = 15f;

		public float UnfixedPointOutlineHoverSpeed = 5f;

		[Space]
		[SerializeField]
		private Color unfixedPointOutlineHoverColor = new Color(0f, 0.5f, 1f, 1f);

		[Space]
		[SerializeField]
		private float fixedPointOutlineWidth = 17f;

		public float FixedPointOutlineSpeed = 5f;

		[SerializeField]
		private Color fixedPointOutlineColor = new Color(0f, 0.8f, 1f, 1f);

		[Space]
		[Header("Grid Settings")]
		[Space]
		public TMP_FontAsset GridTextFont = Assets.mainAssetBundle.LoadAsset<TMP_FontAsset>("LiberationSans SDF.asset");

		[SerializeField]
		private Vector2 gridSpacing = new Vector2(1f, 1f);

		[Space]
		[SerializeField]
		private float xAxisWidth = 3f;

		[SerializeField]
		private Color xAxisColor = new Color(1f, 1f, 1f, 1f);

		[Space]
		[SerializeField]
		private Color xAxisTextColor = new Color(1f, 1f, 1f, 1f);

		[SerializeField]
		private float xAxisTextSize = 10f;

		[SerializeField]
		private float xAxisTextOffset = 10f;

		[Space]
		[SerializeField]
		private float yAxisWidth = 3f;

		[SerializeField]
		private Color yAxisColor = new Color(1f, 1f, 1f, 1f);

		[Space]
		[SerializeField]
		private Color yAxisTextColor = new Color(1f, 1f, 1f, 1f);

		[SerializeField]
		private float yAxisTextSize = 10f;

		[SerializeField]
		private float yAxisTextOffset = 10f;

		[Space]
		[SerializeField]
		private float xGridWidth = 2f;

		[SerializeField]
		private Color xGridColor = new Color(1f, 1f, 1f, 0.6f);

		[Space]
		[SerializeField]
		private float yGridWidth = 2f;

		[SerializeField]
		private Color yGridColor = new Color(1f, 1f, 1f, 0.6f);

		[Space]
		[SerializeField]
		private Color zoomSelectionColor = new Color(0f, 0.8f, 1f, 0.2f);

		[SerializeField]
		private float zoomSelectionOutlineWidth = 5f;

		[SerializeField]
		private Color zoomSelectionOutlineColor = new Color(0f, 0.8f, 1f, 0.6f);

		[Space]
		[SerializeField]
		private Color pointSelectionColor = new Color(1f, 0.35f, 0f, 0.2f);

		[SerializeField]
		private float pointSelectionOutlineWidth = 5f;

		[SerializeField]
		private Color pointSelectionOutlineColor = new Color(1f, 0.35f, 0f, 0.4f);

		[Space]
		public float ZoomSpeed = 5f;

		public float SmoothZoomSpeed = 20f;

		public float SmoothMoveSpeed = 20f;

		private GraphHandler GH;

		public Vector2 GraphSize
		{
			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)
				return graphSize;
			}
			set
			{
				//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)
				graphSize = value;
				GH.UpdateGraphInternal(GraphHandler.UpdateMethod.UpdatePositionAndScale | GraphHandler.UpdateMethod.UpdateContent | GraphHandler.UpdateMethod.UpdateGridLines);
			}
		}

		public Vector2 GraphScale
		{
			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)
				return graphScale;
			}
			set
			{
				//

Unity.Mathematics.dll

Decompiled 2 weeks ago

Download (1.6 MB)

The result has been truncated due to the large size, download it to view full contents!

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Unity.IL2CPP.CompilerServices;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Unity.Mathematics")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Unity.Mathematics")]
[assembly: AssemblyCopyright("Copyright ©  2017")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("19810344-7387-4155-935F-BDD5CC61F0BF")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")]
[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")]
[assembly: InternalsVisibleTo("btests")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Unity.IL2CPP.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false, AllowMultiple = false)]
	public class Il2CppEagerStaticClassConstructionAttribute : Attribute
	{
	}
}
namespace Unity.Mathematics
{
	[Serializable]
	[DebuggerTypeProxy(typeof(DebuggerProxy))]
	[Il2CppEagerStaticClassConstruction]
	public struct bool2 : IEquatable<bool2>
	{
		internal sealed class DebuggerProxy
		{
			public bool x;

			public bool y;

			public DebuggerProxy(bool2 v)
			{
				x = v.x;
				y = v.y;
			}
		}

		[MarshalAs(UnmanagedType.U1)]
		public bool x;

		[MarshalAs(UnmanagedType.U1)]
		public bool y;

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 xxxx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(x, x, x, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 xxxy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(x, x, x, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 xxyx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(x, x, y, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 xxyy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(x, x, y, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 xyxx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(x, y, x, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 xyxy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(x, y, x, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 xyyx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(x, y, y, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 xyyy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(x, y, y, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 yxxx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(y, x, x, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 yxxy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(y, x, x, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 yxyx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(y, x, y, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 yxyy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(y, x, y, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 yyxx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(y, y, x, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 yyxy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(y, y, x, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 yyyx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(y, y, y, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool4 yyyy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool4(y, y, y, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool3 xxx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool3(x, x, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool3 xxy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool3(x, x, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool3 xyx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool3(x, y, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool3 xyy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool3(x, y, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool3 yxx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool3(y, x, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool3 yxy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool3(y, x, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool3 yyx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool3(y, y, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool3 yyy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool3(y, y, y);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool2 xx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool2(x, x);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool2 xy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool2(x, y);
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				x = value.x;
				y = value.y;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool2 yx
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool2(y, x);
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				y = value.x;
				x = value.y;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool2 yy
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new bool2(y, y);
			}
		}

		public unsafe bool this[int index]
		{
			get
			{
				fixed (bool2* ptr = &this)
				{
					return ((byte*)ptr)[index] != 0;
				}
			}
			set
			{
				fixed (bool* ptr = &x)
				{
					ptr[index] = value;
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool2(bool x, bool y)
		{
			this.x = x;
			this.y = y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool2(bool2 xy)
		{
			x = xy.x;
			y = xy.y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool2(bool v)
		{
			x = v;
			y = v;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator bool2(bool v)
		{
			return new bool2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator ==(bool2 lhs, bool2 rhs)
		{
			return new bool2(lhs.x == rhs.x, lhs.y == rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator ==(bool2 lhs, bool rhs)
		{
			return new bool2(lhs.x == rhs, lhs.y == rhs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator ==(bool lhs, bool2 rhs)
		{
			return new bool2(lhs == rhs.x, lhs == rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator !=(bool2 lhs, bool2 rhs)
		{
			return new bool2(lhs.x != rhs.x, lhs.y != rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator !=(bool2 lhs, bool rhs)
		{
			return new bool2(lhs.x != rhs, lhs.y != rhs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator !=(bool lhs, bool2 rhs)
		{
			return new bool2(lhs != rhs.x, lhs != rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator !(bool2 val)
		{
			return new bool2(!val.x, !val.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator &(bool2 lhs, bool2 rhs)
		{
			return new bool2(lhs.x & rhs.x, lhs.y & rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator &(bool2 lhs, bool rhs)
		{
			return new bool2(lhs.x && rhs, lhs.y && rhs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator &(bool lhs, bool2 rhs)
		{
			return new bool2(lhs & rhs.x, lhs & rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator |(bool2 lhs, bool2 rhs)
		{
			return new bool2(lhs.x | rhs.x, lhs.y | rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator |(bool2 lhs, bool rhs)
		{
			return new bool2(lhs.x || rhs, lhs.y || rhs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator |(bool lhs, bool2 rhs)
		{
			return new bool2(lhs | rhs.x, lhs | rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator ^(bool2 lhs, bool2 rhs)
		{
			return new bool2(lhs.x ^ rhs.x, lhs.y ^ rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator ^(bool2 lhs, bool rhs)
		{
			return new bool2(lhs.x ^ rhs, lhs.y ^ rhs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 operator ^(bool lhs, bool2 rhs)
		{
			return new bool2(lhs ^ rhs.x, lhs ^ rhs.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Equals(bool2 rhs)
		{
			return x == rhs.x && y == rhs.y;
		}

		public override bool Equals(object o)
		{
			return o is bool2 rhs && Equals(rhs);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode()
		{
			return (int)math.hash(this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override string ToString()
		{
			return $"bool2({x}, {y})";
		}
	}
	[Il2CppEagerStaticClassConstruction]
	public static class math
	{
		public enum RotationOrder : byte
		{
			XYZ = 0,
			XZY = 1,
			YXZ = 2,
			YZX = 3,
			ZXY = 4,
			ZYX = 5,
			Default = 4
		}

		public enum ShuffleComponent : byte
		{
			LeftX,
			LeftY,
			LeftZ,
			LeftW,
			RightX,
			RightY,
			RightZ,
			RightW
		}

		[StructLayout(LayoutKind.Explicit)]
		internal struct IntFloatUnion
		{
			[FieldOffset(0)]
			public int intValue;

			[FieldOffset(0)]
			public float floatValue;
		}

		[StructLayout(LayoutKind.Explicit)]
		internal struct LongDoubleUnion
		{
			[FieldOffset(0)]
			public long longValue;

			[FieldOffset(0)]
			public double doubleValue;
		}

		public const double E_DBL = Math.E;

		public const double LOG2E_DBL = 1.4426950408889634;

		public const double LOG10E_DBL = 0.4342944819032518;

		public const double LN2_DBL = 0.6931471805599453;

		public const double LN10_DBL = 2.302585092994046;

		public const double PI_DBL = Math.PI;

		public const double SQRT2_DBL = 1.4142135623730951;

		public const double EPSILON_DBL = 2.220446049250313E-16;

		public const double INFINITY_DBL = double.PositiveInfinity;

		public const double NAN_DBL = double.NaN;

		public const float FLT_MIN_NORMAL = 1.1754944E-38f;

		public const double DBL_MIN_NORMAL = 2.2250738585072014E-308;

		public const float E = (float)Math.E;

		public const float LOG2E = 1.442695f;

		public const float LOG10E = 0.4342945f;

		public const float LN2 = 0.6931472f;

		public const float LN10 = 2.3025851f;

		public const float PI = (float)Math.PI;

		public const float SQRT2 = 1.4142135f;

		public const float EPSILON = 1.1920929E-07f;

		public const float INFINITY = float.PositiveInfinity;

		public const float NAN = float.NaN;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 bool2(bool x, bool y)
		{
			return new bool2(x, y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 bool2(bool2 xy)
		{
			return new bool2(xy);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 bool2(bool v)
		{
			return new bool2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool2 v)
		{
			return csum(select(uint2(2426570171u, 1561977301u), uint2(4205774813u, 1650214333u), v));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(bool2 v)
		{
			return select(uint2(3388112843u, 1831150513u), uint2(1848374953u, 3430200247u), v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool shuffle(bool2 left, bool2 right, ShuffleComponent x)
		{
			return select_shuffle_component(left, right, x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 shuffle(bool2 left, bool2 right, ShuffleComponent x, ShuffleComponent y)
		{
			return bool2(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3 shuffle(bool2 left, bool2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
		{
			return bool3(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 shuffle(bool2 left, bool2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
		{
			return bool4(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z), select_shuffle_component(left, right, w));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool select_shuffle_component(bool2 a, bool2 b, ShuffleComponent component)
		{
			return component switch
			{
				ShuffleComponent.LeftX => a.x, 
				ShuffleComponent.LeftY => a.y, 
				ShuffleComponent.RightX => b.x, 
				ShuffleComponent.RightY => b.y, 
				_ => throw new ArgumentException("Invalid shuffle component: " + component), 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x2 bool2x2(bool2 c0, bool2 c1)
		{
			return new bool2x2(c0, c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x2 bool2x2(bool m00, bool m01, bool m10, bool m11)
		{
			return new bool2x2(m00, m01, m10, m11);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x2 bool2x2(bool v)
		{
			return new bool2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x2 transpose(bool2x2 v)
		{
			return bool2x2(v.c0.x, v.c0.y, v.c1.x, v.c1.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool2x2 v)
		{
			return csum(select(uint2(2062756937u, 2920485769u), uint2(1562056283u, 2265541847u), v.c0) + select(uint2(1283419601u, 1210229737u), uint2(2864955997u, 3525118277u), v.c1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(bool2x2 v)
		{
			return select(uint2(2298260269u, 1632478733u), uint2(1537393931u, 2353355467u), v.c0) + select(uint2(3441847433u, 4052036147u), uint2(2011389559u, 2252224297u), v.c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x3 bool2x3(bool2 c0, bool2 c1, bool2 c2)
		{
			return new bool2x3(c0, c1, c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x3 bool2x3(bool m00, bool m01, bool m02, bool m10, bool m11, bool m12)
		{
			return new bool2x3(m00, m01, m02, m10, m11, m12);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x3 bool2x3(bool v)
		{
			return new bool2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x2 transpose(bool2x3 v)
		{
			return bool3x2(v.c0.x, v.c0.y, v.c1.x, v.c1.y, v.c2.x, v.c2.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool2x3 v)
		{
			return csum(select(uint2(2078515003u, 4206465343u), uint2(3025146473u, 3763046909u), v.c0) + select(uint2(3678265601u, 2070747979u), uint2(1480171127u, 1588341193u), v.c1) + select(uint2(4234155257u, 1811310911u), uint2(2635799963u, 4165137857u), v.c2));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(bool2x3 v)
		{
			return select(uint2(2759770933u, 2759319383u), uint2(3299952959u, 3121178323u), v.c0) + select(uint2(2948522579u, 1531026433u), uint2(1365086453u, 3969870067u), v.c1) + select(uint2(4192899797u, 3271228601u), uint2(1634639009u, 3318036811u), v.c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x4 bool2x4(bool2 c0, bool2 c1, bool2 c2, bool2 c3)
		{
			return new bool2x4(c0, c1, c2, c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x4 bool2x4(bool m00, bool m01, bool m02, bool m03, bool m10, bool m11, bool m12, bool m13)
		{
			return new bool2x4(m00, m01, m02, m03, m10, m11, m12, m13);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x4 bool2x4(bool v)
		{
			return new bool2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x2 transpose(bool2x4 v)
		{
			return bool4x2(v.c0.x, v.c0.y, v.c1.x, v.c1.y, v.c2.x, v.c2.y, v.c3.x, v.c3.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool2x4 v)
		{
			return csum(select(uint2(1168253063u, 4228926523u), uint2(1610574617u, 1584185147u), v.c0) + select(uint2(3041325733u, 3150930919u), uint2(3309258581u, 1770373673u), v.c1) + select(uint2(3778261171u, 3286279097u), uint2(4264629071u, 1898591447u), v.c2) + select(uint2(2641864091u, 1229113913u), uint2(3020867117u, 1449055807u), v.c3));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(bool2x4 v)
		{
			return select(uint2(2479033387u, 3702457169u), uint2(1845824257u, 1963973621u), v.c0) + select(uint2(2134758553u, 1391111867u), uint2(1167706003u, 2209736489u), v.c1) + select(uint2(3261535807u, 1740411209u), uint2(2910609089u, 2183822701u), v.c2) + select(uint2(3029516053u, 3547472099u), uint2(2057487037u, 3781937309u), v.c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3 bool3(bool x, bool y, bool z)
		{
			return new bool3(x, y, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3 bool3(bool x, bool2 yz)
		{
			return new bool3(x, yz);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3 bool3(bool2 xy, bool z)
		{
			return new bool3(xy, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3 bool3(bool3 xyz)
		{
			return new bool3(xyz);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3 bool3(bool v)
		{
			return new bool3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool3 v)
		{
			return csum(select(uint3(2716413241u, 1166264321u, 2503385333u), uint3(2944493077u, 2599999021u, 3814721321u), v));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(bool3 v)
		{
			return select(uint3(1595355149u, 1728931849u, 2062756937u), uint3(2920485769u, 1562056283u, 2265541847u), v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool shuffle(bool3 left, bool3 right, ShuffleComponent x)
		{
			return select_shuffle_component(left, right, x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 shuffle(bool3 left, bool3 right, ShuffleComponent x, ShuffleComponent y)
		{
			return bool2(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3 shuffle(bool3 left, bool3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
		{
			return bool3(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 shuffle(bool3 left, bool3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
		{
			return bool4(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z), select_shuffle_component(left, right, w));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool select_shuffle_component(bool3 a, bool3 b, ShuffleComponent component)
		{
			return component switch
			{
				ShuffleComponent.LeftX => a.x, 
				ShuffleComponent.LeftY => a.y, 
				ShuffleComponent.LeftZ => a.z, 
				ShuffleComponent.RightX => b.x, 
				ShuffleComponent.RightY => b.y, 
				ShuffleComponent.RightZ => b.z, 
				_ => throw new ArgumentException("Invalid shuffle component: " + component), 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x2 bool3x2(bool3 c0, bool3 c1)
		{
			return new bool3x2(c0, c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x2 bool3x2(bool m00, bool m01, bool m10, bool m11, bool m20, bool m21)
		{
			return new bool3x2(m00, m01, m10, m11, m20, m21);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x2 bool3x2(bool v)
		{
			return new bool3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x3 transpose(bool3x2 v)
		{
			return bool2x3(v.c0.x, v.c0.y, v.c0.z, v.c1.x, v.c1.y, v.c1.z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool3x2 v)
		{
			return csum(select(uint3(2627668003u, 1520214331u, 2949502447u), uint3(2827819133u, 3480140317u, 2642994593u), v.c0) + select(uint3(3940484981u, 1954192763u, 1091696537u), uint3(3052428017u, 4253034763u, 2338696631u), v.c1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(bool3x2 v)
		{
			return select(uint3(3757372771u, 1885959949u, 3508684087u), uint3(3919501043u, 1209161033u, 4007793211u), v.c0) + select(uint3(3819806693u, 3458005183u, 2078515003u), uint3(4206465343u, 3025146473u, 3763046909u), v.c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x3 bool3x3(bool3 c0, bool3 c1, bool3 c2)
		{
			return new bool3x3(c0, c1, c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x3 bool3x3(bool m00, bool m01, bool m02, bool m10, bool m11, bool m12, bool m20, bool m21, bool m22)
		{
			return new bool3x3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x3 bool3x3(bool v)
		{
			return new bool3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x3 transpose(bool3x3 v)
		{
			return bool3x3(v.c0.x, v.c0.y, v.c0.z, v.c1.x, v.c1.y, v.c1.z, v.c2.x, v.c2.y, v.c2.z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool3x3 v)
		{
			return csum(select(uint3(3881277847u, 4017968839u, 1727237899u), uint3(1648514723u, 1385344481u, 3538260197u), v.c0) + select(uint3(4066109527u, 2613148903u, 3367528529u), uint3(1678332449u, 2918459647u, 2744611081u), v.c1) + select(uint3(1952372791u, 2631698677u, 4200781601u), uint3(2119021007u, 1760485621u, 3157985881u), v.c2));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(bool3x3 v)
		{
			return select(uint3(2171534173u, 2723054263u, 1168253063u), uint3(4228926523u, 1610574617u, 1584185147u), v.c0) + select(uint3(3041325733u, 3150930919u, 3309258581u), uint3(1770373673u, 3778261171u, 3286279097u), v.c1) + select(uint3(4264629071u, 1898591447u, 2641864091u), uint3(1229113913u, 3020867117u, 1449055807u), v.c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x4 bool3x4(bool3 c0, bool3 c1, bool3 c2, bool3 c3)
		{
			return new bool3x4(c0, c1, c2, c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x4 bool3x4(bool m00, bool m01, bool m02, bool m03, bool m10, bool m11, bool m12, bool m13, bool m20, bool m21, bool m22, bool m23)
		{
			return new bool3x4(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x4 bool3x4(bool v)
		{
			return new bool3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x3 transpose(bool3x4 v)
		{
			return bool4x3(v.c0.x, v.c0.y, v.c0.z, v.c1.x, v.c1.y, v.c1.z, v.c2.x, v.c2.y, v.c2.z, v.c3.x, v.c3.y, v.c3.z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool3x4 v)
		{
			return csum(select(uint3(2209710647u, 2201894441u, 2849577407u), uint3(3287031191u, 3098675399u, 1564399943u), v.c0) + select(uint3(1148435377u, 3416333663u, 1750611407u), uint3(3285396193u, 3110507567u, 4271396531u), v.c1) + select(uint3(4198118021u, 2908068253u, 3705492289u), uint3(2497566569u, 2716413241u, 1166264321u), v.c2) + select(uint3(2503385333u, 2944493077u, 2599999021u), uint3(3814721321u, 1595355149u, 1728931849u), v.c3));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(bool3x4 v)
		{
			return select(uint3(2062756937u, 2920485769u, 1562056283u), uint3(2265541847u, 1283419601u, 1210229737u), v.c0) + select(uint3(2864955997u, 3525118277u, 2298260269u), uint3(1632478733u, 1537393931u, 2353355467u), v.c1) + select(uint3(3441847433u, 4052036147u, 2011389559u), uint3(2252224297u, 3784421429u, 1750626223u), v.c2) + select(uint3(3571447507u, 3412283213u, 2601761069u), uint3(1254033427u, 2248573027u, 3612677113u), v.c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 bool4(bool x, bool y, bool z, bool w)
		{
			return new bool4(x, y, z, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 bool4(bool x, bool y, bool2 zw)
		{
			return new bool4(x, y, zw);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 bool4(bool x, bool2 yz, bool w)
		{
			return new bool4(x, yz, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 bool4(bool x, bool3 yzw)
		{
			return new bool4(x, yzw);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 bool4(bool2 xy, bool z, bool w)
		{
			return new bool4(xy, z, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 bool4(bool2 xy, bool2 zw)
		{
			return new bool4(xy, zw);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 bool4(bool3 xyz, bool w)
		{
			return new bool4(xyz, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 bool4(bool4 xyzw)
		{
			return new bool4(xyzw);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 bool4(bool v)
		{
			return new bool4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool4 v)
		{
			return csum(select(uint4(1610574617u, 1584185147u, 3041325733u, 3150930919u), uint4(3309258581u, 1770373673u, 3778261171u, 3286279097u), v));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint4 hashwide(bool4 v)
		{
			return select(uint4(4264629071u, 1898591447u, 2641864091u, 1229113913u), uint4(3020867117u, 1449055807u, 2479033387u, 3702457169u), v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool shuffle(bool4 left, bool4 right, ShuffleComponent x)
		{
			return select_shuffle_component(left, right, x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2 shuffle(bool4 left, bool4 right, ShuffleComponent x, ShuffleComponent y)
		{
			return bool2(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3 shuffle(bool4 left, bool4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
		{
			return bool3(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4 shuffle(bool4 left, bool4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
		{
			return bool4(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z), select_shuffle_component(left, right, w));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool select_shuffle_component(bool4 a, bool4 b, ShuffleComponent component)
		{
			return component switch
			{
				ShuffleComponent.LeftX => a.x, 
				ShuffleComponent.LeftY => a.y, 
				ShuffleComponent.LeftZ => a.z, 
				ShuffleComponent.LeftW => a.w, 
				ShuffleComponent.RightX => b.x, 
				ShuffleComponent.RightY => b.y, 
				ShuffleComponent.RightZ => b.z, 
				ShuffleComponent.RightW => b.w, 
				_ => throw new ArgumentException("Invalid shuffle component: " + component), 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x2 bool4x2(bool4 c0, bool4 c1)
		{
			return new bool4x2(c0, c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x2 bool4x2(bool m00, bool m01, bool m10, bool m11, bool m20, bool m21, bool m30, bool m31)
		{
			return new bool4x2(m00, m01, m10, m11, m20, m21, m30, m31);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x2 bool4x2(bool v)
		{
			return new bool4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool2x4 transpose(bool4x2 v)
		{
			return bool2x4(v.c0.x, v.c0.y, v.c0.z, v.c0.w, v.c1.x, v.c1.y, v.c1.z, v.c1.w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool4x2 v)
		{
			return csum(select(uint4(3516359879u, 3050356579u, 4178586719u, 2558655391u), uint4(1453413133u, 2152428077u, 1938706661u, 1338588197u), v.c0) + select(uint4(3439609253u, 3535343003u, 3546061613u, 2702024231u), uint4(1452124841u, 1966089551u, 2668168249u, 1587512777u), v.c1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint4 hashwide(bool4x2 v)
		{
			return select(uint4(2353831999u, 3101256173u, 2891822459u, 2837054189u), uint4(3016004371u, 4097481403u, 2229788699u, 2382715877u), v.c0) + select(uint4(1851936439u, 1938025801u, 3712598587u, 3956330501u), uint4(2437373431u, 1441286183u, 2426570171u, 1561977301u), v.c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x3 bool4x3(bool4 c0, bool4 c1, bool4 c2)
		{
			return new bool4x3(c0, c1, c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x3 bool4x3(bool m00, bool m01, bool m02, bool m10, bool m11, bool m12, bool m20, bool m21, bool m22, bool m30, bool m31, bool m32)
		{
			return new bool4x3(m00, m01, m02, m10, m11, m12, m20, m21, m22, m30, m31, m32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x3 bool4x3(bool v)
		{
			return new bool4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool3x4 transpose(bool4x3 v)
		{
			return bool3x4(v.c0.x, v.c0.y, v.c0.z, v.c0.w, v.c1.x, v.c1.y, v.c1.z, v.c1.w, v.c2.x, v.c2.y, v.c2.z, v.c2.w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool4x3 v)
		{
			return csum(select(uint4(3940484981u, 1954192763u, 1091696537u, 3052428017u), uint4(4253034763u, 2338696631u, 3757372771u, 1885959949u), v.c0) + select(uint4(3508684087u, 3919501043u, 1209161033u, 4007793211u), uint4(3819806693u, 3458005183u, 2078515003u, 4206465343u), v.c1) + select(uint4(3025146473u, 3763046909u, 3678265601u, 2070747979u), uint4(1480171127u, 1588341193u, 4234155257u, 1811310911u), v.c2));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint4 hashwide(bool4x3 v)
		{
			return select(uint4(2635799963u, 4165137857u, 2759770933u, 2759319383u), uint4(3299952959u, 3121178323u, 2948522579u, 1531026433u), v.c0) + select(uint4(1365086453u, 3969870067u, 4192899797u, 3271228601u), uint4(1634639009u, 3318036811u, 3404170631u, 2048213449u), v.c1) + select(uint4(4164671783u, 1780759499u, 1352369353u, 2446407751u), uint4(1391928079u, 3475533443u, 3777095341u, 3385463369u), v.c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x4 bool4x4(bool4 c0, bool4 c1, bool4 c2, bool4 c3)
		{
			return new bool4x4(c0, c1, c2, c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x4 bool4x4(bool m00, bool m01, bool m02, bool m03, bool m10, bool m11, bool m12, bool m13, bool m20, bool m21, bool m22, bool m23, bool m30, bool m31, bool m32, bool m33)
		{
			return new bool4x4(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x4 bool4x4(bool v)
		{
			return new bool4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool4x4 transpose(bool4x4 v)
		{
			return bool4x4(v.c0.x, v.c0.y, v.c0.z, v.c0.w, v.c1.x, v.c1.y, v.c1.z, v.c1.w, v.c2.x, v.c2.y, v.c2.z, v.c2.w, v.c3.x, v.c3.y, v.c3.z, v.c3.w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(bool4x4 v)
		{
			return csum(select(uint4(3516359879u, 3050356579u, 4178586719u, 2558655391u), uint4(1453413133u, 2152428077u, 1938706661u, 1338588197u), v.c0) + select(uint4(3439609253u, 3535343003u, 3546061613u, 2702024231u), uint4(1452124841u, 1966089551u, 2668168249u, 1587512777u), v.c1) + select(uint4(2353831999u, 3101256173u, 2891822459u, 2837054189u), uint4(3016004371u, 4097481403u, 2229788699u, 2382715877u), v.c2) + select(uint4(1851936439u, 1938025801u, 3712598587u, 3956330501u), uint4(2437373431u, 1441286183u, 2426570171u, 1561977301u), v.c3));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint4 hashwide(bool4x4 v)
		{
			return select(uint4(4205774813u, 1650214333u, 3388112843u, 1831150513u), uint4(1848374953u, 3430200247u, 2209710647u, 2201894441u), v.c0) + select(uint4(2849577407u, 3287031191u, 3098675399u, 1564399943u), uint4(1148435377u, 3416333663u, 1750611407u, 3285396193u), v.c1) + select(uint4(3110507567u, 4271396531u, 4198118021u, 2908068253u), uint4(3705492289u, 2497566569u, 2716413241u, 1166264321u), v.c2) + select(uint4(2503385333u, 2944493077u, 2599999021u, 3814721321u), uint4(1595355149u, 1728931849u, 2062756937u, 2920485769u), v.c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(double x, double y)
		{
			return new double2(x, y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(double2 xy)
		{
			return new double2(xy);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(double v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(bool v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(bool2 v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(int v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(int2 v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(uint v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(uint2 v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(half v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(half2 v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(float v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 double2(float2 v)
		{
			return new double2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double2 v)
		{
			return csum(fold_to_uint(v) * uint2(2503385333u, 2944493077u)) + 2599999021u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(double2 v)
		{
			return fold_to_uint(v) * uint2(3814721321u, 1595355149u) + 1728931849u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double shuffle(double2 left, double2 right, ShuffleComponent x)
		{
			return select_shuffle_component(left, right, x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 shuffle(double2 left, double2 right, ShuffleComponent x, ShuffleComponent y)
		{
			return double2(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 shuffle(double2 left, double2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
		{
			return double3(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 shuffle(double2 left, double2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
		{
			return double4(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z), select_shuffle_component(left, right, w));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double select_shuffle_component(double2 a, double2 b, ShuffleComponent component)
		{
			return component switch
			{
				ShuffleComponent.LeftX => a.x, 
				ShuffleComponent.LeftY => a.y, 
				ShuffleComponent.RightX => b.x, 
				ShuffleComponent.RightY => b.y, 
				_ => throw new ArgumentException("Invalid shuffle component: " + component), 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(double2 c0, double2 c1)
		{
			return new double2x2(c0, c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(double m00, double m01, double m10, double m11)
		{
			return new double2x2(m00, m01, m10, m11);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(double v)
		{
			return new double2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(bool v)
		{
			return new double2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(bool2x2 v)
		{
			return new double2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(int v)
		{
			return new double2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(int2x2 v)
		{
			return new double2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(uint v)
		{
			return new double2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(uint2x2 v)
		{
			return new double2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(float v)
		{
			return new double2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 double2x2(float2x2 v)
		{
			return new double2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 transpose(double2x2 v)
		{
			return double2x2(v.c0.x, v.c0.y, v.c1.x, v.c1.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x2 inverse(double2x2 m)
		{
			double x = m.c0.x;
			double x2 = m.c1.x;
			double y = m.c0.y;
			double y2 = m.c1.y;
			double num = x * y2 - x2 * y;
			return double2x2(y2, 0.0 - x2, 0.0 - y, x) * (1.0 / num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double determinant(double2x2 m)
		{
			double x = m.c0.x;
			double x2 = m.c1.x;
			double y = m.c0.y;
			double y2 = m.c1.y;
			return x * y2 - x2 * y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double2x2 v)
		{
			return csum(fold_to_uint(v.c0) * uint2(4253034763u, 2338696631u) + fold_to_uint(v.c1) * uint2(3757372771u, 1885959949u)) + 3508684087u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(double2x2 v)
		{
			return fold_to_uint(v.c0) * uint2(3919501043u, 1209161033u) + fold_to_uint(v.c1) * uint2(4007793211u, 3819806693u) + 3458005183u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(double2 c0, double2 c1, double2 c2)
		{
			return new double2x3(c0, c1, c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(double m00, double m01, double m02, double m10, double m11, double m12)
		{
			return new double2x3(m00, m01, m02, m10, m11, m12);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(double v)
		{
			return new double2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(bool v)
		{
			return new double2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(bool2x3 v)
		{
			return new double2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(int v)
		{
			return new double2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(int2x3 v)
		{
			return new double2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(uint v)
		{
			return new double2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(uint2x3 v)
		{
			return new double2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(float v)
		{
			return new double2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 double2x3(float2x3 v)
		{
			return new double2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 transpose(double2x3 v)
		{
			return double3x2(v.c0.x, v.c0.y, v.c1.x, v.c1.y, v.c2.x, v.c2.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double2x3 v)
		{
			return csum(fold_to_uint(v.c0) * uint2(4066109527u, 2613148903u) + fold_to_uint(v.c1) * uint2(3367528529u, 1678332449u) + fold_to_uint(v.c2) * uint2(2918459647u, 2744611081u)) + 1952372791;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(double2x3 v)
		{
			return fold_to_uint(v.c0) * uint2(2631698677u, 4200781601u) + fold_to_uint(v.c1) * uint2(2119021007u, 1760485621u) + fold_to_uint(v.c2) * uint2(3157985881u, 2171534173u) + 2723054263u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(double2 c0, double2 c1, double2 c2, double2 c3)
		{
			return new double2x4(c0, c1, c2, c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13)
		{
			return new double2x4(m00, m01, m02, m03, m10, m11, m12, m13);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(double v)
		{
			return new double2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(bool v)
		{
			return new double2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(bool2x4 v)
		{
			return new double2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(int v)
		{
			return new double2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(int2x4 v)
		{
			return new double2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(uint v)
		{
			return new double2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(uint2x4 v)
		{
			return new double2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(float v)
		{
			return new double2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 double2x4(float2x4 v)
		{
			return new double2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 transpose(double2x4 v)
		{
			return double4x2(v.c0.x, v.c0.y, v.c1.x, v.c1.y, v.c2.x, v.c2.y, v.c3.x, v.c3.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double2x4 v)
		{
			return csum(fold_to_uint(v.c0) * uint2(2437373431u, 1441286183u) + fold_to_uint(v.c1) * uint2(2426570171u, 1561977301u) + fold_to_uint(v.c2) * uint2(4205774813u, 1650214333u) + fold_to_uint(v.c3) * uint2(3388112843u, 1831150513u)) + 1848374953;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(double2x4 v)
		{
			return fold_to_uint(v.c0) * uint2(3430200247u, 2209710647u) + fold_to_uint(v.c1) * uint2(2201894441u, 2849577407u) + fold_to_uint(v.c2) * uint2(3287031191u, 3098675399u) + fold_to_uint(v.c3) * uint2(1564399943u, 1148435377u) + 3416333663u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(double x, double y, double z)
		{
			return new double3(x, y, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(double x, double2 yz)
		{
			return new double3(x, yz);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(double2 xy, double z)
		{
			return new double3(xy, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(double3 xyz)
		{
			return new double3(xyz);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(double v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(bool v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(bool3 v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(int v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(int3 v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(uint v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(uint3 v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(half v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(half3 v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(float v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 double3(float3 v)
		{
			return new double3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double3 v)
		{
			return csum(fold_to_uint(v) * uint3(2937008387u, 3835713223u, 2216526373u)) + 3375971453u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(double3 v)
		{
			return fold_to_uint(v) * uint3(3559829411u, 3652178029u, 2544260129u) + 2013864031u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double shuffle(double3 left, double3 right, ShuffleComponent x)
		{
			return select_shuffle_component(left, right, x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 shuffle(double3 left, double3 right, ShuffleComponent x, ShuffleComponent y)
		{
			return double2(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 shuffle(double3 left, double3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
		{
			return double3(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 shuffle(double3 left, double3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
		{
			return double4(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z), select_shuffle_component(left, right, w));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double select_shuffle_component(double3 a, double3 b, ShuffleComponent component)
		{
			return component switch
			{
				ShuffleComponent.LeftX => a.x, 
				ShuffleComponent.LeftY => a.y, 
				ShuffleComponent.LeftZ => a.z, 
				ShuffleComponent.RightX => b.x, 
				ShuffleComponent.RightY => b.y, 
				ShuffleComponent.RightZ => b.z, 
				_ => throw new ArgumentException("Invalid shuffle component: " + component), 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(double3 c0, double3 c1)
		{
			return new double3x2(c0, c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(double m00, double m01, double m10, double m11, double m20, double m21)
		{
			return new double3x2(m00, m01, m10, m11, m20, m21);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(double v)
		{
			return new double3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(bool v)
		{
			return new double3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(bool3x2 v)
		{
			return new double3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(int v)
		{
			return new double3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(int3x2 v)
		{
			return new double3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(uint v)
		{
			return new double3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(uint3x2 v)
		{
			return new double3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(float v)
		{
			return new double3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x2 double3x2(float3x2 v)
		{
			return new double3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x3 transpose(double3x2 v)
		{
			return double2x3(v.c0.x, v.c0.y, v.c0.z, v.c1.x, v.c1.y, v.c1.z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double3x2 v)
		{
			return csum(fold_to_uint(v.c0) * uint3(3996716183u, 2626301701u, 1306289417u) + fold_to_uint(v.c1) * uint3(2096137163u, 1548578029u, 4178800919u)) + 3898072289u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(double3x2 v)
		{
			return fold_to_uint(v.c0) * uint3(4129428421u, 2631575897u, 2854656703u) + fold_to_uint(v.c1) * uint3(3578504047u, 4245178297u, 2173281923u) + 2973357649u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(double3 c0, double3 c1, double3 c2)
		{
			return new double3x3(c0, c1, c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22)
		{
			return new double3x3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(double v)
		{
			return new double3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(bool v)
		{
			return new double3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(bool3x3 v)
		{
			return new double3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(int v)
		{
			return new double3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(int3x3 v)
		{
			return new double3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(uint v)
		{
			return new double3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(uint3x3 v)
		{
			return new double3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(float v)
		{
			return new double3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 double3x3(float3x3 v)
		{
			return new double3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x3 transpose(double3x3 v)
		{
			return double3x3(v.c0.x, v.c0.y, v.c0.z, v.c1.x, v.c1.y, v.c1.z, v.c2.x, v.c2.y, v.c2.z);
		}

		public static double3x3 inverse(double3x3 m)
		{
			double3 c = m.c0;
			double3 c2 = m.c1;
			double3 c3 = m.c2;
			double3 double5 = double3(c2.x, c3.x, c.x);
			double3 double6 = double3(c2.y, c3.y, c.y);
			double3 double7 = double3(c2.z, c3.z, c.z);
			double3 double8 = double6 * double7.yzx - double6.yzx * double7;
			double3 c4 = double5.yzx * double7 - double5 * double7.yzx;
			double3 c5 = double5 * double6.yzx - double5.yzx * double6;
			double num = 1.0 / csum(double5.zxy * double8);
			return double3x3(double8, c4, c5) * num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double determinant(double3x3 m)
		{
			double3 c = m.c0;
			double3 c2 = m.c1;
			double3 c3 = m.c2;
			double num = c2.y * c3.z - c2.z * c3.y;
			double num2 = c.y * c3.z - c.z * c3.y;
			double num3 = c.y * c2.z - c.z * c2.y;
			return c.x * num - c2.x * num2 + c3.x * num3;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double3x3 v)
		{
			return csum(fold_to_uint(v.c0) * uint3(2891822459u, 2837054189u, 3016004371u) + fold_to_uint(v.c1) * uint3(4097481403u, 2229788699u, 2382715877u) + fold_to_uint(v.c2) * uint3(1851936439u, 1938025801u, 3712598587u)) + 3956330501u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(double3x3 v)
		{
			return fold_to_uint(v.c0) * uint3(2437373431u, 1441286183u, 2426570171u) + fold_to_uint(v.c1) * uint3(1561977301u, 4205774813u, 1650214333u) + fold_to_uint(v.c2) * uint3(3388112843u, 1831150513u, 1848374953u) + 3430200247u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(double3 c0, double3 c1, double3 c2, double3 c3)
		{
			return new double3x4(c0, c1, c2, c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23)
		{
			return new double3x4(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(double v)
		{
			return new double3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(bool v)
		{
			return new double3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(bool3x4 v)
		{
			return new double3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(int v)
		{
			return new double3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(int3x4 v)
		{
			return new double3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(uint v)
		{
			return new double3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(uint3x4 v)
		{
			return new double3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(float v)
		{
			return new double3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 double3x4(float3x4 v)
		{
			return new double3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 transpose(double3x4 v)
		{
			return double4x3(v.c0.x, v.c0.y, v.c0.z, v.c1.x, v.c1.y, v.c1.z, v.c2.x, v.c2.y, v.c2.z, v.c3.x, v.c3.y, v.c3.z);
		}

		public static double3x4 fastinverse(double3x4 m)
		{
			double3 c = m.c0;
			double3 c2 = m.c1;
			double3 c3 = m.c2;
			double3 c4 = m.c3;
			double3 double5 = double3(c.x, c2.x, c3.x);
			double3 double6 = double3(c.y, c2.y, c3.y);
			double3 double7 = double3(c.z, c2.z, c3.z);
			c4 = -(double5 * c4.x + double6 * c4.y + double7 * c4.z);
			return double3x4(double5, double6, double7, c4);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double3x4 v)
		{
			return csum(fold_to_uint(v.c0) * uint3(3996716183u, 2626301701u, 1306289417u) + fold_to_uint(v.c1) * uint3(2096137163u, 1548578029u, 4178800919u) + fold_to_uint(v.c2) * uint3(3898072289u, 4129428421u, 2631575897u) + fold_to_uint(v.c3) * uint3(2854656703u, 3578504047u, 4245178297u)) + 2173281923u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(double3x4 v)
		{
			return fold_to_uint(v.c0) * uint3(2973357649u, 3881277847u, 4017968839u) + fold_to_uint(v.c1) * uint3(1727237899u, 1648514723u, 1385344481u) + fold_to_uint(v.c2) * uint3(3538260197u, 4066109527u, 2613148903u) + fold_to_uint(v.c3) * uint3(3367528529u, 1678332449u, 2918459647u) + 2744611081u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(double x, double y, double z, double w)
		{
			return new double4(x, y, z, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(double x, double y, double2 zw)
		{
			return new double4(x, y, zw);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(double x, double2 yz, double w)
		{
			return new double4(x, yz, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(double x, double3 yzw)
		{
			return new double4(x, yzw);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(double2 xy, double z, double w)
		{
			return new double4(xy, z, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(double2 xy, double2 zw)
		{
			return new double4(xy, zw);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(double3 xyz, double w)
		{
			return new double4(xyz, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(double4 xyzw)
		{
			return new double4(xyzw);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(double v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(bool v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(bool4 v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(int v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(int4 v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(uint v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(uint4 v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(half v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(half4 v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(float v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 double4(float4 v)
		{
			return new double4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double4 v)
		{
			return csum(fold_to_uint(v) * uint4(2669441947u, 1260114311u, 2650080659u, 4052675461u)) + 2652487619u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint4 hashwide(double4 v)
		{
			return fold_to_uint(v) * uint4(2174136431u, 3528391193u, 2105559227u, 1899745391u) + 1966790317u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double shuffle(double4 left, double4 right, ShuffleComponent x)
		{
			return select_shuffle_component(left, right, x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2 shuffle(double4 left, double4 right, ShuffleComponent x, ShuffleComponent y)
		{
			return double2(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 shuffle(double4 left, double4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
		{
			return double3(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4 shuffle(double4 left, double4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
		{
			return double4(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z), select_shuffle_component(left, right, w));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double select_shuffle_component(double4 a, double4 b, ShuffleComponent component)
		{
			return component switch
			{
				ShuffleComponent.LeftX => a.x, 
				ShuffleComponent.LeftY => a.y, 
				ShuffleComponent.LeftZ => a.z, 
				ShuffleComponent.LeftW => a.w, 
				ShuffleComponent.RightX => b.x, 
				ShuffleComponent.RightY => b.y, 
				ShuffleComponent.RightZ => b.z, 
				ShuffleComponent.RightW => b.w, 
				_ => throw new ArgumentException("Invalid shuffle component: " + component), 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(double4 c0, double4 c1)
		{
			return new double4x2(c0, c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(double m00, double m01, double m10, double m11, double m20, double m21, double m30, double m31)
		{
			return new double4x2(m00, m01, m10, m11, m20, m21, m30, m31);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(double v)
		{
			return new double4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(bool v)
		{
			return new double4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(bool4x2 v)
		{
			return new double4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(int v)
		{
			return new double4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(int4x2 v)
		{
			return new double4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(uint v)
		{
			return new double4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(uint4x2 v)
		{
			return new double4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(float v)
		{
			return new double4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x2 double4x2(float4x2 v)
		{
			return new double4x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double2x4 transpose(double4x2 v)
		{
			return double2x4(v.c0.x, v.c0.y, v.c0.z, v.c0.w, v.c1.x, v.c1.y, v.c1.z, v.c1.w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double4x2 v)
		{
			return csum(fold_to_uint(v.c0) * uint4(1521739981u, 1735296007u, 3010324327u, 1875523709u) + fold_to_uint(v.c1) * uint4(2937008387u, 3835713223u, 2216526373u, 3375971453u)) + 3559829411u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint4 hashwide(double4x2 v)
		{
			return fold_to_uint(v.c0) * uint4(3652178029u, 2544260129u, 2013864031u, 2627668003u) + fold_to_uint(v.c1) * uint4(1520214331u, 2949502447u, 2827819133u, 3480140317u) + 2642994593u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(double4 c0, double4 c1, double4 c2)
		{
			return new double4x3(c0, c1, c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22, double m30, double m31, double m32)
		{
			return new double4x3(m00, m01, m02, m10, m11, m12, m20, m21, m22, m30, m31, m32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(double v)
		{
			return new double4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(bool v)
		{
			return new double4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(bool4x3 v)
		{
			return new double4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(int v)
		{
			return new double4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(int4x3 v)
		{
			return new double4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(uint v)
		{
			return new double4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(uint4x3 v)
		{
			return new double4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(float v)
		{
			return new double4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x3 double4x3(float4x3 v)
		{
			return new double4x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3x4 transpose(double4x3 v)
		{
			return double3x4(v.c0.x, v.c0.y, v.c0.z, v.c0.w, v.c1.x, v.c1.y, v.c1.z, v.c1.w, v.c2.x, v.c2.y, v.c2.z, v.c2.w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double4x3 v)
		{
			return csum(fold_to_uint(v.c0) * uint4(2057338067u, 2942577577u, 2834440507u, 2671762487u) + fold_to_uint(v.c1) * uint4(2892026051u, 2455987759u, 3868600063u, 3170963179u) + fold_to_uint(v.c2) * uint4(2632835537u, 1136528209u, 2944626401u, 2972762423u)) + 1417889653;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint4 hashwide(double4x3 v)
		{
			return fold_to_uint(v.c0) * uint4(2080514593u, 2731544287u, 2828498809u, 2669441947u) + fold_to_uint(v.c1) * uint4(1260114311u, 2650080659u, 4052675461u, 2652487619u) + fold_to_uint(v.c2) * uint4(2174136431u, 3528391193u, 2105559227u, 1899745391u) + 1966790317u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(double4 c0, double4 c1, double4 c2, double4 c3)
		{
			return new double4x4(c0, c1, c2, c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33)
		{
			return new double4x4(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(double v)
		{
			return new double4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(bool v)
		{
			return new double4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(bool4x4 v)
		{
			return new double4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(int v)
		{
			return new double4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(int4x4 v)
		{
			return new double4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(uint v)
		{
			return new double4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(uint4x4 v)
		{
			return new double4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(float v)
		{
			return new double4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 double4x4(float4x4 v)
		{
			return new double4x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 rotate(double4x4 a, double3 b)
		{
			return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z).xyz;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double3 transform(double4x4 a, double3 b)
		{
			return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3).xyz;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double4x4 transpose(double4x4 v)
		{
			return double4x4(v.c0.x, v.c0.y, v.c0.z, v.c0.w, v.c1.x, v.c1.y, v.c1.z, v.c1.w, v.c2.x, v.c2.y, v.c2.z, v.c2.w, v.c3.x, v.c3.y, v.c3.z, v.c3.w);
		}

		public static double4x4 inverse(double4x4 m)
		{
			double4 c = m.c0;
			double4 c2 = m.c1;
			double4 c3 = m.c2;
			double4 c4 = m.c3;
			double4 double5 = movelh(c2, c);
			double4 double6 = movelh(c3, c4);
			double4 double7 = movehl(c, c2);
			double4 double8 = movehl(c4, c3);
			double4 double9 = shuffle(c2, c, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ);
			double4 double10 = shuffle(c3, c4, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ);
			double4 double11 = shuffle(c2, c, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX);
			double4 double12 = shuffle(c3, c4, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX);
			double4 double13 = shuffle(double6, double5, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
			double4 double14 = shuffle(double6, double5, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW);
			double4 double15 = shuffle(double8, double7, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
			double4 double16 = shuffle(double8, double7, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW);
			double4 double17 = shuffle(double5, double6, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
			double4 double18 = double9 * double8 - double10 * double7;
			double4 double19 = double5 * double8 - double6 * double7;
			double4 double20 = double12 * double5 - double11 * double6;
			double4 double21 = shuffle(double18, double18, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
			double4 double22 = shuffle(double18, double18, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
			double4 double23 = shuffle(double19, double19, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
			double4 double24 = shuffle(double19, double19, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
			double4 double25 = double16 * double21 - double15 * double24 + double14 * double22;
			double4 double26 = double17 * double25;
			double26 += shuffle(double26, double26, ShuffleComponent.LeftY, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightZ);
			double26 -= shuffle(double26, double26, ShuffleComponent.LeftZ, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.RightX);
			double4 double27 = double4(1.0) / double26;
			double4x4 result = default(double4x4);
			result.c0 = double25 * double27;
			double4 double28 = shuffle(double20, double20, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
			double4 double29 = shuffle(double20, double20, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
			double4 double30 = double15 * double28 - double13 * double22 - double16 * double23;
			result.c1 = double30 * double27;
			double4 double31 = double13 * double24 - double14 * double28 - double16 * double29;
			result.c2 = double31 * double27;
			double4 double32 = double14 * double23 - double13 * double21 + double15 * double29;
			result.c3 = double32 * double27;
			return result;
		}

		public static double4x4 fastinverse(double4x4 m)
		{
			double4 c = m.c0;
			double4 c2 = m.c1;
			double4 c3 = m.c2;
			double4 c4 = m.c3;
			double4 b = double4(0);
			double4 a = unpacklo(c, c3);
			double4 b2 = unpacklo(c2, b);
			double4 a2 = unpackhi(c, c3);
			double4 b3 = unpackhi(c2, b);
			double4 double5 = unpacklo(a, b2);
			double4 double6 = unpackhi(a, b2);
			double4 double7 = unpacklo(a2, b3);
			c4 = -(double5 * c4.x + double6 * c4.y + double7 * c4.z);
			c4.w = 1.0;
			return double4x4(double5, double6, double7, c4);
		}

		public static double determinant(double4x4 m)
		{
			double4 c = m.c0;
			double4 c2 = m.c1;
			double4 c3 = m.c2;
			double4 c4 = m.c3;
			double num = c2.y * (c3.z * c4.w - c3.w * c4.z) - c3.y * (c2.z * c4.w - c2.w * c4.z) + c4.y * (c2.z * c3.w - c2.w * c3.z);
			double num2 = c.y * (c3.z * c4.w - c3.w * c4.z) - c3.y * (c.z * c4.w - c.w * c4.z) + c4.y * (c.z * c3.w - c.w * c3.z);
			double num3 = c.y * (c2.z * c4.w - c2.w * c4.z) - c2.y * (c.z * c4.w - c.w * c4.z) + c4.y * (c.z * c2.w - c.w * c2.z);
			double num4 = c.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c.z * c3.w - c.w * c3.z) + c3.y * (c.z * c2.w - c.w * c2.z);
			return c.x * num - c2.x * num2 + c3.x * num3 - c4.x * num4;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(double4x4 v)
		{
			return csum(fold_to_uint(v.c0) * uint4(1306289417u, 2096137163u, 1548578029u, 4178800919u) + fold_to_uint(v.c1) * uint4(3898072289u, 4129428421u, 2631575897u, 2854656703u) + fold_to_uint(v.c2) * uint4(3578504047u, 4245178297u, 2173281923u, 2973357649u) + fold_to_uint(v.c3) * uint4(3881277847u, 4017968839u, 1727237899u, 1648514723u)) + 1385344481;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint4 hashwide(double4x4 v)
		{
			return fold_to_uint(v.c0) * uint4(3538260197u, 4066109527u, 2613148903u, 3367528529u) + fold_to_uint(v.c1) * uint4(1678332449u, 2918459647u, 2744611081u, 1952372791u) + fold_to_uint(v.c2) * uint4(2631698677u, 4200781601u, 2119021007u, 1760485621u) + fold_to_uint(v.c3) * uint4(3157985881u, 2171534173u, 2723054263u, 1168253063u) + 4228926523u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(float x, float y)
		{
			return new float2(x, y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(float2 xy)
		{
			return new float2(xy);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(float v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(bool v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(bool2 v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(int v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(int2 v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(uint v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(uint2 v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(half v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(half2 v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(double v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 float2(double2 v)
		{
			return new float2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(float2 v)
		{
			return csum(asuint(v) * uint2(4198118021u, 2908068253u)) + 3705492289u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(float2 v)
		{
			return asuint(v) * uint2(2497566569u, 2716413241u) + 1166264321u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float shuffle(float2 left, float2 right, ShuffleComponent x)
		{
			return select_shuffle_component(left, right, x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 shuffle(float2 left, float2 right, ShuffleComponent x, ShuffleComponent y)
		{
			return float2(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 shuffle(float2 left, float2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
		{
			return float3(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float4 shuffle(float2 left, float2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
		{
			return float4(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z), select_shuffle_component(left, right, w));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float select_shuffle_component(float2 a, float2 b, ShuffleComponent component)
		{
			return component switch
			{
				ShuffleComponent.LeftX => a.x, 
				ShuffleComponent.LeftY => a.y, 
				ShuffleComponent.RightX => b.x, 
				ShuffleComponent.RightY => b.y, 
				_ => throw new ArgumentException("Invalid shuffle component: " + component), 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(float2 c0, float2 c1)
		{
			return new float2x2(c0, c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(float m00, float m01, float m10, float m11)
		{
			return new float2x2(m00, m01, m10, m11);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(float v)
		{
			return new float2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(bool v)
		{
			return new float2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(bool2x2 v)
		{
			return new float2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(int v)
		{
			return new float2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(int2x2 v)
		{
			return new float2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(uint v)
		{
			return new float2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(uint2x2 v)
		{
			return new float2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(double v)
		{
			return new float2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 float2x2(double2x2 v)
		{
			return new float2x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 transpose(float2x2 v)
		{
			return float2x2(v.c0.x, v.c0.y, v.c1.x, v.c1.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x2 inverse(float2x2 m)
		{
			float x = m.c0.x;
			float x2 = m.c1.x;
			float y = m.c0.y;
			float y2 = m.c1.y;
			float num = x * y2 - x2 * y;
			return float2x2(y2, 0f - x2, 0f - y, x) * (1f / num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float determinant(float2x2 m)
		{
			float x = m.c0.x;
			float x2 = m.c1.x;
			float y = m.c0.y;
			float y2 = m.c1.y;
			return x * y2 - x2 * y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(float2x2 v)
		{
			return csum(asuint(v.c0) * uint2(2627668003u, 1520214331u) + asuint(v.c1) * uint2(2949502447u, 2827819133u)) + 3480140317u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(float2x2 v)
		{
			return asuint(v.c0) * uint2(2642994593u, 3940484981u) + asuint(v.c1) * uint2(1954192763u, 1091696537u) + 3052428017u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(float2 c0, float2 c1, float2 c2)
		{
			return new float2x3(c0, c1, c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(float m00, float m01, float m02, float m10, float m11, float m12)
		{
			return new float2x3(m00, m01, m02, m10, m11, m12);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(float v)
		{
			return new float2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(bool v)
		{
			return new float2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(bool2x3 v)
		{
			return new float2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(int v)
		{
			return new float2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(int2x3 v)
		{
			return new float2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(uint v)
		{
			return new float2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(uint2x3 v)
		{
			return new float2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(double v)
		{
			return new float2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 float2x3(double2x3 v)
		{
			return new float2x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 transpose(float2x3 v)
		{
			return float3x2(v.c0.x, v.c0.y, v.c1.x, v.c1.y, v.c2.x, v.c2.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(float2x3 v)
		{
			return csum(asuint(v.c0) * uint2(3898072289u, 4129428421u) + asuint(v.c1) * uint2(2631575897u, 2854656703u) + asuint(v.c2) * uint2(3578504047u, 4245178297u)) + 2173281923u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(float2x3 v)
		{
			return asuint(v.c0) * uint2(2973357649u, 3881277847u) + asuint(v.c1) * uint2(4017968839u, 1727237899u) + asuint(v.c2) * uint2(1648514723u, 1385344481u) + 3538260197u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(float2 c0, float2 c1, float2 c2, float2 c3)
		{
			return new float2x4(c0, c1, c2, c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13)
		{
			return new float2x4(m00, m01, m02, m03, m10, m11, m12, m13);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(float v)
		{
			return new float2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(bool v)
		{
			return new float2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(bool2x4 v)
		{
			return new float2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(int v)
		{
			return new float2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(int2x4 v)
		{
			return new float2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(uint v)
		{
			return new float2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(uint2x4 v)
		{
			return new float2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(double v)
		{
			return new float2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x4 float2x4(double2x4 v)
		{
			return new float2x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float4x2 transpose(float2x4 v)
		{
			return float4x2(v.c0.x, v.c0.y, v.c1.x, v.c1.y, v.c2.x, v.c2.y, v.c3.x, v.c3.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(float2x4 v)
		{
			return csum(asuint(v.c0) * uint2(3546061613u, 2702024231u) + asuint(v.c1) * uint2(1452124841u, 1966089551u) + asuint(v.c2) * uint2(2668168249u, 1587512777u) + asuint(v.c3) * uint2(2353831999u, 3101256173u)) + 2891822459u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint2 hashwide(float2x4 v)
		{
			return asuint(v.c0) * uint2(2837054189u, 3016004371u) + asuint(v.c1) * uint2(4097481403u, 2229788699u) + asuint(v.c2) * uint2(2382715877u, 1851936439u) + asuint(v.c3) * uint2(1938025801u, 3712598587u) + 3956330501u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(float x, float y, float z)
		{
			return new float3(x, y, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(float x, float2 yz)
		{
			return new float3(x, yz);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(float2 xy, float z)
		{
			return new float3(xy, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(float3 xyz)
		{
			return new float3(xyz);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(float v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(bool v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(bool3 v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(int v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(int3 v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(uint v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(uint3 v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(half v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(half3 v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(double v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 float3(double3 v)
		{
			return new float3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(float3 v)
		{
			return csum(asuint(v) * uint3(2601761069u, 1254033427u, 2248573027u)) + 3612677113u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(float3 v)
		{
			return asuint(v) * uint3(1521739981u, 1735296007u, 3010324327u) + 1875523709u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float shuffle(float3 left, float3 right, ShuffleComponent x)
		{
			return select_shuffle_component(left, right, x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2 shuffle(float3 left, float3 right, ShuffleComponent x, ShuffleComponent y)
		{
			return float2(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3 shuffle(float3 left, float3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
		{
			return float3(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float4 shuffle(float3 left, float3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
		{
			return float4(select_shuffle_component(left, right, x), select_shuffle_component(left, right, y), select_shuffle_component(left, right, z), select_shuffle_component(left, right, w));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float select_shuffle_component(float3 a, float3 b, ShuffleComponent component)
		{
			return component switch
			{
				ShuffleComponent.LeftX => a.x, 
				ShuffleComponent.LeftY => a.y, 
				ShuffleComponent.LeftZ => a.z, 
				ShuffleComponent.RightX => b.x, 
				ShuffleComponent.RightY => b.y, 
				ShuffleComponent.RightZ => b.z, 
				_ => throw new ArgumentException("Invalid shuffle component: " + component), 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(float3 c0, float3 c1)
		{
			return new float3x2(c0, c1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(float m00, float m01, float m10, float m11, float m20, float m21)
		{
			return new float3x2(m00, m01, m10, m11, m20, m21);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(float v)
		{
			return new float3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(bool v)
		{
			return new float3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(bool3x2 v)
		{
			return new float3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(int v)
		{
			return new float3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(int3x2 v)
		{
			return new float3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(uint v)
		{
			return new float3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(uint3x2 v)
		{
			return new float3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(double v)
		{
			return new float3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x2 float3x2(double3x2 v)
		{
			return new float3x2(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float2x3 transpose(float3x2 v)
		{
			return float2x3(v.c0.x, v.c0.y, v.c0.z, v.c1.x, v.c1.y, v.c1.z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(float3x2 v)
		{
			return csum(asuint(v.c0) * uint3(3777095341u, 3385463369u, 1773538433u) + asuint(v.c1) * uint3(3773525029u, 4131962539u, 1809525511u)) + 4016293529u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(float3x2 v)
		{
			return asuint(v.c0) * uint3(2416021567u, 2828384717u, 2636362241u) + asuint(v.c1) * uint3(1258410977u, 1952565773u, 2037535609u) + 3592785499u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(float3 c0, float3 c1, float3 c2)
		{
			return new float3x3(c0, c1, c2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22)
		{
			return new float3x3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(float v)
		{
			return new float3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(bool v)
		{
			return new float3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(bool3x3 v)
		{
			return new float3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(int v)
		{
			return new float3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(int3x3 v)
		{
			return new float3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(uint v)
		{
			return new float3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(uint3x3 v)
		{
			return new float3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(double v)
		{
			return new float3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 float3x3(double3x3 v)
		{
			return new float3x3(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x3 transpose(float3x3 v)
		{
			return float3x3(v.c0.x, v.c0.y, v.c0.z, v.c1.x, v.c1.y, v.c1.z, v.c2.x, v.c2.y, v.c2.z);
		}

		public static float3x3 inverse(float3x3 m)
		{
			float3 c = m.c0;
			float3 c2 = m.c1;
			float3 c3 = m.c2;
			float3 float5 = float3(c2.x, c3.x, c.x);
			float3 float6 = float3(c2.y, c3.y, c.y);
			float3 float7 = float3(c2.z, c3.z, c.z);
			float3 float8 = float6 * float7.yzx - float6.yzx * float7;
			float3 c4 = float5.yzx * float7 - float5 * float7.yzx;
			float3 c5 = float5 * float6.yzx - float5.yzx * float6;
			float num = 1f / csum(float5.zxy * float8);
			return float3x3(float8, c4, c5) * num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float determinant(float3x3 m)
		{
			float3 c = m.c0;
			float3 c2 = m.c1;
			float3 c3 = m.c2;
			float num = c2.y * c3.z - c2.z * c3.y;
			float num2 = c.y * c3.z - c.z * c3.y;
			float num3 = c.y * c2.z - c.z * c2.y;
			return c.x * num - c2.x * num2 + c3.x * num3;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(float3x3 v)
		{
			return csum(asuint(v.c0) * uint3(1899745391u, 1966790317u, 3516359879u) + asuint(v.c1) * uint3(3050356579u, 4178586719u, 2558655391u) + asuint(v.c2) * uint3(1453413133u, 2152428077u, 1938706661u)) + 1338588197;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(float3x3 v)
		{
			return asuint(v.c0) * uint3(3439609253u, 3535343003u, 3546061613u) + asuint(v.c1) * uint3(2702024231u, 1452124841u, 1966089551u) + asuint(v.c2) * uint3(2668168249u, 1587512777u, 2353831999u) + 3101256173u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(float3 c0, float3 c1, float3 c2, float3 c3)
		{
			return new float3x4(c0, c1, c2, c3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23)
		{
			return new float3x4(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(float v)
		{
			return new float3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(bool v)
		{
			return new float3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(bool3x4 v)
		{
			return new float3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(int v)
		{
			return new float3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(int3x4 v)
		{
			return new float3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(uint v)
		{
			return new float3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(uint3x4 v)
		{
			return new float3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(double v)
		{
			return new float3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float3x4 float3x4(double3x4 v)
		{
			return new float3x4(v);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float4x3 transpose(float3x4 v)
		{
			return float4x3(v.c0.x, v.c0.y, v.c0.z, v.c1.x, v.c1.y, v.c1.z, v.c2.x, v.c2.y, v.c2.z, v.c3.x, v.c3.y, v.c3.z);
		}

		public static float3x4 fastinverse(float3x4 m)
		{
			float3 c = m.c0;
			float3 c2 = m.c1;
			float3 c3 = m.c2;
			float3 c4 = m.c3;
			float3 float5 = float3(c.x, c2.x, c3.x);
			float3 float6 = float3(c.y, c2.y, c3.y);
			float3 float7 = float3(c.z, c2.z, c3.z);
			c4 = -(float5 * c4.x + float6 * c4.y + float7 * c4.z);
			return float3x4(float5, float6, float7, c4);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint hash(float3x4 v)
		{
			return csum(asuint(v.c0) * uint3(4192899797u, 3271228601u, 1634639009u) + asuint(v.c1) * uint3(3318036811u, 3404170631u, 2048213449u) + asuint(v.c2) * uint3(4164671783u, 1780759499u, 1352369353u) + asuint(v.c3) * uint3(2446407751u, 1391928079u, 3475533443u)) + 3777095341u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint3 hashwide(float3x4 v)
		{
			return asuint(v.c0) * uint3(3385463369u, 1773538433u, 3773525029u) + asuint(v.c1) * uint3(4131962539u, 1809525511u, 4016293529u) + asuint(v.c2) * uint3(2416021567u, 2828384717u, 2636362241u) + asuint(v.c3) * uint3(1258410977u, 1952565773u, 2037535609u) + 3592785499u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float4 float4(float x, float y, float z, float w)
		{
			return new float4(x, y, z, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float4 float4(float x, float y, float2 zw)
		{
			return new float4(x, y, zw);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float4 float4(float x, float2 yz, float w)
		{
			return new float4(x, yz, w);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		publ

Get the Thunderstore App

Decompiled source of StatsPlus v1.1.0

StatsMod.dll

Unity.Mathematics.dll

About

Developers