code: def cuirfft(inp, norm=None, is_odd=False):
      """
      Performs the inverse fast Fourier Transform with real-valued output on the GPU.
  
      The input is a variable of dimensions (m, ..., n//2+1, 2) with
      type float32 representing the non-trivial elements of m
      real-valued Fourier transforms of initial size (..., n). The real and
      imaginary parts are stored as a pair of float32 arrays.
  
      The output is a real-valued float32 variable of dimensions (m, ..., n)
      giving the m inverse FFTs.
  
      Parameters
      ----------
      inp
          Array of float32 of size (m, ..., n//2+1, 2), containing m inputs
          with n//2+1 non-trivial elements on the last dimension and real
          and imaginary parts stored as separate arrays.
      norm : {None, 'ortho', 'no_norm'}
          Normalization of transform. Following numpy, default *None* normalizes
          only the inverse transform by n, 'ortho' yields the unitary transform
          (:math:`1/\sqrt n` forward and inverse). In addition, 'no_norm' leaves
          the transform unnormalized.
      is_odd : {True, False}
          Set to True to get a real inverse transform output with an odd last dimension
          of length (N-1)*2 + 1 for an input last dimension of length N.
  
      """
  
      if is_odd not in (True, False):
          raise ValueError(
              "Invalid value %s for id_odd, must be True or False"
              % is_odd
          )
  
      s = inp.shape[1:-1]
      if is_odd:
          s = T.set_subtensor(s[-1], (s[-1] - 1) * 2 + 1)
      else:
          s = T.set_subtensor(s[-1], (s[-1] - 1) * 2)
  
      cond_norm = _unitary(norm)
      scaling = 1
      if cond_norm is None:
          scaling = s.prod().astype("float32")
      elif cond_norm == "ortho":
          scaling = T.sqrt(s.prod().astype("float32"))
  
      return cuirfft_op(inp, s) / scaling
  
imports: from __future__ import absolute_import, print_function, division
  import numpy
  import theano
  from theano import Op
  import theano.tensor
  from theano.gradient import DisconnectedType
  from .basic_ops import gpu_contiguous, as_gpuarray_variable, infer_context_name
  from .type import GpuArrayType
  import theano.tensor.fft
  from .opt import register_opt, op_lifter, register_opt2
label_desc: Use image node_id 2 for calling a global function with example usage: cuirfft(inp, norm, is_odd) and returns: unknown