}

#footnotes hr {
	width: 20%;
	min-width: 6.25em;
	margin: -0.25em 0 0.75em 0;
	border-width: 1px 0 0 0;
}

#footnotes .footnote {
	padding: 0 0.375em 0 0.225em;
	line-height: 1.3334;
	font-size: 0.875em;
	margin-left: 1.2em;
	text-indent: -1.05em;
	margin-bottom: 0.2em;
}

#footnotes .footnote a:first-of-type {
	font-weight: bold;

Since build scripts are Kotlin or Groovy scripts, you can execute an Ant build as an external process.
Your build script may contain statements like: `"ant clean compile".execute()`.footnote:[In Groovy you can execute Strings.]

Gradle's Ant integration allows you to migrate your build from Ant to Gradle smoothly:

1. Begin by importing your existing Ant build.

.example-break, .figure-break {
    display: none;
}

.exampleLocation .emphasis em {
    font-style: normal;
    font-weight: bold;
}

.appendix h1 {
    margin-bottom: 1.0em;
}

.footnote sup {
    vertical-align: baseline;
    font-size: 100%;
}

.note p:first-child, .tip p:first-child {
    margin-top: 0;
}

|`@OutputDirectories`
|Property is one or more output directories for the task

|`@Destroys`
|Property is one or more files or directories (coming from other tasks) that the task destroys (deletes/removes)footnote:2[This notation is used to specify locations/files that a task will always delete, and these locations/files typically belong to other tasks. This annotation is useful for tasks that clean up after other tasks such as `clean`.]

.module-label-in-package, .module-label-in-type, .package-label-in-type,
.package-hierarchy-label, .type-name-label, .type-name-link, .search-tag-link, .preview-label {
    font-weight:bold;
}
.deprecation-comment, .help-footnote, .preview-comment {
    font-style:italic;
}
.deprecation-block {
    font-size:1em;
    font-family:var(--block-font-family);
    border-style:solid;
    border-width:thin;
    border-radius:10px;

import org.gradle.internal.component.model.VariantGraphResolveState;

import java.util.List;
import java.util.Set;

class RootNode extends NodeState implements RootGraphNode {
    private final ResolveOptimizations resolveOptimizations;
    private final List<? extends DependencyMetadata> syntheticDependencies;

        private final Node rootNode;

        PrefixFileSet(File rootDir) {
            this(toAbsolutePath(rootDir));
        }

        PrefixFileSet(String rootPath) {
            String path = removeTrailingSeparator(rootPath);
            this.rootNode = new Node(path);
        }

        PrefixFileSet(Node rootNode) {
            this.rootNode = rootNode;
        }

        false
    )

    def "result can be read multiple times"() {
        def rootNode = rootNode(1, "org", "root", "1.0")
        builder.start(rootNode)
        builder.visitNode(rootNode)
        builder.finish(rootNode)

        when:
        def result = builder.getResolutionResult([] as Set)

        then:
        with(result.rootSource.get()) {

    private final Map<ModuleIdentifier, ModuleResolveState> modules;
    private final Map<NodeIdentifier, NodeState> nodes;
    private final Map<SelectorCacheKey, SelectorState> selectors;
    private final RootNode root;
    private final ComponentIdGenerator idGenerator;
    private final DependencyToComponentIdResolver idResolver;
    private final ComponentMetaDataResolver metaDataResolver;
    private final Deque<NodeState> queue;

	for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
		if mp.procid != 0 && mp.procid != pid {
			postnote(mp.procid, buf[:])
		}
	}
	getg().m.locks--
}

var procdir = []byte("/proc/")
var notefile = []byte("/note\x00")

func postnote(pid uint64, msg []byte) int {
	var buf [128]byte
	var tmp [32]byte
	n := copy(buf[:], procdir)
	n += copy(buf[n:], itoa(tmp[:], pid))