registry.insert<TF::TensorFlowDialect>();
  }
  void runOnOperation() override;
};

void DeviceTransformNNAPIPass::runOnOperation() {
  auto func = getOperation();
  auto* ctx = &getContext();
  NNAPIHardware nnapi_hardware;
  RewritePatternSet patterns = nnapi_hardware.GetTransformations(ctx);
  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
}

 public:
  void runOnOperation() override;
};

void InputMetricsLoweringPass::runOnOperation() {
  bool has_dynamic_op = false;
  Operation* func_op = getOperation();

  func_op->walk([&](Operation* op) {
    auto abstractOp = op->getRegisteredInfo();
    if (!abstractOp) return WalkResult::advance();

    if (mlir::mhlo::IsDynamicPadderOp(abstractOp->getTypeID())) {

      if (failed(layout)) return;

      op->setAttr("layout", layout.value());
    }
  }
};

void InfeedsOpsXlaAdjustLayout::runOnOperation() {
  getOperation().walk(runOnInfeedOp);
}

}  // anonymous namespace

std::unique_ptr<mlir::OperationPass<func::FuncOp>>
CreateInfeedsOpsXlaAdjustLayoutPass() {
  return std::make_unique<InfeedsOpsXlaAdjustLayout>();
}

    auto fail = [&](Operation* op, std::string message) {
      op->emitError(message);
      signalPassFailure();
    };

    DenseMap<StringRef, func::FuncOp> entrypoints;
    auto module = getOperation();
    module.walk([&](func::FuncOp op) {
      auto visibility = SymbolTable::getSymbolVisibility(op);
      if (visibility != SymbolTable::Visibility::Public) return;
      entrypoints[op.getSymName()] = op;
    });

  }
  return std::move(tail_assign_variable_ops);
}

void HoistReplicateInvariantResourceWritesPass::runOnOperation() {
  SmallVector<tf_device::ReplicateOp, 2> replicate_ops;
  getOperation().walk([&](tf_device::ReplicateOp replicate_op) {
    replicate_ops.push_back(replicate_op);
  });
  for (auto replicate_op : replicate_ops) {
    SmallVector<TF::AssignVariableOp> tail_writes =

           "storage types.";
  }
  void runOnOperation() override;
};

void RewriteQuantizedIOPass::runOnOperation() {
  ModuleOp module = getOperation();
  OpBuilder builder(module);
  module.walk([&](func::FuncOp func) {
    Block& block = func.front();
    Operation* terminator = block.getTerminator();

    // Replace input_arg(tensor<quant_type>) -> tfr.cast

  cluster_func_op.replaceAllUsesWith(xla_launch_op.getResults());
  cluster_func_op.erase();
}

void XlaRewritePass::runOnOperation() {
  ModuleOp module = getOperation();
  SymbolTable symtab(module);
  OpBuilder builder(&getContext());
  module.walk([&](tf_device::ClusterFuncOp cluster_func_op) {
    RewriteCall(cluster_func_op, symtab, builder);
  });
}

}  // namespace

    ConversionTarget target(getContext());
    target.addIllegalOp<TF::ResizeBilinearOp, TF::ResizeNearestNeighborOp>();
    target.addLegalDialect<mlir::stablehlo::StablehloDialect>();
    if (failed(applyPartialConversion(getOperation(), target,
                                      std::move(patterns)))) {
      signalPassFailure();
    }
  }
};

std::unique_ptr<Pass> CreateSmuggleDisallowedOpsPass() {

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTFToStablehloPass)

 private:
  void runOnOperation() override;
};

void TestTFToStablehloPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext* ctx = &getContext();
  mlir::PassManager pm(ctx);

  AddTFToStablehloPasses(pm);
  if (!RunPassesOnModuleOp(
           /*mlir_dump_file_name=*/"test_tf_to_stablehlo_pass", pm, module_op)

    registry.insert<TF::TensorFlowDialect>();
  }
  void runOnOperation() override;
};

void DeviceTransformGPUPass::runOnOperation() {
  auto func = getOperation();
  auto* ctx = &getContext();
  RewritePatternSet patterns = GetHardwareRewritePatternsGPU(ctx);
  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
}

}  // namespace