*/
  @SuppressWarnings("unchecked") // TODO(cpovirk): Make constructor accept wildcard types?
  public static <R, C, V> ArrayTable<R, C, V> create(Table<R, C, ? extends @Nullable V> table) {
    return (table instanceof ArrayTable)
        ? new ArrayTable<R, C, V>((ArrayTable<R, C, V>) table)
        : new ArrayTable<R, C, V>(table);
  }

  private final ImmutableList<R> rowList;
  private final ImmutableList<C> columnList;

   *     key
   * @throws NullPointerException if any key or value in {@code map} is null
   */
  public static <K, V> ImmutableBiMap<K, V> copyOf(Map<? extends K, ? extends V> map) {
    if (map instanceof ImmutableBiMap) {
      @SuppressWarnings("unchecked") // safe since map is not writable
      ImmutableBiMap<K, V> bimap = (ImmutableBiMap<K, V>) map;
      // TODO(lowasser): if we need to make a copy of a BiMap because the

        return put(key, Collections.singletonList(comment), value);
    }

    public boolean update(Map<String, String> props) {
        MavenProperties properties;
        if (props instanceof MavenProperties mavenProperties) {
            properties = mavenProperties;
        } else {
            properties = new MavenProperties();
            properties.putAll(props);
        }

        return put(key, Collections.singletonList(comment), value);
    }

    public boolean update(Map<String, String> props) {
        MavenProperties properties;
        if (props instanceof MavenProperties mavenProperties) {
            properties = mavenProperties;
        } else {
            properties = new MavenProperties();
            properties.putAll(props);
        }

    for (int i = 1; i < size; i++) {
      if (!heapForIndex(i).verifyIndex(i)) {
        return false;
      }
    }
    return true;
  }

  /**
   * Each instance of MinMaxPriorityQueue encapsulates two instances of Heap: a min-heap and a
   * max-heap. Conceptually, these might each have their own array for storage, but for efficiency's

     */
    @Override
    public boolean equals(final Object obj) {
        if (obj instanceof final NtlmPasswordAuthentication ntlm) {
            if (ntlm.domain.toUpperCase().equals(domain.toUpperCase()) && ntlm.username.toUpperCase().equals(username.toUpperCase())) {

   */
  public static <E> ImmutableSortedMultiset<E> copyOf(
      Comparator<? super E> comparator, Iterable<? extends E> elements) {
    if (elements instanceof ImmutableSortedMultiset) {
      @SuppressWarnings("unchecked") // immutable collections are always safe for covariant casts
      ImmutableSortedMultiset<E> multiset = (ImmutableSortedMultiset<E>) elements;

   *       is used to construct the sample instances. In case of tie, the candidate constructors or
   *       factories are tried one after another until one can be used to construct sample
   *       instances.
   *   <li>For the constructor or static factory method used to construct instances, it's checked
   *       that when equal parameters are passed, the result instance should also be equal; and vice
   *       versa.

            final HttpSession session = request.getSession(false);
            if (session != null && session.getAttribute(LastaWebKey.USER_LOCALE_KEY) instanceof final Locale sessionLocale) {
                return sessionLocale;
            }
            if (request.getAttribute(LastaWebKey.USER_LOCALE_KEY) instanceof final Locale requestLocale) {
                return requestLocale;
            }
            return request.getLocale();

  }

  /**
   * Returns a new {@link ByteArrayDataInput} instance to read from the {@code bytes} array from the
   * beginning.
   */
  @J2ktIncompatible
  public static ByteArrayDataInput newDataInput(byte[] bytes) {
    return newDataInput(new ByteArrayInputStream(bytes));
  }

  /**
   * Returns a new {@link ByteArrayDataInput} instance to read from the {@code bytes} array,
   * starting at the given position.