using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = ".NET Framework 4.6")]
[assembly: AssemblyCompany("LateCompany")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LateCompany")]
[assembly: AssemblyTitle("LateCompany")]
[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 LateCompany
{
	public static class PluginInfo
	{
		public const string GUID = "twig.latecompany";

		public const string PrintName = "Late Company";

		public const string Version = "1.0.4";
	}
	[BepInPlugin("twig.latecompany", "Late Company", "1.0.4")]
	internal class Plugin : BaseUnityPlugin
	{
		private ConfigEntry<bool> configLateJoinOrbitOnly;

		public static bool OnlyLateJoinInOrbit;

		public void Awake()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			configLateJoinOrbitOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Late join orbit only", true, "Don't allow joining while the ship is not in orbit.");
			OnlyLateJoinInOrbit = configLateJoinOrbitOnly.Value;
			Harmony val = new Harmony("twig.latecompany");
			val.PatchAll(typeof(Plugin).Assembly);
			((BaseUnityPlugin)this).Logger.Log((LogLevel)16, (object)"Late Company loaded!");
		}
	}
}
namespace LateCompany.Patches
{
	[HarmonyPatch(typeof(GameNetworkManager), "LeaveLobbyAtGameStart")]
	[HarmonyWrapSafe]
	internal static class LeaveLobbyAtGameStart_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "ConnectionApproval")]
	[HarmonyWrapSafe]
	internal static class ConnectionApproval_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(ConnectionApprovalRequest request, ConnectionApprovalResponse response)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (request.ClientNetworkId != NetworkManager.Singleton.LocalClientId && response.Reason.Contains("Game has already started") && GameNetworkManager.Instance.gameHasStarted && (StartOfRound.Instance.inShipPhase || !Plugin.OnlyLateJoinInOrbit))
			{
				response.Reason = "";
				response.CreatePlayerObject = false;
				response.Approved = true;
				response.Pending = false;
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
	[HarmonyWrapSafe]
	internal class OnPlayerConnectedClientRpc_Patch
	{
		public static MethodInfo BeginSendClientRpc = typeof(RoundManager).GetMethod("__beginSendClientRpc", BindingFlags.Instance | BindingFlags.NonPublic);

		public static MethodInfo EndSendClientRpc = typeof(RoundManager).GetMethod("__endSendClientRpc", BindingFlags.Instance | BindingFlags.NonPublic);

		[HarmonyPostfix]
		private static void Postfix(ulong clientId, int connectedPlayers, ulong[] connectedPlayerIdsOrdered, int assignedPlayerObjectId, int serverMoneyAmount, int levelID, int profitQuota, int timeUntilDeadline, int quotaFulfilled, int randomSeed)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			PlayerControllerB val = instance.allPlayerScripts[assignedPlayerObjectId];
			if (instance.connectedPlayersAmount + 1 >= instance.allPlayerScripts.Length)
			{
				GameNetworkManager.Instance.SetLobbyJoinable(false);
			}
			val.DisablePlayerModel(instance.allPlayerObjects[assignedPlayerObjectId], true, true);
			if (((NetworkBehaviour)instance).IsServer && !instance.inShipPhase)
			{
				RoundManager instance2 = RoundManager.Instance;
				ClientRpcParams val2 = default(ClientRpcParams);
				val2.Send = new ClientRpcSendParams
				{
					TargetClientIds = new List<ulong> { clientId }
				};
				ClientRpcParams val3 = val2;
				FastBufferWriter val4 = (FastBufferWriter)BeginSendClientRpc.Invoke(instance2, new object[3] { 1193916134u, val3, 0 });
				BytePacker.WriteValueBitPacked(val4, StartOfRound.Instance.randomMapSeed);
				BytePacker.WriteValueBitPacked(val4, StartOfRound.Instance.currentLevelID);
				EndSendClientRpc.Invoke(instance2, new object[4] { val4, 1193916134u, val3, 0 });
				FastBufferWriter val5 = (FastBufferWriter)BeginSendClientRpc.Invoke(instance2, new object[3] { 2729232387u, val3, 0 });
				EndSendClientRpc.Invoke(instance2, new object[4] { val5, 2729232387u, val3, 0 });
			}
			instance.livingPlayers = instance.connectedPlayersAmount + 1;
			for (int i = 0; i < instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val6 = instance.allPlayerScripts[i];
				if (val6.isPlayerControlled && val6.isPlayerDead)
				{
					instance.livingPlayers--;
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "OnPlayerDC")]
	[HarmonyWrapSafe]
	internal class OnPlayerDC_Patch
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			if (StartOfRound.Instance.inShipPhase || !Plugin.OnlyLateJoinInOrbit)
			{
				GameNetworkManager.Instance.SetLobbyJoinable(true);
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "StartGame")]
	[HarmonyWrapSafe]
	internal class StartGame_Patch
	{
		[HarmonyPrefix]
		public static void Prefix()
		{
			if (Plugin.OnlyLateJoinInOrbit)
			{
				GameNetworkManager.Instance.SetLobbyJoinable(false);
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")]
	[HarmonyWrapSafe]
	internal class SetShipReadyToLand_Patch
	{
		[HarmonyPrefix]
		public static void Postfix()
		{
			if (Plugin.OnlyLateJoinInOrbit && StartOfRound.Instance.connectedPlayersAmount + 1 < StartOfRound.Instance.allPlayerScripts.Length)
			{
				GameNetworkManager.Instance.SetLobbyJoinable(true);
			}
		}
	}
}

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using AssetRipper.VersionUtilities.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 ds5678")]
[assembly: AssemblyDescription("Managed library for handling Unity versions")]
[assembly: AssemblyFileVersion("1.2.1.0")]
[assembly: AssemblyInformationalVersion("1.2.1.0")]
[assembly: AssemblyProduct("AssetRipper.VersionUtilities")]
[assembly: AssemblyTitle("AssetRipper.VersionUtilities")]
[assembly: AssemblyVersion("1.2.1.0")]
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;
		}
	}
}
namespace AssetRipper.VersionUtilities
{
	public struct CompactUnityVersion24 : IEquatable<CompactUnityVersion24>, IComparable, IComparable<CompactUnityVersion24>
	{
		private const int majorOffset = 3;

