通过反编译得到System.Core程序集中System.Linq命名空间下的Enumerable类

通过反编译得到System.Core程序集中System.Linq命名空间下的Enumerable类如下所示：

using System.Collections;
using System.Collections.Generic;
using System.Threading;

namespace System.Linq
{
    [__DynamicallyInvokable]
    public static class Enumerable
    {
        private abstract class Iterator<TSource> : IEnumerable<TSource>, IEnumerable, IEnumerator<TSource>, IDisposable, IEnumerator
        {
            private int threadId;

            internal int state;

            internal TSource current;

            public TSource Current => current;

            object IEnumerator.Current => Current;

            public Iterator()
            {
                threadId = Thread.CurrentThread.ManagedThreadId;
            }

            public abstract Iterator<TSource> Clone();

            public virtual void Dispose()
            {
                current = default(TSource);
                state = -1;
            }

            public IEnumerator<TSource> GetEnumerator()
            {
                if (threadId == Thread.CurrentThread.ManagedThreadId && state == 0)
                {
                    state = 1;
                    return this;
                }

                Iterator<TSource> iterator = Clone();
                iterator.state = 1;
                return iterator;
            }

            public abstract bool MoveNext();

            public abstract IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector);

            public abstract IEnumerable<TSource> Where(Func<TSource, bool> predicate);

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

            void IEnumerator.Reset()
            {
                throw new NotImplementedException();
            }
        }

        private class WhereEnumerableIterator<TSource> : Iterator<TSource>
        {
            private IEnumerable<TSource> source;

            private Func<TSource, bool> predicate;

            private IEnumerator<TSource> enumerator;

            public WhereEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate)
            {
                this.source = source;
                this.predicate = predicate;
            }

            public override Iterator<TSource> Clone()
            {
                return new WhereEnumerableIterator<TSource>(source, predicate);
            }

            public override void Dispose()
            {
                if (enumerator != null)
                {
                    enumerator.Dispose();
                }

                enumerator = null;
                base.Dispose();
            }

            public override bool MoveNext()
            {
                int state = base.state;
                if (state != 1)
                {
                    if (state != 2)
                    {
                        goto IL_0061;
                    }
                }
                else
                {
                    enumerator = source.GetEnumerator();
                    base.state = 2;
                }

                while (enumerator.MoveNext())
                {
                    TSource current = enumerator.Current;
                    if (predicate(current))
                    {
                        base.current = current;
                        return true;
                    }
                }

                Dispose();
                goto IL_0061;
                IL_0061:
                return false;
            }

            public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
            {
                return new WhereSelectEnumerableIterator<TSource, TResult>(source, predicate, selector);
            }

