%cst_3 = arith.constant dense<1.0> : tensor<20x20xf32>
    %cst_7 = arith.constant dense<1.0> : tensor<20xf32>
    %recurrent_input = arith.constant dense<1.0> : tensor<1x20xf32>
    %recurrent_stats = "quantfork.stats"(%recurrent_input) {layerStats = dense<[-2.0, 1.0]> : tensor<2xf32>} : (tensor<1x20xf32>) -> tensor<1x20xf32>
    %cell_input = arith.constant dense<1.0> : tensor<1x20xf32>

// Issue #42732.

const a = 1e+500000000
const b = a * a // ERROR "constant multiplication overflow|not representable"
const c = b * b

const MaxInt512 = (1<<256 - 1) * (1<<256 + 1)
const _ = MaxInt512 + 1  // ERROR "constant addition overflow"
const _ = MaxInt512 ^ -1 // ERROR "constant bitwise XOR overflow"

	floatOne   = constant.ToFloat(intOne)
	complexOne = constant.ToComplex(intOne)
)

const (
	// Maximum size in bits for big.Ints before signaling
	// overflow and also mantissa precision for big.Floats.
	ConstPrec = 512
)

func BigFloat(v constant.Value) *big.Float {
	f := new(big.Float)
	f.SetPrec(ConstPrec)
	switch u := constant.Val(v).(type) {
	case int64:
		f.SetInt64(u)
	case *big.Int:

// CHECK-LABEL: @fuseMulIntoConv2d
func.func @fuseMulIntoConv2d(%arg0: tensor<1x112x112x3xf32>) -> tensor<1x28x23x2xf32> {
  %cst0 = arith.constant dense<[[[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], [[7.0, 8.0], [9.0, 10.0], [11.0, 12.0]], [[13.0, 14.0], [15.0, 16.0], [17.0, 18.0]]]]> : tensor<1x3x3x2xf32>
  %cst2 = arith.constant dense<[1.0, 2.0]> : tensor<2xf32>

// CHECK-SAME: %[[ARG:.+]]: tensor<1x2x5x5xf32>
func.func @nchw_conv_with_bias_add_max_pool(%arg0: tensor<1x2x5x5xf32>) -> tensor<1x4x2x2xf32> {
  %0 = stablehlo.constant dense<2.000000e+00> : tensor<4x2x3x3xf32>
  %1 = stablehlo.constant dense<3.000000e+00> : tensor<1x4x5x5xf32>
  %5 = stablehlo.constant dense<0xFF800000> : tensor<f32>  // -inf

func tocplx(v constant.Value) constant.Value {
	return constant.ToComplex(v)
}

func toflt(v constant.Value) constant.Value {
	if v.Kind() == constant.Complex {
		v = constant.Real(v)
	}

	return constant.ToFloat(v)
}

func toint(v constant.Value) constant.Value {
	if v.Kind() == constant.Complex {
		v = constant.Real(v)
	}

	if v := constant.ToInt(v); v.Kind() == constant.Int {
		return v
	}

// CHECK: func @empty
// CHECK-NOT: call
// -----

func.func @only_top_level() -> (i32, i32, i32, i32) {
  %0 = "glue.constant"() { value = 0: i32 } : () -> i32
  %1 = "glue.constant"() { value = 1: i32 } : () -> i32
  %2 = "glue.constant"() { value = 2: i32 } : () -> i32
  %3 = "glue.constant"() { value = 3: i32 } : () -> i32
  func.return %0, %1, %2, %3: i32, i32, i32, i32
}

// CHECK: func @only_top_level

// CHECK-LABEL: einsum_with_runtime_outputshape1
// CHECK-DAG: %[[cst:.*]] = arith.constant dense<[0, 1, 3, 2]> : tensor<4xi32>
// CHECK-DAG: %[[cst_0:.*]] = arith.constant dense<[-1, 36, 1, 32]> : tensor<4xi64>
// CHECK-DAG: %[[cst_1:.*]] = arith.constant dense<[0, 1]> : tensor<2xi32>
// CHECK-DAG: %[[cst_2:.*]] = arith.constant dense<2> : tensor<1xi32>

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 = arith.constant dense<0.000000e+00> : tensor<4x2xf32>
  %cst_0 = arith.constant dense<0.000000e+00> : tensor<8xf32>
  %cst_1 = arith.constant dense<[1, 0, 2]> : tensor<3xi32>
  %cst_2 = arith.constant dense<0.000000e+00> : tensor<4x4x2xf32>
  %cst_3 = arith.constant dense<4> : tensor<i32>
  %cst_4 = arith.constant dense<1.000000e+00> : tensor<f32>
  %cst_5 = arith.constant dense<1> : tensor<i32>