code: def split(
      y: np.ndarray,
      *,
      top_db: float = 60,
      ref: Union[float, Callable] = np.max,
      frame_length: int = 2048,
      hop_length: int = 512,
      aggregate: Callable = np.max,
  ) -> np.ndarray:
      """Split an audio signal into non-silent intervals.
  
      Parameters
      ----------
      y : np.ndarray, shape=(..., n)
          An audio signal. Multi-channel is supported.
      top_db : number > 0
          The threshold (in decibels) below reference to consider as
          silence
      ref : number or callable
          The reference amplitude.  By default, it uses `np.max` and compares
          to the peak amplitude in the signal.
      frame_length : int > 0
          The number of samples per analysis frame
      hop_length : int > 0
          The number of samples between analysis frames
      aggregate : callable [default: np.max]
          Function to aggregate across channels (if y.ndim > 1)
  
      Returns
      -------
      intervals : np.ndarray, shape=(m, 2)
          ``intervals[i] == (start_i, end_i)`` are the start and end time
          (in samples) of non-silent interval ``i``.
      """
      non_silent = _signal_to_frame_nonsilent(
          y,
          frame_length=frame_length,
          hop_length=hop_length,
          ref=ref,
          top_db=top_db,
          aggregate=aggregate,
      )
  
      # Interval slicing, adapted from
      # https://stackoverflow.com/questions/2619413/efficiently-finding-the-interval-with-non-zeros-in-scipy-numpy-in-python
      # Find points where the sign flips
      edges = np.flatnonzero(np.diff(non_silent.astype(int)))
  
      # Pad back the sample lost in the diff
      edges = [edges + 1]
  
      # If the first frame had high energy, count it
      if non_silent[0]:
          edges.insert(0, np.array([0]))
  
      # Likewise for the last frame
      if non_silent[-1]:
          edges.append(np.array([len(non_silent)]))
  
      # Convert from frames to samples
      edges = core.frames_to_samples(
          np.concatenate(edges), hop_length=hop_length
      )
  
      # Clip to the signal duration
      edges = np.minimum(edges, y.shape[-1])
  
      # Stack the results back as an ndarray
      edges = edges.reshape((-1, 2))  # type: np.ndarray
      return edges
  
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 9 for calling a global function with example usage: split(y) and returns: edges