*scratch*.txt

public static TResult Aggregate<TSource, TAccumulate, TResult> (this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector) {
       return System.Linq.Aggregate(source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector) ;
}

public static TAccumulate Aggregate<TSource, TAccumulate> (this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func) {
       return System.Linq.Aggregate (source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func);
}

public static bool All<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.All (source, Func<TSource, bool> predicate);
}

public static bool Any<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.Any(source);
}

public static bool Any<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.Any(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static IEnumerable<TSource> AsEnumerable<TSource> (this IEnumerable<TSource> source) {r
       return System.Linq.AsEnumerable(IEnumerable<TSource> source);
}

public static double Average<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector) {r
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, double> selector);
}

public static double? Average (this IEnumerable<double?> source) {
       return System.Linq.Average(IEnumerable<double?> source);
}

public static double? Average (this IEnumerable<long?> source) {
       return System.Linq.Average(IEnumerable<long?> source);
}

public static double? Average (this IEnumerable<int?> source) {
       return System.Linq.Average(IEnumerable<int?> source);
}

public static decimal? Average (this IEnumerable<decimal?> source) {
       return System.Linq.Average(IEnumerable<decimal?> source);
}

public static float? Average (this IEnumerable<float?> source) {
       return System.Linq.Average(IEnumerable<float?> source);
}

public static double Average<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector) {
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, int> selector);
}

public static double? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector) {
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, int?> selector);
}

public static double Average<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector) {
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, long> selector);
}

public static double? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector) {
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, double?> selector);
}

public static decimal? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector) {
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, decimal?> selector);
}

public static decimal Average<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector) {
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, decimal> selector);
}

public static float? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector) {
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, float?> selector);
}

public static float Average<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector) {
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, float> selector);
}

public static double Average (this IEnumerable<int> source) {
       return System.Linq.Average(IEnumerable<int> source);
}

public static double Average (this IEnumerable<long> source) {
       return System.Linq.Average(IEnumerable<long> source);
}

public static double Average (this IEnumerable<double> source) {
       return System.Linq.Average(IEnumerable<double> source);
}

public static float Average (this IEnumerable<float> source) {
       return System.Linq.Average(IEnumerable<float> source);
}

public static decimal Average (this IEnumerable<decimal> source) {
       return System.Linq.Average(IEnumerable<decimal> source);
}

public static double? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector) {
       return System.Linq.Average(IEnumerable<TSource> source, Func<TSource, long?> selector);
}

public static IEnumerable<TResult> Cast<TResult> (this IEnumerable source) {
       return System.Linq.Cast<TResult>(IEnumerable source);
}

public static IEnumerable<TSource> Concat<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second) {
       return System.Linq.TSource(IEnumerable<TSource> first, IEnumerable<TSource> second);
}

public static bool Contains<TSource> (this IEnumerable<TSource> source, TSource value) {
       return System.Linq.Contains(IEnumerable<TSource> source, TSource value);
}

public static bool Contains<TSource> (this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer) {
       return System.Linq.Contains(IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer);
}

public static int Count<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.Count(IEnumerable<TSource> source);
}

public static int Count<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.Count(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static IEnumerable<TSource> DefaultIfEmpty<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.DefaultIfEmpty(IEnumerable<TSource> source);
}

public static IEnumerable<TSource> DefaultIfEmpty<TSource> (this IEnumerable<TSource> source, TSource defaultValue) {
       return System.Linq.DefaultIfEmpty(IEnumerable<TSource> source, TSource defaultValue);
}

public static IEnumerable<TSource> Distinct<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.TSource(IEnumerable<TSource> source);
}

public static IEnumerable<TSource> Distinct<TSource> (this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer) {
       return System.Linq.TSource(IEnumerable<TSource> source, IEqualityComparer<TSource> comparer);
}

public static TSource ElementAt<TSource> (this IEnumerable<TSource> source, int index) {
       return System.Linq.ElementAt(IEnumerable<TSource> source, int index);
}

