code: def dst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False):
      """Return the Discrete Sine Transform of an array, x.
  
      Parameters
      ----------
      x : cupy.ndarray
          The input array.
      type : {1, 2, 3, 4}, optional
          Type of the DST (see Notes). Default type is 2.
      n : int, optional
          Length of the transform.  If ``n < x.shape[axis]``, `x` is
          truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The
          default results in ``n = x.shape[axis]``.
      axis : int, optional
          Axis along which the dst is computed; the default is over the
          last axis (i.e., ``axis=-1``).
      norm : {"backward", "ortho", "forward"}, optional
          Normalization mode (see Notes). Default is "backward".
      overwrite_x : bool, optional
          If True, the contents of `x` can be destroyed; the default is False.
  
      Returns
      -------
      dst : cupy.ndarray of real
          The transformed input array.
  
      See Also
      --------
      :func:`scipy.fft.dst`
  
      Notes
      -----
  
      For ``norm="ortho"`` both the `dst` and `idst` are scaled by the same
      overall factor in both directions. By default, the transform is also
      orthogonalized which for types 2 and 3 means the transform definition is
      modified to give orthogonality of the DST matrix (see below).
  
      For ``norm="backward"``, there is no scaling on the `dst` and the `idst` is
      scaled by ``1/N`` where ``N`` is the "logical" size of the DST.
  
      See the :func:`scipy.fft.dst` documentation for a full description of each
      type. CuPy currently only supports DST types 2 and 3.
      """
      if x.dtype.kind == "c":
          # separable application on real and imaginary parts
          out = dst(x.real, type, n, axis, norm, overwrite_x)
          out = out + 1j * dst(x.imag, type, n, axis, norm, overwrite_x)
          return out
  
      x = _promote_dtype(x)
  
      if type == 2:
          return _dct_or_dst_type2(
              x, n=n, axis=axis, norm=norm, forward=True, dst=True
          )
      elif type == 3:
          return _dct_or_dst_type3(
              x, n=n, axis=axis, norm=norm, forward=True, dst=True
          )
      elif type in [1, 4]:
          raise NotImplementedError(
              "Only DST-II and DST-III have been implemented."
          )
      else:
          raise ValueError("invalid DST type")
  
imports: import math
  import numbers
  import operator
  import numpy
  import cupy
  from cupy import _core
  from cupy.fft._fft import _cook_shape
  from cupyx.scipy.fft import _fft
label_desc: Use image node_id 10 for calling a global function with example usage: dst(x, type, n, axis, norm, overwrite_x) and returns: out, _dct_or_dst_type2, _dct_or_dst_type3