org:leaf2:1.0
+--- org:middle:1.0
|    \\--- org:top:1.0
|         \\--- conf
\\--- org:top:1.0 (*)

(*) - Indicates repeated occurrences of a transitive dependency subtree. Gradle expands transitive dependency subtrees only once per project; repeat occurrences only display the root of the subtree, followed by this annotation.

          <name>exclusions</name>
          <version>4.0.0+</version>
          <description>Lists a set of artifacts that should be excluded from this dependency's
            artifact list when it comes to calculating transitive dependencies.</description>
          <association>
            <type>Exclusion</type>
            <multiplicity>*</multiplicity>
          </association>
        </field>
        <field>

//		When the special name "auto" is specified, for each main package in the
//		build, the go command selects a file named "default.pgo" in the package's
//		directory if that file exists, and applies it to the (transitive)
//		dependencies of the main package (other packages are not affected).
//		Special name "off" turns off PGO. The default is "auto".
//	-pkgdir dir
//		install and load all packages from dir instead of the usual locations.

  let summary = "Prunes unreachable ops in a tf_executor.graph";

  let description = [{
    This pass removes ops from a `tf_executor.graph` that are not transitively, via
    data or control dependencies, connected to the associated `tf_executor.fetch`
    op. The order of ops will be preserved. Functions named `main` with no

  //
  // Note that the operands and body results need not be compatible as they are
  // never converted from one to the another nor there is a common source
  // tensors. Compatibility requirement is not transitive.

  if (!shape_invariant &&
      failed(VerifyTypeRangesAreCompatible(op, input_type, result_type)))
    return failure();

  // Skip the first pair as the While op operands and body function results does

	cfile := objdir + "_cgo_main.c"
	ofile := objdir + "_cgo_main.o"
	if err := b.gcc(a, objdir, ofile, cflags, cfile); err != nil {
		return "", "", err
	}

	// Gather .syso files from this package and all (transitive) dependencies.
	var syso []string
	seen := make(map[*Action]bool)
	var gatherSyso func(*Action)
	gatherSyso = func(a1 *Action) {
		if seen[a1] {
			return
		}
		seen[a1] = true

  // control dependencies to data outputs and not removing single output nodes.
  // When a data output is replaced as a feed, unless there is another non feed
  // data output or an explicit control output used by the same node, transitive
  // control dependencies are not to be executed. For single output nodes,
  // Placeholders can be converted to a NoOp if there are no uses, and
  // PlaceholderWithDefault can be converted to an Identity.

in the second file, and so on.
</p>

<p>
Dependency analysis does not rely on the actual values of the
variables, only on lexical <i>references</i> to them in the source,
analyzed transitively. For instance, if a variable <code>x</code>'s
initialization expression refers to a function whose body refers to
variable <code>y</code> then <code>x</code> depends on <code>y</code>.
Specifically:
</p>

			// nothing to do except drop freem from the sched.freem
			// list.
			if wait == freeMStack {
				// stackfree must be on the system stack, but allocm is
				// reachable off the system stack transitively from
				// startm.
				systemstack(func() {
					stackfree(freem.g0.stack)
				})
			}
			freem = freem.freelink
		}
		sched.freem = newList
		unlock(&sched.lock)
	}