void copy_nonoverlapping(BlobPtr dst, size_t n = 1) const {
#if __has_builtin(__builtin_memcpy_inline)
    if (element_size <= 16 && n == 1) {
      std::byte *src = data;
      std::byte *dest = dst.data;
      if (element_size >= 8) {
        __builtin_memcpy_inline(dest, src, 8);
        __builtin_memcpy_inline(&dest[element_size - 8], &src[element_size - 8],
                                8);
      } else if (element_size >= 4) {
        __builtin_memcpy_inline(dest, src, 4);
        __builtin_memcpy_inline(&dest[element_size - 4], &src[element_size - 4],
                                4);
      } else if (element_size >= 2) {
        __builtin_memcpy_inline(dest, src, 2);
        __builtin_memcpy_inline(&dest[element_size - 2], &src[element_size - 2],
                                2);
      } else {
        __builtin_memcpy_inline(dest, src, 1);
      }
      return;
    }
#endif
    std::memcpy(dst, data, element_size * n);
  }

  size_t alignment = guess_alignment(element_size, data);
  BlobComparator<Comp> comp{element_size, alignment, compare};

  // Insertion sort is always fine because we never call comparison on temporary
  // space
  constexpr size_t MAX_LEN_ALWAYS_INSERTION_SORT = 20;
  constexpr size_t MAX_ALIGNMENT = 32;
  if (DRIFTSORT_LIKELY(length <= MAX_LEN_ALWAYS_INSERTION_SORT)) {
    BlobPtr v = comp.lift(data);
    return small::insertion_sort_shift_left(v, length, 1, comp);
  }

  // unfortunately, due to qsort_r's restriction, we cannot really know the
  // alignment of over-aligned types, so we have to fall back to slow path.
  // This is similar to the behavior of glibc's qsort.
  if (DRIFTSORT_UNLIKELY(alignment > MAX_ALIGNMENT))
    return trivial_heap_sort(data, length, comp);