Apr2020-Cpp2Il-Dump/System.Core/System/Linq/Enumerable.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Cpp2IlInjected;

namespace System.Linq
{
	/// <summary>Provides a set of <see langword="static" /> (<see langword="Shared" /> in Visual Basic) methods for querying objects that implement <see cref="T:System.Collections.Generic.IEnumerable`1" />.</summary>
	// Token: 0x0200001B RID: 27
	[Token(Token = "0x200001B")]
	public static class Enumerable
	{
		/// <summary>Filters a sequence of values based on a predicate.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to filter.</param>
		/// <param name="predicate">A function to test each element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains elements from the input sequence that satisfy the condition.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		// Token: 0x06000095 RID: 149 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000095")]
		[Address(RVA = "0x13F7310", Offset = "0x13F6110", VA = "0x1813F7310")]
		public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return null;
		}

		// Token: 0x06000096 RID: 150 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000096")]
		[Address(RVA = "0x13EF310", Offset = "0x13EE110", VA = "0x1813EF310")]
		public static IEnumerable<TResult> Select<TResult, TSource>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
		{
			return null;
		}

		// Token: 0x06000097 RID: 151 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000097")]
		[Address(RVA = "0x14CF920", Offset = "0x14CE720", VA = "0x1814CF920")]
		public static IEnumerable<TResult> Select<TResult, TSource>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
		{
			return null;
		}

		// Token: 0x06000098 RID: 152 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000098")]
		[Address(RVA = "0x13EA060", Offset = "0x13E8E60", VA = "0x1813EA060")]
		private static IEnumerable<TResult> SelectIterator<TResult, TSource>(IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
		{
			return null;
		}

		// Token: 0x06000099 RID: 153 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000099")]
		[Address(RVA = "0x220E2E0", Offset = "0x220D0E0", VA = "0x18220E2E0")]
		private static Func<TSource, bool> CombinePredicates<TSource>(Func<TSource, bool> predicate1, Func<TSource, bool> predicate2)
		{
			return null;
		}

		// Token: 0x0600009A RID: 154 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600009A")]
		[Address(RVA = "0x1861E00", Offset = "0x1860C00", VA = "0x181861E00")]
		private static Func<TSource, TResult> CombineSelectors<TSource, TResult, TMiddle>(Func<TSource, TMiddle> selector1, Func<TMiddle, TResult> selector2)
		{
			return null;
		}

		// Token: 0x0600009B RID: 155 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600009B")]
		[Address(RVA = "0x13EAA40", Offset = "0x13E9840", VA = "0x1813EAA40")]
		public static IEnumerable<TResult> SelectMany<TResult, TSource>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
		{
			return null;
		}

		// Token: 0x0600009C RID: 156 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600009C")]
		[Address(RVA = "0x13E8700", Offset = "0x13E7500", VA = "0x1813E8700")]
		private static IEnumerable<TResult> SelectManyIterator<TResult, TSource>(IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
		{
			return null;
		}

		// Token: 0x0600009D RID: 157 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600009D")]
		[Address(RVA = "0x13EAB80", Offset = "0x13E9980", VA = "0x1813EAB80")]
		public static IEnumerable<TResult> SelectMany<TResult, TSource>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
		{
			return null;
		}

		// Token: 0x0600009E RID: 158 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600009E")]
		[Address(RVA = "0x13E8EA0", Offset = "0x13E7CA0", VA = "0x1813E8EA0")]
		private static IEnumerable<TResult> SelectManyIterator<TResult, TSource>(IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
		{
			return null;
		}

		// Token: 0x0600009F RID: 159 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600009F")]
		[Address(RVA = "0x13EA970", Offset = "0x13E9770", VA = "0x1813EA970")]
		public static IEnumerable<TResult> SelectMany<TResult, TSource, TCollection>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
		{
			return null;
		}

		// Token: 0x060000A0 RID: 160 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A0")]
		[Address(RVA = "0x13EA330", Offset = "0x13E9130", VA = "0x1813EA330")]
		private static IEnumerable<TResult> SelectManyIterator<TResult, TSource, TCollection>(IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
		{
			return null;
		}

		/// <summary>Returns a specified number of contiguous elements from the start of a sequence.</summary>
		/// <param name="source">The sequence to return elements from.</param>
		/// <param name="count">The number of elements to return.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains the specified number of elements from the start of the input sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000A1 RID: 161 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A1")]
		[Address(RVA = "0x13F4A50", Offset = "0x13F3850", VA = "0x1813F4A50")]
		public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
		{
			return null;
		}

		// Token: 0x060000A2 RID: 162 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A2")]
		[Address(RVA = "0x13F41D0", Offset = "0x13F2FD0", VA = "0x1813F41D0")]
		private static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> source, int count)
		{
			return null;
		}

		/// <summary>Bypasses a specified number of elements in a sequence and then returns the remaining elements.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return elements from.</param>
		/// <param name="count">The number of elements to skip before returning the remaining elements.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains the elements that occur after the specified index in the input sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000A3 RID: 163 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A3")]
		[Address(RVA = "0x13F3F50", Offset = "0x13F2D50", VA = "0x1813F3F50")]
		public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
		{
			return null;
		}

		// Token: 0x060000A4 RID: 164 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A4")]
		[Address(RVA = "0x13F38D0", Offset = "0x13F26D0", VA = "0x1813F38D0")]
		private static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count)
		{
			return null;
		}

		/// <summary>Sorts the elements of a sequence in ascending order according to a key.</summary>
		/// <param name="source">A sequence of values to order.</param>
		/// <param name="keySelector">A function to extract a key from an element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
		/// <returns>An <see cref="T:System.Linq.IOrderedEnumerable`1" /> whose elements are sorted according to a key.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="keySelector" /> is <see langword="null" />.</exception>
		// Token: 0x060000A5 RID: 165 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A5")]
		[Address(RVA = "0x2173B80", Offset = "0x2172980", VA = "0x182173B80")]
		public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		/// <summary>Sorts the elements of a sequence in ascending order by using a specified comparer.</summary>
		/// <param name="source">A sequence of values to order.</param>
		/// <param name="keySelector">A function to extract a key from an element.</param>
		/// <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1" /> to compare keys.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
		/// <returns>An <see cref="T:System.Linq.IOrderedEnumerable`1" /> whose elements are sorted according to a key.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="keySelector" /> is <see langword="null" />.</exception>
		// Token: 0x060000A6 RID: 166 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A6")]
		[Address(RVA = "0x2173C00", Offset = "0x2172A00", VA = "0x182173C00")]
		public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
		{
			return null;
		}

		/// <summary>Sorts the elements of a sequence in descending order according to a key.</summary>
		/// <param name="source">A sequence of values to order.</param>
		/// <param name="keySelector">A function to extract a key from an element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
		/// <returns>An <see cref="T:System.Linq.IOrderedEnumerable`1" /> whose elements are sorted in descending order according to a key.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="keySelector" /> is <see langword="null" />.</exception>
		// Token: 0x060000A7 RID: 167 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A7")]
		[Address(RVA = "0x2173A70", Offset = "0x2172870", VA = "0x182173A70")]
		public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		/// <summary>Sorts the elements of a sequence in descending order by using a specified comparer.</summary>
		/// <param name="source">A sequence of values to order.</param>
		/// <param name="keySelector">A function to extract a key from an element.</param>
		/// <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1" /> to compare keys.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
		/// <returns>An <see cref="T:System.Linq.IOrderedEnumerable`1" /> whose elements are sorted in descending order according to a key.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="keySelector" /> is <see langword="null" />.</exception>
		// Token: 0x060000A8 RID: 168 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A8")]
		[Address(RVA = "0x2173AF0", Offset = "0x21728F0", VA = "0x182173AF0")]
		public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
		{
			return null;
		}

		/// <summary>Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.</summary>
		/// <param name="source">An <see cref="T:System.Linq.IOrderedEnumerable`1" /> that contains elements to sort.</param>
		/// <param name="keySelector">A function to extract a key from each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
		/// <returns>An <see cref="T:System.Linq.IOrderedEnumerable`1" /> whose elements are sorted according to a key.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="keySelector" /> is <see langword="null" />.</exception>
		// Token: 0x060000A9 RID: 169 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000A9")]
		[Address(RVA = "0x2174100", Offset = "0x2172F00", VA = "0x182174100")]
		public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		/// <summary>Performs a subsequent ordering of the elements in a sequence in descending order, according to a key.</summary>
		/// <param name="source">An <see cref="T:System.Linq.IOrderedEnumerable`1" /> that contains elements to sort.</param>
		/// <param name="keySelector">A function to extract a key from each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
		/// <returns>An <see cref="T:System.Linq.IOrderedEnumerable`1" /> whose elements are sorted in descending order according to a key.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="keySelector" /> is <see langword="null" />.</exception>
		// Token: 0x060000AA RID: 170 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000AA")]
		[Address(RVA = "0x2173E60", Offset = "0x2172C60", VA = "0x182173E60")]
		public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		// Token: 0x060000AB RID: 171 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000AB")]
		[Address(RVA = "0x1958C80", Offset = "0x1957A80", VA = "0x181958C80")]
		public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TKey, TSource>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		// Token: 0x060000AC RID: 172 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000AC")]
		[Address(RVA = "0x1958D20", Offset = "0x1957B20", VA = "0x181958D20")]
		public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TKey, TElement, TSource>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
		{
			return null;
		}

		/// <summary>Concatenates two sequences.</summary>
		/// <param name="first">The first sequence to concatenate.</param>
		/// <param name="second">The sequence to concatenate to the first sequence.</param>
		/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains the concatenated elements of the two input sequences.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="first" /> or <paramref name="second" /> is <see langword="null" />.</exception>
		// Token: 0x060000AD RID: 173 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000AD")]
		[Address(RVA = "0x13E8CD0", Offset = "0x13E7AD0", VA = "0x1813E8CD0")]
		public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
		{
			return null;
		}

		// Token: 0x060000AE RID: 174 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000AE")]
		[Address(RVA = "0x13E8930", Offset = "0x13E7730", VA = "0x1813E8930")]
		private static IEnumerable<TSource> ConcatIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second)
		{
			return null;
		}

		/// <summary>Appends a value to the end of the sequence.</summary>
		/// <param name="source">A sequence of values. </param>
		/// <param name="element">The value to append to <paramref name="source" />.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />. </typeparam>
		/// <returns>A new sequence that ends with <paramref name="element" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000AF RID: 175 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000AF")]
		[Address(RVA = "0x13E8790", Offset = "0x13E7590", VA = "0x1813E8790")]
		public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource element)
		{
			return null;
		}

