Component(providerAccessors, "Accessors", "Collects Project Schema, generates Accessors source and bytecode")
            Component(providerImports, "Implicit Imports", "Includes Gradle's default imports")


            Rel_Neighbor(providerFactory, providerExecution, "Delegates to")
            Rel(providerExecution, providerScriptTemplates, "Uses", "script API for compilation")

        }
    }

    /**
     * Returns the set of implicit selector names expected for any project for the target Gradle version.
     *
     * <p>Note that in some versions the handling of implicit selectors was broken, so this method may return a different value
     * to {@link #getImplicitTasks()}.
     */
    Set<String> getImplicitSelectors() {

    public AbstractHeaderExportingSourceSet() {
        this.exportedHeaders = objectFactory.sourceDirectorySet("exported", "exported headers");
        this.implicitHeaders = objectFactory.sourceDirectorySet("implicit", "implicit headers");
    }

    @Override
    public SourceDirectorySet getExportedHeaders() {
        return exportedHeaders;
    }

    @Override
    public SourceDirectorySet getImplicitHeaders() {

#
# (The fix in golang.org/issue/29004 didn't completely fix the underlying issue:
# cmd/go/internal/load adds a bunch of implicit dependencies
# based on various heuristics, and, due to a bug described in
# https://golang.org/issue/31544#issuecomment-490607180,
# those implicit dependencies are not added early enough during
# loading to properly affect the import graph.)
go build runtime/cgo

go build -x -o main main.go

	B	_f32loop

_4tail:
	SUB	$3, TOE, TMP	/* do remaining words if possible */
_4loop:
	CMP	TMP, TO
	BHS	_1tail

	MOVW.P	R0, 4(TO)		/* implicit write back */
	B	_4loop

_1tail:
	CMP	TO, TOE
	BEQ	_return

	MOVBU.P	R0, 1(TO)		/* implicit write back */
	B	_1tail

_return:

     * - Resolved subject and input paths relative to the target element.
     * - Resolves subject type references relative to the target element.
     * - Adds implicit inputs.
     *
     * The returned action invokes the provided action with a {@link ModelRuleInvoker} contextualized with implicit inputs.
     */
    ModelAction contextualize(MethodRuleAction action);

    ModelPath getScope();

 * where the single parameter is passed as the implicit receiver of the
 * invocation ({@code this} in Kotlin, {@code delegate} in Groovy) as if
 * the lambda expression was an extension method of the parameter type.
 *
 * <pre>
 *     // copySpec(Action&lt;CopySpec&gt;)
 *     copySpec {
 *         from("./sources") // the given CopySpec is the implicit receiver
 *     }
 * </pre>
 *
 * @since 3.5
 */

	isCompound         bool
}

// ASN.1 has IMPLICIT and EXPLICIT tags, which can be translated as "instead
// of" and "in addition to". When not specified, every primitive type has a
// default tag in the UNIVERSAL class.
//
// For example: a BIT STRING is tagged [UNIVERSAL 3] by default (although ASN.1
// doesn't actually have a UNIVERSAL keyword). However, by saying [IMPLICIT

		check.needsCleanup(typ)
	}
	return typ
}

// MarkImplicit marks the interface t as implicit, meaning this interface
// corresponds to a constraint literal such as ~T or A|B without explicit
// interface embedding. MarkImplicit should be called before any concurrent use
// of implicit interfaces.
func (t *Interface) MarkImplicit() {
	t.implicit = true
}

// sequence of selection operations x.a.b.c.f. The SelectionKind
// describes the kind of the final (explicit) operation; all the
// previous (implicit) operations are always field selections.
// Each element of Indices specifies an implicit field (a, b, c)
// by its index in the struct type of the field selection operand.
//
// For a FieldVal operation, the final selection refers to the field