#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/optimize_graph.inc"

void OptimizeGraphPass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  populateWithGenerated(patterns);
  auto func = getOperation();
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    signalPassFailure();
  }
}
}  // namespace

 public:
  void runOnOperation() override {
    RewritePatternSet patterns(&getContext());
    mlir::TF::PopulateLoweringQuantizedPatterns(&getContext(), &patterns);
    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
  }
};

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateLowerQuantizedPass() {
  return std::make_unique<LowerQuantizedPass>();
}

}  // namespace TF

    }
    if (pre_hlo_patterns_) {
      mlir::TF::PopulateTFLoweringBeforeHLOPatterns(&getContext(), &patterns);
    }

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

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateTestTFLowerTFPass() {
  return std::make_unique<LowerTF>();
}

}  // namespace tf_test

        replicate_op.GetReplicaOperandForBlockArgument(block_arg,
                                                       /*replica=*/0));
    shape_op.replaceAllUsesWith(new_shape_op.getOperation());
    shape_op.erase();
  }
}

// Checks if op and inner op operands are all replicate invariant.
bool IsOpReplicateInvariant(Region* replicate_region, Operation* op) {

 private:
  std::vector<std::string> accepted_dialects_;
  std::vector<std::string> optional_accepted_dialects_;
};
}  // namespace

void CheckAcceptedOpsPass::runOnOperation() {
  getOperation()->walk([&](Operation *op) {
    auto dialect_name = op->getDialect()->getNamespace();
    auto op_name = op->getName().stripDialect();
    if (IsAcceptedOp(dialect_name, op_name, accepted_dialects_)) {

};

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

void OptimizePass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  populateWithGenerated(patterns);
  auto func = getOperation();
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateOptimizePass() {

  void runOnOperation() override;
};

static PassRegistration<ConvertFakeQuantToQdqPass> pass;

void ConvertFakeQuantToQdqPass::runOnOperation() {
  MLIRContext* ctx = &getContext();
  func::FuncOp func = getOperation();

  if (failed(
          ConvertFakeQuantOps(func, ctx, /*use_fake_quant_num_bits=*/false))) {
    func.emitError() << "quant-convert-fake-quant-to-qdq pass failed.";
    signalPassFailure();
  }

            !isa<tf_device::LaunchOp>(op)) {
          op->removeAttr(kDeviceAttr);
        }
      }
      return WalkResult::advance();
    };

    if (failed(TFTPU::WalkReachableFromTpuCluster(getOperation(), traverse_op)))
      return signalPassFailure();
  }
};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>
CreateTPUClusterCleanupAttributesPass() {

          analyzer.IsPotentiallyWritten(var_handle_op.getResource())));
    }
  });
}

void ResourceAnalyzerTestPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  TF::ResourceAnalyzer resource_analyzer(module_op);

  PrintAnalysisResults(resource_analyzer, module_op);
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateResourceAnalyzerTestPass() {

  // third_party/tensorflow/compiler/mlir/tfrt/transforms/lower_saved_model.cc
  // with the original code trimmed and adapted as needed.
  void runOnOperation() override {
    auto module = getOperation();
    if (!tf_saved_model::HasTfSavedModelSemantics(module)) return;

    // Clean up functions from tf_saved_model attributes.
    OpBuilder builder(module);