src/slices/zsortanyfunc.go - go - Git at Google

 // Code generated by gen_sort_variants.go; DO NOT EDIT.

 // Copyright 2022 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package slices

 // insertionSortCmpFunc sorts data[a:b] using insertion sort.
 func insertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
 	for i := a + 1; i < b; i++ {
 		for j := i; j > a && (cmp(data[j], data[j-1]) < 0); j-- {
 			data[j], data[j-1] = data[j-1], data[j]
 		}
 	}
 }

 // siftDownCmpFunc implements the heap property on data[lo:hi].
 // first is an offset into the array where the root of the heap lies.
 func siftDownCmpFunc[E any](data []E, lo, hi, first int, cmp func(a, b E) int) {
 	root := lo
 	for {
 		child := 2*root + 1
 		if child >= hi {
 			break
 		}
 		if child+1 < hi && (cmp(data[first+child], data[first+child+1]) < 0) {
 			child++
 		}
 		if !(cmp(data[first+root], data[first+child]) < 0) {
 			return
 		}
 		data[first+root], data[first+child] = data[first+child], data[first+root]
 		root = child
 	}
 }

 func heapSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
 	first := a
 	lo := 0
 	hi := b - a

 	// Build heap with greatest element at top.
 	for i := (hi - 1) / 2; i >= 0; i-- {
 		siftDownCmpFunc(data, i, hi, first, cmp)
 	}

 	// Pop elements, largest first, into end of data.
 	for i := hi - 1; i >= 0; i-- {
 		data[first], data[first+i] = data[first+i], data[first]
 		siftDownCmpFunc(data, lo, i, first, cmp)
 	}
 }

 // pdqsortCmpFunc sorts data[a:b].
 // The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
 // pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
 // C++ implementation: https://github.com/orlp/pdqsort
 // Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
 // limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
 func pdqsortCmpFunc[E any](data []E, a, b, limit int, cmp func(a, b E) int) {
 	const maxInsertion = 12

 	var (
 		wasBalanced    = true // whether the last partitioning was reasonably balanced
 		wasPartitioned = true // whether the slice was already partitioned
 	)

 	for {
 		length := b - a

 		if length <= maxInsertion {
 			insertionSortCmpFunc(data, a, b, cmp)
 			return
 		}

 		// Fall back to heapsort if too many bad choices were made.
 		if limit == 0 {
 			heapSortCmpFunc(data, a, b, cmp)
 			return
 		}

 		// If the last partitioning was imbalanced, we need to breaking patterns.
 		if !wasBalanced {
 			breakPatternsCmpFunc(data, a, b, cmp)
 			limit--
 		}

 		pivot, hint := choosePivotCmpFunc(data, a, b, cmp)
 		if hint == decreasingHint {
 			reverseRangeCmpFunc(data, a, b, cmp)
 			// The chosen pivot was pivot-a elements after the start of the array.
 			// After reversing it is pivot-a elements before the end of the array.
 			// The idea came from Rust's implementation.
 			pivot = (b - 1) - (pivot - a)
 			hint = increasingHint
 		}

 		// The slice is likely already sorted.
 		if wasBalanced && wasPartitioned && hint == increasingHint {
 			if partialInsertionSortCmpFunc(data, a, b, cmp) {
 				return
 			}
 		}

 		// Probably the slice contains many duplicate elements, partition the slice into
 		// elements equal to and elements greater than the pivot.
 		if a > 0 && !(cmp(data[a-1], data[pivot]) < 0) {
 			mid := partitionEqualCmpFunc(data, a, b, pivot, cmp)
 			a = mid
 			continue
 		}

 		mid, alreadyPartitioned := partitionCmpFunc(data, a, b, pivot, cmp)
 		wasPartitioned = alreadyPartitioned

 		leftLen, rightLen := mid-a, b-mid
 		balanceThreshold := length / 8
 		if leftLen < rightLen {
 			wasBalanced = leftLen >= balanceThreshold
 			pdqsortCmpFunc(data, a, mid, limit, cmp)
 			a = mid + 1
 		} else {
 			wasBalanced = rightLen >= balanceThreshold
 			pdqsortCmpFunc(data, mid+1, b, limit, cmp)
 			b = mid
 		}
 	}
 }

 // partitionCmpFunc does one quicksort partition.
 // Let p = data[pivot]
 // Moves elements in data[a:b] around, so that data[i]<p and data[j]>=p for i<newpivot and j>newpivot.
 // On return, data[newpivot] = p
 func partitionCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int, alreadyPartitioned bool) {
 	data[a], data[pivot] = data[pivot], data[a]
 	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned

 	for i <= j && (cmp(data[i], data[a]) < 0) {
 		i++
 	}
 	for i <= j && !(cmp(data[j], data[a]) < 0) {
 		j--
 	}
 	if i > j {
 		data[j], data[a] = data[a], data[j]
 		return j, true
 	}
 	data[i], data[j] = data[j], data[i]
 	i++
 	j--

 	for {
 		for i <= j && (cmp(data[i], data[a]) < 0) {
 			i++
 		}
 		for i <= j && !(cmp(data[j], data[a]) < 0) {
 			j--
 		}
 		if i > j {
 			break
 		}
 		data[i], data[j] = data[j], data[i]
 		i++
 		j--
 	}
 	data[j], data[a] = data[a], data[j]
 	return j, false
 }

 // partitionEqualCmpFunc partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
 // It assumed that data[a:b] does not contain elements smaller than the data[pivot].
 func partitionEqualCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int) {
 	data[a], data[pivot] = data[pivot], data[a]
 	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned

 	for {
 		for i <= j && !(cmp(data[a], data[i]) < 0) {
 			i++
 		}
 		for i <= j && (cmp(data[a], data[j]) < 0) {
 			j--
 		}
 		if i > j {
 			break
 		}
 		data[i], data[j] = data[j], data[i]
 		i++
 		j--
 	}
 	return i
 }

 // partialInsertionSortCmpFunc partially sorts a slice, returns true if the slice is sorted at the end.
 func partialInsertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) bool {
 	const (
 		maxSteps         = 5  // maximum number of adjacent out-of-order pairs that will get shifted
 		shortestShifting = 50 // don't shift any elements on short arrays
 	)
 	i := a + 1
 	for j := 0; j < maxSteps; j++ {
 		for i < b && !(cmp(data[i], data[i-1]) < 0) {
 			i++
 		}

 		if i == b {
 			return true
 		}

 		if b-a < shortestShifting {
 			return false
 		}

 		data[i], data[i-1] = data[i-1], data[i]

 		// Shift the smaller one to the left.
 		if i-a >= 2 {
 			for j := i - 1; j >= 1; j-- {
 				if !(cmp(data[j], data[j-1]) < 0) {
 					break
 				}
 				data[j], data[j-1] = data[j-1], data[j]
 			}
 		}
 		// Shift the greater one to the right.
 		if b-i >= 2 {
 			for j := i + 1; j < b; j++ {
 				if !(cmp(data[j], data[j-1]) < 0) {
 					break
 				}
 				data[j], data[j-1] = data[j-1], data[j]
 			}
 		}
 	}
 	return false
 }

 // breakPatternsCmpFunc scatters some elements around in an attempt to break some patterns
 // that might cause imbalanced partitions in quicksort.
 func breakPatternsCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
 	length := b - a
 	if length >= 8 {
 		random := xorshift(length)
 		modulus := nextPowerOfTwo(length)

 		for idx := a + (length/4)*2 - 1; idx <= a+(length/4)*2+1; idx++ {
 			other := int(uint(random.Next()) & (modulus - 1))
 			if other >= length {
 				other -= length
 			}
 			data[idx], data[a+other] = data[a+other], data[idx]
 		}
 	}
 }

 // choosePivotCmpFunc chooses a pivot in data[a:b].
 //
 // [0,8): chooses a static pivot.
 // [8,shortestNinther): uses the simple median-of-three method.
 // [shortestNinther,∞): uses the Tukey ninther method.
 func choosePivotCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) (pivot int, hint sortedHint) {
 	const (
 		shortestNinther = 50
 		maxSwaps        = 4 * 3
 	)

 	l := b - a

 	var (
 		swaps int
 		i     = a + l/4*1
 		j     = a + l/4*2
 		k     = a + l/4*3
 	)

 	if l >= 8 {
 		if l >= shortestNinther {
 			// Tukey ninther method, the idea came from Rust's implementation.
 			i = medianAdjacentCmpFunc(data, i, &swaps, cmp)
 			j = medianAdjacentCmpFunc(data, j, &swaps, cmp)
 			k = medianAdjacentCmpFunc(data, k, &swaps, cmp)
 		}
 		// Find the median among i, j, k and stores it into j.
 		j = medianCmpFunc(data, i, j, k, &swaps, cmp)
 	}

 	switch swaps {
 	case 0:
 		return j, increasingHint
 	case maxSwaps:
 		return j, decreasingHint
 	default:
 		return j, unknownHint
 	}
 }

 // order2CmpFunc returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
 func order2CmpFunc[E any](data []E, a, b int, swaps *int, cmp func(a, b E) int) (int, int) {
 	if cmp(data[b], data[a]) < 0 {
 		*swaps++
 		return b, a
 	}
 	return a, b
 }

 // medianCmpFunc returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
 func medianCmpFunc[E any](data []E, a, b, c int, swaps *int, cmp func(a, b E) int) int {
 	a, b = order2CmpFunc(data, a, b, swaps, cmp)
 	b, c = order2CmpFunc(data, b, c, swaps, cmp)
 	a, b = order2CmpFunc(data, a, b, swaps, cmp)
 	return b
 }

 // medianAdjacentCmpFunc finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
 func medianAdjacentCmpFunc[E any](data []E, a int, swaps *int, cmp func(a, b E) int) int {
 	return medianCmpFunc(data, a-1, a, a+1, swaps, cmp)
 }

 func reverseRangeCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
 	i := a
 	j := b - 1
 	for i < j {
 		data[i], data[j] = data[j], data[i]
 		i++
 		j--
 	}
 }

 func swapRangeCmpFunc[E any](data []E, a, b, n int, cmp func(a, b E) int) {
 	for i := 0; i < n; i++ {
 		data[a+i], data[b+i] = data[b+i], data[a+i]
 	}
 }

 func stableCmpFunc[E any](data []E, n int, cmp func(a, b E) int) {
 	blockSize := 20 // must be > 0
 	a, b := 0, blockSize
 	for b <= n {
 		insertionSortCmpFunc(data, a, b, cmp)
 		a = b
 		b += blockSize
 	}
 	insertionSortCmpFunc(data, a, n, cmp)

 	for blockSize < n {
 		a, b = 0, 2*blockSize
 		for b <= n {
 			symMergeCmpFunc(data, a, a+blockSize, b, cmp)
 			a = b
 			b += 2 * blockSize
 		}
 		if m := a + blockSize; m < n {
 			symMergeCmpFunc(data, a, m, n, cmp)
 		}
 		blockSize *= 2
 	}
 }

 // symMergeCmpFunc merges the two sorted subsequences data[a:m] and data[m:b] using
 // the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
 // Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
 // Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
 // Computer Science, pages 714-723. Springer, 2004.
 //
 // Let M = m-a and N = b-n. Wolog M < N.
 // The recursion depth is bound by ceil(log(N+M)).
 // The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
 // The algorithm needs O((M+N)*log(M)) calls to data.Swap.
 //
 // The paper gives O((M+N)*log(M)) as the number of assignments assuming a
 // rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
 // in the paper carries through for Swap operations, especially as the block
 // swapping rotate uses only O(M+N) Swaps.
 //
 // symMerge assumes non-degenerate arguments: a < m && m < b.
 // Having the caller check this condition eliminates many leaf recursion calls,
 // which improves performance.
 func symMergeCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
 	// Avoid unnecessary recursions of symMerge
 	// by direct insertion of data[a] into data[m:b]
 	// if data[a:m] only contains one element.
 	if m-a == 1 {
 		// Use binary search to find the lowest index i
 		// such that data[i] >= data[a] for m <= i < b.
 		// Exit the search loop with i == b in case no such index exists.
 		i := m
 		j := b
 		for i < j {
 			h := int(uint(i+j) >> 1)
 			if cmp(data[h], data[a]) < 0 {
 				i = h + 1
 			} else {
 				j = h
 			}
 		}
 		// Swap values until data[a] reaches the position before i.
 		for k := a; k < i-1; k++ {
 			data[k], data[k+1] = data[k+1], data[k]
 		}
 		return
 	}

 	// Avoid unnecessary recursions of symMerge
 	// by direct insertion of data[m] into data[a:m]
 	// if data[m:b] only contains one element.
 	if b-m == 1 {
 		// Use binary search to find the lowest index i
 		// such that data[i] > data[m] for a <= i < m.
 		// Exit the search loop with i == m in case no such index exists.
 		i := a
 		j := m
 		for i < j {
 			h := int(uint(i+j) >> 1)
 			if !(cmp(data[m], data[h]) < 0) {
 				i = h + 1
 			} else {
 				j = h
 			}
 		}
 		// Swap values until data[m] reaches the position i.
 		for k := m; k > i; k-- {
 			data[k], data[k-1] = data[k-1], data[k]
 		}
 		return
 	}

 	mid := int(uint(a+b) >> 1)
 	n := mid + m
 	var start, r int
 	if m > mid {
 		start = n - b
 		r = mid
 	} else {
 		start = a
 		r = m
 	}
 	p := n - 1

 	for start < r {
 		c := int(uint(start+r) >> 1)
 		if !(cmp(data[p-c], data[c]) < 0) {
 			start = c + 1
 		} else {
 			r = c
 		}
 	}

 	end := n - start
 	if start < m && m < end {
 		rotateCmpFunc(data, start, m, end, cmp)
 	}
 	if a < start && start < mid {
 		symMergeCmpFunc(data, a, start, mid, cmp)
 	}
 	if mid < end && end < b {
 		symMergeCmpFunc(data, mid, end, b, cmp)
 	}
 }

 // rotateCmpFunc rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
 // Data of the form 'x u v y' is changed to 'x v u y'.
 // rotate performs at most b-a many calls to data.Swap,
 // and it assumes non-degenerate arguments: a < m && m < b.
 func rotateCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
 	i := m - a
 	j := b - m

 	for i != j {
 		if i > j {
 			swapRangeCmpFunc(data, m-i, m, j, cmp)
 			i -= j
 		} else {
 			swapRangeCmpFunc(data, m-i, m+j-i, i, cmp)
 			j -= i
 		}
 	}
 	// i == j
 	swapRangeCmpFunc(data, m-i, m, i, cmp)
 }
	// Code generated by gen_sort_variants.go; DO NOT EDIT.

	// Copyright 2022 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package slices

	// insertionSortCmpFunc sorts data[a:b] using insertion sort.
	func insertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
	for i := a + 1; i < b; i++ {
	for j := i; j > a && (cmp(data[j], data[j-1]) < 0); j-- {
	data[j], data[j-1] = data[j-1], data[j]
	}
	}
	}

	// siftDownCmpFunc implements the heap property on data[lo:hi].
	// first is an offset into the array where the root of the heap lies.
	func siftDownCmpFunc[E any](data []E, lo, hi, first int, cmp func(a, b E) int) {
	root := lo
	for {
	child := 2*root + 1
	if child >= hi {
	break
	}
	if child+1 < hi && (cmp(data[first+child], data[first+child+1]) < 0) {
	child++
	}
	if !(cmp(data[first+root], data[first+child]) < 0) {
	return
	}
	data[first+root], data[first+child] = data[first+child], data[first+root]
	root = child
	}
	}

	func heapSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
	first := a
	lo := 0
	hi := b - a

	// Build heap with greatest element at top.
	for i := (hi - 1) / 2; i >= 0; i-- {
	siftDownCmpFunc(data, i, hi, first, cmp)
	}

	// Pop elements, largest first, into end of data.
	for i := hi - 1; i >= 0; i-- {
	data[first], data[first+i] = data[first+i], data[first]
	siftDownCmpFunc(data, lo, i, first, cmp)
	}
	}

	// pdqsortCmpFunc sorts data[a:b].
	// The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
	// pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
	// C++ implementation: https://github.com/orlp/pdqsort
	// Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
	// limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
	func pdqsortCmpFunc[E any](data []E, a, b, limit int, cmp func(a, b E) int) {
	const maxInsertion = 12

	var (
	wasBalanced = true // whether the last partitioning was reasonably balanced
	wasPartitioned = true // whether the slice was already partitioned
	)

	for {
	length := b - a

	if length <= maxInsertion {
	insertionSortCmpFunc(data, a, b, cmp)
	return
	}

	// Fall back to heapsort if too many bad choices were made.
	if limit == 0 {
	heapSortCmpFunc(data, a, b, cmp)
	return
	}

	// If the last partitioning was imbalanced, we need to breaking patterns.
	if !wasBalanced {
	breakPatternsCmpFunc(data, a, b, cmp)
	limit--
	}

	pivot, hint := choosePivotCmpFunc(data, a, b, cmp)
	if hint == decreasingHint {
	reverseRangeCmpFunc(data, a, b, cmp)
	// The chosen pivot was pivot-a elements after the start of the array.
	// After reversing it is pivot-a elements before the end of the array.
	// The idea came from Rust's implementation.
	pivot = (b - 1) - (pivot - a)
	hint = increasingHint
	}

	// The slice is likely already sorted.
	if wasBalanced && wasPartitioned && hint == increasingHint {
	if partialInsertionSortCmpFunc(data, a, b, cmp) {
	return
	}
	}

	// Probably the slice contains many duplicate elements, partition the slice into
	// elements equal to and elements greater than the pivot.
	if a > 0 && !(cmp(data[a-1], data[pivot]) < 0) {
	mid := partitionEqualCmpFunc(data, a, b, pivot, cmp)
	a = mid
	continue
	}

	mid, alreadyPartitioned := partitionCmpFunc(data, a, b, pivot, cmp)
	wasPartitioned = alreadyPartitioned

	leftLen, rightLen := mid-a, b-mid
	balanceThreshold := length / 8
	if leftLen < rightLen {
	wasBalanced = leftLen >= balanceThreshold
	pdqsortCmpFunc(data, a, mid, limit, cmp)
	a = mid + 1
	} else {
	wasBalanced = rightLen >= balanceThreshold
	pdqsortCmpFunc(data, mid+1, b, limit, cmp)
	b = mid
	}
	}
	}

	// partitionCmpFunc does one quicksort partition.
	// Let p = data[pivot]
	// Moves elements in data[a:b] around, so that data[i]<p and data[j]>=p for i<newpivot and j>newpivot.
	// On return, data[newpivot] = p
	func partitionCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int, alreadyPartitioned bool) {
	data[a], data[pivot] = data[pivot], data[a]
	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned

	for i <= j && (cmp(data[i], data[a]) < 0) {
	i++
	}
	for i <= j && !(cmp(data[j], data[a]) < 0) {
	j--
	}
	if i > j {
	data[j], data[a] = data[a], data[j]
	return j, true
	}
	data[i], data[j] = data[j], data[i]
	i++
	j--

	for {
	for i <= j && (cmp(data[i], data[a]) < 0) {
	i++
	}
	for i <= j && !(cmp(data[j], data[a]) < 0) {
	j--
	}
	if i > j {
	break
	}
	data[i], data[j] = data[j], data[i]
	i++
	j--
	}
	data[j], data[a] = data[a], data[j]
	return j, false
	}

	// partitionEqualCmpFunc partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
	// It assumed that data[a:b] does not contain elements smaller than the data[pivot].
	func partitionEqualCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int) {
	data[a], data[pivot] = data[pivot], data[a]
	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned

	for {
	for i <= j && !(cmp(data[a], data[i]) < 0) {
	i++
	}
	for i <= j && (cmp(data[a], data[j]) < 0) {
	j--
	}
	if i > j {
	break
	}
	data[i], data[j] = data[j], data[i]
	i++
	j--
	}
	return i
	}

	// partialInsertionSortCmpFunc partially sorts a slice, returns true if the slice is sorted at the end.
	func partialInsertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) bool {
	const (
	maxSteps = 5 // maximum number of adjacent out-of-order pairs that will get shifted
	shortestShifting = 50 // don't shift any elements on short arrays
	)
	i := a + 1
	for j := 0; j < maxSteps; j++ {
	for i < b && !(cmp(data[i], data[i-1]) < 0) {
	i++
	}

	if i == b {
	return true
	}

	if b-a < shortestShifting {
	return false
	}

	data[i], data[i-1] = data[i-1], data[i]

	// Shift the smaller one to the left.
	if i-a >= 2 {
	for j := i - 1; j >= 1; j-- {
	if !(cmp(data[j], data[j-1]) < 0) {
	break
	}
	data[j], data[j-1] = data[j-1], data[j]
	}
	}
	// Shift the greater one to the right.
	if b-i >= 2 {
	for j := i + 1; j < b; j++ {
	if !(cmp(data[j], data[j-1]) < 0) {
	break
	}
	data[j], data[j-1] = data[j-1], data[j]
	}
	}
	}
	return false
	}

	// breakPatternsCmpFunc scatters some elements around in an attempt to break some patterns
	// that might cause imbalanced partitions in quicksort.
	func breakPatternsCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
	length := b - a
	if length >= 8 {
	random := xorshift(length)
	modulus := nextPowerOfTwo(length)

	for idx := a + (length/4)2 - 1; idx <= a+(length/4)2+1; idx++ {
	other := int(uint(random.Next()) & (modulus - 1))
	if other >= length {
	other -= length
	}
	data[idx], data[a+other] = data[a+other], data[idx]
	}
	}
	}

	// choosePivotCmpFunc chooses a pivot in data[a:b].
	//
	// [0,8): chooses a static pivot.
	// [8,shortestNinther): uses the simple median-of-three method.
	// [shortestNinther,∞): uses the Tukey ninther method.
	func choosePivotCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) (pivot int, hint sortedHint) {
	const (
	shortestNinther = 50
	maxSwaps = 4 * 3
	)

	l := b - a

	var (
	swaps int
	i = a + l/4*1
	j = a + l/4*2
	k = a + l/4*3
	)

	if l >= 8 {
	if l >= shortestNinther {
	// Tukey ninther method, the idea came from Rust's implementation.
	i = medianAdjacentCmpFunc(data, i, &swaps, cmp)
	j = medianAdjacentCmpFunc(data, j, &swaps, cmp)
	k = medianAdjacentCmpFunc(data, k, &swaps, cmp)
	}
	// Find the median among i, j, k and stores it into j.
	j = medianCmpFunc(data, i, j, k, &swaps, cmp)
	}

	switch swaps {
	case 0:
	return j, increasingHint
	case maxSwaps:
	return j, decreasingHint
	default:
	return j, unknownHint
	}
	}

	// order2CmpFunc returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
	func order2CmpFunc[E any](data []E, a, b int, swaps *int, cmp func(a, b E) int) (int, int) {
	if cmp(data[b], data[a]) < 0 {
	*swaps++
	return b, a
	}
	return a, b
	}

	// medianCmpFunc returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
	func medianCmpFunc[E any](data []E, a, b, c int, swaps *int, cmp func(a, b E) int) int {
	a, b = order2CmpFunc(data, a, b, swaps, cmp)
	b, c = order2CmpFunc(data, b, c, swaps, cmp)
	a, b = order2CmpFunc(data, a, b, swaps, cmp)
	return b
	}

	// medianAdjacentCmpFunc finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
	func medianAdjacentCmpFunc[E any](data []E, a int, swaps *int, cmp func(a, b E) int) int {
	return medianCmpFunc(data, a-1, a, a+1, swaps, cmp)
	}

	func reverseRangeCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
	i := a
	j := b - 1
	for i < j {
	data[i], data[j] = data[j], data[i]
	i++
	j--
	}
	}

	func swapRangeCmpFunc[E any](data []E, a, b, n int, cmp func(a, b E) int) {
	for i := 0; i < n; i++ {
	data[a+i], data[b+i] = data[b+i], data[a+i]
	}
	}

	func stableCmpFunc[E any](data []E, n int, cmp func(a, b E) int) {
	blockSize := 20 // must be > 0
	a, b := 0, blockSize
	for b <= n {
	insertionSortCmpFunc(data, a, b, cmp)
	a = b
	b += blockSize
	}
	insertionSortCmpFunc(data, a, n, cmp)

	for blockSize < n {
	a, b = 0, 2*blockSize
	for b <= n {
	symMergeCmpFunc(data, a, a+blockSize, b, cmp)
	a = b
	b += 2 * blockSize
	}
	if m := a + blockSize; m < n {
	symMergeCmpFunc(data, a, m, n, cmp)
	}
	blockSize *= 2
	}
	}

	// symMergeCmpFunc merges the two sorted subsequences data[a:m] and data[m:b] using
	// the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
	// Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
	// Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
	// Computer Science, pages 714-723. Springer, 2004.
	//
	// Let M = m-a and N = b-n. Wolog M < N.
	// The recursion depth is bound by ceil(log(N+M)).
	// The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
	// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
	//
	// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
	// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
	// in the paper carries through for Swap operations, especially as the block
	// swapping rotate uses only O(M+N) Swaps.
	//
	// symMerge assumes non-degenerate arguments: a < m && m < b.
	// Having the caller check this condition eliminates many leaf recursion calls,
	// which improves performance.
	func symMergeCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
	// Avoid unnecessary recursions of symMerge
	// by direct insertion of data[a] into data[m:b]
	// if data[a:m] only contains one element.
	if m-a == 1 {
	// Use binary search to find the lowest index i
	// such that data[i] >= data[a] for m <= i < b.
	// Exit the search loop with i == b in case no such index exists.
	i := m
	j := b
	for i < j {
	h := int(uint(i+j) >> 1)
	if cmp(data[h], data[a]) < 0 {
	i = h + 1
	} else {
	j = h
	}
	}
	// Swap values until data[a] reaches the position before i.
	for k := a; k < i-1; k++ {
	data[k], data[k+1] = data[k+1], data[k]
	}
	return
	}

	// Avoid unnecessary recursions of symMerge
	// by direct insertion of data[m] into data[a:m]
	// if data[m:b] only contains one element.
	if b-m == 1 {
	// Use binary search to find the lowest index i
	// such that data[i] > data[m] for a <= i < m.
	// Exit the search loop with i == m in case no such index exists.
	i := a
	j := m
	for i < j {
	h := int(uint(i+j) >> 1)
	if !(cmp(data[m], data[h]) < 0) {
	i = h + 1
	} else {
	j = h
	}
	}
	// Swap values until data[m] reaches the position i.
	for k := m; k > i; k-- {
	data[k], data[k-1] = data[k-1], data[k]
	}
	return
	}

	mid := int(uint(a+b) >> 1)
	n := mid + m
	var start, r int
	if m > mid {
	start = n - b
	r = mid
	} else {
	start = a
	r = m
	}
	p := n - 1

	for start < r {
	c := int(uint(start+r) >> 1)
	if !(cmp(data[p-c], data[c]) < 0) {
	start = c + 1
	} else {
	r = c
	}
	}

	end := n - start
	if start < m && m < end {
	rotateCmpFunc(data, start, m, end, cmp)
	}
	if a < start && start < mid {
	symMergeCmpFunc(data, a, start, mid, cmp)
	}
	if mid < end && end < b {
	symMergeCmpFunc(data, mid, end, b, cmp)
	}
	}

	// rotateCmpFunc rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
	// Data of the form 'x u v y' is changed to 'x v u y'.
	// rotate performs at most b-a many calls to data.Swap,
	// and it assumes non-degenerate arguments: a < m && m < b.
	func rotateCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
	i := m - a
	j := b - m

	for i != j {
	if i > j {
	swapRangeCmpFunc(data, m-i, m, j, cmp)
	i -= j
	} else {
	swapRangeCmpFunc(data, m-i, m+j-i, i, cmp)
	j -= i
	}
	}
	// i == j
	swapRangeCmpFunc(data, m-i, m, i, cmp)
	}