using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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 System.Text.RegularExpressions;
using UnityEngine;
using UnityEngine.SceneManagement;
using Vheos.Helpers.Common;
using Vheos.Helpers.Math;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Vheos.Helpers.UnityObjects
{
	public static class Extensions_Camera
	{
		public static Ray CursorRay(this Camera @this)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return @this.ScreenPointToRay(Input.mousePosition);
		}

		public static Plane ScreenPlane(this Camera @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return new Plane(((Component)@this).transform.forward.Neg(), a);
		}

		public static Plane ScreenPlane(this Camera @this, float a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return new Plane(((Component)@this).transform.forward.Neg(), a);
		}

		public static Vector3 CursorToWorldPoint(this Camera @this, float a)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return @this.ScreenToWorldPoint(Input.mousePosition.XY().Append(a));
		}

		public static Vector3 CursorToPlanePoint(this Camera @this, Plane a)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			Ray val = @this.CursorRay();
			float num = default(float);
			if (!((Plane)(ref a)).Raycast(val, ref num))
			{
				return float.NaN.ToVector3();
			}
			return ((Ray)(ref val)).GetPoint(num);
		}
	}
	public static class Extensions_MonoBehaviour
	{
		public static void Enable(this MonoBehaviour t)
		{
			((Behaviour)t).enabled = true;
		}

		public static void Disable(this MonoBehaviour t)
		{
			((Behaviour)t).enabled = false;
		}

		public static Coroutine ExecuteAfterUpdate(this MonoBehaviour @this, Action action)
		{
			return @this.StartCoroutine(AfterUpdate(action));
		}

		public static Coroutine ExecuteAfterFixedUpdate(this MonoBehaviour @this, Action action)
		{
			return @this.StartCoroutine(AfterFixedUpdate(action));
		}

		public static Coroutine ExecuteAfterCurrentUpdate(this MonoBehaviour @this, Action action)
		{
			return @this.StartCoroutine(AfterCurrentUpdate(action));
		}

		public static Coroutine ExecuteAfterSeconds(this MonoBehaviour @this, float delay, Action action)
		{
			return @this.StartCoroutine(AfterSeconds(delay, action));
		}

		public static Coroutine ExecuteAfterRealSeconds(this MonoBehaviour @this, float delay, Action action)
		{
			return @this.StartCoroutine(AfterRealSeconds(delay, action));
		}

		public static Coroutine ExecuteAfterCheck(this MonoBehaviour @this, Func<bool> test, Action action)
		{
			return @this.StartCoroutine(AfterCheck(test, action));
		}

		public static Coroutine ExecuteWhile(this MonoBehaviour @this, Func<bool> test, Action action, Action finalAction = null)
		{
			return @this.StartCoroutine(While(test, action, finalAction));
		}

		public static Coroutine ExecuteWhileNot(this MonoBehaviour @this, Func<bool> test, Action action, Action finalAction = null)
		{
			return @this.StartCoroutine(WhileNot(test, action, finalAction));
		}

		public static Coroutine ExecuteUntil(this MonoBehaviour @this, Func<bool> test, Action action, Action finalAction = null)
		{
			return @this.StartCoroutine(Until(test, action, finalAction));
		}

		public static Coroutine ExecuteUntilNot(this MonoBehaviour @this, Func<bool> test, Action action, Action finalAction = null)
		{
			return @this.StartCoroutine(UntilNot(test, action, finalAction));
		}

		private static IEnumerator AfterUpdate(Action action)
		{
			yield return (object)new WaitForEndOfFrame();
			action();
		}

		private static IEnumerator AfterFixedUpdate(Action action)
		{
			yield return (object)new WaitForFixedUpdate();
			action();
		}

		private static IEnumerator AfterCurrentUpdate(Action action)
		{
			yield return (object)(Time.inFixedTimeStep ? new WaitForFixedUpdate() : new WaitForEndOfFrame());
			action();
		}

		private static IEnumerator AfterSeconds(float delay, Action action)
		{
			yield return (object)new WaitForSeconds(delay);
			action();
		}

		private static IEnumerator AfterRealSeconds(float delay, Action action)
		{
			yield return (object)new WaitForSecondsRealtime(delay);
			action();
		}

		private static IEnumerator AfterCheck(Func<bool> check, Action action)
		{
			yield return (object)new WaitUntil(check);
			action();
		}

		private static IEnumerator While(Func<bool> test, Action action, Action finalAction = null)
		{
			while (test())
			{
				action();
				yield return null;
			}
			finalAction?.Invoke();
		}

		private static IEnumerator WhileNot(Func<bool> test, Action action, Action finalAction = null)
		{
			while (!test())
			{
				action();
				yield return null;
			}
			finalAction?.Invoke();
		}

		private static IEnumerator Until(Func<bool> test, Action action, Action finalAction = null)
		{
			do
			{
				action();
				yield return null;
			}
			while (!test());
			finalAction?.Invoke();
		}

		private static IEnumerator UntilNot(Func<bool> test, Action action, Action finalAction = null)
		{
			do
			{
				action();
				yield return null;
			}
			while (test());
			finalAction?.Invoke();
		}
	}
	public static class Extensions_Component
	{
		public static void Activate(this Component t)
		{
			t.gameObject.SetActive(true);
		}

		public static void Deactivate(this Component t)
		{
			t.gameObject.SetActive(false);
		}

		public static bool IsActive(this Component t)
		{
			return t.gameObject.activeSelf;
		}

		public static bool IsActiveInHierarchy(this Component t)
		{
			return t.gameObject.activeInHierarchy;
		}

		public static void ToggleActive(this Component t)
		{
			t.gameObject.ToggleActive();
		}

		public static void SetActive(this Component t, bool state)
		{
			t.gameObject.SetActive(state);
		}

		public static void Unparent(this Component @this, bool retainWorldTransform = false)
		{
			@this.gameObject.Unparent(retainWorldTransform);
		}

		public static void MoveToScene(this Component @this, Scene scene)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			@this.gameObject.MoveToScene(scene);
		}

		public static void BecomeSiblingOf(this Component @this, GameObject a, bool retainWorldTransform = false)
		{
			@this.gameObject.BecomeSiblingOf(a, retainWorldTransform);
		}

		public static void BecomeChildOf(this Component @this, GameObject a, bool retainWorldTransform = false)
		{
			@this.gameObject.BecomeChildOf(a, retainWorldTransform);
		}

		public static void BecomeSiblingOf(this Component @this, Component a, bool retainWorldTransform = false)
		{
			@this.gameObject.BecomeSiblingOf(a, retainWorldTransform);
		}

		public static void BecomeChildOf(this Component @this, Component a, bool retainWorldTransform = false)
		{
			@this.gameObject.BecomeChildOf(a, retainWorldTransform);
		}

		public static bool IsAtRoot(this Component @this)
		{
			return @this.gameObject.IsAtRoot();
		}

		public static bool HasParent(this Component @this)
		{
			return @this.gameObject.HasParent();
		}

		public static bool HasAnyChild(this Component @this)
		{
			return @this.gameObject.HasAnyChild();
		}

		public static bool IsParentOf(this Component @this, GameObject a)
		{
			return @this.gameObject.IsParentOf(a);
		}

		public static bool IsSiblingOf(this Component @this, GameObject a)
		{
			return @this.gameObject.IsSiblingOf(a);
		}

		public static bool IsChildOf(this Component @this, GameObject a)
		{
			return @this.gameObject.IsChildOf(a);
		}

		public static bool IsParentOf(this Component @this, Component a)
		{
			return @this.gameObject.IsParentOf(a);
		}

		public static bool IsSiblingOf(this Component @this, Component a)
		{
			return @this.gameObject.IsSiblingOf(a);
		}

		public static bool IsChildOf(this Component @this, Component a)
		{
			return @this.gameObject.IsChildOf(a);
		}

		public static GameObject FindChild(this Component @this, string a)
		{
			return @this.gameObject.FindChild(a);
		}

		public static T FindChild<T>(this Component @this, string a) where T : Component
		{
			return @this.gameObject.FindChild<T>(a);
		}

		public static GameObject GetParent(this Component @this)
		{
			return @this.gameObject.GetParent();
		}

		public static IEnumerable<GameObject> GetAncestors(this Component @this)
		{
			return @this.gameObject.GetAncestors();
		}

		public static GameObject GetRootAncestor(this Component @this)
		{
			return @this.gameObject.GetRootAncestor();
		}

		public static float DistanceTo(this Component @this, GameObject a)
		{
			return @this.gameObject.DistanceTo(a);
		}

		public static Vector3 OffsetTo(this Component @this, GameObject a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.OffsetTo(a);
		}

		public static Vector3 OffsetFrom(this Component @this, GameObject a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.OffsetFrom(a);
		}

		public static Vector3 DirectionTowards(this Component @this, GameObject a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.DirectionTowards(a);
		}

		public static Vector3 DirectionAwayFrom(this Component @this, GameObject a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.DirectionAwayFrom(a);
		}

		public static Ray RayTowards(this Component @this, GameObject a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.RayTowards(a);
		}

		public static Ray RayAwayFrom(this Component @this, GameObject a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.RayAwayFrom(a);
		}

		public static float ScreenDistanceTo(this Component @this, GameObject a, Camera b)
		{
			return @this.gameObject.ScreenDistanceTo(a, b);
		}

		public static Vector2 ScreenOffsetTo(this Component @this, GameObject a, Camera b)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenOffsetTo(a, b);
		}

		public static Vector2 ScreenOffsetFrom(this Component @this, GameObject a, Camera b)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenOffsetFrom(a, b);
		}

		public static Vector2 ScreenDirectionTowards(this Component @this, GameObject a, Camera b)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenDirectionTowards(a, b);
		}

		public static Vector2 ScreenDirectionAwayFrom(this Component @this, GameObject a, Camera b)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenDirectionAwayFrom(a, b);
		}

		public static float DistanceTo(this Component @this, Component a)
		{
			return @this.gameObject.DistanceTo(a);
		}

		public static Vector3 OffsetTo(this Component @this, Component a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.OffsetTo(a);
		}

		public static Vector3 OffsetFrom(this Component @this, Component a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.OffsetFrom(a);
		}

		public static Vector3 DirectionTowards(this Component @this, Component a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.DirectionTowards(a);
		}

		public static Vector3 DirectionAwayFrom(this Component @this, Component a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.DirectionAwayFrom(a);
		}

		public static Ray RayTowards(this Component @this, Component a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.RayTowards(a);
		}

		public static Ray RayAwayFrom(this Component @this, Component a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.RayAwayFrom(a);
		}

		public static float ScreenDistanceTo(this Component @this, Component a, Camera b)
		{
			return @this.gameObject.ScreenDistanceTo(a, b);
		}

		public static Vector2 ScreenOffsetTo(this Component @this, Component a, Camera b)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenOffsetTo(a, b);
		}

		public static Vector2 ScreenOffsetFrom(this Component @this, Component a, Camera b)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenOffsetFrom(a, b);
		}

		public static Vector2 ScreenDirectionTowards(this Component @this, Component a, Camera b)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenDirectionTowards(a, b);
		}

		public static Vector2 ScreenDirectionAwayFrom(this Component @this, Component a, Camera b)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenDirectionAwayFrom(a, b);
		}

		public static float DistanceTo(this Component @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.DistanceTo(a);
		}

		public static Vector3 OffsetTo(this Component @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.OffsetTo(a);
		}

		public static Vector3 OffsetFrom(this Component @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.OffsetFrom(a);
		}

		public static Vector3 DirectionTowards(this Component @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.DirectionTowards(a);
		}

		public static Vector3 DirectionAwayFrom(this Component @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.DirectionAwayFrom(a);
		}

		public static Ray RayTowards(this Component @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.RayTowards(a);
		}

		public static Ray RayAwayFrom(this Component @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.RayAwayFrom(a);
		}

		public static float ScreenDistanceTo(this Component @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenDistanceTo(a, b);
		}

		public static Vector2 ScreenOffsetTo(this Component @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenOffsetTo(a, b);
		}

		public static Vector2 ScreenOffsetFrom(this Component @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenOffsetFrom(a, b);
		}

		public static Vector2 ScreenDirectionTowards(this Component @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenDirectionTowards(a, b);
		}

		public static Vector2 ScreenDirectionAwayFrom(this Component @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return @this.gameObject.ScreenDirectionAwayFrom(a, b);
		}

		public static bool HasComponent<T>(this Component @this) where T : Component
		{
			return @this.gameObject.HasComponent<T>();
		}

		public static bool ParentHasComponent<T>(this Component @this) where T : Component
		{
			return @this.gameObject.ParentHasComponent<T>();
		}

		public static bool ChildHasComponent<T>(this Component @this) where T : Component
		{
			return @this.gameObject.ChildHasComponent<T>();
		}

		public static GameObject CreateSiblingGameObject(this Component @this, string name = null)
		{
			return @this.gameObject.CreateSiblingGameObject(name);
		}

		public static T CreateSiblingComponent<T>(this Component @this, T a, string name = null) where T : Component
		{
			return @this.gameObject.CreateSiblingComponent(a, name);
		}

		public static T CreateSiblingComponent<T>(this Component @this, string name = null) where T : Component
		{
			return @this.gameObject.CreateSiblingComponent<T>(name);
		}

		public static GameObject CreateChildGameObject(this Component @this, string name = null)
		{
			return @this.gameObject.CreateChildGameObject(name);
		}

		public static T CreateChildComponent<T>(this Component @this, T a, string name = null) where T : Component
		{
			return @this.gameObject.CreateChildComponent(a, name);
		}

		public static T CreateChildComponent<T>(this Component @this, string name = null) where T : Component
		{
			return @this.gameObject.CreateChildComponent<T>(name);
		}

		public static T GetOrAddComponent<T>(this Component @this) where T : Component
		{
			return @this.gameObject.GetOrAddComponent<T>();
		}

		public static IEnumerable<GameObject> GetChildGameObjects(this Component @this)
		{
			return @this.gameObject.GetChildGameObjects();
		}

		public static IEnumerable<GameObject> GetSiblingGameObjects(this Component @this)
		{
			return @this.gameObject.GetSiblingGameObjects();
		}

		public static IEnumerable<T> GetChildComponents<T>(this Component @this) where T : Component
		{
			return @this.gameObject.GetChildComponents<T>();
		}

		public static IEnumerable<T> GetSiblingComponents<T>(this Component @this) where T : Component
		{
			return @this.gameObject.GetSiblingComponents<T>();
		}

		public static IEnumerable<GameObject> GetGameObjects<T>(this IEnumerable<T> @this) where T : Component
		{
			foreach (T item in @this)
			{
				yield return ((Component)item).gameObject;
			}
		}

		public static T GetChildComponent<T>(this Component @this) where T : Component
		{
			return @this.gameObject.GetChildComponent<T>();
		}

		public static T GetSiblingComponent<T>(this Component @this) where T : Component
		{
			return @this.gameObject.GetSiblingComponent<T>();
		}

		public static bool TryGetComponent<T>(this Component @this, out T a) where T : Component
		{
			return @this.gameObject.TryGetComponent<T>(out a);
		}

		public static void Destroy(this Component @this)
		{
			if ((Object)(object)@this != (Object)null)
			{
				Object.Destroy((Object)(object)@this);
			}
		}

		public static void DestroyInstantly(this Component @this)
		{
			if ((Object)(object)@this != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)@this);
			}
		}

		public static void Destroy<T>(this IEnumerable<T> @this) where T : Component
		{
			foreach (T item in @this)
			{
				if ((Object)(object)item != (Object)null)
				{
					Object.Destroy((Object)(object)item);
				}
			}
		}

		public static void DestroyInstantly<T>(this IEnumerable<T> @this) where T : Component
		{
			foreach (T item in @this)
			{
				if ((Object)(object)item != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)item);
				}
			}
		}

		public static void DestroyObject(this Component @this)
		{
			if ((Object)(object)@this != (Object)null)
			{
				Object.Destroy((Object)(object)@this.gameObject);
			}
		}

		public static void DestroyObjectInstantly(this Component @this)
		{
			if ((Object)(object)@this != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)@this.gameObject);
			}
		}

		public static void DestroyObject<T>(this IEnumerable<T> @this) where T : Component
		{
			foreach (T item in @this)
			{
				if ((Object)(object)item != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
			}
		}

		public static void DestroyObjectInstantly<T>(this IEnumerable<T> @this) where T : Component
		{
			foreach (T item in @this)
			{
				if ((Object)(object)item != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)item);
				}
			}
		}

		public static void SetPhysics(this Component @this, bool state)
		{
			@this.gameObject.SetPhysics(state);
		}

		public static void SetCollisions(this Component @this, bool state)
		{
			@this.gameObject.SetCollisions(state);
		}

		public static void ResetLocalTransform(this Component @this)
		{
			@this.gameObject.ResetLocalTransform();
		}

		public static void SetCollisionsWith(this Component @this, GameObject a, bool state)
		{
			@this.gameObject.SetCollisionsWith(a, state);
		}

		public static void SetCollisionsWith(this Component @this, IEnumerable<GameObject> aCollection, bool state)
		{
			@this.gameObject.SetCollisionsWith(aCollection, state);
		}

		public static void CopyTransformFrom(this Component @this, GameObject a)
		{
			@this.gameObject.CopyTransformFrom(a);
		}

		public static void CopyRigidbodyFrom(this Component @this, GameObject a, bool copyMassAndTensors = false)
		{
			@this.gameObject.CopyRigidbodyFrom(a, copyMassAndTensors);
		}

		public static void SetCollisionsWith(this Component @this, Component a, bool state)
		{
			@this.gameObject.SetCollisionsWith(a, state);
		}

		public static void SetCollisionsWith(this Component @this, IEnumerable<Component> aCollection, bool state)
		{
			@this.gameObject.SetCollisionsWith(aCollection, state);
		}

		public static void CopyTransformFrom(this Component @this, Component a)
		{
			@this.gameObject.CopyTransformFrom(a);
		}

		public static void CopyRigidbodyFrom(this Component @this, Component a, bool copyMassAndTensors = false)
		{
			@this.gameObject.CopyRigidbodyFrom(a, copyMassAndTensors);
		}
	}
	public static class Extensions_GameObject
	{
		public static void Activate(this GameObject t)
		{
			t.SetActive(true);
		}

		public static void Deactivate(this GameObject t)
		{
			t.SetActive(false);
		}

		public static bool IsActive(this GameObject t)
		{
			return t.activeSelf;
		}

		public static bool IsActiveInHierarchy(this GameObject t)
		{
			return t.activeInHierarchy;
		}

		public static void ToggleActive(this GameObject t)
		{
			t.SetActive(!t.activeSelf);
		}

		public static void Unparent(this GameObject @this, bool retainWorldTransform = false)
		{
			@this.transform.SetParent((Transform)null, retainWorldTransform);
		}

		public static void MoveToScene(this GameObject @this, Scene scene)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!(@this.gameObject.scene == scene))
			{
				@this.Unparent();
				SceneManager.MoveGameObjectToScene(@this, scene);
			}
		}

		public static void BecomeSiblingOf(this GameObject @this, GameObject a, bool retainWorldTransform = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (a.transform.parent.TryNonNull<Transform>(out var r))
			{
				@this.transform.SetParent(r, retainWorldTransform);
			}
			else
			{
				SceneManager.MoveGameObjectToScene(@this, a.scene);
			}
		}

		public static void BecomeChildOf(this GameObject @this, GameObject a, bool retainWorldTransform = false)
		{
			@this.transform.SetParent(a.transform, retainWorldTransform);
		}

		public static void BecomeSiblingOf(this GameObject @this, Component a, bool retainWorldTransform = false)
		{
			@this.BecomeSiblingOf(a.gameObject, retainWorldTransform);
		}

		public static void BecomeChildOf(this GameObject @this, Component a, bool retainWorldTransform = false)
		{
			@this.BecomeChildOf(a.gameObject, retainWorldTransform);
		}

		public static bool IsAtRoot(this GameObject @this)
		{
			return (Object)(object)@this.transform.parent == (Object)null;
		}

		public static bool HasParent(this GameObject @this)
		{
			return (Object)(object)@this.transform.parent != (Object)null;
		}

		public static bool HasAnyChild(this GameObject @this)
		{
			return @this.transform.childCount > 0;
		}

		public static bool IsParentOf(this GameObject @this, GameObject a)
		{
			return (Object)(object)@this.transform == (Object)(object)a.transform.parent;
		}

		public static bool IsSiblingOf(this GameObject @this, GameObject a)
		{
			return (Object)(object)@this.transform.parent == (Object)(object)a.transform.parent;
		}

		public static bool IsChildOf(this GameObject @this, GameObject a)
		{
			return (Object)(object)@this.transform.parent == (Object)(object)a.transform;
		}

		public static bool IsParentOf(this GameObject @this, Component a)
		{
			return @this.IsParentOf(a.gameObject);
		}

		public static bool IsSiblingOf(this GameObject @this, Component a)
		{
			return @this.IsSiblingOf(a.gameObject);
		}

		public static bool IsChildOf(this GameObject @this, Component a)
		{
			return @this.IsChildOf(a.gameObject);
		}

		public static GameObject FindChild(this GameObject @this, string a)
		{
			Transform val = @this.transform.Find(a);
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).gameObject;
		}

		public static T FindChild<T>(this GameObject @this, string a) where T : Component
		{
			Transform val = @this.transform.Find(a);
			if (!((Object)(object)val != (Object)null))
			{
				return default(T);
			}
			return ((Component)val).GetComponent<T>();
		}

		public static GameObject GetParent(this GameObject @this)
		{
			if (!@this.HasParent())
			{
				return null;
			}
			return ((Component)@this.transform.parent).gameObject;
		}

		public static IEnumerable<GameObject> GetAncestors(this GameObject @this)
		{
			Transform i = @this.transform.parent;
			while ((Object)(object)i != (Object)null)
			{
				yield return ((Component)i).gameObject;
				i = i.parent;
			}
		}

		public static GameObject GetRootAncestor(this GameObject @this)
		{
			Transform val = @this.transform;
			while ((Object)(object)val.parent != (Object)null)
			{
				val = val.parent;
			}
			return ((Component)val).gameObject;
		}

		public static float DistanceTo(this GameObject @this, GameObject a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.DistanceTo(a);
		}

		public static Vector3 OffsetTo(this GameObject @this, GameObject a)
		{
			//IL_0006: 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)
			return @this.transform.position.OffsetTo(a);
		}

		public static Vector3 OffsetFrom(this GameObject @this, GameObject a)
		{
			//IL_0006: 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)
			return @this.transform.position.OffsetFrom(a);
		}

		public static Vector3 DirectionTowards(this GameObject @this, GameObject a)
		{
			//IL_0006: 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)
			return @this.transform.position.DirectionTowards(a);
		}

		public static Vector3 DirectionAwayFrom(this GameObject @this, GameObject a)
		{
			//IL_0006: 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)
			return @this.transform.position.DirectionAwayFrom(a);
		}

		public static Ray RayTowards(this GameObject @this, GameObject a)
		{
			//IL_0006: 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)
			return @this.transform.position.RayTowards(a);
		}

		public static Ray RayAwayFrom(this GameObject @this, GameObject a)
		{
			//IL_0006: 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)
			return @this.transform.position.RayAwayFrom(a);
		}

		public static float ScreenDistanceTo(this GameObject @this, GameObject a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.ScreenDistanceTo(a, b);
		}

		public static Vector2 ScreenOffsetTo(this GameObject @this, GameObject a, Camera b)
		{
			//IL_0006: 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)
			return @this.transform.position.ScreenOffsetTo(a, b);
		}

		public static Vector2 ScreenOffsetFrom(this GameObject @this, GameObject a, Camera b)
		{
			//IL_0006: 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)
			return @this.transform.position.ScreenOffsetFrom(a, b);
		}

		public static Vector2 ScreenDirectionTowards(this GameObject @this, GameObject a, Camera b)
		{
			//IL_0006: 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)
			return @this.transform.position.ScreenDirectionTowards(a, b);
		}

		public static Vector2 ScreenDirectionAwayFrom(this GameObject @this, GameObject a, Camera b)
		{
			//IL_0006: 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)
			return @this.transform.position.ScreenDirectionAwayFrom(a, b);
		}

		public static float DistanceTo(this GameObject @this, Component a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.DistanceTo(a);
		}

		public static Vector3 OffsetTo(this GameObject @this, Component a)
		{
			//IL_0006: 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)
			return @this.transform.position.OffsetTo(a);
		}

		public static Vector3 OffsetFrom(this GameObject @this, Component a)
		{
			//IL_0006: 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)
			return @this.transform.position.OffsetFrom(a);
		}

		public static Vector3 DirectionTowards(this GameObject @this, Component a)
		{
			//IL_0006: 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)
			return @this.transform.position.DirectionTowards(a);
		}

		public static Vector3 DirectionAwayFrom(this GameObject @this, Component a)
		{
			//IL_0006: 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)
			return @this.transform.position.DirectionAwayFrom(a);
		}

		public static Ray RayTowards(this GameObject @this, Component a)
		{
			//IL_0006: 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)
			return @this.transform.position.RayTowards(a);
		}

		public static Ray RayAwayFrom(this GameObject @this, Component a)
		{
			//IL_0006: 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)
			return @this.transform.position.RayAwayFrom(a);
		}

		public static float ScreenDistanceTo(this GameObject @this, Component a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.ScreenDistanceTo(a, b);
		}

		public static Vector2 ScreenOffsetTo(this GameObject @this, Component a, Camera b)
		{
			//IL_0006: 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)
			return @this.transform.position.ScreenOffsetTo(a, b);
		}

		public static Vector2 ScreenOffsetFrom(this GameObject @this, Component a, Camera b)
		{
			//IL_0006: 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)
			return @this.transform.position.ScreenOffsetFrom(a, b);
		}

		public static Vector2 ScreenDirectionTowards(this GameObject @this, Component a, Camera b)
		{
			//IL_0006: 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)
			return @this.transform.position.ScreenDirectionTowards(a, b);
		}

		public static Vector2 ScreenDirectionAwayFrom(this GameObject @this, Component a, Camera b)
		{
			//IL_0006: 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)
			return @this.transform.position.ScreenDirectionAwayFrom(a, b);
		}

		public static float DistanceTo(this GameObject @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.DistanceTo(a);
		}

		public static Vector3 OffsetTo(this GameObject @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.OffsetTo(a);
		}

		public static Vector3 OffsetFrom(this GameObject @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.OffsetFrom(a);
		}

		public static Vector3 DirectionTowards(this GameObject @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.DirectionTowards(a);
		}

		public static Vector3 DirectionAwayFrom(this GameObject @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.DirectionAwayFrom(a);
		}

		public static Ray RayTowards(this GameObject @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.RayTowards(a);
		}

		public static Ray RayAwayFrom(this GameObject @this, Vector3 a)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.RayAwayFrom(a);
		}

		public static float ScreenDistanceTo(this GameObject @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.ScreenDistanceTo(a, b);
		}

		public static Vector2 ScreenOffsetTo(this GameObject @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.ScreenOffsetTo(a, b);
		}

		public static Vector2 ScreenOffsetFrom(this GameObject @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.ScreenOffsetFrom(a, b);
		}

		public static Vector2 ScreenDirectionTowards(this GameObject @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.ScreenDirectionTowards(a, b);
		}

		public static Vector2 ScreenDirectionAwayFrom(this GameObject @this, Vector3 a, Camera b)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return @this.transform.position.ScreenDirectionAwayFrom(a, b);
		}

		public static bool HasComponent<T>(this GameObject @this) where T : Component
		{
			return (Object)(object)@this.GetComponent<T>() != (Object)null;
		}

		public static bool ParentHasComponent<T>(this GameObject @this) where T : Component
		{
			return (Object)(object)@this.GetParentComponent<T>() != (Object)null;
		}

		public static bool ChildHasComponent<T>(this GameObject @this) where T : Component
		{
			return (Object)(object)@this.GetChildComponent<T>() != (Object)null;
		}

		public static bool SiblingHasComponent<T>(this GameObject @this) where T : Component
		{
			return (Object)(object)@this.GetSiblingComponent<T>() != (Object)null;
		}

		public static T GetParentComponent<T>(this GameObject @this) where T : Component
		{
			if (!@this.transform.parent.TryNonNull<Transform>(out var r))
			{
				return default(T);
			}
			return ((Component)r).GetComponent<T>();
		}

		public static T GetChildComponent<T>(this GameObject @this) where T : Component
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			foreach (Transform item in @this.transform)
			{
				if (((Component)item).TryGetComponent<T>(out var a))
				{
					return a;
				}
			}
			return default(T);
		}

		public static T GetSiblingComponent<T>(this GameObject @this) where T : Component
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			foreach (Transform item in @this.transform.parent)
			{
				Transform val = item;
				if ((Object)(object)val != (Object)(object)@this.transform && ((Component)(object)val).TryGetComponent<T>(out var a))
				{
					return a;
				}
			}
			return default(T);
		}

		public static IEnumerable<T> GetParentComponents<T>(this GameObject @this) where T : Component
		{
			foreach (Transform item in @this.transform)
			{
				Transform val = item;
				T[] components = ((Component)val).GetComponents<T>();
				for (int i = 0; i < components.Length; i++)
				{
					yield return components[i];
				}
			}
		}

		public static IEnumerable<T> GetChildComponents<T>(this GameObject @this) where T : Component
		{
			foreach (Transform item in @this.transform)
			{
				Transform val = item;
				T[] components = ((Component)val).GetComponents<T>();
				for (int i = 0; i < components.Length; i++)
				{
					yield return components[i];
				}
			}
		}

		public static IEnumerable<T> GetSiblingComponents<T>(this GameObject @this) where T : Component
		{
			foreach (Transform item in @this.transform.parent)
			{
				Transform val = item;
				if ((Object)(object)val != (Object)(object)@this.transform)
				{
					T[] components = ((Component)val).GetComponents<T>();
					for (int i = 0; i < components.Length; i++)
					{
						yield return components[i];
					}
				}
			}
		}

		public static IEnumerable<GameObject> GetChildGameObjects(this GameObject @this)
		{
			foreach (Transform item in @this.transform)
			{
				Transform val = item;
				yield return ((Component)val).gameObject;
			}
		}

		public static IEnumerable<GameObject> GetSiblingGameObjects(this GameObject @this)
		{
			foreach (Transform item in @this.transform.parent)
			{
				Transform val = item;
				if ((Object)(object)val != (Object)(object)@this.transform)
				{
					yield return ((Component)val).gameObject;
				}
			}
		}

		public static GameObject CreateChildGameObject(this GameObject @this, string name = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			GameObject val = new GameObject();
			val.BecomeChildOf(@this);
			if (name != null)
			{
				((Object)val).name = name;
			}
			return val;
		}

		public static T CreateChildComponent<T>(this GameObject @this, T a, string name = null) where T : Component
		{
			T val = Object.Instantiate<T>(a, @this.transform);
			if (name != null)
			{
				((Object)(object)val).name = name;
			}
			return val;
		}

		public static T CreateChildComponent<T>(this GameObject @this, string name = null) where T : Component
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			GameObject val = new GameObject();
			val.BecomeChildOf(@this);
			T result = val.AddComponent<T>();
			if (name != null)
			{
				((Object)val).name = name;
			}
			return result;
		}

		public static GameObject CreateSiblingGameObject(this GameObject @this, string name = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			GameObject val = new GameObject();
			val.BecomeSiblingOf(@this);
			if (name != null)
			{
				((Object)val).name = name;
			}
			return val;
		}

		public static T CreateSiblingComponent<T>(this GameObject @this, T a, string name = null) where T : Component
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			T val = Object.Instantiate<T>(a, @this.transform.parent);
			if ((Object)(object)@this.transform.parent == (Object)null)
			{
				((Component)val).gameObject.MoveToScene(@this.scene);
			}
			if (name != null)
			{
				((Object)(object)val).name = name;
			}
			return val;
		}

		public static T CreateSiblingComponent<T>(this GameObject @this, string name = null) where T : Component
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			GameObject val = new GameObject();
			val.BecomeSiblingOf(@this);
			T result = val.AddComponent<T>();
			if (name != null)
			{
				((Object)val).name = name;
			}
			return result;
		}

		public static T GetOrAddComponent<T>(this GameObject @this) where T : Component
		{
			T component = @this.GetComponent<T>();
			if (!((Object)(object)component != (Object)null))
			{
				return @this.AddComponent<T>();
			}
			return component;
		}

		public static IEnumerable<T> GetComponents<T>(this IEnumerable<GameObject> @this) where T : Component
		{
			foreach (GameObject item in @this)
			{
				T[] components = item.GetComponents<T>();
				for (int i = 0; i < components.Length; i++)
				{
					yield return components[i];
				}
			}
		}

		public static bool TryGetComponent<T>(this GameObject @this, out T a) where T : Component
		{
			a = @this.GetComponent<T>();
			return (Object)(object)a != (Object)null;
		}

		public static void Destroy(this GameObject @this)
		{
			if ((Object)(object)@this != (Object)null)
			{
				Object.Destroy((Object)(object)@this);
			}
		}

		public static void DestroyInstantly(this GameObject @this)
		{
			if ((Object)(object)@this != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)@this);
			}
		}

		public static void Destroy(this IEnumerable<GameObject> @this)
		{
			foreach (GameObject item in @this)
			{
				if ((Object)(object)item != (Object)null)
				{
					Object.Destroy((Object)(object)item);
				}
			}
		}

		public static void DestroyInstantly(this IEnumerable<GameObject> @this)
		{
			foreach (GameObject item in @this)
			{
				if ((Object)(object)item != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)item);
				}
			}
		}

		public static void SetPhysics(this GameObject @this, bool state)
		{
			@this.GetComponent<Rigidbody>().isKinematic = !state;
		}

		public static void SetCollisions(this GameObject @this, bool state)
		{
			Collider[] components = @this.GetComponents<Collider>();
			for (int i = 0; i < components.Length; i++)
			{
				components[i].isTrigger = !state;
			}
		}

		public static void ResetLocalTransform(this GameObject @this)
		{
			//IL_0006: 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)
			@this.transform.localPosition = Vector3.zero;
			@this.transform.localRotation = Quaternion.identity;
			@this.transform.localScale = Vector3.one;
		}

		public static void SetCollisionsWith(this GameObject @this, GameObject a, bool state)
		{
			Collider[] components = @this.GetComponents<Collider>();
			foreach (Collider val in components)
			{
				Collider[] components2 = a.GetComponents<Collider>();
				foreach (Collider val2 in components2)
				{
					Physics.IgnoreCollision(val, val2, !state);
				}
			}
		}

		public static void SetCollisionsWith(this GameObject @this, IEnumerable<GameObject> aCollection, bool state)
		{
			foreach (GameObject item in aCollection)
			{
				@this.SetCollisionsWith(item, state);
			}
		}

		public static void CopyTransformFrom(this GameObject @this, GameObject a)
		{
			CopyLocalTransform(a.transform, @this.transform);
		}

		public static void CopyRigidbodyFrom(this GameObject @this, GameObject a, bool copyMassAndTensors = false)
		{
			CopyRigidbody(a.GetComponent<Rigidbody>(), @this.GetComponent<Rigidbody>(), copyMassAndTensors);
		}

		public static void SetCollisionsWith(this GameObject @this, Component a, bool state)
		{
			@this.SetCollisionsWith(a.gameObject, state);
		}

		public static void SetCollisionsWith(this GameObject @this, IEnumerable<Component> aCollection, bool state)
		{
			foreach (Component item in aCollection)
			{
				@this.SetCollisionsWith(item.gameObject, state);
			}
		}

		public static void CopyTransformFrom(this GameObject @this, Component a)
		{
			@this.CopyTransformFrom(a.gameObject);
		}

		public static void CopyRigidbodyFrom(this GameObject @this, Component a, bool copyMassAndTensors = false)
		{
			@this.CopyRigidbodyFrom(a.gameObject, copyMassAndTensors);
		}

		private static void CopyLocalTransform(Transform from, Transform to)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			to.localPosition = from.localPosition;
			to.localRotation = from.localRotation;
			to.localScale = from.localScale;
		}

		private static void CopyRigidbody(Rigidbody from, Rigidbody to, bool copyMassAndTensors = false)
		{
			//IL_0002: 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_0056: 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_007a: 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_00f4: 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)
			to.velocity = from.velocity;
			to.drag = from.drag;
			to.angularVelocity = from.angularVelocity;
			to.angularDrag = from.angularDrag;
			to.isKinematic = from.isKinematic;
			to.useGravity = from.useGravity;
			to.freezeRotation = from.freezeRotation;
			to.constraints = from.constraints;
			to.detectCollisions = from.detectCollisions;
			to.collisionDetectionMode = from.collisionDetectionMode;
			to.interpolation = from.interpolation;
			to.maxAngularVelocity = from.maxAngularVelocity;
			to.maxDepenetrationVelocity = from.maxDepenetrationVelocity;
			to.sleepThreshold = from.sleepThreshold;
			to.mass = 1f;
			to.solverIterations = from.solverIterations;
			to.solverVelocityIterations = from.solverVelocityIterations;
			to.ResetCenterOfMass();
			to.ResetInertiaTensor();
			if (copyMassAndTensors)
			{
				to.mass = from.mass;
				to.centerOfMass = from.centerOfMass;
				to.inertiaTensor = from.inertiaTensor;
				to.inertiaTensorRotation = from.inertiaTensorRotation;
			}
		}
	}
	public static class Extensions
	{
		public static float StartValue(this AnimationCurve @this)
		{
			return ((Keyframe)(ref @this.keys[0])).value;
		}

		public static float EndValue(this AnimationCurve @this)
		{
			return ((Keyframe)(ref @this.keys[@this.keys.Length - 1])).value;
		}

		public static float StartTime(this AnimationCurve @this)
		{
			return ((Keyframe)(ref @this.keys[0])).time;
		}

		public static float EndTime(this AnimationCurve @this)
		{
			return ((Keyframe)(ref @this.keys[@this.keys.Length - 1])).time;
		}

		public static float Duration(this AnimationCurve @this)
		{
			return @this.EndTime() - @this.StartTime();
		}

		public static bool IsValid(this AnimationCurve @this)
		{
			return @this.length >= 2;
		}

		public static void AddLinearKeys(this AnimationCurve @this, params (float Time, float Value)[] a)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < a.Length; i++)
			{
				@this.AddKey(new Keyframe(a[i].Time, a[i].Value, 0f, 0f));
			}
		}

		public static bool Pressed(this KeyCode @this)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Input.GetKeyDown(@this);
		}

		public static bool Released(this KeyCode @this)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Input.GetKeyUp(@this);
		}

		public static bool Down(this KeyCode @this)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Input.GetKey(@this);
		}

		public static bool Up(this KeyCode @this)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return !Input.GetKey(@this);
		}

		public static RaycastHit[] SortedByDistanceFrom(this RaycastHit[] @this, Vector3 a)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit[] array = @this.MakeCopy();
			for (int i = 0; i < array.Length; i++)
			{
				int num = i;
				for (int j = i + 1; j < array.Length; j++)
				{
					if (a.DistanceTo(((RaycastHit)(ref array[j])).point) < a.DistanceTo(((RaycastHit)(ref array[num])).point))
					{
						num = j;
					}
				}
				if (num != i)
				{
					array[i].SwapWith<RaycastHit>(ref array[num]);
				}
			}
			return array;
		}

		public static RaycastHit[] SortedByDistanceFrom(this RaycastHit[] @this, GameObject a)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return @this.SortedByDistanceFrom(a.transform.position);
		}

		public static RaycastHit[] SortedByDistanceFrom(this RaycastHit[] @this, Component a)
		{
			return @this.SortedByDistanceFrom(a.gameObject);
		}

		public static Vector3 Midpoint<T>(this IEnumerable<T> @this, Func<T, Vector3> positionFunc)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.zero;
			int num = 0;
			foreach (T item in @this)
			{
				val += positionFunc(item);
				num++;
			}
			return val / (float)num;
		}

		public static Vector3 Midpoint(this IEnumerable<GameObject> @this)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return @this.Midpoint((GameObject GameObject) => GameObject.transform.position);
		}

		public static Vector3 Midpoint(this IEnumerable<Component> @this)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return @this.Midpoint((Component component) => component.transform.position);
		}

		public static void SetPositionX(this Transform @this, float x)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = @this.position;
			position.x = x;
			@this.position = position;
		}

		public static void SetPositionY(this Transform @this, float y)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = @this.position;
			position.y = y;
			@this.position = position;
		}

		public static void SetPositionZ(this Transform @this, float z)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = @this.position;
			position.z = z;
			@this.position = position;
		}

		public static void SetLocalPositionX(this Transform @this, float x)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localPosition = @this.localPosition;
			localPosition.x = x;
			@this.localPosition = localPosition;
		}

		public static void SetLocalPositionY(this Transform @this, float y)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localPosition = @this.localPosition;
			localPosition.y = y;
			@this.localPosition = localPosition;
		}

		public static void SetLocalPositionZ(this Transform @this, float z)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localPosition = @this.localPosition;
			localPosition.z = z;
			@this.localPosition = localPosition;
		}

		public static void SetAngleX(this Transform @this, float x)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Quaternion rotation = @this.rotation;
			Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
			eulerAngles.x = x;
			@this.rotation = Quaternion.Euler(eulerAngles);
		}

		public static void SetAngleY(this Transform @this, float y)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Quaternion rotation = @this.rotation;
			Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
			eulerAngles.y = y;
			@this.rotation = Quaternion.Euler(eulerAngles);
		}

		public static void SetAngleZ(this Transform @this, float z)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Quaternion rotation = @this.rotation;
			Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
			eulerAngles.z = z;
			@this.rotation = Quaternion.Euler(eulerAngles);
		}

		public static void SetLocalAngleX(this Transform @this, float x)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Quaternion localRotation = @this.localRotation;
			Vector3 eulerAngles = ((Quaternion)(ref localRotation)).eulerAngles;
			eulerAngles.x = x;
			@this.localRotation = Quaternion.Euler(eulerAngles);
		}

		public static void SetLocalAngleY(this Transform @this, float y)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Quaternion localRotation = @this.localRotation;
			Vector3 eulerAngles = ((Quaternion)(ref localRotation)).eulerAngles;
			eulerAngles.y = y;
			@this.localRotation = Quaternion.Euler(eulerAngles);
		}

		public static void SetLocalAngleZ(this Transform @this, float z)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Quaternion localRotation = @this.localRotation;
			Vector3 eulerAngles = ((Quaternion)(ref localRotation)).eulerAngles;
			eulerAngles.z = z;
			@this.localRotation = Quaternion.Euler(eulerAngles);
		}

		public static void SetLocalScaleX(this Transform @this, float x)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localScale = @this.localScale;
			localScale.x = x;
			@this.localScale = localScale;
		}

		public static void SetLocalScaleY(this Transform @this, float y)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localScale = @this.localScale;
			localScale.y = y;
			@this.localScale = localScale;
		}

		public static void SetLocalScaleZ(this Transform @this, float z)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localScale = @this.localScale;
			localScale.z = z;
			@this.localScale = localScale;
		}
	}
	public static class Extensions_Sprite
	{
		public static Texture2D Texture(this Sprite @this)
		{
			return @this.texture;
		}

		public static Vector2 TextureSizePixels(this Sprite @this)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2((float)((Texture)@this.Texture()).width, (float)((Texture)@this.Texture()).height);
		}

		public static Vector2 TextureSizeUnits(this Sprite @this)
		{
			//IL_0001: 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)
			return @this.TextureSizePixels() / @this.pixelsPerUnit;
		}

		public static Vector2 SizePixels(this Sprite @this)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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)
			Rect rect = @this.rect;
			float width = ((Rect)(ref rect)).width;
			rect = @this.rect;
			return new Vector2(width, ((Rect)(ref rect)).height);
		}

		public static Vector2 SizeUnits(this Sprite @this)
		{
			//IL_0001: 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)
			return @this.SizePixels() / @this.pixelsPerUnit;
		}

		public static Vector2 Size01(this Sprite @this)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.SizePixels().Div(@this.TextureSizePixels());
		}

		public static Vector2 OffsetPixels(this Sprite @this)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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)
			Rect rect = @this.rect;
			float x = ((Rect)(ref rect)).min.x;
			rect = @this.rect;
			return new Vector2(x, ((Rect)(ref rect)).min.y);
		}

		public static Vector2 OffsetUnits(this Sprite @this)
		{
			//IL_0001: 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)
			return @this.OffsetPixels() / @this.pixelsPerUnit;
		}

		public static Vector2 Offset01(this Sprite @this)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.OffsetPixels().Div(@this.TextureSizePixels());
		}

		public static Vector4 SizeOffsetPixels(this Sprite @this)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.SizePixels().Append(@this.OffsetPixels());
		}

		public static Vector4 SizeOffsetUnits(this Sprite @this)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.SizeUnits().Append(@this.OffsetUnits());
		}

		public static Vector4 SizeOffset01(this Sprite @this)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return @this.Size01().Append(@this.Offset01());
		}

		public static Rect RectPixels(this Sprite @this)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return @this.rect;
		}

		public static Vector2 PositionToPixelCoords(this Sprite @this, Vector3 a, Transform b = null)
		{
			//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)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)b != (Object)null)
			{
				a = a.Untransform(b);
			}
			Rect val = @this.RectPixels();
			return Vector2Int.op_Implicit((((Rect)(ref val)).center + a.XY() * @this.pixelsPerUnit).RoundDown());
		}

		public static Color PositionToPixelColor(this Sprite @this, Vector3 a, Transform b = null)
		{
			//IL_0001: 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_0008: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = @this.PositionToPixelCoords(a, b);
			return @this.Texture().GetPixel((int)val.x, (int)val.y);
		}

		public static float PositionToPixelAlpha(this Sprite @this, Vector3 a, Transform b = null)
		{
			//IL_0001: 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)
			return @this.PositionToPixelColor(a, b).a;
		}

		public static Vector3 PixelCoordsToPosition(this Sprite @this, Vector2 a, Transform b = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Rect val = @this.RectPixels();
			Vector3 val2 = Vector2.op_Implicit((a - ((Rect)(ref val)).center) / @this.pixelsPerUnit);
			if ((Object)(object)b != (Object)null)
			{
				val2 = val2.Transform(b);
			}
			return val2;
		}
	}
}
namespace Vheos.Helpers.Reflection
{
	public static class Extensions
	{
		private static BindingFlags InstanceMembers => BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static BindingFlags StaticMembers => BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static TReturn GetField<TReturn>(this object @this, string name)
		{
			return (TReturn)@this.GetType().GetField(name, InstanceMembers).GetValue(@this);
		}

