// Hoist coefficient-wise binary operation out of the Concat op:
//
//   %0 = tf.Mul(%lhs_0, %rhs_0)
//   %1 = tf.Mul(%lhs_1, %rhs_1)
//   ...
//   %n = tf.Mul(%lhs_n, %rhs_n)
//   %m = tf.ConcatV2(%0, %1, ..., %n, %axis)
//
// Rewrite it to:
//
//   %0 = tf.ConcatV2(%lhs0, %lhs1, ..., %lhs_n, %lhs_concat_axis)
//   %1 = tf.ConcatV2(%rhs0, %rhs1, ..., %rhs_n, %rhs_concat_axis)
//   %2 = tf.Mul(%0, %1)
//

// dimensions must be equal to be compatible) and identical element types.
bool VerifyCompatibleShapesSameElementType(TypeRange lhs, TypeRange rhs) {
  if (lhs.size() != rhs.size() || lhs.size() != 1) return false;
  if (failed(mlir::verifyCompatibleShape(lhs[0], rhs[0]))) return false;
  auto lhsShaped = lhs[0].cast<ShapedType>();
  auto rhsShaped = rhs[0].cast<ShapedType>();
  return lhsShaped.getElementType() == rhsShaped.getElementType();

  %0 = "tf.BatchMatMul"(%lhs, %rhs) : (tensor<1x3x5xf32>, tensor<2x5x7xf32>) -> tensor<2x3x7xf32>
}

// -----

func.func @testBatchMatMulV2(%lhs: tensor<f32>, %rhs: tensor<10x10xf32>) {
  // expected-error @+1 {{requires lhs operand to have rank at least two}}
  %0 = "tf.BatchMatMulV2"(%lhs, %rhs) : (tensor<f32>, tensor<10x10xf32>) -> tensor<10x10xf32>

  OpBuilder<(ins "Value":$lhs, "Value":$rhs,
    "StringAttr":$fusedActivationFunction),
  [{
    buildFusedBroadcastableBinOp(
       &$_builder, $_state, lhs, rhs, fusedActivationFunction);
  }]>;

def TFL_ComparisonBinaryBuilder :
  OpBuilder<(ins "Value":$lhs, "Value":$rhs),
  [{
    buildComparisonBinOp(&$_builder, $_state, lhs, rhs);
  }]>;

//
// In case of inconsistencies (rank disagreement for example), it returns `lhs`.
Type TypeMeet(Type lhs, Type rhs) {
  DCOMMENT("RefineTypeWith : " << lhs << " : " << rhs);
  if (lhs == rhs) return lhs;

  auto rhs_shape_type = mlir::dyn_cast<ShapedType>(rhs);
  if (!rhs_shape_type) return lhs;
  auto lhs_shape_type = mlir::cast<ShapedType>(lhs);
  if (lhs_shape_type.hasRank() && rhs_shape_type.hasRank() &&

, anyOf(startsWith("foo"), containsString("Val"))) both public static <LHS> CombinableMatcher.CombinableBothMatche<LHS> both(Matcher<? super LHS> matcher) Creates a matcher that matches when both of the specified matchers match the examined object. For example: assertThat("fab", both(containsString("a")).and(containsString("b"))) either public static <LHS> CombinableMatcher.CombinableEitherMatc<LHS> either(Matcher<? super LHS> matcher) Creates a matcher that matches when either of the specified matchers...

    // expected-error @below {{'tf.XlaConvV2' op Expected the size of kernel_input_features (value 16) in rhs times feature_group_count (value 2) in lhs should equal the size of the z dimension (value 16) in lhs.}}

        fc_op.getAsymmetricQuantizeInputsAttr());
    rewriter.replaceOp(add_op, fc.getOutput());

    return success();
  }
};

// Replace ..
// FC(Add(lhs, rhs), filter, bias)
// .. with ..
// FC(lhs, filter, FC(rhs, filter, bias))
// .. if rhs, filter, and bias are all constants.
// The second FC will be constant folded to a single vector.

                    int input_channels,
                    ConversionPatternRewriter& rewriter) const {
    mhlo::ConvDimensionNumbersAttr dnums = conv_op.getDimensionNumbers();
    // Transposes lhs and rhs if their formats are not NHWC.
    Value lhs = InsertTranspose(
        conv_op.getLhs(), dnums.getInputBatchDimension(),
        dnums.getInputFeatureDimension(), dnums.getInputSpatialDimensions(),

    : public OpRewritePattern<stablehlo::DotGeneralOp> {
 public:
  using OpRewritePattern<stablehlo::DotGeneralOp>::OpRewritePattern;

  LogicalResult match(stablehlo::DotGeneralOp op) const override {
    // Lhs and result should not be quantized and rhs should be quantized.
    return success(!IsQuantizedTensorType(op->getOperand(0).getType()) &&
                   IsQuantizedTensorType(op->getOperand(1).getType()) &&