using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq.Parallel;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Threading.Tasks;

[assembly: InternalsVisibleTo("PlinqTest, PublicKey=0024000004800000940000000602000000240000525341310004000001000100CB7351F3887F5CB603C8CFBCA50868570B5BBECB60106DCBBDC4E18A20D5F84A64294699284628A768130175AF63C391C5E0D7FF19F05AF5FD4BC9641391293E094F92CCFF19234F3284DB149AFAE9F604A9A34FA7203549D2D4AD5CD80088682E0C137BCE1C38400955CB7CEDF5E9F532852F9C06AB50FCAA036216A95DE0CE")]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyFileVersion("1.0.2856.0")]
[assembly: CLSCompliant(true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("plinq_devtests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100CB7351F3887F5CB603C8CFBCA50868570B5BBECB60106DCBBDC4E18A20D5F84A64294699284628A768130175AF63C391C5E0D7FF19F05AF5FD4BC9641391293E094F92CCFF19234F3284DB149AFAE9F604A9A34FA7203549D2D4AD5CD80088682E0C137BCE1C38400955CB7CEDF5E9F532852F9C06AB50FCAA036216A95DE0CE")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("Copyright © Microsoft Corporation 2011")]
[assembly: AssemblyTitle("System.Threading")]
[assembly: AssemblyProduct("Reactive Extensions Core Library")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2856.102")]
[module: UnverifiableCode]
namespace System.Diagnostics.Contracts
{
	internal static class Contract
	{
		[Conditional("DEBUG")]
		internal static void Assert(bool condition)
		{
		}

		[Conditional("DEBUG")]
		internal static void Assert(bool condition, string message)
		{
		}

		[Conditional("DEBUG")]
		internal static void Ensures(bool condition)
		{
		}

		[Conditional("DEBUG")]
		internal static void EndContractBlock()
		{
		}
	}
}
namespace System
{
	internal static class Environment2
	{
		internal static string GetResourceString(string key)
		{
			if (key == "AggregateException_ToString")
			{
				return "{0}{1}---> (Inner Exception #{2}) {3}{4}{5}";
			}
			return key;
		}
	}
}
namespace System.Threading.Tasks
{
	internal interface IThreadPoolWorkItem
	{
		void ExecuteWorkItem();

		void MarkAborted(ThreadAbortException tae);
	}
}
namespace System.Threading
{
	internal class Monitor2
	{
		internal static void Enter(object obj, ref bool taken)
		{
			Monitor.Enter(obj);
			taken = true;
		}

		internal static bool TryEnter(object obj)
		{
			return Monitor.TryEnter(obj);
		}

		internal static void TryEnter(object obj, ref bool taken)
		{
			taken = Monitor.TryEnter(obj);
		}

		internal static bool TryEnter(object obj, int millisecondsTimeout)
		{
			return Monitor.TryEnter(obj, millisecondsTimeout);
		}

		internal static bool TryEnter(object obj, TimeSpan timeout)
		{
			return Monitor.TryEnter(obj, timeout);
		}

		internal static void TryEnter(object obj, int millisecondsTimeout, ref bool taken)
		{
			taken = Monitor.TryEnter(obj, millisecondsTimeout);
		}
	}
}
namespace System.Collections.Generic
{
	internal sealed class Mscorlib_DictionaryDebugView<K, V>
	{
		private IDictionary<K, V> dict;

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

		internal Mscorlib_DictionaryDebugView(IDictionary<K, V> dictionary)
		{
			if (dictionary == null)
			{
				throw new ArgumentNullException("dictionary");
			}
			dict = dictionary;
		}
	}
}
namespace System
{
	[Serializable]
	[ComVisible(true)]
	internal class OperationCanceledException2 : OperationCanceledException
	{
		[NonSerialized]
		private CancellationToken _cancellationToken;

		public new CancellationToken CancellationToken
		{
			get
			{
				return _cancellationToken;
			}
			private set
			{
				_cancellationToken = value;
			}
		}

		public OperationCanceledException2()
			: base(Environment2.GetResourceString("OperationCanceled"))
		{
		}

		public OperationCanceledException2(string message)
			: base(message)
		{
		}

		public OperationCanceledException2(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public OperationCanceledException2(CancellationToken token)
			: this()
		{
			CancellationToken = token;
		}

		public OperationCanceledException2(string message, CancellationToken token)
			: this(message)
		{
			CancellationToken = token;
		}

		public OperationCanceledException2(string message, Exception innerException, CancellationToken token)
			: this(message, innerException)
		{
			CancellationToken = token;
		}

		protected OperationCanceledException2(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
}
namespace System.Threading
{
	internal static class Platform
	{
		internal static int ProcessorCount => Environment.ProcessorCount;

		internal static bool IsSingleProcessor => ProcessorCount == 1;

		[DllImport("kernel32.dll")]
		private static extern int SwitchToThread();

		internal static void Yield()
		{
			SwitchToThread();
		}
	}
}
namespace System
{
	internal class SecuritySafeCriticalAttribute : Attribute
	{
	}
}
namespace System.Threading
{
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct StackCrawlMark2
	{
		internal static StackCrawlMark2 LookForMyCaller => default(StackCrawlMark2);
	}
}
namespace System.Collections.Concurrent
{
	[Serializable]
	[DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<, >))]
	[DebuggerDisplay("Count = {Count}")]
	[ComVisible(false)]
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public class ConcurrentDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IDictionary, ICollection, IEnumerable
	{
		private class Node
		{
			internal TKey m_key;

			internal TValue m_value;

			internal volatile Node m_next;

			internal int m_hashcode;

			internal Node(TKey key, TValue value, int hashcode)
				: this(key, value, hashcode, (Node)null)
			{
			}

			internal Node(TKey key, TValue value, int hashcode, Node next)
			{
				m_key = key;
				m_value = value;
				m_next = next;
				m_hashcode = hashcode;
			}
		}

		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private IEnumerator<KeyValuePair<TKey, TValue>> m_enumerator;

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

			public object Key => m_enumerator.Current.Key;

			public object Value => m_enumerator.Current.Value;

			public object Current => Entry;

			internal DictionaryEnumerator(ConcurrentDictionary<TKey, TValue> dictionary)
			{
				m_enumerator = dictionary.GetEnumerator();
			}

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

			public void Reset()
			{
				m_enumerator.Reset();
			}
		}

		private const int DEFAULT_CONCURRENCY_MULTIPLIER = 4;

		private const int DEFAULT_CAPACITY = 31;

		[NonSerialized]
		private volatile Node[] m_buckets;

		[NonSerialized]
		private object[] m_locks;

		[NonSerialized]
		private volatile int[] m_countPerLock;

		private IEqualityComparer<TKey> m_comparer;

		private KeyValuePair<TKey, TValue>[] m_serializationArray;

		private int m_serializationConcurrencyLevel;

		private int m_serializationCapacity;

		public TValue this[TKey key]
		{
			get
			{
				if (!TryGetValue(key, out var value))
				{
					throw new KeyNotFoundException();
				}
				return value;
			}
			set
			{
				if (key == null)
				{
					throw new ArgumentNullException("key");
				}
				TryAddInternal(key, value, updateIfExists: true, acquireLock: true, out var _);
			}
		}

		public int Count
		{
			get
			{
				int num = 0;
				int locksAcquired = 0;
				try
				{
					AcquireAllLocks(ref locksAcquired);
					for (int i = 0; i < m_countPerLock.Length; i++)
					{
						num += m_countPerLock[i];
					}
					return num;
				}
				finally
				{
					ReleaseLocks(0, locksAcquired);
				}
			}
		}

		public bool IsEmpty
		{
			get
			{
				int locksAcquired = 0;
				try
				{
					AcquireAllLocks(ref locksAcquired);
					for (int i = 0; i < m_countPerLock.Length; i++)
					{
						if (m_countPerLock[i] != 0)
						{
							return false;
						}
					}
				}
				finally
				{
					ReleaseLocks(0, locksAcquired);
				}
				return true;
			}
		}

		public ICollection<TKey> Keys => GetKeys();

		public ICollection<TValue> Values => GetValues();

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

		bool IDictionary.IsFixedSize => false;

		bool IDictionary.IsReadOnly => false;

		ICollection IDictionary.Keys => GetKeys();

		ICollection IDictionary.Values => GetValues();

		object IDictionary.this[object key]
		{
			get
			{
				if (key == null)
				{
					throw new ArgumentNullException("key");
				}
				if (key is TKey && TryGetValue((TKey)key, out var value))
				{
					return value;
				}
				return null;
			}
			set
			{
				if (key == null)
				{
					throw new ArgumentNullException("key");
				}
				if (!(key is TKey))
				{
					throw new ArgumentException(GetResource("ConcurrentDictionary_TypeOfKeyIncorrect"));
				}
				if (!(value is TValue))
				{
					throw new ArgumentException(GetResource("ConcurrentDictionary_TypeOfValueIncorrect"));
				}
				this[(TKey)key] = (TValue)value;
			}
		}

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot
		{
			get
			{
				throw new NotSupportedException(Environment2.GetResourceString("ConcurrentCollection_SyncRoot_NotSupported"));
			}
		}

		private static int DefaultConcurrencyLevel => 4 * Environment.ProcessorCount;

		public ConcurrentDictionary()
			: this(DefaultConcurrencyLevel, 31)
		{
		}

		public ConcurrentDictionary(int concurrencyLevel, int capacity)
			: this(concurrencyLevel, capacity, (IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public ConcurrentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection)
			: this(collection, (IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public ConcurrentDictionary(IEqualityComparer<TKey> comparer)
			: this(DefaultConcurrencyLevel, 31, comparer)
		{
		}

		public ConcurrentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer)
			: this(DefaultConcurrencyLevel, collection, comparer)
		{
		}

		public ConcurrentDictionary(int concurrencyLevel, IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer)
			: this(concurrencyLevel, 31, comparer)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			if (comparer == null)
			{
				throw new ArgumentNullException("comparer");
			}
			InitializeFromCollection(collection);
		}

		private void InitializeFromCollection(IEnumerable<KeyValuePair<TKey, TValue>> collection)
		{
			foreach (KeyValuePair<TKey, TValue> item in collection)
			{
				if (item.Key == null)
				{
					throw new ArgumentNullException("key");
				}
				if (!TryAddInternal(item.Key, item.Value, updateIfExists: false, acquireLock: false, out var _))
				{
					throw new ArgumentException(GetResource("ConcurrentDictionary_SourceContainsDuplicateKeys"));
				}
			}
		}

		public ConcurrentDictionary(int concurrencyLevel, int capacity, IEqualityComparer<TKey> comparer)
		{
			if (concurrencyLevel < 1)
			{
				throw new ArgumentOutOfRangeException("concurrencyLevel", GetResource("ConcurrentDictionary_ConcurrencyLevelMustBePositive"));
			}
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", GetResource("ConcurrentDictionary_CapacityMustNotBeNegative"));
			}
			if (comparer == null)
			{
				throw new ArgumentNullException("comparer");
			}
			if (capacity < concurrencyLevel)
			{
				capacity = concurrencyLevel;
			}
			m_locks = new object[concurrencyLevel];
			for (int i = 0; i < m_locks.Length; i++)
			{
				m_locks[i] = new object();
			}
			m_countPerLock = new int[m_locks.Length];
			m_buckets = new Node[capacity];
			m_comparer = comparer;
		}

		public bool TryAdd(TKey key, TValue value)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			TValue resultingValue;
			return TryAddInternal(key, value, updateIfExists: false, acquireLock: true, out resultingValue);
		}

		public bool ContainsKey(TKey key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			TValue value;
			return TryGetValue(key, out value);
		}

		public bool TryRemove(TKey key, out TValue value)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			return TryRemoveInternal(key, out value, matchValue: false, default(TValue));
		}

		private bool TryRemoveInternal(TKey key, out TValue value, bool matchValue, TValue oldValue)
		{
			while (true)
			{
				Node[] buckets = m_buckets;
				GetBucketAndLockNo(m_comparer.GetHashCode(key), out var bucketNo, out var lockNo, buckets.Length);
				lock (m_locks[lockNo])
				{
					if (buckets != m_buckets)
					{
						continue;
					}
					Node node = null;
					for (Node node2 = m_buckets[bucketNo]; node2 != null; node2 = node2.m_next)
					{
						if (m_comparer.Equals(node2.m_key, key))
						{
							if (matchValue && !EqualityComparer<TValue>.Default.Equals(oldValue, node2.m_value))
							{
								value = default(TValue);
								return false;
							}
							if (node == null)
							{
								m_buckets[bucketNo] = node2.m_next;
							}
							else
							{
								node.m_next = node2.m_next;
							}
							value = node2.m_value;
							m_countPerLock[lockNo]--;
							return true;
						}
						node = node2;
					}
					break;
				}
			}
			value = default(TValue);
			return false;
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			Node[] buckets = m_buckets;
			GetBucketAndLockNo(m_comparer.GetHashCode(key), out var bucketNo, out var _, buckets.Length);
			Node node = buckets[bucketNo];
			Thread.MemoryBarrier();
			while (node != null)
			{
				if (m_comparer.Equals(node.m_key, key))
				{
					value = node.m_value;
					return true;
				}
				node = node.m_next;
			}
			value = default(TValue);
			return false;
		}

		public bool TryUpdate(TKey key, TValue newValue, TValue comparisonValue)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			int hashCode = m_comparer.GetHashCode(key);
			IEqualityComparer<TValue> @default = EqualityComparer<TValue>.Default;
			while (true)
			{
				Node[] buckets = m_buckets;
				GetBucketAndLockNo(hashCode, out var bucketNo, out var lockNo, buckets.Length);
				lock (m_locks[lockNo])
				{
					if (buckets != m_buckets)
					{
						continue;
					}
					Node node = null;
					for (Node node2 = buckets[bucketNo]; node2 != null; node2 = node2.m_next)
					{
						if (m_comparer.Equals(node2.m_key, key))
						{
							if (@default.Equals(node2.m_value, comparisonValue))
							{
								Node node3 = new Node(node2.m_key, newValue, hashCode, node2.m_next);
								if (node == null)
								{
									buckets[bucketNo] = node3;
								}
								else
								{
									node.m_next = node3;
								}
								return true;
							}
							return false;
						}
						node = node2;
					}
					return false;
				}
			}
		}

		public void Clear()
		{
			int locksAcquired = 0;
			try
			{
				AcquireAllLocks(ref locksAcquired);
				m_buckets = new Node[31];
				Array.Clear(m_countPerLock, 0, m_countPerLock.Length);
			}
			finally
			{
				ReleaseLocks(0, locksAcquired);
			}
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", GetResource("ConcurrentDictionary_IndexIsNegative"));
			}
			int locksAcquired = 0;
			try
			{
				AcquireAllLocks(ref locksAcquired);
				int num = 0;
				for (int i = 0; i < m_locks.Length; i++)
				{
					num += m_countPerLock[i];
				}
				if (array.Length - num < index || num < 0)
				{
					throw new ArgumentException(GetResource("ConcurrentDictionary_ArrayNotLargeEnough"));
				}
				CopyToPairs(array, index);
			}
			finally
			{
				ReleaseLocks(0, locksAcquired);
			}
		}

		public KeyValuePair<TKey, TValue>[] ToArray()
		{
			int locksAcquired = 0;
			checked
			{
				try
				{
					AcquireAllLocks(ref locksAcquired);
					int num = 0;
					for (int i = 0; i < m_locks.Length; i++)
					{
						num += m_countPerLock[i];
					}
					KeyValuePair<TKey, TValue>[] array = new KeyValuePair<TKey, TValue>[num];
					CopyToPairs(array, 0);
					return array;
				}
				finally
				{
					ReleaseLocks(0, locksAcquired);
				}
			}
		}

		private void CopyToPairs(KeyValuePair<TKey, TValue>[] array, int index)
		{
			Node[] buckets = m_buckets;
			for (int i = 0; i < buckets.Length; i++)
			{
				for (Node node = buckets[i]; node != null; node = node.m_next)
				{
					ref KeyValuePair<TKey, TValue> reference = ref array[index];
					reference = new KeyValuePair<TKey, TValue>(node.m_key, node.m_value);
					index++;
				}
			}
		}

		private void CopyToEntries(DictionaryEntry[] array, int index)
		{
			Node[] buckets = m_buckets;
			for (int i = 0; i < buckets.Length; i++)
			{
				for (Node node = buckets[i]; node != null; node = node.m_next)
				{
					ref DictionaryEntry reference = ref array[index];
					reference = new DictionaryEntry(node.m_key, node.m_value);
					index++;
				}
			}
		}

		private void CopyToObjects(object[] array, int index)
		{
			Node[] buckets = m_buckets;
			for (int i = 0; i < buckets.Length; i++)
			{
				for (Node node = buckets[i]; node != null; node = node.m_next)
				{
					array[index] = new KeyValuePair<TKey, TValue>(node.m_key, node.m_value);
					index++;
				}
			}
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			Node[] buckets = m_buckets;
			for (int i = 0; i < buckets.Length; i++)
			{
				Node current = buckets[i];
				Thread.MemoryBarrier();
				while (current != null)
				{
					yield return new KeyValuePair<TKey, TValue>(current.m_key, current.m_value);
					current = current.m_next;
				}
			}
		}

		private bool TryAddInternal(TKey key, TValue value, bool updateIfExists, bool acquireLock, out TValue resultingValue)
		{
			int hashCode = m_comparer.GetHashCode(key);
			Node[] buckets;
			bool flag;
			while (true)
			{
				buckets = m_buckets;
				GetBucketAndLockNo(hashCode, out var bucketNo, out var lockNo, buckets.Length);
				flag = false;
				bool taken = false;
				try
				{
					if (acquireLock)
					{
						Monitor2.Enter(m_locks[lockNo], ref taken);
					}
					if (buckets != m_buckets)
					{
						continue;
					}
					Node node = null;
					for (Node node2 = buckets[bucketNo]; node2 != null; node2 = node2.m_next)
					{
						if (m_comparer.Equals(node2.m_key, key))
						{
							if (updateIfExists)
							{
								Node node3 = new Node(node2.m_key, value, hashCode, node2.m_next);
								if (node == null)
								{
									buckets[bucketNo] = node3;
								}
								else
								{
									node.m_next = node3;
								}
								resultingValue = value;
							}
							else
							{
								resultingValue = node2.m_value;
							}
							return false;
						}
						node = node2;
					}
					buckets[bucketNo] = new Node(key, value, hashCode, buckets[bucketNo]);
					checked
					{
						m_countPerLock[lockNo]++;
					}
					if (m_countPerLock[lockNo] > buckets.Length / m_locks.Length)
					{
						flag = true;
					}
					break;
				}
				finally
				{
					if (taken)
					{
						Monitor.Exit(m_locks[lockNo]);
					}
				}
			}
			if (flag)
			{
				GrowTable(buckets);
			}
			resultingValue = value;
			return true;
		}

		public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			if (TryGetValue(key, out var value))
			{
				return value;
			}
			TryAddInternal(key, valueFactory(key), updateIfExists: false, acquireLock: true, out value);
			return value;
		}

		public TValue GetOrAdd(TKey key, TValue value)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			TryAddInternal(key, value, updateIfExists: false, acquireLock: true, out var resultingValue);
			return resultingValue;
		}

		public TValue AddOrUpdate(TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (addValueFactory == null)
			{
				throw new ArgumentNullException("addValueFactory");
			}
			if (updateValueFactory == null)
			{
				throw new ArgumentNullException("updateValueFactory");
			}
			TValue resultingValue;
			while (true)
			{
				if (TryGetValue(key, out var value))
				{
					TValue val = updateValueFactory(key, value);
					if (TryUpdate(key, val, value))
					{
						return val;
					}
				}
				else
				{
					TValue val = addValueFactory(key);
					if (TryAddInternal(key, val, updateIfExists: false, acquireLock: true, out resultingValue))
					{
						break;
					}
				}
			}
			return resultingValue;
		}

		public TValue AddOrUpdate(TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (updateValueFactory == null)
			{
				throw new ArgumentNullException("updateValueFactory");
			}
			TValue resultingValue;
			while (true)
			{
				if (TryGetValue(key, out var value))
				{
					TValue val = updateValueFactory(key, value);
					if (TryUpdate(key, val, value))
					{
						return val;
					}
				}
				else if (TryAddInternal(key, addValue, updateIfExists: false, acquireLock: true, out resultingValue))
				{
					break;
				}
			}
			return resultingValue;
		}

		void IDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			if (!TryAdd(key, value))
			{
				throw new ArgumentException(GetResource("ConcurrentDictionary_KeyAlreadyExisted"));
			}
		}

		bool IDictionary<TKey, TValue>.Remove(TKey key)
		{
			TValue value;
			return TryRemove(key, out value);
		}

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

		bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair)
		{
			if (!TryGetValue(keyValuePair.Key, out var value))
			{
				return false;
			}
			return EqualityComparer<TValue>.Default.Equals(value, keyValuePair.Value);
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair)
		{
			if (keyValuePair.Key == null)
			{
				throw new ArgumentNullException(GetResource("ConcurrentDictionary_ItemKeyIsNull"));
			}
			TValue value;
			return TryRemoveInternal(keyValuePair.Key, out value, matchValue: true, keyValuePair.Value);
		}

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

		void IDictionary.Add(object key, object value)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (!(key is TKey))
			{
				throw new ArgumentException(GetResource("ConcurrentDictionary_TypeOfKeyIncorrect"));
			}
			TValue value2;
			try
			{
				value2 = (TValue)value;
			}
			catch (InvalidCastException)
			{
				throw new ArgumentException(GetResource("ConcurrentDictionary_TypeOfValueIncorrect"));
			}
			((IDictionary<TKey, TValue>)this).Add((TKey)key, value2);
		}

		bool IDictionary.Contains(object key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (key is TKey)
			{
				return ContainsKey((TKey)key);
			}
			return false;
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return new DictionaryEnumerator(this);
		}

		void IDictionary.Remove(object key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (key is TKey)
			{
				TryRemove((TKey)key, out var _);
			}
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", GetResource("ConcurrentDictionary_IndexIsNegative"));
			}
			int locksAcquired = 0;
			try
			{
				AcquireAllLocks(ref locksAcquired);
				int num = 0;
				for (int i = 0; i < m_locks.Length; i++)
				{
					num += m_countPerLock[i];
				}
				if (array.Length - num < index || num < 0)
				{
					throw new ArgumentException(GetResource("ConcurrentDictionary_ArrayNotLargeEnough"));
				}
				if (array is KeyValuePair<TKey, TValue>[] array2)
				{
					CopyToPairs(array2, index);
					return;
				}
				if (array is DictionaryEntry[] array3)
				{
					CopyToEntries(array3, index);
					return;
				}
				if (array is object[] array4)
				{
					CopyToObjects(array4, index);
					return;
				}
				throw new ArgumentException(GetResource("ConcurrentDictionary_ArrayIncorrectType"), "array");
			}
			finally
			{
				ReleaseLocks(0, locksAcquired);
			}
		}

		private void GrowTable(Node[] buckets)
		{
			int locksAcquired = 0;
			checked
			{
				try
				{
					AcquireLocks(0, 1, ref locksAcquired);
					if (buckets != m_buckets)
					{
						return;
					}
					int i;
					try
					{
						for (i = buckets.Length * 2 + 1; unchecked(i % 3 == 0 || i % 5 == 0 || i % 7 == 0); i += 2)
						{
						}
					}
					catch (OverflowException)
					{
						return;
					}
					Node[] array = new Node[i];
					int[] array2 = new int[m_locks.Length];
					AcquireLocks(1, m_locks.Length, ref locksAcquired);
					for (int j = 0; j < buckets.Length; j = unchecked(j + 1))
					{
						Node node = buckets[j];
						while (node != null)
						{
							Node next = node.m_next;
							GetBucketAndLockNo(node.m_hashcode, out var bucketNo, out var lockNo, array.Length);
							array[bucketNo] = new Node(node.m_key, node.m_value, node.m_hashcode, array[bucketNo]);
							array2[lockNo]++;
							node = next;
						}
					}
					m_buckets = array;
					m_countPerLock = array2;
				}
				finally
				{
					ReleaseLocks(0, locksAcquired);
				}
			}
		}

		private void GetBucketAndLockNo(int hashcode, out int bucketNo, out int lockNo, int bucketCount)
		{
			bucketNo = (hashcode & 0x7FFFFFFF) % bucketCount;
			lockNo = bucketNo % m_locks.Length;
		}

		private void AcquireAllLocks(ref int locksAcquired)
		{
			AcquireLocks(0, m_locks.Length, ref locksAcquired);
		}

		private void AcquireLocks(int fromInclusive, int toExclusive, ref int locksAcquired)
		{
			for (int i = fromInclusive; i < toExclusive; i++)
			{
				bool taken = false;
				try
				{
					Monitor2.Enter(m_locks[i], ref taken);
				}
				finally
				{
					if (taken)
					{
						locksAcquired++;
					}
				}
			}
		}

		private void ReleaseLocks(int fromInclusive, int toExclusive)
		{
			for (int i = fromInclusive; i < toExclusive; i++)
			{
				Monitor.Exit(m_locks[i]);
			}
		}

		private ReadOnlyCollection<TKey> GetKeys()
		{
			int locksAcquired = 0;
			try
			{
				AcquireAllLocks(ref locksAcquired);
				List<TKey> list = new List<TKey>();
				for (int i = 0; i < m_buckets.Length; i++)
				{
					for (Node node = m_buckets[i]; node != null; node = node.m_next)
					{
						list.Add(node.m_key);
					}
				}
				return new ReadOnlyCollection<TKey>(list);
			}
			finally
			{
				ReleaseLocks(0, locksAcquired);
			}
		}

		private ReadOnlyCollection<TValue> GetValues()
		{
			int locksAcquired = 0;
			try
			{
				AcquireAllLocks(ref locksAcquired);
				List<TValue> list = new List<TValue>();
				for (int i = 0; i < m_buckets.Length; i++)
				{
					for (Node node = m_buckets[i]; node != null; node = node.m_next)
					{
						list.Add(node.m_value);
					}
				}
				return new ReadOnlyCollection<TValue>(list);
			}
			finally
			{
				ReleaseLocks(0, locksAcquired);
			}
		}

		[Conditional("DEBUG")]
		private void Assert(bool condition)
		{
		}

		private string GetResource(string key)
		{
			return Environment2.GetResourceString(key);
		}

		[OnSerializing]
		private void OnSerializing(StreamingContext context)
		{
			m_serializationArray = ToArray();
			m_serializationConcurrencyLevel = m_locks.Length;
			m_serializationCapacity = m_buckets.Length;
		}

		[OnDeserialized]
		private void OnDeserialized(StreamingContext context)
		{
			KeyValuePair<TKey, TValue>[] serializationArray = m_serializationArray;
			m_buckets = new Node[m_serializationCapacity];
			m_countPerLock = new int[m_serializationConcurrencyLevel];
			m_locks = new object[m_serializationConcurrencyLevel];
			for (int i = 0; i < m_locks.Length; i++)
			{
				m_locks[i] = new object();
			}
			InitializeFromCollection(serializationArray);
			m_serializationArray = null;
		}
	}
	public interface IProducerConsumerCollection<T> : IEnumerable<T>, ICollection, IEnumerable
	{
		void CopyTo(T[] array, int index);

		bool TryAdd(T item);

		bool TryTake(out T item);

		T[] ToArray();
	}
	[Serializable]
	[DebuggerDisplay("Count = {Count}")]
	[ComVisible(false)]
	[DebuggerTypeProxy(typeof(SystemCollectionsConcurrent_ProducerConsumerCollectionDebugView<>))]
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public class ConcurrentQueue<T> : IProducerConsumerCollection<T>, IEnumerable<T>, ICollection, IEnumerable
	{
		private class Segment
		{
			internal volatile T[] m_array;

			private volatile int[] m_state;

			private volatile Segment m_next;

			internal readonly long m_index;

			private volatile int m_low;

			private volatile int m_high;

			internal Segment Next => m_next;

			internal bool IsEmpty => Low > High;

			internal int Low => Math.Min(m_low, 32);

			internal int High => Math.Min(m_high, 31);

			internal Segment(long index)
			{
				m_array = new T[32];
				m_state = new int[32];
				m_high = -1;
				m_index = index;
			}

			internal void UnsafeAdd(T value)
			{
				m_high++;
				m_array[m_high] = value;
				m_state[m_high] = 1;
			}

			internal Segment UnsafeGrow()
			{
				return m_next = new Segment(m_index + 1);
			}

			internal void Grow(ref Segment tail)
			{
				Segment next = new Segment(m_index + 1);
				m_next = next;
				tail = m_next;
			}

			internal bool TryAppend(T value, ref Segment tail)
			{
				if (m_high >= 31)
				{
					return false;
				}
				int num = 32;
				try
				{
				}
				finally
				{
					num = Interlocked.Increment(ref m_high);
					if (num <= 31)
					{
						m_array[num] = value;
						m_state[num] = 1;
					}
					if (num == 31)
					{
						Grow(ref tail);
					}
				}
				return num <= 31;
			}

			internal bool TryRemove(out T result, ref Segment head)
			{
				SpinWait spinWait = default(SpinWait);
				int low = Low;
				int high = High;
				while (low <= high)
				{
					if (Interlocked.CompareExchange(ref m_low, low + 1, low) == low)
					{
						SpinWait spinWait2 = default(SpinWait);
						while (m_state[low] == 0)
						{
							spinWait2.SpinOnce();
						}
						result = m_array[low];
						if (low + 1 >= 32)
						{
							spinWait2 = default(SpinWait);
							while (m_next == null)
							{
								spinWait2.SpinOnce();
							}
							head = m_next;
						}
						return true;
					}
					spinWait.SpinOnce();
					low = Low;
					high = High;
				}
				result = default(T);
				return false;
			}

			internal bool TryPeek(out T result)
			{
				result = default(T);
				int low = Low;
				if (low > High)
				{
					return false;
				}
				SpinWait spinWait = default(SpinWait);
				while (m_state[low] == 0)
				{
					spinWait.SpinOnce();
				}
				result = m_array[low];
				return true;
			}

			internal List<T> ToList(int start, int end)
			{
				List<T> list = new List<T>();
				for (int i = start; i <= end; i++)
				{
					SpinWait spinWait = default(SpinWait);
					while (m_state[i] == 0)
					{
						spinWait.SpinOnce();
					}
					list.Add(m_array[i]);
				}
				return list;
			}
		}

		private const int SEGMENT_SIZE = 32;

		[NonSerialized]
		private volatile Segment m_head;

		[NonSerialized]
		private volatile Segment m_tail;

		private T[] m_serializationArray;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot
		{
			get
			{
				throw new NotSupportedException(Environment2.GetResourceString("ConcurrentCollection_SyncRoot_NotSupported"));
			}
		}

		public bool IsEmpty
		{
			get
			{
				Segment head = m_head;
				if (!head.IsEmpty)
				{
					return false;
				}
				if (head.Next == null)
				{
					return true;
				}
				SpinWait spinWait = default(SpinWait);
				while (head.IsEmpty)
				{
					if (head.Next == null)
					{
						return true;
					}
					spinWait.SpinOnce();
					head = m_head;
				}
				return false;
			}
		}

		public int Count
		{
			get
			{
				GetHeadTailPositions(out var head, out var tail, out var headLow, out var tailHigh);
				if (head == tail)
				{
					return tailHigh - headLow + 1;
				}
				int num = 32 - headLow;
				num += 32 * (int)(tail.m_index - head.m_index - 1);
				return num + (tailHigh + 1);
			}
		}

		public ConcurrentQueue()
		{
			m_head = (m_tail = new Segment(0L));
		}

		private void InitializeFromCollection(IEnumerable<T> collection)
		{
			m_head = (m_tail = new Segment(0L));
			int num = 0;
			foreach (T item in collection)
			{
				m_tail.UnsafeAdd(item);
				num++;
				if (num >= 32)
				{
					m_tail = m_tail.UnsafeGrow();
					num = 0;
				}
			}
		}

		public ConcurrentQueue(IEnumerable<T> collection)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			InitializeFromCollection(collection);
		}

		[OnSerializing]
		private void OnSerializing(StreamingContext context)
		{
			m_serializationArray = ToArray();
		}

		[OnDeserialized]
		private void OnDeserialized(StreamingContext context)
		{
			InitializeFromCollection(m_serializationArray);
			m_serializationArray = null;
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			((ICollection)ToList()).CopyTo(array, index);
		}

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

		bool IProducerConsumerCollection<T>.TryAdd(T item)
		{
			Enqueue(item);
			return true;
		}

		bool IProducerConsumerCollection<T>.TryTake(out T item)
		{
			return TryDequeue(out item);
		}

		public T[] ToArray()
		{
			return ToList().ToArray();
		}

		private List<T> ToList()
		{
			GetHeadTailPositions(out var head, out var tail, out var headLow, out var tailHigh);
			if (head == tail)
			{
				return head.ToList(headLow, tailHigh);
			}
			List<T> list = new List<T>(head.ToList(headLow, 31));
			for (Segment next = head.Next; next != tail; next = next.Next)
			{
				list.AddRange(next.ToList(0, 31));
			}
			list.AddRange(tail.ToList(0, tailHigh));
			return list;
		}

		private void GetHeadTailPositions(out Segment head, out Segment tail, out int headLow, out int tailHigh)
		{
			head = m_head;
			tail = m_tail;
			headLow = head.Low;
			tailHigh = tail.High;
			SpinWait spinWait = default(SpinWait);
			while (head != m_head || tail != m_tail || headLow != head.Low || tailHigh != tail.High || head.m_index > tail.m_index)
			{
				spinWait.SpinOnce();
				head = m_head;
				tail = m_tail;
				headLow = head.Low;
				tailHigh = tail.High;
			}
		}

		public void CopyTo(T[] array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			ToList().CopyTo(array, index);
		}

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

		public void Enqueue(T item)
		{
			SpinWait spinWait = default(SpinWait);
			while (true)
			{
				Segment tail = m_tail;
				if (tail.TryAppend(item, ref m_tail))
				{
					break;
				}
				spinWait.SpinOnce();
			}
		}

		public bool TryDequeue(out T result)
		{
			while (!IsEmpty)
			{
				Segment head = m_head;
				if (head.TryRemove(out result, ref m_head))
				{
					return true;
				}
			}
			result = default(T);
			return false;
		}

		public bool TryPeek(out T result)
		{
			while (!IsEmpty)
			{
				Segment head = m_head;
				if (head.TryPeek(out result))
				{
					return true;
				}
			}
			result = default(T);
			return false;
		}
	}
	[Serializable]
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(SystemCollectionsConcurrent_ProducerConsumerCollectionDebugView<>))]
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public class ConcurrentStack<T> : IProducerConsumerCollection<T>, IEnumerable<T>, ICollection, IEnumerable
	{
		private class Node
		{
			internal T m_value;

			internal Node m_next;

			internal Node(T value)
			{
				m_value = value;
				m_next = null;
			}
		}

		private const int BACKOFF_MAX_YIELDS = 8;

		[NonSerialized]
		private volatile Node m_head;

		private T[] m_serializationArray;

		public bool IsEmpty => m_head == null;

		public int Count
		{
			get
			{
				int num = 0;
				for (Node node = m_head; node != null; node = node.m_next)
				{
					num++;
				}
				return num;
			}
		}

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot
		{
			get
			{
				throw new NotSupportedException(Environment2.GetResourceString("ConcurrentCollection_SyncRoot_NotSupported"));
			}
		}

		public ConcurrentStack()
		{
		}

		public ConcurrentStack(IEnumerable<T> collection)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			InitializeFromCollection(collection);
		}

		private void InitializeFromCollection(IEnumerable<T> collection)
		{
			Node node = null;
			foreach (T item in collection)
			{
				Node node2 = new Node(item);
				node2.m_next = node;
				node = node2;
			}
			m_head = node;
		}

		[OnSerializing]
		private void OnSerializing(StreamingContext context)
		{
			m_serializationArray = ToArray();
		}

		[OnDeserialized]
		private void OnDeserialized(StreamingContext context)
		{
			Node node = null;
			Node head = null;
			for (int i = 0; i < m_serializationArray.Length; i++)
			{
				Node node2 = new Node(m_serializationArray[i]);
				if (node == null)
				{
					head = node2;
				}
				else
				{
					node.m_next = node2;
				}
				node = node2;
			}
			m_head = head;
			m_serializationArray = null;
		}

		public void Clear()
		{
			m_head = null;
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			((ICollection)ToList()).CopyTo(array, index);
		}

		public void CopyTo(T[] array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			ToList().CopyTo(array, index);
		}

		public void Push(T item)
		{
			Node node = new Node(item);
			node.m_next = m_head;
			if (Interlocked.CompareExchange(ref m_head, node, node.m_next) != node.m_next)
			{
				PushCore(node, node);
			}
		}

		public void PushRange(T[] items)
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			PushRange(items, 0, items.Length);
		}

		public void PushRange(T[] items, int startIndex, int count)
		{
			ValidatePushPopRangeInput(items, startIndex, count);
			if (count != 0)
			{
				Node node;
				Node node2 = (node = new Node(items[startIndex]));
				for (int i = startIndex + 1; i < startIndex + count; i++)
				{
					Node node3 = new Node(items[i]);
					node3.m_next = node2;
					node2 = node3;
				}
				node.m_next = m_head;
				if (Interlocked.CompareExchange(ref m_head, node2, node.m_next) != node.m_next)
				{
					PushCore(node2, node);
				}
			}
		}

		private void PushCore(Node head, Node tail)
		{
			SpinWait spinWait = default(SpinWait);
			do
			{
				spinWait.SpinOnce();
				tail.m_next = m_head;
			}
			while (Interlocked.CompareExchange(ref m_head, head, tail.m_next) != tail.m_next);
		}

		private void ValidatePushPopRangeInput(T[] items, int startIndex, int count)
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", Environment2.GetResourceString("ConcurrentStack_PushPopRange_CountOutOfRange"));
			}
			int num = items.Length;
			if (startIndex >= num || startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", Environment2.GetResourceString("ConcurrentStack_PushPopRange_StartOutOfRange"));
			}
			if (num - count < startIndex)
			{
				throw new ArgumentException(Environment2.GetResourceString("ConcurrentStack_PushPopRange_InvalidCount"));
			}
		}

		bool IProducerConsumerCollection<T>.TryAdd(T item)
		{
			Push(item);
			return true;
		}

		public bool TryPeek(out T result)
		{
			Node head = m_head;
			if (head == null)
			{
				result = default(T);
				return false;
			}
			result = head.m_value;
			return true;
		}

		public bool TryPop(out T result)
		{
			Node head = m_head;
			if (head == null)
			{
				result = default(T);
				return false;
			}
			if (Interlocked.CompareExchange(ref m_head, head.m_next, head) == head)
			{
				result = head.m_value;
				return true;
			}
			return TryPopCore(out result);
		}

		public int TryPopRange(T[] items)
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			return TryPopRange(items, 0, items.Length);
		}

		public int TryPopRange(T[] items, int startIndex, int count)
		{
			ValidatePushPopRangeInput(items, startIndex, count);
			if (count == 0)
			{
				return 0;
			}
			Node poppedHead;
			int num = TryPopCore(count, out poppedHead);
			if (num > 0)
			{
				CopyRemovedItems(poppedHead, items, startIndex, num);
			}
			return num;
		}

		private bool TryPopCore(out T result)
		{
			if (TryPopCore(1, out var poppedHead) == 1)
			{
				result = poppedHead.m_value;
				return true;
			}
			result = default(T);
			return false;
		}

		private int TryPopCore(int count, out Node poppedHead)
		{
			SpinWait spinWait = default(SpinWait);
			int num = 1;
			Random random = new Random(Environment.TickCount & 0x7FFFFFFF);
			Node head;
			int i;
			while (true)
			{
				head = m_head;
				if (head == null)
				{
					poppedHead = null;
					return 0;
				}
				Node node = head;
				for (i = 1; i < count; i++)
				{
					if (node.m_next == null)
					{
						break;
					}
					node = node.m_next;
				}
				if (Interlocked.CompareExchange(ref m_head, node.m_next, head) == head)
				{
					break;
				}
				for (int j = 0; j < num; j++)
				{
					spinWait.SpinOnce();
				}
				num = (spinWait.NextSpinWillYield ? random.Next(1, 8) : (num * 2));
			}
			poppedHead = head;
			return i;
		}

		private void CopyRemovedItems(Node head, T[] collection, int startIndex, int nodesCount)
		{
			Node node = head;
			for (int i = startIndex; i < startIndex + nodesCount; i++)
			{
				collection[i] = node.m_value;
				node = node.m_next;
			}
		}

		bool IProducerConsumerCollection<T>.TryTake(out T item)
		{
			return TryPop(out item);
		}

		public T[] ToArray()
		{
			return ToList().ToArray();
		}

		private List<T> ToList()
		{
			List<T> list = new List<T>();
			for (Node node = m_head; node != null; node = node.m_next)
			{
				list.Add(node.m_value);
			}
			return list;
		}

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

		private IEnumerator<T> GetEnumerator(Node head)
		{
			for (Node current = head; current != null; current = current.m_next)
			{
				yield return current.m_value;
			}
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable<T>)this).GetEnumerator();
		}
	}
	internal sealed class SystemCollectionsConcurrent_ProducerConsumerCollectionDebugView<T>
	{
		private IProducerConsumerCollection<T> m_collection;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items => m_collection.ToArray();

		public SystemCollectionsConcurrent_ProducerConsumerCollectionDebugView(IProducerConsumerCollection<T> collection)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			m_collection = collection;
		}
	}
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public abstract class Partitioner<TSource>
	{
		public virtual bool SupportsDynamicPartitions => false;

		public abstract IList<IEnumerator<TSource>> GetPartitions(int partitionCount);

		public virtual IEnumerable<TSource> GetDynamicPartitions()
		{
			throw new NotSupportedException(Environment2.GetResourceString("Partitioner_DynamicPartitionsNotSupported"));
		}
	}
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public abstract class OrderablePartitioner<TSource> : Partitioner<TSource>
	{
		private class EnumerableDropIndices : IEnumerable<TSource>, IEnumerable, IDisposable
		{
			private readonly IEnumerable<KeyValuePair<long, TSource>> m_source;

			public EnumerableDropIndices(IEnumerable<KeyValuePair<long, TSource>> source)
			{
				m_source = source;
			}

			public IEnumerator<TSource> GetEnumerator()
			{
				return new EnumeratorDropIndices(m_source.GetEnumerator());
			}

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

			public void Dispose()
			{
				if (m_source is IDisposable disposable)
				{
					disposable.Dispose();
				}
			}
		}

		private class EnumeratorDropIndices : IEnumerator<TSource>, IDisposable, IEnumerator
		{
			private readonly IEnumerator<KeyValuePair<long, TSource>> m_source;

			public TSource Current => m_source.Current.Value;

			object IEnumerator.Current => Current;

			public EnumeratorDropIndices(IEnumerator<KeyValuePair<long, TSource>> source)
			{
				m_source = source;
			}

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

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

			public void Reset()
			{
				m_source.Reset();
			}
		}

		public bool KeysOrderedInEachPartition { get; private set; }

		public bool KeysOrderedAcrossPartitions { get; private set; }

		public bool KeysNormalized { get; private set; }

		protected OrderablePartitioner(bool keysOrderedInEachPartition, bool keysOrderedAcrossPartitions, bool keysNormalized)
		{
			KeysOrderedInEachPartition = keysOrderedInEachPartition;
			KeysOrderedAcrossPartitions = keysOrderedAcrossPartitions;
			KeysNormalized = keysNormalized;
		}

		public abstract IList<IEnumerator<KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount);

		public virtual IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions()
		{
			throw new NotSupportedException(Environment2.GetResourceString("Partitioner_DynamicPartitionsNotSupported"));
		}

		public override IList<IEnumerator<TSource>> GetPartitions(int partitionCount)
		{
			IList<IEnumerator<KeyValuePair<long, TSource>>> orderablePartitions = GetOrderablePartitions(partitionCount);
			if (orderablePartitions.Count != partitionCount)
			{
				throw new InvalidOperationException("OrderablePartitioner_GetPartitions_WrongNumberOfPartitions");
			}
			IEnumerator<TSource>[] array = new IEnumerator<TSource>[partitionCount];
			for (int i = 0; i < partitionCount; i++)
			{
				array[i] = new EnumeratorDropIndices(orderablePartitions[i]);
			}
			return array;
		}

		public override IEnumerable<TSource> GetDynamicPartitions()
		{
			IEnumerable<KeyValuePair<long, TSource>> orderableDynamicPartitions = GetOrderableDynamicPartitions();
			return new EnumerableDropIndices(orderableDynamicPartitions);
		}
	}
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public static class Partitioner
	{
		private abstract class DynamicPartitionEnumerator_Abstract<TSource, TSourceReader> : IEnumerator<KeyValuePair<long, TSource>>, IDisposable, IEnumerator
		{
			private const int CHUNK_DOUBLING_RATE = 3;

			protected readonly TSourceReader m_sharedReader;

			protected static int s_defaultMaxChunkSize = GetDefaultChunkSize<TSource>();

			protected Shared<int> m_currentChunkSize;

			protected Shared<int> m_localOffset;

			private int m_doublingCountdown;

			protected readonly int m_maxChunkSize;

			protected readonly Shared<long> m_sharedIndex;

			protected abstract bool HasNoElementsLeft { get; set; }

			public abstract KeyValuePair<long, TSource> Current { get; }

			object IEnumerator.Current => Current;

			protected DynamicPartitionEnumerator_Abstract(TSourceReader sharedReader, Shared<long> sharedIndex)
				: this(sharedReader, sharedIndex, -1)
			{
			}

			protected DynamicPartitionEnumerator_Abstract(TSourceReader sharedReader, Shared<long> sharedIndex, int maxChunkSize)
			{
				m_sharedReader = sharedReader;
				m_sharedIndex = sharedIndex;
				if (maxChunkSize == -1)
				{
					m_maxChunkSize = s_defaultMaxChunkSize;
				}
				else
				{
					m_maxChunkSize = maxChunkSize;
				}
			}

			protected abstract bool GrabNextChunk(int requestedChunkSize);

			public abstract void Dispose();

			public void Reset()
			{
				throw new NotSupportedException();
			}

			public bool MoveNext()
			{
				if (m_localOffset == null)
				{
					m_localOffset = new Shared<int>(-1);
					m_currentChunkSize = new Shared<int>(0);
					m_doublingCountdown = 3;
				}
				if (m_localOffset.Value < m_currentChunkSize.Value - 1)
				{
					m_localOffset.Value++;
					return true;
				}
				int requestedChunkSize;
				if (m_currentChunkSize.Value == 0)
				{
					requestedChunkSize = 1;
				}
				else if (m_doublingCountdown > 0)
				{
					requestedChunkSize = m_currentChunkSize.Value;
				}
				else
				{
					requestedChunkSize = Math.Min(m_currentChunkSize.Value * 2, m_maxChunkSize);
					m_doublingCountdown = 3;
				}
				m_doublingCountdown--;
				if (GrabNextChunk(requestedChunkSize))
				{
					m_localOffset.Value = 0;
					return true;
				}
				return false;
			}
		}

		private class DynamicPartitionerForIEnumerable<TSource> : OrderablePartitioner<TSource>
		{
			private class InternalPartitionEnumerable : IEnumerable<KeyValuePair<long, TSource>>, IEnumerable, IDisposable
			{
				private readonly IEnumerator<TSource> m_sharedReader;

				private Shared<long> m_sharedIndex;

				private Shared<bool> m_hasNoElementsLeft;

				private object m_sharedLock;

				private bool m_disposed;

				private Shared<int> m_activePartitionCount;

				private readonly int m_maxChunkSize;

				internal InternalPartitionEnumerable(IEnumerator<TSource> sharedReader, int maxChunkSize)
				{
					m_sharedReader = sharedReader;
					m_sharedIndex = new Shared<long>(-1L);
					m_hasNoElementsLeft = new Shared<bool>(value: false);
					m_sharedLock = new object();
					m_activePartitionCount = new Shared<int>(0);
					m_maxChunkSize = maxChunkSize;
				}

				public IEnumerator<KeyValuePair<long, TSource>> GetEnumerator()
				{
					if (m_disposed)
					{
						throw new ObjectDisposedException(Environment2.GetResourceString("PartitionerStatic_CanNotCallGetEnumeratorAfterSourceHasBeenDisposed"));
					}
					return new InternalPartitionEnumerator(m_sharedReader, m_sharedIndex, m_hasNoElementsLeft, m_sharedLock, m_activePartitionCount, this, m_maxChunkSize);
				}

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

				public void Dispose()
				{
					if (!m_disposed)
					{
						m_disposed = true;
						m_sharedReader.Dispose();
					}
				}
			}

			private class InternalPartitionEnumerator : DynamicPartitionEnumerator_Abstract<TSource, IEnumerator<TSource>>
			{
				private KeyValuePair<long, TSource>[] m_localList;

				private readonly Shared<bool> m_hasNoElementsLeft;

				private readonly object m_sharedLock;

				private readonly Shared<int> m_activePartitionCount;

				private InternalPartitionEnumerable m_enumerable;

				protected override bool HasNoElementsLeft
				{
					get
					{
						return m_hasNoElementsLeft.Value;
					}
					set
					{
						m_hasNoElementsLeft.Value = true;
					}
				}

				public override KeyValuePair<long, TSource> Current
				{
					get
					{
						if (m_currentChunkSize == null)
						{
							throw new InvalidOperationException(Environment2.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
						}
						return m_localList[m_localOffset.Value];
					}
				}

				internal InternalPartitionEnumerator(IEnumerator<TSource> sharedReader, Shared<long> sharedIndex, Shared<bool> hasNoElementsLeft, object sharedLock, Shared<int> activePartitionCount, InternalPartitionEnumerable enumerable, int maxChunkSize)
					: base(sharedReader, sharedIndex, maxChunkSize)
				{
					m_hasNoElementsLeft = hasNoElementsLeft;
					m_sharedLock = sharedLock;
					m_enumerable = enumerable;
					m_activePartitionCount = activePartitionCount;
					Interlocked.Increment(ref m_activePartitionCount.Value);
				}

				protected override bool GrabNextChunk(int requestedChunkSize)
				{
					if (HasNoElementsLeft)
					{
						return false;
					}
					lock (m_sharedLock)
					{
						if (HasNoElementsLeft)
						{
							return false;
						}
						try
						{
							int i;
							for (i = 0; i < requestedChunkSize; i++)
							{
								if (m_sharedReader.MoveNext())
								{
									if (m_localList == null)
									{
										m_localList = new KeyValuePair<long, TSource>[m_maxChunkSize];
									}
									m_sharedIndex.Value = checked(m_sharedIndex.Value + 1);
									ref KeyValuePair<long, TSource> reference = ref m_localList[i];
									reference = new KeyValuePair<long, TSource>(m_sharedIndex.Value, m_sharedReader.Current);
									continue;
								}
								HasNoElementsLeft = true;
								break;
							}
							if (i > 0)
							{
								m_currentChunkSize.Value = i;
								return true;
							}
							return false;
						}
						catch
						{
							HasNoElementsLeft = true;
							throw;
						}
					}
				}

				public override void Dispose()
				{
					if (Interlocked.Decrement(ref m_activePartitionCount.Value) == 0)
					{
						m_enumerable.Dispose();
					}
				}
			}

			private IEnumerable<TSource> m_source;

			private int m_maxChunkSize;

			public override bool SupportsDynamicPartitions => true;

			internal DynamicPartitionerForIEnumerable(IEnumerable<TSource> source, int maxChunkSize)
				: base(keysOrderedInEachPartition: true, keysOrderedAcrossPartitions: false, keysNormalized: true)
			{
				m_source = source;
				m_maxChunkSize = maxChunkSize;
			}

			public override IList<IEnumerator<KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount)
			{
				if (partitionCount <= 0)
				{
					throw new ArgumentOutOfRangeException("partitionCount");
				}
				IEnumerator<KeyValuePair<long, TSource>>[] array = new IEnumerator<KeyValuePair<long, TSource>>[partitionCount];
				IEnumerable<KeyValuePair<long, TSource>> enumerable = new InternalPartitionEnumerable(m_source.GetEnumerator(), m_maxChunkSize);
				for (int i = 0; i < partitionCount; i++)
				{
					array[i] = enumerable.GetEnumerator();
				}
				return array;
			}

			public override IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions()
			{
				return new InternalPartitionEnumerable(m_source.GetEnumerator(), m_maxChunkSize);
			}
		}

		private abstract class DynamicPartitionerForIndexRange_Abstract<TSource, TCollection> : OrderablePartitioner<TSource>
		{
			private TCollection m_data;

			public override bool SupportsDynamicPartitions => true;

			protected DynamicPartitionerForIndexRange_Abstract(TCollection data)
				: base(keysOrderedInEachPartition: true, keysOrderedAcrossPartitions: false, keysNormalized: true)
			{
				m_data = data;
			}

			protected abstract IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions_Factory(TCollection data);

			public override IList<IEnumerator<KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount)
			{
				if (partitionCount <= 0)
				{
					throw new ArgumentOutOfRangeException("partitionCount");
				}
				IEnumerator<KeyValuePair<long, TSource>>[] array = new IEnumerator<KeyValuePair<long, TSource>>[partitionCount];
				IEnumerable<KeyValuePair<long, TSource>> orderableDynamicPartitions_Factory = GetOrderableDynamicPartitions_Factory(m_data);
				for (int i = 0; i < partitionCount; i++)
				{
					array[i] = orderableDynamicPartitions_Factory.GetEnumerator();
				}
				return array;
			}

			public override IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions()
			{
				return GetOrderableDynamicPartitions_Factory(m_data);
			}
		}

		private abstract class DynamicPartitionEnumeratorForIndexRange_Abstract<TSource, TSourceReader> : DynamicPartitionEnumerator_Abstract<TSource, TSourceReader>
		{
			protected int m_startIndex;

			protected abstract int SourceCount { get; }

			protected override bool HasNoElementsLeft
			{
				get
				{
					return m_sharedIndex.Value >= SourceCount - 1;
				}
				set
				{
				}
			}

			protected DynamicPartitionEnumeratorForIndexRange_Abstract(TSourceReader sharedReader, Shared<long> sharedIndex)
				: base(sharedReader, sharedIndex)
			{
			}

			protected override bool GrabNextChunk(int requestedChunkSize)
			{
				while (!HasNoElementsLeft)
				{
					long value = m_sharedIndex.Value;
					if (HasNoElementsLeft)
					{
						return false;
					}
					long num = Math.Min(SourceCount - 1, value + requestedChunkSize);
					if (Interlocked.CompareExchange(ref m_sharedIndex.Value, num, value) == value)
					{
						m_currentChunkSize.Value = (int)(num - value);
						m_localOffset.Value = -1;
						m_startIndex = (int)(value + 1);
						return true;
					}
				}
				return false;
			}

			public override void Dispose()
			{
			}
		}

		private class DynamicPartitionerForIList<TSource> : DynamicPartitionerForIndexRange_Abstract<TSource, IList<TSource>>
		{
			private class InternalPartitionEnumerable : IEnumerable<KeyValuePair<long, TSource>>, IEnumerable
			{
				private readonly IList<TSource> m_sharedReader;

				private Shared<long> m_sharedIndex;

				internal InternalPartitionEnumerable(IList<TSource> sharedReader)
				{
					m_sharedReader = sharedReader;
					m_sharedIndex = new Shared<long>(-1L);
				}

				public IEnumerator<KeyValuePair<long, TSource>> GetEnumerator()
				{
					return new InternalPartitionEnumerator(m_sharedReader, m_sharedIndex);
				}

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

			private class InternalPartitionEnumerator : DynamicPartitionEnumeratorForIndexRange_Abstract<TSource, IList<TSource>>
			{
				protected override int SourceCount => m_sharedReader.Count;

				public override KeyValuePair<long, TSource> Current
				{
					get
					{
						if (m_currentChunkSize == null)
						{
							throw new InvalidOperationException(Environment2.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
						}
						return new KeyValuePair<long, TSource>(m_startIndex + m_localOffset.Value, m_sharedReader[m_startIndex + m_localOffset.Value]);
					}
				}

				internal InternalPartitionEnumerator(IList<TSource> sharedReader, Shared<long> sharedIndex)
					: base(sharedReader, sharedIndex)
				{
				}
			}

			internal DynamicPartitionerForIList(IList<TSource> source)
				: base(source)
			{
			}

			protected override IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions_Factory(IList<TSource> m_data)
			{
				return new InternalPartitionEnumerable(m_data);
			}
		}

		private class DynamicPartitionerForArray<TSource> : DynamicPartitionerForIndexRange_Abstract<TSource, TSource[]>
		{
			private class InternalPartitionEnumerable : IEnumerable<KeyValuePair<long, TSource>>, IEnumerable
			{
				private readonly TSource[] m_sharedReader;

				private Shared<long> m_sharedIndex;

				internal InternalPartitionEnumerable(TSource[] sharedReader)
				{
					m_sharedReader = sharedReader;
					m_sharedIndex = new Shared<long>(-1L);
				}

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

				public IEnumerator<KeyValuePair<long, TSource>> GetEnumerator()
				{
					return new InternalPartitionEnumerator(m_sharedReader, m_sharedIndex);
				}
			}

			private class InternalPartitionEnumerator : DynamicPartitionEnumeratorForIndexRange_Abstract<TSource, TSource[]>
			{
				protected override int SourceCount => m_sharedReader.Length;

				public override KeyValuePair<long, TSource> Current
				{
					get
					{
						if (m_currentChunkSize == null)
						{
							throw new InvalidOperationException(Environment2.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
						}
						return new KeyValuePair<long, TSource>(m_startIndex + m_localOffset.Value, m_sharedReader[m_startIndex + m_localOffset.Value]);
					}
				}

				internal InternalPartitionEnumerator(TSource[] sharedReader, Shared<long> sharedIndex)
					: base(sharedReader, sharedIndex)
				{
				}
			}

			internal DynamicPartitionerForArray(TSource[] source)
				: base(source)
			{
			}

			protected override IEnumerable<KeyValuePair<long, TSource>> GetOrderableDynamicPartitions_Factory(TSource[] m_data)
			{
				return new InternalPartitionEnumerable(m_data);
			}
		}

		private abstract class StaticIndexRangePartitioner<TSource, TCollection> : OrderablePartitioner<TSource>
		{
			protected abstract int SourceCount { get; }

			protected StaticIndexRangePartitioner()
				: base(keysOrderedInEachPartition: true, keysOrderedAcrossPartitions: true, keysNormalized: true)
			{
			}

			protected abstract IEnumerator<KeyValuePair<long, TSource>> CreatePartition(int startIndex, int endIndex);

			public override IList<IEnumerator<KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount)
			{
				if (partitionCount <= 0)
				{
					throw new ArgumentOutOfRangeException("partitionCount");
				}
				int result;
				int num = Math.DivRem(SourceCount, partitionCount, out result);
				IEnumerator<KeyValuePair<long, TSource>>[] array = new IEnumerator<KeyValuePair<long, TSource>>[partitionCount];
				int num2 = -1;
				for (int i = 0; i < partitionCount; i++)
				{
					int num3 = num2 + 1;
					num2 = ((i >= result) ? (num3 + num - 1) : (num3 + num));
					array[i] = CreatePartition(num3, num2);
				}
				return array;
			}
		}

		private abstract class StaticIndexRangePartition<TSource> : IEnumerator<KeyValuePair<long, TSource>>, IDisposable, IEnumerator
		{
			protected readonly int m_startIndex;

			protected readonly int m_endIndex;

			protected volatile int m_offset;

			public abstract KeyValuePair<long, TSource> Current { get; }

			object IEnumerator.Current => Current;

			protected StaticIndexRangePartition(int startIndex, int endIndex)
			{
				m_startIndex = startIndex;
				m_endIndex = endIndex;
				m_offset = startIndex - 1;
			}

			public void Dispose()
			{
			}

			public void Reset()
			{
				throw new NotSupportedException();
			}

			public bool MoveNext()
			{
				if (m_offset < m_endIndex)
				{
					m_offset++;
					return true;
				}
				m_offset = m_endIndex + 1;
				return false;
			}
		}

		private class StaticIndexRangePartitionerForIList<TSource> : StaticIndexRangePartitioner<TSource, IList<TSource>>
		{
			private IList<TSource> m_list;

			protected override int SourceCount => m_list.Count;

			internal StaticIndexRangePartitionerForIList(IList<TSource> list)
			{
				m_list = list;
			}

			protected override IEnumerator<KeyValuePair<long, TSource>> CreatePartition(int startIndex, int endIndex)
			{
				return new StaticIndexRangePartitionForIList<TSource>(m_list, startIndex, endIndex);
			}
		}

		private class StaticIndexRangePartitionForIList<TSource> : StaticIndexRangePartition<TSource>
		{
			private volatile IList<TSource> m_list;

			public override KeyValuePair<long, TSource> Current
			{
				get
				{
					if (m_offset < m_startIndex)
					{
						throw new InvalidOperationException(Environment2.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
					}
					return new KeyValuePair<long, TSource>(m_offset, m_list[m_offset]);
				}
			}

			internal StaticIndexRangePartitionForIList(IList<TSource> list, int startIndex, int endIndex)
				: base(startIndex, endIndex)
			{
				m_list = list;
			}
		}

		private class StaticIndexRangePartitionerForArray<TSource> : StaticIndexRangePartitioner<TSource, TSource[]>
		{
			private TSource[] m_array;

			protected override int SourceCount => m_array.Length;

			internal StaticIndexRangePartitionerForArray(TSource[] array)
			{
				m_array = array;
			}

			protected override IEnumerator<KeyValuePair<long, TSource>> CreatePartition(int startIndex, int endIndex)
			{
				return new StaticIndexRangePartitionForArray<TSource>(m_array, startIndex, endIndex);
			}
		}

		private class StaticIndexRangePartitionForArray<TSource> : StaticIndexRangePartition<TSource>
		{
			private volatile TSource[] m_array;

			public override KeyValuePair<long, TSource> Current
			{
				get
				{
					if (m_offset < m_startIndex)
					{
						throw new InvalidOperationException(Environment2.GetResourceString("PartitionerStatic_CurrentCalledBeforeMoveNext"));
					}
					return new KeyValuePair<long, TSource>(m_offset, m_array[m_offset]);
				}
			}

			internal StaticIndexRangePartitionForArray(TSource[] array, int startIndex, int endIndex)
				: base(startIndex, endIndex)
			{
				m_array = array;
			}
		}

		private class Shared<TSource>
		{
			internal TSource Value;

			internal Shared(TSource value)
			{
				Value = value;
			}
		}

		private const int DEFAULT_BYTES_PER_CHUNK = 512;

		public static OrderablePartitioner<TSource> Create<TSource>(IList<TSource> list, bool loadBalance)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			if (loadBalance)
			{
				return new DynamicPartitionerForIList<TSource>(list);
			}
			return new StaticIndexRangePartitionerForIList<TSource>(list);
		}

		public static OrderablePartitioner<TSource> Create<TSource>(TSource[] array, bool loadBalance)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (loadBalance)
			{
				return new DynamicPartitionerForArray<TSource>(array);
			}
			return new StaticIndexRangePartitionerForArray<TSource>(array);
		}

		public static OrderablePartitioner<TSource> Create<TSource>(IEnumerable<TSource> source)
		{
			return Create(source, -1);
		}

		internal static OrderablePartitioner<TSource> Create<TSource>(IEnumerable<TSource> source, int maxChunkSize)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return new DynamicPartitionerForIEnumerable<TSource>(source, maxChunkSize);
		}

		private static int GetDefaultChunkSize<TSource>()
		{
			if (typeof(TSource).IsValueType)
			{
				if (typeof(TSource).StructLayoutAttribute.Value == LayoutKind.Explicit)
				{
					return Math.Max(1, 512 / Marshal.SizeOf(typeof(TSource)));
				}
				return 128;
			}
			return 512 / IntPtr.Size;
		}
	}
}
namespace System
{
	[Serializable]
	[DebuggerDisplay("Count = {InnerExceptions.Count}")]
	public class AggregateException : Exception
	{
		private ReadOnlyCollection<Exception> m_innerExceptions;

