/*lhsBatchingDimensions=*/{},
          /*rhsBatchingDimensions=*/{},
          /*lhsContractingDimensions=*/{lhs_type.getRank() - 1},
          /*rhsContractingDimensions=*/{0}),
      op.getPrecisionConfigAttr());
  return success();
}

// Convert reshape(dot_general(reshape(%y), %z)) to
// dot_general(%y, %z) if possible.
LogicalResult RemoveReshapeAroundDotGeneral(mhlo::ReshapeOp reshape_after,

        /*dimension_numbers=*/new_dimension_nums,
        /*feature_group_count=*/op.getFeatureGroupCountAttr(),
        /*batch_group_count=*/op.getBatchGroupCountAttr(),
        /*precision_config=*/op.getPrecisionConfigAttr());

    // Transpose the output of the `ConvolutionOp` back to the original op's
    // output shape so that users' shapes match.
    // [b, 0, 1, f] => [b, f, 0, 1]

        conv_op.getWindowReversalAttr(), conv_op.getDimensionNumbers(),
        conv_op.getFeatureGroupCount(), conv_op.getBatchGroupCount(),
        conv_op.getPrecisionConfigAttr());
    // For static case, replace the convolution op now.
    if (!is_dynamic_broadcast) {
      rewriter.replaceOp(mul_op, {new_conv});
    } else {

//===----------------------------------------------------------------------===//

def ToDotDimNumsAttr : NativeCodeCall<"GetDotDimNumsAttr($0, &$_builder)">;

def ToPrecisionConfigsAttr : NativeCodeCall<"GetPrecisionConfigAttr($0, &$_builder)">;

def HasValidDotDims : Constraint<CPred<"HasValidDotDims($0)">>;

def HasValidPrecisionConfig : Constraint<CPred<"HasValidPrecisionConfig($0)">>;

            .clone(output_uniform_quantized_type),
        /*lhs=*/op.getLhs(), /*rhs=*/op.getRhs(),
        /*dot_dimension_numbers=*/op.getDotDimensionNumbers(),
        /*precision_config=*/op.getPrecisionConfigAttr());

    rewriter.replaceAllUsesWith(op.getResult(), new_dot_general_op.getResult());

    auto new_output_dequant_op =
        rewriter.create<stablehlo::UniformDequantizeOp>(

        lhs_dilation_2d, rhs_dilation_2d, window_reversal_2d, dnums_2d,
        conv_op.getFeatureGroupCount(), conv_op.getBatchGroupCount(),
        conv_op.getPrecisionConfigAttr());

    OpResult conv2d_output = conv2d_op->getResult(0);
    auto conv2d_output_type = mlir::cast<ShapedType>(conv2d_output.getType());

    //
    // Transpose and reshape the output
    //

}

bool HasValidPrecisionConfig(StringAttr attr) {
  ::xla::PrecisionConfig precision;
  return precision.ParseFromString(attr.getValue().str());
}

mlir::ArrayAttr GetPrecisionConfigAttr(StringAttr attr, Builder *builder) {
  ::xla::PrecisionConfig precision;
  if (!precision.ParseFromString(attr.getValue().str())) return {};
  return ::xla::ConvertPrecisionConfig(&precision, builder);
}