public static TSource ElementAtOrDefault<TSource> (this IEnumerable<TSource> source, int index) {
       return System.Linq.ElementAtOrDefault(IEnumerable<TSource> source, int index);
}

public static IEnumerable<TResult> Empty<TResult> () {
       return System.Linq.Empty<TResult>();
}

public static IEnumerable<TSource> Except<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer) {
       return System.Linq.Except(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
}

public static IEnumerable<TSource> Except<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second) {
       return System.Linq.Except(IEnumerable<TSource> first, IEnumerable<TSource> second);
}

public static TSource First<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.First(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static TSource First<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.First(IEnumerable<TSource> source);
}

public static TSource FirstOrDefault<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.FirstOrDefault(IEnumerable<TSource> source);
}

public static TSource FirstOrDefault<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.FirstOrDefault(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) {
       return System.Linq.GroupBy(IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
}

public static IEnumerable<GroupBy<TKey, TSource>> GroupBy<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer) {
       return System.Linq.GroupBy(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
}

public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer) {
       return System.Linq.GroupBy(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer);
}

public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector) {
       return System.Linq.GroupBy(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector);
}

public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer) {
       return System.Linq.GroupBy(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer);
}

public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector) {
       return System.Linq.GroupBy(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector);
}

public static IEnumerable<GroupBy<TKey, TElement>> GroupBy<TSource, TKey, TElement> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer) {
       return System.Linq(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
}

public static IEnumerable<GroupBy<TKey, TElement>> GroupBy<TSource, TKey, TElement> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) {
       return System.Linq(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
}

public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector) {
       return System.Linq.GroupJoin(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector);
}

public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer) {
       return System.Linq.GroupJoin(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer);
}

public static IEnumerable<TSource> Intersect<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer) {
       return System.Linq.Instersect(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
}

public static IEnumerable<TSource> Intersect<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second) {
       return System.Linq.Intersect(IEnumerable<TSource> first, IEnumerable<TSource> second);
}

public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector) {
       return System.Linq.Join(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector);
}

public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer) {
       return System.Linq.Join(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer);
}

public static TSource Last<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.Last(IEnumerable<TSource> source);
}

public static TSource Last<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.Last(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static TSource LastOrDefault<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.LastOrDefault(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static TSource LastOrDefault<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.LastOrDefault(IEnumerable<TSource> source);
}

public static long LongCount<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.LongCount(IEnumerable<TSource> source);
}

public static long LongCount<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.LongCount(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static float Max (this IEnumerable<float> source) {
       return System.Linq.Max(IEnumerable<float> source);
}

public static double Max (this IEnumerable<double> source) {
       return System.Linq.Max(IEnumerable<double> source);
}

public static long Max (this IEnumerable<long> source) {
       return System.Linq.Max(IEnumerable<long> source);
}

public static int Max (this IEnumerable<int> source) {
       return System.Linq.Max(IEnumerable<int> source);
}

public static long? Max (this IEnumerable<long?> source) {
       return System.Linq.?Max(IEnumerable<long?> source);
}

public static decimal Max (this IEnumerable<decimal> source) {
       return System.Linq.Max(IEnumerable<decimal> source);
}

public static double Max<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, double> selector);
}

public static long Max<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, long> selector);
}

public static int Max<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, int> selector);
}

public static TSource Max<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.Max(IEnumerable<TSource> source);
}

public static decimal? Max (this IEnumerable<decimal?> source) {
       return System.Linq.Max(IEnumerable<decimal?> source);
}

public static float? Max (this IEnumerable<float?> source) {
       return System.Linq.Max(IEnumerable<float?> source);
}

public static double? Max (this IEnumerable<double?> source) {
       return System.Linq.Max(IEnumerable<double?> source);
}

public static float Max<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, float> selector);
}

public static int? Max (this IEnumerable<int?> source) {
       return System.Linq.Max(IEnumerable<int?> source);
}

public static TResult Max<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, TResult> selector);
}

public static decimal? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, decimal?> selector);
}

public static float? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, float?> selector);
}

public static decimal Max<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, decimal> selector);
}