		public ReadOnlyCollection<Exception> InnerExceptions => m_innerExceptions;

		public AggregateException()
			: base(Environment2.GetResourceString("AggregateException_ctor_DefaultMessage"))
		{
			m_innerExceptions = new ReadOnlyCollection<Exception>(new Exception[0]);
		}

		public AggregateException(string message)
			: base(message)
		{
			m_innerExceptions = new ReadOnlyCollection<Exception>(new Exception[0]);
		}

		public AggregateException(string message, Exception innerException)
			: base(message, innerException)
		{
			if (innerException == null)
			{
				throw new ArgumentNullException("innerException");
			}
			m_innerExceptions = new ReadOnlyCollection<Exception>(new Exception[1] { innerException });
		}

		public AggregateException(IEnumerable<Exception> innerExceptions)
			: this(Environment2.GetResourceString("AggregateException_ctor_DefaultMessage"), innerExceptions)
		{
		}

		public AggregateException(params Exception[] innerExceptions)
			: this(Environment2.GetResourceString("AggregateException_ctor_DefaultMessage"), innerExceptions)
		{
		}

		public AggregateException(string message, IEnumerable<Exception> innerExceptions)
			: this(message, (innerExceptions == null) ? null : new List<Exception>(innerExceptions))
		{
		}

