override suspend fun WriteContext.encode(value: TransformChain) {
        write(value.init)
        write(value.last)
    }

    override suspend fun ReadContext.decode(): TransformChain {
        val init = read() as TransformChain?
        val last = readNonNull<TransformStep>()
        return TransformChain(init, last)
    }

        if (logger.isInfoEnabled()) {
            init();
            logger.info("Scanning for projects...");
        }
    }

    @Override
    public void sessionStarted(ExecutionEvent event) {
        if (logger.isInfoEnabled() && event.getSession().getProjects().size() > 1) {
            init();
            infoLine('-');

            infoMain("Reactor Build Order:");

public final class CodeFragment {
    // source: 'fragment.kt'
    public method <init>(): void
    public final static method run(p0: Foo): void
}

public final class ContextKt

public final class Foo {
    // source: 'context.kt'
    public method <init>(): void
    private final static method test$call(p0: Foo): void
    public final method test(): void

                }
            }

            @Override
            public BuildOperationDescriptor.Builder description() {
                return BuildOperationDescriptor.displayName("Run init scripts").progressDisplayName("Running init scripts");
            }
        });
    }

	initContainerLimits := v1.ResourceList{}
	// init containers define the minimum of any resource
	//
	// Let's say `InitContainerUse(i)` is the resource requirements when the i-th
	// init container is initializing, then
	// `InitContainerUse(i) = sum(Resources of restartable init containers with index < i) + Resources of i-th init container`.
	//

            synchronized (lock) {
                init();
                return communicationAddresses;
            }
        } catch (Exception e) {
            throw new RuntimeException("Could not determine the local IP addresses for this machine.", e);
        }
    }

    public InetAddress getLocalBindingAddress() {
        try {
            synchronized (lock) {
                init();
                return localBindingAddress;

    private enum Type {
        PROJECT(ProjectInternal.class, SCRIPT_PLUGIN_EXTENSION),
        SETTINGS(SettingsInternal.class, ".settings" + SCRIPT_PLUGIN_EXTENSION),
        INIT(GradleInternal.class, ".init" + SCRIPT_PLUGIN_EXTENSION);

        private final Class<?> targetClass;
        private final String fileExtension;

        Type(Class<?> targetClass, String fileExtension) {

}

// Called to initialize a new m (including the bootstrap m).
// Called on the new thread, cannot allocate memory.
func minit() {
}

// Called from dropm to undo the effect of an minit.
func unminit() {
}

// Called from exitm, but not from drop, to undo the effect of thread-owned
// resources in minit, semacreate, or elsewhere. Do not take locks after calling this.
func mdestroy(mp *m) {
}

// wasm has no signals

      CONSTRUCTOR visibility:public <> () returnType:<root>.CodeFragment [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
      FUN name:run visibility:public modality:FINAL <> () returnType:kotlin.Unit
        EXPRESSION_BODY
          BLOCK type=kotlin.Unit origin=null

				obj := NewConst(name.Pos(), pkg, name.Name, nil, constant.MakeInt64(int64(d.iota)))
				lhs[i] = obj

				var init ast.Expr
				if i < len(d.init) {
					init = d.init[i]
				}

				check.constDecl(obj, d.typ, init, d.inherited)
			}

			// process function literals in init expressions before scope changes
			check.processDelayed(top)

			// spec: "The scope of a constant or variable identifier declared