func.return
}

// -----

func.func @parallel_execute_regions_with_data_results(%arg0: tensor<i32>) -> tensor<i32> {
  // expected-error @+1 {{'func' attribute refers to an undefined function: undefined_func}}
  %0 = "tf_device.cluster_func"(%arg0) {func = @undefined_func} : (tensor<i32>) -> tensor<i32>
  func.return %0 : tensor<i32>

  %1 = "tf.Const"() { value = dense<42.0> : tensor<f32> } : () -> tensor<f32>
  func.return %0, %1 : tensor<i32>, tensor<f32>
}

// CHECK: @cond(%arg0{{.*}}, %arg1{{.*}})
func.func private @cond(%arg0: tensor<i32>, %arg1: tensor<f32>) -> tensor<i1> {
  %const = "tf.Const"() { value = dense<1000> : tensor<i32> } : () -> tensor<i32>
  %result = "tf.Less"(%const, %arg0) : (tensor<i32>, tensor<i32>) -> tensor<i1>

  // CHECK-DAG: %0 = mhlo.constant dense<1> : tensor<i32>
  // CHECK: %1 = "mhlo.broadcast_in_dim"(%0) <{broadcast_dimensions = dense<> : tensor<0xi64>}> : (tensor<i32>) -> tensor<1x750xi32>
  // CHECK: return %1 : tensor<1x750xi32>
}

// CHECK-LABEL: @splat_scalar_no_change
func.func @splat_scalar_no_change() -> (tensor<f32>, tensor<i32>) {
  // CHECK-NOT: mhlo.broadcast_in_dim

  bad_consumers: 2
  bad_consumers: 9
}

# Find module attributes and verify tf.versions attribute
# CHECK: module attributes

  // CHECK-SAME: tfl.schema_version = 3 : i32

  // CHECK:          %{{.*}} = "tfl.pseudo_const"() <{value = dense<{{\[\[1, 2\], \[3, 4\], \[5, 6\]\]}}> : tensor<3x2xi32>}>
  // CHECK-NEXT:     [[SUB:%.*]] = tfl.sub %{{.*}}, %{{.*}} {fused_activation_function = "RELU6"} : tensor<3x2xi32>
  // CHECK-NEXT:     [[SCALAR:%.*]] = "tfl.pseudo_const"() <{value = dense<10> : tensor<i32>}> : () -> tensor<i32>

  tfrt.return %0 : !tfrt.chain
}

func.func @callee(%ch: !tfrt.chain, %arg: !tfrt_fallback.tf_tensor) -> (!tfrt.chain, !tfrt_fallback.tf_tensor) {
  %const = tfrt_fallback_async.const_dense_tensor dense<9> : tensor<i32> {_tfrt_cost = 1 : i64}
  %result = tfrt_fallback_async.executeop key(0) cost(3) device("/device:CPU:0") "tf.Less"(%arg, %const) {T = i32} : 1

	var s string
	var i8 int8
	var i16 int16
	var i32 int32
	var i64 int64
	var u8 uint8
	var u16 uint16
	var u32 uint32
	var u64 uint64

	f()

	ia[0] = "xxx"
	ia[1] = 12345
	ia[2] = true

	s = "now is"
	ia[3] = s
	b = false
	ia[4] = b

	i8 = 29
	ia[5] = i8
	i16 = 994
	ia[6] = i16
	i32 = 3434
	ia[7] = i32
	i64 = 1234567
	ia[8] = i64

	u8 = 12

// CHECK-LABEL: func @func_attr
// CHECK-SAME: tf._implements = #tf_type.func<@symbol_a, {attr0 = 1 : i32, attr1 = "random"}>
func.func @func_attr() attributes {tf._implements = #tf_type.func<@symbol_a, {attr0 = 1 : i32, attr1 = "random"}>} {
  func.return
}

// CHECK-LABEL: func @nested_func_attr
// CHECK-SAME: tf._implements = #tf_type.func<@symbol_a, {attr0 = 1 : i32, attr1 = "random", nested = #tf_type.func<@symbol_b, {attr2 = true, attr3 = 8.000000e+00 : f32}>}>

    %output_1, %token_1, %control_1 = tf_executor.NextIteration.Source : tensor<1xi32> {T = i32, device = ""}
    %output_2, %token_2, %control_2 = tf_executor.NextIteration.Source : tensor<1xi32> {T = i32, device = ""}
    tf_executor.NextIteration.Sink [%token_1] %output_1 : tensor<1xi32> {T = i32, device = ""}
    tf_executor.NextIteration.Sink [%token_2] %output_2 : tensor<1xi32> {T = i32, device = ""}
    tf_executor.fetch %output_1, %output_2 : tensor<1xi32>, tensor<1xi32>

	chki8(int8(i16), ci16&0xff)
	chki8(int8(i32), ci32&0xff-1<<8)
	chki8(int8(i64), ci64&0xff)
	chki8(int8(u8), cu8&0xff-1<<8)
	chki8(int8(u16), cu16&0xff)
	chki8(int8(u32), cu32&0xff)
	chki8(int8(u64), cu64&0xff)
	//	chki8(int8(f32), 0)
	//	chki8(int8(f64), 0)

	chki16(int16(i8), ci8&0xffff-1<<16)
	chki16(int16(i16), ci16&0xffff-1<<16)
	chki16(int16(i32), ci32&0xffff-1<<16)
	chki16(int16(i64), ci64&0xffff-1<<16)