		public AggregateException(string message, params Exception[] innerExceptions)
			: this(message, (IList<Exception>)innerExceptions)
		{
		}

		private AggregateException(string message, IList<Exception> innerExceptions)
			: base(message, (innerExceptions != null && innerExceptions.Count > 0) ? innerExceptions[0] : null)
		{
			if (innerExceptions == null)
			{
				throw new ArgumentNullException("innerExceptions");
			}
			Exception[] array = new Exception[innerExceptions.Count];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = innerExceptions[i];
				if (array[i] == null)
				{
					throw new ArgumentException(Environment2.GetResourceString("AggregateException_ctor_InnerExceptionNull"));
				}
			}
			m_innerExceptions = new ReadOnlyCollection<Exception>(array);
		}

		[SecurityCritical]
		protected AggregateException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			if (!(info.GetValue("InnerExceptions", typeof(Exception[])) is Exception[] list))
			{
				throw new SerializationException(Environment2.GetResourceString("AggregateException_DeserializationFailure"));
			}
			m_innerExceptions = new ReadOnlyCollection<Exception>(list);
		}

		[SecurityCritical]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			base.GetObjectData(info, context);
			Exception[] array = new Exception[m_innerExceptions.Count];
			m_innerExceptions.CopyTo(array, 0);
			info.AddValue("InnerExceptions", array, typeof(Exception[]));
		}

		public override Exception GetBaseException()
		{
			Exception ex = this;
			AggregateException ex2 = this;
			while (ex2 != null && ex2.InnerExceptions.Count == 1)
			{
				ex = ex.InnerException;
				ex2 = ex as AggregateException;
			}
			return ex;
		}

		public void Handle(Func<Exception, bool> predicate)
		{
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			List<Exception> list = null;
			for (int i = 0; i < m_innerExceptions.Count; i++)
			{
				if (!predicate(m_innerExceptions[i]))
				{
					if (list == null)
					{
						list = new List<Exception>();
					}
					list.Add(m_innerExceptions[i]);
				}
			}
			if (list != null)
			{
				throw new AggregateException(Message, list);
			}
		}

		public AggregateException Flatten()
		{
			List<Exception> list = new List<Exception>();
			List<AggregateException> list2 = new List<AggregateException>();
			list2.Add(this);
			int num = 0;
			while (list2.Count > num)
			{
				IList<Exception> innerExceptions = list2[num++].InnerExceptions;
				for (int i = 0; i < innerExceptions.Count; i++)
				{
					Exception ex = innerExceptions[i];
					if (ex != null)
					{
						if (ex is AggregateException item)
						{
							list2.Add(item);
						}
						else
						{
							list.Add(ex);
						}
					}
				}
			}
			return new AggregateException(Message, list);
		}

		public override string ToString()
		{
			string text = base.ToString();
			for (int i = 0; i < m_innerExceptions.Count; i++)
			{
				text = string.Format(CultureInfo.InvariantCulture, Environment2.GetResourceString("AggregateException_ToString"), text, Environment.NewLine, i, m_innerExceptions[i].ToString(), "<---", Environment.NewLine);
			}
			return text;
		}
	}
	public delegate TResult Func_<T1, T2, T3, T4, T5, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
}
namespace System.Threading
{
	[ComVisible(false)]
	[DebuggerDisplay("IsCancellationRequested = {IsCancellationRequested}")]
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public struct CancellationToken
	{
		private CancellationTokenSource m_source;

		private static Action<object> s_ActionToActionObjShunt = ActionToActionObjShunt;

		public static CancellationToken None => default(CancellationToken);

		public bool IsCancellationRequested
		{
			get
			{
				if (m_source != null)
				{
					return m_source.IsCancellationRequested;
				}
				return false;
			}
		}

		public bool CanBeCanceled
		{
			get
			{
				if (m_source != null)
				{
					return m_source.CanBeCanceled;
				}
				return false;
			}
		}

		public WaitHandle WaitHandle
		{
			get
			{
				if (m_source == null)
				{
					InitializeDefaultSource();
				}
				return m_source.WaitHandle;
			}
		}

		internal CancellationToken(CancellationTokenSource source)
		{
			m_source = source;
		}

		public CancellationToken(bool canceled)
		{
			this = default(CancellationToken);
			if (canceled)
			{
				m_source = CancellationTokenSource.InternalGetStaticSource(canceled);
			}
		}

		private static void ActionToActionObjShunt(object obj)
		{
			Action action = obj as Action;
			action();
		}

		public CancellationTokenRegistration Register(Action callback)
		{
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			return Register(s_ActionToActionObjShunt, callback, useSynchronizationContext: false, useExecutionContext: true);
		}

		public CancellationTokenRegistration Register(Action callback, bool useSynchronizationContext)
		{
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			return Register(s_ActionToActionObjShunt, callback, useSynchronizationContext, useExecutionContext: true);
		}

		public CancellationTokenRegistration Register(Action<object> callback, object state)
		{
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			return Register(callback, state, useSynchronizationContext: false, useExecutionContext: true);
		}

		public CancellationTokenRegistration Register(Action<object> callback, object state, bool useSynchronizationContext)
		{
			return Register(callback, state, useSynchronizationContext, useExecutionContext: true);
		}

		internal CancellationTokenRegistration InternalRegisterWithoutEC(Action<object> callback, object state)
		{
			return Register(callback, state, useSynchronizationContext: false, useExecutionContext: false);
		}

		private CancellationTokenRegistration Register(Action<object> callback, object state, bool useSynchronizationContext, bool useExecutionContext)
		{
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			if (!CanBeCanceled)
			{
				return default(CancellationTokenRegistration);
			}
			SynchronizationContext targetSyncContext = null;
			if (!IsCancellationRequested && useSynchronizationContext)
			{
				targetSyncContext = SynchronizationContext.Current;
			}
			ExecutionContext executionContext = null;
			if (!IsCancellationRequested && useExecutionContext)
			{
				executionContext = ExecutionContext.Capture();
			}
			return m_source.InternalRegister(callback, state, targetSyncContext, executionContext);
		}

		public bool Equals(CancellationToken other)
		{
			if (m_source == null && other.m_source == null)
			{
				return true;
			}
			if (m_source == null)
			{
				return other.m_source == CancellationTokenSource.InternalGetStaticSource(set: false);
			}
			if (other.m_source == null)
			{
				return m_source == CancellationTokenSource.InternalGetStaticSource(set: false);
			}
			return m_source == other.m_source;
		}

		public override bool Equals(object other)
		{
			if (other is CancellationToken)
			{
				return Equals((CancellationToken)other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			if (m_source == null)
			{
				return CancellationTokenSource.InternalGetStaticSource(set: false).GetHashCode();
			}
			return m_source.GetHashCode();
		}

		public static bool operator ==(CancellationToken left, CancellationToken right)
		{
			return left.Equals(right);
		}

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

		public void ThrowIfCancellationRequested()
		{
			if (IsCancellationRequested)
			{
				throw new OperationCanceledException2(Environment2.GetResourceString("OperationCanceled"), this);
			}
		}

		internal void ThrowIfSourceDisposed()
		{
			if (m_source != null && m_source.IsDisposed)
			{
				throw new ObjectDisposedException(null, Environment2.GetResourceString("CancellationToken_SourceDisposed"));
			}
		}

		private void InitializeDefaultSource()
		{
			m_source = CancellationTokenSource.InternalGetStaticSource(set: false);
		}
	}
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public struct CancellationTokenRegistration : IEquatable<CancellationTokenRegistration>, IDisposable
	{
		private readonly CancellationTokenSource m_tokenSource;

		private readonly CancellationCallbackInfo m_callbackInfo;

		private readonly SparselyPopulatedArrayAddInfo<CancellationCallbackInfo> m_registrationInfo;

		internal CancellationTokenRegistration(CancellationTokenSource tokenSource, CancellationCallbackInfo callbackInfo, SparselyPopulatedArrayAddInfo<CancellationCallbackInfo> registrationInfo)
		{
			m_tokenSource = tokenSource;
			m_callbackInfo = callbackInfo;
			m_registrationInfo = registrationInfo;
		}

		internal bool TryDeregister()
		{
			if (m_registrationInfo.Source == null)
			{
				return false;
			}
			CancellationCallbackInfo cancellationCallbackInfo = m_registrationInfo.Source.SafeAtomicRemove(m_registrationInfo.Index, m_callbackInfo);
			if (cancellationCallbackInfo != m_callbackInfo)
			{
				return false;
			}
			return true;
		}

		public void Dispose()
		{
			if (m_tokenSource != null)
			{
				m_tokenSource.ThrowIfDisposed();
			}
			bool flag = TryDeregister();
			if (m_tokenSource != null && m_tokenSource.IsCancellationRequested && !m_tokenSource.IsCancellationCompleted && !flag && m_tokenSource.ThreadIDExecutingCallbacks != Thread.CurrentThread.ManagedThreadId)
			{
				m_tokenSource.WaitForCallbackToComplete(m_callbackInfo);
			}
		}

		public static bool operator ==(CancellationTokenRegistration left, CancellationTokenRegistration right)
		{
			return left.Equals(right);
		}

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

		public override bool Equals(object obj)
		{
			if (obj is CancellationTokenRegistration)
			{
				return Equals((CancellationTokenRegistration)obj);
			}
			return false;
		}

		public bool Equals(CancellationTokenRegistration other)
		{
			if (m_tokenSource == other.m_tokenSource && m_callbackInfo == other.m_callbackInfo && m_registrationInfo.Source == other.m_registrationInfo.Source)
			{
				return m_registrationInfo.Index == other.m_registrationInfo.Index;
			}
			return false;
		}

		public override int GetHashCode()
		{
			if (m_registrationInfo.Source != null)
			{
				return m_registrationInfo.Source.GetHashCode() ^ m_registrationInfo.Index.GetHashCode();
			}
			return m_registrationInfo.Index.GetHashCode();
		}
	}
	[ComVisible(false)]
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public sealed class CancellationTokenSource : IDisposable
	{
		private const int CANNOT_BE_CANCELED = 0;

		private const int NOT_CANCELED = 1;

		private const int NOTIFYING = 2;

		private const int NOTIFYINGCOMPLETE = 3;

		private static readonly CancellationTokenSource _staticSource_Set = new CancellationTokenSource(set: true);

		private static readonly CancellationTokenSource _staticSource_NotCancelable = new CancellationTokenSource(set: false);

		private static readonly int s_nLists = ((PlatformHelper.ProcessorCount > 24) ? 24 : PlatformHelper.ProcessorCount);

		private volatile ManualResetEvent m_kernelEvent;

		private volatile SparselyPopulatedArray<CancellationCallbackInfo>[] m_registeredCallbacksLists;

		private volatile int m_state;

		private volatile int m_threadIDExecutingCallbacks = -1;

		private bool m_disposed;

		private List<CancellationTokenRegistration> m_linkingRegistrations;

		private static readonly Action<object> s_LinkedTokenCancelDelegate = LinkedTokenCancelDelegate;

		private volatile CancellationCallbackInfo m_executingCallback;

		public bool IsCancellationRequested => m_state >= 2;

		internal bool IsCancellationCompleted => m_state == 3;

		internal bool IsDisposed => m_disposed;

		internal int ThreadIDExecutingCallbacks
		{
			get
			{
				return m_threadIDExecutingCallbacks;
			}
			set
			{
				m_threadIDExecutingCallbacks = value;
			}
		}

		public CancellationToken Token
		{
			get
			{
				ThrowIfDisposed();
				return new CancellationToken(this);
			}
		}

		internal bool CanBeCanceled => m_state != 0;

		internal WaitHandle WaitHandle
		{
			get
			{
				ThrowIfDisposed();
				if (m_kernelEvent != null)
				{
					return m_kernelEvent;
				}
				ManualResetEvent manualResetEvent = new ManualResetEvent(initialState: false);
				if (Interlocked.CompareExchange(ref m_kernelEvent, manualResetEvent, null) != null)
				{
					((IDisposable)manualResetEvent).Dispose();
				}
				if (IsCancellationRequested)
				{
					m_kernelEvent.Set();
				}
				return m_kernelEvent;
			}
		}

		internal CancellationCallbackInfo ExecutingCallback => m_executingCallback;

		private static void LinkedTokenCancelDelegate(object source)
		{
			CancellationTokenSource cancellationTokenSource = source as CancellationTokenSource;
			cancellationTokenSource.Cancel();
		}

		public CancellationTokenSource()
		{
			m_state = 1;
		}

		private CancellationTokenSource(bool set)
		{
			m_state = (set ? 3 : 0);
		}

		public void Cancel()
		{
			Cancel(throwOnFirstException: false);
		}

		public void Cancel(bool throwOnFirstException)
		{
			ThrowIfDisposed();
			NotifyCancellation(throwOnFirstException);
		}

		public void Dispose()
		{
			if (m_disposed)
			{
				return;
			}
			if (m_linkingRegistrations != null)
			{
				foreach (CancellationTokenRegistration linkingRegistration in m_linkingRegistrations)
				{
					linkingRegistration.Dispose();
				}
				m_linkingRegistrations = null;
			}
			m_registeredCallbacksLists = null;
			if (m_kernelEvent != null)
			{
				m_kernelEvent.Close();
				m_kernelEvent = null;
			}
			m_disposed = true;
		}

		internal void ThrowIfDisposed()
		{
			if (m_disposed)
			{
				throw new ObjectDisposedException(null, Environment2.GetResourceString("CancellationTokenSource_Disposed"));
			}
		}

		internal static CancellationTokenSource InternalGetStaticSource(bool set)
		{
			if (!set)
			{
				return _staticSource_NotCancelable;
			}
			return _staticSource_Set;
		}

		internal CancellationTokenRegistration InternalRegister(Action<object> callback, object stateForCallback, SynchronizationContext targetSyncContext, ExecutionContext executionContext)
		{
			ThrowIfDisposed();
			if (!IsCancellationRequested)
			{
				int num = Thread.CurrentThread.ManagedThreadId % s_nLists;
				CancellationCallbackInfo cancellationCallbackInfo = new CancellationCallbackInfo(callback, stateForCallback, targetSyncContext, executionContext, this);
				if (m_registeredCallbacksLists == null)
				{
					SparselyPopulatedArray<CancellationCallbackInfo>[] value = new SparselyPopulatedArray<CancellationCallbackInfo>[s_nLists];
					Interlocked.CompareExchange(ref m_registeredCallbacksLists, value, null);
				}
				if (m_registeredCallbacksLists[num] == null)
				{
					SparselyPopulatedArray<CancellationCallbackInfo> value2 = new SparselyPopulatedArray<CancellationCallbackInfo>(4);
					Interlocked.CompareExchange(ref m_registeredCallbacksLists[num], value2, null);
				}
				SparselyPopulatedArray<CancellationCallbackInfo> sparselyPopulatedArray = m_registeredCallbacksLists[num];
				SparselyPopulatedArrayAddInfo<CancellationCallbackInfo> registrationInfo = sparselyPopulatedArray.Add(cancellationCallbackInfo);
				CancellationTokenRegistration result = new CancellationTokenRegistration(this, cancellationCallbackInfo, registrationInfo);
				if (!IsCancellationRequested)
				{
					return result;
				}
				if (!result.TryDeregister())
				{
					WaitForCallbackToComplete(cancellationCallbackInfo);
					return default(CancellationTokenRegistration);
				}
			}
			callback(stateForCallback);
			return default(CancellationTokenRegistration);
		}

		private void NotifyCancellation(bool throwOnFirstException)
		{
			if (!IsCancellationRequested && Interlocked.CompareExchange(ref m_state, 2, 1) == 1)
			{
				ThreadIDExecutingCallbacks = Thread.CurrentThread.ManagedThreadId;
				if (m_kernelEvent != null)
				{
					m_kernelEvent.Set();
				}
				ExecuteCallbackHandlers(throwOnFirstException);
			}
		}

		private void ExecuteCallbackHandlers(bool throwOnFirstException)
		{
			List<Exception> list = null;
			SparselyPopulatedArray<CancellationCallbackInfo>[] registeredCallbacksLists = m_registeredCallbacksLists;
			if (registeredCallbacksLists == null)
			{
				Interlocked.Exchange(ref m_state, 3);
				return;
			}
			try
			{
				foreach (SparselyPopulatedArray<CancellationCallbackInfo> sparselyPopulatedArray in registeredCallbacksLists)
				{
					if (sparselyPopulatedArray == null)
					{
						continue;
					}
					for (SparselyPopulatedArrayFragment<CancellationCallbackInfo> sparselyPopulatedArrayFragment = sparselyPopulatedArray.Tail; sparselyPopulatedArrayFragment != null; sparselyPopulatedArrayFragment = sparselyPopulatedArrayFragment.Prev)
					{
						for (int num = sparselyPopulatedArrayFragment.Length - 1; num >= 0; num--)
						{
							m_executingCallback = sparselyPopulatedArrayFragment[num];
							if (m_executingCallback != null)
							{
								CancellationCallbackCoreWorkArguments cancellationCallbackCoreWorkArguments = new CancellationCallbackCoreWorkArguments(sparselyPopulatedArrayFragment, num);
								try
								{
									if (m_executingCallback.TargetSyncContext != null)
									{
										m_executingCallback.TargetSyncContext.Send(CancellationCallbackCoreWork_OnSyncContext, cancellationCallbackCoreWorkArguments);
										ThreadIDExecutingCallbacks = Thread.CurrentThread.ManagedThreadId;
									}
									else
									{
										CancellationCallbackCoreWork_OnSyncContext(cancellationCallbackCoreWorkArguments);
									}
								}
								catch (Exception item)
								{
									if (throwOnFirstException)
									{
										throw;
									}
									if (list == null)
									{
										list = new List<Exception>();
									}
									list.Add(item);
								}
							}
						}
					}
				}
			}
			finally
			{
				m_state = 3;
				m_executingCallback = null;
				Thread.MemoryBarrier();
			}
			if (list == null)
			{
				return;
			}
			throw new AggregateException(list);
		}

		private void CancellationCallbackCoreWork_OnSyncContext(object obj)
		{
			CancellationCallbackCoreWorkArguments cancellationCallbackCoreWorkArguments = (CancellationCallbackCoreWorkArguments)obj;
			CancellationCallbackInfo cancellationCallbackInfo = cancellationCallbackCoreWorkArguments.m_currArrayFragment.SafeAtomicRemove(cancellationCallbackCoreWorkArguments.m_currArrayIndex, m_executingCallback);
			if (cancellationCallbackInfo == m_executingCallback)
			{
				if (cancellationCallbackInfo.TargetExecutionContext != null)
				{
					cancellationCallbackInfo.CancellationTokenSource.ThreadIDExecutingCallbacks = Thread.CurrentThread.ManagedThreadId;
				}
				cancellationCallbackInfo.ExecuteCallback();
			}
		}

		public static CancellationTokenSource CreateLinkedTokenSource(CancellationToken token1, CancellationToken token2)
		{
			CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
			if (token1.CanBeCanceled)
			{
				cancellationTokenSource.m_linkingRegistrations = new List<CancellationTokenRegistration>();
				cancellationTokenSource.m_linkingRegistrations.Add(token1.InternalRegisterWithoutEC(s_LinkedTokenCancelDelegate, cancellationTokenSource));
			}
			if (token2.CanBeCanceled)
			{
				if (cancellationTokenSource.m_linkingRegistrations == null)
				{
					cancellationTokenSource.m_linkingRegistrations = new List<CancellationTokenRegistration>();
				}
				cancellationTokenSource.m_linkingRegistrations.Add(token2.InternalRegisterWithoutEC(s_LinkedTokenCancelDelegate, cancellationTokenSource));
			}
			return cancellationTokenSource;
		}

		public static CancellationTokenSource CreateLinkedTokenSource(params CancellationToken[] tokens)
		{
			if (tokens == null)
			{
				throw new ArgumentNullException("tokens");
			}
			if (tokens.Length == 0)
			{
				throw new ArgumentException(Environment2.GetResourceString("CancellationToken_CreateLinkedToken_TokensIsEmpty"));
			}
			CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
			cancellationTokenSource.m_linkingRegistrations = new List<CancellationTokenRegistration>();
			for (int i = 0; i < tokens.Length; i++)
			{
				if (tokens[i].CanBeCanceled)
				{
					cancellationTokenSource.m_linkingRegistrations.Add(tokens[i].InternalRegisterWithoutEC(s_LinkedTokenCancelDelegate, cancellationTokenSource));
				}
			}
			return cancellationTokenSource;
		}

		internal void WaitForCallbackToComplete(CancellationCallbackInfo callbackInfo)
		{
			SpinWait spinWait = default(SpinWait);
			while (ExecutingCallback == callbackInfo)
			{
				spinWait.SpinOnce();
			}
		}
	}
	internal struct CancellationCallbackCoreWorkArguments
	{
		internal SparselyPopulatedArrayFragment<CancellationCallbackInfo> m_currArrayFragment;

		internal int m_currArrayIndex;

		public CancellationCallbackCoreWorkArguments(SparselyPopulatedArrayFragment<CancellationCallbackInfo> currArrayFragment, int currArrayIndex)
		{
			m_currArrayFragment = currArrayFragment;
			m_currArrayIndex = currArrayIndex;
		}
	}
	internal class CancellationCallbackInfo
	{
		internal readonly Action<object> Callback;

		internal readonly object StateForCallback;

		internal readonly SynchronizationContext TargetSyncContext;

		internal readonly ExecutionContext TargetExecutionContext;

		internal readonly CancellationTokenSource CancellationTokenSource;

		internal CancellationCallbackInfo(Action<object> callback, object stateForCallback, SynchronizationContext targetSyncContext, ExecutionContext targetExecutionContext, CancellationTokenSource cancellationTokenSource)
		{
			Callback = callback;
			StateForCallback = stateForCallback;
			TargetSyncContext = targetSyncContext;
			TargetExecutionContext = targetExecutionContext;
			CancellationTokenSource = cancellationTokenSource;
		}

		[SecuritySafeCritical]
		internal void ExecuteCallback()
		{
			if (TargetExecutionContext != null)
			{
				ExecutionContext.Run(TargetExecutionContext, ExecutionContextCallback, this);
			}
			else
			{
				ExecutionContextCallback(this);
			}
		}

		private static void ExecutionContextCallback(object obj)
		{
			CancellationCallbackInfo cancellationCallbackInfo = obj as CancellationCallbackInfo;
			cancellationCallbackInfo.Callback(cancellationCallbackInfo.StateForCallback);
		}
	}
	internal class SparselyPopulatedArray<T> where T : class
	{
		private readonly SparselyPopulatedArrayFragment<T> m_head;

		private volatile SparselyPopulatedArrayFragment<T> m_tail;

		internal SparselyPopulatedArrayFragment<T> Head => m_head;

		internal SparselyPopulatedArrayFragment<T> Tail => m_tail;

		internal SparselyPopulatedArray(int initialSize)
		{
			m_head = (m_tail = new SparselyPopulatedArrayFragment<T>(initialSize));
		}

		internal SparselyPopulatedArrayAddInfo<T> Add(T element)
		{
			while (true)
			{
				SparselyPopulatedArrayFragment<T> sparselyPopulatedArrayFragment = m_tail;
				while (sparselyPopulatedArrayFragment.m_next != null)
				{
					sparselyPopulatedArrayFragment = (m_tail = sparselyPopulatedArrayFragment.m_next);
				}
				for (SparselyPopulatedArrayFragment<T> sparselyPopulatedArrayFragment2 = sparselyPopulatedArrayFragment; sparselyPopulatedArrayFragment2 != null; sparselyPopulatedArrayFragment2 = sparselyPopulatedArrayFragment2.m_prev)
				{
					if (sparselyPopulatedArrayFragment2.m_freeCount < 1)
					{
						sparselyPopulatedArrayFragment2.m_freeCount--;
					}
					if (sparselyPopulatedArrayFragment2.m_freeCount > 0 || sparselyPopulatedArrayFragment2.m_freeCount < -10)
					{
						int length = sparselyPopulatedArrayFragment2.Length;
						int num = (length - sparselyPopulatedArrayFragment2.m_freeCount) % length;
						if (num < 0)
						{
							num = 0;
							sparselyPopulatedArrayFragment2.m_freeCount--;
						}
						for (int i = 0; i < length; i++)
						{
							int num2 = (num + i) % length;
							if (sparselyPopulatedArrayFragment2.m_elements[num2] == null && Interlocked.CompareExchange(ref sparselyPopulatedArrayFragment2.m_elements[num2], element, null) == null)
							{
								int num3 = sparselyPopulatedArrayFragment2.m_freeCount - 1;
								sparselyPopulatedArrayFragment2.m_freeCount = ((num3 > 0) ? num3 : 0);
								return new SparselyPopulatedArrayAddInfo<T>(sparselyPopulatedArrayFragment2, num2);
							}
						}
					}
				}
				SparselyPopulatedArrayFragment<T> sparselyPopulatedArrayFragment3 = new SparselyPopulatedArrayFragment<T>((sparselyPopulatedArrayFragment.m_elements.Length == 4096) ? 4096 : (sparselyPopulatedArrayFragment.m_elements.Length * 2), sparselyPopulatedArrayFragment);
				if (Interlocked.CompareExchange(ref sparselyPopulatedArrayFragment.m_next, sparselyPopulatedArrayFragment3, null) == null)
				{
					m_tail = sparselyPopulatedArrayFragment3;
				}
			}
		}
	}
	internal struct SparselyPopulatedArrayAddInfo<T> where T : class
	{
		private SparselyPopulatedArrayFragment<T> m_source;

		private int m_index;

		internal SparselyPopulatedArrayFragment<T> Source => m_source;

		internal int Index => m_index;

		internal SparselyPopulatedArrayAddInfo(SparselyPopulatedArrayFragment<T> source, int index)
		{
			m_source = source;
			m_index = index;
		}
	}
	internal class SparselyPopulatedArrayFragment<T> where T : class
	{
		internal readonly T[] m_elements;

		internal volatile int m_freeCount;

		internal volatile SparselyPopulatedArrayFragment<T> m_next;

		internal volatile SparselyPopulatedArrayFragment<T> m_prev;

		internal T this[int index] => m_elements[index];

		internal int Length => m_elements.Length;

		internal SparselyPopulatedArrayFragment<T> Next => m_next;

		internal SparselyPopulatedArrayFragment<T> Prev => m_prev;

		internal SparselyPopulatedArrayFragment(int size)
			: this(size, (SparselyPopulatedArrayFragment<T>)null)
		{
		}

		internal SparselyPopulatedArrayFragment(int size, SparselyPopulatedArrayFragment<T> prev)
		{
			m_elements = new T[size];
			m_freeCount = size;
			m_prev = prev;
		}

		internal T SafeAtomicRemove(int index, T expectedElement)
		{
			T val = Interlocked.CompareExchange(ref m_elements[index], null, expectedElement);
			if (val != null)
			{
				m_freeCount++;
			}
			return val;
		}
	}
	[DebuggerDisplay("Initial Count={InitialCount}, Current Count={CurrentCount}")]
	[ComVisible(false)]
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public class CountdownEvent : IDisposable
	{
		private int m_initialCount;

		private volatile int m_currentCount;

		private ManualResetEventSlim m_event;

		private volatile bool m_disposed;

		public int CurrentCount => m_currentCount;

		public int InitialCount => m_initialCount;

		public bool IsSet => m_currentCount == 0;

		public WaitHandle WaitHandle
		{
			get
			{
				ThrowIfDisposed();
				return m_event.WaitHandle;
			}
		}

		public CountdownEvent(int initialCount)
		{
			if (initialCount < 0)
			{
				throw new ArgumentOutOfRangeException("initialCount");
			}
			m_initialCount = initialCount;
			m_currentCount = initialCount;
			m_event = new ManualResetEventSlim();
			if (initialCount == 0)
			{
				m_event.Set();
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				m_event.Dispose();
				m_disposed = true;
			}
		}

		public bool Signal()
		{
			return Signal(1);
		}

		public bool Signal(int signalCount)
		{
			if (signalCount <= 0)
			{
				throw new ArgumentOutOfRangeException("signalCount");
			}
			ThrowIfDisposed();
			SpinWait spinWait = default(SpinWait);
			int currentCount;
			while (true)
			{
				currentCount = m_currentCount;
				if (currentCount < signalCount)
				{
					throw new InvalidOperationException(Environment2.GetResourceString("CountdownEvent_Decrement_BelowZero"));
				}
				if (Interlocked.CompareExchange(ref m_currentCount, currentCount - signalCount, currentCount) == currentCount)
				{
					break;
				}
				spinWait.SpinOnce();
			}
			if (currentCount == signalCount)
			{
				m_event.Set();
				return true;
			}
			return false;
		}

		public void AddCount()
		{
			AddCount(1);
		}

		public bool TryAddCount()
		{
			return TryAddCount(1);
		}

		public void AddCount(int signalCount)
		{
			if (!TryAddCount(signalCount))
			{
				throw new InvalidOperationException(Environment2.GetResourceString("CountdownEvent_Increment_AlreadyZero"));
			}
		}

		public bool TryAddCount(int signalCount)
		{
			if (signalCount <= 0)
			{
				throw new ArgumentOutOfRangeException("signalCount");
			}
			ThrowIfDisposed();
			SpinWait spinWait = default(SpinWait);
			while (true)
			{
				int currentCount = m_currentCount;
				if (currentCount == 0)
				{
					return false;
				}
				if (currentCount > int.MaxValue - signalCount)
				{
					throw new InvalidOperationException(Environment2.GetResourceString("CountdownEvent_Increment_AlreadyMax"));
				}
				if (Interlocked.CompareExchange(ref m_currentCount, currentCount + signalCount, currentCount) == currentCount)
				{
					break;
				}
				spinWait.SpinOnce();
			}
			return true;
		}

		public void Reset()
		{
			Reset(m_initialCount);
		}

		public void Reset(int count)
		{
			ThrowIfDisposed();
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count");
			}
			m_currentCount = count;
			m_initialCount = count;
			if (count == 0)
			{
				m_event.Set();
			}
			else
			{
				m_event.Reset();
			}
		}

		public void Wait()
		{
			Wait(-1, default(CancellationToken));
		}

		public void Wait(CancellationToken cancellationToken)
		{
			Wait(-1, cancellationToken);
		}

		public bool Wait(TimeSpan timeout)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout");
			}
			return Wait((int)num, default(CancellationToken));
		}