		// Token: 0x060000B0 RID: 176 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B0")]
		[Address(RVA = "0x13E8670", Offset = "0x13E7470", VA = "0x1813E8670")]
		private static IEnumerable<TSource> AppendIterator<TSource>(IEnumerable<TSource> source, TSource element)
		{
			return null;
		}

		// Token: 0x060000B1 RID: 177 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B1")]
		[Address(RVA = "0x13FCCC0", Offset = "0x13FBAC0", VA = "0x1813FCCC0")]
		public static IEnumerable<TResult> Zip<TResult, TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
		{
			return null;
		}

		// Token: 0x060000B2 RID: 178 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B2")]
		[Address(RVA = "0x13FC7A0", Offset = "0x13FB5A0", VA = "0x1813FC7A0")]
		private static IEnumerable<TResult> ZipIterator<TResult, TFirst, TSecond>(IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
		{
			return null;
		}

		/// <summary>Returns distinct elements from a sequence by using the default equality comparer to compare values.</summary>
		/// <param name="source">The sequence to remove duplicate elements from.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains distinct elements from the source sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000B3 RID: 179 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B3")]
		[Address(RVA = "0x13E93A0", Offset = "0x13E81A0", VA = "0x1813E93A0")]
		public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Returns distinct elements from a sequence by using a specified <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> to compare values.</summary>
		/// <param name="source">The sequence to remove duplicate elements from.</param>
		/// <param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> to compare values.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains distinct elements from the source sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000B4 RID: 180 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B4")]
		[Address(RVA = "0x13E9410", Offset = "0x13E8210", VA = "0x1813E9410")]
		public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
		{
			return null;
		}

		// Token: 0x060000B5 RID: 181 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B5")]
		[Address(RVA = "0x13E9030", Offset = "0x13E7E30", VA = "0x1813E9030")]
		private static IEnumerable<TSource> DistinctIterator<TSource>(IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
		{
			return null;
		}

		/// <summary>Produces the set union of two sequences by using the default equality comparer.</summary>
		/// <param name="first">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose distinct elements form the first set for the union.</param>
		/// <param name="second">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose distinct elements form the second set for the union.</param>
		/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains the elements from both input sequences, excluding duplicates.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="first" /> or <paramref name="second" /> is <see langword="null" />.</exception>
		// Token: 0x060000B6 RID: 182 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B6")]
		[Address(RVA = "0x13F4DF0", Offset = "0x13F3BF0", VA = "0x1813F4DF0")]
		public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
		{
			return null;
		}

		// Token: 0x060000B7 RID: 183 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B7")]
		[Address(RVA = "0x13F4AD0", Offset = "0x13F38D0", VA = "0x1813F4AD0")]
		private static IEnumerable<TSource> UnionIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			return null;
		}

		/// <summary>Produces the set intersection of two sequences by using the default equality comparer to compare values.</summary>
		/// <param name="first">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose distinct elements that also appear in <paramref name="second" /> will be returned.</param>
		/// <param name="second">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose distinct elements that also appear in the first sequence will be returned.</param>
		/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
		/// <returns>A sequence that contains the elements that form the set intersection of two sequences.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="first" /> or <paramref name="second" /> is <see langword="null" />.</exception>
		// Token: 0x060000B8 RID: 184 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B8")]
		[Address(RVA = "0x13E9C00", Offset = "0x13E8A00", VA = "0x1813E9C00")]
		public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
		{
			return null;
		}

		// Token: 0x060000B9 RID: 185 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000B9")]
		[Address(RVA = "0x13E9510", Offset = "0x13E8310", VA = "0x1813E9510")]
		private static IEnumerable<TSource> IntersectIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			return null;
		}

		/// <summary>Produces the set difference of two sequences by using the default equality comparer to compare values.</summary>
		/// <param name="first">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose elements that are not also in <paramref name="second" /> will be returned.</param>
		/// <param name="second">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.</param>
		/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
		/// <returns>A sequence that contains the set difference of the elements of two sequences.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="first" /> or <paramref name="second" /> is <see langword="null" />.</exception>
		// Token: 0x060000BA RID: 186 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000BA")]
		[Address(RVA = "0x13E9A20", Offset = "0x13E8820", VA = "0x1813E9A20")]
		public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
		{
			return null;
		}

