27Aug2021-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: 0x0200001F RID: 31
	[Token(Token = "0x200001F")]
	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: 0x060000C6 RID: 198 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C6")]
		[Address(RVA = "0x1CBE8C0", Offset = "0x1CBD8C0", VA = "0x181CBE8C0")]
		public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return null;
		}

		// Token: 0x060000C7 RID: 199 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C7")]
		[Address(RVA = "0x1F83A70", Offset = "0x1F82A70", VA = "0x181F83A70")]
		public static IEnumerable<TResult> Select<TResult, TSource>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
		{
			return null;
		}

		// Token: 0x060000C8 RID: 200 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C8")]
		[Address(RVA = "0x1F8F520", Offset = "0x1F8E520", VA = "0x181F8F520")]
		public static IEnumerable<TResult> Select<TResult, TSource>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
		{
			return null;
		}

		// Token: 0x060000C9 RID: 201 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000C9")]
		[Address(RVA = "0x1F80A00", Offset = "0x1F7FA00", VA = "0x181F80A00")]
		private static IEnumerable<TResult> SelectIterator<TResult, TSource>(IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
		{
			return null;
		}

		// Token: 0x060000CA RID: 202 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CA")]
		[Address(RVA = "0x3166080", Offset = "0x3165080", VA = "0x183166080")]
		private static Func<TSource, bool> CombinePredicates<TSource>(Func<TSource, bool> predicate1, Func<TSource, bool> predicate2)
		{
			return null;
		}

		// Token: 0x060000CB RID: 203 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CB")]
		[Address(RVA = "0x2388A70", Offset = "0x2387A70", VA = "0x182388A70")]
		private static Func<TSource, TResult> CombineSelectors<TSource, TResult, TMiddle>(Func<TSource, TMiddle> selector1, Func<TMiddle, TResult> selector2)
		{
			return null;
		}

		// Token: 0x060000CC RID: 204 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CC")]
		[Address(RVA = "0x1F81350", Offset = "0x1F80350", VA = "0x181F81350")]
		public static IEnumerable<TResult> SelectMany<TResult, TSource>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
		{
			return null;
		}

		// Token: 0x060000CD RID: 205 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CD")]
		[Address(RVA = "0x1CC4110", Offset = "0x1CC3110", VA = "0x181CC4110")]
		private static IEnumerable<TResult> SelectManyIterator<TResult, TSource>(IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
		{
			return null;
		}

		// Token: 0x060000CE RID: 206 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CE")]
		[Address(RVA = "0x1F81490", Offset = "0x1F80490", VA = "0x181F81490")]
		public static IEnumerable<TResult> SelectMany<TResult, TSource>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
		{
			return null;
		}

		// Token: 0x060000CF RID: 207 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000CF")]
		[Address(RVA = "0x1F7FAA0", Offset = "0x1F7EAA0", VA = "0x181F7FAA0")]
		private static IEnumerable<TResult> SelectManyIterator<TResult, TSource>(IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
		{
			return null;
		}

		// Token: 0x060000D0 RID: 208 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D0")]
		[Address(RVA = "0x1F81280", Offset = "0x1F80280", VA = "0x181F81280")]
		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: 0x060000D1 RID: 209 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D1")]
		[Address(RVA = "0x1F80C40", Offset = "0x1F7FC40", VA = "0x181F80C40")]
		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: 0x060000D2 RID: 210 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D2")]
		[Address(RVA = "0x1CBC210", Offset = "0x1CBB210", VA = "0x181CBC210")]
		public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
		{
			return null;
		}

		// Token: 0x060000D3 RID: 211 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D3")]
		[Address(RVA = "0x1CBB990", Offset = "0x1CBA990", VA = "0x181CBB990")]
		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: 0x060000D4 RID: 212 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D4")]
		[Address(RVA = "0x1CBB710", Offset = "0x1CBA710", VA = "0x181CBB710")]
		public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
		{
			return null;
		}

		// Token: 0x060000D5 RID: 213 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D5")]
		[Address(RVA = "0x1CBB390", Offset = "0x1CBA390", VA = "0x181CBB390")]
		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: 0x060000D6 RID: 214 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D6")]
		[Address(RVA = "0x27D5C40", Offset = "0x27D4C40", VA = "0x1827D5C40")]
		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: 0x060000D7 RID: 215 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D7")]
		[Address(RVA = "0x27D5CC0", Offset = "0x27D4CC0", VA = "0x1827D5CC0")]
		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: 0x060000D8 RID: 216 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D8")]
		[Address(RVA = "0x27D5B30", Offset = "0x27D4B30", VA = "0x1827D5B30")]
		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: 0x060000D9 RID: 217 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000D9")]
		[Address(RVA = "0x27D5BB0", Offset = "0x27D4BB0", VA = "0x1827D5BB0")]
		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: 0x060000DA RID: 218 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DA")]
		[Address(RVA = "0x27D61C0", Offset = "0x27D51C0", VA = "0x1827D61C0")]
		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: 0x060000DB RID: 219 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DB")]
		[Address(RVA = "0x27D5F20", Offset = "0x27D4F20", VA = "0x1827D5F20")]
		public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		// Token: 0x060000DC RID: 220 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DC")]
		[Address(RVA = "0x2466B00", Offset = "0x2465B00", VA = "0x182466B00")]
		public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TKey, TSource>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		// Token: 0x060000DD RID: 221 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DD")]
		[Address(RVA = "0x2466BA0", Offset = "0x2465BA0", VA = "0x182466BA0")]
		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: 0x060000DE RID: 222 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DE")]
		[Address(RVA = "0x1F7F830", Offset = "0x1F7E830", VA = "0x181F7F830")]
		public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
		{
			return null;
		}

		// Token: 0x060000DF RID: 223 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000DF")]
		[Address(RVA = "0x1F7F400", Offset = "0x1F7E400", VA = "0x181F7F400")]
		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: 0x060000E0 RID: 224 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E0")]
		[Address(RVA = "0x1F7F260", Offset = "0x1F7E260", VA = "0x181F7F260")]
		public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource element)
		{
			return null;
		}

		// Token: 0x060000E1 RID: 225 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E1")]
		[Address(RVA = "0x1F7F1D0", Offset = "0x1F7E1D0", VA = "0x181F7F1D0")]
		private static IEnumerable<TSource> AppendIterator<TSource>(IEnumerable<TSource> source, TSource element)
		{
			return null;
		}

		/// <summary>Adds a value to the beginning of the sequence.</summary>
		/// <param name="source">A sequence of values. </param>
		/// <param name="element">The value to prepend to <paramref name="source" />. </param>
		/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
		/// <returns>A new sequence that begins with <paramref name="element" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="source" /> is <see langword="null" />. </exception>
		// Token: 0x060000E2 RID: 226 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E2")]
		[Address(RVA = "0x1F80710", Offset = "0x1F7F710", VA = "0x181F80710")]
		public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource element)
		{
			return null;
		}

		// Token: 0x060000E3 RID: 227 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E3")]
		[Address(RVA = "0x1F7FCC0", Offset = "0x1F7ECC0", VA = "0x181F7FCC0")]
		private static IEnumerable<TSource> PrependIterator<TSource>(IEnumerable<TSource> source, TSource element)
		{
			return null;
		}

		// Token: 0x060000E4 RID: 228 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E4")]
		[Address(RVA = "0x1F97850", Offset = "0x1F96850", VA = "0x181F97850")]
		public static IEnumerable<TResult> Zip<TResult, TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
		{
			return null;
		}

		// Token: 0x060000E5 RID: 229 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E5")]
		[Address(RVA = "0x1F974D0", Offset = "0x1F964D0", VA = "0x181F974D0")]
		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: 0x060000E6 RID: 230 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E6")]
		[Address(RVA = "0x1F7FF10", Offset = "0x1F7EF10", VA = "0x181F7FF10")]
		public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		// Token: 0x060000E7 RID: 231 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E7")]
		[Address(RVA = "0x1F7FC30", Offset = "0x1F7EC30", VA = "0x181F7FC30")]
		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: 0x060000E8 RID: 232 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E8")]
		[Address(RVA = "0x1CBC630", Offset = "0x1CBB630", VA = "0x181CBC630")]
		public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
		{
			return null;
		}

		// Token: 0x060000E9 RID: 233 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000E9")]
		[Address(RVA = "0x1CBC310", Offset = "0x1CBB310", VA = "0x181CBC310")]
		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: 0x060000EA RID: 234 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000EA")]
		[Address(RVA = "0x1F80670", Offset = "0x1F7F670", VA = "0x181F80670")]
		public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
		{
			return null;
		}

		// Token: 0x060000EB RID: 235 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000EB")]
		[Address(RVA = "0x1F7FF80", Offset = "0x1F7EF80", VA = "0x181F7FF80")]
		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: 0x060000EC RID: 236 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000EC")]
		[Address(RVA = "0x1F80490", Offset = "0x1F7F490", VA = "0x181F80490")]
		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: 0x060000ED RID: 237 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000ED")]
		[Address(RVA = "0x1F803E0", Offset = "0x1F7F3E0", VA = "0x181F803E0")]
		public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
		{
			return null;
		}

		// Token: 0x060000EE RID: 238 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000EE")]
		[Address(RVA = "0x1F800C0", Offset = "0x1F7F0C0", VA = "0x181F800C0")]
		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: 0x060000EF RID: 239 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000EF")]
		[Address(RVA = "0x1F80800", Offset = "0x1F7F800", VA = "0x181F80800")]
		public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		// Token: 0x060000F0 RID: 240 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000F0")]
		[Address(RVA = "0x1CEEC90", Offset = "0x1CEDC90", VA = "0x181CEEC90")]
		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: 0x060000F1 RID: 241 RVA: 0x00002340 File Offset: 0x00000540
		[Token(Token = "0x60000F1")]
		[Address(RVA = "0x21B2F10", Offset = "0x21B1F10", VA = "0x1821B2F10")]
		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: 0x060000F2 RID: 242 RVA: 0x00002358 File Offset: 0x00000558
		[Token(Token = "0x60000F2")]
		[Address(RVA = "0x21B2BA0", Offset = "0x21B1BA0", VA = "0x1821B2BA0")]
		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: 0x060000F3 RID: 243 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000F3")]
		[Address(RVA = "0x4A65C0", Offset = "0x4A55C0", VA = "0x1804A65C0")]
		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: 0x060000F4 RID: 244 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000F4")]
		[Address(RVA = "0x29460C0", Offset = "0x29450C0", VA = "0x1829460C0")]
		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: 0x060000F5 RID: 245 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000F5")]
		[Address(RVA = "0x31D74D0", Offset = "0x31D64D0", VA = "0x1831D74D0")]
		public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
		{
			return null;
		}

		// Token: 0x060000F6 RID: 246 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000F6")]
		[Address(RVA = "0x2467580", Offset = "0x2466580", VA = "0x182467580")]
		public static Dictionary<TKey, TSource> ToDictionary<TKey, TSource>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return null;
		}

		// Token: 0x060000F7 RID: 247 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000F7")]
		[Address(RVA = "0x1E7CCA0", Offset = "0x1E7BCA0", VA = "0x181E7CCA0")]
		public static Dictionary<TKey, TElement> ToDictionary<TKey, TElement, TSource>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
		{
			return null;
		}

		// Token: 0x060000F8 RID: 248 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000F8")]
		[Address(RVA = "0x2466C30", Offset = "0x2465C30", VA = "0x182466C30")]
		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: 0x060000F9 RID: 249 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000F9")]
		[Address(RVA = "0x2467580", Offset = "0x2466580", VA = "0x182467580")]
		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: 0x060000FA RID: 250 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000FA")]
		[Address(RVA = "0x1F7FB30", Offset = "0x1F7EB30", VA = "0x181F7FB30")]
		public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source, TSource defaultValue)
		{
			return null;
		}

		// Token: 0x060000FB RID: 251 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000FB")]
		[Address(RVA = "0x1F7FA10", Offset = "0x1F7EA10", VA = "0x181F7FA10")]
		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: 0x060000FC RID: 252 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000FC")]
		[Address(RVA = "0x1CEF090", Offset = "0x1CEE090", VA = "0x181CEF090")]
		public static IEnumerable<TResult> OfType<TResult>(this IEnumerable source)
		{
			return null;
		}

		// Token: 0x060000FD RID: 253 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000FD")]
		[Address(RVA = "0x1CEEC90", Offset = "0x1CEDC90", VA = "0x181CEEC90")]
		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: 0x060000FE RID: 254 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000FE")]
		[Address(RVA = "0x1CEEFF0", Offset = "0x1CEDFF0", VA = "0x181CEEFF0")]
		public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source)
		{
			return null;
		}

		// Token: 0x060000FF RID: 255 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60000FF")]
		[Address(RVA = "0x1CEEC20", Offset = "0x1CEDC20", VA = "0x181CEEC20")]
		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: 0x06000100 RID: 256 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000100")]
		[Address(RVA = "0x1E569D0", Offset = "0x1E559D0", VA = "0x181E569D0")]
		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: 0x06000101 RID: 257 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000101")]
		[Address(RVA = "0x2941C70", Offset = "0x2940C70", VA = "0x182941C70")]
		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: 0x06000102 RID: 258 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000102")]
		[Address(RVA = "0x2941190", Offset = "0x2940190", VA = "0x182941190")]
		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: 0x06000103 RID: 259 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000103")]
		[Address(RVA = "0x2940FB0", Offset = "0x293FFB0", VA = "0x182940FB0")]
		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: 0x06000104 RID: 260 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000104")]
		[Address(RVA = "0x2944050", Offset = "0x2943050", VA = "0x182944050")]
		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: 0x06000105 RID: 261 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000105")]
		[Address(RVA = "0x2944360", Offset = "0x2943360", VA = "0x182944360")]
		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: 0x06000106 RID: 262 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000106")]
		[Address(RVA = "0x2943290", Offset = "0x2942290", VA = "0x182943290")]
		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: 0x06000107 RID: 263 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000107")]
		[Address(RVA = "0x2943080", Offset = "0x2942080", VA = "0x182943080")]
		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: 0x06000108 RID: 264 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000108")]
		[Address(RVA = "0x2945470", Offset = "0x2944470", VA = "0x182945470")]
		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: 0x06000109 RID: 265 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000109")]
		[Address(RVA = "0x29456F0", Offset = "0x29446F0", VA = "0x1829456F0")]
		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: 0x0600010A RID: 266 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600010A")]
		[Address(RVA = "0x2944CF0", Offset = "0x2943CF0", VA = "0x182944CF0")]
		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: 0x0600010B RID: 267 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600010B")]
		[Address(RVA = "0x2944F60", Offset = "0x2943F60", VA = "0x182944F60")]
		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: 0x0600010C RID: 268 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600010C")]
		[Address(RVA = "0x1E56470", Offset = "0x1E55470", VA = "0x181E56470")]
		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: 0x0600010D RID: 269 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600010D")]
		[Address(RVA = "0x1E55CD0", Offset = "0x1E54CD0", VA = "0x181E55CD0")]
		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: 0x0600010E RID: 270 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600010E")]
		[Address(RVA = "0x861CD0", Offset = "0x860CD0", VA = "0x180861CD0")]
		public static IEnumerable<int> Range(int start, int count)
		{
			return null;
		}

		// Token: 0x0600010F RID: 271 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600010F")]
		[Address(RVA = "0x861C50", Offset = "0x860C50", VA = "0x180861C50")]
		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: 0x06000110 RID: 272 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000110")]
		[Address(RVA = "0x1CEF1F0", Offset = "0x1CEE1F0", VA = "0x181CEF1F0")]
		public static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)
		{
			return null;
		}

		// Token: 0x06000111 RID: 273 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000111")]
		[Address(RVA = "0x1CEF170", Offset = "0x1CEE170", VA = "0x181CEF170")]
		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: 0x06000112 RID: 274 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000112")]
		[Address(RVA = "0x4F5590", Offset = "0x4F4590", VA = "0x1804F5590")]
		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: 0x06000113 RID: 275 RVA: 0x00002370 File Offset: 0x00000570
		[Token(Token = "0x6000113")]
		[Address(RVA = "0x21B0CE0", Offset = "0x21AFCE0", VA = "0x1821B0CE0")]
		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: 0x06000114 RID: 276 RVA: 0x00002388 File Offset: 0x00000588
		[Token(Token = "0x6000114")]
		[Address(RVA = "0x21B0E50", Offset = "0x21AFE50", VA = "0x1821B0E50")]
		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: 0x06000115 RID: 277 RVA: 0x000023A0 File Offset: 0x000005A0
		[Token(Token = "0x6000115")]
		[Address(RVA = "0x21ACF20", Offset = "0x21ABF20", VA = "0x1821ACF20")]
		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: 0x06000116 RID: 278 RVA: 0x000023B8 File Offset: 0x000005B8
		[Token(Token = "0x6000116")]
		[Address(RVA = "0x27D5300", Offset = "0x27D4300", VA = "0x1827D5300")]
		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: 0x06000117 RID: 279 RVA: 0x000023D0 File Offset: 0x000005D0
		[Token(Token = "0x6000117")]
		[Address(RVA = "0x27D54F0", Offset = "0x27D44F0", VA = "0x1827D54F0")]
		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: 0x06000118 RID: 280 RVA: 0x000023E8 File Offset: 0x000005E8
		[Token(Token = "0x6000118")]
		[Address(RVA = "0x21B2AF0", Offset = "0x21B1AF0", VA = "0x1821B2AF0")]
		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: 0x06000119 RID: 281 RVA: 0x00002400 File Offset: 0x00000600
		[Token(Token = "0x6000119")]
		[Address(RVA = "0x21B25E0", Offset = "0x21B15E0", VA = "0x1821B25E0")]
		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: 0x0600011A RID: 282 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600011A")]
		[Address(RVA = "0x1E55150", Offset = "0x1E54150", VA = "0x181E55150")]
		public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func)
		{
			return null;
		}

		// Token: 0x0600011B RID: 283 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600011B")]
		[Address(RVA = "0x1E533B0", Offset = "0x1E523B0", VA = "0x181E533B0")]
		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: 0x0600011C RID: 284 RVA: 0x00002418 File Offset: 0x00000618
		[Token(Token = "0x600011C")]
		[Address(RVA = "0x862090", Offset = "0x861090", VA = "0x180862090")]
		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: 0x0600011D RID: 285 RVA: 0x00002430 File Offset: 0x00000630
		[Token(Token = "0x600011D")]
		[Address(RVA = "0x861F20", Offset = "0x860F20", VA = "0x180861F20")]
		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: 0x0600011E RID: 286 RVA: 0x00002448 File Offset: 0x00000648
		[Token(Token = "0x600011E")]
		[Address(RVA = "0x861D90", Offset = "0x860D90", VA = "0x180861D90")]
		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: 0x0600011F RID: 287 RVA: 0x00002460 File Offset: 0x00000660
		[Token(Token = "0x600011F")]
		[Address(RVA = "0x27D5D70", Offset = "0x27D4D70", VA = "0x1827D5D70")]
		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: 0x06000120 RID: 288 RVA: 0x00002478 File Offset: 0x00000678
		[Token(Token = "0x6000120")]
		[Address(RVA = "0x27D5D50", Offset = "0x27D4D50", VA = "0x1827D5D50")]
		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: 0x06000121 RID: 289 RVA: 0x00002490 File Offset: 0x00000690
		[Token(Token = "0x6000121")]
		[Address(RVA = "0x25F3BE0", Offset = "0x25F2BE0", VA = "0x1825F3BE0")]
		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: 0x06000122 RID: 290 RVA: 0x000024A8 File Offset: 0x000006A8
		[Token(Token = "0x6000122")]
		[Address(RVA = "0x861A80", Offset = "0x860A80", VA = "0x180861A80")]
		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: 0x06000123 RID: 291 RVA: 0x000024C0 File Offset: 0x000006C0
		[Token(Token = "0x6000123")]
		[Address(RVA = "0x861880", Offset = "0x860880", VA = "0x180861880")]
		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: 0x06000124 RID: 292 RVA: 0x000024D8 File Offset: 0x000006D8
		[Token(Token = "0x6000124")]
		[Address(RVA = "0x27D5B10", Offset = "0x27D4B10", VA = "0x1827D5B10")]
		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: 0x06000125 RID: 293 RVA: 0x000024F0 File Offset: 0x000006F0
		[Token(Token = "0x6000125")]
		[Address(RVA = "0x25F3BC0", Offset = "0x25F2BC0", VA = "0x1825F3BC0")]
		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: 0x06000126 RID: 294 RVA: 0x00002508 File Offset: 0x00000708
		[Token(Token = "0x6000126")]
		[Address(RVA = "0x861320", Offset = "0x860320", VA = "0x180861320")]
		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: 0x06000127 RID: 295 RVA: 0x00002520 File Offset: 0x00000720
		[Token(Token = "0x6000127")]
		[Address(RVA = "0x8616A0", Offset = "0x8606A0", VA = "0x1808616A0")]
		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: 0x06000128 RID: 296 RVA: 0x00002538 File Offset: 0x00000738
		[Token(Token = "0x6000128")]
		[Address(RVA = "0x8614F0", Offset = "0x8604F0", VA = "0x1808614F0")]
		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: 0x06000129 RID: 297 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000129")]
		[Address(RVA = "0x2944590", Offset = "0x2943590", VA = "0x182944590")]
		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: 0x0600012A RID: 298 RVA: 0x00002550 File Offset: 0x00000750
		[Token(Token = "0x600012A")]
		[Address(RVA = "0x27D5AF0", Offset = "0x27D4AF0", VA = "0x1827D5AF0")]
		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: 0x0600012B RID: 299 RVA: 0x00002568 File Offset: 0x00000768
		[Token(Token = "0x600012B")]
		[Address(RVA = "0x27D5AD0", Offset = "0x27D4AD0", VA = "0x1827D5AD0")]
		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: 0x0600012C RID: 300 RVA: 0x00002580 File Offset: 0x00000780
		[Token(Token = "0x600012C")]
		[Address(RVA = "0x25F3BA0", Offset = "0x25F2BA0", VA = "0x1825F3BA0")]
		public static float Max<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
		{
			return 0f;
		}

		// Token: 0x0600012D RID: 301 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600012D")]
		[Address(RVA = "0x1E58250", Offset = "0x1E57250", VA = "0x181E58250")]
		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: 0x0600012E RID: 302 RVA: 0x00002598 File Offset: 0x00000798
		[Token(Token = "0x600012E")]
		[Address(RVA = "0x861120", Offset = "0x860120", VA = "0x180861120")]
		public static double Average(this IEnumerable<int> source)
		{
			return 0.0;
		}

		// Token: 0x02000020 RID: 32
		[Token(Token = "0x2000020")]
		private abstract class Iterator<TSource> : IEnumerable<TSource>, IEnumerable, IEnumerator<TSource>, IDisposable, IEnumerator
		{
			// Token: 0x0600012F RID: 303 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x600012F")]
			[Address(RVA = "0x3013750", Offset = "0x3012750", VA = "0x183013750")]
			public Iterator()
			{
			}

			// Token: 0x17000018 RID: 24
			// (get) Token: 0x06000130 RID: 304 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x17000018")]
			public TSource Current
			{
				[Token(Token = "0x6000130")]
				[Address(RVA = "0x1CD7000", Offset = "0x1CD6000", VA = "0x181CD7000", Slot = "6")]
				get
				{
					return null;
				}
			}

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

			// Token: 0x06000132 RID: 306 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000132")]
			[Address(RVA = "0x30FE3C0", Offset = "0x30FD3C0", VA = "0x1830FE3C0", Slot = "12")]
			public virtual void Dispose()
			{
			}

			// Token: 0x06000133 RID: 307 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000133")]
			[Address(RVA = "0x3013600", Offset = "0x3012600", VA = "0x183013600", Slot = "4")]
			public IEnumerator<TSource> GetEnumerator()
			{
				return null;
			}

			// Token: 0x06000134 RID: 308
			[Token(Token = "0x6000134")]
			[Address(Slot = "13")]
			public abstract bool MoveNext();

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

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

			// Token: 0x17000019 RID: 25
			// (get) Token: 0x06000137 RID: 311 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x17000019")]
			object IEnumerator.Current
			{
				[Token(Token = "0x6000137")]
				[Address(RVA = "0x3100990", Offset = "0x30FF990", VA = "0x183100990", Slot = "9")]
				get
				{
					return null;
				}
			}

			// Token: 0x06000138 RID: 312 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000138")]
			[Address(RVA = "0x1CD4C20", Offset = "0x1CD3C20", VA = "0x181CD4C20", Slot = "5")]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return null;
			}

			// Token: 0x06000139 RID: 313 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000139")]
			[Address(RVA = "0x30FE880", Offset = "0x30FD880", VA = "0x1830FE880", Slot = "10")]
			void IEnumerator.Reset()
			{
			}

			// Token: 0x04000037 RID: 55
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000037")]
			private int threadId;

			// Token: 0x04000038 RID: 56
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000038")]
			internal int state;

			// Token: 0x04000039 RID: 57
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000039")]
			internal TSource current;
		}

		// Token: 0x02000021 RID: 33
		[Token(Token = "0x2000021")]
		private class WhereEnumerableIterator<TSource> : Enumerable.Iterator<TSource>
		{
			// Token: 0x0600013A RID: 314 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x600013A")]
			[Address(RVA = "0x301EB20", Offset = "0x301DB20", VA = "0x18301EB20")]
			public WhereEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate)
			{
			}

			// Token: 0x0600013B RID: 315 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600013B")]
			[Address(RVA = "0x30147B0", Offset = "0x30137B0", VA = "0x1830147B0", Slot = "11")]
			public override Enumerable.Iterator<TSource> Clone()
			{
				return null;
			}

			// Token: 0x0600013C RID: 316 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x600013C")]
			[Address(RVA = "0x3016600", Offset = "0x3015600", VA = "0x183016600", Slot = "12")]
			public override void Dispose()
			{
			}

			// Token: 0x0600013D RID: 317 RVA: 0x000025B0 File Offset: 0x000007B0
			[Token(Token = "0x600013D")]
			[Address(RVA = "0x301D920", Offset = "0x301C920", VA = "0x18301D920", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x0600013E RID: 318 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600013E")]
			[Address(RVA = "0x1CF2DC0", Offset = "0x1CF1DC0", VA = "0x181CF2DC0", Slot = "14")]
			public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
			{
				return null;
			}

			// Token: 0x0600013F RID: 319 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600013F")]
			[Address(RVA = "0x301E8A0", Offset = "0x301D8A0", VA = "0x18301E8A0", Slot = "15")]
			public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
			{
				return null;
			}

			// Token: 0x0400003A RID: 58
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400003A")]
			private IEnumerable<TSource> source;

			// Token: 0x0400003B RID: 59
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400003B")]
			private Func<TSource, bool> predicate;

			// Token: 0x0400003C RID: 60
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400003C")]
			private IEnumerator<TSource> enumerator;
		}

		// Token: 0x02000022 RID: 34
		[Token(Token = "0x2000022")]
		private class WhereArrayIterator<TSource> : Enumerable.Iterator<TSource>
		{
			// Token: 0x06000140 RID: 320 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000140")]
			[Address(RVA = "0x29710D0", Offset = "0x29700D0", VA = "0x1829710D0")]
			public WhereArrayIterator(TSource[] source, Func<TSource, bool> predicate)
			{
			}

			// Token: 0x06000141 RID: 321 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000141")]
			[Address(RVA = "0x296FD00", Offset = "0x296ED00", VA = "0x18296FD00", Slot = "11")]
			public override Enumerable.Iterator<TSource> Clone()
			{
				return null;
			}

			// Token: 0x06000142 RID: 322 RVA: 0x000025C8 File Offset: 0x000007C8
			[Token(Token = "0x6000142")]
			[Address(RVA = "0x30141C0", Offset = "0x30131C0", VA = "0x1830141C0", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x06000143 RID: 323 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000143")]
			[Address(RVA = "0x1CF2E50", Offset = "0x1CF1E50", VA = "0x181CF2E50", Slot = "14")]
			public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
			{
				return null;
			}

			// Token: 0x06000144 RID: 324 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000144")]
			[Address(RVA = "0x3014530", Offset = "0x3013530", VA = "0x183014530", Slot = "15")]
			public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
			{
				return null;
			}

			// Token: 0x0400003D RID: 61
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400003D")]
			private TSource[] source;

			// Token: 0x0400003E RID: 62
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400003E")]
			private Func<TSource, bool> predicate;

			// Token: 0x0400003F RID: 63
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400003F")]
			private int index;
		}

		// Token: 0x02000023 RID: 35
		[Token(Token = "0x2000023")]
		private class WhereListIterator<TSource> : Enumerable.Iterator<TSource>
		{
			// Token: 0x06000145 RID: 325 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000145")]
			[Address(RVA = "0x29710D0", Offset = "0x29700D0", VA = "0x1829710D0")]
			public WhereListIterator(List<TSource> source, Func<TSource, bool> predicate)
			{
			}

			// Token: 0x06000146 RID: 326 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000146")]
			[Address(RVA = "0x296FD00", Offset = "0x296ED00", VA = "0x18296FD00", Slot = "11")]
			public override Enumerable.Iterator<TSource> Clone()
			{
				return null;
			}

			// Token: 0x06000147 RID: 327 RVA: 0x000025E0 File Offset: 0x000007E0
			[Token(Token = "0x6000147")]
			[Address(RVA = "0x2970900", Offset = "0x296F900", VA = "0x182970900", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x06000148 RID: 328 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000148")]
			[Address(RVA = "0x1CF2E50", Offset = "0x1CF1E50", VA = "0x181CF2E50", Slot = "14")]
			public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
			{
				return null;
			}

			// Token: 0x06000149 RID: 329 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000149")]
			[Address(RVA = "0x2970FE0", Offset = "0x296FFE0", VA = "0x182970FE0", Slot = "15")]
			public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
			{
				return null;
			}

			// Token: 0x04000040 RID: 64
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000040")]
			private List<TSource> source;

			// Token: 0x04000041 RID: 65
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000041")]
			private Func<TSource, bool> predicate;

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

		// Token: 0x02000024 RID: 36
		[Token(Token = "0x2000024")]
		private class WhereSelectEnumerableIterator<TSource, TResult> : Enumerable.Iterator<TResult>
		{
			// Token: 0x0600014A RID: 330 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x600014A")]
			[Address(RVA = "0x2972A40", Offset = "0x2971A40", VA = "0x182972A40")]
			public WhereSelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
			{
			}

			// Token: 0x0600014B RID: 331 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600014B")]
			[Address(RVA = "0x29711C0", Offset = "0x29701C0", VA = "0x1829711C0", Slot = "11")]
			public override Enumerable.Iterator<TResult> Clone()
			{
				return null;
			}

			// Token: 0x0600014C RID: 332 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x600014C")]
			[Address(RVA = "0x301F1B0", Offset = "0x301E1B0", VA = "0x18301F1B0", Slot = "12")]
			public override void Dispose()
			{
			}

			// Token: 0x0600014D RID: 333 RVA: 0x000025F8 File Offset: 0x000007F8
			[Token(Token = "0x600014D")]
			[Address(RVA = "0x301F290", Offset = "0x301E290", VA = "0x18301F290", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x0600014E RID: 334 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600014E")]
			[Address(RVA = "0x1CF2EE0", Offset = "0x1CF1EE0", VA = "0x181CF2EE0", Slot = "14")]
			public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
			{
				return null;
			}

			// Token: 0x0600014F RID: 335 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600014F")]
			[Address(RVA = "0x30128A0", Offset = "0x30118A0", VA = "0x1830128A0", Slot = "15")]
			public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
			{
				return null;
			}

			// Token: 0x04000043 RID: 67
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000043")]
			private IEnumerable<TSource> source;

			// Token: 0x04000044 RID: 68
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000044")]
			private Func<TSource, bool> predicate;

			// Token: 0x04000045 RID: 69
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000045")]
			private Func<TSource, TResult> selector;

			// Token: 0x04000046 RID: 70
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000046")]
			private IEnumerator<TSource> enumerator;
		}

		// Token: 0x02000025 RID: 37
		[Token(Token = "0x2000025")]
		private class WhereSelectArrayIterator<TSource, TResult> : Enumerable.Iterator<TResult>
		{
			// Token: 0x06000150 RID: 336 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000150")]
			[Address(RVA = "0x2972A40", Offset = "0x2971A40", VA = "0x182972A40")]
			public WhereSelectArrayIterator(TSource[] source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
			{
			}

			// Token: 0x06000151 RID: 337 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000151")]
			[Address(RVA = "0x29711C0", Offset = "0x29701C0", VA = "0x1829711C0", Slot = "11")]
			public override Enumerable.Iterator<TResult> Clone()
			{
				return null;
			}

			// Token: 0x06000152 RID: 338 RVA: 0x00002610 File Offset: 0x00000810
			[Token(Token = "0x6000152")]
			[Address(RVA = "0x29714E0", Offset = "0x29704E0", VA = "0x1829714E0", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x06000153 RID: 339 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000153")]
			[Address(RVA = "0x1CF2EE0", Offset = "0x1CF1EE0", VA = "0x181CF2EE0", Slot = "14")]
			public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
			{
				return null;
			}

			// Token: 0x06000154 RID: 340 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000154")]
			[Address(RVA = "0x29729C0", Offset = "0x29719C0", VA = "0x1829729C0", Slot = "15")]
			public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
			{
				return null;
			}

			// Token: 0x04000047 RID: 71
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000047")]
			private TSource[] source;

			// Token: 0x04000048 RID: 72
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000048")]
			private Func<TSource, bool> predicate;

			// Token: 0x04000049 RID: 73
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000049")]
			private Func<TSource, TResult> selector;

			// Token: 0x0400004A RID: 74
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400004A")]
			private int index;
		}

		// Token: 0x02000026 RID: 38
		[Token(Token = "0x2000026")]
		private class WhereSelectListIterator<TSource, TResult> : Enumerable.Iterator<TResult>
		{
			// Token: 0x06000155 RID: 341 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000155")]
			[Address(RVA = "0x2972A40", Offset = "0x2971A40", VA = "0x182972A40")]
			public WhereSelectListIterator(List<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
			{
			}

			// Token: 0x06000156 RID: 342 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000156")]
			[Address(RVA = "0x29711C0", Offset = "0x29701C0", VA = "0x1829711C0", Slot = "11")]
			public override Enumerable.Iterator<TResult> Clone()
			{
				return null;
			}

			// Token: 0x06000157 RID: 343 RVA: 0x00002628 File Offset: 0x00000828
			[Token(Token = "0x6000157")]
			[Address(RVA = "0x2E75540", Offset = "0x2E74540", VA = "0x182E75540", Slot = "13")]
			public override bool MoveNext()
			{
				return default(bool);
			}

			// Token: 0x06000158 RID: 344 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000158")]
			[Address(RVA = "0x1CF2EE0", Offset = "0x1CF1EE0", VA = "0x181CF2EE0", Slot = "14")]
			public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
			{
				return null;
			}

			// Token: 0x06000159 RID: 345 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000159")]
			[Address(RVA = "0x2E78170", Offset = "0x2E77170", VA = "0x182E78170", Slot = "15")]
			public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
			{
				return null;
			}

			// Token: 0x0400004B RID: 75
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400004B")]
			private List<TSource> source;

			// Token: 0x0400004C RID: 76
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400004C")]
			private Func<TSource, bool> predicate;

			// Token: 0x0400004D RID: 77
			[FieldOffset(Offset = "0x0")]
			[Token(Token = "0x400004D")]
			private Func<TSource, TResult> selector;

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