32,
            16
          ],
          "name": "output",
          "quantization": {
          }
        }
      ],
      "inputs": [
        0,
        1
      ],
      "outputs": [
        2
      ],
      "operators": [
        {
          "inputs": [
            0,
            1
          ],
          "outputs": [
            2
          ],

  //    operators. We also convert the XlaClusterOutput output nodes of the
  //    function call into the outputs of the XlaLaunch operator.
  static Status BuildXlaLaunchOps(Graph* graph);

  struct XlaFunctionInfo {
    int variable_start_index = -1;
    std::string function_name;
  };

  // We need to introduce this version to adapt to the output of gpu inference

    @get:InputArtifact
    @get:Classpath
    abstract val inputArtifact: Provider<FileSystemLocation>

    override fun transform(outputs: TransformOutputs) {
        val jarFile = inputArtifact.get().asFile
        val zipFile = ZipFile(jarFile)
        val outputRoot = outputs.dir("public-api")
        zipFile.stream().forEach { entry ->
            if (entry.shouldInclude()) {

            outputFile = "${sourceSets.main.get().output.resourcesDir}/output.js"
            sourceMap = true
        }
    }
    val unpackKotlinJsStdlib by registering {
        group = "build"
        description = "Unpack the Kotlin JavaScript standard library"
        val outputDir = file("$buildDir/$name")
        inputs.property("compileClasspath", configurations.compileClasspath.get())
        outputs.dir(outputDir)
        doLast {

)

type WarningPrinter struct {
	// out is the writer to output warnings to
	out io.Writer
	// opts contains options controlling warning output
	opts WarningPrinterOptions
}

// WarningPrinterOptions controls the behavior of a WarningPrinter constructed using NewWarningPrinter()
type WarningPrinterOptions struct {
	// Color indicates that warning output can include ANSI color codes
	Color bool
}

     *
     * @since 8.3
     */
    NOT_CACHEABLE,

    /**
     * The work has no outputs declared.
     */
    NO_OUTPUTS_DECLARED,

    /**
     * The work has a {@code org.gradle.api.file.FileTree} or {@code org.gradle.api.internal.file.collections.DirectoryFileTree} as an output.
     *
     * @since 5.0
     */
    NON_CACHEABLE_TREE_OUTPUT,

    /**

    private final String[] inputs;

    private final String[] outputs;

    private String[] newInputs;

    private String[] newOutputs;

    public SynonymItem(final long id, final String[] inputs, final String[] outputs) {
        this.id = id;
        this.inputs = inputs;
        this.outputs = outputs;

        if (id == 0) {
            // create
            newInputs = inputs;

    /**
     * The type of output the report produces
     */
    enum OutputType {

        /**
         * The report outputs a single file.
         * <p>
         * That is, the {@link #getOutputLocation()} points to a single file.
         */
        FILE,

        /**
         * The report outputs files into a directory.
         * <p>

            class MyPlugin : Plugin<Project> {
                override fun apply(target: Project) {
                    target.tasks.register("myTask") { task ->
                        task.outputs.file("build/output.txt")
                        task.doLast(Action { println("Hello") })
                    }
                }
            }
        """

        buildFile << """
            plugins {

                configurations { create("default") }
            }
            project(":producer") {
                task producer {
                    ext.output = objects.fileProperty()
                    outputs.file output
                    output.set(file("out"))
                }
                task longRunning {
                    dependsOn producer
                    doLast {