using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Microsoft.CodeAnalysis;
using UnityEngine;

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Vheos.Helpers.Math
{
	public static class Const
	{
		internal const MethodImplOptions Inline = MethodImplOptions.AggressiveInlining;

		public const bool Bool0 = false;

		public const bool Bool1 = true;

		public const int Int0 = 0;

		public const int Int1 = 1;

		public const int Int2 = 2;

		public const float Float0 = 0f;

		public const float Float1 = 1f;

		public const float Float2 = 2f;

		public const float FloatSqrt2 = 1.4142135f;

		public const float FloatSqrt3 = 1.7320508f;

		public const float FloatPI = MathF.PI;

		public const float FloatDegToRad = MathF.PI / 180f;
	}
	public static class Extensions_bool
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Not(this bool @this)
		{
			return !@this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool And(this bool @this, bool a)
		{
			return @this && a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Or(this bool @this, bool a)
		{
			return @this || a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LogicAnd(this bool @this, bool a)
		{
			return @this && a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LogicOr(this bool @this, bool a)
		{
			return @this || a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LogicXor(this bool @this, bool a)
		{
			return @this ^ a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsEqual(this bool @this, bool a)
		{
			return @this == a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNotEqual(this bool @this, bool a)
		{
			return @this != a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) Append(this bool @this, bool a)
		{
			return (@this, a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool ToBool(this bool @this)
		{
			return @this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) ToBool2(this bool @this)
		{
			return (@this.ToBool(), @this.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) ToBool3(this bool @this)
		{
			return (@this.ToBool(), @this.ToBool(), @this.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ToInt(this bool @this)
		{
			return @this ? 1 : 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) ToInt2(this bool @this)
		{
			return (@this.ToInt(), @this.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) ToInt3(this bool @this)
		{
			return (@this.ToInt(), @this.ToInt(), @this.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ToFloat(this bool @this)
		{
			return @this ? 1f : 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ToFloat2(this bool @this)
		{
			return (@this.ToFloat(), @this.ToFloat());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ToFloat3(this bool @this)
		{
			return (@this.ToFloat(), @this.ToFloat(), @this.ToFloat());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static g Choose<g>(this bool @this, g a, g b)
		{
			return @this ? a : b;
		}
	}
	public static class Extensions_bool2
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) Not(this (bool X, bool Y) @this)
		{
			return (@this.X.Not(), @this.Y.Not());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) And(this (bool X, bool Y) @this, (bool X, bool Y) a)
		{
			return (@this.X.And(a.X), @this.Y.And(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) Or(this (bool X, bool Y) @this, (bool X, bool Y) a)
		{
			return (@this.X.Or(a.X), @this.Y.Or(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) LogicAnd(this (bool X, bool Y) @this, (bool X, bool Y) a)
		{
			return (@this.X.LogicAnd(a.X), @this.Y.LogicAnd(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) LogicOr(this (bool X, bool Y) @this, (bool X, bool Y) a)
		{
			return (@this.X.LogicOr(a.X), @this.Y.LogicOr(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) LogicXor(this (bool X, bool Y) @this, (bool X, bool Y) a)
		{
			return (@this.X.LogicXor(a.X), @this.Y.LogicXor(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsEqual(this (bool X, bool Y) @this, (bool X, bool Y) a)
		{
			return (@this.X.IsEqual(a.X), @this.Y.IsEqual(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsNotEqual(this (bool X, bool Y) @this, (bool X, bool Y) a)
		{
			return (@this.X.IsNotEqual(a.X), @this.Y.IsNotEqual(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) Append(this (bool X, bool Y) @this, bool a)
		{
			return (@this.X, @this.Y, a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool ToBool(this (bool X, bool Y) @this)
		{
			return @this.X.ToBool();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) ToBool2(this (bool X, bool Y) @this)
		{
			return (@this.X.ToBool(), @this.Y.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) ToBool3(this (bool X, bool Y) @this)
		{
			return (@this.X.ToBool(), @this.Y.ToBool(), false);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ToInt(this (bool X, bool Y) @this)
		{
			return @this.X.ToInt();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) ToInt2(this (bool X, bool Y) @this)
		{
			return (@this.X.ToInt(), @this.Y.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) ToInt3(this (bool X, bool Y) @this)
		{
			return (@this.X.ToInt(), @this.Y.ToInt(), 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ToFloat(this (bool X, bool Y) @this)
		{
			return @this.X.ToFloat();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ToFloat2(this (bool X, bool Y) @this)
		{
			return (@this.X.ToFloat(), @this.Y.ToFloat());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ToFloat3(this (bool X, bool Y) @this)
		{
			return (@this.X.ToFloat(), @this.Y.ToFloat(), 0f);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (g X, g Y) Choose<g>(this (bool X, bool Y) @this, (g X, g Y) a, (g X, g Y) b)
		{
			return (@this.X.Choose(a.X, b.X), @this.Y.Choose(a.Y, b.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (g X, g Y) Choose<g>(this (bool X, bool Y) @this, g a, g b)
		{
			return @this.Choose(a.ToSelf2(), b.ToSelf2());
		}
	}
	public static class Extensions_bool3
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) Not(this (bool X, bool Y, bool Z) @this)
		{
			return (@this.X.Not(), @this.Y.Not(), @this.Z.Not());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) And(this (bool X, bool Y, bool Z) @this, (bool X, bool Y, bool Z) a)
		{
			return (@this.X.And(a.X), @this.Y.And(a.Y), @this.Z.And(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) Or(this (bool X, bool Y, bool Z) @this, (bool X, bool Y, bool Z) a)
		{
			return (@this.X.Or(a.X), @this.Y.Or(a.Y), @this.Z.Or(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) LogicAnd(this (bool X, bool Y, bool Z) @this, (bool X, bool Y, bool Z) a)
		{
			return (@this.X.LogicAnd(a.X), @this.Y.LogicAnd(a.Y), @this.Z.LogicAnd(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) LogicOr(this (bool X, bool Y, bool Z) @this, (bool X, bool Y, bool Z) a)
		{
			return (@this.X.LogicOr(a.X), @this.Y.LogicOr(a.Y), @this.Z.LogicOr(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) LogicXor(this (bool X, bool Y, bool Z) @this, (bool X, bool Y, bool Z) a)
		{
			return (@this.X.LogicXor(a.X), @this.Y.LogicXor(a.Y), @this.Z.LogicXor(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsEqual(this (bool X, bool Y, bool Z) @this, (bool X, bool Y, bool Z) a)
		{
			return (@this.X.IsEqual(a.X), @this.Y.IsEqual(a.Y), @this.Z.IsEqual(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsNotEqual(this (bool X, bool Y, bool Z) @this, (bool X, bool Y, bool Z) a)
		{
			return (@this.X.IsNotEqual(a.X), @this.Y.IsNotEqual(a.Y), @this.Z.IsNotEqual(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool Append(this (bool X, bool Y, bool Z) @this)
		{
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool ToBool(this (bool X, bool Y, bool Z) @this)
		{
			return @this.X.ToBool();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) ToBool2(this (bool X, bool Y, bool Z) @this)
		{
			return (@this.X.ToBool(), @this.Y.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) ToBool3(this (bool X, bool Y, bool Z) @this)
		{
			return (@this.X.ToBool(), @this.Y.ToBool(), @this.Z.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ToInt(this (bool X, bool Y, bool Z) @this)
		{
			return @this.X.ToInt();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) ToInt2(this (bool X, bool Y, bool Z) @this)
		{
			return (@this.X.ToInt(), @this.Y.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) ToInt3(this (bool X, bool Y, bool Z) @this)
		{
			return (@this.X.ToInt(), @this.Y.ToInt(), @this.Z.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ToFloat(this (bool X, bool Y, bool Z) @this)
		{
			return @this.X.ToFloat();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ToFloat2(this (bool X, bool Y, bool Z) @this)
		{
			return (@this.X.ToFloat(), @this.Y.ToFloat());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ToFloat3(this (bool X, bool Y, bool Z) @this)
		{
			return (@this.X.ToFloat(), @this.Y.ToFloat(), @this.Z.ToFloat());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (g X, g Y, g Z) Choose<g>(this (bool X, bool Y, bool Z) @this, (g X, g Y, g Z) a, (g X, g Y, g Z) b)
		{
			return (@this.X.Choose(a.X, b.X), @this.Y.Choose(a.Y, b.Y), @this.Z.Choose(a.Z, b.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (g X, g Y, g Z) Choose<g>(this (bool X, bool Y, bool Z) @this, g a, g b)
		{
			return @this.Choose(a.ToSelf3(), b.ToSelf3());
		}
	}
	public static class Extensions_float
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Neg(this float @this)
		{
			return 0f - @this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Inc(this float @this)
		{
			return @this++;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Dec(this float @this)
		{
			return @this--;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Add(this float @this, float a)
		{
			return @this + a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sub(this float @this, float a)
		{
			return @this - a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Mul(this float @this, float a)
		{
			return @this * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Div(this float @this, float a)
		{
			return @this / a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Rem(this float @this, float a)
		{
			return @this % a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static float BitAnd(this float @this)
		{
			return 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static float BitOr(this float @this)
		{
			return 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static float BitXor(this float @this)
		{
			return 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static float BitShiftLeft(this float @this)
		{
			return 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static float BitShiftRight(this float @this)
		{
			return 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsEqual(this float @this, float a)
		{
			return @this == a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNotEqual(this float @this, float a)
		{
			return @this != a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsGreater(this float @this, float a)
		{
			return @this > a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsGreaterOrEqual(this float @this, float a)
		{
			return @this >= a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsLess(this float @this, float a)
		{
			return @this < a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsLessOrEqual(this float @this, float a)
		{
			return @this <= a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Inv(this float @this)
		{
			return 1f / @this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Abs(this float @this)
		{
			return (@this < 0f) ? (0f - @this) : @this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Sig(this float @this)
		{
			return @this.Compare(0f);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sqrd(this float @this)
		{
			return @this * @this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sqrt(this float @this)
		{
			return (float)System.Math.Sqrt(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Pow(this float @this, float a)
		{
			return (float)System.Math.Pow(@this, a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Root(this float @this, float a)
		{
			return @this.Pow(a.Inv());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ModEuclid(this float @this, float a)
		{
			return @this - a.Abs() * (float)(@this / a.Abs()).RoundDown();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ModRound(this float @this, float a)
		{
			return @this - a * (float)(@this / a).Round();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Avg(this float @this, float a)
		{
			return (@this + a) / 2f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Lerp(this float @this, float a, float b)
		{
			return @this + (a - @this) * b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float LerpClamp(this float @this, float a, float b)
		{
			return (b <= 0f) ? @this : ((b >= 1f) ? a : @this.Lerp(a, b));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Map(this float @this, float a, float b, float c, float d)
		{
			return (@this - a) * (d - c) / (b - a) + c;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MapClamp(this float @this, float a, float b, float c, float d)
		{
			return (@this <= a) ? c : ((@this >= b) ? d : @this.Map(a, b, c, d));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Round(this float @this)
		{
			return (int)System.Math.Round(@this, MidpointRounding.AwayFromZero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RoundDown(this float @this)
		{
			return (int)System.Math.Floor(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RoundUp(this float @this)
		{
			return (int)System.Math.Ceiling(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RoundTowardsZero(this float @this)
		{
			return (@this > 0f) ? @this.RoundDown() : @this.RoundUp();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RoundAwayFromZero(this float @this)
		{
			return (@this > 0f) ? @this.RoundUp() : @this.RoundDown();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RoundToMultiple(this float @this, int a)
		{
			return (@this / (float)a).Round() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RoundDownToMultiple(this float @this, int a)
		{
			return (@this / (float)a).RoundDown() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RoundUpToMultiple(this float @this, int a)
		{
			return (@this / (float)a).RoundUp() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RoundTowardsZeroToMultiple(this float @this, int a)
		{
			return (@this / (float)a).RoundTowardsZero() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int RoundAwayFromZeroToMultiple(this float @this, int a)
		{
			return (@this / (float)a).RoundAwayFromZero() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float RoundToMultiple(this float @this, float a)
		{
			return (float)(@this / a).Round() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float RoundDownToMultiple(this float @this, float a)
		{
			return (float)(@this / a).RoundDown() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float RoundUpToMultiple(this float @this, float a)
		{
			return (float)(@this / a).RoundUp() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float RoundTowardsZeroToMultiple(this float @this, float a)
		{
			return (float)(@this / a).RoundTowardsZero() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float RoundAwayFromZeroToMultiple(this float @this, float a)
		{
			return (float)(@this / a).RoundAwayFromZero() * a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ToRad(this float @this)
		{
			return @this * (MathF.PI / 180f);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ToDeg(this float @this)
		{
			return @this / (MathF.PI / 180f);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sin(this float @this)
		{
			return (float)System.Math.Sin(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Cos(this float @this)
		{
			return (float)System.Math.Cos(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Tan(this float @this)
		{
			return (float)System.Math.Tan(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Cot(this float @this)
		{
			return @this.Tan().Inv();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sec(this float @this)
		{
			return @this.Cos().Inv();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Csc(this float @this)
		{
			return @this.Sin().Inv();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ArcSin(this float @this)
		{
			return (float)System.Math.Asin(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ArcCos(this float @this)
		{
			return (float)System.Math.Acos(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ArcTan(this float @this)
		{
			return (float)System.Math.Atan(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ArcCot(this float @this)
		{
			return @this.Inv().ArcTan();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ArcSec(this float @this)
		{
			return @this.Inv().ArcCos();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ArcCsc(this float @this)
		{
			return @this.Inv().ArcSin();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Compare(this float @this, float a)
		{
			return (@this > a) ? 1 : ((@this < a) ? (-1) : 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Min(this float @this, float a)
		{
			return (@this <= a) ? @this : a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Max(this float @this, float a)
		{
			return (@this >= a) ? @this : a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Clamp(this float @this, float a, float b)
		{
			return (@this < a) ? a : ((@this > b) ? b : @this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ClampMin(this float @this, float a)
		{
			return @this.Max(a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ClampMax(this float @this, float a)
		{
			return @this.Min(a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsBetween(this float @this, float a, float b)
		{
			return @this >= a && @this <= b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNotBetween(this float @this, float a, float b)
		{
			return @this < a || @this > b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsEven(this float @this)
		{
			return @this % 2f == 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsOdd(this float @this)
		{
			return @this % 2f != 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsZero(this float @this)
		{
			return @this == 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNotZero(this float @this)
		{
			return @this != 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPositive(this float @this)
		{
			return @this > 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNotPositive(this float @this)
		{
			return @this <= 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNegative(this float @this)
		{
			return @this < 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNotNegative(this float @this)
		{
			return @this >= 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Append(this float @this, float a)
		{
			return (@this, a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool ToBool(this float @this)
		{
			return @this > 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) ToBool2(this float @this)
		{
			return (@this.ToBool(), @this.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) ToBool3(this float @this)
		{
			return (@this.ToBool(), @this.ToBool(), @this.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ToInt(this float @this)
		{
			return (int)@this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) ToInt2(this float @this)
		{
			return (@this.ToInt(), @this.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) ToInt3(this float @this)
		{
			return (@this.ToInt(), @this.ToInt(), @this.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ToFloat(this float @this)
		{
			return @this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ToFloat2(this float @this)
		{
			return (@this.ToFloat(), @this.ToFloat());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ToFloat3(this float @this)
		{
			return (@this.ToFloat(), @this.ToFloat(), @this.ToFloat());
		}
	}
	public static class Extensions_float2
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Neg(this (float X, float Y) @this)
		{
			return (@this.X.Neg(), @this.Y.Neg());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Inc(this (float X, float Y) @this)
		{
			return (@this.X.Inc(), @this.Y.Inc());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Dec(this (float X, float Y) @this)
		{
			return (@this.X.Dec(), @this.Y.Dec());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Add(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Add(a.X), @this.Y.Add(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Sub(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Sub(a.X), @this.Y.Sub(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Mul(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Mul(a.X), @this.Y.Mul(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Div(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Div(a.X), @this.Y.Div(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Rem(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Rem(a.X), @this.Y.Rem(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) BitAnd(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) BitOr(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) BitXor(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) BitShiftLeft(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) BitShiftRight(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsEqual(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.IsEqual(a.X), @this.Y.IsEqual(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsNotEqual(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.IsNotEqual(a.X), @this.Y.IsNotEqual(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsGreater(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.IsGreater(a.X), @this.Y.IsGreater(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsGreaterOrEqual(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.IsGreaterOrEqual(a.X), @this.Y.IsGreaterOrEqual(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsLess(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.IsLess(a.X), @this.Y.IsLess(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsLessOrEqual(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.IsLessOrEqual(a.X), @this.Y.IsLessOrEqual(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Inv(this (float X, float Y) @this)
		{
			return (@this.X.Inv(), @this.Y.Inv());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Abs(this (float X, float Y) @this)
		{
			return (@this.X.Abs(), @this.Y.Abs());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Sig(this (float X, float Y) @this)
		{
			return (@this.X.Sig(), @this.Y.Sig());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Sqrd(this (float X, float Y) @this)
		{
			return (@this.X.Sqrd(), @this.Y.Sqrd());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Sqrt(this (float X, float Y) @this)
		{
			return (@this.X.Sqrt(), @this.Y.Sqrt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Pow(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Pow(a.X), @this.Y.Pow(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Root(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Root(a.X), @this.Y.Root(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ModEuclid(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.ModEuclid(a.X), @this.Y.ModEuclid(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ModRound(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.ModRound(a.X), @this.Y.ModRound(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Avg(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Avg(a.X), @this.Y.Avg(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Lerp(this (float X, float Y) @this, (float X, float Y) a, (float X, float Y) b)
		{
			return (@this.X.Lerp(a.X, b.X), @this.Y.Lerp(a.Y, b.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) LerpClamp(this (float X, float Y) @this, (float X, float Y) a, (float X, float Y) b)
		{
			return (@this.X.LerpClamp(a.X, b.X), @this.Y.LerpClamp(a.Y, b.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Map(this (float X, float Y) @this, (float X, float Y) a, (float X, float Y) b, (float X, float Y) c, (float X, float Y) d)
		{
			return (@this.X.Map(a.X, b.X, c.X, d.X), @this.Y.Map(a.Y, b.Y, c.Y, d.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) MapClamp(this (float X, float Y) @this, (float X, float Y) a, (float X, float Y) b, (float X, float Y) c, (float X, float Y) d)
		{
			return (@this.X.MapClamp(a.X, b.X, c.X, d.X), @this.Y.MapClamp(a.Y, b.Y, c.Y, d.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) Round(this (float X, float Y) @this)
		{
			return (@this.X.Round(), @this.Y.Round());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundDown(this (float X, float Y) @this)
		{
			return (@this.X.RoundDown(), @this.Y.RoundDown());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundUp(this (float X, float Y) @this)
		{
			return (@this.X.RoundUp(), @this.Y.RoundUp());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundTowardsZero(this (float X, float Y) @this)
		{
			return (@this.X.RoundTowardsZero(), @this.Y.RoundTowardsZero());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundAwayFromZero(this (float X, float Y) @this)
		{
			return (@this.X.RoundAwayFromZero(), @this.Y.RoundAwayFromZero());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundToMultiple(this (float X, float Y) @this, (int X, int Y) a)
		{
			return (@this.X.RoundToMultiple(a.X), @this.Y.RoundToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundDownToMultiple(this (float X, float Y) @this, (int X, int Y) a)
		{
			return (@this.X.RoundDownToMultiple(a.X), @this.Y.RoundDownToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundUpToMultiple(this (float X, float Y) @this, (int X, int Y) a)
		{
			return (@this.X.RoundUpToMultiple(a.X), @this.Y.RoundUpToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundTowardsZeroToMultiple(this (float X, float Y) @this, (int X, int Y) a)
		{
			return (@this.X.RoundTowardsZeroToMultiple(a.X), @this.Y.RoundTowardsZeroToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundAwayFromZeroToMultiple(this (float X, float Y) @this, (int X, int Y) a)
		{
			return (@this.X.RoundAwayFromZeroToMultiple(a.X), @this.Y.RoundAwayFromZeroToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundToMultiple(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.RoundToMultiple(a.X), @this.Y.RoundToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundDownToMultiple(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.RoundDownToMultiple(a.X), @this.Y.RoundDownToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundUpToMultiple(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.RoundUpToMultiple(a.X), @this.Y.RoundUpToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundTowardsZeroToMultiple(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.RoundTowardsZeroToMultiple(a.X), @this.Y.RoundTowardsZeroToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundAwayFromZeroToMultiple(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.RoundAwayFromZeroToMultiple(a.X), @this.Y.RoundAwayFromZeroToMultiple(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ToRad(this (float X, float Y) @this)
		{
			return (@this.X.ToRad(), @this.Y.ToRad());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ToDeg(this (float X, float Y) @this)
		{
			return (@this.X.ToDeg(), @this.Y.ToDeg());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Sin(this (float X, float Y) @this)
		{
			return (@this.X.Sin(), @this.Y.Sin());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Cos(this (float X, float Y) @this)
		{
			return (@this.X.Cos(), @this.Y.Cos());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Tan(this (float X, float Y) @this)
		{
			return (@this.X.Tan(), @this.Y.Tan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Cot(this (float X, float Y) @this)
		{
			return (@this.X.Cot(), @this.Y.Cot());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Sec(this (float X, float Y) @this)
		{
			return (@this.X.Sec(), @this.Y.Sec());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Csc(this (float X, float Y) @this)
		{
			return (@this.X.Csc(), @this.Y.Csc());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ArcSin(this (float X, float Y) @this)
		{
			return (@this.X.ArcSin(), @this.Y.ArcSin());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ArcCos(this (float X, float Y) @this)
		{
			return (@this.X.ArcCos(), @this.Y.ArcCos());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ArcTan(this (float X, float Y) @this)
		{
			return (@this.X.ArcTan(), @this.Y.ArcTan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ArcCot(this (float X, float Y) @this)
		{
			return (@this.X.ArcCot(), @this.Y.ArcCot());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ArcSec(this (float X, float Y) @this)
		{
			return (@this.X.ArcSec(), @this.Y.ArcSec());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ArcCsc(this (float X, float Y) @this)
		{
			return (@this.X.ArcCsc(), @this.Y.ArcCsc());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) Compare(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Compare(a.X), @this.Y.Compare(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Min(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Min(a.X), @this.Y.Min(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Max(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.Max(a.X), @this.Y.Max(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Clamp(this (float X, float Y) @this, (float X, float Y) a, (float X, float Y) b)
		{
			return (@this.X.Clamp(a.X, b.X), @this.Y.Clamp(a.Y, b.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ClampMin(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.ClampMin(a.X), @this.Y.ClampMin(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ClampMax(this (float X, float Y) @this, (float X, float Y) a)
		{
			return (@this.X.ClampMax(a.X), @this.Y.ClampMax(a.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsBetween(this (float X, float Y) @this, (float X, float Y) a, (float X, float Y) b)
		{
			return (@this.X.IsBetween(a.X, b.X), @this.Y.IsBetween(a.Y, b.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsNotBetween(this (float X, float Y) @this, (float X, float Y) a, (float X, float Y) b)
		{
			return (@this.X.IsNotBetween(a.X, b.X), @this.Y.IsNotBetween(a.Y, b.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsEven(this (float X, float Y) @this)
		{
			return (@this.X.IsEven(), @this.Y.IsEven());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsOdd(this (float X, float Y) @this)
		{
			return (@this.X.IsOdd(), @this.Y.IsOdd());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsZero(this (float X, float Y) @this)
		{
			return (@this.X.IsZero(), @this.Y.IsZero());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsNotZero(this (float X, float Y) @this)
		{
			return (@this.X.IsNotZero(), @this.Y.IsNotZero());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsPositive(this (float X, float Y) @this)
		{
			return (@this.X.IsPositive(), @this.Y.IsPositive());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsNotPositive(this (float X, float Y) @this)
		{
			return (@this.X.IsNotPositive(), @this.Y.IsNotPositive());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsNegative(this (float X, float Y) @this)
		{
			return (@this.X.IsNegative(), @this.Y.IsNegative());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsNotNegative(this (float X, float Y) @this)
		{
			return (@this.X.IsNotNegative(), @this.Y.IsNotNegative());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Append(this (float X, float Y) @this, float a)
		{
			return (@this.X, @this.Y, a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool ToBool(this (float X, float Y) @this)
		{
			return @this.X.ToBool();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) ToBool2(this (float X, float Y) @this)
		{
			return (@this.X.ToBool(), @this.Y.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) ToBool3(this (float X, float Y) @this)
		{
			return (@this.X.ToBool(), @this.Y.ToBool(), false);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ToInt(this (float X, float Y) @this)
		{
			return @this.X.ToInt();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) ToInt2(this (float X, float Y) @this)
		{
			return (@this.X.ToInt(), @this.Y.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) ToInt3(this (float X, float Y) @this)
		{
			return (@this.X.ToInt(), @this.Y.ToInt(), 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ToFloat(this (float X, float Y) @this)
		{
			return @this.X.ToFloat();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ToFloat2(this (float X, float Y) @this)
		{
			return (@this.X.ToFloat(), @this.Y.ToFloat());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ToFloat3(this (float X, float Y) @this)
		{
			return (@this.X.ToFloat(), @this.Y.ToFloat(), 0f);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Dot(this (float X, float Y) @this, (float X, float Y) a)
		{
			return @this.X * a.X + @this.Y * a.Y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Cross(this (float X, float Y) @this, (float X, float Y) a)
		{
			return @this.ToFloat3().Cross(a.ToFloat3());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float LenSqrd(this (float X, float Y) @this)
		{
			return @this.Dot(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Len(this (float X, float Y) @this)
		{
			return @this.LenSqrd().Sqrt();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Norm(this (float X, float Y) @this)
		{
			return @this.Div(@this.Len().ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) OffsetTo(this (float X, float Y) @this, (float X, float Y) a)
		{
			return a.Sub(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) OffsetFrom(this (float X, float Y) @this, (float X, float Y) a)
		{
			return @this.Sub(a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DistanceTo(this (float X, float Y) @this, (float X, float Y) a)
		{
			return @this.OffsetTo(a).Len();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DistanceFrom(this (float X, float Y) @this, (float X, float Y) a)
		{
			return @this.OffsetFrom(a).Len();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) DirectionTo(this (float X, float Y) @this, (float X, float Y) a)
		{
			return @this.OffsetTo(a).Norm();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) DirectionFrom(this (float X, float Y) @this, (float X, float Y) a)
		{
			return @this.OffsetFrom(a).Norm();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float GetComp(this (float X, float Y) @this, Axis a)
		{
			float result;
			switch (a)
			{
			default:
				result = 0f;
				break;
			case Axis.Y:
				result = @this.Y;
				break;
			case Axis.X:
				(result, _) = @this;
				break;
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float AddComps(this (float X, float Y) @this)
		{
			return @this.X + @this.Y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MulComps(this (float X, float Y) @this)
		{
			return @this.X * @this.Y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MaxComp(this (float X, float Y) @this)
		{
			float result;
			if (@this.X >= @this.Y)
			{
				(result, _) = @this;
			}
			else
			{
				result = @this.Y;
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MinComp(this (float X, float Y) @this)
		{
			float result;
			if (@this.X <= @this.Y)
			{
				(result, _) = @this;
			}
			else
			{
				result = @this.Y;
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Axis MaxAxis(this (float X, float Y) @this)
		{
			return (@this.X >= @this.Y) ? Axis.X : Axis.Y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Axis MinAxis(this (float X, float Y) @this)
		{
			return (@this.X <= @this.Y) ? Axis.X : Axis.Y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (T X, T Y) ProcessComps<T>(this (float X, float Y) @this, Func<float, T> func)
		{
			return (func(@this.X), func(@this.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) NewX(this (float X, float Y) @this, float x)
		{
			return (x, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) NewY(this (float X, float Y) @this, float y)
		{
			return (@this.X, y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) NewZ(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) NewXY(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) NewXZ(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) NewYX(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) NewYZ(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) NewZX(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) NewZY(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) XX(this (float X, float Y) @this)
		{
			return (@this.X, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) XY(this (float X, float Y) @this)
		{
			return (@this.X, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) YX(this (float X, float Y) @this)
		{
			return (@this.Y, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) YY(this (float X, float Y) @this)
		{
			return (@this.Y, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) XZ(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) YZ(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) ZX(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) ZY(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y) ZZ(this (float X, float Y) @this)
		{
			return default((float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XXX(this (float X, float Y) @this)
		{
			return (@this.X, @this.X, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XXY(this (float X, float Y) @this)
		{
			return (@this.X, @this.X, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XYX(this (float X, float Y) @this)
		{
			return (@this.X, @this.Y, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XYY(this (float X, float Y) @this)
		{
			return (@this.X, @this.Y, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YXX(this (float X, float Y) @this)
		{
			return (@this.Y, @this.X, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YXY(this (float X, float Y) @this)
		{
			return (@this.Y, @this.X, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YYX(this (float X, float Y) @this)
		{
			return (@this.Y, @this.Y, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YYY(this (float X, float Y) @this)
		{
			return (@this.Y, @this.Y, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) XXZ(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) XYZ(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) XZX(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) XZY(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) XZZ(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) YXZ(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) YYZ(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) YZX(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) YZY(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) YZZ(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) ZXX(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) ZXY(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) ZXZ(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) ZYX(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) ZYY(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) ZYZ(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) ZZX(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) ZZY(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) ZZZ(this (float X, float Y) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Add(this (float X, float Y) @this, float a)
		{
			return @this.Add(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Sub(this (float X, float Y) @this, float a)
		{
			return @this.Sub(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Mul(this (float X, float Y) @this, float a)
		{
			return @this.Mul(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Div(this (float X, float Y) @this, float a)
		{
			return @this.Div(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Rem(this (float X, float Y) @this, float a)
		{
			return @this.Rem(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y) BitAnd(this (float X, float Y) @this, float a)
		{
			return default((int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y) BitOr(this (float X, float Y) @this, float a)
		{
			return default((int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y) BitXor(this (float X, float Y) @this, float a)
		{
			return default((int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y) BitShiftLeft(this (float X, float Y) @this, float a)
		{
			return default((int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y) BitShiftRight(this (float X, float Y) @this, float a)
		{
			return default((int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsEqual(this (float X, float Y) @this, float a)
		{
			return @this.IsEqual(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsNotEqual(this (float X, float Y) @this, float a)
		{
			return @this.IsNotEqual(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsGreater(this (float X, float Y) @this, float a)
		{
			return @this.IsGreater(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsGreaterOrEqual(this (float X, float Y) @this, float a)
		{
			return @this.IsGreaterOrEqual(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsLess(this (float X, float Y) @this, float a)
		{
			return @this.IsLess(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsLessOrEqual(this (float X, float Y) @this, float a)
		{
			return @this.IsLessOrEqual(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Pow(this (float X, float Y) @this, float a)
		{
			return @this.Pow(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Root(this (float X, float Y) @this, float a)
		{
			return @this.Root(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ModEuclid(this (float X, float Y) @this, float a)
		{
			return @this.ModEuclid(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ModRound(this (float X, float Y) @this, float a)
		{
			return @this.ModRound(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Avg(this (float X, float Y) @this, float a)
		{
			return @this.Avg(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Lerp(this (float X, float Y) @this, float a, float b)
		{
			return @this.Lerp(a.ToFloat2(), b.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) LerpClamp(this (float X, float Y) @this, float a, float b)
		{
			return @this.LerpClamp(a.ToFloat2(), b.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Map(this (float X, float Y) @this, float a, float b, float c, float d)
		{
			return @this.Map(a.ToFloat2(), b.ToFloat2(), c.ToFloat2(), d.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) MapClamp(this (float X, float Y) @this, float a, float b, float c, float d)
		{
			return @this.MapClamp(a.ToFloat2(), b.ToFloat2(), c.ToFloat2(), d.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundToMultiple(this (float X, float Y) @this, int a)
		{
			return @this.RoundToMultiple(a.ToInt2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundDownToMultiple(this (float X, float Y) @this, int a)
		{
			return @this.RoundDownToMultiple(a.ToInt2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundUpToMultiple(this (float X, float Y) @this, int a)
		{
			return @this.RoundUpToMultiple(a.ToInt2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundTowardsZeroToMultiple(this (float X, float Y) @this, int a)
		{
			return @this.RoundTowardsZeroToMultiple(a.ToInt2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) RoundAwayFromZeroToMultiple(this (float X, float Y) @this, int a)
		{
			return @this.RoundAwayFromZeroToMultiple(a.ToInt2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundToMultiple(this (float X, float Y) @this, float a)
		{
			return @this.RoundToMultiple(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundDownToMultiple(this (float X, float Y) @this, float a)
		{
			return @this.RoundDownToMultiple(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundUpToMultiple(this (float X, float Y) @this, float a)
		{
			return @this.RoundUpToMultiple(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundTowardsZeroToMultiple(this (float X, float Y) @this, float a)
		{
			return @this.RoundTowardsZeroToMultiple(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) RoundAwayFromZeroToMultiple(this (float X, float Y) @this, float a)
		{
			return @this.RoundAwayFromZeroToMultiple(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) Compare(this (float X, float Y) @this, float a)
		{
			return @this.Compare(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Min(this (float X, float Y) @this, float a)
		{
			return @this.Min(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Max(this (float X, float Y) @this, float a)
		{
			return @this.Max(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) Clamp(this (float X, float Y) @this, float a, float b)
		{
			return @this.Clamp(a.ToFloat2(), b.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ClampMin(this (float X, float Y) @this, float a)
		{
			return @this.ClampMin(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ClampMax(this (float X, float Y) @this, float a)
		{
			return @this.ClampMax(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsBetween(this (float X, float Y) @this, float a, float b)
		{
			return @this.IsBetween(a.ToFloat2(), b.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) IsNotBetween(this (float X, float Y) @this, float a, float b)
		{
			return @this.IsNotBetween(a.ToFloat2(), b.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Dot(this (float X, float Y) @this, float a)
		{
			return @this.Dot(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Cross(this (float X, float Y) @this, float a)
		{
			return @this.Cross(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) OffsetTo(this (float X, float Y) @this, float a)
		{
			return @this.OffsetTo(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) OffsetFrom(this (float X, float Y) @this, float a)
		{
			return @this.OffsetFrom(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DistanceTo(this (float X, float Y) @this, float a)
		{
			return @this.DistanceTo(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DistanceFrom(this (float X, float Y) @this, float a)
		{
			return @this.DistanceFrom(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) DirectionTo(this (float X, float Y) @this, float a)
		{
			return @this.DirectionTo(a.ToFloat2());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) DirectionFrom(this (float X, float Y) @this, float a)
		{
			return @this.DirectionFrom(a.ToFloat2());
		}
	}
	public static class Extensions_float3
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Neg(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Neg(), @this.Y.Neg(), @this.Z.Neg());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Inc(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Inc(), @this.Y.Inc(), @this.Z.Inc());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Dec(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Dec(), @this.Y.Dec(), @this.Z.Dec());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Add(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Add(a.X), @this.Y.Add(a.Y), @this.Z.Add(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Sub(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Sub(a.X), @this.Y.Sub(a.Y), @this.Z.Sub(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Mul(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Mul(a.X), @this.Y.Mul(a.Y), @this.Z.Mul(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Div(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Div(a.X), @this.Y.Div(a.Y), @this.Z.Div(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Rem(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Rem(a.X), @this.Y.Rem(a.Y), @this.Z.Rem(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) BitAnd(this (float X, float Y, float Z) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) BitOr(this (float X, float Y, float Z) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) BitXor(this (float X, float Y, float Z) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) BitShiftLeft(this (float X, float Y, float Z) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (float X, float Y, float Z) BitShiftRight(this (float X, float Y, float Z) @this)
		{
			return default((float, float, float));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsEqual(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.IsEqual(a.X), @this.Y.IsEqual(a.Y), @this.Z.IsEqual(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsNotEqual(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.IsNotEqual(a.X), @this.Y.IsNotEqual(a.Y), @this.Z.IsNotEqual(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsGreater(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.IsGreater(a.X), @this.Y.IsGreater(a.Y), @this.Z.IsGreater(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsGreaterOrEqual(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.IsGreaterOrEqual(a.X), @this.Y.IsGreaterOrEqual(a.Y), @this.Z.IsGreaterOrEqual(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsLess(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.IsLess(a.X), @this.Y.IsLess(a.Y), @this.Z.IsLess(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsLessOrEqual(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.IsLessOrEqual(a.X), @this.Y.IsLessOrEqual(a.Y), @this.Z.IsLessOrEqual(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Inv(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Inv(), @this.Y.Inv(), @this.Z.Inv());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Abs(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Abs(), @this.Y.Abs(), @this.Z.Abs());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Sig(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Sig(), @this.Y.Sig(), @this.Z.Sig());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Sqrd(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Sqrd(), @this.Y.Sqrd(), @this.Z.Sqrd());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Sqrt(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Sqrt(), @this.Y.Sqrt(), @this.Z.Sqrt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Pow(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Pow(a.X), @this.Y.Pow(a.Y), @this.Z.Pow(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Root(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Root(a.X), @this.Y.Root(a.Y), @this.Z.Root(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ModEuclid(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.ModEuclid(a.X), @this.Y.ModEuclid(a.Y), @this.Z.ModEuclid(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ModRound(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.ModRound(a.X), @this.Y.ModRound(a.Y), @this.Z.ModRound(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Avg(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Avg(a.X), @this.Y.Avg(a.Y), @this.Z.Avg(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Lerp(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a, (float X, float Y, float Z) b)
		{
			return (@this.X.Lerp(a.X, b.X), @this.Y.Lerp(a.Y, b.Y), @this.Z.Lerp(a.Z, b.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) LerpClamp(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a, (float X, float Y, float Z) b)
		{
			return (@this.X.LerpClamp(a.X, b.X), @this.Y.LerpClamp(a.Y, b.Y), @this.Z.LerpClamp(a.Z, b.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Map(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a, (float X, float Y, float Z) b, (float X, float Y, float Z) c, (float X, float Y, float Z) d)
		{
			return (@this.X.Map(a.X, b.X, c.X, d.X), @this.Y.Map(a.Y, b.Y, c.Y, d.Y), @this.Z.Map(a.Z, b.Z, c.Z, d.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) MapClamp(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a, (float X, float Y, float Z) b, (float X, float Y, float Z) c, (float X, float Y, float Z) d)
		{
			return (@this.X.MapClamp(a.X, b.X, c.X, d.X), @this.Y.MapClamp(a.Y, b.Y, c.Y, d.Y), @this.Z.MapClamp(a.Z, b.Z, c.Z, d.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) Round(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Round(), @this.Y.Round(), @this.Z.Round());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) RoundDown(this (float X, float Y, float Z) @this)
		{
			return (@this.X.RoundDown(), @this.Y.RoundDown(), @this.Z.RoundDown());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) RoundUp(this (float X, float Y, float Z) @this)
		{
			return (@this.X.RoundUp(), @this.Y.RoundUp(), @this.Z.RoundUp());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) RoundTowardsZero(this (float X, float Y, float Z) @this)
		{
			return (@this.X.RoundTowardsZero(), @this.Y.RoundTowardsZero(), @this.Z.RoundTowardsZero());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) RoundAwayFromZero(this (float X, float Y, float Z) @this)
		{
			return (@this.X.RoundAwayFromZero(), @this.Y.RoundAwayFromZero(), @this.Z.RoundAwayFromZero());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) RoundToMultiple(this (float X, float Y, float Z) @this, (int X, int Y, int Z) a)
		{
			return (@this.X.RoundToMultiple(a.X), @this.Y.RoundToMultiple(a.Y), @this.Z.RoundToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) RoundDownToMultiple(this (float X, float Y, float Z) @this, (int X, int Y, int Z) a)
		{
			return (@this.X.RoundDownToMultiple(a.X), @this.Y.RoundDownToMultiple(a.Y), @this.Z.RoundDownToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) RoundUpToMultiple(this (float X, float Y, float Z) @this, (int X, int Y, int Z) a)
		{
			return (@this.X.RoundUpToMultiple(a.X), @this.Y.RoundUpToMultiple(a.Y), @this.Z.RoundUpToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) RoundTowardsZeroToMultiple(this (float X, float Y, float Z) @this, (int X, int Y, int Z) a)
		{
			return (@this.X.RoundTowardsZeroToMultiple(a.X), @this.Y.RoundTowardsZeroToMultiple(a.Y), @this.Z.RoundTowardsZeroToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) RoundAwayFromZeroToMultiple(this (float X, float Y, float Z) @this, (int X, int Y, int Z) a)
		{
			return (@this.X.RoundAwayFromZeroToMultiple(a.X), @this.Y.RoundAwayFromZeroToMultiple(a.Y), @this.Z.RoundAwayFromZeroToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) RoundToMultiple(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.RoundToMultiple(a.X), @this.Y.RoundToMultiple(a.Y), @this.Z.RoundToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) RoundDownToMultiple(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.RoundDownToMultiple(a.X), @this.Y.RoundDownToMultiple(a.Y), @this.Z.RoundDownToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) RoundUpToMultiple(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.RoundUpToMultiple(a.X), @this.Y.RoundUpToMultiple(a.Y), @this.Z.RoundUpToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) RoundTowardsZeroToMultiple(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.RoundTowardsZeroToMultiple(a.X), @this.Y.RoundTowardsZeroToMultiple(a.Y), @this.Z.RoundTowardsZeroToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) RoundAwayFromZeroToMultiple(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.RoundAwayFromZeroToMultiple(a.X), @this.Y.RoundAwayFromZeroToMultiple(a.Y), @this.Z.RoundAwayFromZeroToMultiple(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ToRad(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ToRad(), @this.Y.ToRad(), @this.Z.ToRad());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ToDeg(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ToDeg(), @this.Y.ToDeg(), @this.Z.ToDeg());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Sin(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Sin(), @this.Y.Sin(), @this.Z.Sin());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Cos(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Cos(), @this.Y.Cos(), @this.Z.Cos());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Tan(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Tan(), @this.Y.Tan(), @this.Z.Tan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Cot(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Cot(), @this.Y.Cot(), @this.Z.Cot());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Sec(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Sec(), @this.Y.Sec(), @this.Z.Sec());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Csc(this (float X, float Y, float Z) @this)
		{
			return (@this.X.Csc(), @this.Y.Csc(), @this.Z.Csc());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ArcSin(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ArcSin(), @this.Y.ArcSin(), @this.Z.ArcSin());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ArcCos(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ArcCos(), @this.Y.ArcCos(), @this.Z.ArcCos());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ArcTan(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ArcTan(), @this.Y.ArcTan(), @this.Z.ArcTan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ArcCot(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ArcCot(), @this.Y.ArcCot(), @this.Z.ArcCot());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ArcSec(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ArcSec(), @this.Y.ArcSec(), @this.Z.ArcSec());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ArcCsc(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ArcCsc(), @this.Y.ArcCsc(), @this.Z.ArcCsc());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) Compare(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Compare(a.X), @this.Y.Compare(a.Y), @this.Z.Compare(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Min(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Min(a.X), @this.Y.Min(a.Y), @this.Z.Min(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Max(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.Max(a.X), @this.Y.Max(a.Y), @this.Z.Max(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Clamp(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a, (float X, float Y, float Z) b)
		{
			return (@this.X.Clamp(a.X, b.X), @this.Y.Clamp(a.Y, b.Y), @this.Z.Clamp(a.Z, b.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ClampMin(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.ClampMin(a.X), @this.Y.ClampMin(a.Y), @this.Z.ClampMin(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ClampMax(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.X.ClampMax(a.X), @this.Y.ClampMax(a.Y), @this.Z.ClampMax(a.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsBetween(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a, (float X, float Y, float Z) b)
		{
			return (@this.X.IsBetween(a.X, b.X), @this.Y.IsBetween(a.Y, b.Y), @this.Z.IsBetween(a.Z, b.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsNotBetween(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a, (float X, float Y, float Z) b)
		{
			return (@this.X.IsNotBetween(a.X, b.X), @this.Y.IsNotBetween(a.Y, b.Y), @this.Z.IsNotBetween(a.Z, b.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsEven(this (float X, float Y, float Z) @this)
		{
			return (@this.X.IsEven(), @this.Y.IsEven(), @this.Z.IsEven());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsOdd(this (float X, float Y, float Z) @this)
		{
			return (@this.X.IsOdd(), @this.Y.IsOdd(), @this.Z.IsOdd());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsZero(this (float X, float Y, float Z) @this)
		{
			return (@this.X.IsZero(), @this.Y.IsZero(), @this.Z.IsZero());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsNotZero(this (float X, float Y, float Z) @this)
		{
			return (@this.X.IsNotZero(), @this.Y.IsNotZero(), @this.Z.IsNotZero());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsPositive(this (float X, float Y, float Z) @this)
		{
			return (@this.X.IsPositive(), @this.Y.IsPositive(), @this.Z.IsPositive());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsNotPositive(this (float X, float Y, float Z) @this)
		{
			return (@this.X.IsNotPositive(), @this.Y.IsNotPositive(), @this.Z.IsNotPositive());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsNegative(this (float X, float Y, float Z) @this)
		{
			return (@this.X.IsNegative(), @this.Y.IsNegative(), @this.Z.IsNegative());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsNotNegative(this (float X, float Y, float Z) @this)
		{
			return (@this.X.IsNotNegative(), @this.Y.IsNotNegative(), @this.Z.IsNotNegative());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static float Append(this (float X, float Y, float Z) @this)
		{
			return 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool ToBool(this (float X, float Y, float Z) @this)
		{
			return @this.X.ToBool();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y) ToBool2(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ToBool(), @this.Y.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) ToBool3(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ToBool(), @this.Y.ToBool(), @this.Z.ToBool());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ToInt(this (float X, float Y, float Z) @this)
		{
			return @this.X.ToInt();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y) ToInt2(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ToInt(), @this.Y.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (int X, int Y, int Z) ToInt3(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ToInt(), @this.Y.ToInt(), @this.Z.ToInt());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ToFloat(this (float X, float Y, float Z) @this)
		{
			return @this.X.ToFloat();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ToFloat2(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ToFloat(), @this.Y.ToFloat());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ToFloat3(this (float X, float Y, float Z) @this)
		{
			return (@this.X.ToFloat(), @this.Y.ToFloat(), @this.Z.ToFloat());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Dot(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return @this.X * a.X + @this.Y * a.Y + @this.Z * a.Z;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Cross(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return (@this.Y * a.Z - @this.Z * a.Y, @this.Z * a.X - @this.X * a.Z, @this.X * a.Y - @this.Y * a.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float LenSqrd(this (float X, float Y, float Z) @this)
		{
			return @this.Dot(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Len(this (float X, float Y, float Z) @this)
		{
			return @this.LenSqrd().Sqrt();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Norm(this (float X, float Y, float Z) @this)
		{
			return @this.Div(@this.Len().ToFloat3());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) OffsetTo(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return a.Sub(@this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) OffsetFrom(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return @this.Sub(a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DistanceTo(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return @this.OffsetTo(a).Len();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DistanceFrom(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return @this.OffsetFrom(a).Len();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) DirectionTo(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return @this.OffsetTo(a).Norm();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) DirectionFrom(this (float X, float Y, float Z) @this, (float X, float Y, float Z) a)
		{
			return @this.OffsetFrom(a).Norm();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float GetComp(this (float X, float Y, float Z) @this, Axis a)
		{
			float result;
			switch (a)
			{
			default:
				result = 0f;
				break;
			case Axis.Z:
				result = @this.Z;
				break;
			case Axis.Y:
				result = @this.Y;
				break;
			case Axis.X:
				(result, _, _) = @this;
				break;
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float AddComps(this (float X, float Y, float Z) @this)
		{
			return @this.X + @this.Y + @this.Z;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MulComps(this (float X, float Y, float Z) @this)
		{
			return @this.X * @this.Y * @this.Z;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MaxComp(this (float X, float Y, float Z) @this)
		{
			float result;
			if (@this.X >= @this.Y && @this.X >= @this.Z)
			{
				(result, _, _) = @this;
			}
			else
			{
				result = ((@this.Y >= @this.Z) ? @this.Y : @this.Z);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MinComp(this (float X, float Y, float Z) @this)
		{
			float result;
			if (@this.X <= @this.Y && @this.X <= @this.Z)
			{
				(result, _, _) = @this;
			}
			else
			{
				result = ((@this.Y <= @this.Z) ? @this.Y : @this.Z);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Axis MaxAxis(this (float X, float Y, float Z) @this)
		{
			return (@this.X >= @this.Y && @this.X >= @this.Z) ? Axis.X : ((@this.Y >= @this.Z) ? Axis.Y : Axis.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Axis MinAxis(this (float X, float Y, float Z) @this)
		{
			return (@this.X <= @this.Y && @this.X <= @this.Z) ? Axis.X : ((@this.Y <= @this.Z) ? Axis.Y : Axis.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (T X, T Y, T Z) ProcessComps<T>(this (float X, float Y, float Z) @this, Func<float, T> func)
		{
			return (func(@this.X), func(@this.Y), func(@this.X));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) NewX(this (float X, float Y, float Z) @this, float x)
		{
			return (x, @this.Y, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) NewY(this (float X, float Y, float Z) @this, float y)
		{
			return (@this.X, y, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) NewZ(this (float X, float Y, float Z) @this, float z)
		{
			return (@this.X, @this.Y, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) NewXY(this (float X, float Y, float Z) @this, float x, float y)
		{
			return (x, y, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) NewXZ(this (float X, float Y, float Z) @this, float x, float z)
		{
			return (x, @this.Y, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) NewYX(this (float X, float Y, float Z) @this, float y, float x)
		{
			return (x, y, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) NewYZ(this (float X, float Y, float Z) @this, float y, float z)
		{
			return (@this.X, y, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) NewZX(this (float X, float Y, float Z) @this, float z, float x)
		{
			return (x, @this.Y, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) NewZY(this (float X, float Y, float Z) @this, float z, float y)
		{
			return (@this.X, y, z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) XX(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) XY(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) YX(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) YY(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) XZ(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) YZ(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ZX(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ZY(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y) ZZ(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XXX(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.X, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XXY(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.X, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XYX(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.Y, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XYY(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.Y, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YXX(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.X, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YXY(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.X, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YYX(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.Y, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YYY(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.Y, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XXZ(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.X, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XYZ(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.Y, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XZX(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.Z, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XZY(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.Z, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) XZZ(this (float X, float Y, float Z) @this)
		{
			return (@this.X, @this.Z, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YXZ(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.X, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YYZ(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.Y, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YZX(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.Z, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YZY(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.Z, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) YZZ(this (float X, float Y, float Z) @this)
		{
			return (@this.Y, @this.Z, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ZXX(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.X, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ZXY(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.X, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ZXZ(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.X, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ZYX(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.Y, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ZYY(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.Y, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ZYZ(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.Y, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ZZX(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.Z, @this.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ZZY(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.Z, @this.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) ZZZ(this (float X, float Y, float Z) @this)
		{
			return (@this.Z, @this.Z, @this.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Add(this (float X, float Y, float Z) @this, float a)
		{
			return @this.Add(a.ToFloat3());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Sub(this (float X, float Y, float Z) @this, float a)
		{
			return @this.Sub(a.ToFloat3());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Mul(this (float X, float Y, float Z) @this, float a)
		{
			return @this.Mul(a.ToFloat3());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Div(this (float X, float Y, float Z) @this, float a)
		{
			return @this.Div(a.ToFloat3());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (float X, float Y, float Z) Rem(this (float X, float Y, float Z) @this, float a)
		{
			return @this.Rem(a.ToFloat3());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y, int Z) BitAnd(this (float X, float Y, float Z) @this, float a)
		{
			return default((int, int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y, int Z) BitOr(this (float X, float Y, float Z) @this, float a)
		{
			return default((int, int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y, int Z) BitXor(this (float X, float Y, float Z) @this, float a)
		{
			return default((int, int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y, int Z) BitShiftLeft(this (float X, float Y, float Z) @this, float a)
		{
			return default((int, int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (int X, int Y, int Z) BitShiftRight(this (float X, float Y, float Z) @this, float a)
		{
			return default((int, int, int));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsEqual(this (float X, float Y, float Z) @this, float a)
		{
			return @this.IsEqual(a.ToFloat3());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static (bool X, bool Y, bool Z) IsNotEqual(this (float X, float Y, float Z) @this, float a)
		{
			return @this.