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

struct DecomposeOptionalsPass
    : public impl::DecomposeOptionalsPassBase<DecomposeOptionalsPass> {
  void runOnOperation() override;
};

class HandleOptionalFrom : public OpRewritePattern<TF::OptionalFromValueOp> {
 public:
  using OpRewritePattern::OpRewritePattern;
  LogicalResult matchAndRewrite(TF::OptionalFromValueOp op,

class TFExecutorCheckControlDependencies
    : public impl::ExecutorCheckControlDependenciesPassBase<
          TFExecutorCheckControlDependencies> {
 public:
  void runOnOperation() override;
};

using ResourceIdVec = llvm::SmallVector<std::pair<TF::ResourceId, bool>>;
// MapVector provides both fast lookup and deterministic iteration order.
using IslandToIslandMapVec =

struct TPUResourceReadsWritesPartitioningPass
    : public impl::TPUResourceReadsWritesPartitioningPassBase<
          TPUResourceReadsWritesPartitioningPass> {
  void runOnOperation() override;
};

bool AllResourceTypesHaveSubtypes(TypeRange resources) {
  for (Type resource : resources)
    if (!llvm::hasSingleElement(resource.cast<TensorType>()

    : public impl::ParallelExecuteToIslandsPassBase<
          ParallelExecuteToIslandsPass> {
  explicit ParallelExecuteToIslandsPass(bool legacy_graph_export) {
    legacy_graph_export_ = legacy_graph_export;
  }
  void runOnOperation() override;
};

// Convert parallel_execute op to a set of islands where each region of
// parallel_execute op becomes a separate island. This ensures that the regions

// Removes unused arguments from functions and their callers.
struct RemoveUnusedArgumentsPass
    : public impl::RemoveUnusedArgumentsPassBase<RemoveUnusedArgumentsPass> {
  void runOnOperation() override;
};

// Return a bitvector that marks all return values that always come from
// the same value.
llvm::BitVector GetInvariantReturns(Region* region, int number_of_results) {

  explicit FunctionalControlFlowToRegions(bool allow_passthrough_args)
      : FunctionalControlFlowToRegionsPassBase(
            FunctionalControlFlowToRegionsPassOptions{allow_passthrough_args}) {
  }
  void runOnOperation() override;
};

// Creates a call to function `func` in region `caller_region`. Use `args` as
// the call arguments, and terminate the region with a yield. The arguments are

    return "Smuggle disallowed ops via stablehlo.custom_calls";
  }
  void getDependentDialects(DialectRegistry& registry) const final {
    registry.insert<mlir::stablehlo::StablehloDialect>();
  }

  void runOnOperation() override {
    RewritePatternSet patterns(&getContext());
    patterns.add<SmuggleOpPattern<TF::ResizeBilinearOp>>(&getContext());
    patterns.add<SmuggleOpPattern<TF::ResizeNearestNeighborOp>>(&getContext());

 public:
  using TacPass<func::FuncOp>::TacPass;

  ~TacFunctionPass() override = default;

  mlir::func::FuncOp getFunction() { return getOperation(); }

  virtual void runOnFunction() = 0;

  void runOnOperation() final {
    if (!getFunction().isExternal()) runOnFunction();
  }

 protected:
  // Returns the derived pass name.
  StringRef getName() const override { return llvm::getTypeName<T>(); }

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OptimizeBatchMatmulPass)

  OptimizeBatchMatmulPass() = default;
  OptimizeBatchMatmulPass(const OptimizeBatchMatmulPass &) {}

  void runOnOperation() override;
};

// Converts batch_matmul operation to fully_connected if rhs is a
// constant tensor with rank 2
struct ConvertBatchMatMulOp2FullyConnectedOp
    : public OpRewritePattern<TFL::BatchMatMulOp> {

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InsertWeightParamPass)

  using impl::InsertWeightParamPassBase<
      InsertWeightParamPass>::InsertWeightParamPassBase;

 private:
  void runOnOperation() override;
};

// Inserts quantization parameters for weights for hybrid quantization of
// `stablehlo.convolution` and `stablehlo.dot_general`.
class InsertWeightParamPattern