docs: def _refine_upcheck(merge, min_goodness):
      """Remove from the merge any entries which would be covered by entries
      between their current position and the merge insertion position.
  
      For example, the third entry of::
  
          0011 -> N
          0100 -> N
          1000 -> N
          X000 -> NE
  
      Cannot be merged with the first two entries because that would generate the
      new entry ``XXXX`` which would move ``1000`` below the entry with the
      key-mask pair of ``X000``, which would cover it.
  
      Returns
      -------
      :py:class:`~.Merge`
          New merge with entries possibly removed. If the goodness of the merge
          ever drops below `min_goodness` then an empty merge will be returned.
      bool
          If the merge has been changed at all.
      """
      # Remove any entries which would be covered by entries above the merge
      # position.
      changed = False
      for i in sorted(merge.entries, reverse=True):
          # Get all the entries that are between the entry we're looking at the
          # insertion index of the proposed merged index. If this entry would be
          # covered up by any of them then we remove it from the merge.
          entry = merge.routing_table[i]
          key, mask = entry.key, entry.mask
          if any(intersect(key, mask, other.key, other.mask) for other in
                 merge.routing_table[i+1:merge.insertion_index]):
              # The entry would be partially or wholly covered by another entry,
              # remove it from the merge and return a new merge.
              merge = _Merge(merge.routing_table, merge.entries - {i})
              changed = True
  
              # Check if the merge is sufficiently good
              if merge.goodness <= min_goodness:
                  merge = _Merge(merge.routing_table)  # Replace with empty merge
                  break
  
      # Return the final merge
      return merge, changed