quantize_output.getType(), loc);
        new_arg = block.addArgument(arg_type, loc);
        quantize_op.setOperand(new_arg);
      } else {
        input_type.print(llvm::errs() << "Requested input type ");
        quantize_op.emitError(" Couldn't be modified to the requested type.");
        return failure();
      }
      new_input_types[i] = arg_type;
      arg.dropAllUses();

                                    bool enable_select_tf_ops) {
  std::string error_msg;
  auto output = mlir::openOutputFile(output_filename, &error_msg);
  if (output == nullptr) {
    llvm::errs() << error_msg << '\n';
    return absl::InvalidArgumentError("cannot open output file.");
  }

  std::string result;
  if (output_mlir) {
    llvm::raw_string_ostream os(result);
    module.print(os);

  auto module = TfToStablehlo(
      input_path, &context, exported_model_signatures_in_vector,
      tag_names_in_vector, input_arg_shapes_str, is_input_mlir_module);
  if (!module.ok()) {
    llvm::errs() << module.status().ToString() << "\n";
    return module.status().raw_code();
  }

  return mlir::ExportModule(module->get()).raw_code();

  // This means this quantizable unit has been explicitly denylisted by the
  // user.
  if (IsDenylistedLiftedFunction(op)) {
    LLVM_DEBUG(llvm::errs() << "Denylisted quantizable unit: \n" << op << "\n");
    return false;
  }

  if (GetStableHloQuantConstraints(op)->has_same_scale_requirement) {
    return true;
  }

  llvm::InitLLVM y(argc, argv);
  llvm::cl::ParseCommandLineOptions(argc, argv);
  auto file_or_err = llvm::MemoryBuffer::getFileOrSTDIN(inputFileName.c_str());
  if (std::error_code error = file_or_err.getError()) {
    llvm::errs() << argv[0] << ": could not open input file '" << inputFileName
                 << "': " << error.message() << "\n";
    return 1;
  }
  auto buffer = file_or_err->get();
  auto maybe_module =

                                              batch_function.getOperands());
      return;
    }
    // For all other ops, we assume it mutates all resources it uses, so
    // this errs on the side of being conservative. We should improve
    // this by using either a property or a trait that clearly
    // identifies ops with resource mutating behavior.
    PropagatePotentiallyWrittenWithinUnhandledOp(op);