static void quicksortlu(register long unsigned *const v,const unsigned n)
{
  register long unsigned T;

  if (n < 2)
    return;

  {
#   define stackMAX 100
    unsigned stackB[stackMAX];
    unsigned stackN[stackMAX];
    unsigned depth;

    unsigned statDepthMax = 0;
    unsigned statPartSize1 = 0;
    unsigned statPartSize2 = 0;
    unsigned statPartSizeN = 0;

    stackB[0] = 0;
    stackN[0] = n;
    depth = 1;

    do
      {
	const unsigned b = stackB[depth-1];
	const unsigned n = stackN[depth-1];

	if (depth > statDepthMax)
	  statDepthMax = depth;

	if (n == 1)
	  statPartSize1++;
	else if (n == 2)
	  {
	    statPartSize2++;

	    if (v[b] > v[b+1])
	      SWAP(T,v[b],v[b+1]);

	    --depth;
	  }
	else
	  {
	    const unsigned pi = (b+n-1) >> 1;
	    const long unsigned p = v[pi];
	    unsigned l = b+1;
	    unsigned r = b+n-1;

	    statPartSizeN++;

	    while (l < r)
	      if (v[l] <= p)	l++;
	      else		SWAP(T,v[l],v[r]),--r;

	    {
	      register long unsigned vl = v[l], vr = v[r];

	      if (vl <= p && vr <= p)		l = r+1;
	      else if (vl <= p && p < vr)	l++,--r;
	      else if (vr <= p && p < vl)	SWAP(T,v[l],v[r]),l++,--r;
	      else				r = l-1;
	    }

	    SWAP(T,v[r],v[b]),--r;

	    --depth;

	    {
	      const unsigned m1 = r-b+1;
	      const unsigned m2 = b+n-l;

	      fprintf(stderr,"m1 %u, m2 %u\n",m1,m2);

	      if (m1 > 1)
		{
		  stackB[depth] = b;
		  stackN[depth] = m1;
		  depth++;
		}

	      if (m2 > 1)
		{
		  stackB[depth] = l;
		  stackN[depth] = m2;
		  depth++;
		}
	    }
	  }
      }
    while (depth != 0);

    fprintf(stderr,"quicksortlu: max depth %u, size1 %u, size2 %u, sizeN %u\n",
	    statDepthMax,statPartSize1,statPartSize2,statPartSizeN);
  }
}