* Collections#emptyMap}, and is preferable mainly for consistency and maintainability of your
   * code.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   */
  @SuppressWarnings("unchecked")
  public static <K, V> ImmutableMap<K, V> of() {
    return (ImmutableMap<K, V>) RegularImmutableMap.EMPTY;
  }

  /**

                                mergeResponseData(dataMap, responseDataMap);
                            } catch (final Exception e) {
                                throw new CrawlerSystemException("Could not create an instance from bytes.", e);
                            }
                        }
                    }
                    crawlerStatsHelper.record(keyObj, StatsAction.ACCESSED);

                    // remove

   *
   * @since 2.0
   */
  interface Entry<E extends @Nullable Object> {

    /**
     * Returns the multiset element corresponding to this entry. Multiple calls to this method
     * always return the same instance.
     *
     * @return the element corresponding to this entry
     */
    @ParametricNullness
    E getElement();

    /**

        }
    }

    static String DEFAULT_DOMAIN;
    static String DEFAULT_USERNAME;
    static String DEFAULT_PASSWORD;
    static final String BLANK = "";

    /**
     * Anonymous credentials instance with empty domain, username, and password.
     */
    public static final NtlmPasswordAuthentication ANONYMOUS = new NtlmPasswordAuthentication("", "", "");

    static void initDefaults() {

        if (this.localhostAddress != null) {
            return this.localhostAddress.hostName;
        }
        return null;
    }

    /**
     * Gets the lmhosts resolver instance used by this client.
     *
     * @return lmhosts file used
     */
    public Lmhosts getLmhosts() {
        return this.lmhosts;
    }

    /**
     * {@inheritDoc}
     *

   * for {@code minimumBits}, will return identically-behaving {@link HashFunction} instances.
   *
   * @param minimumBits a positive integer. This can be arbitrarily large. The returned {@link
   *     HashFunction} instance may use memory proportional to this integer.
   * @return a hash function, described above, that produces hash codes of length {@code
   *     minimumBits} or greater
   */

    peer.play()
    val longString = repeat('a', Http2.INITIAL_MAX_FRAME_SIZE + 1)
    val socket = peer.openSocket()
    val connection =
      Http2Connection
        .Builder(true, TaskRunner.INSTANCE)
        .socket(socket.asBufferedSocket(), "peer")
        .pushObserver(IGNORE)
        .build()
    connection.start(sendConnectionPreface = false)
    socket.shutdownOutput()
    assertFailsWith<IOException> {

  private static final class NodeAndRemainingSuccessors<N> {
    final N node;

    /**
     * The successors left to be visited, or {@code null} if we just added this {@code
     * NodeAndRemainingSuccessors} instance to the stack. In the latter case, we'll compute the
     * successors if we determine that we need them after we've performed the initial processing of
     * the node.
     */
    @Nullable Queue<N> remainingSuccessors;

    return CollectCollectors.toImmutableRangeSet();
  }

  /**
   * Returns an empty immutable range set.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   */
  @SuppressWarnings("unchecked")
  public static <C extends Comparable> ImmutableRangeSet<C> of() {
    return (ImmutableRangeSet<C>) EMPTY;
  }

  /**

  /**
   * Returns the index to which the given key is mapped, so that getAt(indexFor(key)) == get(key).
   */
  abstract int indexFor(Object key);

  /** Returns the total number of stripes in this instance. */
  public abstract int size();

  /**
   * Returns the stripes that correspond to the passed objects, in ascending (as per {@link