通过反编译得到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 : IEnumerable, IEnumerable, IEnumerator, 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 Clone();

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

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

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

            public abstract bool MoveNext();

            public abstract IEnumerable Select(Func selector);

            public abstract IEnumerable Where(Funcbool> predicate);

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

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

        private class WhereEnumerableIterator : Iterator
        {
            private IEnumerable source;

            private Funcbool> predicate;

            private IEnumerator enumerator;

            public WhereEnumerableIterator(IEnumerable source, Funcbool> predicate)
            {
                this.source = source;
                this.predicate = predicate;
            }

            public override Iterator Clone()
            {
                return new WhereEnumerableIterator(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 Select(Func selector)
            {
                return new WhereSelectEnumerableIterator(source, predicate, selector);
            }

            public override IEnumerable Where(Funcbool> predicate)
            {
                return new WhereEnumerableIterator(source, CombinePredicates(this.predicate, predicate));
            }
        }

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

            private Funcbool> predicate;

            private int index;

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

            public override Iterator Clone()
            {
                return new WhereArrayIterator(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 Select(Func selector)
            {
                return new WhereSelectArrayIterator(source, predicate, selector);
            }

            public override IEnumerable Where(Funcbool> predicate)
            {
                return new WhereArrayIterator(source, CombinePredicates(this.predicate, predicate));
            }
        }

        private class WhereListIterator : Iterator
        {
            private List source;

            private Funcbool> predicate;

            private List.Enumerator enumerator;

            public WhereListIterator(List source, Funcbool> predicate)
            {
                this.source = source;
                this.predicate = predicate;
            }

            public override Iterator Clone()
            {
                return new WhereListIterator(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 Select(Func selector)
            {
                return new WhereSelectListIterator(source, predicate, selector);
            }

            public override IEnumerable Where(Funcbool> predicate)
            {
                return new WhereListIterator(source, CombinePredicates(this.predicate, predicate));
            }
        }

        private class SelectEnumerableIterator : Iterator, IIListProvider, IEnumerable, IEnumerable
        {
            private readonly IEnumerable _source;

            private readonly Func _selector;

            private IEnumerator _enumerator;

            public SelectEnumerableIterator(IEnumerable source, Func selector)
            {
                _source = source;
                _selector = selector;
            }

            public override Iterator Clone()
            {
                return new SelectEnumerableIterator(_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 Select(Func selector)
            {
                return new SelectEnumerableIterator(_source, CombineSelectors(_selector, selector));
            }

            public override IEnumerable Where(Funcbool> predicate)
            {
                return new WhereEnumerableIterator(this, predicate);
            }

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

                return largeArrayBuilder.ToArray();
            }

            public List ToList()
            {
                List list = new List();
                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 : Iterator
        {
            private IEnumerable source;

            private Funcbool> predicate;

            private Func selector;

            private IEnumerator enumerator;

            public WhereSelectEnumerableIterator(IEnumerable source, Funcbool> predicate, Func selector)
            {
                this.source = source;
                this.predicate = predicate;
                this.selector = selector;
            }

            public override Iterator Clone()
            {
                return new WhereSelectEnumerableIterator(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 Select(Func selector)
            {
                return new WhereSelectEnumerableIterator(source, predicate, CombineSelectors(this.selector, selector));
            }

            public override IEnumerable Where(Funcbool> predicate)
            {
                return new WhereEnumerableIterator(this, predicate);
            }
        }

        private class WhereSelectArrayIterator : Iterator
        {
            private TSource[] source;

            private Funcbool> predicate;

            private Func selector;

            private int index;

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

            public override Iterator Clone()
            {
                return new WhereSelectArrayIterator(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 Select(Func selector)
            {
                return new WhereSelectArrayIterator(source, predicate, CombineSelectors(this.selector, selector));
            }

            public override IEnumerable Where(Funcbool> predicate)
            {
                return new WhereEnumerableIterator(this, predicate);
            }
        }

        private class WhereSelectListIterator : Iterator
        {
            private List source;

            private Funcbool> predicate;

            private Func selector;

            private List.Enumerator enumerator;

            public WhereSelectListIterator(List source, Funcbool> predicate, Func selector)
            {
                this.source = source;
                this.predicate = predicate;
                this.selector = selector;
            }

            public override Iterator Clone()
            {
                return new WhereSelectListIterator(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 Select(Func selector)
            {
                return new WhereSelectListIterator(source, predicate, CombineSelectors(this.selector, selector));
            }

            public override IEnumerable Where(Funcbool> predicate)
            {
                return new WhereEnumerableIterator(this, predicate);
            }
        }

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

            protected IEnumerator enumerator;

            protected AppendPrependIterator(IEnumerable source)
            {
                _source = source;
            }

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

            public abstract AppendPrependIterator Append(TSource item);

            public abstract AppendPrependIterator 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 Select(Func selector)
            {
                return new SelectEnumerableIterator(this, selector);
            }

            public override IEnumerable Where(Funcbool> predicate)
            {
                return new WhereEnumerableIterator(this, predicate);
            }

            public abstract TSource[] ToArray();

            public abstract List ToList();

            public abstract int GetCount(bool onlyIfCheap);
        }

        private class AppendPrepend1Iterator : AppendPrependIterator
        {
            private readonly TSource _item;

            private readonly bool _appending;

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

            public override Iterator Clone()
            {
                return new AppendPrepend1Iterator(_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 Append(TSource item)
            {
                if (_appending)
                {
                    return new AppendPrependN(_source, null, new SingleLinkedNode(_item).Add(item), 0, 2);
                }

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

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

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

            private TSource[] LazyToArray()
            {
                LargeArrayBuilder largeArrayBuilder = new LargeArrayBuilder(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 ToList()
            {
                int count = GetCount(onlyIfCheap: true);
                List list = (count == -1) ? new List() : new List(count);
                if (!_appending)
                {
                    list.Add(_item);
                }

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

                return list;
            }

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

                    return -1;
                }

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

                return _source.Count() + 1;
            }
        }

        private class AppendPrependN : AppendPrependIterator
        {
            private readonly SingleLinkedNode _prepended;

            private readonly SingleLinkedNode _appended;

            private readonly int _prependCount;

            private readonly int _appendCount;

            private SingleLinkedNode _node;

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

            public override Iterator Clone()
            {
                return new AppendPrependN(_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 Append(TSource item)
            {
                SingleLinkedNode appended = (_appended != null) ? _appended.Add(item) : new SingleLinkedNode(item);
                return new AppendPrependN(_source, _prepended, appended, _prependCount, _appendCount + 1);
            }

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

            private TSource[] LazyToArray()
            {
                SparseArrayBuilder sparseArrayBuilder = new SparseArrayBuilder(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 singleLinkedNode = _prepended; singleLinkedNode != null; singleLinkedNode = singleLinkedNode.Linked)
                {
                    array[num++] = singleLinkedNode.Item;
                }

                num = array.Length - 1;
                for (SingleLinkedNode 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 singleLinkedNode = _prepended; singleLinkedNode != null; singleLinkedNode = singleLinkedNode.Linked)
                {
                    array[num] = singleLinkedNode.Item;
                    num++;
                }

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

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

                return array;
            }

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

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

                return list;
            }

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

                    return -1;
                }

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

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

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

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

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

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

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

            return new WhereEnumerableIterator(source, predicate);
        }

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

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

            return WhereIterator(source, predicate);
        }

        private static IEnumerable WhereIterator(IEnumerable source, Funcint, 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 Select(this IEnumerable source, Func selector)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

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

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

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

            if (source is List)
            {
                return new WhereSelectListIterator((List)source, null, selector);
            }

            return new WhereSelectEnumerableIterator(source, null, selector);
        }

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

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

            return SelectIterator(source, selector);
        }

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

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

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

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

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

            return SelectManyIterator(source, selector);
        }

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

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

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

            return SelectManyIterator(source, selector);
        }

        private static IEnumerable SelectManyIterator(IEnumerable source, Funcint, IEnumerable> 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 SelectMany(this IEnumerable source, Funcint, IEnumerable> collectionSelector, Func 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 SelectManyIterator(IEnumerable source, Funcint, IEnumerable> collectionSelector, Func 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 SelectMany(this IEnumerable source, Func> collectionSelector, Func 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 SelectManyIterator(IEnumerable source, Func> collectionSelector, Func resultSelector)
        {
            foreach (TSource element in source)
            {
                foreach (TCollection item in collectionSelector(element))
                {
                    yield return resultSelector(element, item);
                }
            }
        }

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

            return TakeIterator(source, count);
        }

        private static IEnumerable TakeIterator(IEnumerable 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 TakeWhile(this IEnumerable source, Funcbool> predicate)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

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

            return TakeWhileIterator(source, predicate);
        }

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

                yield return item;
            }
        }

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

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

            return TakeWhileIterator(source, predicate);
        }

        private static IEnumerable TakeWhileIterator(IEnumerable source, Funcint, 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 Skip(this IEnumerable source, int count)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            return SkipIterator(source, count);
        }

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

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

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

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

            return SkipWhileIterator(source, predicate);
        }

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

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

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

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

            return SkipWhileIterator(source, predicate);
        }

        private static IEnumerable SkipWhileIterator(IEnumerable source, Funcint, 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 Join(this IEnumerable outer, IEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func 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 Join(this IEnumerable outer, IEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector, IEqualityComparer 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 JoinIterator(IEnumerable outer, IEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector, IEqualityComparer comparer)
        {
            Lookup lookup = Lookup.CreateForJoin(inner, innerKeySelector, comparer);
            foreach (TOuter item in outer)
            {
                Lookup.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 GroupJoin(this IEnumerable outer, IEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, 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 GroupJoin(this IEnumerable outer, IEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector, IEqualityComparer 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 GroupJoinIterator(IEnumerable outer, IEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector, IEqualityComparer comparer)
        {
            Lookup lookup = Lookup.CreateForJoin(inner, innerKeySelector, comparer);
            foreach (TOuter item in outer)
            {
                yield return resultSelector(item, lookup[outerKeySelector(item)]);
            }
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        [__DynamicallyInvokable]
        public static IEnumerable GroupBy(this IEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector)
        {
            return new GroupedEnumerable(source, keySelector, elementSelector, resultSelector, null);
        }

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

        [__DynamicallyInvokable]
        public static IEnumerable GroupBy(this IEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector, IEqualityComparer comparer)
        {
            return new GroupedEnumerable(source, keySelector, elementSelector, resultSelector, comparer);
        }

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

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

            return ConcatIterator(first, second);
        }

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

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

        [__DynamicallyInvokable]
        public static IEnumerable Zip(this IEnumerable first, IEnumerable second, Func 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 ZipIterator(IEnumerable first, IEnumerable second, Func (IEnumerator resultSelector)
        {
            using e3 = (IEnumerator first.GetEnumerator())
            {
                using e2 = (e3.MoveNext() &&   IEnumerable second.GetEnumerator())
                {
                    while e2.MoveNext())
                    {
                        yieldreturn resultSelector(e3.Current, e2.Current);
                    }
                }
            }
        }

        [__DynamicallyInvokable]
        publicstatic Distinct( IEnumerablethis (source ==  Error.ArgumentNull( DistinctIterator(source,   IEnumerable source)
        {
            ifnull)
            {
                throw"source");
            }

            returnnull);
        }

        [__DynamicallyInvokable]
        publicstatic Distinct( IEnumerablethis source, IEqualityComparer (source ==  Error.ArgumentNull(  IEnumerable comparer)
        {
            ifnull)
            {
                throw"source");
            }

            return DistinctIterator(source, comparer);
        }

        privatestatic DistinctIterator(IEnumerable source, IEqualityComparer comparer)
        {
            Set  =  Setsetnew (TSource item  (   IEnumerable(comparer);
            foreachin source)
            {
                ifset.Add(item))
                {
                    yieldreturn item;
                }
            }
        }

        [__DynamicallyInvokable]
        publicstatic Union( IEnumerablethis first, IEnumerable (first ==  Error.ArgumentNull( (second ==  Error.ArgumentNull( UnionIterator(first, second,   IEnumerable second)
        {
            ifnull)
            {
                throw"first");
            }

            ifnull)
            {
                throw"second");
            }

            returnnull);
        }

        [__DynamicallyInvokable]
        publicstatic Union( IEnumerablethis first, IEnumerable second, IEqualityComparer (first ==  Error.ArgumentNull( (second ==  Error.ArgumentNull(  IEnumerable comparer)
        {
            ifnull)
            {
                throw"first");
            }

            ifnull)
            {
                throw"second");
            }

            return UnionIterator(first, second, comparer);
        }

        privatestatic UnionIterator(IEnumerable first, IEnumerable second, IEqualityComparer comparer)
        {
            Set  =  Setsetnew (TSource item  (  (TSource item2  (   IEnumerable(comparer);
            foreachin first)
            {
                ifset.Add(item))
                {
                    yieldreturn item;
                }
            }

            foreachin second)
            {
                ifset.Add(item2))
                {
                    yieldreturn item2;
                }
            }
        }

        [__DynamicallyInvokable]
        publicstatic Intersect( IEnumerablethis first, IEnumerable (first ==  Error.ArgumentNull( (second ==  Error.ArgumentNull( IntersectIterator(first, second,   IEnumerable second)
        {
            ifnull)
            {
                throw"first");
            }

            ifnull)
            {
                throw"second");
            }

            returnnull);
        }

        [__DynamicallyInvokable]
        publicstatic Intersect( IEnumerablethis first, IEnumerable second, IEqualityComparer (first ==  Error.ArgumentNull( (second ==  Error.ArgumentNull(  IEnumerable comparer)
        {
            ifnull)
            {
                throw"first");
            }

            ifnull)
            {
                throw"second");
            }

            return IntersectIterator(first, second, comparer);
        }

        privatestatic IntersectIterator(IEnumerable first, IEnumerable second, IEqualityComparer comparer)
        {
            Set  =  Setsetnew (TSource item  (TSource item2  (   IEnumerable(comparer);
            foreachin second)
            {
                set.Add(item);
            }

            foreachin first)
            {
                ifset.Remove(item2))
                {
                    yieldreturn item2;
                }
            }
        }

        [__DynamicallyInvokable]
        publicstatic Except( IEnumerablethis first, IEnumerable (first ==  Error.ArgumentNull( (second ==  Error.ArgumentNull( ExceptIterator(first, second,   IEnumerable second)
        {
            ifnull)
            {
                throw"first");
            }

            ifnull)
            {
                throw"second");
            }

            returnnull);
        }

        [__DynamicallyInvokable]
        publicstatic Except( IEnumerablethis first, IEnumerable second, IEqualityComparer (first ==  Error.ArgumentNull( (second ==  Error.ArgumentNull(  IEnumerable comparer)
        {
            ifnull)
            {
                throw"first");
            }

            ifnull)
            {
                throw"second");
            }

            return ExceptIterator(first, second, comparer);
        }

        privatestatic ExceptIterator(IEnumerable first, IEnumerable second, IEqualityComparer comparer)
        {
            Set  =  Setsetnew (TSource item  (TSource item2  (   IEnumerable(comparer);
            foreachin second)
            {
                set.Add(item);
            }

            foreachin first)
            {
                ifset.Add(item2))
                {
                    yieldreturn item2;
                }
            }
        }

        [__DynamicallyInvokable]
        publicstatic Reverse( IEnumerablethis (source ==  Error.ArgumentNull(  IEnumerable source)
        {
            ifnull)
            {
                throw"source");
            }

            return ReverseIterator(source);
        }

        privatestatic ReverseIterator(IEnumerable source)
        {
            Buffer buffer =  Buffernew ( i = buffer.count - ; i >= ; i--    SequenceEqual(source);
            forint10)
            {
                yieldreturn buffer.items[i];
            }
        }

        [__DynamicallyInvokable]
        publicstaticbool( IEnumerablethis first, IEnumerable first.SequenceEqual(second,    SequenceEqual second)
        {
            returnnull);
        }

        [__DynamicallyInvokable]
        publicstaticbool( IEnumerablethis first, IEnumerable second, IEqualityComparer (comparer == = EqualityComparer comparer)
        {
            ifnull)
            {
                comparer  (first ==  Error.ArgumentNull( (second ==  Error.ArgumentNull( (IEnumerator.Default;
            }

            ifnull)
            {
                throw"first");
            }

            ifnull)
            {
                throw"second");
            }

            using enumerator = (IEnumerator first.GetEnumerator())
            {
                using enumerator2 = (!enumerator2.MoveNext() || !     IEnumerable second.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        ifcomparer.Equals(enumerator.Current, enumerator2.Current))
                        {
                            returnfalse;
                        }
                    }

                    if (enumerator2.MoveNext())
                    {
                        returnfalse;
                    }
                }
            }

            returntrue;
        }

        [__DynamicallyInvokable]
        publicstatic AsEnumerable( IEnumerablethis  TSource[] ToArray source)
        {
            return source;
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis (source ==  Error.ArgumentNull(  Buffer source)
        {
            ifnull)
            {
                throw"source");
            }

            returnnew  List(source).ToArray();
        }

        [__DynamicallyInvokable]
        publicstatic ToList( IEnumerablethis (source ==  Error.ArgumentNull(  List source)
        {
            ifnull)
            {
                throw"source");
            }

            returnnew  Dictionary(source);
        }

        [__DynamicallyInvokable]
        publicstatic ToDictionary( IEnumerablethis source, Func source.ToDictionary(keySelector, IdentityFunction keySelector)
        {
            return.Instance,   Dictionarynull);
        }

        [__DynamicallyInvokable]
        publicstatic ToDictionary( IEnumerablethis source, Func keySelector, IEqualityComparer source.ToDictionary(keySelector, IdentityFunction comparer)
        {
            return  Dictionary.Instance, comparer);
        }

        [__DynamicallyInvokable]
        publicstatic ToDictionary( IEnumerablethis source, Func keySelector, Func source.ToDictionary(keySelector, elementSelector,   Dictionary elementSelector)
        {
            returnnull);
        }

        [__DynamicallyInvokable]
        publicstatic ToDictionary( IEnumerablethis source, Func keySelector, Func elementSelector, IEqualityComparer (source ==  Error.ArgumentNull( (keySelector ==  Error.ArgumentNull( (elementSelector ==  Error.ArgumentNull( comparer)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"keySelector");
            }

            ifnull)
            {
                throw"elementSelector");
            }

            Dictionary dictionary =  Dictionarynew (TSource item   ILookup(comparer);
            foreachin source)
            {
                dictionary.Add(keySelector(item), elementSelector(item));
            }

            return dictionary;
        }

        [__DynamicallyInvokable]
        publicstatic ToLookup( IEnumerablethis source, Func Lookup keySelector)
        {
            return.Create(source, keySelector, IdentityFunction.Instance,   ILookupnull);
        }

        [__DynamicallyInvokable]
        publicstatic ToLookup( IEnumerablethis source, Func keySelector, IEqualityComparer Lookup comparer)
        {
            return.Create(source, keySelector, IdentityFunction  ILookup.Instance, comparer);
        }

        [__DynamicallyInvokable]
        publicstatic ToLookup( IEnumerablethis source, Func keySelector, Func Lookup elementSelector)
        {
            return.Create(source, keySelector, elementSelector,   ILookupnull);
        }

        [__DynamicallyInvokable]
        publicstatic ToLookup( IEnumerablethis source, Func keySelector, Func elementSelector, IEqualityComparer Lookup comparer)
        {
            return  HashSet.Create(source, keySelector, elementSelector, comparer);
        }

        publicstatic ToHashSet( IEnumerablethis source.ToHashSet(  HashSet source)
        {
            returnnull);
        }

        publicstatic ToHashSet( IEnumerablethis source, IEqualityComparer (source ==  Error.ArgumentNull(  HashSet comparer)
        {
            ifnull)
            {
                throw"source");
            }

            returnnew  IEnumerable(source, comparer);
        }

        [__DynamicallyInvokable]
        publicstatic DefaultIfEmpty( IEnumerablethis source.DefaultIfEmpty(  IEnumerable source)
        {
            returndefault(TSource));
        }

        [__DynamicallyInvokable]
        publicstatic DefaultIfEmpty( IEnumerablethis (source ==  Error.ArgumentNull(  IEnumerable source, TSource defaultValue)
        {
            ifnull)
            {
                throw"source");
            }

            return DefaultIfEmptyIterator(source, defaultValue);
        }

        privatestatic DefaultIfEmptyIterator(IEnumerable (IEnumerator source, TSource defaultValue)
        {
            using e =    IEnumerable source.GetEnumerator())
            {
                if (e.MoveNext())
                {
                    do
                    {
                        yieldreturn e.Current;
                    }
                    while (e.MoveNext());
                }
                else
                {
                    yieldreturn defaultValue;
                }
            }
        }

        [__DynamicallyInvokable]
        publicstatic OfType( (source ==  Error.ArgumentNull( OfTypeIteratorthis IEnumerable source)
        {
            ifnull)
            {
                throw"source");
            }

            return  IEnumerable(source);
        }

        privatestatic OfTypeIterator ( item  (item    IEnumerable(IEnumerable source)
        {
            foreachobjectin source)
            {
                ifis TResult)
                {
                    yieldreturn (TResult)item;
                }
            }
        }

        [__DynamicallyInvokable]
        publicstatic Cast(this IEnumerable source)
        {
            IEnumerable enumerable = source  IEnumerableas (enumerable !=  (source ==  Error.ArgumentNull( CastIterator;
            ifnull)
            {
                return enumerable;
            }

            ifnull)
            {
                throw"source");
            }

            return  IEnumerable(source);
        }

        privatestatic CastIterator ( item    TSource First(IEnumerable source)
        {
            foreachobjectin source)
            {
                yieldreturn (TResult)item;
            }
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis (source ==  Error.ArgumentNull( source)
        {
            ifnull)
            {
                throw"source");
            }

            IList list = source  IListas (list !=  (list.Count >  list[ (IEnumerator;
            ifnull)
            {
                if0)
                {
                    return0];
                }
            }
            else
            {
                using enumerator =  TSource First source.GetEnumerator())
                {
                    if (enumerator.MoveNext())
                    {
                        return enumerator.Current;
                    }
                }
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull( (TSource item   TSource FirstOrDefault predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            foreachin source)
            {
                if (predicate(item))
                {
                    return item;
                }
            }

            throw Error.NoMatch();
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis (source ==  Error.ArgumentNull( source)
        {
            ifnull)
            {
                throw"source");
            }

            IList list = source  IListas (list !=  (list.Count >  list[ (IEnumerator;
            ifnull)
            {
                if0)
                {
                    return0];
                }
            }
            else
            {
                using enumerator =   TSource FirstOrDefault source.GetEnumerator())
                {
                    if (enumerator.MoveNext())
                    {
                        return enumerator.Current;
                    }
                }
            }

            returndefault(TSource);
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull( (TSource item    TSource Last predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            foreachin source)
            {
                if (predicate(item))
                {
                    return item;
                }
            }

            returndefault(TSource);
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis (source ==  Error.ArgumentNull( source)
        {
            ifnull)
            {
                throw"source");
            }

            IList list = source  IListas (list !=  count = (count >  list[count -  (IEnumerator;
            ifnull)
            {
                int list.Count;
                if0)
                {
                    return1];
                }
            }
            else
            {
                using enumerator ==  TSource Last source.GetEnumerator())
                {
                    if (enumerator.MoveNext())
                    {
                        TSource current;
                        do
                        {
                            current  enumerator.Current;
                        }
                        while (enumerator.MoveNext());
                        return current;
                    }
                }
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull(=  flag =  (TSource item ==   TSource LastOrDefault predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            TSource result default(TSource);
            boolfalse;
            foreachin source)
            {
                if (predicate(item))
                {
                    result  item;
                    flag true;
                }
            }

            if (flag)
            {
                return result;
            }

            throw Error.NoMatch();
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis (source ==  Error.ArgumentNull( source)
        {
            ifnull)
            {
                throw"source");
            }

            IList list = source  IListas (list !=  count = (count >  list[count -  (IEnumerator;
            ifnull)
            {
                int list.Count;
                if0)
                {
                    return1];
                }
            }
            else
            {
                using enumerator ==   TSource LastOrDefault source.GetEnumerator())
                {
                    if (enumerator.MoveNext())
                    {
                        TSource current;
                        do
                        {
                            current  enumerator.Current;
                        }
                        while (enumerator.MoveNext());
                        return current;
                    }
                }
            }

            returndefault(TSource);
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull(=  (TSource item =  TSource Single predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            TSource result default(TSource);
            foreachin source)
            {
                if (predicate(item))
                {
                    result  item;
                }
            }

            return result;
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis (source ==  Error.ArgumentNull( source)
        {
            ifnull)
            {
                throw"source");
            }

            IList list = source  IListas (list !=    list[ (IEnumerator;
            ifnull)
            {
                switch (list.Count)
                {
                    case0:
                        throw Error.NoElements();
                    case1:
                        return0];
                }
            }
            else
            {
                using enumerator = (!= (!  TSource Single source.GetEnumerator())
                {
                    ifenumerator.MoveNext())
                    {
                        throw Error.NoElements();
                    }

                    TSource current  enumerator.Current;
                    ifenumerator.MoveNext())
                    {
                        return current;
                    }
                }
            }

            throw Error.MoreThanOneElement();
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull(=  num =  (TSource item == (num +     TSource SingleOrDefault predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            TSource result default(TSource);
            long0L;
            foreachin source)
            {
                if (predicate(item))
                {
                    result  item;
                    num checked1);
                }
            }

            switch (num)
            {
                case0L:
                    throw Error.NoMatch();
                case1L:
                    return result;
                default:
                    throw Error.MoreThanOneMatch();
            }
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis (source ==  Error.ArgumentNull( source)
        {
            ifnull)
            {
                throw"source");
            }

            IList list = source  IListas (list !=     list[ (IEnumerator;
            ifnull)
            {
                switch (list.Count)
                {
                    case0:
                        returndefault(TSource);
                    case1:
                        return0];
                }
            }
            else
            {
                using enumerator = (! = (!  TSource SingleOrDefault source.GetEnumerator())
                {
                    ifenumerator.MoveNext())
                    {
                        returndefault(TSource);
                    }

                    TSource current  enumerator.Current;
                    ifenumerator.MoveNext())
                    {
                        return current;
                    }
                }
            }

            throw Error.MoreThanOneElement();
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull(=  num =  (TSource item == (num +      TSource ElementAt predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            TSource result default(TSource);
            long0L;
            foreachin source)
            {
                if (predicate(item))
                {
                    result  item;
                    num checked1);
                }
            }

            switch (num)
            {
                case0L:
                    returndefault(TSource);
                case1L:
                    return result;
                default:
                    throw Error.MoreThanOneMatch();
            }
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source,  (source ==  Error.ArgumentNull(int index)
        {
            ifnull)
            {
                throw"source");
            }

            IList list = source  IListas (list !=  (index <  Error.ArgumentOutOfRange( (IEnumerator;
            ifnull)
            {
                return list[index];
            }

            if0)
            {
                throw"index");
            }

            using enumerator = (index == -- Error.ArgumentOutOfRange(  TSource ElementAtOrDefault source.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    if0)
                    {
                        return enumerator.Current;
                    }

                    index;
                }

                throw"index");
            }
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source,  (source ==  Error.ArgumentNull( (index >= int index)
        {
            ifnull)
            {
                throw"source");
            }

            if0)
            {
                IList list = source  IListas (list !=  (index < (IEnumerator;
                ifnull)
                {
                    if list.Count)
                    {
                        return list[index];
                    }
                }
                else
                {
                    using enumerator = (index == --   IEnumerable<> Range( start,  num = ()start + ()count -  (count <  || num >  Error.ArgumentOutOfRange(  IEnumerable<> RangeIterator( start,  ( i = ; i < count; i++  start +  IEnumerable source.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            if0)
                            {
                                return enumerator.Current;
                            }

                            index;
                        }
                    }
                }
            }

            returndefault(TSource);
        }

        [__DynamicallyInvokable]
        publicstaticintintint count)
        {
            longlonglong1;
            if0int.MaxValue)
            {
                throw"count");
            }

            return RangeIterator(start, count);
        }

        privatestaticintintint count)
        {
            forint0)
            {
                yieldreturn i;
            }
        }

        [__DynamicallyInvokable]
        publicstatic Repeat(TResult element,  (count <  Error.ArgumentOutOfRange(  IEnumerableint count)
        {
            if0)
            {
                throw"count");
            }

            return RepeatIterator(element, count);
        }

        privatestatic RepeatIterator(TResult element,  ( i = ; i < count; i++   IEnumerableint count)
        {
            forint0)
            {
                yieldreturn element;
            }
        }

        [__DynamicallyInvokable]
        publicstatic Empty EmptyEnumerable()
        {
            return   Any.Instance;
        }

        [__DynamicallyInvokable]
        publicstaticbool( IEnumerablethis (source ==  Error.ArgumentNull( (IEnumerator source)
        {
            ifnull)
            {
                throw"source");
            }

            using enumerator =     Any source.GetEnumerator())
            {
                if (enumerator.MoveNext())
                {
                    returntrue;
                }
            }

            returnfalse;
        }

        [__DynamicallyInvokable]
        publicstaticbool( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull( (TSource item      All predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            foreachin source)
            {
                if (predicate(item))
                {
                    returntrue;
                }
            }

            returnfalse;
        }

        [__DynamicallyInvokable]
        publicstaticbool( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull( (TSource item  (!     Count predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            foreachin source)
            {
                ifpredicate(item))
                {
                    returnfalse;
                }
            }

            returntrue;
        }

        [__DynamicallyInvokable]
        publicstaticint( IEnumerablethis (source ==  Error.ArgumentNull( source)
        {
            ifnull)
            {
                throw"source");
            }

            ICollection collection = source  ICollectionas (collection != = source  (collection2 !=  num =  (IEnumerator;
            ifnull)
            {
                return collection.Count;
            }

            ICollection collection2 as ICollection;
            ifnull)
            {
                return collection2.Count;
            }

            int0;
            using enumerator == (num +    Count source.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    num checked1);
                }

                return num;
            }
        }

        [__DynamicallyInvokable]
        publicstaticint( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull( num =  (TSource item = (num +    LongCount predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            int0;
            foreachin source)
            {
                if (predicate(item))
                {
                    num checked1);
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticlong( IEnumerablethis (source ==  Error.ArgumentNull( num =  (IEnumerator source)
        {
            ifnull)
            {
                throw"source");
            }

            long0L;
            using enumerator == (num +    LongCount source.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    num checked1);
                }

                return num;
            }
        }

        [__DynamicallyInvokable]
        publicstaticlong( IEnumerablethis source, Funcbool> (source ==  Error.ArgumentNull( (predicate ==  Error.ArgumentNull( num =  (TSource item = (num +    Contains predicate)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"predicate");
            }

            long0L;
            foreachin source)
            {
                if (predicate(item))
                {
                    num checked1);
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticbool( IEnumerablethis (source  ICollection source, TSource value)
        {
            returnas)?.Contains(value) ?? source.Contains(value,    Containsnull);
        }

        [__DynamicallyInvokable]
        publicstaticbool( IEnumerablethis source, TSource value, IEqualityComparer (comparer == = EqualityComparer comparer)
        {
            ifnull)
            {
                comparer  (source ==  Error.ArgumentNull( (TSource item     TSource Aggregate.Default;
            }

            ifnull)
            {
                throw"source");
            }

            foreachin source)
            {
                if (comparer.Equals(item, value))
                {
                    returntrue;
                }
            }

            returnfalse;
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, Func (source ==  Error.ArgumentNull( (func ==  Error.ArgumentNull( (IEnumerator func)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"func");
            }

            using enumerator = (!==  TAccumulate Aggregate source.GetEnumerator())
            {
                ifenumerator.MoveNext())
                {
                    throw Error.NoElements();
                }

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

                return val;
            }
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, TAccumulate seed, Func (source ==  Error.ArgumentNull( (func ==  Error.ArgumentNull(= (TSource item =  TResult Aggregate func)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"func");
            }

            TAccumulate val  seed;
            foreachin source)
            {
                val  func(val, item);
            }

            return val;
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, TAccumulate seed, Func func, Func (source ==  Error.ArgumentNull( (func ==  Error.ArgumentNull( (resultSelector ==  Error.ArgumentNull(= (TSource item =   Sum( IEnumerable<> (source ==  Error.ArgumentNull( num =  ( item = (num +  ? Sum( IEnumerable<?> (source ==  Error.ArgumentNull( num =  (? item = (num +   Sum( IEnumerable<> (source ==  Error.ArgumentNull( num =  ( item = (num +  ? Sum( IEnumerable<?> (source ==  Error.ArgumentNull( num =  (? item = (num +   Sum( IEnumerable<> (source ==  Error.ArgumentNull( num =  ( item += ( (  ? Sum( IEnumerable<?> (source ==  Error.ArgumentNull( num =  (? item += ( (   Sum( IEnumerable<> (source ==  Error.ArgumentNull( num =  ( item +=  ? Sum( IEnumerable<?> (source ==  Error.ArgumentNull( num =  (? item +=   Sum( IEnumerable<> (source ==  Error.ArgumentNull( result = ( ( item +=  ? Sum( IEnumerable<?> (source ==  Error.ArgumentNull( value = ( (? item +=   Sum resultSelector)
        {
            ifnull)
            {
                throw"source");
            }

            ifnull)
            {
                throw"func");
            }

            ifnull)
            {
                throw"resultSelector");
            }

            TAccumulate val  seed;
            foreachin source)
            {
                val  func(val, item);
            }

            return resultSelector(val);
        }

        [__DynamicallyInvokable]
        publicstaticintthisint source)
        {
            ifnull)
            {
                throw"source");
            }

            int0;
            foreachintin source)
            {
                num checked item);
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticintthisint source)
        {
            ifnull)
            {
                throw"source");
            }

            int0;
            foreachintin source)
            {
                if (item.HasValue)
                {
                    num checked item.GetValueOrDefault());
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticlongthislong source)
        {
            ifnull)
            {
                throw"source");
            }

            long0L;
            foreachlongin source)
            {
                num checked item);
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticlongthislong source)
        {
            ifnull)
            {
                throw"source");
            }

            long0L;
            foreachlongin source)
            {
                if (item.HasValue)
                {
                    num checked item.GetValueOrDefault());
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticfloatthisfloat source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            foreachfloatin source)
            {
                num double)item;
            }

            returnfloat)num;
        }

        [__DynamicallyInvokable]
        publicstaticfloatthisfloat source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            foreachfloatin source)
            {
                if (item.HasValue)
                {
                    num double)item.GetValueOrDefault();
                }
            }

            returnfloat)num;
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisdouble source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            foreachdoublein source)
            {
                num  item;
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisdouble source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            foreachdoublein source)
            {
                if (item.HasValue)
                {
                    num  item.GetValueOrDefault();
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticdecimalthisdecimal source)
        {
            ifnull)
            {
                throw"source");
            }

            decimaldefaultdecimal);
            foreachdecimalin source)
            {
                result  item;
            }

            return result;
        }

        [__DynamicallyInvokable]
        publicstaticdecimalthisdecimal source)
        {
            ifnull)
            {
                throw"source");
            }

            decimaldefaultdecimal);
            foreachdecimalin source)
            {
                if (item.HasValue)
                {
                    value  item.GetValueOrDefault();
                }
            }

            return value;
        }

        [__DynamicallyInvokable]
        publicstaticint( IEnumerablethis source, Funcint>  ? Sum selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticint( IEnumerablethis source, Funcint?>   Sum selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticlong( IEnumerablethis source, Funclong>  ? Sum selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticlong( IEnumerablethis source, Funclong?>   Sum selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticfloat( IEnumerablethis source, Funcfloat>  ? Sum selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticfloat( IEnumerablethis source, Funcfloat?>   Sum selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcdouble>  ? Sum selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcdouble?>   Sum selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticdecimal( IEnumerablethis source, Funcdecimal>  ? Sum selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticdecimal( IEnumerablethis source, Funcdecimal?>   Min( IEnumerable<> (source ==  Error.ArgumentNull( num =  flag =  ( item  (item <===   ? Min( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (!num.HasValue || item <=   Min( IEnumerable<> (source ==  Error.ArgumentNull( num =  flag =  ( item  (item <===   ? Min( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (!num.HasValue || item <=   Min( IEnumerable<> (source ==  Error.ArgumentNull( num = flag =  ( item  (item < num || ===   ? Min( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (item.HasValue && (!num.HasValue || item < num || =   Min( IEnumerable<> (source ==  Error.ArgumentNull( num =  flag =  ( item  (item < num || ===   ? Min( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (item.HasValue && (!num.HasValue || item < num || =   Min( IEnumerable<> (source ==  Error.ArgumentNull( num = ( flag =  ( item  (item <===   ? Min( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (!num.HasValue || item <=  TSource Min selector)
        {
            return source.Select(selector).Sum();
        }

        [__DynamicallyInvokable]
        publicstaticintthisint source)
        {
            ifnull)
            {
                throw"source");
            }

            int0;
            boolfalse;
            foreachintin source)
            {
                if (flag)
                {
                    if num)
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticintthisint source)
        {
            ifnull)
            {
                throw"source");
            }

            intnull;
            foreachintin source)
            {
                if num)
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticlongthislong source)
        {
            ifnull)
            {
                throw"source");
            }

            long0L;
            boolfalse;
            foreachlongin source)
            {
                if (flag)
                {
                    if num)
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticlongthislong source)
        {
            ifnull)
            {
                throw"source");
            }

            longnull;
            foreachlongin source)
            {
                if num)
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticfloatthisfloat source)
        {
            ifnull)
            {
                throw"source");
            }

            float 0f;
            boolfalse;
            foreachfloatin source)
            {
                if (flag)
                {
                    iffloat.IsNaN(item))
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticfloatthisfloat source)
        {
            ifnull)
            {
                throw"source");
            }

            floatnull;
            foreachfloatin source)
            {
                iffloat.IsNaN(item.Value)))
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisdouble source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            boolfalse;
            foreachdoublein source)
            {
                if (flag)
                {
                    ifdouble.IsNaN(item))
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisdouble source)
        {
            ifnull)
            {
                throw"source");
            }

            doublenull;
            foreachdoublein source)
            {
                ifdouble.IsNaN(item.Value)))
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticdecimalthisdecimal source)
        {
            ifnull)
            {
                throw"source");
            }

            decimaldefaultdecimal);
            boolfalse;
            foreachdecimalin source)
            {
                if (flag)
                {
                    if num)
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticdecimalthisdecimal source)
        {
            ifnull)
            {
                throw"source");
            }

            decimalnull;
            foreachdecimalin source)
            {
                if num)
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis (source ==  Error.ArgumentNull( source)
        {
            ifnull)
            {
                throw"source");
            }

            Comparer @default = Comparer=  (val ==  (TSource item  (item !=  && (val ==  || @default.Compare(item, val) < = flag =  (TSource item2  (@default.Compare(item2, val) < ===    Min.Default;
            TSource val default(TSource);
            ifnull)
            {
                foreachin source)
                {
                    ifnullnull0))
                    {
                        val  item;
                    }
                }

                return val;
            }

            boolfalse;
            foreachin source)
            {
                if (flag)
                {
                    if0)
                    {
                        val  item2;
                    }
                }
                else
                {
                    val  item2;
                    flag true;
                }
            }

            if (flag)
            {
                return val;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticint( IEnumerablethis source, Funcint>  ? Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticint( IEnumerablethis source, Funcint?>   Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticlong( IEnumerablethis source, Funclong>  ? Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticlong( IEnumerablethis source, Funclong?>   Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticfloat( IEnumerablethis source, Funcfloat>  ? Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticfloat( IEnumerablethis source, Funcfloat?>   Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcdouble>  ? Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcdouble?>   Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticdecimal( IEnumerablethis source, Funcdecimal>  ? Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticdecimal( IEnumerablethis source, Funcdecimal?>  TResult Min selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, Func   Max( IEnumerable<> (source ==  Error.ArgumentNull( num =  flag =  ( item  (item >===   ? Max( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (!num.HasValue || item >=   Max( IEnumerable<> (source ==  Error.ArgumentNull( num =  flag =  ( item  (item >===   ? Max( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (!num.HasValue || item >=   Max( IEnumerable<> (source ==  Error.ArgumentNull( num =  flag =  ( item  (item > num || ===   ? Max( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (item.HasValue && (!num.HasValue || item > num || =   Max( IEnumerable<> (source ==  Error.ArgumentNull( num = flag =  ( item  (item > num || ===   ? Max( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (item.HasValue && (!num.HasValue || item > num || =   Max( IEnumerable<> (source ==  Error.ArgumentNull( num = ( flag =  ( item  (item >===   ? Max( IEnumerable<?> (source ==  Error.ArgumentNull(? num =  (? item  (!num.HasValue || item >=  TSource Max selector)
        {
            return source.Select(selector).Min();
        }

        [__DynamicallyInvokable]
        publicstaticintthisint source)
        {
            ifnull)
            {
                throw"source");
            }

            int0;
            boolfalse;
            foreachintin source)
            {
                if (flag)
                {
                    if num)
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticintthisint source)
        {
            ifnull)
            {
                throw"source");
            }

            intnull;
            foreachintin source)
            {
                if num)
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticlongthislong source)
        {
            ifnull)
            {
                throw"source");
            }

            long0L;
            boolfalse;
            foreachlongin source)
            {
                if (flag)
                {
                    if num)
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticlongthislong source)
        {
            ifnull)
            {
                throw"source");
            }

            longnull;
            foreachlongin source)
            {
                if num)
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisdouble source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            boolfalse;
            foreachdoublein source)
            {
                if (flag)
                {
                    ifdouble.IsNaN(num))
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisdouble source)
        {
            ifnull)
            {
                throw"source");
            }

            doublenull;
            foreachdoublein source)
            {
                ifdouble.IsNaN(num.Value)))
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticfloatthisfloat source)
        {
            ifnull)
            {
                throw"source");
            }

            float 0f;
            boolfalse;
            foreachfloatin source)
            {
                if (flag)
                {
                    ifdouble.IsNaN(num))
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticfloatthisfloat source)
        {
            ifnull)
            {
                throw"source");
            }

            floatnull;
            foreachfloatin source)
            {
                iffloat.IsNaN(num.Value)))
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstaticdecimalthisdecimal source)
        {
            ifnull)
            {
                throw"source");
            }

            decimaldefaultdecimal);
            boolfalse;
            foreachdecimalin source)
            {
                if (flag)
                {
                    if num)
                    {
                        num  item;
                    }
                }
                else
                {
                    num  item;
                    flag true;
                }
            }

            if (flag)
            {
                return num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticdecimalthisdecimal source)
        {
            ifnull)
            {
                throw"source");
            }

            decimalnull;
            foreachdecimalin source)
            {
                if num)
                {
                    num  item;
                }
            }

            return num;
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis (source ==  Error.ArgumentNull( source)
        {
            ifnull)
            {
                throw"source");
            }

            Comparer @default = Comparer=  (val ==  (TSource item  (item !=  && (val ==  || @default.Compare(item, val) > = flag =  (TSource item2  (@default.Compare(item2, val) > ===    Max.Default;
            TSource val default(TSource);
            ifnull)
            {
                foreachin source)
                {
                    ifnullnull0))
                    {
                        val  item;
                    }
                }

                return val;
            }

            boolfalse;
            foreachin source)
            {
                if (flag)
                {
                    if0)
                    {
                        val  item2;
                    }
                }
                else
                {
                    val  item2;
                    flag true;
                }
            }

            if (flag)
            {
                return val;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticint( IEnumerablethis source, Funcint>  ? Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticint( IEnumerablethis source, Funcint?>   Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticlong( IEnumerablethis source, Funclong>  ? Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticlong( IEnumerablethis source, Funclong?>   Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticfloat( IEnumerablethis source, Funcfloat>  ? Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticfloat( IEnumerablethis source, Funcfloat?>   Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcdouble>  ? Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcdouble?>   Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticdecimal( IEnumerablethis source, Funcdecimal>  ? Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticdecimal( IEnumerablethis source, Funcdecimal?>  TResult Max selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstatic( IEnumerablethis source, Func   Average( IEnumerable<> (source ==  Error.ArgumentNull( num =  num2 =  ( item +=++ (num2 >  ()num / (  ? Average( IEnumerable<?> (source ==  Error.ArgumentNull( num =  num2 =  (? item +=++ (num2 >  ()num / (    Average( IEnumerable<> (source ==  Error.ArgumentNull( num =  num2 =  ( item +=++ (num2 >  ()num / (  ? Average( IEnumerable<?> (source ==  Error.ArgumentNull( num =  num2 =  (? item +=++ (num2 >  ()num / (    Average( IEnumerable<> (source ==  Error.ArgumentNull( num =  num2 =  ( item += (= (num2 +  (num2 >  ()(num / (  ? Average( IEnumerable<?> (source ==  Error.ArgumentNull( num =  num2 =  (? item += (= (num2 +  (num2 >  ()(num / (    Average( IEnumerable<> (source ==  Error.ArgumentNull( num =  num2 =  ( item +== (num2 +  (num2 >  num / (  ? Average( IEnumerable<?> (source ==  Error.ArgumentNull( num =  num2 =  (? item +== (num2 +  (num2 >  num / (    Average( IEnumerable<> (source ==  Error.ArgumentNull( d = ( num =  ( item +== (num +  (num >  d / (  ? Average( IEnumerable<?> (source ==  Error.ArgumentNull( d = ( num =  (? item +== (num +  (num >  d / (    Average selector)
        {
            return source.Select(selector).Max();
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisint source)
        {
            ifnull)
            {
                throw"source");
            }

            long0L;
            long0L;
            checked
            {
                foreachintin source)
                {
                    num  item;
                    num2;
                }

                if0)
                {
                    returndoubledouble)num2;
                }

                throw Error.NoElements();
            }
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisint source)
        {
            ifnull)
            {
                throw"source");
            }

            long0L;
            long0L;
            checked
            {
                foreachintin source)
                {
                    if (item.HasValue)
                    {
                        num  item.GetValueOrDefault();
                        num2;
                    }
                }

                if0)
                {
                    returndoubledouble)num2;
                }

                returnnull;
            }
        }

        [__DynamicallyInvokable]
        publicstaticdoublethislong source)
        {
            ifnull)
            {
                throw"source");
            }

            long0L;
            long0L;
            checked
            {
                foreachlongin source)
                {
                    num  item;
                    num2;
                }

                if0)
                {
                    returndoubledouble)num2;
                }

                throw Error.NoElements();
            }
        }

        [__DynamicallyInvokable]
        publicstaticdoublethislong source)
        {
            ifnull)
            {
                throw"source");
            }

            long0L;
            long0L;
            checked
            {
                foreachlongin source)
                {
                    if (item.HasValue)
                    {
                        num  item.GetValueOrDefault();
                        num2;
                    }
                }

                if0)
                {
                    returndoubledouble)num2;
                }

                returnnull;
            }
        }

        [__DynamicallyInvokable]
        publicstaticfloatthisfloat source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            long0L;
            foreachfloatin source)
            {
                num double)item;
                num2 checked1);
            }

            if0)
            {
                returnfloatdouble)num2);
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticfloatthisfloat source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            long0L;
            foreachfloatin source)
            {
                if (item.HasValue)
                {
                    num double)item.GetValueOrDefault();
                    num2 checked1);
                }
            }

            if0)
            {
                returnfloatdouble)num2);
            }

            returnnull;
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisdouble source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            long0L;
            foreachdoublein source)
            {
                num  item;
                num2 checked1);
            }

            if0)
            {
                returndouble)num2;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticdoublethisdouble source)
        {
            ifnull)
            {
                throw"source");
            }

            double0.0;
            long0L;
            foreachdoublein source)
            {
                if (item.HasValue)
                {
                    num  item.GetValueOrDefault();
                    num2 checked1);
                }
            }

            if0)
            {
                returndouble)num2;
            }

            returnnull;
        }

        [__DynamicallyInvokable]
        publicstaticdecimalthisdecimal source)
        {
            ifnull)
            {
                throw"source");
            }

            decimaldefaultdecimal);
            long0L;
            foreachdecimalin source)
            {
                d  item;
                num checked1);
            }

            if0)
            {
                returndecimal)num;
            }

            throw Error.NoElements();
        }

        [__DynamicallyInvokable]
        publicstaticdecimalthisdecimal source)
        {
            ifnull)
            {
                throw"source");
            }

            decimaldefaultdecimal);
            long0L;
            foreachdecimalin source)
            {
                if (item.HasValue)
                {
                    d  item.GetValueOrDefault();
                    num checked1);
                }
            }

            if0)
            {
                returndecimal)num;
            }

            returnnull;
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcint>  ? Average selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcint?>   Average selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funclong>  ? Average selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funclong?>   Average selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        publicstaticfloat( IEnumerablethis source, Funcfloat>  ? Average selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        publicstaticfloat( IEnumerablethis source, Funcfloat?>   Average selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcdouble>  ? Average selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        publicstaticdouble( IEnumerablethis source, Funcdouble?>   Average selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        publicstaticdecimal( IEnumerablethis source, Funcdecimal>  ? Average selector)
        {
            return source.Select(selector).Average();
        }

        [__DynamicallyInvokable]
        publicstaticdecimal( IEnumerablethis source, Funcdecimal?>  IEnumerable selector)
        {
            return source.Select(selector).Average();
        }

        publicstatic Append( IEnumerablethis (source ==  Error.ArgumentNull( source, TSource element)
        {
            ifnull)
            {
                throw"source");
            }

            AppendPrependIterator appendPrependIterator = source  AppendPrependIteratoras (appendPrependIterator !=   AppendPrepend1Iterator;
            ifnull)
            {
                return appendPrependIterator.Append(element);
            }

            returnnew(source, element, appending:   IEnumerabletrue);
        }

        publicstatic Prepend( IEnumerablethis (source ==  Error.ArgumentNull( source, TSource element)
        {
            ifnull)
            {
                throw"source");
            }

            AppendPrependIterator appendPrependIterator = source  AppendPrependIteratoras (appendPrependIterator !=   AppendPrepend1Iterator;
            ifnull)
            {
                return appendPrependIterator.Prepend(element);
            }

            returnnew(source, element, appending: false);
        }
    }
}

 

你可能感兴趣的:(通过反编译得到System.Core程序集中System.Linq命名空间下的Enumerable类)