// used under GWT, etc., since the override of this method does not exist there
    ImmutableMap<Class<? extends Throwable>, Predicate<Throwable>> exceptions() {
      return ImmutableMap.of();
    }
  }

  private static final ImmutableMap<Class<? extends Throwable>, Predicate<Throwable>> INSTANCE_OF =
      ImmutableMap.<Class<? extends Throwable>, Predicate<Throwable>>builder()

   * ElementOrder#stable()}, regardless of the value that was set in this builder.
   *
   * @since 28.0
   */
  public <N1 extends N, V1 extends V> ImmutableValueGraph.Builder<N1, V1> immutable() {
    ValueGraphBuilder<N1, V1> castBuilder = cast();
    return new ImmutableValueGraph.Builder<>(castBuilder);
  }

  /**

     * @since 19.0
     */
    @CanIgnoreReturnValue
    public Builder<K, V> putAll(Iterable<? extends Entry<? extends K, ? extends V>> entries) {
      if (entries instanceof Collection) {
        ensureCapacity(size + ((Collection<?>) entries).size());
      }
      for (Entry<? extends K, ? extends V> entry : entries) {
        put(entry);
      }
      return this;
    }

    /**

 *     constructed based on an existing {@code Graph} using {@link #from(Graph)}.
 * @since 20.0
 */
@DoNotMock
public final class GraphBuilder<N> extends AbstractGraphBuilder<N> {

  /** Creates a new instance with the specified edge directionality. */
  private GraphBuilder(boolean directed) {
    super(directed);
  }

    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

  static <C extends Comparable> Cut<C> belowValue(C endpoint) {
    return new BelowValue<>(endpoint);
  }

  private static final class BelowValue<C extends Comparable> extends Cut<C> {
    BelowValue(C endpoint) {
      super(checkNotNull(endpoint));
    }

    @Override

 * @param <V> the type of the mapped values
 * @since 7.0
 */
@DoNotMock("Use ImmutableTable, HashBasedTable, or another implementation")
@GwtCompatible
public interface Table<
    R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object> {
  // TODO(jlevy): Consider adding methods similar to ConcurrentMap methods.

  // Accessors

  /**

import java.util.Iterator;

@GwtCompatible
@J2ktIncompatible
public final class EnumMultiset<E extends Enum<E>> extends AbstractMapBasedMultiset<E>
    implements Serializable {
  public static <E extends Enum<E>> EnumMultiset<E> create(Class<E> type) {
    return new EnumMultiset<>(new EnumMap<E, Count>(type));
  }

  public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements) {
    Iterator<E> iterator = elements.iterator();

    public String toString() {
      return "another arbitrary string";
    }
  }

  private static class SubHandler1 extends DelegatingInvocationHandlerWithEquals {
    SubHandler1(Object delegate) {
      super(delegate);
    }
  }

  private static class SubHandler2 extends DelegatingInvocationHandlerWithEquals {
    SubHandler2(Object delegate) {
      super(delegate);
    }
  }

 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@GwtCompatible
@FunctionalInterface
public interface Function<F extends @Nullable Object, T extends @Nullable Object>
    extends java.util.function.Function<F, T> {
  @Override
  @ParametricNullness
  T apply(@ParametricNullness F input);

  /**

 * @author Mike Bostock
 * @since 2.0
 */
@GwtCompatible
public final class HashBiMap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMap<K, V> implements BiMap<K, V>, Serializable {

  /** Returns a new, empty {@code HashBiMap} with the default initial capacity (16). */
  public static <K extends @Nullable Object, V extends @Nullable Object> HashBiMap<K, V> create() {
    return create(16);
  }

  /**