code: def ifftn(
      x, s=None, axes=None, norm=None, overwrite_x=False, *, plan=None
  ):
      """Compute the N-dimensional inverse FFT.
  
      Args:
          x (cupy.ndarray): Array to be transformed.
          s (None or tuple of ints): Shape of the transformed axes of the
              output. If ``s`` is not given, the lengths of the input along
              the axes specified by ``axes`` are used.
          axes (tuple of ints): Axes over which to compute the FFT.
          norm (``"backward"``, ``"ortho"``, or ``"forward"``): Optional keyword
              to specify the normalization mode. Default is ``None``, which is
              an alias of ``"backward"``.
          overwrite_x (bool): If True, the contents of ``x`` can be destroyed.
          plan (:class:`cupy.cuda.cufft.PlanNd` or ``None``): a cuFFT plan for
              transforming ``x`` over ``axes``, which can be obtained using::
  
                  plan = cupyx.scipy.fftpack.get_fft_plan(x, s, axes)
  
              Note that ``plan`` is defaulted to ``None``, meaning CuPy will use
              an auto-generated plan behind the scene.
  
      Returns:
          cupy.ndarray:
              The transformed array which shape is specified by ``s`` and
              type will convert to complex if that of the input is another.
  
      .. seealso:: :func:`scipy.fft.ifftn`
      """
      from cupy.cuda import cufft
  
      s = _assequence(s)
      axes = _assequence(axes)
      func = _default_fft_func(x, s, axes)
      return func(
          x,
          s,
          axes,
          norm,
          cufft.CUFFT_INVERSE,
          overwrite_x=overwrite_x,
          plan=plan,
      )
  
imports: from numbers import Number
  import warnings
  import numpy
  import cupy
  from cupy.fft._fft import _fft, _default_fft_func, hfft, ihfft, _swap_direction
label_desc: Use image node_id 10 for calling a global function with example usage: ifftn(x, s, axes, norm, overwrite_x) and returns: func