Index: src/benchmark/Makefile.am
===================================================================
--- src/benchmark/Makefile.am	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/Makefile.am	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -97,20 +97,20 @@
 
 mutex-function$(EXEEXT):
-	@BACKEND_CC@ mutex/function.c -DBENCH_N=500000000      -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	@BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-pthread_lock$(EXEEXT):
-	@BACKEND_CC@ mutex/pthreads.c -DBENCH_N=50000000       -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	@BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-upp$(EXEEXT):
-	u++          mutex/upp.cc     -DBENCH_N=50000000       -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	u++          mutex/upp.cc        -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-cfa1$(EXEEXT):
-	${CC}        mutex/cfa1.c     -DBENCH_N=5000000        -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	${CC}        mutex/cfa1.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-cfa2$(EXEEXT):
-	${CC}        mutex/cfa2.c     -DBENCH_N=5000000        -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	${CC}        mutex/cfa2.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-cfa4$(EXEEXT):
-	${CC}        mutex/cfa4.c     -DBENCH_N=5000000        -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 ## =========================================================================================================
@@ -122,5 +122,5 @@
 
 signal-upp$(EXEEXT):
-	u++          schedint/upp.cc     -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	u++          schedint/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 signal-cfa1$(EXEEXT):
Index: src/benchmark/Makefile.in
===================================================================
--- src/benchmark/Makefile.in	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/Makefile.in	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -510,20 +510,20 @@
 
 mutex-function$(EXEEXT):
-	@BACKEND_CC@ mutex/function.c -DBENCH_N=500000000      -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	@BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-pthread_lock$(EXEEXT):
-	@BACKEND_CC@ mutex/pthreads.c -DBENCH_N=50000000       -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	@BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-upp$(EXEEXT):
-	u++          mutex/upp.cc     -DBENCH_N=50000000       -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	u++          mutex/upp.cc        -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-cfa1$(EXEEXT):
-	${CC}        mutex/cfa1.c     -DBENCH_N=5000000        -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	${CC}        mutex/cfa1.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-cfa2$(EXEEXT):
-	${CC}        mutex/cfa2.c     -DBENCH_N=5000000        -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	${CC}        mutex/cfa2.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 mutex-cfa4$(EXEEXT):
-	${CC}        mutex/cfa4.c     -DBENCH_N=5000000        -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 signal$(EXEEXT) :\
@@ -534,5 +534,5 @@
 
 signal-upp$(EXEEXT):
-	u++          schedint/upp.cc     -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+	u++          schedint/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 signal-cfa1$(EXEEXT):
Index: src/benchmark/mutex/function.c
===================================================================
--- src/benchmark/mutex/function.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/mutex/function.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -3,10 +3,12 @@
 #include "bench.h"
 
