void getDependentDialects(DialectRegistry &registry) const override {
    registry.insert<TFL::TensorFlowLiteDialect, TF::TensorFlowDialect>();
  }
  void runOnOperation() override;
};

LogicalResult FindImplicityProducers(
    const std::vector<uint64_t> &explicitly_consumed_ids,
    std::vector<bool> &is_consumed_id,
    const std::vector<std::vector<uint64_t>> &dependency_graph) {

  }

  void getDependentDialects(DialectRegistry &registry) const override {
    registry.insert<TF::TensorFlowDialect>();
  }

  void runOnOperation() override;

 private:
  enum TestCase {
    TEST_CASE_MIN_MAX,
    TEST_CASE_AVERAGE_MIN_MAX,
    TEST_CASE_HISTOGRAM_PERCENTILE,
    TEST_CASE_HISTOGRAM_MSE_BRUTEFORCE,

class PrepareTpuComputationForTfExportPass
    : public impl::PrepareTpuComputationForTfExportPassBase<
          PrepareTpuComputationForTfExportPass> {
  void runOnOperation() override;
};

class RewriteXlaHostComputeMlir
    : public OpRewritePattern<TF::_XlaHostComputeMlirOp> {
 public:
  using OpRewritePattern<TF::_XlaHostComputeMlirOp>::OpRewritePattern;

 public:
  explicit ClusterConstantSinkingPass(
      llvm::function_ref<bool(tf_device::ClusterOp, ElementsAttr)> filter)
      : filter_(filter) {}

  void runOnOperation() override {
    getOperation().walk([filter = filter_](tf_device::ClusterOp cluster) {
      LLVM_DEBUG(llvm::dbgs() << "Visit " << *cluster.getOperation() << "\n");

// of callees which is difficult if callees have multiple uses.
class GuaranteeAllFuncsOneUse
    : public impl::GuaranteeAllFuncsOneUsePassBase<GuaranteeAllFuncsOneUse> {
 public:
  void runOnOperation() override {
    if (failed(Run())) {
      signalPassFailure();
    }
  }

  LogicalResult Run() {
    auto module = getOperation();

    // Overall strategy:

#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

struct FunctionalControlFlowToCFG
    : public impl::FunctionalControlFlowToCFGPassBase<
          FunctionalControlFlowToCFG> {
  void runOnOperation() override;
};

// Lowers a general tensor argument that is used as a condition to a functional
// control flow op into an i1 value.
static Value LowerCondition(Location loc, Value value, OpBuilder* builder) {

    return success();
  }
};

struct ConvertTFQuantTypes
    : public impl::ConvertTFQuantTypesBase<ConvertTFQuantTypes> {
  void runOnOperation() override;
};

void ConvertTFQuantTypes::runOnOperation() {
  TFQuantTypeConverter converter;
  RewritePatternSet patterns(&getContext());
  patterns.add<TFQuantTypePattern>(&getContext(), converter);

// arguments and adding "device" attribute to TF ops.
struct ResourceDeviceInference
    : public impl::ResourceDeviceInferencePassBase<ResourceDeviceInference> {
  void runOnOperation() override;
};

// A class that records each resource's device assignment in a function.
class PerFunctionResult {
 public:
  explicit PerFunctionResult(
      func::FuncOp func_op,

  }

  StringRef getArgument() const override { return "quant-unfreeze-constants"; }

  StringRef getDescription() const override {
    return "Unfreeze large constants.";
  }

  void runOnOperation() override;

 private:
  Option<int64_t> CreateSizeThresholdInBytesOption(const int64_t init_value) {
    return Option<int64_t>(
        *this, "size_threshold_in_bytes", llvm::cl::init(init_value),

 public:
  FallbackToFlexOps() = default;
  explicit FallbackToFlexOps(const std::string &mode) { mode_ = mode; }
  FallbackToFlexOps(const FallbackToFlexOps &other) { mode_ = other.mode_; }

  void runOnOperation() override;

  StringRef getArgument() const final { return "quant-raise-flex-fallback"; }

  StringRef getDescription() const final {
    return "Fallback TF-Quantization-unsupported ops to TFLite Flex ops.";