code: def deemphasis(
      y: np.ndarray,
      *,
      coef: float = 0.97,
      zi: Optional[ArrayLike] = None,
      return_zf: bool = False,
  ) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
      """De-emphasize an audio signal with the inverse operation of preemphasis():
  
      If y = preemphasis(x, coef=coef, zi=zi), the deemphasis is:
  
      >>> x[i] = y[i] + coef * x[i-1]
      >>> x = deemphasis(y, coef=coef, zi=zi)
  
      Parameters
      ----------
      y : np.ndarray [shape=(..., n)]
          Audio signal. Multi-channel is supported.
  
      coef : positive number
          Pre-emphasis coefficient.  Typical values of ``coef`` are between 0 and 1.
  
          At the limit ``coef=0``, the signal is unchanged.
  
          At ``coef=1``, the result is the first-order difference of the signal.
  
          The default (0.97) matches the pre-emphasis filter used in the HTK
          implementation of MFCCs [#]_.
  
          .. [#] https://htk.eng.cam.ac.uk/
  
      zi : number
          Initial filter state. If inverting a previous preemphasis(), the same value should be used.
  
          By default ``zi`` is initialized as
          ``((2 - coef) * y[0] - y[1]) / (3 - coef)``. This
          value corresponds to the transformation of the default initialization of ``zi`` in ``preemphasis()``,
          ``2*x[0] - x[1]``.
  
      return_zf : boolean
          If ``True``, return the final filter state.
          If ``False``, only return the pre-emphasized signal.
  
      Returns
      -------
      y_out : np.ndarray
          de-emphasized signal
      zf : number
          if ``return_zf=True``, the final filter state is also returned
  
      Examples
      --------
      Apply a standard pre-emphasis filter and invert it with de-emphasis
  
      >>> y, sr = librosa.load(librosa.ex('trumpet'))
      >>> y_filt = librosa.effects.preemphasis(y)
      >>> y_deemph = librosa.effects.deemphasis(y_filt)
      >>> np.allclose(y, y_deemph)
      True
  
      See Also
      --------
      preemphasis
      """
      b = np.array([1.0, -coef], dtype=y.dtype)
      a = np.array([1.0], dtype=y.dtype)
  
      y_out: np.ndarray
      zf: np.ndarray
      if zi is None:
          # initialize with all zeros
          zi = np.zeros(list(y.shape[:-1]) + [1], dtype=y.dtype)
          y_out, zf = scipy.signal.lfilter(a, b, y, zi=zi)
  
          # factor in the linear extrapolation
          y_out -= (
              ((2 - coef) * y[..., 0:1] - y[..., 1:2])
              / (3 - coef)
              * (coef ** np.arange(y.shape[-1]))
          )
  
      else:
          zi = np.atleast_1d(zi)
          y_out, zf = scipy.signal.lfilter(
              a, b, y, zi=zi.astype(y.dtype)
          )
  
      if return_zf:
          return y_out, zf
      else:
          return y_out
  
imports: import numpy
  import scipy.signal
  from .None import core
  from .None import decompose
  from .None import feature
  from .None import util
  from .util.exceptions import ParameterError
  from typing import Any, Callable, Iterable, Optional, Tuple, Union, overload
  from typing_extensions import Literal
  from numpy.typing import ArrayLike
label_desc: Use image node_id 16 for calling a global function with example usage: deemphasis(y) and returns: y_out,  zf, y_out