failed(AddFloatAttr(func, attrs, "w_scale", &fbb)))
    return failure();
  auto use_regular_nms =
      mlir::dyn_cast_or_null<BoolAttr>(attrs.get("use_regular_nms"));
  if (!use_regular_nms) {
    return func.emitError()
           << "use_regular_nms attribute is not set or not a bool";
  }
  fbb.Int("use_regular_nms", use_regular_nms.getValue());

  fbb.EndMap(start_map);
  fbb.Finish();

    // previous optimize global tensors pass). If not, this pass has to fail
    // since it cannot perform one of its goals.
    if (global_tensor.getIsMutable()) {
      if (allow_mutable_tensors) continue;
      global_tensor.emitError()
          << "is not immutable, try removing mutable variables in your model "
             "since mutable variables are currently not supported through "
             "this converter";
      return signalPassFailure();

  auto parent_module = entry_func->getParentOfType<ModuleOp>();
  auto versions_attr = parent_module->getAttr(kVersionsAttr);
  if (!versions_attr)
    return parent_module.emitError(CreateMissingAttributeMsg(kVersionsAttr));

  module_for_func.get().getOperation()->setAttr(kVersionsAttr, versions_attr);
  SymbolTable symbol_table(module_for_func.get());

  while (!referenced.empty()) {

}

bool EmitMustBeConstantError(Operation* op) {
  if (operations_to_skip->contains(op->getRegisteredInfo()->getTypeID())) {
    IncrementCounterFor(mlir_non_static_op_skip_count, op);
    return true;
  }
  emitError(op->getLoc()) << absl::StrCat(
      "Node `", op->getName().getStringRef().str(), "` ", kMustBeConstantError);
  return false;
}

bool IsStaticOperation(Operation* op) {
  for (auto o : op->getResults()) {

  Type storageType;
  int64_t qmin;
  int64_t qmax;
  if (getDefaultStorageParams(numBits, narrowRange, isSigned, ctx, storageType,
                              qmin, qmax)) {
    return (emitError(loc, "unsupported FakeQuant number of bits: ") << numBits,
            nullptr);
  }

  // Special case where min/max is close enough. The tensor contents are all

  std::unique_ptr<llvm::MemoryBuffer> mem_buffer;
  llvm::StringRef quantized_function_library =
      GetFunctionLibrary(quantization_method_, op_set_);

  if (quantized_function_library.empty()) {
    emitError(module.getLoc())
        << "Failed to get function library for the opset.";
    signalPassFailure();
    return;
  }

  mem_buffer =
      llvm::MemoryBuffer::getMemBuffer(quantized_function_library,

  for (llvm::scc_iterator<const CallGraph *> scci =
           llvm::scc_begin<const CallGraph *>(&call_graph);
       !scci.isAtEnd(); ++scci) {
    if (scci.hasCycle()) {
      auto err = module.emitError()
                 << "A recursive call graph cannot be transformed to "
                    "one use for all functions. Functions in the "
                    "recursive cycle are: ";

    if (target_opset_ == OpSet::UNIFORM_QUANTIZED) {
      ShapedType new_output_type = ConvertIntToQint(
          mlir::cast<ShapedType>(output_type), rewriter.getContext());
      if (!new_output_type) {
        q_op->emitError(
            "Failed to convert the type to the corresponding qtype.");
        return failure();
      }
      output_types = {new_output_type};
    } else {

      // Rewire the inputs.
      duplicated_dq_op->setOperand(0, duplicated_input_op->getResult(0));
      op->setOperand(index, duplicated_dq_op->getResult(0));
    } else {
      op->emitError()
          << "We cannot duplicate the value since it's not constant.\n";
      return failure();
    }
  }
  return success();
}

void SplitMergedOperandsPass::runOnOperation() {

    ModuleOp module, tensorflow::Session* session) {
  const tensorflow::DeviceMgr* mgr = nullptr;
  auto status = session->LocalDeviceManager(&mgr);
  if (!status.ok()) {
    module->emitError(
        absl::StrCat("failed to fetch device manager: ", status.message()));
    return failure();
  }

  // Fetch all VarHandleOp.
  llvm::StringSet<> variable_names;