$

5. Merge profiles together:

	$ go tool covdata merge -i=indir1,indir2 -o=outdir -modpaths=github.com/go-delve/delve
	$

6. Subtract one profile from another

	$ go tool covdata subtract -i=indir1,indir2 -o=outdir
	$

7. Intersect profiles

	$ go tool covdata intersect -i=indir1,indir2 -o=outdir
	$

8. Dump a profile for debugging purposes.

	$ go tool covdata debugdump -i=indir

}

func writeOutFileList(t *testing.T, infiles []string, outdir, tag string) ([]string, string) {
	outfilelist := filepath.Join(outdir, tag+"outfilelist.txt")
	var sb strings.Builder
	cv := filepath.Join(outdir, "covervars.go")
	outfs := []string{cv}
	fmt.Fprintf(&sb, "%s\n", cv)
	for _, inf := range infiles {
		base := filepath.Base(inf)
		of := filepath.Join(outdir, tag+".cov."+base)
		outfs = append(outfs, of)

  builder->create<func::ReturnOp>(cluster_return_op.getLoc(),
                                  cluster_return_op.getOperands());
  cluster_return_op.erase();
}

// Builds a function that outlines region attached to cluster_op or launch_op,
// and inserts built function into given module.
template <typename ClusterOrLaunchOp>
func::FuncOp BuildFunction(llvm::ArrayRef<Value> live_ins, ClusterOrLaunchOp op,

// RUN: tf-opt %s -split-input-file -verify-diagnostics  -tf-xla-cluster-formation | FileCheck %s

// Check that we outline the partitioned call with `_xla_compile_device_type`
// to a device cluster.
// CHECK-LABEL: func.func @xla_must_compile_true
// CHECK: tf_device.cluster
// CHECK-NEXT: tf.StatefulPartitionedCall
// CHECK-NEXT: tf_device.return
// CHECK: _cluster_outlined_function_name = "stateful_pcall_func"
// CHECK-SAME: allow_soft_placement = true

        file("in-dir").createDir()
        def outDir = file("out-dir")
        def copy = file("other")

        given:
        run("work")
        run("work")
        result.assertTasksSkipped(":work")

        when:
        Files.move(outDir.toPath(), copy.toPath(), StandardCopyOption.ATOMIC_MOVE)
        outDir.deleteDir()
        outDir.createLink(copy)

        run("work")

        /*

    # copybara:comment_begin(JitRt/Auto fusion depreciated)
    exclude = [
        "auto-fusion.mlir",
        "tf_to_corert_pipeline_cpurt.mlir",
        "outline-cpurt-cluster.mlir",
    ],
    # copybara:comment_end
    features = if_oss(["--path=org_tensorflow/tensorflow/compiler/mlir/tfrt"]),
    size_override = {
        "fallback.mlir": "medium",
    },

    @Rule
    final TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    final TestFile srcDir = temporaryFolder.createDir('src')
    final TestFile outDir = temporaryFolder.createDir('out')
    final TestFile classesDir = temporaryFolder.createDir('classes')

    def "code generation is deterministic regardless of type processing order"() {
        given:

			panic(err)
		}
	} else {
		h.outer.Reset()
		h.outer.Write(h.opad)
	}
	h.outer.Write(in[origLen:])
	return h.outer.Sum(in[:origLen])
}

func (h *hmac) Write(p []byte) (n int, err error) {
	return h.inner.Write(p)
}

func (h *hmac) Size() int      { return h.outer.Size() }
func (h *hmac) BlockSize() int { return h.inner.BlockSize() }

func (h *hmac) Reset() {
	if h.marshaled {

model {
    thing {
        conf {
            println "outer 1"
        }
        someProp.conf {
            println "outer 2"
            // not a rule
            conf { println "inner 1" }
        }
    }
    tasks {
        show(Task) { doLast { println $.thing } }
    }
}
'''

        expect:
        succeeds "show"
        output.contains("outer 1")
        output.contains("outer 2")

some form of isolation when dealing with untrusted data. As a result, this
document also outlines what issues we consider as TensorFlow security
vulnerabilities.

We recognize issues as vulnerabilities only when they occur in scenarios that we
outline as safe; issues that have a security impact only when TensorFlow is used