code: def deheap_sort(heap):
      
      indices = heap[0]
      weights = heap[1]
  
      for i in range(indices.shape[0]):
  
          ind_heap = indices[i]
          dist_heap = weights[i]
  
          for j in range(ind_heap.shape[0] - 1):
              ind_heap[0], ind_heap[ind_heap.shape[0] - j - 1] = (
                  ind_heap[ind_heap.shape[0] - j - 1],
                  ind_heap[0],
              )
              dist_heap[0], dist_heap[dist_heap.shape[0] - j - 1] = (
                  dist_heap[dist_heap.shape[0] - j - 1],
                  dist_heap[0],
              )
  
              siftdown(
                  dist_heap[: dist_heap.shape[0] - j - 1],
                  ind_heap[: ind_heap.shape[0] - j - 1],
                  0,
              )
  
      return indices.astype(np.int64), weights
docs: Given an array of heaps (of indices and weights), unpack the heap
      out to give and array of sorted lists of indices and weights by increasing
      weight. This is effectively just the second half of heap sort (the first
      half not being required since we already have the data in a heap).
  
      Parameters
      ----------
      heap : array of shape (3, n_samples, n_neighbors)
          The heap to turn into sorted lists.
  
      Returns
      -------
      indices, weights: arrays of shape (n_samples, n_neighbors)
          The indices and weights sorted by increasing weight.