void MergeWithEnumerators(IEnumerable<int> leftSequence, IEnumerable<int> rightSequence)
    {
        // enumerate the sequences

        using (IEnumerator<int> left = leftSequence.GetEnumerator())
        using (IEnumerator<int> right = rightSequence.GetEnumerator())
        {
            // start the enumeration

            bool leftHasItems = left.MoveNext();
            bool rightHasItems = right.MoveNext();

            // continue until out of items

            while (leftHasItems || rightHasItems)
            {
                // determine whether to output from left or right

                bool outputLeft;
                if (leftHasItems && rightHasItems)
                    outputLeft = left.Current < right.Current;
                else
                    outputLeft = leftHasItems;

                // output correct element

                if (outputLeft)
                {
                    Console.WriteLine(left.Current);
                    leftHasItems = left.MoveNext();
                }
                else
                {
                    Console.WriteLine(right.Current);
                    rightHasItems = right.MoveNext();
                }
            }
        }
    }

    // The Merge coroutine is run on each of the two input sequences.

    async void Merge(IEnumerable<int> seq, int? smallestInOther)
    {
        // process our entire sequence

        foreach (int value in seq)
        {
            // switch to the other if it has smaller values than we do

            if (value > smallestInOther)
                smallestInOther = await SwitchToOther(value);

            // our value is smaller, print it

            Console.WriteLine(value);
        }
    }

    // continuations (queued up by "await SwitchToOther") that are ready to be resumed

    Queue<SwitchAwaiter> awaiters = new Queue<SwitchAwaiter>();

    // the smallest value in each input sequence; this needs to be passed to the other Merge method

    Queue<int> smallestValues = new Queue<int>();

    // Merges two sequences using coroutines.

    void Merge(IEnumerable<int> left, IEnumerable<int> right)
    {
        // start each of the methods running

        Merge(left, int.MinValue);
        Merge(right, smallestValues.Dequeue());

        // keep switching between them as requested

        while (awaiters.Count > 0)
        {
            SwitchAwaiter switchAwaiter = awaiters.Dequeue();

            // the last switch will have no smallest value (because the Merge method finished its

            // enumeration, and exited); we pass 'null' as a sentinel

            switchAwaiter.Resume(smallestValues.Count == 0 ? default(int?) : smallestValues.Dequeue());
        }
    }

    // Allows a method to switch to another method by 'awaiting' the returned value.

    SwitchAwaiter SwitchToOther(int smallest)
    {
        // this method is called by 'await', so we need to return a type that implements 'GetAwaiter'

        SwitchAwaiter switchAwaiter = new SwitchAwaiter();

        // queue this as the method to switch to in the future

        awaiters.Enqueue(switchAwaiter);
        smallestValues.Enqueue(smallest);

        return switchAwaiter;
    }

    class SwitchAwaiter
    {
        public SwitchAwaiter GetAwaiter()
        {
            // 'GetAwaiter' must return an object that implements 'BeginAwait' and 'EndAwait'

            // for simplicity, it can be this same object

            return this;
        }

        // 'BeginAwait' is called to "suspend" the method executing the 'await'.

        public bool BeginAwait(Action resume)
        {
            // save the action that will be used to resume the method

            m_resume = resume;

            // 'true' means that the awaiting method needs to return control to its caller and

            // that it will be resumed later on

            return true;
        }

        public int? EndAwait()
        {
            // once we resume the method, 'EndAwait' supplies a value to it (from the 'await' keyword)

            // in this case, we give it the smallest value from the other Merge method

            return m_smallest;
        }

        // 'Resume' returns control to the method that executed 'await SwitchToOther'. 'smallest' is the

        // smallest value in the sequence being enumerated by the other method.

        public void Resume(int? smallestInOther)
        {
            m_smallest = smallestInOther;
            m_resume();
        }

        Action m_resume;
        int? m_smallest;
    }