// CHECK-SAME: {{{.*tf.entry_function = {inputs = "restore_op_0:0", outputs = ""}.*}}}
// CHECK-NEXT: tf_executor.graph

// Checks that the ops from @init_func_restore_op are cloned.
// CHECK-DAG: %[[CONST_0:.*]], %[[CTL:.*]] = tf_executor.island wraps "tf.Const"() <{{{.*value = dense<""> : tensor<1x!tf_type\.string>.*}}}>

    %15 = "tf.Cast"(%14) {Truncate = false} : (tensor<1x3x2x2xi32>) -> tensor<1x3x2x2xi8>
    return %15 : tensor<1x3x2x2xi8>
  }

// CHECK-LABEL: func @conv_with_bias_and_relu
// CHECK-DAG: %[[CONST_0:.*]] = "tf.Const"() <{value = dense<[1, 2]> : tensor<2xi32>}> : () -> tensor<2xi32>
// CHECK-DAG: %[[CONST_1:.*]] = "tf.Const"() <{value = dense<1> : tensor<2xi32>}> : () -> tensor<2xi32>

}
// CHECK-LABEL: func.func @conv_srq
// CHECK-SAME: (%[[ARG_0:.+]]: tensor<1x5x5x2x!quant.uniform<i8:f32, 2.000000e+00>>) -> tensor<1x4x4x4x!quant.uniform<i8:f32, 8.000000e+00:-128>>
// CHECK-DAG: %[[CONST_0:.+]] = "tfl.pseudo_const"() <{value = dense<{{\[\[0, 0\], \[1, 1\], \[1, 1\], \[0, 0\]\]}}> : tensor<4x2xi32>}> : () -> tensor<4x2xi32>

    // CHECK: %[[CONST0:.*]] = "tf.Const"() <{value = dense<
    // CHECK-SAME: [4, 4, 2, 2, 3, 64]
    // CHECK: %[[RESHAPE0:.*]] = "tf.Reshape"(%[[BACKPROP:.*]], %[[CONST0:.*]]) : (tensor<4x4x12x64xf32>, tensor<6xi64>) -> tensor<4x4x2x2x3x64xf32>
    // CHECK: %[[CONST1:.*]] = "tf.Const"() <{value = dense<

//   |        |          |
//   |      MatMul_0     |
//   |     /        \    |
//   |    ^          ^   |
//   |    |          |   |
//   |---x|         y|---|
//        |          |
//        |          |
//      Const_0   Const_1
//

TEST_F(GradientsTest, OneMatMul) {
  for (const bool expected : {false, true}) {
    const Scope& scope = expected ? scope_expected_ : scope_test_;
    // Construct forward graph.

  //
  // We implement a "control merge", which is a control edge that is alive if
  // either of two nodes (denoted as A and B below) are alive, in the following
  // manner:
  //
  //   A --ctrl--> Const0 --data--> Merge --data--> Identity
  //                                 ^                 |
  //                                 |                ctrl
  //   B --ctrl--> Const1 --data-----+                 |

      {});
}

TEST_F(CApiFunctionTest, UsingOneOutputOfSplit) {
  /*
   *                      feed
   *                       |
   *             +---------+---+
   *             | const0  |   |
   *             |    |    |   |
   *             |    v    /   |
   *             |    split    |
   *             |   |  |  |   |
   *             |   v  |  v   |
   *             |      |      |

  %0 = "tf.Relu"(%arg0) : (tensor<1xi32>) -> tensor<1xi32>
  func.return %0: tensor<1xi32>

// CHECK-LABEL: testReluI32
// CHECK:  %[[CONST_0:.*]] = arith.constant dense<0> : tensor<i32>
// CHECK:  %[[RES0:.*]] = "tfl.maximum"(%arg0, %[[CONST_0]]) : (tensor<1xi32>, tensor<i32>) -> tensor<1xi32>
// CHECK:  return %[[RES0]] : tensor<1xi32>
}

func.func @testReluI64(%arg0: tensor<1xi64>) -> tensor<1xi64> {

    ```mlir
      %old_val = "tf.ReadVariableOp"(%buffer)
      %old_size = "tf.ReadVariableOp"(%size)
      %offsets = "tf.ConcatV2"(%old_size, %other_dims_0s, %const0)
      %new_val = "tf.XlaDynamicUpdateSlice"(%old_val, %push_val, %offsets)
      "tf.AssignVariableOp"(%buffer, %new_val)
      %new_size = "tf.AddV2"(%old_size, %const1)
      "tf.AssignVariableOp"(%size, %new_size)

variables, for the buffer and current size. Each push will be turned into
```mlir
  %old_val = "tf.ReadVariableOp"(%buffer)
  %old_size = "tf.ReadVariableOp"(%size)
  %offsets = "tf.ConcatV2"(%old_size, %other_dims_0s, %const0)
  %new_val = "tf.XlaDynamicUpdateSlice"(%old_val, %push_val, %offsets)
  "tf.AssignVariableOp"(%buffer, %new_val)
  %new_size = "tf.AddV2"(%old_size, %const1)
  "tf.AssignVariableOp"(%size, %new_size)
```