using System;
using System.Buffers;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Collections.Pooled.Tests")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("Joel Mueller")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2018, 2019 Joel Mueller, Dzmitry Lahoda, based on code from the .NET Foundation")]
[assembly: AssemblyDescription("Includes PooledList, PooledDictionary, PooledSet, PooledStack, and PooledQueue: based on the corresponding collections in System.Collections.Generic, but using ArrayPool internally to reduce allocations, and with some API changes that allow for better compatibility with Span.")]
[assembly: AssemblyFileVersion("1.0.82")]
[assembly: AssemblyInformationalVersion("1.0.82")]
[assembly: AssemblyProduct("Collections.Pooled")]
[assembly: AssemblyTitle("Collections.Pooled")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.82.0")]
[module: UnverifiableCode]
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 IsByRefLikeAttribute : Attribute
	{
	}
}
namespace Collections.Pooled
{
	internal ref struct BitHelper
	{
		private const int IntSize = 32;

		private readonly Span<int> _span;

		internal BitHelper(Span<int> span, bool clear)
		{
			if (clear)
			{
				span.Clear();
			}
			_span = span;
		}

		internal void MarkBit(int bitPosition)
		{
			int num = bitPosition / 32;
			if ((uint)num < (uint)_span.Length)
			{
				_span[num] |= 1 << bitPosition % 32;
			}
		}

		internal bool IsMarked(int bitPosition)
		{
			int num = bitPosition / 32;
			if ((uint)num < (uint)_span.Length)
			{
				return (_span[num] & (1 << bitPosition % 32)) != 0;
			}
			return false;
		}

		internal int FindFirstUnmarked(int startPosition = 0)
		{
			int num = startPosition;
			int num2 = num / 32;
			while ((uint)num2 < (uint)_span.Length)
			{
				if ((_span[num2] & (1 << num % 32)) == 0)
				{
					return num;
				}
				num2 = ++num / 32;
			}
			return -1;
		}

		internal int FindFirstMarked(int startPosition = 0)
		{
			int num = startPosition;
			int num2 = num / 32;
			while ((uint)num2 < (uint)_span.Length)
			{
				if ((_span[num2] & (1 << num % 32)) != 0)
				{
					return num;
				}
				num2 = ++num / 32;
			}
			return -1;
		}

		internal static int ToIntArrayLength(int n)
		{
			if (n <= 0)
			{
				return 0;
			}
			return (n - 1) / 32 + 1;
		}
	}
	public enum ClearMode
	{
		Auto,
		Always,
		Never
	}
	internal static class HashHelpers
	{
		public const int HashCollisionThreshold = 100;

		public const int MaxPrimeArrayLength = 2146435069;

		public const int HashPrime = 101;

		public static readonly int[] primes = 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
		};

		private static ConditionalWeakTable<object, SerializationInfo> s_serializationInfoTable;