		public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout");
			}
			return Wait((int)num, cancellationToken);
		}

		public bool Wait(int millisecondsTimeout)
		{
			return Wait(millisecondsTimeout, default(CancellationToken));
		}

		public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
		{
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout");
			}
			ThrowIfDisposed();
			cancellationToken.ThrowIfCancellationRequested();
			bool flag = IsSet;
			if (!flag)
			{
				flag = m_event.Wait(millisecondsTimeout, cancellationToken);
			}
			return flag;
		}

		private void ThrowIfDisposed()
		{
			if (m_disposed)
			{
				throw new ObjectDisposedException("CountdownEvent");
			}
		}
	}
	[ComVisible(false)]
	[DebuggerDisplay("Set = {IsSet}")]
	[HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
	public class ManualResetEventSlim : IDisposable
	{
		private const int DEFAULT_SPIN_SP = 1;

		private const int DEFAULT_SPIN_MP = 10;

		private const int SignalledState_BitMask = int.MinValue;

		private const int SignalledState_ShiftCount = 31;

		private const int Dispose_BitMask = 1073741824;

		private const int SpinCountState_BitMask = 1073217536;

		private const int SpinCountState_ShiftCount = 19;

		private const int SpinCountState_MaxValue = 2047;

		private const int NumWaitersState_BitMask = 524287;

		private const int NumWaitersState_ShiftCount = 0;

		private const int NumWaitersState_MaxValue = 524287;

		private object m_lock;

		private ManualResetEvent m_eventObj;

		private volatile int m_combinedState;

		private static Action<object> s_cancellationTokenCallback = CancellationTokenCallback;

		public WaitHandle WaitHandle
		{
			get
			{
				ThrowIfDisposed();
				if (m_eventObj == null)
				{
					LazyInitializeEvent();
				}
				return m_eventObj;
			}
		}

		public bool IsSet
		{
			get
			{
				return 0 != ExtractStatePortion(m_combinedState, int.MinValue);
			}
			private set
			{
				UpdateStateAtomically((value ? 1 : 0) << 31, int.MinValue);
			}
		}

		public int SpinCount
		{
			get
			{
				return ExtractStatePortionAndShiftRight(m_combinedState, 1073217536, 19);
			}
			private set
			{
				m_combinedState = (m_combinedState & -1073217537) | (value << 19);
			}
		}

		private int Waiter