U0 QuickSortI64(I64 *base, I64 num, I64 (*fp_compare)(I64 e1, I64 e2))
{/*Quick Sort for width==8.
fp_compare() passes by value instead of ref.

For ascending strings: return StrCompare(e1,e2);
For ascending ints	 : return e1-e2;

Maybe, look at $LK,"::/Demo/MultiCore/MPRadix.CC"$.
*/
	I64 i, *left, *right, pivot;

	if (num > 1)
	{
		left  = base;
		right = base + num - 1;
		pivot = base[num / 2];
		do
		{
			while ((*fp_compare)(*left, pivot) < 0)
				left++;
			while ((*fp_compare)(*right, pivot) > 0)
				right--;
			if (left <= right)
				SwapI64(left++, right--);
		}
		while (left <= right);

		i = right + 1 - base;
		if (1 < i < num)
			QuickSortI64(base, i, fp_compare);
		i = base + num - left;
		if (1 < i < num)
			QuickSortI64(left, i, fp_compare);
	}
}

U0 QuickSort2a(U8 **base, I64 num, I64 (*fp_compare)(U8 **_e1, U8 **_e2))
{//Not public.For case of width==size(U8 *)==8.
//fp_compare() passes by ref.
	I64  i;
	U8 **left, **right, *pivot;

	left  = base;
	right = base + num - 1;
	pivot = base[num / 2];
	do
	{
		while ((*fp_compare)(left, &pivot) < 0)
			left++;
		while ((*fp_compare)(right, &pivot) > 0)
			right--;
		if (left <= right)
			SwapI64(left++, right--);
	}
	while (left <= right);

	i = right + 1 - base;
	if (1 < i < num)
		QuickSort2a(base, i, fp_compare);
	i = base + num - left;
	if (1 < i < num)
		QuickSort2a(left, i, fp_compare);
}
U0 QuickSort2b(U8 *base, I64 num, I64 width, I64 (*fp_compare)(U8 *e1, U8 *e2), U8 *tmp)
{//Not public
	I64 i;
	U8 *left, *right, *pivot = tmp + width;

	left  = base;
	right = base + (num - 1) * width;
	MemCopy(pivot, base + num / 2 * width, width);
	do
	{
		while ((*fp_compare)(left, pivot) < 0)
			left += width;
		while ((*fp_compare)(right, pivot) > 0)
			right -= width;
		if (left <= right)
		{
			if (left != right)
			{
				MemCopy(tmp, right, width);
				MemCopy(right, left, width);
				MemCopy(left, tmp, width);
			}
			left  += width;
			right -= width;
		}
	}
	while (left <= right);

	i = 1 + (right - base) / width;
	if (1 < i < num)
		QuickSort2b(base, i, width, fp_compare, tmp);
	i = num + (base - left) / width;
	if (1 < i < num)
		QuickSort2b(left, i, width, fp_compare, tmp);
}
U0 QuickSort(U8 *base, I64 num, I64 width, I64 (*fp_compare)(U8 *e1, U8 *e2))
{/*Quick Sort: fp_compare() passes by ref.

For ascending strings: return StrCompare(*e1,*e2);
For ascending ints	 : return *e1-*e2;
Don't return e1-e2 if numbers can overflow, return -1,0 or 1.

Maybe, look at $LK,"::/Demo/MultiCore/MPRadix.CC"$.
*/
	U8 *tmp;

	if (width && num > 1)
	{
		if (width == sizeof(U8 *))		//assign instead of MemCopy for width 8
			QuickSort2a(base, num, fp_compare);
		else
		{
			tmp = MAlloc(width * 2);
			QuickSort2b(base, num, width, fp_compare, tmp);
			Free(tmp);
		}
	}
}