		private const int buildOffset = 9;

		private const int typeOffset = 6;

		private const uint bitMask3 = 7u;

		private const uint bitMask5 = 31u;

		private const uint bitMask6 = 63u;

		private const uint bitMask7 = 127u;

		private readonly byte m_MajorMinorByte;

		private readonly ushort m_BuildTypeShort;

		public const ushort MajorMaxValue = 2042;

		private byte MajorRaw => (byte)((ulong)(m_MajorMinorByte >> 3) & 0x1FuL);

		public ushort Major => ConvertMajorRawToNormal(MajorRaw);

		public byte Minor => (byte)(m_MajorMinorByte & 7u);

		public byte Build => (byte)((ulong)(m_BuildTypeShort >> 9) & 0x7FuL);

		public UnityVersionType Type => (UnityVersionType)((ulong)(m_BuildTypeShort >> 6) & 7uL);

		public byte TypeNumber => (byte)(m_BuildTypeShort & 0x3Fu);

		public static CompactUnityVersion24 MinVersion { get; } = new CompactUnityVersion24((byte)0, (ushort)0);


		public static CompactUnityVersion24 MaxVersion { get; } = new CompactUnityVersion24(byte.MaxValue, ushort.MaxValue);


		public CompactUnityVersion24(ushort major)
		{
			m_MajorMinorByte = (byte)(ConvertMajorRawToNormal(major) << 3);
			m_BuildTypeShort = 0;
		}