		public static ConditionalWeakTable<object, SerializationInfo> SerializationInfoTable
		{
			get
			{
				if (s_serializationInfoTable == null)
				{
					Interlocked.CompareExchange(ref s_serializationInfoTable, new ConditionalWeakTable<object, SerializationInfo>(), null);
				}
				return s_serializationInfoTable;
			}
		}

		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("Cannot get the next prime from a negative number.");
			}
			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 > 2146435069u && 2146435069 > oldSize)
			{
				return 2146435069;
			}
			return GetPrime(num);
		}
	}
	internal sealed class ICollectionDebugView<T>
	{
		private readonly ICollection<T> _collection;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items
		{
			get
			{
				T[] array = new T[_collection.Count];
				_collection.CopyTo(array, 0);
				return array;
			}
		}

		public ICollectionDebugView(ICollection<T> collection)
		{
			_collection = collection ?? throw new ArgumentNullException("collection");
		}
	}
	internal sealed class IDictionaryDebugView<K, V>
	{
		private readonly IDictionary<K, V> _dict;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public KeyValuePair<K, V>[] Items
		{
			get
			{
				KeyValuePair<K, V>[] array = new KeyValuePair<K, V>[_dict.Count];
				_dict.CopyTo(array, 0);
				return array;
			}
		}

		public IDictionaryDebugView(IDictionary<K, V> 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");
		}
	}
	public interface IReadOnlyPooledList<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
	{
		ReadOnlySpan<T> Span { get; }
	}
	[Serializable]
	public sealed class NonRandomizedStringEqualityComparer : EqualityComparer<string>, ISerializable
	{
		private static readonly int s_empyStringHashCode = string.Empty.GetHashCode();

		internal new static IEqualityComparer<string> Default { get; } = new NonRandomizedStringEqualityComparer();


		private NonRandomizedStringEqualityComparer()
		{
		}

		private NonRandomizedStringEqualityComparer(SerializationInfo information, StreamingContext context)
		{
		}

		public sealed override bool Equals(string x, string y)
		{
			return string.Equals(x, y);
		}

		public sealed override int GetHashCode(string str)
		{
			if (str != null)
			{
				if (str.Length != 0)
				{
					return GetNonRandomizedHashCode(str);
				}
				return s_empyStringHashCode;
			}
			return 0;
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.SetType(typeof(NonRandomizedStringEqualityComparer));
		}

		private unsafe static int GetNonRandomizedHashCode(string str)
		{
			ReadOnlySpan<char> readOnlySpan = str.AsSpan();
			fixed (char* ptr = readOnlySpan)
			{
				uint num = 352654597u;
				uint num2 = num;
				uint* ptr2 = (uint*)ptr;
				int num3 = readOnlySpan.Length;
				while (num3 > 2)
				{
					num3 -= 4;
					num = (((num << 5) | (num >> 27)) + num) ^ *ptr2;
					num2 = (((num2 << 5) | (num2 >> 27)) + num2) ^ ptr2[1];
					ptr2 += 2;
				}
				if (num3 > 0)
				{
					num2 = (((num2 << 5) | (num2 >> 27)) + num2) ^ *ptr2;
				}
				return (int)(num + num2 * 1566083941);
			}
		}
	}
	internal enum InsertionBehavior : byte
	{
		None,
		OverwriteExisting,
		ThrowOnExisting
	}
	[Serializable]
	[DebuggerTypeProxy(typeof(IDictionaryDebugView<, >))]
	[DebuggerDisplay("Count = {Count}")]
	public class PooledDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IDictionary, ICollection, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, ISerializable, IDeserializationCallback, IDisposable
	{
		private struct Entry
		{
			public int hashCode;

			public int next;

			public TKey key;

			public TValue value;
		}

		public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IEnumerator, IDisposable, IDictionaryEnumerator
		{
			private readonly PooledDictionary<TKey, TValue> _dictionary;

			private readonly int _version;

			private int _index;

			private KeyValuePair<TKey, TValue> _current;

			private readonly int _getEnumeratorRetType;

			internal const int DictEntry = 1;

			internal const int KeyValuePair = 2;

			public KeyValuePair<TKey, TValue> Current => _current;

			object IEnumerator.Current
			{
				get
				{
					if (_index == 0 || _index == _dictionary._count + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					if (_getEnumeratorRetType == 1)
					{
						return new DictionaryEntry(_current.Key, _current.Value);
					}
					return new KeyValuePair<TKey, TValue>(_current.Key, _current.Value);
				}
			}

			DictionaryEntry IDictionaryEnumerator.Entry
			{
				get
				{
					if (_index == 0 || _index == _dictionary._count + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return new DictionaryEntry(_current.Key, _current.Value);
				}
			}

			object IDictionaryEnumerator.Key
			{
				get
				{
					if (_index == 0 || _index == _dictionary._count + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return _current.Key;
				}
			}

			object IDictionaryEnumerator.Value
			{
				get
				{
					if (_index == 0 || _index == _dictionary._count + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return _current.Value;
				}
			}

			internal Enumerator(PooledDictionary<TKey, TValue> dictionary, int getEnumeratorRetType)
			{
				_dictionary = dictionary;
				_version = dictionary._version;
				_index = 0;
				_getEnumeratorRetType = getEnumeratorRetType;
				_current = default(KeyValuePair<TKey, TValue>);
			}

			public bool MoveNext()
			{
				if (_version != _dictionary._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				while ((uint)_index < (uint)_dictionary._count)
				{
					ref Entry reference = ref _dictionary._entries[_index++];
					if (reference.hashCode >= 0)
					{
						_current = new KeyValuePair<TKey, TValue>(reference.key, reference.value);
						return true;
					}
				}
				_index = _dictionary._count + 1;
				_current = default(KeyValuePair<TKey, TValue>);
				return false;
			}

			public void Dispose()
			{
			}

			void IEnumerator.Reset()
			{
				if (_version != _dictionary._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				_index = 0;
				_current = default(KeyValuePair<TKey, TValue>);
			}
		}

		[DebuggerTypeProxy(typeof(DictionaryKeyCollectionDebugView<, >))]
		[DebuggerDisplay("Count = {Count}")]
		public sealed class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable, ICollection, IReadOnlyCollection<TKey>
		{
			public struct Enumerator : IEnumerator<TKey>, IEnumerator, IDisposable
			{
				private readonly PooledDictionary<TKey, TValue> _dictionary;

				private int _index;

				private readonly int _version;

				private TKey _currentKey;

				public TKey Current => _currentKey;

				object IEnumerator.Current
				{
					get
					{
						if (_index == 0 || _index == _dictionary._count + 1)
						{
							ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
						}
						return _currentKey;
					}
				}

				internal Enumerator(PooledDictionary<TKey, TValue> dictionary)
				{
					_dictionary = dictionary;
					_version = dictionary._version;
					_index = 0;
					_currentKey = default(TKey);
				}

				public void Dispose()
				{
				}

				public bool MoveNext()
				{
					if (_version != _dictionary._version)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
					}
					while ((uint)_index < (uint)_dictionary._count)
					{
						ref Entry reference = ref _dictionary._entries[_index++];
						if (reference.hashCode >= 0)
						{
							_currentKey = reference.key;
							return true;
						}
					}
					_index = _dictionary._count + 1;
					_currentKey = default(TKey);
					return false;
				}

				void IEnumerator.Reset()
				{
					if (_version != _dictionary._version)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
					}
					_index = 0;
					_currentKey = default(TKey);
				}
			}

			private readonly PooledDictionary<TKey, TValue> _dictionary;

			public int Count => _dictionary.Count;

			bool ICollection<TKey>.IsReadOnly => true;

			bool ICollection.IsSynchronized => false;

			object ICollection.SyncRoot => ((ICollection)_dictionary).SyncRoot;

			public KeyCollection(PooledDictionary<TKey, TValue> dictionary)
			{
				_dictionary = dictionary ?? throw new ArgumentNullException("dictionary");
			}

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

			public void CopyTo(TKey[] array, int index)
			{
				if (array == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				if (index < 0 || index > array.Length)
				{
					ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
				}
				if (array.Length - index < _dictionary.Count)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
				}
				int count = _dictionary._count;
				Entry[] entries = _dictionary._entries;
				for (int i = 0; i < count; i++)
				{
					if (entries[i].hashCode >= 0)
					{
						array[index++] = entries[i].key;
					}
				}
			}

			void ICollection<TKey>.Add(TKey item)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
			}

			void ICollection<TKey>.Clear()
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
			}

			bool ICollection<TKey>.Contains(TKey item)
			{
				return _dictionary.ContainsKey(item);
			}

			bool ICollection<TKey>.Remove(TKey item)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
				return false;
			}

			IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			void ICollection.CopyTo(Array array, int index)
			{
				if (array == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				if (array.Rank != 1)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
				}
				if (array.GetLowerBound(0) != 0)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
				}
				if ((uint)index > (uint)array.Length)
				{
					ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
				}
				if (array.Length - index < _dictionary.Count)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
				}
				if (array is TKey[] array2)
				{
					CopyTo(array2, index);
					return;
				}
				object[] array3 = array as object[];
				if (array3 == null)
				{
					ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
				}
				int count = _dictionary._count;
				Entry[] entries = _dictionary._entries;
				try
				{
					for (int i = 0; i < count; i++)
					{
						if (entries[i].hashCode >= 0)
						{
							array3[index++] = entries[i].key;
						}
					}
				}
				catch (ArrayTypeMismatchException)
				{
					ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
				}
			}
		}

		[DebuggerTypeProxy(typeof(DictionaryValueCollectionDebugView<, >))]
		[DebuggerDisplay("Count = {Count}")]
		public sealed class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable, ICollection, IReadOnlyCollection<TValue>
		{
			public struct Enumerator : IEnumerator<TValue>, IEnumerator, IDisposable
			{
				private readonly PooledDictionary<TKey, TValue> _dictionary;

				private int _index;

				private readonly int _version;

				private TValue _currentValue;

				public TValue Current => _currentValue;

				object IEnumerator.Current
				{
					get
					{
						if (_index == 0 || _index == _dictionary._count + 1)
						{
							ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
						}
						return _currentValue;
					}
				}

				internal Enumerator(PooledDictionary<TKey, TValue> dictionary)
				{
					_dictionary = dictionary;
					_version = dictionary._version;
					_index = 0;
					_currentValue = default(TValue);
				}

				public void Dispose()
				{
				}

				public bool MoveNext()
				{
					if (_version != _dictionary._version)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
					}
					while ((uint)_index < (uint)_dictionary._count)
					{
						ref Entry reference = ref _dictionary._entries[_index++];
						if (reference.hashCode >= 0)
						{
							_currentValue = reference.value;
							return true;
						}
					}
					_index = _dictionary._count + 1;
					_currentValue = default(TValue);
					return false;
				}

				void IEnumerator.Reset()
				{
					if (_version != _dictionary._version)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
					}
					_index = 0;
					_currentValue = default(TValue);
				}
			}

			private readonly PooledDictionary<TKey, TValue> _dictionary;

			public int Count => _dictionary.Count;

			bool ICollection<TValue>.IsReadOnly => true;

			bool ICollection.IsSynchronized => false;

			object ICollection.SyncRoot => ((ICollection)_dictionary).SyncRoot;

			public ValueCollection(PooledDictionary<TKey, TValue> dictionary)
			{
				if (dictionary == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
				}
				_dictionary = dictionary;
			}

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

			public void CopyTo(TValue[] array, int index)
			{
				if (array == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				if (index < 0 || index > array.Length)
				{
					ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
				}
				if (array.Length - index < _dictionary.Count)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
				}
				int count = _dictionary._count;
				Entry[] entries = _dictionary._entries;
				for (int i = 0; i < count; i++)
				{
					if (entries[i].hashCode >= 0)
					{
						array[index++] = entries[i].value;
					}
				}
			}

			void ICollection<TValue>.Add(TValue item)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
			}

			bool ICollection<TValue>.Remove(TValue item)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
				return false;
			}

			void ICollection<TValue>.Clear()
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
			}

			bool ICollection<TValue>.Contains(TValue item)
			{
				return _dictionary.ContainsValue(item);
			}

			IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			void ICollection.CopyTo(Array array, int index)
			{
				if (array == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				if (array.Rank != 1)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
				}
				if (array.GetLowerBound(0) != 0)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
				}
				if ((uint)index > (uint)array.Length)
				{
					ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
				}
				if (array.Length - index < _dictionary.Count)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
				}
				if (array is TValue[] array2)
				{
					CopyTo(array2, index);
					return;
				}
				if (array is object[] array3)
				{
					int count = _dictionary._count;
					Entry[] entries = _dictionary._entries;
					try
					{
						for (int i = 0; i < count; i++)
						{
							if (entries[i].hashCode >= 0)
							{
								array3[index++] = entries[i].value;
							}
						}
						return;
					}
					catch (ArrayTypeMismatchException)
					{
						ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
						return;
					}
				}
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
		}

		private const int Lower31BitMask = int.MaxValue;

		private const string VersionName = "Version";

		private const string HashSizeName = "HashSize";

		private const string KeyValuePairsName = "KeyValuePairs";

		private const string ComparerName = "Comparer";

		private const string ClearKeyName = "CK";

		private const string ClearValueName = "CV";

		private static readonly ArrayPool<int> s_bucketPool = ArrayPool<int>.Shared;

		private static readonly ArrayPool<Entry> s_entryPool = ArrayPool<Entry>.Shared;

		private int[] _buckets;

		private Entry[] _entries;

		private int _size;

		private int _count;

		private int _freeList;

		private int _freeCount;

		private int _version;

		private IEqualityComparer<TKey> _comparer;

		private KeyCollection _keys;

		private ValueCollection _values;

		private object _syncRoot;

		private readonly bool _clearKeyOnFree;

		private readonly bool _clearValueOnFree;

		public IEqualityComparer<TKey> Comparer
		{
			get
			{
				if (_comparer != null && !(_comparer is NonRandomizedStringEqualityComparer))
				{
					return _comparer;
				}
				return EqualityComparer<TKey>.Default;
			}
		}

		public int Count => _count - _freeCount;

		public ClearMode KeyClearMode
		{
			get
			{
				if (!_clearKeyOnFree)
				{
					return ClearMode.Never;
				}
				return ClearMode.Always;
			}
		}

		public ClearMode ValueClearMode
		{
			get
			{
				if (!_clearValueOnFree)
				{
					return ClearMode.Never;
				}
				return ClearMode.Always;
			}
		}

		public KeyCollection Keys
		{
			get
			{
				if (_keys == null)
				{
					_keys = new KeyCollection(this);
				}
				return _keys;
			}
		}

		ICollection<TKey> IDictionary<TKey, TValue>.Keys
		{
			get
			{
				if (_keys == null)
				{
					_keys = new KeyCollection(this);
				}
				return _keys;
			}
		}

		IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys
		{
			get
			{
				if (_keys == null)
				{
					_keys = new KeyCollection(this);
				}
				return _keys;
			}
		}

		public ValueCollection Values
		{
			get
			{
				if (_values == null)
				{
					_values = new ValueCollection(this);
				}
				return _values;
			}
		}

		ICollection<TValue> IDictionary<TKey, TValue>.Values
		{
			get
			{
				if (_values == null)
				{
					_values = new ValueCollection(this);
				}
				return _values;
			}
		}

		IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values
		{
			get
			{
				if (_values == null)
				{
					_values = new ValueCollection(this);
				}
				return _values;
			}
		}

		public TValue this[TKey key]
		{
			get
			{
				int num = FindEntry(key);
				if (num >= 0)
				{
					return _entries[num].value;
				}
				ThrowHelper.ThrowKeyNotFoundException(key);
				return default(TValue);
			}
			set
			{
				TryInsert(key, value, InsertionBehavior.OverwriteExisting);
			}
		}

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

		bool ICollection.IsSynchronized => false;

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

		bool IDictionary.IsFixedSize => false;

		bool IDictionary.IsReadOnly => false;

		ICollection IDictionary.Keys => Keys;

		ICollection IDictionary.Values => Values;

		object IDictionary.this[object key]
		{
			get
			{
				if (IsCompatibleKey(key))
				{
					int num = FindEntry((TKey)key);
					if (num >= 0)
					{
						return _entries[num].value;
					}
				}
				return null;
			}
			set
			{
				if (key == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
				}
				ThrowHelper.IfNullAndNullsAreIllegalThenThrow<TValue>(value, ExceptionArgument.value);
				try
				{
					TKey key2 = (TKey)key;
					try
					{
						this[key2] = (TValue)value;
					}
					catch (InvalidCastException)
					{
						ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(TValue));
					}
				}
				catch (InvalidCastException)
				{
					ThrowHelper.ThrowWrongKeyTypeArgumentException(key, typeof(TKey));
				}
			}
		}

		public PooledDictionary()
			: this(0, ClearMode.Auto, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(ClearMode clearMode)
			: this(0, clearMode, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(int capacity)
			: this(capacity, ClearMode.Auto, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(int capacity, ClearMode clearMode)
			: this(capacity, clearMode, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(IEqualityComparer<TKey> comparer)
			: this(0, ClearMode.Auto, comparer)
		{
		}

		public PooledDictionary(int capacity, IEqualityComparer<TKey> comparer)
			: this(capacity, ClearMode.Auto, comparer)
		{
		}

		public PooledDictionary(ClearMode clearMode, IEqualityComparer<TKey> comparer)
			: this(0, clearMode, comparer)
		{
		}

		public PooledDictionary(int capacity, ClearMode clearMode, IEqualityComparer<TKey> comparer)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
			}
			if (capacity > 0)
			{
				Initialize(capacity);
			}
			if (comparer != EqualityComparer<TKey>.Default)
			{
				_comparer = comparer;
			}
			_clearKeyOnFree = ShouldClearKey(clearMode);
			_clearValueOnFree = ShouldClearValue(clearMode);
			if (typeof(TKey) == typeof(string) && _comparer == null)
			{
				_comparer = (IEqualityComparer<TKey>)NonRandomizedStringEqualityComparer.Default;
			}
		}

		public PooledDictionary(IDictionary<TKey, TValue> dictionary)
			: this(dictionary, ClearMode.Auto, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(IDictionary<TKey, TValue> dictionary, ClearMode clearMode)
			: this(dictionary, clearMode, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer)
			: this(dictionary, ClearMode.Auto, comparer)
		{
		}

		public PooledDictionary(IDictionary<TKey, TValue> dictionary, ClearMode clearMode, IEqualityComparer<TKey> comparer)
			: this(dictionary?.Count ?? 0, clearMode, comparer)
		{
			if (dictionary == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
			}
			if (dictionary is PooledDictionary<TKey, TValue> pooledDictionary)
			{
				int count = pooledDictionary._count;
				Entry[] entries = pooledDictionary._entries;
				for (int i = 0; i < count; i++)
				{
					if (entries[i].hashCode >= 0)
					{
						TryInsert(entries[i].key, entries[i].value, InsertionBehavior.ThrowOnExisting);
					}
				}
				return;
			}
			foreach (KeyValuePair<TKey, TValue> item in dictionary)
			{
				TryInsert(item.Key, item.Value, InsertionBehavior.ThrowOnExisting);
			}
		}

		public PooledDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection)
			: this(collection, ClearMode.Auto, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, ClearMode clearMode)
			: this(collection, clearMode, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer)
			: this(collection, ClearMode.Auto, comparer)
		{
		}

		public PooledDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, ClearMode clearMode, IEqualityComparer<TKey> comparer)
			: this((collection as ICollection<KeyValuePair<TKey, TValue>>)?.Count ?? 0, clearMode, comparer)
		{
			if (collection == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
			}
			foreach (KeyValuePair<TKey, TValue> item in collection)
			{
				TryInsert(item.Key, item.Value, InsertionBehavior.ThrowOnExisting);
			}
		}

		public PooledDictionary(IEnumerable<(TKey key, TValue value)> collection)
			: this(collection, ClearMode.Auto, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(IEnumerable<(TKey key, TValue value)> collection, ClearMode clearMode)
			: this(collection, clearMode, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(IEnumerable<(TKey key, TValue value)> collection, IEqualityComparer<TKey> comparer)
			: this(collection, ClearMode.Auto, comparer)
		{
		}

		public PooledDictionary(IEnumerable<(TKey key, TValue value)> collection, ClearMode clearMode, IEqualityComparer<TKey> comparer)
			: this((collection as ICollection<(TKey, TValue)>)?.Count ?? 0, clearMode, comparer)
		{
			if (collection == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
			}
			foreach (var (key, value) in collection)
			{
				TryInsert(key, value, InsertionBehavior.ThrowOnExisting);
			}
		}

		public PooledDictionary((TKey key, TValue value)[] array)
			: this((ReadOnlySpan<(TKey, TValue)>)array.AsSpan(), ClearMode.Auto, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary((TKey key, TValue value)[] array, ClearMode clearMode)
			: this((ReadOnlySpan<(TKey, TValue)>)array.AsSpan(), clearMode, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary((TKey key, TValue value)[] array, IEqualityComparer<TKey> comparer)
			: this((ReadOnlySpan<(TKey, TValue)>)array.AsSpan(), ClearMode.Auto, comparer)
		{
		}

		public PooledDictionary((TKey key, TValue value)[] array, ClearMode clearMode, IEqualityComparer<TKey> comparer)
			: this((ReadOnlySpan<(TKey, TValue)>)array.AsSpan(), clearMode, comparer)
		{
		}

		public PooledDictionary(ReadOnlySpan<(TKey key, TValue value)> span)
			: this(span, ClearMode.Auto, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(ReadOnlySpan<(TKey key, TValue value)> span, ClearMode clearMode)
			: this(span, clearMode, (IEqualityComparer<TKey>)null)
		{
		}

		public PooledDictionary(ReadOnlySpan<(TKey key, TValue value)> span, IEqualityComparer<TKey> comparer)
			: this(span, ClearMode.Auto, comparer)
		{
		}

		public PooledDictionary(ReadOnlySpan<(TKey key, TValue value)> span, ClearMode clearMode, IEqualityComparer<TKey> comparer)
			: this(span.Length, clearMode, comparer)
		{
			ReadOnlySpan<(TKey, TValue)> readOnlySpan = span;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				var (key, value) = readOnlySpan[i];
				TryInsert(key, value, InsertionBehavior.ThrowOnExisting);
			}
		}

		protected PooledDictionary(SerializationInfo info, StreamingContext context)
		{
			_clearKeyOnFree = ((bool?)info.GetValue("CK", typeof(bool))) ?? ShouldClearKey(ClearMode.Auto);
			_clearValueOnFree = ((bool?)info.GetValue("CV", typeof(bool))) ?? ShouldClearValue(ClearMode.Auto);
			HashHelpers.SerializationInfoTable.Add(this, info);
		}

		public void Add(TKey key, TValue value)
		{
			TryInsert(key, value, InsertionBehavior.ThrowOnExisting);
		}

		public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> enumerable)
		{
			if (enumerable == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.enumerable);
			}
			if (enumerable is ICollection<KeyValuePair<TKey, TValue>> collection)
			{
				EnsureCapacity(_count + collection.Count);
			}
			foreach (KeyValuePair<TKey, TValue> item in enumerable)
			{
				TryInsert(item.Key, item.Value, InsertionBehavior.ThrowOnExisting);
			}
		}

		public void AddRange(IEnumerable<(TKey key, TValue value)> enumerable)
		{
			if (enumerable == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.enumerable);
			}
			if (enumerable is ICollection<KeyValuePair<TKey, TValue>> collection)
			{
				EnsureCapacity(_count + collection.Count);
			}
			foreach (var (key, value) in enumerable)
			{
				TryInsert(key, value, InsertionBehavior.ThrowOnExisting);
			}
		}

		public void AddRange(ReadOnlySpan<(TKey key, TValue value)> span)
		{
			EnsureCapacity(_count + span.Length);
			ReadOnlySpan<(TKey, TValue)> readOnlySpan = span;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				var (key, value) = readOnlySpan[i];
				TryInsert(key, value, InsertionBehavior.ThrowOnExisting);
			}
		}

		public void AddRange((TKey key, TValue value)[] array)
		{
			AddRange(array.AsSpan());
		}

		public void AddOrUpdate(TKey key, TValue addValue, Func<TKey, TValue, TValue> updater)
		{
			if (TryGetValue(key, out var value))
			{
				TValue value2 = updater(key, value);
				TryInsert(key, value2, InsertionBehavior.OverwriteExisting);
			}
			else
			{
				TryInsert(key, addValue, InsertionBehavior.ThrowOnExisting);
			}
		}

		public void AddOrUpdate(TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updater)
		{
			if (TryGetValue(key, out var value))
			{
				TValue value2 = updater(key, value);
				TryInsert(key, value2, InsertionBehavior.OverwriteExisting);
			}
			else
			{
				TValue value3 = addValueFactory(key);
				TryInsert(key, value3, InsertionBehavior.ThrowOnExisting);
			}
		}

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

		bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair)
		{
			int num = FindEntry(keyValuePair.Key);
			if (num >= 0 && EqualityComparer<TValue>.Default.Equals(_entries[num].value, keyValuePair.Value))
			{
				return true;
			}
			return false;
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair)
		{
			int num = FindEntry(keyValuePair.Key);
			if (num >= 0 && EqualityComparer<TValue>.Default.Equals(_entries[num].value, keyValuePair.Value))
			{
				Remove(keyValuePair.Key);
				return true;
			}
			return false;
		}

		public void Clear()
		{
			int count = _count;
			if (count > 0)
			{
				Array.Clear(_buckets, 0, _size);
				_count = 0;
				_freeList = -1;
				_freeCount = 0;
				_size = 0;
				Array.Clear(_entries, 0, count);
				_version++;
			}
		}

		public bool ContainsKey(TKey key)
		{
			return FindEntry(key) >= 0;
		}

		public bool ContainsValue(TValue value)
		{
			Entry[] entries = _entries;
			if (value == null)
			{
				for (int i = 0; i < _count; i++)
				{
					if (entries[i].hashCode >= 0 && entries[i].value == null)
					{
						return true;
					}
				}
			}
			else if (default(TValue) != null)
			{
				for (int j = 0; j < _count; j++)
				{
					if (entries[j].hashCode >= 0 && EqualityComparer<TValue>.Default.Equals(entries[j].value, value))
					{
						return true;
					}
				}
			}
			else
			{
				EqualityComparer<TValue> @default = EqualityComparer<TValue>.Default;
				for (int k = 0; k < _count; k++)
				{
					if (entries[k].hashCode >= 0 && @default.Equals(entries[k].value, value))
					{
						return true;
					}
				}
			}
			return false;
		}

		private void CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if ((uint)index > (uint)array.Length)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (array.Length - index < Count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
			}
			int count = _count;
			Entry[] entries = _entries;
			for (int i = 0; i < count; i++)
			{
				if (entries[i].hashCode >= 0)
				{
					array[index++] = new KeyValuePair<TKey, TValue>(entries[i].key, entries[i].value);
				}
			}
		}

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

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

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			GetObjectData(info, context);
		}

		protected virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.info);
			}
			info.AddValue("Version", _version);
			info.AddValue("Comparer", _comparer ?? EqualityComparer<TKey>.Default, typeof(IEqualityComparer<TKey>));
			info.AddValue("HashSize", _size);
			info.AddValue("CK", _clearKeyOnFree);
			info.AddValue("CV", _clearValueOnFree);
			if (_buckets != null)
			{
				KeyValuePair<TKey, TValue>[] array = new KeyValuePair<TKey, TValue>[Count];
				CopyTo(array, 0);
				info.AddValue("KeyValuePairs", array, typeof(KeyValuePair<TKey, TValue>[]));
			}
		}

		private int FindEntry(TKey key)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			int result = -1;
			int size = _size;
			if (size <= 0)
			{
				return result;
			}
			int[] buckets = _buckets;
			Entry[] entries = _entries;
			int num = 0;
			IEqualityComparer<TKey> comparer = _comparer;
			if (comparer == null)
			{
				int num2 = key.GetHashCode() & 0x7FFFFFFF;
				result = buckets[num2 % size] - 1;
				if (default(TKey) != null)
				{
					while ((uint)result < (uint)size && (entries[result].hashCode != num2 || !EqualityComparer<TKey>.Default.Equals(entries[result].key, key)))
					{
						result = entries[result].next;
						if (num >= size)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
						num++;
					}
				}
				else
				{
					EqualityComparer<TKey> @default = EqualityComparer<TKey>.Default;
					while ((uint)result < (uint)size && (entries[result].hashCode != num2 || !@default.Equals(entries[result].key, key)))
					{
						result = entries[result].next;
						if (num >= size)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
						num++;
					}
				}
			}
			else
			{
				int num3 = comparer.GetHashCode(key) & 0x7FFFFFFF;
				result = buckets[num3 % size] - 1;
				while ((uint)result < (uint)size && (entries[result].hashCode != num3 || !comparer.Equals(entries[result].key, key)))
				{
					result = entries[result].next;
					if (num >= size)
					{
						ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
					}
					num++;
				}
			}
			return result;
		}

		private int Initialize(int capacity)
		{
			_size = HashHelpers.GetPrime(capacity);
			_freeList = -1;
			_buckets = s_bucketPool.Rent(_size);
			Array.Clear(_buckets, 0, _buckets.Length);
			_entries = s_entryPool.Rent(_size);
			return _size;
		}

		private bool TryInsert(TKey key, TValue value, InsertionBehavior behavior)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			if (_buckets == null || _size == 0)
			{
				Initialize(0);
			}
			Entry[] entries = _entries;
			IEqualityComparer<TKey> comparer = _comparer;
			int size = _size;
			int num = (comparer?.GetHashCode(key) ?? key.GetHashCode()) & 0x7FFFFFFF;
			int num2 = 0;
			ref int reference = ref _buckets[num % size];
			int num3 = reference - 1;
			if (comparer == null)
			{
				if (default(TKey) != null)
				{
					while ((uint)num3 < (uint)size)
					{
						if (entries[num3].hashCode == num && EqualityComparer<TKey>.Default.Equals(entries[num3].key, key))
						{
							switch (behavior)
							{
							case InsertionBehavior.OverwriteExisting:
								entries[num3].value = value;
								_version++;
								return true;
							case InsertionBehavior.ThrowOnExisting:
								ThrowHelper.ThrowAddingDuplicateWithKeyArgumentException(key);
								break;
							}
							return false;
						}
						num3 = entries[num3].next;
						if (num2 >= size)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
						num2++;
					}
				}
				else
				{
					EqualityComparer<TKey> @default = EqualityComparer<TKey>.Default;
					while ((uint)num3 < (uint)size)
					{
						if (entries[num3].hashCode == num && @default.Equals(entries[num3].key, key))
						{
							switch (behavior)
							{
							case InsertionBehavior.OverwriteExisting:
								entries[num3].value = value;
								_version++;
								return true;
							case InsertionBehavior.ThrowOnExisting:
								ThrowHelper.ThrowAddingDuplicateWithKeyArgumentException(key);
								break;
							}
							return false;
						}
						num3 = entries[num3].next;
						if (num2 >= size)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
						num2++;
					}
				}
			}
			else
			{
				while ((uint)num3 < (uint)size)
				{
					if (entries[num3].hashCode == num && comparer.Equals(entries[num3].key, key))
					{
						switch (behavior)
						{
						case InsertionBehavior.OverwriteExisting:
							entries[num3].value = value;
							_version++;
							return true;
						case InsertionBehavior.ThrowOnExisting:
							ThrowHelper.ThrowAddingDuplicateWithKeyArgumentException(key);
							break;
						}
						return false;
					}
					num3 = entries[num3].next;
					if (num2 >= size)
					{
						ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
					}
					num2++;
				}
			}
			bool flag = false;
			int num4;
			if (_freeCount > 0)
			{
				num4 = _freeList;
				flag = true;
				_freeCount--;
			}
			else
			{
				int count = _count;
				if (count == size)
				{
					Resize();
					size = _size;
					reference = ref _buckets[num % size];
				}
				num4 = count;
				_count = count + 1;
				entries = _entries;
			}
			ref Entry reference2 = ref entries[num4];
			if (flag)
			{
				_freeList = reference2.next;
			}
			reference2.hashCode = num;
			reference2.next = reference - 1;
			reference2.key = key;
			reference2.value = value;
			reference = num4 + 1;
			_version++;
			if (default(TKey) == null && num2 > 100 && comparer is NonRandomizedStringEqualityComparer)
			{
				_comparer = null;
				Resize(size, forceNewHashCodes: true);
			}
			return true;
		}

		public virtual void OnDeserialization(object sender)
		{
			HashHelpers.SerializationInfoTable.TryGetValue(this, out var value);
			if (value == null)
			{
				return;
			}
			int @int = value.GetInt32("Version");
			int int2 = value.GetInt32("HashSize");
			_comparer = (IEqualityComparer<TKey>)value.GetValue("Comparer", typeof(IEqualityComparer<TKey>));
			if (int2 != 0)
			{
				Initialize(int2);
				KeyValuePair<TKey, TValue>[] array = (KeyValuePair<TKey, TValue>[])value.GetValue("KeyValuePairs", typeof(KeyValuePair<TKey, TValue>[]));
				if (array == null)
				{
					throw new SerializationException("Serialized PooledDictionary missing data.");
				}
				for (int i = 0; i < array.Length; i++)
				{
					if (array[i].Key == null)
					{
						throw new SerializationException("Serialized PooledDictionary had null key.");
					}
					Add(array[i].Key, array[i].Value);
				}
			}
			else
			{
				_buckets = null;
			}
			_version = @int;
			HashHelpers.SerializationInfoTable.Remove(this);
		}

		private void Resize()
		{
			Resize(HashHelpers.ExpandPrime(_count), forceNewHashCodes: false);
		}

		private void Resize(int newSize, bool forceNewHashCodes)
		{
			int count = _count;
			int[] array;
			Entry[] array2;
			bool flag;
			if (_buckets.Length >= newSize && _entries.Length >= newSize)
			{
				Array.Clear(_buckets, 0, _buckets.Length);
				Array.Clear(_entries, _size, newSize - _size);
				array = _buckets;
				array2 = _entries;
				flag = false;
			}
			else
			{
				array = s_bucketPool.Rent(newSize);
				array2 = s_entryPool.Rent(newSize);
				Array.Clear(array, 0, array.Length);
				Array.Copy(_entries, 0, array2, 0, count);
				flag = true;
			}
			if (default(TKey) == null && forceNewHashCodes)
			{
				for (int i = 0; i < count; i++)
				{
					if (array2[i].hashCode >= 0)
					{
						array2[i].hashCode = array2[i].key.GetHashCode() & 0x7FFFFFFF;
					}
				}
			}
			for (int j = 0; j < count; j++)
			{
				if (array2[j].hashCode >= 0)
				{
					int num = array2[j].hashCode % newSize;
					array2[j].next = array[num] - 1;
					array[num] = j + 1;
				}
			}
			if (flag)
			{
				ReturnArrays();
				_buckets = array;
				_entries = array2;
			}
			_size = newSize;
		}

		public bool Remove(TKey key)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			int[] buckets = _buckets;
			Entry[] entries = _entries;
			int num = 0;
			if (_size > 0)
			{
				int num2 = (_comparer?.GetHashCode(key) ?? key.GetHashCode()) & 0x7FFFFFFF;
				int num3 = num2 % _size;
				int num4 = -1;
				int num5 = buckets[num3] - 1;
				while (num5 >= 0)
				{
					ref Entry reference = ref entries[num5];
					if (reference.hashCode == num2 && (_comparer?.Equals(reference.key, key) ?? EqualityComparer<TKey>.Default.Equals(reference.key, key)))
					{
						if (num4 < 0)
						{
							buckets[num3] = reference.next + 1;
						}
						else
						{
							entries[num4].next = reference.next;
						}
						reference.hashCode = -1;
						reference.next = _freeList;
						if (_clearKeyOnFree)
						{
							reference.key = default(TKey);
						}
						if (_clearValueOnFree)
						{
							reference.value = default(TValue);
						}
						_freeList = num5;
						_freeCount++;
						_version++;
						return true;
					}
					num4 = num5;
					num5 = reference.next;
					if (num >= _size)
					{
						ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
					}
					num++;
				}
			}
			return false;
		}

		public bool Remove(TKey key, out TValue value)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			int[] buckets = _buckets;
			Entry[] entries = _entries;
			int num = 0;
			int num2 = (_comparer?.GetHashCode(key) ?? key.GetHashCode()) & 0x7FFFFFFF;
			int num3 = num2 % _size;
			int num4 = -1;
			int num5 = buckets[num3] - 1;
			while (num5 >= 0)
			{
				ref Entry reference = ref entries[num5];
				if (reference.hashCode == num2 && (_comparer?.Equals(reference.key, key) ?? EqualityComparer<TKey>.Default.Equals(reference.key, key)))
				{
					if (num4 < 0)
					{
						buckets[num3] = reference.next + 1;
					}
					else
					{
						entries[num4].next = reference.next;
					}
					value = reference.value;
					reference.hashCode = -1;
					reference.next = _freeList;
					if (_clearKeyOnFree)
					{
						reference.key = default(TKey);
					}
					if (_clearValueOnFree)
					{
						reference.value = default(TValue);
					}
					_freeList = num5;
					_freeCount++;
					return true;
				}
				num4 = num5;
				num5 = reference.next;
				if (num >= _size)
				{
					ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
				}
				num++;
			}
			value = default(TValue);
			return false;
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			int num = FindEntry(key);
			if (num >= 0)
			{
				value = _entries[num].value;
				return true;
			}
			value = default(TValue);
			return false;
		}

		public bool TryAdd(TKey key, TValue value)
		{
			return TryInsert(key, value, InsertionBehavior.None);
		}

		public TValue GetOrAdd(TKey key, TValue addValue)
		{
			if (TryGetValue(key, out var value))
			{
				return value;
			}
			Add(key, addValue);
			return addValue;
		}

		public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory)
		{
			if (TryGetValue(key, out var value))
			{
				return value;
			}
			TValue val = valueFactory(key);
			Add(key, val);
			return val;
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
		{
			CopyTo(array, index);
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (array.Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
			}
			if (array.GetLowerBound(0) != 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
			}
			if ((uint)index > (uint)array.Length)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (array.Length - index < Count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
			}
			if (array is KeyValuePair<TKey, TValue>[] array2)
			{
				CopyTo(array2, index);
				return;
			}
			if (array is DictionaryEntry[] array3)
			{
				Entry[] entries = _entries;
				for (int i = 0; i < _count; i++)
				{
					if (entries[i].hashCode >= 0)
					{
						array3[index++] = new DictionaryEntry(entries[i].key, entries[i].value);
					}
				}
				return;
			}
			if (array is object[] array4)
			{
				try
				{
					int count = _count;
					Entry[] entries2 = _entries;
					for (int j = 0; j < count; j++)
					{
						if (entries2[j].hashCode >= 0)
						{
							array4[index++] = new KeyValuePair<TKey, TValue>(entries2[j].key, entries2[j].value);
						}
					}
					return;
				}
				catch (ArrayTypeMismatchException)
				{
					ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
					return;
				}
			}
			ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new Enumerator(this, 2);
		}

		public int EnsureCapacity(int capacity)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
			}
			int size = _size;
			if (size >= capacity)
			{
				return size;
			}
			_version++;
			if (_buckets == null || _size == 0)
			{
				return Initialize(capacity);
			}
			int prime = HashHelpers.GetPrime(capacity);
			Resize(prime, forceNewHashCodes: false);
			return prime;
		}

		public void TrimExcess()
		{
			TrimExcess(Count);
		}

		public void TrimExcess(int capacity)
		{
			if (capacity < Count)
			{
				throw new ArgumentOutOfRangeException("capacity");
			}
			int prime = HashHelpers.GetPrime(capacity);
			Entry[] entries = _entries;
			int[] buckets = _buckets;
			int num = ((entries != null) ? entries.Length : 0);
			if (prime >= num)
			{
				return;
			}
			int count = _count;
			_version++;
			Initialize(prime);
			Entry[] entries2 = _entries;
			int[] buckets2 = _buckets;
			int num2 = 0;
			for (int i = 0; i < count; i++)
			{
				int hashCode = entries[i].hashCode;
				if (hashCode >= 0)
				{
					ref Entry reference = ref entries2[num2];
					reference = entries[i];
					int num3 = hashCode % prime;
					reference.next = buckets2[num3] - 1;
					buckets2[num3] = num2 + 1;
					num2++;
				}
			}
			_count = num2;
			_size = prime;
			_freeCount = 0;
			s_bucketPool.Return(buckets);
			s_entryPool.Return(entries2, _clearKeyOnFree || _clearValueOnFree);
		}

		private void ReturnArrays()
		{
			Entry[] entries = _entries;
			if (entries != null && entries.Length != 0)
			{
				try
				{
					s_entryPool.Return(_entries, _clearKeyOnFree || _clearValueOnFree);
				}
				catch (ArgumentException)
				{
				}
			}
			int[] buckets = _buckets;
			if (buckets != null && buckets.Length != 0)
			{
				try
				{
					s_bucketPool.Return(_buckets);
				}
				catch (ArgumentException)
				{
				}
			}
			_entries = null;
			_buckets = null;
		}

		private static bool ShouldClearKey(ClearMode mode)
		{
			return mode != ClearMode.Never;
		}

		private static bool ShouldClearValue(ClearMode mode)
		{
			return mode != ClearMode.Never;
		}

		private static bool IsCompatibleKey(object key)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			return key is TKey;
		}

		void IDictionary.Add(object key, object value)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			ThrowHelper.IfNullAndNullsAreIllegalThenThrow<TValue>(value, ExceptionArgument.value);
			try
			{
				TKey key2 = (TKey)key;
				try
				{
					Add(key2, (TValue)value);
				}
				catch (InvalidCastException)
				{
					ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(TValue));
				}
			}
			catch (InvalidCastException)
			{
				ThrowHelper.ThrowWrongKeyTypeArgumentException(key, typeof(TKey));
			}
		}

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

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return new Enumerator(this, 1);
		}

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

		public void Dispose()
		{
			ReturnArrays();
			_count = 0;
			_size = 0;
			_freeList = -1;
			_freeCount = 0;
		}
	}
	public static class PooledExtensions
	{
		public static PooledList<T> ToPooledList<T>(this IEnumerable<T> items)
		{
			return new PooledList<T>(items);
		}

		public static PooledList<T> ToPooledList<T>(this T[] array)
		{
			return new PooledList<T>(array.AsSpan());
		}

		public static PooledList<T> ToPooledList<T>(this ReadOnlySpan<T> span)
		{
			return new PooledList<T>(span);
		}

		public static PooledList<T> ToPooledList<T>(this Span<T> span)
		{
			return new PooledList<T>(span);
		}

		public static PooledList<T> ToPooledList<T>(this ReadOnlyMemory<T> memory)
		{
			return new PooledList<T>(memory.Span);
		}

		public static PooledList<T> ToPooledList<T>(this Memory<T> memory)
		{
			return new PooledList<T>(memory.Span);
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector, IEqualityComparer<TKey> comparer = null)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			PooledDictionary<TKey, TValue> pooledDictionary = new PooledDictionary<TKey, TValue>((source as ICollection<TSource>)?.Count ?? 0, comparer);
			foreach (TSource item in source)
			{
				pooledDictionary.Add(keySelector(item), valueSelector(item));
			}
			return pooledDictionary;
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TSource, TKey, TValue>(this ReadOnlySpan<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector, IEqualityComparer<TKey> comparer = null)
		{
			PooledDictionary<TKey, TValue> pooledDictionary = new PooledDictionary<TKey, TValue>(source.Length, comparer);
			ReadOnlySpan<TSource> readOnlySpan = source;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				TSource arg = readOnlySpan[i];
				pooledDictionary.Add(keySelector(arg), valueSelector(arg));
			}
			return pooledDictionary;
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TSource, TKey, TValue>(this Span<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector, IEqualityComparer<TKey> comparer)
		{
			return ((ReadOnlySpan<TSource>)source).ToPooledDictionary(keySelector, valueSelector, comparer);
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TSource, TKey, TValue>(this ReadOnlyMemory<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector, IEqualityComparer<TKey> comparer)
		{
			return source.Span.ToPooledDictionary(keySelector, valueSelector, comparer);
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TSource, TKey, TValue>(this Memory<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector, IEqualityComparer<TKey> comparer)
		{
			return source.Span.ToPooledDictionary(keySelector, valueSelector, comparer);
		}

		public static PooledDictionary<TKey, TSource> ToPooledDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer = null)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			PooledDictionary<TKey, TSource> pooledDictionary = new PooledDictionary<TKey, TSource>((source as ICollection<TSource>)?.Count ?? 0, comparer);
			foreach (TSource item in source)
			{
				pooledDictionary.Add(keySelector(item), item);
			}
			return pooledDictionary;
		}

		public static PooledDictionary<TKey, TSource> ToPooledDictionary<TSource, TKey>(this ReadOnlySpan<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer = null)
		{
			PooledDictionary<TKey, TSource> pooledDictionary = new PooledDictionary<TKey, TSource>(source.Length, comparer);
			ReadOnlySpan<TSource> readOnlySpan = source;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				TSource val = readOnlySpan[i];
				pooledDictionary.Add(keySelector(val), val);
			}
			return pooledDictionary;
		}

		public static PooledDictionary<TKey, TSource> ToPooledDictionary<TSource, TKey>(this Span<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer = null)
		{
			return ((ReadOnlySpan<TSource>)source).ToPooledDictionary(keySelector, comparer);
		}

		public static PooledDictionary<TKey, TSource> ToPooledDictionary<TSource, TKey>(this ReadOnlyMemory<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer = null)
		{
			return source.Span.ToPooledDictionary(keySelector, comparer);
		}

		public static PooledDictionary<TKey, TSource> ToPooledDictionary<TSource, TKey>(this Memory<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer = null)
		{
			return source.Span.ToPooledDictionary(keySelector, comparer);
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TKey, TValue>(this IEnumerable<(TKey, TValue)> source, IEqualityComparer<TKey> comparer = null)
		{
			return new PooledDictionary<TKey, TValue>(source, comparer);
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey> comparer = null)
		{
			return new PooledDictionary<TKey, TValue>(source, comparer);
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TKey, TValue>(this IEnumerable<Tuple<TKey, TValue>> source, IEqualityComparer<TKey> comparer = null)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			PooledDictionary<TKey, TValue> pooledDictionary = new PooledDictionary<TKey, TValue>((source as ICollection<Tuple<TKey, TValue>>)?.Count ?? 0, comparer);
			foreach (Tuple<TKey, TValue> item in source)
			{
				pooledDictionary.Add(item.Item1, item.Item2);
			}
			return pooledDictionary;
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TKey, TValue>(this ReadOnlySpan<(TKey, TValue)> source, IEqualityComparer<TKey> comparer = null)
		{
			return new PooledDictionary<TKey, TValue>(source, comparer);
		}

		public static PooledDictionary<TKey, TValue> ToPooledDictionary<TKey, TValue>(this Span<(TKey, TValue)> source, IEqualityComparer<TKey> comparer = null)
		{
			return new PooledDictionary<TKey, TValue>(source, comparer);
		}

		public static PooledSet<T> ToPooledSet<T>(this IEnumerable<T> source, IEqualityComparer<T> comparer = null)
		{
			return new PooledSet<T>(source, comparer);
		}

		public static PooledSet<T> ToPooledSet<T>(this Span<T> source, IEqualityComparer<T> comparer = null)
		{
			return new PooledSet<T>(source, comparer);
		}

		public static PooledSet<T> ToPooledSet<T>(this ReadOnlySpan<T> source, IEqualityComparer<T> comparer = null)
		{
			return new PooledSet<T>(source, comparer);
		}

		public static PooledSet<T> ToPooledSet<T>(this Memory<T> source, IEqualityComparer<T> comparer = null)
		{
			return new PooledSet<T>(source.Span, comparer);
		}

		public static PooledSet<T> ToPooledSet<T>(this ReadOnlyMemory<T> source, IEqualityComparer<T> comparer = null)
		{
			return new PooledSet<T>(source.Span, comparer);
		}

		public static PooledStack<T> ToPooledStack<T>(this IEnumerable<T> items)
		{
			return new PooledStack<T>(items);
		}

		public static PooledStack<T> ToPooledStack<T>(this T[] array)
		{
			return new PooledStack<T>(array.AsSpan());
		}

		public static PooledStack<T> ToPooledStack<T>(this ReadOnlySpan<T> span)
		{
			return new PooledStack<T>(span);
		}

		public static PooledStack<T> ToPooledStack<T>(this Span<T> span)
		{
			return new PooledStack<T>(span);
		}

		public static PooledStack<T> ToPooledStack<T>(this ReadOnlyMemory<T> memory)
		{
			return new PooledStack<T>(memory.Span);
		}

		public static PooledStack<T> ToPooledStack<T>(this Memory<T> memory)
		{
			return new PooledStack<T>(memory.Span);
		}

		public static PooledQueue<T> ToPooledQueue<T>(this IEnumerable<T> items)
		{
			return new PooledQueue<T>(items);
		}

		public static PooledQueue<T> ToPooledQueue<T>(this ReadOnlySpan<T> span)
		{
			return new PooledQueue<T>(span);
		}

		public static PooledQueue<T> ToPooledQueue<T>(this Span<T> span)
		{
			return new PooledQueue<T>(span);
		}

		public static PooledQueue<T> ToPooledQueue<T>(this ReadOnlyMemory<T> memory)
		{
			return new PooledQueue<T>(memory.Span);
		}

		public static PooledQueue<T> ToPooledQueue<T>(this Memory<T> memory)
		{
			return new PooledQueue<T>(memory.Span);
		}

		public static PooledQueue<T> ToPooledQueue<T>(this T[] array)
		{
			return new PooledQueue<T>(array.AsSpan());
		}
	}
	[Serializable]
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(ICollectionDebugView<>))]
	public class PooledList<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyPooledList<T>, IReadOnlyList<T>, IReadOnlyCollection<T>, IList, ICollection, IDisposable, IDeserializationCallback
	{
		public struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable
		{
			private readonly PooledList<T> _list;

			private int _index;

			private readonly int _version;

			private T _current;

			public T Current => _current;

			object IEnumerator.Current
			{
				get
				{
					if (_index == 0 || _index == _list._size + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return Current;
				}
			}

			internal Enumerator(PooledList<T> list)
			{
				_list = list;
				_index = 0;
				_version = list._version;
				_current = default(T);
			}

			public void Dispose()
			{
			}

			public bool MoveNext()
			{
				PooledList<T> list = _list;
				if (_version == list._version && (uint)_index < (uint)list._size)
				{
					_current = list._items[_index];
					_index++;
					return true;
				}
				return MoveNextRare();
			}

			private bool MoveNextRare()
			{
				if (_version != _list._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				_index = _list._size + 1;
				_current = default(T);
				return false;
			}

			void IEnumerator.Reset()
			{
				if (_version != _list._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				_index = 0;
				_current = default(T);
			}
		}

		private readonly struct Comparer : IComparer<T>
		{
			private readonly Func<T, T, int> _comparison;

			public Comparer(Func<T, T, int> comparison)
			{
				_comparison = comparison;
			}

			public int Compare(T x, T y)
			{
				return _comparison(x, y);
			}
		}

		private const int MaxArrayLength = 2146435071;

		private const int DefaultCapacity = 4;

		private static readonly T[] s_emptyArray = Array.Empty<T>();

		[NonSerialized]
		private ArrayPool<T> _pool;

		[NonSerialized]
		private object _syncRoot;

		private T[] _items;

		private int _size;

		private int _version;

		private readonly bool _clearOnFree;

		public Span<T> Span => _items.AsSpan(0, _size);

		ReadOnlySpan<T> IReadOnlyPooledList<T>.Span => Span;

		public int Capacity
		{
			get
			{
				return _items.Length;
			}
			set
			{
				if (value < _size)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_SmallCapacity);
				}
				if (value == _items.Length)
				{
					return;
				}
				if (value > 0)
				{
					T[] array = _pool.Rent(value);
					if (_size > 0)
					{
						Array.Copy(_items, array, _size);
					}
					ReturnArray();
					_items = array;
				}
				else
				{
					ReturnArray();
					_size = 0;
				}
			}
		}

		public int Count => _size;

		public ClearMode ClearMode
		{
			get
			{
				if (!_clearOnFree)
				{
					return ClearMode.Never;
				}
				return ClearMode.Always;
			}
		}

		bool IList.IsFixedSize => false;

		bool ICollection<T>.IsReadOnly => false;

		bool IList.IsReadOnly => false;

		int ICollection.Count => _size;

		bool ICollection.IsSynchronized => false;

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

		public T this[int index]
		{
			get
			{
				if ((uint)index >= (uint)_size)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				return _items[index];
			}
			set
			{
				if ((uint)index >= (uint)_size)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				_items[index] = value;
				_version++;
			}
		}

		object IList.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(value, ExceptionArgument.value);
				try
				{
					this[index] = (T)value;
				}
				catch (InvalidCastException)
				{
					ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
				}
			}
		}

		public PooledList()
			: this(ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledList(ClearMode clearMode)
			: this(clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledList(ArrayPool<T> customPool)
			: this(ClearMode.Auto, customPool)
		{
		}

		public PooledList(ClearMode clearMode, ArrayPool<T> customPool)
		{
			_items = s_emptyArray;
			_pool = customPool ?? ArrayPool<T>.Shared;
			_clearOnFree = ShouldClear(clearMode);
		}

		public PooledList(int capacity)
			: this(capacity, ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledList(int capacity, bool sizeToCapacity)
			: this(capacity, ClearMode.Auto, ArrayPool<T>.Shared, sizeToCapacity)
		{
		}

		public PooledList(int capacity, ClearMode clearMode)
			: this(capacity, clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledList(int capacity, ClearMode clearMode, bool sizeToCapacity)
			: this(capacity, clearMode, ArrayPool<T>.Shared, sizeToCapacity)
		{
		}

		public PooledList(int capacity, ArrayPool<T> customPool)
			: this(capacity, ClearMode.Auto, customPool)
		{
		}

		public PooledList(int capacity, ArrayPool<T> customPool, bool sizeToCapacity)
			: this(capacity, ClearMode.Auto, customPool, sizeToCapacity)
		{
		}

		public PooledList(int capacity, ClearMode clearMode, ArrayPool<T> customPool)
			: this(capacity, clearMode, customPool, sizeToCapacity: false)
		{
		}

		public PooledList(int capacity, ClearMode clearMode, ArrayPool<T> customPool, bool sizeToCapacity)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			_pool = customPool ?? ArrayPool<T>.Shared;
			_clearOnFree = ShouldClear(clearMode);
			if (capacity == 0)
			{
				_items = s_emptyArray;
			}
			else
			{
				_items = _pool.Rent(capacity);
			}
			if (sizeToCapacity)
			{
				_size = capacity;
				if (clearMode != ClearMode.Never)
				{
					Array.Clear(_items, 0, _size);
				}
			}
		}

		public PooledList(T[] array)
			: this((ReadOnlySpan<T>)array.AsSpan(), ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledList(T[] array, ClearMode clearMode)
			: this((ReadOnlySpan<T>)array.AsSpan(), clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledList(T[] array, ArrayPool<T> customPool)
			: this((ReadOnlySpan<T>)array.AsSpan(), ClearMode.Auto, customPool)
		{
		}

		public PooledList(T[] array, ClearMode clearMode, ArrayPool<T> customPool)
			: this((ReadOnlySpan<T>)array.AsSpan(), clearMode, customPool)
		{
		}

		public PooledList(ReadOnlySpan<T> span)
			: this(span, ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledList(ReadOnlySpan<T> span, ClearMode clearMode)
			: this(span, clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledList(ReadOnlySpan<T> span, ArrayPool<T> customPool)
			: this(span, ClearMode.Auto, customPool)
		{
		}

		public PooledList(ReadOnlySpan<T> span, ClearMode clearMode, ArrayPool<T> customPool)
		{
			_pool = customPool ?? ArrayPool<T>.Shared;
			_clearOnFree = ShouldClear(clearMode);
			int length = span.Length;
			if (length == 0)
			{
				_items = s_emptyArray;
				return;
			}
			_items = _pool.Rent(length);
			span.CopyTo(_items);
			_size = length;
		}

		public PooledList(IEnumerable<T> collection)
			: this(collection, ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledList(IEnumerable<T> collection, ClearMode clearMode)
			: this(collection, clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledList(IEnumerable<T> collection, ArrayPool<T> customPool)
			: this(collection, ClearMode.Auto, customPool)
		{
		}

		public PooledList(IEnumerable<T> collection, ClearMode clearMode, ArrayPool<T> customPool)
		{
			_pool = customPool ?? ArrayPool<T>.Shared;
			_clearOnFree = ShouldClear(clearMode);
			if (collection != null)
			{
				if (!(collection is ICollection<T> collection2))
				{
					_size = 0;
					_items = s_emptyArray;
					{
						foreach (T item in collection)
						{
							Add(item);
						}
						return;
					}
				}
				ICollection<T> collection3 = collection2;
				int count = collection3.Count;
				if (count == 0)
				{
					_items = s_emptyArray;
					return;
				}
				_items = _pool.Rent(count);
				collection3.CopyTo(_items, 0);
				_size = count;
			}
			else
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
			}
		}

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

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Add(T item)
		{
			_version++;
			int size = _size;
			if ((uint)size < (uint)_items.Length)
			{
				_size = size + 1;
				_items[size] = item;
			}
			else
			{
				AddWithResize(item);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void AddWithResize(T item)
		{
			int size = _size;
			EnsureCapacity(size + 1);
			_size = size + 1;
			_items[size] = item;
		}

		int IList.Add(object item)
		{
			ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(item, ExceptionArgument.item);
			try
			{
				Add((T)item);
			}
			catch (InvalidCastException)
			{
				ThrowHelper.ThrowWrongValueTypeArgumentException(item, typeof(T));
			}
			return Count - 1;
		}

		public void AddRange(IEnumerable<T> collection)
		{
			InsertRange(_size, collection);
		}

		public void AddRange(T[] array)
		{
			AddRange(array.AsSpan());
		}

		public void AddRange(ReadOnlySpan<T> span)
		{
			Span<T> destination = InsertSpan(_size, span.Length, clearOutput: false);
			span.CopyTo(destination);
		}

		public Span<T> AddSpan(int count)
		{
			return InsertSpan(_size, count);
		}

		public ReadOnlyCollection<T> AsReadOnly()
		{
			return new ReadOnlyCollection<T>(this);
		}

		public int BinarySearch(int index, int count, T item, IComparer<T> comparer)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			return Array.BinarySearch(_items, index, count, item, comparer);
		}

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

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

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Clear()
		{
			_version++;
			int size = _size;
			_size = 0;
			if (size > 0 && _clearOnFree)
			{
				Array.Clear(_items, 0, _size);
			}
		}

		public bool Contains(T item)
		{
			if (_size != 0)
			{
				return IndexOf(item) != -1;
			}
			return false;
		}

		bool IList.Contains(object item)
		{
			if (IsCompatibleObject(item))
			{
				return Contains((T)item);
			}
			return false;
		}

		public PooledList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter)
		{
			if (converter == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.converter);
			}
			PooledList<TOutput> pooledList = new PooledList<TOutput>(_size);
			for (int i = 0; i < _size; i++)
			{
				pooledList._items[i] = converter(_items[i]);
			}
			pooledList._size = _size;
			return pooledList;
		}

		public void CopyTo(Span<T> span)
		{
			if (span.Length < Count)
			{
				throw new ArgumentException("Destination span is shorter than the list to be copied.");
			}
			Span.CopyTo(span);
		}

		void ICollection<T>.CopyTo(T[] array, int arrayIndex)
		{
			Array.Copy(_items, 0, array, arrayIndex, _size);
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			if (array != null && array.Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
			}
			try
			{
				Array.Copy(_items, 0, array, arrayIndex, _size);
			}
			catch (ArrayTypeMismatchException)
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
		}

		private void EnsureCapacity(int min)
		{
			if (_items.Length < min)
			{
				int num = ((_items.Length == 0) ? 4 : (_items.Length * 2));
				if ((uint)num > 2146435071u)
				{
					num = 2146435071;
				}
				if (num < min)
				{
					num = min;
				}
				Capacity = num;
			}
		}

		public bool Exists(Func<T, bool> match)
		{
			return FindIndex(match) != -1;
		}

		public bool TryFind(Func<T, bool> match, out T result)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			for (int i = 0; i < _size; i++)
			{
				if (match(_items[i]))
				{
					result = _items[i];
					return true;
				}
			}
			result = default(T);
			return false;
		}

		public PooledList<T> FindAll(Func<T, bool> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			PooledList<T> pooledList = new PooledList<T>();
			for (int i = 0; i < _size; i++)
			{
				if (match(_items[i]))
				{
					pooledList.Add(_items[i]);
				}
			}
			return pooledList;
		}

		public int FindIndex(Func<T, bool> match)
		{
			return FindIndex(0, _size, match);
		}

		public int FindIndex(int startIndex, Func<T, bool> match)
		{
			return FindIndex(startIndex, _size - startIndex, match);
		}

		public int FindIndex(int startIndex, int count, Func<T, bool> match)
		{
			if ((uint)startIndex > (uint)_size)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if (count < 0 || startIndex > _size - count)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			int num = startIndex + count;
			for (int i = startIndex; i < num; i++)
			{
				if (match(_items[i]))
				{
					return i;
				}
			}
			return -1;
		}

		public bool TryFindLast(Func<T, bool> match, out T result)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			for (int num = _size - 1; num >= 0; num--)
			{
				if (match(_items[num]))
				{
					result = _items[num];
					return true;
				}
			}
			result = default(T);
			return false;
		}

		public int FindLastIndex(Func<T, bool> match)
		{
			return FindLastIndex(_size - 1, _size, match);
		}

		public int FindLastIndex(int startIndex, Func<T, bool> match)
		{
			return FindLastIndex(startIndex, startIndex + 1, match);
		}

		public int FindLastIndex(int startIndex, int count, Func<T, bool> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			if (_size == 0)
			{
				if (startIndex != -1)
				{
					ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
				}
			}
			else if ((uint)startIndex >= (uint)_size)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if (count < 0 || startIndex - count + 1 < 0)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			int num = startIndex - count;
			for (int num2 = startIndex; num2 > num; num2--)
			{
				if (match(_items[num2]))
				{
					return num2;
				}
			}
			return -1;
		}

		public void ForEach(Action<T> action)
		{
			if (action == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action);
			}
			int version = _version;
			for (int i = 0; i < _size; i++)
			{
				if (version != _version)
				{
					break;
				}
				action(_items[i]);
			}
			if (version != _version)
			{
				ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
			}
		}

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

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

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new Enumerator(this);
		}

		public Span<T> GetRange(int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			return Span.Slice(index, count);
		}

		public int IndexOf(T item)
		{
			return Array.IndexOf(_items, item, 0, _size);
		}

		int IList.IndexOf(object item)
		{
			if (IsCompatibleObject(item))
			{
				return IndexOf((T)item);
			}
			return -1;
		}

		public int IndexOf(T item, int index)
		{
			if (index > _size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			return Array.IndexOf(_items, item, index, _size - index);
		}

		public int IndexOf(T item, int index, int count)
		{
			if (index > _size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			if (count < 0 || index > _size - count)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			return Array.IndexOf(_items, item, index, count);
		}

		public void Insert(int index, T item)
		{
			if ((uint)index > (uint)_size)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_ListInsert);
			}
			if (_size == _items.Length)
			{
				EnsureCapacity(_size + 1);
			}
			if (index < _size)
			{
				Array.Copy(_items, index, _items, index + 1, _size - index);
			}
			_items[index] = item;
			_size++;
			_version++;
		}

		void IList.Insert(int index, object item)
		{
			ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(item, ExceptionArgument.item);
			try
			{
				Insert(index, (T)item);
			}
			catch (InvalidCastException)
			{
				ThrowHelper.ThrowWrongValueTypeArgumentException(item, typeof(T));
			}
		}

		public void InsertRange(int index, IEnumerable<T> collection)
		{
			if ((uint)index > (uint)_size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			if (collection != null)
			{
				if (collection is ICollection<T> collection2)
				{
					ICollection<T> collection3 = collection2;
					int count = collection3.Count;
					if (count > 0)
					{
						EnsureCapacity(_size + count);
						if (index < _size)
						{
							Array.Copy(_items, index, _items, index + count, _size - index);
						}
						if (this == collection3)
						{
							Array.Copy(_items, 0, _items, index, index);
							Array.Copy(_items, index + count, _items, index * 2, _size - index);
						}
						else
						{
							collection3.CopyTo(_items, index);
						}
						_size += count;
					}
				}
				else
				{
					using IEnumerator<T> enumerator = collection.GetEnumerator();
					while (enumerator.MoveNext())
					{
						Insert(index++, enumerator.Current);
					}
				}
			}
			else
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
			}
			_version++;
		}

		public void InsertRange(int index, ReadOnlySpan<T> span)
		{
			Span<T> destination = InsertSpan(index, span.Length, clearOutput: false);
			span.CopyTo(destination);
		}

		public void InsertRange(int index, T[] array)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			InsertRange(index, array.AsSpan());
		}

		public Span<T> InsertSpan(int index, int count)
		{
			return InsertSpan(index, count, clearOutput: true);
		}

		private Span<T> InsertSpan(int index, int count, bool clearOutput)
		{
			EnsureCapacity(_size + count);
			if (index < _size)
			{
				Array.Copy(_items, index, _items, index + count, _size - index);
			}
			_size += count;
			_version++;
			Span<T> result = _items.AsSpan(index, count);
			if (clearOutput && _clearOnFree)
			{
				result.Clear();
			}
			return result;
		}

		public int LastIndexOf(T item)
		{
			if (_size == 0)
			{
				return -1;
			}
			return LastIndexOf(item, _size - 1, _size);
		}

		public int LastIndexOf(T item, int index)
		{
			if (index >= _size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			return LastIndexOf(item, index, index + 1);
		}

		public int LastIndexOf(T item, int index, int count)
		{
			if (Count != 0 && index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (Count != 0 && count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size == 0)
			{
				return -1;
			}
			if (index >= _size)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_BiggerThanCollection);
			}
			if (count > index + 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_BiggerThanCollection);
			}
			return Array.LastIndexOf(_items, item, index, count);
		}

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

		void IList.Remove(object item)
		{
			if (IsCompatibleObject(item))
			{
				Remove((T)item);
			}
		}

		public int RemoveAll(Func<T, bool> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			int i;
			for (i = 0; i < _size && !match(_items[i]); i++)
			{
			}
			if (i >= _size)
			{
				return 0;
			}
			int j = i + 1;
			while (j < _size)
			{
				for (; j < _size && match(_items[j]); j++)
				{
				}
				if (j < _size)
				{
					_items[i++] = _items[j++];
				}
			}
			if (_clearOnFree)
			{
				Array.Clear(_items, i, _size - i);
			}
			int result = _size - i;
			_size = i;
			_version++;
			return result;
		}

		public void RemoveAt(int index)
		{
			if ((uint)index >= (uint)_size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			_size--;
			if (index < _size)
			{
				Array.Copy(_items, index + 1, _items, index, _size - index);
			}
			_version++;
			if (_clearOnFree)
			{
				_items[_size] = default(T);
			}
		}

		public void RemoveRange(int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (count > 0)
			{
				_size -= count;
				if (index < _size)
				{
					Array.Copy(_items, index + count, _items, index, _size - index);
				}
				_version++;
				if (_clearOnFree)
				{
					Array.Clear(_items, _size, count);
				}
			}
		}

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

		public void Reverse(int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (count > 1)
			{
				Array.Reverse((Array)_items, index, count);
			}
			_version++;
		}

		public void Sort()
		{
			Sort(0, Count, null);
		}

		public void Sort(IComparer<T> comparer)
		{
			Sort(0, Count, comparer);
		}

		public void Sort(int index, int count, IComparer<T> comparer)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (count > 1)
			{
				Array.Sort(_items, index, count, comparer);
			}
			_version++;
		}

		public void Sort(Func<T, T, int> comparison)
		{
			if (comparison == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparison);
			}
			if (_size > 1)
			{
				Array.Sort(_items, 0, _size, new Comparer(comparison));
			}
			_version++;
		}

		public T[] ToArray()
		{
			if (_size == 0)
			{
				return s_emptyArray;
			}
			return Span.ToArray();
		}

		public void TrimExcess()
		{
			int num = (int)((double)_items.Length * 0.9);
			if (_size < num)
			{
				Capacity = _size;
			}
		}

		public bool TrueForAll(Func<T, bool> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			for (int i = 0; i < _size; i++)
			{
				if (!match(_items[i]))
				{
					return false;
				}
			}
			return true;
		}

		private void ReturnArray()
		{
			if (_items.Length != 0)
			{
				try
				{
					_pool.Return(_items, _clearOnFree);
				}
				catch (ArgumentException)
				{
				}
				_items = s_emptyArray;
			}
		}

		private static bool ShouldClear(ClearMode mode)
		{
			return mode != ClearMode.Never;
		}

		public void Dispose()
		{
			ReturnArray();
			_size = 0;
			_version++;
		}

		void IDeserializationCallback.OnDeserialization(object sender)
		{
			_pool = ArrayPool<T>.Shared;
		}
	}
	[Serializable]
	[DebuggerTypeProxy(typeof(QueueDebugView<>))]
	[DebuggerDisplay("Count = {Count}")]
	public class PooledQueue<T> : IEnumerable<T>, IEnumerable, ICollection, IReadOnlyCollection<T>, IDisposable, IDeserializationCallback
	{
		public struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable
		{
			private readonly PooledQueue<T> _q;

			private readonly int _version;

			private int _index;

			private T _currentElement;

			public T Current
			{
				get
				{
					if (_index < 0)
					{
						ThrowEnumerationNotStartedOrEnded();
					}
					return _currentElement;
				}
			}

			object IEnumerator.Current => Current;

			internal Enumerator(PooledQueue<T> q)
			{
				_q = q;
				_version = q._version;
				_index = -1;
				_currentElement = default(T);
			}

			public void Dispose()
			{
				_index = -2;
				_currentElement = default(T);
			}

			public bool MoveNext()
			{
				if (_version != _q._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				if (_index == -2)
				{
					return false;
				}
				_index++;
				if (_index == _q._size)
				{
					_index = -2;
					_currentElement = default(T);
					return false;
				}
				T[] array = _q._array;
				int num = array.Length;
				int num2 = _q._head + _index;
				if (num2 >= num)
				{
					num2 -= num;
				}
				_currentElement = array[num2];
				return true;
			}

			private void ThrowEnumerationNotStartedOrEnded()
			{
				if (_index == -1)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumNotStarted();
				}
				else
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumEnded();
				}
			}

			void IEnumerator.Reset()
			{
				if (_version != _q._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				_index = -1;
				_currentElement = default(T);
			}
		}

		private const int MinimumGrow = 4;

		private const int GrowFactor = 200;

		[NonSerialized]
		private ArrayPool<T> _pool;

		[NonSerialized]
		private object _syncRoot;

		private T[] _array;

		private int _head;

		private int _tail;

		private int _size;

		private int _version;

		private readonly bool _clearOnFree;

		public int Count => _size;

		public ClearMode ClearMode
		{
			get
			{
				if (!_clearOnFree)
				{
					return ClearMode.Never;
				}
				return ClearMode.Always;
			}
		}

		bool ICollection.IsSynchronized => false;

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

		public PooledQueue()
			: this(ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(ClearMode clearMode)
			: this(clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(ArrayPool<T> customPool)
			: this(ClearMode.Auto, customPool)
		{
		}

		public PooledQueue(ClearMode clearMode, ArrayPool<T> customPool)
		{
			_pool = customPool ?? ArrayPool<T>.Shared;
			_array = Array.Empty<T>();
			_clearOnFree = ShouldClear(clearMode);
		}

		public PooledQueue(int capacity)
			: this(capacity, ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(int capacity, ClearMode clearMode)
			: this(capacity, clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(int capacity, ArrayPool<T> customPool)
			: this(capacity, ClearMode.Auto, customPool)
		{
		}

		public PooledQueue(int capacity, ClearMode clearMode, ArrayPool<T> customPool)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			_pool = customPool ?? ArrayPool<T>.Shared;
			_array = _pool.Rent(capacity);
			_clearOnFree = ShouldClear(clearMode);
		}

		public PooledQueue(IEnumerable<T> enumerable)
			: this(enumerable, ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(IEnumerable<T> enumerable, ClearMode clearMode)
			: this(enumerable, clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(IEnumerable<T> enumerable, ArrayPool<T> customPool)
			: this(enumerable, ClearMode.Auto, customPool)
		{
		}

		public PooledQueue(IEnumerable<T> enumerable, ClearMode clearMode, ArrayPool<T> customPool)
		{
			_pool = customPool ?? ArrayPool<T>.Shared;
			_clearOnFree = ShouldClear(clearMode);
			if (enumerable != null)
			{
				if (!(enumerable is ICollection<T> collection))
				{
					using (PooledList<T> pooledList = new PooledList<T>(enumerable))
					{
						_array = _pool.Rent(pooledList.Count);
						pooledList.Span.CopyTo(_array);
						_size = pooledList.Count;
						if (_size != _array.Length)
						{
							_tail = _size;
						}
						return;
					}
				}
				ICollection<T> collection2 = collection;
				if (collection2.Count == 0)
				{
					_array = Array.Empty<T>();
					return;
				}
				_array = _pool.Rent(collection2.Count);
				collection2.CopyTo(_array, 0);
				_size = collection2.Count;
				if (_size != _array.Length)
				{
					_tail = _size;
				}
			}
			else
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.enumerable);
			}
		}

		public PooledQueue(T[] array)
			: this((ReadOnlySpan<T>)array.AsSpan(), ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(T[] array, ClearMode clearMode)
			: this((ReadOnlySpan<T>)array.AsSpan(), clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(T[] array, ArrayPool<T> customPool)
			: this((ReadOnlySpan<T>)array.AsSpan(), ClearMode.Auto, customPool)
		{
		}

		public PooledQueue(T[] array, ClearMode clearMode, ArrayPool<T> customPool)
			: this((ReadOnlySpan<T>)array.AsSpan(), clearMode, customPool)
		{
		}

		public PooledQueue(ReadOnlySpan<T> span)
			: this(span, ClearMode.Auto, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(ReadOnlySpan<T> span, ClearMode clearMode)
			: this(span, clearMode, ArrayPool<T>.Shared)
		{
		}

		public PooledQueue(ReadOnlySpan<T> span, ArrayPool<T> customPool)
			: this(span, ClearMode.Auto, customPool)
		{
		}

		public PooledQueue(ReadOnlySpan<T> span, ClearMode clearMode, ArrayPool<T> customPool)
		{
			_pool = customPool ?? ArrayPool<T>.Shared;
			_clearOnFree = ShouldClear(clearMode);
			_array = _pool.Rent(span.Length);
			span.CopyTo(_array);
			_size = span.Length;
			if (_size != _array.Length)
			{
				_tail = _size;
			}
		}

		public void Clear()
		{
			if (_size != 0)
			{
				if (_clearOnFree)
				{
					if (_head < _tail)
					{
						Array.Clear(_array, _head, _size);
					}
					else
					{
						Array.Clear(_array, _head, _array.Length - _head);
						Array.Clear(_array, 0, _tail);
					}
				}
				_size = 0;
			}
			_head = 0;
			_tail = 0;
			_version++;
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if ((uint)arrayIndex > (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.arrayIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			if (array.Length - arrayIndex < _size)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			int size = _size;
			if (size != 0)
			{
				int num = Math.Min(_array.Length - _head, size);
				Array.Copy(_array, _head, array, arrayIndex, num);
				size -= num;
				if (size > 0)
				{
					Array.Copy(_array, 0, array, arrayIndex + _array.Length - _head, size);
				}
			}
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (array.Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Rank_MultiDimNotSupported, ExceptionArgument.array);
			}
			if (array.GetLowerBound(0) != 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound, ExceptionArgument.array);
			}
			int length = array.Length;
			if ((uint)index > (uint)length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
			}
			if (length - index < _size)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			int size = _size;
			if (size == 0)
			{
				return;
			}
			try
			{
				int num = ((_array.Length - _head < size) ? (_array.Length - _head) : size);
				Array.Copy(_array, _head, array, index, num);
				size -= num;
				if (size > 0)
				{
					Array.Copy(_array, 0, array, index + _array.Length - _head, size);
				}
			}
			catch (ArrayTypeMismatchException)
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
		}

		public void Enqueue(T item)
		{
			if (_size == _array.Length)
			{
				int num = (int)((long)_array.Length * 200L / 100);
				if (num < _array.Length + 4)
				{
					num = _array.Length + 4;
				}
				SetCapacity(num);
			}
			_array[_tail] = item;
			MoveNext(ref _tail);
			_size++;
			_version++;
		}

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

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

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new Enumerator(this);
		}

		public T Dequeue()
		{
			int head = _head;
			T[] array = _array;
			if (_size == 0)
			{
				ThrowForEmptyQueue();
			}
			T result = array[head];
			if (_clearOnFree)
			{
				array[head] = default(T);
			}
			MoveNext(ref _head);
			_size--;
			_version++;
			return result;
		}

		public bool TryDequeue(out T result)
		{
			int head = _head;
			T[] array = _array;
			if (_size == 0)
			{
				result = default(T);
				return false;
			}
			result = array[head];
			if (_clearOnFree)
			{
				array[head] = default(T);
			}
			MoveNext(ref _head);
			_size--;
			_version++;
			return true;
		}

		public T Peek()
		{
			if (_size == 0)
			{
				ThrowForEmptyQueue();
			}
			return _array[_head];
		}

		public bool TryPeek(out T result)
		{
			if (_size == 0)
			{
				result = default(T);
				return false;
			}
			result = _array[_head];
			return true;
		}

		public bool Contains(T item)
		{
			if (_size == 0)
			{
				return false;
			}
			if (_head < _tail)
			{
				return Array.IndexOf(_array, item, _head, _size) >= 0;
			}
			if (Array.IndexOf(_array, item, _head, _array.Length - _head) < 0)
			{
				return Array.IndexOf(_array, item, 0, _tail) >= 0;
			}
			return true;
		}

		public int RemoveWhere(Func<T, bool> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			if (_size == 0)
			{
				return 0;
			}
			T[] array = _pool.Rent(_size);
			int num = 0;
			if (_head < _tail)
			{
				int num2 = 0;
				for (int i = _head; i < _size; i++)
				{
					if (match(_array[i]))
					{
						num++;
					}
					else
					{
						array[num2++] = _array[i];
					}
				}
			}
			else
			{
				int num3 = 0;
				for (int j = _head; j < _array.Length - _head; j++)
				{
					if (match(_array[j]))
					{
						num++;
					}
					else
					{
						array[num3++] = _array[j];
					}
				}
				for (int k = 0; k < _tail; k++)
				{
					if (match(_array[k]))
					{
						num++;
					}
					else
					{
						array[num3++] = _array[k];
					}
				}
			}
			ReturnArray(array);
			_size -= num;
			_head = (_tail = 0);
			if (_size != _array.Length)
			{
				_tail = _size;
			}
			_version++;
			return num;
		}

		public T[] ToArray()
		{
			if (_size == 0)
			{
				return Array.Empty<T>();
			}
			T[] array = new T[_size];
			if (_head < _tail)
			{
				Array.Copy(_array, _head, array, 0, _size);
			}
			else
			{
				Array.Copy(_array, _head, array, 0, _array.Length - _head);
				Array.Copy(_array, 0, array, _array.Length - _head, _tail);
			}
			return array;
		}

		private void SetCapacity(int capacity)
		{
			T[] array = _pool.Rent(capacity);
			if (_size > 0)
			{
				if (_head < _tail)
				{
					Array.Copy(_array, _head, array, 0, _size);
				}
				else
				{
					Array.Copy(_array, _head, array, 0, _array.Length - _head);
					Array.Copy(_array, 0, array, _array.Length - _head, _tail);
				}
			}
			ReturnArray(array);
			_head = 0;
			_tail = ((_size != array.Length) ? _size : 0);
			_version++;
		}

		private void MoveNext(ref int index)
		{
			int num = index + 1;
			if (num == _array.Length)
			{
				num = 0;
			}
			index = num;
		}

		private void ThrowForEmptyQueue()
		{
			throw new InvalidOperationException("Queue is empty.");
		}

		public void TrimExcess()
		{
			int num = (int)((double)_array.Length * 0.9);
			if (_size < num)
			{
				SetCapacity(_size);
			}
		}

		private void ReturnArray(T[] replaceWith)
		{
			if (_array.Length != 0)
			{
				try
				{
					_pool.Return(_array, _clearOnFree);
				}
				catch (ArgumentException)
				{
				}
			}
			_array = replaceWith;
		}

		private static bool ShouldClear(C