docs: def split(self, cutting_points, shift_times=False, overlap=0.0):
          """
          Split the label-list into x parts and return them as new label-lists.
          x is defined by the number of cutting-points(``x == len(cutting_points) + 1``)
  
          The result is a list of label-lists corresponding to each part.
          Label-list 0 contains labels between ``0`` and ``cutting_points[0]``.
          Label-list 1 contains labels between ``cutting_points[0]`` and ``cutting_points[1]``.
          And so on.
  
          Args:
              cutting_points(list): List of floats defining the points in seconds,
                                    where the label-list is splitted.
              shift_times(bool): If True, start and end-time are shifted in splitted label-lists.
                                 So the start is relative to the cutting point and
                                 not to the beginning of the original label-list.
              overlap(float): Amount of overlap in seconds. This amount is subtracted
                              from a start-cutting-point, and added to a end-cutting-point.
  
          Returns:
              list: A list of of: class: `audiomate.annotations.LabelList`.
  
          Example:
  
              >>> ll = LabelList(labels=[
              >>>     Label('a', 0, 5),
              >>>     Label('b', 5, 10),
              >>>     Label('c', 11, 15),
              >>>])
              >>>
              >>> res = ll.split([4.1, 8.9, 12.0])
              >>> len(res)
              4
              >>> res[0].labels
              [Label('a', 0.0, 4.1)]
              >>> res[1].labels
              [
                  Label('a', 4.1, 5.0),
                  Label('b', 5.0, 8.9)
              ]
              >>> res[2].labels
              [
                  Label('b', 8.9, 10.0),
                  Label('c', 11.0, 12.0)
              ]
              >>> res[3].labels
              [Label('c', 12.0, 15.0)]
  
          If ``shift_times = True``, the times are adjusted to be relative
          to the cutting-points for every label-list but the first.
  
              >>> ll = LabelList(labels=[
              >>>     Label('a', 0, 5),
              >>>     Label('b', 5, 10),
              >>>])
              >>>
              >>> res = ll.split([4.6])
              >>> len(res)
              4
              >>> res[0].labels
              [Label('a', 0.0, 4.6)]
              >>> res[1].labels
              [
                  Label('a', 0.0, 0.4),
                  Label('b', 0.4, 5.4)
              ]
          """
  
          if len(cutting_points) == 0:
              raise ValueError('At least one cutting-point is needed!')
  
          # we have to loop in sorted order
          cutting_points = sorted(cutting_points)
  
          splits = []
          iv_start = 0.0
  
          for i in range(len(cutting_points) + 1):
              if i < len(cutting_points):
                  iv_end = cutting_points[i]
              else:
                  iv_end = float('inf')
  
              # get all intervals intersecting range
              intervals = self.label_tree.overlap(
                  iv_start - overlap,
                  iv_end + overlap
              )
  
              cp_splits = LabelList(idx=self.idx)
  
              # Extract labels from intervals with updated times
              for iv in intervals:
                  label = copy.deepcopy(iv.data)
                  label.start = max(0, iv_start - overlap, label.start)
                  label.end = min(iv_end + overlap, label.end)
  
                  if shift_times:
                      orig_start = max(0, iv_start - overlap)
                      label.start -= orig_start
                      label.end -= orig_start
  
                  cp_splits.add(label)
  
              splits.append(cp_splits)
              iv_start = iv_end
  
          return splits