Index: src/tests/concurrent/examples/boundedBuffer.c
===================================================================
--- src/tests/concurrent/examples/boundedBuffer.c	(revision f7397880750e07e837239917d936c796fff29c30)
+++ src/tests/concurrent/examples/boundedBuffer.c	(revision cd3aee209938ee02e412040e59eebda1a7e26be0)
@@ -8,6 +8,6 @@
 // Created On       : Mon Oct 30 12:45:13 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec 13 21:01:49 2017
-// Update Count     : 27
+// Last Modified On : Thu Dec 14 21:28:52 2017
+// Update Count     : 32
 //
 
@@ -18,21 +18,17 @@
 #include <unistd.h>										// getpid
 
-forall( otype T )
 monitor Buffer {
 	condition full, empty;
 	int front, back, count;
-	T elements[20];
+	int elements[20];
 };
 
-forall( otype T )
-void ?{}( Buffer(T) & buffer ) {
+void ?{}( Buffer & buffer ) {
 	buffer.front = buffer.back = buffer.count = 0;
 }
 
-forall( otype T )
-int query( Buffer(T) & buffer ) { return buffer.count; }
+int query( Buffer & buffer ) { return buffer.count; }
 
-forall( otype T )
-void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) {
+void insert( Buffer & mutex buffer, int elem ) with( buffer ) {
 	if ( count == 20 ) wait( empty );
 	elements[back] = elem;
@@ -42,8 +38,7 @@
 }
 
-forall( otype T )
-T remove( Buffer(T) & mutex buffer ) with( buffer ) {
+int remove( Buffer & mutex buffer ) with( buffer ) {
 	if ( count == 0 ) wait( full );
-	T elem = elements[front];
+	int elem = elements[front];
 	front = ( front + 1 ) % 20;
 	count -= 1;
@@ -53,5 +48,5 @@
 
 thread Producer {
-	Buffer(int) & buffer;
+	Buffer & buffer;
 	unsigned int N;
 };
@@ -63,5 +58,5 @@
 	insert( prod.buffer, -1 );
 }
-void ?{}( Producer & prod, Buffer(int) * buffer, unsigned int N ) {
+void ?{}( Producer & prod, Buffer * buffer, unsigned int N ) {
 	&prod.buffer = buffer;
 	prod.N = N;
@@ -69,5 +64,5 @@
 
 thread Consumer {
-	Buffer(int) & buffer;
+	Buffer & buffer;
 	int & sum;						// summation of producer values
 };
@@ -81,5 +76,5 @@
 	} // for
 }
-void ?{}( Consumer & cons, Buffer(int) * buffer, int * sum ) {
+void ?{}( Consumer & cons, Buffer * buffer, int * sum ) {
 	&cons.buffer = buffer;
 	&cons.sum = sum;
@@ -87,5 +82,5 @@
 
 int main() {
-	Buffer(int) buffer;
+	Buffer buffer;
 	enum { Prods = 5, Cons = 5 };
 	Producer * prods[Prods];
Index: src/tests/concurrent/examples/quickSort.c
===================================================================
--- src/tests/concurrent/examples/quickSort.c	(revision f7397880750e07e837239917d936c796fff29c30)
+++ src/tests/concurrent/examples/quickSort.c	(revision cd3aee209938ee02e412040e59eebda1a7e26be0)
@@ -9,6 +9,6 @@
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec 13 18:20:18 2017
-// Update Count     : 138
+// Last Modified On : Thu Dec 14 11:20:40 2017
+// Update Count     : 142
 // 
 
@@ -19,5 +19,5 @@
 #include <string.h>										// strcmp
 
-forall( otype T | { T ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 thread Quicksort {
 	T * values;											// communication variables
@@ -25,10 +25,10 @@
 };
 
-forall( otype T | { T ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void ?{}( Quicksort(T) & qs, T values[], int size, int depth ) {
 	qs.values = values;  qs.low = 0;  qs.high = size;  qs.depth = depth;
 } // Quicksort
 
-forall( otype T | { T ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void main( Quicksort(T) & qs ) {
 	// nested routines: information hiding
@@ -140,5 +140,7 @@
 			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 = 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 );
 			for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers
 				unsortedfile | values[counter];
@@ -165,5 +167,6 @@
 		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 = 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
 		for ( int counter = 0; counter < size; counter += 1 ) { // generate unsorted numbers
 			values[counter] = size - counter;			// descending values