Index: tests/concurrent/examples/boundedBufferEXT.c
===================================================================
--- tests/concurrent/examples/boundedBufferEXT.c	(revision 5ea5b28f99a21543ee16545ccb212eddbb550eff)
+++ 	(revision )
@@ -1,123 +1,0 @@
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// boundedBufferEXT.c --
-//
-// Author           : Peter A. Buhr
-// Created On       : Wed Apr 18 22:52:12 2018
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec 11 21:55:02 2018
-// Update Count     : 9
-//
-
-#include <stdlib.hfa>										// random
-#include <fstream.hfa>
-#include <kernel.hfa>
-#include <thread.hfa>
-#include <unistd.h>										// getpid
-
-//Duration default_preemption() { return 0; }
-
-enum { BufferSize = 50 };
-
-forall( otype T ) {
-	monitor Buffer {
-		int front, back, count;
-		T elements[BufferSize];
-	}; // Buffer
-
-	void ?{}( Buffer(T) & buffer ) with( buffer ) { [front, back, count] = 0; }
-
-	int query( Buffer(T) & buffer ) { return buffer.count; } // read-only, no mutual exclusion
-
-	T remove( Buffer(T) & mutex buffer );				// forward
-
-	void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) {
-		if ( count == BufferSize ) waitfor( remove, buffer );
-		elements[back] = elem;
-		back = ( back + 1 ) % BufferSize;
-		count += 1;
-	} // insert
-
-	T remove( Buffer(T) & mutex buffer ) with( buffer ) {
-		if ( count == 0 ) waitfor( insert, buffer );
-		T elem = elements[front];
-		front = ( front + 1 ) % BufferSize;
-		count -= 1;
-		return elem;
-	} // remove
-}
-
-const int Sentinel = -1;
-
-thread Producer {
-	Buffer(int) & buffer;
-	unsigned int N;
-};
-void main( Producer & prod ) with( prod ) {
-	for ( int i = 1; i <= N; i += 1 ) {
-		yield( random( 5 ) );
-		insert( buffer, 1 );
-	} // for
-}
-void ?{}( Producer & prod, Buffer(int) * buffer, int N ) {
-	&prod.buffer = buffer;
-	prod.N = N;
-}
-
-thread Consumer {
-	Buffer(int) & buffer;
-	int & sum;											// summation of producer values
-};
-void main( Consumer & cons ) with( cons ) {
-	sum = 0;
-	for () {
-		yield( random( 5 ) );
-		int item = remove( buffer );
-	  if ( item == Sentinel ) break;					// sentinel ?
-		sum += item;
-	} // for
-}
-void ?{}( Consumer & cons, Buffer(int) * buffer, int & sum ) {
-	&cons.buffer = buffer;
-	&cons.sum = &sum;
-}
-
-int main() {
-	Buffer(int) buffer;
-	enum { Prods = 4, Cons = 5 };
-	Producer * prods[Prods];
-	Consumer * cons[Cons];
-	int sums[Cons];
-	int i;
-	processor p;
-
-	//srandom( getpid() );
-	srandom( 1003 );
-
-	for ( i = 0; i < Cons; i += 1 ) {					// create consumers
-		cons[i] = new( &buffer, sums[i] );
-	} // for
-	for ( i = 0; i < Prods; i += 1 ) {					// create producers
-		prods[i] = new( &buffer, 100000 );
-	} // for
-
-	for ( i = 0; i < Prods; i += 1 ) {					// wait for producers to finish
-		delete( prods[i] );
-	} // for
-	for ( i = 0; i < Cons; i += 1 ) {					// generate sentinal values to stop consumers
-		insert( buffer, Sentinel );
-	} // for
-	int sum = 0;
-	for ( i = 0; i < Cons; i += 1 ) {					// wait for consumers to finish
-		delete( cons[i] );
-		sum += sums[i];
-	} // for
-	sout | "total:" | sum;
-}
-
-// Local Variables: //
-// tab-width: 4 //
-// compile-command: "cfa boundedBufferEXT.c" //
-// End: //
Index: tests/concurrent/examples/boundedBufferEXT.cfa
===================================================================
--- tests/concurrent/examples/boundedBufferEXT.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
+++ tests/concurrent/examples/boundedBufferEXT.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
@@ -0,0 +1,123 @@
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// boundedBufferEXT.c --
+//
+// Author           : Peter A. Buhr
+// Created On       : Wed Apr 18 22:52:12 2018
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Dec 11 21:55:02 2018
+// Update Count     : 9
+//
+
+#include <stdlib.hfa>										// random
+#include <fstream.hfa>
+#include <kernel.hfa>
+#include <thread.hfa>
+#include <unistd.h>										// getpid
+
+//Duration default_preemption() { return 0; }
+
+enum { BufferSize = 50 };
+
+forall( otype T ) {
+	monitor Buffer {
+		int front, back, count;
+		T elements[BufferSize];
+	}; // Buffer
+
+	void ?{}( Buffer(T) & buffer ) with( buffer ) { [front, back, count] = 0; }
+
+	int query( Buffer(T) & buffer ) { return buffer.count; } // read-only, no mutual exclusion
+
+	T remove( Buffer(T) & mutex buffer );				// forward
+
+	void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) {
+		if ( count == BufferSize ) waitfor( remove, buffer );
+		elements[back] = elem;
+		back = ( back + 1 ) % BufferSize;
+		count += 1;
+	} // insert
+
+	T remove( Buffer(T) & mutex buffer ) with( buffer ) {
+		if ( count == 0 ) waitfor( insert, buffer );
+		T elem = elements[front];
+		front = ( front + 1 ) % BufferSize;
+		count -= 1;
+		return elem;
+	} // remove
+}
+
+const int Sentinel = -1;
+
+thread Producer {
+	Buffer(int) & buffer;
+	unsigned int N;
+};
+void main( Producer & prod ) with( prod ) {
+	for ( int i = 1; i <= N; i += 1 ) {
+		yield( random( 5 ) );
+		insert( buffer, 1 );
+	} // for
+}
+void ?{}( Producer & prod, Buffer(int) * buffer, int N ) {
+	&prod.buffer = buffer;
+	prod.N = N;
+}
+
+thread Consumer {
+	Buffer(int) & buffer;
+	int & sum;											// summation of producer values
+};
+void main( Consumer & cons ) with( cons ) {
+	sum = 0;
+	for () {
+		yield( random( 5 ) );
+		int item = remove( buffer );
+	  if ( item == Sentinel ) break;					// sentinel ?
+		sum += item;
+	} // for
+}
+void ?{}( Consumer & cons, Buffer(int) * buffer, int & sum ) {
+	&cons.buffer = buffer;
+	&cons.sum = &sum;
+}
+
+int main() {
+	Buffer(int) buffer;
+	enum { Prods = 4, Cons = 5 };
+	Producer * prods[Prods];
+	Consumer * cons[Cons];
+	int sums[Cons];
+	int i;
+	processor p;
+
+	//srandom( getpid() );
+	srandom( 1003 );
+
+	for ( i = 0; i < Cons; i += 1 ) {					// create consumers
+		cons[i] = new( &buffer, sums[i] );
+	} // for
+	for ( i = 0; i < Prods; i += 1 ) {					// create producers
+		prods[i] = new( &buffer, 100000 );
+	} // for
+
+	for ( i = 0; i < Prods; i += 1 ) {					// wait for producers to finish
+		delete( prods[i] );
+	} // for
+	for ( i = 0; i < Cons; i += 1 ) {					// generate sentinal values to stop consumers
+		insert( buffer, Sentinel );
+	} // for
+	int sum = 0;
+	for ( i = 0; i < Cons; i += 1 ) {					// wait for consumers to finish
+		delete( cons[i] );
+		sum += sums[i];
+	} // for
+	sout | "total:" | sum;
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa boundedBufferEXT.c" //
+// End: //
Index: tests/concurrent/examples/boundedBufferINT.c
===================================================================
--- tests/concurrent/examples/boundedBufferINT.c	(revision 5ea5b28f99a21543ee16545ccb212eddbb550eff)
+++ 	(revision )
@@ -1,124 +1,0 @@
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// boundedBuffer.c --
-//
-// Author           : Peter A. Buhr
-// Created On       : Mon Oct 30 12:45:13 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec 11 21:55:45 2018
-// Update Count     : 84
-//
-
-#include <stdlib.hfa>										// random
-#include <fstream.hfa>
-#include <kernel.hfa>
-#include <thread.hfa>
-#include <unistd.h>										// getpid
-
-//Duration default_preemption() { return 0; }
-
-enum { BufferSize = 50 };
-
-forall( otype T ) {
-	monitor Buffer {
-		condition full, empty;
-		int front, back, count;
-		T elements[BufferSize];
-	}; // Buffer
-
-	void ?{}( Buffer(T) & buffer ) with( buffer ) { [front, back, count] = 0; }
-
-	int query( Buffer(T) & buffer ) { return buffer.count; } // read-only, no mutual exclusion
-
-	void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) {
-		if ( count == BufferSize ) wait( empty );
-		elements[back] = elem;
-		back = ( back + 1 ) % BufferSize;
-		count += 1;
-		signal( full );
-	} // insert
-
-	T remove( Buffer(T) & mutex buffer ) with( buffer ) {
-		if ( count == 0 ) wait( full );
-		T elem = elements[front];
-		front = ( front + 1 ) % BufferSize;
-		count -= 1;
-		signal( empty );
-		return elem;
-	} // remove
-}
-
-const int Sentinel = -1;
-
-thread Producer {
-	Buffer(int) & buffer;
-	unsigned int N;
-};
-void main( Producer & prod ) with( prod ) {
-	for ( int i = 1; i <= N; i += 1 ) {
-		yield( random( 5 ) );
-		insert( buffer, 1 );
-	} // for
-}
-void ?{}( Producer & prod, Buffer(int) * buffer, int N ) {
-	&prod.buffer = buffer;
-	prod.N = N;
-}
-
-thread Consumer {
-	Buffer(int) & buffer;
-	int & sum;											// summation of producer values
-};
-void main( Consumer & cons ) with( cons ) {
-	sum = 0;
-	for () {
-		yield( random( 5 ) );
-		int item = remove( buffer );
-	  if ( item == Sentinel ) break;					// sentinel ?
-		sum += item;
-	} // for
-}
-void ?{}( Consumer & cons, Buffer(int) * buffer, int & sum ) {
-	&cons.buffer = buffer;
-	&cons.sum = &sum;
-}
-
-int main() {
-	Buffer(int) buffer;
-	enum { Prods = 4, Cons = 5 };
-	Producer * prods[Prods];
-	Consumer * cons[Cons];
-	int sums[Cons];
-	int i;
-	processor p;
-
-	//srandom( getpid() );
-	srandom( 1003 );
-
-	for ( i = 0; i < Cons; i += 1 ) {					// create consumers
-		cons[i] = new( &buffer, sums[i] );
-	} // for
-	for ( i = 0; i < Prods; i += 1 ) {					// create producers
-		prods[i] = new( &buffer, 100000 );
-	} // for
-
-	for ( i = 0; i < Prods; i += 1 ) {					// wait for producers to finish
-		delete( prods[i] );
-	} // for
-	for ( i = 0; i < Cons; i += 1 ) {					// generate sentinal values to stop consumers
-		insert( buffer, Sentinel );
-	} // for
-	int sum = 0;
-	for ( i = 0; i < Cons; i += 1 ) {					// wait for consumers to finish
-		delete( cons[i] );
-		sum += sums[i];
-	} // for
-	sout | "total:" | sum;
-}
-
-// Local Variables: //
-// tab-width: 4 //
-// compile-command: "cfa boundedBufferINT.c" //
-// End: //
Index: tests/concurrent/examples/boundedBufferINT.cfa
===================================================================
--- tests/concurrent/examples/boundedBufferINT.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
+++ tests/concurrent/examples/boundedBufferINT.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
@@ -0,0 +1,124 @@
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// boundedBuffer.c --
+//
+// Author           : Peter A. Buhr
+// Created On       : Mon Oct 30 12:45:13 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Dec 11 21:55:45 2018
+// Update Count     : 84
+//
+
+#include <stdlib.hfa>										// random
+#include <fstream.hfa>
+#include <kernel.hfa>
+#include <thread.hfa>
+#include <unistd.h>										// getpid
+
+//Duration default_preemption() { return 0; }
+
+enum { BufferSize = 50 };
+
+forall( otype T ) {
+	monitor Buffer {
+		condition full, empty;
+		int front, back, count;
+		T elements[BufferSize];
+	}; // Buffer
+
+	void ?{}( Buffer(T) & buffer ) with( buffer ) { [front, back, count] = 0; }
+
+	int query( Buffer(T) & buffer ) { return buffer.count; } // read-only, no mutual exclusion
+
+	void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) {
+		if ( count == BufferSize ) wait( empty );
+		elements[back] = elem;
+		back = ( back + 1 ) % BufferSize;
+		count += 1;
+		signal( full );
+	} // insert
+
+	T remove( Buffer(T) & mutex buffer ) with( buffer ) {
+		if ( count == 0 ) wait( full );
+		T elem = elements[front];
+		front = ( front + 1 ) % BufferSize;
+		count -= 1;
+		signal( empty );
+		return elem;
+	} // remove
+}
+
+const int Sentinel = -1;
+
+thread Producer {
+	Buffer(int) & buffer;
+	unsigned int N;
+};
+void main( Producer & prod ) with( prod ) {
+	for ( int i = 1; i <= N; i += 1 ) {
+		yield( random( 5 ) );
+		insert( buffer, 1 );
+	} // for
+}
+void ?{}( Producer & prod, Buffer(int) * buffer, int N ) {
+	&prod.buffer = buffer;
+	prod.N = N;
+}
+
+thread Consumer {
+	Buffer(int) & buffer;
+	int & sum;											// summation of producer values
+};
+void main( Consumer & cons ) with( cons ) {
+	sum = 0;
+	for () {
+		yield( random( 5 ) );
+		int item = remove( buffer );
+	  if ( item == Sentinel ) break;					// sentinel ?
+		sum += item;
+	} // for
+}
+void ?{}( Consumer & cons, Buffer(int) * buffer, int & sum ) {
+	&cons.buffer = buffer;
+	&cons.sum = &sum;
+}
+
+int main() {
+	Buffer(int) buffer;
+	enum { Prods = 4, Cons = 5 };
+	Producer * prods[Prods];
+	Consumer * cons[Cons];
+	int sums[Cons];
+	int i;
+	processor p;
+
+	//srandom( getpid() );
+	srandom( 1003 );
+
+	for ( i = 0; i < Cons; i += 1 ) {					// create consumers
+		cons[i] = new( &buffer, sums[i] );
+	} // for
+	for ( i = 0; i < Prods; i += 1 ) {					// create producers
+		prods[i] = new( &buffer, 100000 );
+	} // for
+
+	for ( i = 0; i < Prods; i += 1 ) {					// wait for producers to finish
+		delete( prods[i] );
+	} // for
+	for ( i = 0; i < Cons; i += 1 ) {					// generate sentinal values to stop consumers
+		insert( buffer, Sentinel );
+	} // for
+	int sum = 0;
+	for ( i = 0; i < Cons; i += 1 ) {					// wait for consumers to finish
+		delete( cons[i] );
+		sum += sums[i];
+	} // for
+	sout | "total:" | sum;
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa boundedBufferINT.c" //
+// End: //
Index: tests/concurrent/examples/datingService.c
===================================================================
--- tests/concurrent/examples/datingService.c	(revision 5ea5b28f99a21543ee16545ccb212eddbb550eff)
+++ 	(revision )
@@ -1,113 +1,0 @@
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// datingService.c --
-//
-// Author           : Peter A. Buhr
-// Created On       : Mon Oct 30 12:56:20 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec 11 21:55:34 2018
-// Update Count     : 28
-//
-
-#include <stdlib.hfa>										// random
-#include <fstream.hfa>
-#include <kernel.hfa>
-#include <thread.hfa>
-#include <unistd.h>										// getpid
-
-enum { CompCodes = 20 };								// number of compatibility codes
-
-monitor DatingService {
-	condition Girls[CompCodes], Boys[CompCodes];
-	unsigned int GirlPhoneNo, BoyPhoneNo;
-}; // DatingService
-
-unsigned int girl( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) with( ds ) {
-	if ( is_empty( Boys[ccode] ) ) {					// no compatible boy ?
-		wait( Girls[ccode] );							// wait for boy
-		GirlPhoneNo = PhoneNo;							// make phone number available
-	} else {
-		GirlPhoneNo = PhoneNo;							// make phone number available
-		signal_block( Boys[ccode] );					// restart boy to set phone number
-	} // if
-	return BoyPhoneNo;
-} // DatingService girl
-
-unsigned int boy( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) with( ds ) {
-	if ( is_empty( Girls[ccode] ) ) {					// no compatible girl ?
-		wait( Boys[ccode] );							// wait for girl
-		BoyPhoneNo = PhoneNo;							// make phone number available
-	} else {
-		BoyPhoneNo = PhoneNo;							// make phone number available
-		signal_block( Girls[ccode] );					// restart girl to set phone number
-	} // if
-	return GirlPhoneNo;
-} // DatingService boy
-
-unsigned int girlck[CompCodes];
-unsigned int boyck[CompCodes];
-
-thread Girl {
-	DatingService & TheExchange;
-	unsigned int id, ccode;
-}; // Girl
-
-void main( Girl & g ) with( g ) {
-	yield( random( 100 ) );								// don't all start at the same time
-	unsigned int partner = girl( TheExchange, id, ccode );
-	sout | "Girl:" | id | "is dating Boy at" | partner | "with ccode" | ccode;
-	girlck[id] = partner;
-} // Girl main
-
-void ?{}( Girl & g, DatingService * TheExchange, unsigned int id, unsigned int ccode ) {
-	&g.TheExchange = TheExchange;
-	g.id = id;
-	g.ccode = ccode;
-} // Girl ?{}
-
-thread Boy {
-	DatingService & TheExchange;
-	unsigned int id, ccode;
-}; // Boy
-
-void main( Boy & b ) with( b ) {
-	yield( random( 100 ) );								// don't all start at the same time
-	unsigned int partner = boy( TheExchange, id, ccode );
-	sout | " Boy:" | id | "is dating Girl" | partner | "with ccode" | ccode;
-	boyck[id] = partner;
-} // Boy main
-
-void ?{}( Boy & b, DatingService * TheExchange, unsigned int id, unsigned int ccode ) {
-	&b.TheExchange = TheExchange;
-	b.id = id;
-	b.ccode = ccode;
-} // Boy ?{}
-
-int main() {
-	DatingService TheExchange;
-	Girl * girls[CompCodes];
-	Boy  * boys[CompCodes];
-
-	srandom( /*getpid()*/ 103 );
-
-	for ( unsigned int i = 0; i < CompCodes; i += 1 ) {
-		girls[i] = new( &TheExchange, i, i );
-		boys[i]  = new( &TheExchange, i, CompCodes - ( i + 1 ) );
-	} // for
-
-	for ( unsigned int i = 0; i < CompCodes; i += 1 ) {
-		delete( boys[i] );
-		delete( girls[i] );
-	} // for
-
-	for ( unsigned int i = 0; i < CompCodes; i += 1 ) {
-		if ( girlck[ boyck[i] ] != boyck[ girlck[i] ] ) abort();
-	} // for
-} // main
-
-// Local Variables: //
-// tab-width: 4 //
-// compile-command: "cfa datingService.c" //
-// End: //
Index: tests/concurrent/examples/datingService.cfa
===================================================================
--- tests/concurrent/examples/datingService.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
+++ tests/concurrent/examples/datingService.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
@@ -0,0 +1,113 @@
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// datingService.c --
+//
+// Author           : Peter A. Buhr
+// Created On       : Mon Oct 30 12:56:20 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Dec 11 21:55:34 2018
+// Update Count     : 28
+//
+
+#include <stdlib.hfa>										// random
+#include <fstream.hfa>
+#include <kernel.hfa>
+#include <thread.hfa>
+#include <unistd.h>										// getpid
+
+enum { CompCodes = 20 };								// number of compatibility codes
+
+monitor DatingService {
+	condition Girls[CompCodes], Boys[CompCodes];
+	unsigned int GirlPhoneNo, BoyPhoneNo;
+}; // DatingService
+
+unsigned int girl( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) with( ds ) {
+	if ( is_empty( Boys[ccode] ) ) {					// no compatible boy ?
+		wait( Girls[ccode] );							// wait for boy
+		GirlPhoneNo = PhoneNo;							// make phone number available
+	} else {
+		GirlPhoneNo = PhoneNo;							// make phone number available
+		signal_block( Boys[ccode] );					// restart boy to set phone number
+	} // if
+	return BoyPhoneNo;
+} // DatingService girl
+
+unsigned int boy( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) with( ds ) {
+	if ( is_empty( Girls[ccode] ) ) {					// no compatible girl ?
+		wait( Boys[ccode] );							// wait for girl
+		BoyPhoneNo = PhoneNo;							// make phone number available
+	} else {
+		BoyPhoneNo = PhoneNo;							// make phone number available
+		signal_block( Girls[ccode] );					// restart girl to set phone number
+	} // if
+	return GirlPhoneNo;
+} // DatingService boy
+
+unsigned int girlck[CompCodes];
+unsigned int boyck[CompCodes];
+
+thread Girl {
+	DatingService & TheExchange;
+	unsigned int id, ccode;
+}; // Girl
+
+void main( Girl & g ) with( g ) {
+	yield( random( 100 ) );								// don't all start at the same time
+	unsigned int partner = girl( TheExchange, id, ccode );
+	sout | "Girl:" | id | "is dating Boy at" | partner | "with ccode" | ccode;
+	girlck[id] = partner;
+} // Girl main
+
+void ?{}( Girl & g, DatingService * TheExchange, unsigned int id, unsigned int ccode ) {
+	&g.TheExchange = TheExchange;
+	g.id = id;
+	g.ccode = ccode;
+} // Girl ?{}
+
+thread Boy {
+	DatingService & TheExchange;
+	unsigned int id, ccode;
+}; // Boy
+
+void main( Boy & b ) with( b ) {
+	yield( random( 100 ) );								// don't all start at the same time
+	unsigned int partner = boy( TheExchange, id, ccode );
+	sout | " Boy:" | id | "is dating Girl" | partner | "with ccode" | ccode;
+	boyck[id] = partner;
+} // Boy main
+
+void ?{}( Boy & b, DatingService * TheExchange, unsigned int id, unsigned int ccode ) {
+	&b.TheExchange = TheExchange;
+	b.id = id;
+	b.ccode = ccode;
+} // Boy ?{}
+
+int main() {
+	DatingService TheExchange;
+	Girl * girls[CompCodes];
+	Boy  * boys[CompCodes];
+
+	srandom( /*getpid()*/ 103 );
+
+	for ( unsigned int i = 0; i < CompCodes; i += 1 ) {
+		girls[i] = new( &TheExchange, i, i );
+		boys[i]  = new( &TheExchange, i, CompCodes - ( i + 1 ) );
+	} // for
+
+	for ( unsigned int i = 0; i < CompCodes; i += 1 ) {
+		delete( boys[i] );
+		delete( girls[i] );
+	} // for
+
+	for ( unsigned int i = 0; i < CompCodes; i += 1 ) {
+		if ( girlck[ boyck[i] ] != boyck[ girlck[i] ] ) abort();
+	} // for
+} // main
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa datingService.c" //
+// End: //
Index: tests/concurrent/examples/matrixSum.c
===================================================================
--- tests/concurrent/examples/matrixSum.c	(revision 5ea5b28f99a21543ee16545ccb212eddbb550eff)
+++ 	(revision )
@@ -1,62 +1,0 @@
-//                               -*- Mode: C -*-
-//
-// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// matrixSum.cfa --
-//
-// Author           : Peter A. Buhr
-// Created On       : Mon Oct  9 08:29:28 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec 11 21:54:55 2018
-// Update Count     : 15
-//
-
-#include <fstream.hfa>
-#include <kernel.hfa>
-#include <thread.hfa>
-
-thread Adder {
-	int * row, cols, & subtotal;						// communication
-};
-
-void ?{}( Adder & adder, int row[], int cols, int & subtotal ) {
-	adder.[ row, cols ] = [ row, cols ];				// expression disallowed in multi-member access
-	&adder.subtotal = &subtotal;
-}
-
-void main( Adder & adder ) with( adder ) {				// thread starts here
-	subtotal = 0;
-	for ( c; cols ) {
-		subtotal += row[c];
-	} // for
-}
-
-int main() {
-	/* const */ int rows = 10, cols = 1000;
-	int matrix[rows][cols], subtotals[rows], total = 0;
-	processor p;										// add kernel thread
-
-	for ( r; rows ) {
-		for ( c; cols ) {
-			matrix[r][c] = 1;
-		} // for
-	} // for
-	Adder * adders[rows];
-	for ( r; rows ) {									// start threads to sum rows
-		adders[r] = &(*malloc()){ matrix[r], cols, subtotals[r] };
-//		adders[r] = new( matrix[r], cols, &subtotals[r] );
-	} // for
-	for ( r; rows ) {									// wait for threads to finish
-		delete( adders[r] );
-		total += subtotals[r];							// total subtotals
-	} // for
-	sout | total;
-}
-
-// Local Variables: //
-// tab-width: 4 //
-// compile-command: "cfa matrixSum.cfa" //
-// End: //
Index: tests/concurrent/examples/matrixSum.cfa
===================================================================
--- tests/concurrent/examples/matrixSum.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
+++ tests/concurrent/examples/matrixSum.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
@@ -0,0 +1,62 @@
+//                               -*- Mode: C -*-
+//
+// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// matrixSum.cfa --
+//
+// Author           : Peter A. Buhr
+// Created On       : Mon Oct  9 08:29:28 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Dec 11 21:54:55 2018
+// Update Count     : 15
+//
+
+#include <fstream.hfa>
+#include <kernel.hfa>
+#include <thread.hfa>
+
+thread Adder {
+	int * row, cols, & subtotal;						// communication
+};
+
+void ?{}( Adder & adder, int row[], int cols, int & subtotal ) {
+	adder.[ row, cols ] = [ row, cols ];				// expression disallowed in multi-member access
+	&adder.subtotal = &subtotal;
+}
+
+void main( Adder & adder ) with( adder ) {				// thread starts here
+	subtotal = 0;
+	for ( c; cols ) {
+		subtotal += row[c];
+	} // for
+}
+
+int main() {
+	/* const */ int rows = 10, cols = 1000;
+	int matrix[rows][cols], subtotals[rows], total = 0;
+	processor p;										// add kernel thread
+
+	for ( r; rows ) {
+		for ( c; cols ) {
+			matrix[r][c] = 1;
+		} // for
+	} // for
+	Adder * adders[rows];
+	for ( r; rows ) {									// start threads to sum rows
+		adders[r] = &(*malloc()){ matrix[r], cols, subtotals[r] };
+//		adders[r] = new( matrix[r], cols, &subtotals[r] );
+	} // for
+	for ( r; rows ) {									// wait for threads to finish
+		delete( adders[r] );
+		total += subtotals[r];							// total subtotals
+	} // for
+	sout | total;
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa matrixSum.cfa" //
+// End: //
Index: tests/concurrent/examples/quickSort.c
===================================================================
--- tests/concurrent/examples/quickSort.c	(revision 5ea5b28f99a21543ee16545ccb212eddbb550eff)
+++ 	(revision )
@@ -1,181 +1,0 @@
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// quickSort.c -- In-place concurrent quick-sort: threads are created to partition to a specific depth, then sequential
-//		recursive-calls are use to sort each partition.
-//
-// Author           : Peter A. Buhr
-// Created On       : Wed Dec  6 12:15:52 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Dec 22 08:44:27 2018
-// Update Count     : 168
-//
-
-#include <fstream.hfa>
-#include <stdlib.hfa>
-#include <kernel.hfa>
-#include <thread.hfa>
-#include <string.h>										// strcmp
-
-thread Quicksort {
-	int * values;										// communication variables
-	int low, high, depth;
-};
-
-void ?{}( Quicksort & qs, int values[], int size, int depth ) {
-	qs.values = values;  qs.low = 0;  qs.high = size;  qs.depth = depth;
-} // Quicksort
-
-void main( Quicksort & qs ) {							// thread starts here
-	// nested routines: information hiding
-
-	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( int values[], int low, int high, int depth ) {
-		int left, right;								// index to left/right-hand side of the values
-		int pivot;										// pivot value of values
-		int swap;										// temporary
-
-		//verify();										// check for stack overflow due to recursion
-
-		// partition while 2 or more elements in the array
-		if ( low < high ) {
-			pivot = values[low + ( high - low ) / 2];
-			left  = low;
-			right = high;
-
-			// partition: move values less < pivot before the pivot and values > pivot after the pivot
-			do {
-				while ( values[left] < pivot ) left += 1; // changed values[left] < pivot
-				while ( pivot < values[right] ) right -= 1;
-				if ( left <= right ) {
-					swap = values[left];				// interchange values
-					values[left]  = values[right];
-					values[right] = swap;
-					left += 1;
-					right -= 1;
-				} // if
-			} while ( left <= right );
-
-			// restrict number of tasks to slightly greater than number of processors
-			if ( depth > 0 ) {
-				depth -= 1;
-				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
-			} else {
-				sort( values, low, right, 0 );			// sequentially sort lower half
-				sort( values, left, high, 0 );			// sequentially sort upper half
-			} // if
-		} // if
-	} // sort
-
-	with( qs ) {
-		sort( values, low, high, depth );
-	} // with
-} // main
-
-
-bool convert( int & val, const char * nptr ) {			// convert C string to integer
-	char * eptr;
-	int temp = strto( nptr, &eptr, 10 );				// do not change val on false
-	// true => entire string valid with no extra characters
-	return *nptr != '\0' && *eptr == '\0' ? val = temp, true : false;
-} // convert
-
-void usage( char * argv[] ) {
-	sout | "Usage:" | argv[0] | "( -s unsorted-file [ sorted-file ] | -t size (>= 0) [ depth (>= 0) ] )";
-	exit( EXIT_FAILURE );								// TERMINATE!
-} // usage
-
-
-int main( int argc, char * argv[] ) {
-	ifstream & unsortedfile = sin;
-	ofstream & sortedfile = sout;						// default value
-	int depth = 0, size;
-
-	if ( argc != 1 ) {									// do not use defaults
-		if ( argc < 2 || argc > 4 ) usage( argv );		// wrong number of options
-		if ( strcmp( argv[1], "-t" ) == 0 ) {			// timing ?
-			&unsortedfile = (ifstream *)0;				// no input
-			choose ( argc ) {
-			  case 4:
-				if ( ! convert( depth, argv[3] ) || depth < 0 ) usage( argv );
-				fallthrough;
-			  case 3:
-				if ( ! convert( size, argv[2] ) || size < 0 ) usage( argv );
-			} // choose
-		} 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] | "\"";
-					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] | "\"";
-					usage( argv );
-				} // if
-			} // choose
-		} // if
-	} // if
-	sortedfile | nlOff;									// turn off auto newline
-
-	enum { ValuesPerLine = 22 };						// number of values printed per line
-
-	if ( &unsortedfile ) {								// generate output ?
-		for () {
-			unsortedfile | size;						// read number of elements in the list
-		  if ( eof( unsortedfile ) ) break;
-			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];
-				if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
-				sortedfile | values[counter];
-				if ( counter < size - 1 && (counter + 1) % ValuesPerLine != 0 ) sortedfile | ' ';
-			} // for
-			sortedfile | nl;
-			if ( size > 0 ) {							// values to sort ?
-				Quicksort QS = { values, size - 1, 0 }; // sort values
-			} // wait until sort tasks terminate
-			for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list
-				if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
-				sortedfile | values[counter];
-				if ( counter < size - 1 && (counter + 1) % ValuesPerLine != 0 ) sortedfile | ' ';
-			} // for
-			sortedfile | nl | nl;
-
-			delete( values );
-		} // for
-		if ( &unsortedfile != &sin ) delete( &unsortedfile ); // close input/output files
-		if ( &sortedfile != &sout ) delete( &sortedfile );
-	} else {
-		processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads
-
-		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 QS = { values, size - 1, depth }; // sort values
-		} // wait until sort tasks terminate
-
-		// for ( int counter = 0; counter < size - 1; counter += 1 ) { // check sorting
-		// 	if ( values[counter] > values[counter + 1] ) abort();
-		// } // for
-
-		delete( values );
-	} // if
-} // main
-
-// Local Variables: //
-// tab-width: 4 //
-// compile-command: "cfa quickSort.c" //
-// End: //
Index: tests/concurrent/examples/quickSort.cfa
===================================================================
--- tests/concurrent/examples/quickSort.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
+++ tests/concurrent/examples/quickSort.cfa	(revision 456834bab8c511c181adb66426754ef2b7815b3c)
@@ -0,0 +1,181 @@
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// quickSort.c -- In-place concurrent quick-sort: threads are created to partition to a specific depth, then sequential
+//		recursive-calls are use to sort each partition.
+//
+// Author           : Peter A. Buhr
+// Created On       : Wed Dec  6 12:15:52 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Dec 22 08:44:27 2018
+// Update Count     : 168
+//
+
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <kernel.hfa>
+#include <thread.hfa>
+#include <string.h>										// strcmp
+
+thread Quicksort {
+	int * values;										// communication variables
+	int low, high, depth;
+};
+
+void ?{}( Quicksort & qs, int values[], int size, int depth ) {
+	qs.values = values;  qs.low = 0;  qs.high = size;  qs.depth = depth;
+} // Quicksort
+
+void main( Quicksort & qs ) {							// thread starts here
+	// nested routines: information hiding
+
+	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( int values[], int low, int high, int depth ) {
+		int left, right;								// index to left/right-hand side of the values
+		int pivot;										// pivot value of values
+		int swap;										// temporary
+
+		//verify();										// check for stack overflow due to recursion
+
+		// partition while 2 or more elements in the array
+		if ( low < high ) {
+			pivot = values[low + ( high - low ) / 2];
+			left  = low;
+			right = high;
+
+			// partition: move values less < pivot before the pivot and values > pivot after the pivot
+			do {
+				while ( values[left] < pivot ) left += 1; // changed values[left] < pivot
+				while ( pivot < values[right] ) right -= 1;
+				if ( left <= right ) {
+					swap = values[left];				// interchange values
+					values[left]  = values[right];
+					values[right] = swap;
+					left += 1;
+					right -= 1;
+				} // if
+			} while ( left <= right );
+
+			// restrict number of tasks to slightly greater than number of processors
+			if ( depth > 0 ) {
+				depth -= 1;
+				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
+			} else {
+				sort( values, low, right, 0 );			// sequentially sort lower half
+				sort( values, left, high, 0 );			// sequentially sort upper half
+			} // if
+		} // if
+	} // sort
+
+	with( qs ) {
+		sort( values, low, high, depth );
+	} // with
+} // main
+
+
+bool convert( int & val, const char * nptr ) {			// convert C string to integer
+	char * eptr;
+	int temp = strto( nptr, &eptr, 10 );				// do not change val on false
+	// true => entire string valid with no extra characters
+	return *nptr != '\0' && *eptr == '\0' ? val = temp, true : false;
+} // convert
+
+void usage( char * argv[] ) {
+	sout | "Usage:" | argv[0] | "( -s unsorted-file [ sorted-file ] | -t size (>= 0) [ depth (>= 0) ] )";
+	exit( EXIT_FAILURE );								// TERMINATE!
+} // usage
+
+
+int main( int argc, char * argv[] ) {
+	ifstream & unsortedfile = sin;
+	ofstream & sortedfile = sout;						// default value
+	int depth = 0, size;
+
+	if ( argc != 1 ) {									// do not use defaults
+		if ( argc < 2 || argc > 4 ) usage( argv );		// wrong number of options
+		if ( strcmp( argv[1], "-t" ) == 0 ) {			// timing ?
+			&unsortedfile = (ifstream *)0;				// no input
+			choose ( argc ) {
+			  case 4:
+				if ( ! convert( depth, argv[3] ) || depth < 0 ) usage( argv );
+				fallthrough;
+			  case 3:
+				if ( ! convert( size, argv[2] ) || size < 0 ) usage( argv );
+			} // choose
+		} 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] | "\"";
+					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] | "\"";
+					usage( argv );
+				} // if
+			} // choose
+		} // if
+	} // if
+	sortedfile | nlOff;									// turn off auto newline
+
+	enum { ValuesPerLine = 22 };						// number of values printed per line
+
+	if ( &unsortedfile ) {								// generate output ?
+		for () {
+			unsortedfile | size;						// read number of elements in the list
+		  if ( eof( unsortedfile ) ) break;
+			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];
+				if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
+				sortedfile | values[counter];
+				if ( counter < size - 1 && (counter + 1) % ValuesPerLine != 0 ) sortedfile | ' ';
+			} // for
+			sortedfile | nl;
+			if ( size > 0 ) {							// values to sort ?
+				Quicksort QS = { values, size - 1, 0 }; // sort values
+			} // wait until sort tasks terminate
+			for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list
+				if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
+				sortedfile | values[counter];
+				if ( counter < size - 1 && (counter + 1) % ValuesPerLine != 0 ) sortedfile | ' ';
+			} // for
+			sortedfile | nl | nl;
+
+			delete( values );
+		} // for
+		if ( &unsortedfile != &sin ) delete( &unsortedfile ); // close input/output files
+		if ( &sortedfile != &sout ) delete( &sortedfile );
+	} else {
+		processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads
+
+		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 QS = { values, size - 1, depth }; // sort values
+		} // wait until sort tasks terminate
+
+		// for ( int counter = 0; counter < size - 1; counter += 1 ) { // check sorting
+		// 	if ( values[counter] > values[counter + 1] ) abort();
+		// } // for
+
+		delete( values );
+	} // if
+} // main
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa quickSort.c" //
+// End: //