		public CompactUnityVersion24(ushort major, byte minor)
		{
			m_MajorMinorByte = (byte)((ConvertMajorRawToNormal(major) << 3) | CastToThreeBits(minor));
			m_BuildTypeShort = 0;
		}

		public CompactUnityVersion24(ushort major, byte minor, byte build)
		{
			m_MajorMinorByte = (byte)((ConvertMajorRawToNormal(major) << 3) | CastToThreeBits(minor));
			m_BuildTypeShort = (ushort)(CastToSevenBits(build) << 9);
		}

		public CompactUnityVersion24(ushort major, byte minor, byte build, UnityVersionType type)
		{
			m_MajorMinorByte = (byte)((ConvertMajorRawToNormal(major) << 3) | CastToThreeBits(minor));
			m_BuildTypeShort = (ushort)((CastToSevenBits(build) << 9) | (CastToThreeBits((byte)type) << 6));
		}

		public CompactUnityVersion24(ushort major, byte minor, byte build, UnityVersionType type, byte typeNumber)
		{
			m_MajorMinorByte = (byte)((ConvertMajorRawToNormal(major) << 3) | CastToThreeBits(minor));
			m_BuildTypeShort = (ushort)((CastToSevenBits(build) << 9) | (CastToThreeBits((byte)type) << 6) | CastToSixBits(typeNumber));
		}

		private CompactUnityVersion24(byte majorMinorByte, ushort buildTypeShort)
		{
			m_MajorMinorByte = majorMinorByte;
			m_BuildTypeShort = buildTypeShort;
		}

		public void GetBits(out byte majorMinorByte, out ushort buildTypeShort)
		{
			majorMinorByte = m_MajorMinorByte;
			buildTypeShort = m_BuildTypeShort;
		}

		public static CompactUnityVersion24 FromBits(byte majorMinorByte, ushort buildTypeShort)
		{
			return new CompactUnityVersion24(majorMinorByte, buildTypeShort);
		}

		private static ushort ConvertMajorRawToNormal(byte raw)
		{
			if (raw >= 6)
			{
				return (ushort)(raw + 2011);
			}
			return raw;
		}

		private static byte ConvertMajorRawToNormal(ushort major)
		{
			if (major < 6)
			{
				return (byte)major;
			}
			if (major >= 2017 && major <= 2042)
			{
				return (byte)(major - 2011);
			}
			throw new ArgumentOutOfRangeException("major");
		}

		private static byte CastToThreeBits(byte b)
		{
			if ((uint)b > 7u)
			{
				throw new ArgumentOutOfRangeException("b");
			}
			return b;
		}

		private static byte CastToSixBits(byte b)
		{
			if ((uint)b > 63u)
			{
				throw new ArgumentOutOfRangeException("b");
			}
			return b;
		}

		private static byte CastToSevenBits(byte b)
		{
			if ((uint)b > 127u)
			{
				throw new ArgumentOutOfRangeException("b");
			}
			return b;
		}

		public override string ToString()
		{
			return $"{Major}.{Minor}.{Build}{Type.ToCharacter()}{TypeNumber}";
		}

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

		public int CompareTo(CompactUnityVersion24 other)
		{
			if (this > other)
			{
				return 1;
			}
			if (this < other)
			{
				return -1;
			}
			return 0;
		}

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

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

		public override int GetHashCode()
		{
			return (m_MajorMinorByte << 16) | m_BuildTypeShort;
		}

		public static implicit operator UnityVersion(CompactUnityVersion24 version)
		{
			return new UnityVersion(version.Major, version.Minor, version.Build, version.Type, version.TypeNumber);
		}

		public static implicit operator CompactUnityVersion32(CompactUnityVersion24 version)
		{
			return new CompactUnityVersion32(version.Major, version.Minor, version.Build, version.Type, version.TypeNumber);
		}

		public static explicit operator CompactUnityVersion24(UnityVersion version)
		{
			return new CompactUnityVersion24(version.Major, (byte)version.Minor, (byte)version.Build, version.Type, version.TypeNumber);
		}

