}

        private void unwindTo(String element, TokenVisitor visitor) {
            if (elementStack.contains(element)) {
                while (!elementStack.getFirst().equals(element)) {
                    visitor.onEndHtmlElement(elementStack.removeFirst());
                }
                elementStack.removeFirst();
                visitor.onEndHtmlElement(element);
            }
        }

  private static final @Nullable String NE = null;

  private static <E extends @Nullable Object> Entry<E> entry(E element, int count) {
    return Multisets.immutableEntry(element, count);
  }

  private static <E extends @Nullable Object> Entry<E> control(E element, int count) {
    return HashMultiset.create(nCopies(count, element)).entrySet().iterator().next();
  }

  public void testToString() {

        Element rootElement = parentPom.root();
        if (rootElement == null) {
            return;
        }

        // Find modules element
        Element modulesElement = rootElement.child(MODULES).orElse(null);
        if (modulesElement == null) {
            return;
        }

        // Process each module

    }

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

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

    @Override
    public Iterator<E> iterator() {
      // We explicitly don't lock for iterator()
      assertFalse(Thread.holdsLock(mutex));

             */
            requireNonNull(element);
            if (visited.add(element)) {
              return element;
            }
          }
          horizon.removeFirst();
          return null;
        }
      };
    }

   * nulls as long as the *last* element is *not* null.
   *
   * (To "go out of its way," the method tracks a `set` bit so that it can distinguish "the final
   * split has a last element of null, so throw NPE" from "the final split was empty, so look for an
   * element in the prior one.")
   */
  public static <T> java.util.Optional<T> findLast(Stream<T> stream) {

                    List<Integer> columnKeys = new ArrayList<>();
                    for (Object element : elements) {
                      @SuppressWarnings("unchecked")
                      Cell<String, Integer, Character> cell =
                          (Cell<String, Integer, Character>) element;
                      columnKeys.add(cell.getColumnKey());
                    }

                    List<Integer> columnKeys = new ArrayList<>();
                    for (Object element : elements) {
                      @SuppressWarnings("unchecked")
                      Cell<String, Integer, Character> cell =
                          (Cell<String, Integer, Character>) element;
                      columnKeys.add(cell.getColumnKey());
                    }

        override fun contains(element: Protocol?): Boolean {
          if (element == null) throw NullPointerException()
          return super.contains(element)
        }

        override fun indexOf(element: Protocol?): Int {
          if (element == null) throw NullPointerException()
          return super.indexOf(element)
        }
      } as List<Protocol>
    val client =

      }
      return newCapacity;
    }

    @CanIgnoreReturnValue
    public abstract Builder<E> add(E element);

    @CanIgnoreReturnValue
    public Builder<E> add(E... elements) {
      checkNotNull(elements); // for GWT
      for (E element : elements) {
        add(checkNotNull(element));
      }
      return this;
    }

    @CanIgnoreReturnValue