//  arg 1 ---> R1
	CMP  R8, $0
	BEQ  docall
	SUB  $1, R8
	MOVD 0(R7), R1

	//  arg 2 ---> R2
	CMP  R8, $0
	BEQ  docall
	SUB  $1, R8
	ADD  $8, R7
	MOVD 0(R7), R2

	//  arg 3 --> R3
	CMP  R8, $0
	BEQ  docall
	SUB  $1, R8
	ADD  $8, R7
	MOVD 0(R7), R3

	CMP  R8, $0
	BEQ  docall
	MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument

         * Renames the Closure's original `doCall` method and adds a wrapper method that invokes the original one.
         */
        RENAME_ORIGINAL_DO_CALL("doCall", null, false, (clazz, methodData) -> {
            // A Closure implementation may have an abstract doCall method. It makes no sense to rewrite that.
            boolean isValidDoCallMethod = !methodData.isAbstract() && methodData.name.equals("doCall");

        val firCall = ktCallElement.getOrBuildFir(firResolveSession)?.unwrapSafeCall() as? FirCall ?: return null

        val callee = (firCall.toReference(firResolveSession.useSiteFirSession) as? FirResolvedNamedReference)?.resolvedSymbol
        if (callee?.fir?.origin == FirDeclarationOrigin.SamConstructor) {
            val substitutor = (firCall as? FirQualifiedAccessExpression)

		g.mu.Unlock()
		return ch
	}
	c := &call{chans: []chan<- Result{ch}}
	c.wg.Add(1)
	g.m[key] = c
	g.mu.Unlock()

	go g.doCall(c, key, fn)

	return ch
}

// doCall handles the single call for a key.
func (g *Group) doCall(c *call, key string, fn func() (any, error)) {
	c.val, c.err = fn()

	g.mu.Lock()
	c.wg.Done()
	if g.m[key] == c {
		delete(g.m, key)
	}

 *
 * @see [KotlinClosure1]
 */
fun <T> Any.delegateClosureOf(action: T.() -> Unit) =
    object : Closure<Unit>(this, this) {
        @Suppress("unused") // to be called dynamically by Groovy
        fun doCall() = uncheckedCast<T>(delegate).action()
    }


/**
 * Adapts a parameterless Kotlin function to a parameterless Groovy [Closure].
 *
 * @param V the return type.
 * @param function the function to be adapted.

                        }

                        @Override
                        public abstract void setDelegate(Object delegate);

                        public abstract String doCall(String argument);
                    }
                """

                file("ReverseClosure.java") << """
                    public class ReverseClosure extends MyBaseClosure {

        }

        dynamicObject.invokeMethod("or", new Closure<Void>(this) {
            public Object doCall(Object ignore) {
                for (final DirectoryTree fileTree : existing) {
                    dynamicObject.invokeMethod("and", new Closure<Void>(this) {
                        public Object doCall(Object ignore) {

        }

        ant.withClasspath(combinedClasspath).execute(new Closure<Object>(this, this) {
            @SuppressWarnings("UnusedDeclaration")
            public Object doCall(Object it) {
                final GroovyObjectSupport antBuilder = (GroovyObjectSupport) it;

                antBuilder.invokeMethod("taskdef", ImmutableMap.of(
                    "name", "groovy",

        val c0 =
            object : Closure<Boolean>(null, null) {
                @Suppress("unused")
                fun doCall() = invocations.add("c0")
            }

        val c1 =
            object : Closure<Boolean>(null, null) {
                @Suppress("unused")
                fun doCall(x: Any) = invocations.add("c1($x)")
            }

        val c2 =
            object : Closure<Boolean>(null, null) {

  }

  /**
   * Returns a new {@code TypeResolver} with type variables in {@code formal} mapping to types in
   * {@code actual}.
   *
   * <p>For example, if {@code formal} is a {@code TypeVariable T}, and {@code actual} is {@code
   * String.class}, then {@code new TypeResolver().where(formal, actual)} will {@linkplain
   * #resolveType resolve} {@code ParameterizedType List<T>} to {@code List<String>}, and resolve