		public static explicit operator CompactUnityVersion24(CompactUnityVersion32 version)
		{
			return new CompactUnityVersion24(version.Major, version.Minor, version.Build, version.Type, version.TypeNumber);
		}

		public static bool operator ==(CompactUnityVersion24 left, CompactUnityVersion24 right)
		{
			if (left.m_MajorMinorByte == right.m_MajorMinorByte)
			{
				return left.m_BuildTypeShort == right.m_BuildTypeShort;
			}
			return false;
		}

		public static bool operator !=(CompactUnityVersion24 left, CompactUnityVersion24 right)
		{
			if (left.m_MajorMinorByte == right.m_MajorMinorByte)
			{
				return left.m_BuildTypeShort != right.m_BuildTypeShort;
			}
			return true;
		}

		public static bool operator >(CompactUnityVersion24 left, CompactUnityVersion24 right)
		{
			if (left.m_MajorMinorByte <= right.m_MajorMinorByte)
			{
				if (left.m_MajorMinorByte == right.m_MajorMinorByte)
				{
					return left.m_BuildTypeShort > right.m_BuildTypeShort;
				}
				return false;
			}
			return true;
		}

		public static bool operator >=(CompactUnityVersion24 left, CompactUnityVersion24 right)
		{
			if (left.m_MajorMinorByte <= right.m_MajorMinorByte)
			{
				if (left.m_MajorMinorByte == right.m_MajorMinorByte)
				{
					return left.m_BuildTypeShort >= right.m_BuildTypeShort;
				}
				return false;
			}
			return true;
		}

		public static bool operator <(CompactUnityVersion24 left, CompactUnityVersion24 right)
		{
			if (left.m_MajorMinorByte >= right.m_MajorMinorByte)
			{
				if (left.m_MajorMinorByte == right.m_MajorMinorByte)
				{
					return left.m_BuildTypeShort < right.m_BuildTypeShort;
				}
				return false;
			}
			return true;
		}

		public static bool operator <=(CompactUnityVersion24 left, CompactUnityVersion24 right)
		{
			if (left.m_MajorMinorByte >= right.m_MajorMinorByte)
			{
				if (left.m_MajorMinorByte == right.m_MajorMinorByte)
				{
					return left.m_BuildTypeShort <= right.m_BuildTypeShort;
				}
				return false;
			}
			return true;
		}
	}
	public struct CompactUnityVersion32 : IEquatable<CompactUnityVersion32>, IComparable, IComparable<CompactUnityVersion32>
	{
		private const int majorOffset = 24;

		private const int minorOffset = 20;

		private const int buildOffset = 12;

		private const int typeOffset = 8;

		private const uint byteMask = 255u;

		private const uint bitMask4 = 15u;

		private readonly uint m_data;

		public const ushort MajorMaxValue = 2266;

		private byte MajorRaw => (byte)((m_data >> 24) & 0xFFu);

		public ushort Major => ConvertMajorRawToNormal(MajorRaw);

		public byte Minor => (byte)((m_data >> 20) & 0xFu);

		public byte Build => (byte)((m_data >> 12) & 0xFFu);

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

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

		public static CompactUnityVersion32 MinVersion { get; } = new CompactUnityVersion32(0u);


		public static CompactUnityVersion32 MaxVersion { get; } = new CompactUnityVersion32(uint.MaxValue);


		public CompactUnityVersion32(ushort major)
		{
			m_data = (uint)(ConvertMajorRawToNormal(major) << 24);
		}

		public CompactUnityVersion32(ushort major, byte minor)
		{
			m_data = (uint)((ConvertMajorRawToNormal(major) << 24) | (CastToFourBits(minor) << 20));
		}

