code: def ufuncify(
      args,
      expr,
      language=None,
      backend="numpy",
      tempdir=None,
      flags=None,
      verbose=False,
      helpers=None,
      **kwargs,
  ):
      """Generates a binary function that supports broadcasting on numpy arrays.
  
      Parameters
      ==========
  
      args : iterable
          Either a Symbol or an iterable of symbols. Specifies the argument
          sequence for the function.
      expr
          A SymPy expression that defines the element wise operation.
      language : string, optional
          If supplied, (options: 'C' or 'F95'), specifies the language of the
          generated code. If ``None`` [default], the language is inferred based
          upon the specified backend.
      backend : string, optional
          Backend used to wrap the generated code. Either 'numpy' [default],
          'cython', or 'f2py'.
      tempdir : string, optional
          Path to directory for temporary files. If this argument is supplied,
          the generated code and the wrapper input files are left intact in
          the specified path.
      flags : iterable, optional
          Additional option flags that will be passed to the backend.
      verbose : bool, optional
          If True, autowrap will not mute the command line backends. This can
          be helpful for debugging.
      helpers : iterable, optional
          Used to define auxiliary expressions needed for the main expr. If
          the main expression needs to call a specialized function it should
          be put in the ``helpers`` iterable. Autowrap will then make sure
          that the compiled main expression can link to the helper routine.
          Items should be tuples with (<funtion_name>, <sympy_expression>,
          <arguments>). It is mandatory to supply an argument sequence to
          helper routines.
      kwargs : dict
          These kwargs will be passed to autowrap if the `f2py` or `cython`
          backend is used and ignored if the `numpy` backend is used.
  
      Notes
      =====
  
      The default backend ('numpy') will create actual instances of
      ``numpy.ufunc``. These support ndimensional broadcasting, and implicit type
      conversion. Use of the other backends will result in a "ufunc-like"
      function, which requires equal length 1-dimensional arrays for all
      arguments, and will not perform any type conversions.
  
      References
      ==========
  
      .. [1] https://numpy.org/doc/stable/reference/ufuncs.html
  
      Examples
      ========
  
      >>> from sympy.utilities.autowrap import ufuncify
      >>> from sympy.abc import x, y
      >>> import numpy as np
      >>> f = ufuncify((x, y), y + x**2)
      >>> type(f)
      <class 'numpy.ufunc'>
      >>> f([1, 2, 3], 2)
      array([  3.,   6.,  11.])
      >>> f(np.arange(5), 3)
      array([  3.,   4.,   7.,  12.,  19.])
  
      For the 'f2py' and 'cython' backends, inputs are required to be equal length
      1-dimensional arrays. The 'f2py' backend will perform type conversion, but
      the Cython backend will error if the inputs are not of the expected type.
  
      >>> f_fortran = ufuncify((x, y), y + x**2, backend='f2py')
      >>> f_fortran(1, 2)
      array([ 3.])
      >>> f_fortran(np.array([1, 2, 3]), np.array([1.0, 2.0, 3.0]))
      array([  2.,   6.,  12.])
      >>> f_cython = ufuncify((x, y), y + x**2, backend='Cython')
      >>> f_cython(1, 2)  # doctest: +ELLIPSIS
      Traceback (most recent call last):
        ...
      TypeError: Argument '_x' has incorrect type (expected numpy.ndarray, got int)
      >>> f_cython(np.array([1.0]), np.array([2.0]))
      array([ 3.])
  
      """
  
      if isinstance(args, Symbol):
          args = (args,)
      else:
          args = tuple(args)
  
      if language:
          _validate_backend_language(backend, language)
      else:
          language = _infer_language(backend)
  
      helpers = helpers if helpers else ()
      flags = flags if flags else ()
  
      if backend.upper() == "NUMPY":
          # maxargs is set by numpy compile-time constant NPY_MAXARGS
          # If a future version of numpy modifies or removes this restriction
          # this variable should be changed or removed
          maxargs = 32
          helps = []
          for name, expr, args in helpers:
              helps.append(make_routine(name, expr, args))
          code_wrapper = UfuncifyCodeWrapper(
              C99CodeGen("ufuncify"), tempdir, flags, verbose
          )
          if not isinstance(expr, (list, tuple)):
              expr = [expr]
          if len(expr) == 0:
              raise ValueError("Expression iterable has zero length")
          if len(expr) + len(args) > maxargs:
              msg = (
                  "Cannot create ufunc with more than {0} total arguments: "
                  "got {1} in, {2} out"
              )
              raise ValueError(
                  msg.format(maxargs, len(args), len(expr))
              )
          routines = [
              make_routine("autofunc{}".format(idx), exprx, args)
              for idx, exprx in enumerate(expr)
          ]
          return code_wrapper.wrap_code(routines, helpers=helps)
      else:
          # Dummies are used for all added expressions to prevent name clashes
          # within the original expression.
          y = IndexedBase(Dummy("y"))
          m = Dummy("m", integer=True)
          i = Idx(Dummy("i", integer=True), m)
          f_dummy = Dummy("f")
          f = implemented_function(
              "%s_%d" % (f_dummy.name, f_dummy.dummy_index),
              Lambda(args, expr),
          )
          # For each of the args create an indexed version.
          indexed_args = [IndexedBase(Dummy(str(a))) for a in args]
          # Order the arguments (out, args, dim)
          args = [y] + indexed_args + [m]
          args_with_indices = [a[i] for a in indexed_args]
          return autowrap(
              Eq(y[i], f(*args_with_indices)),
              language,
              backend,
              tempdir,
              args,
              flags,
              verbose,
              helpers,
              **kwargs,
          )
  
imports: import sys
  import os
  import shutil
  import tempfile
  from subprocess import STDOUT, CalledProcessError, check_output
  from string import Template
  from warnings import warn
  from sympy.core.cache import cacheit
  from sympy.core.function import Lambda
  from sympy.core.relational import Eq
  from sympy.core.symbol import Dummy, Symbol
  from sympy.tensor.indexed import Idx, IndexedBase
  from sympy.utilities.codegen import make_routine, get_code_generator, OutputArgument, InOutArgument, InputArgument, CodeGenArgumentListError, Result, ResultBase, C99CodeGen
  from sympy.utilities.iterables import iterable
  from sympy.utilities.lambdify import implemented_function
  from sympy.utilities.decorator import doctest_depends_on
label_desc: Use image node_id 5 for calling a global function with example usage: ufuncify(args, expr, language, backend, tempdir, flags, verbose, helpers) and returns: code_wrapper, autowrap