// CHECK-LABEL: conv
// CHECK-DAG:  %[[CONSTANT:.*]] = arith.constant dense<0.000000e+00> : tensor<16xf32>
// CHECK-DAG:  %[[CONSTANT0:.*]] = arith.constant dense<[3, 0, 1, 2]> : tensor<4xi32>
// CHECK-DAG:  %[[CONSTANT1:.*]] = arith.constant dense<[{{\[}}0, 0], [1, 1], [1, 1], [0, 0]]> : tensor<4x2xi32>

func keyVal(x constant.Value) interface{} {
	switch x.Kind() {
	case constant.Complex:
		f := constant.ToFloat(x)
		if f.Kind() != constant.Float {
			r, _ := constant.Float64Val(constant.Real(x))
			i, _ := constant.Float64Val(constant.Imag(x))
			return complex(r, i)
		}
		x = f
		fallthrough
	case constant.Float:
		i := constant.ToInt(x)
		if i.Kind() != constant.Int {

    %cst_0 = stablehlo.constant dense<3> : tensor<1xi32>
    %cst_1 = stablehlo.constant dense<4> : tensor<1xi32>
    %cst_2 = stablehlo.constant dense<2> : tensor<1xi32>
    %cst_3 = stablehlo.constant dense<0.000000e+00> : tensor<f32>
    %cst_4 = stablehlo.constant dense<6.000000e+00> : tensor<f32>

// %1 = // Input tensor r2.
// %2 = stablehlo.constant  // Input 1 inverse scale 1 / s1.
// %3 = stablehlo.constant  // Input 1 zero point z1 (i8).
// %4 = stablehlo.constant  // Input 1 zero point z1 (i32).
// %5 = stablehlo.constant  // Input 2 inverse scale 1 / s2.
// %6 = stablehlo.constant  // Input 2 zero point z2 (i8).
// %7 = stablehlo.constant  // Input 2 zero point z2 (i32).

  %cst = arith.constant dense<25.4> : tensor<2x3xf32>
  func.return %cst : tensor<2x3xf32>

// CHECK-NEXT:  %[[cst:.*]] = arith.constant dense<2.540000e+01> : tensor<2x3xf32>
// CHECK-NEXT:  "tfl.quantize"(%[[cst]]) <{qtype = tensor<2x3x!quant.uniform<u8:f32, 0.099607841641295186>>}> {volatile}
}

// CHECK-LABEL: QuantizePositiveScalar
func.func @QuantizePositiveScalar() -> tensor<f32> {
  %cst = arith.constant dense<2.54> : tensor<f32>

// If we see a binary op (add, sub) op adding a constant value to a convolution
// op with constant bias, we can fuse the binary op into the convolution op by
// constant folding the bias and the binary op's constant operand. The following
// pattern restricts to float constant values for now.
multiclass FuseBinaryOpToPrecedingAffine<Op binaryOp> {
  def FuseBinaryOpWithConv#binaryOp : Pat<

      %cst_4 = arith.constant dense<[0, 0, 1, 1, 1]> : tensor<5xi32>
      %cst_5 = arith.constant dense<[0, 1, 0, 1, 1]> : tensor<5xi32>
      %cst_6 = arith.constant dense<2> : tensor<i32>
      %cst_7 = arith.constant dense<"*"> : tensor<!tf_type.string>
      %cst_8 = arith.constant dense<-1> : tensor<1xi32>
      %cst_9 = arith.constant dense<-1> : tensor<i32>

  // CHECK-NEXT: %[[CONST:.*]] = "tf.Const"()
  %constant = "tf.Const"() {value = dense<0.0> : tensor<4xf32>} : () -> tensor<4xf32>
  "tf.AssignVariableOp"(%arg0, %constant) : (tensor<*x!tf_type.resource<tensor<4xf32>>>, tensor<4xf32>) -> ()
  // CHECK-NEXT: return %[[CONST]], %[[CONST]]
  func.return %arg0, %constant : tensor<*x!tf_type.resource<tensor<4xf32>>>, tensor<4xf32>
}

   *                            8
   */

  // Constant matcher factory methods

  /**
   * Matches any character.
   *
   * @since 19.0 (since 1.0 as constant {@code ANY})
   */
  public static CharMatcher any() {
    return Any.INSTANCE;
  }

  /**
   * Matches no characters.
   *
   * @since 19.0 (since 1.0 as constant {@code NONE})
   */
  public static CharMatcher none() {

          'to _ATTRIBUTE_RENAMES.')
    if cst_ty == TFRTypes.ATTR:
      self._emit_with_loc('\n{} = tfr.constant {} -> {}'.format(
          name, cst_val, cst_ty))
    elif cst_ty == TFRTypes.I1:
      self._emit_with_loc('\n{} = arith.constant {}'.format(name, cst_val))
    else:
      self._emit_with_loc('\n{} = arith.constant {} : {}'.format(
          name, cst_val, cst_ty))
    return name, cst_ty