using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Runtime.ConstrainedExecution;
using Cpp2IlInjected;

namespace System
{
	/// <summary>Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.</summary>
	// Token: 0x0200007B RID: 123
	[Token(Token = "0x200007B")]
	public abstract class Array : ICollection, IEnumerable, IList, IStructuralComparable, IStructuralEquatable, ICloneable
	{
		/// <summary>Creates a multidimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> and dimension lengths, with zero-based indexing. The dimension lengths are specified in an array of 64-bit integers.</summary>
		/// <param name="elementType">The <see cref="T:System.Type" /> of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="lengths">An array of 64-bit integers that represent the size of each dimension of the <see cref="T:System.Array" /> to create. Each integer in the array must be between zero and <see cref="F:System.Int32.MaxValue" />, inclusive.</param>
		/// <returns>A new multidimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> with the specified length for each dimension, using zero-based indexing.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="elementType" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="lengths" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="elementType" /> is not a valid <see cref="T:System.Type" />.  
		/// -or-  
		/// The <paramref name="lengths" /> array contains less than one element.</exception>
		/// <exception cref="T:System.NotSupportedException">
		///   <paramref name="elementType" /> is not supported. For example, <see cref="T:System.Void" /> is not supported.  
		/// -or-  
		/// <paramref name="elementType" /> is an open generic type.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">Any value in <paramref name="lengths" /> is less than zero or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x06000352 RID: 850 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000352")]
		[Address(RVA = "0x26C1080", Offset = "0x26BFE80", VA = "0x1826C1080")]
		public static Array CreateInstance(Type elementType, params long[] lengths)
		{
			return null;
		}

		/// <summary>Returns a read-only wrapper for the specified array.</summary>
		/// <param name="array">The one-dimensional, zero-based array to wrap in a read-only <see cref="T:System.Collections.ObjectModel.ReadOnlyCollection`1" /> wrapper.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>A read-only <see cref="T:System.Collections.ObjectModel.ReadOnlyCollection`1" /> wrapper for the specified array.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		// Token: 0x06000353 RID: 851 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000353")]
		[Address(RVA = "0x192FD40", Offset = "0x192EB40", VA = "0x18192FD40")]
		public static ReadOnlyCollection<T> AsReadOnly<T>(T[] array)
		{
			return null;
		}

		/// <summary>Changes the number of elements of a one-dimensional array to the specified new size.</summary>
		/// <param name="array">The one-dimensional, zero-based array to resize, or <see langword="null" /> to create a new array with the specified size.</param>
		/// <param name="newSize">The size of the new array.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="newSize" /> is less than zero.</exception>
		// Token: 0x06000354 RID: 852 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000354")]
		[Address(RVA = "0x1DE7520", Offset = "0x1DE6320", VA = "0x181DE7520")]
		public static void Resize<T>(ref T[] array, int newSize)
		{
		}

		/// <summary>Gets the number of elements contained in the <see cref="T:System.Array" />.</summary>
		/// <returns>The number of elements contained in the collection.</returns>
		// Token: 0x17000068 RID: 104
		// (get) Token: 0x06000355 RID: 853 RVA: 0x00003888 File Offset: 0x00001A88
		[Token(Token = "0x17000068")]
		int ICollection.Count
		{
			[Token(Token = "0x6000355")]
			[Address(RVA = "0x26C2910", Offset = "0x26C1710", VA = "0x1826C2910", Slot = "5")]
			get
			{
				return 0;
			}
		}

		// Token: 0x17000069 RID: 105
		// (get) Token: 0x06000356 RID: 854 RVA: 0x000038A0 File Offset: 0x00001AA0
		[Token(Token = "0x17000069")]
		bool IList.IsReadOnly
		{
			[Token(Token = "0x6000356")]
			[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930", Slot = "14")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets or sets the element at the specified index.</summary>
		/// <param name="index">The index of the element to get or set.</param>
		/// <returns>The element at the specified index.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than zero.  
		/// -or-  
		/// <paramref name="index" /> is equal to or greater than <see cref="P:System.Collections.ICollection.Count" />.</exception>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly one dimension.</exception>
		// Token: 0x1700006A RID: 106
		[Token(Token = "0x1700006A")]
		object IList.this[int index]
		{
			[Token(Token = "0x6000357")]
			[Address(RVA = "0x26C47C0", Offset = "0x26C35C0", VA = "0x1826C47C0", Slot = "9")]
			get
			{
				return null;
			}
			[Token(Token = "0x6000358")]
			[Address(RVA = "0x26C47D0", Offset = "0x26C35D0", VA = "0x1826C47D0", Slot = "10")]
			set
			{
			}
		}

		/// <summary>Calling this method always throws a <see cref="T:System.NotSupportedException" /> exception.</summary>
		/// <param name="value">The object to be added to the <see cref="T:System.Collections.IList" />.</param>
		/// <returns>Adding a value to an array is not supported. No value is returned.</returns>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.IList" /> has a fixed size.</exception>
		// Token: 0x06000359 RID: 857 RVA: 0x000038B8 File Offset: 0x00001AB8
		[Token(Token = "0x6000359")]
		[Address(RVA = "0x26C4480", Offset = "0x26C3280", VA = "0x1826C4480", Slot = "11")]
		int IList.Add(object value)
		{
			return 0;
		}

		/// <summary>Determines whether an element is in the <see cref="T:System.Collections.IList" />.</summary>
		/// <param name="value">The object to locate in the current list. The element to locate can be <see langword="null" /> for reference types.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is found in the <see cref="T:System.Collections.IList" />; otherwise, <see langword="false" />.</returns>
		// Token: 0x0600035A RID: 858 RVA: 0x000038D0 File Offset: 0x00001AD0
		[Token(Token = "0x600035A")]
		[Address(RVA = "0x26C4670", Offset = "0x26C3470", VA = "0x1826C4670", Slot = "12")]
		bool IList.Contains(object value)
		{
			return default(bool);
		}

		/// <summary>Removes all items from the <see cref="T:System.Collections.IList" />.</summary>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.IList" /> is read-only.</exception>
		// Token: 0x0600035B RID: 859 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600035B")]
		[Address(RVA = "0x26C44E0", Offset = "0x26C32E0", VA = "0x1826C44E0", Slot = "13")]
		void IList.Clear()
		{
		}

		/// <summary>Determines the index of a specific item in the <see cref="T:System.Collections.IList" />.</summary>
		/// <param name="value">The object to locate in the current list.</param>
		/// <returns>The index of value if found in the list; otherwise, -1.</returns>
		// Token: 0x0600035C RID: 860 RVA: 0x000038E8 File Offset: 0x00001AE8
		[Token(Token = "0x600035C")]
		[Address(RVA = "0x26C4690", Offset = "0x26C3490", VA = "0x1826C4690", Slot = "16")]
		int IList.IndexOf(object value)
		{
			return 0;
		}

		/// <summary>Inserts an item to the <see cref="T:System.Collections.IList" /> at the specified index.</summary>
		/// <param name="index">The index at which <paramref name="value" /> should be inserted.</param>
		/// <param name="value">The object to insert.</param>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is not a valid index in the <see cref="T:System.Collections.IList" />.</exception>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.IList" /> is read-only.  
		///  -or-  
		///  The <see cref="T:System.Collections.IList" /> has a fixed size.</exception>
		/// <exception cref="T:System.NullReferenceException">
		///   <paramref name="value" /> is null reference in the <see cref="T:System.Collections.IList" />.</exception>
		// Token: 0x0600035D RID: 861 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600035D")]
		[Address(RVA = "0x26C46A0", Offset = "0x26C34A0", VA = "0x1826C46A0", Slot = "17")]
		void IList.Insert(int index, object value)
		{
		}

		/// <summary>Removes the first occurrence of a specific object from the <see cref="T:System.Collections.IList" />.</summary>
		/// <param name="value">The object to remove from the <see cref="T:System.Collections.IList" />.</param>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.IList" /> is read-only.  
		///  -or-  
		///  The <see cref="T:System.Collections.IList" /> has a fixed size.</exception>
		// Token: 0x0600035E RID: 862 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600035E")]
		[Address(RVA = "0x26C4760", Offset = "0x26C3560", VA = "0x1826C4760", Slot = "18")]
		void IList.Remove(object value)
		{
		}

		/// <summary>Removes the <see cref="T:System.Collections.IList" /> item at the specified index.</summary>
		/// <param name="index">The index of the element to remove.</param>
		/// <exception cref="T:System.ArgumentOutOfRangeException">index is not a valid index in the <see cref="T:System.Collections.IList" />.</exception>
		/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.IList" /> is read-only.  
		///  -or-  
		///  The <see cref="T:System.Collections.IList" /> has a fixed size.</exception>
		// Token: 0x0600035F RID: 863 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600035F")]
		[Address(RVA = "0x26C4700", Offset = "0x26C3500", VA = "0x1826C4700", Slot = "19")]
		void IList.RemoveAt(int index)
		{
		}

		/// <summary>Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. The index is specified as a 32-bit integer.</summary>
		/// <param name="array">The one-dimensional array that is the destination of the elements copied from the current array.</param>
		/// <param name="index">A 32-bit integer that represents the index in <paramref name="array" /> at which copying begins.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="array" /> is multidimensional.  
		/// -or-  
		/// The number of elements in the source array is greater than the available number of elements from <paramref name="index" /> to the end of the destination <paramref name="array" />.</exception>
		/// <exception cref="T:System.ArrayTypeMismatchException">The type of the source <see cref="T:System.Array" /> cannot be cast automatically to the type of the destination <paramref name="array" />.</exception>
		/// <exception cref="T:System.RankException">The source array is multidimensional.</exception>
		/// <exception cref="T:System.InvalidCastException">At least one element in the source <see cref="T:System.Array" /> cannot be cast to the type of destination <paramref name="array" />.</exception>
		// Token: 0x06000360 RID: 864 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000360")]
		[Address(RVA = "0x26C0750", Offset = "0x26BF550", VA = "0x1826C0750", Slot = "4")]
		public void CopyTo(Array array, int index)
		{
		}

		/// <summary>Creates a shallow copy of the <see cref="T:System.Array" />.</summary>
		/// <returns>A shallow copy of the <see cref="T:System.Array" />.</returns>
		// Token: 0x06000361 RID: 865 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000361")]
		[Address(RVA = "0x6A0DF0", Offset = "0x69FBF0", VA = "0x1806A0DF0", Slot = "23")]
		public object Clone()
		{
			return null;
		}

		/// <summary>Determines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order.</summary>
		/// <param name="other">The object to compare with the current instance.</param>
		/// <param name="comparer">An object that compares the current object and <paramref name="other" />.</param>
		/// <returns>An integer that indicates the relationship of the current collection object to other, as shown in the following table.  
		///   Return value  
		///
		///   Description  
		///
		///   -1  
		///
		///   The current instance precedes <paramref name="other" />.  
		///
		///   0  
		///
		///   The current instance and <paramref name="other" /> are equal.  
		///
		///   1  
		///
		///   The current instance follows <paramref name="other" />.</returns>
		// Token: 0x06000362 RID: 866 RVA: 0x00003900 File Offset: 0x00001B00
		[Token(Token = "0x6000362")]
		[Address(RVA = "0x26C47F0", Offset = "0x26C35F0", VA = "0x1826C47F0", Slot = "20")]
		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			return 0;
		}

		/// <summary>Determines whether an object is equal to the current instance.</summary>
		/// <param name="other">The object to compare with the current instance.</param>
		/// <param name="comparer">An object that determines whether the current instance and <paramref name="other" /> are equal.</param>
		/// <returns>
		///   <see langword="true" /> if the two objects are equal; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000363 RID: 867 RVA: 0x00003918 File Offset: 0x00001B18
		[Token(Token = "0x6000363")]
		[Address(RVA = "0x26C4A20", Offset = "0x26C3820", VA = "0x1826C4A20", Slot = "21")]
		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			return default(bool);
		}

		// Token: 0x06000364 RID: 868 RVA: 0x00003930 File Offset: 0x00001B30
		[Token(Token = "0x6000364")]
		[Address(RVA = "0x26C05C0", Offset = "0x26BF3C0", VA = "0x1826C05C0")]
		internal static int CombineHashCodes(int h1, int h2)
		{
			return 0;
		}

		/// <summary>Returns a hash code for the current instance.</summary>
		/// <param name="comparer">An object that computes the hash code of the current object.</param>
		/// <returns>The hash code for the current instance.</returns>
		// Token: 0x06000365 RID: 869 RVA: 0x00003948 File Offset: 0x00001B48
		[Token(Token = "0x6000365")]
		[Address(RVA = "0x26C4BC0", Offset = "0x26C39C0", VA = "0x1826C4BC0", Slot = "22")]
		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return 0;
		}

		/// <summary>Searches an entire one-dimensional sorted array for a specific element, using the <see cref="T:System.IComparable" /> interface implemented by each element of the array and by the specified object.</summary>
		/// <param name="array">The sorted one-dimensional <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to search for.</param>
		/// <returns>The index of the specified <paramref name="value" /> in the specified <paramref name="array" />, if <paramref name="value" /> is found; otherwise, a negative number. If <paramref name="value" /> is not found and <paramref name="value" /> is less than one or more elements in <paramref name="array" />, the negative number returned is the bitwise complement of the index of the first element that is larger than <paramref name="value" />. If <paramref name="value" /> is not found and <paramref name="value" /> is greater than all elements in <paramref name="array" />, the negative number returned is the bitwise complement of (the index of the last element plus 1). If this method is called with a non-sorted <paramref name="array" />, the return value can be incorrect and a negative number could be returned, even if <paramref name="value" /> is present in <paramref name="array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="value" /> is of a type that is not compatible with the elements of <paramref name="array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IComparable" /> interface, and the search encounters an element that does not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000366 RID: 870 RVA: 0x00003960 File Offset: 0x00001B60
		[Token(Token = "0x6000366")]
		[Address(RVA = "0x26BFE60", Offset = "0x26BEC60", VA = "0x1826BFE60")]
		public static int BinarySearch(Array array, object value)
		{
			return 0;
		}

		// Token: 0x06000367 RID: 871 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000367")]
		[Address(RVA = "0x23829B0", Offset = "0x23817B0", VA = "0x1823829B0")]
		public static TOutput[] ConvertAll<TOutput, TInput>(TInput[] array, Converter<TInput, TOutput> converter)
		{
			return null;
		}

		/// <summary>Copies a range of elements from an <see cref="T:System.Array" /> starting at the first element and pastes them into another <see cref="T:System.Array" /> starting at the first element. The length is specified as a 64-bit integer.</summary>
		/// <param name="sourceArray">The <see cref="T:System.Array" /> that contains the data to copy.</param>
		/// <param name="destinationArray">The <see cref="T:System.Array" /> that receives the data.</param>
		/// <param name="length">A 64-bit integer that represents the number of elements to copy. The integer must be between zero and <see cref="F:System.Int32.MaxValue" />, inclusive.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="sourceArray" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="destinationArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="sourceArray" /> and <paramref name="destinationArray" /> have different ranks.</exception>
		/// <exception cref="T:System.ArrayTypeMismatchException">
		///   <paramref name="sourceArray" /> and <paramref name="destinationArray" /> are of incompatible types.</exception>
		/// <exception cref="T:System.InvalidCastException">At least one element in <paramref name="sourceArray" /> cannot be cast to the type of <paramref name="destinationArray" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="length" /> is less than 0 or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="length" /> is greater than the number of elements in <paramref name="sourceArray" />.  
		/// -or-  
		/// <paramref name="length" /> is greater than the number of elements in <paramref name="destinationArray" />.</exception>
		// Token: 0x06000368 RID: 872 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000368")]
		[Address(RVA = "0x26C0860", Offset = "0x26BF660", VA = "0x1826C0860")]
		public static void Copy(Array sourceArray, Array destinationArray, long length)
		{
		}