		public static TReturn GetField<TReturn, TBase>(this object @this, string name)
		{
			return (TReturn)typeof(TBase).GetField(name, InstanceMembers).GetValue(@this);
		}

		public static void SetField<TValue>(this object @this, string name, TValue value)
		{
			@this.GetType().GetField(name, InstanceMembers).SetValue(@this, value);
		}

		public static void SetField<TValue, TBase>(this object @this, string name, TValue value)
		{
			typeof(TBase).GetField(name, InstanceMembers).SetValue(@this, value);
		}

		public static bool TryGetField<TReturn>(this object @this, string name, out TReturn value)
		{
			if (@this.GetType().GetField(name, InstanceMembers).TryNonNull(out FieldInfo r) && r.GetValue(@this).TryCast<TReturn>(out value))
			{
				return true;
			}
			value = default(TReturn);
			return false;
		}

		public static bool TryGetField<TReturn, TBase>(this object @this, string name, out TReturn value)
		{
			if (typeof(TBase).GetField(name, InstanceMembers).TryNonNull(out FieldInfo r) && r.GetValue(@this).TryCast<TReturn>(out value))
			{
				return true;
			}
			value = default(TReturn);
			return false;
		}

		public static bool TrySetField<TValue>(this object @this, string name, TValue value)
		{
			if (@this.GetType().GetField(name, InstanceMembers).TryNonNull(out FieldInfo r))
			{
				r.SetValue(@this, value);
				return true;
			}
			return false;
		}

