assertEquals(a, sortedMultiset.headMultiset(b.getElement(), OPEN).lastEntry());
    assertEquals(a, sortedMultiset.headMultiset(c.getElement(), OPEN).lastEntry());
  }

  @CollectionSize.Require(SEVERAL)
  public void testFloor() {
    resetWithHole();
    assertEquals(a, sortedMultiset.headMultiset(a.getElement(), CLOSED).lastEntry());

    }
  }

  @Override
  public @Nullable Entry<K, V> lastEntry() {
    return delegate().lastEntry();
  }

  /**
   * A sensible definition of {@link #lastEntry} in terms of the {@code iterator()} of the {@link
   * #entrySet} of {@link #descendingMap}. If you override {@code descendingMap}, you may wish to
   * override {@code lastEntry} to forward to this implementation.
   */

    }
  }

  @Override
  public @Nullable Entry<K, V> lastEntry() {
    return delegate().lastEntry();
  }

  /**
   * A sensible definition of {@link #lastEntry} in terms of the {@code iterator()} of the {@link
   * #entrySet} of {@link #descendingMap}. If you override {@code descendingMap}, you may wish to
   * override {@code lastEntry} to forward to this implementation.
   */

    assertEquals(a, sortedMultiset.headMultiset(b.getElement(), OPEN).lastEntry());
    assertEquals(a, sortedMultiset.headMultiset(c.getElement(), OPEN).lastEntry());
  }

  @CollectionSize.Require(SEVERAL)
  public void testFloor() {
    resetWithHole();
    assertEquals(a, sortedMultiset.headMultiset(a.getElement(), CLOSED).lastEntry());

      }
      if (succ == null) {
        lastEntry = pred;
      } else {
        succ.predecessorInValueSet = pred;
      }
    }

    private void deleteFromValueSet(ValueEntry<K, V> entry) {
      succeedsInValueSet(entry.predecessorInValueSet, entry.successorInValueSet);
    }

    private void appendToValueSet(ValueEntry<K, V> newEntry) {
      succeedsInValueSet(lastEntry, newEntry);
      lastEntry = newEntry;

      }
      if (succ == null) {
        lastEntry = pred;
      } else {
        succ.predecessorInValueSet = pred;
      }
    }

    private void deleteFromValueSet(ValueEntry<K, V> entry) {
      succeedsInValueSet(entry.predecessorInValueSet, entry.successorInValueSet);
    }

    private void appendToValueSet(ValueEntry<K, V> newEntry) {
      succeedsInValueSet(lastEntry, newEntry);
      lastEntry = newEntry;

    }

    if (succ == ENDPOINT) {
      lastEntry = pred;
    } else {
      setPredecessor(succ, pred);
    }
  }

  @Override
  void insertEntry(
      int entryIndex, @ParametricNullness K key, @ParametricNullness V value, int hash, int mask) {
    super.insertEntry(entryIndex, key, value, hash, mask);
    setSucceeds(lastEntry, entryIndex);
    setSucceeds(entryIndex, ENDPOINT);
  }

      assertTrue(Thread.holdsLock(mutex));
      return delegate().higherKey(key);
    }

    @Override
    public @Nullable Entry<K, V> lastEntry() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate().lastEntry();
    }

    @Override
    public @Nullable Entry<K, V> lowerEntry(K key) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate().lowerEntry(key);

          }
        }
        return false;
      }
      return true;
    }

    @Override
    public void remove() {
      checkState(lastEntry != null);
      LocalCache.this.remove(lastEntry.getKey(), lastEntry.getValue());
      lastEntry = null;
    }
  }

  /** KeyIterator build on top of EntryIterator. */
  final class KeyIterator implements Iterator<K> {

      long lastEntry = entries[srcIndex];
      entries[dstIndex] = lastEntry;
      entries[srcIndex] = UNSET;

      // also need to update whoever's "next" pointer was pointing to the last entry place
      // reusing "tableIndex" and "next"; these variables were no longer needed
      int tableIndex = getHash(lastEntry) & hashTableMask();
      int lastNext = table[tableIndex];