-void __attribute__((noinline)) call() {}
+void __attribute__((noinline)) do_call() {
+	asm volatile ("");
+}
 
 int main(int argc, char* argv[]) {
 	BENCH(
 		for (size_t i = 0; i < n; i++) {
-			call();
+			do_call();
 		},
 		result
Index: src/benchmark/schedext/cfa1.c
===================================================================
--- src/benchmark/schedext/cfa1.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/schedext/cfa1.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -40,5 +40,4 @@
 	argc = margc;
 	argv = margv;
-	processor p;
 	T t;
 	return wait(m1);
Index: src/benchmark/schedext/cfa2.c
===================================================================
--- src/benchmark/schedext/cfa2.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/schedext/cfa2.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -40,5 +40,4 @@
 	argc = margc;
 	argv = margv;
-	processor p;
 	T t;
 	return wait(m1, m2);
Index: src/benchmark/schedext/cfa4.c
===================================================================
--- src/benchmark/schedext/cfa4.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/schedext/cfa4.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -40,5 +40,4 @@
 	argc = margc;
 	argv = margv;
-	processor p;
 	T t;
 	return wait(m1, m2, m3, m4);
Index: src/benchmark/schedext/upp.cc
===================================================================
--- src/benchmark/schedext/upp.cc	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/schedext/upp.cc	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -39,5 +39,4 @@
 	argc = margc;
 	argv = margv;
-	uProcessor p;
 	T t;
 	return m.wait();
Index: src/benchmark/schedint/cfa1.c
===================================================================
--- src/benchmark/schedint/cfa1.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/schedint/cfa1.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -43,5 +43,4 @@
 	argc = margc;
 	argv = margv;
-	processor p;
 	T t;
 	return wait(m1);
Index: src/benchmark/schedint/cfa2.c
===================================================================
--- src/benchmark/schedint/cfa2.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/schedint/cfa2.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -43,5 +43,4 @@
 	argc = margc;
 	argv = margv;
-	processor p;
 	T t;
 	return wait(m1, m2);
Index: src/benchmark/schedint/cfa4.c
===================================================================
--- src/benchmark/schedint/cfa4.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/schedint/cfa4.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -43,5 +43,4 @@
 	argc = margc;
 	argv = margv;
-	processor p;
 	T t;
 	return wait(m1, m2, m3, m4);
Index: src/benchmark/schedint/upp.cc
===================================================================
--- src/benchmark/schedint/upp.cc	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/benchmark/schedint/upp.cc	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -42,5 +42,4 @@
 	argc = margc;
 	argv = margv;
-	uProcessor p;
 	T t;
 	return m.wait();
Index: src/driver/cfa.cc
===================================================================
--- src/driver/cfa.cc	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/driver/cfa.cc	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -10,6 +10,6 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Sep 26 23:12:38 2017
-// Update Count     : 159
+// Last Modified On : Tue Oct 31 11:40:44 2017
+// Update Count     : 160
 //
 
@@ -305,8 +305,14 @@
 	} // if
 
+	shuffle( args, sargs, nargs, 1 );					// make room at front of argument list
+	nargs += 1;
 	if ( CFA_flag ) {
+		args[sargs] = "-D__CFA_FLAG__=-N";
 		args[nargs] = "-D__CFA_PREPROCESS_";
 		nargs += 1;
-	} // if
+	} else {
+		args[sargs] = "-D__CFA_FLAG__=-L";
+	} // if
+	sargs += 1;
 
 	if ( debug ) {
Index: src/libcfa/bits/algorithms.h
===================================================================
--- src/libcfa/bits/algorithms.h	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
+++ src/libcfa/bits/algorithms.h	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -0,0 +1,191 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// bits/algorithms.h -- Builtins for exception handling.
+//
+// Author           : Thierry Delisle
+// Created On       : Mon Oct 30 13:37:34 2017
+// Last Modified By : --
+// Last Modified On : --
+// Update Count     : 0
+//
+
+#pragma once
+
+#ifdef SAFE_SORT
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort2( T * arr );
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort3( T * arr );
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort4( T * arr );
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort5( T * arr );
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sort6( T * arr );
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } ) static inline void __libcfa_small_sortN( T * arr, size_t dim );
+
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+static inline void __libcfa_small_sort( T * arr, size_t dim ) {
+	switch( dim ) {
+		case 1 : return;
+		case 2 : __libcfa_small_sort2( arr ); return;
+		case 3 : __libcfa_small_sort3( arr ); return;
+		case 4 : __libcfa_small_sort4( arr ); return;
+		case 5 : __libcfa_small_sort5( arr ); return;
+		case 6 : __libcfa_small_sort6( arr ); return;
+		default: __libcfa_small_sortN( arr, dim ); return;
+	}
+}
+
+#define min(x, y) (y > x ? x : y)
+#define max(x, y) (y > x ? y : x)
+#define SWAP(x,y) { T a = min(arr[x], arr[y]); T b = max(arr[x], arr[y]); arr[x] = a; arr[y] = b;}
+
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+static inline void __libcfa_small_sort2( T * arr ) {
+	SWAP(0, 1);
+}
+
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+static inline void __libcfa_small_sort3( T * arr ) {
+	SWAP(1, 2);
+	SWAP(0, 2);
+	SWAP(0, 1);
+}
+
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+static inline void __libcfa_small_sort4( T * arr ) {
+	SWAP(0, 1);
+	SWAP(2, 3);
+	SWAP(0, 2);
+	SWAP(1, 3);
+	SWAP(1, 2);
+}
+
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+static inline void __libcfa_small_sort5( T * arr ) {
+	SWAP(0, 1);
+	SWAP(3, 4);
+	SWAP(2, 4);
+	SWAP(2, 3);
+	SWAP(0, 3);
+	SWAP(0, 2);
+	SWAP(1, 4);
+	SWAP(1, 3);
+	SWAP(1, 2);
+}
+
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+static inline void __libcfa_small_sort6( T * arr ) {
+	SWAP(1, 2);
+	SWAP(4, 5);
+	SWAP(0, 2);
+	SWAP(3, 5);
+	SWAP(0, 1);
+	SWAP(3, 4);
+	SWAP(1, 4);
+	SWAP(0, 3);
+	SWAP(2, 5);
+	SWAP(1, 3);
+	SWAP(2, 4);
+	SWAP(2, 3);
+}
+
+forall( otype T | {  int ?<?( T, T ); int ?>?( T, T ); } )
+static inline void __libcfa_small_sortN( T * arr, size_t dim ) {
+	int i, j;
+	for (i = 1; i < dim; i++) {
+		T tmp = arr[i];
+		for (j = i; j >= 1 && tmp < arr[j-1]; j--) {
+			arr[j] = arr[j-1];
+		}
+		arr[j] = tmp;
+	}
+}
+
+#else
+
+static inline void __libcfa_small_sort2( void* * arr );
+static inline void __libcfa_small_sort3( void* * arr );
+static inline void __libcfa_small_sort4( void* * arr );
+static inline void __libcfa_small_sort5( void* * arr );
+static inline void __libcfa_small_sort6( void* * arr );
+static inline void __libcfa_small_sortN( void* * arr, size_t dim );
+
+forall( dtype T )
+static inline void __libcfa_small_sort( T* * arr, size_t dim ) {
+	switch( dim ) {
+		case 1 : return;
+		case 2 : __libcfa_small_sort2( (void **) arr ); return;
+		case 3 : __libcfa_small_sort3( (void **) arr ); return;
+		case 4 : __libcfa_small_sort4( (void **) arr ); return;
+		case 5 : __libcfa_small_sort5( (void **) arr ); return;
+		case 6 : __libcfa_small_sort6( (void **) arr ); return;
+		default: __libcfa_small_sortN( (void **) arr, dim ); return;
+	}
+}
+
+#define min(x, y) (y > x ? x : y)
+#define max(x, y) (y > x ? y : x)
+#define SWAP(x,y) { void* a = min(arr[x], arr[y]); void* b = max(arr[x], arr[y]); arr[x] = a; arr[y] = b;}
+
+static inline void __libcfa_small_sort2( void* * arr ) {
+	SWAP(0, 1);
+}
+
+static inline void __libcfa_small_sort3( void* * arr ) {
+	SWAP(1, 2);
+	SWAP(0, 2);
+	SWAP(0, 1);
+}
+
+static inline void __libcfa_small_sort4( void* * arr ) {
+	SWAP(0, 1);
+	SWAP(2, 3);
+	SWAP(0, 2);
+	SWAP(1, 3);
+	SWAP(1, 2);
+}
+
+static inline void __libcfa_small_sort5( void* * arr ) {
+	SWAP(0, 1);
+	SWAP(3, 4);
+	SWAP(2, 4);
+	SWAP(2, 3);
+	SWAP(0, 3);
+	SWAP(0, 2);
+	SWAP(1, 4);
+	SWAP(1, 3);
+	SWAP(1, 2);
+}
+
+static inline void __libcfa_small_sort6( void* * arr ) {
+	SWAP(1, 2);
+	SWAP(4, 5);
+	SWAP(0, 2);
+	SWAP(3, 5);
+	SWAP(0, 1);
+	SWAP(3, 4);
+	SWAP(1, 4);
+	SWAP(0, 3);
+	SWAP(2, 5);
+	SWAP(1, 3);
+	SWAP(2, 4);
+	SWAP(2, 3);
+}
+
+static inline void __libcfa_small_sortN( void* * arr, size_t dim ) {
+	int i, j;
+	for (i = 1; i < dim; i++) {
+		void* tmp = arr[i];
+		for (j = i; j >= 1 && tmp < arr[j-1]; j--) {
+			arr[j] = arr[j-1];
+		}
+		arr[j] = tmp;
+	}
+}
+
+#endif
+
+#undef SWAP
+#undef min
+#undef max
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/libcfa/concurrency/monitor.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -21,4 +21,6 @@
 #include "kernel_private.h"
 
