rootManager = newManager();
    }

    public LoggingManagerInternal getRoot() {
        return rootManager;
    }

    @Override
    public LoggingManagerInternal create() {
        if (!created) {
            created = true;
            return getRoot();
        }
        return newManager();
    }

    private DefaultLoggingManager newManager() {

  }

  @Override
  public List<Character> create(Object... elements) {
    Character[] array = new Character[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (Character) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link
   * #create(Object...)}.
   */

repositories {
    mavenCentral()
}

val codec = configurations.create("codec") {
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
    }
    isVisible = false
    isCanBeConsumed = false
}

dependencies {
    codec("commons-codec:commons-codec:1.10")
}

tasks.register<CreateMD5>("md5") {
    codecClasspath.from(codec)

 *
 * When the hierarchy is first registered via {@link #registerProbe(File)}, we don't yet create the probe.
 * That only happens when the hierarchy is actually read or written by Gradle, in which case
 * {@link #armWatchProbe(File)} is called.
 *
 * When the probe is armed, a probe file is created (or re-created) under the hierarchy.
 * This should cause a file system event to be produced by the operating system.

    private val emptyProvider: P,
    private val composeProviders: (List<P>) -> P,
) {
    public fun create(providers: List<P>): P = when (providers.size) {
        0 -> emptyProvider
        1 -> providers.single()
        else -> composeProviders(providers)
    }

    public fun createFlattened(providers: List<P>): P =
        create(if (providers.size > 1) flatten(providers) else providers)

    /**
     * Creates a problem with the given message and exception.
     *
     * Problem has no documentation, and a default location is inferred from the calling thread's state.
     */
    fun problem(message: StructuredMessage, exception: Throwable? = null, documentationSection: DocumentationSection? = null): PropertyProblem

    /**
     * Creates a problem with the given message.
     *

     *     or the link is removed and a new directory is created (if {@code followSymlinks}
     *     is {@code false}),</li>
     *     <li>a file, or a symlink to an existing file, it is deleted and a directory is created in its place,</li>
     *     <li>non-existent, then a directory is created in its place.</li>
     * </ul>
     *
     * Follows symlinks pointing to directories when instructed to.

import org.jetbrains.kotlin.analysis.api.symbols.markers.KaSymbolWithKind
import org.jetbrains.kotlin.analysis.api.symbols.pointers.KaSymbolPointer

/**
 *  A [KaSymbol] created from a [destructuring declaration][org.jetbrains.kotlin.psi.KtDestructuringDeclaration] (possibly from a lambda parameter).
 *
 * Examples:
 * - `val (a, _) = Pair(1, 2)` leads to `KaDestructuringDeclarationSymbol(entries = [a, _])`

    /**
     * Loads a cached intermediate model, if available, or else runs the given function to create it and then writes the result to the cache.
     *
     * @param identityPath The project for which the model should be created, or null for a build scoped model.
     */
    fun <T> loadOrCreateIntermediateModel(identityPath: Path?, modelName: String, parameter: ToolingModelParameterCarrier?, creator: () -> T?): T?

import org.gradle.internal.build.BuildState;

public interface BuildScopeModelBuilder {
    /**
     * Creates the model for the given target. The target build will not necessarily have been configured.
     * This method is responsible for transitioning the target into the appropriate state required to create the model.
     *