#
  # CHECK:      func {{@[a-zA-Z_0-9]+}}(
  # CHECK-SAME:   %arg0: tensor<f32> {tf._user_specified_name = "x", tf_saved_model.index_path = [0]},
  # CHECK-SAME:   %arg1: tensor<!tf_type.resource<{{.*}}>>
  # CHECK-SAME: ) -> (
  # CHECK-SAME:   tensor<f32> {tf_saved_model.index_path = [0]},
  # CHECK-SAME:   tensor<f32> {tf_saved_model.index_path = [1]})
  # CHECK-SAME: attributes{{.*}}tf_saved_model.exported_names = ["callee"]

// CHECK-LABEL: non_max_suppression_v4
func.func @non_max_suppression_v4(%arg0: tensor<3x4xf32>, %arg1: tensor<3xf32>, %arg2: tensor<f32>, %arg3: tensor<f32>) -> tensor<2xi32> {
  %max_size = mhlo.constant dense<2> : tensor<i32>
  // NO_FALLBACK: tf.NonMaxSuppressionV4
  // SUPPORTED_FALLBACK_DEVICE-NOT: tf.NonMaxSuppressionV4

    return TaggedValue(args.tuple()[0].f32() + args.tuple()[1].f32());
  }
  return TaggedValue::None();
}
}  // namespace
TEST(Test1, TestFunctionCall) {
  TaggedValue f32 = TaggedValue(add);
  TaggedValue args = TaggedValue::Tuple();
  args.tuple().emplace_back(TaggedValue(1.f));
  args.tuple().emplace_back(TaggedValue(2.f));
  TaggedValue c = f32.func()(args, TaggedValue::None()).value();

    %0 = stablehlo.constant() : () -> tensor<...x!quant.uniform<i8:f32:3 ...>>
    %1 = stablehlo.uniform_quantize %2 : (tensor<...xf32>) -> tensor<...x!quant.uniform<i8:f32 ...>>
    %3 = stablehlo.my_quantized_op(%1, %0) : (tensor<...x!quant.uniform<i8:f32 ...>>, tensor<...x!quant.uniform<i8:f32:3 ...>>) -> tensor<...x!quant.uniform<i8:f32 ...>>
    %4 = stablehlo.dequantize %3 : (tensor<...x!quant.uniform<i8:f32 ...>>) -> tensor<...xf32>
    ```
  }];

  // CHECK:      node {
  // CHECK-NEXT:   name: "Const"
  // CHECK-NEXT:   op: "Const"
    %0:2 = tf_executor.island wraps "tf.Const"() {device = "", dtype = "tfdtype$DT_FLOAT", value = dense<2.500000e-01> : tensor<f32>} : () -> tensor<f32> loc("Const")

  // CHECK:      node {
  // CHECK-NEXT:   name: "tf.PartitionedCall"
  // CHECK-NEXT:   op: "PartitionedCall"
  // CHECK:        func {
  // CHECK:          name: "foo"
  // CHECK:        }

  return
}

// -----

// CHECK-LABEL: strips_result_attributes
// CHECK-NOT: tf
func.func @strips_result_attributes() -> (f32 {tf.foo = "bar"}) {
  %0 = "foo.constant"() : () -> f32
  return %0 : f32
}

// -----

// CHECK-LABEL: strips_module_attributes

  func.return
}

// CHECK-LABEL: func @basic
func.func @basic(
    %arg0: tensor<3x1xf32>,
    %arg1: tensor<!tf_type.resource<tensor<1x3xf32>>>) -> (tensor<3x3xf32>) {

  } : (tensor<i32>) -> (tensor<2xi32>, tensor<*xf32>)

// CHECK: "tf.TensorArrayV3"
// CHECK-SAME: : (tensor<i32>) -> (tensor<2x!tf_type.resource>, tensor<f32>)

  %1 = "tfl.cast"(%0#1) : (tensor<*xf32>) -> tensor<f32>
  func.return %1 : tensor<f32>
}

// CHECK-LABEL: TfParseExample
func.func @TfParseExample(%arg0: tensor<1x!tf_type.string>) -> (tensor<1x1x!tf_type.string>, tensor<1x1x!tf_type.string>) {

// RUN: tf-mlir-translate -mlir-to-graphdef %s -o - | FileCheck %s

func.func @main(%arg0: tensor<f32>, %arg1: tensor<f32>, %arg2: tensor<4xf32>, %arg3: tensor<4xf32>) -> (tensor<4xf32>, tensor<4xf32>) {
  %0:2 = tf_executor.graph {
    %outputs_2, %control_3 = tf_executor.island wraps "tf.Less"(%arg0, %arg1) : (tensor<f32>, tensor<f32>) -> tensor<i1>

}

//go:noinline
func g8(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, x uint8) int64 {
	return int64(int8(x))
}

func main() {
	if got := f32(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1); got != 0xffffffff {
		println("bad f32", got)
	}
	if got := f16(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1); got != 0xffff {
		println("bad f16", got)
	}