public static int? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, int?> selector);
}

public static long? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, long?> selector);
}

public static double? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector) {
       return System.Linq.Max(IEnumerable<TSource> source, Func<TSource, double?> selector);
}

public static TResult Min<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, TResult> selector);
}

public static decimal? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, decimal?> selector);
}

public static double? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, double?> selector);
}

public static float? Min (this IEnumerable<float?> source) {
       return System.Linq.Min(IEnumerable<float?> source);
}

public static double? Min (this IEnumerable<double?> source) {
       return System.Linq.Min(IEnumerable<double?> source);
}

public static long? Min (this IEnumerable<long?> source) {
       return System.Linq.Min(IEnumerable<long?> source);
}

public static int? Min (this IEnumerable<int?> source) {
       return System.Linq.Min(IEnumerable<int?> source);
}

public static decimal Min (this IEnumerable<decimal> source) {
       return System.Linq.Min(IEnumerable<decimal> source);
}

public static float Min (this IEnumerable<float> source) {
       return System.Linq.Min(IEnumerable<float> source);
}

public static double Min (this IEnumerable<double> source) {
       return System.Linq.Min(IEnumerable<double> source);
}

public static int Min (this IEnumerable<int> source) {
       return System.Linq.Min(IEnumerable<int> source);
}

public static long Min (this IEnumerable<long> source) {
       return System.Linq.Min(IEnumerable<long> source);
}

public static decimal? Min (this IEnumerable<decimal?> source) {
       return System.Linq.Min(IEnumerable<decimal?> source);
}

public static float? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, float?> selector);
}

public static long? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, long?> selector);
}

public static int? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, int?> selector);
}

public static decimal Min<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, decimal> selector);
}

public static float Min<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, float> selector);
}

public static double Min<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, double> selector);
}

public static long Min<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, long> selector);
}

public static int Min<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector) {
       return System.Linq.Min(IEnumerable<TSource> source, Func<TSource, int> selector);
}

public static TSource Min<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.Min(IEnumerable<TSource> source);
}

public static IEnumerable<TResult> OfType<TResult> (this IEnumerable source) {
       return System.Linq.OfType<TResult>(IEnumerable source);
}

public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) {
       return System.Linq.OrderBy(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
}

public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) {
       return System.Linq.OrderBy(IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
}

public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) {
       return System.Linq.OrderByDescending(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
}

public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) {
       return System.Linq.OrderByDescending(IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
}

public static IEnumerable<int> Range (int start, int count) {
       return System.Linq.Range(int start, int count);
}

public static IEnumerable<TResult> Repeat<TResult> (TResult element, int count) {
       return System.Linq.Repeat(TResult element, int count);
}

public static IEnumerable<TSource> Reverse<TSource> (IEnumerable<TSource> source) {
       return System.Linq.Reverse(this IEnumerable<TSource> source);
}

public static IEnumerable<TResult> Select<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, int, TResult> selector) {
       return System.Linq.Select(IEnumerable<TSource> source, Func<TSource, int, TResult> selector);
}

public static IEnumerable<TResult> Select<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector) {
       return System.Linq.Select(IEnumerable<TSource> source, Func<TSource, TResult> selector);
}

public static IEnumerable<TResult> SelectMany<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector) {
       return System.Linq.SelectMany(IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector);
}

public static IEnumerable<TResult> SelectMany<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector) {
       return System.Linq.SelectMany(IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector);
}

public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector) {
       return return System.Linq.SelectMany(IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
}

public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector) {
       return System.Linq.SelectMany(IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
}

public static bool SequenceEqual<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second) {
       return System.Linq.SequenceEqual(IEnumerable<TSource> first, IEnumerable<TSource> second);
}

public static bool SequenceEqual<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer) {
       return System.Linq.SequenceEqual(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
}

public static TSource Single<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.Single(IEnumerable<TSource> source);
}

public static TSource Single<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.Single(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.SingleOrDefault(IEnumerable<TSource> source);
}

