return backingMap.size();
      }

      @Override
      public boolean contains(@CheckForNull Object key) {
        return containsKey(key);
      }
    };
  }

  // Internal methods (package-visible, but treat as only subclass-visible)

  @CheckForNull
  V getIfCached(@CheckForNull Object key) {
    Entry<K, V> entry = cacheEntry; // store local reference for thread-safety

    }

    @Override
    @CheckForNull
    public E lower(@ParametricNullness E e) {
      return getElementOrNull(multiset().headMultiset(e, OPEN).lastEntry());
    }

    @Override
    @CheckForNull
    public E floor(@ParametricNullness E e) {
      return getElementOrNull(multiset().headMultiset(e, CLOSED).lastEntry());
    }

    @Override
    @CheckForNull

    delegate().clear();
  }

  @Override
  public boolean containsEntry(@CheckForNull Object key, @CheckForNull Object value) {
    return delegate().containsEntry(key, value);
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    return delegate().containsKey(key);
  }

  @Override
  public boolean containsValue(@CheckForNull Object value) {
    return delegate().containsValue(value);
  }

    delegate().clear();
  }

  @Override
  public boolean containsEntry(@CheckForNull Object key, @CheckForNull Object value) {
    return delegate().containsEntry(key, value);
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    return delegate().containsKey(key);
  }

  @Override
  public boolean containsValue(@CheckForNull Object value) {
    return delegate().containsValue(value);
  }

    }

    @Override
    public boolean containsValue(@CheckForNull Object value) {
      return original.containsValue(value);
    }

    @Override
    @CheckForNull
    public V get(@CheckForNull Object rowKey, @CheckForNull Object columnKey) {
      return original.get(columnKey, rowKey);
    }

    @Override
    @CheckForNull
    public V put(
        @ParametricNullness C rowKey,

  @CanIgnoreReturnValue
  @Override
  @CheckForNull
  public V putIfAbsent(K key, V value) {
    return delegate().putIfAbsent(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@CheckForNull Object key, @CheckForNull Object value) {
    return delegate().remove(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  @CheckForNull
  public V replace(K key, V value) {

    this.delegate = delegate;
  }

  @Override
  @CheckForNull
  public <T extends B> T getInstance(TypeToken<T> type) {
    return trustedGet(type.rejectTypeVariables());
  }

  @Override
  @CheckForNull
  public <T extends B> T getInstance(Class<T> type) {
    return trustedGet(TypeToken.of(type));
  }

  /**

      };
    }

    // TODO(lowasser): consider an optimized values() implementation

    @Override
    public boolean containsKey(@CheckForNull Object key) {
      return keyIndex.containsKey(key);
    }

    @CheckForNull
    @Override
    public V get(@CheckForNull Object key) {
      Integer index = keyIndex.get(key);
      if (index == null) {
        return null;
      } else {

      throw new NoSuchElementException();
    }
    return elements.get(size() - 1);
  }

  @Override
  @CheckForNull
  public E lower(E element) {
    int index = headIndex(element, false) - 1;
    return (index == -1) ? null : elements.get(index);
  }

  @Override
  @CheckForNull
  public E floor(E element) {
    int index = headIndex(element, true) - 1;

    return forwardMultiset();
  }

  @Override
  @CheckForNull
  public Entry<E> firstEntry() {
    return forwardMultiset().lastEntry();
  }

  @Override
  @CheckForNull
  public Entry<E> lastEntry() {
    return forwardMultiset().firstEntry();
  }

  abstract Iterator<Entry<E>> entryIterator();

  @LazyInit @CheckForNull private transient Set<Entry<E>> entrySet;

  @Override