		public CompactUnityVersion32(ushort major, byte minor, byte build)
		{
			m_data = (uint)((ConvertMajorRawToNormal(major) << 24) | (CastToFourBits(minor) << 20) | (build << 12));
		}

		public CompactUnityVersion32(ushort major, byte minor, byte build, UnityVersionType type)
		{
			m_data = (uint)((ConvertMajorRawToNormal(major) << 24) | (CastToFourBits(minor) << 20) | (build << 12)) | ((uint)CastToFourBits(type) << 8);
		}

		public CompactUnityVersion32(ushort major, byte minor, byte build, UnityVersionType type, byte typeNumber)
		{
			m_data = (uint)((ConvertMajorRawToNormal(major) << 24) | (CastToFourBits(minor) << 20) | (build << 12)) | ((uint)CastToFourBits(type) << 8) | typeNumber;
		}

		private CompactUnityVersion32(uint data)
		{
			m_data = data;
		}

		public uint GetBits()
		{
			return m_data;
		}

		public static CompactUnityVersion32 FromBits(uint bits)
		{
			return new CompactUnityVersion32(bits);
		}

		private static ushort ConvertMajorRawToNormal(byte raw)
		{
			if (raw >= 6)
			{
				return (ushort)(raw + 2011);
			}
			return raw;
		}

		private static byte ConvertMajorRawToNormal(ushort major)
		{
			if (major < 6)
			{
				return (byte)major;
			}
			if (major >= 2017 && major <= 2266)
			{
				return (byte)(major - 2011);
			}
			throw new ArgumentOutOfRangeException("major");
		}

		private static byte CastToFourBits(byte b)
		{
			if ((uint)b > 15u)
			{
				throw new ArgumentOutOfRangeException("b");
			}
			return b;
		}

		private static UnityVersionType CastToFourBits(UnityVersionType type)
		{
			if (type > (UnityVersionType)15)
			{
				throw new ArgumentOutOfRangeException("type");
			}
			return type;
		}

		public override string ToString()
		{
			return $"{Major}.{Minor}.{Build}{Type.ToCharacter()}{TypeNumber}";
		}

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

		public int CompareTo(CompactUnityVersion32 other)
		{
			if (this > other)
			{
				return 1;
			}
			if (this < other)
			{
				return -1;
			}
			return 0;
		}

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

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

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

		public static implicit operator UnityVersion(CompactUnityVersion32 version)
		{
			return new UnityVersion(version.Major, version.Minor, version.Build, version.Type, version.TypeNumber);
		}

		public static explicit operator CompactUnityVersion32(UnityVersion version)
		{
			return new CompactUnityVersion32(version.Major, (byte)version.Minor, (byte)version.Build, version.Type, version.TypeNumber);
		}

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

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

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

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

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

		public static bool operator <=(CompactUnityVersion32 left, CompactUnityVersion32 right)
		{
			return left.m_data <= right.m_data;
		}
	}
	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 IsEqual(ushort major)
		{
			return this == From(major);
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public bool IsGreaterEqual(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)
		{
			if (this > other)
			{
				return 1;
			}
			if (this < other)
			{
				return -1;
			}
			return 0;
		}

		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 827 + 911 * 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 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 $"{Major}.{Minor}.{Build}{Type.ToCharacter()}{TypeNumber}";
		}

		public string ToString(bool hasUnderscorePrefix, bool useUnderscores, bool hasExtension)
		{
			StringBuilder stringBuilder = new StringBuilder();
			char value = (useUnderscores ? '_' : '.');
			if (hasUnderscorePrefix)
			{
				stringBuilder.Append('_');
			}
			stringBuilder.Append(Major);
			stringBuilder.Append(value);
			stringBuilder.Append(Minor);
			stringBuilder.Append(value);
			stringBuilder.Append(Build);
			stringBuilder.Append(value);
			stringBuilder.Append(Type.ToCharacter());
			stringBuilder.Append(TypeNumber);
			if (hasExtension)
			{
				stringBuilder.Append(".dll");
			}
			return stringBuilder.ToString();
		}

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

