// CHECK-NOT: "tf_device.launch"
  // CHECK: "tf.opA"
  "tf.opA"() {device = ""} : () -> tensor<i1>
  func.return
}

// Tests that an op not in tf dialect (tf_device.launch) with device attribute is not wrapped in `tf_device.launch`.
// Also tests that a `tf_device.launch` is not rewrapped.
// CHECK-LABEL: func @non_tf_op
func.func @non_tf_op() {
  // CHECK: "tf_device.launch"
  // CHECK-NOT "tf_device.launch"
  // CHECK: "tf.opA"

func.func @non_replicated(%arg0: tensor<*x!tf_type.resource> {tf.device = "/device:CPU:0"}) -> tensor<i32> {
  // CHECK: %[[COMPILE:.*]]:2 = "tf_device.launch"
  // CHECK-NEXT: "tf._TPUCompileMlir"()
  %compile:2 = "tf_device.launch"() ({
    %1:2 = "tf._TPUCompileMlir"() {
      NumDynamicShapes = 0 : i64,
      // The metadata encodes 2 parameter and two return values.

  %read2 = "tf.ReadVariableOp"(%arg2) : (tensor<*x!tf_type.resource<tensor<16xf32>>>) -> tensor<16xf32>
  // CHECK: %[[COMPILE:.*]]:2 = "tf_device.launch"
  %compile:2 = "tf_device.launch"() ({
      // CHECK: tf._TPUCompileMlir
      %0:2 = "tf._TPUCompileMlir"() {
        metadata = "",

      %0 = tf_executor.island {
        "tf_device.launch"() ({
          %1 = "tf.opA"() : () -> tensor<!tf_type.string>
          "tf.EnqueueTPUEmbeddingArbitraryTensorBatch"(%1){_xla_replica_id = 0 : i64, device_ordinal = -1 : i64} : (tensor<!tf_type.string>) -> ()
          tf_device.return
        }) {device = "/job:worker/replica:0/task:0/device:CPU:0"} : () -> ()
        "tf_device.launch"() ({

  }

  // Replaces each launch function call together with its neighboring
  // XlaClusterOutput nodes with a XlaLaunch node.
  for (Node* launch : launch_nodes) {
    TF_ASSIGN_OR_RETURN(const XlaFunctionInfo xla_function_info,
                        get_xla_function_info(*launch));

    std::vector<const Edge*> in_edges;
    TF_RETURN_IF_ERROR(launch->input_edges(&in_edges));

  // CHECK-LABEL: func @head_single_outside_compiled_op
  func.func @head_single_outside_compiled_op(%arg0: tensor<i32>) {
    // CHECK:      "tf_device.launch"
    // CHECK-SAME: device = "/job:worker/replica:0/task:0/device:CPU:0"
    // CHECK-NEXT:   "tf.A"
    // CHECK-NOT:    _xla_outside_compilation
    // CHECK-NEXT:   tf_device.return
    //

}

// LoadEncryptionConfig parses and validates the encryption config specified by filepath.
// It may launch multiple go routines whose lifecycle is controlled by ctx.
// In case of an error, the caller is responsible for canceling ctx to clean up any go routines that may have been launched.
// If reload is true, or KMS v2 plugins are used with no KMS v1 plugins, the returned slice of health checkers will always be of length 1.

  ModuleOp module = getOperation();
  module.walk([&](tf_device::LaunchFuncOp launch) {
    OpBuilder builder(launch);
    auto call_op = builder.create<TF::PartitionedCallOp>(
        module.getLoc(), launch.getResultTypes(), launch.getOperands(),
        SymbolRefAttr::get(builder.getContext(), launch.getFunc()),
        /*config=*/builder.getStringAttr(""),
        /*config_proto=*/builder.getStringAttr(""),

	func (b *B) StartTimer()

	// StopTimer stops timing a test. This can be used to pause the ...
	func (b *B) StopTimer()

	// launch launches the benchmark function. It gradually increases ...
	func (b *B) launch()

	// log generates the output. It's always at the same stack depth. 
	func (c *B) log(s string)

	// 
	func (b *B) nsPerOp() int64

      "tf_device.launch"() ( {
        "tf.TPUCompileSucceededAssert"(%0#0) : (tensor<!tf_type.string>) -> ()
        tf_device.return
      }) {device = "/job:worker/replica:0/task:0/device:CPU:0"} : () -> ()
      %1 = "tf_device.launch"() ( {
        %2 = "tf.TPUExecute"(%arg0, %0#1) : (tensor<i8>, tensor<3x!tf_type.string>) -> tensor<i8>