}

        public void mergeBuildBase(BuildBase.Builder builder, BuildBase target, BuildBase source) {
            mergeBuildBase(builder, target, source, true, Collections.emptyMap());
        }

        @Override
        protected void mergePluginContainer_Plugins(
                PluginContainer.Builder builder,
                PluginContainer target,

    public SortedMap<String, String> create(Entry<String, String>[] entries) {
      ImmutableSortedMap.Builder<String, String> builder = ImmutableSortedMap.naturalOrder();
      for (Entry<String, String> entry : entries) {
        checkNotNull(entry);
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.build();
    }
  }

  public static class ImmutableSortedMapCopyOfEntriesGenerator

    private final File daemonBaseDir;
    private final boolean verboseLogging;
    private final File distributionBaseDir;

    public static Builder builder() {
        return new Builder();
    }

    public static class Builder {
        private File projectDir;
        private File gradleUserHomeDir;
        private Boolean embedded;
        private Integer daemonMaxIdleTimeValue;

                    add(builder.classifierBuilder.buildClassifierSymbol(firSymbol))
                }
            }
        }
    }

internal fun FirScope.getConstructors(builder: KaSymbolByFirBuilder): Sequence<KaConstructorSymbol> =
    sequence {
        yieldList {
            processDeclaredConstructors { firSymbol ->
                add(builder.functionLikeBuilder.buildConstructorSymbol(firSymbol))

  OpBuilder builder(module_op);
  builder.setInsertionPointToEnd(&module_op.getBodyRegion().front());

  auto filename_input_type = RankedTensorType::get(
      /*shape=*/{}, /*elementType=*/builder.getType<TF::StringType>());

  FunctionType func_type = builder.getFunctionType(
      /*inputs=*/{filename_input_type}, /*results=*/{});
  auto save_func = builder.create<func::FuncOp>(

        def expected = new StringBuilder().with { builder ->
            builder << "destfile=build/jacoco/fake.exec,"
            builder << "append=true,"
            builder << "includes=org.*:*.?acoco*,"
            builder << "excludes=org.?joberstar,"
            builder << "exclclassloader=com.sun.*:org.fak?.*,"
            builder << "inclnolocationclasses=$includeNoLocationClassesValue,"
            builder << "sessionid=testSession,"

        }
    }

    static abstract class Builder {
        private final StringBuilder scriptCommands = new StringBuilder()

        protected Builder() {}

        abstract Builder printArguments();

        abstract Builder printText(String text);

        abstract Builder printEnvironmentVariable(String variableName)

        abstract Builder printWorkingDir()

  func->setAttr("tf._implements", attr_value);
  return func;
}

func::FuncOp createMaxUnpoolingFunc(
    mlir::Builder* builder, const SmallVector<int64_t, 4>& input_shape,
    const SmallVector<int64_t, 4>& output_shape) {
  auto input_type = RankedTensorType::get(input_shape, builder->getF32Type());
  auto indices_type = RankedTensorType::get(input_shape, builder->getI64Type());

        builder(settings, buildContentGenerationContext).create(settings.getTarget()).generate();
    }

    private BuildScriptBuilder builder(InitSettings settings, BuildContentGenerationContext buildContentGenerationContext) {

        fun collectPackages(files: Iterable<Path>): Trie {
            val builder = Trie.Builder()
            for (file in files) {
                if (Files.exists(file)) {
                    if (file.fileName.toString().endsWith(".jar")) {
                        processJarFile(file, builder)
                    } else {
                        processDirectory(file, builder)
                    }
                }
            }