}

        // Preliminary extension function check
        val extensionCandidate = couldBeExtensionFunction && ktFunction.receiverTypeReference != null &&
            method.firstParameterMatches(ktFunction.receiverTypeReference!!) &&
            ktFunction.valueParameters.size == paramCountWithReceiver
        if (!(extensionCandidate || ktFunction.valueParameters.size == paramCount)) {

import kotlinx.metadata.KmConstructor
import kotlinx.metadata.KmFunction
import kotlinx.metadata.KmPackage
import kotlinx.metadata.KmProperty
import kotlinx.metadata.jvm.KotlinClassMetadata
import kotlinx.metadata.jvm.fieldSignature
import kotlinx.metadata.jvm.getterSignature
import kotlinx.metadata.jvm.setterSignature
import kotlinx.metadata.jvm.signature
import java.util.function.Supplier


internal

# Each automation is independent of the others.  Every time one of the `on` conditions match for
# this PR, this automations will have its `if` checked to run.  In a way, the `on` conditions
# function as an implicit first `if` for every automation in the file.

# You can define multiple automations in a .cm file, but each automation name should be unique

            ?: Type.getArgumentTypes(delegate.desc).map { it.className }
        val names by unsafeLazy {
            parameterNamesFor(
                function.owner.sourceName,
                function.name,
                parameterTypesBinaryNames
            )
        }
        parameterTypesBinaryNames.mapIndexed { idx, parameterTypeBinaryName ->

# Each automation is independent of the others.  Every time one of the `on` conditions match for
# this PR, this automations will have its `if` checked to run.  In a way, the `on` conditions
# function as an implicit first `if` for every automation in the file.

# You can define multiple automations in a .cm file, but each automation name should be unique

# Each automation is independent of the others.  Every time one of the `on` conditions match for
# this PR, this automations will have its `if` checked to run.  In a way, the `on` conditions
# function as an implicit first `if` for every automation in the file.

# You can define multiple automations in a .cm file, but each automation name should be unique

    sourceFilesBaseName: String,
    hashTypeSourceName: java.util.function.Function<String, String>,
    classPath: List<File>,
    classPathDependencies: List<File>,
    apiSpec: java.util.function.Function<String, Boolean>,
    parameterNamesSupplier: java.util.function.Function<String, List<String>?>,
    sinceSupplier: java.util.function.Function<String, String?>,
): List<File> =

    apiTypeProviderFor(
        asmLevel,

 *
 * @param list the list to split, must be ordered by size desc
 * @param toIntFunction the function used to map the element to its "size"
 * @param largeElementSplitFunction the function used to further split the large element into smaller pieces
 * @param smallElementAggregateFunction the function used to aggregate tiny elements into a large bucket

# Each automation is independent of the others.  Every time one of the `on` conditions match for
# this PR, this automations will have its `if` checked to run.  In a way, the `on` conditions
# function as an implicit first `if` for every automation in the file.

# You can define multiple automations in a .cm file, but each automation name should be unique

        else hasKotlinFlag(ctMember, Flag.IS_INTERNAL)

    fun isKotlinOperatorFunction(ctMethod: CtMethod): Boolean =
        hasKotlinFlag(ctMethod, Flag.Function.IS_OPERATOR)

    fun isKotlinInfixFunction(ctMethod: CtMethod): Boolean =
        hasKotlinFlag(ctMethod, Flag.Function.IS_INFIX)

    private
    fun hasKotlinFlag(ctClass: CtClass, flag: Flag): Boolean =
        queryKotlinMetadata(ctClass, false) { metadata ->