		public static bool TrySetField<TValue, TBase>(this object @this, string name, TValue value)
		{
			if (typeof(TBase).GetField(name, InstanceMembers).TryNonNull(out FieldInfo r))
			{
				r.SetValue(@this, value);
				return true;
			}
			return false;
		}

		public static TReturn GetProperty<TReturn>(this object @this, string name)
		{
			return (TReturn)@this.GetType().GetProperty(name, InstanceMembers).GetValue(@this, null);
		}

		public static TReturn GetProperty<TReturn, TBase>(this object @this, string name)
		{
			return (TReturn)typeof(TBase).GetType().GetProperty(name, InstanceMembers).GetValue(@this, null);
		}

		public static void SetProperty<TValue>(this object @this, string name, TValue value)
		{
			@this.GetType().GetProperty(name, InstanceMembers).SetValue(@this, value, null);
		}

		public static void SetProperty<TValue, TBase>(this object @this, string name, TValue value)
		{
			typeof(TBase).GetProperty(name, InstanceMembers).SetValue(@this, value, null);
		}

		public static bool TryGetProperty<TReturn>(this object @this, string name, out TReturn value)
		{
			if (@this.GetType().GetProperty(name, InstanceMembers).TryNonNull(out PropertyInfo r) && r.GetValue(@this, null).TryCast<TReturn>(out value))
			{
				return true;
			}
			value = default(TReturn);
			return false;
		}