		/// <summary>Produces the set difference of two sequences by using the specified <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> to compare values.</summary>
		/// <param name="first">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose elements that are not also in <paramref name="second" /> will be returned.</param>
		/// <param name="second">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.</param>
		/// <param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> to compare values.</param>
		/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
		/// <returns>A sequence that contains the set difference of the elements of two sequences.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="first" /> or <paramref name="second" /> is <see langword="null" />.</exception>
		// Token: 0x060000BB RID: 187 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000BB")]
		[Address(RVA = "0x13E9970", Offset = "0x13E8770", VA = "0x1813E9970")]
		public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			return null;
		}

		// Token: 0x060000BC RID: 188 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000BC")]
		[Address(RVA = "0x13E9650", Offset = "0x13E8450", VA = "0x1813E9650")]
		private static IEnumerable<TSource> ExceptIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			return null;
		}

		/// <summary>Inverts the order of the elements in a sequence.</summary>
		/// <param name="source">A sequence of values to reverse.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>A sequence whose elements correspond to those of the input sequence in reverse order.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000BD RID: 189 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000BD")]
		[Address(RVA = "0x13E9E60", Offset = "0x13E8C60", VA = "0x1813E9E60")]
		public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		// Token: 0x060000BE RID: 190 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000BE")]
		[Address(RVA = "0x13E9CA0", Offset = "0x13E8AA0", VA = "0x1813E9CA0")]
		private static IEnumerable<TSource> ReverseIterator<TSource>(IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.</summary>
		/// <param name="first">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to compare to <paramref name="second" />.</param>
		/// <param name="second">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to compare to the first sequence.</param>
		/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
		/// <returns>
		///     <see langword="true" /> if the two source sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="first" /> or <paramref name="second" /> is <see langword="null" />.</exception>
		// Token: 0x060000BF RID: 191 RVA: 0x00002130 File Offset: 0x00000330
		[Token(Token = "0x60000BF")]
		[Address(RVA = "0x19089B0", Offset = "0x19077B0", VA = "0x1819089B0")]
		public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
		{
			return default(bool);
		}

		/// <summary>Determines whether two sequences are equal by comparing their elements by using a specified <see cref="T:System.Collections.Generic.IEqualityComparer`1" />.</summary>
		/// <param name="first">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to compare to <paramref name="second" />.</param>
		/// <param name="second">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to compare to the first sequence.</param>
		/// <param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> to use to compare elements.</param>
		/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
		/// <returns>
		///     <see langword="true" /> if the two source sequences are of equal length and their corresponding elements compare equal according to <paramref name="comparer" />; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="first" /> or <paramref name="second" /> is <see langword="null" />.</exception>
		// Token: 0x060000C0 RID: 192 RVA: 0x00002148 File Offset: 0x00000348
		[Token(Token = "0x60000C0")]
		[Address(RVA = "0x1908640", Offset = "0x1907440", VA = "0x181908640")]
		public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			return default(bool);
		}

		/// <summary>Returns the input typed as <see cref="T:System.Collections.Generic.IEnumerable`1" />.</summary>
		/// <param name="source">The sequence to type as <see cref="T:System.Collections.Generic.IEnumerable`1" />.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The input sequence typed as <see cref="T:System.Collections.Generic.IEnumerable`1" />.</returns>
		// Token: 0x060000C1 RID: 193 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C1")]
		[Address(RVA = "0x434BD0", Offset = "0x4339D0", VA = "0x180434BD0")]
		public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Creates an array from a <see cref="T:System.Collections.Generic.IEnumerable`1" />.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to create an array from.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>An array that contains the elements from the input sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000C2 RID: 194 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C2")]
		[Address(RVA = "0x2392140", Offset = "0x2390F40", VA = "0x182392140")]
		public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Creates a <see cref="T:System.Collections.Generic.List`1" /> from an <see cref="T:System.Collections.Generic.IEnumerable`1" />.</summary>
		/// <param name="source">The <see cref="T:System.Collections.Generic.IEnumerable`1" /> to create a <see cref="T:System.Collections.Generic.List`1" /> from.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>A <see cref="T:System.Collections.Generic.List`1" /> that contains elements from the input sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000C3 RID: 195 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C3")]
		[Address(RVA = "0x1933810", Offset = "0x1932610", VA = "0x181933810")]
		public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		// Token: 0x060000C4 RID: 196 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C4")]
		[Address(RVA = "0x1958DB0", Offset = "0x1957BB0", VA = "0x181958DB0")]
		public static Dictionary<TKey, TSource> ToDictionary<TKey, TSource>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		// Token: 0x060000C5 RID: 197 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C5")]
		[Address(RVA = "0x19094B0", Offset = "0x19082B0", VA = "0x1819094B0")]
		public static Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TSource>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
		{
			return null;
		}

		// Token: 0x060000C6 RID: 198 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C6")]
		[Address(RVA = "0x1909110", Offset = "0x1907F10", VA = "0x181909110")]
		public static Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TSource>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
		{
			return null;
		}

		// Token: 0x060000C7 RID: 199 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C7")]
		[Address(RVA = "0x1958DB0", Offset = "0x1957BB0", VA = "0x181958DB0")]
		public static ILookup<TKey, TSource> ToLookup<TKey, TSource>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		/// <summary>Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.</summary>
		/// <param name="source">The sequence to return the specified value for if it is empty.</param>
		/// <param name="defaultValue">The value to return if the sequence is empty.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <paramref name="defaultValue" /> if <paramref name="source" /> is empty; otherwise, <paramref name="source" />.</returns>
		// Token: 0x060000C8 RID: 200 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C8")]
		[Address(RVA = "0x13E8F30", Offset = "0x13E7D30", VA = "0x1813E8F30")]
		public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source, TSource defaultValue)
		{
			return null;
		}

		// Token: 0x060000C9 RID: 201 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C9")]
		[Address(RVA = "0x13E8E10", Offset = "0x13E7C10", VA = "0x1813E8E10")]
		private static IEnumerable<TSource> DefaultIfEmptyIterator<TSource>(IEnumerable<TSource> source, TSource defaultValue)
		{
			return null;
		}

		/// <summary>Filters the elements of an <see cref="T:System.Collections.IEnumerable" /> based on a specified type.</summary>
		/// <param name="source">The <see cref="T:System.Collections.IEnumerable" /> whose elements to filter.</param>
		/// <typeparam name="TResult">The type to filter the elements of the sequence on.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains elements from the input sequence of type <paramref name="TResult" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000CA RID: 202 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CA")]
		[Address(RVA = "0x14BFEF0", Offset = "0x14BECF0", VA = "0x1814BFEF0")]
		public static IEnumerable<TResult> OfType<TResult>(this IEnumerable source)
		{
			return null;
		}

		// Token: 0x060000CB RID: 203 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CB")]
		[Address(RVA = "0x13E9CA0", Offset = "0x13E8AA0", VA = "0x1813E9CA0")]
		private static IEnumerable<TResult> OfTypeIterator<TResult>(IEnumerable source)
		{
			return null;
		}

		/// <summary>Casts the elements of an <see cref="T:System.Collections.IEnumerable" /> to the specified type.</summary>
		/// <param name="source">The <see cref="T:System.Collections.IEnumerable" /> that contains the elements to be cast to type <paramref name="TResult" />.</param>
		/// <typeparam name="TResult">The type to cast the elements of <paramref name="source" /> to.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains each element of the source sequence cast to the specified type.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidCastException">An element in the sequence cannot be cast to type <paramref name="TResult" />.</exception>
		// Token: 0x060000CC RID: 204 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CC")]
		[Address(RVA = "0x14BFE50", Offset = "0x14BEC50", VA = "0x1814BFE50")]
		public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source)
		{
			return null;
		}

		// Token: 0x060000CD RID: 205 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CD")]
		[Address(RVA = "0x13E9D80", Offset = "0x13E8B80", VA = "0x1813E9D80")]
		private static IEnumerable<TResult> CastIterator<TResult>(IEnumerable source)
		{
			return null;
		}

		/// <summary>Returns the first element of a sequence.</summary>
		/// <param name="source">The <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return the first element of.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The first element in the specified sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">The source sequence is empty.</exception>
		// Token: 0x060000CE RID: 206 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CE")]
		[Address(RVA = "0x238C770", Offset = "0x238B570", VA = "0x18238C770")]
		public static TSource First<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Returns the first element in a sequence that satisfies a specified condition.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return an element from.</param>
		/// <param name="predicate">A function to test each element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The first element in the sequence that passes the test in the specified predicate function.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">No element satisfies the condition in <paramref name="predicate" />.-or-The source sequence is empty.</exception>
		// Token: 0x060000CF RID: 207 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CF")]
		[Address(RVA = "0x238DC20", Offset = "0x238CA20", VA = "0x18238DC20")]
		public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return null;
		}

		/// <summary>Returns the first element of a sequence, or a default value if the sequence contains no elements.</summary>
		/// <param name="source">The <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return the first element of.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="default" />(<paramref name="TSource" />) if <paramref name="source" /> is empty; otherwise, the first element in <paramref name="source" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000D0 RID: 208 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D0")]
		[Address(RVA = "0x238BC90", Offset = "0x238AA90", VA = "0x18238BC90")]
		public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return an element from.</param>
		/// <param name="predicate">A function to test each element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="default" />(<paramref name="TSource" />) if <paramref name="source" /> is empty or if no element passes the test specified by <paramref name="predicate" />; otherwise, the first element in <paramref name="source" /> that passes the test specified by <paramref name="predicate" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		// Token: 0x060000D1 RID: 209 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D1")]
		[Address(RVA = "0x238BAB0", Offset = "0x238A8B0", VA = "0x18238BAB0")]
		public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return null;
		}

		/// <summary>Returns the last element of a sequence.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return the last element of.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The value at the last position in the source sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">The source sequence is empty.</exception>
		// Token: 0x060000D2 RID: 210 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D2")]
		[Address(RVA = "0x238FEB0", Offset = "0x238ECB0", VA = "0x18238FEB0")]
		public static TSource Last<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Returns the last element of a sequence that satisfies a specified condition.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return an element from.</param>
		/// <param name="predicate">A function to test each element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The last element in the sequence that passes the test in the specified predicate function.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">No element satisfies the condition in <paramref name="predicate" />.-or-The source sequence is empty.</exception>
		// Token: 0x060000D3 RID: 211 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D3")]
		[Address(RVA = "0x23901C0", Offset = "0x238EFC0", VA = "0x1823901C0")]
		public static TSource Last<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return null;
		}

		/// <summary>Returns the last element of a sequence, or a default value if the sequence contains no elements.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return the last element of.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="default" />(<paramref name="TSource" />) if the source sequence is empty; otherwise, the last element in the <see cref="T:System.Collections.Generic.IEnumerable`1" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000D4 RID: 212 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D4")]
		[Address(RVA = "0x238EEE0", Offset = "0x238DCE0", VA = "0x18238EEE0")]
		public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return an element from.</param>
		/// <param name="predicate">A function to test each element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="default" />(<paramref name="TSource" />) if the sequence is empty or if no elements pass the test in the predicate function; otherwise, the last element that passes the test in the predicate function.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		// Token: 0x060000D5 RID: 213 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D5")]
		[Address(RVA = "0x238F1E0", Offset = "0x238DFE0", VA = "0x18238F1E0")]
		public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return null;
		}

		/// <summary>Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return the single element of.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The single element of the input sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">The input sequence contains more than one element.-or-The input sequence is empty.</exception>
		// Token: 0x060000D6 RID: 214 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D6")]
		[Address(RVA = "0x23914F0", Offset = "0x23902F0", VA = "0x1823914F0")]
		public static TSource Single<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return a single element from.</param>
		/// <param name="predicate">A function to test an element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The single element of the input sequence that satisfies a condition.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">No element satisfies the condition in <paramref name="predicate" />.-or-More than one element satisfies the condition in <paramref name="predicate" />.-or-The source sequence is empty.</exception>
		// Token: 0x060000D7 RID: 215 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D7")]
		[Address(RVA = "0x2391770", Offset = "0x2390570", VA = "0x182391770")]
		public static TSource Single<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return null;
		}

		/// <summary>Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return the single element of.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The single element of the input sequence, or <see langword="default" />(<paramref name="TSource" />) if the sequence contains no elements.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">The input sequence contains more than one element.</exception>
		// Token: 0x060000D8 RID: 216 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D8")]
		[Address(RVA = "0x2390D70", Offset = "0x238FB70", VA = "0x182390D70")]
		public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return a single element from.</param>
		/// <param name="predicate">A function to test an element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The single element of the input sequence that satisfies the condition, or <see langword="default" />(<paramref name="TSource" />) if no such element is found.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		// Token: 0x060000D9 RID: 217 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D9")]
		[Address(RVA = "0x2390FE0", Offset = "0x238FDE0", VA = "0x182390FE0")]
		public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return null;
		}

		/// <summary>Returns the element at a specified index in a sequence.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return an element from.</param>
		/// <param name="index">The zero-based index of the element to retrieve.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The element at the specified position in the source sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///         <paramref name="index" /> is less than 0 or greater than or equal to the number of elements in <paramref name="source" />.</exception>
		// Token: 0x060000DA RID: 218 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DA")]
		[Address(RVA = "0x2388BA0", Offset = "0x23879A0", VA = "0x182388BA0")]
		public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int index)
		{
			return null;
		}

		/// <summary>Returns the element at a specified index in a sequence or a default value if the index is out of range.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return an element from.</param>
		/// <param name="index">The zero-based index of the element to retrieve.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="default" />(<paramref name="TSource" />) if the index is outside the bounds of the source sequence; otherwise, the element at the specified position in the source sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000DB RID: 219 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DB")]
		[Address(RVA = "0x2388400", Offset = "0x2387200", VA = "0x182388400")]
		public static TSource ElementAtOrDefault<TSource>(this IEnumerable<TSource> source, int index)
		{
			return null;
		}

		/// <summary>Generates a sequence of integral numbers within a specified range.</summary>
		/// <param name="start">The value of the first integer in the sequence.</param>
		/// <param name="count">The number of sequential integers to generate.</param>
		/// <returns>An IEnumerable&lt;Int32&gt; in C# or IEnumerable(Of Int32) in Visual Basic that contains a range of sequential integral numbers.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///         <paramref name="count" /> is less than 0.-or-
		///         <paramref name="start" /> + <paramref name="count" /> -1 is larger than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x060000DC RID: 220 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DC")]
		[Address(RVA = "0x53D1B0", Offset = "0x53BFB0", VA = "0x18053D1B0")]
		public static IEnumerable<int> Range(int start, int count)
		{
			return null;
		}

		// Token: 0x060000DD RID: 221 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DD")]
		[Address(RVA = "0x53D130", Offset = "0x53BF30", VA = "0x18053D130")]
		private static IEnumerable<int> RangeIterator(int start, int count)
		{
			return null;
		}

		/// <summary>Generates a sequence that contains one repeated value.</summary>
		/// <param name="element">The value to be repeated.</param>
		/// <param name="count">The number of times to repeat the value in the generated sequence.</param>
		/// <typeparam name="TResult">The type of the value to be repeated in the result sequence.</typeparam>
		/// <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains a repeated value.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///         <paramref name="count" /> is less than 0.</exception>
		// Token: 0x060000DE RID: 222 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DE")]
		[Address(RVA = "0x14C0050", Offset = "0x14BEE50", VA = "0x1814C0050")]
		public static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)
		{
			return null;
		}

		// Token: 0x060000DF RID: 223 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DF")]
		[Address(RVA = "0x14BFFD0", Offset = "0x14BEDD0", VA = "0x1814BFFD0")]
		private static IEnumerable<TResult> RepeatIterator<TResult>(TResult element, int count)
		{
			return null;
		}

		/// <summary>Returns an empty <see cref="T:System.Collections.Generic.IEnumerable`1" /> that has the specified type argument.</summary>
		/// <typeparam name="TResult">The type to assign to the type parameter of the returned generic <see cref="T:System.Collections.Generic.IEnumerable`1" />.</typeparam>
		/// <returns>An empty <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose type argument is <paramref name="TResult" />.</returns>
		// Token: 0x060000E0 RID: 224 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E0")]
		[Address(RVA = "0x3F5110", Offset = "0x3F3F10", VA = "0x1803F5110")]
		public static IEnumerable<TResult> Empty<TResult>()
		{
			return null;
		}

		/// <summary>Determines whether a sequence contains any elements.</summary>
		/// <param name="source">The <see cref="T:System.Collections.Generic.IEnumerable`1" /> to check for emptiness.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="true" /> if the source sequence contains any elements; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000E1 RID: 225 RVA: 0x00002160 File Offset: 0x00000360
		[Token(Token = "0x60000E1")]
		[Address(RVA = "0x19069C0", Offset = "0x19057C0", VA = "0x1819069C0")]
		public static bool Any<TSource>(this IEnumerable<TSource> source)
		{
			return default(bool);
		}

		/// <summary>Determines whether any element of a sequence satisfies a condition.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> whose elements to apply the predicate to.</param>
		/// <param name="predicate">A function to test each element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="true" /> if any elements in the source sequence pass the test in the specified predicate; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		// Token: 0x060000E2 RID: 226 RVA: 0x00002178 File Offset: 0x00000378
		[Token(Token = "0x60000E2")]
		[Address(RVA = "0x1906B30", Offset = "0x1905930", VA = "0x181906B30")]
		public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return default(bool);
		}

		/// <summary>Determines whether all elements of a sequence satisfy a condition.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains the elements to apply the predicate to.</param>
		/// <param name="predicate">A function to test each element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="true" /> if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		// Token: 0x060000E3 RID: 227 RVA: 0x00002190 File Offset: 0x00000390
		[Token(Token = "0x60000E3")]
		[Address(RVA = "0x1902F60", Offset = "0x1901D60", VA = "0x181902F60")]
		public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return default(bool);
		}

		/// <summary>Returns the number of elements in a sequence.</summary>
		/// <param name="source">A sequence that contains elements to be counted.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The number of elements in the input sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.OverflowException">The number of elements in <paramref name="source" /> is larger than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x060000E4 RID: 228 RVA: 0x000021A8 File Offset: 0x000003A8
		[Token(Token = "0x60000E4")]
		[Address(RVA = "0x2172E60", Offset = "0x2171C60", VA = "0x182172E60")]
		public static int Count<TSource>(this IEnumerable<TSource> source)
		{
			return 0;
		}

		/// <summary>Returns a number that represents how many elements in the specified sequence satisfy a condition.</summary>
		/// <param name="source">A sequence that contains elements to be tested and counted.</param>
		/// <param name="predicate">A function to test each element for a condition.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>A number that represents how many elements in the sequence satisfy the condition in the predicate function.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="predicate" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.OverflowException">The number of elements in <paramref name="source" /> is larger than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x060000E5 RID: 229 RVA: 0x000021C0 File Offset: 0x000003C0
		[Token(Token = "0x60000E5")]
		[Address(RVA = "0x2173050", Offset = "0x2171E50", VA = "0x182173050")]
		public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return 0;
		}

		/// <summary>Determines whether a sequence contains a specified element by using the default equality comparer.</summary>
		/// <param name="source">A sequence in which to locate a value.</param>
		/// <param name="value">The value to locate in the sequence.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="true" /> if the source sequence contains an element that has the specified value; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000E6 RID: 230 RVA: 0x000021D8 File Offset: 0x000003D8
		[Token(Token = "0x60000E6")]
		[Address(RVA = "0x1908590", Offset = "0x1907390", VA = "0x181908590")]
		public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value)
		{
			return default(bool);
		}

		/// <summary>Determines whether a sequence contains a specified element by using a specified <see cref="T:System.Collections.Generic.IEqualityComparer`1" />.</summary>
		/// <param name="source">A sequence in which to locate a value.</param>
		/// <param name="value">The value to locate in the sequence.</param>
		/// <param name="comparer">An equality comparer to compare values.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>
		///     <see langword="true" /> if the source sequence contains an element that has the specified value; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000E7 RID: 231 RVA: 0x000021F0 File Offset: 0x000003F0
		[Token(Token = "0x60000E7")]
		[Address(RVA = "0x1908080", Offset = "0x1906E80", VA = "0x181908080")]
		public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer)
		{
			return default(bool);
		}

		/// <summary>Applies an accumulator function over a sequence.</summary>
		/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to aggregate over.</param>
		/// <param name="func">An accumulator function to be invoked on each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The final accumulator value.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="func" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000E8 RID: 232 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E8")]
		[Address(RVA = "0x2387880", Offset = "0x2386680", VA = "0x182387880")]
		public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func)
		{
			return null;
		}

		// Token: 0x060000E9 RID: 233 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E9")]
		[Address(RVA = "0x1295D90", Offset = "0x1294B90", VA = "0x181295D90")]
		public static TAccumulate Aggregate<TAccumulate, TSource>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
		{
			return null;
		}

		/// <summary>Computes the sum of a sequence of <see cref="T:System.Int32" /> values.</summary>
		/// <param name="source">A sequence of <see cref="T:System.Int32" /> values to calculate the sum of.</param>
		/// <returns>The sum of the values in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.OverflowException">The sum is larger than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x060000EA RID: 234 RVA: 0x00002208 File Offset: 0x00000408
		[Token(Token = "0x60000EA")]
		[Address(RVA = "0x53D570", Offset = "0x53C370", VA = "0x18053D570")]
		public static int Sum(this IEnumerable<int> source)
		{
			return 0;
		}

		/// <summary>Computes the sum of a sequence of <see cref="T:System.Int64" /> values.</summary>
		/// <param name="source">A sequence of <see cref="T:System.Int64" /> values to calculate the sum of.</param>
		/// <returns>The sum of the values in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.OverflowException">The sum is larger than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x060000EB RID: 235 RVA: 0x00002220 File Offset: 0x00000420
		[Token(Token = "0x60000EB")]
		[Address(RVA = "0x53D400", Offset = "0x53C200", VA = "0x18053D400")]
		public static long Sum(this IEnumerable<long> source)
		{
			return 0L;
		}

		/// <summary>Computes the sum of a sequence of <see cref="T:System.Single" /> values.</summary>
		/// <param name="source">A sequence of <see cref="T:System.Single" /> values to calculate the sum of.</param>
		/// <returns>The sum of the values in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000EC RID: 236 RVA: 0x00002238 File Offset: 0x00000438
		[Token(Token = "0x60000EC")]
		[Address(RVA = "0x53D270", Offset = "0x53C070", VA = "0x18053D270")]
		public static float Sum(this IEnumerable<float> source)
		{
			return 0f;
		}

		/// <summary>Computes the sum of the sequence of <see cref="T:System.Int32" /> values that are obtained by invoking a transform function on each element of the input sequence.</summary>
		/// <param name="source">A sequence of values that are used to calculate a sum.</param>
		/// <param name="selector">A transform function to apply to each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The sum of the projected values.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="selector" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.OverflowException">The sum is larger than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x060000ED RID: 237 RVA: 0x00002250 File Offset: 0x00000450
		[Token(Token = "0x60000ED")]
		[Address(RVA = "0x2173CB0", Offset = "0x2172AB0", VA = "0x182173CB0")]
		public static int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
		{
			return 0;
		}

		/// <summary>Computes the sum of the sequence of <see cref="T:System.Int64" /> values that are obtained by invoking a transform function on each element of the input sequence.</summary>
		/// <param name="source">A sequence of values that are used to calculate a sum.</param>
		/// <param name="selector">A transform function to apply to each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The sum of the projected values.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="selector" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.OverflowException">The sum is larger than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x060000EE RID: 238 RVA: 0x00002268 File Offset: 0x00000468
		[Token(Token = "0x60000EE")]
		[Address(RVA = "0x2173C90", Offset = "0x2172A90", VA = "0x182173C90")]
		public static long Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
		{
			return 0L;
		}

		/// <summary>Computes the sum of the sequence of <see cref="T:System.Single" /> values that are obtained by invoking a transform function on each element of the input sequence.</summary>
		/// <param name="source">A sequence of values that are used to calculate a sum.</param>
		/// <param name="selector">A transform function to apply to each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The sum of the projected values.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="selector" /> is <see langword="null" />.</exception>
		// Token: 0x060000EF RID: 239 RVA: 0x00002280 File Offset: 0x00000480
		[Token(Token = "0x60000EF")]
		[Address(RVA = "0x1B52D00", Offset = "0x1B51B00", VA = "0x181B52D00")]
		public static float Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
		{
			return 0f;
		}

		/// <summary>Returns the minimum value in a sequence of <see cref="T:System.Int32" /> values.</summary>
		/// <param name="source">A sequence of <see cref="T:System.Int32" /> values to determine the minimum value of.</param>
		/// <returns>The minimum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000F0 RID: 240 RVA: 0x00002298 File Offset: 0x00000498
		[Token(Token = "0x60000F0")]
		[Address(RVA = "0x53CF60", Offset = "0x53BD60", VA = "0x18053CF60")]
		public static int Min(this IEnumerable<int> source)
		{
			return 0;
		}

		/// <summary>Returns the minimum value in a sequence of <see cref="T:System.Single" /> values.</summary>
		/// <param name="source">A sequence of <see cref="T:System.Single" /> values to determine the minimum value of.</param>
		/// <returns>The minimum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000F1 RID: 241 RVA: 0x000022B0 File Offset: 0x000004B0
		[Token(Token = "0x60000F1")]
		[Address(RVA = "0x53CD60", Offset = "0x53BB60", VA = "0x18053CD60")]
		public static float Min(this IEnumerable<float> source)
		{
			return 0f;
		}

		/// <summary>Invokes a transform function on each element of a sequence and returns the minimum <see cref="T:System.Int32" /> value.</summary>
		/// <param name="source">A sequence of values to determine the minimum value of.</param>
		/// <param name="selector">A transform function to apply to each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The minimum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="selector" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000F2 RID: 242 RVA: 0x000022C8 File Offset: 0x000004C8
		[Token(Token = "0x60000F2")]
		[Address(RVA = "0x2173A50", Offset = "0x2172850", VA = "0x182173A50")]
		public static int Min<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
		{
			return 0;
		}

		/// <summary>Invokes a transform function on each element of a sequence and returns the minimum <see cref="T:System.Single" /> value.</summary>
		/// <param name="source">A sequence of values to determine the minimum value of.</param>
		/// <param name="selector">A transform function to apply to each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The minimum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="selector" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000F3 RID: 243 RVA: 0x000022E0 File Offset: 0x000004E0
		[Token(Token = "0x60000F3")]
		[Address(RVA = "0x1B52CE0", Offset = "0x1B51AE0", VA = "0x181B52CE0")]
		public static float Min<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
		{
			return 0f;
		}

		/// <summary>Returns the maximum value in a sequence of <see cref="T:System.Int32" /> values.</summary>
		/// <param name="source">A sequence of <see cref="T:System.Int32" /> values to determine the maximum value of.</param>
		/// <returns>The maximum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000F4 RID: 244 RVA: 0x000022F8 File Offset: 0x000004F8
		[Token(Token = "0x60000F4")]
		[Address(RVA = "0x53C800", Offset = "0x53B600", VA = "0x18053C800")]
		public static int Max(this IEnumerable<int> source)
		{
			return 0;
		}

		/// <summary>Returns the maximum value in a sequence of <see cref="T:System.Int64" /> values.</summary>
		/// <param name="source">A sequence of <see cref="T:System.Int64" /> values to determine the maximum value of.</param>
		/// <returns>The maximum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000F5 RID: 245 RVA: 0x00002310 File Offset: 0x00000510
		[Token(Token = "0x60000F5")]
		[Address(RVA = "0x53CB80", Offset = "0x53B980", VA = "0x18053CB80")]
		public static long Max(this IEnumerable<long> source)
		{
			return 0L;
		}

		/// <summary>Returns the maximum value in a sequence of <see cref="T:System.Single" /> values.</summary>
		/// <param name="source">A sequence of <see cref="T:System.Single" /> values to determine the maximum value of.</param>
		/// <returns>The maximum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000F6 RID: 246 RVA: 0x00002328 File Offset: 0x00000528
		[Token(Token = "0x60000F6")]
		[Address(RVA = "0x53C9D0", Offset = "0x53B7D0", VA = "0x18053C9D0")]
		public static float Max(this IEnumerable<float> source)
		{
			return 0f;
		}

		/// <summary>Returns the maximum value in a generic sequence.</summary>
		/// <param name="source">A sequence of values to determine the maximum value of.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The maximum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		// Token: 0x060000F7 RID: 247 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000F7")]
		[Address(RVA = "0x2390640", Offset = "0x238F440", VA = "0x182390640")]
		public static TSource Max<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		/// <summary>Invokes a transform function on each element of a sequence and returns the maximum <see cref="T:System.Int32" /> value.</summary>
		/// <param name="source">A sequence of values to determine the maximum value of.</param>
		/// <param name="selector">A transform function to apply to each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The maximum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="selector" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000F8 RID: 248 RVA: 0x00002340 File Offset: 0x00000540
		[Token(Token = "0x60000F8")]
		[Address(RVA = "0x2173A30", Offset = "0x2172830", VA = "0x182173A30")]
		public static int Max<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
		{
			return 0;
		}

		/// <summary>Invokes a transform function on each element of a sequence and returns the maximum <see cref="T:System.Int64" /> value.</summary>
		/// <param name="source">A sequence of values to determine the maximum value of.</param>
		/// <param name="selector">A transform function to apply to each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The maximum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="selector" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000F9 RID: 249 RVA: 0x00002358 File Offset: 0x00000558
		[Token(Token = "0x60000F9")]
		[Address(RVA = "0x2173A10", Offset = "0x2172810", VA = "0x182173A10")]
		public static long Max<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
		{
			return 0L;
		}

		/// <summary>Invokes a transform function on each element of a sequence and returns the maximum <see cref="T:System.Single" /> value.</summary>
		/// <param name="source">A sequence of values to determine the maximum value of.</param>
		/// <param name="selector">A transform function to apply to each element.</param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>The maximum value in the sequence.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> or <paramref name="selector" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000FA RID: 250 RVA: 0x00002370 File Offset: 0x00000570
		[Token(Token = "0x60000FA")]
		[Address(RVA = "0x1B52CC0", Offset = "0x1B51AC0", VA = "0x181B52CC0")]
		public static float Max<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
		{
			return 0f;
		}

		// Token: 0x060000FB RID: 251 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000FB")]
		[Address(RVA = "0x2390890", Offset = "0x238F690", VA = "0x182390890")]
		public static TResult Max<TResult, TSource>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
		{
			return null;
		}

		/// <summary>Computes the average of a sequence of <see cref="T:System.Int32" /> values.</summary>
		/// <param name="source">A sequence of <see cref="T:System.Int32" /> values to calculate the average of.</param>
		/// <returns>The average of the sequence of values.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///         <paramref name="source" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">
		///         <paramref name="source" /> contains no elements.</exception>
		// Token: 0x060000FC RID: 252 RVA: 0x00002388 File Offset: 0x00000588
		[Token(Token = "0x60000FC")]
		[Address(RVA = "0x53C600", Offset = "0x53B400", VA = "0x18053C600")]
		public static double Average(this IEnumerable<int> source)
		{
			return 0.0;
		}

		// Token: 0x0200001C RID: 28
		[Token(Token = "0x200001C")]
		private abstract class Iterator<TSource> : IEnumerable<TSource>, IEnumerable, IEnumerator<TSource>, IDisposable, IEnumerator
		{
			// Token: 0x060000FD RID: 253 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x60000FD")]
			[Address(RVA = "0x2C766C0", Offset = "0x2C754C0", VA = "0x182C766C0")]
			public Iterator()
			{
			}

			// Token: 0x1700000D RID: 13
			// (get) Token: 0x060000FE RID: 254 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x1700000D")]
			public TSource Current
			{
				[Token(Token = "0x60000FE")]
				[Address(RVA = "0x11A1230", Offset = "0x11A0030", VA = "0x1811A1230", Slot = "6")]
				get
				{
					return null;
				}
			}

			// Token: 0x060000FF RID: 255
			[Token(Token = "0x60000FF")]
			[Address(Slot = "11")]
			public abstract Enumerable.Iterator<TSource> Clone();

			// Token: 0x06000100 RID: 256 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000100")]
			[Address(RVA = "0x2C94960", Offset = "0x2C93760", VA = "0x182C94960", Slot = "12")]
			public virtual void Dispose()
			{
			}

			// Token: 0x06000101 RID: 257 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000101")]
			[Address(RVA = "0x2C765F0", Offset = "0x2C753F0", VA = "0x182C765F0", Slot = "4")]
			public IEnumerator<TSource> GetEnumerator()
			{
				return null;
			}

			// Token: 0x06000102 RID: 258
			[Token(Token = "0x6000102")]
			[Address(Slot = "13")]
			public abstract bool MoveNext();

			// Token: 0x06000103 RID: 259
			[Token(Token = "0x6000103")]
			[Address(Slot = "14")]
			public abstract IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector);

			// Token: 0x06000104 RID: 260
			[Token(Token = "0x6000104")]
			[Address(Slot = "15")]
			public abstract IEnumerable<TSource> Where(Func<TSource, bool> predicate);

			// Token: 0x1700000E RID: 14
			// (get) Token: 0x06000105 RID: 261 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x1700000E")]
			object IEnumerator.Current
			{
				[Token(Token = "0x6000105")]
				[Address(RVA = "0x2C96510", Offset = "0x2C95310", VA = "0x182C96510", Slot = "9")]
				get
				{
					return null;
				}
			}

			// Token: 0x06000106 RID: 262 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000106")]
			[Address(RVA = "0x119EE00", Offset = "0x119DC00", VA = "0x18119EE00", Slot = "5")]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return null;
			}

			// Token: 0x06000107 RID: 263 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000107")]
			[Address(RVA = "0x2EA24F0", Offset = "0x2EA12F0", VA = "0x182EA24F0", Slot = "10")]
			void IEnumerator.Reset()
			{
			}

			// Token: 0x0400001A RID: 26
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400001A")]
			private int threadId;

			// Token: 0x0400001B RID: 27
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400001B")]
			internal int state;

			// Token: 0x0400001C RID: 28
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400001C")]
			internal TSource current;
		}

		// Token: 0x0200001D RID: 29
		[Token(Token = "0x200001D")]
		private class WhereEnumerableIterator<TSource> : Enumerable.Iterator<TSource>
		{
			// Token: 0x06000108 RID: 264 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000108")]
			[Address(RVA = "0x2C99290", Offset = "0x2C98090", VA = "0x182C99290")]
			public WhereEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate)
			{
			}

			// Token: 0x06000109 RID: 265 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000109")]
			[Address(RVA = "0x2C979F0", Offset = "0x2C967F0", VA = "0x182C979F0", Slot = "11")]
			public override Enumerable.Iterator<TSource> Clone()
			{
				return null;
			}

			// Token: 0x0600010A RID: 266 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x600010A")]
			[Address(RVA = "0x2C97E00", Offset = "0x2C96C00", VA = "0x182C97E00", Slot = "12")]
			public override void Dispose()
			{
			}

			// Token: 0x0600010B RID: 267 RVA: 0x000023A0 File Offset: 0x000005A0
			[Token(Token = "0x600010B")]
			[Address(RVA = "0x2C98F20", Offset = "0x2C97D20", VA = "0x182C98F20", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x0600010C RID: 268 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600010C")]
			[Address(RVA = "0x14D0CB0", Offset = "0x14CFAB0", VA = "0x1814D0CB0", Slot = "14")]
			public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
			{
				return null;
			}

			// Token: 0x0600010D RID: 269 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600010D")]
			[Address(RVA = "0x2C99150", Offset = "0x2C97F50", VA = "0x182C99150", Slot = "15")]
			public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
			{
				return null;
			}

			// Token: 0x0400001D RID: 29
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400001D")]
			private IEnumerable<TSource> source;

			// Token: 0x0400001E RID: 30
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400001E")]
			private Func<TSource, bool> predicate;

			// Token: 0x0400001F RID: 31
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400001F")]
			private IEnumerator<TSource> enumerator;
		}

		// Token: 0x0200001E RID: 30
		[Token(Token = "0x200001E")]
		private class WhereArrayIterator<TSource> : Enumerable.Iterator<TSource>
		{
			// Token: 0x0600010E RID: 270 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x600010E")]
			[Address(RVA = "0x261FEB0", Offset = "0x261ECB0", VA = "0x18261FEB0")]
			public WhereArrayIterator(TSource[] source, Func<TSource, bool> predicate)
			{
			}

			// Token: 0x0600010F RID: 271 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600010F")]
			[Address(RVA = "0x261F070", Offset = "0x261DE70", VA = "0x18261F070", Slot = "11")]
			public override Enumerable.Iterator<TSource> Clone()
			{
				return null;
			}

			// Token: 0x06000110 RID: 272 RVA: 0x000023B8 File Offset: 0x000005B8
			[Token(Token = "0x6000110")]
			[Address(RVA = "0x2C97400", Offset = "0x2C96200", VA = "0x182C97400", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x06000111 RID: 273 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000111")]
			[Address(RVA = "0x14D0CB0", Offset = "0x14CFAB0", VA = "0x1814D0CB0", Slot = "14")]
			public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
			{
				return null;
			}

			// Token: 0x06000112 RID: 274 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000112")]
			[Address(RVA = "0x2C97770", Offset = "0x2C96570", VA = "0x182C97770", Slot = "15")]
			public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
			{
				return null;
			}

			// Token: 0x04000020 RID: 32
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000020")]
			private TSource[] source;

			// Token: 0x04000021 RID: 33
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000021")]
			private Func<TSource, bool> predicate;

			// Token: 0x04000022 RID: 34
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000022")]
			private int index;
		}

		// Token: 0x0200001F RID: 31
		[Token(Token = "0x200001F")]
		private class WhereListIterator<TSource> : Enumerable.Iterator<TSource>
		{
			// Token: 0x06000113 RID: 275 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000113")]
			[Address(RVA = "0x261FEB0", Offset = "0x261ECB0", VA = "0x18261FEB0")]
			public WhereListIterator(List<TSource> source, Func<TSource, bool> predicate)
			{
			}

			// Token: 0x06000114 RID: 276 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000114")]
			[Address(RVA = "0x261F070", Offset = "0x261DE70", VA = "0x18261F070", Slot = "11")]
			public override Enumerable.Iterator<TSource> Clone()
			{
				return null;
			}

			// Token: 0x06000115 RID: 277 RVA: 0x000023D0 File Offset: 0x000005D0
			[Token(Token = "0x6000115")]
			[Address(RVA = "0x261F6E0", Offset = "0x261E4E0", VA = "0x18261F6E0", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x06000116 RID: 278 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000116")]
			[Address(RVA = "0x14D0CB0", Offset = "0x14CFAB0", VA = "0x1814D0CB0", Slot = "14")]
			public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
			{
				return null;
			}

			// Token: 0x06000117 RID: 279 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000117")]
			[Address(RVA = "0x261FE10", Offset = "0x261EC10", VA = "0x18261FE10", Slot = "15")]
			public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
			{
				return null;
			}

			// Token: 0x04000023 RID: 35
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000023")]
			private List<TSource> source;

			// Token: 0x04000024 RID: 36
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000024")]
			private Func<TSource, bool> predicate;

			// Token: 0x04000025 RID: 37
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000025")]
			private List<TSource>.Enumerator enumerator;
		}

		// Token: 0x02000020 RID: 32
		[Token(Token = "0x2000020")]
		private class WhereSelectEnumerableIterator<TSource, TResult> : Enumerable.Iterator<TResult>
		{
			// Token: 0x06000118 RID: 280 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000118")]
			[Address(RVA = "0x27B64B0", Offset = "0x27B52B0", VA = "0x1827B64B0")]
			public WhereSelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
			{
			}

			// Token: 0x06000119 RID: 281 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000119")]
			[Address(RVA = "0x27B3E40", Offset = "0x27B2C40", VA = "0x1827B3E40", Slot = "11")]
			public override Enumerable.Iterator<TResult> Clone()
			{
				return null;
			}

			// Token: 0x0600011A RID: 282 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x600011A")]
			[Address(RVA = "0x2CA8140", Offset = "0x2CA6F40", VA = "0x182CA8140", Slot = "12")]
			public override void Dispose()
			{
			}

			// Token: 0x0600011B RID: 283 RVA: 0x000023E8 File Offset: 0x000005E8
			[Token(Token = "0x600011B")]
			[Address(RVA = "0x2CABC70", Offset = "0x2CAAA70", VA = "0x182CABC70", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x0600011C RID: 284 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600011C")]
			[Address(RVA = "0x15C5660", Offset = "0x15C4460", VA = "0x1815C5660", Slot = "14")]
			public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
			{
				return null;
			}

			// Token: 0x0600011D RID: 285 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600011D")]
			[Address(RVA = "0x2A75620", Offset = "0x2A74420", VA = "0x182A75620", Slot = "15")]
			public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
			{
				return null;
			}

			// Token: 0x04000026 RID: 38
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000026")]
			private IEnumerable<TSource> source;

			// Token: 0x04000027 RID: 39
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000027")]
			private Func<TSource, bool> predicate;

			// Token: 0x04000028 RID: 40
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000028")]
			private Func<TSource, TResult> selector;

			// Token: 0x04000029 RID: 41
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000029")]
			private IEnumerator<TSource> enumerator;
		}

		// Token: 0x02000021 RID: 33
		[Token(Token = "0x2000021")]
		private class WhereSelectArrayIterator<TSource, TResult> : Enumerable.Iterator<TResult>
		{
			// Token: 0x0600011E RID: 286 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x600011E")]
			[Address(RVA = "0x27B64B0", Offset = "0x27B52B0", VA = "0x1827B64B0")]
			public WhereSelectArrayIterator(TSource[] source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
			{
			}

			// Token: 0x0600011F RID: 287 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600011F")]
			[Address(RVA = "0x27B3E40", Offset = "0x27B2C40", VA = "0x1827B3E40", Slot = "11")]
			public override Enumerable.Iterator<TResult> Clone()
			{
				return null;
			}

			// Token: 0x06000120 RID: 288 RVA: 0x00002400 File Offset: 0x00000600
			[Token(Token = "0x6000120")]
			[Address(RVA = "0x2870310", Offset = "0x286F110", VA = "0x182870310", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x06000121 RID: 289 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000121")]
			[Address(RVA = "0x15C5660", Offset = "0x15C4460", VA = "0x1815C5660", Slot = "14")]
			public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
			{
				return null;
			}

			// Token: 0x06000122 RID: 290 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000122")]
			[Address(RVA = "0x28727A0", Offset = "0x28715A0", VA = "0x1828727A0", Slot = "15")]
			public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
			{
				return null;
			}

			// Token: 0x0400002A RID: 42
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400002A")]
			private TSource[] source;

			// Token: 0x0400002B RID: 43
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400002B")]
			private Func<TSource, bool> predicate;

			// Token: 0x0400002C RID: 44
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400002C")]
			private Func<TSource, TResult> selector;

			// Token: 0x0400002D RID: 45
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400002D")]
			private int index;
		}

		// Token: 0x02000022 RID: 34
		[Token(Token = "0x2000022")]
		private class WhereSelectListIterator<TSource, TResult> : Enumerable.Iterator<TResult>
		{
			// Token: 0x06000123 RID: 291 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000123")]
			[Address(RVA = "0x27B64B0", Offset = "0x27B52B0", VA = "0x1827B64B0")]
			public WhereSelectListIterator(List<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
			{
			}

			// Token: 0x06000124 RID: 292 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000124")]
			[Address(RVA = "0x27B3E40", Offset = "0x27B2C40", VA = "0x1827B3E40", Slot = "11")]
			public override Enumerable.Iterator<TResult> Clone()
			{
				return null;
			}

			// Token: 0x06000125 RID: 293 RVA: 0x00002418 File Offset: 0x00000618
			[Token(Token = "0x6000125")]
			[Address(RVA = "0x2A757E0", Offset = "0x2A745E0", VA = "0x182A757E0", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x06000126 RID: 294 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000126")]
			[Address(RVA = "0x15C5660", Offset = "0x15C4460", VA = "0x1815C5660", Slot = "14")]
			public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
			{
				return null;
			}

			// Token: 0x06000127 RID: 295 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000127")]
			[Address(RVA = "0x27B62E0", Offset = "0x27B50E0", VA = "0x1827B62E0", Slot = "15")]
			public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
			{
				return null;
			}

			// Token: 0x0400002E RID: 46
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400002E")]
			private List<TSource> source;

			// Token: 0x0400002F RID: 47
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400002F")]
			private Func<TSource, bool> predicate;

			// Token: 0x04000030 RID: 48
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000030")]
			private Func<TSource, TResult> selector;

			// Token: 0x04000031 RID: 49
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000031")]
			private List<TSource>.Enumerator enumerator;
		}
	}
}