StringRef shared_name = GetSharedName(hash_table);
  if (shared_name.empty()) return false;

  for (func::FuncOp init_func_op :
       tf_saved_model::GetInitializerFunctions(module_op)) {
    for (Operation& op : init_func_op.getBody().getOps()) {
      StringRef other_shared_name = GetSharedName(&op);
      if (IsHashTableOp(&op) && other_shared_name == shared_name) {

  // then fallback to shared_name attribute.
  if (auto loc = mlir::dyn_cast<NameLoc>(var_handle_op->getLoc()))
    return loc.getName().str();
  return var_handle_op.getSharedName().str();
}

std::vector<std::string> GetVariableNames(
    llvm::ArrayRef<TF::VarHandleOp> var_handle_ops) {
  std::vector<std::string> names;
  names.reserve(var_handle_ops.size());

        {mlir::cast<TensorType>(ref_qtype)}, builder.getContext()));
    auto new_var_handle_op = builder.create<VarHandleOp>(
        var_handle_op.getLoc(), output_type, var_handle_op.getContainer(),
        var_handle_op.getSharedName());
    var_handle_op->replaceAllUsesWith(new_var_handle_op);
    var_handle_op.erase();
  }
}

void QuantizeVariablesPass::runOnOperation() {
  ResourceIdMap resource_id_map;

      resource_vec.push_back(GetResourceHandleValueAndIdBase(
          mlir::cast<mlir::StringAttr>(getContainer()[index]).getValue(),
          mlir::cast<mlir::StringAttr>(getSharedName()[index]).getValue(),
          device, getResults()[index], resource_handle_id_map, next_id));
    }
  }
  return resource_vec;
}

LogicalResult _TfrtGetResourceOp::verify() {

    // native resource design is based on integer keys to identify the
    // corresponding resource objects.
    auto table_id =
        static_cast<int32_t>(::llvm::hash_value(hashtable_op.getSharedName()));
    auto key_dtype = hashtable_op.getKeyDtype();
    auto value_dtype = hashtable_op.getValueDtype();

    rewriter.replaceOpWithNewOp<TFL::HashtableOp>(

  }
  if (TF::VarHandleOp var_handle_op = llvm::dyn_cast<TF::VarHandleOp>(&op)) {
    auto ANONYMOUS_NAME = ::tensorflow::ResourceHandle::ANONYMOUS_NAME;
    if (var_handle_op.getSharedName() == ANONYMOUS_NAME) {
      return std::make_optional(LocalVarOp(var_handle_op));
    }
  }
  return {};
}

// Eliminate local variables that are only assigned to but never read, and thus
// are dead.

    llvm::SmallDenseMap<ResourceHandle, int64_t> &resource_handle_id_map,
    int64_t &next_id) {
  llvm::StringRef device = GetDeviceOrEmpty(getOperation());
  return {GetResourceHandleValueAndIdBase(getContainer(), getSharedName(),
                                          device, getWriter(),
                                          resource_handle_id_map, next_id)};
}