+#include "bits/algorithms.h"
+
 //-----------------------------------------------------------------------------
 // Forward declarations
@@ -291,5 +293,5 @@
 
 	// Sort monitors based on address -> TODO use a sort specialized for small numbers
-	qsort(this.m, count);
+	__libcfa_small_sort(this.m, count);
 
 	// Save previous thread context
@@ -492,4 +494,6 @@
 	set_owner( monitors, count, signallee );
 
+	LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", this, signallee );
+
 	//Everything is ready to go to sleep
 	BlockInternal( locks, count, &signallee, 1 );
@@ -498,4 +502,6 @@
 	// WE WOKE UP
 
+
+	LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :   signal_block returned\n" );
 
 	//We are back, restore the masks and recursions
@@ -869,5 +875,5 @@
 	short size = 0;
 	for( int i = 0; i < mask.size; i++ ) {
-		qsort( mask.clauses[i].list, mask.clauses[i].size );
+		__libcfa_small_sort( mask.clauses[i].list, mask.clauses[i].size );
 		for( int j = 0; j < mask.clauses[i].size; j++) {
 			insert_unique( storage, size, mask.clauses[i].list[j] );
@@ -875,5 +881,5 @@
 	}
 	// TODO insertion sort instead of this
-	qsort( storage, size );
+	__libcfa_small_sort( storage, size );
 	return size;
 }
Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/libcfa/stdlib	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 23 20:29:47 2017
-// Update Count     : 224
+// Last Modified On : Tue Oct 31 13:47:24 2017
+// Update Count     : 245
 //
 
@@ -27,7 +27,14 @@
 // allocation, non-array types
 static inline forall( dtype T | sized(T) ) T * malloc( void ) {
-	//printf( "X1\n" );
+	// printf( "* malloc\n" );
 	return (T *)(void *)malloc( (size_t)sizeof(T) );	// C malloc
 } // malloc
+
+// static inline forall( dtype T | sized(T) ) T & malloc( void ) {
+// 	int & p = *(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+// 	printf( "& malloc %p\n", &p );
+// 	return p;
+// //	return (T &)*(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+// } // malloc
 
 extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine
@@ -206,15 +213,20 @@
 //---------------------------------------
 
