%0 = arith.constant 3.0: f32
  %t = tfr.constant f32 -> !tfr.attr
  %cst = tfr.call @tf__const(%0, %t) : (f32, !tfr.attr) -> !tfr.tensor
  %4 = "tfr.cast"(%cst) : (!tfr.tensor) -> tensor<f32>
  func.return %4 : tensor<f32>

// CHECK: %[[cst:.*]] = "tf.Const"() <{value = dense<3.000000e+00> : tensor<f32>}> : () -> tensor<f32>
// CHECK: return %[[cst]] : tensor<f32>
}

// CHECK-LABEL: attribute_propagate

  %cst = "tf.Const"() {__op_key = 2: i32, device = "/device:CPU:0", value = dense<0> : tensor<i32>} : () -> tensor<i32>
  // Predicate should be inlined.
  // CHECK-NEXT: tf_mlrt.predicate
  // CHECK-NEXT: mlrt.cond
  // CHECK-NEXT: tf_mlrt.predicate

  // CHECK-NEXT: mlrt.while

// CHECK-NEXT:    name: "min_runtime_version",
// CHECK-NEXT:    buffer: 5
// CHECK-NEXT:  } ]
// CHECK-NEXT:  signature_defs: [ ]
// CHECK-NEXT:}

  %cst = "tfl.no_value"() {value = unit} : () -> none
  %0 = "tfl.transpose_conv"(%arg0, %arg1, %arg2, %cst) {padding = "SAME", stride_h = 2 : i32, stride_w = 2 : i32, fused_activation_function = "NONE"} : (tensor<4xi32>, tensor<32x4x4x128xf32>, tensor<1x32x42x128xf32>, none) -> tensor<1x64x84x32xf32>

  %index = arith.constant 0 : index
  %cst = arith.constant 1 : i64
  %eq = arith.cmpi "eq", %n, %cst : i64
  %v1 = tfr.get_element %values[%index] : (!tfr.tensor_list, index) -> !tfr.tensor
  %res = scf.if %eq -> !tfr.tensor {
    scf.yield %v1 : !tfr.tensor
  } else {
    %step = arith.index_cast %cst : i64 to index
    %end = arith.index_cast %n : i64 to index

					return
				}
				z.BucketStatuses[za0001] = za0002
			}
		case "tb":
			z.TotBuckets, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "TotBuckets")
				return
			}
		case "cst":
			err = z.TargetReplicationResyncStatus.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "TargetReplicationResyncStatus")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {

// not contributing to the dimentionality. This will run if the rank>6
// Pattern will convert-
// %0 = "tfl.transpose"(%arg0, %cst) : (tensor<56x8x56x1x1x1x7xf32>, tensor<7xi32>) -> tensor<1x1x8x56x56x7x1xf32>
// to-
// %0 = "tfl.reshape"(%arg0, %cst) : (tensor<56x8x56x1x1x1x7xf32>, tensor<4xi32>) -> tensor<56x8x56x7xf32>
// %1 = "tfl.transpose"(%0, %cst_0) : (tensor<56x8x56x7xf32>, tensor<4xi32>) -> tensor<8x56x56x7xf32>

func.func @invalid_non_mhlo() -> ( tensor<128x32x4xcomplex<f32>> {mhlo.sharding = ""}) {
  // expected-error @+1 {{Could not legalize op: tf.Const}}
  %cst = "tf.Const"() {value = dense<(1.000000e+00,-1.000000e+00)> : tensor<128x32x4xcomplex<f32>>} : () -> tensor<128x32x4xcomplex<f32>>
  return %cst : tensor<128x32x4xcomplex<f32>>
}

// -----

func.func @invalid_mixed_mhlo() -> (tensor<8x64x128xcomplex<f32>> {mhlo.sharding = ""}) {

module attributes {tf.versions = {bad_consumers = [], min_consumer = 0 : i32, producer = 1399 : i32}} {

// CHECK-LABEL: stateless_op
func.func @stateless_op() -> tensor<i32> {
  // CHECK: %cst = "tf.Const"() <{value = dense<1> : tensor<i32>}> : () -> tensor<i32>
  %0 = "tf.StatelessRandomGetAlg"() {device = ""} : () -> tensor<i32>
  return %0 : tensor<i32>
}

// CHECK-NEXT: "func.return"([[res]]) : (tensor<*xf32>) -> ()


// -----

// CHECK-LABEL: same_scale_test
func.func @same_scale_test(%arg0: tensor<*xf32>) -> tensor<*xf32> {
  %cst = arith.constant dense<[-1, 144]> : tensor<2xi32>
  %0 = "quantfork.qcast"(%arg0) : (tensor<*xf32>) -> tensor<*x!quant.uniform<i8:f32, 5.000000e-02:-10>>

// CHECK-LABEL: func private @merge_stateless_merged_if_0_0_else
// CHECK-SAME: ([[x:%.*]]: tensor<i32>, [[y:%.*]]: tensor<i32>)
// CHECK-DAG: [[cst:%.*]] = "tf.Const"() <{value = dense<1> : tensor<i32>}>
// CHECK-DAG: [[cst_0:%.*]] = "tf.Const"() <{value = dense<2> : tensor<i32>}>
// CHECK: [[r0:%.*]] = "tf.AddV2"([[x]], [[cst]])
// CHECK: [[r1:%.*]] = "tf.AddV2"([[y]], [[r0]])
// CHECK: [[r2:%.*]] = "tf.AddV2"([[x]], [[cst_0]])