		public static UnityVersion ParseFromDllName(string dllName)
		{
			if (string.IsNullOrEmpty(dllName))
			{
				throw new ArgumentNullException("dllName");
			}
			if (dllName[0] == '_')
			{
				dllName = dllName.Substring(1);
			}
			return Parse(dllName.Replace('_', '.').Replace(".dll", ""));
		}

		public static UnityVersion Parse(string version)
		{
			if (string.IsNullOrEmpty(version))
			{
				throw new ArgumentNullException("version");
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			UnityVersionType type = UnityVersionType.Final;
			int num4 = 0;
			using StringReader stringReader = new StringReader(version);
			while (true)
			{
				int num5 = stringReader.Read();
				if (num5 == -1)
				{
					throw new ArgumentException("Invalid version formatting: " + version, "version");
				}
				char c = (char)num5;
				if (c == '.')
				{
					break;
				}
				num = num * 10 + c.ParseDigit();
			}
			while (true)
			{
				int num6 = stringReader.Read();
				if (num6 == -1)
				{
					break;
				}
				char c2 = (char)num6;
				if (c2 == '.')
				{
					break;
				}
				num2 = num2 * 10 + c2.ParseDigit();
			}
			while (true)
			{
				int num7 = stringReader.Read();
				if (num7 == -1)
				{
					break;
				}
				char c3 = (char)num7;
				if (char.IsDigit(c3))
				{
					num3 = num3 * 10 + c3.ParseDigit();
					continue;
				}
				type = c3.ToUnityVersionType();
				break;
			}
			while (true)
			{
				int num8 = stringReader.Read();
				if (num8 == -1)
				{
					break;
				}
				char @this = (char)num8;
				num4 = num4 * 10 + @this.ParseDigit();
			}
			return new UnityVersion((ushort)num, (ushort)num2, (ushort)num3, type, (byte)num4);
		}
	}
	public enum UnityVersionType : byte
	{
		Alpha = 0,
		Beta = 1,
		China = 2,
		Final = 3,
		Patch = 4,
		Experimental = 5,
		MinValue = 0,
		MaxValue = 5
	}
	public static class UnityVersionTypeExtentions
	{
		[Obsolete("Changed to ToCharacter", true)]
		public static char ToLiteral(this UnityVersionType _this)
		{
			return _this.ToCharacter();
		}

		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.VersionUtilities.Extensions
{
	public static class BinaryReaderExtensions
	{
		public static UnityVersion ReadUnityVersion(this BinaryReader reader)
		{
			return UnityVersion.FromBits(reader.ReadUInt64());
		}

		public static CompactUnityVersion32 ReadCompactUnityVersion32(this BinaryReader reader)
		{
			return CompactUnityVersion32.FromBits(reader.ReadUInt32());
		}

		public static CompactUnityVersion24 ReadCompactUnityVersion24(this BinaryReader reader)
		{
			byte majorMinorByte = reader.ReadByte();
			ushort buildTypeShort = reader.ReadUInt16();
			return CompactUnityVersion24.FromBits(majorMinorByte, buildTypeShort);
		}
	}
	public static class BinaryWriterExtensions
	{
		public static void Write(this BinaryWriter writer, UnityVersion version)
		{
			writer.Write(version.GetBits());
		}

		public static void Write(this BinaryWriter writer, CompactUnityVersion32 version)
		{
			writer.Write(version.GetBits());
		}

		public static void Write(this BinaryWriter writer, CompactUnityVersion24 version)
		{
			version.GetBits(out var majorMinorByte, out var buildTypeShort);
			writer.Write(majorMinorByte);
			writer.Write(buildTypeShort);
		}
	}
	public static class CharacterExtensions
	{
		internal static int ParseDigit(this char _this)
		{
			return _this - 48;
		}

		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"), 
			};
		}
	}
}