}

  @Override
  public Range<K> span() {
    Entry<Cut<K>, RangeMapEntry<K, V>> firstEntry = entriesByLowerBound.firstEntry();
    Entry<Cut<K>, RangeMapEntry<K, V>> lastEntry = entriesByLowerBound.lastEntry();
    // Either both are null or neither is, but we check both to satisfy the nullness checker.
    if (firstEntry == null || lastEntry == null) {
      throw new NoSuchElementException();
    }
    return Range.create(

  }

  @Override
  Entry<E> getEntry(int index) {
    return Multisets.immutableEntry(elementSet.asList().get(index), getCount(index));
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return isEmpty() ? null : getEntry(0);
  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return isEmpty() ? null : getEntry(length - 1);
  }

  @Override

        }
      };
    }

    @Override
    public NavigableSet<E> elementSet() {
      return new StandardElementSet();
    }

    @Override
    public Entry<E> firstEntry() {
      return standardFirstEntry();
    }

    @Override
    public Entry<E> lastEntry() {
      return standardLastEntry();
    }

    @Override
    public Entry<E> pollFirstEntry() {

        }
      };
    }

    @Override
    public NavigableSet<E> elementSet() {
      return new StandardElementSet();
    }

    @Override
    public Entry<E> firstEntry() {
      return standardFirstEntry();
    }

    @Override
    public Entry<E> lastEntry() {
      return standardLastEntry();
    }

    @Override
    public Entry<E> pollFirstEntry() {

      return standardHigherEntry(key);
    }

    @Override
    public @Nullable K higherKey(K key) {
      return standardHigherKey(key);
    }

    @Override
    public @Nullable Entry<K, V> firstEntry() {
      return standardFirstEntry();
    }

    /*
     * We can't override lastEntry to delegate to standardLastEntry, as it would create an infinite

              });
          // requireNonNull is safe because the first `size` elements have been filled in.
          Entry<K, V> firstEntry = requireNonNull(entryArray[0]);
          K prevKey = firstEntry.getKey();
          keys[0] = prevKey;
          values[0] = firstEntry.getValue();
          checkEntryNotNull(keys[0], values[0]);
          for (int i = 1; i < size; i++) {

    public @Nullable K higherKey(@ParametricNullness K key) {
      return sortedMap().higherKey(key);
    }

    @Override
    public @Nullable Entry<K, Collection<V>> firstEntry() {
      Entry<K, Collection<V>> entry = sortedMap().firstEntry();
      return (entry == null) ? null : wrapEntry(entry);
    }

    @Override
    public @Nullable Entry<K, Collection<V>> lastEntry() {

        }
        return descendingMap;
      }
    }

    @Override
    public Map.@Nullable Entry<K, V> firstEntry() {
      synchronized (mutex) {
        return nullableSynchronizedEntry(delegate().firstEntry(), mutex);
      }
    }

    @Override
    public Map.@Nullable Entry<K, V> floorEntry(K key) {
      synchronized (mutex) {

        }
        return descendingMap;
      }
    }

    @Override
    public Map.@Nullable Entry<K, V> firstEntry() {
      synchronized (mutex) {
        return nullableSynchronizedEntry(delegate().firstEntry(), mutex);
      }
    }

    @Override
    public Map.@Nullable Entry<K, V> floorEntry(K key) {
      synchronized (mutex) {

    public NavigableMap<K, V2> descendingMap() {
      return transformEntries(fromMap().descendingMap(), transformer);
    }

    @Override
    public @Nullable Entry<K, V2> firstEntry() {
      return transformEntry(fromMap().firstEntry());
    }

    @Override
    public @Nullable Entry<K, V2> floorEntry(@ParametricNullness K key) {
      return transformEntry(fromMap().floorEntry(key));
    }