if (!function_uses.has_value()) return false;
  for (auto& function_use : function_uses.value()) {
    if (!llvm::isa<TF::PartitionedCallOp, TF::StatefulPartitionedCallOp>(
            function_use.getUser())) {
      return false;
    }
  }
  return true;
}

// Returns the `shared_name` attribute value if exists. If not, returns an
// empty string.
StringRef GetSharedName(Operation* op) {

		errs = AppendValidation(errs, ValidateHTTPHeaderWithAuthorityOperationName(name))
		errs = AppendValidation(errs, ValidateHTTPHeaderValue(val))
	}
	for name, val := range http.Headers.GetRequest().GetSet() {
		errs = AppendValidation(errs, ValidateHTTPHeaderWithAuthorityOperationName(name))
		errs = AppendValidation(errs, ValidateHTTPHeaderValue(val))
	}
	for _, name := range http.Headers.GetRequest().GetRemove() {

        freezeable[val] = false;
        continue;
      }

      freezeable[val] = true;

      // Verify users are supported kind.
      for (Operation *user : val.getUsers()) {
        if (!(isa<TF::ReadVariableOp>(user) || isa<CallOpInterface>(user))) {
          freezeable[val] = false;
          // Error out early if possible.
          if (!allow_mutable_tensors) {

// Check if an op result value is consumed by qint -> int TF Cast OP.
bool IsQintValueQintToIntCast(Value v) {
  if (!IsIllegalType(v.getType())) {
    return true;
  }
  if (v.getUsers().empty()) {
    return false;
  }
  return llvm::all_of(v.getUsers(), [&](OpOperand operand) {
    return IsQintToIntCast(operand.getOwner());
  });
}

// Check if an op operand value is defined by int -> qint TF Cast OP.

	case <-sys.configLoaded:
	default:
		err = sys.store.LoadUser(ctx, accessKey)
		loadUserCalled = true
	}

	u, ok = sys.store.GetUser(accessKey)
	if !ok && !loadUserCalled {
		err = sys.store.LoadUser(ctx, accessKey)
		loadUserCalled = true

		u, ok = sys.store.GetUser(accessKey)
	}

	if !ok && loadUserCalled && err != nil {
		iamLogOnceIf(ctx, err, accessKey)

		// return 503 to application

                     llvm::SmallVectorImpl<Operation*>& erase_list,
                     llvm::SmallPtrSetImpl<Operation*>& dead_ops) {
  for (mlir::Value res : op->getResults()) {
    for (Operation* user : res.getUsers()) {
      if (!dead_ops.insert(user).second) continue;
      RecursiveRemove(user, erase_list, dead_ops);
    }
  }

  erase_list.push_back(op);

  for (auto& use : op->getOpOperands()) {

      min -= kNearZeroTolerance;
      max += kNearZeroTolerance;
    }
  }
};

template <typename VerifierT>
bool UsedBy(Operation* op) {
  for (Operation* user : op->getUsers()) {
    if (llvm::isa_and_nonnull<VerifierT>(user)) return true;
  }
  return false;
}

template <typename VerifierT>
void CreateVerifier(Operation* quantizing_op, Operation* quantized_op,

        head_outside_compiled_ops.insert(&cluster_op);
    }
  }

  for (auto head_outside_compiled_op :
       llvm::reverse(head_outside_compiled_ops)) {
    auto users = head_outside_compiled_op->getUsers();
    if (users.empty() ||
        HasOutsideCompilationAttribute(head_outside_compiled_op))
      continue;

    bool should_expand_op_to_host_computation = true;
    for (auto consumer_op : users) {

    auto func = symbol_table.lookupNearestSymbolFrom<func::FuncOp>(
        symbol_use.getUser(), symbol_use.getSymbolRef());
    if (func && IsExported(func)) {
      // If it is an init function, then it can be used by the unique
      // session_initializer op.
      if (is_init(func) &&
          llvm::isa<SessionInitializerOp>(symbol_use.getUser())) {
        if (!func->getAttr(kTfSavedModelInitializerTypeAttr)) {
          LOG(WARNING)

  for (const auto &[resource_handle, var_handle_ops] : resources) {
    if (std::all_of(var_handle_ops.begin(), var_handle_ops.end(),
                    [](Operation *op) {
                      for (auto *user : op->getUsers()) {
                        if (!OnlyHasReadEffect(user)) return false;
                      }
                      return true;
                    })) {
      read_only_vars.insert(resource_handle);
    }