code: def match_events(ref, est, window, distance=None):
      
      if distance is not None:
          # Compute the indices of feasible pairings
          hits = np.where(distance(ref, est) <= window)
      else:
          hits = _fast_hit_windows(ref, est, window)
  
      # Construct the graph input
      G = {}
      for ref_i, est_i in zip(*hits):
          if est_i not in G:
              G[est_i] = []
          G[est_i].append(ref_i)
  
      # Compute the maximum matching
      matching = sorted(_bipartite_match(G).items())
  
      return matching
docs: Compute a maximum matching between reference and estimated event times,
      subject to a window constraint.
  
      Given two lists of event times ``ref`` and ``est``, we seek the largest set
      of correspondences ``(ref[i], est[j])`` such that
      ``distance(ref[i], est[j]) <= window``, and each
      ``ref[i]`` and ``est[j]`` is matched at most once.
  
      This is useful for computing precision/recall metrics in beat tracking,
      onset detection, and segmentation.
  
      Parameters
      ----------
      ref : np.ndarray, shape=(n,)
          Array of reference values
      est : np.ndarray, shape=(m,)
          Array of estimated values
      window : float > 0
          Size of the window.
      distance : function
          function that computes the outer distance of ref and est.
          By default uses ``|ref[i] - est[j]|``
  
      Returns
      -------
      matching : list of tuples
          A list of matched reference and event numbers.
          ``matching[i] == (i, j)`` where ``ref[i]`` matches ``est[j]``.