int j = i & ARRAY_MASK;
      tmp += DoubleMath.roundToInt(doubleInIntRange[j], mode);
    }
    return tmp;
  }

  @Benchmark
  long roundToLong(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += DoubleMath.roundToLong(doubleInLongRange[j], mode);
    }
    return tmp;
  }

  @Benchmark
  int roundToBigInteger(int reps) {

 * graphs. Instances of this class should be constructed with {@link GraphBuilder}.
 *
 * <p>Time complexities for mutation methods are all O(1) except for {@code removeNode(N node)},
 * which is in O(d_node) where d_node is the degree of {@code node}.
 *
 * @author James Sexton
 * @param <N> Node parameter type
 */
final class StandardMutableGraph<N> extends ForwardingGraph<N> implements MutableGraph<N> {

     *
     * @return the exceptions that occurred, never {@code null}
     */
    @Nonnull
    List<Exception> getExceptions();

    /**
     * Gets the root node of the dependency graph.
     *
     * @return the root node of the dependency graph or {@code null} if none
     */
    @Nullable
    Node getRoot();

    /**
     * The ordered list of the flattened dependency nodes.
     *

  /** Returns d's value as an X, rounded with the specified mode. */
  abstract X toX(double d, RoundingMode mode);

  /** Returns a - b, guaranteed that both arguments are nonnegative. */
  abstract X minus(X a, X b);

  /** Rounds {@code x} to a {@code double}. */
  final double roundToDouble(X x, RoundingMode mode) {
    checkNotNull(x, "x");
    checkNotNull(mode, "mode");
    double roundArbitrarily = roundToDoubleArbitrarily(x);

     * the local SMB network. If this <code>SmbResource</code> refers to the root
     * <code>smb://</code> resource <code>true</code> is always returned. If
     * this <code>SmbResource</code> is a traditional file or directory, it will
     * be queried for on the specified server as expected.
     *
     * @return <code>true</code> if the resource exists or is alive or
     *         <code>false</code> otherwise

 * implement it:
 *
 * {@snippet :
 * // won't work
 * TreeTraverser<NodeType> traverser = node -> node.getChildNodes();
 * }
 *
 * Instead, you can pass a lambda expression to the {@code using} factory method:
 *
 * {@snippet :
 * TreeTraverser<NodeType> traverser = TreeTraverser.using(node -> node.getChildNodes());
 * }
 *
 * @author Louis Wasserman
 * @since 15.0

# MinIO Erasure Code Quickstart Guide [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)

MinIO protects data against hardware failures and silent data corruption using erasure code and checksums. With the highest level of redundancy, you may lose up to half (N/2) of the total drives and still be able to recover the data.

## What is Erasure Code?

   * <p>The valid values are:
   *
   * <ul>
   *   <li>{@code null} initial state, nothing has happened.
   *   <li>{@link Cancellation} terminal state, {@code cancel} was called.
   *   <li>{@link Failure} terminal state, {@code setException} was called.
   *   <li>{@link DelegatingToFuture} intermediate state, {@code setFuture} was called.
   *   <li>{@link #NULL} terminal state, {@code set(null)} was called.

     * Lookup <code>hostname</code> and return it's <code>UniAddress</code>. If the
     * <code>possibleNTDomainOrWorkgroup</code> parameter is <code>true</code> an
     * additional name query will be performed to locate a master browser.
     *
     * @param hostname the hostname to resolve
     * @param possibleNTDomainOrWorkgroup if true, perform additional master browser lookup
     *
     * @return the first resolved address

  /** Returns a PublicSuffixType of the right type according to the given code */
  static PublicSuffixType fromCode(char code) {
    for (PublicSuffixType value : values()) {
      if (value.getInnerNodeCode() == code || value.getLeafNodeCode() == code) {
        return value;
      }
    }
    throw new IllegalArgumentException("No enum corresponding to given code: " + code);
  }