while (stack.size() > 1) {
          A right = pop(stack);
          A left = pop(stack);
          push(stack, collector.combiner().apply(left, right));
        }
        return pop(stack);
      }

      <E extends @Nullable Object> void push(List<E> stack, E value) {
        stack.add(value);
      }

      <E extends @Nullable Object> E pop(List<E> stack) {
        return stack.remove(stack.size() - 1);

     * null} if {@code remove()} or {@code add()} has been called more recently than either. We use
     * this to determine which stack to pop from on a call to {@code remove()} (or to pop from and
     * push to on a call to {@code set()}).
     */
    @Nullable Stack<E> stackWithLastReturnedElementAtTop = null;

    MultiExceptionListIterator(List<E> expectedElements) {

  @Override
  @CheckForNull
  public E pollLast() {
    return delegate().pollLast();
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public E pop() {
    return delegate().pop();
  }

  @Override
  public void push(@ParametricNullness E e) {
    delegate().push(e);
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness

     * null} if {@code remove()} or {@code add()} has been called more recently than either. We use
     * this to determine which stack to pop from on a call to {@code remove()} (or to pop from and
     * push to on a call to {@code set()}).
     */
    @Nullable Stack<E> stackWithLastReturnedElementAtTop = null;

    MultiExceptionListIterator(List<E> expectedElements) {

    }

    @Override
    public void push(E e) {
      assertTrue(Thread.holdsLock(mutex));
      delegate.push(e);
    }

    @Override
    public E pop() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.pop();
    }

    @Override
    public Iterator<E> descendingIterator() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.descendingIterator();
    }

          // An extra '?' or ',' after a child node indicates the end of all children of this node.
          idx++;
          break;
        }
      }
    }

    stack.pop();
    return idx - start;
  }

  private static CharSequence reverse(CharSequence s) {
    return new StringBuilder(s).reverse();
  }

    }

    @Override
    public void push(E e) {
      assertTrue(Thread.holdsLock(mutex));
      delegate.push(e);
    }

    @Override
    public E pop() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.pop();
    }

    @Override
    public Iterator<E> descendingIterator() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.descendingIterator();
    }

  @Override
  @CheckForNull
  public E pollLast() {
    return delegate().pollLast();
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public E pop() {
    return delegate().pop();
  }

  @Override
  public void push(@ParametricNullness E e) {
    delegate().push(e);
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness

    }

    @Override
    public void push(E e) {
      synchronized (mutex) {
        delegate().push(e);
      }
    }

    @Override
    public E pop() {
      synchronized (mutex) {
        return delegate().pop();
      }
    }

    @Override
    public Iterator<E> descendingIterator() {
      synchronized (mutex) {
        return delegate().descendingIterator();

            ancestorStack.push(next);
          }
          // TODO(b/192579700): Use a ternary once it no longer confuses our nullness checker.
          if (!ancestorStack.isEmpty()) {
            return ancestorStack.pop();
          }
          return endOfData();
        }
      };
    }

    /**
     * Visits the next node from the top iterator of {@code horizon} and returns the visited node.