func.func @splat_scalar_no_change() -> (tensor<f32>, tensor<i32>) {
  // CHECK-NOT: mhlo.broadcast_in_dim
  %cst0 = mhlo.constant dense<0.000000e+00> : tensor<f32>
  %cst1 = mhlo.constant dense<0> : tensor<i32>
  func.return %cst0, %cst1 : tensor<f32>, tensor<i32>

  // CHECK-DAG: %[[CST1:.*]] = arith.constant dense<1> : tensor<4xi32>
  // CHECK-DAG: %[[cst_1:.*]] = arith.constant dense<[1, 2, 3, 1]> : tensor<4xi32>
  // CHECK: %0 = "tf.Reshape"(%arg0, %[[cst_1]]) : (tensor<2x3xf32>, tensor<4xi32>) -> tensor<1x2x3x1xf32>

    // CHECK: %[[CST0:.*]] = stablehlo.constant dense<0xFF800000> : tensor<f32>
    // CHECK: %[[CST1:.*]] = stablehlo.constant dense<0xFF80000E> : tensor<2x3x1024x3xf32>
    // CHECK: %[[Q0:.*]] = "quantfork.qcast"(%[[CST0]])
    // CHECK: %[[Q1:.*]] = "quantfork.qcast"(%[[CST1]])
    // CHECK: %[[Q2:.*]] = "quantfork.qcast"(%[[ARG0]])
    // CHECK: %[[CALL:.*]] = call @quantized_dot_general_fn_1(%[[Q2]], %[[Q1]])

// C0 should be first.
const C0 = 0

// V1 should be second.
var V1 uint

// V0 should be first.
var V0 uintptr

// CAx constants should appear after CBx constants.
const (
	CA2 = iota // before CA1
	CA1        // before CA0
	CA0        // at end
)

// VAx variables should appear after VBx variables.
var (
	VA2 int // before VA1
	VA1 int // before VA0
	VA0 int // at end
)

// T1 should be second.

  %cst0 = arith.constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf32>
  %cst1 = arith.constant dense<2.0> : tensor<2xf32>
  %cst2 = arith.constant dense<[1.0, 2.0]> : tensor<2xf32>

  %cst1 = "tfl.pseudo_const" () {value = dense<0.0> : tensor<1x4xf32>} : () -> tensor<1x4xf32> loc("Const")

	const (
		CB2	= iota	// before CB1
		CB1		// before CB0
		CB0		// at end
	)

	// CAx constants should appear after CBx constants. 
	const (
		CA2	= iota	// before CA1
		CA1		// before CA0
		CA0		// at end
	)

	// C0 should be first. 
	const C0 = 0

	// C1 should be second. 
	const C1 = 1

	// C2 should be third. 
	const C2 = 2

	// 
	const (

func.func @mixed_no_constant_folding() -> (tensor<f32>) {
  // CHECK:      %[[CST0:.+]] = arith.constant dense<0.000000e+00>
  // CHECK-NEXT: %[[CST1:.+]] = arith.constant dense<0.000000e+00>
  // CHECK-NEXT: "vhlo.add_v1"(%[[CST0]], %[[CST1]]) : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %cst_0 = arith.constant dense<0.000000e+00> : tensor<f32>
  %cst_1 = arith.constant dense<0.000000e+00> : tensor<f32>

// This pattern optimizes:
//   (x + cst1) + cst2 -> x + cst
//   (x - cst1) - cst2 -> x - cst
// Where: cst = cst1 + cst2
foreach BinaryOp = [TF_AddV2Op, TF_SubOp] in {
  def OptimizeConsecutive#BinaryOp : Pat<
    (BinaryOp
      (BinaryOp $x, (TF_ConstOp:$cst1 $cst1_value)),
      (TF_ConstOp:$cst2 $cst2_value)),
    (BinaryOp
      $x, (TF_AddV2Op $cst1, $cst2))>;
}

// This pattern optimizes:

          [(ValueEquals<"0.0"> $cst),
           (ValueEquals<"0.0"> $cst1),
           (ValueEquals<"0.0"> $cst2),
           (SameValue $rem, $rem1),
           (SameValue $rem, $rem2),
           (SameValue $rem, $rem3),
           (SameTypeOrDefaultCompare $compare_type, $cst),
           (SameTypeOrDefaultCompare $compare_type1, $cst1)]>;

// Converts a dag of HLOs representing floor_mod with a constant to