println("Processing ${logFile} into directory ${processedDirectory}")

int uniqueOpCount = 0
int uniqueExcludeCount = 0

Map<String, Counter> opCounters = [:].withDefault { new Counter(uniqueOpCount++) }
Map<String, Counter> excludeCounters = [:].withDefault { new Counter(uniqueExcludeCount++) }

class Counter {
    final int id
    Counter(int id) { this.id = id}

    int counter = -1

    void inc() {

	b.Min = &value
	return b
}

// WithDefault sets the Default field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Default field is set to the value of the last call.
func (b *LimitRangeItemApplyConfiguration) WithDefault(value v1.ResourceList) *LimitRangeItemApplyConfiguration {

@CompileStatic
class PolyglotProjectBuilder {
    private final GradleDsl dsl
    private final TestFile targetDirectory
    private final Map<String, BuildFileBuilder> buildFiles = [:].withDefault { new BuildFileBuilder(it.toString()) }

    @Delegate
    private final BuildFileBuilder mainBuildFile

    PolyglotProjectBuilder(GradleDsl dsl, TestFile targetDirectory) {
        this.dsl = dsl

 */

package org.gradle.integtests.fixtures.publish

import org.gradle.test.fixtures.HttpRepository

class GroupSpec {
    private final String groupId
    final Map<String, ModuleSpec> modules = [:].withDefault { new ModuleSpec(groupId, it) }

    GroupSpec(String name) {
        groupId = name
    }

    void module(String name, @DelegatesTo(value = ModuleSpec, strategy = Closure.DELEGATE_ONLY) Closure<Void> moduleSpec) {

    @get:OutputDirectory
    abstract val destination: DirectoryProperty

    @TaskAction
    fun render() {
        var first = true
        val benchmarks = mutableMapOf<String, MutableList<Pair<String, Int>>>().withDefault { mutableListOf() }
        csv.get().asFile.forEachLine { line ->
            if (first) {
                first = false
            } else {
                val tokens = line.replace("\"", "").split(",")

import org.gradle.test.fixtures.maven.MavenModule

class ModuleSpec {
    private final String groupId
    private final String artifactId
    private final Map<String, ModuleVersionSpec> versions = [:].withDefault { new ModuleVersionSpec(groupId, artifactId, it) }

    private List<InteractionExpectation> metadataExpectations = []

    ModuleSpec(String group, String name) {
        groupId = group
        artifactId = name

        @Override
        protected Boolean initialValue() {
            false
        }
    }

    final Map<String, GroupSpec> groups = [:].withDefault { new GroupSpec(it) }

    void nextStep() {
        groups.clear()
    }

    void group(String group, @DelegatesTo(value=GroupSpec, strategy = Closure.DELEGATE_ONLY) Closure<Void> groupSpec) {

        "brother",
        "deer",
        "waves",
        "advice",
        "acoustics",
        "nut",
        "store",
        "finger"
    ]

    private final Map<String, String> mappingCache = [:].withDefault {
        def size = mappingCache.size()
        size >WORDS.size() ? "word${size}" : WORDS[size]
    }

    /**
     * Converts an operation dumped as JSON into code which can be used to

    private VariantContext() {
        this([:])
    }

    private VariantContext(Map<String, VariantDimension> dimensions) {
        this.dimensions = dimensions.withDefault { VariantDimension.missing(it) }
    }

    VariantDimension getBuildType() {
        return dimensions.get("buildType")
    }

    VariantDimension getOs() {
        return dimensions.get("os")
    }

        private final static boolean LOG = false
        private final static Map<String, Integer> FACTORS = [
            'jar': 10,
            'xml': 3,
            'pom': 3
        ].withDefault { 1 }

        private final AtomicInteger concurrency = new AtomicInteger()

        @Override
        void init(FilterConfig filterConfig) throws ServletException {

        }

        @Override