using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using AssetRipper.Primitives.Extensions;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("VersionUtilities.Tests")]
[assembly: AssemblyCompany("AssetRipper")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2022-2024 ds5678")]
[assembly: AssemblyDescription("Managed library for primitive types used in AssetRipper.")]
[assembly: AssemblyFileVersion("3.1.3")]
[assembly: AssemblyInformationalVersion("3.1.3+9c4a7d8127cc9af1e5f61edee8eeb90bd90676aa")]
[assembly: AssemblyProduct("AssetRipper.Primitives")]
[assembly: AssemblyTitle("AssetRipper.Primitives")]
[assembly: AssemblyVersion("3.1.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 System
{
	internal readonly struct Index : IEquatable<Index>
	{
		private static class ThrowHelper
		{
			[DoesNotReturn]
			public static void ThrowValueArgumentOutOfRange_NeedNonNegNumException()
			{
				throw new ArgumentOutOfRangeException("value", "Non-negative number required.");
			}
		}

		private readonly int _value;

		public static Index Start => new Index(0);

		public static Index End => new Index(-1);

		public int Value
		{
			get
			{
				if (_value < 0)
				{
					return ~_value;
				}
				return _value;
			}
		}

		public bool IsFromEnd => _value < 0;

		public Index(int value, bool fromEnd = false)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			if (fromEnd)
			{
				_value = ~value;
			}
			else
			{
				_value = value;
			}
		}

		private Index(int value)
		{
			_value = value;
		}

		public static Index FromStart(int value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return new Index(value);
		}

		public static Index FromEnd(int value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return new Index(~value);
		}

		public int GetOffset(int length)
		{
			int num = _value;
			if (IsFromEnd)
			{
				num += length + 1;
			}
			return num;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is Index)
			{
				return _value == ((Index)value)._value;
			}
			return false;
		}

		public bool Equals(Index other)
		{
			return _value == other._value;
		}

		public override int GetHashCode()
		{
			return _value;
		}

		public static implicit operator Index(int value)
		{
			return FromStart(value);
		}

		public override string ToString()
		{
			if (IsFromEnd)
			{
				return ToStringFromEnd();
			}
			return ((uint)Value).ToString();
		}

		private string ToStringFromEnd()
		{
			return "^" + Value;
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false, AllowMultiple = false)]
	internal sealed class AsyncMethodBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public AsyncMethodBuilderAttribute(Type builderType)
		{
			BuilderType = builderType;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace AssetRipper.Primitives
{
	public readonly struct UnityVersion : IEquatable<UnityVersion>, IComparable, IComparable<UnityVersion>
	{
		private const ulong subMajorMask = 281474976710655uL;

		private const ulong subMinorMask = 4294967295uL;

		private const ulong subBuildMask = 65535uL;

		private const ulong subTypeMask = 255uL;

		private const int majorOffset = 48;

		private const int minorOffset = 32;

		private const int buildOffset = 16;

		private const int typeOffset = 8;

		private const ulong byteMask = 255uL;

		private const ulong ushortMask = 65535uL;

		private readonly ulong m_data;

		public ushort Major => (ushort)((m_data >> 48) & 0xFFFF);

		public ushort Minor => (ushort)((m_data >> 32) & 0xFFFF);

		public ushort Build => (ushort)((m_data >> 16) & 0xFFFF);

		public UnityVersionType Type => (UnityVersionType)((m_data >> 8) & 0xFF);

		public byte TypeNumber => (byte)(m_data & 0xFF);

		public static UnityVersion MinVersion { get; } = new UnityVersion(0uL);


		public static UnityVersion MaxVersion { get; } = new UnityVersion(ulong.MaxValue);


		public bool Equals(ushort major)
		{
			return this == From(major);
		}

		public bool Equals(ushort major, ushort minor)
		{
			return this == From(major, minor);
		}

		public bool Equals(ushort major, ushort minor, ushort build)
		{
			return this == From(major, minor, build);
		}

		public bool Equals(ushort major, ushort minor, ushort build, UnityVersionType type)
		{
			return this == From(major, minor, build, type);
		}

		public bool Equals(ushort major, ushort minor, ushort build, UnityVersionType type, byte typeNumber)
		{
			return this == new UnityVersion(major, minor, build, type, typeNumber);
		}

		public bool Equals(string version)
		{
			return this == Parse(version);
		}

		public bool LessThan(ushort major)
		{
			return this < From(major);
		}

		public bool LessThan(ushort major, ushort minor)
		{
			return this < From(major, minor);
		}

		public bool LessThan(ushort major, ushort minor, ushort build)
		{
			return this < From(major, minor, build);
		}

		public bool LessThan(ushort major, ushort minor, ushort build, UnityVersionType type)
		{
			return this < From(major, minor, build, type);
		}

		public bool LessThan(ushort major, ushort minor, ushort build, UnityVersionType type, byte typeNumber)
		{
			return this < new UnityVersion(major, minor, build, type, typeNumber);
		}

		public bool LessThan(string version)
		{
			return this < Parse(version);
		}

		public bool LessThanOrEquals(ushort major)
		{
			return this <= From(major);
		}

		public bool LessThanOrEquals(ushort major, ushort minor)
		{
			return this <= From(major, minor);
		}

		public bool LessThanOrEquals(ushort major, ushort minor, ushort build)
		{
			return this <= From(major, minor, build);
		}

		public bool LessThanOrEquals(ushort major, ushort minor, ushort build, UnityVersionType type)
		{
			return this <= From(major, minor, build, type);
		}

		public bool LessThanOrEquals(ushort major, ushort minor, ushort build, UnityVersionType type, byte typeNumber)
		{
			return this <= new UnityVersion(major, minor, build, type, typeNumber);
		}

		public bool LessThanOrEquals(string version)
		{
			return this <= Parse(version);
		}

		public bool GreaterThan(ushort major)
		{
			return this > From(major);
		}

		public bool GreaterThan(ushort major, ushort minor)
		{
			return this > From(major, minor);
		}

		public bool GreaterThan(ushort major, ushort minor, ushort build)
		{
			return this > From(major, minor, build);
		}

		public bool GreaterThan(ushort major, ushort minor, ushort build, UnityVersionType type)
		{
			return this > From(major, minor, build, type);
		}

		public bool GreaterThan(ushort major, ushort minor, ushort build, UnityVersionType type, byte typeNumber)
		{
			return this > new UnityVersion(major, minor, build, type, typeNumber);
		}

		public bool GreaterThan(string version)
		{
			return this > Parse(version);
		}

		public bool GreaterThanOrEquals(ushort major)
		{
			return this >= From(major);
		}

		public bool GreaterThanOrEquals(ushort major, ushort minor)
		{
			return this >= From(major, minor);
		}

		public bool GreaterThanOrEquals(ushort major, ushort minor, ushort build)
		{
			return this >= From(major, minor, build);
		}

		public bool GreaterThanOrEquals(ushort major, ushort minor, ushort build, UnityVersionType type)
		{
			return this >= From(major, minor, build, type);
		}

		public bool GreaterThanOrEquals(ushort major, ushort minor, ushort build, UnityVersionType type, byte typeNumber)
		{
			return this >= new UnityVersion(major, minor, build, type, typeNumber);
		}

		public bool GreaterThanOrEquals(string version)
		{
			return this >= Parse(version);
		}

		private UnityVersion From(ushort major)
		{
			return new UnityVersion(((ulong)major << 48) | (0xFFFFFFFFFFFFuL & m_data));
		}

		private UnityVersion From(ushort major, ushort minor)
		{
			return new UnityVersion(((ulong)major << 48) | ((ulong)minor << 32) | (0xFFFFFFFFu & m_data));
		}

		private UnityVersion From(ushort major, ushort minor, ushort build)
		{
			return new UnityVersion(((ulong)major << 48) | ((ulong)minor << 32) | ((ulong)build << 16) | (0xFFFF & m_data));
		}

		private UnityVersion From(ushort major, ushort minor, ushort build, UnityVersionType type)
		{
			return new UnityVersion(((ulong)major << 48) | ((ulong)minor << 32) | ((ulong)build << 16) | ((ulong)type << 8) | (0xFF & m_data));
		}

		public UnityVersion(ushort major)
		{
			m_data = (ulong)major << 48;
		}

		public UnityVersion(ushort major, ushort minor)
		{
			m_data = ((ulong)major << 48) | ((ulong)minor << 32);
		}

		public UnityVersion(ushort major, ushort minor, ushort build)
		{
			m_data = ((ulong)major << 48) | ((ulong)minor << 32) | ((ulong)build << 16);
		}

		public UnityVersion(ushort major, ushort minor, ushort build, UnityVersionType type)
		{
			m_data = ((ulong)major << 48) | ((ulong)minor << 32) | ((ulong)build << 16) | ((ulong)type << 8);
		}

		public UnityVersion(ushort major, ushort minor, ushort build, UnityVersionType type, byte typeNumber)
		{
			m_data = ((ulong)major << 48) | ((ulong)minor << 32) | ((ulong)build << 16) | ((ulong)type << 8) | typeNumber;
		}

		private UnityVersion(ulong data)
		{
			m_data = data;
		}

		public ulong GetBits()
		{
			return m_data;
		}

		public static UnityVersion FromBits(ulong bits)
		{
			return new UnityVersion(bits);
		}

		public int CompareTo(object? obj)
		{
			if (!(obj is UnityVersion other))
			{
				return 1;
			}
			return CompareTo(other);
		}

		public int CompareTo(UnityVersion other)
		{
			ulong data = m_data;
			return data.CompareTo(other.m_data);
		}

		public override bool Equals(object? obj)
		{
			if (obj is UnityVersion unityVersion)
			{
				return this == unityVersion;
			}
			return false;
		}

		public bool Equals(UnityVersion other)
		{
			return this == other;
		}

		public override int GetHashCode()
		{
			ulong data = m_data;
			return data.GetHashCode();
		}

		public static UnityVersion Max(UnityVersion left, UnityVersion right)
		{
			if (!(left > right))
			{
				return right;
			}
			return left;
		}

		public static UnityVersion Min(UnityVersion left, UnityVersion right)
		{
			if (!(left < right))
			{
				return right;
			}
			return left;
		}

		public static ulong Distance(UnityVersion left, UnityVersion right)
		{
			if (left.m_data >= right.m_data)
			{
				return left.m_data - right.m_data;
			}
			return right.m_data - left.m_data;
		}

		public UnityVersion GetClosestVersion(UnityVersion[] versions)
		{
			if (versions == null)
			{
				throw new ArgumentNullException("versions");
			}
			if (versions.Length == 0)
			{
				throw new ArgumentException("Length cannot be zero", "versions");
			}
			UnityVersion unityVersion = versions[0];
			ulong num = Distance(this, unityVersion);
			for (int i = 1; i < versions.Length; i++)
			{
				ulong num2 = Distance(this, versions[i]);
				if (num2 < num)
				{
					num = num2;
					unityVersion = versions[i];
				}
			}
			return unityVersion;
		}

		public UnityVersion ChangeMajor(ushort value)
		{
			return new UnityVersion(value, Minor, Build, Type, TypeNumber);
		}

		public UnityVersion ChangeMinor(ushort value)
		{
			return new UnityVersion(Major, value, Build, Type, TypeNumber);
		}

		public UnityVersion ChangeBuild(ushort value)
		{
			return new UnityVersion(Major, Minor, value, Type, TypeNumber);
		}

		public UnityVersion ChangeType(UnityVersionType value)
		{
			return new UnityVersion(Major, Minor, Build, value, TypeNumber);
		}

		public UnityVersion ChangeTypeNumber(byte value)
		{
			return new UnityVersion(Major, Minor, Build, Type, value);
		}

		public static bool operator ==(UnityVersion left, UnityVersion right)
		{
			return left.m_data == right.m_data;
		}

		public static bool operator !=(UnityVersion left, UnityVersion right)
		{
			return left.m_data != right.m_data;
		}

		public static bool operator >(UnityVersion left, UnityVersion right)
		{
			return left.m_data > right.m_data;
		}

		public static bool operator >=(UnityVersion left, UnityVersion right)
		{
			return left.m_data >= right.m_data;
		}

		public static bool operator <(UnityVersion left, UnityVersion right)
		{
			return left.m_data < right.m_data;
		}

		public static bool operator <=(UnityVersion left, UnityVersion right)
		{
			return left.m_data <= right.m_data;
		}

		public override string ToString()
		{
			return ToString(UnityVersionFormatFlags.Default);
		}

		public string ToString(UnityVersionFormatFlags flags)
		{
			if ((flags & UnityVersionFormatFlags.ExcludeType) == 0)
			{
				if (Type == UnityVersionType.China && (flags & UnityVersionFormatFlags.UseShortChineseFormat) == 0)
				{
					return $"{Major}.{Minor}.{Build}f1c{TypeNumber}";
				}
				return $"{Major}.{Minor}.{Build}{Type.ToCharacter()}{TypeNumber}";
			}
			return ToStringWithoutType();
		}

		public string ToString(UnityVersionFormatFlags flags, string customEngineString = "")
		{
			if (customEngineString.Length != 0)
			{
				if ((flags & UnityVersionFormatFlags.ExcludeType) == 0)
				{
					if (Type == UnityVersionType.China && (flags & UnityVersionFormatFlags.UseShortChineseFormat) == 0)
					{
						return $"{Major}.{Minor}.{Build}f1c{TypeNumber}{customEngineString}";
					}
					return $"{Major}.{Minor}.{Build}{Type.ToCharacter()}{TypeNumber}{customEngineString}";
				}
				return ToStringWithoutType();
			}
			return ToString(flags);
		}

		public string ToStringWithoutType()
		{
			return $"{Major}.{Minor}.{Build}";
		}

		public static UnityVersion Parse(string s)
		{
			string customEngine;
			return Parse(s, out customEngine);
		}

		public static UnityVersion Parse(string s, out string? customEngine)
		{
			if (!TryParse(s, out var version, out customEngine))
			{
				throw new ArgumentException("Invalid version format: " + s, "s");
			}
			return version;
		}

		public static bool TryParse(string s, out UnityVersion version, out string? customEngine)
		{
			if (string.IsNullOrEmpty(s))
			{
				customEngine = null;
				version = default(UnityVersion);
				return false;
			}
			if (UnityVersionRegexes.GetChinaRegex().TryMatch(s, out Match match))
			{
				int num = int.Parse(match.Groups[1].Value);
				int num2 = int.Parse(match.Groups[2].Value);
				int num3 = int.Parse(match.Groups[3].Value);
				int num4 = int.Parse(match.Groups[4].Value);
				customEngine = GetNullableString(match.Groups[5]);
				version = new UnityVersion((ushort)num, (ushort)num2, (ushort)num3, UnityVersionType.China, (byte)num4);
				return true;
			}
			if (UnityVersionRegexes.GetNormalRegex().TryMatch(s, out match))
			{
				int num5 = int.Parse(match.Groups[1].Value);
				int num6 = int.Parse(match.Groups[2].Value);
				int num7 = int.Parse(match.Groups[3].Value);
				char c = match.Groups[4].Value[0];
				int num8 = int.Parse(match.Groups[5].Value);
				customEngine = GetNullableString(match.Groups[6]);
				version = new UnityVersion((ushort)num5, (ushort)num6, (ushort)num7, c.ToUnityVersionType(), (byte)num8);
				return true;
			}
			if (UnityVersionRegexes.GetMajorMinorBuildRegex().TryMatch(s, out match))
			{
				int num9 = int.Parse(match.Groups[1].Value);
				int num10 = int.Parse(match.Groups[2].Value);
				int num11 = int.Parse(match.Groups[3].Value);
				customEngine = null;
				version = ((num9 != 0 || num10 != 0 || num11 != 0) ? new UnityVersion((ushort)num9, (ushort)num10, (ushort)num11, UnityVersionType.Final, 1) : default(UnityVersion));
				return true;
			}
			if (UnityVersionRegexes.GetMajorMinorRegex().TryMatch(s, out match))
			{
				int num12 = int.Parse(match.Groups[1].Value);
				int num13 = int.Parse(match.Groups[2].Value);
				customEngine = null;
				version = ((num12 != 0 || num13 != 0) ? new UnityVersion((ushort)num12, (ushort)num13, 0, UnityVersionType.Final, 1) : default(UnityVersion));
				return true;
			}
			if (UnityVersionRegexes.GetMajorRegex().TryMatch(s, out match))
			{
				int num14 = int.Parse(match.Groups[1].Value);
				customEngine = null;
				version = ((num14 != 0) ? new UnityVersion((ushort)num14, 0, 0, UnityVersionType.Final, 1) : default(UnityVersion));
				return true;
			}
			customEngine = null;
			version = default(UnityVersion);
			return false;
			static string? GetNullableString(Capture capture)
			{
				if (capture.Length != 0)
				{
					return capture.Value;
				}
				return null;
			}
		}
	}
	[Flags]
	public enum UnityVersionFormatFlags
	{
		Default = 0,
		ExcludeType = 1,
		UseShortChineseFormat = 2
	}
	internal static class UnityVersionRegexes
	{
		private const RegexOptions Options = RegexOptions.None;

		[StringSyntax("regex")]
		private const string Major = "([0-9]+)";

		[StringSyntax("regex")]
		private const string MajorMinor = "([0-9]+)\\.([0-9]+)";

		[StringSyntax("regex")]
		private const string MajorMinorBuild = "([0-9]+)\\.([0-9]+)\\.([0-9]+)";

		[StringSyntax("regex")]
		private const string Normal = "([0-9]+)\\.([0-9]+)\\.([0-9]+)\\.?([abcfpx])([0-9]+)((?:.|[\\r\\n])+)?";

		[StringSyntax("regex")]
		private const string China = "([0-9]+)\\.([0-9]+)\\.([0-9]+)\\.?f1c([0-9]+)((?:.|[\\r\\n])+)?";

		private static readonly Regex majorRegex = new Regex("([0-9]+)", RegexOptions.None);

		private static readonly Regex majorMinorRegex = new Regex("([0-9]+)\\.([0-9]+)", RegexOptions.None);

		private static readonly Regex majorMinorBuildRegex = new Regex("([0-9]+)\\.([0-9]+)\\.([0-9]+)", RegexOptions.None);

		private static readonly Regex normalRegex = new Regex("([0-9]+)\\.([0-9]+)\\.([0-9]+)\\.?([abcfpx])([0-9]+)((?:.|[\\r\\n])+)?", RegexOptions.None);

		private static readonly Regex chinaRegex = new Regex("([0-9]+)\\.([0-9]+)\\.([0-9]+)\\.?f1c([0-9]+)((?:.|[\\r\\n])+)?", RegexOptions.None);

		public static Regex GetMajorRegex()
		{
			return majorRegex;
		}

		public static Regex GetMajorMinorRegex()
		{
			return majorMinorRegex;
		}

		public static Regex GetMajorMinorBuildRegex()
		{
			return majorMinorBuildRegex;
		}

		public static Regex GetNormalRegex()
		{
			return normalRegex;
		}

		public static Regex GetChinaRegex()
		{
			return chinaRegex;
		}
	}
	public enum UnityVersionType : byte
	{
		Alpha = 0,
		Beta = 1,
		China = 2,
		Final = 3,
		Patch = 4,
		Experimental = 5,
		MinValue = 0,
		MaxValue = 5
	}
	public static class UnityVersionTypeExtentions
	{
		public static char ToCharacter(this UnityVersionType type)
		{
			return type switch
			{
				UnityVersionType.Alpha => 'a', 
				UnityVersionType.Beta => 'b', 
				UnityVersionType.China => 'c', 
				UnityVersionType.Final => 'f', 
				UnityVersionType.Patch => 'p', 
				UnityVersionType.Experimental => 'x', 
				_ => 'u', 
			};
		}
	}
}
namespace AssetRipper.Primitives.Extensions
{
	public static class CharacterExtensions
	{
		public static UnityVersionType ToUnityVersionType(this char c)
		{
			return c switch
			{
				'a' => UnityVersionType.Alpha, 
				'b' => UnityVersionType.Beta, 
				'c' => UnityVersionType.China, 
				'f' => UnityVersionType.Final, 
				'p' => UnityVersionType.Patch, 
				'x' => UnityVersionType.Experimental, 
				_ => throw new ArgumentException($"There is no version type {c}", "c"), 
			};
		}
	}
	internal static class RegexExtensions
	{
		public static bool TryMatch(this Regex regex, string input, [NotNullWhen(true)] out Match? match)
		{
			match = regex.Match(input);
			if (match.Success)
			{
				return true;
			}
			match = null;
			return false;
		}
	}
}