            public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
            {
                return new WhereEnumerableIterator<TSource>(source, CombinePredicates(this.predicate, predicate));
            }
        }

        private class WhereArrayIterator<TSource> : Iterator<TSource>
        {
            private TSource[] source;

            private Func<TSource, bool> predicate;

            private int index;

            public WhereArrayIterator(TSource[] source, Func<TSource, bool> predicate)
            {
                this.source = source;
                this.predicate = predicate;
            }

            public override Iterator<TSource> Clone()
            {
                return new WhereArrayIterator<TSource>(source, predicate);
            }

            public override bool MoveNext()
            {
                if (state == 1)
                {
                    while (index < source.Length)
                    {
                        TSource val = source[index];
                        index++;
                        if (predicate(val))
                        {
                            current = val;
                            return true;
                        }
                    }

                    Dispose();
                }

                return false;
            }

            public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
            {
                return new WhereSelectArrayIterator<TSource, TResult>(source, predicate, selector);
            }

            public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
            {
                return new WhereArrayIterator<TSource>(source, CombinePredicates(this.predicate, predicate));
            }
        }

        private class WhereListIterator<TSource> : Iterator<TSource>
        {
            private List<TSource> source;

            private Func<TSource, bool> predicate;

            private List<TSource>.Enumerator enumerator;

            public WhereListIterator(List<TSource> source, Func<TSource, bool> predicate)
            {
                this.source = source;
                this.predicate = predicate;
            }

            public override Iterator<TSource> Clone()
            {
                return new WhereListIterator<TSource>(source, predicate);
            }

            public override bool MoveNext()
            {
                int state = base.state;
                if (state != 1)
                {
                    if (state != 2)
                    {
                        goto IL_0061;
                    }
                }
                else
                {
                    enumerator = source.GetEnumerator();
                    base.state = 2;
                }

                while (enumerator.MoveNext())
                {
                    TSource current = enumerator.Current;
                    if (predicate(current))
                    {
                        base.current = current;
                        return true;
                    }
                }

                Dispose();
                goto IL_0061;
                IL_0061:
                return false;
            }

            public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
            {
                return new WhereSelectListIterator<TSource, TResult>(source, predicate, selector);
            }

            public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
            {
                return new WhereListIterator<TSource>(source, CombinePredicates(this.predicate, predicate));
            }
        }

        private class SelectEnumerableIterator<TSource, TResult> : Iterator<TResult>, IIListProvider<TResult>, IEnumerable<TResult>, IEnumerable
        {
            private readonly IEnumerable<TSource> _source;

            private readonly Func<TSource, TResult> _selector;

            private IEnumerator<TSource> _enumerator;

            public SelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, TResult> selector)
            {
                _source = source;
                _selector = selector;
            }

            public override Iterator<TResult> Clone()
            {
                return new SelectEnumerableIterator<TSource, TResult>(_source, _selector);
            }

            public override void Dispose()
            {
                if (_enumerator != null)
                {
                    _enumerator.Dispose();
                    _enumerator = null;
                }

                base.Dispose();
            }

            public override bool MoveNext()
            {
                int state = base.state;
                if (state != 1)
                {
                    if (state != 2)
                    {
                        goto IL_005a;
                    }
                }
                else
                {
                    _enumerator = _source.GetEnumerator();
                    base.state = 2;
                }

                if (_enumerator.MoveNext())
                {
                    current = _selector(_enumerator.Current);
                    return true;
                }

                Dispose();
                goto IL_005a;
                IL_005a:
                return false;
            }

            public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
            {
                return new SelectEnumerableIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
            }

            public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
            {
                return new WhereEnumerableIterator<TResult>(this, predicate);
            }

            public TResult[] ToArray()
            {
                LargeArrayBuilder<TResult> largeArrayBuilder = new LargeArrayBuilder<TResult>(initialize: true);
                foreach (TSource item in _source)
                {
                    largeArrayBuilder.Add(_selector(item));
                }

                return largeArrayBuilder.ToArray();
            }

            public List<TResult> ToList()
            {
                List<TResult> list = new List<TResult>();
                foreach (TSource item in _source)
                {
                    list.Add(_selector(item));
                }

                return list;
            }

            public int GetCount(bool onlyIfCheap)
            {
                if (onlyIfCheap)
                {
                    return -1;
                }

                int num = 0;
                foreach (TSource item in _source)
                {
                    _selector(item);
                    num = checked(num + 1);
                }

                return num;
            }
        }

        private class WhereSelectEnumerableIterator<TSource, TResult> : Iterator<TResult>
        {
            private IEnumerable<TSource> source;

            private Func<TSource, bool> predicate;

            private Func<TSource, TResult> selector;

            private IEnumerator<TSource> enumerator;

            public WhereSelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
            {
                this.source = source;
                this.predicate = predicate;
                this.selector = selector;
            }

            public override Iterator<TResult> Clone()
            {
                return new WhereSelectEnumerableIterator<TSource, TResult>(source, predicate, selector);
            }

            public override void Dispose()
            {
                if (enumerator != null)
                {
                    enumerator.Dispose();
                }

                enumerator = null;
                base.Dispose();
            }

            public override bool MoveNext()
            {
                int state = base.state;
                if (state != 1)
                {
                    if (state != 2)
                    {
                        goto IL_0074;
                    }
                }
                else
                {
                    enumerator = source.GetEnumerator();
                    base.state = 2;
                }

                while (enumerator.MoveNext())
                {
                    TSource current = enumerator.Current;
                    if (predicate == null || predicate(current))
                    {
                        base.current = selector(current);
                        return true;
                    }
                }

                Dispose();
                goto IL_0074;
                IL_0074:
                return false;
            }

            public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
            {
                return new WhereSelectEnumerableIterator<TSource, TResult2>(source, predicate, CombineSelectors(this.selector, selector));
            }

            public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
            {
                return new WhereEnumerableIterator<TResult>(this, predicate);
            }
        }

        private class WhereSelectArrayIterator<TSource, TResult> : Iterator<TResult>
        {
            private TSource[] source;

            private Func<TSource, bool> predicate;

            private Func<TSource, TResult> selector;

            private int index;

            public WhereSelectArrayIterator(TSource[] source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
            {
                this.source = source;
                this.predicate = predicate;
                this.selector = selector;
            }

            public override Iterator<TResult> Clone()
            {
                return new WhereSelectArrayIterator<TSource, TResult>(source, predicate, selector);
            }

            public override bool MoveNext()
            {
                if (state == 1)
                {
                    while (index < source.Length)
                    {
                        TSource arg = source[index];
                        index++;
                        if (predicate == null || predicate(arg))
                        {
                            current = selector(arg);
                            return true;
                        }
                    }

                    Dispose();
                }

                return false;
            }

            public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
            {
                return new WhereSelectArrayIterator<TSource, TResult2>(source, predicate, CombineSelectors(this.selector, selector));
            }

            public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
            {
                return new WhereEnumerableIterator<TResult>(this, predicate);
            }
        }

        private class WhereSelectListIterator<TSource, TResult> : Iterator<TResult>
        {
            private List<TSource> source;

            private Func<TSource, bool> predicate;

            private Func<TSource, TResult> selector;

            private List<TSource>.Enumerator enumerator;

            public WhereSelectListIterator(List<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
            {
                this.source = source;
                this.predicate = predicate;
                this.selector = selector;
            }

            public override Iterator<TResult> Clone()
            {
                return new WhereSelectListIterator<TSource, TResult>(source, predicate, selector);
            }

            public override bool MoveNext()
            {
                int state = base.state;
                if (state != 1)
                {
                    if (state != 2)
                    {
                        goto IL_0074;
                    }
                }
                else
                {
                    enumerator = source.GetEnumerator();
                    base.state = 2;
                }

                while (enumerator.MoveNext())
                {
                    TSource current = enumerator.Current;
                    if (predicate == null || predicate(current))
                    {
                        base.current = selector(current);
                        return true;
                    }
                }

                Dispose();
                goto IL_0074;
                IL_0074:
                return false;
            }

            public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
            {
                return new WhereSelectListIterator<TSource, TResult2>(source, predicate, CombineSelectors(this.selector, selector));
            }

            public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
            {
                return new WhereEnumerableIterator<TResult>(this, predicate);
            }
        }

        private abstract class AppendPrependIterator<TSource> : Iterator<TSource>, IIListProvider<TSource>, IEnumerable<TSource>, IEnumerable
        {
            protected readonly IEnumerable<TSource> _source;

            protected IEnumerator<TSource> enumerator;

            protected AppendPrependIterator(IEnumerable<TSource> source)
            {
                _source = source;
            }

            protected void GetSourceEnumerator()
            {
                enumerator = _source.GetEnumerator();
            }

            public abstract AppendPrependIterator<TSource> Append(TSource item);

            public abstract AppendPrependIterator<TSource> Prepend(TSource item);

            protected bool LoadFromEnumerator()
            {
                if (enumerator.MoveNext())
                {
                    current = enumerator.Current;
                    return true;
                }

                Dispose();
                return false;
            }

            public override void Dispose()
            {
                if (enumerator != null)
                {
                    enumerator.Dispose();
                    enumerator = null;
                }

                base.Dispose();
            }

            public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
            {
                return new SelectEnumerableIterator<TSource, TResult>(this, selector);
            }

            public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
            {
                return new WhereEnumerableIterator<TSource>(this, predicate);
            }

            public abstract TSource[] ToArray();

            public abstract List<TSource> ToList();

            public abstract int GetCount(bool onlyIfCheap);
        }

        private class AppendPrepend1Iterator<TSource> : AppendPrependIterator<TSource>
        {
            private readonly TSource _item;

            private readonly bool _appending;

            public AppendPrepend1Iterator(IEnumerable<TSource> source, TSource item, bool appending)
                : base(source)
            {
                _item = item;
                _appending = appending;
            }

            public override Iterator<TSource> Clone()
            {
                return new AppendPrepend1Iterator<TSource>(_source, _item, _appending);
            }

            public override bool MoveNext()
            {
                switch (state)
                {
                    case 1:
                        state = 2;
                        if (!_appending)
                        {
                            current = _item;
                            return true;
                        }

                        goto case 2;
                    case 2:
                        GetSourceEnumerator();
                        state = 3;
                        goto case 3;
                    case 3:
                        if (LoadFromEnumerator())
                        {
                            return true;
                        }

                        if (_appending)
                        {
                            current = _item;
                            return true;
                        }

                        break;
                }

                Dispose();
                return false;
            }

            public override AppendPrependIterator<TSource> Append(TSource item)
            {
                if (_appending)
                {
                    return new AppendPrependN<TSource>(_source, null, new SingleLinkedNode<TSource>(_item).Add(item), 0, 2);
                }

                return new AppendPrependN<TSource>(_source, new SingleLinkedNode<TSource>(_item), new SingleLinkedNode<TSource>(item), 1, 1);
            }

            public override AppendPrependIterator<TSource> Prepend(TSource item)
            {
                if (_appending)
                {
                    return new AppendPrependN<TSource>(_source, new SingleLinkedNode<TSource>(item), new SingleLinkedNode<TSource>(_item), 1, 1);
                }

                return new AppendPrependN<TSource>(_source, new SingleLinkedNode<TSource>(_item).Add(item), null, 2, 0);
            }

            private TSource[] LazyToArray()
            {
                LargeArrayBuilder<TSource> largeArrayBuilder = new LargeArrayBuilder<TSource>(initialize: true);
                if (!_appending)
                {
                    largeArrayBuilder.SlowAdd(_item);
                }

                largeArrayBuilder.AddRange(_source);
                if (_appending)
                {
                    largeArrayBuilder.SlowAdd(_item);
                }

                return largeArrayBuilder.ToArray();
            }

            public override TSource[] ToArray()
            {
                int count = GetCount(onlyIfCheap: true);
                if (count == -1)
                {
                    return LazyToArray();
                }

                TSource[] array = new TSource[count];
                int arrayIndex;
                if (_appending)
                {
                    arrayIndex = 0;
                }
                else
                {
                    array[0] = _item;
                    arrayIndex = 1;
                }

                EnumerableHelpers.Copy(_source, array, arrayIndex, count - 1);
                if (_appending)
                {
                    array[array.Length - 1] = _item;
                }

                return array;
            }

            public override List<TSource> ToList()
            {
                int count = GetCount(onlyIfCheap: true);
                List<TSource> list = (count == -1) ? new List<TSource>() : new List<TSource>(count);
                if (!_appending)
                {
                    list.Add(_item);
                }

                list.AddRange(_source);
                if (_appending)
                {
                    list.Add(_item);
                }

                return list;
            }

            public override int GetCount(bool onlyIfCheap)
            {
                IIListProvider<TSource> iIListProvider = _source as IIListProvider<TSource>;
                if (iIListProvider != null)
                {
                    int count = iIListProvider.GetCount(onlyIfCheap);
                    if (count != -1)
                    {
                        return count + 1;
                    }

                    return -1;
                }

                if (onlyIfCheap && !(_source is ICollection<TSource>))
                {
                    return -1;
                }

                return _source.Count() + 1;
            }
        }

        private class AppendPrependN<TSource> : AppendPrependIterator<TSource>
        {
            private readonly SingleLinkedNode<TSource> _prepended;

            private readonly SingleLinkedNode<TSource> _appended;

            private readonly int _prependCount;

            private readonly int _appendCount;

            private SingleLinkedNode<TSource> _node;

            public AppendPrependN(IEnumerable<TSource> source, SingleLinkedNode<TSource> prepended, SingleLinkedNode<TSource> appended, int prependCount, int appendCount)
                : base(source)
            {
                _prepended = prepended;
                _appended = appended;
                _prependCount = prependCount;
                _appendCount = appendCount;
            }

            public override Iterator<TSource> Clone()
            {
                return new AppendPrependN<TSource>(_source, _prepended, _appended, _prependCount, _appendCount);
            }

            public override bool MoveNext()
            {
                switch (state)
                {
                    case 1:
                        _node = _prepended;
                        state = 2;
                        goto case 2;
                    case 2:
                        if (_node != null)
                        {
                            current = _node.Item;
                            _node = _node.Linked;
                            return true;
                        }

                        GetSourceEnumerator();
                        state = 3;
                        goto case 3;
                    case 3:
                        if (LoadFromEnumerator())
                        {
                            return true;
                        }

                        if (_appended == null)
                        {
                            return false;
                        }

                        enumerator = _appended.GetEnumerator(_appendCount);
                        state = 4;
                        goto case 4;
                    case 4:
                        return LoadFromEnumerator();
                    default:
                        Dispose();
                        return false;
                }
            }

            public override AppendPrependIterator<TSource> Append(TSource item)
            {
                SingleLinkedNode<TSource> appended = (_appended != null) ? _appended.Add(item) : new SingleLinkedNode<TSource>(item);
                return new AppendPrependN<TSource>(_source, _prepended, appended, _prependCount, _appendCount + 1);
            }

            public override AppendPrependIterator<TSource> Prepend(TSource item)
            {
                SingleLinkedNode<TSource> prepended = (_prepended != null) ? _prepended.Add(item) : new SingleLinkedNode<TSource>(item);
                return new AppendPrependN<TSource>(_source, prepended, _appended, _prependCount + 1, _appendCount);
            }

            private TSource[] LazyToArray()
            {
                SparseArrayBuilder<TSource> sparseArrayBuilder = new SparseArrayBuilder<TSource>(initialize: true);
                if (_prepended != null)
                {
                    sparseArrayBuilder.Reserve(_prependCount);
                }

                sparseArrayBuilder.AddRange(_source);
                if (_appended != null)
                {
                    sparseArrayBuilder.Reserve(_appendCount);
                }

                TSource[] array = sparseArrayBuilder.ToArray();
                int num = 0;
                for (SingleLinkedNode<TSource> singleLinkedNode = _prepended; singleLinkedNode != null; singleLinkedNode = singleLinkedNode.Linked)
                {
                    array[num++] = singleLinkedNode.Item;
                }

                num = array.Length - 1;
                for (SingleLinkedNode<TSource> singleLinkedNode2 = _appended; singleLinkedNode2 != null; singleLinkedNode2 = singleLinkedNode2.Linked)
                {
                    array[num--] = singleLinkedNode2.Item;
                }

                return array;
            }

            public override TSource[] ToArray()
            {
                int count = GetCount(onlyIfCheap: true);
                if (count == -1)
                {
                    return LazyToArray();
                }

                TSource[] array = new TSource[count];
                int num = 0;
                for (SingleLinkedNode<TSource> singleLinkedNode = _prepended; singleLinkedNode != null; singleLinkedNode = singleLinkedNode.Linked)
                {
                    array[num] = singleLinkedNode.Item;
                    num++;
                }

                ICollection<TSource> collection = _source as ICollection<TSource>;
                if (collection != null)
                {
                    collection.CopyTo(array, num);
                }
                else
                {
                    foreach (TSource item in _source)
                    {
                        TSource val = array[num] = item;
                        num++;
                    }
                }

                num = array.Length;
                for (SingleLinkedNode<TSource> singleLinkedNode2 = _appended; singleLinkedNode2 != null; singleLinkedNode2 = singleLinkedNode2.Linked)
                {
                    num--;
                    array[num] = singleLinkedNode2.Item;
                }

                return array;
            }

            public override List<TSource> ToList()
            {
                int count = GetCount(onlyIfCheap: true);
                List<TSource> list = (count == -1) ? new List<TSource>() : new List<TSource>(count);
                for (SingleLinkedNode<TSource> singleLinkedNode = _prepended; singleLinkedNode != null; singleLinkedNode = singleLinkedNode.Linked)
                {
                    list.Add(singleLinkedNode.Item);
                }

                list.AddRange(_source);
                if (_appended != null)
                {
                    IEnumerator<TSource> enumerator = _appended.GetEnumerator(_appendCount);
                    while (enumerator.MoveNext())
                    {
                        list.Add(enumerator.Current);
                    }
                }

                return list;
            }

            public override int GetCount(bool onlyIfCheap)
            {
                IIListProvider<TSource> iIListProvider = _source as IIListProvider<TSource>;
                if (iIListProvider != null)
                {
                    int count = iIListProvider.GetCount(onlyIfCheap);
                    if (count != -1)
                    {
                        return count + _appendCount + _prependCount;
                    }

                    return -1;
                }

                if (onlyIfCheap && !(_source is ICollection<TSource>))
                {
                    return -1;
                }

                return _source.Count() + _appendCount + _prependCount;
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            if (source is Iterator<TSource>)
            {
                return ((Iterator<TSource>)source).Where(predicate);
            }

            if (source is TSource[])
            {
                return new WhereArrayIterator<TSource>((TSource[])source, predicate);
            }

            if (source is List<TSource>)
            {
                return new WhereListIterator<TSource>((List<TSource>)source, predicate);
            }

            return new WhereEnumerableIterator<TSource>(source, predicate);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            return WhereIterator(source, predicate);
        }

        private static IEnumerable<TSource> WhereIterator<TSource>(IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
        {
            int index = -1;
            foreach (TSource item in source)
            {
                index = checked(index + 1);
                if (predicate(item, index))
                {
                    yield return item;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (selector == null)
            {
                throw Error.ArgumentNull("selector");
            }

            if (source is Iterator<TSource>)
            {
                return ((Iterator<TSource>)source).Select(selector);
            }

            if (source is TSource[])
            {
                return new WhereSelectArrayIterator<TSource, TResult>((TSource[])source, null, selector);
            }

            if (source is List<TSource>)
            {
                return new WhereSelectListIterator<TSource, TResult>((List<TSource>)source, null, selector);
            }

            return new WhereSelectEnumerableIterator<TSource, TResult>(source, null, selector);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (selector == null)
            {
                throw Error.ArgumentNull("selector");
            }

            return SelectIterator(source, selector);
        }

        private static IEnumerable<TResult> SelectIterator<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
        {
            int index = -1;
            foreach (TSource item in source)
            {
                index = checked(index + 1);
                yield return selector(item, index);
            }
        }

        private static Func<TSource, bool> CombinePredicates<TSource>(Func<TSource, bool> predicate1, Func<TSource, bool> predicate2)
        {
            return (TSource x) => predicate1(x) && predicate2(x);
        }

        private static Func<TSource, TResult> CombineSelectors<TSource, TMiddle, TResult>(Func<TSource, TMiddle> selector1, Func<TMiddle, TResult> selector2)
        {
            return (TSource x) => selector2(selector1(x));
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (selector == null)
            {
                throw Error.ArgumentNull("selector");
            }

            return SelectManyIterator(source, selector);
        }

        private static IEnumerable<TResult> SelectManyIterator<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
        {
            foreach (TSource item in source)
            {
                foreach (TResult item2 in selector(item))
                {
                    yield return item2;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (selector == null)
            {
                throw Error.ArgumentNull("selector");
            }

            return SelectManyIterator(source, selector);
        }

        private static IEnumerable<TResult> SelectManyIterator<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
        {
            int index = -1;
            foreach (TSource item in source)
            {
                index = checked(index + 1);
                foreach (TResult item2 in selector(item, index))
                {
                    yield return item2;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (collectionSelector == null)
            {
                throw Error.ArgumentNull("collectionSelector");
            }

            if (resultSelector == null)
            {
                throw Error.ArgumentNull("resultSelector");
            }

            return SelectManyIterator(source, collectionSelector, resultSelector);
        }

        private static IEnumerable<TResult> SelectManyIterator<TSource, TCollection, TResult>(IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
        {
            int index = -1;
            foreach (TSource element in source)
            {
                index = checked(index + 1);
                foreach (TCollection item in collectionSelector(element, index))
                {
                    yield return resultSelector(element, item);
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (collectionSelector == null)
            {
                throw Error.ArgumentNull("collectionSelector");
            }

            if (resultSelector == null)
            {
                throw Error.ArgumentNull("resultSelector");
            }

            return SelectManyIterator(source, collectionSelector, resultSelector);
        }

        private static IEnumerable<TResult> SelectManyIterator<TSource, TCollection, TResult>(IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
        {
            foreach (TSource element in source)
            {
                foreach (TCollection item in collectionSelector(element))
                {
                    yield return resultSelector(element, item);
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return TakeIterator(source, count);
        }

        private static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> source, int count)
        {
            if (count > 0)
            {
                foreach (TSource item in source)
                {
                    yield return item;
                    int num = count - 1;
                    count = num;
                    if (num == 0)
                    {
                        break;
                    }
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            return TakeWhileIterator(source, predicate);
        }

        private static IEnumerable<TSource> TakeWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            foreach (TSource item in source)
            {
                if (!predicate(item))
                {
                    break;
                }

                yield return item;
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            return TakeWhileIterator(source, predicate);
        }

        private static IEnumerable<TSource> TakeWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
        {
            int index = -1;
            foreach (TSource item in source)
            {
                index = checked(index + 1);
                if (!predicate(item, index))
                {
                    break;
                }

                yield return item;
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return SkipIterator(source, count);
        }

        private static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count)
        {
            using (IEnumerator<TSource> e = source.GetEnumerator())
            {
                while (count > 0 && e.MoveNext())
                {
                    count--;
                }

                if (count <= 0)
                {
                    while (e.MoveNext())
                    {
                        yield return e.Current;
                    }
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            return SkipWhileIterator(source, predicate);
        }

        private static IEnumerable<TSource> SkipWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            bool yielding = false;
            foreach (TSource item in source)
            {
                if (!yielding && !predicate(item))
                {
                    yielding = true;
                }

                if (yielding)
                {
                    yield return item;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            return SkipWhileIterator(source, predicate);
        }

        private static IEnumerable<TSource> SkipWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
        {
            int index = -1;
            bool yielding = false;
            foreach (TSource item in source)
            {
                index = checked(index + 1);
                if (!yielding && !predicate(item, index))
                {
                    yielding = true;
                }

                if (yielding)
                {
                    yield return item;
                }
            }
        }

        [__DynamicallyInvokable]
        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)
        {
            if (outer == null)
            {
                throw Error.ArgumentNull("outer");
            }

            if (inner == null)
            {
                throw Error.ArgumentNull("inner");
            }

            if (outerKeySelector == null)
            {
                throw Error.ArgumentNull("outerKeySelector");
            }

            if (innerKeySelector == null)
            {
                throw Error.ArgumentNull("innerKeySelector");
            }

            if (resultSelector == null)
            {
                throw Error.ArgumentNull("resultSelector");
            }

            return JoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, null);
        }

        [__DynamicallyInvokable]
        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)
        {
            if (outer == null)
            {
                throw Error.ArgumentNull("outer");
            }

            if (inner == null)
            {
                throw Error.ArgumentNull("inner");
            }

            if (outerKeySelector == null)
            {
                throw Error.ArgumentNull("outerKeySelector");
            }

            if (innerKeySelector == null)
            {
                throw Error.ArgumentNull("innerKeySelector");
            }

            if (resultSelector == null)
            {
                throw Error.ArgumentNull("resultSelector");
            }

            return JoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
        }

        private static IEnumerable<TResult> JoinIterator<TOuter, TInner, TKey, TResult>(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
        {
            Lookup<TKey, TInner> lookup = Lookup<TKey, TInner>.CreateForJoin(inner, innerKeySelector, comparer);
            foreach (TOuter item in outer)
            {
                Lookup<TKey, TInner>.Grouping g = lookup.GetGrouping(outerKeySelector(item), create: false);
                if (g != null)
                {
                    for (int i = 0; i < g.count; i++)
                    {
                        yield return resultSelector(item, g.elements[i]);
                    }
                }
            }
        }

        [__DynamicallyInvokable]
        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)
        {
            if (outer == null)
            {
                throw Error.ArgumentNull("outer");
            }

            if (inner == null)
            {
                throw Error.ArgumentNull("inner");
            }

            if (outerKeySelector == null)
            {
                throw Error.ArgumentNull("outerKeySelector");
            }

            if (innerKeySelector == null)
            {
                throw Error.ArgumentNull("innerKeySelector");
            }

            if (resultSelector == null)
            {
                throw Error.ArgumentNull("resultSelector");
            }

            return GroupJoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, null);
        }

        [__DynamicallyInvokable]
        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)
        {
            if (outer == null)
            {
                throw Error.ArgumentNull("outer");
            }

            if (inner == null)
            {
                throw Error.ArgumentNull("inner");
            }

            if (outerKeySelector == null)
            {
                throw Error.ArgumentNull("outerKeySelector");
            }

            if (innerKeySelector == null)
            {
                throw Error.ArgumentNull("innerKeySelector");
            }

            if (resultSelector == null)
            {
                throw Error.ArgumentNull("resultSelector");
            }

            return GroupJoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
        }

        private static IEnumerable<TResult> GroupJoinIterator<TOuter, TInner, TKey, TResult>(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
        {
            Lookup<TKey, TInner> lookup = Lookup<TKey, TInner>.CreateForJoin(inner, innerKeySelector, comparer);
            foreach (TOuter item in outer)
            {
                yield return resultSelector(item, lookup[outerKeySelector(item)]);
            }
        }

        [__DynamicallyInvokable]
        public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return new OrderedEnumerable<TSource, TKey>(source, keySelector, null, descending: false);
        }

        [__DynamicallyInvokable]
        public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
            return new OrderedEnumerable<TSource, TKey>(source, keySelector, comparer, descending: false);
        }

        [__DynamicallyInvokable]
        public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return new OrderedEnumerable<TSource, TKey>(source, keySelector, null, descending: true);
        }

        [__DynamicallyInvokable]
        public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
            return new OrderedEnumerable<TSource, TKey>(source, keySelector, comparer, descending: true);
        }

        [__DynamicallyInvokable]
        public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return source.CreateOrderedEnumerable(keySelector, null, descending: false);
        }

        [__DynamicallyInvokable]
        public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return source.CreateOrderedEnumerable(keySelector, comparer, descending: false);
        }

        [__DynamicallyInvokable]
        public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return source.CreateOrderedEnumerable(keySelector, null, descending: true);
        }

        [__DynamicallyInvokable]
        public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return source.CreateOrderedEnumerable(keySelector, comparer, descending: true);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return new GroupedEnumerable<TSource, TKey, TSource>(source, keySelector, IdentityFunction<TSource>.Instance, null);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            return new GroupedEnumerable<TSource, TKey, TSource>(source, keySelector, IdentityFunction<TSource>.Instance, comparer);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
        {
            return new GroupedEnumerable<TSource, TKey, TElement>(source, keySelector, elementSelector, null);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
        {
            return new GroupedEnumerable<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector)
        {
            return new GroupedEnumerable<TSource, TKey, TSource, TResult>(source, keySelector, IdentityFunction<TSource>.Instance, resultSelector, null);
        }

        [__DynamicallyInvokable]
        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 new GroupedEnumerable<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, null);
        }

        [__DynamicallyInvokable]
        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 new GroupedEnumerable<TSource, TKey, TSource, TResult>(source, keySelector, IdentityFunction<TSource>.Instance, resultSelector, comparer);
        }

        [__DynamicallyInvokable]
        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 new GroupedEnumerable<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            if (first == null)
            {
                throw Error.ArgumentNull("first");
            }

            if (second == null)
            {
                throw Error.ArgumentNull("second");
            }

            return ConcatIterator(first, second);
        }

        private static IEnumerable<TSource> ConcatIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            foreach (TSource item in first)
            {
                yield return item;
            }

            foreach (TSource item2 in second)
            {
                yield return item2;
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
        {
            if (first == null)
            {
                throw Error.ArgumentNull("first");
            }

            if (second == null)
            {
                throw Error.ArgumentNull("second");
            }

            if (resultSelector == null)
            {
                throw Error.ArgumentNull("resultSelector");
            }

            return ZipIterator(first, second, resultSelector);
        }

        private static IEnumerable<TResult> ZipIterator<TFirst, TSecond, TResult>(IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
        {
            using (IEnumerator<TFirst> e3 = first.GetEnumerator())
            {
                using (IEnumerator<TSecond> e2 = second.GetEnumerator())
                {
                    while (e3.MoveNext() && e2.MoveNext())
                    {
                        yield return resultSelector(e3.Current, e2.Current);
                    }
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return DistinctIterator(source, null);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return DistinctIterator(source, comparer);
        }

        private static IEnumerable<TSource> DistinctIterator<TSource>(IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
        {
            Set<TSource> set = new Set<TSource>(comparer);
            foreach (TSource item in source)
            {
                if (set.Add(item))
                {
                    yield return item;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            if (first == null)
            {
                throw Error.ArgumentNull("first");
            }

            if (second == null)
            {
                throw Error.ArgumentNull("second");
            }

            return UnionIterator(first, second, null);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            if (first == null)
            {
                throw Error.ArgumentNull("first");
            }

            if (second == null)
            {
                throw Error.ArgumentNull("second");
            }

            return UnionIterator(first, second, comparer);
        }

        private static IEnumerable<TSource> UnionIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            Set<TSource> set = new Set<TSource>(comparer);
            foreach (TSource item in first)
            {
                if (set.Add(item))
                {
                    yield return item;
                }
            }

            foreach (TSource item2 in second)
            {
                if (set.Add(item2))
                {
                    yield return item2;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            if (first == null)
            {
                throw Error.ArgumentNull("first");
            }

            if (second == null)
            {
                throw Error.ArgumentNull("second");
            }

            return IntersectIterator(first, second, null);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            if (first == null)
            {
                throw Error.ArgumentNull("first");
            }

            if (second == null)
            {
                throw Error.ArgumentNull("second");
            }

            return IntersectIterator(first, second, comparer);
        }

        private static IEnumerable<TSource> IntersectIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            Set<TSource> set = new Set<TSource>(comparer);
            foreach (TSource item in second)
            {
                set.Add(item);
            }

            foreach (TSource item2 in first)
            {
                if (set.Remove(item2))
                {
                    yield return item2;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            if (first == null)
            {
                throw Error.ArgumentNull("first");
            }

            if (second == null)
            {
                throw Error.ArgumentNull("second");
            }

            return ExceptIterator(first, second, null);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            if (first == null)
            {
                throw Error.ArgumentNull("first");
            }

            if (second == null)
            {
                throw Error.ArgumentNull("second");
            }

            return ExceptIterator(first, second, comparer);
        }

        private static IEnumerable<TSource> ExceptIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            Set<TSource> set = new Set<TSource>(comparer);
            foreach (TSource item in second)
            {
                set.Add(item);
            }

            foreach (TSource item2 in first)
            {
                if (set.Add(item2))
                {
                    yield return item2;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return ReverseIterator(source);
        }

        private static IEnumerable<TSource> ReverseIterator<TSource>(IEnumerable<TSource> source)
        {
            Buffer<TSource> buffer = new Buffer<TSource>(source);
            for (int i = buffer.count - 1; i >= 0; i--)
            {
                yield return buffer.items[i];
            }
        }

        [__DynamicallyInvokable]
        public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            return first.SequenceEqual(second, null);
        }

        [__DynamicallyInvokable]
        public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
        {
            if (comparer == null)
            {
                comparer = EqualityComparer<TSource>.Default;
            }

            if (first == null)
            {
                throw Error.ArgumentNull("first");
            }

            if (second == null)
            {
                throw Error.ArgumentNull("second");
            }

            using (IEnumerator<TSource> enumerator = first.GetEnumerator())
            {
                using (IEnumerator<TSource> enumerator2 = second.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        if (!enumerator2.MoveNext() || !comparer.Equals(enumerator.Current, enumerator2.Current))
                        {
                            return false;
                        }
                    }

                    if (enumerator2.MoveNext())
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source)
        {
            return source;
        }

        [__DynamicallyInvokable]
        public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return new Buffer<TSource>(source).ToArray();
        }

        [__DynamicallyInvokable]
        public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return new List<TSource>(source);
        }

        [__DynamicallyInvokable]
        public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return source.ToDictionary(keySelector, IdentityFunction<TSource>.Instance, null);
        }

        [__DynamicallyInvokable]
        public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            return source.ToDictionary(keySelector, IdentityFunction<TSource>.Instance, comparer);
        }

        [__DynamicallyInvokable]
        public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
        {
            return source.ToDictionary(keySelector, elementSelector, null);
        }

        [__DynamicallyInvokable]
        public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (keySelector == null)
            {
                throw Error.ArgumentNull("keySelector");
            }

            if (elementSelector == null)
            {
                throw Error.ArgumentNull("elementSelector");
            }

            Dictionary<TKey, TElement> dictionary = new Dictionary<TKey, TElement>(comparer);
            foreach (TSource item in source)
            {
                dictionary.Add(keySelector(item), elementSelector(item));
            }

            return dictionary;
        }

        [__DynamicallyInvokable]
        public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return Lookup<TKey, TSource>.Create(source, keySelector, IdentityFunction<TSource>.Instance, null);
        }

        [__DynamicallyInvokable]
        public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            return Lookup<TKey, TSource>.Create(source, keySelector, IdentityFunction<TSource>.Instance, comparer);
        }

        [__DynamicallyInvokable]
        public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
        {
            return Lookup<TKey, TElement>.Create(source, keySelector, elementSelector, null);
        }

        [__DynamicallyInvokable]
        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 Lookup<TKey, TElement>.Create(source, keySelector, elementSelector, comparer);
        }

        public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource> source)
        {
            return source.ToHashSet(null);
        }

        public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return new HashSet<TSource>(source, comparer);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source)
        {
            return source.DefaultIfEmpty(default(TSource));
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source, TSource defaultValue)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return DefaultIfEmptyIterator(source, defaultValue);
        }

        private static IEnumerable<TSource> DefaultIfEmptyIterator<TSource>(IEnumerable<TSource> source, TSource defaultValue)
        {
            using (IEnumerator<TSource> e = source.GetEnumerator())
            {
                if (e.MoveNext())
                {
                    do
                    {
                        yield return e.Current;
                    }
                    while (e.MoveNext());
                }
                else
                {
                    yield return defaultValue;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> OfType<TResult>(this IEnumerable source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return OfTypeIterator<TResult>(source);
        }

        private static IEnumerable<TResult> OfTypeIterator<TResult>(IEnumerable source)
        {
            foreach (object item in source)
            {
                if (item is TResult)
                {
                    yield return (TResult)item;
                }
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source)
        {
            IEnumerable<TResult> enumerable = source as IEnumerable<TResult>;
            if (enumerable != null)
            {
                return enumerable;
            }

            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return CastIterator<TResult>(source);
        }

        private static IEnumerable<TResult> CastIterator<TResult>(IEnumerable source)
        {
            foreach (object item in source)
            {
                yield return (TResult)item;
            }
        }

        [__DynamicallyInvokable]
        public static TSource First<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            IList<TSource> list = source as IList<TSource>;
            if (list != null)
            {
                if (list.Count > 0)
                {
                    return list[0];
                }
            }
            else
            {
                using (IEnumerator<TSource> enumerator = source.GetEnumerator())
                {
                    if (enumerator.MoveNext())
                    {
                        return enumerator.Current;
                    }
                }
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    return item;
                }
            }

            throw Error.NoMatch();
        }

        [__DynamicallyInvokable]
        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            IList<TSource> list = source as IList<TSource>;
            if (list != null)
            {
                if (list.Count > 0)
                {
                    return list[0];
                }
            }
            else
            {
                using (IEnumerator<TSource> enumerator = source.GetEnumerator())
                {
                    if (enumerator.MoveNext())
                    {
                        return enumerator.Current;
                    }
                }
            }

            return default(TSource);
        }

        [__DynamicallyInvokable]
        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    return item;
                }
            }

            return default(TSource);
        }

        [__DynamicallyInvokable]
        public static TSource Last<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            IList<TSource> list = source as IList<TSource>;
            if (list != null)
            {
                int count = list.Count;
                if (count > 0)
                {
                    return list[count - 1];
                }
            }
            else
            {
                using (IEnumerator<TSource> enumerator = source.GetEnumerator())
                {
                    if (enumerator.MoveNext())
                    {
                        TSource current;
                        do
                        {
                            current = enumerator.Current;
                        }
                        while (enumerator.MoveNext());
                        return current;
                    }
                }
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static TSource Last<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            TSource result = default(TSource);
            bool flag = false;
            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    result = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return result;
            }

            throw Error.NoMatch();
        }

        [__DynamicallyInvokable]
        public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            IList<TSource> list = source as IList<TSource>;
            if (list != null)
            {
                int count = list.Count;
                if (count > 0)
                {
                    return list[count - 1];
                }
            }
            else
            {
                using (IEnumerator<TSource> enumerator = source.GetEnumerator())
                {
                    if (enumerator.MoveNext())
                    {
                        TSource current;
                        do
                        {
                            current = enumerator.Current;
                        }
                        while (enumerator.MoveNext());
                        return current;
                    }
                }
            }

            return default(TSource);
        }

        [__DynamicallyInvokable]
        public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            TSource result = default(TSource);
            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    result = item;
                }
            }

            return result;
        }

        [__DynamicallyInvokable]
        public static TSource Single<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            IList<TSource> list = source as IList<TSource>;
            if (list != null)
            {
                switch (list.Count)
                {
                    case 0:
                        throw Error.NoElements();
                    case 1:
                        return list[0];
                }
            }
            else
            {
                using (IEnumerator<TSource> enumerator = source.GetEnumerator())
                {
                    if (!enumerator.MoveNext())
                    {
                        throw Error.NoElements();
                    }

                    TSource current = enumerator.Current;
                    if (!enumerator.MoveNext())
                    {
                        return current;
                    }
                }
            }

            throw Error.MoreThanOneElement();
        }

        [__DynamicallyInvokable]
        public static TSource Single<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            TSource result = default(TSource);
            long num = 0L;
            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    result = item;
                    num = checked(num + 1);
                }
            }

            switch (num)
            {
                case 0L:
                    throw Error.NoMatch();
                case 1L:
                    return result;
                default:
                    throw Error.MoreThanOneMatch();
            }
        }

        [__DynamicallyInvokable]
        public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            IList<TSource> list = source as IList<TSource>;
            if (list != null)
            {
                switch (list.Count)
                {
                    case 0:
                        return default(TSource);
                    case 1:
                        return list[0];
                }
            }
            else
            {
                using (IEnumerator<TSource> enumerator = source.GetEnumerator())
                {
                    if (!enumerator.MoveNext())
                    {
                        return default(TSource);
                    }

                    TSource current = enumerator.Current;
                    if (!enumerator.MoveNext())
                    {
                        return current;
                    }
                }
            }

            throw Error.MoreThanOneElement();
        }

        [__DynamicallyInvokable]
        public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            TSource result = default(TSource);
            long num = 0L;
            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    result = item;
                    num = checked(num + 1);
                }
            }

            switch (num)
            {
                case 0L:
                    return default(TSource);
                case 1L:
                    return result;
                default:
                    throw Error.MoreThanOneMatch();
            }
        }

        [__DynamicallyInvokable]
        public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int index)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            IList<TSource> list = source as IList<TSource>;
            if (list != null)
            {
                return list[index];
            }

            if (index < 0)
            {
                throw Error.ArgumentOutOfRange("index");
            }

            using (IEnumerator<TSource> enumerator = source.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    if (index == 0)
                    {
                        return enumerator.Current;
                    }

                    index--;
                }

                throw Error.ArgumentOutOfRange("index");
            }
        }

        [__DynamicallyInvokable]
        public static TSource ElementAtOrDefault<TSource>(this IEnumerable<TSource> source, int index)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (index >= 0)
            {
                IList<TSource> list = source as IList<TSource>;
                if (list != null)
                {
                    if (index < list.Count)
                    {
                        return list[index];
                    }
                }
                else
                {
                    using (IEnumerator<TSource> enumerator = source.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            if (index == 0)
                            {
                                return enumerator.Current;
                            }

                            index--;
                        }
                    }
                }
            }

            return default(TSource);
        }

        [__DynamicallyInvokable]
        public static IEnumerable<int> Range(int start, int count)
        {
            long num = (long)start + (long)count - 1;
            if (count < 0 || num > int.MaxValue)
            {
                throw Error.ArgumentOutOfRange("count");
            }

            return RangeIterator(start, count);
        }

        private static IEnumerable<int> RangeIterator(int start, int count)
        {
            for (int i = 0; i < count; i++)
            {
                yield return start + i;
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)
        {
            if (count < 0)
            {
                throw Error.ArgumentOutOfRange("count");
            }

            return RepeatIterator(element, count);
        }

        private static IEnumerable<TResult> RepeatIterator<TResult>(TResult element, int count)
        {
            for (int i = 0; i < count; i++)
            {
                yield return element;
            }
        }

        [__DynamicallyInvokable]
        public static IEnumerable<TResult> Empty<TResult>()
        {
            return EmptyEnumerable<TResult>.Instance;
        }

        [__DynamicallyInvokable]
        public static bool Any<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            using (IEnumerator<TSource> enumerator = source.GetEnumerator())
            {
                if (enumerator.MoveNext())
                {
                    return true;
                }
            }

            return false;
        }

        [__DynamicallyInvokable]
        public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    return true;
                }
            }

            return false;
        }

        [__DynamicallyInvokable]
        public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            foreach (TSource item in source)
            {
                if (!predicate(item))
                {
                    return false;
                }
            }

            return true;
        }

        [__DynamicallyInvokable]
        public static int Count<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            ICollection<TSource> collection = source as ICollection<TSource>;
            if (collection != null)
            {
                return collection.Count;
            }

            ICollection collection2 = source as ICollection;
            if (collection2 != null)
            {
                return collection2.Count;
            }

            int num = 0;
            using (IEnumerator<TSource> enumerator = source.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    num = checked(num + 1);
                }

                return num;
            }
        }

        [__DynamicallyInvokable]
        public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            int num = 0;
            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    num = checked(num + 1);
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static long LongCount<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long num = 0L;
            using (IEnumerator<TSource> enumerator = source.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    num = checked(num + 1);
                }

                return num;
            }
        }

        [__DynamicallyInvokable]
        public static long LongCount<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            long num = 0L;
            foreach (TSource item in source)
            {
                if (predicate(item))
                {
                    num = checked(num + 1);
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value)
        {
            return (source as ICollection<TSource>)?.Contains(value) ?? source.Contains(value, null);
        }

        [__DynamicallyInvokable]
        public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer)
        {
            if (comparer == null)
            {
                comparer = EqualityComparer<TSource>.Default;
            }

            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            foreach (TSource item in source)
            {
                if (comparer.Equals(item, value))
                {
                    return true;
                }
            }

            return false;
        }

        [__DynamicallyInvokable]
        public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (func == null)
            {
                throw Error.ArgumentNull("func");
            }

            using (IEnumerator<TSource> enumerator = source.GetEnumerator())
            {
                if (!enumerator.MoveNext())
                {
                    throw Error.NoElements();
                }

                TSource val = enumerator.Current;
                while (enumerator.MoveNext())
                {
                    val = func(val, enumerator.Current);
                }

                return val;
            }
        }

        [__DynamicallyInvokable]
        public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (func == null)
            {
                throw Error.ArgumentNull("func");
            }

            TAccumulate val = seed;
            foreach (TSource item in source)
            {
                val = func(val, item);
            }

            return val;
        }

        [__DynamicallyInvokable]
        public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            if (func == null)
            {
                throw Error.ArgumentNull("func");
            }

            if (resultSelector == null)
            {
                throw Error.ArgumentNull("resultSelector");
            }

            TAccumulate val = seed;
            foreach (TSource item in source)
            {
                val = func(val, item);
            }

            return resultSelector(val);
        }

        [__DynamicallyInvokable]
        public static int Sum(this IEnumerable<int> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            int num = 0;
            foreach (int item in source)
            {
                num = checked(num + item);
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static int? Sum(this IEnumerable<int?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            int num = 0;
            foreach (int? item in source)
            {
                if (item.HasValue)
                {
                    num = checked(num + item.GetValueOrDefault());
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static long Sum(this IEnumerable<long> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long num = 0L;
            foreach (long item in source)
            {
                num = checked(num + item);
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static long? Sum(this IEnumerable<long?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long num = 0L;
            foreach (long? item in source)
            {
                if (item.HasValue)
                {
                    num = checked(num + item.GetValueOrDefault());
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static float Sum(this IEnumerable<float> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            foreach (float item in source)
            {
                num += (double)item;
            }

            return (float)num;
        }

        [__DynamicallyInvokable]
        public static float? Sum(this IEnumerable<float?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            foreach (float? item in source)
            {
                if (item.HasValue)
                {
                    num += (double)item.GetValueOrDefault();
                }
            }

            return (float)num;
        }

        [__DynamicallyInvokable]
        public static double Sum(this IEnumerable<double> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            foreach (double item in source)
            {
                num += item;
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static double? Sum(this IEnumerable<double?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            foreach (double? item in source)
            {
                if (item.HasValue)
                {
                    num += item.GetValueOrDefault();
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static decimal Sum(this IEnumerable<decimal> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            decimal result = default(decimal);
            foreach (decimal item in source)
            {
                result += item;
            }

            return result;
        }

        [__DynamicallyInvokable]
        public static decimal? Sum(this IEnumerable<decimal?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            decimal value = default(decimal);
            foreach (decimal? item in source)
            {
                if (item.HasValue)
                {
                    value += item.GetValueOrDefault();
                }
            }

            return value;
        }

        [__DynamicallyInvokable]
        public static int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static int? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static long Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static long? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static float Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static float? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, float?> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static double Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static double? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static decimal Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static decimal? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        public static int Min(this IEnumerable<int> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            int num = 0;
            bool flag = false;
            foreach (int item in source)
            {
                if (flag)
                {
                    if (item < num)
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static int? Min(this IEnumerable<int?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            int? num = null;
            foreach (int? item in source)
            {
                if (!num.HasValue || item < num)
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static long Min(this IEnumerable<long> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long num = 0L;
            bool flag = false;
            foreach (long item in source)
            {
                if (flag)
                {
                    if (item < num)
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static long? Min(this IEnumerable<long?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long? num = null;
            foreach (long? item in source)
            {
                if (!num.HasValue || item < num)
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static float Min(this IEnumerable<float> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            float num = 0f;
            bool flag = false;
            foreach (float item in source)
            {
                if (flag)
                {
                    if (item < num || float.IsNaN(item))
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static float? Min(this IEnumerable<float?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            float? num = null;
            foreach (float? item in source)
            {
                if (item.HasValue && (!num.HasValue || item < num || float.IsNaN(item.Value)))
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static double Min(this IEnumerable<double> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            bool flag = false;
            foreach (double item in source)
            {
                if (flag)
                {
                    if (item < num || double.IsNaN(item))
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static double? Min(this IEnumerable<double?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double? num = null;
            foreach (double? item in source)
            {
                if (item.HasValue && (!num.HasValue || item < num || double.IsNaN(item.Value)))
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static decimal Min(this IEnumerable<decimal> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            decimal num = default(decimal);
            bool flag = false;
            foreach (decimal item in source)
            {
                if (flag)
                {
                    if (item < num)
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static decimal? Min(this IEnumerable<decimal?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            decimal? num = null;
            foreach (decimal? item in source)
            {
                if (!num.HasValue || item < num)
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static TSource Min<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            Comparer<TSource> @default = Comparer<TSource>.Default;
            TSource val = default(TSource);
            if (val == null)
            {
                foreach (TSource item in source)
                {
                    if (item != null && (val == null || @default.Compare(item, val) < 0))
                    {
                        val = item;
                    }
                }

                return val;
            }

            bool flag = false;
            foreach (TSource item2 in source)
            {
                if (flag)
                {
                    if (@default.Compare(item2, val) < 0)
                    {
                        val = item2;
                    }
                }
                else
                {
                    val = item2;
                    flag = true;
                }
            }

            if (flag)
            {
                return val;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static int Min<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static int? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static long Min<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static long? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static float Min<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static float? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, float?> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static double Min<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static double? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static decimal Min<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static decimal? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static TResult Min<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        public static int Max(this IEnumerable<int> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            int num = 0;
            bool flag = false;
            foreach (int item in source)
            {
                if (flag)
                {
                    if (item > num)
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static int? Max(this IEnumerable<int?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            int? num = null;
            foreach (int? item in source)
            {
                if (!num.HasValue || item > num)
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static long Max(this IEnumerable<long> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long num = 0L;
            bool flag = false;
            foreach (long item in source)
            {
                if (flag)
                {
                    if (item > num)
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static long? Max(this IEnumerable<long?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long? num = null;
            foreach (long? item in source)
            {
                if (!num.HasValue || item > num)
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static double Max(this IEnumerable<double> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            bool flag = false;
            foreach (double item in source)
            {
                if (flag)
                {
                    if (item > num || double.IsNaN(num))
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static double? Max(this IEnumerable<double?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double? num = null;
            foreach (double? item in source)
            {
                if (item.HasValue && (!num.HasValue || item > num || double.IsNaN(num.Value)))
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static float Max(this IEnumerable<float> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            float num = 0f;
            bool flag = false;
            foreach (float item in source)
            {
                if (flag)
                {
                    if (item > num || double.IsNaN(num))
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static float? Max(this IEnumerable<float?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            float? num = null;
            foreach (float? item in source)
            {
                if (item.HasValue && (!num.HasValue || item > num || float.IsNaN(num.Value)))
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static decimal Max(this IEnumerable<decimal> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            decimal num = default(decimal);
            bool flag = false;
            foreach (decimal item in source)
            {
                if (flag)
                {
                    if (item > num)
                    {
                        num = item;
                    }
                }
                else
                {
                    num = item;
                    flag = true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static decimal? Max(this IEnumerable<decimal?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            decimal? num = null;
            foreach (decimal? item in source)
            {
                if (!num.HasValue || item > num)
                {
                    num = item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        public static TSource Max<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            Comparer<TSource> @default = Comparer<TSource>.Default;
            TSource val = default(TSource);
            if (val == null)
            {
                foreach (TSource item in source)
                {
                    if (item != null && (val == null || @default.Compare(item, val) > 0))
                    {
                        val = item;
                    }
                }

                return val;
            }

            bool flag = false;
            foreach (TSource item2 in source)
            {
                if (flag)
                {
                    if (@default.Compare(item2, val) > 0)
                    {
                        val = item2;
                    }
                }
                else
                {
                    val = item2;
                    flag = true;
                }
            }

            if (flag)
            {
                return val;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static int Max<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static int? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static long Max<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static long? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static float Max<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static float? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, float?> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static double Max<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static double? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static decimal Max<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static decimal? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static TResult Max<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        public static double Average(this IEnumerable<int> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long num = 0L;
            long num2 = 0L;
            checked
            {
                foreach (int item in source)
                {
                    num += item;
                    num2++;
                }

                if (num2 > 0)
                {
                    return (double)num / (double)num2;
                }

                throw Error.NoElements();
            }
        }

        [__DynamicallyInvokable]
        public static double? Average(this IEnumerable<int?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long num = 0L;
            long num2 = 0L;
            checked
            {
                foreach (int? item in source)
                {
                    if (item.HasValue)
                    {
                        num += item.GetValueOrDefault();
                        num2++;
                    }
                }

                if (num2 > 0)
                {
                    return (double)num / (double)num2;
                }

                return null;
            }
        }

        [__DynamicallyInvokable]
        public static double Average(this IEnumerable<long> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long num = 0L;
            long num2 = 0L;
            checked
            {
                foreach (long item in source)
                {
                    num += item;
                    num2++;
                }

                if (num2 > 0)
                {
                    return (double)num / (double)num2;
                }

                throw Error.NoElements();
            }
        }

        [__DynamicallyInvokable]
        public static double? Average(this IEnumerable<long?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            long num = 0L;
            long num2 = 0L;
            checked
            {
                foreach (long? item in source)
                {
                    if (item.HasValue)
                    {
                        num += item.GetValueOrDefault();
                        num2++;
                    }
                }

                if (num2 > 0)
                {
                    return (double)num / (double)num2;
                }

                return null;
            }
        }

        [__DynamicallyInvokable]
        public static float Average(this IEnumerable<float> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            long num2 = 0L;
            foreach (float item in source)
            {
                num += (double)item;
                num2 = checked(num2 + 1);
            }

            if (num2 > 0)
            {
                return (float)(num / (double)num2);
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static float? Average(this IEnumerable<float?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            long num2 = 0L;
            foreach (float? item in source)
            {
                if (item.HasValue)
                {
                    num += (double)item.GetValueOrDefault();
                    num2 = checked(num2 + 1);
                }
            }

            if (num2 > 0)
            {
                return (float)(num / (double)num2);
            }

            return null;
        }

        [__DynamicallyInvokable]
        public static double Average(this IEnumerable<double> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            long num2 = 0L;
            foreach (double item in source)
            {
                num += item;
                num2 = checked(num2 + 1);
            }

            if (num2 > 0)
            {
                return num / (double)num2;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static double? Average(this IEnumerable<double?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            double num = 0.0;
            long num2 = 0L;
            foreach (double? item in source)
            {
                if (item.HasValue)
                {
                    num += item.GetValueOrDefault();
                    num2 = checked(num2 + 1);
                }
            }

            if (num2 > 0)
            {
                return num / (double)num2;
            }

            return null;
        }

        [__DynamicallyInvokable]
        public static decimal Average(this IEnumerable<decimal> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            decimal d = default(decimal);
            long num = 0L;
            foreach (decimal item in source)
            {
                d += item;
                num = checked(num + 1);
            }

            if (num > 0)
            {
                return d / (decimal)num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        public static decimal? Average(this IEnumerable<decimal?> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            decimal d = default(decimal);
            long num = 0L;
            foreach (decimal? item in source)
            {
                if (item.HasValue)
                {
                    d += item.GetValueOrDefault();
                    num = checked(num + 1);
                }
            }

            if (num > 0)
            {
                return d / (decimal)num;
            }

            return null;
        }

        [__DynamicallyInvokable]
        public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        public static double? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        public static double? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        public static float Average<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        public static float? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, float?> selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        public static double? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        public static decimal Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        public static decimal? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
        {
            return source.Select(selector).Average();
        }

        public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource element)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            AppendPrependIterator<TSource> appendPrependIterator = source as AppendPrependIterator<TSource>;
            if (appendPrependIterator != null)
            {
                return appendPrependIterator.Append(element);
            }

            return new AppendPrepend1Iterator<TSource>(source, element, appending: true);
        }

        public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource element)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            AppendPrependIterator<TSource> appendPrependIterator = source as AppendPrependIterator<TSource>;
            if (appendPrependIterator != null)
            {
                return appendPrependIterator.Prepend(element);
            }

            return new AppendPrepend1Iterator<TSource>(source, element, appending: false);
        }
    }
}