-void rand48seed( long int s );
-char rand48( void );
-int rand48( void );
-unsigned int rand48( void );
-long int rand48( void );
-unsigned long int rand48( void );
-float rand48( void );
-double rand48( void );
-float _Complex rand48( void );
-double _Complex rand48( void );
-long double _Complex rand48( void );
+void random_seed( long int s );
+char random( void );
+char random( char l, char u );
+int random( void );
+unsigned int random( void );
+unsigned int random( unsigned int u );
+unsigned int random( unsigned int l, unsigned int u );
+//long int random( void );
+unsigned long int random( void );
+unsigned long int random( unsigned long int u );
+unsigned long int random( unsigned long int l, unsigned long int u );
+float random( void );
+double random( void );
+float _Complex random( void );
+double _Complex random( void );
+long double _Complex random( void );
 
 //---------------------------------------
Index: src/libcfa/stdlib.c
===================================================================
--- src/libcfa/stdlib.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/libcfa/stdlib.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 23 20:30:44 2017
-// Update Count     : 292
+// Last Modified On : Mon Oct 30 22:43:02 2017
+// Update Count     : 297
 //
 
@@ -275,15 +275,20 @@
 //---------------------------------------
 
-void rand48seed( long int s ) { srand48( s ); }
-char rand48( void ) { return mrand48(); }
-int rand48( void ) { return mrand48(); }
-unsigned int rand48( void ) { return lrand48(); }
-long int rand48( void ) { return mrand48(); }
-unsigned long int rand48( void ) { return lrand48(); }
-float rand48( void ) { return (float)drand48(); }		// otherwise float uses lrand48
-double rand48( void ) { return drand48(); }
-float _Complex rand48( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
-double _Complex rand48( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
-long double _Complex rand48( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
+void random_seed( long int s ) { srand48( s ); }
+char random( void ) { return mrand48(); }
+char random( char l, char u ) { return lrand48() % (u - l) + l; }
+int random( void ) { return mrand48(); }
+unsigned int random( void ) { return lrand48(); }
+unsigned int random( unsigned int u ) { return lrand48() % u; }
+unsigned int random( unsigned int l, unsigned int u ) { return lrand48() % (u - l) + l; }
+//long int random( void ) { return mrand48(); }
+unsigned long int random( void ) { return lrand48(); }
+unsigned long int random( unsigned long int u ) { return lrand48() % u; }
+unsigned long int random( unsigned long int l, unsigned long int u ) { return lrand48() % (u - l) + l; }
+float random( void ) { return (float)drand48(); }		// otherwise float uses lrand48
+double random( void ) { return drand48(); }
+float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
+double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
+long double _Complex random( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
 
 //---------------------------------------
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/main.cc	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -10,7 +10,7 @@
 // Author           : Richard C. Bilson
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Jul 26 14:38:00 2017
-// Update Count     : 443
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Oct 31 12:22:40 2017
+// Update Count     : 445
 //
 
@@ -81,4 +81,5 @@
 	expraltp = false,
 	libcfap = false,
+	preludep = false,
 	nopreludep = false,
 	noprotop = false,
@@ -378,5 +379,5 @@
 
 void parse_cmdline( int argc, char * argv[], const char *& filename ) {
-	enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, TupleExpansion, Validate, };
+	enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Preamble, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, TupleExpansion, Validate, };
 
 	static struct option long_opts[] = {
@@ -390,4 +391,5 @@
 		{ "grammar", no_argument, 0, Grammar },
 		{ "libcfa", no_argument, 0, LibCFA },
+		{ "preamble", no_argument, 0, Preamble },
 		{ "no-preamble", no_argument, 0, Nopreamble },
 		{ "parse", no_argument, 0, Parse },
@@ -405,5 +407,5 @@
 
 	int c;
-	while ( (c = getopt_long( argc, argv, "abBcCdefglLmnpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
+	while ( (c = getopt_long( argc, argv, "abBcCdefglLmnNpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
 		switch ( c ) {
 		  case Ast:
@@ -451,4 +453,8 @@
 		  case 'n':										// do not read preamble
 			nopreludep = true;
+			break;
+		  case Preamble:
+		  case 'N':										// read preamble
+			preludep = true;
 			break;
 		  case Prototypes:
Index: src/tests/boundedBuffer.c
===================================================================
--- src/tests/boundedBuffer.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/boundedBuffer.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -1,16 +1,29 @@
+// 
+// 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 : Mon Oct 30 23:02:46 2017
+// Update Count     : 9
+// 
+
 #include <stdlib>
-#include <fstream>
+#include <fstream>										// random
 #include <kernel>
 #include <thread>
-#include <unistd.h>					// getpid
+#include <unistd.h>										// getpid
 
 monitor Buffer {
-    condition full, empty;
-    int front, back, count;
-    int elements[20];
+	condition full, empty;
+	int front, back, count;
+	int elements[20];
 };
 
 void ?{}( Buffer & buffer ) {
-    buffer.front = buffer.back = buffer.count = 0;
+	buffer.front = buffer.back = buffer.count = 0;
 }
 
@@ -18,84 +31,89 @@
 
 void insert( Buffer & mutex buffer, int elem ) {
-    if ( buffer.count == 20 ) wait( &buffer.empty );
-    buffer.elements[buffer.back] = elem;
-    buffer.back = ( buffer.back + 1 ) % 20;
-    buffer.count += 1;
-    signal( &buffer.full );
+	if ( buffer.count == 20 ) wait( &buffer.empty );
+	buffer.elements[buffer.back] = elem;
+	buffer.back = ( buffer.back + 1 ) % 20;
+	buffer.count += 1;
+	signal( &buffer.full );
 }
 int remove( Buffer & mutex buffer ) {
-    if ( buffer.count == 0 ) wait( &buffer.full );
-    int elem = buffer.elements[buffer.front];
-    buffer.front = ( buffer.front + 1 ) % 20;
-    buffer.count -= 1;
-    signal( &buffer.empty );
-    return elem;
+	if ( buffer.count == 0 ) wait( &buffer.full );
+	int elem = buffer.elements[buffer.front];
+	buffer.front = ( buffer.front + 1 ) % 20;
+	buffer.count -= 1;
+	signal( &buffer.empty );
+	return elem;
 }
 
 thread Producer {
-    Buffer * buffer;
-    unsigned int N;
+	Buffer & buffer;
+	unsigned int N;
 };
 void main( Producer & prod ) {
-    for ( int i = 1; i <= prod.N; i += 1 ) {
-	yield( (unsigned int)rand48() % 5 );
-	insert( *prod.buffer, 1 );
-    } // for
-    insert( *prod.buffer, -1 );
+	for ( int i = 1; i <= prod.N; i += 1 ) {
+		yield( random( 5 ) );
+		insert( prod.buffer, 1 );
+	} // for
+	insert( prod.buffer, -1 );
 }
 void ?{}( Producer & prod, Buffer * buffer, unsigned int N ) {
-    prod.buffer = buffer;
-    prod.N = N;
-}
+	&prod.buffer = buffer;
+	prod.N = N;
+		}
 
 thread Consumer {
-    Buffer * buffer;
-    int * sum;						// summation of producer values
+	Buffer & buffer;
+	int & sum;						// summation of producer values
 };
 void main( Consumer & cons ) {
-    *cons.sum = 0;
-    for ( ;; ) {
-	yield( (unsigned int)rand48() % 5 );
-	int item = remove( *cons.buffer );
-      if ( item == -1 ) break;				// sentinel ?
-    	*cons.sum += item;
-    } // for
+	cons.sum = 0;
+	for ( ;; ) {
+		yield( random( 5 ) );
+		int item = remove( cons.buffer );
+		if ( item == -1 ) break;				// sentinel ?
+		cons.sum += item;
+	} // for
 }
 void ?{}( Consumer & cons, Buffer * buffer, int * sum ) {
-    cons.buffer = buffer;
-    cons.sum = sum;
+	&cons.buffer = buffer;
+	&cons.sum = sum;
 }
 
 int main() {
-    Buffer buffer;
-    enum { Prods = 5, Cons = 5 };
-    Producer * prods[Prods];
-    Consumer * cons[Cons];
-    const int Sentinel = -1;
-    int sums[Cons];
-    int i;
-    processor p;
+	Buffer buffer;
+	enum { Prods = 5, Cons = 5 };
+	Producer * prods[Prods];
+	Consumer * cons[Cons];
+	const int Sentinel = -1;
+	int sums[Cons];
+	int i;
+	processor p;
 
-    //rand48seed( getpid() );
-    rand48seed( 1003 );
+	//random_seed( getpid() );
+	random_seed( 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, 100000u );
-    } // for
+	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, 100000u );
+	} // 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 | endl;
+	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 | endl;
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa boundedBuffer.c" //
+// End: //
Index: src/tests/datingService.c
===================================================================
--- src/tests/datingService.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
+++ src/tests/datingService.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -0,0 +1,118 @@
+//                               -*- Mode: C -*- 
+// 
+// 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 : Mon Oct 30 23:02:11 2017
+// Update Count     : 15
+// 
+
+#include <stdlib>										// random
+#include <fstream>
+#include <kernel>
+#include <thread>
+#include <unistd.h>										// getpid
+
+bool empty( condition & c ) {
+	return c.blocked.head == NULL;
+}
+
+enum { NoOfPairs = 20 };
+
+monitor DatingService {
+	condition Girls[NoOfPairs], Boys[NoOfPairs];
+	unsigned int GirlPhoneNo, BoyPhoneNo;
+}; // DatingService
+
+unsigned int girl( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) {
+	if ( empty( ds.Boys[ccode] ) ) {
+		wait( &ds.Girls[ccode] );
+		ds.GirlPhoneNo = PhoneNo;
+	} else {
+		ds.GirlPhoneNo = PhoneNo;
+		signal_block( &ds.Boys[ccode] );
+	} // if
+	return ds.BoyPhoneNo;
+} // DatingService girl
+
+unsigned int boy( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) {
+	if ( empty( ds.Girls[ccode] ) ) {
+		wait( &ds.Boys[ccode] );
+		ds.BoyPhoneNo = PhoneNo;
+	} else {
+		ds.BoyPhoneNo = PhoneNo;
+		signal_block( &ds.Girls[ccode] );
+	} // if
+	return ds.GirlPhoneNo;
+} // DatingService boy
+
+unsigned int girlck[NoOfPairs];
+unsigned int boyck[NoOfPairs];
+
+thread Girl {
+	DatingService & TheExchange;
+	unsigned int id, ccode;
+}; // Girl
+
+void main( Girl & g ) {
+	yield( random( 100 ) );								// don't all start at the same time
+	unsigned int partner = girl( g.TheExchange, g.id, g.ccode );
+	//sout | "Girl:" | g.id | "is dating Boy at" | partner | "with ccode" | g.ccode | endl;
+	girlck[g.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 ) {
+	yield( random( 100 ) );								// don't all start at the same time
+	unsigned int partner = boy( b.TheExchange, b.id, b.ccode );
+	//sout | " Boy:" | b.id | "is dating Girl" | partner | "with ccode" | b.ccode | endl;
+	boyck[b.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[NoOfPairs];
+	Boy  *boys[NoOfPairs];
+
+	random_seed( getpid() );
+
+	for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) {
+		girls[i] = new( &TheExchange, i, i );
+		boys[i]  = new( &TheExchange, i, NoOfPairs - ( i + 1 ) );
+	} // for
+
+	for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) {
+		delete( boys[i] );
+		delete( girls[i] );
+	} // for
+
+	for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) {
+		if ( girlck[ boyck[i] ] != boyck[ girlck[i] ] ) abort();
+	} // for
+} // main
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa datingService.c" //
+// End: //
Index: src/tests/matrixSum.c
===================================================================
--- src/tests/matrixSum.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/matrixSum.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -11,6 +11,6 @@
 // Created On       : Mon Oct  9 08:29:28 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Oct  9 08:30:08 2017
-// Update Count     : 1
+// Last Modified On : Sun Oct 29 21:08:48 2017
+// Update Count     : 2
 // 
 
@@ -20,5 +20,5 @@
 
 thread Adder {
-    int * row, cols, * subtotal;			// communication
+    int * row, cols, * subtotal;						// communication
 };
 
@@ -32,5 +32,5 @@
     *adder.subtotal = 0;
     for ( int c = 0; c < adder.cols; c += 1 ) {
-	*adder.subtotal += adder.row[c];
+		*adder.subtotal += adder.row[c];
     } // for
 }
@@ -39,19 +39,19 @@
     const int rows = 10, cols = 1000;
     int matrix[rows][cols], subtotals[rows], total = 0;
-    processor p;					// extra kernel thread
+    processor p;										// extra kernel thread
 
     for ( int r = 0; r < rows; r += 1 ) {
-	for ( int c = 0; c < cols; c += 1 ) {
-	    matrix[r][c] = 1;
-	} // for
+		for ( int c = 0; c < cols; c += 1 ) {
+			matrix[r][c] = 1;
+		} // for
     } // for
     Adder * adders[rows];
-    for ( int r = 0; r < rows; r += 1 ) {		// start threads to sum rows
-	adders[r] = &(*malloc()){ matrix[r], cols, subtotals[r] };
-//	adders[r] = new( matrix[r], cols, &subtotals[r] );
+    for ( int r = 0; r < rows; r += 1 ) {				// start threads to sum rows
+		adders[r] = &(*malloc()){ matrix[r], cols, subtotals[r] };
+//		adders[r] = new( matrix[r], cols, &subtotals[r] );
     } // for
-    for ( int r = 0; r < rows; r += 1 ) {		// wait for threads to finish
-	delete( adders[r] );
-	total += subtotals[r];				// total subtotals
+    for ( int r = 0; r < rows; r += 1 ) {				// wait for threads to finish
+		delete( adders[r] );
+		total += subtotals[r];							// total subtotals
     } // for
     sout | total | endl;
Index: src/tests/prodcons.c
===================================================================
--- src/tests/prodcons.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/prodcons.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -10,11 +10,11 @@
 // Created On       : Mon Sep 18 12:23:39 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Sep 20 17:03:28 2017
-// Update Count     : 40
+// Last Modified On : Mon Oct 30 23:06:05 2017
+// Update Count     : 42
 // 
 
 #include <fstream>
 #include <coroutine>
-#include <stdlib>										// rand48
+#include <stdlib>										// random
 #include <unistd.h>										// getpid
 
@@ -30,6 +30,6 @@
 	// 1st resume starts here
 	for ( int i = 0; i < prod.N; i += 1 ) {
-		int p1 = (unsigned int)rand48() % 100;			// non-negative
-		int p2 = (unsigned int)rand48() % 100;
+		int p1 = random( 100 );
+		int p2 = random( 100 );
 		sout | p1 | " " | p2 | endl;
 		int status = delivery( *prod.c, p1, p2 );
@@ -90,5 +90,5 @@
 	Prod prod;
 	Cons cons = { prod };
-	rand48seed( /* getpid() */ 103 );					// fixed seed for testing
+	random_seed( /* getpid() */ 103 );					// fixed seed for testing
 	start( prod, 5, cons );
 	sout | "main stops" | endl;
Index: src/tests/random.c
===================================================================
--- src/tests/random.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/random.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -10,6 +10,6 @@
 // Created On       : Tue Jul  5 21:29:30 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul  6 18:00:29 2016
-// Update Count     : 3
+// Last Modified On : Mon Oct 30 23:06:49 2017
+// Update Count     : 6
 // 
 
@@ -19,27 +19,27 @@
 
 int main() {
-	//rand48seed( getpid() );								// set random seed
-	rand48seed( 1003 );									// fixed seed for repeatable tests
+	//srandom( getpid() );								// set random seed
+	random_seed( 1003 );								// fixed seed for repeatable tests
 
 	// test polymorphic calls to random and stream
-	char c = rand48();
+	char c = random();
 	sout | c | endl;
-	int i = rand48();
+	int i = random();
     sout | i | endl;
-	unsigned int ui = rand48();
+	unsigned int ui = random();
     sout | ui | endl;
-	long int li = rand48();
+	long int li = random();
     sout | li | endl;
-	unsigned long int uli = rand48();
+	unsigned long int uli = random();
     sout | uli | endl;
-    float f = rand48();
+    float f = random();
     sout | f | endl;
-    double d = rand48();
+    double d = random();
     sout | d | endl;
-    float _Complex fc = rand48();
+    float _Complex fc = random();
     sout | fc | endl;
-    double _Complex dc = rand48();
+    double _Complex dc = random();
     sout | dc | endl;
-    long double _Complex ldc = rand48();
+    long double _Complex ldc = random();
     sout | ldc | endl;
 } // main
Index: src/tests/rational.c
===================================================================
--- src/tests/rational.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/rational.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -10,6 +10,6 @@
 // Created On       : Mon Mar 28 08:43:12 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 23 21:40:11 2017
-// Update Count     : 66
+// Last Modified On : Tue Oct 10 23:25:04 2017
+// Update Count     : 67
 //
 
Index: src/tests/sched-ext-barge.c
===================================================================
--- src/tests/sched-ext-barge.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/sched-ext-barge.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -42,9 +42,9 @@
 void main( barger_t & this ) {
 	yield();
-	while( barge( global ) ) { yield(((unsigned)rand48()) % 10); }
+	while( barge( global ) ) { yield(random( 10 )); }
 }
 
 bool do_call( global_t & mutex this ) {
-	yield(((unsigned)rand48()) % 10);
+	yield(random( 10 ));
 	if( this.state != WAITFOR && !this.done && this.started ) {
 		serr | "Barging before caller detected" | endl;
@@ -57,5 +57,5 @@
 thread caller_t {};
 void main( caller_t & this ) {
-	while( do_call(global) ) { yield(((unsigned)rand48()) % 10); }
+	while( do_call(global) ) { yield(random( 10 )); }
 }
 
@@ -63,5 +63,5 @@
 	this.started = true;
 	for( int i = 0; i < N; i++) {
-		yield(((unsigned)rand48()) % 10);
+		yield(random( 10 ));
 		this.state = WAITFOR;
 		waitfor(do_call, this) {
Index: src/tests/sched-ext-dtor.c
===================================================================
--- src/tests/sched-ext-dtor.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/sched-ext-dtor.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -45,5 +45,5 @@
 
 void main( dummy_t & this ) {
-	yield(((unsigned)rand48()) % 10);
+	yield(random( 10 ));
 	set_state( this, MAIN );
 	waitfor( ^?{}, this ) {
@@ -58,5 +58,5 @@
 	for( int i = 0; i < N; i++ ){
 		dummy_t dummy[4];
-		yield( ((unsigned)rand48()) % 100 );
+		yield( random( 100 ) );
 	}
 	sout | "Stopping" | endl;
Index: src/tests/sched-ext-recurse.c
===================================================================
--- src/tests/sched-ext-recurse.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/sched-ext-recurse.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -15,5 +15,5 @@
 static const unsigned long N = 5_000ul;
 
-static inline void rand_yield() { yield(((unsigned)rand48()) % 10); }
+static inline void rand_yield() { yield(random( 10 )); }
 
 enum state_t { FIRST, SECOND, THIRD, LAST, STOP };
@@ -23,5 +23,5 @@
 	for (i = 0; i < 4; i++)
 	{
-		int j = ((unsigned)rand48()) % 4;
+		int j = random( 4 );
 		enum state_t t = array[j];
 		array[j] = array[i];
@@ -131,5 +131,5 @@
 
 int main() {
-	rand48seed( time(NULL) );
+	random_seed( time(NULL) );
 	sout | "Starting" | endl;
 	{
Index: src/tests/sched-ext-when.c
===================================================================
--- src/tests/sched-ext-when.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/sched-ext-when.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -15,5 +15,5 @@
 static const unsigned long N = 4_998ul;
 
-static inline void rand_yield() { yield(((unsigned)rand48()) % 10); }
+static inline void rand_yield() { yield(random( 10 )); }
 
 monitor global_t {
@@ -77,5 +77,5 @@
 
 int main() {
-	rand48seed( time(NULL) );
+	random_seed( time(NULL) );
 	sout | "Starting" | endl;
 	{
Index: src/tests/sched-ext.c
===================================================================
--- src/tests/sched-ext.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/sched-ext.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -26,8 +26,4 @@
 volatile bool done;
 
-unsigned rand10() {
-	return (unsigned)rand48() % 10;
-}
-
 //----------------------------------------------------------------------------------------------------
 // Acceptor
@@ -36,5 +32,5 @@
 void do_wait( global_t * mutex a ) {
 	sout | "Waiting to accept" | endl;
-	yield( rand10() );
+	yield( random( 10 ) );
 
 	sout | "Accepting" | endl;
@@ -48,5 +44,5 @@
 
 	sout | "Accepted" | endl;
-	yield( rand10() );
+	yield( random( 10 ) );
 }
 
@@ -68,7 +64,7 @@
 void main( Acceptee* this ) {
 	while( !done ) {
-		yield( rand10() );
+		yield( random( 10 ) );
 		do_notify( &globalA );
-		yield( rand10() );
+		yield( random( 10 ) );
 	}
 }
@@ -78,5 +74,5 @@
 int main(int argc, char* argv[]) {
 	done = false;
-	rand48seed( time( NULL ) );
+	random_seed( time( NULL ) );
 	printf("%p\n", &globalA);
 	sout | "Starting" | endl;
Index: src/tests/sched-int-barge.c
===================================================================
--- src/tests/sched-int-barge.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/sched-int-barge.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -64,7 +64,7 @@
 
 	if( action == 0 ) {
-		c.do_signal = max( ((unsigned)rand48()) % 10, 1);
-		c.do_wait1 = ((unsigned)rand48()) % (c.do_signal);
-		c.do_wait2 = ((unsigned)rand48()) % (c.do_signal);
+		c.do_signal = max( random( 10 ), 1);
+		c.do_wait1 = random( c.do_signal );
+		c.do_wait2 = random( c.do_signal );
 
 		if(c.do_wait1 == c.do_wait2) sout | "Same" | endl;
@@ -109,5 +109,5 @@
 
 int main(int argc, char* argv[]) {
-	rand48seed(0);
+	random_seed(0);
 	processor p;
 	{
Index: src/tests/sched-int-block.c
===================================================================
--- src/tests/sched-int-block.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/sched-int-block.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -49,5 +49,5 @@
 	wait( &cond, (uintptr_t)this_thread );
 
-	yield( ((unsigned)rand48()) % 10 );
+	yield( random( 10 ) );
 
 	if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) {
@@ -58,5 +58,5 @@
 	a.last_thread = b.last_thread = this_thread;
 
-	yield( ((unsigned)rand48()) % 10 );
+	yield( random( 10 ) );
 }
 
@@ -70,5 +70,5 @@
 //------------------------------------------------------------------------------
 void signal_op( global_data_t & mutex a, global_data_t & mutex b ) {
-	yield( ((unsigned)rand48()) % 10 );
+	yield( random( 10 ) );
 
 	[a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread;
@@ -83,5 +83,5 @@
 		}
 
-		yield( ((unsigned)rand48()) % 10 );
+		yield( random( 10 ) );
 
 		if(a.last_thread != next || b.last_thread != next) {
@@ -118,5 +118,5 @@
 
 int main(int argc, char* argv[]) {
-	rand48seed( time( NULL ) );
+	random_seed( time( NULL ) );
 	done = false;
 	processor p;
Index: src/tests/sched-int-disjoint.c
===================================================================
--- src/tests/sched-int-disjoint.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/sched-int-disjoint.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -88,5 +88,5 @@
 	signal( &cond, a, data );
 
-	yield( (unsigned)rand48() % 10 );
+	yield( random( 10 ) );
 
 	//This is technically a mutual exclusion violation but the mutex monitor protects us
@@ -109,5 +109,5 @@
 // Main loop
 int main(int argc, char* argv[]) {
-	rand48seed( time( NULL ) );
+	random_seed( time( NULL ) );
 	all_done = false;
 	processor p;
Index: src/tests/sched-int-wait.c
===================================================================
--- src/tests/sched-int-wait.c	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ src/tests/sched-int-wait.c	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -62,5 +62,5 @@
 
 	while( waiter_left != 0 ) {
-		unsigned action = (unsigned)rand48() % 4;
+		unsigned action = random( 4 );
 		switch( action ) {
 			case 0:
@@ -127,5 +127,5 @@
 // Main
 int main(int argc, char* argv[]) {
-	rand48seed( time( NULL ) );
+	random_seed( time( NULL ) );
 	waiter_left = 4;
 	processor p[2];
Index: tools/stat.py
===================================================================
--- tools/stat.py	(revision 64b272aedd6db65f570acb3d386065b1438f00f8)
+++ tools/stat.py	(revision e706bfdd16d98ec3bd9aa37c28043cfd7c27ef6f)
@@ -14,5 +14,8 @@
 		content.remove(max(content))
 		content.remove(min(content))
-		print "median {0} avg {1} stddev {2}".format( numpy.median(content), numpy.mean(content), numpy.std(content) )
+		med = numpy.around( numpy.median(content), decimals=1)
+		avg = numpy.around( numpy.mean  (content), decimals=2)
+		std = numpy.around( numpy.std   (content), decimals=2)
+		print "median {0} avg {1} stddev {2}".format( med, avg, std )