code: def _unevaluated_Add(*args):
      """Return a well-formed unevaluated Add: Numbers are collected and
      put in slot 0 and args are sorted. Use this when args have changed
      but you still want to return an unevaluated Add.
  
      Examples
      ========
  
      >>> from sympy.core.add import _unevaluated_Add as uAdd
      >>> from sympy import S, Add
      >>> from sympy.abc import x, y
      >>> a = uAdd(*[S(1.0), x, S(2)])
      >>> a.args[0]
      3.00000000000000
      >>> a.args[1]
      x
  
      Beyond the Number being in slot 0, there is no other assurance of
      order for the arguments since they are hash sorted. So, for testing
      purposes, output produced by this in some other function can only
      be tested against the output of this function or as one of several
      options:
  
      >>> opts = (Add(x, y, evaluate=False), Add(y, x, evaluate=False))
      >>> a = uAdd(x, y)
      >>> assert a in opts and a == uAdd(x, y)
      >>> uAdd(x + 1, x + 2)
      x + x + 3
      """
      args = list(args)
      newargs = []
      co = S.Zero
      while args:
          a = args.pop()
          if a.is_Add:
              # this will keep nesting from building up
              # so that x + (x + 1) -> x + x + 1 (3 args)
              args.extend(a.args)
          elif a.is_Number:
              co += a
          else:
              newargs.append(a)
      _addsort(newargs)
      if co:
          newargs.insert(0, co)
      return Add._from_args(newargs)
  
imports: from typing import Tuple
  from collections import defaultdict
  from functools import reduce
  from operator import attrgetter
  from .basic import _args_sortkey
  from .parameters import global_parameters
  from .logic import _fuzzy_group, fuzzy_or, fuzzy_not
  from .singleton import S
  from .operations import AssocOp, AssocOpDispatcher
  from .cache import cacheit
  from .numbers import equal_valued
  from .intfunc import ilcm, igcd
  from .expr import Expr
  from .kind import UndefinedKind
  from sympy.utilities.iterables import is_sequence, sift
  from .mul import Mul, _keep_coeff, _unevaluated_Mul
  from .numbers import Rational
label_desc: Use image node_id 3 for calling a global function with example usage: _unevaluated_Add() and returns: Add