@Override
      public ImmutableMultiset<Object> create(List<?> keys) {
        ImmutableMultiset.Builder<Object> builder = ImmutableMultiset.builder();
        for (Object o : keys) {
          builder.add(o);
        }
        return builder.build();
      }
    },
    BUILDER_ADD_ALL_COLLECTION {
      @Override
      public ImmutableMultiset<Object> create(List<?> keys) {

     * Converts to {@link Short}.
     *
     * @param o
     *            The object to convert
     * @return The converted {@link Short}
     */
    public static Short toShort(final Object o) {
        return toShort(o, null);
    }

    /**
     * Converts to {@link Short}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string

   *
   * This returns null if:
   *
   *  * The stream is exhausted.
   *  * We've read all of the bytes of an object whose length is known.
   *  * We've reached the [DerHeader.TAG_END_OF_CONTENTS] of an object whose length is unknown.
   */
  fun peekHeader(): DerHeader? {
    var result = peekedHeader

    if (result == null) {
      result = readHeader()

  }

  @Override
  public int lastIndexOf(@Nullable Object object) {
    return (object == null) ? -1 : Lists.lastIndexOfImpl(this, object);
  }

  @Override
  public final boolean addAll(int index, Collection<? extends E> newElements) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final E set(int index, E element) {

    return comparator.compare(a, b);
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ComparatorOrdering) {
      ComparatorOrdering<?> that = (ComparatorOrdering<?>) object;
      return this.comparator.equals(that.comparator);
    }
    return false;
  }

  @Override

  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return Iterators.unmodifiableIterator(delegate.iterator());
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && delegate.contains(object);
  }

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

  @Override
  public int size() {

     *       object associated with our thread, because if it was the publication wouldn't have been
     *       unsafe and we'd have seen our thread as the value. This state is also why a new
     *       ThreadConfinedTaskQueue object must be created for each inline execution, because
     *       observing a null thread does not mean the object is safe to reuse.

  }

  public void testStrong_builder() {
    int concurrencyLevel = 42;
    Interner<Object> interner =
        Interners.newBuilder().strong().concurrencyLevel(concurrencyLevel).build();
    InternerImpl<Object> internerImpl = (InternerImpl<Object>) interner;
    assertEquals(Strength.STRONG, internerImpl.map.keyStrength());
  }

  public void testWeak_simplistic() {

      return false;
    }
  }

  /**
   * A sensible default implementation of {@link #subMap(Object, Object)} in terms of {@link
   * #headMap(Object)} and {@link #tailMap(Object)}. In some situations, you may wish to override
   * {@link #subMap(Object, Object)} to forward to this implementation.
   *
   * @since 7.0
   */
  protected SortedMap<K, V> standardSubMap(K fromKey, K toKey) {

 */
@GwtCompatible
abstract class AbstractTable<
        R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object>
    implements Table<R, C, V> {

  @Override
  public boolean containsRow(@Nullable Object rowKey) {
    return Maps.safeContainsKey(rowMap(), rowKey);
  }

  @Override
  public boolean containsColumn(@Nullable Object columnKey) {
    return Maps.safeContainsKey(columnMap(), columnKey);
  }