		/// <summary>Copies a range of elements from an <see cref="T:System.Array" /> starting at the specified source index and pastes them to another <see cref="T:System.Array" /> starting at the specified destination index. The length and the indexes are specified as 64-bit integers.</summary>
		/// <param name="sourceArray">The <see cref="T:System.Array" /> that contains the data to copy.</param>
		/// <param name="sourceIndex">A 64-bit integer that represents the index in the <paramref name="sourceArray" /> at which copying begins.</param>
		/// <param name="destinationArray">The <see cref="T:System.Array" /> that receives the data.</param>
		/// <param name="destinationIndex">A 64-bit integer that represents the index in the <paramref name="destinationArray" /> at which storing begins.</param>
		/// <param name="length">A 64-bit integer that represents the number of elements to copy. The integer must be between zero and <see cref="F:System.Int32.MaxValue" />, inclusive.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="sourceArray" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="destinationArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="sourceArray" /> and <paramref name="destinationArray" /> have different ranks.</exception>
		/// <exception cref="T:System.ArrayTypeMismatchException">
		///   <paramref name="sourceArray" /> and <paramref name="destinationArray" /> are of incompatible types.</exception>
		/// <exception cref="T:System.InvalidCastException">At least one element in <paramref name="sourceArray" /> cannot be cast to the type of <paramref name="destinationArray" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="sourceIndex" /> is outside the range of valid indexes for the <paramref name="sourceArray" />.  
		/// -or-  
		/// <paramref name="destinationIndex" /> is outside the range of valid indexes for the <paramref name="destinationArray" />.  
		/// -or-  
		/// <paramref name="length" /> is less than 0 or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="length" /> is greater than the number of elements from <paramref name="sourceIndex" /> to the end of <paramref name="sourceArray" />.  
		/// -or-  
		/// <paramref name="length" /> is greater than the number of elements from <paramref name="destinationIndex" /> to the end of <paramref name="destinationArray" />.</exception>
		// Token: 0x06000369 RID: 873 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000369")]
		[Address(RVA = "0x26C0EA0", Offset = "0x26BFCA0", VA = "0x1826C0EA0")]
		public static void Copy(Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length)
		{
		}

		/// <summary>Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. The index is specified as a 64-bit integer.</summary>
		/// <param name="array">The one-dimensional array that is the destination of the elements copied from the current array.</param>
		/// <param name="index">A 64-bit integer that represents the index in <paramref name="array" /> at which copying begins.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is outside the range of valid indexes for <paramref name="array" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="array" /> is multidimensional.  
		/// -or-  
		/// The number of elements in the source array is greater than the available number of elements from <paramref name="index" /> to the end of the destination <paramref name="array" />.</exception>
		/// <exception cref="T:System.ArrayTypeMismatchException">The type of the source <see cref="T:System.Array" /> cannot be cast automatically to the type of the destination <paramref name="array" />.</exception>
		/// <exception cref="T:System.RankException">The source <see cref="T:System.Array" /> is multidimensional.</exception>
		/// <exception cref="T:System.InvalidCastException">At least one element in the source <see cref="T:System.Array" /> cannot be cast to the type of destination <paramref name="array" />.</exception>
		// Token: 0x0600036A RID: 874 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600036A")]
		[Address(RVA = "0x26C05E0", Offset = "0x26BF3E0", VA = "0x1826C05E0")]
		public void CopyTo(Array array, long index)
		{
		}

		/// <summary>Performs the specified action on each element of the specified array.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> on whose elements the action is to be performed.</param>
		/// <param name="action">The <see cref="T:System.Action`1" /> to perform on each element of <paramref name="array" />.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="action" /> is <see langword="null" />.</exception>
		// Token: 0x0600036B RID: 875 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600036B")]
		[Address(RVA = "0x1694F10", Offset = "0x1693D10", VA = "0x181694F10")]
		public static void ForEach<T>(T[] array, Action<T> action)
		{
		}

		/// <summary>Gets a 64-bit integer that represents the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary>
		/// <returns>A 64-bit integer that represents the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</returns>
		// Token: 0x1700006B RID: 107
		// (get) Token: 0x0600036C RID: 876 RVA: 0x00003978 File Offset: 0x00001B78
		[Token(Token = "0x1700006B")]
		public long LongLength
		{
			[Token(Token = "0x600036C")]
			[Address(RVA = "0x26C4DB0", Offset = "0x26C3BB0", VA = "0x1826C4DB0")]
			get
			{
				return 0L;
			}
		}

		/// <summary>Gets a 64-bit integer that represents the number of elements in the specified dimension of the <see cref="T:System.Array" />.</summary>
		/// <param name="dimension">A zero-based dimension of the <see cref="T:System.Array" /> whose length needs to be determined.</param>
		/// <returns>A 64-bit integer that represents the number of elements in the specified dimension.</returns>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="dimension" /> is less than zero.  
		/// -or-  
		/// <paramref name="dimension" /> is equal to or greater than <see cref="P:System.Array.Rank" />.</exception>
		// Token: 0x0600036D RID: 877 RVA: 0x00003990 File Offset: 0x00001B90
		[Token(Token = "0x600036D")]
		[Address(RVA = "0x26C1BB0", Offset = "0x26C09B0", VA = "0x1826C1BB0")]
		public long GetLongLength(int dimension)
		{
			return 0L;
		}

		/// <summary>Gets the value at the specified position in the one-dimensional <see cref="T:System.Array" />. The index is specified as a 64-bit integer.</summary>
		/// <param name="index">A 64-bit integer that represents the position of the <see cref="T:System.Array" /> element to get.</param>
		/// <returns>The value at the specified position in the one-dimensional <see cref="T:System.Array" />.</returns>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly one dimension.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is outside the range of valid indexes for the current <see cref="T:System.Array" />.</exception>
		// Token: 0x0600036E RID: 878 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600036E")]
		[Address(RVA = "0x26C21C0", Offset = "0x26C0FC0", VA = "0x1826C21C0")]
		public object GetValue(long index)
		{
			return null;
		}

		/// <summary>Gets the value at the specified position in the two-dimensional <see cref="T:System.Array" />. The indexes are specified as 64-bit integers.</summary>
		/// <param name="index1">A 64-bit integer that represents the first-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <param name="index2">A 64-bit integer that represents the second-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <returns>The value at the specified position in the two-dimensional <see cref="T:System.Array" />.</returns>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly two dimensions.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">Either <paramref name="index1" /> or <paramref name="index2" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x0600036F RID: 879 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600036F")]
		[Address(RVA = "0x26C22F0", Offset = "0x26C10F0", VA = "0x1826C22F0")]
		public object GetValue(long index1, long index2)
		{
			return null;
		}

		/// <summary>Gets the value at the specified position in the three-dimensional <see cref="T:System.Array" />. The indexes are specified as 64-bit integers.</summary>
		/// <param name="index1">A 64-bit integer that represents the first-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <param name="index2">A 64-bit integer that represents the second-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <param name="index3">A 64-bit integer that represents the third-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <returns>The value at the specified position in the three-dimensional <see cref="T:System.Array" />.</returns>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly three dimensions.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index1" /> or <paramref name="index2" /> or <paramref name="index3" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x06000370 RID: 880 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000370")]
		[Address(RVA = "0x26C1DC0", Offset = "0x26C0BC0", VA = "0x1826C1DC0")]
		public object GetValue(long index1, long index2, long index3)
		{
			return null;
		}

		/// <summary>Gets the value at the specified position in the multidimensional <see cref="T:System.Array" />. The indexes are specified as an array of 64-bit integers.</summary>
		/// <param name="indices">A one-dimensional array of 64-bit integers that represent the indexes specifying the position of the <see cref="T:System.Array" /> element to get.</param>
		/// <returns>The value at the specified position in the multidimensional <see cref="T:System.Array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="indices" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">The number of dimensions in the current <see cref="T:System.Array" /> is not equal to the number of elements in <paramref name="indices" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">Any element in <paramref name="indices" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x06000371 RID: 881 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000371")]
		[Address(RVA = "0x26C1C50", Offset = "0x26C0A50", VA = "0x1826C1C50")]
		public object GetValue(params long[] indices)
		{
			return null;
		}

