}

  /**
   * A sensible definition of {@link #pollLast} in terms of the {@code descendingIterator} method.
   * If you override {@link #descendingIterator} you may wish to override {@link #pollLast} to
   * forward to this implementation.
   */
  @CheckForNull
  protected E standardPollLast() {
    return Iterators.pollNext(descendingIterator());
  }

  @ParametricNullness
  protected E standardFirst() {

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

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

    private static final long serialVersionUID = 0;
  }

  @SuppressWarnings("CheckReturnValue")
  public void testHoldsLockOnAllOperations() {

    return forward.contains(object);
  }

  @Override
  public int size() {
    return forward.size();
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return forward.descendingIterator();
  }

  @Override
  ImmutableSortedSet<E> headSetImpl(E toElement, boolean inclusive) {
    return forward.tailSet(toElement, inclusive).descendingSet();
  }

  @Override

  }

  @Override
  public boolean containsAll(Collection<?> c) {
    return delegate.containsAll(c);
  }

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

  @Override
  public NavigableSet<E> descendingSet() {
    return new SafeTreeSet<>(delegate.descendingSet());
  }

  @Override
  public E first() {

    return forward.contains(object);
  }

  @Override
  public int size() {
    return forward.size();
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return forward.descendingIterator();
  }

  @Override
  ImmutableSortedSet<E> headSetImpl(E toElement, boolean inclusive) {
    return forward.tailSet(toElement, inclusive).descendingSet();
  }

  @Override

    delegate().addFirst(e);
  }

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

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

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

  @Override
  @ParametricNullness
  public E getLast() {

    }

    @Override
    public NavigableSet<E> descendingSet() {
      return new NavigableElementSet<>(multiset().descendingMultiset());
    }

    @Override
    public Iterator<E> descendingIterator() {
      return descendingSet().iterator();
    }

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

    }

    @Override
    public Iterator<E> descendingIterator() {
      return Iterators.filter(unfiltered().descendingIterator(), predicate);
    }

    @Override
    @ParametricNullness
    public E last() {
      return Iterators.find(unfiltered().descendingIterator(), predicate);
    }

    @Override
    public NavigableSet<E> subSet(

  @Override
  @CheckForNull
  public E lower(E e) {
    return Iterators.<@Nullable E>getNext(headSet(e, false).descendingIterator(), null);
  }

  /** @since 12.0 */
  @Override
  @CheckForNull
  public E floor(E e) {
    return Iterators.<@Nullable E>getNext(headSet(e, true).descendingIterator(), null);
  }

  /** @since 12.0 */
  @Override
  @CheckForNull
  public E ceiling(E e) {

        return equalsOrThrow(previous, last) ? null : domain.next(previous);
      }
    };
  }

  @GwtIncompatible // NavigableSet
  @Override
  public UnmodifiableIterator<C> descendingIterator() {
    return new AbstractSequentialIterator<C>(last()) {
      final C first = first();

      @Override
      @CheckForNull
      protected C computeNext(C previous) {