}
		return
	}

	rhs, commaOk := check.multiExpr(orig_rhs[0], l == 2)
	r = len(rhs)
	if l == r {
		for i, lhs := range lhs {
			check.assignVar(lhs, nil, rhs[i], "assignment")
		}
		// Only record comma-ok expression if both assignments succeeded
		// (go.dev/issue/59371).
		if commaOk && rhs[0].mode != invalid && rhs[1].mode != invalid {
			check.recordCommaOkTypes(orig_rhs[0], rhs)
		}
		return
	}

// RUN: stablehlo-quant-opt -optimize-int-graph -split-input-file %s -verify-diagnostics | FileCheck %s

// CHECK-LABEL: func @convolution_add_add
func.func @convolution_add_add(
    %lhs: tensor<?x3x2x1xi8>, %rhs: tensor<2x1x1x1xi8>,
    %zp_offset: tensor<?x2x2x1xi32>, %bias: tensor<1xi32>
  ) -> tensor<?x2x2x1xi32> {
  // CHECK-DAG: %[[conv:.*]] = mhlo.convolution
  // CHECK-DAG: %[[combined:.*]] = chlo.broadcast_add %[[zp_offset:.*]], %[[bias:.*]]

def LiftDotGeneralWithBiasSameShape : Pat<
  (StableHLO_AddOp:$res
    (StableHLO_DotGeneralOp
        $lhs, $rhs, $dot_dimension_numbers, $precision_config),
    $bias),
  (LiftAsTFXlaCallModule<"composite_dot_general_with_bias_same_shape_fn">
    (ArgumentList $lhs, $rhs, $bias),
    (ResultList $res),
    (NamedAttributeList
      (NamedAttr<"dot_dimension_numbers"> $dot_dimension_numbers),

		}
		return
	}

	rhs, commaOk := check.multiExpr(orig_rhs[0], l == 2)
	r = len(rhs)
	if l == r {
		for i, lhs := range lhs {
			check.assignVar(lhs, nil, rhs[i], "assignment")
		}
		// Only record comma-ok expression if both assignments succeeded
		// (go.dev/issue/59371).
		if commaOk && rhs[0].mode != invalid && rhs[1].mode != invalid {
			check.recordCommaOkTypes(orig_rhs[0], rhs)
		}
		return
	}

		name  string
		lhs   ref.Val
		rhs   ref.Val
		equal bool
	}{
		{
			name: "map lists are equal regardless of order",
			lhs: UnstructuredToVal([]interface{}{
				map[string]interface{}{
					"key": "a",
					"val": 1,
				},
				map[string]interface{}{
					"key": "b",
					"val": 2,
				},
			}, &mapListSchema),
			rhs: UnstructuredToVal([]interface{}{

  llvm::StringRef lhs;
  llvm::StringRef rhs;
  std::tie(lhs, rhs) = lhs_rhs.split(',');
  if (lhs.empty() || rhs.empty()) return std::nullopt;

  // Try to flatten the "..." if possible.
  int lhs_named_label, rhs_named_label;
  auto available_labels =
      GetAvailableLabels(lhs, rhs, &lhs_named_label, &rhs_named_label);
  if (!available_labels.has_value()) return std::nullopt;

		name  string
		lhs   ref.Val
		rhs   ref.Val
		equal bool
	}{
		{
			name: "map lists are equal regardless of order",
			lhs: UnstructuredToVal([]interface{}{
				map[string]interface{}{
					"key": "a",
					"val": 1,
				},
				map[string]interface{}{
					"key": "b",
					"val": 2,
				},
			}, mapListSchema),
			rhs: UnstructuredToVal([]interface{}{
				map[string]interface{}{

            LocalValue [indexes: 0..9, line/column: 1/1..1/10, file: test] (
                name = a
                rhs = IntLiteral [indexes: 8..9, line/column: 1/9..1/10, file: test] (1)
            )
            LocalValue [indexes: 10..19, line/column: 2/1..2/10, file: test] (
                name = b
                rhs = IntLiteral [indexes: 18..19, line/column: 2/9..2/10, file: test] (2)
            )
            ErroneousStatement (

                    )
                    rhs = IntLiteral [indexes: 4..5, line/column: 1/5..1/6, file: test] (1)
                )
                Assignment [indexes: 6..16, line/column: 2/1..2/11, file: test] (
                    lhs = PropertyAccess [indexes: 6..7, line/column: 2/1..2/2, file: test] (
                        name = b
                    )

def LegalizeMul : Pat<(TF_MulOp $lhs, $rhs),
                      (TFL_MulOp $lhs, $rhs, TFL_AF_None)>;
def LegalizeRealDiv : Pat<(TF_RealDivOp $lhs, $rhs),
                          (TFL_DivOp $lhs, $rhs, TFL_AF_None)>;
def LegalizeDiv : Pat<(TF_DivOp $lhs, $rhs),
                      (TFL_DivOp $lhs, $rhs, TFL_AF_None)>;

// When batch size is known, TF BatchMatMul gets unfolded to TFL FullyConnected