func.func private @handles_multiple_returns(%arg0: f32, %arg1: f32) -> (f32, f32) {
  "SomeOp"() : () -> ()
 ^bb0:
  return %arg0, %arg1 : f32, f32
 ^bb1:
  return %arg1, %arg0 : f32, f32
}

// -----

// CHECK-LABEL: @removes_multiple_returns
func.func private @removes_multiple_returns(%arg0: f32, %arg1: f32) -> (f32, f32) {
  "SomeOp"() : () -> ()
 ^bb0:
  // CHECK: return
  // CHECK-NOT: arg

  %graph:2 = tf_executor.graph {
    %value, %value_control = tf_executor.island wraps "tf.GetKey"() : () -> tensor<f32>
    %ret0, %ret0_control = tf_executor.island wraps "tf.SomeOp"() : () -> !tf_res
    %ret1, %ret1_control = tf_executor.island wraps "tf.SomeOp"() : () -> !tf_res
    %control_unknown = tf_executor.island wraps "tf.UnknownOp"() : () -> ()
    %key, %key_control = tf_executor.island wraps "tf.GetKey"() : () -> !tf_str

  func.return
}

// CHECK-LABEL: func @resource
func.func @resource() {
  // CHECK: tf.SomeOp
  // CHECK-SAME: dtype = !corert.resource
  "tf.SomeOp"() {device = "/device:CPU:0", dtype = !tf_type.resource} : () -> ()
  func.return
}

// CHECK-LABEL: func @variant
func.func @variant(%arg: tensor<!tf_type.variant>) {

func.func @simple_independent_chains_while_cond(%arg0: !tf_res, %arg1: !tf_res, %arg2: tensor<f32>, %arg3: tensor<f32>) -> (tensor<i32>) {
  %graph = tf_executor.graph {
    %island, %ctrl = tf_executor.island {
      %pred = "tf.SomeOp"(%arg2) : (tensor<f32>) -> tensor<i32>
      tf_executor.yield %pred : tensor<i32>
    }
    tf_executor.fetch %island : tensor<i32>
  }
  func.return %graph : tensor<i32>
}

  "tf.AssignVariableOp"(%arg0, %device_output) : (!tf_res_i32, tensor<i32>) -> ()
  "tf.SomeOp"(%device_output) : (tensor<i32>) -> ()
  func.return
}

// CHECK-LABEL: func @device_func_1
// CHECK-NOT: tf.aliasing_output
func.func @device_func_1(%arg0: tensor<i32>) -> tensor<i32> {

  if (TF_GetCode(status) != TF_OK) {
    fprintf(stderr, "TF_CloseWritableFile failed: %s\n", TF_Message(status));
  }
  TF_StringStreamDone(s);

  TF_KernelBuilder* b =
      TF_NewKernelBuilder("SomeOp", "SomeDevice", &create, &compute, NULL);
  TF_RegisterKernelBuilder("someKernel", b, status);

  TF_DeleteStatus(status);
  return 0;

  %index = "tf.Const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
  %elem = "tf._SomeOp"() : () -> tensor<3xf32>
  %flow = "tf.Const"() {value = dense<1.0> : tensor<f32>} : () -> tensor<f32>
  // CHECK: %[[BR_INDEX:.*]] = "tf.SomeOp"() : () -> tensor<i32>
  %branch_index = "tf.SomeOp"() : () -> tensor<i32>
  // CHECK: "tf.CaseRegion"(%[[BR_INDEX]]) {{.*}} ({
  "tf.CaseRegion"(%branch_index) ({

    %tl_0 = "tf.TensorListReserve"(%elem_shape, %size) : (tensor<2xi32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<?x1xf32>>>
    %elem_0 = "tf.SomeOp"() : () -> tensor<16x1xf32>
    %elem_1 = "tf.SomeOp"() : () -> tensor<16x1xf32>
    %elem_2 = "tf.SomeOp"() : () -> tensor<8x1xf32>
    %tl_1 = "tf.IfRegion"(%arg0) ({

  "tf_device.cluster"() ({
    // expected-error@+1 {{Result #0 is not tied to arg #0 of the body}}
    %1 = "tf.WhileRegion"(%0) ({
      ^bb0(%carg0:tensor<*x!tf_type.resource<tensor<f32>>>):
        %cond = "tf.SomeOp"() : () -> tensor<i1>
        "tf.Yield"(%cond) : (tensor<i1>) -> ()
      }, {
      ^bb0(%carg0:tensor<*x!tf_type.resource<tensor<f32>>>):

        buildFile << """
            task someDep
            task someOtherDep
            task someTask(dependsOn: [someDep, someOtherDep])
        """

        expect:
        2.times {
            executer.withTasks("someTask").withArguments("-x", "sODep").run().assertTasksExecuted(":someDep", ":someTask")
            executer.withTasks("someTask").withArguments("-x", ":sODep").run().assertTasksExecuted(":someDep", ":someTask")