		public static bool TryGetProperty<TReturn, TBase>(this object @this, string name, out TReturn value)
		{
			if (typeof(TBase).GetProperty(name, InstanceMembers).TryNonNull(out PropertyInfo r) && r.GetValue(@this, null).TryCast<TReturn>(out value))
			{
				return true;
			}
			value = default(TReturn);
			return false;
		}

		public static bool TrySetProperty<TValue>(this object @this, string name, TValue value)
		{
			if (@this.GetType().GetProperty(name, InstanceMembers).TryNonNull(out PropertyInfo r))
			{
				r.SetValue(@this, value, null);
				return true;
			}
			return false;
		}

		public static bool TrySetProperty<TValue, TBase>(this object @this, string name, TValue value)
		{
			if (typeof(TBase).GetProperty(name, InstanceMembers).TryNonNull(out PropertyInfo r))
			{
				r.SetValue(@this, value, null);
				return true;
			}
			return false;
		}

		public static TReturn InvokeMethod<TReturn>(this object @this, string name, params object[] parameters)
		{
			return (TReturn)@this.GetType().GetMethod(name, InstanceMembers).Invoke(@this, parameters);
		}

		public static TReturn InvokeMethod<TReturn, TBase>(this object @this, string name, params object[] parameters)
		{
			return (TReturn)typeof(TBase).GetMethod(name, InstanceMembers).Invoke(@this, parameters);
		}

