// CHECK-LABEL: result_used_in_cond
// CHECK:       tf.WhileRegion
// CHECK-SAME:    (%[[ARG0:[a-zA-Z0-9_]+]], %[[ARG1:[a-zA-Z0-9_]+]])
// CHECK:       ^bb0
// CHECK:         (%[[CARG0:[a-zA-Z0-9_]+]]: tensor<*xf32>, %[[CARG1:[a-zA-Z0-9_]+]]: tensor<*xf32>)
// CHECK:       tf.OpA
// CHECK:       ^bb0
// CHECK:         (%[[BARG0:[a-zA-Z0-9_]+]]: tensor<*xf32>, %[[BARG1:[a-zA-Z0-9_]+]]: tensor<*xf32>)
// CHECK:       tf.OpB

  %push = "tf.TensorListPushBack"(%arg0, %elem) : (tensor<!tf_type.variant<tensor<f32>>>, tensor<f32>) -> tensor<!tf_type.variant<tensor<f32>>>
  // CHECK: return %[[UPDATE]], %[[ADD]]
  func.return %push : tensor<!tf_type.variant<tensor<f32>>>
}
// CHECK: func @if_else(%[[EARG0:.*]]: tensor<10xf32>, %[[EARG1:.*]]: tensor<1xi32>) -> (tensor<10xf32>, tensor<1xi32>)

// CHECK: while_1([[ARG0:%[^ :]*]]: tensor<i32>, [[ARG1:%[^ :]*]]: tensor<1xf32>)
func.func @while_1(%arg0: tensor<i32>, %arg1: tensor<1xf32>) -> tensor<1xf32> {
  // CHECK: [[CST:%[^ ]*]] = arith.constant dense<1> : tensor<i32>
  // CHECK: "tf.WhileRegion"([[ARG0]], [[ARG1]])
  // CHECK: (tensor<i32>, tensor<1xf32>) -> (tensor<i32>, tensor<1xf32>)
  %0:2 = "tf.WhileRegion"(%arg0, %arg1) (
    // cond
    {

  }

  // CHECK: func private @f_callee_callee(%arg0: tensor<*x!tf_type.resource>) -> tensor<0xf32>
  func.func private @f_callee_callee(%arg0: tensor<*x!tf_type.resource>) -> tensor<0xf32> {
    %val = "tf.ReadVariableOp"(%arg0) : (tensor<*x!tf_type.resource>) -> tensor<0xf32>
    %0 = "tf.AddV2"(%val, %val) : (tensor<0xf32>, tensor<0xf32>) -> tensor<0xf32>
    "tf.AssignVariableOp"(%arg0, %0) : (tensor<*x!tf_type.resource>, tensor<0xf32>) -> ()

          ^bb0(%carg0: tensor<i32>, %carg1: !tf_res, %carg2: !tf_res):
            %cond = func.call @whileregion_cond(%carg0, %carg1, %carg2) : (tensor<i32>, !tf_res, !tf_res) -> tensor<i1>
            "tf.Yield"(%cond) : (tensor<i1>) -> ()
        }, {
          ^bb0(%barg0: tensor<i32>, %barg1: !tf_res, %barg2: !tf_res):

  %0 = "tf.Bitcast"(%arg0) : (tensor<8x16x32x64xf32>) -> tensor<8x16x32x64xf32>
  // CHECK: return %arg0
  func.return %0: tensor<8x16x32x64xf32>
}

// CHECK-LABEL: testDifferentBitcastType
func.func @testDifferentBitcastType(%arg0: tensor<8x16x32x64xf32>) -> tensor<8x16x32x64xi32> {

  // Build the XLA computation graph.
  // "arg0" (T=DT_RESOURCE), "arg1" (T=DT_INT32)
  // "arg0", "arg1" -> "if" (If) -> "ret0", "ret1"
  // "arg0", "arg1" -> "while" (While) -> "ret2", "ret3"
  tensorflow::Scope s = tensorflow::Scope::NewRootScope();
  Output arg0 = ops::_Arg(s.WithOpName("arg0"), DT_RESOURCE, 0);
  Output arg1 = ops::_Arg(s.WithOpName("arg1"), DT_BOOL, 1);
  NameAttrList f;
  f.set_name("f1");

		{name: "ADDF", argLength: 2, reg: fp21, asm: "ADDF", commutative: true}, // arg0 + arg1
		{name: "ADDD", argLength: 2, reg: fp21, asm: "ADDD", commutative: true}, // arg0 + arg1
		{name: "SUBF", argLength: 2, reg: fp21, asm: "SUBF"},                    // arg0 - arg1
		{name: "SUBD", argLength: 2, reg: fp21, asm: "SUBD"},                    // arg0 - arg1

// CHECK-NEXT:   name: "args_0"
// CHECK-NEXT:   op: "_Arg"
// CHECK:          i: 0
// CHECK:      node {
// CHECK-NEXT:   name: "args_1"
// CHECK-NEXT:   op: "_Arg"
// CHECK:          i: 1
// CHECK:      node {
// CHECK-NEXT:   name: "args_2"
// CHECK-NEXT:   op: "_Arg"
// CHECK:          i: 2
// CHECK:      node {
// CHECK-NEXT:   name: "args_3"
// CHECK-NEXT:   op: "_Arg"
// CHECK:          i: 3
// CHECK:      node {

		{name: "MULV", argLength: 2, reg: gp2hilo, asm: "MULV", commutative: true, typ: "(Int64,Int64)"},     // arg0 * arg1, signed, results hi,lo
		{name: "MULVU", argLength: 2, reg: gp2hilo, asm: "MULVU", commutative: true, typ: "(UInt64,UInt64)"}, // arg0 * arg1, unsigned, results hi,lo
		{name: "DIVV", argLength: 2, reg: gp2hilo, asm: "DIVV", typ: "(Int64,Int64)"},                        // arg0 / arg1, signed, results hi=arg0%arg1,lo=arg0/arg1