auto func = getOperation();

  // The pattern includes
  // - Converting XlaDotV2Op to EinsumOp
  // - Converting XlaGatherOp to SliceOp
  RewritePatternSet patterns(ctx);
  populateWithGenerated(patterns);

  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    func.emitError() << "quant-converting-tf-xla-op-to-tf-op failed.";
    signalPassFailure();
  }
}

                      "all can be supported."
                   << "\n";
      return;
    }
    RewritePatternSet patterns(&getContext());
    populateWithGenerated(patterns);
    patterns.add<ConvertTensorListPopBack>(&getContext());
    patterns.add<ConvertTensorListPushBack>(&getContext());
    patterns.add<ConvertVariantAddNOp>(&getContext());

void PreprocessOpPass::runOnOperation() {
  MLIRContext* ctx = &getContext();
  RewritePatternSet patterns(ctx);
  ModuleOp module_op = getOperation();

  populateWithGenerated(patterns);
  patterns.add<PreprocessConstantOp>(ctx, op_set_, quantization_method_,
                                     enable_per_channel_quantization_);
  FrozenRewritePatternSet frozen_patterns(std::move(patterns));

  auto func = getOperation();

  // The pattern includes decomposing batch normalization ops, fusing add/mul
  // with a constant operand to a preceding affine operation.
  RewritePatternSet patterns(ctx);
  populateWithGenerated(patterns);
  patterns.add<RemoveIdentity, ConstantFoldQuantizableOperands>(ctx);
  if (op_set_ != OpSet::XLA) {
    // Convert Einsum into BatchMatMul for non-XLA opsets.

void LiftQuantizableSpotsAsFunctionsPass::runOnOperation() {
  MLIRContext* ctx = &getContext();
  RewritePatternSet patterns(ctx);
  ModuleOp module = getOperation();

  populateWithGenerated(patterns);
  patterns.add<CheckQuantizableOps>(ctx, quant_options_);
  FrozenRewritePatternSet frozen_patterns(std::move(patterns));

  // Iterate over the sorted list of functions to keep the order deterministic.

  if (mode_.empty()) return;

  func::FuncOp func = getOperation();
  MLIRContext *ctx = &getContext();

  // Convert binary ops to BiasAdd ops if possible.
  RewritePatternSet patterns(ctx);
  populateWithGenerated(patterns);
  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));

  // Convert unsupported ops to Flex ops.
  auto tf_dialect = ctx->getLoadedDialect<TF::TensorFlowDialect>();

#include "tensorflow/compiler/mlir/tfr/passes/generated_decompose.inc"

void DecomposeTFOpsPass::ApplyCanonicalization() {
  func::FuncOp func = getOperation();
  RewritePatternSet patterns(&getContext());

  populateWithGenerated(patterns);
  populateCanonicalizationPatterns(func, patterns);

  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
}

LogicalResult DecomposeTFOpsPass::RewriteUnregisteredTFOps() {

      !quant_specs_.disable_infer_tensor_range;

  // During the legalization, unsigned quantized type is used, so we have to
  // convert all of them to signed.
  RewritePatternSet patterns(ctx);
  populateWithGenerated(patterns);
  patterns.add<quant::ConvertUnsignedToSigned<quantfork::QuantizeCastOp>>(ctx);
  // Convert quant stats to int8 quantization parameters.

  patterns.add<ConvertTFDilatedConvOp<TF::Conv2DOp>, FusedBatchNormV3Pat,
               ConvertTFDilatedConvOp<TF::DepthwiseConv2dNativeOp>>(ctx);

  patterns.add<RemoveIdentity>(ctx);
  TFL::populateWithGenerated(patterns);
  // TODO(fengliuai): Implement similar rule in the QuantizePass if the constant
  // folding hook of tfl.transpose and tfl.reshape are implemented.
  patterns.add<ReorderFakeQuantPattern<TF::ReshapeOp>,

                 bool preserve_assert_op) {
  // Add TF->TF lowering patterns.
  TF::PopulateLoweringTFPatterns(context, &patterns);

  // Add the generated patterns to the list.
  populateWithGenerated(patterns);
  patterns.add<ConvertTFConcatV2Op, ConvertTFBatchMatMulOp,
               ConvertTFBatchMatMulV2Op, ConvertTFBatchMatMulV3Op,
               ConvertTFMatMulOp, ConvertTFMatrixDiagV2Op,