		public static void InvokeMethodVoid(this object @this, string name, params object[] parameters)
		{
			@this.GetType().GetMethod(name, InstanceMembers).Invoke(@this, parameters);
		}

		public static void InvokeMethodVoid<TBase>(this object @this, string name, params object[] parameters)
		{
			typeof(TBase).GetMethod(name, InstanceMembers).Invoke(@this, parameters);
		}

		public static bool TryInvokeMethod<TReturn>(this object @this, string name, object[] parameters, out TReturn returnValue)
		{
			if (@this.GetType().GetMethod(name, InstanceMembers).TryNonNull(out MethodInfo r) && r.GetParameters().Length == parameters.Length)
			{
				returnValue = (TReturn)r.Invoke(@this, parameters);
				return true;
			}
			returnValue = default(TReturn);
			return false;
		}

		public static bool TryInvokeMethod<TReturn, TBase>(this object @this, string name, object[] parameters, out TReturn returnValue)
		{
			if (typeof(TBase).GetMethod(name, InstanceMembers).TryNonNull(out MethodInfo r) && r.GetParameters().Length == parameters.Length)
			{
				returnValue = (TReturn)r.Invoke(@this, parameters);
				return true;
			}
			returnValue = default(TReturn);
			return false;
		}

		public static bool TryInvokeMethodVoid(this object @this, string name, params object[] parameters)
		{
			if (@this.GetType().GetMethod(name, InstanceMembers).TryNonNull(out MethodInfo r) && r.GetParameters().Length == parameters.Length)
			{
				r.Invoke(@this, parameters);
				return true;
			}
			return false;
		}

