// CHECK: %[[arg1_floor:.*]] = "tf.Floor"(%[[arg1_add]]
// CHECK: %[[arg1_clip:.*]] = "tf.ClipByValue"(%[[arg1_floor]]
// CHECK: %[[arg1_cast:.*]] = "tf.Cast"(%[[arg1_clip]]

// CHECK: %[[arg0_div:.*]] = "tf.Div"(%arg0
// CHECK: %[[arg0_add:.*]] = "tf.AddV2"(%[[arg0_div]]
// CHECK: %[[arg0_floor:.*]] = "tf.Floor"(%[[arg0_add]]
// CHECK: %[[arg0_clip:.*]] = "tf.ClipByValue"(%[[arg0_floor]]
// CHECK: %[[arg0_cast:.*]] = "tf.Cast"(%[[arg0_clip]]

// CHECK-LABEL: func.func @remove_redundant_cast

// CHECK: %[[CLIPBYVALUE_0:.*]] = "tf.ClipByValue"
// CHECK-SAME: (tensor<1x100x100x1xi32>, tensor<i32>, tensor<i32>) -> tensor<1x100x100x1xi32>
// CHECK: %[[CAST_1:.*]] = "tf.Cast"(%[[CLIPBYVALUE_0]]) <{Truncate = false}> : (tensor<1x100x100x1xi32>) -> tensor<1x100x100x1xf32>

// CHECK: %[[CLIPBYVALUE_1:.*]] = "tf.ClipByValue"
// CHECK-SAME: (tensor<1x98x98x1xi32>, tensor<i32>, tensor<i32>) -> tensor<1x98x98x1xi32>

module {
func.func @main(%arg0 : tensor<5xf32>, %arg1 : tensor<f32>, %arg2 : tensor<f32>) -> tensor<5xf32> {
  %0 = "tf.ClipByValue"(%arg0, %arg1, %arg2) : (tensor<5xf32>, tensor<f32>, tensor<f32>) -> tensor<5xf32>
  func.return %0 : tensor<5xf32>
}

    %12 = "tf.AddV2"(%11, %arg7) : (tensor<1x2240x1120x512xi32>, tensor<i32>) -> tensor<1x2240x1120x512xi32>
    %13 = "tf.Maximum"(%cst_0, %arg7) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    %14 = "tf.ClipByValue"(%12, %13, %cst) : (tensor<1x2240x1120x512xi32>, tensor<i32>, tensor<i32>) -> tensor<1x2240x1120x512xi32>
    %15 = "tf.Cast"(%14) {Truncate = false} : (tensor<1x2240x1120x512xi32>) -> tensor<1x2240x1120x512xi8>

    %i8_min = "tf.Const"() {value = dense<-128.0> : tensor<f32>} : () -> tensor<f32>
    %i8_max = "tf.Const"() {value = dense<127.0> : tensor<f32>} : () -> tensor<f32>
    %clip = "tf.ClipByValue"(%round, %i8_min, %i8_max) : (tensor<*xf32>, tensor<f32>, tensor<f32>) -> tensor<*xf32>
    %i8 = "tf.Cast"(%clip) : (tensor<*xf32>) -> tensor<*xi8>
    func.return %i8 : tensor<*xi8>
  }

                       std::vector<Output>* grad_outputs) {
  if (op.num_inputs() != 3) {
    return absl::InvalidArgumentError("ClipByValue requires 3 arguments");
  }
  if (grad_inputs.size() != 1) {
    return absl::InvalidArgumentError("ClipByValue grad requires 1 grad input");
  }

  Output x = op.input(0);
  Output min = op.input(1);
  Output max = op.input(2);

    "$_builder.create<TF::SelectOp>("
    "$0.getLoc(), $3.getType(), $1, $2, $3)">;

def ConstAttrIfThenElse: NativeCodeCall<
    "($0).getValue() ? ($1) : ($2)">;

// Convert clamp(lo, x, hi) to clipbyvalue(x, lo, hi).
def Clamp: NativeCodeCall<
    "$_builder.create<TF::ClipByValueOp>("
    "  $0.getLoc(),"
    "  $2.getType(), $2, $1, $3)">;

def CopyXlaOutsideCompilationAttr: NativeCodeCallVoid<

namespace tensorflow {
namespace {

using ops::Abs;
using ops::Add;
using ops::AddN;
using ops::AddV2;
using ops::Atan2;
using ops::BatchMatMul;
using ops::BatchMatMulV3;
using ops::Cast;
using ops::ClipByValue;
using ops::Const;
using ops::Cumsum;
using ops::Div;
using ops::DivNoNan;
using ops::MatMul;
using ops::Max;
using ops::Maximum;
using ops::Mean;
using ops::Min;
using ops::Minimum;
using ops::Mul;

      %outputs_75, %control_76 = tf_executor.island wraps "tf.Mul"(%arg0, %outputs_41) {device = "/device:CPU:0"} : (tensor<3x32x32x3xf32>, tensor<f32>) -> tensor<*xf32>
      %outputs_77, %control_78 = tf_executor.island wraps "tf.ClipByValue"(%outputs_75, %outputs_37, %outputs_39) {device = "/device:CPU:0"} : (tensor<*xf32>, tensor<f32>, tensor<f32>) -> tensor<*xf32>

  // CHECK-DAG: [[VAL3:%.+]] = "tf.Const"() <{value = dense<0.00784313772> : tensor<f32>}>
  // CHECK-DAG: [[VAL4:%.+]] = "tf.Const"() <{value = dense<5.000000e-01> : tensor<f32>}>
  // CHECK-DAG: [[VAL5:%.+]] = "tf.ClipByValue"(%arg0, [[VAL2]], [[VAL1]])
  // CHECK-DAG: [[VAL6:%.+]] = "tf.Sub"([[VAL5]], [[VAL2]])
  // CHECK-DAG: [[VAL7:%.+]] = "tf.Mul"([[VAL6]], [[VAL0]])
  // CHECK-DAG: [[VAL8:%.+]] = "tf.AddV2"([[VAL7]], [[VAL4]])