## Conect-se com o autor

Você pode se conectar <a href="https://tiangolo.com" class="external-link" target="_blank">comigo (Sebastián Ramírez / `tiangolo`)</a>, o autor.

Você pode:

* <a href="https://github.com/tiangolo" class="external-link" target="_blank">Me siga no **GitHub**</a>.
    * Ver também outros projetos Open Source criados por mim que podem te ajudar.

= vendor/github.com/antlr/antlr4/runtime/Go/antlr/v4 licensed under: =

Copyright 2021 The ANTLR Project

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

    1. Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer.

        sink.writeUtf8("-------\n");
        for (int i = 2; i <= 997; i++) {
          sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i)));
        }
      }

      private String factor(int n) {
        for (int i = 2; i < n; i++) {
          int x = n / i;
          if (x * i == n) return factor(x) + " × " + i;
        }
        return Integer.toString(n);
      }
    };

    Request request = new Request.Builder()

  private static final double DESIRED_LOAD_FACTOR = 0.5;

  /**
   * Returns an array size suitable for the backing array of a hash table that uses open addressing
   * with linear probing in its implementation. The returned size is the smallest power of two that
   * can hold setSize elements with the desired load factor.
   */
  @VisibleForTesting
  static int chooseTableSize(int setSize) {

            sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i)));
          }
          sink.close();
        } catch (IOException | InterruptedException e) {
          e.printStackTrace();
        }
      }

      private String factor(int n) {
        for (int i = 2; i < n; i++) {
          int x = n / i;
          if (x * i == n) return factor(x) + " × " + i;
        }
        return Integer.toString(n);

          sink.writeUtf8("-------\n")
          for (i in 2..997) {
            sink.writeUtf8(String.format(" * $i = ${factor(i)}\n"))
          }
        }

        private fun factor(n: Int): String {
          for (i in 2 until n) {
            val x = n / i
            if (x * i == n) return "${factor(x)} × $i"
          }
          return n.toString()
        }
      }

    val request =
      Request(

  static final int DEFAULT_EDGE_COUNT = DEFAULT_NODE_COUNT * EXPECTED_DEGREE;

  // Load factor and capacity for "inner" (i.e. per node/edge element) hash sets or maps
  static final float INNER_LOAD_FACTOR = 1.0f;
  static final int INNER_CAPACITY = 2; // ceiling(EXPECTED_DEGREE / INNER_LOAD_FACTOR)

  // Error messages
  static final String NODE_NOT_IN_GRAPH = "Node %s is not an element of this graph.";

  }

  static <N, E> DirectedMultiNetworkConnections<N, E> of() {
    return new DirectedMultiNetworkConnections<>(
        new HashMap<E, N>(INNER_CAPACITY, INNER_LOAD_FACTOR),
        new HashMap<E, N>(INNER_CAPACITY, INNER_LOAD_FACTOR),
        0);
  }

  static <N, E> DirectedMultiNetworkConnections<N, E> ofImmutable(
      Map<E, N> inEdges, Map<E, N> outEdges, int selfLoopCount) {

  private static final double DESIRED_LOAD_FACTOR = 0.5;

  /**
   * Returns an array size suitable for the backing array of a hash table that uses open addressing
   * with linear probing in its implementation. The returned size is the smallest power of two that
   * can hold setSize elements with the desired load factor.
   */
  @VisibleForTesting
  static int chooseTableSize(int setSize) {

            LinkedList(subProjectTestClassTimes),
            SubprojectTestClassTime::totalTime,
            { largeElement, factor ->
                List(factor) { SmallSubprojectBucket(largeElement.subProject, parallelization(factor)) }
            },
            { list ->
                SmallSubprojectBucket(list.map { it.subProject }, parallelization(1))
            },