		public static bool TryInvokeMethodVoid<TBase>(this object @this, string name, params object[] parameters)
		{
			if (typeof(TBase).GetMethod(name, InstanceMembers).TryNonNull(out MethodInfo r) && r.GetParameters().Length == parameters.Length)
			{
				r.Invoke(@this, parameters);
				return true;
			}
			return false;
		}

		public static TReturn GetField<TReturn>(this Type type, string fieldName)
		{
			return (TReturn)type.GetField(fieldName, StaticMembers).GetValue(null);
		}

		public static void SetField<TValue>(this Type type, string fieldName, TValue value)
		{
			type.GetField(fieldName, StaticMembers).SetValue(null, value);
		}

		public static TReturn GetProperty<TReturn>(this Type type, string propName)
		{
			return (TReturn)type.GetProperty(propName, StaticMembers).GetValue(null, null);
		}

		public static void SetProperty<TValue>(this Type type, string propName, TValue value)
		{
			type.GetProperty(propName, StaticMembers).SetValue(null, value, null);
		}

		public static TReturn InvokeMethod<TReturn>(this Type type, string methodName, params object[] methodParams)
		{
			return (TReturn)type.GetMethod(methodName, StaticMembers).Invoke(null, methodParams);
		}

		public static void InvokeMethodVoid(this Type type, string methodName, params object[] methodParams)
		{
			type.GetMethod(methodName, StaticMembers).Invoke(null, methodParams);
		}
	}
}
namespace Vheos.Helpers.RNG
{
	public static class Random_Extensions
	{
		public static T Random<T>(this IList<T> t)
		{
			return t[RNG.Range(0, t.Count)];
		}

		public static void Shuffle<T>(this IList<T> t)
		{
			for (int i = 0; i < t.Count - 1; i++)
			{
				int num = RNG.Range(i, t.Count);
				int index = num;
				int index2 = i;
				T val = t[i];
				T val2 = t[num];
				T val4 = (t[index] = val);
				val4 = (t[index2] = val2);
			}
		}

		public static bool Roll(this float @this)
		{
			if (!(RNG.Value01 < @this))
			{
				return @this == 1f;
			}
			return true;
		}

		public static bool RollPercent(this float @this)
		{
			if (!(RNG.Value01 < @this / 100f))
			{
				return @this == 100f;
			}
			return true;
		}

		public static bool RollPercent(this int @this)
		{
			if (!(RNG.Value01 < (float)@this / 100f))
			{
				return (float)@this == 100f;
			}
			return true;
		}
	}
	public static class RNG
	{
		private static Random _randomizer;

		public static int Seed { get; private set; }

		public static float Value01 => (float)_randomizer.NextDouble();

		public static float Degree => Value01 * 360f;

