docs: private static void quickSort1(int off, int len, IntComparator comp, Swapper swapper) {
  	// Insertion sort on smallest arrays
  	if (len < SMALL) {
  		for (int i=off; i<len+off; i++)
  		for (int j=i; j>off && (comp.compare(j-1,j)>0); j--) {
  		    swapper.swap(j, j-1);
  		}
  		return;
  	}
  
  	// Choose a partition element, v
  	int m = off + len/2;       // Small arrays, middle element
  	if (len > SMALL) {
  		int l = off;
  		int n = off + len - 1;
  		if (len > MEDIUM) {        // Big arrays, pseudomedian of 9
  			int s = len/8;
  			l = med3(l,     l+s, l+2*s, comp);
  			m = med3(m-s,   m,   m+s, comp);
  			n = med3(n-2*s, n-s, n, comp);
  		}
  		m = med3(l, m, n, comp); // Mid-size, med of 3
  	}
  	//long v = x[m];
  	
  	// Establish Invariant: v* (<v)* (>v)* v*
  	int a = off, b = a, c = off + len - 1, d = c;
  	while(true) {
  		int comparison;
  		while (b <= c && ((comparison=comp.compare(b,m))<=0)) {
  			if (comparison == 0) {
  				if (a==m) m = b; // moving target; DELTA to JDK !!!
  				else if (b==m) m = a; // moving target; DELTA to JDK !!!
  			    swapper.swap(a++, b);
  			}
  			b++;
  		}
  		while (c >= b && ((comparison=comp.compare(c,m))>=0)) {
  			if (comparison == 0) {
  				if (c==m) m = d; // moving target; DELTA to JDK !!!
  				else if (d==m) m = c; // moving target; DELTA to JDK !!!
  			    swapper.swap(c, d--);
  			}
  			c--;
  		}
  		if (b > c) break;
  		if (b==m) m = d; // moving target; DELTA to JDK !!!
  		else if (c==m) m = c; // moving target; DELTA to JDK !!!
  		swapper.swap(b++, c--);
  	}
  
  	// Swap partition elements back to middle
  	int s, n = off + len;
  	s = java.lang.Math.min(a-off, b-a  );  vecswap(swapper, off, b-s, s);
  	s = java.lang.Math.min(d-c,   n-d-1);  vecswap(swapper, b,   n-s, s);
  
  	// Recursively sort non-partition-elements
  	if ((s = b-a) > 1) 
  		quickSort1(off, s, comp, swapper);
  	if ((s = d-c) > 1) 
  		quickSort1(n-s, s, comp, swapper);
  }