Index: src/tests/concurrent/examples/.expect/quickSort.txt
===================================================================
--- src/tests/concurrent/examples/.expect/quickSort.txt	(revision f0322e2081a0f0317a6822041312273f4fd2881d)
+++ src/tests/concurrent/examples/.expect/quickSort.txt	(revision f0322e2081a0f0317a6822041312273f4fd2881d)
@@ -0,0 +1,32 @@
+25 6 8 -5 99 100 101 7
+-5 6 7 8 25 99 100 101
+
+1 -3 5
+-3 1 5
+
+
+
+
+9 8 7 6 5 4 3 2 1 0
+0 1 2 3 4 5 6 7 8 9
+
+1 2 3 4 5
+1 2 3 4 5
+
+5 4 3 2 1
+1 2 3 4 5
+
+3 1 5 4 2
+1 2 3 4 5
+
+
+
+
+1 1 1 1 1
+1 1 1 1 1
+
+29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8
+  7 6 5 4 3 2 1 0
+0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
+  22 23 24 25 26 27 28 29
+
Index: src/tests/concurrent/examples/quickSort.c
===================================================================
--- src/tests/concurrent/examples/quickSort.c	(revision b834e98393306fc30c2857f5d569dc319f987d67)
+++ src/tests/concurrent/examples/quickSort.c	(revision f0322e2081a0f0317a6822041312273f4fd2881d)
@@ -9,6 +9,6 @@
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec 14 11:20:40 2017
-// Update Count     : 142
+// Last Modified On : Mon Jan 29 08:41:37 2018
+// Update Count     : 155
 // 
 
@@ -19,27 +19,24 @@
 #include <string.h>										// strcmp
 
-forall( otype T | { int ?<?( T, T ); } )
 thread Quicksort {
-	T * values;											// communication variables
+	int * values;										// communication variables
 	int low, high, depth;
 };
 
-forall( otype T | { int ?<?( T, T ); } )
-void ?{}( Quicksort(T) & qs, T values[], int size, int depth ) {
+void ?{}( Quicksort & qs, int values[], int size, int depth ) {
 	qs.values = values;  qs.low = 0;  qs.high = size;  qs.depth = depth;
 } // Quicksort
 
-forall( otype T | { int ?<?( T, T ); } )
-void main( Quicksort(T) & qs ) {
+void main( Quicksort & qs ) {							// thread starts here
 	// nested routines: information hiding
 
-	void ?{}( Quicksort(T) & qs, T values[], int low, int high, int depth ) {
+	void ?{}( Quicksort & qs, int values[], int low, int high, int depth ) {
 		qs.values = values;  qs.low = low;  qs.high = high;  qs.depth = depth;
 	} // Quicksort
 
-	void sort( T values[], int low, int high, int depth ) {
+	void sort( int values[], int low, int high, int depth ) {
 		int left, right;								// index to left/right-hand side of the values
-		T pivot;										// pivot value of values
-		T swap;											// temporary
+		int pivot;										// pivot value of values
+		int swap;										// temporary
 
 		//verify();										// check for stack overflow due to recursion
@@ -67,6 +64,5 @@
 			if ( depth > 0 ) {
 				depth -= 1;
-				//sout << &uThisTask() << " " << depth << endl;
-				Quicksort(T) rqs = { values, low, right, depth }; // concurrently sort upper half
+				Quicksort rqs = { values, low, right, depth }; // concurrently sort upper half
 				//Quicksort lqs( values, left, high, depth ); // concurrently sort lower half
 				sort( values, left, high, depth );		// concurrently sort lower half
@@ -97,6 +93,4 @@
 
 
-#define ELEMTYPE int
-
 int main( int argc, char * argv[] ) {
 	ifstream & unsortedfile = sin;
@@ -106,22 +100,7 @@
 	if ( argc != 1 ) {									// do not use defaults
 		if ( argc < 2 || argc > 4 ) usage( argv );		// wrong number of options
-		if ( strcmp( argv[1], "-s" ) == 0 ) {
-			choose ( argc ) {
-			  case 4:
-				&sortedfile = new( (const char *)argv[3] ); // open the output file
-				if ( fail( sortedfile ) ) {
-					serr | "Error! Could not open sorted output file \"" | argv[3] | "\"" | endl;
-					usage( argv );
-				} // if
-				fallthrough;
-			  case 3:
-				&unsortedfile = new( (const char *)argv[2] ); // open the input file
-				if ( fail( unsortedfile ) ) {
-					serr | "Error! Could not open unsorted input file \"" | argv[2] | "\"" | endl;
-					usage( argv );
-				} // if
-			} // choose
-		} else if ( strcmp( argv[1], "-t" ) == 0 ) {
-			unsortedfile = *(ifstream *)0;				// no input
+//		if ( strcmp( argv[1], "-t" ) == 0 ) {			// timing ?
+		if ( argv[1][0] == '-' && argv[1][1] == 't' ) {	// timing ?
+			&unsortedfile = (ifstream *)0;				// no input
 			choose ( argc ) {
 			  case 4:
@@ -131,5 +110,21 @@
 				if ( ! convert( size, argv[2] ) || size < 0 ) usage( argv );
 			} // choose
-		} else usage( argv );							// invalid flag
+		} else {										// sort file
+			choose ( argc ) {
+			  case 3:
+				&sortedfile = new( (const char *)argv[2] ); // open the output file
+				if ( fail( sortedfile ) ) {
+					serr | "Error! Could not open sorted output file \"" | argv[2] | "\"" | endl;
+					usage( argv );
+				} // if
+				fallthrough;
+			  case 2:
+				&unsortedfile = new( (const char *)argv[1] ); // open the input file
+				if ( fail( unsortedfile ) ) {
+					serr | "Error! Could not open unsorted input file \"" | argv[1] | "\"" | endl;
+					usage( argv );
+				} // if
+			} // choose
+		} // if
 	} // if
 
@@ -140,7 +135,5 @@
 			unsortedfile | size;						// read number of elements in the list
 		  if ( eof( unsortedfile ) ) break;
-//			ELEMTYPE * values = anew( size );			// values to be sorted, too large to put on stack
-			ELEMTYPE * values = alloc( size );			// values to be sorted, too large to put on stack
-//			ELEMTYPE * values = (ELEMTYPE *)malloc( sizeof(ELEMTYPE) * size );
+			int * values = alloc( size );				// values to be sorted, too large to put on stack
 			for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers
 				unsortedfile | values[counter];
@@ -151,5 +144,5 @@
 			sortedfile | endl;
 			if ( size > 0 ) {							// values to sort ?
-				Quicksort(ELEMTYPE) QS = { values, size - 1, 0 }; // sort values
+				Quicksort QS = { values, size - 1, 0 }; // sort values
 			} // wait until sort tasks terminate
 			for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list
@@ -167,11 +160,10 @@
 		processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads
 
-//		ELEMTYPE * values = anew( size );				// values to be sorted, too large to put on stack
-		ELEMTYPE * values = alloc( size );				// values to be sorted, too large to put on stack
+		int * values = alloc( size );				// values to be sorted, too large to put on stack
 		for ( int counter = 0; counter < size; counter += 1 ) { // generate unsorted numbers
 			values[counter] = size - counter;			// descending values
 		} // for
 		{
-			Quicksort(ELEMTYPE) QS = { values, size - 1, depth }; // sort values
+			Quicksort QS = { values, size - 1, depth }; // sort values
 		} // wait until sort tasks terminate