		public static float Radian => Value01 * 2f * (float)System.Math.PI;

		public static float Range(float toEx)
		{
			return Value01 * toEx;
		}

		public static float Range(float fromIn, float toEx)
		{
			return Value01.MapFrom01(fromIn, toEx);
		}

		public static int Range(int toEx)
		{
			return _randomizer.Next(toEx);
		}

		public static int Range(int fromIn, int toEx)
		{
			return _randomizer.Next(fromIn, toEx);
		}

		public static int RangeInclusive(int toIn)
		{
			return _randomizer.Next(toIn + 1);
		}

		public static int RangeInclusive(int fromIn, int toIn)
		{
			return _randomizer.Next(fromIn, toIn + 1);
		}

		public static Vector2 OnCircle(float radius = 1f)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			float radian = Radian;
			float num = radian.Cos();
			float num2 = radian.Sin();
			return new Vector2(num, num2);
		}

		public static Vector2 InCircle(float radius = 1f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return OnCircle(radius) * Value01;
		}

		public static Vector3 OnSphere(float radius = 1f)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			float radian = Radian;
			float radian2 = Radian;
			float num = radian.Sin() * radian2.Cos();
			float num2 = radian.Sin() * radian2.Cos();
			float num3 = radian.Cos();
			return new Vector3(num, num2, num3);
		}

		public static Vector3 InSphere(float radius = 1f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return OnSphere(radius) * Value01;
		}

		static RNG()
		{
			Initialize((int)DateTime.Now.Ticks);
		}

		public static void Initialize(int seed)
		{
			Seed = seed;
			_randomizer = new Random(Seed);
		}
	}
}
namespace Vheos.Helpers.Math
{
	public static class Extensions_float
	{
		private const float DEG_TO_RAD = (float)System.Math.PI / 180f;

		public static float Add(this float @this, float a)
		{
			return @this + a;
		}

		public static float Sub(this float @this, float a)
		{
			return @this - a;
		}

		public static float Mul(this float @this, float a)
		{
			return @this * a;
		}

		public static float Div(this float @this, float a)
		{
			return @this / a;
		}

		public static float Pow(this float @this, float a)
		{
			return (float)System.Math.Pow(@this, a);
		}

		public static float Root(this float @this, float a)
		{
			return (float)System.Math.Pow(1f / @this, a);
		}

		public static float Mod(this float @this, float a)
		{
			return @this % a;
		}

		public static float PosMod(this float @this, float a)
		{
			return (@this % a + a) % a;
		}

		public static float Min(this float @this, float a)
		{
			if (!(@this < a))
			{
				return a;
			}
			return @this;
		}

		public static float Max(this float @this, float a)
		{
			if (!(@this > a))
			{
				return a;
			}
			return @this;
		}

		public static float Avg(this float @this, float a)
		{
			return (@this + a) / 2f;
		}

		public static float Add(this float @this, int a)
		{
			return @this + (float)a;
		}

		public static float Sub(this float @this, int a)
		{
			return @this - (float)a;
		}

		public static float Mul(this float @this, int a)
		{
			return @this * (float)a;
		}

		public static float Div(this float @this, int a)
		{
			return @this / (float)a;
		}

		public static float Pow(this float @this, int a)
		{
			return (float)System.Math.Pow(@this, a);
		}

		public static float Root(this float @this, int a)
		{
			return (float)System.Math.Pow(1f / @this, a);
		}

		public static float Mod(this float @this, int a)
		{
			return @this % (float)a;
		}

		public static float PosMod(this float @this, int a)
		{
			return (@this % (float)a + (float)a) % (float)a;
		}

		public static float Min(this float @this, int a)
		{
			if (!(@this < (float)a))
			{
				return a;
			}
			return @this;
		}

		public static float Max(this float @this, int a)
		{
			if (!(@this > (float)a))
			{
				return a;
			}
			return @this;
		}

		public static float Avg(this float @this, int a)
		{
			return (@this + (float)a) / 2f;
		}

		public static float Neg(this float @this)
		{
			return 0f - @this;
		}

		public static float Inv(this float @this)
		{
			return 1f / @this;
		}

		public static float Abs(this float @this)
		{
			if (!(@this > 0f))
			{
				return 0f - @this;
			}
			return @this;
		}

		public static int Sig(this float @this)
		{
			if (!(@this > 0f))
			{
				if (!(@this < 0f))
				{
					return 0;
				}
				return -1;
			}
			return 1;
		}

		public static float Sqrd(this float @this)
		{
			return @this * @this;
		}

		public static float Sqrt(this float @this)
		{
			return (float)System.Math.Sqrt(@this);
		}

		public static float Sin(this float @this, bool degrees = false)
		{
			return Mathf.Sin(degrees ? (@this * ((float)System.Math.PI / 180f)) : @this);
		}

		public static float Cos(this float @this, bool degrees = false)
		{
			return Mathf.Cos(degrees ? (@this * ((float)System.Math.PI / 180f)) : @this);
		}

		public static float Tan(this float @this, bool degrees = false)
		{
			return Mathf.Tan(degrees ? (@this * ((float)System.Math.PI / 180f)) : @this);
		}

		public static float Cot(this float @this, bool degrees = false)
		{
			return 1f / Mathf.Tan(degrees ? (@this * ((float)System.Math.PI / 180f)) : @this);
		}

		public static float Sec(this float @this, bool degrees = false)
		{
			return 1f / Mathf.Cos(degrees ? (@this * ((float)System.Math.PI / 180f)) : @this);
		}

		public static float Csc(this float @this, bool degrees = false)
		{
			return 1f / Mathf.Sin(degrees ? (@this * ((float)System.Math.PI / 180f)) : @this);
		}

		public static float ArcSin(this float @this, bool degrees = false)
		{
			return Mathf.Asin(degrees ? (@this * ((float)System.Math.PI / 180f)) : @this);
		}

		public static float ArcCos(this float @this, bool degrees = false)
		{
			return Mathf.Acos(degrees ? (@this * ((float)System.Math.PI / 180f)) : @this);
		}

		public static float ArcTan(this float @this, bool degrees = false)
		{
			return Mathf.Atan(degrees ? (@this * ((float)System.Math.PI / 180f)) : @this);
		}

		public static int Round(this float @this)
		{
			return (int)System.Math.Round(@this, MidpointRounding.AwayFromZero);
		}

		public static int RoundDown(this float @this)
		{
			return (int)System.Math.Floor(@this);
		}

		public static int RoundUp(this float @this)
		{
			return (int)System.Math.Ceiling(@this);
		}

		public static int RoundTowardsZero(this float @this)
		{
			return (int)@this;
		}

		public static int RoundAwayFromZero(this float @this)
		{
			if (!(@this > 0f))
			{
				return (int)System.Math.Floor(@this);
			}
			return (int)System.Math.Ceiling(@this);
		}

		public static float RoundToDecimalDigits(this float @this, int a)
		{
			return (float)System.Math.Round(@this, a, MidpointRounding.AwayFromZero);
		}

		public static float RoundToMultiple(this float @this, float a)
		{
			return (float)System.Math.Round(@this / a, MidpointRounding.AwayFromZero) * a;
		}

		public static int RoundToMultiple(this float @this, int a)
		{
			return (int)System.Math.Round(@this / (float)a, MidpointRounding.AwayFromZero) * a;
		}

		public static float Clamp01(this float @this)
		{
			if (!(@this < 0f))
			{
				if (!(@this > 1f))
				{
					return @this;
				}
				return 1f;
			}
			return 0f;
		}

		public static float Clamp(this float @this, float a, float b)
		{
			if (!(@this < a))
			{
				if (!(@this > b))
				{
					return @this;
				}
				return b;
			}
			return a;
		}

		public static float ClampMin(this float @this, float a)
		{
			if (!(@this > a))
			{
				return a;
			}
			return @this;
		}

		public static float ClampMax(this float @this, float a)
		{
			if (!(@this < a))
			{
				return a;
			}
			return @this;
		}

		public static float Lerp(this float @this, float a, float b)
		{
			return @this + (a - @this) * b;
		}

		public static float LerpClamped(this float @this, float a, float b)
		{
			if (!(b <= 0f))
			{
				if (!(b >= 1f))
				{
					return @this.Lerp(a, b);
				}
				return a;
			}
			return @this;
		}

		public static float InverseLerp(this float @this, float a, float b)
		{
			return (@this - a) / (b - a);
		}

		public static float InverseLerpClamped(this float @this, float a, float b)
		{
			if (!(@this <= a))
			{
				if (!(@this >= b))
				{
					return @this.InverseLerp(a, b);
				}
				return 1f;
			}
			return 0f;
		}

		public static float Map(this float @this, float a, float b, float c, float d)
		{
			return (@this - a) * (d - c) / (b - a) + c;
		}

		public static float MapClamped(this float @this, float a, float b, float c, float d)
		{
			if (!(@this <= a))
			{
				if (!(@this >= b))
				{
					return @this.Map(a, b, c, d);
				}
				return d;
			}
			return c;
		}

		public static float MapFrom01(this float @this, float a, float b)
		{
			return @this.Map(0f, 1f, a, b);
		}

		public static float MapTo01(this float @this, float a, float b)
		{
			return @this.Map(a, b, 0f, 1f);
		}

