@GwtIncompatible
public abstract class ForwardingNavigableMap<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingSortedMap<K, V> implements NavigableMap<K, V> {

  /** Constructor for use by subclasses. */
  protected ForwardingNavigableMap() {}

  @Override
  protected abstract NavigableMap<K, V> delegate();

  @Override
  public @Nullable Entry<K, V> lowerEntry(@ParametricNullness K key) {

@GwtIncompatible
public abstract class ForwardingNavigableMap<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingSortedMap<K, V> implements NavigableMap<K, V> {

  /** Constructor for use by subclasses. */
  protected ForwardingNavigableMap() {}

  @Override
  protected abstract NavigableMap<K, V> delegate();

  @Override
  public @Nullable Entry<K, V> lowerEntry(@ParametricNullness K key) {

    return (Collector) TO_OPTIONAL;
  }

  private static final Object NULL_PLACEHOLDER = new Object();

  private static final Collector<@Nullable Object, ?, @Nullable Object> ONLY_ELEMENT =
      Collector.<@Nullable Object, ToOptionalState<Object>, @Nullable Object>of(
          () -> new ToOptionalState<>(null),
          (state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),
          ToOptionalState::combine,

    }
  }

  private static <E extends @Nullable Object> E getElementOrThrow(@Nullable Entry<E> entry) {
    if (entry == null) {
      throw new NoSuchElementException();
    }
    return entry.getElement();
  }

  private static <E extends @Nullable Object> @Nullable E getElementOrNull(
      @Nullable Entry<E> entry) {
    return (entry == null) ? null : entry.getElement();
  }

  private final boolean hasLowerBound;
  private final @Nullable T lowerEndpoint;
  private final BoundType lowerBoundType;
  private final boolean hasUpperBound;
  private final @Nullable T upperEndpoint;
  private final BoundType upperBoundType;

  private GeneralRange(
      Comparator<? super T> comparator,
      boolean hasLowerBound,
      @Nullable T lowerEndpoint,
      BoundType lowerBoundType,

    TreeMultimap<@Nullable String, @Nullable Integer> multimap = createPopulate();
    assertThat(multimap.entries())
        .containsExactly(
            Maps.<@Nullable String, Integer>immutableEntry(null, 7),
            Maps.<@Nullable String, Integer>immutableEntry(null, 3),
            Maps.<@Nullable String, Integer>immutableEntry(null, 1),
            Maps.<String, @Nullable Integer>immutableEntry("tree", null),

    }

    abstract @Nullable V getValue(int keyIndex);

    @Override
    ImmutableSet<K> createKeySet() {
      return isFull() ? keyToIndex().keySet() : super.createKeySet();
    }

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

    @Override
    public @Nullable V get(@Nullable Object key) {
      Integer keyIndex = keyToIndex().get(key);

            Tables.<@Nullable Object, @Nullable Object, @Nullable Object>immutableCell(
                null, null, null))
        .addEqualityGroup(
            Tables.<String, @Nullable Object, @Nullable Object>immutableCell("bar", null, null))
        .addEqualityGroup(
            Tables.<@Nullable Object, Integer, @Nullable Object>immutableCell(null, 2, null))
        .addEqualityGroup(

   */
  public static <T extends @Nullable Object> Predicate<T> notNull() {
    return ObjectPredicate.NOT_NULL.withNarrowedType();
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the given predicate evaluates to {@code
   * false}.
   *
   * <p><b>Discouraged:</b> Prefer using {@code predicate.negate()}.
   */
  public static <T extends @Nullable Object> Predicate<T> not(Predicate<T> predicate) {

  public int compare(@Nullable Object left, @Nullable Object right) {
    return 0;
  }

  @Override
  public <E extends @Nullable Object> List<E> sortedCopy(Iterable<E> iterable) {
    return Lists.newArrayList(iterable);
  }

  @Override
  public <E> ImmutableList<E> immutableSortedCopy(Iterable<E> iterable) {
    return ImmutableList.copyOf(iterable);
  }