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 _get_args_transposed(self, args, input_axes, outs, output_axes):
      # This code credit goes to Dask
      # https://github.com/dask/dask/blob/61b578f5a3ad88cbc6a8b9a73ce08c551bd969fa/dask/array/gufunc.py#L349-L377
      # modifications have been done to support arguments broadcast
      # out argument, and optional core dims.
      transposed_args = []
      # This is used when reshaping the outputs so that we can delete
      # dims that were not specified in the input
      missing_dims = set()
      for i, (arg, iax, input_coredims, md) in enumerate(
          zip(args, input_axes, self._input_coredimss, self._min_dims)
      ):
          shape = arg.shape
          nds = len(shape)
          # For the inputs that has missing dimensions we need to reshape
          if nds < md:
              raise ValueError(
                  f"Input operand {i} does not have enough"
                  f" dimensions (has {nds}, gufunc core with"
                  f" signature {self._signature} requires {md}"
              )
          optionals = len(input_coredims) - nds
          if optionals > 0:
              # Look for optional dimensions
              # We only allow the first or the last dimensions to be optional
              if input_coredims[0][-1] == "?":
                  shape = (1,) * optionals + shape
                  missing_dims.update(set(input_coredims[:optionals]))
              else:
                  shape = shape + (1,) * optionals
                  missing_dims.update(
                      set(input_coredims[min(0, len(shape) - 1) :])
                  )
              arg = arg.reshape(shape)
          transposed_args.append(
              self._transpose_element(arg, iax, shape)
          )
      args = transposed_args
  
      if outs is not None:
          transposed_outs = []
          # outs should be transposed to the intermediate form before
          # copying all results
          for out, iox, coredims in zip(
              outs, output_axes, self._output_coredimss
          ):
              transposed_outs.append(
                  self._transpose_element(out, iox, out.shape)
              )
          # check that outs has been correctly transposed
          # if the function returns a scalar, outs will be ignored
          if len(transposed_outs) == len(outs):
              outs = transposed_outs
  
      # we cant directly broadcast arrays together since their core dims
      # might differ. Only the loop dimensions are broadcastable
      shape = internal._broadcast_shapes(
          [a.shape[: -len(self._input_coredimss)] for a in args]
      )
      args = [
          _manipulation.broadcast_to(
              a, shape + a.shape[-len(self._input_coredimss) :]
          )
          for a in args
      ]
  
      # Assess input args for loop dims
      input_shapes = [a.shape for a in args]
      num_loopdims = [
          len(s) - len(cd)
          for s, cd in zip(input_shapes, self._input_coredimss)
      ]
      max_loopdims = max(num_loopdims) if num_loopdims else None
      core_input_shapes = [
          dict(zip(icd, s[n:]))
          for s, n, icd in zip(
              input_shapes, num_loopdims, self._input_coredimss
          )
      ]
      core_shapes = {}
      for d in core_input_shapes:
          core_shapes.update(d)
  
      loop_input_dimss = [
          tuple(
              "__loopdim%d__" % d
              for d in range(max_loopdims - n, max_loopdims)
          )
          for n in num_loopdims
      ]
      input_dimss = [
          li + c
          for li, c in zip(loop_input_dimss, self._input_coredimss)
      ]
  
      loop_output_dims = max(loop_input_dimss, key=len, default=())
  
      # Assess input args for same size and chunk sizes
      # Collect sizes and chunksizes of all dims in all arrays
      dimsizess = {}
      for dims, shape in zip(input_dimss, input_shapes):
          for dim, size in zip(dims, shape):
              dimsizes = dimsizess.get(dim, [])
              dimsizes.append(size)
              dimsizess[dim] = dimsizes
  
      # Assert correct partitioning, for case:
      for dim, sizes in dimsizess.items():
          if set(sizes).union({1}) != {1, max(sizes)}:
              raise ValueError(
                  f"Dimension {dim} with different lengths in arrays"
              )
  
      return args, dimsizess, loop_output_dims, outs, missing_dims
  
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 4 for calling the _GUFunc obj's underlying member method code with example usage: obj._get_args_transposed(args, input_axes, outs, output_axes) and returns: args,  dimsizess,  loop_output_dims,  outs,  missing_dims