};

static PassRegistration<QuantizeWeightsPass> pass;

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

  patterns.add<QuantizeConstWeights>(ctx, quant_options_);

  FrozenRewritePatternSet frozen_patterns(std::move(patterns));

  return target_opset_ == OpSet::XLA &&
         (quant_specs_.weight_only_quantization ||
          quant_specs_.weight_quantization);
}

void QuantizePass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  auto func = getOperation();
  auto* ctx = func.getContext();

  quant_specs_.weight_quantization = weight_quantization_;
  const QuantPassSpec quant_params = {

        rewriter.cancelOpModification(caller);
      }
    }
    return success();
  }
};

void DecomposeOptionalsPass::runOnOperation() {
  mlir::ModuleOp module = getOperation();

  RewritePatternSet pattern_list(&getContext());
  pattern_list.add<HandleOptionalFrom>(&getContext());
  pattern_list.add<HandleOptionalGet>(&getContext());
  pattern_list.add<HandleOptionalNone>(&getContext());

                                           cast_op);
    return success();
  }
};

void BroadcastToOp::getCanonicalizationPatterns(RewritePatternSet& results,
                                                MLIRContext* context) {
  results.add<ConvertBroadcastToReshape>(context);
}

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OutlineCompositesPass)

  void runOnOperation() override {
    auto func = getOperation();
    RewritePatternSet patterns(&getContext());
    patterns.add<OutlineGELU>(&getContext());
    if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
      signalPassFailure();
    }
  }
};

  }
};

void InsertWeightParamPass::runOnOperation() {
  func::FuncOp func = getOperation();
  MLIRContext* context = func.getContext();
  RewritePatternSet patterns(context);

  patterns.add<InsertWeightParamPattern>(context);

  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    signalPassFailure();
  }
}

}  // namespace

#include "tensorflow/compiler/mlir/lite/transforms/generated_optimize_batch_matmul.inc"

void OptimizeBatchMatmulPass::runOnOperation() {
  auto func = getOperation();
  auto* ctx = &getContext();

  RewritePatternSet patterns(ctx);
  patterns.add<ConvertBatchMatMulOp2FullyConnectedOp,
               ConvertBatchMatMulOpToReduceSum>(ctx);
  TFL::populateWithGenerated(patterns);

                    quant::QuantizationDialect, shape::ShapeDialect>();
  }

  void runOnOperation() override {
    ModuleOp module_op = getOperation();
    RewritePatternSet patterns(&getContext());
    patterns.add<ConvertTFXlaCallModuleOp>(&getContext(), module_op);
    patterns.add<RemoveCustomCallWithSharding>(&getContext());

      llvm::errs() << "Tried legalizing to tfl custom tensorlist ops, but not "
                      "all can be supported."
                   << "\n";
      return;
    }
    RewritePatternSet patterns(&getContext());
    populateWithGenerated(patterns);
    patterns.add<ConvertTensorListPopBack>(&getContext());
    patterns.add<ConvertTensorListPushBack>(&getContext());

};

#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/preprocess_op.inc"

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

  populateWithGenerated(patterns);
  patterns.add<PreprocessConstantOp>(ctx, op_set_, quantization_method_,