code: def irfft(inp, norm=None, is_odd=False):
      r"""
      Performs the inverse fast Fourier Transform with real-valued output.
  
      The input is a variable of dimensions (m, ..., n//2+1, 2)
      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 float arrays.
  
      The output is a real-valued variable of dimensions (m, ..., n)
      giving the m inverse FFTs.
  
      Parameters
      ----------
      inp
          Array 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 real 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(
              f"Invalid value {is_odd} for id_odd, must be True or False"
          )
  
      s = inp.shape[1:-1]
      if is_odd:
          s = set_subtensor(s[-1], (s[-1] - 1) * 2 + 1)
      else:
          s = set_subtensor(s[-1], (s[-1] - 1) * 2)
  
      cond_norm = _unitary(norm)
      scaling = 1
      # Numpy's default normalization is 1/N on the inverse transform.
      if cond_norm is None:
          scaling = s.prod().astype(inp.dtype)
      elif cond_norm == "ortho":
          scaling = sqrt(s.prod().astype(inp.dtype))
  
      return irfft_op(inp, s) / scaling
  
imports: import numpy
  from pytensor.gradient import DisconnectedType
  from pytensor.graph.basic import Apply
  from pytensor.graph.op import Op
  from pytensor.tensor.basic import as_tensor_variable
  from pytensor.tensor.math import sqrt
  from pytensor.tensor.subtensor import set_subtensor
  from pytensor.tensor.type import TensorType, integer_dtypes
label_desc: Use image node_id 2 for calling a global function with example usage: irfft(inp, norm, is_odd) and returns: unknown