		/// <summary>Gets a value indicating whether the <see cref="T:System.Array" /> has a fixed size.</summary>
		/// <returns>This property is always <see langword="true" /> for all arrays.</returns>
		// Token: 0x1700006C RID: 108
		// (get) Token: 0x06000372 RID: 882 RVA: 0x000039A8 File Offset: 0x00001BA8
		[Token(Token = "0x1700006C")]
		public bool IsFixedSize
		{
			[Token(Token = "0x6000372")]
			[Address(RVA = "0x460D40", Offset = "0x45FB40", VA = "0x180460D40", Slot = "15")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets a value indicating whether the <see cref="T:System.Array" /> is read-only.</summary>
		/// <returns>This property is always <see langword="false" /> for all arrays.</returns>
		// Token: 0x1700006D RID: 109
		// (get) Token: 0x06000373 RID: 883 RVA: 0x000039C0 File Offset: 0x00001BC0
		[Token(Token = "0x1700006D")]
		public bool IsReadOnly
		{
			[Token(Token = "0x6000373")]
			[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930", Slot = "24")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets a value indicating whether access to the <see cref="T:System.Array" /> is synchronized (thread safe).</summary>
		/// <returns>This property is always <see langword="false" /> for all arrays.</returns>
		// Token: 0x1700006E RID: 110
		// (get) Token: 0x06000374 RID: 884 RVA: 0x000039D8 File Offset: 0x00001BD8
		[Token(Token = "0x1700006E")]
		public bool IsSynchronized
		{
			[Token(Token = "0x6000374")]
			[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930", Slot = "7")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets an object that can be used to synchronize access to the <see cref="T:System.Array" />.</summary>
		/// <returns>An object that can be used to synchronize access to the <see cref="T:System.Array" />.</returns>
		// Token: 0x1700006F RID: 111
		// (get) Token: 0x06000375 RID: 885 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x1700006F")]
		public object SyncRoot
		{
			[Token(Token = "0x6000375")]
			[Address(RVA = "0x434BD0", Offset = "0x4339D0", VA = "0x180434BD0", Slot = "6")]
			get
			{
				return null;
			}
		}

		/// <summary>Searches a range of elements in a one-dimensional sorted array for a value, using the <see cref="T:System.IComparable" /> interface implemented by each element of the array and by the specified value.</summary>
		/// <param name="array">The sorted one-dimensional <see cref="T:System.Array" /> to search.</param>
		/// <param name="index">The starting index of the range to search.</param>
		/// <param name="length">The length of the range to search.</param>
		/// <param name="value">The object to search for.</param>
		/// <returns>The index of the specified <paramref name="value" /> in the specified <paramref name="array" />, if <paramref name="value" /> is found; otherwise, a negative number. If <paramref name="value" /> is not found and <paramref name="value" /> is less than one or more elements in <paramref name="array" />, the negative number returned is the bitwise complement of the index of the first element that is larger than <paramref name="value" />. If <paramref name="value" /> is not found and <paramref name="value" /> is greater than all elements in <paramref name="array" />, the negative number returned is the bitwise complement of (the index of the last element plus 1). If this method is called with a non-sorted <paramref name="array" />, the return value can be incorrect and a negative number could be returned, even if <paramref name="value" /> is present in <paramref name="array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in <paramref name="array" />.  
		/// -or-  
		/// <paramref name="value" /> is of a type that is not compatible with the elements of <paramref name="array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IComparable" /> interface, and the search encounters an element that does not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000376 RID: 886 RVA: 0x000039F0 File Offset: 0x00001BF0
		[Token(Token = "0x6000376")]
		[Address(RVA = "0x26C0060", Offset = "0x26BEE60", VA = "0x1826C0060")]
		public static int BinarySearch(Array array, int index, int length, object value)
		{
			return 0;
		}

		/// <summary>Searches an entire one-dimensional sorted array for a value using the specified <see cref="T:System.Collections.IComparer" /> interface.</summary>
		/// <param name="array">The sorted one-dimensional <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to search for.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.IComparer" /> implementation to use when comparing elements.  
		///  -or-  
		///  <see langword="null" /> to use the <see cref="T:System.IComparable" /> implementation of each element.</param>
		/// <returns>The index of the specified <paramref name="value" /> in the specified <paramref name="array" />, if <paramref name="value" /> is found; otherwise, a negative number. If <paramref name="value" /> is not found and <paramref name="value" /> is less than one or more elements in <paramref name="array" />, the negative number returned is the bitwise complement of the index of the first element that is larger than <paramref name="value" />. If <paramref name="value" /> is not found and <paramref name="value" /> is greater than all elements in <paramref name="array" />, the negative number returned is the bitwise complement of (the index of the last element plus 1). If this method is called with a non-sorted <paramref name="array" />, the return value can be incorrect and a negative number could be returned, even if <paramref name="value" /> is present in <paramref name="array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparer" /> is <see langword="null" />, and <paramref name="value" /> is of a type that is not compatible with the elements of <paramref name="array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, <paramref name="value" /> does not implement the <see cref="T:System.IComparable" /> interface, and the search encounters an element that does not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000377 RID: 887 RVA: 0x00003A08 File Offset: 0x00001C08
		[Token(Token = "0x6000377")]
		[Address(RVA = "0x26BFF60", Offset = "0x26BED60", VA = "0x1826BFF60")]
		public static int BinarySearch(Array array, object value, IComparer comparer)
		{
			return 0;
		}

		/// <summary>Searches a range of elements in a one-dimensional sorted array for a value, using the specified <see cref="T:System.Collections.IComparer" /> interface.</summary>
		/// <param name="array">The sorted one-dimensional <see cref="T:System.Array" /> to search.</param>
		/// <param name="index">The starting index of the range to search.</param>
		/// <param name="length">The length of the range to search.</param>
		/// <param name="value">The object to search for.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.IComparer" /> implementation to use when comparing elements.  
		///  -or-  
		///  <see langword="null" /> to use the <see cref="T:System.IComparable" /> implementation of each element.</param>
		/// <returns>The index of the specified <paramref name="value" /> in the specified <paramref name="array" />, if <paramref name="value" /> is found; otherwise, a negative number. If <paramref name="value" /> is not found and <paramref name="value" /> is less than one or more elements in <paramref name="array" />, the negative number returned is the bitwise complement of the index of the first element that is larger than <paramref name="value" />. If <paramref name="value" /> is not found and <paramref name="value" /> is greater than all elements in <paramref name="array" />, the negative number returned is the bitwise complement of (the index of the last element plus 1). If this method is called with a non-sorted <paramref name="array" />, the return value can be incorrect and a negative number could be returned, even if <paramref name="value" /> is present in <paramref name="array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in <paramref name="array" />.  
		/// -or-  
		/// <paramref name="comparer" /> is <see langword="null" />, and <paramref name="value" /> is of a type that is not compatible with the elements of <paramref name="array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, <paramref name="value" /> does not implement the <see cref="T:System.IComparable" /> interface, and the search encounters an element that does not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000378 RID: 888 RVA: 0x00003A20 File Offset: 0x00001C20
		[Token(Token = "0x6000378")]
		[Address(RVA = "0x26C0080", Offset = "0x26BEE80", VA = "0x1826C0080")]
		public static int BinarySearch(Array array, int index, int length, object value, IComparer comparer)
		{
			return 0;
		}

		// Token: 0x06000379 RID: 889 RVA: 0x00003A38 File Offset: 0x00001C38
		[Token(Token = "0x6000379")]
		[Address(RVA = "0x26C1BD0", Offset = "0x26C09D0", VA = "0x1826C1BD0")]
		private static int GetMedian(int low, int hi)
		{
			return 0;
		}

		/// <summary>Searches an entire one-dimensional sorted array for a specific element, using the <see cref="T:System.IComparable`1" /> generic interface implemented by each element of the <see cref="T:System.Array" /> and by the specified object.</summary>
		/// <param name="array">The sorted one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The index of the specified <paramref name="value" /> in the specified <paramref name="array" />, if <paramref name="value" /> is found; otherwise, a negative number. If <paramref name="value" /> is not found and <paramref name="value" /> is less than one or more elements in <paramref name="array" />, the negative number returned is the bitwise complement of the index of the first element that is larger than <paramref name="value" />. If <paramref name="value" /> is not found and <paramref name="value" /> is greater than all elements in <paramref name="array" />, the negative number returned is the bitwise complement of (the index of the last element plus 1). If this method is called with a non-sorted <paramref name="array" />, the return value can be incorrect and a negative number could be returned, even if <paramref name="value" /> is present in <paramref name="array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="T" /> does not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x0600037A RID: 890 RVA: 0x00003A50 File Offset: 0x00001C50
		[Token(Token = "0x600037A")]
		[Address(RVA = "0x22F9810", Offset = "0x22F8610", VA = "0x1822F9810")]
		public static int BinarySearch<T>(T[] array, T value)
		{
			return 0;
		}

		/// <summary>Searches an entire one-dimensional sorted array for a value using the specified <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface.</summary>
		/// <param name="array">The sorted one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to search for.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.Generic.IComparer`1" /> implementation to use when comparing elements.  
		///  -or-  
		///  <see langword="null" /> to use the <see cref="T:System.IComparable`1" /> implementation of each element.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The index of the specified <paramref name="value" /> in the specified <paramref name="array" />, if <paramref name="value" /> is found; otherwise, a negative number. If <paramref name="value" /> is not found and <paramref name="value" /> is less than one or more elements in <paramref name="array" />, the negative number returned is the bitwise complement of the index of the first element that is larger than <paramref name="value" />. If <paramref name="value" /> is not found and <paramref name="value" /> is greater than all elements in <paramref name="array" />, the negative number returned is the bitwise complement of (the index of the last element plus 1). If this method is called with a non-sorted <paramref name="array" />, the return value can be incorrect and a negative number could be returned, even if <paramref name="value" /> is present in <paramref name="array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="comparer" /> is <see langword="null" />, and <paramref name="value" /> is of a type that is not compatible with the elements of <paramref name="array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and <paramref name="T" /> does not implement the <see cref="T:System.IComparable`1" /> generic interface</exception>
		// Token: 0x0600037B RID: 891 RVA: 0x00003A68 File Offset: 0x00001C68
		[Token(Token = "0x600037B")]
		[Address(RVA = "0x22F98B0", Offset = "0x22F86B0", VA = "0x1822F98B0")]
		public static int BinarySearch<T>(T[] array, T value, IComparer<T> comparer)
		{
			return 0;
		}

		/// <summary>Searches a range of elements in a one-dimensional sorted array for a value, using the <see cref="T:System.IComparable`1" /> generic interface implemented by each element of the <see cref="T:System.Array" /> and by the specified value.</summary>
		/// <param name="array">The sorted one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="index">The starting index of the range to search.</param>
		/// <param name="length">The length of the range to search.</param>
		/// <param name="value">The object to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The index of the specified <paramref name="value" /> in the specified <paramref name="array" />, if <paramref name="value" /> is found; otherwise, a negative number. If <paramref name="value" /> is not found and <paramref name="value" /> is less than one or more elements in <paramref name="array" />, the negative number returned is the bitwise complement of the index of the first element that is larger than <paramref name="value" />. If <paramref name="value" /> is not found and <paramref name="value" /> is greater than all elements in <paramref name="array" />, the negative number returned is the bitwise complement of (the index of the last element plus 1). If this method is called with a non-sorted <paramref name="array" />, the return value can be incorrect and a negative number could be returned, even if <paramref name="value" /> is present in <paramref name="array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in <paramref name="array" />.  
		/// -or-  
		/// <paramref name="value" /> is of a type that is not compatible with the elements of <paramref name="array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="T" /> does not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x0600037C RID: 892 RVA: 0x00003A80 File Offset: 0x00001C80
		[Token(Token = "0x600037C")]
		[Address(RVA = "0x19E8840", Offset = "0x19E7640", VA = "0x1819E8840")]
		public static int BinarySearch<T>(T[] array, int index, int length, T value)
		{
			return 0;
		}

		/// <summary>Searches a range of elements in a one-dimensional sorted array for a value, using the specified <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface.</summary>
		/// <param name="array">The sorted one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="index">The starting index of the range to search.</param>
		/// <param name="length">The length of the range to search.</param>
		/// <param name="value">The object to search for.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.Generic.IComparer`1" /> implementation to use when comparing elements.  
		///  -or-  
		///  <see langword="null" /> to use the <see cref="T:System.IComparable`1" /> implementation of each element.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The index of the specified <paramref name="value" /> in the specified <paramref name="array" />, if <paramref name="value" /> is found; otherwise, a negative number. If <paramref name="value" /> is not found and <paramref name="value" /> is less than one or more elements in <paramref name="array" />, the negative number returned is the bitwise complement of the index of the first element that is larger than <paramref name="value" />. If <paramref name="value" /> is not found and <paramref name="value" /> is greater than all elements in <paramref name="array" />, the negative number returned is the bitwise complement of (the index of the last element plus 1). If this method is called with a non-sorted <paramref name="array" />, the return value can be incorrect and a negative number could be returned, even if <paramref name="value" /> is present in <paramref name="array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in <paramref name="array" />.  
		/// -or-  
		/// <paramref name="comparer" /> is <see langword="null" />, and <paramref name="value" /> is of a type that is not compatible with the elements of <paramref name="array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and <paramref name="T" /> does not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x0600037D RID: 893 RVA: 0x00003A98 File Offset: 0x00001C98
		[Token(Token = "0x600037D")]
		[Address(RVA = "0x185E7D0", Offset = "0x185D5D0", VA = "0x18185E7D0")]
		public static int BinarySearch<T>(T[] array, int index, int length, T value, IComparer<T> comparer)
		{
			return 0;
		}

		/// <summary>Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.</summary>
		/// <param name="array">The one-dimensional array to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <returns>The index of the first occurrence of <paramref name="value" /> in <paramref name="array" />, if found; otherwise, the lower bound of the array minus 1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		// Token: 0x0600037E RID: 894 RVA: 0x00003AB0 File Offset: 0x00001CB0
		[Token(Token = "0x600037E")]
		[Address(RVA = "0x26C26C0", Offset = "0x26C14C0", VA = "0x1826C26C0")]
		public static int IndexOf(Array array, object value)
		{
			return 0;
		}

		/// <summary>Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. The range extends from a specified index to the end of the array.</summary>
		/// <param name="array">The one-dimensional array to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <param name="startIndex">The starting index of the search. 0 (zero) is valid in an empty array.</param>
		/// <returns>The index of the first occurrence of <paramref name="value" />, if it's found, within the range of elements in <paramref name="array" /> that extends from <paramref name="startIndex" /> to the last element; otherwise, the lower bound of the array minus 1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		// Token: 0x0600037F RID: 895 RVA: 0x00003AC8 File Offset: 0x00001CC8
		[Token(Token = "0x600037F")]
		[Address(RVA = "0x26C27B0", Offset = "0x26C15B0", VA = "0x1826C27B0")]
		public static int IndexOf(Array array, object value, int startIndex)
		{
			return 0;
		}

		/// <summary>Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. The range extends from a specified index for a specified number of elements.</summary>
		/// <param name="array">The one-dimensional array to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <param name="startIndex">The starting index of the search. 0 (zero) is valid in an empty array.</param>
		/// <param name="count">The number of elements to search.</param>
		/// <returns>The index of the first occurrence of <paramref name="value" />, if it's found in the <paramref name="array" /> from index <paramref name="startIndex" /> to <paramref name="startIndex" /> + <paramref name="count" /> - 1; otherwise, the lower bound of the array minus 1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.  
		/// -or-  
		/// <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="startIndex" /> and <paramref name="count" /> do not specify a valid section in <paramref name="array" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		// Token: 0x06000380 RID: 896 RVA: 0x00003AE0 File Offset: 0x00001CE0
		[Token(Token = "0x6000380")]
		[Address(RVA = "0x26C2440", Offset = "0x26C1240", VA = "0x1826C2440")]
		public static int IndexOf(Array array, object value, int startIndex, int count)
		{
			return 0;
		}

		/// <summary>Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.</summary>
		/// <param name="array">The one-dimensional, zero-based array to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the first occurrence of <paramref name="value" /> in the entire <paramref name="array" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		// Token: 0x06000381 RID: 897 RVA: 0x00003AF8 File Offset: 0x00001CF8
		[Token(Token = "0x6000381")]
		[Address(RVA = "0x2221580", Offset = "0x2220380", VA = "0x182221580")]
		public static int IndexOf<T>(T[] array, T value)
		{
			return 0;
		}

		/// <summary>Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. The range extends from a specified index to the end of the array.</summary>
		/// <param name="array">The one-dimensional, zero-based array to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <param name="startIndex">The zero-based starting index of the search. 0 (zero) is valid in an empty array.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the first occurrence of <paramref name="value" /> within the range of elements in <paramref name="array" /> that extends from <paramref name="startIndex" /> to the last element, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.</exception>
		// Token: 0x06000382 RID: 898 RVA: 0x00003B10 File Offset: 0x00001D10
		[Token(Token = "0x6000382")]
		[Address(RVA = "0x22214D0", Offset = "0x22202D0", VA = "0x1822214D0")]
		public static int IndexOf<T>(T[] array, T value, int startIndex)
		{
			return 0;
		}

		/// <summary>Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. The range extends from a specified index for a specified number of elements.</summary>
		/// <param name="array">The one-dimensional, zero-based array to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <param name="startIndex">The zero-based starting index of the search. 0 (zero) is valid in an empty array.</param>
		/// <param name="count">The number of elements in the section to search.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the first occurrence of <paramref name="value" /> within the range of elements in <paramref name="array" /> that starts at <paramref name="startIndex" /> and contains the number of elements specified in <paramref name="count" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.  
		/// -or-  
		/// <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="startIndex" /> and <paramref name="count" /> do not specify a valid section in <paramref name="array" />.</exception>
		// Token: 0x06000383 RID: 899 RVA: 0x00003B28 File Offset: 0x00001D28
		[Token(Token = "0x6000383")]
		[Address(RVA = "0x2305580", Offset = "0x2304380", VA = "0x182305580")]
		public static int IndexOf<T>(T[] array, T value, int startIndex, int count)
		{
			return 0;
		}

		/// <summary>Searches for the specified object and returns the index of the last occurrence within the entire one-dimensional <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <returns>The index of the last occurrence of <paramref name="value" /> within the entire <paramref name="array" />, if found; otherwise, the lower bound of the array minus 1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		// Token: 0x06000384 RID: 900 RVA: 0x00003B40 File Offset: 0x00001D40
		[Token(Token = "0x6000384")]
		[Address(RVA = "0x26C29D0", Offset = "0x26C17D0", VA = "0x1826C29D0")]
		public static int LastIndexOf(Array array, object value)
		{
			return 0;
		}

		/// <summary>Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional <see cref="T:System.Array" /> that extends from the first element to the specified index.</summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <param name="startIndex">The starting index of the backward search.</param>
		/// <returns>The index of the last occurrence of <paramref name="value" /> within the range of elements in <paramref name="array" /> that extends from the first element to <paramref name="startIndex" />, if found; otherwise, the lower bound of the array minus 1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		// Token: 0x06000385 RID: 901 RVA: 0x00003B58 File Offset: 0x00001D58
		[Token(Token = "0x6000385")]
		[Address(RVA = "0x26C2DE0", Offset = "0x26C1BE0", VA = "0x1826C2DE0")]
		public static int LastIndexOf(Array array, object value, int startIndex)
		{
			return 0;
		}

		/// <summary>Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional <see cref="T:System.Array" /> that contains the specified number of elements and ends at the specified index.</summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <param name="startIndex">The starting index of the backward search.</param>
		/// <param name="count">The number of elements in the section to search.</param>
		/// <returns>The index of the last occurrence of <paramref name="value" /> within the range of elements in <paramref name="array" /> that contains the number of elements specified in <paramref name="count" /> and ends at <paramref name="startIndex" />, if found; otherwise, the lower bound of the array minus 1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.  
		/// -or-  
		/// <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="startIndex" /> and <paramref name="count" /> do not specify a valid section in <paramref name="array" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		// Token: 0x06000386 RID: 902 RVA: 0x00003B70 File Offset: 0x00001D70
		[Token(Token = "0x6000386")]
		[Address(RVA = "0x26C2AF0", Offset = "0x26C18F0", VA = "0x1826C2AF0")]
		public static int LastIndexOf(Array array, object value, int startIndex, int count)
		{
			return 0;
		}

		/// <summary>Searches for the specified object and returns the index of the last occurrence within the entire <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the last occurrence of <paramref name="value" /> within the entire <paramref name="array" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		// Token: 0x06000387 RID: 903 RVA: 0x00003B88 File Offset: 0x00001D88
		[Token(Token = "0x6000387")]
		[Address(RVA = "0x216FC70", Offset = "0x216EA70", VA = "0x18216FC70")]
		public static int LastIndexOf<T>(T[] array, T value)
		{
			return 0;
		}

		/// <summary>Searches for the specified object and returns the index of the last occurrence within the range of elements in the <see cref="T:System.Array" /> that extends from the first element to the specified index.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <param name="startIndex">The zero-based starting index of the backward search.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the last occurrence of <paramref name="value" /> within the range of elements in <paramref name="array" /> that extends from the first element to <paramref name="startIndex" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.</exception>
		// Token: 0x06000388 RID: 904 RVA: 0x00003BA0 File Offset: 0x00001DA0
		[Token(Token = "0x6000388")]
		[Address(RVA = "0x216F6B0", Offset = "0x216E4B0", VA = "0x18216F6B0")]
		public static int LastIndexOf<T>(T[] array, T value, int startIndex)
		{
			return 0;
		}

		/// <summary>Searches for the specified object and returns the index of the last occurrence within the range of elements in the <see cref="T:System.Array" /> that contains the specified number of elements and ends at the specified index.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="value">The object to locate in <paramref name="array" />.</param>
		/// <param name="startIndex">The zero-based starting index of the backward search.</param>
		/// <param name="count">The number of elements in the section to search.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the last occurrence of <paramref name="value" /> within the range of elements in <paramref name="array" /> that contains the number of elements specified in <paramref name="count" /> and ends at <paramref name="startIndex" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.  
		/// -or-  
		/// <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="startIndex" /> and <paramref name="count" /> do not specify a valid section in <paramref name="array" />.</exception>
		// Token: 0x06000389 RID: 905 RVA: 0x00003BB8 File Offset: 0x00001DB8
		[Token(Token = "0x6000389")]
		[Address(RVA = "0x216F4D0", Offset = "0x216E2D0", VA = "0x18216F4D0")]
		public static int LastIndexOf<T>(T[] array, T value, int startIndex, int count)
		{
			return 0;
		}

		/// <summary>Reverses the sequence of the elements in the entire one-dimensional <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array" /> to reverse.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		// Token: 0x0600038A RID: 906 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600038A")]
		[Address(RVA = "0x26C3160", Offset = "0x26C1F60", VA = "0x1826C3160")]
		public static void Reverse(Array array)
		{
		}

		/// <summary>Reverses the sequence of the elements in a range of elements in the one-dimensional <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array" /> to reverse.</param>
		/// <param name="index">The starting index of the section to reverse.</param>
		/// <param name="length">The number of elements in the section to reverse.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in <paramref name="array" />.</exception>
		// Token: 0x0600038B RID: 907 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600038B")]
		[Address(RVA = "0x26C2E80", Offset = "0x26C1C80", VA = "0x1826C2E80")]
		public static void Reverse(Array array, int index, int length)
		{
		}

		// Token: 0x0600038C RID: 908 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600038C")]
		[Address(RVA = "0x276AA80", Offset = "0x2769880", VA = "0x18276AA80")]
		public static void Reverse<T>(T[] array)
		{
		}

		// Token: 0x0600038D RID: 909 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600038D")]
		[Address(RVA = "0x1DF00F0", Offset = "0x1DEEEF0", VA = "0x181DF00F0")]
		public static void Reverse<T>(T[] array, int index, int length)
		{
		}

		/// <summary>Sets a value to the element at the specified position in the one-dimensional <see cref="T:System.Array" />. The index is specified as a 64-bit integer.</summary>
		/// <param name="value">The new value for the specified element.</param>
		/// <param name="index">A 64-bit integer that represents the position of the <see cref="T:System.Array" /> element to set.</param>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly one dimension.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> cannot be cast to the element type of the current <see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is outside the range of valid indexes for the current <see cref="T:System.Array" />.</exception>
		// Token: 0x0600038E RID: 910 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600038E")]
		[Address(RVA = "0x26C3830", Offset = "0x26C2630", VA = "0x1826C3830")]
		public void SetValue(object value, long index)
		{
		}

		/// <summary>Sets a value to the element at the specified position in the two-dimensional <see cref="T:System.Array" />. The indexes are specified as 64-bit integers.</summary>
		/// <param name="value">The new value for the specified element.</param>
		/// <param name="index1">A 64-bit integer that represents the first-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <param name="index2">A 64-bit integer that represents the second-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly two dimensions.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> cannot be cast to the element type of the current <see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">Either <paramref name="index1" /> or <paramref name="index2" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x0600038F RID: 911 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600038F")]
		[Address(RVA = "0x26C38D0", Offset = "0x26C26D0", VA = "0x1826C38D0")]
		public void SetValue(object value, long index1, long index2)
		{
		}

		/// <summary>Sets a value to the element at the specified position in the three-dimensional <see cref="T:System.Array" />. The indexes are specified as 64-bit integers.</summary>
		/// <param name="value">The new value for the specified element.</param>
		/// <param name="index1">A 64-bit integer that represents the first-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <param name="index2">A 64-bit integer that represents the second-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <param name="index3">A 64-bit integer that represents the third-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly three dimensions.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> cannot be cast to the element type of the current <see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index1" /> or <paramref name="index2" /> or <paramref name="index3" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x06000390 RID: 912 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000390")]
		[Address(RVA = "0x26C3650", Offset = "0x26C2450", VA = "0x1826C3650")]
		public void SetValue(object value, long index1, long index2, long index3)
		{
		}

		/// <summary>Sets a value to the element at the specified position in the multidimensional <see cref="T:System.Array" />. The indexes are specified as an array of 64-bit integers.</summary>
		/// <param name="value">The new value for the specified element.</param>
		/// <param name="indices">A one-dimensional array of 64-bit integers that represent the indexes specifying the position of the element to set.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="indices" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">The number of dimensions in the current <see cref="T:System.Array" /> is not equal to the number of elements in <paramref name="indices" />.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> cannot be cast to the element type of the current <see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">Any element in <paramref name="indices" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x06000391 RID: 913 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000391")]
		[Address(RVA = "0x26C3260", Offset = "0x26C2060", VA = "0x1826C3260")]
		public void SetValue(object value, params long[] indices)
		{
		}

		/// <summary>Sorts the elements in an entire one-dimensional <see cref="T:System.Array" /> using the <see cref="T:System.IComparable" /> implementation of each element of the <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array" /> to sort.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		/// <exception cref="T:System.InvalidOperationException">One or more elements in <paramref name="array" /> do not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000392 RID: 914 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000392")]
		[Address(RVA = "0x26C3DD0", Offset = "0x26C2BD0", VA = "0x1826C3DD0")]
		public static void Sort(Array array)
		{
		}

		/// <summary>Sorts the elements in a range of elements in a one-dimensional <see cref="T:System.Array" /> using the <see cref="T:System.IComparable" /> implementation of each element of the <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array" /> to sort.</param>
		/// <param name="index">The starting index of the range to sort.</param>
		/// <param name="length">The number of elements in the range to sort.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in <paramref name="array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">One or more elements in <paramref name="array" /> do not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000393 RID: 915 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000393")]
		[Address(RVA = "0x26C3CA0", Offset = "0x26C2AA0", VA = "0x1826C3CA0")]
		public static void Sort(Array array, int index, int length)
		{
		}

		/// <summary>Sorts the elements in a one-dimensional <see cref="T:System.Array" /> using the specified <see cref="T:System.Collections.IComparer" />.</summary>
		/// <param name="array">The one-dimensional array to sort.</param>
		/// <param name="comparer">The implementation to use when comparing elements.  
		///  -or-  
		///  <see langword="null" /> to use the <see cref="T:System.IComparable" /> implementation of each element.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and one or more elements in <paramref name="array" /> do not implement the <see cref="T:System.IComparable" /> interface.</exception>
		/// <exception cref="T:System.ArgumentException">The implementation of <paramref name="comparer" /> caused an error during the sort. For example, <paramref name="comparer" /> might not return 0 when comparing an item with itself.</exception>
		// Token: 0x06000394 RID: 916 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000394")]
		[Address(RVA = "0x26C4350", Offset = "0x26C3150", VA = "0x1826C4350")]
		public static void Sort(Array array, IComparer comparer)
		{
		}

		/// <summary>Sorts the elements in a range of elements in a one-dimensional <see cref="T:System.Array" /> using the specified <see cref="T:System.Collections.IComparer" />.</summary>
		/// <param name="array">The one-dimensional <see cref="T:System.Array" /> to sort.</param>
		/// <param name="index">The starting index of the range to sort.</param>
		/// <param name="length">The number of elements in the range to sort.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.IComparer" /> implementation to use when comparing elements.  
		///  -or-  
		///  <see langword="null" /> to use the <see cref="T:System.IComparable" /> implementation of each element.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in <paramref name="array" />.  
		/// -or-  
		/// The implementation of <paramref name="comparer" /> caused an error during the sort. For example, <paramref name="comparer" /> might not return 0 when comparing an item with itself.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and one or more elements in <paramref name="array" /> do not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000395 RID: 917 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000395")]
		[Address(RVA = "0x26C4450", Offset = "0x26C3250", VA = "0x1826C4450")]
		public static void Sort(Array array, int index, int length, IComparer comparer)
		{
		}

		/// <summary>Sorts a pair of one-dimensional <see cref="T:System.Array" /> objects (one contains the keys and the other contains the corresponding items) based on the keys in the first <see cref="T:System.Array" /> using the <see cref="T:System.IComparable" /> implementation of each key.</summary>
		/// <param name="keys">The one-dimensional <see cref="T:System.Array" /> that contains the keys to sort.</param>
		/// <param name="items">The one-dimensional <see cref="T:System.Array" /> that contains the items that correspond to each of the keys in the <paramref name="keys" /><see cref="T:System.Array" />.  
		///  -or-  
		///  <see langword="null" /> to sort only the <paramref name="keys" /><see cref="T:System.Array" />.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="keys" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">The <paramref name="keys" /><see cref="T:System.Array" /> is multidimensional.  
		///  -or-  
		///  The <paramref name="items" /><see cref="T:System.Array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="items" /> is not <see langword="null" />, and the length of <paramref name="keys" /> is greater than the length of <paramref name="items" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">One or more elements in the <paramref name="keys" /><see cref="T:System.Array" /> do not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000396 RID: 918 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000396")]
		[Address(RVA = "0x26C4230", Offset = "0x26C3030", VA = "0x1826C4230")]
		public static void Sort(Array keys, Array items)
		{
		}

		/// <summary>Sorts a pair of one-dimensional <see cref="T:System.Array" /> objects (one contains the keys and the other contains the corresponding items) based on the keys in the first <see cref="T:System.Array" /> using the specified <see cref="T:System.Collections.IComparer" />.</summary>
		/// <param name="keys">The one-dimensional <see cref="T:System.Array" /> that contains the keys to sort.</param>
		/// <param name="items">The one-dimensional <see cref="T:System.Array" /> that contains the items that correspond to each of the keys in the <paramref name="keys" /><see cref="T:System.Array" />.  
		///  -or-  
		///  <see langword="null" /> to sort only the <paramref name="keys" /><see cref="T:System.Array" />.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.IComparer" /> implementation to use when comparing elements.  
		///  -or-  
		///  <see langword="null" /> to use the <see cref="T:System.IComparable" /> implementation of each element.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="keys" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">The <paramref name="keys" /><see cref="T:System.Array" /> is multidimensional.  
		///  -or-  
		///  The <paramref name="items" /><see cref="T:System.Array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="items" /> is not <see langword="null" />, and the length of <paramref name="keys" /> is greater than the length of <paramref name="items" />.  
		/// -or-  
		/// The implementation of <paramref name="comparer" /> caused an error during the sort. For example, <paramref name="comparer" /> might not return 0 when comparing an item with itself.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and one or more elements in the <paramref name="keys" /><see cref="T:System.Array" /> do not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000397 RID: 919 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000397")]
		[Address(RVA = "0x26C3CD0", Offset = "0x26C2AD0", VA = "0x1826C3CD0")]
		public static void Sort(Array keys, Array items, IComparer comparer)
		{
		}

		/// <summary>Sorts a range of elements in a pair of one-dimensional <see cref="T:System.Array" /> objects (one contains the keys and the other contains the corresponding items) based on the keys in the first <see cref="T:System.Array" /> using the <see cref="T:System.IComparable" /> implementation of each key.</summary>
		/// <param name="keys">The one-dimensional <see cref="T:System.Array" /> that contains the keys to sort.</param>
		/// <param name="items">The one-dimensional <see cref="T:System.Array" /> that contains the items that correspond to each of the keys in the <paramref name="keys" /><see cref="T:System.Array" />.  
		///  -or-  
		///  <see langword="null" /> to sort only the <paramref name="keys" /><see cref="T:System.Array" />.</param>
		/// <param name="index">The starting index of the range to sort.</param>
		/// <param name="length">The number of elements in the range to sort.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="keys" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">The <paramref name="keys" /><see cref="T:System.Array" /> is multidimensional.  
		///  -or-  
		///  The <paramref name="items" /><see cref="T:System.Array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="keys" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="items" /> is not <see langword="null" />, and the length of <paramref name="keys" /> is greater than the length of <paramref name="items" />.  
		/// -or-  
		/// <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in the <paramref name="keys" /><see cref="T:System.Array" />.  
		/// -or-  
		/// <paramref name="items" /> is not <see langword="null" />, and <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in the <paramref name="items" /><see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">One or more elements in the <paramref name="keys" /><see cref="T:System.Array" /> do not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000398 RID: 920 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000398")]
		[Address(RVA = "0x26C4330", Offset = "0x26C3130", VA = "0x1826C4330")]
		public static void Sort(Array keys, Array items, int index, int length)
		{
		}

		/// <summary>Sorts a range of elements in a pair of one-dimensional <see cref="T:System.Array" /> objects (one contains the keys and the other contains the corresponding items) based on the keys in the first <see cref="T:System.Array" /> using the specified <see cref="T:System.Collections.IComparer" />.</summary>
		/// <param name="keys">The one-dimensional <see cref="T:System.Array" /> that contains the keys to sort.</param>
		/// <param name="items">The one-dimensional <see cref="T:System.Array" /> that contains the items that correspond to each of the keys in the <paramref name="keys" /><see cref="T:System.Array" />.  
		///  -or-  
		///  <see langword="null" /> to sort only the <paramref name="keys" /><see cref="T:System.Array" />.</param>
		/// <param name="index">The starting index of the range to sort.</param>
		/// <param name="length">The number of elements in the range to sort.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.IComparer" /> implementation to use when comparing elements.  
		///  -or-  
		///  <see langword="null" /> to use the <see cref="T:System.IComparable" /> implementation of each element.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="keys" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">The <paramref name="keys" /><see cref="T:System.Array" /> is multidimensional.  
		///  -or-  
		///  The <paramref name="items" /><see cref="T:System.Array" /> is multidimensional.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="keys" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="items" /> is not <see langword="null" />, and the lower bound of <paramref name="keys" /> does not match the lower bound of <paramref name="items" />.  
		/// -or-  
		/// <paramref name="items" /> is not <see langword="null" />, and the length of <paramref name="keys" /> is greater than the length of <paramref name="items" />.  
		/// -or-  
		/// <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in the <paramref name="keys" /><see cref="T:System.Array" />.  
		/// -or-  
		/// <paramref name="items" /> is not <see langword="null" />, and <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in the <paramref name="items" /><see cref="T:System.Array" />.  
		/// -or-  
		/// The implementation of <paramref name="comparer" /> caused an error during the sort. For example, <paramref name="comparer" /> might not return 0 when comparing an item with itself.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and one or more elements in the <paramref name="keys" /><see cref="T:System.Array" /> do not implement the <see cref="T:System.IComparable" /> interface.</exception>
		// Token: 0x06000399 RID: 921 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000399")]
		[Address(RVA = "0x26C3EB0", Offset = "0x26C2CB0", VA = "0x1826C3EB0")]
		public static void Sort(Array keys, Array items, int index, int length, IComparer comparer)
		{
		}

		/// <summary>Sorts the elements in an entire <see cref="T:System.Array" /> using the <see cref="T:System.IComparable`1" /> generic interface implementation of each element of the <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to sort.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">One or more elements in <paramref name="array" /> do not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x0600039A RID: 922 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600039A")]
		[Address(RVA = "0x19E8D80", Offset = "0x19E7B80", VA = "0x1819E8D80")]
		public static void Sort<T>(T[] array)
		{
		}

		/// <summary>Sorts the elements in a range of elements in an <see cref="T:System.Array" /> using the <see cref="T:System.IComparable`1" /> generic interface implementation of each element of the <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to sort</param>
		/// <param name="index">The starting index of the range to sort.</param>
		/// <param name="length">The number of elements in the range to sort.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in <paramref name="array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">One or more elements in <paramref name="array" /> do not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x0600039B RID: 923 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600039B")]
		[Address(RVA = "0x19094B0", Offset = "0x19082B0", VA = "0x1819094B0")]
		public static void Sort<T>(T[] array, int index, int length)
		{
		}

		/// <summary>Sorts the elements in an <see cref="T:System.Array" /> using the specified <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface.</summary>
		/// <param name="array">The one-dimensional, zero-base <see cref="T:System.Array" /> to sort</param>
		/// <param name="comparer">The <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface implementation to use when comparing elements, or <see langword="null" /> to use the <see cref="T:System.IComparable`1" /> generic interface implementation of each element.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and one or more elements in <paramref name="array" /> do not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		/// <exception cref="T:System.ArgumentException">The implementation of <paramref name="comparer" /> caused an error during the sort. For example, <paramref name="comparer" /> might not return 0 when comparing an item with itself.</exception>
		// Token: 0x0600039C RID: 924 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600039C")]
		[Address(RVA = "0x19E45A0", Offset = "0x19E33A0", VA = "0x1819E45A0")]
		public static void Sort<T>(T[] array, IComparer<T> comparer)
		{
		}

		/// <summary>Sorts the elements in a range of elements in an <see cref="T:System.Array" /> using the specified <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to sort.</param>
		/// <param name="index">The starting index of the range to sort.</param>
		/// <param name="length">The number of elements in the range to sort.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface implementation to use when comparing elements, or <see langword="null" /> to use the <see cref="T:System.IComparable`1" /> generic interface implementation of each element.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in <paramref name="array" />.  
		/// -or-  
		/// The implementation of <paramref name="comparer" /> caused an error during the sort. For example, <paramref name="comparer" /> might not return 0 when comparing an item with itself.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and one or more elements in <paramref name="array" /> do not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x0600039D RID: 925 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600039D")]
		[Address(RVA = "0x215CFC0", Offset = "0x215BDC0", VA = "0x18215CFC0")]
		public static void Sort<T>(T[] array, int index, int length, IComparer<T> comparer)
		{
		}

		/// <summary>Sorts the elements in an <see cref="T:System.Array" /> using the specified <see cref="T:System.Comparison`1" />.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to sort</param>
		/// <param name="comparison">The <see cref="T:System.Comparison`1" /> to use when comparing elements.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="comparison" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">The implementation of <paramref name="comparison" /> caused an error during the sort. For example, <paramref name="comparison" /> might not return 0 when comparing an item with itself.</exception>
		// Token: 0x0600039E RID: 926 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600039E")]
		[Address(RVA = "0x19E8AD0", Offset = "0x19E78D0", VA = "0x1819E8AD0")]
		public static void Sort<T>(T[] array, Comparison<T> comparison)
		{
		}

		/// <summary>Sorts a pair of <see cref="T:System.Array" /> objects (one contains the keys and the other contains the corresponding items) based on the keys in the first <see cref="T:System.Array" /> using the <see cref="T:System.IComparable`1" /> generic interface implementation of each key.</summary>
		/// <param name="keys">The one-dimensional, zero-based <see cref="T:System.Array" /> that contains the keys to sort.</param>
		/// <param name="items">The one-dimensional, zero-based <see cref="T:System.Array" /> that contains the items that correspond to the keys in <paramref name="keys" />, or <see langword="null" /> to sort only <paramref name="keys" />.</param>
		/// <typeparam name="TKey">The type of the elements of the key array.</typeparam>
		/// <typeparam name="TValue">The type of the elements of the items array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="keys" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="items" /> is not <see langword="null" />, and the lower bound of <paramref name="keys" /> does not match the lower bound of <paramref name="items" />.  
		/// -or-  
		/// <paramref name="items" /> is not <see langword="null" />, and the length of <paramref name="keys" /> is greater than the length of <paramref name="items" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">One or more elements in the <paramref name="keys" /><see cref="T:System.Array" /> do not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x0600039F RID: 927 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600039F")]
		[Address(RVA = "0x19E87A0", Offset = "0x19E75A0", VA = "0x1819E87A0")]
		public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items)
		{
		}

		/// <summary>Sorts a range of elements in a pair of <see cref="T:System.Array" /> objects (one contains the keys and the other contains the corresponding items) based on the keys in the first <see cref="T:System.Array" /> using the <see cref="T:System.IComparable`1" /> generic interface implementation of each key.</summary>
		/// <param name="keys">The one-dimensional, zero-based <see cref="T:System.Array" /> that contains the keys to sort.</param>
		/// <param name="items">The one-dimensional, zero-based <see cref="T:System.Array" /> that contains the items that correspond to the keys in <paramref name="keys" />, or <see langword="null" /> to sort only <paramref name="keys" />.</param>
		/// <param name="index">The starting index of the range to sort.</param>
		/// <param name="length">The number of elements in the range to sort.</param>
		/// <typeparam name="TKey">The type of the elements of the key array.</typeparam>
		/// <typeparam name="TValue">The type of the elements of the items array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="keys" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="keys" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="items" /> is not <see langword="null" />, and the lower bound of <paramref name="keys" /> does not match the lower bound of <paramref name="items" />.  
		/// -or-  
		/// <paramref name="items" /> is not <see langword="null" />, and the length of <paramref name="keys" /> is greater than the length of <paramref name="items" />.  
		/// -or-  
		/// <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in the <paramref name="keys" /><see cref="T:System.Array" />.  
		/// -or-  
		/// <paramref name="items" /> is not <see langword="null" />, and <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in the <paramref name="items" /><see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">One or more elements in the <paramref name="keys" /><see cref="T:System.Array" /> do not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x060003A0 RID: 928 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003A0")]
		[Address(RVA = "0x19E8840", Offset = "0x19E7640", VA = "0x1819E8840")]
		public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, int index, int length)
		{
		}

		/// <summary>Sorts a pair of <see cref="T:System.Array" /> objects (one contains the keys and the other contains the corresponding items) based on the keys in the first <see cref="T:System.Array" /> using the specified <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface.</summary>
		/// <param name="keys">The one-dimensional, zero-based <see cref="T:System.Array" /> that contains the keys to sort.</param>
		/// <param name="items">The one-dimensional, zero-based <see cref="T:System.Array" /> that contains the items that correspond to the keys in <paramref name="keys" />, or <see langword="null" /> to sort only <paramref name="keys" />.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface implementation to use when comparing elements, or <see langword="null" /> to use the <see cref="T:System.IComparable`1" /> generic interface implementation of each element.</param>
		/// <typeparam name="TKey">The type of the elements of the key array.</typeparam>
		/// <typeparam name="TValue">The type of the elements of the items array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="keys" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="items" /> is not <see langword="null" />, and the lower bound of <paramref name="keys" /> does not match the lower bound of <paramref name="items" />.  
		/// -or-  
		/// <paramref name="items" /> is not <see langword="null" />, and the length of <paramref name="keys" /> is greater than the length of <paramref name="items" />.  
		/// -or-  
		/// The implementation of <paramref name="comparer" /> caused an error during the sort. For example, <paramref name="comparer" /> might not return 0 when comparing an item with itself.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and one or more elements in the <paramref name="keys" /><see cref="T:System.Array" /> do not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x060003A1 RID: 929 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003A1")]
		[Address(RVA = "0x19E8A20", Offset = "0x19E7820", VA = "0x1819E8A20")]
		public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, IComparer<TKey> comparer)
		{
		}

		/// <summary>Sorts a range of elements in a pair of <see cref="T:System.Array" /> objects (one contains the keys and the other contains the corresponding items) based on the keys in the first <see cref="T:System.Array" /> using the specified <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface.</summary>
		/// <param name="keys">The one-dimensional, zero-based <see cref="T:System.Array" /> that contains the keys to sort.</param>
		/// <param name="items">The one-dimensional, zero-based <see cref="T:System.Array" /> that contains the items that correspond to the keys in <paramref name="keys" />, or <see langword="null" /> to sort only <paramref name="keys" />.</param>
		/// <param name="index">The starting index of the range to sort.</param>
		/// <param name="length">The number of elements in the range to sort.</param>
		/// <param name="comparer">The <see cref="T:System.Collections.Generic.IComparer`1" /> generic interface implementation to use when comparing elements, or <see langword="null" /> to use the <see cref="T:System.IComparable`1" /> generic interface implementation of each element.</param>
		/// <typeparam name="TKey">The type of the elements of the key array.</typeparam>
		/// <typeparam name="TValue">The type of the elements of the items array.</typeparam>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="keys" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="keys" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="items" /> is not <see langword="null" />, and the lower bound of <paramref name="keys" /> does not match the lower bound of <paramref name="items" />.  
		/// -or-  
		/// <paramref name="items" /> is not <see langword="null" />, and the length of <paramref name="keys" /> is greater than the length of <paramref name="items" />.  
		/// -or-  
		/// <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in the <paramref name="keys" /><see cref="T:System.Array" />.  
		/// -or-  
		/// <paramref name="items" /> is not <see langword="null" />, and <paramref name="index" /> and <paramref name="length" /> do not specify a valid range in the <paramref name="items" /><see cref="T:System.Array" />.  
		/// -or-  
		/// The implementation of <paramref name="comparer" /> caused an error during the sort. For example, <paramref name="comparer" /> might not return 0 when comparing an item with itself.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///   <paramref name="comparer" /> is <see langword="null" />, and one or more elements in the <paramref name="keys" /><see cref="T:System.Array" /> do not implement the <see cref="T:System.IComparable`1" /> generic interface.</exception>
		// Token: 0x060003A2 RID: 930 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003A2")]
		[Address(RVA = "0x19E8870", Offset = "0x19E7670", VA = "0x1819E8870")]
		public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, int index, int length, IComparer<TKey> comparer)
		{
		}

		/// <summary>Determines whether the specified array contains elements that match the conditions defined by the specified predicate.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="match">The <see cref="T:System.Predicate`1" /> that defines the conditions of the elements to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>
		///   <see langword="true" /> if <paramref name="array" /> contains one or more elements that match the conditions defined by the specified predicate; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		// Token: 0x060003A3 RID: 931 RVA: 0x00003BD0 File Offset: 0x00001DD0
		[Token(Token = "0x60003A3")]
		[Address(RVA = "0x1D692A0", Offset = "0x1D680A0", VA = "0x181D692A0")]
		public static bool Exists<T>(T[] array, Predicate<T> match)
		{
			return default(bool);
		}

		// Token: 0x060003A4 RID: 932 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003A4")]
		[Address(RVA = "0x1694D30", Offset = "0x1693B30", VA = "0x181694D30")]
		public static void Fill<T>(T[] array, T value)
		{
		}

		// Token: 0x060003A5 RID: 933 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003A5")]
		[Address(RVA = "0x1694DD0", Offset = "0x1693BD0", VA = "0x181694DD0")]
		public static void Fill<T>(T[] array, T value, int startIndex, int count)
		{
		}

		/// <summary>Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional, zero-based array to search.</param>
		/// <param name="match">The predicate that defines the conditions of the element to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type <paramref name="T" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		// Token: 0x060003A6 RID: 934 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003A6")]
		[Address(RVA = "0x15F5AD0", Offset = "0x15F48D0", VA = "0x1815F5AD0")]
		public static T Find<T>(T[] array, Predicate<T> match)
		{
			return null;
		}

		/// <summary>Retrieves all the elements that match the conditions defined by the specified predicate.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="match">The <see cref="T:System.Predicate`1" /> that defines the conditions of the elements to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>An <see cref="T:System.Array" /> containing all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty <see cref="T:System.Array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		// Token: 0x060003A7 RID: 935 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003A7")]
		[Address(RVA = "0x2382B10", Offset = "0x2381910", VA = "0x182382B10")]
		public static T[] FindAll<T>(T[] array, Predicate<T> match)
		{
			return null;
		}

		/// <summary>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="match">The <see cref="T:System.Predicate`1" /> that defines the conditions of the element to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		// Token: 0x060003A8 RID: 936 RVA: 0x00003BE8 File Offset: 0x00001DE8
		[Token(Token = "0x60003A8")]
		[Address(RVA = "0x22FD370", Offset = "0x22FC170", VA = "0x1822FD370")]
		public static int FindIndex<T>(T[] array, Predicate<T> match)
		{
			return 0;
		}

		/// <summary>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the <see cref="T:System.Array" /> that extends from the specified index to the last element.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="startIndex">The zero-based starting index of the search.</param>
		/// <param name="match">The <see cref="T:System.Predicate`1" /> that defines the conditions of the element to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.</exception>
		// Token: 0x060003A9 RID: 937 RVA: 0x00003C00 File Offset: 0x00001E00
		[Token(Token = "0x60003A9")]
		[Address(RVA = "0x22FD5E0", Offset = "0x22FC3E0", VA = "0x1822FD5E0")]
		public static int FindIndex<T>(T[] array, int startIndex, Predicate<T> match)
		{
			return 0;
		}

		/// <summary>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the <see cref="T:System.Array" /> that starts at the specified index and contains the specified number of elements.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="startIndex">The zero-based starting index of the search.</param>
		/// <param name="count">The number of elements in the section to search.</param>
		/// <param name="match">The <see cref="T:System.Predicate`1" /> that defines the conditions of the element to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.  
		/// -or-  
		/// <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="startIndex" /> and <paramref name="count" /> do not specify a valid section in <paramref name="array" />.</exception>
		// Token: 0x060003AA RID: 938 RVA: 0x00003C18 File Offset: 0x00001E18
		[Token(Token = "0x60003AA")]
		[Address(RVA = "0x22FD410", Offset = "0x22FC210", VA = "0x1822FD410")]
		public static int FindIndex<T>(T[] array, int startIndex, int count, Predicate<T> match)
		{
			return 0;
		}

		/// <summary>Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="match">The <see cref="T:System.Predicate`1" /> that defines the conditions of the element to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The last element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type <paramref name="T" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		// Token: 0x060003AB RID: 939 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003AB")]
		[Address(RVA = "0x15F59A0", Offset = "0x15F47A0", VA = "0x1815F59A0")]
		public static T FindLast<T>(T[] array, Predicate<T> match)
		{
			return null;
		}

		/// <summary>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire <see cref="T:System.Array" />.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="match">The <see cref="T:System.Predicate`1" /> that defines the conditions of the element to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the last occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		// Token: 0x060003AC RID: 940 RVA: 0x00003C30 File Offset: 0x00001E30
		[Token(Token = "0x60003AC")]
		[Address(RVA = "0x22FDAE0", Offset = "0x22FC8E0", VA = "0x1822FDAE0")]
		public static int FindLastIndex<T>(T[] array, Predicate<T> match)
		{
			return 0;
		}

		/// <summary>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the <see cref="T:System.Array" /> that extends from the first element to the specified index.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="startIndex">The zero-based starting index of the backward search.</param>
		/// <param name="match">The <see cref="T:System.Predicate`1" /> that defines the conditions of the element to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the last occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.</exception>
		// Token: 0x060003AD RID: 941 RVA: 0x00003C48 File Offset: 0x00001E48
		[Token(Token = "0x60003AD")]
		[Address(RVA = "0x22FDB80", Offset = "0x22FC980", VA = "0x1822FDB80")]
		public static int FindLastIndex<T>(T[] array, int startIndex, Predicate<T> match)
		{
			return 0;
		}

		/// <summary>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the <see cref="T:System.Array" /> that contains the specified number of elements and ends at the specified index.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to search.</param>
		/// <param name="startIndex">The zero-based starting index of the backward search.</param>
		/// <param name="count">The number of elements in the section to search.</param>
		/// <param name="match">The <see cref="T:System.Predicate`1" /> that defines the conditions of the element to search for.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>The zero-based index of the last occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="startIndex" /> is outside the range of valid indexes for <paramref name="array" />.  
		/// -or-  
		/// <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="startIndex" /> and <paramref name="count" /> do not specify a valid section in <paramref name="array" />.</exception>
		// Token: 0x060003AE RID: 942 RVA: 0x00003C60 File Offset: 0x00001E60
		[Token(Token = "0x60003AE")]
		[Address(RVA = "0x22FD8E0", Offset = "0x22FC6E0", VA = "0x1822FD8E0")]
		public static int FindLastIndex<T>(T[] array, int startIndex, int count, Predicate<T> match)
		{
			return 0;
		}

		/// <summary>Determines whether every element in the array matches the conditions defined by the specified predicate.</summary>
		/// <param name="array">The one-dimensional, zero-based <see cref="T:System.Array" /> to check against the conditions.</param>
		/// <param name="match">The predicate that defines the conditions to check against the elements.</param>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>
		///   <see langword="true" /> if every element in <paramref name="array" /> matches the conditions defined by the specified predicate; otherwise, <see langword="false" />. If there are no elements in the array, the return value is <see langword="true" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="match" /> is <see langword="null" />.</exception>
		// Token: 0x060003AF RID: 943 RVA: 0x00003C78 File Offset: 0x00001E78
		[Token(Token = "0x60003AF")]
		[Address(RVA = "0x1902030", Offset = "0x1900E30", VA = "0x181902030")]
		public static bool TrueForAll<T>(T[] array, Predicate<T> match)
		{
			return default(bool);
		}

		/// <summary>Returns an <see cref="T:System.Collections.IEnumerator" /> for the <see cref="T:System.Array" />.</summary>
		/// <returns>An <see cref="T:System.Collections.IEnumerator" /> for the <see cref="T:System.Array" />.</returns>
		// Token: 0x060003B0 RID: 944 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003B0")]
		[Address(RVA = "0x26C1AE0", Offset = "0x26C08E0", VA = "0x1826C1AE0", Slot = "8")]
		public IEnumerator GetEnumerator()
		{
			return null;
		}

		// Token: 0x060003B1 RID: 945 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003B1")]
		[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
		private Array()
		{
		}

		// Token: 0x060003B2 RID: 946 RVA: 0x00003C90 File Offset: 0x00001E90
		[Token(Token = "0x60003B2")]
		[Address(RVA = "0x26C2910", Offset = "0x26C1710", VA = "0x1826C2910")]
		internal int InternalArray__ICollection_get_Count()
		{
			return 0;
		}

		// Token: 0x060003B3 RID: 947 RVA: 0x00003CA8 File Offset: 0x00001EA8
		[Token(Token = "0x60003B3")]
		[Address(RVA = "0x460D40", Offset = "0x45FB40", VA = "0x180460D40")]
		internal bool InternalArray__ICollection_get_IsReadOnly()
		{
			return default(bool);
		}

		// Token: 0x060003B4 RID: 948 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003B4")]
		[Address(RVA = "0x11B8B20", Offset = "0x11B7920", VA = "0x1811B8B20")]
		internal IEnumerator<T> InternalArray__IEnumerable_GetEnumerator<T>()
		{
			return null;
		}

		// Token: 0x060003B5 RID: 949 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003B5")]
		[Address(RVA = "0x26C28B0", Offset = "0x26C16B0", VA = "0x1826C28B0")]
		internal void InternalArray__ICollection_Clear()
		{
		}

		// Token: 0x060003B6 RID: 950 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003B6")]
		[Address(RVA = "0x1695A90", Offset = "0x1694890", VA = "0x181695A90")]
		internal void InternalArray__ICollection_Add<T>(T item)
		{
		}

		// Token: 0x060003B7 RID: 951 RVA: 0x00003CC0 File Offset: 0x00001EC0
		[Token(Token = "0x60003B7")]
		[Address(RVA = "0x1613470", Offset = "0x1612270", VA = "0x181613470")]
		internal bool InternalArray__ICollection_Remove<T>(T item)
		{
			return default(bool);
		}

		// Token: 0x060003B8 RID: 952 RVA: 0x00003CD8 File Offset: 0x00001ED8
		[Token(Token = "0x60003B8")]
		[Address(RVA = "0x1D6AAC0", Offset = "0x1D698C0", VA = "0x181D6AAC0")]
		internal bool InternalArray__ICollection_Contains<T>(T item)
		{
			return default(bool);
		}

		// Token: 0x060003B9 RID: 953 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003B9")]
		[Address(RVA = "0xBB1750", Offset = "0xBB0550", VA = "0x180BB1750")]
		internal void InternalArray__ICollection_CopyTo<T>(T[] array, int arrayIndex)
		{
		}

		// Token: 0x060003BA RID: 954 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003BA")]
		[Address(RVA = "0x15F9C60", Offset = "0x15F8A60", VA = "0x1815F9C60")]
		internal T InternalArray__IReadOnlyList_get_Item<T>(int index)
		{
			return null;
		}

		// Token: 0x060003BB RID: 955 RVA: 0x00003CF0 File Offset: 0x00001EF0
		[Token(Token = "0x60003BB")]
		[Address(RVA = "0x26C2910", Offset = "0x26C1710", VA = "0x1826C2910")]
		internal int InternalArray__IReadOnlyCollection_get_Count()
		{
			return 0;
		}

		// Token: 0x060003BC RID: 956 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003BC")]
		[Address(RVA = "0x10BDB30", Offset = "0x10BC930", VA = "0x1810BDB30")]
		internal void InternalArray__Insert<T>(int index, T item)
		{
		}

		// Token: 0x060003BD RID: 957 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003BD")]
		[Address(RVA = "0x26C2970", Offset = "0x26C1770", VA = "0x1826C2970")]
		internal void InternalArray__RemoveAt(int index)
		{
		}

		// Token: 0x060003BE RID: 958 RVA: 0x00003D08 File Offset: 0x00001F08
		[Token(Token = "0x60003BE")]
		[Address(RVA = "0x163F620", Offset = "0x163E420", VA = "0x18163F620")]
		internal int InternalArray__IndexOf<T>(T item)
		{
			return 0;
		}

		// Token: 0x060003BF RID: 959 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003BF")]
		[Address(RVA = "0x18422F0", Offset = "0x18410F0", VA = "0x1818422F0")]
		internal T InternalArray__get_Item<T>(int index)
		{
			return null;
		}

		// Token: 0x060003C0 RID: 960 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003C0")]
		[Address(RVA = "0x1709340", Offset = "0x1708140", VA = "0x181709340")]
		internal void InternalArray__set_Item<T>(int index, T item)
		{
		}

		// Token: 0x060003C1 RID: 961 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003C1")]
		internal void GetGenericValueImpl<T>(int pos, out T value)
		{
		}

		// Token: 0x060003C2 RID: 962 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003C2")]
		internal void SetGenericValueImpl<T>(int pos, ref T value)
		{
		}

		/// <summary>Gets the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary>
		/// <returns>The total number of elements in all the dimensions of the <see cref="T:System.Array" />; zero if there are no elements in the array.</returns>
		/// <exception cref="T:System.OverflowException">The array is multidimensional and contains more than <see cref="F:System.Int32.MaxValue" /> elements.</exception>
		// Token: 0x17000070 RID: 112
		// (get) Token: 0x060003C3 RID: 963 RVA: 0x00003D20 File Offset: 0x00001F20
		[Token(Token = "0x17000070")]
		public int Length
		{
			[Token(Token = "0x60003C3")]
			[Address(RVA = "0x26C2910", Offset = "0x26C1710", VA = "0x1826C2910")]
			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
			get
			{
				return 0;
			}
		}

		/// <summary>Gets the rank (number of dimensions) of the <see cref="T:System.Array" />. For example, a one-dimensional array returns 1, a two-dimensional array returns 2, and so on.</summary>
		/// <returns>The rank (number of dimensions) of the <see cref="T:System.Array" />.</returns>
		// Token: 0x17000071 RID: 113
		// (get) Token: 0x060003C4 RID: 964 RVA: 0x00003D38 File Offset: 0x00001F38
		[Token(Token = "0x17000071")]
		public int Rank
		{
			[Token(Token = "0x60003C4")]
			[Address(RVA = "0x26C1BE0", Offset = "0x26C09E0", VA = "0x1826C1BE0")]
			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
			get
			{
				return 0;
			}
		}

		// Token: 0x060003C5 RID: 965 RVA: 0x00003D50 File Offset: 0x00001F50
		[Token(Token = "0x60003C5")]
		[Address(RVA = "0x26C1BE0", Offset = "0x26C09E0", VA = "0x1826C1BE0")]
		private int GetRank()
		{
			return 0;
		}

		/// <summary>Gets a 32-bit integer that represents the number of elements in the specified dimension of the <see cref="T:System.Array" />.</summary>
		/// <param name="dimension">A zero-based dimension of the <see cref="T:System.Array" /> whose length needs to be determined.</param>
		/// <returns>A 32-bit integer that represents the number of elements in the specified dimension.</returns>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="dimension" /> is less than zero.  
		/// -or-  
		/// <paramref name="dimension" /> is equal to or greater than <see cref="P:System.Array.Rank" />.</exception>
		// Token: 0x060003C6 RID: 966 RVA: 0x00003D68 File Offset: 0x00001F68
		[Token(Token = "0x60003C6")]
		[Address(RVA = "0x26C1BA0", Offset = "0x26C09A0", VA = "0x1826C1BA0")]
		public int GetLength(int dimension)
		{
			return 0;
		}

		/// <summary>Gets the index of the first element of the specified dimension in the array.</summary>
		/// <param name="dimension">A zero-based dimension of the array whose starting index needs to be determined.</param>
		/// <returns>The index of the first element of the specified dimension in the array.</returns>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="dimension" /> is less than zero.  
		/// -or-  
		/// <paramref name="dimension" /> is equal to or greater than <see cref="P:System.Array.Rank" />.</exception>
		// Token: 0x060003C7 RID: 967 RVA: 0x00003D80 File Offset: 0x00001F80
		[Token(Token = "0x60003C7")]
		[Address(RVA = "0x26C1BC0", Offset = "0x26C09C0", VA = "0x1826C1BC0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public int GetLowerBound(int dimension)
		{
			return 0;
		}

		/// <summary>Gets the value at the specified position in the multidimensional <see cref="T:System.Array" />. The indexes are specified as an array of 32-bit integers.</summary>
		/// <param name="indices">A one-dimensional array of 32-bit integers that represent the indexes specifying the position of the <see cref="T:System.Array" /> element to get.</param>
		/// <returns>The value at the specified position in the multidimensional <see cref="T:System.Array" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="indices" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">The number of dimensions in the current <see cref="T:System.Array" /> is not equal to the number of elements in <paramref name="indices" />.</exception>
		/// <exception cref="T:System.IndexOutOfRangeException">Any element in <paramref name="indices" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x060003C8 RID: 968 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003C8")]
		[Address(RVA = "0x26C1C40", Offset = "0x26C0A40", VA = "0x1826C1C40")]
		public object GetValue(params int[] indices)
		{
			return null;
		}

		/// <summary>Sets a value to the element at the specified position in the multidimensional <see cref="T:System.Array" />. The indexes are specified as an array of 32-bit integers.</summary>
		/// <param name="value">The new value for the specified element.</param>
		/// <param name="indices">A one-dimensional array of 32-bit integers that represent the indexes specifying the position of the element to set.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="indices" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">The number of dimensions in the current <see cref="T:System.Array" /> is not equal to the number of elements in <paramref name="indices" />.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> cannot be cast to the element type of the current <see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.IndexOutOfRangeException">Any element in <paramref name="indices" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x060003C9 RID: 969 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003C9")]
		[Address(RVA = "0x26C3250", Offset = "0x26C2050", VA = "0x1826C3250")]
		public void SetValue(object value, params int[] indices)
		{
		}

		// Token: 0x060003CA RID: 970 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003CA")]
		[Address(RVA = "0x26C1C30", Offset = "0x26C0A30", VA = "0x1826C1C30")]
		internal object GetValueImpl(int pos)
		{
			return null;
		}

		// Token: 0x060003CB RID: 971 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003CB")]
		[Address(RVA = "0x26C3240", Offset = "0x26C2040", VA = "0x1826C3240")]
		internal void SetValueImpl(object value, int pos)
		{
		}

		// Token: 0x060003CC RID: 972 RVA: 0x00003D98 File Offset: 0x00001F98
		[Token(Token = "0x60003CC")]
		[Address(RVA = "0x26C1AD0", Offset = "0x26C08D0", VA = "0x1826C1AD0")]
		internal static bool FastCopy(Array source, int source_idx, Array dest, int dest_idx, int length)
		{
			return default(bool);
		}

		// Token: 0x060003CD RID: 973 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003CD")]
		[Address(RVA = "0x26C1070", Offset = "0x26BFE70", VA = "0x1826C1070")]
		internal static Array CreateInstanceImpl(Type elementType, int[] lengths, int[] bounds)
		{
			return null;
		}

		/// <summary>Gets the index of the last element of the specified dimension in the array.</summary>
		/// <param name="dimension">A zero-based dimension of the array whose upper bound needs to be determined.</param>
		/// <returns>The index of the last element of the specified dimension in the array, or -1 if the specified dimension is empty.</returns>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="dimension" /> is less than zero.  
		/// -or-  
		/// <paramref name="dimension" /> is equal to or greater than <see cref="P:System.Array.Rank" />.</exception>
		// Token: 0x060003CE RID: 974 RVA: 0x00003DB0 File Offset: 0x00001FB0
		[Token(Token = "0x60003CE")]
		[Address(RVA = "0x26C1BF0", Offset = "0x26C09F0", VA = "0x1826C1BF0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public int GetUpperBound(int dimension)
		{
			return 0;
		}

		/// <summary>Gets the value at the specified position in the one-dimensional <see cref="T:System.Array" />. The index is specified as a 32-bit integer.</summary>
		/// <param name="index">A 32-bit integer that represents the position of the <see cref="T:System.Array" /> element to get.</param>
		/// <returns>The value at the specified position in the one-dimensional <see cref="T:System.Array" />.</returns>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly one dimension.</exception>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="index" /> is outside the range of valid indexes for the current <see cref="T:System.Array" />.</exception>
		// Token: 0x060003CF RID: 975 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003CF")]
		[Address(RVA = "0x26C1F80", Offset = "0x26C0D80", VA = "0x1826C1F80")]
		public object GetValue(int index)
		{
			return null;
		}

		/// <summary>Gets the value at the specified position in the two-dimensional <see cref="T:System.Array" />. The indexes are specified as 32-bit integers.</summary>
		/// <param name="index1">A 32-bit integer that represents the first-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <param name="index2">A 32-bit integer that represents the second-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <returns>The value at the specified position in the two-dimensional <see cref="T:System.Array" />.</returns>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly two dimensions.</exception>
		/// <exception cref="T:System.IndexOutOfRangeException">Either <paramref name="index1" /> or <paramref name="index2" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x060003D0 RID: 976 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003D0")]
		[Address(RVA = "0x26C2250", Offset = "0x26C1050", VA = "0x1826C2250")]
		public object GetValue(int index1, int index2)
		{
			return null;
		}

		/// <summary>Gets the value at the specified position in the three-dimensional <see cref="T:System.Array" />. The indexes are specified as 32-bit integers.</summary>
		/// <param name="index1">A 32-bit integer that represents the first-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <param name="index2">A 32-bit integer that represents the second-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <param name="index3">A 32-bit integer that represents the third-dimension index of the <see cref="T:System.Array" /> element to get.</param>
		/// <returns>The value at the specified position in the three-dimensional <see cref="T:System.Array" />.</returns>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly three dimensions.</exception>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="index1" /> or <paramref name="index2" /> or <paramref name="index3" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x060003D1 RID: 977 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003D1")]
		[Address(RVA = "0x26C2100", Offset = "0x26C0F00", VA = "0x1826C2100")]
		public object GetValue(int index1, int index2, int index3)
		{
			return null;
		}

		/// <summary>Sets a value to the element at the specified position in the one-dimensional <see cref="T:System.Array" />. The index is specified as a 32-bit integer.</summary>
		/// <param name="value">The new value for the specified element.</param>
		/// <param name="index">A 32-bit integer that represents the position of the <see cref="T:System.Array" /> element to set.</param>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly one dimension.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> cannot be cast to the element type of the current <see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="index" /> is outside the range of valid indexes for the current <see cref="T:System.Array" />.</exception>
		// Token: 0x060003D2 RID: 978 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003D2")]
		[Address(RVA = "0x26C34B0", Offset = "0x26C22B0", VA = "0x1826C34B0")]
		public void SetValue(object value, int index)
		{
		}

		/// <summary>Sets a value to the element at the specified position in the two-dimensional <see cref="T:System.Array" />. The indexes are specified as 32-bit integers.</summary>
		/// <param name="value">The new value for the specified element.</param>
		/// <param name="index1">A 32-bit integer that represents the first-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <param name="index2">A 32-bit integer that represents the second-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly two dimensions.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> cannot be cast to the element type of the current <see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.IndexOutOfRangeException">Either <paramref name="index1" /> or <paramref name="index2" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x060003D3 RID: 979 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003D3")]
		[Address(RVA = "0x26C3A30", Offset = "0x26C2830", VA = "0x1826C3A30")]
		public void SetValue(object value, int index1, int index2)
		{
		}

		/// <summary>Sets a value to the element at the specified position in the three-dimensional <see cref="T:System.Array" />. The indexes are specified as 32-bit integers.</summary>
		/// <param name="value">The new value for the specified element.</param>
		/// <param name="index1">A 32-bit integer that represents the first-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <param name="index2">A 32-bit integer that represents the second-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <param name="index3">A 32-bit integer that represents the third-dimension index of the <see cref="T:System.Array" /> element to set.</param>
		/// <exception cref="T:System.ArgumentException">The current <see cref="T:System.Array" /> does not have exactly three dimensions.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> cannot be cast to the element type of the current <see cref="T:System.Array" />.</exception>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="index1" /> or <paramref name="index2" /> or <paramref name="index3" /> is outside the range of valid indexes for the corresponding dimension of the current <see cref="T:System.Array" />.</exception>
		// Token: 0x060003D4 RID: 980 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003D4")]
		[Address(RVA = "0x26C33E0", Offset = "0x26C21E0", VA = "0x1826C33E0")]
		public void SetValue(object value, int index1, int index2, int index3)
		{
		}

		// Token: 0x060003D5 RID: 981 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003D5")]
		[Address(RVA = "0x26C4D90", Offset = "0x26C3B90", VA = "0x1826C4D90")]
		internal static Array UnsafeCreateInstance(Type elementType, int[] lengths, int[] lowerBounds)
		{
			return null;
		}

		// Token: 0x060003D6 RID: 982 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003D6")]
		[Address(RVA = "0x26C11F0", Offset = "0x26BFFF0", VA = "0x1826C11F0")]
		internal static Array UnsafeCreateInstance(Type elementType, int length1, int length2)
		{
			return null;
		}

		// Token: 0x060003D7 RID: 983 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003D7")]
		[Address(RVA = "0x26C4DA0", Offset = "0x26C3BA0", VA = "0x1826C4DA0")]
		internal static Array UnsafeCreateInstance(Type elementType, params int[] lengths)
		{
			return null;
		}

		/// <summary>Creates a one-dimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> and length, with zero-based indexing.</summary>
		/// <param name="elementType">The <see cref="T:System.Type" /> of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="length">The size of the <see cref="T:System.Array" /> to create.</param>
		/// <returns>A new one-dimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> with the specified length, using zero-based indexing.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="elementType" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="elementType" /> is not a valid <see cref="T:System.Type" />.</exception>
		/// <exception cref="T:System.NotSupportedException">
		///   <paramref name="elementType" /> is not supported. For example, <see cref="T:System.Void" /> is not supported.  
		/// -or-  
		/// <paramref name="elementType" /> is an open generic type.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="length" /> is less than zero.</exception>
		// Token: 0x060003D8 RID: 984 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003D8")]
		[Address(RVA = "0x26C1A50", Offset = "0x26C0850", VA = "0x1826C1A50")]
		public static Array CreateInstance(Type elementType, int length)
		{
			return null;
		}

		/// <summary>Creates a two-dimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> and dimension lengths, with zero-based indexing.</summary>
		/// <param name="elementType">The <see cref="T:System.Type" /> of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="length1">The size of the first dimension of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="length2">The size of the second dimension of the <see cref="T:System.Array" /> to create.</param>
		/// <returns>A new two-dimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> with the specified length for each dimension, using zero-based indexing.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="elementType" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="elementType" /> is not a valid <see cref="T:System.Type" />.</exception>
		/// <exception cref="T:System.NotSupportedException">
		///   <paramref name="elementType" /> is not supported. For example, <see cref="T:System.Void" /> is not supported.  
		/// -or-  
		/// <paramref name="elementType" /> is an open generic type.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="length1" /> is less than zero.  
		/// -or-  
		/// <paramref name="length2" /> is less than zero.</exception>
		// Token: 0x060003D9 RID: 985 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003D9")]
		[Address(RVA = "0x26C11F0", Offset = "0x26BFFF0", VA = "0x1826C11F0")]
		public static Array CreateInstance(Type elementType, int length1, int length2)
		{
			return null;
		}

		/// <summary>Creates a three-dimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> and dimension lengths, with zero-based indexing.</summary>
		/// <param name="elementType">The <see cref="T:System.Type" /> of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="length1">The size of the first dimension of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="length2">The size of the second dimension of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="length3">The size of the third dimension of the <see cref="T:System.Array" /> to create.</param>
		/// <returns>A new three-dimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> with the specified length for each dimension, using zero-based indexing.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="elementType" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="elementType" /> is not a valid <see cref="T:System.Type" />.</exception>
		/// <exception cref="T:System.NotSupportedException">
		///   <paramref name="elementType" /> is not supported. For example, <see cref="T:System.Void" /> is not supported.  
		/// -or-  
		/// <paramref name="elementType" /> is an open generic type.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="length1" /> is less than zero.  
		/// -or-  
		/// <paramref name="length2" /> is less than zero.  
		/// -or-  
		/// <paramref name="length3" /> is less than zero.</exception>
		// Token: 0x060003DA RID: 986 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003DA")]
		[Address(RVA = "0x26C16F0", Offset = "0x26C04F0", VA = "0x1826C16F0")]
		public static Array CreateInstance(Type elementType, int length1, int length2, int length3)
		{
			return null;
		}

		/// <summary>Creates a multidimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> and dimension lengths, with zero-based indexing. The dimension lengths are specified in an array of 32-bit integers.</summary>
		/// <param name="elementType">The <see cref="T:System.Type" /> of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="lengths">An array of 32-bit integers that represent the size of each dimension of the <see cref="T:System.Array" /> to create.</param>
		/// <returns>A new multidimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> with the specified length for each dimension, using zero-based indexing.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="elementType" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="lengths" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="elementType" /> is not a valid <see cref="T:System.Type" />.  
		/// -or-  
		/// The <paramref name="lengths" /> array contains less than one element.</exception>
		/// <exception cref="T:System.NotSupportedException">
		///   <paramref name="elementType" /> is not supported. For example, <see cref="T:System.Void" /> is not supported.  
		/// -or-  
		/// <paramref name="elementType" /> is an open generic type.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">Any value in <paramref name="lengths" /> is less than zero.</exception>
		// Token: 0x060003DB RID: 987 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003DB")]
		[Address(RVA = "0x26C17C0", Offset = "0x26C05C0", VA = "0x1826C17C0")]
		public static Array CreateInstance(Type elementType, params int[] lengths)
		{
			return null;
		}

		/// <summary>Creates a multidimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> and dimension lengths, with the specified lower bounds.</summary>
		/// <param name="elementType">The <see cref="T:System.Type" /> of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="lengths">A one-dimensional array that contains the size of each dimension of the <see cref="T:System.Array" /> to create.</param>
		/// <param name="lowerBounds">A one-dimensional array that contains the lower bound (starting index) of each dimension of the <see cref="T:System.Array" /> to create.</param>
		/// <returns>A new multidimensional <see cref="T:System.Array" /> of the specified <see cref="T:System.Type" /> with the specified length and lower bound for each dimension.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="elementType" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="lengths" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="lowerBounds" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="elementType" /> is not a valid <see cref="T:System.Type" />.  
		/// -or-  
		/// The <paramref name="lengths" /> array contains less than one element.  
		/// -or-  
		/// The <paramref name="lengths" /> and <paramref name="lowerBounds" /> arrays do not contain the same number of elements.</exception>
		/// <exception cref="T:System.NotSupportedException">
		///   <paramref name="elementType" /> is not supported. For example, <see cref="T:System.Void" /> is not supported.  
		/// -or-  
		/// <paramref name="elementType" /> is an open generic type.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">Any value in <paramref name="lengths" /> is less than zero.  
		///  -or-  
		///  Any value in <paramref name="lowerBounds" /> is very large, such that the sum of a dimension's lower bound and length is greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x060003DC RID: 988 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003DC")]
		[Address(RVA = "0x26C1290", Offset = "0x26C0090", VA = "0x1826C1290")]
		public static Array CreateInstance(Type elementType, int[] lengths, int[] lowerBounds)
		{
			return null;
		}

		/// <summary>Sets a range of elements in an array to the default value of each element type.</summary>
		/// <param name="array">The array whose elements need to be cleared.</param>
		/// <param name="index">The starting index of the range of elements to clear.</param>
		/// <param name="length">The number of elements to clear.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="array" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="index" /> is less than the lower bound of <paramref name="array" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.  
		/// -or-  
		/// The sum of <paramref name="index" /> and <paramref name="length" /> is greater than the size of <paramref name="array" />.</exception>
		// Token: 0x060003DD RID: 989 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003DD")]
		[Address(RVA = "0x26C0470", Offset = "0x26BF270", VA = "0x1826C0470")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static void Clear(Array array, int index, int length)
		{
		}

		// Token: 0x060003DE RID: 990 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003DE")]
		[Address(RVA = "0x26C0460", Offset = "0x26BF260", VA = "0x1826C0460")]
		private static void ClearInternal(Array a, int index, int count)
		{
		}

		/// <summary>Copies a range of elements from an <see cref="T:System.Array" /> starting at the first element and pastes them into another <see cref="T:System.Array" /> starting at the first element. The length is specified as a 32-bit integer.</summary>
		/// <param name="sourceArray">The <see cref="T:System.Array" /> that contains the data to copy.</param>
		/// <param name="destinationArray">The <see cref="T:System.Array" /> that receives the data.</param>
		/// <param name="length">A 32-bit integer that represents the number of elements to copy.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="sourceArray" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="destinationArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="sourceArray" /> and <paramref name="destinationArray" /> have different ranks.</exception>
		/// <exception cref="T:System.ArrayTypeMismatchException">
		///   <paramref name="sourceArray" /> and <paramref name="destinationArray" /> are of incompatible types.</exception>
		/// <exception cref="T:System.InvalidCastException">At least one element in <paramref name="sourceArray" /> cannot be cast to the type of <paramref name="destinationArray" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="length" /> is greater than the number of elements in <paramref name="sourceArray" />.  
		/// -or-  
		/// <paramref name="length" /> is greater than the number of elements in <paramref name="destinationArray" />.</exception>
		// Token: 0x060003DF RID: 991 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003DF")]
		[Address(RVA = "0x26C0900", Offset = "0x26BF700", VA = "0x1826C0900")]
		[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
		public static void Copy(Array sourceArray, Array destinationArray, int length)
		{
		}

		/// <summary>Copies a range of elements from an <see cref="T:System.Array" /> starting at the specified source index and pastes them to another <see cref="T:System.Array" /> starting at the specified destination index. The length and the indexes are specified as 32-bit integers.</summary>
		/// <param name="sourceArray">The <see cref="T:System.Array" /> that contains the data to copy.</param>
		/// <param name="sourceIndex">A 32-bit integer that represents the index in the <paramref name="sourceArray" /> at which copying begins.</param>
		/// <param name="destinationArray">The <see cref="T:System.Array" /> that receives the data.</param>
		/// <param name="destinationIndex">A 32-bit integer that represents the index in the <paramref name="destinationArray" /> at which storing begins.</param>
		/// <param name="length">A 32-bit integer that represents the number of elements to copy.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="sourceArray" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="destinationArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="sourceArray" /> and <paramref name="destinationArray" /> have different ranks.</exception>
		/// <exception cref="T:System.ArrayTypeMismatchException">
		///   <paramref name="sourceArray" /> and <paramref name="destinationArray" /> are of incompatible types.</exception>
		/// <exception cref="T:System.InvalidCastException">At least one element in <paramref name="sourceArray" /> cannot be cast to the type of <paramref name="destinationArray" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="sourceIndex" /> is less than the lower bound of the first dimension of <paramref name="sourceArray" />.  
		/// -or-  
		/// <paramref name="destinationIndex" /> is less than the lower bound of the first dimension of <paramref name="destinationArray" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="length" /> is greater than the number of elements from <paramref name="sourceIndex" /> to the end of <paramref name="sourceArray" />.  
		/// -or-  
		/// <paramref name="length" /> is greater than the number of elements from <paramref name="destinationIndex" /> to the end of <paramref name="destinationArray" />.</exception>
		// Token: 0x060003E0 RID: 992 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003E0")]
		[Address(RVA = "0x26C09F0", Offset = "0x26BF7F0", VA = "0x1826C09F0")]
		[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
		public static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
		{
		}

		// Token: 0x060003E1 RID: 993 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003E1")]
		[Address(RVA = "0x26C0FF0", Offset = "0x26BFDF0", VA = "0x1826C0FF0")]
		private static Exception CreateArrayTypeMismatchException()
		{
			return null;
		}

		// Token: 0x060003E2 RID: 994 RVA: 0x00003DC8 File Offset: 0x00001FC8
		[Token(Token = "0x60003E2")]
		[Address(RVA = "0x26C0390", Offset = "0x26BF190", VA = "0x1826C0390")]
		private static bool CanAssignArrayElement(Type source, Type target)
		{
			return default(bool);
		}

		/// <summary>Copies a range of elements from an <see cref="T:System.Array" /> starting at the specified source index and pastes them to another <see cref="T:System.Array" /> starting at the specified destination index.  Guarantees that all changes are undone if the copy does not succeed completely.</summary>
		/// <param name="sourceArray">The <see cref="T:System.Array" /> that contains the data to copy.</param>
		/// <param name="sourceIndex">A 32-bit integer that represents the index in the <paramref name="sourceArray" /> at which copying begins.</param>
		/// <param name="destinationArray">The <see cref="T:System.Array" /> that receives the data.</param>
		/// <param name="destinationIndex">A 32-bit integer that represents the index in the <paramref name="destinationArray" /> at which storing begins.</param>
		/// <param name="length">A 32-bit integer that represents the number of elements to copy.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="sourceArray" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="destinationArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.RankException">
		///   <paramref name="sourceArray" /> and <paramref name="destinationArray" /> have different ranks.</exception>
		/// <exception cref="T:System.ArrayTypeMismatchException">The <paramref name="sourceArray" /> type is neither the same as nor derived from the <paramref name="destinationArray" /> type.</exception>
		/// <exception cref="T:System.InvalidCastException">At least one element in <paramref name="sourceArray" /> cannot be cast to the type of <paramref name="destinationArray" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="sourceIndex" /> is less than the lower bound of the first dimension of <paramref name="sourceArray" />.  
		/// -or-  
		/// <paramref name="destinationIndex" /> is less than the lower bound of the first dimension of <paramref name="destinationArray" />.  
		/// -or-  
		/// <paramref name="length" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="length" /> is greater than the number of elements from <paramref name="sourceIndex" /> to the end of <paramref name="sourceArray" />.  
		/// -or-  
		/// <paramref name="length" /> is greater than the number of elements from <paramref name="destinationIndex" /> to the end of <paramref name="destinationArray" />.</exception>
		// Token: 0x060003E3 RID: 995 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003E3")]
		[Address(RVA = "0x26C05D0", Offset = "0x26BF3D0", VA = "0x1826C05D0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static void ConstrainedCopy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
		{
		}

		/// <summary>Returns an empty array.</summary>
		/// <typeparam name="T">The type of the elements of the array.</typeparam>
		/// <returns>An empty array.</returns>
		// Token: 0x060003E4 RID: 996 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003E4")]
		[Address(RVA = "0x3F5110", Offset = "0x3F3F10", VA = "0x1803F5110")]
		public static T[] Empty<T>()
		{
			return null;
		}

		/// <summary>Initializes every element of the value-type <see cref="T:System.Array" /> by calling the default constructor of the value type.</summary>
		// Token: 0x060003E5 RID: 997 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003E5")]
		[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080")]
		public void Initialize()
		{
		}

		// Token: 0x060003E6 RID: 998 RVA: 0x00003DE0 File Offset: 0x00001FE0
		[Token(Token = "0x60003E6")]
		[Address(RVA = "0x163AC70", Offset = "0x1639A70", VA = "0x18163AC70")]
		private static int IndexOfImpl<T>(T[] array, T value, int startIndex, int count)
		{
			return 0;
		}

		// Token: 0x060003E7 RID: 999 RVA: 0x00003DF8 File Offset: 0x00001FF8
		[Token(Token = "0x60003E7")]
		[Address(RVA = "0x216EA00", Offset = "0x216D800", VA = "0x18216EA00")]
		private static int LastIndexOfImpl<T>(T[] array, T value, int startIndex, int count)
		{
			return 0;
		}

		// Token: 0x060003E8 RID: 1000 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003E8")]
		[Address(RVA = "0x26C3AE0", Offset = "0x26C28E0", VA = "0x1826C3AE0")]
		private static void SortImpl(Array keys, Array items, int index, int length, IComparer comparer)
		{
		}

		// Token: 0x060003E9 RID: 1001 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003E9")]
		[Address(RVA = "0x1294730", Offset = "0x1293530", VA = "0x181294730")]
		internal static T UnsafeLoad<T>(T[] array, int index)
		{
			return null;
		}

		// Token: 0x060003EA RID: 1002 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60003EA")]
		[Address(RVA = "0x19EC8B0", Offset = "0x19EB6B0", VA = "0x1819EC8B0")]
		internal static void UnsafeStore<T>(T[] array, int index, T value)
		{
		}

		// Token: 0x060003EB RID: 1003 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60003EB")]
		[Address(RVA = "0x1E3D0F0", Offset = "0x1E3BEF0", VA = "0x181E3D0F0")]
		internal static R UnsafeMov<R, S>(S instance)
		{
			return null;
		}

		// Token: 0x0200007C RID: 124
		[Token(Token = "0x200007C")]
		private sealed class ArrayEnumerator : IEnumerator, ICloneable
		{
			// Token: 0x060003EC RID: 1004 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003EC")]
			[Address(RVA = "0x26BFA10", Offset = "0x26BE810", VA = "0x1826BFA10")]
			internal ArrayEnumerator(Array array)
			{
			}

			// Token: 0x060003ED RID: 1005 RVA: 0x00003E10 File Offset: 0x00002010
			[Token(Token = "0x60003ED")]
			[Address(RVA = "0x26BF9F0", Offset = "0x26BE7F0", VA = "0x1826BF9F0", Slot = "4")]
			public bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x060003EE RID: 1006 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003EE")]
			[Address(RVA = "0x45BBE0", Offset = "0x45A9E0", VA = "0x18045BBE0", Slot = "6")]
			public void Reset()
			{
			}

			// Token: 0x060003EF RID: 1007 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x60003EF")]
			[Address(RVA = "0x6A0DF0", Offset = "0x69FBF0", VA = "0x1806A0DF0", Slot = "7")]
			public object Clone()
			{
				return null;
			}

			// Token: 0x17000072 RID: 114
			// (get) Token: 0x060003F0 RID: 1008 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x17000072")]
			public object Current
			{
				[Token(Token = "0x60003F0")]
				[Address(RVA = "0x26BFAA0", Offset = "0x26BE8A0", VA = "0x1826BFAA0", Slot = "5")]
				get
				{
					return null;
				}
			}

			// Token: 0x040001C0 RID: 448
			[FieldOffset(Offset = "0x10")]
			[Token(Token = "0x40001C0")]
			private Array _array;

			// Token: 0x040001C1 RID: 449
			[FieldOffset(Offset = "0x18")]
			[Token(Token = "0x40001C1")]
			private int _index;

			// Token: 0x040001C2 RID: 450
			[FieldOffset(Offset = "0x1C")]
			[Token(Token = "0x40001C2")]
			private int _endIndex;
		}

		// Token: 0x0200007D RID: 125
		[Token(Token = "0x200007D")]
		internal struct InternalEnumerator<T> : IEnumerator<T>, IDisposable, IEnumerator
		{
			// Token: 0x060003F1 RID: 1009 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003F1")]
			[Address(RVA = "0x1CE06E0", Offset = "0x1CDF4E0", VA = "0x181CE06E0")]
			internal InternalEnumerator(Array array)
			{
			}

			// Token: 0x060003F2 RID: 1010 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003F2")]
			[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080", Slot = "5")]
			public void Dispose()
			{
			}

			// Token: 0x060003F3 RID: 1011 RVA: 0x00003E28 File Offset: 0x00002028
			[Token(Token = "0x60003F3")]
			[Address(RVA = "0x1CDBBA0", Offset = "0x1CDA9A0", VA = "0x181CDBBA0", Slot = "6")]
			public bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x17000073 RID: 115
			// (get) Token: 0x060003F4 RID: 1012 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x17000073")]
			public T Current
			{
				[Token(Token = "0x60003F4")]
				[Address(RVA = "0x1F87B10", Offset = "0x1F86910", VA = "0x181F87B10", Slot = "4")]
				get
				{
					return null;
				}
			}

			// Token: 0x060003F5 RID: 1013 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003F5")]
			[Address(RVA = "0x1CDBBF0", Offset = "0x1CDA9F0", VA = "0x181CDBBF0", Slot = "8")]
			void IEnumerator.Reset()
			{
			}

			// Token: 0x17000074 RID: 116
			// (get) Token: 0x060003F6 RID: 1014 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x17000074")]
			object IEnumerator.Current
			{
				[Token(Token = "0x60003F6")]
				[Address(RVA = "0x1F85D00", Offset = "0x1F84B00", VA = "0x181F85D00", Slot = "7")]
				get
				{
					return null;
				}
			}

			// Token: 0x040001C3 RID: 451
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x40001C3")]
			private readonly Array array;

			// Token: 0x040001C4 RID: 452
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x40001C4")]
			private int idx;
		}

		// Token: 0x0200007E RID: 126
		[Token(Token = "0x200007E")]
		internal class EmptyInternalEnumerator<T> : IEnumerator<T>, IDisposable, IEnumerator
		{
			// Token: 0x060003F7 RID: 1015 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003F7")]
			[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080", Slot = "5")]
			public void Dispose()
			{
			}

			// Token: 0x060003F8 RID: 1016 RVA: 0x00003E40 File Offset: 0x00002040
			[Token(Token = "0x60003F8")]
			[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930", Slot = "6")]
			public bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x17000075 RID: 117
			// (get) Token: 0x060003F9 RID: 1017 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x17000075")]
			public T Current
			{
				[Token(Token = "0x60003F9")]
				[Address(RVA = "0x2A73410", Offset = "0x2A72210", VA = "0x182A73410", Slot = "4")]
				get
				{
					return null;
				}
			}

			// Token: 0x17000076 RID: 118
			// (get) Token: 0x060003FA RID: 1018 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x17000076")]
			object IEnumerator.Current
			{
				[Token(Token = "0x60003FA")]
				[Address(RVA = "0x1F818E0", Offset = "0x1F806E0", VA = "0x181F818E0", Slot = "7")]
				get
				{
					return null;
				}
			}

			// Token: 0x060003FB RID: 1019 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003FB")]
			[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080", Slot = "8")]
			void IEnumerator.Reset()
			{
			}

			// Token: 0x060003FC RID: 1020 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003FC")]
			[Address(RVA = "0x118F5A0", Offset = "0x118E3A0", VA = "0x18118F5A0")]
			public EmptyInternalEnumerator()
			{
			}

			// Token: 0x040001C5 RID: 453
			[Token(Token = "0x40001C5")]
			public static readonly Array.EmptyInternalEnumerator<T> Value;
		}

		// Token: 0x0200007F RID: 127
		[Token(Token = "0x200007F")]
		private struct SorterObjectArray
		{
			// Token: 0x060003FE RID: 1022 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003FE")]
			[Address(RVA = "0x26D22E0", Offset = "0x26D10E0", VA = "0x1826D22E0")]
			internal SorterObjectArray(object[] keys, object[] items, IComparer comparer)
			{
			}

			// Token: 0x060003FF RID: 1023 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60003FF")]
			[Address(RVA = "0x26D1DD0", Offset = "0x26D0BD0", VA = "0x1826D1DD0")]
			internal void SwapIfGreaterWithItems(int a, int b)
			{
			}

			// Token: 0x06000400 RID: 1024 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000400")]
			[Address(RVA = "0x26D20B0", Offset = "0x26D0EB0", VA = "0x1826D20B0")]
			private void Swap(int i, int j)
			{
			}

			// Token: 0x06000401 RID: 1025 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000401")]
			[Address(RVA = "0x26D1DC0", Offset = "0x26D0BC0", VA = "0x1826D1DC0")]
			internal void Sort(int left, int length)
			{
			}

			// Token: 0x06000402 RID: 1026 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000402")]
			[Address(RVA = "0x26D1B10", Offset = "0x26D0910", VA = "0x1826D1B10")]
			private void IntrospectiveSort(int left, int length)
			{
			}

			// Token: 0x06000403 RID: 1027 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000403")]
			[Address(RVA = "0x26D1A30", Offset = "0x26D0830", VA = "0x1826D1A30")]
			private void IntroSort(int lo, int hi, int depthLimit)
			{
			}

			// Token: 0x06000404 RID: 1028 RVA: 0x00003E58 File Offset: 0x00002058
			[Token(Token = "0x6000404")]
			[Address(RVA = "0x26D1C00", Offset = "0x26D0A00", VA = "0x1826D1C00")]
			private int PickPivotAndPartition(int lo, int hi)
			{
				return 0;
			}

			// Token: 0x06000405 RID: 1029 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000405")]
			[Address(RVA = "0x26D16C0", Offset = "0x26D04C0", VA = "0x1826D16C0")]
			private void Heapsort(int lo, int hi)
			{
			}

			// Token: 0x06000406 RID: 1030 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000406")]
			[Address(RVA = "0x26D1320", Offset = "0x26D0120", VA = "0x1826D1320")]
			private void DownHeap(int i, int n, int lo)
			{
			}

			// Token: 0x06000407 RID: 1031 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000407")]
			[Address(RVA = "0x26D1780", Offset = "0x26D0580", VA = "0x1826D1780")]
			private void InsertionSort(int lo, int hi)
			{
			}

			// Token: 0x040001C6 RID: 454
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x40001C6")]
			private object[] keys;

			// Token: 0x040001C7 RID: 455
			[FieldOffset(Offset = "0x8")]
			[Token(Token = "0x40001C7")]
			private object[] items;

			// Token: 0x040001C8 RID: 456
			[FieldOffset(Offset = "0x10")]
			[Token(Token = "0x40001C8")]
			private IComparer comparer;
		}

		// Token: 0x02000080 RID: 128
		[Token(Token = "0x2000080")]
		private struct SorterGenericArray
		{
			// Token: 0x06000408 RID: 1032 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000408")]
			[Address(RVA = "0x26D1280", Offset = "0x26D0080", VA = "0x1826D1280")]
			internal SorterGenericArray(Array keys, Array items, IComparer comparer)
			{
			}

			// Token: 0x06000409 RID: 1033 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000409")]
			[Address(RVA = "0x26D1020", Offset = "0x26CFE20", VA = "0x1826D1020")]
			internal void SwapIfGreaterWithItems(int a, int b)
			{
			}

			// Token: 0x0600040A RID: 1034 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600040A")]
			[Address(RVA = "0x26D1190", Offset = "0x26CFF90", VA = "0x1826D1190")]
			private void Swap(int i, int j)
			{
			}

			// Token: 0x0600040B RID: 1035 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600040B")]
			[Address(RVA = "0x26D1010", Offset = "0x26CFE10", VA = "0x1826D1010")]
			internal void Sort(int left, int length)
			{
			}

			// Token: 0x0600040C RID: 1036 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600040C")]
			[Address(RVA = "0x26D0D50", Offset = "0x26CFB50", VA = "0x1826D0D50")]
			private void IntrospectiveSort(int left, int length)
			{
			}

			// Token: 0x0600040D RID: 1037 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600040D")]
			[Address(RVA = "0x26D0C70", Offset = "0x26CFA70", VA = "0x1826D0C70")]
			private void IntroSort(int lo, int hi, int depthLimit)
			{
			}

			// Token: 0x0600040E RID: 1038 RVA: 0x00003E70 File Offset: 0x00002070
			[Token(Token = "0x600040E")]
			[Address(RVA = "0x26D0E70", Offset = "0x26CFC70", VA = "0x1826D0E70")]
			private int PickPivotAndPartition(int lo, int hi)
			{
				return 0;
			}

			// Token: 0x0600040F RID: 1039 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600040F")]
			[Address(RVA = "0x26D0A00", Offset = "0x26CF800", VA = "0x1826D0A00")]
			private void Heapsort(int lo, int hi)
			{
			}

			// Token: 0x06000410 RID: 1040 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000410")]
			[Address(RVA = "0x26D07C0", Offset = "0x26CF5C0", VA = "0x1826D07C0")]
			private void DownHeap(int i, int n, int lo)
			{
			}

			// Token: 0x06000411 RID: 1041 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000411")]
			[Address(RVA = "0x26D0AC0", Offset = "0x26CF8C0", VA = "0x1826D0AC0")]
			private void InsertionSort(int lo, int hi)
			{
			}

			// Token: 0x040001C9 RID: 457
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x40001C9")]
			private Array keys;

			// Token: 0x040001CA RID: 458
			[FieldOffset(Offset = "0x8")]
			[Token(Token = "0x40001CA")]
			private Array items;

			// Token: 0x040001CB RID: 459
			[FieldOffset(Offset = "0x10")]
			[Token(Token = "0x40001CB")]
			private IComparer comparer;
		}
	}
}