		public static float Clamp(this float @this, int a, int b)
		{
			if (!(@this < (float)a))
			{
				if (!(@this > (float)b))
				{
					return @this;
				}
				return b;
			}
			return a;
		}

		public static float ClampMin(this float @this, int a)
		{
			if (!(@this > (float)a))
			{
				return a;
			}
			return @this;
		}

		public static float ClampMax(this float @this, int a)
		{
			if (!(@this < (float)a))
			{
				return a;
			}
			return @this;
		}

		public static float Lerp(this float @this, int a, float b)
		{
			return @this + ((float)a - @this) * b;
		}

		public static float LerpClamped(this float @this, int a, float b)
		{
			if (!(b <= 0f))
			{
				if (!(b >= 1f))
				{
					return @this.Lerp(a, b);
				}
				return a;
			}
			return @this;
		}

		public static float InverseLerp(this float @this, int a, int b)
		{
			return (@this - (float)a) / (float)(b - a);
		}

		public static float InverseLerpClamped(this float @this, int a, int b)
		{
			if (!(@this <= (float)a))
			{
				if (!(@this >= (float)b))
				{
					return @this.InverseLerp(a, b);
				}
				return 1f;
			}
			return 0f;
		}

		public static float Map(this float @this, int a, int b, int c, int d)
		{
			return (@this - (float)a) * (float)(d - c) / (float)(b - a) + (float)c;
		}

		public static float MapClamped(this float @this, int a, int b, int c, int d)
		{
			if (!(@this <= (float)a))
			{
				if (!(@this >= (float)b))
				{
					return @this.Map(a, b, c, d);
				}
				return d;
			}
			return c;
		}

		public static float MapFrom01(this float @this, int a, int b)
		{
			return @this.Map(0f, 1f, a, b);
		}

		public static float MapTo01(this float @this, int a, int b)
		{
			return @this.Map(a, b, 0f, 1f);
		}

		public static bool IsPos(this float @this)
		{
			return @this > 0f;
		}

		public static bool IsNeg(this float @this)
		{
			return @this < 0f;
		}

		public static bool IsPosInf(this float @this)
		{
			return float.IsPositiveInfinity(@this);
		}

		public static bool IsNegInf(this float @this)
		{
			return float.IsNegativeInfinity(@this);
		}

		public static bool IsInf(this float @this)
		{
			return float.IsInfinity(@this);
		}

		public static bool IsNaN(this float @this)
		{
			return float.IsNaN(@this);
		}

		public static bool IsBetween(this float @this, float a, float b)
		{
			if (@this >= a)
			{
				return @this <= b;
			}
			return false;
		}

		public static bool IsBetween(this float @this, int a, int b)
		{
			if (@this >= (float)a)
			{
				return @this <= (float)b;
			}
			return false;
		}

		public static float DistanceTo(this float @this, float a)
		{
			return (@this - a).Abs();
		}

		public static float DistanceTo(this float @this, int a)
		{
			return (@this - (float)a).Abs();
		}

		public static int ToInt(this float @this)
		{
			return (int)@this;
		}

		public static Vector2 ToVector2(this float @this)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(@this, @this);
		}

		public static Vector3 ToVector3(this float @this)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(@this, @this, @this);
		}

		public static Vector4 ToVector4(this float @this)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return new Vector4(@this, @this, @this, @this);
		}

		public static Vector2 Append(this float @this)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(@this, 0f);
		}

		public static Vector2 Append(this float @this, float y)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(@this, y);
		}

		public static Vector3 Append(this float @this, float y, float z)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(@this, y, z);
		}

		public static Vector3 Append(this float @this, Vector2 a)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(@this, a.x, a.y);
		}

		public static Vector4 Append(this float @this, float y, float z, float w)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return new Vector4(@this, y, z, w);
		}

		public static Vector4 Append(this float @this, Vector3 a)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return new Vector4(@this, a.x, a.y, a.z);
		}

		public static void SetAdd(this ref float @this, int a)
		{
			@this = @this.Add(a);
		}

		public static void SetSub(this ref float @this, int a)
		{
			@this = @this.Sub(a);
		}

		public static void SetMul(this ref float @this, int a)
		{
			@this = @this.Mul(a);
		}

		public static void SetDiv(this ref float @this, int a)
		{
			@this = @this.Div(a);
		}

		public static void SetPow(this ref float @this, int a)
		{
			@this = @this.Pow(a);
		}

		public static void SetRoot(this ref float @this, int a)
		{
			@this = @this.Root(a);
		}

		public static void SetMod(this ref float @this, int a)
		{
			@this = @this.Mod(a);
		}

		public static void SetPosMod(this ref float @this, int a)
		{
			@this = @this.PosMod(a);
		}

		public static void SetMin(this ref float @this, int a)
		{
			@this = @this.Min(a);
		}

		public static void SetMax(this ref float @this, int a)
		{
			@this = @this.Max(a);
		}

		public static void SetAvg(this ref float @this, int a)
		{
			@this = @this.Avg(a);
		}

		public static void SetAdd(this ref float @this, float a)
		{
			@this = @this.Add(a);
		}

		public static void SetSub(this ref float @this, float a)
		{
			@this = @this.Sub(a);
		}

		public static void SetMul(this ref float @this, float a)
		{
			@this = @this.Mul(a);
		}

		public static void SetDiv(this ref float @this, float a)
		{
			@this = @this.Div(a);
		}

		public static void SetPow(this ref float @this, float a)
		{
			@this = @this.Pow(a);
		}

		public static void SetRoot(this ref float @this, float a)
		{
			@this = @this.Root(a);
		}

		public static void SetMod(this ref float @this, float a)
		{
			@this = @this.Mod(a);
		}

		public static void SetPosMod(this ref float @this, float a)
		{
			@this = @this.PosMod(a);
		}

		public static void SetMin(this ref float @this, float a)
		{
			@this = @this.Min(a);
		}

		public static void SetMax(this ref float @this, float a)
		{
			@this = @this.Max(a);
		}

		public static void SetAvg(this ref float @this, float a)
		{
			@this = @this.Avg(a);
		}

		public static void SetNeg(this ref float @this)
		{
			@this = @this.Neg();
		}

		public static void SetInv(this ref float @this)
		{
			@this = @this.Inv();
		}

		public static void SetAbs(this ref float @this)
		{
			@this = @this.Abs();
		}

		public static void SetSig(this ref float @this)
		{
			@this = @this.Sig();
		}

		public static void SetSqrt(this ref float @this)
		{
			@this = @this.Sqrt();
		}

		public static void SetSqrd(this ref float @this)
		{
			@this = @this.Sqrd();
		}

		public static void SetSin(this ref float @this, bool degrees = false)
		{
			@this = @this.Sin(degrees);
		}

		public static void SetCos(this ref float @this, bool degrees = false)
		{
			@this = @this.Cos(degrees);
		}

		public static void SetTan(this ref float @this, bool degrees = false)
		{
			@this = @this.Tan(degrees);
		}

		public static void SetCot(this ref float @this, bool degrees = false)
		{
			@this = @this.Cot(degrees);
		}

		public static void SetSec(this ref float @this, bool degrees = false)
		{
			@this = @this.Sec(degrees);
		}

		public static void SetCsc(this ref float @this, bool degrees = false)
		{
			@this = @this.Csc(degrees);
		}

		public static void SetArcSin(this ref float @this, bool degrees = false)
		{
			@this = @this.ArcSin(degrees);
		}

		public static void SetArcCos(this ref float @this, bool degrees = false)
		{
			@this = @this.ArcCos(degrees);
		}

		public static void SetArcTan(this ref float @this, bool degrees = false)
		{
			@this = @this.ArcTan(degrees);
		}

		public static void SetRound(this ref float @this)
		{
			@this = @this.Round();
		}

		public static void SetRoundDown(this ref float @this)
		{
			@this = @this.RoundDown();
		}

		public static void SetRoundUp(this ref float @this)
		{
			@this = @this.RoundUp();
		}

		public static void SetRoundTowardsZero(this ref float @this)
		{
			@this = @this.RoundTowardsZero();
		}

		public static void SetRoundAwayFromZero(this ref float @this)
		{
			@this = @this.RoundAwayFromZero();
		}

		public static void SetRoundToDecimalDigits(this ref float @this, int a)
		{
			@this = @this.RoundToDecimalDigits(a);
		}

		public static void SetRoundToMultiple(this ref float @this, int a)
		{
			@this = @this.RoundToMultiple(a);
		}

		public static void SetRoundToMultiple(this ref float @this, float a)
		{
			@this = @this.RoundToMultiple(a);
		}

		public static void SetClamp(this ref float @this, int a, int b)
		{
			@this = @this.Clamp(a, b);
		}

		public static void SetClampMin(this ref float @this, int a)
		{
			@this = @this.ClampMin(a);
		}

		public static void SetClampMax(this ref float @this, int a)
		{
			@this = @this.ClampMax(a);
		}

		public static void SetLerp(this ref float @this, int a, float b)
		{
			@this = @this.Lerp(a, b);
		}

		public static void SetLerpClamped(this ref float @this, int a, float b)
		{
			@this = @this.LerpClamped(a, b);
		}

		public static float SetInverseLerp(this ref float @this, int a, int b)
		{
			return @this = @this.InverseLerp(a, b);
		}

		public static float SetInverseLerpClamped(this ref float @this, int a, int b)
		{
			return @this = @this.SetInverseLerpClamped(a, b);
		}