NODES=4

args1=()
args2=()
for i in $(seq 1 $NODES); do
	args1+=("http://localhost:$((9000 + i))/tmp/xl/1/$i ")
	args2+=("http://localhost:$((9100 + i))/tmp/xl/2/$i ")
done

for i in $(seq 1 $NODES); do
	./minio server --address "127.0.0.1:$((9000 + i))" ${args1[@]} & # | tee /tmp/minio/node.$i &

     */
    @Nullable
    Dependency getDependency();

    /**
     * Gets the child nodes of this node.
     *
     * @return the child nodes of this node, never {@code null}
     */
    @Nonnull
    List<Node> getChildren();

    /**
     * @return repositories of this node
     */
    @Nonnull
    List<RemoteRepository> getRemoteRepositories();

    /**

  @Override
  @Test
  public void nodes_checkReturnedSetMutability() {
    assume().that(graphIsMutable()).isTrue();

    Set<Integer> nodes = graph.nodes();
    UnsupportedOperationException e =
        assertThrows(UnsupportedOperationException.class, () -> nodes.add(N2));
    addNode(N1);
    assertThat(graph.nodes()).containsExactlyElementsIn(nodes);
  }

  @Override
  @Test

    MutableGraph<N> subgraph =
        (nodes instanceof Collection)
            ? GraphBuilder.from(graph).expectedNodeCount(((Collection) nodes).size()).build()
            : GraphBuilder.from(graph).build();
    for (N node : nodes) {
      subgraph.addNode(node);
    }
    for (N node : subgraph.nodes()) {
      for (N successorNode : graph.successors(node)) {

      AbstractGraphTest.validateGraph(graph);

      Collections.shuffle(nodeList, gen);
      for (Integer node : nodeList) {
        assertThat(graph.addNode(node)).isTrue();
      }
      Collections.shuffle(edgeList, gen);
      for (EndpointPair<Integer> edge : edgeList) {
        assertThat(graph.putEdge(edge.nodeU(), edge.nodeV())).isTrue();
      }

      assertThat(graph.nodes()).hasSize(NUM_NODES);

  int outDegree(N node);

  /**
   * Returns true if there is an edge that directly connects {@code nodeU} to {@code nodeV}. This is
   * equivalent to {@code nodes().contains(nodeU) && successors(nodeU).contains(nodeV)}.
   *
   * <p>In an undirected graph, this is equal to {@code hasEdgeConnecting(nodeV, nodeU)}.
   *
   * @since 23.0
   */
  @Override
  boolean hasEdgeConnecting(N nodeU, N nodeV);

  /**

     */
    private final List<Exception> exceptions;

    /**
     * The root node of the dependency graph.
     */
    private final Node root;

    /**
     * The ordered list of the flattened dependency nodes.
     */
    private final List<Node> nodes;

    /**
     * The file paths of all dependencies, regardless on which Java tool option those paths should be placed.
     */

      // Fill graph_def with nodes with ids in the range
      // [session->last_num_graph_nodes, num_nodes), that is the nodes
      // added since the last TF_SessionRun() call.
      for (auto id = session->last_num_graph_nodes; id < num_nodes; ++id) {
        Node* const node = graph.FindNodeId(id);
        if (node != nullptr && node->IsOp()) {
          NodeDef* const node_def = graph_def.add_node();

        writeElastisearchJsonApi(zos, id, "nodes", "stats");
        writeElastisearchJsonApi(zos, id, "nodes", "_all");
        writeElastisearchJsonApi(zos, id, "nodes", "usage");
        writeElastisearchJsonApi(zos, id, "remote", "info");
        writeElastisearchJsonApi(zos, id, "tasks", "");
        writeElastisearchJsonApi(zos, id, "nodes", "hot_threads");
    }

    }
  }

  @Override
  @Test
  public void nodes_checkReturnedSetMutability() {
    assume().that(graphIsMutable()).isTrue();

    Set<Integer> nodes = network.nodes();
    UnsupportedOperationException e =
        assertThrows(UnsupportedOperationException.class, () -> nodes.add(N2));
    addNode(N1);
    assertThat(network.nodes()).containsExactlyElementsIn(nodes);
  }

  @Override
  @Test