mmHeap.add(4);
    mmHeap.add(2);
    mmHeap.add(3);
    assertEquals(4, (int) mmHeap.pollLast());
    assertEquals(3, (int) mmHeap.peekLast());
    assertEquals(3, (int) mmHeap.pollLast());
    assertEquals(1, (int) mmHeap.peek());
    assertEquals(2, (int) mmHeap.peekLast());
    assertEquals(2, (int) mmHeap.pollLast());
    assertEquals(1, (int) mmHeap.peek());
    assertEquals(1, (int) mmHeap.peekLast());

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

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

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

    @Override

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

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

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

    @Override

    }

    @Override
    public @Nullable E pollFirst() {
      return getElementOrNull(multiset().pollFirstEntry());
    }

    @Override
    public @Nullable E pollLast() {
      return getElementOrNull(multiset().pollLastEntry());
    }

    @Override
    public NavigableSet<E> subSet(
        @ParametricNullness E fromElement,
        boolean fromInclusive,

        NavigableSet<Integer> filtered = filter(createUnfiltered(contents), EVEN);
        NavigableSet<Integer> unfiltered = createUnfiltered(filtered);

        assertEquals(unfiltered.pollLast(), filtered.pollLast());
        assertEquals(unfiltered, filtered);
      }
    }

    public void testNavigation() {
      for (List<Integer> contents : SAMPLE_INPUTS) {

    public @Nullable E higher(@ParametricNullness E e) {
      return forward.lower(e);
    }

    @Override
    public @Nullable E pollFirst() {
      return forward.pollLast();
    }

    @Override
    public @Nullable E pollLast() {
      return forward.pollFirst();
    }

    @Override
    public NavigableSet<E> descendingSet() {
      return forward;
    }

    @Override

      return getSortedSetDelegate().higher(v);
    }

    @Override
    public @Nullable V pollFirst() {
      return Iterators.pollNext(iterator());
    }

    @Override
    public @Nullable V pollLast() {
      return Iterators.pollNext(descendingIterator());
    }

    private NavigableSet<V> wrap(NavigableSet<V> wrapped) {

            }
        } else if ("user_agent".equalsIgnoreCase(qName) && GLOBALPARAMS.equalsIgnoreCase(tagQueue.get(tagQueue.size() - 2))) {
            userAgent = textBuf.toString().trim();
        }
        tagQueue.pollLast();
        textBuf.setLength(0);
    }

    /**
     * SAX event handler called to process character data between XML elements.

    }
    try {
      unmod.pollFirst();
      fail("UnsupportedOperationException expected");
    } catch (UnsupportedOperationException expected) {
    }
    try {
      unmod.pollLast();
      fail("UnsupportedOperationException expected");
    } catch (UnsupportedOperationException expected) {
    }
    try {
      Iterator<Integer> iterator = unmod.iterator();
      iterator.next();

   */
  @CanIgnoreReturnValue
  @Deprecated
  @GwtIncompatible // NavigableSet
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final @Nullable E pollLast() {
    throw new UnsupportedOperationException();
  }

  @GwtIncompatible // NavigableSet
  @LazyInit
  transient @Nullable ImmutableSortedSet<E> descendingSet;

  /**
   * @since 12.0
   */