import java.util.*;

class MultiRadixPar{
	int n;
	int [] a;
	final static int NUM_BIT = 7; // alle tall 6-11 .. finn ut hvilken verdi som er best
	int nThreads = Math.min(
		Runtime.getRuntime().availableProcessors(),
		8);

	int []  radixMulti(int [] a) {
		long tt = System.nanoTime();
		// 1-5 digit radixSort of : a[]
		int max = a[0], numBit = 2, numDigits, n =a.length;
		int [] bit ;

		// a) finn max verdi i a[]
		//Timer ta = new Timer().start();
		for (int i = 1 ; i < n ; i++)
			if (a[i] > max) max = a[i];
		while (max >= (1L<<numBit) )numBit++; // antall binaere siffer i max
		//System.out.println("A: "+ta.end().prettyTime());

		// bestem antall bit i numBits sifre
		numDigits = Math.max(1, numBit/NUM_BIT);
		bit = new int[numDigits];
		int rest = (numBit%numDigits), sum =0;;

		// fordel bitene vi skal sortere paa jevnt
		for (int i = 0; i < bit.length; i++){
			bit[i] = numBit/numDigits;
			if ( rest-- > 0)  bit[i]++;
		}

		int[] t=a, b = new int [n];

		for (int i =0; i < bit.length; i++) {
			radixSort( a,b,bit[i],sum );    // i-te siffer fra a[] til b[]
			sum += bit[i];
			// swap arrays (pointers only)
			t = a;
			a = b;
			b = t;
		}

		return a;
	} // end radixMulti

	class Worker implements Runnable {
		int start, end, shift, mask;
		int[] a, b, count;

		Worker(int start, int end, int[] a, int[] b, int[] count, int shift, int mask) {
			this.start = start;
			this.end = end;
			this.a = a;
			this.b = b;
			this.count = count;
			this.shift = shift;
			this.mask = mask;
		}

		public void run() {
			for (int i = 0; i < a.length; i++) {
				int var = (a[i] >>> shift) & mask;
				if (var >= start && var < end) {
					b[count[var]++] = a[i];
				}
			}
		}
	}

	/** Sort a[] on one digit ; number of bits = maskLen, shiftet up 'shift' bits */
	void radixSort ( int [] a, int [] b, int maskLen, int shift){
		int n = a.length;
		int mask = (1<<maskLen) -1;
		int [] count = new int [mask+1];

		// b) count=the frequency of each radix value in a
		//Timer tb = new Timer().start();
		for (int i = 0; i < n; i++) {
			int var = (a[i]>>>shift) & mask;
			count[var]++;
		}
		//System.out.println("B: "+tb.end().prettyTime());

		// c) Add up in 'count' - accumulated values
		//Timer tc = new Timer().start();
		int j = 0;
		int acumVal = 0;
		for (int i = 0; i <= mask; i++) {
			j = count[i];
			count[i] = acumVal;
			acumVal += j;
		}
		//System.out.println("C: "+tc.end().prettyTime());

		Timer td = new Timer().start();
		int d = n / nThreads;
		Thread[] threads = new Thread[nThreads];
		for (int i = 0; i < nThreads; ++i) {
			int start = d * i;
			int end = i == nThreads - 1 ? n + 1 : d * (i + 1);

			Worker w = new Worker(start, end, a, b, count, shift, mask);
			Thread t = threads[i] = new Thread(w);
			t.start();
		}

		for (Thread t: threads) {
			try { t.join(); } catch (InterruptedException ex) {}
		}
		System.out.println("par D: "+td.end().prettyTime());

		//System.out.println("");
	}// end radixSort

	void testSort(int [] a){
		for (int i = 0; i< a.length-1;i++) {
			if (a[i] > a[i+1]){
				System.out.println("SorteringsFEIL på plass: "+i +" a["+i+"]:"+a[i]+" > a["+(i+1)+"]:"+a[i+1]);
				return;
			}
		}
	}// end simple sorteingstest
}// end SekvensiellRadix