class_docstr: Creates a Generalized Universal Function by wrapping a user
  provided function with the signature.
  
  ``signature`` determines if the function consumes or produces core
  dimensions. The remaining dimensions in given input arrays (``*args``)
  are considered loop dimensions and are required to broadcast
  naturally against each other.
  
  Args:
      func (callable):
          Function to call like ``func(*args, **kwargs)`` on input arrays
          (``*args``) that returns an array or tuple of arrays. If
          multiple arguments with non-matching dimensions are supplied,
          this function is expected to vectorize (broadcast) over axes of
          positional arguments in the style of NumPy universal functions.
      signature (string):
          Specifies what core dimensions are consumed and produced by
          ``func``.  According to the specification of numpy.gufunc
          signature.
      supports_batched (bool, optional):
          If the wrapped function supports to pass the complete input
          array with the loop and the core dimensions.
          Defaults to `False`. Dimensions will be iterated in the
          `GUFunc` processing code.
      supports_out (bool, optional):
          If the wrapped function supports out as one of its kwargs.
          Defaults to `False`.
      signatures (list of tuple of str):
          Contains strings in the form of 'ii->i' with i being the char of a
          dtype. Each element of the list is a tuple with the string
          and a alternative function to `func` to be executed when the inputs
          of the function can be casted as described by this function.
      name (str, optional):
          Name for the GUFunc object. If not specified, ``func``'s name
          is used.
      doc (str, optional):
          Docstring for the GUFunc object. If not specified, ``func.__doc__``
          is used.
code: def _determine_order(self, args, order):
      if order.upper() in ("C", "K"):
          # Order is determined to be C to allocate the out array
          # but we will change the strides of the out array
          # to be K later in __call__
          return "C"
      elif order.upper() == "A":
          # order is F if all arrays are strictly F
          order = (
              "F"
              if all(
                  [
                      a.flags.f_contiguous and not a.flags.c_contiguous
                      for a in args
                  ]
              )
              else "C"
          )
          return order
  
      elif order.upper() == "F":
          return "F"
      else:
          raise RuntimeError(f"Unknown order {order}")
  
imports: import re
  import numpy
  import cupy
  import cupy._core._routines_manipulation
  from cupy._core._dtype import get_dtype, _raise_if_invalid_cast
  from cupy._core import internal
label_desc: Use image node_id 5 for calling the _GUFunc obj's underlying member method code with example usage: obj._determine_order(args, order) and returns: str, order, str