// Relevant argument characteristics are checked by the TFL op definition.
  if (func_.getNumArguments() < 5) {
    return func_.emitWarning()
           << "Invalid number of arguments to "
              "non_max_suppression_padded_v2 (need at least 5): "
           << func_.getNumArguments();
  }
  if (func_.getFunctionType().getNumResults() != 2) {

  void RewriteFunction(const SymbolTable& symbol_table, func::FuncOp func) {
    if (func.getNumArguments() == 0) {
      return;
    }

    auto builder = OpBuilder::atBlockBegin(&func.front());

    llvm::SmallDenseMap<llvm::StringRef, TF::ConstOp> const_ops;
    llvm::BitVector arg_indexes_to_remove(func.getNumArguments());

    // Replace arguments with const ops.
    for (BlockArgument argument : func.getArguments()) {

}

LogicalResult ConvertMaxUnpoolingFunc::VerifySignature() {
  // Verify high-level function signature.
  if (func_.getNumArguments() != 2) {
    return func_.emitWarning()
           << "Invalid number of arguments to " << kMaxUnpooling << ": "
           << func_.getNumArguments();
  }
  if (func_.getFunctionType().getNumResults() != 1) {
    return func_.emitWarning()

    global_tensor.erase();
  }
}

void EraseUnusedBoundInputs(ModuleOp module) {
  for (auto func : module.getOps<func::FuncOp>()) {
    llvm::BitVector args_to_erase(func.getNumArguments());
    for (int i = 0, e = func.getNumArguments(); i < e; i++) {
      if (func.getArgAttr(i, "tf_saved_model.bound_input") &&
          func.getArgument(i).use_empty()) {
        args_to_erase.set(i);
      }
    }

// return %1, %5
LogicalResult MatchReduceToArgMinMaxType2(mhlo::ReduceOp reduce_op,
                                          bool is_argmax) {
  Block& body = reduce_op.getBody().front();
  if (body.getNumArguments() != 4) return failure();

  mhlo::ReturnOp return_op = dyn_cast<mhlo::ReturnOp>(body.back());
  if (!return_op || return_op.getNumOperands() != 2) return failure();

    // right away, since they might weave through blocks, but we can replace
    // them with a dummy which DCE can pick up later.
    llvm::BitVector argsToErase(func.getNumArguments());
    for (int i = 0; i < func.getNumArguments(); i++) {
      if (auto global = tf_saved_model::LookupBoundInputOfType<
              tf_saved_model::GlobalTensorOp>(func, i, syms)) {
        OpBuilder builder(func.getBody());

    llvm::BitVector unused_args(func.getNumArguments());
    llvm::BitVector unused_results(func.getNumResults());
    llvm::DenseMap<int, int> return_to_operand;
    llvm::BitVector invariant_returns =
        GetInvariantReturns(region, func.getNumResults());
    llvm::DenseMap<Value, int> argument_to_index;
    std::vector<int> use_count(func.getNumArguments(), 0);

  void runOnOperation() override;
};

void MoveResourceArgsToEnd(func::FuncOp callee) {
  llvm::DenseMap<BlockArgument, BlockArgument> mapping;
  unsigned num_params = callee.getNumArguments();
  llvm::BitVector removed_params(num_params);
  // Copy the resource-type parameters to the end.
  for (unsigned i = 0; i < num_params; ++i) {
    BlockArgument param = callee.getArgument(i);

        input_specs;
    llvm::SmallVector<llvm::StringRef, 4> input_devices;
    llvm::SmallVector<mlir::Operation*, 4> bound_inputs;
    for (unsigned i = 0, e = func.getNumArguments(); i != e; ++i) {
      if (auto input_index_path = func.getArgAttrOfType<mlir::ArrayAttr>(
              i, kTfSavedModelIndexPathAttr)) {
        input_names.push_back(ProcessIndexPath(input_index_path));

    if (shared_name.empty() || !IsHashTableOp(&op)) continue;
    if (!IsResourceInitialized(module_op, &op)) continue;

    auto it =
        shared_name_to_arg_idx.insert({shared_name, block.getNumArguments()});
    if (it.second) {
      auto resource_type = op.getResult(0).getType();
      op.getResult(0).replaceAllUsesWith(
          block.addArgument(resource_type, op.getLoc()));
      AddEntryFunctionInput(