public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.SingleOrDefault(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static IEnumerable<TSource> Skip<TSource> (this IEnumerable<TSource> source, int count) {
       return System.Linq.Skip(IEnumerable<TSource> source, int count);
}

public static IEnumerable<TSource> SkipWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate) {
       return System.Linq.SkipWhile(IEnumerable<TSource> source, Func<TSource, int, bool> predicate);
}

public static IEnumerable<TSource> SkipWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.SkipWhile(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static float? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, float?> selector);
}

public static decimal Sum (this IEnumerable<decimal> source) {
       return System.Linq.Sum(IEnumerable<decimal> source);
}

public static decimal? Sum (this IEnumerable<decimal?> source) {
       return System.Linq.Sum(IEnumerable<decimal?> source);
}

public static decimal Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, decimal> selector);
}

public static decimal? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, decimal?> selector);
}

public static float Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, float> selector);
}

public static long Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, long> selector);
}

public static int Sum (this IEnumerable<int> source) {
       return System.Linq.Sum(IEnumerable<int> source);
}

public static int? Sum (this IEnumerable<int?> source) {
       return System.Linq.Sum(IEnumerable<int?> source);
}

public static int Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, int> selector);
}

public static int? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, int?> selector);
}

public static long Sum (this IEnumerable<long> source) {
       return System.Linq.Sum(IEnumerable<long> source);
}

public static long? Sum (this IEnumerable<long?> source) {
       return System.Linq.Sum(IEnumerable<long?> source);
}

public static long? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, long?> selector);
}

public static double? Sum (this IEnumerable<double?> source) {
       return System.Linq.Sum(IEnumerable<double?> source);
}

public static double? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, double?> selector);
}

public static float Sum (this IEnumerable<float> source) {
       return System.Linq.Sum(IEnumerable<float> source);
}

public static float? Sum (this IEnumerable<float?> source) {
       return System.Linq.Sum(IEnumerable<float?> source);
}

public static double Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector) {
       return System.Linq.Sum(IEnumerable<TSource> source, Func<TSource, double> selector);
}

public static double Sum (this IEnumerable<double> source) {
       return System.Linq.Sum(IEnumerable<double> source);
}

public static IEnumerable<TSource> Take<TSource> (this IEnumerable<TSource> source, int count) {
       return System.Linq.Take(IEnumerable<TSource> source, int count);
}

public static IEnumerable<TSource> TakeWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate) {
       return System.Linq.TakeWhile(IEnumerable<TSource> source, Func<TSource, int, bool> predicate);
}

public static IEnumerable<TSource> TakeWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.TakeWhile(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}

public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey> (this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector) {
       return System.Linq.ThenBy(IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector);
}

public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey> (this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) {
       return System.Linq.ThenBy(IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
}

public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey> (this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) {
       return System.Linq.ThenByDescending(IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
}

public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey> (this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector) {
       return System.Linq.ThenByDescending(IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector);
}

public static TSource[] ToArray<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.ToArray(IEnumerable<TSource> source);
}

public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) {
       return System.Linq.ToDictionary(IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
}

public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) {
       return System.Linq.ToDictionary(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
}

public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer) {
       return System.Linq.ToDictionary(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
}

public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer) {
       return System.Linq.ToDictionary(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
}

public static List<TSource> ToList<TSource> (this IEnumerable<TSource> source) {
       return System.Linq.ToList(IEnumerable<TSource> source);
}

public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer) {
       return System.Linq.ToLookup(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
}

public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer) {
       return System.Linq.ToLookup(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
}

public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) {
       return System.Linq.ToLookup(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
}

public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) {
       return System.Linq.ToLookup(IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
}

public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer) {
       return System.Linq.Union(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
}

public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second) {
       return System.Linq.Union(IEnumerable<TSource> first, IEnumerable<TSource> second);
}

public static IEnumerable<TSource> Where<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate) {
       return System.Linq.Where(IEnumerable<TSource> source, Func<TSource, int, bool> predicate);
}

public static IEnumerable<TSource> Where<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
       return System.Linq.Where(IEnumerable<TSource> source, Func<TSource, bool> predicate);
}