using System;
using System.Buffers;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using FxResources.System.Collections.Immutable;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("System.Collections.Immutable.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("System.Collections.Immutable")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("This package provides collections that are thread safe and guaranteed to never change their contents, also known as immutable collections. Like strings, any methods that perform modifications will not change the existing instance but instead return a new instance. For efficiency reasons, the implementation uses a sharing mechanism to ensure that newly created instances share as much data as possible with the previous instance while ensuring that operations have a predictable time complexity.\r\n\r\nThe System.Collections.Immutable library is built-in as part of the shared framework in .NET Runtime. The package can be installed when you need to use it in other target frameworks.")]
[assembly: AssemblyFileVersion("9.0.925.41916")]
[assembly: AssemblyInformationalVersion("9.0.9+893c2ebbd49952ca49e93298148af2d95a61a0a4")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("System.Collections.Immutable")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/runtime")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("9.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: System.Runtime.CompilerServices.NullablePublicOnly(true)]
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]
	internal sealed class ParamCollectionAttribute : 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 NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

		public NullablePublicOnlyAttribute(bool P_0)
		{
			IncludesInternals = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	internal sealed class ScopedRefAttribute : Attribute
	{
	}
	[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 FxResources.System.Collections.Immutable
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class SR
	{
		private static readonly bool s_usingResourceKeys = GetUsingResourceKeysSwitchValue();

		private static ResourceManager s_resourceManager;

		internal static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(typeof(SR)));

		internal static string Arg_KeyNotFoundWithKey => GetResourceString("Arg_KeyNotFoundWithKey");

		internal static string ArrayInitializedStateNotEqual => GetResourceString("ArrayInitializedStateNotEqual");

		internal static string ArrayLengthsNotEqual => GetResourceString("ArrayLengthsNotEqual");

		internal static string CannotFindOldValue => GetResourceString("CannotFindOldValue");

		internal static string CapacityMustBeGreaterThanOrEqualToCount => GetResourceString("CapacityMustBeGreaterThanOrEqualToCount");

		internal static string CapacityMustEqualCountOnMove => GetResourceString("CapacityMustEqualCountOnMove");

		internal static string CollectionModifiedDuringEnumeration => GetResourceString("CollectionModifiedDuringEnumeration");

		internal static string DuplicateKey => GetResourceString("DuplicateKey");

		internal static string InvalidEmptyOperation => GetResourceString("InvalidEmptyOperation");

		internal static string InvalidOperationOnDefaultArray => GetResourceString("InvalidOperationOnDefaultArray");

		internal static string Arg_HTCapacityOverflow => GetResourceString("Arg_HTCapacityOverflow");

		internal static string Arg_RankMultiDimNotSupported => GetResourceString("Arg_RankMultiDimNotSupported");

		internal static string Arg_NonZeroLowerBound => GetResourceString("Arg_NonZeroLowerBound");

		internal static string Arg_ArrayPlusOffTooSmall => GetResourceString("Arg_ArrayPlusOffTooSmall");

		internal static string Argument_IncompatibleArrayType => GetResourceString("Argument_IncompatibleArrayType");

		internal static string ArgumentOutOfRange_NeedNonNegNum => GetResourceString("ArgumentOutOfRange_NeedNonNegNum");

		internal static string InvalidOperation_IncompatibleComparer => GetResourceString("InvalidOperation_IncompatibleComparer");

		private static bool GetUsingResourceKeysSwitchValue()
		{
			if (!AppContext.TryGetSwitch("System.Resources.UseSystemResourceKeys", out var isEnabled))
			{
				return false;
			}
			return isEnabled;
		}

		internal static bool UsingResourceKeys()
		{
			return s_usingResourceKeys;
		}

		private static string GetResourceString(string resourceKey)
		{
			if (UsingResourceKeys())
			{
				return resourceKey;
			}
			string result = null;
			try
			{
				result = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			return result;
		}

		private static string GetResourceString(string resourceKey, string defaultString)
		{
			string resourceString = GetResourceString(resourceKey);
			if (!(resourceKey == resourceString) && resourceString != null)
			{
				return resourceString;
			}
			return defaultString;
		}

		internal static string Format(string resourceFormat, object? p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object? p1, object? p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object? p1, object? p2, object? p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}

		internal static string Format(string resourceFormat, params object?[]? args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(provider, resourceFormat, p1);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1, object? p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(provider, resourceFormat, p1, p2);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1, object? p2, object? p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(provider, resourceFormat, p1, p2, p3);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, params object?[]? args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(provider, resourceFormat, args);
			}
			return resourceFormat;
		}
	}
}
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.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

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

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[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.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.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;
		}
	}
}
namespace System.Linq
{
	public static class ImmutableArrayExtensions
	{
		public static IEnumerable<TResult> Select<T, TResult>(this ImmutableArray<T> immutableArray, Func<T, TResult> selector)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.Select(selector);
		}

		public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this ImmutableArray<TSource> immutableArray, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			if (collectionSelector == null || resultSelector == null)
			{
				return Enumerable.SelectMany(immutableArray, collectionSelector, resultSelector);
			}
			if (immutableArray.Length != 0)
			{
				return immutableArray.SelectManyIterator(collectionSelector, resultSelector);
			}
			return Enumerable.Empty<TResult>();
		}

		public static IEnumerable<T> Where<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.Where(predicate);
		}

		public static bool Any<T>(this ImmutableArray<T> immutableArray)
		{
			return immutableArray.Length > 0;
		}

		public static bool Any<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.NotNull(predicate, "predicate");
			T[] array = immutableArray.array;
			foreach (T arg in array)
			{
				if (predicate(arg))
				{
					return true;
				}
			}
			return false;
		}

		public static bool All<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.NotNull(predicate, "predicate");
			T[] array = immutableArray.array;
			foreach (T arg in array)
			{
				if (!predicate(arg))
				{
					return false;
				}
			}
			return true;
		}

		public static bool SequenceEqual<TDerived, TBase>(this ImmutableArray<TBase> immutableArray, ImmutableArray<TDerived> items, IEqualityComparer<TBase>? comparer = null) where TDerived : TBase
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			items.ThrowNullRefIfNotInitialized();
			if (immutableArray.array == items.array)
			{
				return true;
			}
			if (immutableArray.Length != items.Length)
			{
				return false;
			}
			if (comparer == null)
			{
				comparer = EqualityComparer<TBase>.Default;
			}
			for (int i = 0; i < immutableArray.Length; i++)
			{
				if (!comparer.Equals(immutableArray.array[i], (TBase)(object)items.array[i]))
				{
					return false;
				}
			}
			return true;
		}

		public static bool SequenceEqual<TDerived, TBase>(this ImmutableArray<TBase> immutableArray, IEnumerable<TDerived> items, IEqualityComparer<TBase>? comparer = null) where TDerived : TBase
		{
			Requires.NotNull(items, "items");
			if (comparer == null)
			{
				comparer = EqualityComparer<TBase>.Default;
			}
			int num = 0;
			int length = immutableArray.Length;
			foreach (TDerived item in items)
			{
				if (num == length)
				{
					return false;
				}
				if (!comparer.Equals(immutableArray[num], (TBase)(object)item))
				{
					return false;
				}
				num++;
			}
			return num == length;
		}

		public static bool SequenceEqual<TDerived, TBase>(this ImmutableArray<TBase> immutableArray, ImmutableArray<TDerived> items, Func<TBase, TBase, bool> predicate) where TDerived : TBase
		{
			Requires.NotNull(predicate, "predicate");
			immutableArray.ThrowNullRefIfNotInitialized();
			items.ThrowNullRefIfNotInitialized();
			if (immutableArray.array == items.array)
			{
				return true;
			}
			if (immutableArray.Length != items.Length)
			{
				return false;
			}
			int i = 0;
			for (int length = immutableArray.Length; i < length; i++)
			{
				if (!predicate(immutableArray[i], (TBase)(object)items[i]))
				{
					return false;
				}
			}
			return true;
		}

		public static T? Aggregate<T>(this ImmutableArray<T> immutableArray, Func<T, T, T> func)
		{
			Requires.NotNull(func, "func");
			if (immutableArray.Length == 0)
			{
				return default(T);
			}
			T val = immutableArray[0];
			int i = 1;
			for (int length = immutableArray.Length; i < length; i++)
			{
				val = func(val, immutableArray[i]);
			}
			return val;
		}

		public static TAccumulate Aggregate<TAccumulate, T>(this ImmutableArray<T> immutableArray, TAccumulate seed, Func<TAccumulate, T, TAccumulate> func)
		{
			Requires.NotNull(func, "func");
			TAccumulate val = seed;
			T[] array = immutableArray.array;
			foreach (T arg in array)
			{
				val = func(val, arg);
			}
			return val;
		}

		public static TResult Aggregate<TAccumulate, TResult, T>(this ImmutableArray<T> immutableArray, TAccumulate seed, Func<TAccumulate, T, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
		{
			Requires.NotNull(resultSelector, "resultSelector");
			return resultSelector(immutableArray.Aggregate(seed, func));
		}

		public static T ElementAt<T>(this ImmutableArray<T> immutableArray, int index)
		{
			return immutableArray[index];
		}

		public static T? ElementAtOrDefault<T>(this ImmutableArray<T> immutableArray, int index)
		{
			if (index < 0 || index >= immutableArray.Length)
			{
				return default(T);
			}
			return immutableArray[index];
		}

		public static T First<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			T[] array = immutableArray.array;
			foreach (T val in array)
			{
				if (predicate(val))
				{
					return val;
				}
			}
			return Enumerable.Empty<T>().First();
		}

		public static T First<T>(this ImmutableArray<T> immutableArray)
		{
			if (immutableArray.Length <= 0)
			{
				return immutableArray.array.First();
			}
			return immutableArray[0];
		}

		public static T? FirstOrDefault<T>(this ImmutableArray<T> immutableArray)
		{
			if (immutableArray.array.Length == 0)
			{
				return default(T);
			}
			return immutableArray.array[0];
		}

		public static T? FirstOrDefault<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			T[] array = immutableArray.array;
			foreach (T val in array)
			{
				if (predicate(val))
				{
					return val;
				}
			}
			return default(T);
		}

		public static T Last<T>(this ImmutableArray<T> immutableArray)
		{
			if (immutableArray.Length <= 0)
			{
				return immutableArray.array.Last();
			}
			return immutableArray[immutableArray.Length - 1];
		}

		public static T Last<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			for (int num = immutableArray.Length - 1; num >= 0; num--)
			{
				if (predicate(immutableArray[num]))
				{
					return immutableArray[num];
				}
			}
			return Enumerable.Empty<T>().Last();
		}

		public static T? LastOrDefault<T>(this ImmutableArray<T> immutableArray)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.LastOrDefault();
		}

		public static T? LastOrDefault<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			for (int num = immutableArray.Length - 1; num >= 0; num--)
			{
				if (predicate(immutableArray[num]))
				{
					return immutableArray[num];
				}
			}
			return default(T);
		}

		public static T Single<T>(this ImmutableArray<T> immutableArray)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.Single();
		}

		public static T Single<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			bool flag = true;
			T result = default(T);
			T[] array = immutableArray.array;
			foreach (T val in array)
			{
				if (predicate(val))
				{
					if (!flag)
					{
						ImmutableArray.TwoElementArray.Single();
					}
					flag = false;
					result = val;
				}
			}
			if (flag)
			{
				Enumerable.Empty<T>().Single();
			}
			return result;
		}

		public static T? SingleOrDefault<T>(this ImmutableArray<T> immutableArray)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.SingleOrDefault();
		}

		public static T? SingleOrDefault<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			bool flag = true;
			T result = default(T);
			T[] array = immutableArray.array;
			foreach (T val in array)
			{
				if (predicate(val))
				{
					if (!flag)
					{
						ImmutableArray.TwoElementArray.Single();
					}
					flag = false;
					result = val;
				}
			}
			return result;
		}

		public static Dictionary<TKey, T> ToDictionary<TKey, T>(this ImmutableArray<T> immutableArray, Func<T, TKey> keySelector) where TKey : notnull
		{
			return immutableArray.ToDictionary(keySelector, EqualityComparer<TKey>.Default);
		}

		public static Dictionary<TKey, TElement> ToDictionary<TKey, TElement, T>(this ImmutableArray<T> immutableArray, Func<T, TKey> keySelector, Func<T, TElement> elementSelector) where TKey : notnull
		{
			return immutableArray.ToDictionary(keySelector, elementSelector, EqualityComparer<TKey>.Default);
		}

		public static Dictionary<TKey, T> ToDictionary<TKey, T>(this ImmutableArray<T> immutableArray, Func<T, TKey> keySelector, IEqualityComparer<TKey>? comparer) where TKey : notnull
		{
			Requires.NotNull(keySelector, "keySelector");
			Dictionary<TKey, T> dictionary = new Dictionary<TKey, T>(immutableArray.Length, comparer);
			ImmutableArray<T>.Enumerator enumerator = immutableArray.GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				dictionary.Add(keySelector(current), current);
			}
			return dictionary;
		}

		public static Dictionary<TKey, TElement> ToDictionary<TKey, TElement, T>(this ImmutableArray<T> immutableArray, Func<T, TKey> keySelector, Func<T, TElement> elementSelector, IEqualityComparer<TKey>? comparer) where TKey : notnull
		{
			Requires.NotNull(keySelector, "keySelector");
			Requires.NotNull(elementSelector, "elementSelector");
			Dictionary<TKey, TElement> dictionary = new Dictionary<TKey, TElement>(immutableArray.Length, comparer);
			T[] array = immutableArray.array;
			foreach (T arg in array)
			{
				dictionary.Add(keySelector(arg), elementSelector(arg));
			}
			return dictionary;
		}

		public static T[] ToArray<T>(this ImmutableArray<T> immutableArray)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			if (immutableArray.array.Length == 0)
			{
				return ImmutableArray<T>.Empty.array;
			}
			return (T[])immutableArray.array.Clone();
		}

		public static T First<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			if (!builder.Any())
			{
				throw new InvalidOperationException();
			}
			return builder[0];
		}

		public static T? FirstOrDefault<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			if (!builder.Any())
			{
				return default(T);
			}
			return builder[0];
		}

		public static T Last<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			if (!builder.Any())
			{
				throw new InvalidOperationException();
			}
			return builder[builder.Count - 1];
		}

		public static T? LastOrDefault<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			if (!builder.Any())
			{
				return default(T);
			}
			return builder[builder.Count - 1];
		}

		public static bool Any<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.Count > 0;
		}

		private static IEnumerable<TResult> SelectManyIterator<TSource, TCollection, TResult>(this ImmutableArray<TSource> immutableArray, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
		{
			TSource[] array = immutableArray.array;
			foreach (TSource item in array)
			{
				foreach (TCollection item2 in collectionSelector(item))
				{
					yield return resultSelector(item, item2);
				}
			}
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class NonVersionableAttribute : Attribute
	{
	}
}
namespace System.Runtime.InteropServices
{
	public static class ImmutableCollectionsMarshal
	{
		public static ImmutableArray<T> AsImmutableArray<T>(T[]? array)
		{
			return new ImmutableArray<T>(array);
		}

		public static T[]? AsArray<T>(ImmutableArray<T> array)
		{
			return array.array;
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class LibraryImportAttribute : Attribute
	{
		public string LibraryName { get; }

		public string? EntryPoint { get; set; }

		public StringMarshalling StringMarshalling { get; set; }

		public Type? StringMarshallingCustomType { get; set; }

		public bool SetLastError { get; set; }

		public LibraryImportAttribute(string libraryName)
		{
			LibraryName = libraryName;
		}
	}
	internal enum StringMarshalling
	{
		Custom,
		Utf8,
		Utf16
	}
}
namespace System.Runtime.CompilerServices
{
	[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;
		}
	}
}
namespace System.Numerics
{
	internal static class BitOperations
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint RotateLeft(uint value, int offset)
		{
			return (value << offset) | (value >> 32 - offset);
		}
	}
}
namespace System.Collections
{
	internal static class ThrowHelper
	{
		public static void ThrowIfNull(object arg, [CallerArgumentExpression("arg")] string? paramName = null)
		{
			if (arg == null)
			{
				ThrowArgumentNullException(paramName);
			}
		}

		[DoesNotReturn]
		public static void ThrowIfDestinationTooSmall()
		{
			throw new ArgumentException(System.SR.CapacityMustBeGreaterThanOrEqualToCount, "destination");
		}

		[DoesNotReturn]
		public static void ThrowArgumentNullException(string? paramName)
		{
			throw new ArgumentNullException(paramName);
		}

		[DoesNotReturn]
		public static void ThrowKeyNotFoundException()
		{
			throw new KeyNotFoundException();
		}

		[DoesNotReturn]
		public static void ThrowKeyNotFoundException<TKey>(TKey key)
		{
			throw new KeyNotFoundException(System.SR.Format(System.SR.Arg_KeyNotFoundWithKey, key));
		}

		[DoesNotReturn]
		public static void ThrowInvalidOperationException()
		{
			throw new InvalidOperationException();
		}

		[DoesNotReturn]
		internal static void ThrowIncompatibleComparer()
		{
			throw new InvalidOperationException(System.SR.InvalidOperation_IncompatibleComparer);
		}
	}
	internal static class HashHelpers
	{
		public const uint HashCollisionThreshold = 100u;

		public const int MaxPrimeArrayLength = 2147483587;

		public const int HashPrime = 101;

		internal static ReadOnlySpan<int> Primes
		{
			get
			{
				object obj = global::<PrivateImplementationDetails>.74BCD6ED20AF2231F2BB1CDE814C5F4FF48E54BAC46029EEF90DDF4A208E2B20_A6;
				if (obj == null)
				{
					obj = new int[72]
					{
						3, 7, 11, 17, 23, 29, 37, 47, 59, 71,
						89, 107, 131, 163, 197, 239, 293, 353, 431, 521,
						631, 761, 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371,
						4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591, 17519, 21023,
						25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363,
						156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403,
						968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559,
						5999471, 7199369
					};
					global::<PrivateImplementationDetails>.74BCD6ED20AF2231F2BB1CDE814C5F4FF48E54BAC46029EEF90DDF4A208E2B20_A6 = (int[])obj;
				}
				return new ReadOnlySpan<int>((int[]?)obj);
			}
		}

		public static bool IsPrime(int candidate)
		{
			if (((uint)candidate & (true ? 1u : 0u)) != 0)
			{
				int num = (int)Math.Sqrt(candidate);
				for (int i = 3; i <= num; i += 2)
				{
					if (candidate % i == 0)
					{
						return false;
					}
				}
				return true;
			}
			return candidate == 2;
		}

		public static int GetPrime(int min)
		{
			if (min < 0)
			{
				throw new ArgumentException(System.SR.Arg_HTCapacityOverflow);
			}
			ReadOnlySpan<int> primes = Primes;
			for (int i = 0; i < primes.Length; i++)
			{
				int num = primes[i];
				if (num >= min)
				{
					return num;
				}
			}
			for (int j = min | 1; j < int.MaxValue; j += 2)
			{
				if (IsPrime(j) && (j - 1) % 101 != 0)
				{
					return j;
				}
			}
			return min;
		}

		public static int ExpandPrime(int oldSize)
		{
			int num = 2 * oldSize;
			if ((uint)num > 2147483587u && 2147483587 > oldSize)
			{
				return 2147483587;
			}
			return GetPrime(num);
		}

		public static ulong GetFastModMultiplier(uint divisor)
		{
			return ulong.MaxValue / (ulong)divisor + 1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint FastMod(uint value, uint divisor, ulong multiplier)
		{
			return (uint)(((multiplier * value >> 32) + 1) * divisor >> 32);
		}
	}
}
namespace System.Collections.Immutable
{
	internal static class AllocFreeConcurrentStack<T>
	{
		private const int MaxSize = 35;

		private static readonly Type s_typeOfT = typeof(T);

		private static Stack<RefAsValueType<T>> ThreadLocalStack
		{
			get
			{
				Dictionary<Type, object> dictionary = AllocFreeConcurrentStack.t_stacks ?? (AllocFreeConcurrentStack.t_stacks = new Dictionary<Type, object>());
				if (!dictionary.TryGetValue(s_typeOfT, out var value))
				{
					value = new Stack<RefAsValueType<T>>(35);
					dictionary.Add(s_typeOfT, value);
				}
				return (Stack<RefAsValueType<T>>)value;
			}
		}

		public static void TryAdd(T item)
		{
			Stack<RefAsValueType<T>> threadLocalStack = ThreadLocalStack;
			if (threadLocalStack.Count < 35)
			{
				threadLocalStack.Push(new RefAsValueType<T>(item));
			}
		}

		public static bool TryTake([MaybeNullWhen(false)] out T item)
		{
			Stack<RefAsValueType<T>> threadLocalStack = ThreadLocalStack;
			if (threadLocalStack != null && threadLocalStack.Count > 0)
			{
				item = threadLocalStack.Pop().Value;
				return true;
			}
			item = default(T);
			return false;
		}
	}
	internal static class AllocFreeConcurrentStack
	{
		[ThreadStatic]
		internal static Dictionary<Type, object>? t_stacks;
	}
	internal sealed class DictionaryEnumerator<TKey, TValue> : IDictionaryEnumerator, IEnumerator where TKey : notnull
	{
		private readonly IEnumerator<KeyValuePair<TKey, TValue>> _inner;

		public DictionaryEntry Entry => new DictionaryEntry(_inner.Current.Key, _inner.Current.Value);

		public object Key => _inner.Current.Key;

		public object? Value => _inner.Current.Value;

		public object Current => Entry;

		internal DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> inner)
		{
			Requires.NotNull(inner, "inner");
			_inner = inner;
		}

		public bool MoveNext()
		{
			return _inner.MoveNext();
		}

		public void Reset()
		{
			_inner.Reset();
		}
	}
	internal struct DisposableEnumeratorAdapter<T, TEnumerator> : IDisposable where TEnumerator : struct, IEnumerator<T>
	{
		private readonly IEnumerator<T> _enumeratorObject;

		private TEnumerator _enumeratorStruct;

		public T Current
		{
			get
			{
				if (_enumeratorObject == null)
				{
					return _enumeratorStruct.Current;
				}
				return _enumeratorObject.Current;
			}
		}

		internal DisposableEnumeratorAdapter(TEnumerator enumerator)
		{
			_enumeratorStruct = enumerator;
			_enumeratorObject = null;
		}

		internal DisposableEnumeratorAdapter(IEnumerator<T> enumerator)
		{
			_enumeratorStruct = default(TEnumerator);
			_enumeratorObject = enumerator;
		}

		public bool MoveNext()
		{
			if (_enumeratorObject == null)
			{
				return _enumeratorStruct.MoveNext();
			}
			return _enumeratorObject.MoveNext();
		}

		public void Dispose()
		{
			if (_enumeratorObject != null)
			{
				_enumeratorObject.Dispose();
			}
			else
			{
				_enumeratorStruct.Dispose();
			}
		}

		public DisposableEnumeratorAdapter<T, TEnumerator> GetEnumerator()
		{
			return this;
		}
	}
	internal interface IBinaryTree
	{
		int Height { get; }

		bool IsEmpty { get; }

		int Count { get; }

		IBinaryTree? Left { get; }

		IBinaryTree? Right { get; }
	}
	internal interface IBinaryTree<out T> : IBinaryTree
	{
		T Value { get; }

		new IBinaryTree<T>? Left { get; }

		new IBinaryTree<T>? Right { get; }
	}
	internal interface IImmutableArray
	{
		Array? Array { get; }
	}
	public interface IImmutableDictionary<TKey, TValue> : IReadOnlyDictionary<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TValue>>
	{
		IImmutableDictionary<TKey, TValue> Clear();

		IImmutableDictionary<TKey, TValue> Add(TKey key, TValue value);

		IImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);

		IImmutableDictionary<TKey, TValue> SetItem(TKey key, TValue value);

		IImmutableDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);

		IImmutableDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys);

		IImmutableDictionary<TKey, TValue> Remove(TKey key);

		bool Contains(KeyValuePair<TKey, TValue> pair);

		bool TryGetKey(TKey equalKey, out TKey actualKey);
	}
	internal interface IImmutableDictionaryInternal<TKey, TValue>
	{
		bool ContainsValue(TValue value);
	}
	[CollectionBuilder(typeof(ImmutableList), "Create")]
	public interface IImmutableList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
	{
		IImmutableList<T> Clear();

		int IndexOf(T item, int index, int count, IEqualityComparer<T>? equalityComparer);

		int LastIndexOf(T item, int index, int count, IEqualityComparer<T>? equalityComparer);

		IImmutableList<T> Add(T value);

		IImmutableList<T> AddRange(IEnumerable<T> items);

		IImmutableList<T> Insert(int index, T element);

		IImmutableList<T> InsertRange(int index, IEnumerable<T> items);

		IImmutableList<T> Remove(T value, IEqualityComparer<T>? equalityComparer);

		IImmutableList<T> RemoveAll(Predicate<T> match);

		IImmutableList<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer);

		IImmutableList<T> RemoveRange(int index, int count);

		IImmutableList<T> RemoveAt(int index);

		IImmutableList<T> SetItem(int index, T value);

		IImmutableList<T> Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer);
	}
	internal interface IImmutableListQueries<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
	{
		ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter);

		void ForEach(Action<T> action);

		ImmutableList<T> GetRange(int index, int count);

		void CopyTo(T[] array);

		void CopyTo(T[] array, int arrayIndex);

		void CopyTo(int index, T[] array, int arrayIndex, int count);

		bool Exists(Predicate<T> match);

		T? Find(Predicate<T> match);

		ImmutableList<T> FindAll(Predicate<T> match);

		int FindIndex(Predicate<T> match);

		int FindIndex(int startIndex, Predicate<T> match);

		int FindIndex(int startIndex, int count, Predicate<T> match);

		T? FindLast(Predicate<T> match);

		int FindLastIndex(Predicate<T> match);

		int FindLastIndex(int startIndex, Predicate<T> match);

		int FindLastIndex(int startIndex, int count, Predicate<T> match);

		bool TrueForAll(Predicate<T> match);

		int BinarySearch(T item);

		int BinarySearch(T item, IComparer<T>? comparer);

		int BinarySearch(int index, int count, T item, IComparer<T>? comparer);
	}
	[CollectionBuilder(typeof(ImmutableQueue), "Create")]
	public interface IImmutableQueue<T> : IEnumerable<T>, IEnumerable
	{
		bool IsEmpty { get; }

		IImmutableQueue<T> Clear();

		T Peek();

		IImmutableQueue<T> Enqueue(T value);

		IImmutableQueue<T> Dequeue();
	}
	[CollectionBuilder(typeof(ImmutableHashSet), "Create")]
	public interface IImmutableSet<T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable
	{
		IImmutableSet<T> Clear();

		bool Contains(T value);

		IImmutableSet<T> Add(T value);

		IImmutableSet<T> Remove(T value);

		bool TryGetValue(T equalValue, out T actualValue);

		IImmutableSet<T> Intersect(IEnumerable<T> other);

		IImmutableSet<T> Except(IEnumerable<T> other);

		IImmutableSet<T> SymmetricExcept(IEnumerable<T> other);

		IImmutableSet<T> Union(IEnumerable<T> other);

		bool SetEquals(IEnumerable<T> other);

		bool IsProperSubsetOf(IEnumerable<T> other);

		bool IsProperSupersetOf(IEnumerable<T> other);

		bool IsSubsetOf(IEnumerable<T> other);

		bool IsSupersetOf(IEnumerable<T> other);

		bool Overlaps(IEnumerable<T> other);
	}
	[CollectionBuilder(typeof(ImmutableStack), "Create")]
	public interface IImmutableStack<T> : IEnumerable<T>, IEnumerable
	{
		bool IsEmpty { get; }

		IImmutableStack<T> Clear();

		IImmutableStack<T> Push(T value);

		IImmutableStack<T> Pop();

		T Peek();
	}
	[CollectionBuilder(typeof(ImmutableHashSet), "Create")]
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	public sealed class ImmutableHashSet<T> : IImmutableSet<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IHashKeyCollection<T>, ICollection<T>, ISet<T>, ICollection, IStrongEnumerable<T, ImmutableHashSet<T>.Enumerator>
	{
		private sealed class HashBucketByValueEqualityComparer : IEqualityComparer<HashBucket>
		{
			private static readonly IEqualityComparer<HashBucket> s_defaultInstance = new HashBucketByValueEqualityComparer(EqualityComparer<T>.Default);

			private readonly IEqualityComparer<T> _valueComparer;

			internal static IEqualityComparer<HashBucket> DefaultInstance => s_defaultInstance;

			internal HashBucketByValueEqualityComparer(IEqualityComparer<T> valueComparer)
			{
				Requires.NotNull(valueComparer, "valueComparer");
				_valueComparer = valueComparer;
			}

			public bool Equals(HashBucket x, HashBucket y)
			{
				return x.EqualsByValue(y, _valueComparer);
			}

			public int GetHashCode(HashBucket obj)
			{
				throw new NotSupportedException();
			}
		}

		private sealed class HashBucketByRefEqualityComparer : IEqualityComparer<HashBucket>
		{
			private static readonly IEqualityComparer<HashBucket> s_defaultInstance = new HashBucketByRefEqualityComparer();

			internal static IEqualityComparer<HashBucket> DefaultInstance => s_defaultInstance;

			private HashBucketByRefEqualityComparer()
			{
			}

			public bool Equals(HashBucket x, HashBucket y)
			{
				return x.EqualsByRef(y);
			}

			public int GetHashCode(HashBucket obj)
			{
				throw new NotSupportedException();
			}
		}

		[DebuggerDisplay("Count = {Count}")]
		public sealed class Builder : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, ISet<T>, ICollection<T>
		{
			private SortedInt32KeyNode<HashBucket> _root = SortedInt32KeyNode<HashBucket>.EmptyNode;

			private IEqualityComparer<T> _equalityComparer;

			private readonly IEqualityComparer<HashBucket> _hashBucketEqualityComparer;

			private int _count;

			private ImmutableHashSet<T> _immutable;

			private int _version;

			public int Count => _count;

			bool ICollection<T>.IsReadOnly => false;

			public IEqualityComparer<T> KeyComparer
			{
				get
				{
					return _equalityComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value != _equalityComparer)
					{
						MutationResult mutationResult = ImmutableHashSet<T>.Union((IEnumerable<T>)this, new MutationInput(SortedInt32KeyNode<HashBucket>.EmptyNode, value, _hashBucketEqualityComparer, 0));
						_immutable = null;
						_equalityComparer = value;
						Root = mutationResult.Root;
						_count = mutationResult.Count;
					}
				}
			}

			internal int Version => _version;

			private MutationInput Origin => new MutationInput(Root, _equalityComparer, _hashBucketEqualityComparer, _count);

			private SortedInt32KeyNode<HashBucket> Root
			{
				get
				{
					return _root;
				}
				set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			internal Builder(ImmutableHashSet<T> set)
			{
				Requires.NotNull(set, "set");
				_root = set._root;
				_count = set._count;
				_equalityComparer = set._equalityComparer;
				_hashBucketEqualityComparer = set._hashBucketEqualityComparer;
				_immutable = set;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(_root, this);
			}

			public ImmutableHashSet<T> ToImmutable()
			{
				return _immutable ?? (_immutable = ImmutableHashSet<T>.Wrap(_root, _equalityComparer, _count));
			}

			public bool TryGetValue(T equalValue, out T actualValue)
			{
				int key = ((equalValue != null) ? _equalityComparer.GetHashCode(equalValue) : 0);
				if (_root.TryGetValue(key, out var value))
				{
					return value.TryExchange(equalValue, _equalityComparer, out actualValue);
				}
				actualValue = equalValue;
				return false;
			}

			public bool Add(T item)
			{
				MutationResult result = ImmutableHashSet<T>.Add(item, Origin);
				Apply(result);
				return result.Count != 0;
			}

			public bool Remove(T item)
			{
				MutationResult result = ImmutableHashSet<T>.Remove(item, Origin);
				Apply(result);
				return result.Count != 0;
			}

			public bool Contains(T item)
			{
				return ImmutableHashSet<T>.Contains(item, Origin);
			}

			public void Clear()
			{
				_count = 0;
				Root = SortedInt32KeyNode<HashBucket>.EmptyNode;
			}

			public void ExceptWith(IEnumerable<T> other)
			{
				MutationResult result = ImmutableHashSet<T>.Except(other, _equalityComparer, _hashBucketEqualityComparer, _root);
				Apply(result);
			}

			public void IntersectWith(IEnumerable<T> other)
			{
				MutationResult result = ImmutableHashSet<T>.Intersect(other, Origin);
				Apply(result);
			}

			public bool IsProperSubsetOf(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.IsProperSubsetOf(other, Origin);
			}

			public bool IsProperSupersetOf(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.IsProperSupersetOf(other, Origin);
			}

			public bool IsSubsetOf(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.IsSubsetOf(other, Origin);
			}

			public bool IsSupersetOf(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.IsSupersetOf(other, Origin);
			}

			public bool Overlaps(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.Overlaps(other, Origin);
			}

			public bool SetEquals(IEnumerable<T> other)
			{
				if (this == other)
				{
					return true;
				}
				return ImmutableHashSet<T>.SetEquals(other, Origin);
			}

			public void SymmetricExceptWith(IEnumerable<T> other)
			{
				MutationResult result = ImmutableHashSet<T>.SymmetricExcept(other, Origin);
				Apply(result);
			}

			public void UnionWith(IEnumerable<T> other)
			{
				MutationResult result = ImmutableHashSet<T>.Union(other, Origin);
				Apply(result);
			}

			void ICollection<T>.Add(T item)
			{
				Add(item);
			}

			void ICollection<T>.CopyTo(T[] array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			private void Apply(MutationResult result)
			{
				Root = result.Root;
				if (result.CountType == CountType.Adjustment)
				{
					_count += result.Count;
				}
				else
				{
					_count = result.Count;
				}
			}
		}

		public struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable, IStrongEnumerator<T>
		{
			private readonly Builder _builder;

			private SortedInt32KeyNode<HashBucket>.Enumerator _mapEnumerator;

			private HashBucket.Enumerator _bucketEnumerator;

			private int _enumeratingBuilderVersion;

			public T Current
			{
				get
				{
					_mapEnumerator.ThrowIfDisposed();
					return _bucketEnumerator.Current;
				}
			}

			object? IEnumerator.Current => Current;

			internal Enumerator(SortedInt32KeyNode<HashBucket> root, Builder? builder = null)
			{
				_builder = builder;
				_mapEnumerator = new SortedInt32KeyNode<HashBucket>.Enumerator(root);
				_bucketEnumerator = default(HashBucket.Enumerator);
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
			}

			public bool MoveNext()
			{
				ThrowIfChanged();
				if (_bucketEnumerator.MoveNext())
				{
					return true;
				}
				if (_mapEnumerator.MoveNext())
				{
					_bucketEnumerator = new HashBucket.Enumerator(_mapEnumerator.Current.Value);
					return _bucketEnumerator.MoveNext();
				}
				return false;
			}

			public void Reset()
			{
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_mapEnumerator.Reset();
				_bucketEnumerator.Dispose();
				_bucketEnumerator = default(HashBucket.Enumerator);
			}

			public void Dispose()
			{
				_mapEnumerator.Dispose();
				_bucketEnumerator.Dispose();
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}
		}

		internal enum OperationResult
		{
			SizeChanged,
			NoChangeRequired
		}

		internal readonly struct HashBucket
		{
			internal struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable
			{
				private enum Position
				{
					BeforeFirst,
					First,
					Additional,
					End
				}

				private readonly HashBucket _bucket;

				private bool _disposed;

				private Position _currentPosition;

				private ImmutableList<T>.Enumerator _additionalEnumerator;

				object? IEnumerator.Current => Current;

				public T Current
				{
					get
					{
						ThrowIfDisposed();
						return _currentPosition switch
						{
							Position.First => _bucket._firstValue, 
							Position.Additional => _additionalEnumerator.Current, 
							_ => throw new InvalidOperationException(), 
						};
					}
				}

				internal Enumerator(HashBucket bucket)
				{
					_disposed = false;
					_bucket = bucket;
					_currentPosition = Position.BeforeFirst;
					_additionalEnumerator = default(ImmutableList<T>.Enumerator);
				}

				public bool MoveNext()
				{
					ThrowIfDisposed();
					if (_bucket.IsEmpty)
					{
						_currentPosition = Position.End;
						return false;
					}
					switch (_currentPosition)
					{
					case Position.BeforeFirst:
						_currentPosition = Position.First;
						return true;
					case Position.First:
						if (_bucket._additionalElements.IsEmpty)
						{
							_currentPosition = Position.End;
							return false;
						}
						_currentPosition = Position.Additional;
						_additionalEnumerator = new ImmutableList<T>.Enumerator(_bucket._additionalElements);
						return _additionalEnumerator.MoveNext();
					case Position.Additional:
						return _additionalEnumerator.MoveNext();
					case Position.End:
						return false;
					default:
						throw new InvalidOperationException();
					}
				}

				public void Reset()
				{
					ThrowIfDisposed();
					_additionalEnumerator.Dispose();
					_currentPosition = Position.BeforeFirst;
				}

				public void Dispose()
				{
					_disposed = true;
					_additionalEnumerator.Dispose();
				}

				private void ThrowIfDisposed()
				{
					if (_disposed)
					{
						Requires.FailObjectDisposed(this);
					}
				}
			}

			private readonly T _firstValue;

			private readonly ImmutableList<T>.Node _additionalElements;

			internal bool IsEmpty => _additionalElements == null;

			private HashBucket(T firstElement, ImmutableList<T>.Node additionalElements = null)
			{
				_firstValue = firstElement;
				_additionalElements = additionalElements ?? ImmutableList<T>.Node.EmptyNode;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			public override bool Equals(object? obj)
			{
				throw new NotSupportedException();
			}

			public override int GetHashCode()
			{
				throw new NotSupportedException();
			}

			internal bool EqualsByRef(HashBucket other)
			{
				if ((object)_firstValue == (object)other._firstValue)
				{
					return _additionalElements == other._additionalElements;
				}
				return false;
			}

			internal bool EqualsByValue(HashBucket other, IEqualityComparer<T> valueComparer)
			{
				if (valueComparer.Equals(_firstValue, other._firstValue))
				{
					return _additionalElements == other._additionalElements;
				}
				return false;
			}

			internal HashBucket Add(T value, IEqualityComparer<T> valueComparer, out OperationResult result)
			{
				if (IsEmpty)
				{
					result = OperationResult.SizeChanged;
					return new HashBucket(value);
				}
				if (valueComparer.Equals(value, _firstValue) || _additionalElements.IndexOf(value, valueComparer) >= 0)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				result = OperationResult.SizeChanged;
				return new HashBucket(_firstValue, _additionalElements.Add(value));
			}

			internal bool Contains(T value, IEqualityComparer<T> valueComparer)
			{
				if (IsEmpty)
				{
					return false;
				}
				if (!valueComparer.Equals(value, _firstValue))
				{
					return _additionalElements.IndexOf(value, valueComparer) >= 0;
				}
				return true;
			}

			internal bool TryExchange(T value, IEqualityComparer<T> valueComparer, out T existingValue)
			{
				if (!IsEmpty)
				{
					if (valueComparer.Equals(value, _firstValue))
					{
						existingValue = _firstValue;
						return true;
					}
					int num = _additionalElements.IndexOf(value, valueComparer);
					if (num >= 0)
					{
						existingValue = _additionalElements.ItemRef(num);
						return true;
					}
				}
				existingValue = value;
				return false;
			}

			internal HashBucket Remove(T value, IEqualityComparer<T> equalityComparer, out OperationResult result)
			{
				if (IsEmpty)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				if (equalityComparer.Equals(_firstValue, value))
				{
					if (_additionalElements.IsEmpty)
					{
						result = OperationResult.SizeChanged;
						return default(HashBucket);
					}
					int count = _additionalElements.Left.Count;
					result = OperationResult.SizeChanged;
					return new HashBucket(_additionalElements.Key, _additionalElements.RemoveAt(count));
				}
				int num = _additionalElements.IndexOf(value, equalityComparer);
				if (num < 0)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				result = OperationResult.SizeChanged;
				return new HashBucket(_firstValue, _additionalElements.RemoveAt(num));
			}

			internal void Freeze()
			{
				_additionalElements?.Freeze();
			}
		}

		private readonly struct MutationInput
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			private readonly IEqualityComparer<T> _equalityComparer;

			private readonly int _count;

			private readonly IEqualityComparer<HashBucket> _hashBucketEqualityComparer;

			internal SortedInt32KeyNode<HashBucket> Root => _root;

			internal IEqualityComparer<T> EqualityComparer => _equalityComparer;

			internal int Count => _count;

			internal IEqualityComparer<HashBucket> HashBucketEqualityComparer => _hashBucketEqualityComparer;

			internal MutationInput(ImmutableHashSet<T> set)
			{
				Requires.NotNull(set, "set");
				_root = set._root;
				_equalityComparer = set._equalityComparer;
				_count = set._count;
				_hashBucketEqualityComparer = set._hashBucketEqualityComparer;
			}

			internal MutationInput(SortedInt32KeyNode<HashBucket> root, IEqualityComparer<T> equalityComparer, IEqualityComparer<HashBucket> hashBucketEqualityComparer, int count)
			{
				Requires.NotNull(root, "root");
				Requires.NotNull(equalityComparer, "equalityComparer");
				Requires.Range(count >= 0, "count");
				Requires.NotNull(hashBucketEqualityComparer, "hashBucketEqualityComparer");
				_root = root;
				_equalityComparer = equalityComparer;
				_count = count;
				_hashBucketEqualityComparer = hashBucketEqualityComparer;
			}
		}

		private enum CountType
		{
			Adjustment,
			FinalValue
		}

		private readonly struct MutationResult
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			private readonly int _count;

			private readonly CountType _countType;

			internal SortedInt32KeyNode<HashBucket> Root => _root;

			internal int Count => _count;

			internal CountType CountType => _countType;

			internal MutationResult(SortedInt32KeyNode<HashBucket> root, int count, CountType countType = CountType.Adjustment)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_count = count;
				_countType = countType;
			}

			internal ImmutableHashSet<T> Finalize(ImmutableHashSet<T> priorSet)
			{
				Requires.NotNull(priorSet, "priorSet");
				int num = Count;
				if (CountType == CountType.Adjustment)
				{
					num += priorSet._count;
				}
				return priorSet.Wrap(Root, num);
			}
		}

		private readonly struct NodeEnumerable : IEnumerable<T>, IEnumerable
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			internal NodeEnumerable(SortedInt32KeyNode<HashBucket> root)
			{
				Requires.NotNull(root, "root");
				_root = root;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(_root);
			}

			[ExcludeFromCodeCoverage]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			[ExcludeFromCodeCoverage]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		public static readonly ImmutableHashSet<T> Empty = new ImmutableHashSet<T>(SortedInt32KeyNode<HashBucket>.EmptyNode, EqualityComparer<T>.Default, 0);

		private static readonly Action<KeyValuePair<int, HashBucket>> s_FreezeBucketAction = delegate(KeyValuePair<int, HashBucket> kv)
		{
			kv.Value.Freeze();
		};

		private readonly IEqualityComparer<T> _equalityComparer;

		private readonly int _count;

		private readonly SortedInt32KeyNode<HashBucket> _root;

		private readonly IEqualityComparer<HashBucket> _hashBucketEqualityComparer;

		public int Count => _count;

		public bool IsEmpty => Count == 0;

		public IEqualityComparer<T> KeyComparer => _equalityComparer;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		internal IBinaryTree Root => _root;

		private MutationInput Origin => new MutationInput(this);

		bool ICollection<T>.IsReadOnly => true;

		internal ImmutableHashSet(IEqualityComparer<T> equalityComparer)
			: this(SortedInt32KeyNode<HashBucket>.EmptyNode, equalityComparer, 0)
		{
		}

		private ImmutableHashSet(SortedInt32KeyNode<HashBucket> root, IEqualityComparer<T> equalityComparer, int count)
		{
			Requires.NotNull(root, "root");
			Requires.NotNull(equalityComparer, "equalityComparer");
			root.Freeze(s_FreezeBucketAction);
			_root = root;
			_count = count;
			_equalityComparer = equalityComparer;
			_hashBucketEqualityComparer = GetHashBucketEqualityComparer(equalityComparer);
		}

		public ImmutableHashSet<T> Clear()
		{
			if (!IsEmpty)
			{
				return Empty.WithComparer(_equalityComparer);
			}
			return this;
		}

		IImmutableSet<T> IImmutableSet<T>.Clear()
		{
			return Clear();
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableHashSet<T> Add(T item)
		{
			return Add(item, Origin).Finalize(this);
		}

		public ImmutableHashSet<T> Remove(T item)
		{
			return Remove(item, Origin).Finalize(this);
		}

		public bool TryGetValue(T equalValue, out T actualValue)
		{
			int key = ((equalValue != null) ? _equalityComparer.GetHashCode(equalValue) : 0);
			if (_root.TryGetValue(key, out var value))
			{
				return value.TryExchange(equalValue, _equalityComparer, out actualValue);
			}
			actualValue = equalValue;
			return false;
		}

		public ImmutableHashSet<T> Union(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return Union(other, avoidWithComparer: false);
		}

		internal ImmutableHashSet<T> Union(ReadOnlySpan<T> other)
		{
			return Union(other, Origin).Finalize(this);
		}

		public ImmutableHashSet<T> Intersect(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return Intersect(other, Origin).Finalize(this);
		}

		public ImmutableHashSet<T> Except(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return Except(other, _equalityComparer, _hashBucketEqualityComparer, _root).Finalize(this);
		}

		public ImmutableHashSet<T> SymmetricExcept(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return SymmetricExcept(other, Origin).Finalize(this);
		}

		public bool SetEquals(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (this == other)
			{
				return true;
			}
			return SetEquals(other, Origin);
		}

		public bool IsProperSubsetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return IsProperSubsetOf(other, Origin);
		}

		public bool IsProperSupersetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return IsProperSupersetOf(other, Origin);
		}

		public bool IsSubsetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return IsSubsetOf(other, Origin);
		}

		public bool IsSupersetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return IsSupersetOf(other, Origin);
		}

		public bool Overlaps(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return Overlaps(other, Origin);
		}

		IImmutableSet<T> IImmutableSet<T>.Add(T item)
		{
			return Add(item);
		}

		IImmutableSet<T> IImmutableSet<T>.Remove(T item)
		{
			return Remove(item);
		}

		IImmutableSet<T> IImmutableSet<T>.Union(IEnumerable<T> other)
		{
			return Union(other);
		}

		IImmutableSet<T> IImmutableSet<T>.Intersect(IEnumerable<T> other)
		{
			return Intersect(other);
		}

		IImmutableSet<T> IImmutableSet<T>.Except(IEnumerable<T> other)
		{
			return Except(other);
		}

		IImmutableSet<T> IImmutableSet<T>.SymmetricExcept(IEnumerable<T> other)
		{
			return SymmetricExcept(other);
		}

		public bool Contains(T item)
		{
			return Contains(item, Origin);
		}

		public ImmutableHashSet<T> WithComparer(IEqualityComparer<T>? equalityComparer)
		{
			if (equalityComparer == null)
			{
				equalityComparer = EqualityComparer<T>.Default;
			}
			if (equalityComparer == _equalityComparer)
			{
				return this;
			}
			return new ImmutableHashSet<T>(equalityComparer).Union(this, avoidWithComparer: true);
		}

		bool ISet<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.ExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.IntersectWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.SymmetricExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.UnionWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.CopyTo(T[] array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				array[arrayIndex++] = current;
			}
		}

		void ICollection<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<T>.Remove(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				array.SetValue(current, arrayIndex++);
			}
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(_root);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private static bool IsSupersetOf(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (!Contains(item, origin))
				{
					return false;
				}
			}
			return true;
		}

		private static MutationResult Add(T item, MutationInput origin)
		{
			int num = ((item != null) ? origin.EqualityComparer.GetHashCode(item) : 0);
			OperationResult result;
			HashBucket newBucket = origin.Root.GetValueOrDefault(num).Add(item, origin.EqualityComparer, out result);
			if (result == OperationResult.NoChangeRequired)
			{
				return new MutationResult(origin.Root, 0);
			}
			return new MutationResult(UpdateRoot(origin.Root, num, origin.HashBucketEqualityComparer, newBucket), 1);
		}

		private static MutationResult Remove(T item, MutationInput origin)
		{
			OperationResult result = OperationResult.NoChangeRequired;
			int num = ((item != null) ? origin.EqualityComparer.GetHashCode(item) : 0);
			SortedInt32KeyNode<HashBucket> root = origin.Root;
			if (origin.Root.TryGetValue(num, out var value))
			{
				HashBucket newBucket = value.Remove(item, origin.EqualityComparer, out result);
				if (result == OperationResult.NoChangeRequired)
				{
					return new MutationResult(origin.Root, 0);
				}
				root = UpdateRoot(origin.Root, num, origin.HashBucketEqualityComparer, newBucket);
			}
			return new MutationResult(root, (result == OperationResult.SizeChanged) ? (-1) : 0);
		}

		private static bool Contains(T item, MutationInput origin)
		{
			int key = ((item != null) ? origin.EqualityComparer.GetHashCode(item) : 0);
			if (origin.Root.TryGetValue(key, out var value))
			{
				return value.Contains(item, origin.EqualityComparer);
			}
			return false;
		}

		private static MutationResult Union(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			int num = 0;
			SortedInt32KeyNode<HashBucket> sortedInt32KeyNode = origin.Root;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				int num2 = ((item != null) ? origin.EqualityComparer.GetHashCode(item) : 0);
				OperationResult result;
				HashBucket newBucket = sortedInt32KeyNode.GetValueOrDefault(num2).Add(item, origin.EqualityComparer, out result);
				if (result == OperationResult.SizeChanged)
				{
					sortedInt32KeyNode = UpdateRoot(sortedInt32KeyNode, num2, origin.HashBucketEqualityComparer, newBucket);
					num++;
				}
			}
			return new MutationResult(sortedInt32KeyNode, num);
		}

		private static MutationResult Union(ReadOnlySpan<T> other, MutationInput origin)
		{
			int num = 0;
			SortedInt32KeyNode<HashBucket> sortedInt32KeyNode = origin.Root;
			ReadOnlySpan<T> readOnlySpan = other;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				T val = readOnlySpan[i];
				int num2 = ((val != null) ? origin.EqualityComparer.GetHashCode(val) : 0);
				OperationResult result;
				HashBucket newBucket = sortedInt32KeyNode.GetValueOrDefault(num2).Add(val, origin.EqualityComparer, out result);
				if (result == OperationResult.SizeChanged)
				{
					sortedInt32KeyNode = UpdateRoot(sortedInt32KeyNode, num2, origin.HashBucketEqualityComparer, newBucket);
					num++;
				}
			}
			return new MutationResult(sortedInt32KeyNode, num);
		}

		private static bool Overlaps(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			if (origin.Root.IsEmpty)
			{
				return false;
			}
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (Contains(item, origin))
				{
					return true;
				}
			}
			return false;
		}

		private static bool SetEquals(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			HashSet<T> hashSet = new HashSet<T>(other, origin.EqualityComparer);
			if (origin.Count != hashSet.Count)
			{
				return false;
			}
			foreach (T item in hashSet)
			{
				if (!Contains(item, origin))
				{
					return false;
				}
			}
			return true;
		}

		private static SortedInt32KeyNode<HashBucket> UpdateRoot(SortedInt32KeyNode<HashBucket> root, int hashCode, IEqualityComparer<HashBucket> hashBucketEqualityComparer, HashBucket newBucket)
		{
			bool mutated;
			if (newBucket.IsEmpty)
			{
				return root.Remove(hashCode, out mutated);
			}
			bool mutated2;
			return root.SetItem(hashCode, newBucket, hashBucketEqualityComparer, out mutated, out mutated2);
		}

		private static MutationResult Intersect(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			SortedInt32KeyNode<HashBucket> root = SortedInt32KeyNode<HashBucket>.EmptyNode;
			int num = 0;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (Contains(item, origin))
				{
					MutationResult mutationResult = Add(item, new MutationInput(root, origin.EqualityComparer, origin.HashBucketEqualityComparer, num));
					root = mutationResult.Root;
					num += mutationResult.Count;
				}
			}
			return new MutationResult(root, num, CountType.FinalValue);
		}

		private static MutationResult Except(IEnumerable<T> other, IEqualityComparer<T> equalityComparer, IEqualityComparer<HashBucket> hashBucketEqualityComparer, SortedInt32KeyNode<HashBucket> root)
		{
			Requires.NotNull(other, "other");
			Requires.NotNull(equalityComparer, "equalityComparer");
			Requires.NotNull(root, "root");
			int num = 0;
			SortedInt32KeyNode<HashBucket> sortedInt32KeyNode = root;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				int num2 = ((item != null) ? equalityComparer.GetHashCode(item) : 0);
				if (sortedInt32KeyNode.TryGetValue(num2, out var value))
				{
					OperationResult result;
					HashBucket newBucket = value.Remove(item, equalityComparer, out result);
					if (result == OperationResult.SizeChanged)
					{
						num--;
						sortedInt32KeyNode = UpdateRoot(sortedInt32KeyNode, num2, hashBucketEqualityComparer, newBucket);
					}
				}
			}
			return new MutationResult(sortedInt32KeyNode, num);
		}

		private static MutationResult SymmetricExcept(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			ImmutableHashSet<T> immutableHashSet = ImmutableHashSet.CreateRange(origin.EqualityComparer, other);
			int num = 0;
			SortedInt32KeyNode<HashBucket> root = SortedInt32KeyNode<HashBucket>.EmptyNode;
			foreach (T item in new NodeEnumerable(origin.Root))
			{
				if (!immutableHashSet.Contains(item))
				{
					MutationResult mutationResult = Add(item, new MutationInput(root, origin.EqualityComparer, origin.HashBucketEqualityComparer, num));
					root = mutationResult.Root;
					num += mutationResult.Count;
				}
			}
			foreach (T item2 in immutableHashSet)
			{
				if (!Contains(item2, origin))
				{
					MutationResult mutationResult2 = Add(item2, new MutationInput(root, origin.EqualityComparer, origin.HashBucketEqualityComparer, num));
					root = mutationResult2.Root;
					num += mutationResult2.Count;
				}
			}
			return new MutationResult(root, num, CountType.FinalValue);
		}

		private static bool IsProperSubsetOf(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			if (origin.Root.IsEmpty)
			{
				return other.Any();
			}
			HashSet<T> hashSet = new HashSet<T>(other, origin.EqualityComparer);
			if (origin.Count >= hashSet.Count)
			{
				return false;
			}
			int num = 0;
			bool flag = false;
			foreach (T item in hashSet)
			{
				if (Contains(item, origin))
				{
					num++;
				}
				else
				{
					flag = true;
				}
				if (num == origin.Count && flag)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsProperSupersetOf(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			if (origin.Root.IsEmpty)
			{
				return false;
			}
			int num = 0;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				num++;
				if (!Contains(item, origin))
				{
					return false;
				}
			}
			return origin.Count > num;
		}

		private static bool IsSubsetOf(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			if (origin.Root.IsEmpty)
			{
				return true;
			}
			HashSet<T> hashSet = new HashSet<T>(other, origin.EqualityComparer);
			int num = 0;
			foreach (T item in hashSet)
			{
				if (Contains(item, origin))
				{
					num++;
				}
			}
			return num == origin.Count;
		}

		private static ImmutableHashSet<T> Wrap(SortedInt32KeyNode<HashBucket> root, IEqualityComparer<T> equalityComparer, int count)
		{
			Requires.NotNull(root, "root");
			Requires.NotNull(equalityComparer, "equalityComparer");
			Requires.Range(count >= 0, "count");
			return new ImmutableHashSet<T>(root, equalityComparer, count);
		}

		private static IEqualityComparer<HashBucket> GetHashBucketEqualityComparer(IEqualityComparer<T> valueComparer)
		{
			if (!ImmutableExtensions.IsValueType<T>())
			{
				return HashBucketByRefEqualityComparer.DefaultInstance;
			}
			if (valueComparer == EqualityComparer<T>.Default)
			{
				return HashBucketByValueEqualityComparer.DefaultInstance;
			}
			return new HashBucketByValueEqualityComparer(valueComparer);
		}

		private ImmutableHashSet<T> Wrap(SortedInt32KeyNode<HashBucket> root, int adjustedCountIfDifferentRoot)
		{
			if (root == _root)
			{
				return this;
			}
			return new ImmutableHashSet<T>(root, _equalityComparer, adjustedCountIfDifferentRoot);
		}

		private ImmutableHashSet<T> Union(IEnumerable<T> items, bool avoidWithComparer)
		{
			Requires.NotNull(items, "items");
			if (IsEmpty && !avoidWithComparer && items is ImmutableHashSet<T> immutableHashSet)
			{
				return immutableHashSet.WithComparer(KeyComparer);
			}
			return Union(items, Origin).Finalize(this);
		}
	}
	internal interface IStrongEnumerable<out T, TEnumerator> where TEnumerator : struct, IStrongEnumerator<T>
	{
		TEnumerator GetEnumerator();
	}
	internal interface IStrongEnumerator<T>
	{
		T Current { get; }

		bool MoveNext();
	}
	internal interface IOrderedCollection<out T> : IEnumerable<T>, IEnumerable
	{
		int Count { get; }

		T this[int index] { get; }
	}
	public static class ImmutableArray
	{
		internal static readonly byte[] TwoElementArray = new byte[2];

		public static ImmutableArray<T> Create<T>()
		{
			return ImmutableArray<T>.Empty;
		}

		public static ImmutableArray<T> Create<T>(T item)
		{
			return new ImmutableArray<T>(new T[1] { item });
		}

		public static ImmutableArray<T> Create<T>(T item1, T item2)
		{
			return new ImmutableArray<T>(new T[2] { item1, item2 });
		}

		public static ImmutableArray<T> Create<T>(T item1, T item2, T item3)
		{
			return new ImmutableArray<T>(new T[3] { item1, item2, item3 });
		}

		public static ImmutableArray<T> Create<T>(T item1, T item2, T item3, T item4)
		{
			return new ImmutableArray<T>(new T[4] { item1, item2, item3, item4 });
		}

		public static ImmutableArray<T> Create<T>([ParamCollection] scoped ReadOnlySpan<T> items)
		{
			if (items.IsEmpty)
			{
				return ImmutableArray<T>.Empty;
			}
			return new ImmutableArray<T>(items.ToArray());
		}

		public static ImmutableArray<T> Create<T>(Span<T> items)
		{
			return Create((ReadOnlySpan<T>)items);
		}

		public static ImmutableArray<T> ToImmutableArray<T>(this ReadOnlySpan<T> items)
		{
			return Create(items);
		}

		public static ImmutableArray<T> ToImmutableArray<T>(this Span<T> items)
		{
			return Create((ReadOnlySpan<T>)items);
		}

		public static ImmutableArray<T> CreateRange<T>(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			if (items is IImmutableArray immutableArray)
			{
				return new ImmutableArray<T>((T[])(immutableArray.Array ?? throw new InvalidOperationException(System.SR.InvalidOperationOnDefaultArray)));
			}
			if (items.TryGetCount(out var count))
			{
				return new ImmutableArray<T>(items.ToArray(count));
			}
			return new ImmutableArray<T>(items.ToArray());
		}

		public static ImmutableArray<T> Create<T>(params T[]? items)
		{
			if (items == null || items.Length == 0)
			{
				return ImmutableArray<T>.Empty;
			}
			T[] array = new T[items.Length];
			Array.Copy(items, array, items.Length);
			return new ImmutableArray<T>(array);
		}

		public static ImmutableArray<T> Create<T>(T[] items, int start, int length)
		{
			Requires.NotNull(items, "items");
			Requires.Range(start >= 0 && start <= items.Length, "start");
			Requires.Range(length >= 0 && start + length <= items.Length, "length");
			if (length == 0)
			{
				return Create<T>();
			}
			T[] array = new T[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = items[start + i];
			}
			return new ImmutableArray<T>(array);
		}

		public static ImmutableArray<T> Create<T>(ImmutableArray<T> items, int start, int length)
		{
			Requires.Range(start >= 0 && start <= items.Length, "start");
			Requires.Range(length >= 0 && start + length <= items.Length, "length");
			if (length == 0)
			{
				return Create<T>();
			}
			if (start == 0 && length == items.Length)
			{
				return items;
			}
			T[] array = new T[length];
			Array.Copy(items.array, start, array, 0, length);
			return new ImmutableArray<T>(array);
		}

		public static ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource> items, Func<TSource, TResult> selector)
		{
			Requires.NotNull(selector, "selector");
			int length = items.Length;
			if (length == 0)
			{
				return Create<TResult>();
			}
			TResult[] array = new TResult[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = selector(items[i]);
			}
			return new ImmutableArray<TResult>(array);
		}

		public static ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource> items, int start, int length, Func<TSource, TResult> selector)
		{
			int length2 = items.Length;
			Requires.Range(start >= 0 && start <= length2, "start");
			Requires.Range(length >= 0 && start + length <= length2, "length");
			Requires.NotNull(selector, "selector");
			if (length == 0)
			{
				return Create<TResult>();
			}
			TResult[] array = new TResult[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = selector(items[i + start]);
			}
			return new ImmutableArray<TResult>(array);
		}

		public static ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource> items, Func<TSource, TArg, TResult> selector, TArg arg)
		{
			Requires.NotNull(selector, "selector");
			int length = items.Length;
			if (length == 0)
			{
				return Create<TResult>();
			}
			TResult[] array = new TResult[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = selector(items[i], arg);
			}
			return new ImmutableArray<TResult>(array);
		}

		public static ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource> items, int start, int length, Func<TSource, TArg, TResult> selector, TArg arg)
		{
			int length2 = items.Length;
			Requires.Range(start >= 0 && start <= length2, "start");
			Requires.Range(length >= 0 && start + length <= length2, "length");
			Requires.NotNull(selector, "selector");
			if (length == 0)
			{
				return Create<TResult>();
			}
			TResult[] array = new TResult[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = selector(items[i + start], arg);
			}
			return new ImmutableArray<TResult>(array);
		}

		public static ImmutableArray<T>.Builder CreateBuilder<T>()
		{
			return Create<T>().ToBuilder();
		}

		public static ImmutableArray<T>.Builder CreateBuilder<T>(int initialCapacity)
		{
			return new ImmutableArray<T>.Builder(initialCapacity);
		}

		public static ImmutableArray<TSource> ToImmutableArray<TSource>(this IEnumerable<TSource> items)
		{
			if (items is ImmutableArray<TSource>)
			{
				return (ImmutableArray<TSource>)(object)items;
			}
			return CreateRange(items);
		}

		public static ImmutableArray<TSource> ToImmutableArray<TSource>(this ImmutableArray<TSource>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static int BinarySearch<T>(this ImmutableArray<T> array, T value)
		{
			return Array.BinarySearch(array.array, value);
		}

		public static int BinarySearch<T>(this ImmutableArray<T> array, T value, IComparer<T>? comparer)
		{
			return Array.BinarySearch(array.array, value, comparer);
		}

		public static int BinarySearch<T>(this ImmutableArray<T> array, int index, int length, T value)
		{
			return Array.BinarySearch(array.array, index, length, value);
		}

		public static int BinarySearch<T>(this ImmutableArray<T> array, int index, int length, T value, IComparer<T>? comparer)
		{
			return Array.BinarySearch(array.array, index, length, value, comparer);
		}
	}
	[CollectionBuilder(typeof(ImmutableArray), "Create")]
	[DebuggerDisplay("{DebuggerDisplay,nq}")]
	[System.Runtime.Versioning.NonVersionable]
	public readonly struct ImmutableArray<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, IEquatable<ImmutableArray<T>>, IList, ICollection, IImmutableArray, IStructuralComparable, IStructuralEquatable, IImmutableList<T>
	{
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(ImmutableArrayBuilderDebuggerProxy<>))]
		public sealed class Builder : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>
		{
			private T[] _elements;

			private int _count;

			public int Capacity
			{
				get
				{
					return _elements.Length;
				}
				set
				{
					if (value < _count)
					{
						throw new ArgumentException(System.SR.CapacityMustBeGreaterThanOrEqualToCount, "value");
					}
					if (value == _elements.Length)
					{
						return;
					}
					if (value > 0)
					{
						T[] array = new T[value];
						if (_count > 0)
						{
							Array.Copy(_elements, array, _count);
						}
						_elements = array;
					}
					else
					{
						_elements = ImmutableArray<T>.Empty.array;
					}
				}
			}

			public int Count
			{
				get
				{
					return _count;
				}
				set
				{
					Requires.Range(value >= 0, "value");
					if (value < _count)
					{
						if (_count - value > 64)
						{
							Array.Clear(_elements, value, _count - value);
						}
						else
						{
							for (int i = value; i < Count; i++)
							{
								_elements[i] = default(T);
							}
						}
					}
					else if (value > _count)
					{
						EnsureCapacity(value);
					}
					_count = value;
				}
			}

			public T this[int index]
			{
				get
				{
					if (index >= Count)
					{
						ThrowIndexOutOfRangeException();
					}
					return _elements[index];
				}
				set
				{
					if (index >= Count)
					{
						ThrowIndexOutOfRangeException();
					}
					_elements[index] = value;
				}
			}

			bool ICollection<T>.IsReadOnly => false;

			internal Builder(int capacity)
			{
				Requires.Range(capacity >= 0, "capacity");
				_elements = new T[capacity];
				_count = 0;
			}

			internal Builder()
				: this(8)
			{
			}

			private static void ThrowIndexOutOfRangeException()
			{
				throw new IndexOutOfRangeException();
			}

			public ref readonly T ItemRef(int index)
			{
				if (index >= Count)
				{
					ThrowIndexOutOfRangeException();
				}
				return ref _elements[index];
			}

			public ImmutableArray<T> ToImmutable()
			{
				return new ImmutableArray<T>(ToArray());
			}

			public ImmutableArray<T> MoveToImmutable()
			{
				if (Capacity != Count)
				{
					throw new InvalidOperationException(System.SR.CapacityMustEqualCountOnMove);
				}
				T[] elements = _elements;
				_elements = ImmutableArray<T>.Empty.array;
				_count = 0;
				return new ImmutableArray<T>(elements);
			}

			public ImmutableArray<T> DrainToImmutable()
			{
				T[] array = _elements;
				if (array.Length != _count)
				{
					array = ToArray();
				}
				_elements = ImmutableArray<T>.Empty.array;
				_count = 0;
				return new ImmutableArray<T>(array);
			}

			public void Clear()
			{
				Count = 0;
			}

			public void Insert(int index, T item)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				EnsureCapacity(Count + 1);
				if (index < Count)
				{
					Array.Copy(_elements, index, _elements, index + 1, Count - index);
				}
				_count++;
				_elements[index] = item;
			}

			public void InsertRange(int index, IEnumerable<T> items)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				Requires.NotNull(items, "items");
				int count = ImmutableExtensions.GetCount(ref items);
				EnsureCapacity(Count + count);
				if (index != Count)
				{
					Array.Copy(_elements, index, _elements, index + count, _count - index);
				}
				if (!items.TryCopyTo(_elements, index))
				{
					foreach (T item in items)
					{
						_elements[index++] = item;
					}
				}
				_count += count;
			}

			public void InsertRange(int index, ImmutableArray<T> items)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				if (!items.IsEmpty)
				{
					EnsureCapacity(Count + items.Length);
					if (index != Count)
					{
						Array.Copy(_elements, index, _elements, index + items.Length, _count - index);
					}
					Array.Copy(items.array, 0, _elements, index, items.Length);
					_count += items.Length;
				}
			}

			public void Add(T item)
			{
				int num = _count + 1;
				EnsureCapacity(num);
				_elements[_count] = item;
				_count = num;
			}

			public void AddRange(IEnumerable<T> items)
			{
				Requires.NotNull(items, "items");
				if (items.TryGetCount(out var count))
				{
					EnsureCapacity(Count + count);
					if (items.TryCopyTo(_elements, _count))
					{
						_count += count;
						return;
					}
				}
				foreach (T item in items)
				{
					Add(item);
				}
			}

			public void AddRange(params T[] items)
			{
				Requires.NotNull(items, "items");
				int count = Count;
				Count += items.Length;
				Array.Copy(items, 0, _elements, count, items.Length);
			}

			public void AddRange<TDerived>(TDerived[] items) where TDerived : T
			{
				Requires.NotNull(items, "items");
				int count = Count;
				Count += items.Length;
				Array.Copy(items, 0, _elements, count, items.Length);
			}

			public void AddRange(T[] items, int length)
			{
				Requires.NotNull(items, "items");
				Requires.Range(length >= 0 && length <= items.Length, "length");
				int count = Count;
				Count += length;
				Array.Copy(items, 0, _elements, count, length);
			}

			public void AddRange(ImmutableArray<T> items)
			{
				AddRange(items, items.Length);
			}

			public void AddRange(ImmutableArray<T> items, int length)
			{
				Requires.Range(length >= 0, "length");
				if (items.array != null)
				{
					AddRange(items.array, length);
				}
			}

			public void AddRange([ParamCollection] scoped ReadOnlySpan<T> items)
			{
				int count = Count;
				Count += items.Length;
				items.CopyTo(new Span<T>(_elements, count, items.Length));
			}

			public void AddRange<TDerived>([ParamCollection] scoped ReadOnlySpan<TDerived> items) where TDerived : T
			{
				int count = Count;
				Count += items.Length;
				Span<T> span = new Span<T>(_elements, count, items.Length);
				for (int i = 0; i < items.Length; i++)
				{
					span[i] = (T)(object)items[i];
				}
			}

			public void AddRange<TDerived>(ImmutableArray<TDerived> items) where TDerived : T
			{
				if (items.array != null)
				{
					this.AddRange<TDerived>(items.array);
				}
			}

			public void AddRange(Builder items)
			{
				Requires.NotNull(items, "items");
				AddRange(items._elements, items.Count);
			}

			public void AddRange<TDerived>(ImmutableArray<TDerived>.Builder items) where TDerived : T
			{
				Requires.NotNull(items, "items");
				AddRange<TDerived>(items._elements, items.Count);
			}

			public bool Remove(T element)
			{
				int num = IndexOf(element);
				if (num >= 0)
				{
					RemoveAt(num);
					return true;
				}
				return false;
			}

			public bool Remove(T element, IEqualityComparer<T>? equalityComparer)
			{
				int num = IndexOf(element, 0, _count, equalityComparer);
				if (num >= 0)
				{
					RemoveAt(num);
					return true;
				}
				return false;
			}

			public void RemoveAll(Predicate<T> match)
			{
				List<int> list = null;
				for (int i = 0; i < _count; i++)
				{
					if (match(_elements[i]))
					{
						if (list == null)
						{
							list = new List<int>();
						}
						list.Add(i);
					}
				}
				if (list != null)
				{
					RemoveAtRange(list);
				}
			}

			public void RemoveAt(int index)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				if (index < Count - 1)
				{
					Array.Copy(_elements, index + 1, _elements, index, Count - index - 1);
				}
				Count--;
			}

			public void RemoveRange(int index, int length)
			{
				Requires.Range(index >= 0 && index <= _count, "index");
				Requires.Range(length >= 0 && index <= _count - length, "length");
				if (length != 0)
				{
					if (index + length < _count)
					{
						Array.Copy(_elements, index + length, _elements, index, Count - index - length);
					}
					_count -= length;
				}
			}

			public void RemoveRange(IEnumerable<T> items)
			{
				RemoveRange(items, EqualityComparer<T>.Default);
			}

			public void RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer)
			{
				Requires.NotNull(items, "items");
				SortedSet<int> sortedSet = new SortedSet<int>();
				foreach (T item in items)
				{
					int num = IndexOf(item, 0, _count, equalityComparer);
					while (num >= 0 && !sortedSet.Add(num) && num + 1 < _count)
					{
						num = IndexOf(item, num + 1, equalityComparer);
					}
				}
				RemoveAtRange(sortedSet);
			}

			public void Replace(T oldValue, T newValue)
			{
				Replace(oldValue, newValue, EqualityComparer<T>.Default);
			}

			public void Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer)
			{
				int num = IndexOf(oldValue, 0, _count, equalityComparer);
				if (num >= 0)
				{
					_elements[num] = newValue;
				}
			}

			public bool Contains(T item)
			{
				return IndexOf(item) >= 0;
			}

			public T[] ToArray()
			{
				if (Count == 0)
				{
					return ImmutableArray<T>.Empty.array;
				}
				T[] array = new T[Count];
				Array.Copy(_elements, array, Count);
				return array;
			}

			public void CopyTo(T[] array, int index)
			{
				Requires.NotNull(array, "array");
				Requires.Range(index >= 0 && index + Count <= array.Length, "index");
				Array.Copy(_elements, 0, array, index, Count);
			}

			public void CopyTo(T[] destination)
			{
				Requires.NotNull(destination, "destination");
				Array.Copy(_elements, 0, destination, 0, Count);
			}

			public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int length)
			{
				Requires.NotNull(destination, "destination");
				Requires.Range(length >= 0, "length");
				Requires.Range(sourceIndex >= 0 && sourceIndex + length <= Count, "sourceIndex");
				Requires.Range(destinationIndex >= 0 && destinationIndex + length <= destination.Length, "destinationIndex");
				Array.Copy(_elements, sourceIndex, destination, destinationIndex, length);
			}

			private void EnsureCapacity(int capacity)
			{
				if (_elements.Length < capacity)
				{
					int newSize = Math.Max(_elements.Length * 2, capacity);
					Array.Resize(ref _elements, newSize);
				}
			}

			public int IndexOf(T item)
			{
				return IndexOf(item, 0, _count, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int startIndex)
			{
				return IndexOf(item, startIndex, Count - startIndex, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int startIndex, int count)
			{
				return IndexOf(item, startIndex, count, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T>? equalityComparer)
			{
				if (count == 0 && startIndex == 0)
				{
					return -1;
				}
				Requires.Range(startIndex >= 0 && startIndex < Count, "startIndex");
				Requires.Range(count >= 0 && startIndex + count <= Count, "count");
				if (equalityComparer == null)
				{
					equalityComparer = EqualityComparer<T>.Default;
				}
				if (equalityComparer == EqualityComparer<T>.Default)
				{
					return Array.IndexOf(_elements, item, startIndex, count);
				}
				for (int i = startIndex; i < startIndex + count; i++)
				{
					if (equalityComparer.Equals(_elements[i], item))
					{
						return i;
					}
				}
				return -1;
			}

			public int IndexOf(T item, int startIndex, IEqualityComparer<T>? equalityComparer)
			{
				return IndexOf(item, startIndex, Count - startIndex, equalityComparer);
			}

			public int LastIndexOf(T item)
			{
				if (Count == 0)
				{
					return -1;
				}
				return LastIndexOf(item, Count - 1, Count, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex)
			{
				if (Count == 0 && startIndex == 0)
				{
					return -1;
				}
				Requires.Range(startIndex >= 0 && startIndex < Count, "startIndex");
				return LastIndexOf(item, startIndex, startIndex + 1, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex, int count)
			{
				return LastIndexOf(item, startIndex, count, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T>? equalityComparer)
			{
				if (count == 0 && startIndex == 0)
				{
					return -1;
				}
				Requires.Range(startIndex >= 0 && startIndex < Count, "startIndex");
				Requires.Range(count >= 0 && startIndex - count + 1 >= 0, "count");
				if (equalityComparer == null)
				{
					equalityComparer = EqualityComparer<T>.Default;
				}
				if (equalityComparer == EqualityComparer<T>.Default)
				{
					return Array.LastIndexOf(_elements, item, startIndex, count);
				}
				for (int num = startIndex; num >= startIndex - count + 1; num--)
				{
					if (equalityComparer.Equals(item, _elements[num]))
					{
						return num;
					}
				}
				return -1;
			}

			public void Reverse()
			{
				int num = 0;
				int num2 = _count - 1;
				T[] elements = _elements;
				while (num < num2)
				{
					T val = elements[num];
					elements[num] = elements[num2];
					elements[num2] = val;
					num++;
					num2--;
				}
			}

			public void Sort()
			{
				if (Count > 1)
				{
					Array.Sort(_elements, 0, Count, Comparer<T>.Default);
				}
			}

			public void Sort(Comparison<T> comparison)
			{
				Requires.NotNull(comparison, "comparison");
				if (Count > 1)
				{
					Array.Sort(_elements, 0, _count, Comparer<T>.Create(comparison));
				}
			}

			public void Sort(IComparer<T>? comparer)
			{
				if (Count > 1)
				{
					Array.Sort(_elements, 0, _count, comparer);
				}
			}

			public void Sort(int index, int count, IComparer<T>? comparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0 && index + count <= Count, "count");
				if (count > 1)
				{
					Array.Sort(_elements, index, count, comparer);
				}
			}

			public void CopyTo(Span<T> destination)
			{
				Requires.Range(Count <= destination.Length, "destination");
				new ReadOnlySpan<T>(_elements, 0, Count).CopyTo(destination);
			}

			public IEnumerator<T> GetEnumerator()
			{
				for (int i = 0; i < Count; i++)
				{
					yield return this[i];
				}
			}

			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			private void AddRange<TDerived>(TDerived[] items, int length) where TDerived : T
			{
				EnsureCapacity(Count + length);
				int count = Count;
				Count += length;
				T[] elements = _elements;
				for (int i = 0; i < length; i++)
				{
					elements[count + i] = (T)(object)items[i];
				}
			}

			private void RemoveAtRange(ICollection<int> indicesToRemove)
			{
				Requires.NotNull(indicesToRemove, "indicesToRemove");
				if (indicesToRemove.Count == 0)
				{
					return;
				}
				int num = 0;
				int num2 = 0;
				int num3 = -1;
				foreach (int item in indicesToRemove)
				{
					int num4 = ((num3 == -1) ? item : (item - num3 - 1));
					Array.Copy(_elements, num + num2, _elements, num, num4);
					num2++;
					num += num4;
					num3 = item;
				}
				Array.Copy(_elements, num + num2, _elements, num, _elements.Length - (num + num2));
				_count -= indicesToRemove.Count;
			}
		}

		public struct Enumerator
		{
			private readonly T[] _array;

			private int _index;

			public T Current => _array[_index];

			internal Enumerator(T[] array)
			{
				_array = array;
				_index = -1;
			}

			public bool MoveNext()
			{
				return ++_index < _array.Length;
			}
		}

		private sealed class EnumeratorObject : IEnumerator<T>, IEnumerator, IDisposable
		{
			private static readonly IEnumerator<T> s_EmptyEnumerator = new EnumeratorObject(ImmutableArray<T>.Empty.array);

			private readonly T[] _array;

			private int _index;

			public T Current
			{
				get
				{
					if ((uint)_index < (uint)_array.Length)
					{
						return _array[_index];
					}
					throw new InvalidOperationException();
				}
			}

			object IEnumerator.Current => Current;

			private EnumeratorObject(T[] array)
			{
				_index = -1;
				_array = array;
			}

			public bool MoveNext()
			{
				int num = _index + 1;
				int num2 = _array.Length;
				if ((uint)num <= (uint)num2)
				{
					_index = num;
					return (uint)num < (uint)num2;
				}
				return false;
			}

			void IEnumerator.Reset()
			{
				_index = -1;
			}

			public void Dispose()
			{
			}

			internal static IEnumerator<T> Create(T[] array)
			{
				if (array.Length != 0)
				{
					return new EnumeratorObject(array);
				}
				return s_EmptyEnumerator;
			}
		}

		public static readonly ImmutableArray<T> Empty = new ImmutableArray<T>(new T[0]);

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		internal readonly T[]? array;

		T IList<T>.this[int index]
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection<T>.IsReadOnly => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		int ICollection<T>.Count
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.Length;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		int IReadOnlyCollection<T>.Count
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.Length;
			}
		}

		T IReadOnlyList<T>.this[int index]
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray[index];
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool IList.IsFixedSize => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool IList.IsReadOnly => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		int ICollection.Count
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.Length;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		object? IList.this[int index]
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		public T this[int index]
		{
			[System.Runtime.Versioning.NonVersionable]
			get
			{
				return array[index];
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsEmpty
		{
			[System.Runtime.Versioning.NonVersionable]
			get
			{
				return array.Length == 0;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public int Length
		{
			[System.Runtime.Versioning.NonVersionable]
			get
			{
				return array.Length;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsDefault => array == null;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsDefaultOrEmpty
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				if (immutableArray.array != null)
				{
					return immutableArray.array.Length == 0;
				}
				return true;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		Array? IImmutableArray.Array => array;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string DebuggerDisplay
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				if (!immutableArray.IsDefault)
				{
					return $"Length = {immutableArray.Length}";
				}
				return "Uninitialized";
			}
		}

		public ReadOnlySpan<T> AsSpan()
		{
			return new ReadOnlySpan<T>(array);
		}

		public ReadOnlyMemory<T> AsMemory()
		{
			return new ReadOnlyMemory<T>(array);
		}

		public int IndexOf(T item)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.IndexOf(item, 0, immutableArray.Length, EqualityComparer<T>.Default);
		}

		public int IndexOf(T item, int startIndex, IEqualityComparer<T>? equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.IndexOf(item, startIndex, immutableArray.Length - startIndex, equalityComparer);
		}

		public int IndexOf(T item, int startIndex)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.IndexOf(item, startIndex, immutableArray.Length - startIndex, EqualityComparer<T>.Default);
		}

		public int IndexOf(T item, int startIndex, int count)
		{
			return IndexOf(item, startIndex, count, EqualityComparer<T>.Default);
		}

		public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T>? equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			if (count == 0 && startIndex == 0)
			{
				return -1;
			}
			Requires.Range(startIndex >= 0 && startIndex < immutableArray.Length, "startIndex");
			Requires.Range(count >= 0 && startIndex + count <= immutableArray.Length, "count");
			if (equalityComparer == null)
			{
				equalityComparer = EqualityComparer<T>.Default;
			}
			if (equalityComparer == EqualityComparer<T>.Default)
			{
				return Array.IndexOf(immutableArray.array, item, startIndex, count);
			}
			for (int i = startIndex; i < startIndex + count; i++)
			{
				if (equalityComparer.Equals(immutableArray.array[i], item))
				{
					return i;
				}
			}
			return -1;
		}

		public int LastIndexOf(T item)
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.IsEmpty)
			{
				return -1;
			}
			return immutableArray.LastIndexOf(item, immutableArray.Length - 1, immutableArray.Length, EqualityComparer<T>.Default);
		}

		public int LastIndexOf(T item, int startIndex)
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.IsEmpty && startIndex == 0)
			{
				return -1;
			}
			return immutableArray.LastIndexOf(item, startIndex, startIndex + 1, EqualityComparer<T>.Default);
		}

		public int LastIndexOf(T item, int startIndex, int count)
		{
			return LastIndexOf(item, startIndex, count, EqualityComparer<T>.Default);
		}

		public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T>? equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			if (startIndex == 0 && count == 0)
			{
				return -1;
			}
			Requires.Range(startIndex >= 0 && startIndex < immutableArray.Length, "startIndex");
			Requires.Range(count >= 0 && startIndex - count + 1 >= 0, "count");
			if (equalityComparer == null)
			{
				equalityComparer = EqualityComparer<T>.Default;
			}
			if (equalityComparer == EqualityComparer<T>.Default)
			{
				return Array.LastIndexOf(immutableArray.array, item, startIndex, count);
			}
			for (int num = startIndex; num >= startIndex - count + 1; num--)
			{
				if (equalityComparer.Equals(item, immutableArray.array[num]))
				{
					return num;
				}
			}
			return -1;
		}

		public bool Contains(T item)
		{
			return IndexOf(item) >= 0;
		}

		public bool Contains(T item, IEqualityComparer<T>? equalityComparer)
		{
			return this.IndexOf(item, equalityComparer) >= 0;
		}

		public ImmutableArray<T> Insert(int index, T item)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= immutableArray.Length, "index");
			if (immutableArray.IsEmpty)
			{
				return ImmutableArray.Create(item);
			}
			T[] array = new T[immutableArray.Length + 1];
			array[index] = item;
			if (index != 0)
			{
				Array.Copy(immutableArray.array, array, index);
			}
			if (index != immutableArray.Length)
			{
				Array.Copy(immutableArray.array, index, array, index + 1, immutableArray.Length - index);
			}
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> InsertRange(int index, IEnumerable<T> items)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= result.Length, "index");
			Requires.NotNull(items, "items");
			if (result.IsEmpty)
			{
				return ImmutableArray.CreateRange(items);
			}
			int count = ImmutableExtensions.GetCount(ref items);
			if (count == 0)
			{
				return result;
			}
			T[] array = new T[result.Length + count];
			if (index != 0)
			{
				Array.Copy(result.array, array, index);
			}
			if (index != result.Length)
			{
				Array.Copy(result.array, index, array, index + count, result.Length - index);
			}
			if (!items.TryCopyTo(array, index))
			{
				int num = index;
				foreach (T item in items)
				{
					array[num++] = item;
				}
			}
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> InsertRange(int index, ImmutableArray<T> items)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			items.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= result.Length, "index");
			if (result.IsEmpty)
			{
				return items;
			}
			if (items.IsEmpty)
			{
				return result;
			}
			return result.InsertSpanRangeInternal(index, items.AsSpan());
		}

		public ImmutableArray<T> Add(T item)
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.IsEmpty)
			{
				return ImmutableArray.Create(item);
			}
			return immutableArray.Insert(immutableArray.Length, item);
		}

		public ImmutableArray<T> AddRange(IEnumerable<T> items)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.InsertRange(immutableArray.Length, items);
		}

		public ImmutableArray<T> AddRange(T[] items, int length)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.NotNull(items, "items");
			Requires.Range(length >= 0 && length <= items.Length, "length");
			if (items.Length == 0 || length == 0)
			{
				return result;
			}
			if (result.IsEmpty)
			{
				return ImmutableArray.Create(items, 0, length);
			}
			T[] array = new T[result.Length + length];
			Array.Copy(result.array, array, result.Length);
			Array.Copy(items, 0, array, result.Length, length);
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> AddRange<TDerived>(TDerived[] items) where TDerived : T
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.NotNull(items, "items");
			if (items.Length == 0)
			{
				return result;
			}
			T[] array = new T[result.Length + items.Length];
			Array.Copy(result.array, array, result.Length);
			Array.Copy(items, 0, array, result.Length, items.Length);
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> AddRange(ImmutableArray<T> items, int length)
		{
			ImmutableArray<T> result = this;
			Requires.Range(length >= 0, "length");
			if (items.array != null)
			{
				return result.AddRange(items.array, length);
			}
			return result;
		}

		public ImmutableArray<T> AddRange<TDerived>(ImmutableArray<TDerived> items) where TDerived : T
		{
			ImmutableArray<T> result = this;
			if (items.array != null)
			{
				return result.AddRange<TDerived>(items.array);
			}
			return result;
		}

		public ImmutableArray<T> AddRange(ImmutableArray<T> items)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.InsertRange(immutableArray.Length, items);
		}

		public ImmutableArray<T> SetItem(int index, T item)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index < immutableArray.Length, "index");
			T[] array = new T[immutableArray.Length];
			Array.Copy(immutableArray.array, array, immutableArray.Length);
			array[index] = item;
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> Replace(T oldValue, T newValue)
		{
			return Replace(oldValue, newValue, EqualityComparer<T>.Default);
		}

		public ImmutableArray<T> Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			int num = immutableArray.IndexOf(oldValue, 0, immutableArray.Length, equalityComparer);
			if (num < 0)
			{
				throw new ArgumentException(System.SR.CannotFindOldValue, "oldValue");
			}
			return immutableArray.SetItem(num, newValue);
		}

		public ImmutableArray<T> Remove(T item)
		{
			return Remove(item, EqualityComparer<T>.Default);
		}

		public ImmutableArray<T> Remove(T item, IEqualityComparer<T>? equalityComparer)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			int num = result.IndexOf(item, 0, result.Length, equalityComparer);
			if (num >= 0)
			{
				return result.RemoveAt(num);
			}
			return result;
		}

		public ImmutableArray<T> RemoveAt(int index)
		{
			return RemoveRange(index, 1);
		}

		public ImmutableArray<T> RemoveRange(int index, int length)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= result.Length, "index");
			Requires.Range(length >= 0 && index <= result.Length - length, "length");
			if (length == 0)
			{
				return result;
			}
			T[] array = new T[result.Length - length];
			Array.Copy(result.array, array, index);
			Array.Copy(result.array, index + length, array, index, result.Length - index - length);
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> RemoveRange(IEnumerable<T> items)
		{
			return RemoveRange(items, EqualityComparer<T>.Default);
		}

		public ImmutableArray<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.NotNull(items, "items");
			SortedSet<int> sortedSet = new SortedSet<int>();
			foreach (T item in items)
			{
				int num = -1;
				do
				{
					num = immutableArray.IndexOf(item, num + 1, equalityComparer);
				}
				while (num >= 0 && !sortedSet.Add(num) && num < immutableArray.Length - 1);
			}
			return immutableArray.RemoveAtRange(sortedSet);
		}

		public ImmutableArray<T> RemoveRange(ImmutableArray<T> items)
		{
			return RemoveRange(items, EqualityComparer<T>.Default);
		}

		public ImmutableArray<T> RemoveRange(ImmutableArray<T> items, IEqualityComparer<T>? equalityComparer)
		{
			Requires.NotNull(items.array, "items");
			return RemoveRange(items.AsSpan(), equalityComparer);
		}

		public ImmutableArray<T> RemoveAll(Predicate<T> match)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.NotNull(match, "match");
			if (result.IsEmpty)
			{
				return result;
			}
			List<int> list = null;
			for (int i = 0; i < result.array.Length; i++)
			{
				if (match(result.array[i]))
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(i);
				}
			}
			if (list == null)
			{
				return result;
			}
			return result.RemoveAtRange(list);
		}

		public ImmutableArray<T> Clear()
		{
			return Empty;
		}

		public ImmutableArray<T> Sort()
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.Sort(0, immutableArray.Length, Comparer<T>.Default);
		}

		public ImmutableArray<T> Sort(Comparison<T> comparison)
		{
			Requires.NotNull(comparison, "comparison");
			ImmutableArray<T> immutableArray = this;
			return immutableArray.Sort(Comparer<T>.Create(comparison));
		}

		public ImmutableArray<T> Sort(IComparer<T>? comparer)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.Sort(0, immutableArray.Length, comparer);
		}

		public ImmutableArray<T> Sort(int index, int count, IComparer<T>? comparer)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0, "index");
			Requires.Range(count >= 0 && index + count <= result.Length, "count");
			if (count > 1)
			{
				if (comparer == null)
				{
					comparer = Comparer<T>.Default;
				}
				bool flag = false;
				for (int i = index + 1; i < index + count; i++)
				{
					if (comparer.Compare(result.array[i - 1], result.array[i]) > 0)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					T[] array = new T[result.Length];
					Array.Copy(result.array, array, result.Length);
					Array.Sort(array, index, count, comparer);
					return new ImmutableArray<T>(array);
				}
			}
			return result;
		}

		public IEnumerable<TResult> OfType<TResult>()
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.array == null || immutableArray.array.Length == 0)
			{
				return Enumerable.Empty<TResult>();
			}
			return immutableArray.array.OfType<TResult>();
		}

		public ImmutableArray<T> AddRange([ParamCollection] scoped ReadOnlySpan<T> items)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.InsertRange(immutableArray.Length, items);
		}

		public ImmutableArray<T> AddRange(params T[] items)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.InsertRange(immutableArray.Length, items);
		}

		public ReadOnlySpan<T> AsSpan(int start, int length)
		{
			return new ReadOnlySpan<T>(array, start, length);
		}

		public void CopyTo(Span<T> destination)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.Range(immutableArray.Length <= destination.Length, "destination");
			immutableArray.AsSpan().CopyTo(destination);
		}

		public ImmutableArray<T> InsertRange(int index, T[] items)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= result.Length, "index");
			Requires.NotNull(items, "items");
			if (items.Length == 0)
			{
				return result;
			}
			if (result.IsEmpty)
			{
				return new ImmutableArray<T>(items);
			}
			return result.InsertSpanRangeInternal(index, items);
		}

		public ImmutableArray<T> InsertRange(int index, [ParamCollection] scoped ReadOnlySpan<T> items)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= result.Length, "index");
			if (items.IsEmpty)
			{
				return result;
			}
			if (result.IsEmpty)
			{
				return items.ToImmutableArray();
			}
			return result.InsertSpanRangeInternal(index, items);
		}

		public ImmutableArray<T> RemoveRange(ReadOnlySpan<T> items, IEqualityComparer<T>? equalityComparer = null)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			if (items.IsEmpty || result.IsEmpty)
			{
				return result;
			}
			if (items.Length == 1)
			{
				return result.Remove(items[0], equalityComparer);
			}
			SortedSet<int> sortedSet = new SortedSet<int>();
			ReadOnlySpan<T> readOnlySpan = items;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				T item = readOnlySpan[i];
				int num = -1;
				do
				{
					num = result.IndexOf(item, num + 1, equalityComparer);
				}
				while (num >= 0 && !sortedSet.Add(num) && num < result.Length - 1);
			}
			return result.RemoveAtRange(sortedSet);
		}

		public ImmutableArray<T> RemoveRange(T[] items, IEqualityComparer<T>? equalityComparer = null)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.NotNull(items, "items");
			return immutableArray.RemoveRange(new ReadOnlySpan<T>(items), equalityComparer);
		}

		public ImmutableArray<T> Slice(int start, int length)
		{
			ImmutableArray<T> items = this;
			items.ThrowNullRefIfNotInitialized();
			return ImmutableArray.Create(items, start, length);
		}

		void IList<T>.Insert(int index, T item)
		{
			throw new NotSupportedException();
		}

		void IList<T>.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<T>.Remove(T item)
		{
			throw new NotSupportedException();
		}

		IImmutableList<T> IImmutableList<T>.Clear()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Clear();
		}

		IImmutableList<T> IImmutableList<T>.Add(T value)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Add(value);
		}

		IImmutableList<T> IImmutableList<T>.AddRange(IEnumerable<T> items)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.AddRange(items);
		}

		IImmutableList<T> IImmutableList<T>.Insert(int index, T element)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Insert(index, element);
		}

		IImmutableList<T> IImmutableList<T>.InsertRange(int index, IEnumerable<T> items)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.InsertRange(index, items);
		}

		IImmutableList<T> IImmutableList<T>.Remove(T value, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Remove(value, equalityComparer);
		}

		IImmutableList<T> IImmutableList<T>.RemoveAll(Predicate<T> match)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.RemoveAll(match);
		}

		IImmutableList<T> IImmutableList<T>.RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.RemoveRange(items, equalityComparer);
		}

		IImmutableList<T> IImmutableList<T>.RemoveRange(int index, int count)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.RemoveRange(index, count);
		}

		IImmutableList<T> IImmutableList<T>.RemoveAt(int index)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.RemoveAt(index);
		}

		IImmutableList<T> IImmutableList<T>.SetItem(int index, T value)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.SetItem(index, value);
		}

		IImmutableList<T> IImmutableList<T>.Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Replace(oldValue, newValue, equalityComparer);
		}

		int IList.Add(object value)
		{
			throw new NotSupportedException();
		}

		void IList.Clear()
		{
			throw new NotSupportedException();
		}

		private static bool IsCompatibleObject(object value)
		{
			if (!(value is T))
			{
				if (default(T) == null)
				{
					return value == null;
				}
				return false;
			}
			return true;
		}

		bool IList.Contains(object value)
		{
			if (IsCompatibleObject(value))
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.Contains((T)value);
			}
			return false;
		}

		int IList.IndexOf(object value)
		{
			if (IsCompatibleObject(value))
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.IndexOf((T)value);
			}
			return -1;
		}

		void IList.Insert(int index, object value)
		{
			throw new NotSupportedException();
		}

		void IList.Remove(object value)
		{
			throw new NotSupportedException();
		}

		void IList.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int index)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			Array.Copy(immutableArray.array, 0, array, index, immutableArray.Length);
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			ImmutableArray<T> immutableArray = this;
			Array array = other as Array;
			if (array == null && other is IImmutableArray immutableArray2)
			{
				array = immutableArray2.Array;
				if (immutableArray.array == null && array == null)
				{
					return true;
				}
				if (immutableArray.array == null)
				{
					return false;
				}
			}
			return ((IStructuralEquatable)immutableArray.array).Equals((object?)array, comparer);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			ImmutableArray<T> immutableArray = this;
			return ((IStructuralEquatable)immutableArray.array)?.GetHashCode(comparer) ?? immutableArray.GetHashCode();
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			ImmutableArray<T> immutableArray = this;
			Array array = other as Array;
			if (array == null && other is IImmutableArray immutableArray2)
			{
				array = immutableArray2.Array;
				if (immutableArray.array == null && array == null)
				{
					return 0;
				}
				if ((immutableArray.array == null) ^ (array == null))
				{
					throw new ArgumentException(System.SR.ArrayInitializedStateNotEqual, "other");
				}
			}
			if (array != null)
			{
				return ((IStructuralComparable)(immutableArray.array ?? throw new ArgumentException(System.SR.ArrayInitializedStateNotEqual, "other"))).CompareTo((object?)array, comparer);
			}
			throw new ArgumentException(System.SR.ArrayLengthsNotEqual, "other");
		}

		private ImmutableArray<T> RemoveAtRange(ICollection<int> indicesToRemove)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.NotNull(indicesToRemove, "indicesToRemove");
			if (indicesToRemove.Count == 0)
			{
				return result;
			}
			T[] array = new T[result.Length - indicesToRemove.Count];
			int num = 0;
			int num2 = 0;
			int num3 = -1;
			foreach (int item in indicesToRemove)
			{
				int num4 = ((num3 == -1) ? item : (item - num3 - 1));
				Array.Copy(result.array, num + num2, array, num, num4);
				num2++;
				num += num4;
				num3 = item;
			}
			Array.Copy(result.array, num + num2, array, num, result.Length - (num + num2));
			return new ImmutableArray<T>(array);
		}

		private ImmutableArray<T> InsertSpanRangeInternal(int index, ReadOnlySpan<T> items)
		{
			T[] array = new T[Length + items.Length];
			if (index != 0)
			{
				Array.Copy(this.array, array, index);
			}
			items.CopyTo(new Span<T>(array, index, items.Length));
			if (index != Length)
			{
				Array.Copy(this.array, index, array, index + items.Length, Length - index);
			}
			return new ImmutableArray<T>(array);
		}

		internal ImmutableArray(T[]? items)
		{
			array = items;
		}

		[System.Runtime.Versioning.NonVersionable]
		public static bool operator ==(ImmutableArray<T> left, ImmutableArray<T> right)
		{
			return left.Equals(right);
		}

		[System.Runtime.Versioning.NonVersionable]
		public static bool operator !=(ImmutableArray<T> left, ImmutableArray<T> right)
		{
			return !left.Equals(right);
		}

		public static bool operator ==(ImmutableArray<T>? left, ImmutableArray<T>? right)
		{
			return left.GetValueOrDefault().Equals(right.GetValueOrDefault());
		}

		public static bool operator !=(ImmutableArray<T>? left, ImmutableArray<T>? right)
		{
			return !left.GetValueOrDefault().Equals(right.GetValueOrDefault());
		}

		public ref readonly T ItemRef(int index)
		{
			return ref array[index];
		}

		public void CopyTo(T[] destination)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Array.Copy(immutableArray.array, destination, immutableArray.Length);
		}

		public void CopyTo(T[] destination, int destinationIndex)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Array.Copy(immutableArray.array, 0, destination, destinationIndex, immutableArray.Length);
		}

		public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int length)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Array.Copy(immutableArray.array, sourceIndex, destination, destinationIndex, length);
		}

		public ImmutableArray<T>.Builder ToBuilder()
		{
			ImmutableArray<T> items = this;
			if (items.Length == 0)
			{
				return new Builder();
			}
			Builder builder = new Builder(items.Length);
			builder.AddRange(items);
			return builder;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Enumerator GetEnumerator()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			return new Enumerator(immutableArray.array);
		}

		public override int GetHashCode()
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.array != null)
			{
				return immutableArray.array.GetHashCode();
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is IImmutableArray immutableArray)
			{
				return array == immutableArray.Array;
			}
			return false;
		}

		[System.Runtime.Versioning.NonVersionable]
		public bool Equals(ImmutableArray<T> other)
		{
			return array == other.array;
		}

		public static ImmutableArray<T> CastUp<TDerived>(ImmutableArray<TDerived> items) where TDerived : class?, T
		{
			T[] items2 = (T[])(object)items.array;
			return new ImmutableArray<T>(items2);
		}

		public ImmutableArray<TOther> CastArray<TOther>() where TOther : class?
		{
			return new ImmutableArray<TOther>((TOther[])(object)array);
		}

		public ImmutableArray<TOther> As<TOther>() where TOther : class?
		{
			return new ImmutableArray<TOther>(array as TOther[]);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return EnumeratorObject.Create(immutableArray.array);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return EnumeratorObject.Create(immutableArray.array);
		}

		internal void ThrowNullRefIfNotInitialized()
		{
			_ = array.Length;
		}

		private void ThrowInvalidOperationIfNotInitialized()
		{
			if (IsDefault)
			{
				throw new InvalidOperationException(System.SR.InvalidOperationOnDefaultArray);
			}
		}
	}
	internal sealed class ImmutableArrayBuilderDebuggerProxy<T>
	{
		private readonly ImmutableArray<T>.Builder _builder;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] A => _builder.ToArray();

		public ImmutableArrayBuilderDebuggerProxy(ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			_builder = builder;
		}
	}
	public static class ImmutableDictionary
	{
		public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>() where TKey : notnull
		{
			return ImmutableDictionary<TKey, TValue>.Empty;
		}

		public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey>? keyComparer) where TKey : notnull
		{
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer);
		}

		public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer) where TKey : notnull
		{
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer);
		}

		public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> items) where TKey : notnull
		{
			return ImmutableDictionary<TKey, TValue>.Empty.AddRange(items);
		}

		public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey>? keyComparer, IEnumerable<KeyValuePair<TKey, TValue>> items) where TKey : notnull
		{
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer).AddRange(items);
		}

		public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer, IEnumerable<KeyValuePair<TKey, TValue>> items) where TKey : notnull
		{
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(items);
		}

		public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>() where TKey : notnull
		{
			return Create<TKey, TValue>().ToBuilder();
		}

		public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IEqualityComparer<TKey>? keyComparer) where TKey : notnull
		{
			return Create<TKey, TValue>(keyComparer).ToBuilder();
		}

		public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IEqualityComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer) where TKey : notnull
		{
			return Create(keyComparer, valueComparer).ToBuilder();
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IEqualityComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer) where TKey : notnull
		{
			Func<TSource, TKey> keySelector2 = keySelector;
			Func<TSource, TValue> elementSelector2 = elementSelector;
			Requires.NotNull(source, "source");
			Requires.NotNull(keySelector2, "keySelector");
			Requires.NotNull(elementSelector2, "elementSelector");
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(source.Select((TSource element) => new KeyValuePair<TKey, TValue>(keySelector2(element), elementSelector2(element))));
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue>.Builder builder) where TKey : notnull
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IEqualityComparer<TKey>? keyComparer) where TKey : notnull
		{
			return source.ToImmutableDictionary(keySelector, elementSelector, keyComparer, null);
		}

		public static ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) where TKey : notnull
		{
			return source.ToImmutableDictionary(keySelector, (TSource v) => v, null, null);
		}

		public static ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? keyComparer) where TKey : notnull
		{
			return source.ToImmutableDictionary(keySelector, (TSource v) => v, keyComparer, null);
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector) where TKey : notnull
		{
			return source.ToImmutableDictionary(keySelector, elementSelector, null, null);
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer) where TKey : notnull
		{
			Requires.NotNull(source, "source");
			if (source is ImmutableDictionary<TKey, TValue> immutableDictionary)
			{
				return immutableDictionary.WithComparers(keyComparer, valueComparer);
			}
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(source);
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey>? keyComparer) where TKey : notnull
		{
			return source.ToImmutableDictionary(keyComparer, null);
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source) where TKey : notnull
		{
			return source.ToImmutableDictionary(null, null);
		}

		public static bool Contains<TKey, TValue>(this IImmutableDictionary<TKey, TValue> map, TKey key, TValue value) where TKey : notnull
		{
			Requires.NotNull(map, "map");
			Requires.NotNullAllowStructs(key, "key");
			return map.Contains(new KeyValuePair<TKey, TValue>(key, value));
		}

		public static TValue? GetValueOrDefault<TKey, TValue>(this IImmutableDictionary<TKey, TValue> dictionary, TKey key) where TKey : notnull
		{
			return dictionary.GetValueOrDefault(key, default(TValue));
		}

		public static TValue GetValueOrDefault<TKey, TValue>(this IImmutableDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue) where TKey : notnull
		{
			Requires.NotNull(dictionary, "dictionary");
			Requires.NotNullAllowStructs(key, "key");
			if (dictionary.TryGetValue(key, out TValue value))
			{
				return value;
			}
			return defaultValue;
		}
	}
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(ImmutableDictionaryDebuggerProxy<, >))]
	public sealed class ImmutableDictionary<TKey, TValue> : IImmutableDictionary<TKey, TValue>, IReadOnlyDictionary<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IImmutableDictionaryInternal<TKey, TValue>, IHashKeyCollection<TKey>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection where TKey : notnull
	{
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(System.Collections.Generic.IDictionaryDebugView<, >))]
		public sealed class Builder : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection
		{
			private SortedInt32KeyNode<HashBucket> _root = SortedInt32KeyNode<HashBucket>.EmptyNode;

			private Comparers _comparers;

			private int _count;

			private ImmutableDictionary<TKey, TValue> _immutable;

			private int _version;

			private object _syncRoot;

			public IEqualityComparer<TKey> KeyComparer
			{
				get
				{
					return _comparers.KeyComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value != KeyComparer)
					{
						Comparers comparers = Comparers.Get(value, ValueComparer);
						MutationInput origin = new MutationInput(SortedInt32KeyNode<HashBucket>.EmptyNode, comparers);
						MutationResult mutationResult = ImmutableDictionary<TKey, TValue>.AddRange((IEnumerable<KeyValuePair<TKey, TValue>>)this, origin, KeyCollisionBehavior.ThrowIfValueDifferent);
						_immutable = null;
						_comparers = comparers;
						_count = mutationResult.CountAdjustment;
						Root = mutationResult.Root;
					}
				}
			}

			public IEqualityComparer<TValue> ValueComparer
			{
				get
				{
					return _comparers.ValueComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value != ValueComparer)
					{
						_comparers = _comparers.WithValueComparer(value);
						_immutable = null;
					}
				}
			}

			public int Count => _count;

			bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false;

			public IEnumerable<TKey> Keys
			{
				get
				{
					using Enumerator enumerator = GetEnumerator();
					while (enumerator.MoveNext())
					{
						yield return enumerator.Current.Key;
					}
				}
			}

			ICollection<TKey> IDictionary<TKey, TValue>.Keys => Keys.ToArray(Count);

			public IEnumerable<TValue> Values
			{
				get
				{
					using Enumerator enumerator = GetEnumerator();
					while (enumerator.MoveNext())
					{
						yield return enumerator.Current.Value;
					}
				}
			}

			ICollection<TValue> IDictionary<TKey, TValue>.Values => Values.ToArray(Count);

			bool IDictionary.IsFixedSize => false;

			bool IDictionary.IsReadOnly => false;

			ICollection IDictionary.Keys => Keys.ToArray(Count);

			ICollection IDictionary.Values => Values.ToArray(Count);

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			object ICollection.SyncRoot
			{
				get
				{
					if (_syncRoot == null)
					{
						Interlocked.CompareExchange<object>(ref _syncRoot, new object(), (object)null);
					}
					return _syncRoot;
				}
			}

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			bool ICollection.IsSynchronized => false;

			object? IDictionary.this[object key]
			{
				get
				{
					return this[(TKey)key];
				}
				set
				{
					this[(TKey)key] = (TValue)value;
				}
			}

			internal int Version => _version;

			private MutationInput Origin => new MutationInput(Root, _comparers);

			private SortedInt32KeyNode<HashBucket> Root
			{
				get
				{
					return _root;
				}
				set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			public TValue this[TKey key]
			{
				get
				{
					if (!TryGetValue(key, out var value))
					{
						ThrowHelper.ThrowKeyNotFoundException(key);
					}
					return value;
				}
				set
				{
					MutationResult result = ImmutableDictionary<TKey, TValue>.Add(key, value, KeyCollisionBehavior.SetValue, Origin);
					Apply(result);
				}
			}

			internal Builder(ImmutableDictionary<TKey, TValue> map)
			{
				Requires.NotNull(map, "map");
				_root = map._root;
				_count = map._count;
				_comparers = map._comparers;
				_immutable = map;
			}

			void IDictionary.Add(object key, object value)
			{
				Add((TKey)key, (TValue)value);
			}

			bool IDictionary.Contains(object key)
			{
				return ContainsKey((TKey)key);
			}

			IDictionaryEnumerator IDictionary.GetEnumerator()
			{
				return new DictionaryEnumerator<TKey, TValue>(GetEnumerator());
			}

			void IDictionary.Remove(object key)
			{
				Remove((TKey)key);
			}

			void ICollection.CopyTo(Array array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					array.SetValue(new DictionaryEntry(current.Key, current.Value), arrayIndex++);
				}
			}

			public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items)
			{
				MutationResult result = ImmutableDictionary<TKey, TValue>.AddRange(items, Origin, KeyCollisionBehavior.ThrowIfValueDifferent);
				Apply(result);
			}

			public void RemoveRange(IEnumerable<TKey> keys)
			{
				Requires.NotNull(keys, "keys");
				foreach (TKey key in keys)
				{
					Remove(key);
				}
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(_root, this);
			}

			public TValue? GetValueOrDefault(TKey key)
			{
				return GetValueOrDefault(key, default(TValue));
			}

			public TValue GetValueOrDefault(TKey key, TValue defaultValue)
			{
				Requires.NotNullAllowStructs(key, "key");
				if (TryGetValue(key, out var value))
				{
					return value;
				}
				return defaultValue;
			}

			public ImmutableDictionary<TKey, TValue> ToImmutable()
			{
				return _immutable ?? (_immutable = ImmutableDictionary<TKey, TValue>.Wrap(_root, _comparers, _count));
			}

			public void Add(TKey key, TValue value)
			{
				MutationResult result = ImmutableDictionary<TKey, TValue>.Add(key, value, KeyCollisionBehavior.ThrowIfValueDifferent, Origin);
				Apply(result);
			}

			public bool ContainsKey(TKey key)
			{
				return ImmutableDictionary<TKey, TValue>.ContainsKey(key, Origin);
			}

			public bool ContainsValue(TValue value)
			{
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						KeyValuePair<TKey, TValue> current = enumerator.Current;
						if (ValueComparer.Equals(value, current.Value))
						{
							return true;
						}
					}
				}
				return false;
			}

			public bool Remove(TKey key)
			{
				MutationResult result = ImmutableDictionary<TKey, TValue>.Remove(key, Origin);
				return Apply(result);
			}

			public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
			{
				return ImmutableDictionary<TKey, TValue>.TryGetValue(key, Origin, out value);
			}

			public bool TryGetKey(TKey equalKey, out TKey actualKey)
			{
				return ImmutableDictionary<TKey, TValue>.TryGetKey(equalKey, Origin, out actualKey);
			}

			public void Add(KeyValuePair<TKey, TValue> item)
			{
				Add(item.Key, item.Value);
			}

			public void Clear()
			{
				Root = SortedInt32KeyNode<HashBucket>.EmptyNode;
				_count = 0;
			}

			public bool Contains(KeyValuePair<TKey, TValue> item)
			{
				return ImmutableDictionary<TKey, TValue>.Contains(item, Origin);
			}

			void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			public bool Remove(KeyValuePair<TKey, TValue> item)
			{
				if (Contains(item))
				{
					return Remove(item.Key);
				}
				return false;
			}

			IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			private bool Apply(MutationResult result)
			{
				Root = result.Root;
				_count += result.CountAdjustment;
				return result.CountAdjustment != 0;
			}
		}

		internal sealed class Comparers : IEqualityComparer<HashBucket>, IEqualityComparer<KeyValuePair<TKey, TValue>>
		{
			internal static readonly Comparers Default = new Comparers(EqualityComparer<TKey>.Default, EqualityComparer<TValue>.Default);

			private readonly IEqualityComparer<TKey> _keyComparer;

			private readonly IEqualityComparer<TValue> _valueComparer;

			internal IEqualityComparer<TKey> KeyComparer => _keyComparer;

			internal IEqualityComparer<KeyValuePair<TKey, TValue>> KeyOnlyComparer => this;

			internal IEqualityComparer<TValue> ValueComparer => _valueComparer;

			internal IEqualityComparer<HashBucket> HashBucketEqualityComparer => this;

			internal Comparers(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				_keyComparer = keyComparer;
				_valueComparer = valueComparer;
			}

			public bool Equals(HashBucket x, HashBucket y)
			{
				if (x.AdditionalElements == y.AdditionalElements && KeyComparer.Equals(x.FirstValue.Key, y.FirstValue.Key))
				{
					return ValueComparer.Equals(x.FirstValue.Value, y.FirstValue.Value);
				}
				return false;
			}

			public int GetHashCode(HashBucket obj)
			{
				return KeyComparer.GetHashCode(obj.FirstValue.Key);
			}

			bool IEqualityComparer<KeyValuePair<TKey, TValue>>.Equals(KeyValuePair<TKey, TValue> x, KeyValuePair<TKey, TValue> y)
			{
				return _keyComparer.Equals(x.Key, y.Key);
			}

			int IEqualityComparer<KeyValuePair<TKey, TValue>>.GetHashCode(KeyValuePair<TKey, TValue> obj)
			{
				return _keyComparer.GetHashCode(obj.Key);
			}

			internal static Comparers Get(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				if (keyComparer != Default.KeyComparer || valueComparer != Default.ValueComparer)
				{
					return new Comparers(keyComparer, valueComparer);
				}
				return Default;
			}

			internal Comparers WithValueComparer(IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNull(valueComparer, "valueComparer");
				if (_valueComparer != valueComparer)
				{
					return Get(KeyComparer, valueComparer);
				}
				return this;
			}
		}

		public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IEnumerator, IDisposable
		{
			private readonly Builder _builder;

			private SortedInt32KeyNode<HashBucket>.Enumerator _mapEnumerator;

			private HashBucket.Enumerator _bucketEnumerator;

			private int _enumeratingBuilderVersion;

			public KeyValuePair<TKey, TValue> Current
			{
				get
				{
					_mapEnumerator.ThrowIfDisposed();
					return _bucketEnumerator.Current;
				}
			}

			object IEnumerator.Current => Current;

			internal Enumerator(SortedInt32KeyNode<HashBucket> root, Builder? builder = null)
			{
				_builder = builder;
				_mapEnumerator = new SortedInt32KeyNode<HashBucket>.Enumerator(root);
				_bucketEnumerator = default(HashBucket.Enumerator);
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
			}

			public bool MoveNext()
			{
				ThrowIfChanged();
				if (_bucketEnumerator.MoveNext())
				{
					return true;
				}
				if (_mapEnumerator.MoveNext())
				{
					_bucketEnumerator = new HashBucket.Enumerator(_mapEnumerator.Current.Value);
					return _bucketEnumerator.MoveNext();
				}
				return false;
			}

			public void Reset()
			{
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_mapEnumerator.Reset();
				_bucketEnumerator.Dispose();
				_bucketEnumerator = default(HashBucket.Enumerator);
			}

			public void Dispose()
			{
				_mapEnumerator.Dispose();
				_bucketEnumerator.Dispose();
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}
		}

		internal readonly struct HashBucket : IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
		{
			internal struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IEnumerator, IDisposable
			{
				private enum Position
				{
					BeforeFirst,
					First,
					Additional,
					End
				}

				private readonly HashBucket _bucket;

				private Position _currentPosition;

				private ImmutableList<KeyValuePair<TKey, TValue>>.Enumerator _additionalEnumerator;

				object IEnumerator.Current => Current;

				public KeyValuePair<TKey, TValue> Current => _currentPosition switch
				{
					Position.First => _bucket._firstValue, 
					Position.Additional => _additionalEnumerator.Current, 
					_ => throw new InvalidOperationException(), 
				};

				internal Enumerator(HashBucket bucket)
				{
					_bucket = bucket;
					_currentPosition = Position.BeforeFirst;
					_additionalEnumerator = default(ImmutableList<KeyValuePair<TKey, TValue>>.Enumerator);
				}

				public bool MoveNext()
				{
					if (_bucket.IsEmpty)
					{
						_currentPosition = Position.End;
						return false;
					}
					switch (_currentPosition)
					{
					case Position.BeforeFirst:
						_currentPosition = Position.First;
						return true;
					case Position.First:
						if (_bucket._additionalElements.IsEmpty)
						{
							_currentPosition = Position.End;
							return false;
						}
						_currentPosition = Position.Additional;
						_additionalEnumerator = new ImmutableList<KeyValuePair<TKey, TValue>>.Enumerator(_bucket._additionalElements);
						return _additionalEnumerator.MoveNext();
					case Position.Additional:
						return _additionalEnumerator.MoveNext();
					case Position.End:
						return false;
					default:
						throw new InvalidOperationException();
					}
				}

				public void Reset()
				{
					_additionalEnumerator.Dispose();
					_currentPosition = Position.BeforeFirst;
				}

				public void Dispose()
				{
					_additionalEnumerator.Dispose();
				}
			}

			private readonly KeyValuePair<TKey, TValue> _firstValue;

			private readonly ImmutableList<KeyValuePair<TKey, TValue>>.Node _additionalElements;

			internal bool IsEmpty => _additionalElements == null;

			internal KeyValuePair<TKey, TValue> FirstValue
			{
				get
				{
					if (IsEmpty)
					{
						throw new InvalidOperationException();
					}
					return _firstValue;
				}
			}

			internal ImmutableList<KeyValuePair<TKey, TValue>>.Node AdditionalElements => _additionalElements;

			private HashBucket(KeyValuePair<TKey, TValue> firstElement, ImmutableList<KeyValuePair<TKey, TValue>>.Node additionalElements = null)
			{
				_firstValue = firstElement;
				_additionalElements = additionalElements ?? ImmutableList<KeyValuePair<TKey, TValue>>.Node.EmptyNode;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public override bool Equals(object? obj)
			{
				throw new NotSupportedException();
			}

			public override int GetHashCode()
			{
				throw new NotSupportedException();
			}

			internal HashBucket Add(TKey key, TValue value, IEqualityComparer<KeyValuePair<TKey, TValue>> keyOnlyComparer, IEqualityComparer<TValue> valueComparer, KeyCollisionBehavior behavior, out OperationResult result)
			{
				KeyValuePair<TKey, TValue> keyValuePair = new KeyValuePair<TKey, TValue>(key, value);
				if (IsEmpty)
				{
					result = OperationResult.SizeChanged;
					return new HashBucket(keyValuePair);
				}
				if (keyOnlyComparer.Equals(keyValuePair, _firstValue))
				{
					switch (behavior)
					{
					case KeyCollisionBehavior.SetValue:
						result = OperationResult.AppliedWithoutSizeChange;
						return new HashBucket(keyValuePair, _additionalElements);
					case KeyCollisionBehavior.Skip:
						result = OperationResult.NoChangeRequired;
						return this;
					case KeyCollisionBehavior.ThrowIfValueDifferent:
					{
						KeyValuePair<TKey, TValue> firstValue = _firstValue;
						if (!valueComparer.Equals(firstValue.Value, value))
						{
							throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
						}
						result = OperationResult.NoChangeRequired;
						return this;
					}
					case KeyCollisionBehavior.ThrowAlways:
						throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
					default:
						throw new InvalidOperationException();
					}
				}
				int num = _additionalElements.IndexOf(keyValuePair, keyOnlyComparer);
				if (num < 0)
				{
					result = OperationResult.SizeChanged;
					return new HashBucket(_firstValue, _additionalElements.Add(keyValuePair));
				}
				switch (behavior)
				{
				case KeyCollisionBehavior.SetValue:
					result = OperationResult.AppliedWithoutSizeChange;
					return new HashBucket(_firstValue, _additionalElements.ReplaceAt(num, keyValuePair));
				case KeyCollisionBehavior.Skip:
					result = OperationResult.NoChangeRequired;
					return this;
				case KeyCollisionBehavior.ThrowIfValueDifferent:
				{
					KeyValuePair<TKey, TValue> firstValue = _additionalElements.ItemRef(num);
					if (!valueComparer.Equals(firstValue.Value, value))
					{
						throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
					}
					result = OperationResult.NoChangeRequired;
					return this;
				}
				case KeyCollisionBehavior.ThrowAlways:
					throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
				default:
					throw new InvalidOperationException();
				}
			}

			internal HashBucket Remove(TKey key, IEqualityComparer<KeyValuePair<TKey, TValue>> keyOnlyComparer, out OperationResult result)
			{
				if (IsEmpty)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				KeyValuePair<TKey, TValue> keyValuePair = new KeyValuePair<TKey, TValue>(key, default(TValue));
				if (keyOnlyComparer.Equals(_firstValue, keyValuePair))
				{
					if (_additionalElements.IsEmpty)
					{
						result = OperationResult.SizeChanged;
						return default(HashBucket);
					}
					int count = _additionalElements.Left.Count;
					result = OperationResult.SizeChanged;
					return new HashBucket(_additionalElements.Key, _additionalElements.RemoveAt(count));
				}
				int num = _additionalElements.IndexOf(keyValuePair, keyOnlyComparer);
				if (num < 0)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				result = OperationResult.SizeChanged;
				return new HashBucket(_firstValue, _additionalElements.RemoveAt(num));
			}

			internal bool TryGetValue(TKey key, Comparers comparers, [MaybeNullWhen(false)] out TValue value)
			{
				if (IsEmpty)
				{
					value = default(TValue);
					return false;
				}
				IEqualityComparer<TKey> keyComparer = comparers.KeyComparer;
				KeyValuePair<TKey, TValue> firstValue = _firstValue;
				if (keyComparer.Equals(firstValue.Key, key))
				{
					firstValue = _firstValue;
					value = firstValue.Value;
					return true;
				}
				KeyValuePair<TKey, TValue> item = new KeyValuePair<TKey, TValue>(key, default(TValue));
				int num = _additionalElements.IndexOf(item, comparers.KeyOnlyComparer);
				if (num < 0)
				{
					value = default(TValue);
					return false;
				}
				firstValue = _additionalElements.ItemRef(num);
				value = firstValue.Value;
				return true;
			}

			internal bool TryGetKey(TKey equalKey, Comparers comparers, out TKey actualKey)
			{
				if (IsEmpty)
				{
					actualKey = equalKey;
					return false;
				}
				IEqualityComparer<TKey> keyComparer = comparers.KeyComparer;
				KeyValuePair<TKey, TValue> firstValue = _firstValue;
				if (keyComparer.Equals(firstValue.Key, equalKey))
				{
					firstValue = _firstValue;
					actualKey = firstValue.Key;
					return true;
				}
				KeyValuePair<TKey, TValue> item = new KeyValuePair<TKey, TValue>(equalKey, default(TValue));
				int num = _additionalElements.IndexOf(item, comparers.KeyOnlyComparer);
				if (num < 0)
				{
					actualKey = equalKey;
					return false;
				}
				firstValue = _additionalElements.ItemRef(num);
				actualKey = firstValue.Key;
				return true;
			}

			internal void Freeze()
			{
				_additionalElements?.Freeze();
			}
		}

		private readonly struct MutationInput
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			private readonly Comparers _comparers;

			internal SortedInt32KeyNode<HashBucket> Root => _root;

			internal Comparers Comparers => _comparers;

			internal IEqualityComparer<TKey> KeyComparer => _comparers.KeyComparer;

			internal IEqualityComparer<KeyValuePair<TKey, TValue>> KeyOnlyComparer => _comparers.KeyOnlyComparer;

			internal IEqualityComparer<TValue> ValueComparer => _comparers.ValueComparer;

			internal IEqualityComparer<HashBucket> HashBucketComparer => _comparers.HashBucketEqualityComparer;

			internal MutationInput(SortedInt32KeyNode<HashBucket> root, Comparers comparers)
			{
				_root = root;
				_comparers = comparers;
			}

			internal MutationInput(ImmutableDictionary<TKey, TValue> map)
			{
				_root = map._root;
				_comparers = map._comparers;
			}
		}

		private readonly struct MutationResult
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			private readonly int _countAdjustment;

			internal SortedInt32KeyNode<HashBucket> Root => _root;

			internal int CountAdjustment => _countAdjustment;

			internal MutationResult(MutationInput unchangedInput)
			{
				_root = unchangedInput.Root;
				_countAdjustment = 0;
			}

			internal MutationResult(SortedInt32KeyNode<HashBucket> root, int countAdjustment)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_countAdjustment = countAdjustment;
			}

			internal ImmutableDictionary<TKey, TValue> Finalize(ImmutableDictionary<TKey, TValue> priorMap)
			{
				Requires.NotNull(priorMap, "priorMap");
				return priorMap.Wrap(Root, priorMap._count + CountAdjustment);
			}
		}

		internal enum KeyCollisionBehavior
		{
			SetValue,
			Skip,
			ThrowIfValueDifferent,
			ThrowAlways
		}

		internal enum OperationResult
		{
			AppliedWithoutSizeChange,
			SizeChanged,
			NoChangeRequired
		}

		public static readonly ImmutableDictionary<TKey, TValue> Empty = new ImmutableDictionary<TKey, TValue>();

		private static readonly Action<KeyValuePair<int, HashBucket>> s_FreezeBucketAction = delegate(KeyValuePair<int, HashBucket> kv)
		{
			kv.Value.Freeze();
		};

		private readonly int _count;

		private readonly SortedInt32KeyNode<HashBucket> _root;

		private readonly Comparers _comparers;

		public int Count => _count;

		public bool IsEmpty => Count == 0;

		public IEqualityComparer<TKey> KeyComparer => _comparers.KeyComparer;

		public IEqualityComparer<TValue> ValueComparer => _comparers.ValueComparer;

		public IEnumerable<TKey> Keys
		{
			get
			{
				foreach (KeyValuePair<int, HashBucket> item in _root)
				{
					foreach (KeyValuePair<TKey, TValue> item2 in item.Value)
					{
						yield return item2.Key;
					}
				}
			}
		}

		public IEnumerable<TValue> Values
		{
			get
			{
				foreach (KeyValuePair<int, HashBucket> item in _root)
				{
					foreach (KeyValuePair<TKey, TValue> item2 in item.Value)
					{
						yield return item2.Value;
					}
				}
			}
		}

		ICollection<TKey> IDictionary<TKey, TValue>.Keys => new KeysCollectionAccessor<TKey, TValue>(this);

		ICollection<TValue> IDictionary<TKey, TValue>.Values => new ValuesCollectionAccessor<TKey, TValue>(this);

		private MutationInput Origin => new MutationInput(this);

		public TValue this[TKey key]
		{
			get
			{
				Requires.NotNullAllowStructs(key, "key");
				if (!TryGetValue(key, out var value))
				{
					ThrowHelper.ThrowKeyNotFoundException(key);
				}
				return value;
			}
		}

		TValue IDictionary<TKey, TValue>.this[TKey key]
		{
			get
			{
				return this[key];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true;

		bool IDictionary.IsFixedSize => true;

		bool IDictionary.IsReadOnly => true;

		ICollection IDictionary.Keys => new KeysCollectionAccessor<TKey, TValue>(this);

		ICollection IDictionary.Values => new ValuesCollectionAccessor<TKey, TValue>(this);

		internal SortedInt32KeyNode<HashBucket> Root => _root;

		object? IDictionary.this[object key]
		{
			get
			{
				return this[(TKey)key];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		private ImmutableDictionary(SortedInt32KeyNode<HashBucket> root, Comparers comparers, int count)
			: this(Requires.NotNullPassthrough(comparers, "comparers"))
		{
			Requires.NotNull(root, "root");
			root.Freeze(s_FreezeBucketAction);
			_root = root;
			_count = count;
		}

		private ImmutableDictionary(Comparers comparers = null)
		{
			_comparers = comparers ?? Comparers.Get(EqualityComparer<TKey>.Default, EqualityComparer<TValue>.Default);
			_root = SortedInt32KeyNode<HashBucket>.EmptyNode;
		}

		public ImmutableDictionary<TKey, TValue> Clear()
		{
			if (!IsEmpty)
			{
				return EmptyWithComparers(_comparers);
			}
			return this;
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Clear()
		{
			return Clear();
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableDictionary<TKey, TValue> Add(TKey key, TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			return Add(key, value, KeyCollisionBehavior.ThrowIfValueDifferent, Origin).Finalize(this);
		}

		public ImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs)
		{
			Requires.NotNull(pairs, "pairs");
			return AddRange(pairs, avoidToHashMap: false);
		}

		public ImmutableDictionary<TKey, TValue> SetItem(TKey key, TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			return Add(key, value, KeyCollisionBehavior.SetValue, Origin).Finalize(this);
		}

		public ImmutableDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			Requires.NotNull(items, "items");
			return AddRange(items, Origin, KeyCollisionBehavior.SetValue).Finalize(this);
		}

		public ImmutableDictionary<TKey, TValue> Remove(TKey key)
		{
			Requires.NotNullAllowStructs(key, "key");
			return Remove(key, Origin).Finalize(this);
		}

		public ImmutableDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys)
		{
			Requires.NotNull(keys, "keys");
			int num = _count;
			SortedInt32KeyNode<HashBucket> sortedInt32KeyNode = _root;
			foreach (TKey key in keys)
			{
				int hashCode = KeyComparer.GetHashCode(key);
				if (sortedInt32KeyNode.TryGetValue(hashCode, out var value))
				{
					OperationResult result;
					HashBucket newBucket = value.Remove(key, _comparers.KeyOnlyComparer, out result);
					sortedInt32KeyNode = UpdateRoot(sortedInt32KeyNode, hashCode, newBucket, _comparers.HashBucketEqualityComparer);
					if (result == OperationResult.SizeChanged)
					{
						num--;
					}
				}
			}
			return Wrap(sortedInt32KeyNode, num);
		}

		public bool ContainsKey(TKey key)
		{
			Requires.NotNullAllowStructs(key, "key");
			return ContainsKey(key, Origin);
		}

		public bool Contains(KeyValuePair<TKey, TValue> pair)
		{
			return Contains(pair, Origin);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			return TryGetValue(key, Origin, out value);
		}

		public bool TryGetKey(TKey equalKey, out TKey actualKey)
		{
			Requires.NotNullAllowStructs(equalKey, "equalKey");
			return TryGetKey(equalKey, Origin, out actualKey);
		}

		public ImmutableDictionary<TKey, TValue> WithComparers(IEqualityComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer)
		{
			if (keyComparer == null)
			{
				keyComparer = EqualityComparer<TKey>.Default;
			}
			if (valueComparer == null)
			{
				valueComparer = EqualityComparer<TValue>.Default;
			}
			if (KeyComparer == keyComparer)
			{
				if (ValueComparer == valueComparer)
				{
					return this;
				}
				Comparers comparers = _comparers.WithValueComparer(valueComparer);
				return new ImmutableDictionary<TKey, TValue>(_root, comparers, _count);
			}
			return new ImmutableDictionary<TKey, TValue>(Comparers.Get(keyComparer, valueComparer)).AddRange(this, avoidToHashMap: true);
		}

		public ImmutableDictionary<TKey, TValue> WithComparers(IEqualityComparer<TKey>? keyComparer)
		{
			return WithComparers(keyComparer, _comparers.ValueComparer);
		}

		public bool ContainsValue(TValue value)
		{
			using (Enumerator enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					if (ValueComparer.Equals(value, current.Value))
					{
						return true;
					}
				}
			}
			return false;
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(_root);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			return Add(key, value);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItem(TKey key, TValue value)
		{
			return SetItem(key, value);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return SetItems(items);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs)
		{
			return AddRange(pairs);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.RemoveRange(IEnumerable<TKey> keys)
		{
			return RemoveRange(keys);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Remove(TKey key)
		{
			return Remove(key);
		}

		void IDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			throw new NotSupportedException();
		}

		bool IDictionary<TKey, TValue>.Remove(TKey key)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<TKey, TValue> current = enumerator.Current;
				array[arrayIndex++] = current;
			}
		}

		void IDictionary.Add(object key, object value)
		{
			throw new NotSupportedException();
		}

		bool IDictionary.Contains(object key)
		{
			return ContainsKey((TKey)key);
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return new DictionaryEnumerator<TKey, TValue>(GetEnumerator());
		}

		void IDictionary.Remove(object key)
		{
			throw new NotSupportedException();
		}

		void IDictionary.Clear()
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<TKey, TValue> current = enumerator.Current;
				array.SetValue(new DictionaryEntry(current.Key, current.Value), arrayIndex++);
			}
		}

		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<KeyValuePair<TKey, TValue>>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private static ImmutableDictionary<TKey, TValue> EmptyWithComparers(Comparers comparers)
		{
			Requires.NotNull(comparers, "comparers");
			if (Empty._comparers != comparers)
			{
				return new ImmutableDictionary<TKey, TValue>(comparers);
			}
			return Empty;
		}

		private static bool TryCastToImmutableMap(IEnumerable<KeyValuePair<TKey, TValue>> sequence, [NotNullWhen(true)] out ImmutableDictionary<TKey, TValue> other)
		{
			other = sequence as ImmutableDictionary<TKey, TValue>;
			if (other != null)
			{
				return true;
			}
			if (sequence is Builder builder)
			{
				other = builder.ToImmutable();
				return true;
			}
			return false;
		}

		private static bool ContainsKey(TKey key, MutationInput origin)
		{
			int hashCode = origin.KeyComparer.GetHashCode(key);
			TValue value2;
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				return value.TryGetValue(key, origin.Comparers, out value2);
			}
			return false;
		}

		private static bool Contains(KeyValuePair<TKey, TValue> keyValuePair, MutationInput origin)
		{
			int hashCode = origin.KeyComparer.GetHashCode(keyValuePair.Key);
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				if (value.TryGetValue(keyValuePair.Key, origin.Comparers, out var value2))
				{
					return origin.ValueComparer.Equals(value2, keyValuePair.Value);
				}
				return false;
			}
			return false;
		}

		private static bool TryGetValue(TKey key, MutationInput origin, [MaybeNullWhen(false)] out TValue value)
		{
			int hashCode = origin.KeyComparer.GetHashCode(key);
			if (origin.Root.TryGetValue(hashCode, out var value2))
			{
				return value2.TryGetValue(key, origin.Comparers, out value);
			}
			value = default(TValue);
			return false;
		}

		private static bool TryGetKey(TKey equalKey, MutationInput origin, out TKey actualKey)
		{
			int hashCode = origin.KeyComparer.GetHashCode(equalKey);
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				return value.TryGetKey(equalKey, origin.Comparers, out actualKey);
			}
			actualKey = equalKey;
			return false;
		}

		private static MutationResult Add(TKey key, TValue value, KeyCollisionBehavior behavior, MutationInput origin)
		{
			Requires.NotNullAllowStructs(key, "key");
			int hashCode = origin.KeyComparer.GetHashCode(key);
			OperationResult result;
			HashBucket newBucket = origin.Root.GetValueOrDefault(hashCode).Add(key, value, origin.KeyOnlyComparer, origin.ValueComparer, behavior, out result);
			if (result == OperationResult.NoChangeRequired)
			{
				return new MutationResult(origin);
			}
			return new MutationResult(UpdateRoot(origin.Root, hashCode, newBucket, origin.HashBucketComparer), (result == OperationResult.SizeChanged) ? 1 : 0);
		}

		private static MutationResult AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items, MutationInput origin, KeyCollisionBehavior collisionBehavior = KeyCollisionBehavior.ThrowIfValueDifferent)
		{
			Requires.NotNull(items, "items");
			int num = 0;
			SortedInt32KeyNode<HashBucket> sortedInt32KeyNode = origin.Root;
			foreach (KeyValuePair<TKey, TValue> item in items)
			{
				Requires.NotNullAllowStructs(item.Key, "Key");
				int hashCode = origin.KeyComparer.GetHashCode(item.Key);
				OperationResult result;
				HashBucket newBucket = sortedInt32KeyNode.GetValueOrDefault(hashCode).Add(item.Key, item.Value, origin.KeyOnlyComparer, origin.ValueComparer, collisionBehavior, out result);
				sortedInt32KeyNode = UpdateRoot(sortedInt32KeyNode, hashCode, newBucket, origin.HashBucketComparer);
				if (result == OperationResult.SizeChanged)
				{
					num++;
				}
			}
			return new MutationResult(sortedInt32KeyNode, num);
		}

		private static MutationResult Remove(TKey key, MutationInput origin)
		{
			int hashCode = origin.KeyComparer.GetHashCode(key);
			OperationResult result;
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				return new MutationResult(UpdateRoot(origin.Root, hashCode, value.Remove(key, origin.KeyOnlyComparer, out result), origin.HashBucketComparer), (result == OperationResult.SizeChanged) ? (-1) : 0);
			}
			return new MutationResult(origin);
		}

		private static SortedInt32KeyNode<HashBucket> UpdateRoot(SortedInt32KeyNode<HashBucket> root, int hashCode, HashBucket newBucket, IEqualityComparer<HashBucket> hashBucketComparer)
		{
			bool mutated;
			if (newBucket.IsEmpty)
			{
				return root.Remove(hashCode, out mutated);
			}
			bool mutated2;
			return root.SetItem(hashCode, newBucket, hashBucketComparer, out mutated, out mutated2);
		}

		private static ImmutableDictionary<TKey, TValue> Wrap(SortedInt32KeyNode<HashBucket> root, Comparers comparers, int count)
		{
			Requires.NotNull(root, "root");
			Requires.NotNull(comparers, "comparers");
			Requires.Range(count >= 0, "count");
			return new ImmutableDictionary<TKey, TValue>(root, comparers, count);
		}

		private ImmutableDictionary<TKey, TValue> Wrap(SortedInt32KeyNode<HashBucket> root, int adjustedCountIfDifferentRoot)
		{
			if (root == null)
			{
				return Clear();
			}
			if (_root != root)
			{
				if (!root.IsEmpty)
				{
					return new ImmutableDictionary<TKey, TValue>(root, _comparers, adjustedCountIfDifferentRoot);
				}
				return Clear();
			}
			return this;
		}

		private ImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs, bool avoidToHashMap)
		{
			Requires.NotNull(pairs, "pairs");
			if (IsEmpty && !avoidToHashMap && TryCastToImmutableMap(pairs, out var other))
			{
				return other.WithComparers(KeyComparer, ValueComparer);
			}
			return AddRange(pairs, Origin).Finalize(this);
		}
	}
	internal sealed class ImmutableDictionaryDebuggerProxy<TKey, TValue> where TKey : notnull
	{
		private readonly IReadOnlyDictionary<TKey, TValue> _dictionary;

		private DebugViewDictionaryItem<TKey, TValue>[] _cachedContents;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public DebugViewDictionaryItem<TKey, TValue>[] Contents => _cachedContents ?? (_cachedContents = _dictionary.Select((KeyValuePair<TKey, TValue> kv) => new DebugViewDictionaryItem<TKey, TValue>(kv)).ToArray(_dictionary.Count));

		public ImmutableDictionaryDebuggerProxy(IReadOnlyDictionary<TKey, TValue> dictionary)
		{
			Requires.NotNull(dictionary, "dictionary");
			_dictionary = dictionary;
		}
	}
	internal class ImmutableEnumerableDebuggerProxy<T>
	{
		private readonly IEnumerable<T> _enumerable;

		private T[] _cachedContents;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Contents => _cachedContents ?? (_cachedContents = _enumerable.ToArray());

		public ImmutableEnumerableDebuggerProxy(IEnumerable<T> enumerable)
		{
			Requires.NotNull(enumerable, "enumerable");
			_enumerable = enumerable;
		}
	}
	internal static class ImmutableExtensions
	{
		private sealed class ListOfTWrapper<T> : IOrderedCollection<T>, IEnumerable<T>, IEnumerable
		{
			private readonly IList<T> _collection;

			public int Count => _collection.Count;

			public T this[int index] => _collection[index];

			internal ListOfTWrapper(IList<T> collection)
			{
				Requires.NotNull(collection, "collection");
				_collection = collection;
			}

			public IEnumerator<T> GetEnumerator()
			{
				return _collection.GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		private sealed class FallbackWrapper<T> : IOrderedCollection<T>, IEnumerable<T>, IEnumerable
		{
			private readonly IEnumerable<T> _sequence;

			private IList<T> _collection;

			public int Count
			{
				get
				{
					if (_collection == null)
					{
						if (_sequence.TryGetCount(out var count))
						{
							return count;
						}
						_collection = _sequence.ToArray();
					}
					return _collection.Count;
				}
			}

			public T this[int index]
			{
				get
				{
					if (_collection == null)
					{
						_collection = _sequence.ToArray();
					}
					return _collection[index];
				}
			}

			internal FallbackWrapper(IEnumerable<T> sequence)
			{
				Requires.NotNull(sequence, "sequence");
				_sequence = sequence;
			}

			public IEnumerator<T> GetEnumerator()
			{
				return _sequence.GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		internal static bool IsValueType<T>()
		{
			if (default(T) != null)
			{
				return true;
			}
			Type typeFromHandle = typeof(T);
			if (typeFromHandle.IsConstructedGenericType && typeFromHandle.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
				return true;
			}
			return false;
		}

		internal static IOrderedCollection<T> AsOrderedCollection<T>(this IEnumerable<T> sequence)
		{
			Requires.NotNull(sequence, "sequence");
			if (sequence is IOrderedCollection<T> result)
			{
				return result;
			}
			if (sequence is IList<T> collection)
			{
				return new ListOfTWrapper<T>(collection);
			}
			return new FallbackWrapper<T>(sequence);
		}

		internal static void ClearFastWhenEmpty<T>(this Stack<T> stack)
		{
			if (stack.Count > 0)
			{
				stack.Clear();
			}
		}

		internal static DisposableEnumeratorAdapter<T, TEnumerator> GetEnumerableDisposable<T, TEnumerator>(this IEnumerable<T> enumerable) where TEnumerator : struct, IStrongEnumerator<T>, IEnumerator<T>
		{
			Requires.NotNull(enumerable, "enumerable");
			if (enumerable is IStrongEnumerable<T, TEnumerator> strongEnumerable)
			{
				return new DisposableEnumeratorAdapter<T, TEnumerator>(strongEnumerable.GetEnumerator());
			}
			return new DisposableEnumeratorAdapter<T, TEnumerator>(enumerable.GetEnumerator());
		}

		internal static bool TryGetCount<T>(this IEnumerable<T> sequence, out int count)
		{
			return ((IEnumerable)sequence).TryGetCount<T>(out count);
		}

		internal static bool TryGetCount<T>(this IEnumerable sequence, out int count)
		{
			if (sequence is ICollection collection)
			{
				count = collection.Count;
				return true;
			}
			if (sequence is ICollection<T> collection2)
			{
				count = collection2.Count;
				return true;
			}
			if (sequence is IReadOnlyCollection<T> readOnlyCollection)
			{
				count = readOnlyCollection.Count;
				return true;
			}
			count = 0;
			return false;
		}

		internal static int GetCount<T>(ref IEnumerable<T> sequence)
		{
			if (!sequence.TryGetCount(out var count))
			{
				List<T> list = sequence.ToList();
				count = list.Count;
				sequence = list;
			}
			return count;
		}

		internal static bool TryCopyTo<T>(this IEnumerable<T> sequence, T[] array, int arrayIndex)
		{
			if (sequence is IList<T>)
			{
				if (sequence is List<T> list)
				{
					list.CopyTo(array, arrayIndex);
					return true;
				}
				if (sequence.GetType() == typeof(T[]))
				{
					T[] array2 = (T[])sequence;
					Array.Copy(array2, 0, array, arrayIndex, array2.Length);
					return true;
				}
				if (sequence is ImmutableArray<T> immutableArray)
				{
					Array.Copy(immutableArray.array, 0, array, arrayIndex, immutableArray.Length);
					return true;
				}
			}
			return false;
		}

		internal static T[] ToArray<T>(this IEnumerable<T> sequence, int count)
		{
			Requires.NotNull(sequence, "sequence");
			Requires.Range(count >= 0, "count");
			if (count == 0)
			{
				return ImmutableArray<T>.Empty.array;
			}
			T[] array = new T[count];
			if (!sequence.TryCopyTo(array, 0))
			{
				int num = 0;
				foreach (T item in sequence)
				{
					Requires.Argument(num < count);
					array[num++] = item;
				}
				Requires.Argument(num == count);
			}
			return array;
		}
	}
	public static class ImmutableHashSet
	{
		public static ImmutableHashSet<T> Create<T>()
		{
			return ImmutableHashSet<T>.Empty;
		}

		public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T>? equalityComparer)
		{
			return ImmutableHashSet<T>.Empty.WithComparer(equalityComparer);
		}

		public static ImmutableHashSet<T> Create<T>(T item)
		{
			return ImmutableHashSet<T>.Empty.Add(item);
		}

		public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T>? equalityComparer, T item)
		{
			return ImmutableHashSet<T>.Empty.WithComparer(equalityComparer).Add(item);
		}

		public static ImmutableHashSet<T> CreateRange<T>(IEnumerable<T> items)
		{
			return ImmutableHashSet<T>.Empty.Union(items);
		}

		public static ImmutableHashSet<T> CreateRange<T>(IEqualityComparer<T>? equalityComparer, IEnumerable<T> items)
		{
			return ImmutableHashSet<T>.Empty.WithComparer(equalityComparer).Union(items);
		}

		public static ImmutableHashSet<T> Create<T>(params T[] items)
		{
			Requires.NotNull(items, "items");
			return Create((ReadOnlySpan<T>)items);
		}

		public static ImmutableHashSet<T> Create<T>([ParamCollection] scoped ReadOnlySpan<T> items)
		{
			return ImmutableHashSet<T>.Empty.Union(items);
		}

		public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T>? equalityComparer, params T[] items)
		{
			Requires.NotNull(items, "items");
			return Create(equalityComparer, (ReadOnlySpan<T>)items);
		}

		public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T>? equalityComparer, [ParamCollection] scoped ReadOnlySpan<T> items)
		{
			return ImmutableHashSet<T>.Empty.WithComparer(equalityComparer).Union(items);
		}

		public static ImmutableHashSet<T>.Builder CreateBuilder<T>()
		{
			return Create<T>().ToBuilder();
		}

		public static ImmutableHashSet<T>.Builder CreateBuilder<T>(IEqualityComparer<T>? equalityComparer)
		{
			return Create(equalityComparer).ToBuilder();
		}

		public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource>? equalityComparer)
		{
			if (source is ImmutableHashSet<TSource> immutableHashSet)
			{
				return immutableHashSet.WithComparer(equalityComparer);
			}
			return ImmutableHashSet<TSource>.Empty.WithComparer(equalityComparer).Union(source);
		}

		public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this ImmutableHashSet<TSource>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this IEnumerable<TSource> source)
		{
			return source.ToImmutableHashSet(null);
		}
	}
	public static class ImmutableInterlocked
	{
		public static bool Update<T>(ref T location, Func<T, T> transformer) where T : class?
		{
			Requires.NotNull(transformer, "transformer");
			T val = Volatile.Read(ref location);
			bool flag;
			do
			{
				T val2 = transformer(val);
				if (val == val2)
				{
					return false;
				}
				T val3 = Interlocked.CompareExchange(ref location, val2, val);
				flag = val == val3;
				val = val3;
			}
			while (!flag);
			return true;
		}

		public static bool Update<T, TArg>(ref T location, Func<T, TArg, T> transformer, TArg transformerArgument) where T : class?
		{
			Requires.NotNull(transformer, "transformer");
			T val = Volatile.Read(ref location);
			bool flag;
			do
			{
				T val2 = transformer(val, transformerArgument);
				if (val == val2)
				{
					return false;
				}
				T val3 = Interlocked.CompareExchange(ref location, val2, val);
				flag = val == val3;
				val = val3;
			}
			while (!flag);
			return true;
		}

		public static bool Update<T>(ref ImmutableArray<T> location, Func<ImmutableArray<T>, ImmutableArray<T>> transformer)
		{
			Requires.NotNull(transformer, "transformer");
			T[] array = Volatile.Read(ref Unsafe.AsRef(in location.array));
			bool flag;
			do
			{
				ImmutableArray<T> immutableArray = transformer(new ImmutableArray<T>(array));
				if (array == immutableArray.array)
				{
					return false;
				}
				T[] array2 = Interlocked.CompareExchange(ref Unsafe.AsRef(in location.array), immutableArray.array, array);
				flag = array == array2;
				array = array2;
			}
			while (!flag);
			return true;
		}

		public static bool Update<T, TArg>(ref ImmutableArray<T> location, Func<ImmutableArray<T>, TArg, ImmutableArray<T>> transformer, TArg transformerArgument)
		{
			Requires.NotNull(transformer, "transformer");
			T[] array = Volatile.Read(ref Unsafe.AsRef(in location.array));
			bool flag;
			do
			{
				ImmutableArray<T> immutableArray = transformer(new ImmutableArray<T>(array), transformerArgument);
				if (array == immutableArray.array)
				{
					return false;
				}
				T[] array2 = Interlocked.CompareExchange(ref Unsafe.AsRef(in location.array), immutableArray.array, array);
				flag = array == array2;
				array = array2;
			}
			while (!flag);
			return true;
		}

		public static ImmutableArray<T> InterlockedExchange<T>(ref ImmutableArray<T> location, ImmutableArray<T> value)
		{
			return new ImmutableArray<T>(Interlocked.Exchange(ref Unsafe.AsRef(in location.array), value.array));
		}

		public static ImmutableArray<T> InterlockedCompareExchange<T>(ref ImmutableArray<T> location, ImmutableArray<T> value, ImmutableArray<T> comparand)
		{
			return new ImmutableArray<T>(Interlocked.CompareExchange(ref Unsafe.AsRef(in location.array), value.array, comparand.array));
		}

		public static bool InterlockedInitialize<T>(ref ImmutableArray<T> location, ImmutableArray<T> value)
		{
			return InterlockedCompareExchange(ref location, value, default(ImmutableArray<T>)).IsDefault;
		}

		public static TValue GetOrAdd<TKey, TValue, TArg>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) where TKey : notnull
		{
			Requires.NotNull(valueFactory, "valueFactory");
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			Requires.NotNull(immutableDictionary, "location");
			if (immutableDictionary.TryGetValue(key, out TValue value))
			{
				return value;
			}
			value = valueFactory(key, factoryArgument);
			return GetOrAdd(ref location, key, value);
		}

		public static TValue GetOrAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TValue> valueFactory) where TKey : notnull
		{
			Requires.NotNull(valueFactory, "valueFactory");
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			Requires.NotNull(immutableDictionary, "location");
			if (immutableDictionary.TryGetValue(key, out TValue value))
			{
				return value;
			}
			value = valueFactory(key);
			return GetOrAdd(ref location, key, value);
		}

		public static TValue GetOrAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue value) where TKey : notnull
		{
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				if (immutableDictionary.TryGetValue(key, out var value2))
				{
					return value2;
				}
				ImmutableDictionary<TKey, TValue> value3 = immutableDictionary.Add(key, value);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value3, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return value;
		}

		public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory) where TKey : notnull
		{
			Requires.NotNull(addValueFactory, "addValueFactory");
			Requires.NotNull(updateValueFactory, "updateValueFactory");
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			TValue val;
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				val = ((!immutableDictionary.TryGetValue(key, out var value)) ? addValueFactory(key) : updateValueFactory(key, value));
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = immutableDictionary.SetItem(key, val);
				if (immutableDictionary == immutableDictionary2)
				{
					return value;
				}
				ImmutableDictionary<TKey, TValue> immutableDictionary3 = Interlocked.CompareExchange(ref location, immutableDictionary2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary3;
				immutableDictionary = immutableDictionary3;
			}
			while (!flag);
			return val;
		}

		public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory) where TKey : notnull
		{
			Requires.NotNull(updateValueFactory, "updateValueFactory");
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			TValue val;
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				val = (TValue)((!immutableDictionary.TryGetValue(key, out var value)) ? ((object)addValue) : ((object)updateValueFactory(key, value)));
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = immutableDictionary.SetItem(key, val);
				if (immutableDictionary == immutableDictionary2)
				{
					return value;
				}
				ImmutableDictionary<TKey, TValue> immutableDictionary3 = Interlocked.CompareExchange(ref location, immutableDictionary2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary3;
				immutableDictionary = immutableDictionary3;
			}
			while (!flag);
			return val;
		}

		public static bool TryAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue value) where TKey : notnull
		{
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				if (immutableDictionary.ContainsKey(key))
				{
					return false;
				}
				ImmutableDictionary<TKey, TValue> value2 = immutableDictionary.Add(key, value);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return true;
		}

		public static bool TryUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue newValue, TValue comparisonValue) where TKey : notnull
		{
			EqualityComparer<TValue> @default = EqualityComparer<TValue>.Default;
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				if (!immutableDictionary.TryGetValue(key, out var value) || !@default.Equals(value, comparisonValue))
				{
					return false;
				}
				ImmutableDictionary<TKey, TValue> value2 = immutableDictionary.SetItem(key, newValue);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return true;
		}

		public static bool TryRemove<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, [MaybeNullWhen(false)] out TValue value) where TKey : notnull
		{
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				if (!immutableDictionary.TryGetValue(key, out value))
				{
					return false;
				}
				ImmutableDictionary<TKey, TValue> value2 = immutableDictionary.Remove(key);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return true;
		}

		public static bool TryPop<T>(ref ImmutableStack<T> location, [MaybeNullWhen(false)] out T value)
		{
			ImmutableStack<T> immutableStack = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableStack, "location");
				if (immutableStack.IsEmpty)
				{
					value = default(T);
					return false;
				}
				ImmutableStack<T> value2 = immutableStack.Pop(out value);
				ImmutableStack<T> immutableStack2 = Interlocked.CompareExchange(ref location, value2, immutableStack);
				flag = immutableStack == immutableStack2;
				immutableStack = immutableStack2;
			}
			while (!flag);
			return true;
		}

		public static void Push<T>(ref ImmutableStack<T> location, T value)
		{
			ImmutableStack<T> immutableStack = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableStack, "location");
				ImmutableStack<T> value2 = immutableStack.Push(value);
				ImmutableStack<T> immutableStack2 = Interlocked.CompareExchange(ref location, value2, immutableStack);
				flag = immutableStack == immutableStack2;
				immutableStack = immutableStack2;
			}
			while (!flag);
		}

		public static bool TryDequeue<T>(ref ImmutableQueue<T> location, [MaybeNullWhen(false)] out T value)
		{
			ImmutableQueue<T> immutableQueue = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableQueue, "location");
				if (immutableQueue.IsEmpty)
				{
					value = default(T);
					return false;
				}
				ImmutableQueue<T> value2 = immutableQueue.Dequeue(out value);
				ImmutableQueue<T> immutableQueue2 = Interlocked.CompareExchange(ref location, value2, immutableQueue);
				flag = immutableQueue == immutableQueue2;
				immutableQueue = immutableQueue2;
			}
			while (!flag);
			return true;
		}

		public static void Enqueue<T>(ref ImmutableQueue<T> location, T value)
		{
			ImmutableQueue<T> immutableQueue = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableQueue, "location");
				ImmutableQueue<T> value2 = immutableQueue.Enqueue(value);
				ImmutableQueue<T> immutableQueue2 = Interlocked.CompareExchange(ref location, value2, immutableQueue);
				flag = immutableQueue == immutableQueue2;
				immutableQueue = immutableQueue2;
			}
			while (!flag);
		}
	}
	public static class ImmutableList
	{
		public static ImmutableList<T> Create<T>()
		{
			return ImmutableList<T>.Empty;
		}

		public static ImmutableList<T> Create<T>(T item)
		{
			return ImmutableList<T>.Empty.Add(item);
		}

		public static ImmutableList<T> CreateRange<T>(IEnumerable<T> items)
		{
			return ImmutableList<T>.Empty.AddRange(items);
		}

		public static ImmutableList<T> Create<T>(params T[] items)
		{
			Requires.NotNull(items, "items");
			return Create((ReadOnlySpan<T>)items);
		}

		public static ImmutableList<T> Create<T>([ParamCollection] scoped ReadOnlySpan<T> items)
		{
			return ImmutableList<T>.Empty.AddRange(items);
		}

		public static ImmutableList<T>.Builder CreateBuilder<T>()
		{
			return Create<T>().ToBuilder();
		}

		public static ImmutableList<TSource> ToImmutableList<TSource>(this IEnumerable<TSource> source)
		{
			if (source is ImmutableList<TSource> result)
			{
				return result;
			}
			return ImmutableList<TSource>.Empty.AddRange(source);
		}

		public static ImmutableList<TSource> ToImmutableList<TSource>(this ImmutableList<TSource>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static IImmutableList<T> Replace<T>(this IImmutableList<T> list, T oldValue, T newValue)
		{
			Requires.NotNull(list, "list");
			return list.Replace(oldValue, newValue, EqualityComparer<T>.Default);
		}

		public static IImmutableList<T> Remove<T>(this IImmutableList<T> list, T value)
		{
			Requires.NotNull(list, "list");
			return list.Remove(value, EqualityComparer<T>.Default);
		}

		public static IImmutableList<T> RemoveRange<T>(this IImmutableList<T> list, IEnumerable<T> items)
		{
			Requires.NotNull(list, "list");
			return list.RemoveRange(items, EqualityComparer<T>.Default);
		}

		public static int IndexOf<T>(this IImmutableList<T> list, T item)
		{
			Requires.NotNull(list, "list");
			return list.IndexOf(item, 0, list.Count, EqualityComparer<T>.Default);
		}

		public static int IndexOf<T>(this IImmutableList<T> list, T item, IEqualityComparer<T>? equalityComparer)
		{
			Requires.NotNull(list, "list");
			return list.IndexOf(item, 0, list.Count, equalityComparer);
		}

		public static int IndexOf<T>(this IImmutableList<T> list, T item, int startIndex)
		{
			Requires.NotNull(list, "list");
			return list.IndexOf(item, startIndex, list.Count - startIndex, EqualityComparer<T>.Default);
		}

		public static int IndexOf<T>(this IImmutableList<T> list, T item, int startIndex, int count)
		{
			Requires.NotNull(list, "list");
			return list.IndexOf(item, startIndex, count, EqualityComparer<T>.Default);
		}

		public static int LastIndexOf<T>(this IImmutableList<T> list, T item)
		{
			Requires.NotNull(list, "list");
			if (list.Count == 0)
			{
				return -1;
			}
			return list.LastIndexOf(item, list.Count - 1, list.Count, EqualityComparer<T>.Default);
		}

		public static int LastIndexOf<T>(this IImmutableList<T> list, T item, IEqualityComparer<T>? equalityComparer)
		{
			Requires.NotNull(list, "list");
			if (list.Count == 0)
			{
				return -1;
			}
			return list.LastIndexOf(item, list.Count - 1, list.Count, equalityComparer);
		}

		public static int LastIndexOf<T>(this IImmutableList<T> list, T item, int startIndex)
		{
			Requires.NotNull(list, "list");
			if (list.Count == 0 && startIndex == 0)
			{
				return -1;
			}
			return list.LastIndexOf(item, startIndex, startIndex + 1, EqualityComparer<T>.Default);
		}

		public static int LastIndexOf<T>(this IImmutableList<T> list, T item, int startIndex, int count)
		{
			Requires.NotNull(list, "list");
			return list.LastIndexOf(item, startIndex, count, EqualityComparer<T>.Default);
		}
	}
	[CollectionBuilder(typeof(ImmutableList), "Create")]
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	public sealed class ImmutableList<T> : IImmutableList<T>, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, IList<T>, ICollection<T>, IList, ICollection, IOrderedCollection<T>, IImmutableListQueries<T>, IStrongEnumerable<T, ImmutableList<T>.Enumerator>
	{
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(ImmutableListBuilderDebuggerProxy<>))]
		public sealed class Builder : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IOrderedCollection<T>, IImmutableListQueries<T>, IReadOnlyList<T>, IReadOnlyCollection<T>
		{
			private Node _root = Node.EmptyNode;

			private ImmutableList<T> _immutable;

			private int _version;

			private object _syncRoot;

			public int Count => Root.Count;

			bool ICollection<T>.IsReadOnly => false;

			internal int Version => _version;

			internal Node Root
			{
				get
				{
					return _root;
				}
				private set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			public T this[int index]
			{
				get
				{
					return Root.ItemRef(index);
				}
				set
				{
					Root = Root.ReplaceAt(index, value);
				}
			}

			T IOrderedCollection<T>.this[int index] => this[index];

			bool IList.IsFixedSize => false;

			bool IList.IsReadOnly => false;

			object? IList.this[int index]
			{
				get
				{
					return this[index];
				}
				set
				{
					this[index] = (T)value;
				}
			}

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			bool ICollection.IsSynchronized => false;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			object ICollection.SyncRoot
			{
				get
				{
					if (_syncRoot == null)
					{
						Interlocked.CompareExchange<object>(ref _syncRoot, new object(), (object)null);
					}
					return _syncRoot;
				}
			}

			internal Builder(ImmutableList<T> list)
			{
				Requires.NotNull(list, "list");
				_root = list._root;
				_immutable = list;
			}

			public ref readonly T ItemRef(int index)
			{
				return ref Root.ItemRef(index);
			}

			public int IndexOf(T item)
			{
				return Root.IndexOf(item, EqualityComparer<T>.Default);
			}

			public void Insert(int index, T item)
			{
				Root = Root.Insert(index, item);
			}

			public void RemoveAt(int index)
			{
				Root = Root.RemoveAt(index);
			}

			public void Add(T item)
			{
				Root = Root.Add(item);
			}

			public void Clear()
			{
				Root = Node.EmptyNode;
			}

			public bool Contains(T item)
			{
				return IndexOf(item) >= 0;
			}

			public bool Remove(T item)
			{
				int num = IndexOf(item);
				if (num < 0)
				{
					return false;
				}
				Root = Root.RemoveAt(num);
				return true;
			}

			public ImmutableList<T>.Enumerator GetEnumerator()
			{
				return Root.GetEnumerator(this);
			}

			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public void ForEach(Action<T> action)
			{
				Requires.NotNull(action, "action");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					action(current);
				}
			}

			public void CopyTo(T[] array)
			{
				_root.CopyTo(array);
			}

			public void CopyTo(T[] array, int arrayIndex)
			{
				_root.CopyTo(array, arrayIndex);
			}

			public void CopyTo(int index, T[] array, int arrayIndex, int count)
			{
				_root.CopyTo(index, array, arrayIndex, count);
			}

			public ImmutableList<T> GetRange(int index, int count)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "count");
				return ImmutableList<T>.WrapNode(Node.NodeTreeFromList(this, index, count));
			}

			public ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter)
			{
				Requires.NotNull(converter, "converter");
				return ImmutableList<TOutput>.WrapNode(_root.ConvertAll(converter));
			}

			public bool Exists(Predicate<T> match)
			{
				return _root.Exists(match);
			}

			public T? Find(Predicate<T> match)
			{
				return _root.Find(match);
			}

			public ImmutableList<T> FindAll(Predicate<T> match)
			{
				return _root.FindAll(match);
			}

			public int FindIndex(Predicate<T> match)
			{
				return _root.FindIndex(match);
			}

			public int FindIndex(int startIndex, Predicate<T> match)
			{
				return _root.FindIndex(startIndex, match);
			}

			public int FindIndex(int startIndex, int count, Predicate<T> match)
			{
				return _root.FindIndex(startIndex, count, match);
			}

			public T? FindLast(Predicate<T> match)
			{
				return _root.FindLast(match);
			}

			public int FindLastIndex(Predicate<T> match)
			{
				return _root.FindLastIndex(match);
			}

			public int FindLastIndex(int startIndex, Predicate<T> match)
			{
				return _root.FindLastIndex(startIndex, match);
			}

			public int FindLastIndex(int startIndex, int count, Predicate<T> match)
			{
				return _root.FindLastIndex(startIndex, count, match);
			}

			public int IndexOf(T item, int index)
			{
				return _root.IndexOf(item, index, Count - index, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int index, int count)
			{
				return _root.IndexOf(item, index, count, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int index, int count, IEqualityComparer<T>? equalityComparer)
			{
				return _root.IndexOf(item, index, count, equalityComparer);
			}

			public int LastIndexOf(T item)
			{
				if (Count == 0)
				{
					return -1;
				}
				return _root.LastIndexOf(item, Count - 1, Count, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex)
			{
				if (Count == 0 && startIndex == 0)
				{
					return -1;
				}
				return _root.LastIndexOf(item, startIndex, startIndex + 1, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex, int count)
			{
				return _root.LastIndexOf(item, startIndex, count, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T>? equalityComparer)
			{
				return _root.LastIndexOf(item, startIndex, count, equalityComparer);
			}

			public bool TrueForAll(Predicate<T> match)
			{
				return _root.TrueForAll(match);
			}

			public void AddRange(IEnumerable<T> items)
			{
				Requires.NotNull(items, "items");
				Root = Root.AddRange(items);
			}

			public void InsertRange(int index, IEnumerable<T> items)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				Requires.NotNull(items, "items");
				Root = Root.InsertRange(index, items);
			}

			public int RemoveAll(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				int count = Count;
				Root = Root.RemoveAll(match);
				return count - Count;
			}

			public bool Remove(T item, IEqualityComparer<T>? equalityComparer)
			{
				int num = IndexOf(item, 0, Count, equalityComparer);
				if (num >= 0)
				{
					RemoveAt(num);
					return true;
				}
				return false;
			}

			public void RemoveRange(int index, int count)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				Requires.Range(count >= 0 && index <= Count - count, "count");
				int num = count;
				while (num-- > 0)
				{
					RemoveAt(index);
				}
			}

			public void RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer)
			{
				Requires.NotNull(items, "items");
				foreach (T item in items.GetEnumerableDisposable<T, Enumerator>())
				{
					int num = Root.IndexOf(item, equalityComparer);
					if (num >= 0)
					{
						RemoveAt(num);
					}
				}
			}

			public void RemoveRange(IEnumerable<T> items)
			{
				RemoveRange(items, EqualityComparer<T>.Default);
			}

			public void Replace(T oldValue, T newValue)
			{
				Replace(oldValue, newValue, EqualityComparer<T>.Default);
			}

			public void Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer)
			{
				int num = IndexOf(oldValue, 0, Count, equalityComparer);
				if (num < 0)
				{
					throw new ArgumentException(System.SR.CannotFindOldValue, "oldValue");
				}
				Root = Root.ReplaceAt(num, newValue);
			}

			public void Reverse()
			{
				Reverse(0, Count);
			}

			public void Reverse(int index, int count)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "count");
				Root = Root.Reverse(index, count);
			}

			public void Sort()
			{
				Root = Root.Sort();
			}

			public void Sort(Comparison<T> comparison)
			{
				Requires.NotNull(comparison, "comparison");
				Root = Root.Sort(comparison);
			}

			public void Sort(IComparer<T>? comparer)
			{
				Root = Root.Sort(comparer);
			}

			public void Sort(int index, int count, IComparer<T>? comparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "count");
				Root = Root.Sort(index, count, comparer);
			}

			public int BinarySearch(T item)
			{
				return BinarySearch(item, null);
			}

			public int BinarySearch(T item, IComparer<T>? comparer)
			{
				return BinarySearch(0, Count, item, comparer);
			}

			public int BinarySearch(int index, int count, T item, IComparer<T>? comparer)
			{
				return Root.BinarySearch(index, count, item, comparer);
			}

			public ImmutableList<T> ToImmutable()
			{
				return _immutable ?? (_immutable = ImmutableList<T>.WrapNode(Root));
			}

			int IList.Add(object value)
			{
				Add((T)value);
				return Count - 1;
			}

			void IList.Clear()
			{
				Clear();
			}

			bool IList.Contains(object value)
			{
				if (ImmutableList<T>.IsCompatibleObject(value))
				{
					return Contains((T)value);
				}
				return false;
			}

			int IList.IndexOf(object value)
			{
				if (ImmutableList<T>.IsCompatibleObject(value))
				{
					return IndexOf((T)value);
				}
				return -1;
			}

			void IList.Insert(int index, object value)
			{
				Insert(index, (T)value);
			}

			void IList.Remove(object value)
			{
				if (ImmutableList<T>.IsCompatibleObject(value))
				{
					Remove((T)value);
				}
			}

			void ICollection.CopyTo(Array array, int arrayIndex)
			{
				Root.CopyTo(array, arrayIndex);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable, ISecurePooledObjectUser, IStrongEnumerator<T>
		{
			private readonly Builder _builder;

			private readonly int _poolUserId;

			private readonly int _startIndex;

			private readonly int _count;

			private int _remainingCount;

			private readonly bool _reversed;

			private Node _root;

			private SecurePooledObject<Stack<RefAsValueType<Node>>> _stack;

			private Node _current;

			private int _enumeratingBuilderVersion;

			int ISecurePooledObjectUser.PoolUserId => _poolUserId;

			public T Current
			{
				get
				{
					ThrowIfDisposed();
					if (_current != null)
					{
						return _current.Value;
					}
					throw new InvalidOperationException();
				}
			}

			object? IEnumerator.Current => Current;

			internal Enumerator(Node root, Builder? builder = null, int startIndex = -1, int count = -1, bool reversed = false)
			{
				Requires.NotNull(root, "root");
				Requires.Range(startIndex >= -1, "startIndex");
				Requires.Range(count >= -1, "count");
				Requires.Argument(reversed || count == -1 || ((startIndex != -1) ? startIndex : 0) + count <= root.Count);
				Requires.Argument(!reversed || count == -1 || ((startIndex == -1) ? (root.Count - 1) : startIndex) - count + 1 >= 0);
				_root = root;
				_builder = builder;
				_current = null;
				_startIndex = ((startIndex >= 0) ? startIndex : (reversed ? (root.Count - 1) : 0));
				_count = ((count == -1) ? root.Count : count);
				_remainingCount = _count;
				_reversed = reversed;
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
				_poolUserId = SecureObjectPool.NewId();
				_stack = null;
				if (_count > 0)
				{
					if (!SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>.TryTake(this, out _stack))
					{
						_stack = SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>.PrepNew(this, new Stack<RefAsValueType<Node>>(root.Height));
					}
					ResetStack();
				}
			}

			public void Dispose()
			{
				_root = null;
				_current = null;
				if (_stack != null && _stack.TryUse(ref this, out var value))
				{
					value.ClearFastWhenEmpty();
					SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>.TryAdd(this, _stack);
				}
				_stack = null;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				ThrowIfChanged();
				if (_stack != null)
				{
					Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
					if (_remainingCount > 0 && stack.Count > 0)
					{
						PushNext(NextBranch(_current = stack.Pop().Value));
						_remainingCount--;
						return true;
					}
				}
				_current = null;
				return false;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_remainingCount = _count;
				if (_stack != null)
				{
					ResetStack();
				}
			}

			private void ResetStack()
			{
				Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
				stack.ClearFastWhenEmpty();
				Node node = _root;
				int num = (_reversed ? (_root.Count - _startIndex - 1) : _startIndex);
				while (!node.IsEmpty && num != PreviousBranch(node).Count)
				{
					if (num < PreviousBranch(node).Count)
					{
						stack.Push(new RefAsValueType<Node>(node));
						node = PreviousBranch(node);
					}
					else
					{
						num -= PreviousBranch(node).Count + 1;
						node = NextBranch(node);
					}
				}
				if (!node.IsEmpty)
				{
					stack.Push(new RefAsValueType<Node>(node));
				}
			}

			private Node NextBranch(Node node)
			{
				if (!_reversed)
				{
					return node.Right;
				}
				return node.Left;
			}

			private Node PreviousBranch(Node node)
			{
				if (!_reversed)
				{
					return node.Left;
				}
				return node.Right;
			}

			private void ThrowIfDisposed()
			{
				if (_root == null || (_stack != null && !_stack.IsOwned(ref this)))
				{
					Requires.FailObjectDisposed(this);
				}
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}

			private void PushNext(Node node)
			{
				Requires.NotNull(node, "node");
				if (!node.IsEmpty)
				{
					Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
					while (!node.IsEmpty)
					{
						stack.Push(new RefAsValueType<Node>(node));
						node = PreviousBranch(node);
					}
				}
			}
		}

		[DebuggerDisplay("{_key}")]
		internal sealed class Node : IBinaryTree<T>, IBinaryTree, IEnumerable<T>, IEnumerable
		{
			internal static readonly Node EmptyNode = new Node();

			private T _key;

			private bool _frozen;

			private byte _height;

			private int _count;

			private Node _left;

			private Node _right;

			public bool IsEmpty => _left == null;

			public int Height => _height;

			public Node? Left => _left;

			IBinaryTree? IBinaryTree.Left => _left;

			public Node? Right => _right;

			IBinaryTree? IBinaryTree.Right => _right;

			IBinaryTree<T>? IBinaryTree<T>.Left => _left;

			IBinaryTree<T>? IBinaryTree<T>.Right => _right;

			public T Value => _key;

			public int Count => _count;

			internal T Key => _key;

			internal T this[int index]
			{
				get
				{
					Requires.Range(index >= 0 && index < Count, "index");
					if (index < _left._count)
					{
						return _left[index];
					}
					if (index > _left._count)
					{
						return _right[index - _left._count - 1];
					}
					return _key;
				}
			}

			private int BalanceFactor => _right._height - _left._height;

			private bool IsRightHeavy => BalanceFactor >= 2;

			private bool IsLeftHeavy => BalanceFactor <= -2;

			private bool IsBalanced => (uint)(BalanceFactor + 1) <= 2u;

			private Node()
			{
				_frozen = true;
			}

			private Node(T key, Node left, Node right, bool frozen = false)
			{
				Requires.NotNull(left, "left");
				Requires.NotNull(right, "right");
				_key = key;
				_left = left;
				_right = right;
				_height = ParentHeight(left, right);
				_count = ParentCount(left, right);
				_frozen = frozen;
			}

			internal ref readonly T ItemRef(int index)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				return ref ItemRefUnchecked(index);
			}

			private ref readonly T ItemRefUnchecked(int index)
			{
				if (index < _left._count)
				{
					return ref _left.ItemRefUnchecked(index);
				}
				if (index > _left._count)
				{
					return ref _right.ItemRefUnchecked(index - _left._count - 1);
				}
				return ref _key;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			[ExcludeFromCodeCoverage]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			[ExcludeFromCodeCoverage]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			internal Enumerator GetEnumerator(Builder builder)
			{
				return new Enumerator(this, builder);
			}

			internal static Node NodeTreeFromList(IOrderedCollection<T> items, int start, int length)
			{
				Requires.NotNull(items, "items");
				Requires.Range(start >= 0, "start");
				Requires.Range(length >= 0, "length");
				if (length == 0)
				{
					return EmptyNode;
				}
				int num = (length - 1) / 2;
				int num2 = length - 1 - num;
				Node left = NodeTreeFromList(items, start, num2);
				Node right = NodeTreeFromList(items, start + num2 + 1, num);
				return new Node(items[start + num2], left, right, frozen: true);
			}

			internal static Node NodeTreeFromList(ReadOnlySpan<T> items)
			{
				if (items.IsEmpty)
				{
					return EmptyNode;
				}
				int num = (items.Length - 1) / 2;
				int num2 = items.Length - 1 - num;
				Node left = NodeTreeFromList(items.Slice(0, num2));
				Node right = NodeTreeFromList(items.Slice(num2 + 1));
				return new Node(items[num2], left, right, frozen: true);
			}

			internal Node Add(T key)
			{
				if (IsEmpty)
				{
					return CreateLeaf(key);
				}
				Node right = _right.Add(key);
				Node node = MutateRight(right);
				if (!node.IsBalanced)
				{
					return node.BalanceRight();
				}
				return node;
			}

			internal Node Insert(int index, T key)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				if (IsEmpty)
				{
					return CreateLeaf(key);
				}
				if (index <= _left._count)
				{
					Node left = _left.Insert(index, key);
					Node node = MutateLeft(left);
					if (!node.IsBalanced)
					{
						return node.BalanceLeft();
					}
					return node;
				}
				Node right = _right.Insert(index - _left._count - 1, key);
				Node node2 = MutateRight(right);
				if (!node2.IsBalanced)
				{
					return node2.BalanceRight();
				}
				return node2;
			}

			internal Node AddRange(IEnumerable<T> keys)
			{
				Requires.NotNull(keys, "keys");
				if (IsEmpty)
				{
					return CreateRange(keys);
				}
				Node right = _right.AddRange(keys);
				return MutateRight(right).BalanceMany();
			}

			internal Node AddRange(ReadOnlySpan<T> keys)
			{
				if (IsEmpty)
				{
					return NodeTreeFromList(keys);
				}
				Node right = _right.AddRange(keys);
				return MutateRight(right).BalanceMany();
			}

			internal Node InsertRange(int index, IEnumerable<T> keys)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				Requires.NotNull(keys, "keys");
				if (IsEmpty)
				{
					return CreateRange(keys);
				}
				Node node;
				if (index <= _left._count)
				{
					Node left = _left.InsertRange(index, keys);
					node = MutateLeft(left);
				}
				else
				{
					Node right = _right.InsertRange(index - _left._count - 1, keys);
					node = MutateRight(right);
				}
				return node.BalanceMany();
			}

			internal Node RemoveAt(int index)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				Node node;
				if (index == _left._count)
				{
					if (_right.IsEmpty && _left.IsEmpty)
					{
						node = EmptyNode;
					}
					else if (_right.IsEmpty && !_left.IsEmpty)
					{
						node = _left;
					}
					else if (!_right.IsEmpty && _left.IsEmpty)
					{
						node = _right;
					}
					else
					{
						Node node2 = _right;
						while (!node2._left.IsEmpty)
						{
							node2 = node2._left;
						}
						Node right = _right.RemoveAt(0);
						node = node2.MutateBoth(_left, right);
					}
				}
				else if (index < _left._count)
				{
					Node left = _left.RemoveAt(index);
					node = MutateLeft(left);
				}
				else
				{
					Node right2 = _right.RemoveAt(index - _left._count - 1);
					node = MutateRight(right2);
				}
				if (!node.IsEmpty && !node.IsBalanced)
				{
					return node.Balance();
				}
				return node;
			}

			internal Node RemoveAll(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Node node = this;
				Enumerator enumerator = new Enumerator(node);
				try
				{
					int num = 0;
					while (enumerator.MoveNext())
					{
						if (match(enumerator.Current))
						{
							node = node.RemoveAt(num);
							enumerator.Dispose();
							enumerator = new Enumerator(node, null, num);
						}
						else
						{
							num++;
						}
					}
					return node;
				}
				finally
				{
					enumerator.Dispose();
				}
			}

			internal Node ReplaceAt(int index, T value)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				if (index == _left._count)
				{
					return MutateKey(value);
				}
				if (index < _left._count)
				{
					Node left = _left.ReplaceAt(index, value);
					return MutateLeft(left);
				}
				Node right = _right.ReplaceAt(index - _left._count - 1, value);
				return MutateRight(right);
			}

			internal Node Reverse()
			{
				return Reverse(0, Count);
			}

			internal Node Reverse(int index, int count)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "index");
				Node node = this;
				int num = index;
				int num2 = index + count - 1;
				while (num < num2)
				{
					T value = node.ItemRef(num);
					T value2 = node.ItemRef(num2);
					node = node.ReplaceAt(num2, value).ReplaceAt(num, value2);
					num++;
					num2--;
				}
				return node;
			}

			internal Node Sort()
			{
				return Sort(Comparer<T>.Default);
			}

			internal Node Sort(Comparison<T> comparison)
			{
				Requires.NotNull(comparison, "comparison");
				T[] array = new T[Count];
				CopyTo(array);
				Array.Sort(array, comparison);
				return NodeTreeFromList(array.AsOrderedCollection(), 0, Count);
			}

			internal Node Sort(IComparer<T>? comparer)
			{
				return Sort(0, Count, comparer);
			}

			internal Node Sort(int index, int count, IComparer<T>? comparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Argument(index + count <= Count);
				T[] array = new T[Count];
				CopyTo(array);
				Array.Sort(array, index, count, comparer);
				return NodeTreeFromList(array.AsOrderedCollection(), 0, Count);
			}

			internal int BinarySearch(int index, int count, T item, IComparer<T>? comparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				if (comparer == null)
				{
					comparer = Comparer<T>.Default;
				}
				if (IsEmpty || count <= 0)
				{
					return ~index;
				}
				int count2 = _left.Count;
				if (index + count <= count2)
				{
					return _left.BinarySearch(index, count, item, comparer);
				}
				if (index > count2)
				{
					int num = _right.BinarySearch(index - count2 - 1, count, item, comparer);
					int num2 = count2 + 1;
					if (num >= 0)
					{
						return num + num2;
					}
					return num - num2;
				}
				int num3 = comparer.Compare(item, _key);
				if (num3 == 0)
				{
					return count2;
				}
				if (num3 > 0)
				{
					int num4 = count - (count2 - index) - 1;
					int num5 = ((num4 < 0) ? (-1) : _right.BinarySearch(0, num4, item, comparer));
					int num6 = count2 + 1;
					if (num5 >= 0)
					{
						return num5 + num6;
					}
					return num5 - num6;
				}
				if (index == count2)
				{
					return ~index;
				}
				return _left.BinarySearch(index, count, item, comparer);
			}

			internal int IndexOf(T item, IEqualityComparer<T>? equalityComparer)
			{
				return IndexOf(item, 0, Count, equalityComparer);
			}

			internal bool Contains(T item, IEqualityComparer<T> equalityComparer)
			{
				return Contains(this, item, equalityComparer);
			}

			internal int IndexOf(T item, int index, int count, IEqualityComparer<T>? equalityComparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(count <= Count, "count");
				Requires.Range(index + count <= Count, "count");
				if (equalityComparer == null)
				{
					equalityComparer = EqualityComparer<T>.Default;
				}
				using (Enumerator enumerator = new Enumerator(this, null, index, count))
				{
					while (enumerator.MoveNext())
					{
						if (equalityComparer.Equals(item, enumerator.Current))
						{
							return index;
						}
						index++;
					}
				}
				return -1;
			}

			internal int LastIndexOf(T item, int index, int count, IEqualityComparer<T>? equalityComparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0 && count <= Count, "count");
				Requires.Argument(index - count + 1 >= 0);
				if (equalityComparer == null)
				{
					equalityComparer = EqualityComparer<T>.Default;
				}
				using (Enumerator enumerator = new Enumerator(this, null, index, count, reversed: true))
				{
					while (enumerator.MoveNext())
					{
						if (equalityComparer.Equals(item, enumerator.Current))
						{
							return index;
						}
						index--;
					}
				}
				return -1;
			}

			internal void CopyTo(T[] array)
			{
				Requires.NotNull(array, "array");
				Requires.Range(array.Length >= Count, "array");
				int num = 0;
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array[num++] = current;
				}
			}

			internal void CopyTo(T[] array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			internal void CopyTo(int index, T[] array, int arrayIndex, int count)
			{
				Requires.NotNull(array, "array");
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "count");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(arrayIndex + count <= array.Length, "arrayIndex");
				using Enumerator enumerator = new Enumerator(this, null, index, count);
				while (enumerator.MoveNext())
				{
					array[arrayIndex++] = enumerator.Current;
				}
			}

			internal void CopyTo(Array array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array.SetValue(current, arrayIndex++);
				}
			}

			internal ImmutableList<TOutput>.Node ConvertAll<TOutput>(Func<T, TOutput> converter)
			{
				ImmutableList<TOutput>.Node emptyNode = ImmutableList<TOutput>.Node.EmptyNode;
				if (IsEmpty)
				{
					return emptyNode;
				}
				return emptyNode.AddRange(this.Select(converter));
			}

			internal bool TrueForAll(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						T current = enumerator.Current;
						if (!match(current))
						{
							return false;
						}
					}
				}
				return true;
			}

			internal bool Exists(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						T current = enumerator.Current;
						if (match(current))
						{
							return true;
						}
					}
				}
				return false;
			}

			internal T? Find(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						T current = enumerator.Current;
						if (match(current))
						{
							return current;
						}
					}
				}
				return default(T);
			}

			internal ImmutableList<T> FindAll(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				if (IsEmpty)
				{
					return ImmutableList<T>.Empty;
				}
				List<T> list = null;
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						T current = enumerator.Current;
						if (match(current))
						{
							if (list == null)
							{
								list = new List<T>();
							}
							list.Add(current);
						}
					}
				}
				if (list == null)
				{
					return ImmutableList<T>.Empty;
				}
				return ImmutableList.CreateRange(list);
			}

			internal int FindIndex(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				return FindIndex(0, _count, match);
			}

			internal int FindIndex(int startIndex, Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Requires.Range(startIndex >= 0 && startIndex <= Count, "startIndex");
				return FindIndex(startIndex, Count - startIndex, match);
			}

			internal int FindIndex(int startIndex, int count, Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Requires.Range(startIndex >= 0, "startIndex");
				Requires.Range(count >= 0, "count");
				Requires.Range(startIndex <= Count - count, "count");
				using (Enumerator enumerator = new Enumerator(this, null, startIndex, count))
				{
					int num = startIndex;
					while (enumerator.MoveNext())
					{
						if (match(enumerator.Current))
						{
							return num;
						}
						num++;
					}
				}
				return -1;
			}

			internal T? FindLast(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				using (Enumerator enumerator = new Enumerator(this, null, -1, -1, reversed: true))
				{
					while (enumerator.MoveNext())
					{
						if (match(enumerator.Current))
						{
							return enumerator.Current;
						}
					}
				}
				return default(T);
			}

			internal int FindLastIndex(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				if (!IsEmpty)
				{
					return FindLastIndex(Count - 1, Count, match);
				}
				return -1;
			}

			internal int FindLastIndex(int startIndex, Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Requires.Range(startIndex >= 0, "startIndex");
				Requires.Range(startIndex == 0 || startIndex < Count, "startIndex");
				if (!IsEmpty)
				{
					return FindLastIndex(startIndex, startIndex + 1, match);
				}
				return -1;
			}

			internal int FindLastIndex(int startIndex, int count, Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Requires.Range(startIndex >= 0, "startIndex");
				Requires.Range(count <= Count, "count");
				Requires.Range(startIndex - count + 1 >= 0, "startIndex");
				using (Enumerator enumerator = new Enumerator(this, null, startIndex, count, reversed: true))
				{
					int num = startIndex;
					while (enumerator.MoveNext())
					{
						if (match(enumerator.Current))
						{
							return num;
						}
						num--;
					}
				}
				return -1;
			}

			internal void Freeze()
			{
				if (!_frozen)
				{
					_left.Freeze();
					_right.Freeze();
					_frozen = true;
				}
			}

			private Node RotateLeft()
			{
				return _right.MutateLeft(MutateRight(_right._left));
			}

			private Node RotateRight()
			{
				return _left.MutateRight(MutateLeft(_left._right));
			}

			private Node DoubleLeft()
			{
				Node right = _right;
				Node left = right._left;
				return left.MutateBoth(MutateRight(left._left), right.MutateLeft(left._right));
			}

			private Node DoubleRight()
			{
				Node left = _left;
				Node right = left._right;
				return right.MutateBoth(left.MutateRight(right._left), MutateLeft(right._right));
			}

			private Node Balance()
			{
				if (!IsLeftHeavy)
				{
					return BalanceRight();
				}
				return BalanceLeft();
			}

			private Node BalanceLeft()
			{
				if (_left.BalanceFactor <= 0)
				{
					return RotateRight();
				}
				return DoubleRight();
			}

			private Node BalanceRight()
			{
				if (_right.BalanceFactor >= 0)
				{
					return RotateLeft();
				}
				return DoubleLeft();
			}

			private Node BalanceMany()
			{
				Node node = this;
				while (!node.IsBalanced)
				{
					if (node.IsRightHeavy)
					{
						node = node.BalanceRight();
						node.MutateLeft(node._left.BalanceMany());
					}
					else
					{
						node = node.BalanceLeft();
						node.MutateRight(node._right.BalanceMany());
					}
				}
				return node;
			}

			private Node MutateBoth(Node left, Node right)
			{
				Requires.NotNull(left, "left");
				Requires.NotNull(right, "right");
				if (_frozen)
				{
					return new Node(_key, left, right);
				}
				_left = left;
				_right = right;
				_height = ParentHeight(left, right);
				_count = ParentCount(left, right);
				return this;
			}

			private Node MutateLeft(Node left)
			{
				Requires.NotNull(left, "left");
				if (_frozen)
				{
					return new Node(_key, left, _right);
				}
				_left = left;
				_height = ParentHeight(left, _right);
				_count = ParentCount(left, _right);
				return this;
			}

			private Node MutateRight(Node right)
			{
				Requires.NotNull(right, "right");
				if (_frozen)
				{
					return new Node(_key, _left, right);
				}
				_right = right;
				_height = ParentHeight(_left, right);
				_count = ParentCount(_left, right);
				return this;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static byte ParentHeight(Node left, Node right)
			{
				return checked((byte)(1 + Math.Max(left._height, right._height)));
			}

			private static int ParentCount(Node left, Node right)
			{
				return 1 + left._count + right._count;
			}

			private Node MutateKey(T key)
			{
				if (_frozen)
				{
					return new Node(key, _left, _right);
				}
				_key = key;
				return this;
			}

			private static Node CreateRange(IEnumerable<T> keys)
			{
				if (ImmutableList<T>.TryCastToImmutableList(keys, out ImmutableList<T> other))
				{
					return other._root;
				}
				IOrderedCollection<T> orderedCollection = keys.AsOrderedCollection();
				return NodeTreeFromList(orderedCollection, 0, orderedCollection.Count);
			}

			private static Node CreateLeaf(T key)
			{
				return new Node(key, EmptyNode, EmptyNode);
			}

			private static bool Contains(Node node, T value, IEqualityComparer<T> equalityComparer)
			{
				if (!node.IsEmpty)
				{
					if (!equalityComparer.Equals(value, node._key) && !Contains(node._left, value, equalityComparer))
					{
						return Contains(node._right, value, equalityComparer);
					}
					return true;
				}
				return false;
			}
		}

		public static readonly ImmutableList<T> Empty = new ImmutableList<T>();

		private readonly Node _root;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsEmpty => _root.IsEmpty;

		public int Count => _root.Count;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		public T this[int index] => _root.ItemRef(index);

		T IOrderedCollection<T>.this[int index] => this[index];

		T IList<T>.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		bool ICollection<T>.IsReadOnly => true;

		bool IList.IsFixedSize => true;

		bool IList.IsReadOnly => true;

		object? IList.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		internal Node Root => _root;

		internal ImmutableList()
		{
			_root = Node.EmptyNode;
		}

		private ImmutableList(Node root)
		{
			Requires.NotNull(root, "root");
			root.Freeze();
			_root = root;
		}

		public ImmutableList<T> Clear()
		{
			return Empty;
		}

		public int BinarySearch(T item)
		{
			return BinarySearch(item, null);
		}

		public int BinarySearch(T item, IComparer<T>? comparer)
		{
			return BinarySearch(0, Count, item, comparer);
		}

		public int BinarySearch(int index, int count, T item, IComparer<T>? comparer)
		{
			return _root.BinarySearch(index, count, item, comparer);
		}

		IImmutableList<T> IImmutableList<T>.Clear()
		{
			return Clear();
		}

		public ref readonly T ItemRef(int index)
		{
			return ref _root.ItemRef(index);
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableList<T> Add(T value)
		{
			Node root = _root.Add(value);
			return Wrap(root);
		}

		public ImmutableList<T> AddRange(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			if (IsEmpty)
			{
				return CreateRange(items);
			}
			Node root = _root.AddRange(items);
			return Wrap(root);
		}

		internal ImmutableList<T> AddRange(ReadOnlySpan<T> items)
		{
			if (IsEmpty)
			{
				if (items.IsEmpty)
				{
					return Empty;
				}
				return new ImmutableList<T>(Node.NodeTreeFromList(items));
			}
			if (items.IsEmpty)
			{
				return this;
			}
			return Wrap(_root.AddRange(items));
		}

		public ImmutableList<T> Insert(int index, T item)
		{
			Requires.Range(index >= 0 && index <= Count, "index");
			return Wrap(_root.Insert(index, item));
		}

		public ImmutableList<T> InsertRange(int index, IEnumerable<T> items)
		{
			Requires.Range(index >= 0 && index <= Count, "index");
			Requires.NotNull(items, "items");
			Node root = _root.InsertRange(index, items);
			return Wrap(root);
		}

		public ImmutableList<T> Remove(T value)
		{
			return Remove(value, EqualityComparer<T>.Default);
		}

		public ImmutableList<T> Remove(T value, IEqualityComparer<T>? equalityComparer)
		{
			int num = this.IndexOf(value, equalityComparer);
			if (num >= 0)
			{
				return RemoveAt(num);
			}
			return this;
		}

		public ImmutableList<T> RemoveRange(int index, int count)
		{
			Requires.Range(index >= 0 && index <= Count, "index");
			Requires.Range(count >= 0 && index <= Count - count, "count");
			Node node = _root;
			int num = count;
			while (num-- > 0)
			{
				node = node.RemoveAt(index);
			}
			return Wrap(node);
		}

		public ImmutableList<T> RemoveRange(IEnumerable<T> items)
		{
			return RemoveRange(items, EqualityComparer<T>.Default);
		}

		public ImmutableList<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer)
		{
			Requires.NotNull(items, "items");
			if (IsEmpty)
			{
				return this;
			}
			Node node = _root;
			foreach (T item in items.GetEnumerableDisposable<T, Enumerator>())
			{
				int num = node.IndexOf(item, equalityComparer);
				if (num >= 0)
				{
					node = node.RemoveAt(num);
				}
			}
			return Wrap(node);
		}

		public ImmutableList<T> RemoveAt(int index)
		{
			Requires.Range(index >= 0 && index < Count, "index");
			Node root = _root.RemoveAt(index);
			return Wrap(root);
		}

		public ImmutableList<T> RemoveAll(Predicate<T> match)
		{
			Requires.NotNull(match, "match");
			return Wrap(_root.RemoveAll(match));
		}

		public ImmutableList<T> SetItem(int index, T value)
		{
			return Wrap(_root.ReplaceAt(index, value));
		}

		public ImmutableList<T> Replace(T oldValue, T newValue)
		{
			return Replace(oldValue, newValue, EqualityComparer<T>.Default);
		}

		public ImmutableList<T> Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer)
		{
			int num = this.IndexOf(oldValue, equalityComparer);
			if (num < 0)
			{
				throw new ArgumentException(System.SR.CannotFindOldValue, "oldValue");
			}
			return SetItem(num, newValue);
		}

		public ImmutableList<T> Reverse()
		{
			return Wrap(_root.Reverse());
		}

		public ImmutableList<T> Reverse(int index, int count)
		{
			return Wrap(_root.Reverse(index, count));
		}

		public ImmutableList<T> Sort()
		{
			return Wrap(_root.Sort());
		}

		public ImmutableList<T> Sort(Comparison<T> comparison)
		{
			Requires.NotNull(comparison, "comparison");
			return Wrap(_root.Sort(comparison));
		}

		public ImmutableList<T> Sort(IComparer<T>? comparer)
		{
			return Wrap(_root.Sort(comparer));
		}

		public ImmutableList<T> Sort(int index, int count, IComparer<T>? comparer)
		{
			Requires.Range(index >= 0, "index");
			Requires.Range(count >= 0, "count");
			Requires.Range(index + count <= Count, "count");
			return Wrap(_root.Sort(index, count, comparer));
		}

		public void ForEach(Action<T> action)
		{
			Requires.NotNull(action, "action");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				action(current);
			}
		}

		public void CopyTo(T[] array)
		{
			_root.CopyTo(array);
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			_root.CopyTo(array, arrayIndex);
		}

		public void CopyTo(int index, T[] array, int arrayIndex, int count)
		{
			_root.CopyTo(index, array, arrayIndex, count);
		}

		public ImmutableList<T> GetRange(int index, int count)
		{
			Requires.Range(index >= 0, "index");
			Requires.Range(count >= 0, "count");
			Requires.Range(index + count <= Count, "count");
			return Wrap(Node.NodeTreeFromList(this, index, count));
		}

		public ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter)
		{
			Requires.NotNull(converter, "converter");
			return ImmutableList<TOutput>.WrapNode(_root.ConvertAll(converter));
		}

		public bool Exists(Predicate<T> match)
		{
			return _root.Exists(match);
		}

		public T? Find(Predicate<T> match)
		{
			return _root.Find(match);
		}

		public ImmutableList<T> FindAll(Predicate<T> match)
		{
			return _root.FindAll(match);
		}

		public int FindIndex(Predicate<T> match)
		{
			return _root.FindIndex(match);
		}

		public int FindIndex(int startIndex, Predicate<T> match)
		{
			return _root.FindIndex(startIndex, match);
		}

		public int FindIndex(int startIndex, int count, Predicate<T> match)
		{
			return _root.FindIndex(startIndex, count, match);
		}

		public T? FindLast(Predicate<T> match)
		{
			return _root.FindLast(match);
		}

		public int FindLastIndex(Predicate<T> match)
		{
			return _root.FindLastIndex(match);
		}

		public int FindLastIndex(int startIndex, Predicate<T> match)
		{
			return _root.FindLastIndex(startIndex, match);
		}

		public int FindLastIndex(int startIndex, int count, Predicate<T> match)
		{
			return _root.FindLastIndex(startIndex, count, match);
		}

		public int IndexOf(T item, int index, int count, IEqualityComparer<T>? equalityComparer)
		{
			return _root.IndexOf(item, index, count, equalityComparer);
		}

		public int LastIndexOf(T item, int index, int count, IEqualityComparer<T>? equalityComparer)
		{
			return _root.LastIndexOf(item, index, count, equalityComparer);
		}

		public bool TrueForAll(Predicate<T> match)
		{
			return _root.TrueForAll(match);
		}

		public bool Contains(T value)
		{
			return _root.Contains(value, EqualityComparer<T>.Default);
		}

		public int IndexOf(T value)
		{
			return this.IndexOf(value, EqualityComparer<T>.Default);
		}

		IImmutableList<T> IImmutableList<T>.Add(T value)
		{
			return Add(value);
		}

		IImmutableList<T> IImmutableList<T>.AddRange(IEnumerable<T> items)
		{
			return AddRange(items);
		}

		IImmutableList<T> IImmutableList<T>.Insert(int index, T item)
		{
			return Insert(index, item);
		}

		IImmutableList<T> IImmutableList<T>.InsertRange(int index, IEnumerable<T> items)
		{
			return InsertRange(index, items);
		}

		IImmutableList<T> IImmutableList<T>.Remove(T value, IEqualityComparer<T> equalityComparer)
		{
			return Remove(value, equalityComparer);
		}

		IImmutableList<T> IImmutableList<T>.RemoveAll(Predicate<T> match)
		{
			return RemoveAll(match);
		}

		IImmutableList<T> IImmutableList<T>.RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer)
		{
			return RemoveRange(items, equalityComparer);
		}

		IImmutableList<T> IImmutableList<T>.RemoveRange(int index, int count)
		{
			return RemoveRange(index, count);
		}

		IImmutableList<T> IImmutableList<T>.RemoveAt(int index)
		{
			return RemoveAt(index);
		}

		IImmutableList<T> IImmutableList<T>.SetItem(int index, T value)
		{
			return SetItem(index, value);
		}

		IImmutableList<T> IImmutableList<T>.Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer)
		{
			return Replace(oldValue, newValue, equalityComparer);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void IList<T>.Insert(int index, T item)
		{
			throw new NotSupportedException();
		}

		void IList<T>.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<T>.Remove(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			_root.CopyTo(array, arrayIndex);
		}

		int IList.Add(object value)
		{
			throw new NotSupportedException();
		}

		void IList.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		void IList.Clear()
		{
			throw new NotSupportedException();
		}

		bool IList.Contains(object value)
		{
			if (IsCompatibleObject(value))
			{
				return Contains((T)value);
			}
			return false;
		}

		int IList.IndexOf(object value)
		{
			if (!IsCompatibleObject(value))
			{
				return -1;
			}
			return IndexOf((T)value);
		}

		void IList.Insert(int index, object value)
		{
			throw new NotSupportedException();
		}

		void IList.Remove(object value)
		{
			throw new NotSupportedException();
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(_root);
		}

		private static ImmutableList<T> WrapNode(Node root)
		{
			if (!root.IsEmpty)
			{
				return new ImmutableList<T>(root);
			}
			return Empty;
		}

		private static bool TryCastToImmutableList(IEnumerable<T> sequence, [NotNullWhen(true)] out ImmutableList<T> other)
		{
			other = sequence as ImmutableList<T>;
			if (other != null)
			{
				return true;
			}
			if (sequence is Builder builder)
			{
				other = builder.ToImmutable();
				return true;
			}
			return false;
		}

		private static bool IsCompatibleObject(object value)
		{
			if (!(value is T))
			{
				if (default(T) == null)
				{
					return value == null;
				}
				return false;
			}
			return true;
		}

		private ImmutableList<T> Wrap(Node root)
		{
			if (root != _root)
			{
				if (!root.IsEmpty)
				{
					return new ImmutableList<T>(root);
				}
				return Clear();
			}
			return this;
		}

		private static ImmutableList<T> CreateRange(IEnumerable<T> items)
		{
			if (TryCastToImmutableList(items, out var other))
			{
				return other;
			}
			IOrderedCollection<T> orderedCollection = items.AsOrderedCollection();
			if (orderedCollection.Count == 0)
			{
				return Empty;
			}
			return new ImmutableList<T>(Node.NodeTreeFromList(orderedCollection, 0, orderedCollection.Count));
		}
	}
	internal sealed class ImmutableListBuilderDebuggerProxy<T>
	{
		private readonly ImmutableList<T>.Builder _list;

		private T[] _cachedContents;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Contents => _cachedContents ?? (_cachedContents = _list.ToArray(_list.Count));

		public ImmutableListBuilderDebuggerProxy(ImmutableList<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			_list = builder;
		}
	}
	public static class ImmutableQueue
	{
		public static ImmutableQueue<T> Create<T>()
		{
			return ImmutableQueue<T>.Empty;
		}

		public static ImmutableQueue<T> Create<T>(T item)
		{
			return ImmutableQueue<T>.Empty.Enqueue(item);
		}

		public static ImmutableQueue<T> CreateRange<T>(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			if (items is T[] items2)
			{
				return Create(items2);
			}
			using IEnumerator<T> enumerator = items.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				return ImmutableQueue<T>.Empty;
			}
			ImmutableStack<T> forwards = ImmutableStack.Create(enumerator.Current);
			ImmutableStack<T> immutableStack = ImmutableStack<T>.Empty;
			while (enumerator.MoveNext())
			{
				immutableStack = immutableStack.Push(enumerator.Current);
			}
			return new ImmutableQueue<T>(forwards, immutableStack);
		}

		public static ImmutableQueue<T> Create<T>(params T[] items)
		{
			Requires.NotNull(items, "items");
			return Create((ReadOnlySpan<T>)items);
		}

		public static ImmutableQueue<T> Create<T>([ParamCollection] scoped ReadOnlySpan<T> items)
		{
			if (items.IsEmpty)
			{
				return ImmutableQueue<T>.Empty;
			}
			ImmutableStack<T> immutableStack = ImmutableStack<T>.Empty;
			for (int num = items.Length - 1; num >= 0; num--)
			{
				immutableStack = immutableStack.Push(items[num]);
			}
			return new ImmutableQueue<T>(immutableStack, ImmutableStack<T>.Empty);
		}

		public static IImmutableQueue<T> Dequeue<T>(this IImmutableQueue<T> queue, out T value)
		{
			Requires.NotNull(queue, "queue");
			value = queue.Peek();
			return queue.Dequeue();
		}
	}
	[CollectionBuilder(typeof(ImmutableQueue), "Create")]
	[DebuggerDisplay("IsEmpty = {IsEmpty}")]
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	public sealed class ImmutableQueue<T> : IImmutableQueue<T>, IEnumerable<T>, IEnumerable
	{
		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator
		{
			private readonly ImmutableQueue<T> _originalQueue;

			private ImmutableStack<T> _remainingForwardsStack;

			private ImmutableStack<T> _remainingBackwardsStack;

			public T Current
			{
				get
				{
					if (_remainingForwardsStack == null)
					{
						throw new InvalidOperationException();
					}
					if (!_remainingForwardsStack.IsEmpty)
					{
						return _remainingForwardsStack.Peek();
					}
					if (!_remainingBackwardsStack.IsEmpty)
					{
						return _remainingBackwardsStack.Peek();
					}
					throw new InvalidOperationException();
				}
			}

			internal Enumerator(ImmutableQueue<T> queue)
			{
				_originalQueue = queue;
				_remainingForwardsStack = null;
				_remainingBackwardsStack = null;
			}

			public bool MoveNext()
			{
				if (_remainingForwardsStack == null)
				{
					_remainingForwardsStack = _originalQueue._forwards;
					_remainingBackwardsStack = _originalQueue.BackwardsReversed;
				}
				else if (!_remainingForwardsStack.IsEmpty)
				{
					_remainingForwardsStack = _remainingForwardsStack.Pop();
				}
				else if (!_remainingBackwardsStack.IsEmpty)
				{
					_remainingBackwardsStack = _remainingBackwardsStack.Pop();
				}
				if (_remainingForwardsStack.IsEmpty)
				{
					return !_remainingBackwardsStack.IsEmpty;
				}
				return true;
			}
		}

		private sealed class EnumeratorObject : IEnumerator<T>, IEnumerator, IDisposable
		{
			private readonly ImmutableQueue<T> _originalQueue;

			private ImmutableStack<T> _remainingForwardsStack;

			private ImmutableStack<T> _remainingBackwardsStack;

			private bool _disposed;

			public T Current
			{
				get
				{
					ThrowIfDisposed();
					if (_remainingForwardsStack == null)
					{
						throw new InvalidOperationException();
					}
					if (!_remainingForwardsStack.IsEmpty)
					{
						return _remainingForwardsStack.Peek();
					}
					if (!_remainingBackwardsStack.IsEmpty)
					{
						return _remainingBackwardsStack.Peek();
					}
					throw new InvalidOperationException();
				}
			}

			object IEnumerator.Current => Current;

			internal EnumeratorObject(ImmutableQueue<T> queue)
			{
				_originalQueue = queue;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				if (_remainingForwardsStack == null)
				{
					_remainingForwardsStack = _originalQueue._forwards;
					_remainingBackwardsStack = _originalQueue.BackwardsReversed;
				}
				else if (!_remainingForwardsStack.IsEmpty)
				{
					_remainingForwardsStack = _remainingForwardsStack.Pop();
				}
				else if (!_remainingBackwardsStack.IsEmpty)
				{
					_remainingBackwardsStack = _remainingBackwardsStack.Pop();
				}
				if (_remainingForwardsStack.IsEmpty)
				{
					return !_remainingBackwardsStack.IsEmpty;
				}
				return true;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_remainingBackwardsStack = null;
				_remainingForwardsStack = null;
			}

			public void Dispose()
			{
				_disposed = true;
			}

			private void ThrowIfDisposed()
			{
				if (_disposed)
				{
					Requires.FailObjectDisposed(this);
				}
			}
		}

		private static readonly ImmutableQueue<T> s_EmptyField = new ImmutableQueue<T>(ImmutableStack<T>.Empty, ImmutableStack<T>.Empty);

		private readonly ImmutableStack<T> _backwards;

		private readonly ImmutableStack<T> _forwards;

		private ImmutableStack<T> _backwardsReversed;

		public bool IsEmpty => _forwards.IsEmpty;

		public static ImmutableQueue<T> Empty => s_EmptyField;

		private ImmutableStack<T> BackwardsReversed
		{
			get
			{
				if (_backwardsReversed == null)
				{
					_backwardsReversed = _backwards.Reverse();
				}
				return _backwardsReversed;
			}
		}

		internal ImmutableQueue(ImmutableStack<T> forwards, ImmutableStack<T> backwards)
		{
			_forwards = forwards;
			_backwards = backwards;
		}

		public ImmutableQueue<T> Clear()
		{
			return Empty;
		}

		IImmutableQueue<T> IImmutableQueue<T>.Clear()
		{
			return Clear();
		}

		public T Peek()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return _forwards.Peek();
		}

		public ref readonly T PeekRef()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return ref _forwards.PeekRef();
		}

		public ImmutableQueue<T> Enqueue(T value)
		{
			if (IsEmpty)
			{
				return new ImmutableQueue<T>(ImmutableStack.Create(value), ImmutableStack<T>.Empty);
			}
			return new ImmutableQueue<T>(_forwards, _backwards.Push(value));
		}

		IImmutableQueue<T> IImmutableQueue<T>.Enqueue(T value)
		{
			return Enqueue(value);
		}

		public ImmutableQueue<T> Dequeue()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			ImmutableStack<T> immutableStack = _forwards.Pop();
			if (!immutableStack.IsEmpty)
			{
				return new ImmutableQueue<T>(immutableStack, _backwards);
			}
			if (_backwards.IsEmpty)
			{
				return Empty;
			}
			return new ImmutableQueue<T>(BackwardsReversed, ImmutableStack<T>.Empty);
		}

		public ImmutableQueue<T> Dequeue(out T value)
		{
			value = Peek();
			return Dequeue();
		}

		IImmutableQueue<T> IImmutableQueue<T>.Dequeue()
		{
			return Dequeue();
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return new EnumeratorObject(this);
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new EnumeratorObject(this);
		}
	}
	public static class ImmutableSortedDictionary
	{
		public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>() where TKey : notnull
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty;
		}

		public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey>? keyComparer) where TKey : notnull
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer);
		}

		public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer) where TKey : notnull
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer);
		}

		public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> items) where TKey : notnull
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.AddRange(items);
		}

		public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey>? keyComparer, IEnumerable<KeyValuePair<TKey, TValue>> items) where TKey : notnull
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer).AddRange(items);
		}

		public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer, IEnumerable<KeyValuePair<TKey, TValue>> items) where TKey : notnull
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(items);
		}

		public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>() where TKey : notnull
		{
			return Create<TKey, TValue>().ToBuilder();
		}

		public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IComparer<TKey>? keyComparer) where TKey : notnull
		{
			return Create<TKey, TValue>(keyComparer).ToBuilder();
		}

		public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer) where TKey : notnull
		{
			return Create(keyComparer, valueComparer).ToBuilder();
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer) where TKey : notnull
		{
			Func<TSource, TKey> keySelector2 = keySelector;
			Func<TSource, TValue> elementSelector2 = elementSelector;
			Requires.NotNull(source, "source");
			Requires.NotNull(keySelector2, "keySelector");
			Requires.NotNull(elementSelector2, "elementSelector");
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(source.Select((TSource element) => new KeyValuePair<TKey, TValue>(keySelector2(element), elementSelector2(element))));
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue>.Builder builder) where TKey : notnull
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IComparer<TKey>? keyComparer) where TKey : notnull
		{
			return source.ToImmutableSortedDictionary(keySelector, elementSelector, keyComparer, null);
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector) where TKey : notnull
		{
			return source.ToImmutableSortedDictionary(keySelector, elementSelector, null, null);
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer) where TKey : notnull
		{
			Requires.NotNull(source, "source");
			if (source is ImmutableSortedDictionary<TKey, TValue> immutableSortedDictionary)
			{
				return immutableSortedDictionary.WithComparers(keyComparer, valueComparer);
			}
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(source);
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IComparer<TKey>? keyComparer) where TKey : notnull
		{
			return source.ToImmutableSortedDictionary(keyComparer, null);
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source) where TKey : notnull
		{
			return source.ToImmutableSortedDictionary(null, null);
		}
	}
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(ImmutableDictionaryDebuggerProxy<, >))]
	public sealed class ImmutableSortedDictionary<TKey, TValue> : IImmutableDictionary<TKey, TValue>, IReadOnlyDictionary<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, ISortKeyCollection<TKey>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection where TKey : notnull
	{
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(System.Collections.Generic.IDictionaryDebugView<, >))]
		public sealed class Builder : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection
		{
			private Node _root = Node.EmptyNode;

			private IComparer<TKey> _keyComparer = Comparer<TKey>.Default;

			private IEqualityComparer<TValue> _valueComparer = EqualityComparer<TValue>.Default;

			private int _count;

			private ImmutableSortedDictionary<TKey, TValue> _immutable;

			private int _version;

			private object _syncRoot;

			ICollection<TKey> IDictionary<TKey, TValue>.Keys => Root.Keys.ToArray(Count);

			public IEnumerable<TKey> Keys => Root.Keys;

			ICollection<TValue> IDictionary<TKey, TValue>.Values => Root.Values.ToArray(Count);

			public IEnumerable<TValue> Values => Root.Values;

			public int Count => _count;

			bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false;

			internal int Version => _version;

			private Node Root
			{
				get
				{
					return _root;
				}
				set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			public TValue this[TKey key]
			{
				get
				{
					if (!TryGetValue(key, out var value))
					{
						ThrowHelper.ThrowKeyNotFoundException(key);
					}
					return value;
				}
				set
				{
					Root = _root.SetItem(key, value, _keyComparer, _valueComparer, out var replacedExistingValue, out var mutated);
					if (mutated && !replacedExistingValue)
					{
						_count++;
					}
				}
			}

			bool IDictionary.IsFixedSize => false;

			bool IDictionary.IsReadOnly => false;

			ICollection IDictionary.Keys => Keys.ToArray(Count);

			ICollection IDictionary.Values => Values.ToArray(Count);

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			object ICollection.SyncRoot
			{
				get
				{
					if (_syncRoot == null)
					{
						Interlocked.CompareExchange<object>(ref _syncRoot, new object(), (object)null);
					}
					return _syncRoot;
				}
			}

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			bool ICollection.IsSynchronized => false;

			public IComparer<TKey> KeyComparer
			{
				get
				{
					return _keyComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value == _keyComparer)
					{
						return;
					}
					Node node = Node.EmptyNode;
					int num = 0;
					using (Enumerator enumerator = GetEnumerator())
					{
						while (enumerator.MoveNext())
						{
							KeyValuePair<TKey, TValue> current = enumerator.Current;
							node = node.Add(current.Key, current.Value, value, _valueComparer, out var mutated);
							if (mutated)
							{
								num++;
							}
						}
					}
					_keyComparer = value;
					Root = node;
					_count = num;
				}
			}

			public IEqualityComparer<TValue> ValueComparer
			{
				get
				{
					return _valueComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value != _valueComparer)
					{
						_valueComparer = value;
						_immutable = null;
					}
				}
			}

			object? IDictionary.this[object key]
			{
				get
				{
					return this[(TKey)key];
				}
				set
				{
					this[(TKey)key] = (TValue)value;
				}
			}

			internal Builder(ImmutableSortedDictionary<TKey, TValue> map)
			{
				Requires.NotNull(map, "map");
				_root = map._root;
				_keyComparer = map.KeyComparer;
				_valueComparer = map.ValueComparer;
				_count = map.Count;
				_immutable = map;
			}

			public ref readonly TValue ValueRef(TKey key)
			{
				Requires.NotNullAllowStructs(key, "key");
				return ref _root.ValueRef(key, _keyComparer);
			}

			void IDictionary.Add(object key, object value)
			{
				Add((TKey)key, (TValue)value);
			}

			bool IDictionary.Contains(object key)
			{
				return ContainsKey((TKey)key);
			}

			IDictionaryEnumerator IDictionary.GetEnumerator()
			{
				return new DictionaryEnumerator<TKey, TValue>(GetEnumerator());
			}

			void IDictionary.Remove(object key)
			{
				Remove((TKey)key);
			}

			void ICollection.CopyTo(Array array, int index)
			{
				Root.CopyTo(array, index, Count);
			}

			public void Add(TKey key, TValue value)
			{
				Root = Root.Add(key, value, _keyComparer, _valueComparer, out var mutated);
				if (mutated)
				{
					_count++;
				}
			}

			public bool ContainsKey(TKey key)
			{
				return Root.ContainsKey(key, _keyComparer);
			}

			public bool Remove(TKey key)
			{
				Root = Root.Remove(key, _keyComparer, out var mutated);
				if (mutated)
				{
					_count--;
				}
				return mutated;
			}

			public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
			{
				return Root.TryGetValue(key, _keyComparer, out value);
			}

			public bool TryGetKey(TKey equalKey, out TKey actualKey)
			{
				Requires.NotNullAllowStructs(equalKey, "equalKey");
				return Root.TryGetKey(equalKey, _keyComparer, out actualKey);
			}

			public void Add(KeyValuePair<TKey, TValue> item)
			{
				Add(item.Key, item.Value);
			}

			public void Clear()
			{
				Root = Node.EmptyNode;
				_count = 0;
			}

			public bool Contains(KeyValuePair<TKey, TValue> item)
			{
				return Root.Contains(item, _keyComparer, _valueComparer);
			}

			void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
			{
				Root.CopyTo(array, arrayIndex, Count);
			}

			public bool Remove(KeyValuePair<TKey, TValue> item)
			{
				if (Contains(item))
				{
					return Remove(item.Key);
				}
				return false;
			}

			public ImmutableSortedDictionary<TKey, TValue>.Enumerator GetEnumerator()
			{
				return Root.GetEnumerator(this);
			}

			IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public bool ContainsValue(TValue value)
			{
				return _root.ContainsValue(value, _valueComparer);
			}

			public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items)
			{
				Requires.NotNull(items, "items");
				foreach (KeyValuePair<TKey, TValue> item in items)
				{
					Add(item);
				}
			}

			public void RemoveRange(IEnumerable<TKey> keys)
			{
				Requires.NotNull(keys, "keys");
				foreach (TKey key in keys)
				{
					Remove(key);
				}
			}

			public TValue? GetValueOrDefault(TKey key)
			{
				return GetValueOrDefault(key, default(TValue));
			}

			public TValue GetValueOrDefault(TKey key, TValue defaultValue)
			{
				Requires.NotNullAllowStructs(key, "key");
				if (TryGetValue(key, out var value))
				{
					return value;
				}
				return defaultValue;
			}

			public ImmutableSortedDictionary<TKey, TValue> ToImmutable()
			{
				return _immutable ?? (_immutable = ImmutableSortedDictionary<TKey, TValue>.Wrap(Root, _count, _keyComparer, _valueComparer));
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IEnumerator, IDisposable, ISecurePooledObjectUser
		{
			private readonly Builder _builder;

			private readonly int _poolUserId;

			private Node _root;

			private SecurePooledObject<Stack<RefAsValueType<Node>>> _stack;

			private Node _current;

			private int _enumeratingBuilderVersion;

			public KeyValuePair<TKey, TValue> Current
			{
				get
				{
					ThrowIfDisposed();
					if (_current != null)
					{
						return _current.Value;
					}
					throw new InvalidOperationException();
				}
			}

			int ISecurePooledObjectUser.PoolUserId => _poolUserId;

			object IEnumerator.Current => Current;

			internal Enumerator(Node root, Builder? builder = null)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_builder = builder;
				_current = null;
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
				_poolUserId = SecureObjectPool.NewId();
				_stack = null;
				if (!_root.IsEmpty)
				{
					if (!SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>.TryTake(this, out _stack))
					{
						_stack = SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>.PrepNew(this, new Stack<RefAsValueType<Node>>(root.Height));
					}
					PushLeft(_root);
				}
			}

			public void Dispose()
			{
				_root = null;
				_current = null;
				if (_stack != null && _stack.TryUse(ref this, out var value))
				{
					value.ClearFastWhenEmpty();
					SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>.TryAdd(this, _stack);
				}
				_stack = null;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				ThrowIfChanged();
				if (_stack != null)
				{
					Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
					if (stack.Count > 0)
					{
						PushLeft((_current = stack.Pop().Value).Right);
						return true;
					}
				}
				_current = null;
				return false;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_current = null;
				if (_stack != null)
				{
					_stack.Use(ref this).ClearFastWhenEmpty();
					PushLeft(_root);
				}
			}

			internal void ThrowIfDisposed()
			{
				if (_root == null || (_stack != null && !_stack.IsOwned(ref this)))
				{
					Requires.FailObjectDisposed(this);
				}
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}

			private void PushLeft(Node node)
			{
				Requires.NotNull(node, "node");
				Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
				while (!node.IsEmpty)
				{
					stack.Push(new RefAsValueType<Node>(node));
					node = node.Left;
				}
			}
		}

		[DebuggerDisplay("{_key} = {_value}")]
		internal sealed class Node : IBinaryTree<KeyValuePair<TKey, TValue>>, IBinaryTree, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
		{
			internal static readonly Node EmptyNode = new Node();

			private readonly TKey _key;

			private readonly TValue _value;

			private bool _frozen;

			private byte _height;

			private Node _left;

			private Node _right;

			public bool IsEmpty => _left == null;

			IBinaryTree<KeyValuePair<TKey, TValue>>? IBinaryTree<KeyValuePair<TKey, TValue>>.Left => _left;

			IBinaryTree<KeyValuePair<TKey, TValue>>? IBinaryTree<KeyValuePair<TKey, TValue>>.Right => _right;

			public int Height => _height;

			public Node? Left => _left;

			IBinaryTree? IBinaryTree.Left => _left;

			public Node? Right => _right;

			IBinaryTree? IBinaryTree.Right => _right;

			public KeyValuePair<TKey, TValue> Value => new KeyValuePair<TKey, TValue>(_key, _value);

			int IBinaryTree.Count
			{
				get
				{
					throw new NotSupportedException();
				}
			}

			internal IEnumerable<TKey> Keys => this.Select((KeyValuePair<TKey, TValue> p) => p.Key);

			internal IEnumerable<TValue> Values => this.Select((KeyValuePair<TKey, TValue> p) => p.Value);

			private Node()
			{
				_frozen = true;
			}

			private Node(TKey key, TValue value, Node left, Node right, bool frozen = false)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(left, "left");
				Requires.NotNull(right, "right");
				_key = key;
				_value = value;
				_left = left;
				_right = right;
				_height = checked((byte)(1 + Math.Max(left._height, right._height)));
				_frozen = frozen;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			internal Enumerator GetEnumerator(Builder builder)
			{
				return new Enumerator(this, builder);
			}

			internal void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex, int dictionarySize)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + dictionarySize, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			internal void CopyTo(Array array, int arrayIndex, int dictionarySize)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + dictionarySize, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					array.SetValue(new DictionaryEntry(current.Key, current.Value), arrayIndex++);
				}
			}

			internal static Node NodeTreeFromSortedDictionary(SortedDictionary<TKey, TValue> dictionary)
			{
				Requires.NotNull(dictionary, "dictionary");
				IOrderedCollection<KeyValuePair<TKey, TValue>> orderedCollection = dictionary.AsOrderedCollection();
				return NodeTreeFromList(orderedCollection, 0, orderedCollection.Count);
			}

			internal Node Add(TKey key, TValue value, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, out bool mutated)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				bool replacedExistingValue;
				return SetOrAdd(key, value, keyComparer, valueComparer, overwriteExistingValue: false, out replacedExistingValue, out mutated);
			}

			internal Node SetItem(TKey key, TValue value, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, out bool replacedExistingValue, out bool mutated)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				return SetOrAdd(key, value, keyComparer, valueComparer, overwriteExistingValue: true, out replacedExistingValue, out mutated);
			}

			internal Node Remove(TKey key, IComparer<TKey> keyComparer, out bool mutated)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				return RemoveRecursive(key, keyComparer, out mutated);
			}

			internal ref readonly TValue ValueRef(TKey key, IComparer<TKey> keyComparer)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				Node node = Search(key, keyComparer);
				if (node.IsEmpty)
				{
					ThrowHelper.ThrowKeyNotFoundException(key);
				}
				return ref node._value;
			}

			internal bool TryGetValue(TKey key, IComparer<TKey> keyComparer, [MaybeNullWhen(false)] out TValue value)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				Node node = Search(key, keyComparer);
				if (node.IsEmpty)
				{
					value = default(TValue);
					return false;
				}
				value = node._value;
				return true;
			}

			internal bool TryGetKey(TKey equalKey, IComparer<TKey> keyComparer, out TKey actualKey)
			{
				Requires.NotNullAllowStructs(equalKey, "equalKey");
				Requires.NotNull(keyComparer, "keyComparer");
				Node node = Search(equalKey, keyComparer);
				if (node.IsEmpty)
				{
					actualKey = equalKey;
					return false;
				}
				actualKey = node._key;
				return true;
			}

			internal bool ContainsKey(TKey key, IComparer<TKey> keyComparer)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				return !Search(key, keyComparer).IsEmpty;
			}

			internal bool ContainsValue(TValue value, IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNull(valueComparer, "valueComparer");
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						if (valueComparer.Equals(value, enumerator.Current.Value))
						{
							return true;
						}
					}
				}
				return false;
			}

			internal bool Contains(KeyValuePair<TKey, TValue> pair, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNullAllowStructs(pair.Key, "Key");
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				Node node = Search(pair.Key, keyComparer);
				if (node.IsEmpty)
				{
					return false;
				}
				return valueComparer.Equals(node._value, pair.Value);
			}

			internal void Freeze()
			{
				if (!_frozen)
				{
					_left.Freeze();
					_right.Freeze();
					_frozen = true;
				}
			}

			private static Node RotateLeft(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._right.IsEmpty)
				{
					return tree;
				}
				Node right = tree._right;
				return right.Mutate(tree.Mutate(null, right._left));
			}

			private static Node RotateRight(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._left.IsEmpty)
				{
					return tree;
				}
				Node left = tree._left;
				return left.Mutate(null, tree.Mutate(left._right));
			}

			private static Node DoubleLeft(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._right.IsEmpty)
				{
					return tree;
				}
				return RotateLeft(tree.Mutate(null, RotateRight(tree._right)));
			}

			private static Node DoubleRight(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._left.IsEmpty)
				{
					return tree;
				}
				return RotateRight(tree.Mutate(RotateLeft(tree._left)));
			}

			private static int Balance(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return tree._right._height - tree._left._height;
			}

			private static bool IsRightHeavy(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return Balance(tree) >= 2;
			}

			private static bool IsLeftHeavy(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return Balance(tree) <= -2;
			}

			private static Node MakeBalanced(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (IsRightHeavy(tree))
				{
					if (Balance(tree._right) >= 0)
					{
						return RotateLeft(tree);
					}
					return DoubleLeft(tree);
				}
				if (IsLeftHeavy(tree))
				{
					if (Balance(tree._left) <= 0)
					{
						return RotateRight(tree);
					}
					return DoubleRight(tree);
				}
				return tree;
			}

			private static Node NodeTreeFromList(IOrderedCollection<KeyValuePair<TKey, TValue>> items, int start, int length)
			{
				Requires.NotNull(items, "items");
				Requires.Range(start >= 0, "start");
				Requires.Range(length >= 0, "length");
				if (length == 0)
				{
					return EmptyNode;
				}
				int num = (length - 1) / 2;
				int num2 = length - 1 - num;
				Node left = NodeTreeFromList(items, start, num2);
				Node right = NodeTreeFromList(items, start + num2 + 1, num);
				KeyValuePair<TKey, TValue> keyValuePair = items[start + num2];
				return new Node(keyValuePair.Key, keyValuePair.Value, left, right, frozen: true);
			}

			private Node SetOrAdd(TKey key, TValue value, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, bool overwriteExistingValue, out bool replacedExistingValue, out bool mutated)
			{
				replacedExistingValue = false;
				if (IsEmpty)
				{
					mutated = true;
					return new Node(key, value, this, this);
				}
				Node node = this;
				int num = keyComparer.Compare(key, _key);
				if (num > 0)
				{
					Node right = _right.SetOrAdd(key, value, keyComparer, valueComparer, overwriteExistingValue, out replacedExistingValue, out mutated);
					if (mutated)
					{
						node = Mutate(null, right);
					}
				}
				else if (num < 0)
				{
					Node left = _left.SetOrAdd(key, value, keyComparer, valueComparer, overwriteExistingValue, out replacedExistingValue, out mutated);
					if (mutated)
					{
						node = Mutate(left);
					}
				}
				else
				{
					if (valueComparer.Equals(_value, value))
					{
						mutated = false;
						return this;
					}
					if (!overwriteExistingValue)
					{
						throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
					}
					mutated = true;
					replacedExistingValue = true;
					node = new Node(key, value, _left, _right);
				}
				if (!mutated)
				{
					return node;
				}
				return MakeBalanced(node);
			}

			private Node RemoveRecursive(TKey key, IComparer<TKey> keyComparer, out bool mutated)
			{
				if (IsEmpty)
				{
					mutated = false;
					return this;
				}
				Node node = this;
				int num = keyComparer.Compare(key, _key);
				if (num == 0)
				{
					mutated = true;
					if (_right.IsEmpty && _left.IsEmpty)
					{
						node = EmptyNode;
					}
					else if (_right.IsEmpty && !_left.IsEmpty)
					{
						node = _left;
					}
					else if (!_right.IsEmpty && _left.IsEmpty)
					{
						node = _right;
					}
					else
					{
						Node node2 = _right;
						while (!node2._left.IsEmpty)
						{
							node2 = node2._left;
						}
						bool mutated2;
						Node right = _right.Remove(node2._key, keyComparer, out mutated2);
						node = node2.Mutate(_left, right);
					}
				}
				else if (num < 0)
				{
					Node left = _left.Remove(key, keyComparer, out mutated);
					if (mutated)
					{
						node = Mutate(left);
					}
				}
				else
				{
					Node right2 = _right.Remove(key, keyComparer, out mutated);
					if (mutated)
					{
						node = Mutate(null, right2);
					}
				}
				if (!node.IsEmpty)
				{
					return MakeBalanced(node);
				}
				return node;
			}

			private Node Mutate(Node left = null, Node right = null)
			{
				if (_frozen)
				{
					return new Node(_key, _value, left ?? _left, right ?? _right);
				}
				if (left != null)
				{
					_left = left;
				}
				if (right != null)
				{
					_right = right;
				}
				_height = checked((byte)(1 + Math.Max(_left._height, _right._height)));
				return this;
			}

			private Node Search(TKey key, IComparer<TKey> keyComparer)
			{
				if (IsEmpty)
				{
					return this;
				}
				int num = keyComparer.Compare(key, _key);
				if (num == 0)
				{
					return this;
				}
				if (num > 0)
				{
					return _right.Search(key, keyComparer);
				}
				return _left.Search(key, keyComparer);
			}
		}

		public static readonly ImmutableSortedDictionary<TKey, TValue> Empty = new ImmutableSortedDictionary<TKey, TValue>();

		private readonly Node _root;

		private readonly int _count;

		private readonly IComparer<TKey> _keyComparer;

		private readonly IEqualityComparer<TValue> _valueComparer;

		public IEqualityComparer<TValue> ValueComparer => _valueComparer;

		public bool IsEmpty => _root.IsEmpty;

		public int Count => _count;

		public IEnumerable<TKey> Keys => _root.Keys;

		public IEnumerable<TValue> Values => _root.Values;

		ICollection<TKey> IDictionary<TKey, TValue>.Keys => new KeysCollectionAccessor<TKey, TValue>(this);

		ICollection<TValue> IDictionary<TKey, TValue>.Values => new ValuesCollectionAccessor<TKey, TValue>(this);

		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true;

		public IComparer<TKey> KeyComparer => _keyComparer;

		internal Node Root => _root;

		public TValue this[TKey key]
		{
			get
			{
				Requires.NotNullAllowStructs(key, "key");
				if (!TryGetValue(key, out var value))
				{
					ThrowHelper.ThrowKeyNotFoundException(key);
				}
				return value;
			}
		}

		TValue IDictionary<TKey, TValue>.this[TKey key]
		{
			get
			{
				return this[key];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		bool IDictionary.IsFixedSize => true;

		bool IDictionary.IsReadOnly => true;

		ICollection IDictionary.Keys => new KeysCollectionAccessor<TKey, TValue>(this);

		ICollection IDictionary.Values => new ValuesCollectionAccessor<TKey, TValue>(this);

		object? IDictionary.this[object key]
		{
			get
			{
				return this[(TKey)key];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		internal ImmutableSortedDictionary(IComparer<TKey>? keyComparer = null, IEqualityComparer<TValue>? valueComparer = null)
		{
			_keyComparer = keyComparer ?? Comparer<TKey>.Default;
			_valueComparer = valueComparer ?? EqualityComparer<TValue>.Default;
			_root = Node.EmptyNode;
		}

		private ImmutableSortedDictionary(Node root, int count, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			Requires.NotNull(root, "root");
			Requires.Range(count >= 0, "count");
			Requires.NotNull(keyComparer, "keyComparer");
			Requires.NotNull(valueComparer, "valueComparer");
			root.Freeze();
			_root = root;
			_count = count;
			_keyComparer = keyComparer;
			_valueComparer = valueComparer;
		}

		public ImmutableSortedDictionary<TKey, TValue> Clear()
		{
			if (!_root.IsEmpty)
			{
				return Empty.WithComparers(_keyComparer, _valueComparer);
			}
			return this;
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Clear()
		{
			return Clear();
		}

		public ref readonly TValue ValueRef(TKey key)
		{
			Requires.NotNullAllowStructs(key, "key");
			return ref _root.ValueRef(key, _keyComparer);
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableSortedDictionary<TKey, TValue> Add(TKey key, TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			bool mutated;
			Node root = _root.Add(key, value, _keyComparer, _valueComparer, out mutated);
			return Wrap(root, _count + 1);
		}

		public ImmutableSortedDictionary<TKey, TValue> SetItem(TKey key, TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			bool replacedExistingValue;
			bool mutated;
			Node root = _root.SetItem(key, value, _keyComparer, _valueComparer, out replacedExistingValue, out mutated);
			return Wrap(root, replacedExistingValue ? _count : (_count + 1));
		}

		public ImmutableSortedDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			Requires.NotNull(items, "items");
			return AddRange(items, overwriteOnCollision: true, avoidToSortedMap: false);
		}

		public ImmutableSortedDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			Requires.NotNull(items, "items");
			return AddRange(items, overwriteOnCollision: false, avoidToSortedMap: false);
		}

		public ImmutableSortedDictionary<TKey, TValue> Remove(TKey value)
		{
			Requires.NotNullAllowStructs(value, "value");
			bool mutated;
			Node root = _root.Remove(value, _keyComparer, out mutated);
			return Wrap(root, _count - 1);
		}

		public ImmutableSortedDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys)
		{
			Requires.NotNull(keys, "keys");
			Node node = _root;
			int num = _count;
			foreach (TKey key in keys)
			{
				bool mutated;
				Node node2 = node.Remove(key, _keyComparer, out mutated);
				if (mutated)
				{
					node = node2;
					num--;
				}
			}
			return Wrap(node, num);
		}

		public ImmutableSortedDictionary<TKey, TValue> WithComparers(IComparer<TKey>? keyComparer, IEqualityComparer<TValue>? valueComparer)
		{
			if (keyComparer == null)
			{
				keyComparer = Comparer<TKey>.Default;
			}
			if (valueComparer == null)
			{
				valueComparer = EqualityComparer<TValue>.Default;
			}
			if (keyComparer == _keyComparer)
			{
				if (valueComparer == _valueComparer)
				{
					return this;
				}
				return new ImmutableSortedDictionary<TKey, TValue>(_root, _count, _keyComparer, valueComparer);
			}
			return new ImmutableSortedDictionary<TKey, TValue>(Node.EmptyNode, 0, keyComparer, valueComparer).AddRange(this, overwriteOnCollision: false, avoidToSortedMap: true);
		}

		public ImmutableSortedDictionary<TKey, TValue> WithComparers(IComparer<TKey>? keyComparer)
		{
			return WithComparers(keyComparer, _valueComparer);
		}

		public bool ContainsValue(TValue value)
		{
			return _root.ContainsValue(value, _valueComparer);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			return Add(key, value);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItem(TKey key, TValue value)
		{
			return SetItem(key, value);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return SetItems(items);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs)
		{
			return AddRange(pairs);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.RemoveRange(IEnumerable<TKey> keys)
		{
			return RemoveRange(keys);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Remove(TKey key)
		{
			return Remove(key);
		}

		public bool ContainsKey(TKey key)
		{
			Requires.NotNullAllowStructs(key, "key");
			return _root.ContainsKey(key, _keyComparer);
		}

		public bool Contains(KeyValuePair<TKey, TValue> pair)
		{
			return _root.Contains(pair, _keyComparer, _valueComparer);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			return _root.TryGetValue(key, _keyComparer, out value);
		}

		public bool TryGetKey(TKey equalKey, out TKey actualKey)
		{
			Requires.NotNullAllowStructs(equalKey, "equalKey");
			return _root.TryGetKey(equalKey, _keyComparer, out actualKey);
		}

		void IDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			throw new NotSupportedException();
		}

		bool IDictionary<TKey, TValue>.Remove(TKey key)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<TKey, TValue> current = enumerator.Current;
				array[arrayIndex++] = current;
			}
		}

		void IDictionary.Add(object key, object value)
		{
			throw new NotSupportedException();
		}

		bool IDictionary.Contains(object key)
		{
			return ContainsKey((TKey)key);
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return new DictionaryEnumerator<TKey, TValue>(GetEnumerator());
		}

		void IDictionary.Remove(object key)
		{
			throw new NotSupportedException();
		}

		void IDictionary.Clear()
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int index)
		{
			_root.CopyTo(array, index, Count);
		}

		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<KeyValuePair<TKey, TValue>>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public Enumerator GetEnumerator()
		{
			return _root.GetEnumerator();
		}

		private static ImmutableSortedDictionary<TKey, TValue> Wrap(Node root, int count, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			if (!root.IsEmpty)
			{
				return new ImmutableSortedDictionary<TKey, TValue>(root, count, keyComparer, valueComparer);
			}
			return Empty.WithComparers(keyComparer, valueComparer);
		}

		private static bool TryCastToImmutableMap(IEnumerable<KeyValuePair<TKey, TValue>> sequence, [NotNullWhen(true)] out ImmutableSortedDictionary<TKey, TValue> other)
		{
			other = sequence as ImmutableSortedDictionary<TKey, TValue>;
			if (other != null)
			{
				return true;
			}
			if (sequence is Builder builder)
			{
				other = builder.ToImmutable();
				return true;
			}
			return false;
		}

		private ImmutableSortedDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items, bool overwriteOnCollision, bool avoidToSortedMap)
		{
			Requires.NotNull(items, "items");
			if (IsEmpty && !avoidToSortedMap)
			{
				return FillFromEmpty(items, overwriteOnCollision);
			}
			Node node = _root;
			int num = _count;
			foreach (KeyValuePair<TKey, TValue> item in items)
			{
				bool replacedExistingValue = false;
				bool mutated;
				Node node2 = (overwriteOnCollision ? node.SetItem(item.Key, item.Value, _keyComparer, _valueComparer, out replacedExistingValue, out mutated) : node.Add(item.Key, item.Value, _keyComparer, _valueComparer, out mutated));
				if (mutated)
				{
					node = node2;
					if (!replacedExistingValue)
					{
						num++;
					}
				}
			}
			return Wrap(node, num);
		}

		private ImmutableSortedDictionary<TKey, TValue> Wrap(Node root, int adjustedCountIfDifferentRoot)
		{
			if (_root != root)
			{
				if (!root.IsEmpty)
				{
					return new ImmutableSortedDictionary<TKey, TValue>(root, adjustedCountIfDifferentRoot, _keyComparer, _valueComparer);
				}
				return Clear();
			}
			return this;
		}

		private ImmutableSortedDictionary<TKey, TValue> FillFromEmpty(IEnumerable<KeyValuePair<TKey, TValue>> items, bool overwriteOnCollision)
		{
			Requires.NotNull(items, "items");
			if (TryCastToImmutableMap(items, out var other))
			{
				return other.WithComparers(KeyComparer, ValueComparer);
			}
			SortedDictionary<TKey, TValue> sortedDictionary;
			if (items is IDictionary<TKey, TValue> dictionary)
			{
				sortedDictionary = new SortedDictionary<TKey, TValue>(dictionary, KeyComparer);
			}
			else
			{
				sortedDictionary = new SortedDictionary<TKey, TValue>(KeyComparer);
				foreach (KeyValuePair<TKey, TValue> item in items)
				{
					TValue value;
					if (overwriteOnCollision)
					{
						sortedDictionary[item.Key] = item.Value;
					}
					else if (sortedDictionary.TryGetValue(item.Key, out value))
					{
						if (!_valueComparer.Equals(value, item.Value))
						{
							throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, item.Key));
						}
					}
					else
					{
						sortedDictionary.Add(item.Key, item.Value);
					}
				}
			}
			if (sortedDictionary.Count == 0)
			{
				return this;
			}
			return new ImmutableSortedDictionary<TKey, TValue>(Node.NodeTreeFromSortedDictionary(sortedDictionary), sortedDictionary.Count, KeyComparer, ValueComparer);
		}
	}
	public static class ImmutableSortedSet
	{
		public static ImmutableSortedSet<T> Create<T>()
		{
			return ImmutableSortedSet<T>.Empty;
		}

		public static ImmutableSortedSet<T> Create<T>(IComparer<T>? comparer)
		{
			return ImmutableSortedSet<T>.Empty.WithComparer(comparer);
		}

		public static ImmutableSortedSet<T> Create<T>(T item)
		{
			return ImmutableSortedSet<T>.Empty.Add(item);
		}

		public static ImmutableSortedSet<T> Create<T>(IComparer<T>? comparer, T item)
		{
			return ImmutableSortedSet<T>.Empty.WithComparer(comparer).Add(item);
		}

		public static ImmutableSortedSet<T> CreateRange<T>(IEnumerable<T> items)
		{
			return ImmutableSortedSet<T>.Empty.Union(items);
		}

		public static ImmutableSortedSet<T> CreateRange<T>(IComparer<T>? comparer, IEnumerable<T> items)
		{
			return ImmutableSortedSet<T>.Empty.WithComparer(comparer).Union(items);
		}

		public static ImmutableSortedSet<T> Create<T>(params T[] items)
		{
			Requires.NotNull(items, "items");
			return Create((ReadOnlySpan<T>)items);
		}

		public static ImmutableSortedSet<T> Create<T>([ParamCollection] scoped ReadOnlySpan<T> items)
		{
			return ImmutableSortedSet<T>.Empty.Union(items);
		}

		public static ImmutableSortedSet<T> Create<T>(IComparer<T>? comparer, params T[] items)
		{
			Requires.NotNull(items, "items");
			return Create(comparer, (ReadOnlySpan<T>)items);
		}

		public static ImmutableSortedSet<T> Create<T>(IComparer<T>? comparer, [ParamCollection] scoped ReadOnlySpan<T> items)
		{
			return ImmutableSortedSet<T>.Empty.WithComparer(comparer).Union(items);
		}

		public static ImmutableSortedSet<T>.Builder CreateBuilder<T>()
		{
			return Create<T>().ToBuilder();
		}

		public static ImmutableSortedSet<T>.Builder CreateBuilder<T>(IComparer<T>? comparer)
		{
			return Create(comparer).ToBuilder();
		}

		public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this IEnumerable<TSource> source, IComparer<TSource>? comparer)
		{
			if (source is ImmutableSortedSet<TSource> immutableSortedSet)
			{
				return immutableSortedSet.WithComparer(comparer);
			}
			return ImmutableSortedSet<TSource>.Empty.WithComparer(comparer).Union(source);
		}

		public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this IEnumerable<TSource> source)
		{
			return source.ToImmutableSortedSet(null);
		}

		public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this ImmutableSortedSet<TSource>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}
	}
	[CollectionBuilder(typeof(ImmutableSortedSet), "Create")]
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	public sealed class ImmutableSortedSet<T> : IImmutableSet<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, ISortKeyCollection<T>, IReadOnlyList<T>, IList<T>, ICollection<T>, ISet<T>, IList, ICollection, IStrongEnumerable<T, ImmutableSortedSet<T>.Enumerator>
	{
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(ImmutableSortedSetBuilderDebuggerProxy<>))]
		public sealed class Builder : ISortKeyCollection<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, ISet<T>, ICollection<T>, ICollection
		{
			private Node _root = Node.EmptyNode;

			private IComparer<T> _comparer = Comparer<T>.Default;

			private ImmutableSortedSet<T> _immutable;

			private int _version;

			private object _syncRoot;

			public int Count => Root.Count;

			bool ICollection<T>.IsReadOnly => false;

			public T this[int index] => _root.ItemRef(index);

			public T? Max => _root.Max;

			public T? Min => _root.Min;

			public IComparer<T> KeyComparer
			{
				get
				{
					return _comparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value == _comparer)
					{
						return;
					}
					Node node = Node.EmptyNode;
					using (Enumerator enumerator = GetEnumerator())
					{
						while (enumerator.MoveNext())
						{
							T current = enumerator.Current;
							node = node.Add(current, value, out var _);
						}
					}
					_immutable = null;
					_comparer = value;
					Root = node;
				}
			}

			internal int Version => _version;

			private Node Root
			{
				get
				{
					return _root;
				}
				set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			bool ICollection.IsSynchronized => false;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			object ICollection.SyncRoot
			{
				get
				{
					if (_syncRoot == null)
					{
						Interlocked.CompareExchange<object>(ref _syncRoot, new object(), (object)null);
					}
					return _syncRoot;
				}
			}

			internal Builder(ImmutableSortedSet<T> set)
			{
				Requires.NotNull(set, "set");
				_root = set._root;
				_comparer = set.KeyComparer;
				_immutable = set;
			}

			public ref readonly T ItemRef(int index)
			{
				return ref _root.ItemRef(index);
			}

			public bool Add(T item)
			{
				Root = Root.Add(item, _comparer, out var mutated);
				return mutated;
			}

			public void ExceptWith(IEnumerable<T> other)
			{
				Requires.NotNull(other, "other");
				foreach (T item in other)
				{
					Root = Root.Remove(item, _comparer, out var _);
				}
			}

			public void IntersectWith(IEnumerable<T> other)
			{
				Requires.NotNull(other, "other");
				Node node = Node.EmptyNode;
				foreach (T item in other)
				{
					if (Contains(item))
					{
						node = node.Add(item, _comparer, out var _);
					}
				}
				Root = node;
			}

			public bool IsProperSubsetOf(IEnumerable<T> other)
			{
				return ToImmutable().IsProperSubsetOf(other);
			}

			public bool IsProperSupersetOf(IEnumerable<T> other)
			{
				return ToImmutable().IsProperSupersetOf(other);
			}

			public bool IsSubsetOf(IEnumerable<T> other)
			{
				return ToImmutable().IsSubsetOf(other);
			}

			public bool IsSupersetOf(IEnumerable<T> other)
			{
				return ToImmutable().IsSupersetOf(other);
			}

			public bool Overlaps(IEnumerable<T> other)
			{
				return ToImmutable().Overlaps(other);
			}

			public bool SetEquals(IEnumerable<T> other)
			{
				return ToImmutable().SetEquals(other);
			}

			public void SymmetricExceptWith(IEnumerable<T> other)
			{
				Root = ToImmutable().SymmetricExcept(other)._root;
			}

			public void UnionWith(IEnumerable<T> other)
			{
				Requires.NotNull(other, "other");
				foreach (T item in other)
				{
					Root = Root.Add(item, _comparer, out var _);
				}
			}

			void ICollection<T>.Add(T item)
			{
				Add(item);
			}

			public void Clear()
			{
				Root = Node.EmptyNode;
			}

			public bool Contains(T item)
			{
				return Root.Contains(item, _comparer);
			}

			void ICollection<T>.CopyTo(T[] array, int arrayIndex)
			{
				_root.CopyTo(array, arrayIndex);
			}

			public bool Remove(T item)
			{
				Root = Root.Remove(item, _comparer, out var mutated);
				return mutated;
			}

			public ImmutableSortedSet<T>.Enumerator GetEnumerator()
			{
				return Root.GetEnumerator(this);
			}

			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return Root.GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public int IndexOf(T item)
			{
				return Root.IndexOf(item, _comparer);
			}

			public IEnumerable<T> Reverse()
			{
				return new ReverseEnumerable(_root);
			}

			public ImmutableSortedSet<T> ToImmutable()
			{
				return _immutable ?? (_immutable = ImmutableSortedSet<T>.Wrap(Root, _comparer));
			}

			public bool TryGetValue(T equalValue, out T actualValue)
			{
				Node node = _root.Search(equalValue, _comparer);
				if (!node.IsEmpty)
				{
					actualValue = node.Key;
					return true;
				}
				actualValue = equalValue;
				return false;
			}

			void ICollection.CopyTo(Array array, int arrayIndex)
			{
				Root.CopyTo(array, arrayIndex);
			}
		}

		private sealed class ReverseEnumerable : IEnumerable<T>, IEnumerable
		{
			private readonly Node _root;

			internal ReverseEnumerable(Node root)
			{
				Requires.NotNull(root, "root");
				_root = root;
			}

			public IEnumerator<T> GetEnumerator()
			{
				return _root.Reverse();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable, ISecurePooledObjectUser, IStrongEnumerator<T>
		{
			private readonly Builder _builder;

			private readonly int _poolUserId;

			private readonly bool _reverse;

			private Node _root;

			private SecurePooledObject<Stack<RefAsValueType<Node>>> _stack;

			private Node _current;

			private int _enumeratingBuilderVersion;

			int ISecurePooledObjectUser.PoolUserId => _poolUserId;

			public T Current
			{
				get
				{
					ThrowIfDisposed();
					if (_current != null)
					{
						return _current.Value;
					}
					throw new InvalidOperationException();
				}
			}

			object? IEnumerator.Current => Current;

			internal Enumerator(Node root, Builder? builder = null, bool reverse = false)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_builder = builder;
				_current = null;
				_reverse = reverse;
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
				_poolUserId = SecureObjectPool.NewId();
				_stack = null;
				if (!SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>.TryTake(this, out _stack))
				{
					_stack = SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>.PrepNew(this, new Stack<RefAsValueType<Node>>(root.Height));
				}
				PushNext(_root);
			}

			public void Dispose()
			{
				_root = null;
				_current = null;
				if (_stack != null && _stack.TryUse(ref this, out var value))
				{
					value.ClearFastWhenEmpty();
					SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>.TryAdd(this, _stack);
					_stack = null;
				}
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				ThrowIfChanged();
				Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
				if (stack.Count > 0)
				{
					Node node = (_current = stack.Pop().Value);
					PushNext(_reverse ? node.Left : node.Right);
					return true;
				}
				_current = null;
				return false;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_current = null;
				_stack.Use(ref this).ClearFastWhenEmpty();
				PushNext(_root);
			}

			private void ThrowIfDisposed()
			{
				if (_root == null || (_stack != null && !_stack.IsOwned(ref this)))
				{
					Requires.FailObjectDisposed(this);
				}
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}

			private void PushNext(Node node)
			{
				Requires.NotNull(node, "node");
				Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
				while (!node.IsEmpty)
				{
					stack.Push(new RefAsValueType<Node>(node));
					node = (_reverse ? node.Right : node.Left);
				}
			}
		}

		[DebuggerDisplay("{_key}")]
		internal sealed class Node : IBinaryTree<T>, IBinaryTree, IEnumerable<T>, IEnumerable
		{
			internal static readonly Node EmptyNode = new Node();

			private readonly T _key;

			private bool _frozen;

			private byte _height;

			private int _count;

			private Node _left;

			private Node _right;

			public bool IsEmpty => _left == null;

			public int Height => _height;

			public Node? Left => _left;

			IBinaryTree? IBinaryTree.Left => _left;

			public Node? Right => _right;

			IBinaryTree? IBinaryTree.Right => _right;

			IBinaryTree<T>? IBinaryTree<T>.Left => _left;

			IBinaryTree<T>? IBinaryTree<T>.Right => _right;

			public T Value => _key;

			public int Count => _count;

			internal T Key => _key;

			internal T? Max
			{
				get
				{
					if (IsEmpty)
					{
						return default(T);
					}
					Node node = this;
					while (!node._right.IsEmpty)
					{
						node = node._right;
					}
					return node._key;
				}
			}

			internal T? Min
			{
				get
				{
					if (IsEmpty)
					{
						return default(T);
					}
					Node node = this;
					while (!node._left.IsEmpty)
					{
						node = node._left;
					}
					return node._key;
				}
			}

			internal T this[int index]
			{
				get
				{
					Requires.Range(index >= 0 && index < Count, "index");
					if (index < _left._count)
					{
						return _left[index];
					}
					if (index > _left._count)
					{
						return _right[index - _left._count - 1];
					}
					return _key;
				}
			}

			private Node()
			{
				_frozen = true;
			}

			private Node(T key, Node left, Node right, bool frozen = false)
			{
				Requires.NotNull(left, "left");
				Requires.NotNull(right, "right");
				_key = key;
				_left = left;
				_right = right;
				_height = checked((byte)(1 + Math.Max(left._height, right._height)));
				_count = 1 + left._count + right._count;
				_frozen = frozen;
			}

			internal ref readonly T ItemRef(int index)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				return ref ItemRefUnchecked(index);
			}

			private ref readonly T ItemRefUnchecked(int index)
			{
				if (index < _left._count)
				{
					return ref _left.ItemRefUnchecked(index);
				}
				if (index > _left._count)
				{
					return ref _right.ItemRefUnchecked(index - _left._count - 1);
				}
				return ref _key;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			[ExcludeFromCodeCoverage]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			[ExcludeFromCodeCoverage]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			internal Enumerator GetEnumerator(Builder builder)
			{
				return new Enumerator(this, builder);
			}

			internal void CopyTo(T[] array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			internal void CopyTo(Array array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array.SetValue(current, arrayIndex++);
				}
			}

			internal Node Add(T key, IComparer<T> comparer, out bool mutated)
			{
				Requires.NotNull(comparer, "comparer");
				if (IsEmpty)
				{
					mutated = true;
					return new Node(key, this, this);
				}
				Node node = this;
				int num = comparer.Compare(key, _key);
				if (num > 0)
				{
					Node right = _right.Add(key, comparer, out mutated);
					if (mutated)
					{
						node = Mutate(null, right);
					}
				}
				else
				{
					if (num >= 0)
					{
						mutated = false;
						return this;
					}
					Node left = _left.Add(key, comparer, out mutated);
					if (mutated)
					{
						node = Mutate(left);
					}
				}
				if (!mutated)
				{
					return node;
				}
				return MakeBalanced(node);
			}

			internal Node Remove(T key, IComparer<T> comparer, out bool mutated)
			{
				Requires.NotNull(comparer, "comparer");
				if (IsEmpty)
				{
					mutated = false;
					return this;
				}
				Node node = this;
				int num = comparer.Compare(key, _key);
				if (num == 0)
				{
					mutated = true;
					if (_right.IsEmpty && _left.IsEmpty)
					{
						node = EmptyNode;
					}
					else if (_right.IsEmpty && !_left.IsEmpty)
					{
						node = _left;
					}
					else if (!_right.IsEmpty && _left.IsEmpty)
					{
						node = _right;
					}
					else
					{
						Node node2 = _right;
						while (!node2._left.IsEmpty)
						{
							node2 = node2._left;
						}
						bool mutated2;
						Node right = _right.Remove(node2._key, comparer, out mutated2);
						node = node2.Mutate(_left, right);
					}
				}
				else if (num < 0)
				{
					Node left = _left.Remove(key, comparer, out mutated);
					if (mutated)
					{
						node = Mutate(left);
					}
				}
				else
				{
					Node right2 = _right.Remove(key, comparer, out mutated);
					if (mutated)
					{
						node = Mutate(null, right2);
					}
				}
				if (!node.IsEmpty)
				{
					return MakeBalanced(node);
				}
				return node;
			}

			internal bool Contains(T key, IComparer<T> comparer)
			{
				Requires.NotNull(comparer, "comparer");
				return !Search(key, comparer).IsEmpty;
			}

			internal void Freeze()
			{
				if (!_frozen)
				{
					_left.Freeze();
					_right.Freeze();
					_frozen = true;
				}
			}

			internal Node Search(T key, IComparer<T> comparer)
			{
				Requires.NotNull(comparer, "comparer");
				if (IsEmpty)
				{
					return this;
				}
				int num = comparer.Compare(key, _key);
				if (num == 0)
				{
					return this;
				}
				if (num > 0)
				{
					return _right.Search(key, comparer);
				}
				return _left.Search(key, comparer);
			}

			internal int IndexOf(T key, IComparer<T> comparer)
			{
				Requires.NotNull(comparer, "comparer");
				if (IsEmpty)
				{
					return -1;
				}
				int num = comparer.Compare(key, _key);
				if (num == 0)
				{
					return _left.Count;
				}
				if (num > 0)
				{
					int num2 = _right.IndexOf(key, comparer);
					bool num3 = num2 < 0;
					if (num3)
					{
						num2 = ~num2;
					}
					num2 = _left.Count + 1 + num2;
					if (num3)
					{
						num2 = ~num2;
					}
					return num2;
				}
				return _left.IndexOf(key, comparer);
			}

			internal IEnumerator<T> Reverse()
			{
				return new Enumerator(this, null, reverse: true);
			}

			private static Node RotateLeft(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._right.IsEmpty)
				{
					return tree;
				}
				Node right = tree._right;
				return right.Mutate(tree.Mutate(null, right._left));
			}

			private static Node RotateRight(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._left.IsEmpty)
				{
					return tree;
				}
				Node left = tree._left;
				return left.Mutate(null, tree.Mutate(left._right));
			}

			private static Node DoubleLeft(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._right.IsEmpty)
				{
					return tree;
				}
				return RotateLeft(tree.Mutate(null, RotateRight(tree._right)));
			}

			private static Node DoubleRight(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._left.IsEmpty)
				{
					return tree;
				}
				return RotateRight(tree.Mutate(RotateLeft(tree._left)));
			}

			private static int Balance(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return tree._right._height - tree._left._height;
			}

			private static bool IsRightHeavy(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return Balance(tree) >= 2;
			}

			private static bool IsLeftHeavy(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return Balance(tree) <= -2;
			}

			private static Node MakeBalanced(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (IsRightHeavy(tree))
				{
					if (Balance(tree._right) >= 0)
					{
						return RotateLeft(tree);
					}
					return DoubleLeft(tree);
				}
				if (IsLeftHeavy(tree))
				{
					if (Balance(tree._left) <= 0)
					{
						return RotateRight(tree);
					}
					return DoubleRight(tree);
				}
				return tree;
			}

			internal static Node NodeTreeFromList(IOrderedCollection<T> items, int start, int length)
			{
				Requires.NotNull(items, "items");
				if (length == 0)
				{
					return EmptyNode;
				}
				int num = (length - 1) / 2;
				int num2 = length - 1 - num;
				Node left = NodeTreeFromList(items, start, num2);
				Node right = NodeTreeFromList(items, start + num2 + 1, num);
				return new Node(items[start + num2], left, right, frozen: true);
			}

			private Node Mutate(Node left = null, Node right = null)
			{
				if (_frozen)
				{
					return new Node(_key, left ?? _left, right ?? _right);
				}
				if (left != null)
				{
					_left = left;
				}
				if (right != null)
				{
					_right = right;
				}
				_height = checked((byte)(1 + Math.Max(_left._height, _right._height)));
				_count = 1 + _left._count + _right._count;
				return this;
			}
		}

		private const float RefillOverIncrementalThreshold = 0.15f;

		public static readonly ImmutableSortedSet<T> Empty = new ImmutableSortedSet<T>();

		private readonly Node _root;

		private readonly IComparer<T> _comparer;

		public T? Max => _root.Max;

		public T? Min => _root.Min;

		public bool IsEmpty => _root.IsEmpty;

		public int Count => _root.Count;

		public IComparer<T> KeyComparer => _comparer;

		internal IBinaryTree Root => _root;

		public T this[int index] => _root.ItemRef(index);

		bool ICollection<T>.IsReadOnly => true;

		T IList<T>.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		bool IList.IsFixedSize => true;

		bool IList.IsReadOnly => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		object? IList.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		internal ImmutableSortedSet(IComparer<T>? comparer = null)
		{
			_root = Node.EmptyNode;
			_comparer = comparer ?? Comparer<T>.Default;
		}

		private ImmutableSortedSet(Node root, IComparer<T> comparer)
		{
			Requires.NotNull(root, "root");
			Requires.NotNull(comparer, "comparer");
			root.Freeze();
			_root = root;
			_comparer = comparer;
		}

		public ImmutableSortedSet<T> Clear()
		{
			if (!_root.IsEmpty)
			{
				return Empty.WithComparer(_comparer);
			}
			return this;
		}

		public ref readonly T ItemRef(int index)
		{
			return ref _root.ItemRef(index);
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableSortedSet<T> Add(T value)
		{
			bool mutated;
			return Wrap(_root.Add(value, _comparer, out mutated));
		}

		public ImmutableSortedSet<T> Remove(T value)
		{
			bool mutated;
			return Wrap(_root.Remove(value, _comparer, out mutated));
		}

		public bool TryGetValue(T equalValue, out T actualValue)
		{
			Node node = _root.Search(equalValue, _comparer);
			if (node.IsEmpty)
			{
				actualValue = equalValue;
				return false;
			}
			actualValue = node.Key;
			return true;
		}

		public ImmutableSortedSet<T> Intersect(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			ImmutableSortedSet<T> immutableSortedSet = Clear();
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (Contains(item))
				{
					immutableSortedSet = immutableSortedSet.Add(item);
				}
			}
			return immutableSortedSet;
		}

		public ImmutableSortedSet<T> Except(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			Node node = _root;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				node = node.Remove(item, _comparer, out var _);
			}
			return Wrap(node);
		}

		public ImmutableSortedSet<T> SymmetricExcept(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			ImmutableSortedSet<T> immutableSortedSet = ImmutableSortedSet.CreateRange(_comparer, other);
			ImmutableSortedSet<T> immutableSortedSet2 = Clear();
			using (Enumerator enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					if (!immutableSortedSet.Contains(current))
					{
						immutableSortedSet2 = immutableSortedSet2.Add(current);
					}
				}
			}
			foreach (T item in immutableSortedSet)
			{
				if (!Contains(item))
				{
					immutableSortedSet2 = immutableSortedSet2.Add(item);
				}
			}
			return immutableSortedSet2;
		}

		public ImmutableSortedSet<T> Union(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (TryCastToImmutableSortedSet(other, out var other2) && other2.KeyComparer == KeyComparer)
			{
				if (other2.IsEmpty)
				{
					return this;
				}
				if (IsEmpty)
				{
					return other2;
				}
				if (other2.Count > Count)
				{
					return other2.Union(this);
				}
			}
			if (IsEmpty || (other.TryGetCount(out var count) && (float)(Count + count) * 0.15f > (float)Count))
			{
				return LeafToRootRefill(other);
			}
			return UnionIncremental(other);
		}

		internal ImmutableSortedSet<T> Union(ReadOnlySpan<T> other)
		{
			if (IsEmpty || (float)(Count + other.Length) * 0.15f > (float)Count)
			{
				return LeafToRootRefill(other);
			}
			return UnionIncremental(other);
		}

		public ImmutableSortedSet<T> WithComparer(IComparer<T>? comparer)
		{
			if (comparer == null)
			{
				comparer = Comparer<T>.Default;
			}
			if (comparer == _comparer)
			{
				return this;
			}
			return new ImmutableSortedSet<T>(Node.EmptyNode, comparer).Union(this);
		}

		public bool SetEquals(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (this == other)
			{
				return true;
			}
			SortedSet<T> sortedSet = new SortedSet<T>(other, KeyComparer);
			if (Count != sortedSet.Count)
			{
				return false;
			}
			int num = 0;
			foreach (T item in sortedSet)
			{
				if (!Contains(item))
				{
					return false;
				}
				num++;
			}
			return num == Count;
		}

		public bool IsProperSubsetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (IsEmpty)
			{
				return other.Any();
			}
			SortedSet<T> sortedSet = new SortedSet<T>(other, KeyComparer);
			if (Count >= sortedSet.Count)
			{
				return false;
			}
			int num = 0;
			bool flag = false;
			foreach (T item in sortedSet)
			{
				if (Contains(item))
				{
					num++;
				}
				else
				{
					flag = true;
				}
				if (num == Count && flag)
				{
					return true;
				}
			}
			return false;
		}

		public bool IsProperSupersetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (IsEmpty)
			{
				return false;
			}
			int num = 0;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				num++;
				if (!Contains(item))
				{
					return false;
				}
			}
			return Count > num;
		}

		public bool IsSubsetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (IsEmpty)
			{
				return true;
			}
			SortedSet<T> sortedSet = new SortedSet<T>(other, KeyComparer);
			int num = 0;
			foreach (T item in sortedSet)
			{
				if (Contains(item))
				{
					num++;
				}
			}
			return num == Count;
		}

		public bool IsSupersetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (!Contains(item))
				{
					return false;
				}
			}
			return true;
		}

		public bool Overlaps(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (IsEmpty)
			{
				return false;
			}
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (Contains(item))
				{
					return true;
				}
			}
			return false;
		}

		public IEnumerable<T> Reverse()
		{
			return new ReverseEnumerable(_root);
		}

		public int IndexOf(T item)
		{
			return _root.IndexOf(item, _comparer);
		}

		public bool Contains(T value)
		{
			return _root.Contains(value, _comparer);
		}

		IImmutableSet<T> IImmutableSet<T>.Clear()
		{
			return Clear();
		}

		IImmutableSet<T> IImmutableSet<T>.Add(T value)
		{
			return Add(value);
		}

		IImmutableSet<T> IImmutableSet<T>.Remove(T value)
		{
			return Remove(value);
		}

		IImmutableSet<T> IImmutableSet<T>.Intersect(IEnumerable<T> other)
		{
			return Intersect(other);
		}

		IImmutableSet<T> IImmutableSet<T>.Except(IEnumerable<T> other)
		{
			return Except(other);
		}

		IImmutableSet<T> IImmutableSet<T>.SymmetricExcept(IEnumerable<T> other)
		{
			return SymmetricExcept(other);
		}

		IImmutableSet<T> IImmutableSet<T>.Union(IEnumerable<T> other)
		{
			return Union(other);
		}

		bool ISet<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.ExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.IntersectWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.SymmetricExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.UnionWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.CopyTo(T[] array, int arrayIndex)
		{
			_root.CopyTo(array, arrayIndex);
		}

		void ICollection<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<T>.Remove(T item)
		{
			throw new NotSupportedException();
		}

		void IList<T>.Insert(int index, T item)
		{
			throw new NotSupportedException();
		}

		void IList<T>.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		int IList.Add(object value)
		{
			throw new NotSupportedException();
		}

		void IList.Clear()
		{
			throw new NotSupportedException();
		}

		private static bool IsCompatibleObject(object value)
		{
			if (!(value is T))
			{
				if (default(T) == null)
				{
					return value == null;
				}
				return false;
			}
			return true;
		}

		bool IList.Contains(object value)
		{
			if (IsCompatibleObject(value))
			{
				return Contains((T)value);
			}
			return false;
		}

		int IList.IndexOf(object value)
		{
			if (IsCompatibleObject(value))
			{
				return IndexOf((T)value);
			}
			return -1;
		}

		void IList.Insert(int index, object value)
		{
			throw new NotSupportedException();
		}

		void IList.Remove(object value)
		{
			throw new NotSupportedException();
		}

		void IList.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int index)
		{
			_root.CopyTo(array, index);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public Enumerator GetEnumerator()
		{
			return _root.GetEnumerator();
		}

		private static bool TryCastToImmutableSortedSet(IEnumerable<T> sequence, [NotNullWhen(true)] out ImmutableSortedSet<T> other)
		{
			other = sequence as ImmutableSortedSet<T>;
			if (other != null)
			{
				return true;
			}
			if (sequence is Builder builder)
			{
				other = builder.ToImmutable();
				return true;
			}
			return false;
		}

		private static ImmutableSortedSet<T> Wrap(Node root, IComparer<T> comparer)
		{
			if (!root.IsEmpty)
			{
				return new ImmutableSortedSet<T>(root, comparer);
			}
			return Empty.WithComparer(comparer);
		}

		private ImmutableSortedSet<T> UnionIncremental(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			Node node = _root;
			foreach (T item in items.GetEnumerableDisposable<T, Enumerator>())
			{
				node = node.Add(item, _comparer, out var _);
			}
			return Wrap(node);
		}

		private ImmutableSortedSet<T> UnionIncremental(ReadOnlySpan<T> items)
		{
			Node node = _root;
			ReadOnlySpan<T> readOnlySpan = items;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				T key = readOnlySpan[i];
				node = node.Add(key, _comparer, out var _);
			}
			return Wrap(node);
		}

		private ImmutableSortedSet<T> Wrap(Node root)
		{
			if (root != _root)
			{
				if (!root.IsEmpty)
				{
					return new ImmutableSortedSet<T>(root, _comparer);
				}
				return Clear();
			}
			return this;
		}

		private ImmutableSortedSet<T> LeafToRootRefill(IEnumerable<T> addedItems)
		{
			Requires.NotNull(addedItems, "addedItems");
			List<T> list;
			if (IsEmpty)
			{
				if (addedItems.TryGetCount(out var count) && count == 0)
				{
					return this;
				}
				list = new List<T>(addedItems);
				if (list.Count == 0)
				{
					return this;
				}
			}
			else
			{
				list = new List<T>(this);
				list.AddRange(addedItems);
			}
			IComparer<T> keyComparer = KeyComparer;
			list.Sort(keyComparer);
			int num = 1;
			for (int i = 1; i < list.Count; i++)
			{
				if (keyComparer.Compare(list[i], list[i - 1]) != 0)
				{
					list[num++] = list[i];
				}
			}
			list.RemoveRange(num, list.Count - num);
			Node root = Node.NodeTreeFromList(list.AsOrderedCollection(), 0, list.Count);
			return Wrap(root);
		}

		private ImmutableSortedSet<T> LeafToRootRefill(ReadOnlySpan<T> addedItems)
		{
			List<T> list;
			if (IsEmpty && addedItems.IsEmpty)
			{
				if (addedItems.IsEmpty)
				{
					return this;
				}
				list = new List<T>(addedItems.Length);
			}
			else
			{
				list = new List<T>(Count + addedItems.Length);
				list.AddRange(this);
			}
			ReadOnlySpan<T> readOnlySpan = addedItems;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				T item = readOnlySpan[i];
				list.Add(item);
			}
			IComparer<T> keyComparer = KeyComparer;
			list.Sort(keyComparer);
			int num = 1;
			for (int j = 1; j < list.Count; j++)
			{
				if (keyComparer.Compare(list[j], list[j - 1]) != 0)
				{
					list[num++] = list[j];
				}
			}
			list.RemoveRange(num, list.Count - num);
			Node root = Node.NodeTreeFromList(list.AsOrderedCollection(), 0, list.Count);
			return Wrap(root);
		}
	}
	internal sealed class ImmutableSortedSetBuilderDebuggerProxy<T>
	{
		private readonly ImmutableSortedSet<T>.Builder _set;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Contents => _set.ToArray(_set.Count);

		public ImmutableSortedSetBuilderDebuggerProxy(ImmutableSortedSet<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			_set = builder;
		}
	}
	public static class ImmutableStack
	{
		public static ImmutableStack<T> Create<T>()
		{
			return ImmutableStack<T>.Empty;
		}

		public static ImmutableStack<T> Create<T>(T item)
		{
			return ImmutableStack<T>.Empty.Push(item);
		}

		public static ImmutableStack<T> CreateRange<T>(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			ImmutableStack<T> immutableStack = ImmutableStack<T>.Empty;
			foreach (T item in items)
			{
				immutableStack = immutableStack.Push(item);
			}
			return immutableStack;
		}

		public static ImmutableStack<T> Create<T>(params T[] items)
		{
			Requires.NotNull(items, "items");
			return Create((ReadOnlySpan<T>)items);
		}

		public static ImmutableStack<T> Create<T>([ParamCollection] scoped ReadOnlySpan<T> items)
		{
			ImmutableStack<T> immutableStack = ImmutableStack<T>.Empty;
			ReadOnlySpan<T> readOnlySpan = items;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				T value = readOnlySpan[i];
				immutableStack = immutableStack.Push(value);
			}
			return immutableStack;
		}

		public static IImmutableStack<T> Pop<T>(this IImmutableStack<T> stack, out T value)
		{
			Requires.NotNull(stack, "stack");
			value = stack.Peek();
			return stack.Pop();
		}
	}
	[CollectionBuilder(typeof(ImmutableStack), "Create")]
	[DebuggerDisplay("IsEmpty = {IsEmpty}, Top = {_head}")]
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	public sealed class ImmutableStack<T> : IImmutableStack<T>, IEnumerable<T>, IEnumerable
	{
		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator
		{
			private readonly ImmutableStack<T> _originalStack;

			private ImmutableStack<T> _remainingStack;

			public T Current
			{
				get
				{
					if (_remainingStack == null || _remainingStack.IsEmpty)
					{
						throw new InvalidOperationException();
					}
					return _remainingStack.Peek();
				}
			}

			internal Enumerator(ImmutableStack<T> stack)
			{
				Requires.NotNull(stack, "stack");
				_originalStack = stack;
				_remainingStack = null;
			}

			public bool MoveNext()
			{
				if (_remainingStack == null)
				{
					_remainingStack = _originalStack;
				}
				else if (!_remainingStack.IsEmpty)
				{
					_remainingStack = _remainingStack.Pop();
				}
				return !_remainingStack.IsEmpty;
			}
		}

		private sealed class EnumeratorObject : IEnumerator<T>, IEnumerator, IDisposable
		{
			private readonly ImmutableStack<T> _originalStack;

			private ImmutableStack<T> _remainingStack;

			private bool _disposed;

			public T Current
			{
				get
				{
					ThrowIfDisposed();
					if (_remainingStack == null || _remainingStack.IsEmpty)
					{
						throw new InvalidOperationException();
					}
					return _remainingStack.Peek();
				}
			}

			object IEnumerator.Current => Current;

			internal EnumeratorObject(ImmutableStack<T> stack)
			{
				Requires.NotNull(stack, "stack");
				_originalStack = stack;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				if (_remainingStack == null)
				{
					_remainingStack = _originalStack;
				}
				else if (!_remainingStack.IsEmpty)
				{
					_remainingStack = _remainingStack.Pop();
				}
				return !_remainingStack.IsEmpty;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_remainingStack = null;
			}

			public void Dispose()
			{
				_disposed = true;
			}

			private void ThrowIfDisposed()
			{
				if (_disposed)
				{
					Requires.FailObjectDisposed(this);
				}
			}
		}

		private static readonly ImmutableStack<T> s_EmptyField = new ImmutableStack<T>();

		private readonly T _head;

		private readonly ImmutableStack<T> _tail;

		public static ImmutableStack<T> Empty => s_EmptyField;

		public bool IsEmpty => _tail == null;

		private ImmutableStack()
		{
		}

		private ImmutableStack(T head, ImmutableStack<T> tail)
		{
			_head = head;
			_tail = tail;
		}

		public ImmutableStack<T> Clear()
		{
			return Empty;
		}

		IImmutableStack<T> IImmutableStack<T>.Clear()
		{
			return Clear();
		}

		public T Peek()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return _head;
		}

		public ref readonly T PeekRef()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return ref _head;
		}

		public ImmutableStack<T> Push(T value)
		{
			return new ImmutableStack<T>(value, this);
		}

		IImmutableStack<T> IImmutableStack<T>.Push(T value)
		{
			return Push(value);
		}

		public ImmutableStack<T> Pop()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return _tail;
		}

		public ImmutableStack<T> Pop(out T value)
		{
			value = Peek();
			return Pop();
		}

		IImmutableStack<T> IImmutableStack<T>.Pop()
		{
			return Pop();
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return new EnumeratorObject(this);
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new EnumeratorObject(this);
		}

		internal ImmutableStack<T> Reverse()
		{
			ImmutableStack<T> immutableStack = Clear();
			ImmutableStack<T> immutableStack2 = this;
			while (!immutableStack2.IsEmpty)
			{
				immutableStack = immutableStack.Push(immutableStack2.Peek());
				immutableStack2 = immutableStack2.Pop();
			}
			return immutableStack;
		}
	}
	internal abstract class KeysOrValuesCollectionAccessor<TKey, TValue, T> : ICollection<T>, IEnumerable<T>, IEnumerable, ICollection where TKey : notnull
	{
		private readonly IImmutableDictionary<TKey, TValue> _dictionary;

		private readonly IEnumerable<T> _keysOrValues;

		public bool IsReadOnly => true;

		public int Count => _dictionary.Count;

		protected IImmutableDictionary<TKey, TValue> Dictionary => _dictionary;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		protected KeysOrValuesCollectionAccessor(IImmutableDictionary<TKey, TValue> dictionary, IEnumerable<T> keysOrValues)
		{
			Requires.NotNull(dictionary, "dictionary");
			Requires.NotNull(keysOrValues, "keysOrValues");
			_dictionary = dictionary;
			_keysOrValues = keysOrValues;
		}

		public void Add(T item)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public abstract bool Contains(T item);

		public void CopyTo(T[] array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using IEnumerator<T> enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				array[arrayIndex++] = current;
			}
		}

		public bool Remove(T item)
		{
			throw new NotSupportedException();
		}

		public IEnumerator<T> GetEnumerator()
		{
			return _keysOrValues.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using IEnumerator<T> enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				array.SetValue(current, arrayIndex++);
			}
		}
	}
	internal sealed class KeysCollectionAccessor<TKey, TValue> : KeysOrValuesCollectionAccessor<TKey, TValue, TKey> where TKey : notnull
	{
		internal KeysCollectionAccessor(IImmutableDictionary<TKey, TValue> dictionary)
			: base(dictionary, dictionary.Keys)
		{
		}

		public override bool Contains(TKey item)
		{
			return base.Dictionary.ContainsKey(item);
		}
	}
	internal sealed class ValuesCollectionAccessor<TKey, TValue> : KeysOrValuesCollectionAccessor<TKey, TValue, TValue> where TKey : notnull
	{
		internal ValuesCollectionAccessor(IImmutableDictionary<TKey, TValue> dictionary)
			: base(dictionary, dictionary.Values)
		{
		}

		public override bool Contains(TValue item)
		{
			if (base.Dictionary is ImmutableSortedDictionary<TKey, TValue> immutableSortedDictionary)
			{
				return immutableSortedDictionary.ContainsValue(item);
			}
			if (base.Dictionary is IImmutableDictionaryInternal<TKey, TValue> immutableDictionaryInternal)
			{
				return immutableDictionaryInternal.ContainsValue(item);
			}
			throw new NotSupportedException();
		}
	}
	[DebuggerDisplay("{Value,nq}")]
	internal struct RefAsValueType<T>
	{
		internal T Value;

		internal RefAsValueType(T value)
		{
			Value = value;
		}
	}
	internal static class SecureObjectPool
	{
		private static int s_poolUserIdCounter;

		internal const int UnassignedId = -1;

		internal static int NewId()
		{
			int num;
			do
			{
				num = Interlocked.Increment(ref s_poolUserIdCounter);
			}
			while (num == -1);
			return num;
		}
	}
	internal static class SecureObjectPool<T, TCaller> where TCaller : ISecurePooledObjectUser
	{
		public static void TryAdd(TCaller caller, SecurePooledObject<T> item)
		{
			if (caller.PoolUserId == item.Owner)
			{
				item.Owner = -1;
				AllocFreeConcurrentStack<SecurePooledObject<T>>.TryAdd(item);
			}
		}

		public static bool TryTake(TCaller caller, out SecurePooledObject<T>? item)
		{
			if (caller.PoolUserId != -1 && AllocFreeConcurrentStack<SecurePooledObject<T>>.TryTake(out item))
			{
				item.Owner = caller.PoolUserId;
				return true;
			}
			item = null;
			return false;
		}

		public static SecurePooledObject<T> PrepNew(TCaller caller, T newValue)
		{
			Requires.NotNullAllowStructs(newValue, "newValue");
			return new SecurePooledObject<T>(newValue)
			{
				Owner = caller.PoolUserId
			};
		}
	}
	internal interface ISecurePooledObjectUser
	{
		int PoolUserId { get; }
	}
	internal sealed class SecurePooledObject<T>
	{
		private readonly T _value;

		private int _owner;

		internal int Owner
		{
			get
			{
				return _owner;
			}
			set
			{
				_owner = value;
			}
		}

		internal SecurePooledObject(T newValue)
		{
			Requires.NotNullAllowStructs(newValue, "newValue");
			_value = newValue;
		}

		internal T Use<TCaller>(ref TCaller caller) where TCaller : struct, ISecurePooledObjectUser
		{
			if (!IsOwned(ref caller))
			{
				Requires.FailObjectDisposed(caller);
			}
			return _value;
		}

		internal bool TryUse<TCaller>(ref TCaller caller, [MaybeNullWhen(false)] out T value) where TCaller : struct, ISecurePooledObjectUser
		{
			if (IsOwned(ref caller))
			{
				value = _value;
				return true;
			}
			value = default(T);
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool IsOwned<TCaller>(ref TCaller caller) where TCaller : struct, ISecurePooledObjectUser
		{
			return caller.PoolUserId == _owner;
		}
	}
	[DebuggerDisplay("{_key} = {_value}")]
	internal sealed class SortedInt32KeyNode<TValue> : IBinaryTree
	{
		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator : IEnumerator<KeyValuePair<int, TValue>>, IEnumerator, IDisposable, ISecurePooledObjectUser
		{
			private readonly int _poolUserId;

			private SortedInt32KeyNode<TValue> _root;

			private SecurePooledObject<Stack<RefAsValueType<SortedInt32KeyNode<TValue>>>> _stack;

			private SortedInt32KeyNode<TValue> _current;

			public KeyValuePair<int, TValue> Current
			{
				get
				{
					ThrowIfDisposed();
					if (_current != null)
					{
						return _current.Value;
					}
					throw new InvalidOperationException();
				}
			}

			int ISecurePooledObjectUser.PoolUserId => _poolUserId;

			object IEnumerator.Current => Current;

			internal Enumerator(SortedInt32KeyNode<TValue> root)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_current = null;
				_poolUserId = SecureObjectPool.NewId();
				_stack = null;
				if (!_root.IsEmpty)
				{
					if (!SecureObjectPool<Stack<RefAsValueType<SortedInt32KeyNode<TValue>>>, Enumerator>.TryTake(this, out _stack))
					{
						_stack = SecureObjectPool<Stack<RefAsValueType<SortedInt32KeyNode<TValue>>>, Enumerator>.PrepNew(this, new Stack<RefAsValueType<SortedInt32KeyNode<TValue>>>(root.Height));
					}
					PushLeft(_root);
				}
			}

			public void Dispose()
			{
				_root = null;
				_current = null;
				if (_stack != null && _stack.TryUse(ref this, out var value))
				{
					value.ClearFastWhenEmpty();
					SecureObjectPool<Stack<RefAsValueType<SortedInt32KeyNode<TValue>>>, Enumerator>.TryAdd(this, _stack);
				}
				_stack = null;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				if (_stack != null)
				{
					Stack<RefAsValueType<SortedInt32KeyNode<TValue>>> stack = _stack.Use(ref this);
					if (stack.Count > 0)
					{
						PushLeft((_current = stack.Pop().Value).Right);
						return true;
					}
				}
				_current = null;
				return false;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_current = null;
				if (_stack != null)
				{
					_stack.Use(ref this).ClearFastWhenEmpty();
					PushLeft(_root);
				}
			}

			internal void ThrowIfDisposed()
			{
				if (_root == null || (_stack != null && !_stack.IsOwned(ref this)))
				{
					Requires.FailObjectDisposed(this);
				}
			}

			private void PushLeft(SortedInt32KeyNode<TValue> node)
			{
				Requires.NotNull(node, "node");
				Stack<RefAsValueType<SortedInt32KeyNode<TValue>>> stack = _stack.Use(ref this);
				while (!node.IsEmpty)
				{
					stack.Push(new RefAsValueType<SortedInt32KeyNode<TValue>>(node));
					node = node.Left;
				}
			}
		}

		internal static readonly SortedInt32KeyNode<TValue> EmptyNode = new SortedInt32KeyNode<TValue>();

		private readonly int _key;

		private readonly TValue _value;

		private bool _frozen;

		private byte _height;

		private SortedInt32KeyNode<TValue> _left;

		private SortedInt32KeyNode<TValue> _right;

		public bool IsEmpty => _left == null;

		public int Height => _height;

		public SortedInt32KeyNode<TValue>? Left => _left;

		public SortedInt32KeyNode<TValue>? Right => _right;

		IBinaryTree? IBinaryTree.Left => _left;

		IBinaryTree? IBinaryTree.Right => _right;

		int IBinaryTree.Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public KeyValuePair<int, TValue> Value => new KeyValuePair<int, TValue>(_key, _value);

		internal IEnumerable<TValue> Values
		{
			get
			{
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					yield return enumerator.Current.Value;
				}
			}
		}

		private SortedInt32KeyNode()
		{
			_frozen = true;
		}

		private SortedInt32KeyNode(int key, TValue value, SortedInt32KeyNode<TValue> left, SortedInt32KeyNode<TValue> right, bool frozen = false)
		{
			Requires.NotNull(left, "left");
			Requires.NotNull(right, "right");
			_key = key;
			_value = value;
			_left = left;
			_right = right;
			_frozen = frozen;
			_height = checked((byte)(1 + Math.Max(left._height, right._height)));
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		internal SortedInt32KeyNode<TValue> SetItem(int key, TValue value, IEqualityComparer<TValue> valueComparer, out bool replacedExistingValue, out bool mutated)
		{
			Requires.NotNull(valueComparer, "valueComparer");
			return SetOrAdd(key, value, valueComparer, overwriteExistingValue: true, out replacedExistingValue, out mutated);
		}

		internal SortedInt32KeyNode<TValue> Remove(int key, out bool mutated)
		{
			return RemoveRecursive(key, out mutated);
		}

		internal TValue? GetValueOrDefault(int key)
		{
			SortedInt32KeyNode<TValue> sortedInt32KeyNode = this;
			while (true)
			{
				if (sortedInt32KeyNode.IsEmpty)
				{
					return default(TValue);
				}
				if (key == sortedInt32KeyNode._key)
				{
					break;
				}
				sortedInt32KeyNode = ((key <= sortedInt32KeyNode._key) ? sortedInt32KeyNode._left : sortedInt32KeyNode._right);
			}
			return sortedInt32KeyNode._value;
		}

		internal bool TryGetValue(int key, [MaybeNullWhen(false)] out TValue value)
		{
			SortedInt32KeyNode<TValue> sortedInt32KeyNode = this;
			while (true)
			{
				if (sortedInt32KeyNode.IsEmpty)
				{
					value = default(TValue);
					return false;
				}
				if (key == sortedInt32KeyNode._key)
				{
					break;
				}
				sortedInt32KeyNode = ((key <= sortedInt32KeyNode._key) ? sortedInt32KeyNode._left : sortedInt32KeyNode._right);
			}
			value = sortedInt32KeyNode._value;
			return true;
		}

		internal void Freeze(Action<KeyValuePair<int, TValue>>? freezeAction = null)
		{
			if (!_frozen)
			{
				freezeAction?.Invoke(new KeyValuePair<int, TValue>(_key, _value));
				_left.Freeze(freezeAction);
				_right.Freeze(freezeAction);
				_frozen = true;
			}
		}

		private static SortedInt32KeyNode<TValue> RotateLeft(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (tree._right.IsEmpty)
			{
				return tree;
			}
			SortedInt32KeyNode<TValue> right = tree._right;
			return right.Mutate(tree.Mutate(null, right._left));
		}

		private static SortedInt32KeyNode<TValue> RotateRight(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (tree._left.IsEmpty)
			{
				return tree;
			}
			SortedInt32KeyNode<TValue> left = tree._left;
			return left.Mutate(null, tree.Mutate(left._right));
		}

		private static SortedInt32KeyNode<TValue> DoubleLeft(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (tree._right.IsEmpty)
			{
				return tree;
			}
			return RotateLeft(tree.Mutate(null, RotateRight(tree._right)));
		}

		private static SortedInt32KeyNode<TValue> DoubleRight(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (tree._left.IsEmpty)
			{
				return tree;
			}
			return RotateRight(tree.Mutate(RotateLeft(tree._left)));
		}

		private static int Balance(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			return tree._right._height - tree._left._height;
		}

		private static bool IsRightHeavy(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			return Balance(tree) >= 2;
		}

		private static bool IsLeftHeavy(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			return Balance(tree) <= -2;
		}

		private static SortedInt32KeyNode<TValue> MakeBalanced(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (IsRightHeavy(tree))
			{
				if (Balance(tree._right) >= 0)
				{
					return RotateLeft(tree);
				}
				return DoubleLeft(tree);
			}
			if (IsLeftHeavy(tree))
			{
				if (Balance(tree._left) <= 0)
				{
					return RotateRight(tree);
				}
				return DoubleRight(tree);
			}
			return tree;
		}

		private SortedInt32KeyNode<TValue> SetOrAdd(int key, TValue value, IEqualityComparer<TValue> valueComparer, bool overwriteExistingValue, out bool replacedExistingValue, out bool mutated)
		{
			replacedExistingValue = false;
			if (IsEmpty)
			{
				mutated = true;
				return new SortedInt32KeyNode<TValue>(key, value, this, this);
			}
			SortedInt32KeyNode<TValue> sortedInt32KeyNode = this;
			if (key > _key)
			{
				SortedInt32KeyNode<TValue> right = _right.SetOrAdd(key, value, valueComparer, overwriteExistingValue, out replacedExistingValue, out mutated);
				if (mutated)
				{
					sortedInt32KeyNode = Mutate(null, right);
				}
			}
			else if (key < _key)
			{
				SortedInt32KeyNode<TValue> left = _left.SetOrAdd(key, value, valueComparer, overwriteExistingValue, out replacedExistingValue, out mutated);
				if (mutated)
				{
					sortedInt32KeyNode = Mutate(left);
				}
			}
			else
			{
				if (valueComparer.Equals(_value, value))
				{
					mutated = false;
					return this;
				}
				if (!overwriteExistingValue)
				{
					throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
				}
				mutated = true;
				replacedExistingValue = true;
				sortedInt32KeyNode = new SortedInt32KeyNode<TValue>(key, value, _left, _right);
			}
			if (!mutated)
			{
				return sortedInt32KeyNode;
			}
			return MakeBalanced(sortedInt32KeyNode);
		}

		private SortedInt32KeyNode<TValue> RemoveRecursive(int key, out bool mutated)
		{
			if (IsEmpty)
			{
				mutated = false;
				return this;
			}
			SortedInt32KeyNode<TValue> sortedInt32KeyNode = this;
			if (key == _key)
			{
				mutated = true;
				if (_right.IsEmpty && _left.IsEmpty)
				{
					sortedInt32KeyNode = EmptyNode;
				}
				else if (_right.IsEmpty && !_left.IsEmpty)
				{
					sortedInt32KeyNode = _left;
				}
				else if (!_right.IsEmpty && _left.IsEmpty)
				{
					sortedInt32KeyNode = _right;
				}
				else
				{
					SortedInt32KeyNode<TValue> sortedInt32KeyNode2 = _right;
					while (!sortedInt32KeyNode2._left.IsEmpty)
					{
						sortedInt32KeyNode2 = sortedInt32KeyNode2._left;
					}
					bool mutated2;
					SortedInt32KeyNode<TValue> right = _right.Remove(sortedInt32KeyNode2._key, out mutated2);
					sortedInt32KeyNode = sortedInt32KeyNode2.Mutate(_left, right);
				}
			}
			else if (key < _key)
			{
				SortedInt32KeyNode<TValue> left = _left.Remove(key, out mutated);
				if (mutated)
				{
					sortedInt32KeyNode = Mutate(left);
				}
			}
			else
			{
				SortedInt32KeyNode<TValue> right2 = _right.Remove(key, out mutated);
				if (mutated)
				{
					sortedInt32KeyNode = Mutate(null, right2);
				}
			}
			if (!sortedInt32KeyNode.IsEmpty)
			{
				return MakeBalanced(sortedInt32KeyNode);
			}
			return sortedInt32KeyNode;
		}

		private SortedInt32KeyNode<TValue> Mutate(SortedInt32KeyNode<TValue> left = null, SortedInt32KeyNode<TValue> right = null)
		{
			if (_frozen)
			{
				return new SortedInt32KeyNode<TValue>(_key, _value, left ?? _left, right ?? _right);
			}
			if (left != null)
			{
				_left = left;
			}
			if (right != null)
			{
				_right = right;
			}
			_height = checked((byte)(1 + Math.Max(_left._height, _right._height)));
			return this;
		}
	}
	internal static class Requires
	{
		[DebuggerStepThrough]
		public static void NotNull<T>([NotNull] T value, string? parameterName) where T : class
		{
			if (value == null)
			{
				FailArgumentNullException(parameterName);
			}
		}

		[DebuggerStepThrough]
		public static T NotNullPassthrough<T>([NotNull] T value, string? parameterName) where T : class
		{
			NotNull(value, parameterName);
			return value;
		}

		[DebuggerStepThrough]
		public static void NotNullAllowStructs<T>([NotNull] T value, string? parameterName)
		{
			if (value == null)
			{
				FailArgumentNullException(parameterName);
			}
		}

		[DoesNotReturn]
		[DebuggerStepThrough]
		public static void FailArgumentNullException(string? parameterName)
		{
			throw new ArgumentNullException(parameterName);
		}

		[DebuggerStepThrough]
		public static void Range([DoesNotReturnIf(false)] bool condition, string? parameterName, string? message = null)
		{
			if (!condition)
			{
				FailRange(parameterName, message);
			}
		}

		[DoesNotReturn]
		[DebuggerStepThrough]
		public static void FailRange(string? parameterName, string? message = null)
		{
			if (string.IsNullOrEmpty(message))
			{
				throw new ArgumentOutOfRangeException(parameterName);
			}
			throw new ArgumentOutOfRangeException(parameterName, message);
		}

		[DebuggerStepThrough]
		public static void Argument([DoesNotReturnIf(false)] bool condition, string? parameterName, string? message)
		{
			if (!condition)
			{
				throw new ArgumentException(message, parameterName);
			}
		}

		[DebuggerStepThrough]
		public static void Argument([DoesNotReturnIf(false)] bool condition)
		{
			if (!condition)
			{
				throw new ArgumentException();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[DoesNotReturn]
		[DebuggerStepThrough]
		public static void FailObjectDisposed<TDisposed>(TDisposed disposed)
		{
			throw new ObjectDisposedException(disposed.GetType().FullName);
		}
	}
}
namespace System.Collections.Frozen
{
	internal static class Constants
	{
		public const int MaxItemsInSmallFrozenCollection = 4;

		public const int MaxItemsInSmallValueTypeFrozenCollection = 10;

		public static bool IsKnownComparable<T>()
		{
			if (!(typeof(T) == typeof(bool)) && !(typeof(T) == typeof(sbyte)) && !(typeof(T) == typeof(byte)) && !(typeof(T) == typeof(char)) && !(typeof(T) == typeof(short)) && !(typeof(T) == typeof(ushort)) && !(typeof(T) == typeof(int)) && !(typeof(T) == typeof(uint)) && !(typeof(T) == typeof(long)) && !(typeof(T) == typeof(ulong)) && !(typeof(T) == typeof(decimal)) && !(typeof(T) == typeof(float)) && !(typeof(T) == typeof(double)) && !(typeof(T) == typeof(decimal)) && !(typeof(T) == typeof(TimeSpan)) && !(typeof(T) == typeof(DateTime)) && !(typeof(T) == typeof(DateTimeOffset)) && !(typeof(T) == typeof(Guid)))
			{
				return typeof(T).IsEnum;
			}
			return true;
		}

		internal static bool KeysAreHashCodes<T>()
		{
			if (!(typeof(T) == typeof(int)) && !(typeof(T) == typeof(uint)) && !(typeof(T) == typeof(short)) && !(typeof(T) == typeof(ushort)) && !(typeof(T) == typeof(byte)) && !(typeof(T) == typeof(sbyte)))
			{
				if (typeof(T) == typeof(IntPtr) || typeof(T) == typeof(UIntPtr))
				{
					return IntPtr.Size == 4;
				}
				return false;
			}
			return true;
		}
	}
	internal sealed class DefaultFrozenDictionary<TKey, TValue> : KeysAndValuesFrozenDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		internal DefaultFrozenDictionary(Dictionary<TKey, TValue> source)
			: base(source, keysAreHashCodes: false)
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(TKey key)
		{
			IEqualityComparer<TKey> comparer = base.Comparer;
			int hashCode = comparer.GetHashCode(key);
			_hashTable.FindMatchingEntries(hashCode, out var i, out var endIndex);
			for (; i <= endIndex; i++)
			{
				if (hashCode == _hashTable.HashCodes[i] && comparer.Equals(key, _keys[i]))
				{
					return ref _values[i];
				}
			}
			return ref Unsafe.NullRef<TValue>();
		}
	}
	internal sealed class DefaultFrozenSet<T> : ItemsFrozenSet<T, DefaultFrozenSet<T>.GSW>
	{
		internal struct GSW : IGenericSpecializedWrapper
		{
			private DefaultFrozenSet<T> _set;

			public int Count => _set.Count;

			public IEqualityComparer<T> Comparer => _set.Comparer;

			public void Store(FrozenSet<T> set)
			{
				_set = (DefaultFrozenSet<T>)set;
			}

			public int FindItemIndex(T item)
			{
				return _set.FindItemIndex(item);
			}

			public Enumerator GetEnumerator()
			{
				return _set.GetEnumerator();
			}
		}

		internal DefaultFrozenSet(HashSet<T> source)
			: base(source, keysAreHashCodes: false)
		{
		}

		private protected override int FindItemIndex(T item)
		{
			IEqualityComparer<T> comparer = base.Comparer;
			int num = ((item != null) ? comparer.GetHashCode(item) : 0);
			_hashTable.FindMatchingEntries(num, out var i, out var endIndex);
			for (; i <= endIndex; i++)
			{
				if (num == _hashTable.HashCodes[i] && comparer.Equals(item, _items[i]))
				{
					return i;
				}
			}
			return -1;
		}
	}
	internal sealed class EmptyFrozenDictionary<TKey, TValue> : FrozenDictionary<TKey, TValue> where TKey : notnull
	{
		private protected override TKey[] KeysCore => Array.Empty<TKey>();

		private protected override TValue[] ValuesCore => Array.Empty<TValue>();

		private protected override int CountCore => 0;

		internal EmptyFrozenDictionary(IEqualityComparer<TKey> comparer)
			: base(comparer)
		{
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenDictionary<TKey, TValue>.Enumerator(Array.Empty<TKey>(), Array.Empty<TValue>());
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(TKey key)
		{
			return ref Unsafe.NullRef<TValue>();
		}
	}
	internal sealed class EmptyFrozenSet<T> : FrozenSet<T>
	{
		private protected override T[] ItemsCore => Array.Empty<T>();

		private protected override int CountCore => 0;

		internal EmptyFrozenSet(IEqualityComparer<T> comparer)
			: base(comparer)
		{
		}

		private protected override int FindItemIndex(T item)
		{
			return -1;
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenSet<T>.Enumerator(Array.Empty<T>());
		}

		private protected override bool IsProperSubsetOfCore(IEnumerable<T> other)
		{
			return !OtherIsEmpty(other);
		}

		private protected override bool IsProperSupersetOfCore(IEnumerable<T> other)
		{
			return false;
		}

		private protected override bool IsSubsetOfCore(IEnumerable<T> other)
		{
			return true;
		}

		private protected override bool IsSupersetOfCore(IEnumerable<T> other)
		{
			return OtherIsEmpty(other);
		}

		private protected override bool OverlapsCore(IEnumerable<T> other)
		{
			return false;
		}

		private protected override bool SetEqualsCore(IEnumerable<T> other)
		{
			return OtherIsEmpty(other);
		}

		private static bool OtherIsEmpty(IEnumerable<T> other)
		{
			if (!(other is IReadOnlyCollection<T> readOnlyCollection))
			{
				return !other.Any();
			}
			return readOnlyCollection.Count == 0;
		}
	}
	public static class FrozenDictionary
	{
		public static FrozenDictionary<TKey, TValue> ToFrozenDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey>? comparer = null) where TKey : notnull
		{
			Dictionary<TKey, TValue> newDictionary;
			return GetExistingFrozenOrNewDictionary<TKey, TValue>(source, comparer, out newDictionary) ?? CreateFromDictionary(newDictionary);
		}

		public static FrozenDictionary<TKey, TSource> ToFrozenDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer = null) where TKey : notnull
		{
			return source.ToDictionary(keySelector, comparer).ToFrozenDictionary(comparer);
		}

		public static FrozenDictionary<TKey, TElement> ToFrozenDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer = null) where TKey : notnull
		{
			return source.ToDictionary(keySelector, elementSelector, comparer).ToFrozenDictionary(comparer);
		}

		private static FrozenDictionary<TKey, TValue> GetExistingFrozenOrNewDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey> comparer, out Dictionary<TKey, TValue> newDictionary)
		{
			ThrowHelper.ThrowIfNull(source, "source");
			if (comparer == null)
			{
				comparer = EqualityComparer<TKey>.Default;
			}
			if (source is FrozenDictionary<TKey, TValue> frozenDictionary && frozenDictionary.Comparer.Equals(comparer))
			{
				newDictionary = null;
				return frozenDictionary;
			}
			newDictionary = source as Dictionary<TKey, TValue>;
			if (newDictionary == null || (newDictionary.Count != 0 && !newDictionary.Comparer.Equals(comparer)))
			{
				newDictionary = new Dictionary<TKey, TValue>(comparer);
				foreach (KeyValuePair<TKey, TValue> item in source)
				{
					newDictionary[item.Key] = item.Value;
				}
			}
			if (newDictionary.Count == 0)
			{
				if (comparer != FrozenDictionary<TKey, TValue>.Empty.Comparer)
				{
					return new EmptyFrozenDictionary<TKey, TValue>(comparer);
				}
				return FrozenDictionary<TKey, TValue>.Empty;
			}
			return null;
		}

		private static FrozenDictionary<TKey, TValue> CreateFromDictionary<TKey, TValue>(Dictionary<TKey, TValue> source)
		{
			IEqualityComparer<TKey> comparer = source.Comparer;
			if (typeof(TKey).IsValueType && comparer == EqualityComparer<TKey>.Default)
			{
				if (source.Count <= 10)
				{
					if (Constants.IsKnownComparable<TKey>())
					{
						return new SmallValueTypeComparableFrozenDictionary<TKey, TValue>(source);
					}
					return new SmallValueTypeDefaultComparerFrozenDictionary<TKey, TValue>(source);
				}
				if (typeof(TKey) == typeof(int))
				{
					return (FrozenDictionary<TKey, TValue>)(object)new Int32FrozenDictionary<TValue>((Dictionary<int, TValue>)(object)source);
				}
				return new ValueTypeDefaultComparerFrozenDictionary<TKey, TValue>(source);
			}
			if (typeof(TKey) == typeof(string) && (comparer == EqualityComparer<TKey>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase))
			{
				IEqualityComparer<string> equalityComparer = (IEqualityComparer<string>)comparer;
				string[] array = (string[])(object)source.Keys.ToArray();
				TValue[] values = source.Values.ToArray();
				int num = int.MaxValue;
				int num2 = 0;
				ulong num3 = 0uL;
				string[] array2 = array;
				foreach (string text in array2)
				{
					if (text.Length < num)
					{
						num = text.Length;
					}
					if (text.Length > num2)
					{
						num2 = text.Length;
					}
					num3 |= (ulong)(1L << text.Length % 64);
				}
				FrozenDictionary<string, TValue> frozenDictionary = LengthBucketsFrozenDictionary<TValue>.CreateLengthBucketsFrozenDictionaryIfAppropriate(array, values, equalityComparer, num, num2);
				if (frozenDictionary != null)
				{
					return (FrozenDictionary<TKey, TValue>)(object)frozenDictionary;
				}
				KeyAnalyzer.AnalysisResults analysisResults = KeyAnalyzer.Analyze(array, equalityComparer == StringComparer.OrdinalIgnoreCase, num, num2);
				frozenDictionary = (analysisResults.SubstringHashing ? (analysisResults.RightJustifiedSubstring ? ((!analysisResults.IgnoreCase) ? ((analysisResults.HashCount == 1) ? ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_RightJustifiedSingleChar<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex)) : ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_RightJustifiedSubstring<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount))) : (analysisResults.AllAsciiIfIgnoreCase ? ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveAsciiSubstring<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount)) : ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveSubstring<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount)))) : ((!analysisResults.IgnoreCase) ? ((analysisResults.HashCount == 1) ? ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_LeftJustifiedSingleChar<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex)) : ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_LeftJustifiedSubstring<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount))) : (analysisResults.AllAsciiIfIgnoreCase ? ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveAsciiSubstring<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount)) : ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveSubstring<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount))))) : ((!analysisResults.IgnoreCase) ? new OrdinalStringFrozenDictionary_Full<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, num3) : (analysisResults.AllAsciiIfIgnoreCase ? ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_FullCaseInsensitiveAscii<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, num3)) : ((OrdinalStringFrozenDictionary<TValue>)new OrdinalStringFrozenDictionary_FullCaseInsensitive<TValue>(array, values, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, num3)))));
				return (FrozenDictionary<TKey, TValue>)(object)frozenDictionary;
			}
			if (source.Count <= 4)
			{
				return new SmallFrozenDictionary<TKey, TValue>(source);
			}
			return new DefaultFrozenDictionary<TKey, TValue>(source);
		}
	}
	[DebuggerTypeProxy(typeof(ImmutableDictionaryDebuggerProxy<, >))]
	[DebuggerDisplay("Count = {Count}")]
	public abstract class FrozenDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection where TKey : notnull
	{
		public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IEnumerator, IDisposable
		{
			private readonly TKey[] _keys;

			private readonly TValue[] _values;

			private int _index;

			public readonly KeyValuePair<TKey, TValue> Current
			{
				get
				{
					if ((uint)_index >= (uint)_keys.Length)
					{
						ThrowHelper.ThrowInvalidOperationException();
					}
					return new KeyValuePair<TKey, TValue>(_keys[_index], _values[_index]);
				}
			}

			object IEnumerator.Current => Current;

			internal Enumerator(TKey[] keys, TValue[] values)
			{
				_keys = keys;
				_values = values;
				_index = -1;
			}

			public bool MoveNext()
			{
				_index++;
				if ((uint)_index < (uint)_keys.Length)
				{
					return true;
				}
				_index = _keys.Length;
				return false;
			}

			void IEnumerator.Reset()
			{
				_index = -1;
			}

			void IDisposable.Dispose()
			{
			}
		}

		public static FrozenDictionary<TKey, TValue> Empty { get; } = new EmptyFrozenDictionary<TKey, TValue>(EqualityComparer<TKey>.Default);


		public IEqualityComparer<TKey> Comparer { get; }

		public ImmutableArray<TKey> Keys => ImmutableCollectionsMarshal.AsImmutableArray(KeysCore);

		private protected abstract TKey[] KeysCore { get; }

		ICollection<TKey> IDictionary<TKey, TValue>.Keys
		{
			get
			{
				ImmutableArray<TKey> keys = Keys;
				if (keys.Length <= 0)
				{
					return Array.Empty<TKey>();
				}
				return keys;
			}
		}

		IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => ((IDictionary<TKey, TValue>)this).Keys;

		ICollection IDictionary.Keys => Keys;

		public ImmutableArray<TValue> Values => ImmutableCollectionsMarshal.AsImmutableArray(ValuesCore);

		private protected abstract TValue[] ValuesCore { get; }

		ICollection<TValue> IDictionary<TKey, TValue>.Values
		{
			get
			{
				ImmutableArray<TValue> values = Values;
				if (values.Length <= 0)
				{
					return Array.Empty<TValue>();
				}
				return values;
			}
		}

		ICollection IDictionary.Values => Values;

		IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => ((IDictionary<TKey, TValue>)this).Values;

		public int Count => CountCore;

		private protected abstract int CountCore { get; }

		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true;

		bool IDictionary.IsReadOnly => true;

		bool IDictionary.IsFixedSize => true;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => this;

		object? IDictionary.this[object key]
		{
			get
			{
				ThrowHelper.ThrowIfNull(key, "key");
				if (!(key is TKey key2) || !TryGetValue(key2, out var value))
				{
					return null;
				}
				return value;
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		public ref readonly TValue this[TKey key]
		{
			get
			{
				ref readonly TValue valueRefOrNullRef = ref GetValueRefOrNullRef(key);
				if (Unsafe.IsNullRef(ref Unsafe.AsRef(in valueRefOrNullRef)))
				{
					ThrowHelper.ThrowKeyNotFoundException(key);
				}
				return ref valueRefOrNullRef;
			}
		}

		TValue IDictionary<TKey, TValue>.this[TKey key]
		{
			get
			{
				return this[key];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		TValue IReadOnlyDictionary<TKey, TValue>.this[TKey key] => this[key];

		private protected FrozenDictionary(IEqualityComparer<TKey> comparer)
		{
			Comparer = comparer;
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] destination, int destinationIndex)
		{
			ThrowHelper.ThrowIfNull(destination, "destination");
			CopyTo(destination.AsSpan(destinationIndex));
		}

		public void CopyTo(Span<KeyValuePair<TKey, TValue>> destination)
		{
			if (destination.Length < Count)
			{
				ThrowHelper.ThrowIfDestinationTooSmall();
			}
			TKey[] keysCore = KeysCore;
			TValue[] valuesCore = ValuesCore;
			for (int i = 0; i < keysCore.Length; i++)
			{
				destination[i] = new KeyValuePair<TKey, TValue>(keysCore[i], valuesCore[i]);
			}
		}

		void ICollection.CopyTo(Array array, int index)
		{
			ThrowHelper.ThrowIfNull(array, "array");
			if (array.Rank != 1)
			{
				throw new ArgumentException(System.SR.Arg_RankMultiDimNotSupported, "array");
			}
			if (array.GetLowerBound(0) != 0)
			{
				throw new ArgumentException(System.SR.Arg_NonZeroLowerBound, "array");
			}
			if ((uint)index > (uint)array.Length)
			{
				throw new ArgumentOutOfRangeException("index", System.SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (array.Length - index < Count)
			{
				throw new ArgumentException(System.SR.Arg_ArrayPlusOffTooSmall, "array");
			}
			if (array is KeyValuePair<TKey, TValue>[] array2)
			{
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					array2[index++] = new KeyValuePair<TKey, TValue>(current.Key, current.Value);
				}
				return;
			}
			if (array is DictionaryEntry[] array3)
			{
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current2 = enumerator.Current;
					array3[index++] = new DictionaryEntry(current2.Key, current2.Value);
				}
				return;
			}
			if (!(array is object[] array4))
			{
				throw new ArgumentException(System.SR.Argument_IncompatibleArrayType, "array");
			}
			try
			{
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current3 = enumerator.Current;
					array4[index++] = new KeyValuePair<TKey, TValue>(current3.Key, current3.Value);
				}
			}
			catch (ArrayTypeMismatchException)
			{
				throw new ArgumentException(System.SR.Argument_IncompatibleArrayType, "array");
			}
		}

		public ref readonly TValue GetValueRefOrNullRef(TKey key)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException("key");
			}
			return ref GetValueRefOrNullRefCore(key);
		}

		private protected abstract ref readonly TValue GetValueRefOrNullRefCore(TKey key);

		private protected virtual ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key) where TAlternateKey : notnull
		{
			return ref Unsafe.NullRef<TValue>();
		}

		public bool ContainsKey(TKey key)
		{
			return !Unsafe.IsNullRef(ref Unsafe.AsRef(in GetValueRefOrNullRef(key)));
		}

		bool IDictionary.Contains(object key)
		{
			ThrowHelper.ThrowIfNull(key, "key");
			if (key is TKey key2)
			{
				return ContainsKey(key2);
			}
			return false;
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
		{
			if (TryGetValue(item.Key, out var value))
			{
				return EqualityComparer<TValue>.Default.Equals(value, item.Value);
			}
			return false;
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			ref readonly TValue valueRefOrNullRef = ref GetValueRefOrNullRef(key);
			if (!Unsafe.IsNullRef(ref Unsafe.AsRef(in valueRefOrNullRef)))
			{
				value = valueRefOrNullRef;
				return true;
			}
			value = default(TValue);
			return false;
		}

		public Enumerator GetEnumerator()
		{
			return GetEnumeratorCore();
		}

		private protected abstract Enumerator GetEnumeratorCore();

		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			if (Count != 0)
			{
				return GetEnumerator();
			}
			return ((IEnumerable<KeyValuePair<TKey, TValue>>)Array.Empty<KeyValuePair<TKey, TValue>>()).GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			if (Count != 0)
			{
				return GetEnumerator();
			}
			return Array.Empty<KeyValuePair<TKey, TValue>>().GetEnumerator();
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return new DictionaryEnumerator<TKey, TValue>(GetEnumerator());
		}

		void IDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void IDictionary.Add(object key, object value)
		{
			throw new NotSupportedException();
		}

		bool IDictionary<TKey, TValue>.Remove(TKey key)
		{
			throw new NotSupportedException();
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void IDictionary.Remove(object key)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Clear()
		{
			throw new NotSupportedException();
		}

		void IDictionary.Clear()
		{
			throw new NotSupportedException();
		}
	}
	internal readonly struct FrozenHashTable
	{
		private readonly struct Bucket
		{
			public readonly int StartIndex;

			public readonly int EndIndex;

			public Bucket(int startIndex, int count)
			{
				StartIndex = startIndex;
				EndIndex = startIndex + count - 1;
			}
		}

		private readonly Bucket[] _buckets;

		private readonly ulong _fastModMultiplier;

		public int Count => HashCodes.Length;

		internal int[] HashCodes { get; }

		private FrozenHashTable(int[] hashCodes, Bucket[] buckets, ulong fastModMultiplier)
		{
			HashCodes = hashCodes;
			_buckets = buckets;
			_fastModMultiplier = fastModMultiplier;
		}

		public static FrozenHashTable Create(Span<int> hashCodes, bool hashCodesAreUnique = false)
		{
			int num = CalcNumBuckets(hashCodes, hashCodesAreUnique);
			ulong fastModMultiplier = System.Collections.HashHelpers.GetFastModMultiplier((uint)num);
			int[] array = ArrayPool<int>.Shared.Rent(num + hashCodes.Length);
			Span<int> span = array.AsSpan(0, num);
			Span<int> span2 = array.AsSpan(num, hashCodes.Length);
			span.Fill(-1);
			for (int i = 0; i < hashCodes.Length; i++)
			{
				int index = (int)System.Collections.HashHelpers.FastMod((uint)hashCodes[i], (uint)span.Length, fastModMultiplier);
				ref int reference = ref span[index];
				span2[i] = reference;
				reference = i;
			}
			int[] array2 = new int[hashCodes.Length];
			Bucket[] array3 = new Bucket[span.Length];
			int num2 = 0;
			for (int j = 0; j < array3.Length; j++)
			{
				int num3 = span[j];
				if (num3 >= 0)
				{
					int num4 = 0;
					int num5 = num3;
					num3 = num2;
					while (num5 >= 0)
					{
						ref int reference2 = ref hashCodes[num5];
						array2[num2] = reference2;
						reference2 = num2;
						num2++;
						num4++;
						num5 = span2[num5];
					}
					array3[j] = new Bucket(num3, num4);
				}
			}
			ArrayPool<int>.Shared.Return(array);
			return new FrozenHashTable(array2, array3, fastModMultiplier);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void FindMatchingEntries(int hashCode, out int startIndex, out int endIndex)
		{
			Bucket[] buckets = _buckets;
			ref Bucket reference = ref buckets[System.Collections.HashHelpers.FastMod((uint)hashCode, (uint)buckets.Length, _fastModMultiplier)];
			startIndex = reference.StartIndex;
			endIndex = reference.EndIndex;
		}

		private static int CalcNumBuckets(ReadOnlySpan<int> hashCodes, bool hashCodesAreUnique)
		{
			HashSet<int> hashSet = null;
			int num = hashCodes.Length;
			if (!hashCodesAreUnique)
			{
				hashSet = new HashSet<int>();
				ReadOnlySpan<int> readOnlySpan = hashCodes;
				for (int i = 0; i < readOnlySpan.Length; i++)
				{
					int item = readOnlySpan[i];
					hashSet.Add(item);
				}
				num = hashSet.Count;
			}
			int num2 = num * 2;
			ReadOnlySpan<int> primes = System.Collections.HashHelpers.Primes;
			int j;
			for (j = 0; (uint)j < (uint)primes.Length && num2 > primes[j]; j++)
			{
			}
			if (j >= primes.Length)
			{
				return System.Collections.HashHelpers.GetPrime(num);
			}
			int num3 = num * ((num >= 1000) ? 3 : 16);
			int k;
			for (k = j; (uint)k < (uint)primes.Length && num3 > primes[k]; k++)
			{
			}
			if (k < primes.Length)
			{
				num3 = primes[k - 1];
			}
			int[] seenBuckets = ArrayPool<int>.Shared.Rent(num3 / 32 + 1);
			int result = num3;
			int bestNumCollisions = num;
			int numBuckets = 0;
			int numCollisions = 0;
			for (int l = j; l < k; l++)
			{
				numBuckets = primes[l];
				Array.Clear(seenBuckets, 0, Math.Min(numBuckets, seenBuckets.Length));
				numCollisions = 0;
				if (hashSet != null && num != hashCodes.Length)
				{
					using HashSet<int>.Enumerator enumerator = hashSet.GetEnumerator();
					while (enumerator.MoveNext() && IsBucketFirstVisit(enumerator.Current))
					{
					}
				}
				else
				{
					ReadOnlySpan<int> readOnlySpan = hashCodes;
					for (int i = 0; i < readOnlySpan.Length && IsBucketFirstVisit(readOnlySpan[i]); i++)
					{
					}
				}
				if (numCollisions < bestNumCollisions)
				{
					result = numBuckets;
					if ((double)numCollisions / (double)num <= 0.05)
					{
						break;
					}
					bestNumCollisions = numCollisions;
				}
			}
			ArrayPool<int>.Shared.Return(seenBuckets);
			return result;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			bool IsBucketFirstVisit(int code)
			{
				uint num4 = (uint)code % (uint)numBuckets;
				if ((seenBuckets[num4 / 32] & (1 << (int)num4)) != 0)
				{
					numCollisions++;
					if (numCollisions >= bestNumCollisions)
					{
						return false;
					}
				}
				else
				{
					seenBuckets[num4 / 32] |= 1 << (int)num4;
				}
				return true;
			}
		}
	}
	public static class FrozenSet
	{
		public static FrozenSet<T> Create<T>([ParamCollection] scoped ReadOnlySpan<T> source)
		{
			return Create(null, source);
		}

		public static FrozenSet<T> Create<T>(IEqualityComparer<T>? equalityComparer, [ParamCollection] scoped ReadOnlySpan<T> source)
		{
			if (source.Length == 0)
			{
				if (equalityComparer != null && equalityComparer != FrozenSet<T>.Empty.Comparer)
				{
					return new EmptyFrozenSet<T>(equalityComparer);
				}
				return FrozenSet<T>.Empty;
			}
			HashSet<T> hashSet = new HashSet<T>(equalityComparer);
			ReadOnlySpan<T> readOnlySpan = source;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				T item = readOnlySpan[i];
				hashSet.Add(item);
			}
			return hashSet.ToFrozenSet(equalityComparer);
		}

		public static FrozenSet<T> ToFrozenSet<T>(this IEnumerable<T> source, IEqualityComparer<T>? comparer = null)
		{
			HashSet<T> newSet;
			return GetExistingFrozenOrNewSet<T>(source, comparer, out newSet) ?? CreateFromSet(newSet);
		}

		private static FrozenSet<T> GetExistingFrozenOrNewSet<T>(IEnumerable<T> source, IEqualityComparer<T> comparer, out HashSet<T> newSet)
		{
			ThrowHelper.ThrowIfNull(source, "source");
			if (comparer == null)
			{
				comparer = EqualityComparer<T>.Default;
			}
			if (source is FrozenSet<T> frozenSet && frozenSet.Comparer.Equals(comparer))
			{
				newSet = null;
				return frozenSet;
			}
			newSet = source as HashSet<T>;
			if (newSet == null || (newSet.Count != 0 && !newSet.Comparer.Equals(comparer)))
			{
				newSet = new HashSet<T>(source, comparer);
			}
			if (newSet.Count == 0)
			{
				if (comparer != FrozenSet<T>.Empty.Comparer)
				{
					return new EmptyFrozenSet<T>(comparer);
				}
				return FrozenSet<T>.Empty;
			}
			return null;
		}

		private static FrozenSet<T> CreateFromSet<T>(HashSet<T> source)
		{
			IEqualityComparer<T> comparer = source.Comparer;
			if (typeof(T).IsValueType && comparer == EqualityComparer<T>.Default)
			{
				if (source.Count <= 10)
				{
					if (Constants.IsKnownComparable<T>())
					{
						return new SmallValueTypeComparableFrozenSet<T>(source);
					}
					return new SmallValueTypeDefaultComparerFrozenSet<T>(source);
				}
				if (typeof(T) == typeof(int))
				{
					return (FrozenSet<T>)(object)new Int32FrozenSet((HashSet<int>)(object)source);
				}
				return new ValueTypeDefaultComparerFrozenSet<T>(source);
			}
			if (typeof(T) == typeof(string) && !source.Contains(default(T)) && (comparer == EqualityComparer<T>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase))
			{
				IEqualityComparer<string> equalityComparer = (IEqualityComparer<string>)comparer;
				HashSet<string> obj = (HashSet<string>)(object)source;
				string[] array = new string[obj.Count];
				obj.CopyTo(array);
				int num = int.MaxValue;
				int num2 = 0;
				ulong num3 = 0uL;
				string[] array2 = array;
				foreach (string text in array2)
				{
					if (text.Length < num)
					{
						num = text.Length;
					}
					if (text.Length > num2)
					{
						num2 = text.Length;
					}
					num3 |= (ulong)(1L << text.Length % 64);
				}
				FrozenSet<string> frozenSet = LengthBucketsFrozenSet.CreateLengthBucketsFrozenSetIfAppropriate(array, equalityComparer, num, num2);
				if (frozenSet != null)
				{
					return (FrozenSet<T>)(object)frozenSet;
				}
				KeyAnalyzer.AnalysisResults analysisResults = KeyAnalyzer.Analyze(array, equalityComparer == StringComparer.OrdinalIgnoreCase, num, num2);
				frozenSet = (analysisResults.SubstringHashing ? (analysisResults.RightJustifiedSubstring ? ((!analysisResults.IgnoreCase) ? ((analysisResults.HashCount == 1) ? ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_RightJustifiedSingleChar(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex)) : ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_RightJustifiedSubstring(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount))) : (analysisResults.AllAsciiIfIgnoreCase ? ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_RightJustifiedCaseInsensitiveAsciiSubstring(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount)) : ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_RightJustifiedCaseInsensitiveSubstring(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount)))) : ((!analysisResults.IgnoreCase) ? ((analysisResults.HashCount == 1) ? ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_LeftJustifiedSingleChar(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex)) : ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_LeftJustifiedSubstring(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount))) : (analysisResults.AllAsciiIfIgnoreCase ? ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_LeftJustifiedCaseInsensitiveAsciiSubstring(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount)) : ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_LeftJustifiedCaseInsensitiveSubstring(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, analysisResults.HashIndex, analysisResults.HashCount))))) : ((!analysisResults.IgnoreCase) ? new OrdinalStringFrozenSet_Full(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, num3) : (analysisResults.AllAsciiIfIgnoreCase ? ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_FullCaseInsensitiveAscii(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, num3)) : ((OrdinalStringFrozenSet)new OrdinalStringFrozenSet_FullCaseInsensitive(array, equalityComparer, analysisResults.MinimumLength, analysisResults.MaximumLengthDiff, num3)))));
				return (FrozenSet<T>)(object)frozenSet;
			}
			if (source.Count <= 4)
			{
				return new SmallFrozenSet<T>(source);
			}
			return new DefaultFrozenSet<T>(source);
		}
	}
	[CollectionBuilder(typeof(FrozenSet), "Create")]
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	[DebuggerDisplay("Count = {Count}")]
	public abstract class FrozenSet<T> : ISet<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, ICollection
	{
		public struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable
		{
			private readonly T[] _entries;

			private int _index;

			public readonly T Current
			{
				get
				{
					if ((uint)_index >= (uint)_entries.Length)
					{
						ThrowHelper.ThrowInvalidOperationException();
					}
					return _entries[_index];
				}
			}

			object IEnumerator.Current => Current;

			internal Enumerator(T[] entries)
			{
				_entries = entries;
				_index = -1;
			}

			public bool MoveNext()
			{
				_index++;
				if ((uint)_index < (uint)_entries.Length)
				{
					return true;
				}
				_index = _entries.Length;
				return false;
			}

			void IEnumerator.Reset()
			{
				_index = -1;
			}

			void IDisposable.Dispose()
			{
			}
		}

		public static FrozenSet<T> Empty { get; } = new EmptyFrozenSet<T>(EqualityComparer<T>.Default);


		public IEqualityComparer<T> Comparer { get; }

		public ImmutableArray<T> Items => ImmutableCollectionsMarshal.AsImmutableArray(ItemsCore);

		private protected abstract T[] ItemsCore { get; }

		public int Count => CountCore;

		private protected abstract int CountCore { get; }

		bool ICollection<T>.IsReadOnly => true;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => this;

		private protected FrozenSet(IEqualityComparer<T> comparer)
		{
			Comparer = comparer;
		}

		public void CopyTo(T[] destination, int destinationIndex)
		{
			ThrowHelper.ThrowIfNull(destination, "destination");
			CopyTo(destination.AsSpan(destinationIndex));
		}

		public void CopyTo(Span<T> destination)
		{
			Items.AsSpan().CopyTo(destination);
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array != null && array.Rank != 1)
			{
				throw new ArgumentException(System.SR.Arg_RankMultiDimNotSupported, "array");
			}
			T[] itemsCore = ItemsCore;
			Array.Copy(itemsCore, 0, array, index, itemsCore.Length);
		}

		public bool Contains(T item)
		{
			return FindItemIndex(item) >= 0;
		}

		public bool TryGetValue(T equalValue, [MaybeNullWhen(false)] out T actualValue)
		{
			int num = FindItemIndex(equalValue);
			if (num >= 0)
			{
				actualValue = Items[num];
				return true;
			}
			actualValue = default(T);
			return false;
		}

		private protected abstract int FindItemIndex(T item);

		private protected virtual int FindItemIndex<TAlternate>(TAlternate item)
		{
			return -1;
		}

		public Enumerator GetEnumerator()
		{
			return GetEnumeratorCore();
		}

		private protected abstract Enumerator GetEnumeratorCore();

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (Count != 0)
			{
				return GetEnumerator();
			}
			return ((IEnumerable<T>)Array.Empty<T>()).GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			if (Count != 0)
			{
				return GetEnumerator();
			}
			return Array.Empty<T>().GetEnumerator();
		}

		bool ISet<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.ExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.IntersectWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.SymmetricExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.UnionWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<T>.Remove(T item)
		{
			throw new NotSupportedException();
		}

		public bool IsProperSubsetOf(IEnumerable<T> other)
		{
			ThrowHelper.ThrowIfNull(other, "other");
			return IsProperSubsetOfCore(other);
		}

		private protected abstract bool IsProperSubsetOfCore(IEnumerable<T> other);

		public bool IsProperSupersetOf(IEnumerable<T> other)
		{
			ThrowHelper.ThrowIfNull(other, "other");
			return IsProperSupersetOfCore(other);
		}

		private protected abstract bool IsProperSupersetOfCore(IEnumerable<T> other);

		public bool IsSubsetOf(IEnumerable<T> other)
		{
			ThrowHelper.ThrowIfNull(other, "other");
			return IsSubsetOfCore(other);
		}

		private protected abstract bool IsSubsetOfCore(IEnumerable<T> other);

		public bool IsSupersetOf(IEnumerable<T> other)
		{
			ThrowHelper.ThrowIfNull(other, "other");
			return IsSupersetOfCore(other);
		}

		private protected abstract bool IsSupersetOfCore(IEnumerable<T> other);

		public bool Overlaps(IEnumerable<T> other)
		{
			ThrowHelper.ThrowIfNull(other, "other");
			return OverlapsCore(other);
		}

		private protected abstract bool OverlapsCore(IEnumerable<T> other);

		public bool SetEquals(IEnumerable<T> other)
		{
			ThrowHelper.ThrowIfNull(other, "other");
			return SetEqualsCore(other);
		}

		private protected abstract bool SetEqualsCore(IEnumerable<T> other);
	}
	internal abstract class FrozenSetInternalBase<T, TThisWrapper> : FrozenSet<T> where TThisWrapper : struct, FrozenSetInternalBase<T, TThisWrapper>.IGenericSpecializedWrapper
	{
		internal interface IGenericSpecializedWrapper
		{
			int Count { get; }

			IEqualityComparer<T> Comparer { get; }

			void Store(FrozenSet<T> @this);

			int FindItemIndex(T item);

			Enumerator GetEnumerator();
		}

		private readonly TThisWrapper _thisSet;

		protected FrozenSetInternalBase(IEqualityComparer<T> comparer)
			: base(comparer)
		{
			_thisSet = default(TThisWrapper);
			_thisSet.Store(this);
		}

		private protected override bool IsProperSubsetOfCore(IEnumerable<T> other)
		{
			if (other is ICollection<T> collection)
			{
				int count = collection.Count;
				if (count == 0)
				{
					return false;
				}
				if (other is IReadOnlySet<T> other2 && ComparersAreCompatible(other2))
				{
					if (_thisSet.Count < count)
					{
						return IsSubsetOfSetWithCompatibleComparer(other2);
					}
					return false;
				}
			}
			var (num3, num4) = CheckUniqueAndUnfoundElements(other, returnIfUnfound: false);
			if (num3 == _thisSet.Count)
			{
				return num4 > 0;
			}
			return false;
		}

		private protected override bool IsProperSupersetOfCore(IEnumerable<T> other)
		{
			if (other is ICollection<T> collection)
			{
				int count = collection.Count;
				if (count == 0)
				{
					return true;
				}
				if (other is IReadOnlySet<T> other2 && ComparersAreCompatible(other2))
				{
					if (_thisSet.Count > count)
					{
						return ContainsAllElements(other2);
					}
					return false;
				}
			}
			var (num3, num4) = CheckUniqueAndUnfoundElements(other, returnIfUnfound: true);
			if (num3 < _thisSet.Count)
			{
				return num4 == 0;
			}
			return false;
		}

		private protected override bool IsSubsetOfCore(IEnumerable<T> other)
		{
			if (other is IReadOnlySet<T> readOnlySet && ComparersAreCompatible(readOnlySet))
			{
				if (_thisSet.Count <= readOnlySet.Count)
				{
					return IsSubsetOfSetWithCompatibleComparer(readOnlySet);
				}
				return false;
			}
			var (num3, num4) = CheckUniqueAndUnfoundElements(other, returnIfUnfound: false);
			if (num3 == _thisSet.Count)
			{
				return num4 >= 0;
			}
			return false;
		}

		private protected override bool IsSupersetOfCore(IEnumerable<T> other)
		{
			if (other is ICollection<T> collection)
			{
				int count = collection.Count;
				if (count == 0)
				{
					return true;
				}
				if (other is IReadOnlySet<T> other2 && count > _thisSet.Count && ComparersAreCompatible(other2))
				{
					return false;
				}
			}
			return ContainsAllElements(other);
		}

		private protected override bool OverlapsCore(IEnumerable<T> other)
		{
			foreach (T item in other)
			{
				if (_thisSet.FindItemIndex(item) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private protected override bool SetEqualsCore(IEnumerable<T> other)
		{
			if (other is IReadOnlySet<T> readOnlySet && ComparersAreCompatible(readOnlySet))
			{
				if (_thisSet.Count == readOnlySet.Count)
				{
					return ContainsAllElements(readOnlySet);
				}
				return false;
			}
			var (num3, num4) = CheckUniqueAndUnfoundElements(other, returnIfUnfound: true);
			if (num3 == _thisSet.Count)
			{
				return num4 == 0;
			}
			return false;
		}

		private bool ComparersAreCompatible(IReadOnlySet<T> other)
		{
			if (!(other is HashSet<T> hashSet))
			{
				if (!(other is SortedSet<T> sortedSet))
				{
					if (!(other is ImmutableHashSet<T> immutableHashSet))
					{
						if (!(other is ImmutableSortedSet<T> immutableSortedSet))
						{
							if (other is FrozenSet<T> frozenSet)
							{
								return _thisSet.Comparer.Equals(frozenSet.Comparer);
							}
							return false;
						}
						return _thisSet.Comparer.Equals(immutableSortedSet.KeyComparer);
					}
					return _thisSet.Comparer.Equals(immutableHashSet.KeyComparer);
				}
				return _thisSet.Comparer.Equals(sortedSet.Comparer);
			}
			return _thisSet.Comparer.Equals(hashSet.Comparer);
		}

		private KeyValuePair<int, int> CheckUniqueAndUnfoundElements(IEnumerable<T> other, bool returnIfUnfound)
		{
			int num = _thisSet.Count / 32 + 1;
			int[] array = null;
			Span<int> span = ((num > 128) ? ((Span<int>)(array = ArrayPool<int>.Shared.Rent(num))) : stackalloc int[128]);
			Span<int> span2 = span;
			span2 = span2.Slice(0, num);
			span2.Clear();
			int num2 = 0;
			int num3 = 0;
			foreach (T item in other)
			{
				int num4 = _thisSet.FindItemIndex(item);
				if (num4 >= 0)
				{
					if ((span2[num4 / 32] & (1 << num4)) == 0)
					{
						span2[num4 / 32] |= 1 << num4;
						num3++;
					}
				}
				else
				{
					num2++;
					if (returnIfUnfound)
					{
						break;
					}
				}
			}
			if (array != null)
			{
				ArrayPool<int>.Shared.Return(array);
			}
			return new KeyValuePair<int, int>(num3, num2);
		}

		private bool ContainsAllElements(IEnumerable<T> other)
		{
			foreach (T item in other)
			{
				if (_thisSet.FindItemIndex(item) < 0)
				{
					return false;
				}
			}
			return true;
		}

		private bool IsSubsetOfSetWithCompatibleComparer(IReadOnlySet<T> other)
		{
			foreach (T item in _thisSet)
			{
				if (!other.Contains(item))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal abstract class ItemsFrozenSet<T, TThisWrapper> : FrozenSetInternalBase<T, TThisWrapper> where TThisWrapper : struct, FrozenSetInternalBase<T, TThisWrapper>.IGenericSpecializedWrapper
	{
		private protected readonly FrozenHashTable _hashTable;

		private protected readonly T[] _items;

		private protected sealed override T[] ItemsCore => _items;

		private protected sealed override int CountCore => _hashTable.Count;

		protected ItemsFrozenSet(HashSet<T> source, bool keysAreHashCodes = false)
			: base(source.Comparer)
		{
			T[] array = new T[source.Count];
			source.CopyTo(array);
			_items = new T[array.Length];
			int[] array2 = ArrayPool<int>.Shared.Rent(array.Length);
			Span<int> hashCodes = array2.AsSpan(0, array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				ref int reference = ref hashCodes[i];
				T val = array[i];
				reference = ((val != null) ? base.Comparer.GetHashCode(val) : 0);
			}
			_hashTable = FrozenHashTable.Create(hashCodes, keysAreHashCodes);
			for (int j = 0; j < hashCodes.Length; j++)
			{
				int num = hashCodes[j];
				_items[num] = array[j];
			}
			ArrayPool<int>.Shared.Return(array2);
		}

		private protected sealed override Enumerator GetEnumeratorCore()
		{
			return new FrozenSet<T>.Enumerator(_items);
		}
	}
	internal abstract class KeysAndValuesFrozenDictionary<TKey, TValue> : FrozenDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		private protected readonly FrozenHashTable _hashTable;

		private protected readonly TKey[] _keys;

		private protected readonly TValue[] _values;

		private protected sealed override TKey[] KeysCore => _keys;

		private protected sealed override TValue[] ValuesCore => _values;

		private protected sealed override int CountCore => _hashTable.Count;

		protected KeysAndValuesFrozenDictionary(Dictionary<TKey, TValue> source, bool keysAreHashCodes = false)
			: base(source.Comparer)
		{
			KeyValuePair<TKey, TValue>[] array = new KeyValuePair<TKey, TValue>[source.Count];
			((ICollection<KeyValuePair<TKey, TValue>>)source).CopyTo(array, 0);
			_keys = new TKey[array.Length];
			_values = new TValue[array.Length];
			int[] array2 = ArrayPool<int>.Shared.Rent(array.Length);
			Span<int> hashCodes = array2.AsSpan(0, array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				hashCodes[i] = base.Comparer.GetHashCode(array[i].Key);
			}
			_hashTable = FrozenHashTable.Create(hashCodes, keysAreHashCodes);
			for (int j = 0; j < hashCodes.Length; j++)
			{
				int num = hashCodes[j];
				_keys[num] = array[j].Key;
				_values[num] = array[j].Value;
			}
			ArrayPool<int>.Shared.Return(array2);
		}

		private protected sealed override Enumerator GetEnumeratorCore()
		{
			return new FrozenDictionary<TKey, TValue>.Enumerator(_keys, _values);
		}
	}
	internal sealed class SmallFrozenDictionary<TKey, TValue> : FrozenDictionary<TKey, TValue> where TKey : notnull
	{
		private readonly TKey[] _keys;

		private readonly TValue[] _values;

		private protected override TKey[] KeysCore => _keys;

		private protected override TValue[] ValuesCore => _values;

		private protected override int CountCore => _keys.Length;

		internal SmallFrozenDictionary(Dictionary<TKey, TValue> source)
			: base(source.Comparer)
		{
			_keys = source.Keys.ToArray();
			_values = source.Values.ToArray();
		}

		private protected sealed override Enumerator GetEnumeratorCore()
		{
			return new FrozenDictionary<TKey, TValue>.Enumerator(_keys, _values);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(TKey key)
		{
			IEqualityComparer<TKey> comparer = base.Comparer;
			TKey[] keys = _keys;
			for (int i = 0; i < keys.Length; i++)
			{
				if (comparer.Equals(keys[i], key))
				{
					return ref _values[i];
				}
			}
			return ref Unsafe.NullRef<TValue>();
		}
	}
	internal sealed class SmallFrozenSet<T> : FrozenSetInternalBase<T, SmallFrozenSet<T>.GSW>
	{
		internal struct GSW : IGenericSpecializedWrapper
		{
			private SmallFrozenSet<T> _set;

			public int Count => _set.Count;

			public IEqualityComparer<T> Comparer => _set.Comparer;

			public void Store(FrozenSet<T> set)
			{
				_set = (SmallFrozenSet<T>)set;
			}

			public int FindItemIndex(T item)
			{
				return _set.FindItemIndex(item);
			}

			public Enumerator GetEnumerator()
			{
				return _set.GetEnumerator();
			}
		}

		private readonly T[] _items;

		private protected override T[] ItemsCore => _items;

		private protected override int CountCore => _items.Length;

		internal SmallFrozenSet(HashSet<T> source)
			: base(source.Comparer)
		{
			_items = source.ToArray();
		}

		private protected override int FindItemIndex(T item)
		{
			T[] items = _items;
			for (int i = 0; i < items.Length; i++)
			{
				if (base.Comparer.Equals(item, items[i]))
				{
					return i;
				}
			}
			return -1;
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenSet<T>.Enumerator(_items);
		}
	}
	internal sealed class SmallValueTypeComparableFrozenDictionary<TKey, TValue> : FrozenDictionary<TKey, TValue> where TKey : notnull
	{
		private readonly TKey[] _keys;

		private readonly TValue[] _values;

		private readonly TKey _max;

		private protected override TKey[] KeysCore => _keys;

		private protected override TValue[] ValuesCore => _values;

		private protected override int CountCore => _keys.Length;

		internal SmallValueTypeComparableFrozenDictionary(Dictionary<TKey, TValue> source)
			: base((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
			_keys = source.Keys.ToArray();
			_values = source.Values.ToArray();
			Array.Sort(_keys, _values);
			_max = _keys[_keys.Length - 1];
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenDictionary<TKey, TValue>.Enumerator(_keys, _values);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected override ref readonly TValue GetValueRefOrNullRefCore(TKey key)
		{
			if (Comparer<TKey>.Default.Compare(key, _max) <= 0)
			{
				TKey[] keys = _keys;
				for (int i = 0; i < keys.Length; i++)
				{
					int num = Comparer<TKey>.Default.Compare(key, keys[i]);
					if (num <= 0)
					{
						if (num != 0)
						{
							break;
						}
						return ref _values[i];
					}
				}
			}
			return ref Unsafe.NullRef<TValue>();
		}
	}
	internal sealed class SmallValueTypeComparableFrozenSet<T> : FrozenSetInternalBase<T, SmallValueTypeComparableFrozenSet<T>.GSW>
	{
		internal struct GSW : IGenericSpecializedWrapper
		{
			private SmallValueTypeComparableFrozenSet<T> _set;

			public int Count => _set.Count;

			public IEqualityComparer<T> Comparer => _set.Comparer;

			public void Store(FrozenSet<T> set)
			{
				_set = (SmallValueTypeComparableFrozenSet<T>)set;
			}

			public int FindItemIndex(T item)
			{
				return _set.FindItemIndex(item);
			}

			public Enumerator GetEnumerator()
			{
				return _set.GetEnumerator();
			}
		}

		private readonly T[] _items;

		private readonly T _max;

		private protected override T[] ItemsCore => _items;

		private protected override int CountCore => _items.Length;

		internal SmallValueTypeComparableFrozenSet(HashSet<T> source)
			: base((IEqualityComparer<T>)EqualityComparer<T>.Default)
		{
			_items = source.ToArray();
			Array.Sort(_items);
			_max = _items[_items.Length - 1];
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenSet<T>.Enumerator(_items);
		}

		private protected override int FindItemIndex(T item)
		{
			if (Comparer<T>.Default.Compare(item, _max) <= 0)
			{
				T[] items = _items;
				for (int i = 0; i < items.Length; i++)
				{
					int num = Comparer<T>.Default.Compare(item, items[i]);
					if (num <= 0)
					{
						if (num != 0)
						{
							break;
						}
						return i;
					}
				}
			}
			return -1;
		}
	}
	internal sealed class SmallValueTypeDefaultComparerFrozenDictionary<TKey, TValue> : FrozenDictionary<TKey, TValue> where TKey : notnull
	{
		private readonly TKey[] _keys;

		private readonly TValue[] _values;

		private protected override TKey[] KeysCore => _keys;

		private protected override TValue[] ValuesCore => _values;

		private protected override int CountCore => _keys.Length;

		internal SmallValueTypeDefaultComparerFrozenDictionary(Dictionary<TKey, TValue> source)
			: base((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
			_keys = source.Keys.ToArray();
			_values = source.Values.ToArray();
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenDictionary<TKey, TValue>.Enumerator(_keys, _values);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected override ref readonly TValue GetValueRefOrNullRefCore(TKey key)
		{
			TKey[] keys = _keys;
			for (int i = 0; i < keys.Length; i++)
			{
				if (EqualityComparer<TKey>.Default.Equals(keys[i], key))
				{
					return ref _values[i];
				}
			}
			return ref Unsafe.NullRef<TValue>();
		}
	}
	internal sealed class SmallValueTypeDefaultComparerFrozenSet<T> : FrozenSetInternalBase<T, SmallValueTypeDefaultComparerFrozenSet<T>.GSW>
	{
		internal struct GSW : IGenericSpecializedWrapper
		{
			private SmallValueTypeDefaultComparerFrozenSet<T> _set;

			public int Count => _set.Count;

			public IEqualityComparer<T> Comparer => _set.Comparer;

			public void Store(FrozenSet<T> set)
			{
				_set = (SmallValueTypeDefaultComparerFrozenSet<T>)set;
			}

			public int FindItemIndex(T item)
			{
				return _set.FindItemIndex(item);
			}

			public Enumerator GetEnumerator()
			{
				return _set.GetEnumerator();
			}
		}

		private readonly T[] _items;

		private protected override T[] ItemsCore => _items;

		private protected override int CountCore => _items.Length;

		internal SmallValueTypeDefaultComparerFrozenSet(HashSet<T> source)
			: base((IEqualityComparer<T>)EqualityComparer<T>.Default)
		{
			_items = source.ToArray();
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenSet<T>.Enumerator(_items);
		}

		private protected override int FindItemIndex(T item)
		{
			T[] items = _items;
			for (int i = 0; i < items.Length; i++)
			{
				if (EqualityComparer<T>.Default.Equals(item, items[i]))
				{
					return i;
				}
			}
			return -1;
		}
	}
	internal sealed class ValueTypeDefaultComparerFrozenDictionary<TKey, TValue> : KeysAndValuesFrozenDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		internal ValueTypeDefaultComparerFrozenDictionary(Dictionary<TKey, TValue> source)
			: base(source, Constants.KeysAreHashCodes<TKey>())
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(TKey key)
		{
			int hashCode = EqualityComparer<TKey>.Default.GetHashCode(key);
			_hashTable.FindMatchingEntries(hashCode, out var i, out var endIndex);
			for (; i <= endIndex; i++)
			{
				if (hashCode == _hashTable.HashCodes[i] && EqualityComparer<TKey>.Default.Equals(key, _keys[i]))
				{
					return ref _values[i];
				}
			}
			return ref Unsafe.NullRef<TValue>();
		}
	}
	internal sealed class ValueTypeDefaultComparerFrozenSet<T> : ItemsFrozenSet<T, ValueTypeDefaultComparerFrozenSet<T>.GSW>
	{
		internal struct GSW : IGenericSpecializedWrapper
		{
			private ValueTypeDefaultComparerFrozenSet<T> _set;

			public int Count => _set.Count;

			public IEqualityComparer<T> Comparer => _set.Comparer;

			public void Store(FrozenSet<T> set)
			{
				_set = (ValueTypeDefaultComparerFrozenSet<T>)set;
			}

			public int FindItemIndex(T item)
			{
				return _set.FindItemIndex(item);
			}

			public Enumerator GetEnumerator()
			{
				return _set.GetEnumerator();
			}
		}

		internal ValueTypeDefaultComparerFrozenSet(HashSet<T> source)
			: base(source, Constants.KeysAreHashCodes<T>())
		{
		}

		private protected override int FindItemIndex(T item)
		{
			int hashCode = EqualityComparer<T>.Default.GetHashCode(item);
			_hashTable.FindMatchingEntries(hashCode, out var i, out var endIndex);
			for (; i <= endIndex; i++)
			{
				if (hashCode == _hashTable.HashCodes[i] && EqualityComparer<T>.Default.Equals(item, _items[i]))
				{
					return i;
				}
			}
			return -1;
		}
	}
	internal sealed class Int32FrozenDictionary<TValue> : FrozenDictionary<int, TValue>
	{
		private readonly FrozenHashTable _hashTable;

		private readonly TValue[] _values;

		private protected override int[] KeysCore => _hashTable.HashCodes;

		private protected override TValue[] ValuesCore => _values;

		private protected override int CountCore => _hashTable.Count;

		internal Int32FrozenDictionary(Dictionary<int, TValue> source)
			: base((IEqualityComparer<int>)EqualityComparer<int>.Default)
		{
			KeyValuePair<int, TValue>[] array = new KeyValuePair<int, TValue>[source.Count];
			((ICollection<KeyValuePair<int, TValue>>)source).CopyTo(array, 0);
			_values = new TValue[array.Length];
			int[] array2 = ArrayPool<int>.Shared.Rent(array.Length);
			Span<int> hashCodes = array2.AsSpan(0, array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				hashCodes[i] = array[i].Key;
			}
			_hashTable = FrozenHashTable.Create(hashCodes, hashCodesAreUnique: true);
			for (int j = 0; j < hashCodes.Length; j++)
			{
				int num = hashCodes[j];
				_values[num] = array[j].Value;
			}
			ArrayPool<int>.Shared.Return(array2);
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenDictionary<int, TValue>.Enumerator(_hashTable.HashCodes, _values);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected override ref readonly TValue GetValueRefOrNullRefCore(int key)
		{
			_hashTable.FindMatchingEntries(key, out var i, out var endIndex);
			int[] hashCodes = _hashTable.HashCodes;
			for (; i <= endIndex; i++)
			{
				if (key == hashCodes[i])
				{
					return ref _values[i];
				}
			}
			return ref Unsafe.NullRef<TValue>();
		}
	}
	internal sealed class Int32FrozenSet : FrozenSetInternalBase<int, Int32FrozenSet.GSW>
	{
		internal struct GSW : IGenericSpecializedWrapper
		{
			private Int32FrozenSet _set;

			public int Count => _set.Count;

			public IEqualityComparer<int> Comparer => _set.Comparer;

			public void Store(FrozenSet<int> set)
			{
				_set = (Int32FrozenSet)set;
			}

			public int FindItemIndex(int item)
			{
				return _set.FindItemIndex(item);
			}

			public Enumerator GetEnumerator()
			{
				return _set.GetEnumerator();
			}
		}

		private readonly FrozenHashTable _hashTable;

		private protected override int[] ItemsCore => _hashTable.HashCodes;

		private protected override int CountCore => _hashTable.Count;

		internal Int32FrozenSet(HashSet<int> source)
			: base((IEqualityComparer<int>)EqualityComparer<int>.Default)
		{
			int count = source.Count;
			int[] array = ArrayPool<int>.Shared.Rent(count);
			source.CopyTo(array);
			_hashTable = FrozenHashTable.Create(new Span<int>(array, 0, count), hashCodesAreUnique: true);
			ArrayPool<int>.Shared.Return(array);
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new Enumerator(_hashTable.HashCodes);
		}

		private protected override int FindItemIndex(int item)
		{
			_hashTable.FindMatchingEntries(item, out var i, out var endIndex);
			int[] hashCodes = _hashTable.HashCodes;
			for (; i <= endIndex; i++)
			{
				if (item == hashCodes[i])
				{
					return i;
				}
			}
			return -1;
		}
	}
	internal static class Hashing
	{
		private const uint Hash1Start = 352654597u;

		private const uint Factor = 1566083941u;

		public unsafe static int GetHashCodeOrdinal(ReadOnlySpan<char> s)
		{
			int num = s.Length;
			fixed (char* ptr = &MemoryMarshal.GetReference(s))
			{
				switch (num)
				{
				case 0:
					return 757602046;
				case 1:
				{
					uint num3 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ *ptr;
					return (int)(352654597 + num3 * 1566083941);
				}
				case 2:
				{
					uint num3 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ *ptr;
					num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ ptr[1];
					return (int)(352654597 + num3 * 1566083941);
				}
				case 3:
				{
					uint num3 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ *ptr;
					num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ ptr[1];
					num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ ptr[2];
					return (int)(352654597 + num3 * 1566083941);
				}
				case 4:
				{
					uint num2 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ *(uint*)ptr;
					uint num3 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ *(uint*)(ptr + 2);
					return (int)(num2 + num3 * 1566083941);
				}
				default:
				{
					uint num2 = 352654597u;
					uint num3 = num2;
					uint* ptr2 = (uint*)ptr;
					while (num >= 4)
					{
						num2 = (BitOperations.RotateLeft(num2, 5) + num2) ^ *ptr2;
						num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ ptr2[1];
						ptr2 += 2;
						num -= 4;
					}
					char* ptr3 = (char*)ptr2;
					while (num-- > 0)
					{
						num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ *(ptr3++);
					}
					return (int)(num2 + num3 * 1566083941);
				}
				}
			}
		}

		public unsafe static int GetHashCodeOrdinalIgnoreCaseAscii(ReadOnlySpan<char> s)
		{
			int num = s.Length;
			fixed (char* ptr = &MemoryMarshal.GetReference(s))
			{
				switch (num)
				{
				case 0:
					return 757602046;
				case 1:
				{
					uint num3 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ (*ptr | 0x20u);
					return (int)(352654597 + num3 * 1566083941);
				}
				case 2:
				{
					uint num3 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ (*ptr | 0x20u);
					num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ (ptr[1] | 0x20u);
					return (int)(352654597 + num3 * 1566083941);
				}
				case 3:
				{
					uint num3 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ (*ptr | 0x20u);
					num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ (ptr[1] | 0x20u);
					num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ (ptr[2] | 0x20u);
					return (int)(352654597 + num3 * 1566083941);
				}
				case 4:
				{
					uint num2 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ (*(uint*)ptr | 0x200020u);
					uint num3 = (BitOperations.RotateLeft(352654597u, 5) + 352654597) ^ (*(uint*)(ptr + 2) | 0x200020u);
					return (int)(num2 + num3 * 1566083941);
				}
				default:
				{
					uint num2 = 352654597u;
					uint num3 = num2;
					uint* ptr2 = (uint*)ptr;
					while (num >= 4)
					{
						num2 = (BitOperations.RotateLeft(num2, 5) + num2) ^ (*ptr2 | 0x200020u);
						num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ (ptr2[1] | 0x200020u);
						ptr2 += 2;
						num -= 4;
					}
					char* ptr3 = (char*)ptr2;
					while (num-- > 0)
					{
						num3 = (BitOperations.RotateLeft(num3, 5) + num3) ^ (*ptr3 | 0x200020u);
						ptr3++;
					}
					return (int)(num2 + num3 * 1566083941);
				}
				}
			}
		}

		public static int GetHashCodeOrdinalIgnoreCase(ReadOnlySpan<char> s)
		{
			int length = s.Length;
			char[] array = null;
			Span<char> span = ((length > 256) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(length))) : stackalloc char[256]);
			Span<char> destination = span;
			int hashCodeOrdinal = GetHashCodeOrdinal(destination[..s.ToUpperInvariant(destination)]);
			if (array != null)
			{
				ArrayPool<char>.Shared.Return(array);
			}
			return hashCodeOrdinal;
		}
	}
	internal static class KeyAnalyzer
	{
		private delegate ReadOnlySpan<char> GetSpan(string s, int index, int count);

		internal readonly struct AnalysisResults
		{
			public bool IgnoreCase { get; }

			public bool AllAsciiIfIgnoreCase { get; }

			public int HashIndex { get; }

			public int HashCount { get; }

			public int MinimumLength { get; }

			public int MaximumLengthDiff { get; }

			public bool SubstringHashing => HashCount != 0;

			public bool RightJustifiedSubstring => HashIndex < 0;

			public AnalysisResults(bool ignoreCase, bool allAsciiIfIgnoreCase, int hashIndex, int hashCount, int minLength, int maxLength)
			{
				IgnoreCase = ignoreCase;
				AllAsciiIfIgnoreCase = allAsciiIfIgnoreCase;
				HashIndex = hashIndex;
				HashCount = hashCount;
				MinimumLength = minLength;
				MaximumLengthDiff = maxLength - minLength;
			}
		}

		private abstract class SubstringComparer : IEqualityComparer<string>
		{
			public int Index;

			public int Count;

			public bool IsLeft;

			public abstract bool Equals(string x, string y);

			public abstract int GetHashCode(string s);
		}

		private sealed class JustifiedSubstringComparer : SubstringComparer
		{
			public override bool Equals(string x, string y)
			{
				return x.AsSpan(IsLeft ? Index : (x.Length + Index), Count).SequenceEqual(y.AsSpan(IsLeft ? Index : (y.Length + Index), Count));
			}

			public override int GetHashCode(string s)
			{
				return Hashing.GetHashCodeOrdinal(s.AsSpan(IsLeft ? Index : (s.Length + Index), Count));
			}
		}

		private sealed class JustifiedCaseInsensitiveSubstringComparer : SubstringComparer
		{
			public override bool Equals(string x, string y)
			{
				return MemoryExtensions.Equals(x.AsSpan(IsLeft ? Index : (x.Length + Index), Count), y.AsSpan(IsLeft ? Index : (y.Length + Index), Count), StringComparison.OrdinalIgnoreCase);
			}

			public override int GetHashCode(string s)
			{
				return Hashing.GetHashCodeOrdinalIgnoreCase(s.AsSpan(IsLeft ? Index : (s.Length + Index), Count));
			}
		}

		private sealed class JustifiedCaseInsensitiveAsciiSubstringComparer : SubstringComparer
		{
			public override bool Equals(string x, string y)
			{
				return MemoryExtensions.Equals(x.AsSpan(IsLeft ? Index : (x.Length + Index), Count), y.AsSpan(IsLeft ? Index : (y.Length + Index), Count), StringComparison.OrdinalIgnoreCase);
			}

			public override int GetHashCode(string s)
			{
				return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.AsSpan(IsLeft ? Index : (s.Length + Index), Count));
			}
		}

		public static AnalysisResults Analyze(ReadOnlySpan<string> uniqueStrings, bool ignoreCase, int minLength, int maxLength)
		{
			bool allUniqueStringsAreConfirmedAscii = ignoreCase && AreAllAscii(uniqueStrings);
			if (minLength == 0 || !TryUseSubstring(uniqueStrings, allUniqueStringsAreConfirmedAscii, ignoreCase, minLength, maxLength, out var results))
			{
				return CreateAnalysisResults(uniqueStrings, allUniqueStringsAreConfirmedAscii, ignoreCase, minLength, maxLength, 0, 0, (string s, int _, int _) => s.AsSpan());
			}
			return results;
		}

		private static bool TryUseSubstring(ReadOnlySpan<string> uniqueStrings, bool allUniqueStringsAreConfirmedAscii, bool ignoreCase, int minLength, int maxLength, out AnalysisResults results)
		{
			int acceptableNonUniqueCount = uniqueStrings.Length / 20;
			SubstringComparer substringComparer = ((!ignoreCase) ? new JustifiedSubstringComparer() : (allUniqueStringsAreConfirmedAscii ? ((SubstringComparer)new JustifiedCaseInsensitiveAsciiSubstringComparer()) : ((SubstringComparer)new JustifiedCaseInsensitiveSubstringComparer())));
			HashSet<string> set = new HashSet<string>(substringComparer);
			int num = Math.Min(minLength, 8);
			for (int i = 1; i <= num; i++)
			{
				substringComparer.IsLeft = true;
				substringComparer.Count = i;
				for (int j = 0; j <= minLength - i; j++)
				{
					substringComparer.Index = j;
					if (HasSufficientUniquenessFactor(set, uniqueStrings, acceptableNonUniqueCount))
					{
						results = CreateAnalysisResults(uniqueStrings, allUniqueStringsAreConfirmedAscii, ignoreCase, minLength, maxLength, j, i, (string s, int index, int count) => s.AsSpan(index, count));
						return true;
					}
				}
				if (minLength == maxLength)
				{
					continue;
				}
				substringComparer.IsLeft = false;
				for (int k = 0; k <= minLength - i; k++)
				{
					substringComparer.Index = -k - i;
					if (HasSufficientUniquenessFactor(set, uniqueStrings, acceptableNonUniqueCount))
					{
						results = CreateAnalysisResults(uniqueStrings, allUniqueStringsAreConfirmedAscii, ignoreCase, minLength, maxLength, substringComparer.Index, i, (string s, int index, int count) => s.AsSpan(s.Length + index, count));
						return true;
					}
				}
			}
			results = default(AnalysisResults);
			return false;
		}

		private static AnalysisResults CreateAnalysisResults(ReadOnlySpan<string> uniqueStrings, bool allUniqueStringsAreConfirmedAscii, bool ignoreCase, int minLength, int maxLength, int index, int count, GetSpan getHashString)
		{
			bool allAsciiIfIgnoreCase = true;
			if (ignoreCase)
			{
				bool flag = true;
				ReadOnlySpan<string> readOnlySpan = uniqueStrings;
				for (int i = 0; i < readOnlySpan.Length; i++)
				{
					string text = readOnlySpan[i];
					if (!allUniqueStringsAreConfirmedAscii && !IsAllAscii(getHashString(text, index, count)))
					{
						allAsciiIfIgnoreCase = false;
						flag = false;
						break;
					}
					if (flag && ((count > 0 && !allUniqueStringsAreConfirmedAscii && !IsAllAscii(text.AsSpan())) || ContainsAnyAsciiLetters(text.AsSpan())))
					{
						flag = false;
						if (allUniqueStringsAreConfirmedAscii)
						{
							break;
						}
					}
				}
				if (flag)
				{
					ignoreCase = false;
				}
			}
			return new AnalysisResults(ignoreCase, allAsciiIfIgnoreCase, index, count, minLength, maxLength);
		}

		private static bool AreAllAscii(ReadOnlySpan<string> strings)
		{
			ReadOnlySpan<string> readOnlySpan = strings;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				if (!IsAllAscii(readOnlySpan[i].AsSpan()))
				{
					return false;
				}
			}
			return true;
		}

		internal unsafe static bool IsAllAscii(ReadOnlySpan<char> s)
		{
			fixed (char* ptr = s)
			{
				uint* ptr2 = (uint*)ptr;
				int num;
				for (num = s.Length; num >= 4; num -= 4)
				{
					if (!AllCharsInUInt32AreAscii(*ptr2 | ptr2[1]))
					{
						return false;
					}
					ptr2 += 2;
				}
				char* ptr3 = (char*)ptr2;
				while (num-- > 0)
				{
					if (*(ptr3++) >= '\u0080')
					{
						return false;
					}
				}
			}
			return true;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			static bool AllCharsInUInt32AreAscii(uint value)
			{
				return (value & 0xFF80FF80u) == 0;
			}
		}

		internal static bool ContainsAnyAsciiLetters(ReadOnlySpan<char> s)
		{
			ReadOnlySpan<char> readOnlySpan = s;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				if ((uint)((readOnlySpan[i] | 0x20) - 97) <= 25u)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool HasSufficientUniquenessFactor(HashSet<string> set, ReadOnlySpan<string> uniqueStrings, int acceptableNonUniqueCount)
		{
			set.Clear();
			ReadOnlySpan<string> readOnlySpan = uniqueStrings;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				string item = readOnlySpan[i];
				if (!set.Add(item) && --acceptableNonUniqueCount < 0)
				{
					return false;
				}
			}
			return true;
		}
	}
	internal static class LengthBuckets
	{
		internal const int MaxPerLength = 5;

		private const double EmptyLengthsRatio = 0.2;

		internal static int[]? CreateLengthBucketsArrayIfAppropriate(string[] keys, IEqualityComparer<string> comparer, int minLength, int maxLength)
		{
			int num = maxLength - minLength + 1;
			if (keys.Length / num > 5)
			{
				return null;
			}
			int num2 = num * 5;
			if (num2 > 2147483591)
			{
				return null;
			}
			int[] array = ArrayPool<int>.Shared.Rent(num2);
			array.AsSpan(0, num2).Fill(-1);
			int num3 = 0;
			for (int i = 0; i < keys.Length; i++)
			{
				int num4 = (keys[i].Length - minLength) * 5;
				int num5 = num4 + 5;
				int j;
				for (j = num4; j < num5; j++)
				{
					ref int reference = ref array[j];
					if (reference < 0)
					{
						if (j == num4)
						{
							num3++;
						}
						reference = i;
						break;
					}
				}
				if (j == num5)
				{
					ArrayPool<int>.Shared.Return(array);
					return null;
				}
			}
			if ((double)num3 / (double)num < 0.2)
			{
				ArrayPool<int>.Shared.Return(array);
				return null;
			}
			int[] result = array.AsSpan(0, num2).ToArray();
			ArrayPool<int>.Shared.Return(array);
			return result;
		}
	}
	internal sealed class LengthBucketsFrozenDictionary<TValue> : FrozenDictionary<string, TValue>
	{
		private readonly int[] _lengthBuckets;

		private readonly int _minLength;

		private readonly string[] _keys;

		private readonly TValue[] _values;

		private readonly bool _ignoreCase;

		private protected override string[] KeysCore => _keys;

		private protected override TValue[] ValuesCore => _values;

		private protected override int CountCore => _keys.Length;

		private LengthBucketsFrozenDictionary(string[] keys, TValue[] values, int[] lengthBuckets, int minLength, IEqualityComparer<string> comparer)
			: base(comparer)
		{
			_keys = keys;
			_values = values;
			_lengthBuckets = lengthBuckets;
			_minLength = minLength;
			_ignoreCase = comparer == StringComparer.OrdinalIgnoreCase;
		}

		internal static LengthBucketsFrozenDictionary<TValue>? CreateLengthBucketsFrozenDictionaryIfAppropriate(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minLength, int maxLength)
		{
			int[] array = LengthBuckets.CreateLengthBucketsArrayIfAppropriate(keys, comparer, minLength, maxLength);
			if (array == null)
			{
				return null;
			}
			return new LengthBucketsFrozenDictionary<TValue>(keys, values, array, minLength, comparer);
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenDictionary<string, TValue>.Enumerator(_keys, _values);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			int i = (key.Length - _minLength) * 5;
			int num = i + 5;
			int[] lengthBuckets = _lengthBuckets;
			if (i >= 0 && num <= lengthBuckets.Length)
			{
				string[] keys = _keys;
				TValue[] values = _values;
				if (!_ignoreCase)
				{
					for (; i < num; i++)
					{
						int num2 = lengthBuckets[i];
						if ((uint)num2 >= (uint)keys.Length)
						{
							break;
						}
						if (key == keys[num2])
						{
							return ref values[num2];
						}
					}
				}
				else
				{
					for (; i < num; i++)
					{
						int num3 = lengthBuckets[i];
						if ((uint)num3 >= (uint)keys.Length)
						{
							break;
						}
						if (StringComparer.OrdinalIgnoreCase.Equals(key, keys[num3]))
						{
							return ref values[num3];
						}
					}
				}
			}
			return ref Unsafe.NullRef<TValue>();
		}
	}
	internal sealed class LengthBucketsFrozenSet : FrozenSetInternalBase<string, LengthBucketsFrozenSet.GSW>
	{
		internal struct GSW : IGenericSpecializedWrapper
		{
			private LengthBucketsFrozenSet _set;

			public int Count => _set.Count;

			public IEqualityComparer<string> Comparer => _set.Comparer;

			public void Store(FrozenSet<string> set)
			{
				_set = (LengthBucketsFrozenSet)set;
			}

			public int FindItemIndex(string item)
			{
				return _set.FindItemIndex(item);
			}

			public Enumerator GetEnumerator()
			{
				return _set.GetEnumerator();
			}
		}

		private readonly int[] _lengthBuckets;

		private readonly int _minLength;

		private readonly string[] _items;

		private readonly bool _ignoreCase;

		private protected override string[] ItemsCore => _items;

		private protected override int CountCore => _items.Length;

		private LengthBucketsFrozenSet(string[] items, int[] lengthBuckets, int minLength, IEqualityComparer<string> comparer)
			: base(comparer)
		{
			_items = items;
			_lengthBuckets = lengthBuckets;
			_minLength = minLength;
			_ignoreCase = comparer == StringComparer.OrdinalIgnoreCase;
		}

		internal static LengthBucketsFrozenSet? CreateLengthBucketsFrozenSetIfAppropriate(string[] items, IEqualityComparer<string> comparer, int minLength, int maxLength)
		{
			int[] array = LengthBuckets.CreateLengthBucketsArrayIfAppropriate(items, comparer, minLength, maxLength);
			if (array == null)
			{
				return null;
			}
			return new LengthBucketsFrozenSet(items, array, minLength, comparer);
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenSet<string>.Enumerator(_items);
		}

		private protected override int FindItemIndex(string? item)
		{
			if (item != null)
			{
				int i = (item.Length - _minLength) * 5;
				int num = i + 5;
				int[] lengthBuckets = _lengthBuckets;
				if (i >= 0 && num <= lengthBuckets.Length)
				{
					string[] items = _items;
					if (!_ignoreCase)
					{
						for (; i < num; i++)
						{
							int num2 = lengthBuckets[i];
							if ((uint)num2 >= (uint)items.Length)
							{
								break;
							}
							if (item == items[num2])
							{
								return num2;
							}
						}
					}
					else
					{
						for (; i < num; i++)
						{
							int num3 = lengthBuckets[i];
							if ((uint)num3 >= (uint)items.Length)
							{
								break;
							}
							if (StringComparer.OrdinalIgnoreCase.Equals(item, items[num3]))
							{
								return num3;
							}
						}
					}
				}
			}
			return -1;
		}
	}
	internal abstract class OrdinalStringFrozenDictionary<TValue> : FrozenDictionary<string, TValue>
	{
		private readonly FrozenHashTable _hashTable;

		private readonly string[] _keys;

		private readonly TValue[] _values;

		private readonly int _minimumLength;

		private readonly int _maximumLengthDiff;

		private protected int HashIndex { get; }

		private protected int HashCount { get; }

		private protected override string[] KeysCore => _keys;

		private protected override TValue[] ValuesCore => _values;

		private protected override int CountCore => _hashTable.Count;

		internal OrdinalStringFrozenDictionary(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex = -1, int hashCount = -1)
			: base(comparer)
		{
			_keys = new string[keys.Length];
			_values = new TValue[values.Length];
			_minimumLength = minimumLength;
			_maximumLengthDiff = maximumLengthDiff;
			HashIndex = hashIndex;
			HashCount = hashCount;
			int[] array = ArrayPool<int>.Shared.Rent(keys.Length);
			Span<int> hashCodes = array.AsSpan(0, keys.Length);
			for (int i = 0; i < keys.Length; i++)
			{
				hashCodes[i] = GetHashCode(keys[i]);
			}
			_hashTable = FrozenHashTable.Create(hashCodes);
			for (int j = 0; j < hashCodes.Length; j++)
			{
				int num = hashCodes[j];
				_keys[num] = keys[j];
				_values[num] = values[j];
			}
			ArrayPool<int>.Shared.Return(array);
		}

		private protected abstract bool Equals(string? x, string? y);

		private protected abstract bool Equals(ReadOnlySpan<char> x, string? y);

		private protected abstract int GetHashCode(string s);

		private protected abstract int GetHashCode(ReadOnlySpan<char> s);

		private protected virtual bool CheckLengthQuick(uint length)
		{
			return true;
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenDictionary<string, TValue>.Enumerator(_keys, _values);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			if ((uint)(key.Length - _minimumLength) <= (uint)_maximumLengthDiff && CheckLengthQuick((uint)key.Length))
			{
				int hashCode = GetHashCode(key);
				_hashTable.FindMatchingEntries(hashCode, out var i, out var endIndex);
				for (; i <= endIndex; i++)
				{
					if (hashCode == _hashTable.HashCodes[i] && Equals(key, _keys[i]))
					{
						return ref _values[i];
					}
				}
			}
			return ref Unsafe.NullRef<TValue>();
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_FullCaseInsensitiveAscii<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		private readonly ulong _lengthFilter;

		internal OrdinalStringFrozenDictionary_FullCaseInsensitiveAscii(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, ulong lengthFilter)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, -1, -1)
		{
			_lengthFilter = lengthFilter;
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return MemoryExtensions.Equals(x, y.AsSpan(), StringComparison.OrdinalIgnoreCase);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.AsSpan());
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s);
		}

		private protected override bool CheckLengthQuick(uint length)
		{
			return (_lengthFilter & (ulong)(1L << (int)(length % 64))) != 0;
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_FullCaseInsensitive<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		private readonly ulong _lengthFilter;

		internal OrdinalStringFrozenDictionary_FullCaseInsensitive(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, ulong lengthFilter)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, -1, -1)
		{
			_lengthFilter = lengthFilter;
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return MemoryExtensions.Equals(x, y.AsSpan(), StringComparison.OrdinalIgnoreCase);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.AsSpan());
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s);
		}

		private protected override bool CheckLengthQuick(uint length)
		{
			return (_lengthFilter & (ulong)(1L << (int)(length % 64))) != 0;
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_Full<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		private readonly ulong _lengthFilter;

		internal OrdinalStringFrozenDictionary_Full(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, ulong lengthFilter)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, -1, -1)
		{
			_lengthFilter = lengthFilter;
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return string.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return x.SequenceEqual(y.AsSpan());
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinal(s.AsSpan());
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinal(s);
		}

		private protected override bool CheckLengthQuick(uint length)
		{
			return (_lengthFilter & (ulong)(1L << (int)(length % 64))) != 0;
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveAsciiSubstring<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		internal OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveAsciiSubstring(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return MemoryExtensions.Equals(x, y.AsSpan(), StringComparison.OrdinalIgnoreCase);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.AsSpan(base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.Slice(base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveSubstring<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		internal OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveSubstring(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return MemoryExtensions.Equals(x, y.AsSpan(), StringComparison.OrdinalIgnoreCase);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.AsSpan(base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.Slice(base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_LeftJustifiedSingleChar<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		internal OrdinalStringFrozenDictionary_LeftJustifiedSingleChar(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, 1)
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return string.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return x.SequenceEqual(y.AsSpan());
		}

		private protected override int GetHashCode(string s)
		{
			return s[base.HashIndex];
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return s[base.HashIndex];
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveSubstring<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		internal OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveSubstring(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return MemoryExtensions.Equals(x, y.AsSpan(), StringComparison.OrdinalIgnoreCase);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.AsSpan(s.Length + base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.Slice(s.Length + base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveAsciiSubstring<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		internal OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveAsciiSubstring(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return MemoryExtensions.Equals(x, y.AsSpan(), StringComparison.OrdinalIgnoreCase);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.AsSpan(s.Length + base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.Slice(s.Length + base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_RightJustifiedSingleChar<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		internal OrdinalStringFrozenDictionary_RightJustifiedSingleChar(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, 1)
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return string.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return x.SequenceEqual(y.AsSpan());
		}

		private protected override int GetHashCode(string s)
		{
			return s[s.Length + base.HashIndex];
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return s[s.Length + base.HashIndex];
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_RightJustifiedSubstring<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		internal OrdinalStringFrozenDictionary_RightJustifiedSubstring(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return string.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return x.SequenceEqual(y.AsSpan());
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinal(s.AsSpan(s.Length + base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinal(s.Slice(s.Length + base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenDictionary_LeftJustifiedSubstring<TValue> : OrdinalStringFrozenDictionary<TValue>
	{
		internal OrdinalStringFrozenDictionary_LeftJustifiedSubstring(string[] keys, TValue[] values, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore(string key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override ref readonly TValue GetValueRefOrNullRefCore<TAlternateKey>(TAlternateKey key)
		{
			return ref base.GetValueRefOrNullRefCore(key);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return string.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return x.SequenceEqual(y.AsSpan());
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinal(s.AsSpan(base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinal(s.Slice(base.HashIndex, base.HashCount));
		}
	}
	internal abstract class OrdinalStringFrozenSet : FrozenSetInternalBase<string, OrdinalStringFrozenSet.GSW>
	{
		internal struct GSW : IGenericSpecializedWrapper
		{
			private OrdinalStringFrozenSet _set;

			public int Count => _set.Count;

			public IEqualityComparer<string> Comparer => _set.Comparer;

			public void Store(FrozenSet<string> set)
			{
				_set = (OrdinalStringFrozenSet)set;
			}

			public int FindItemIndex(string item)
			{
				return _set.FindItemIndex(item);
			}

			public Enumerator GetEnumerator()
			{
				return _set.GetEnumerator();
			}
		}

		private readonly FrozenHashTable _hashTable;

		private readonly string[] _items;

		private readonly int _minimumLength;

		private readonly int _maximumLengthDiff;

		private protected int HashIndex { get; }

		private protected int HashCount { get; }

		private protected override string[] ItemsCore => _items;

		private protected override int CountCore => _hashTable.Count;

		internal OrdinalStringFrozenSet(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex = -1, int hashCount = -1)
			: base(comparer)
		{
			_items = new string[entries.Length];
			_minimumLength = minimumLength;
			_maximumLengthDiff = maximumLengthDiff;
			HashIndex = hashIndex;
			HashCount = hashCount;
			int[] array = ArrayPool<int>.Shared.Rent(entries.Length);
			Span<int> hashCodes = array.AsSpan(0, entries.Length);
			for (int i = 0; i < entries.Length; i++)
			{
				hashCodes[i] = GetHashCode(entries[i]);
			}
			_hashTable = FrozenHashTable.Create(hashCodes);
			for (int j = 0; j < hashCodes.Length; j++)
			{
				int num = hashCodes[j];
				_items[num] = entries[j];
			}
			ArrayPool<int>.Shared.Return(array);
		}

		private protected virtual bool Equals(string? x, string? y)
		{
			return string.Equals(x, y);
		}

		private protected virtual bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return EqualsOrdinal(x, y);
		}

		private protected abstract int GetHashCode(string s);

		private protected abstract int GetHashCode(ReadOnlySpan<char> s);

		private protected virtual bool CheckLengthQuick(uint length)
		{
			return true;
		}

		private protected override Enumerator GetEnumeratorCore()
		{
			return new FrozenSet<string>.Enumerator(_items);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected override int FindItemIndex(string item)
		{
			if (item != null && (uint)(item.Length - _minimumLength) <= (uint)_maximumLengthDiff && CheckLengthQuick((uint)item.Length))
			{
				int hashCode = GetHashCode(item);
				_hashTable.FindMatchingEntries(hashCode, out var i, out var endIndex);
				for (; i <= endIndex; i++)
				{
					if (hashCode == _hashTable.HashCodes[i] && Equals(item, _items[i]))
					{
						return i;
					}
				}
			}
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected static bool EqualsOrdinal(ReadOnlySpan<char> x, string? y)
		{
			if (!x.IsEmpty || y != null)
			{
				return x.SequenceEqual(y.AsSpan());
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected static bool EqualsOrdinalIgnoreCase(ReadOnlySpan<char> x, string? y)
		{
			if (!x.IsEmpty || y != null)
			{
				return MemoryExtensions.Equals(x, y.AsSpan(), StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}
	}
	internal sealed class OrdinalStringFrozenSet_FullCaseInsensitiveAscii : OrdinalStringFrozenSet
	{
		private readonly ulong _lengthFilter;

		internal OrdinalStringFrozenSet_FullCaseInsensitiveAscii(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, ulong lengthFilter)
			: base(entries, comparer, minimumLength, maximumLengthDiff)
		{
			_lengthFilter = lengthFilter;
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return OrdinalStringFrozenSet.EqualsOrdinalIgnoreCase(x, y);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.AsSpan());
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s);
		}

		private protected override bool CheckLengthQuick(uint length)
		{
			return (_lengthFilter & (ulong)(1L << (int)(length % 64))) != 0;
		}
	}
	internal sealed class OrdinalStringFrozenSet_FullCaseInsensitive : OrdinalStringFrozenSet
	{
		private readonly ulong _lengthFilter;

		internal OrdinalStringFrozenSet_FullCaseInsensitive(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, ulong lengthFilter)
			: base(entries, comparer, minimumLength, maximumLengthDiff)
		{
			_lengthFilter = lengthFilter;
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return OrdinalStringFrozenSet.EqualsOrdinalIgnoreCase(x, y);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.AsSpan());
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s);
		}

		private protected override bool CheckLengthQuick(uint length)
		{
			return (_lengthFilter & (ulong)(1L << (int)(length % 64))) != 0;
		}
	}
	internal sealed class OrdinalStringFrozenSet_Full : OrdinalStringFrozenSet
	{
		private readonly ulong _lengthFilter;

		internal OrdinalStringFrozenSet_Full(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, ulong lengthFilter)
			: base(entries, comparer, minimumLength, maximumLengthDiff)
		{
			_lengthFilter = lengthFilter;
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinal(s.AsSpan());
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinal(s);
		}

		private protected override bool CheckLengthQuick(uint length)
		{
			return (_lengthFilter & (ulong)(1L << (int)(length % 64))) != 0;
		}
	}
	internal sealed class OrdinalStringFrozenSet_LeftJustifiedCaseInsensitiveSubstring : OrdinalStringFrozenSet
	{
		internal OrdinalStringFrozenSet_LeftJustifiedCaseInsensitiveSubstring(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(entries, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return OrdinalStringFrozenSet.EqualsOrdinalIgnoreCase(x, y);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.AsSpan(base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.Slice(base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenSet_LeftJustifiedCaseInsensitiveAsciiSubstring : OrdinalStringFrozenSet
	{
		internal OrdinalStringFrozenSet_LeftJustifiedCaseInsensitiveAsciiSubstring(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(entries, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return OrdinalStringFrozenSet.EqualsOrdinalIgnoreCase(x, y);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.AsSpan(base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.Slice(base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenSet_LeftJustifiedSubstring : OrdinalStringFrozenSet
	{
		internal OrdinalStringFrozenSet_LeftJustifiedSubstring(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(entries, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinal(s.AsSpan(base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinal(s.Slice(base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenSet_LeftJustifiedSingleChar : OrdinalStringFrozenSet
	{
		internal OrdinalStringFrozenSet_LeftJustifiedSingleChar(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex)
			: base(entries, comparer, minimumLength, maximumLengthDiff, hashIndex, 1)
		{
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int GetHashCode(string s)
		{
			return s[base.HashIndex];
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return s[base.HashIndex];
		}
	}
	internal sealed class OrdinalStringFrozenSet_RightJustifiedCaseInsensitiveAsciiSubstring : OrdinalStringFrozenSet
	{
		internal OrdinalStringFrozenSet_RightJustifiedCaseInsensitiveAsciiSubstring(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(entries, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return OrdinalStringFrozenSet.EqualsOrdinalIgnoreCase(x, y);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.AsSpan(s.Length + base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCaseAscii(s.Slice(s.Length + base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenSet_RightJustifiedCaseInsensitiveSubstring : OrdinalStringFrozenSet
	{
		internal OrdinalStringFrozenSet_RightJustifiedCaseInsensitiveSubstring(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(entries, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override bool Equals(string? x, string? y)
		{
			return StringComparer.OrdinalIgnoreCase.Equals(x, y);
		}

		private protected override bool Equals(ReadOnlySpan<char> x, string? y)
		{
			return OrdinalStringFrozenSet.EqualsOrdinalIgnoreCase(x, y);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.AsSpan(s.Length + base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinalIgnoreCase(s.Slice(s.Length + base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenSet_RightJustifiedSubstring : OrdinalStringFrozenSet
	{
		internal OrdinalStringFrozenSet_RightJustifiedSubstring(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex, int hashCount)
			: base(entries, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
		{
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int GetHashCode(string s)
		{
			return Hashing.GetHashCodeOrdinal(s.AsSpan(s.Length + base.HashIndex, base.HashCount));
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return Hashing.GetHashCodeOrdinal(s.Slice(s.Length + base.HashIndex, base.HashCount));
		}
	}
	internal sealed class OrdinalStringFrozenSet_RightJustifiedSingleChar : OrdinalStringFrozenSet
	{
		internal OrdinalStringFrozenSet_RightJustifiedSingleChar(string[] entries, IEqualityComparer<string> comparer, int minimumLength, int maximumLengthDiff, int hashIndex)
			: base(entries, comparer, minimumLength, maximumLengthDiff, hashIndex, 1)
		{
		}

		private protected override int FindItemIndex(string item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int FindItemIndex<TAlternate>(TAlternate item)
		{
			return base.FindItemIndex(item);
		}

		private protected override int GetHashCode(string s)
		{
			return s[s.Length + base.HashIndex];
		}

		private protected override int GetHashCode(ReadOnlySpan<char> s)
		{
			return s[s.Length + base.HashIndex];
		}
	}
}
namespace System.Collections.Generic
{
	internal static class KeyValuePairExtensions
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> source, out TKey key, out TValue value)
		{
			key = source.Key;
			value = source.Value;
		}
	}
	internal interface IReadOnlySet<T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable
	{
		bool Contains(T item);

		bool IsProperSubsetOf(IEnumerable<T> other);

		bool IsProperSupersetOf(IEnumerable<T> other);

		bool IsSubsetOf(IEnumerable<T> other);

		bool IsSupersetOf(IEnumerable<T> other);

		bool Overlaps(IEnumerable<T> other);

		bool SetEquals(IEnumerable<T> other);
	}
	[DebuggerDisplay("{Value}", Name = "[{Key}]")]
	internal readonly struct DebugViewDictionaryItem<TKey, TValue>
	{
		[DebuggerBrowsable(DebuggerBrowsableState.Collapsed)]
		public TKey Key { get; }

		[DebuggerBrowsable(DebuggerBrowsableState.Collapsed)]
		public TValue Value { get; }

		public DebugViewDictionaryItem(TKey key, TValue value)
		{
			Key = key;
			Value = value;
		}

		public DebugViewDictionaryItem(KeyValuePair<TKey, TValue> keyValue)
		{
			Key = keyValue.Key;
			Value = keyValue.Value;
		}
	}
	internal sealed class IDictionaryDebugView<TKey, TValue> where TKey : notnull
	{
		private readonly IDictionary<TKey, TValue> _dict;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public DebugViewDictionaryItem<TKey, TValue>[] Items
		{
			get
			{
				KeyValuePair<TKey, TValue>[] array = new KeyValuePair<TKey, TValue>[_dict.Count];
				_dict.CopyTo(array, 0);
				DebugViewDictionaryItem<TKey, TValue>[] array2 = new DebugViewDictionaryItem<TKey, TValue>[array.Length];
				for (int i = 0; i < array2.Length; i++)
				{
					array2[i] = new DebugViewDictionaryItem<TKey, TValue>(array[i]);
				}
				return array2;
			}
		}

		public IDictionaryDebugView(IDictionary<TKey, TValue> dictionary)
		{
			_dict = dictionary ?? throw new ArgumentNullException("dictionary");
		}
	}
	internal sealed class DictionaryKeyCollectionDebugView<TKey, TValue>
	{
		private readonly ICollection<TKey> _collection;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public TKey[] Items
		{
			get
			{
				TKey[] array = new TKey[_collection.Count];
				_collection.CopyTo(array, 0);
				return array;
			}
		}

		public DictionaryKeyCollectionDebugView(ICollection<TKey> collection)
		{
			_collection = collection ?? throw new ArgumentNullException("collection");
		}
	}
	internal sealed class DictionaryValueCollectionDebugView<TKey, TValue>
	{
		private readonly ICollection<TValue> _collection;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public TValue[] Items
		{
			get
			{
				TValue[] array = new TValue[_collection.Count];
				_collection.CopyTo(array, 0);
				return array;
			}
		}

		public DictionaryValueCollectionDebugView(ICollection<TValue> collection)
		{
			_collection = collection ?? throw new ArgumentNullException("collection");
		}
	}
	internal interface IHashKeyCollection<in TKey>
	{
		IEqualityComparer<TKey> KeyComparer { get; }
	}
	internal interface ISortKeyCollection<in TKey>
	{
		IComparer<TKey> KeyComparer { get; }
	}
}