queue[index] = parentElement;
        queue[parentIndex] = x;
        return parentIndex;
      }
      queue[index] = x;
      return index;
    }

    // About the term "aunt node": it's better to leave gender out of it, but for this the English
    // language has nothing for us. Except for the whimsical neologism "pibling" (!) which we
    // obviously could not expect to increase anyone's understanding of the code.

   * equivalently, if this inverse view contains a key that is equal to {@code value}).
   *
   * <p>Due to the property that values in a BiMap are unique, this will tend to execute in
   * faster-than-linear time.
   *
   * @param value the object to search for in the values of this BiMap
   * @return true if a mapping exists from a key to the specified value
   */
  @Override

### Concorrência é melhor que paralelismo? { #is-concurrency-better-than-parallelism }

Não! Essa não é a moral da história.

  }

  /**
   * Returns a new builder with a hint for how many distinct keys are expected to be added. The
   * generated builder is equivalent to that returned by {@link #builder}, but may perform better if
   * {@code expectedKeys} is a good estimate.
   *
   * @throws IllegalArgumentException if {@code expectedKeys} is negative
   * @since 33.3.0
   */

   *
   * <p>If {@code expectedSize} is exactly the number of entries added to the builder before {@link
   * Builder#build} is called, the builder is likely to perform better than an unsized {@link
   * #builder()} would have.
   *
   * <p>It is not specified if any performance benefits apply if {@code expectedSize} is close to,
   * but not exactly, the number of entries added to the builder.

 * iterators that don't support {@code remove()}. Otherwise, all optional operations are supported.
 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in
 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs

   *
   * <p>If {@code expectedSize} is exactly the number of distinct elements added to the builder
   * before {@link Builder#build} is called, the builder is likely to perform better than an unsized
   * {@link #builder()} would have.
   *
   * <p>It is not specified if any performance benefits apply if {@code expectedSize} is close to,

        queue[index] = parentElement;
        queue[parentIndex] = x;
        return parentIndex;
      }
      queue[index] = x;
      return index;
    }

    // About the term "aunt node": it's better to leave gender out of it, but for this the English
    // language has nothing for us. Except for the whimsical neologism "pibling" (!) which we
    // obviously could not expect to increase anyone's understanding of the code.

   * structure (to make it possible to throw ConcurrentModificationException in the iterator). Note
   * that we choose not to make this volatile, so we do less of a "best effort" to track such
   * errors, for better performance.
   *
   * <p>For a new instance, where the arrays above have not yet been allocated, the value of {@code
   * metadata} is the size that the arrays should be allocated with. Once the arrays have been

    return Traverser.forTree(FILE_TREE);
  }

  private static final SuccessorsFunction<File> FILE_TREE =
      file -> {
        // check isDirectory() just because it may be faster than listFiles() on a non-directory
        if (file.isDirectory()) {
          File[] files = file.listFiles();
          if (files != null) {
            return unmodifiableList(Arrays.asList(files));
          }