Index: benchmark/io/readv.cfa
===================================================================
--- benchmark/io/readv.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ benchmark/io/readv.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -16,8 +16,4 @@
 #include <thread.hfa>
 #include <time.hfa>
-
-#if !defined(HAVE_LINUX_IO_URING_H)
-#warning no io uring
-#endif
 
 extern bool traceHeapOn();
@@ -53,5 +49,5 @@
 	while(__atomic_load_n(&run, __ATOMIC_RELAXED)) {
 		int r = cfa_preadv2(fd, &iov, 1, 0, 0);
-		if(r < 0) abort(strerror(-r));
+		if(r < 0) abort("%s\n", strerror(-r));
 
 		__atomic_fetch_add( &count, 1, __ATOMIC_SEQ_CST );
@@ -63,20 +59,19 @@
 	unsigned long int nthreads = 2;
 	unsigned long int nprocs   = 1;
-
-	printf("Setting local\n");
-	setlocale(LC_NUMERIC, "");
+	int flags = 0;
 
 	arg_loop:
 	for(;;) {
 		static struct option options[] = {
-			{"duration",  required_argument, 0, 'd'},
-			{"nthreads",  required_argument, 0, 't'},
-			{"nprocs",    required_argument, 0, 'p'},
-			{"bufsize",   required_argument, 0, 'b'},
+			{"duration",   required_argument, 0, 'd'},
+			{"nthreads",   required_argument, 0, 't'},
+			{"nprocs",     required_argument, 0, 'p'},
+			{"bufsize",    required_argument, 0, 'b'},
+			{"userthread", no_argument      , 0, 'u'},
 			{0, 0, 0, 0}
 		};
 
 		int idx = 0;
-		int opt = getopt_long(argc, argv, "d:t:p:b:", options, &idx);
+		int opt = getopt_long(argc, argv, "d:t:p:b:u", options, &idx);
 
 		const char * arg = optarg ? optarg : "";
@@ -115,4 +110,7 @@
 				}
 				break;
+			case 'u':
+				flags |= CFA_CLUSTER_IO_POLLER_USER_THREAD;
+				break;
 			// Other cases
 			default: /* ? */
@@ -135,9 +133,9 @@
 	}
 
-	printf("Running %lu threads over %lu processors for %lf seconds\n", nthreads, nprocs, duration);
+	printf("Running %lu threads, reading %lu bytes each, over %lu processors for %lf seconds\n", nthreads, buflen, nprocs, duration);
 
 	{
 		Time start, end;
-		cluster cl = { "IO Cluster" };
+		cluster cl = { "IO Cluster", flags };
 		the_cluster = &cl;
 		#if !defined(__CFA_NO_STATISTICS__)
@@ -161,7 +159,9 @@
 			}
 		}
-		printf("Took %ld ms\n", (end - start)`ms);
-		printf("Total reads:      %'zu\n", count);
-		printf("Reads per second: %'lf\n", ((double)count) / (end - start)`s);
+		printf("Took %'ld ms\n", (end - start)`ms);
+		printf("Total reads      : %'15zu\n", count);
+		printf("Reads per second : %'18.2lf\n", ((double)count) / (end - start)`s);
+		printf("Total read size  : %'15zu\n", buflen * count);
+		printf("Bytes per second : %'18.2lf\n", ((double)count * buflen) / (end - start)`s);
 	}
 
Index: doc/bibliography/pl.bib
===================================================================
--- doc/bibliography/pl.bib	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ doc/bibliography/pl.bib	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -4759,5 +4759,5 @@
     contributer	= {pabuhr@plg},
     author	= {Gregory R. Andrews},
-    title	= {A Method for Solving Synronization Problems},
+    title	= {A Method for Solving Synchronization Problems},
     journal	= scp,
     volume	= 13,
Index: libcfa/prelude/defines.hfa.in
===================================================================
--- libcfa/prelude/defines.hfa.in	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ libcfa/prelude/defines.hfa.in	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -19,4 +19,3 @@
 #undef HAVE_PWRITEV2
 
-// #define __CFA_IO_POLLING_USER__
-// #define __CFA_IO_POLLING_KERNEL__
+#undef __CFA_NO_STATISTICS__
Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ libcfa/src/concurrency/io.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -20,5 +20,5 @@
 
 #if !defined(HAVE_LINUX_IO_URING_H)
-	void __kernel_io_startup( cluster &, bool ) {
+	void __kernel_io_startup( cluster &, int, bool ) {
 		// Nothing to do without io_uring
 	}
@@ -86,19 +86,122 @@
 	#endif
 
-	#if defined(__CFA_IO_POLLING_USER__)
-		void ?{}( __io_poller_fast & this, struct cluster & cltr ) {
-			this.ring = &cltr.io;
-			(this.thrd){ "Fast I/O Poller", cltr };
-		}
-		void ^?{}( __io_poller_fast & mutex this );
-      	void main( __io_poller_fast & this );
-      	static inline $thread * get_thread( __io_poller_fast & this ) { return &this.thrd; }
-		void ^?{}( __io_poller_fast & mutex this ) {}
-	#endif
+	// Fast poller user-thread
+	// Not using the "thread" keyword because we want to control
+	// more carefully when to start/stop it
+	struct __io_poller_fast {
+		struct __io_data * ring;
+		bool waiting;
+		$thread thrd;
+	};
+
+	void ?{}( __io_poller_fast & this, struct cluster & cltr ) {
+		this.ring = cltr.io;
+		this.waiting = true;
+		(this.thrd){ "Fast I/O Poller", cltr };
+	}
+	void ^?{}( __io_poller_fast & mutex this );
+	void main( __io_poller_fast & this );
+	static inline $thread * get_thread( __io_poller_fast & this ) { return &this.thrd; }
+	void ^?{}( __io_poller_fast & mutex this ) {}
+
+	struct __submition_data {
+		// Head and tail of the ring (associated with array)
+		volatile uint32_t * head;
+		volatile uint32_t * tail;
+
+		// The actual kernel ring which uses head/tail
+		// indexes into the sqes arrays
+		uint32_t * array;
+
+		// number of entries and mask to go with it
+		const uint32_t * num;
+		const uint32_t * mask;
+
+		// Submission flags (Not sure what for)
+		uint32_t * flags;
+
+		// number of sqes not submitted (whatever that means)
+		uint32_t * dropped;
+
+		// Like head/tail but not seen by the kernel
+		volatile uint32_t alloc;
+		volatile uint32_t ready;
+
+		__spinlock_t lock;
+
+		// A buffer of sqes (not the actual ring)
+		struct io_uring_sqe * sqes;
+
+		// The location and size of the mmaped area
+		void * ring_ptr;
+		size_t ring_sz;
+
+		// Statistics
+		#if !defined(__CFA_NO_STATISTICS__)
+			struct {
+				struct {
+					volatile unsigned long long int val;
+					volatile unsigned long long int cnt;
+					volatile unsigned long long int block;
+				} submit_avg;
+			} stats;
+		#endif
+	};
+
+	struct __completion_data {
+		// Head and tail of the ring
+		volatile uint32_t * head;
+		volatile uint32_t * tail;
+
+		// number of entries and mask to go with it
+		const uint32_t * mask;
+		const uint32_t * num;
+
+		// number of cqes not submitted (whatever that means)
+		uint32_t * overflow;
+
+		// the kernel ring
+		struct io_uring_cqe * cqes;
+
+		// The location and size of the mmaped area
+		void * ring_ptr;
+		size_t ring_sz;
+
+		// Statistics
+		#if !defined(__CFA_NO_STATISTICS__)
+			struct {
+				struct {
+					unsigned long long int val;
+					unsigned long long int slow_cnt;
+					unsigned long long int fast_cnt;
+				} completed_avg;
+			} stats;
+		#endif
+	};
+
+	struct __io_data {
+		struct __submition_data submit_q;
+		struct __completion_data completion_q;
+		uint32_t ring_flags;
+		int cltr_flags;
+		int fd;
+		semaphore submit;
+		volatile bool done;
+		struct {
+			struct {
+				void * stack;
+				pthread_t kthrd;
+			} slow;
+			__io_poller_fast fast;
+			__bin_sem_t sem;
+		} poller;
+	};
 
 //=============================================================================================
 // I/O Startup / Shutdown logic
 //=============================================================================================
-	void __kernel_io_startup( cluster & this, bool main_cluster ) {
+	void __kernel_io_startup( cluster & this, int io_flags, bool main_cluster ) {
+		this.io = malloc();
+
 		// Step 1 : call to setup
 		struct io_uring_params params;
@@ -113,7 +216,7 @@
 
 		// Step 2 : mmap result
-		memset(&this.io, 0, sizeof(struct io_ring));
-		struct io_uring_sq & sq = this.io.submit_q;
-		struct io_uring_cq & cq = this.io.completion_q;
+		memset( this.io, 0, sizeof(struct __io_data) );
+		struct __submition_data  & sq = this.io->submit_q;
+		struct __completion_data & cq = this.io->completion_q;
 
 		// calculate the right ring size
@@ -193,15 +296,18 @@
 
 		// Update the global ring info
-		this.io.flags = params.flags;
-		this.io.fd    = fd;
-		this.io.done  = false;
-		(this.io.submit){ min(*sq.num, *cq.num) };
+		this.io->ring_flags = params.flags;
+		this.io->cltr_flags = io_flags;
+		this.io->fd         = fd;
+		this.io->done       = false;
+		(this.io->submit){ min(*sq.num, *cq.num) };
 
 		// Initialize statistics
 		#if !defined(__CFA_NO_STATISTICS__)
-			this.io.submit_q.stats.submit_avg.val = 0;
-			this.io.submit_q.stats.submit_avg.cnt = 0;
-			this.io.completion_q.stats.completed_avg.val = 0;
-			this.io.completion_q.stats.completed_avg.cnt = 0;
+			this.io->submit_q.stats.submit_avg.val   = 0;
+			this.io->submit_q.stats.submit_avg.cnt   = 0;
+			this.io->submit_q.stats.submit_avg.block = 0;
+			this.io->completion_q.stats.completed_avg.val = 0;
+			this.io->completion_q.stats.completed_avg.slow_cnt = 0;
+			this.io->completion_q.stats.completed_avg.fast_cnt = 0;
 		#endif
 
@@ -212,13 +318,13 @@
 
 	void __kernel_io_finish_start( cluster & this ) {
-		#if defined(__CFA_IO_POLLING_USER__)
+		if( this.io->cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ) {
 			__cfadbg_print_safe(io_core, "Kernel I/O : Creating fast poller for cluter %p\n", &this);
-			(this.io.poller.fast){ this };
-			__thrd_start( this.io.poller.fast, main );
-		#endif
+			(this.io->poller.fast){ this };
+			__thrd_start( this.io->poller.fast, main );
+		}
 
 		// Create the poller thread
 		__cfadbg_print_safe(io_core, "Kernel I/O : Creating slow poller for cluter %p\n", &this);
-		this.io.poller.slow.stack = __create_pthread( &this.io.poller.slow.kthrd, __io_poller_slow, &this );
+		this.io->poller.slow.stack = __create_pthread( &this.io->poller.slow.kthrd, __io_poller_slow, &this );
 	}
 
@@ -226,27 +332,66 @@
 		__cfadbg_print_safe(io_core, "Kernel I/O : Stopping pollers for cluster\n", &this);
 		// Notify the poller thread of the shutdown
-		__atomic_store_n(&this.io.done, true, __ATOMIC_SEQ_CST);
+		__atomic_store_n(&this.io->done, true, __ATOMIC_SEQ_CST);
 
 		// Stop the IO Poller
 		sigval val = { 1 };
-		pthread_sigqueue( this.io.poller.slow.kthrd, SIGUSR1, val );
-		#if defined(__CFA_IO_POLLING_USER__)
-			post( this.io.poller.sem );
-		#endif
+		pthread_sigqueue( this.io->poller.slow.kthrd, SIGUSR1, val );
+		post( this.io->poller.sem );
 
 		// Wait for the poller thread to finish
-		pthread_join( this.io.poller.slow.kthrd, 0p );
-		free( this.io.poller.slow.stack );
+		pthread_join( this.io->poller.slow.kthrd, 0p );
+		free( this.io->poller.slow.stack );
 
 		__cfadbg_print_safe(io_core, "Kernel I/O : Slow poller stopped for cluster\n", &this);
 
-		#if defined(__CFA_IO_POLLING_USER__)
+		if( this.io->cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ) {
+			with( this.io->poller.fast ) {
+				/* paranoid */ verify( waiting ); // The thread shouldn't be in a system call
+				/* paranoid */ verify( this.procs.head == 0p || &this == mainCluster );
+				/* paranoid */ verify( this.idles.head == 0p || &this == mainCluster );
+
+				// We need to adjust the clean-up based on where the thread is
+				if( thrd.preempted != __NO_PREEMPTION ) {
+
+					// This is the tricky case
+					// The thread was preempted and now it is on the ready queue
+					/* paranoid */ verify( thrd.state == Active );           // The thread better be in this state
+					/* paranoid */ verify( thrd.next == 1p );                // The thread should be the last on the list
+					/* paranoid */ verify( this.ready_queue.head == &thrd ); // The thread should be the only thing on the list
+
+					// Remove the thread from the ready queue of this cluster
+					this.ready_queue.head = 1p;
+					thrd.next = 0p;
+
+					// Fixup the thread state
+					thrd.state = Blocked;
+					thrd.preempted = __NO_PREEMPTION;
+
+					// Pretend like the thread was blocked all along
+				}
+				// !!! This is not an else if !!!
+				if( thrd.state == Blocked ) {
+
+					// This is the "easy case"
+					// The thread is parked and can easily be moved to active cluster
+					verify( thrd.curr_cluster != active_cluster() || thrd.curr_cluster == mainCluster );
+					thrd.curr_cluster = active_cluster();
+
 			// unpark the fast io_poller
-			unpark( &this.io.poller.fast.thrd __cfaabi_dbg_ctx2 );
-
-			^(this.io.poller.fast){};
+					unpark( &thrd __cfaabi_dbg_ctx2 );
+				}
+				else {
+
+					// The thread is in a weird state
+					// I don't know what to do here
+					abort("Fast poller thread is in unexpected state, cannot clean-up correctly\n");
+				}
+
+			}
+
+			^(this.io->poller.fast){};
 
 			__cfadbg_print_safe(io_core, "Kernel I/O : Fast poller stopped for cluster\n", &this);
-		#endif
+		}
 	}
 
@@ -259,21 +404,26 @@
 		#if !defined(__CFA_NO_STATISTICS__)
 			if(this.print_stats) {
-				__cfaabi_bits_print_safe( STDERR_FILENO,
-					"----- I/O uRing Stats -----\n"
-					"- total submit calls  : %llu\n"
-					"- avg submit          : %lf\n"
-					"- total wait calls    : %llu\n"
-					"- avg completion/wait : %lf\n",
-					this.io.submit_q.stats.submit_avg.cnt,
-					((double)this.io.submit_q.stats.submit_avg.val) / this.io.submit_q.stats.submit_avg.cnt,
-					this.io.completion_q.stats.completed_avg.cnt,
-					((double)this.io.completion_q.stats.completed_avg.val) / this.io.completion_q.stats.completed_avg.cnt
-				);
+				with(this.io->submit_q.stats, this.io->completion_q.stats) {
+					__cfaabi_bits_print_safe( STDERR_FILENO,
+						"----- I/O uRing Stats -----\n"
+						"- total submit calls  : %'15llu\n"
+						"- avg submit          : %'18.2lf\n"
+						"- pre-submit block %%  : %'18.2lf\n"
+						"- total wait calls    : %'15llu   (%'llu slow, %'llu fast)\n"
+						"- avg completion/wait : %'18.2lf\n",
+						submit_avg.cnt,
+						((double)submit_avg.val) / submit_avg.cnt,
+						(100.0 * submit_avg.block) / submit_avg.cnt,
+						completed_avg.slow_cnt + completed_avg.fast_cnt,
+						completed_avg.slow_cnt,  completed_avg.fast_cnt,
+						((double)completed_avg.val) / (completed_avg.slow_cnt + completed_avg.fast_cnt)
+					);
+				}
 			}
 		#endif
 
 		// Shutdown the io rings
-		struct io_uring_sq & sq = this.io.submit_q;
-		struct io_uring_cq & cq = this.io.completion_q;
+		struct __submition_data  & sq = this.io->submit_q;
+		struct __completion_data & cq = this.io->completion_q;
 
 		// unmap the submit queue entries
@@ -289,5 +439,7 @@
 
 		// close the file descriptor
-		close(this.io.fd);
+		close(this.io->fd);
+
+		free( this.io );
 	}
 
@@ -302,5 +454,5 @@
 	// Process a single completion message from the io_uring
 	// This is NOT thread-safe
-	static int __drain_io( struct io_ring & ring, sigset_t * mask, int waitcnt, bool in_kernel ) {
+	static int __drain_io( struct __io_data & ring, sigset_t * mask, int waitcnt, bool in_kernel ) {
 		int ret = syscall( __NR_io_uring_enter, ring.fd, 0, waitcnt, IORING_ENTER_GETEVENTS, mask, _NSIG / 8);
 		if( ret < 0 ) {
@@ -320,7 +472,4 @@
 		// Nothing was new return 0
 		if (head == tail) {
-			#if !defined(__CFA_NO_STATISTICS__)
-				ring.completion_q.stats.completed_avg.cnt += 1;
-			#endif
 			return 0;
 		}
@@ -348,10 +497,4 @@
 		__atomic_fetch_add( ring.completion_q.head, count, __ATOMIC_RELAXED );
 
-		// Update statistics
-		#if !defined(__CFA_NO_STATISTICS__)
-			ring.completion_q.stats.completed_avg.val += count;
-			ring.completion_q.stats.completed_avg.cnt += 1;
-		#endif
-
 		return count;
 	}
@@ -359,5 +502,5 @@
 	static void * __io_poller_slow( void * arg ) {
 		cluster * cltr = (cluster *)arg;
-		struct io_ring & ring = cltr->io;
+		struct __io_data & ring = *cltr->io;
 
 		sigset_t mask;
@@ -372,10 +515,18 @@
 		verify( (*ring.completion_q.head) == (*ring.completion_q.tail) );
 
-		while(!__atomic_load_n(&ring.done, __ATOMIC_SEQ_CST)) {
-			#if defined(__CFA_IO_POLLING_USER__)
-
+		__cfadbg_print_safe(io_core, "Kernel I/O : Slow poller for ring %p ready\n", &ring);
+
+		if( ring.cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ) {
+			while(!__atomic_load_n(&ring.done, __ATOMIC_SEQ_CST)) {
 				// In the user-thread approach drain and if anything was drained,
 				// batton pass to the user-thread
 				int count = __drain_io( ring, &mask, 1, true );
+
+				// Update statistics
+				#if !defined(__CFA_NO_STATISTICS__)
+					ring.completion_q.stats.completed_avg.val += count;
+					ring.completion_q.stats.completed_avg.slow_cnt += 1;
+				#endif
+
 				if(count > 0) {
 					__cfadbg_print_safe(io_core, "Kernel I/O : Moving to ring %p to fast poller\n", &ring);
@@ -383,37 +534,63 @@
 					wait( ring.poller.sem );
 				}
-
-			#else
-
+			}
+		}
+		else {
+			while(!__atomic_load_n(&ring.done, __ATOMIC_SEQ_CST)) {
 				//In the naive approach, just poll the io completion queue directly
-				__drain_io( ring, &mask, 1, true );
-
+				int count = __drain_io( ring, &mask, 1, true );
+
+				// Update statistics
+				#if !defined(__CFA_NO_STATISTICS__)
+					ring.completion_q.stats.completed_avg.val += count;
+					ring.completion_q.stats.completed_avg.slow_cnt += 1;
+				#endif
+			}
+		}
+
+		__cfadbg_print_safe(io_core, "Kernel I/O : Slow poller for ring %p stopping\n", &ring);
+
+		return 0p;
+	}
+
+	void main( __io_poller_fast & this ) {
+		verify( this.ring->cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD );
+
+		// Start parked
+		park( __cfaabi_dbg_ctx );
+
+		__cfadbg_print_safe(io_core, "Kernel I/O : Fast poller for ring %p ready\n", &this.ring);
+
+		int reset = 0;
+
+		// Then loop until we need to start
+		while(!__atomic_load_n(&this.ring->done, __ATOMIC_SEQ_CST)) {
+			// Drain the io
+			this.waiting = false;
+			int count = __drain_io( *this.ring, 0p, 0, false );
+			reset += count > 0 ? 1 : 0;
+
+			// Update statistics
+			#if !defined(__CFA_NO_STATISTICS__)
+				this.ring->completion_q.stats.completed_avg.val += count;
+				this.ring->completion_q.stats.completed_avg.fast_cnt += 1;
 			#endif
-		}
-
-		return 0p;
-	}
-
-	#if defined(__CFA_IO_POLLING_USER__)
-		void main( __io_poller_fast & this ) {
-			// Start parked
-			park( __cfaabi_dbg_ctx );
-
-			// Then loop until we need to start
-			while(!__atomic_load_n(&this.ring->done, __ATOMIC_SEQ_CST)) {
-				// Drain the io
-				if(0 > __drain_io( *this.ring, 0p, 0, false )) {
-					// If we got something, just yield and check again
-					yield();
-				}
-				else {
-					// We didn't get anything baton pass to the slow poller
-					__cfadbg_print_safe(io_core, "Kernel I/O : Moving to ring %p to slow poller\n", &this.ring);
-					post( this.ring->poller.sem );
-					park( __cfaabi_dbg_ctx );
-				}
+
+			this.waiting = true;
+			if(reset < 5) {
+				// If we got something, just yield and check again
+				yield();
 			}
-		}
-	#endif
+			else {
+				// We didn't get anything baton pass to the slow poller
+				__cfadbg_print_safe(io_core, "Kernel I/O : Moving to ring %p to slow poller\n", &this.ring);
+				post( this.ring->poller.sem );
+				park( __cfaabi_dbg_ctx );
+				reset = 0;
+			}
+		}
+
+		__cfadbg_print_safe(io_core, "Kernel I/O : Fast poller for ring %p stopping\n", &this.ring);
+	}
 
 //=============================================================================================
@@ -445,7 +622,10 @@
 //
 
-	static inline [* struct io_uring_sqe, uint32_t] __submit_alloc( struct io_ring & ring ) {
+	static inline [* struct io_uring_sqe, uint32_t] __submit_alloc( struct __io_data & ring ) {
 		// Wait for a spot to be available
-		P(ring.submit);
+		__attribute__((unused)) bool blocked = P(ring.submit);
+		#if !defined(__CFA_NO_STATISTICS__)
+			__atomic_fetch_add( &ring.submit_q.stats.submit_avg.block, blocked ? 1ul64 : 0ul64, __ATOMIC_RELAXED );
+		#endif
 
 		// Allocate the sqe
@@ -463,5 +643,5 @@
 	}
 
-	static inline void __submit( struct io_ring & ring, uint32_t idx ) {
+	static inline void __submit( struct __io_data & ring, uint32_t idx ) {
 		// get mutual exclusion
 		lock(ring.submit_q.lock __cfaabi_dbg_ctx2);
@@ -524,5 +704,5 @@
 
 	#define __submit_prelude \
-		struct io_ring & ring = active_cluster()->io; \
+		struct __io_data & ring = *active_cluster()->io; \
 		struct io_uring_sqe * sqe; \
 		uint32_t idx; \
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ libcfa/src/concurrency/kernel.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -256,5 +256,5 @@
 }
 
-void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
+void ?{}(cluster & this, const char name[], Duration preemption_rate, int io_flags) with( this ) {
 	this.name = name;
 	this.preemption_rate = preemption_rate;
@@ -270,5 +270,5 @@
 	threads{ __get };
 
-	__kernel_io_startup( this, &this == mainCluster );
+	__kernel_io_startup( this, io_flags, &this == mainCluster );
 
 	doregister(this);
@@ -993,5 +993,5 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore & this) with( this ){
+bool P(semaphore & this) with( this ){
 	lock( lock __cfaabi_dbg_ctx2 );
 	count -= 1;
@@ -1003,7 +1003,9 @@
 		unlock( lock );
 		park( __cfaabi_dbg_ctx );
+		return true;
 	}
 	else {
 	    unlock( lock );
+	    return false;
 	}
 }
Index: libcfa/src/concurrency/kernel.hfa
===================================================================
--- libcfa/src/concurrency/kernel.hfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ libcfa/src/concurrency/kernel.hfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -38,5 +38,5 @@
 void  ?{}(semaphore & this, int count = 1);
 void ^?{}(semaphore & this);
-void   P (semaphore & this);
+bool   P (semaphore & this);
 bool   V (semaphore & this);
 bool   V (semaphore & this, unsigned count);
@@ -114,104 +114,8 @@
 //-----------------------------------------------------------------------------
 // I/O
-#if defined(HAVE_LINUX_IO_URING_H)
-struct io_uring_sq {
-	// Head and tail of the ring (associated with array)
-	volatile uint32_t * head;
-	volatile uint32_t * tail;
+struct __io_data;
 
-	// The actual kernel ring which uses head/tail
-	// indexes into the sqes arrays
-	uint32_t * array;
-
-	// number of entries and mask to go with it
-	const uint32_t * num;
-	const uint32_t * mask;
-
-	// Submission flags (Not sure what for)
-	uint32_t * flags;
-
-	// number of sqes not submitted (whatever that means)
-	uint32_t * dropped;
-
-	// Like head/tail but not seen by the kernel
-	volatile uint32_t alloc;
-	volatile uint32_t ready;
-
-	__spinlock_t lock;
-
-	// A buffer of sqes (not the actual ring)
-	struct io_uring_sqe * sqes;
-
-	// The location and size of the mmaped area
-	void * ring_ptr;
-	size_t ring_sz;
-
-	// Statistics
-	#if !defined(__CFA_NO_STATISTICS__)
-		struct {
-			struct {
-				unsigned long long int val;
-				unsigned long long int cnt;
-			} submit_avg;
-		} stats;
-	#endif
-};
-
-struct io_uring_cq {
-	// Head and tail of the ring
-	volatile uint32_t * head;
-	volatile uint32_t * tail;
-
-	// number of entries and mask to go with it
-	const uint32_t * mask;
-	const uint32_t * num;
-
-	// number of cqes not submitted (whatever that means)
-	uint32_t * overflow;
-
-	// the kernel ring
-	struct io_uring_cqe * cqes;
-
-	// The location and size of the mmaped area
-	void * ring_ptr;
-	size_t ring_sz;
-
-	// Statistics
-	#if !defined(__CFA_NO_STATISTICS__)
-		struct {
-			struct {
-				unsigned long long int val;
-				unsigned long long int cnt;
-			} completed_avg;
-		} stats;
-	#endif
-};
-
-#if defined(__CFA_IO_POLLING_USER__)
-	struct __io_poller_fast {
-		struct io_ring * ring;
-		$thread thrd;
-	};
-#endif
-
-struct io_ring {
-	struct io_uring_sq submit_q;
-	struct io_uring_cq completion_q;
-	uint32_t flags;
-	int fd;
-	semaphore submit;
-	volatile bool done;
-	struct {
-		struct {
-			void * stack;
-			pthread_t kthrd;
-		} slow;
-		#if defined(__CFA_IO_POLLING_USER__)
-			__io_poller_fast fast;
-			__bin_sem_t sem;
-		#endif
-	} poller;
-};
-#endif
+#define CFA_CLUSTER_IO_POLLER_USER_THREAD 1 << 0
+// #define CFA_CLUSTER_IO_POLLER_KERNEL_SIDE 1 << 1
 
 //-----------------------------------------------------------------------------
@@ -247,7 +151,5 @@
 	} node;
 
-	#if defined(HAVE_LINUX_IO_URING_H)
-		struct io_ring io;
-	#endif
+	struct __io_data * io;
 
 	#if !defined(__CFA_NO_STATISTICS__)
@@ -257,10 +159,13 @@
 extern Duration default_preemption();
 
-void ?{} (cluster & this, const char name[], Duration preemption_rate);
+void ?{} (cluster & this, const char name[], Duration preemption_rate, int flags);
 void ^?{}(cluster & this);
 
-static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
-static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
-static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
+static inline void ?{} (cluster & this)                                      { this{"Anonymous Cluster", default_preemption(), 0}; }
+static inline void ?{} (cluster & this, Duration preemption_rate)            { this{"Anonymous Cluster", preemption_rate, 0}; }
+static inline void ?{} (cluster & this, const char name[])                   { this{name, default_preemption(), 0}; }
+static inline void ?{} (cluster & this, int flags)                           { this{"Anonymous Cluster", default_preemption(), flags}; }
+static inline void ?{} (cluster & this, Duration preemption_rate, int flags) { this{"Anonymous Cluster", preemption_rate, flags}; }
+static inline void ?{} (cluster & this, const char name[], int flags)        { this{name, default_preemption(), flags}; }
 
 static inline [cluster *&, cluster *& ] __get( cluster & this ) __attribute__((const)) { return this.node.[next, prev]; }
Index: libcfa/src/concurrency/kernel_private.hfa
===================================================================
--- libcfa/src/concurrency/kernel_private.hfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ libcfa/src/concurrency/kernel_private.hfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -59,4 +59,6 @@
 extern volatile thread_local __cfa_kernel_preemption_state_t preemption_state __attribute__ ((tls_model ( "initial-exec" )));
 
+extern cluster * mainCluster;
+
 //-----------------------------------------------------------------------------
 // Threads
@@ -75,5 +77,5 @@
 //-----------------------------------------------------------------------------
 // I/O
-void __kernel_io_startup     ( cluster &, bool );
+void __kernel_io_startup     ( cluster &, int, bool );
 void __kernel_io_finish_start( cluster & );
 void __kernel_io_prepare_stop( cluster & );
Index: libcfa/src/exception.hfa
===================================================================
--- libcfa/src/exception.hfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
+++ libcfa/src/exception.hfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -0,0 +1,106 @@
+//
+// 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.
+//
+// exception.hfa -- User facing tools for working with exceptions.
+//
+// Author           : Andrew Beach
+// Created On       : Thu Apr  7 10:25:00 2020
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Apr  7 10:25:00 2020
+// Update Count     : 0
+//
+
+// Everything below this line should be considered a patch while the exception
+// objects themselves are designed and  created and should be removed in time.
+// -----------------------------------------------------------------------------------------------
+
+// All internals helper macros begin with an underscore.
+#define _CLOSE(...) __VA_ARGS__ }
+#define _GLUE2(left, right) left##right
+#define _GLUE3(left, middle, right) left##middle##right
+#define _EXC_DISPATCH(to, ...) to(__VA_ARGS__,__cfaehm_base_exception_t,)
+
+// FWD_TRIVIAL_EXCEPTION(exception_name);
+// Declare a trivial exception, one that adds no fields or features.
+// This will make the exception visible and may go in a .hfa or .cfa file.
+#define FWD_TRIVIAL_EXCEPTION(...) _EXC_DISPATCH(_FWD_TRIVIAL_EXCEPTION, __VA_ARGS__)
+// INST_TRIVIAL_EXCEPTION(exception_name);
+// Create the trival exception. This must be used exactly once and should be used in a .cfa file,
+// as it creates the unique instance of the virtual table.
+#define INST_TRIVIAL_EXCEPTION(...) _EXC_DISPATCH(_INST_TRIVIAL_EXCEPTION, __VA_ARGS__)
+// TRIVIAL_EXCEPTION(exception_name[, parent_name]);
+// Does both of the above, a short hand if the exception is only used in one .cfa file.
+// For legacy reasons this is the only one that official supports having a parent other than the
+// base exception. This feature may be removed or changed.
+#define TRIVIAL_EXCEPTION(...) \
+	_EXC_DISPATCH(_FWD_TRIVIAL_EXCEPTION, __VA_ARGS__); \
+	_EXC_DISPATCH(_INST_TRIVIAL_EXCEPTION, __VA_ARGS__)
+#define _FWD_TRIVIAL_EXCEPTION(exception_name, parent_name, ...) \
+	_VTABLE_DECLARATION(exception_name, parent_name)(); \
+	struct exception_name { \
+		VTABLE_FIELD(exception_name); \
+	}; \
+	void ?{}(exception_name & this); \
+	const char * _GLUE2(exception_name,_msg)(exception_name * this)
+#define _INST_TRIVIAL_EXCEPTION(exception_name, parent_name, ...) \
+	void ?{}(exception_name & this) { \
+		VTABLE_INIT(this, exception_name); \
+	} \
+	const char * _GLUE2(exception_name,_msg)(exception_name * this) { \
+		return #exception_name; \
+	} \
+	_VTABLE_INSTANCE(exception_name, parent_name,)(_GLUE2(exception_name,_msg))
+
+// DATA_EXCEPTION(exception_name)(fields...);
+// Forward declare an exception that adds fields but no features. The added fields go in the
+// second argument list. The virtual table instance must be provided later (see VTABLE_INSTANCE).
+#define DATA_EXCEPTION(...) _EXC_DISPATCH(_DATA_EXCEPTION, __VA_ARGS__)
+#define _DATA_EXCEPTION(exception_name, parent_name, ...) \
+	_VTABLE_DECLARATION(exception_name, parent_name)(); \
+	struct exception_name { VTABLE_FIELD(exception_name); _CLOSE
+
+// VTABLE_DECLARATION(exception_name)([new_features...]);
+// Declare a virtual table type for an exception with exception_name. You may also add features
+// (fields on the virtual table) by including them in the second list.
+#define VTABLE_DECLARATION(...) _EXC_DISPATCH(_VTABLE_DECLARATION, __VA_ARGS__)
+#define _VTABLE_DECLARATION(exception_name, parent_name, ...) \
+	struct exception_name; \
+	VTABLE_TYPE(exception_name); \
+	extern VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name); \
+	VTABLE_TYPE(exception_name) { \
+		VTABLE_TYPE(parent_name) const * parent; \
+		size_t size; \
+		void (*copy)(exception_name * this, exception_name * other); \
+		void (*free)(exception_name & this); \
+		const char * (*msg)(exception_name * this); \
+		_CLOSE
+
+// VTABLE_INSTANCE(exception_name)(msg [, others...]);
+// Create the instance of the virtual table. There must be exactly one instance of a virtual table
+// for each exception type. This fills in most of the fields of the virtual table (uses ?=? and
+// ^?{}) but you must provide the message function and any other fields added in the declaration.
+#define VTABLE_INSTANCE(...) _EXC_DISPATCH(_VTABLE_INSTANCE, __VA_ARGS__)
+#define _VTABLE_INSTANCE(exception_name, parent_name, ...) \
+	void _GLUE2(exception_name,_copy)(exception_name * this, exception_name * other) { \
+		*this = *other; \
+	} \
+	VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name) @= { \
+		&VTABLE_NAME(parent_name), sizeof(exception_name), \
+		_GLUE2(exception_name,_copy), ^?{}, \
+		_CLOSE
+
+// VTABLE_TYPE(exception_name) | VTABLE_NAME(exception_name)
+// Get the name of the vtable type or the name of the vtable instance for an exception type.
+#define VTABLE_TYPE(exception_name) struct _GLUE2(exception_name,_vtable)
+#define VTABLE_NAME(exception_name) _GLUE3(_,exception_name,_vtable_instance)
+
+// VTABLE_FIELD(exception_name);
+// The declaration of the virtual table field. Should be the first declaration in a virtual type.
+#define VTABLE_FIELD(exception_name) VTABLE_TYPE(exception_name) const * virtual_table
+
+// VTABLE_INIT(object_reference, exception_name);
+// Sets a virtual table field on an object to the virtual table instance for the type.
+#define VTABLE_INIT(this, exception_name) (this).virtual_table = &VTABLE_NAME(exception_name)
Index: libcfa/src/heap.cfa
===================================================================
--- libcfa/src/heap.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ libcfa/src/heap.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -10,6 +10,6 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr 18 17:43:15 2020
-// Update Count     : 718
+// Last Modified On : Wed May  6 17:29:26 2020
+// Update Count     : 727
 //
 
@@ -19,9 +19,9 @@
 #include <errno.h>										// errno
 #include <string.h>										// memset, memcpy
+#include <limits.h>										// ULONG_MAX
 extern "C" {
 #include <sys/mman.h>									// mmap, munmap
 } // extern "C"
 
-// #comment TD : Many of these should be merged into math I believe
 #include "bits/align.hfa"								// libPow2
 #include "bits/defs.hfa"								// likely, unlikely
@@ -30,4 +30,5 @@
 //#include "stdlib.hfa"									// bsearchl
 #include "malloc.h"
+#include "bitmanip.hfa"									// ceiling
 
 #define MIN(x, y) (y > x ? x : y)
@@ -81,11 +82,11 @@
 };
 
+size_t default_heap_expansion() __attribute__(( weak )) {
+	return __CFA_DEFAULT_HEAP_EXPANSION__;
+} // default_heap_expansion
+
 size_t default_mmap_start() __attribute__(( weak )) {
 	return __CFA_DEFAULT_MMAP_START__;
 } // default_mmap_start
-
-size_t default_heap_expansion() __attribute__(( weak )) {
-	return __CFA_DEFAULT_HEAP_EXPANSION__;
-} // default_heap_expansion
 
 
@@ -360,11 +361,4 @@
 
 
-static inline bool setHeapExpand( size_t value ) {
-  if ( heapExpand < pageSize ) return true;
-	heapExpand = value;
-	return false;
-} // setHeapExpand
-
-
 // thunk problem
 size_t Bsearchl( unsigned int key, const unsigned int * vals, size_t dim ) {
@@ -383,5 +377,5 @@
 
 static inline bool setMmapStart( size_t value ) {		// true => mmapped, false => sbrk
-  if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true;
+  if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return false;
 	mmapStart = value;									// set global
 
@@ -390,5 +384,5 @@
 	assert( maxBucketsUsed < NoBucketSizes );			// subscript failure ?
 	assert( mmapStart <= bucketSizes[maxBucketsUsed] ); // search failure ?
-	return false;
+	return true;
 } // setMmapStart
 
@@ -449,5 +443,5 @@
 
 	#ifdef __CFA_DEBUG__
-	checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
+	checkHeader( addr < heapBegin, name, addr );		// bad low address ?
 	#endif // __CFA_DEBUG__
 
@@ -508,5 +502,5 @@
 	// along with the block and is a multiple of the alignment size.
 
-  if ( unlikely( size > ~0ul - sizeof(HeapManager.Storage) ) ) return 0p;
+  if ( unlikely( size > ULONG_MAX - sizeof(HeapManager.Storage) ) ) return 0p;
 	size_t tsize = size + sizeof(HeapManager.Storage);
 	if ( likely( tsize < mmapStart ) ) {				// small size => sbrk
@@ -560,5 +554,5 @@
 		block->header.kind.real.home = freeElem;		// pointer back to free list of apropriate size
 	} else {											// large size => mmap
-  if ( unlikely( size > ~0ul - pageSize ) ) return 0p;
+  if ( unlikely( size > ULONG_MAX - pageSize ) ) return 0p;
 		tsize = libCeiling( tsize, pageSize );			// must be multiple of page size
 		#ifdef __STATISTICS__
@@ -702,5 +696,5 @@
 	#endif // FASTLOOKUP
 
-	if ( setMmapStart( default_mmap_start() ) ) {
+	if ( ! setMmapStart( default_mmap_start() ) ) {
 		abort( "HeapManager : internal error, mmap start initialization failure." );
 	} // if
@@ -708,6 +702,5 @@
 
 	char * end = (char *)sbrk( 0 );
-	sbrk( (char *)libCeiling( (long unsigned int)end, libAlign() ) - end ); // move start of heap to multiple of alignment
-	heapBegin = heapEnd = sbrk( 0 );					// get new start point
+	heapBegin = heapEnd = sbrk( (char *)libCeiling( (long unsigned int)end, libAlign() ) - end ); // move start of heap to multiple of alignment
 } // HeapManager
 
@@ -735,5 +728,5 @@
 	//assert( heapManager.heapBegin != 0 );
 	//heapManager{};
-	if ( heapManager.heapBegin == 0p ) heapManager{};
+	if ( heapManager.heapBegin == 0p ) heapManager{};	// sanity check
 } // memory_startup
 
@@ -863,15 +856,5 @@
 		#endif // __STATISTICS__
 
-		size_t size = dim * elemSize;
-		char * addr = (char *)mallocNoStats( size );
-	  if ( unlikely( addr == 0p ) ) return 0p;
-
-		HeapManager.Storage.Header * header;
-		HeapManager.FreeHeader * freeElem;
-		size_t bsize, alignment;
-		headers( "aalloc", addr, header, freeElem, bsize, alignment );
-
-		header->kind.real.blockSize |= 2;				// mark as zero filled
-		return addr;
+		return mallocNoStats( dim * elemSize );
 	} // aalloc
 
@@ -914,6 +897,6 @@
 	
 		// change size, DO NOT preserve STICKY PROPERTIES.
+		free( oaddr );
 		void * naddr = mallocNoStats( size );			// create new area
-		free( oaddr );
 		return naddr;
 	} // resize
@@ -988,14 +971,5 @@
 		#endif // __STATISTICS__
 
-		size_t size = dim * elemSize;
-		char * addr = (char *)memalignNoStats( alignment, size );
-	  if ( unlikely( addr == 0p ) ) return 0p;
-		HeapManager.Storage.Header * header;
-		HeapManager.FreeHeader * freeElem;
-		size_t bsize;
-		headers( "amemalign", addr, header, freeElem, bsize, alignment );
-
-		header->kind.real.blockSize |= 2;				// mark as zero filled
-		return addr;
+		return memalignNoStats( alignment, dim * elemSize );
 	} // amemalign
 
@@ -1043,5 +1017,5 @@
 
 	// Frees the memory space pointed to by ptr, which must have been returned by a previous call to malloc(), calloc()
-	// or realloc().  Otherwise, or if free(ptr) has already been called before, undefined behavior occurs. If ptr is
+	// or realloc().  Otherwise, or if free(ptr) has already been called before, undefined behaviour occurs. If ptr is
 	// 0p, no operation is performed.
 	void free( void * addr ) {
@@ -1170,12 +1144,13 @@
 
 
-	// Adjusts parameters that control the behavior of the memory-allocation functions (see malloc). The param argument
+	// Adjusts parameters that control the behaviour of the memory-allocation functions (see malloc). The param argument
 	// specifies the parameter to be modified, and value specifies the new value for that parameter.
 	int mallopt( int option, int value ) {
 		choose( option ) {
 		  case M_TOP_PAD:
-			if ( setHeapExpand( value ) ) return 1;
+			heapExpand = ceiling( value, pageSize ); return 1;
 		  case M_MMAP_THRESHOLD:
 			if ( setMmapStart( value ) ) return 1;
+			break;
 		} // switch
 		return 0;										// error, unsupported
Index: libcfa/src/iostream.cfa
===================================================================
--- libcfa/src/iostream.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ libcfa/src/iostream.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Apr 30 10:50:31 2020
-// Update Count     : 1001
+// Last Modified On : Sat May  2 18:30:25 2020
+// Update Count     : 1017
 //
 
@@ -583,27 +583,20 @@
 					if ( fmt.flags.pc && fmt.pc > 64 ) fmt.pc -= 64; else { fmt.flags.pc = false; fmt.pc = 0; } \
 					if ( fmt.flags.left ) { \
-						fmt2.wd = fmt.wd; \
-						if ( fmt2.wd <= 64 ) { \
-							fmt2.wd = 64; \
-						} else { \
-							if ( fmt.pc > 0 ) { \
-								fmt2.wd -= fmt.pc; \
-							} else { \
-								fmt2.wd = fmt.wd - high1( msig ); \
-							} /* if */ \
-							if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; \
-							if ( fmt2.wd < 0 ) fmt2.wd = 0; \
-							fmt2.flags.left = true; \
-							fmt.wd = 0; \
-						} /* if */ \
-						printf( "left %d %d %x\n", f.wd, f.pc, f.all ); \
-						printf( "left %d %d %x\n", fmt.wd, fmt.pc, fmt.all ); \
+						fmt.flags.left = false; \
+						fmt.wd = 0; \
+						/* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+						fmt2.flags.left = true;	\
+						int msigd = high1( msig ); \
+						fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \
+						if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0b base specifier */ \
+						if ( (int)fmt2.wd < 64 ) fmt2.wd = 64; /* cast deals with negative value */ \
+						fmt2.flags.pc = true; fmt2.pc = 64; \
 					} else { \
 						if ( fmt.wd > 64 ) fmt.wd -= 64; \
-						/* if ( ! fmt.flags.nobsdp && fmt.pc < fmt.wd ) fmt.wd -= 1; */ \
+						else fmt.wd = 1; \
+						/* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
 						fmt2.wd = 64; \
-						/* printf( "R %llo %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt2.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
 					} /* if */ \
-					/* printf( "\nC %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
+					/* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
 					(ostype &)(os | fmt | "" | fmt2); \
 				} else if ( f.base == 'o' ) { \
@@ -614,18 +607,16 @@
 						fmt.flags.left = false; \
 						fmt.wd = 0; \
-						/* if ( fmt2.val > 1 && fmt.flags.pc && fmt.pc > 0 ) fmt.pc -= 1; */ \
 						/* printf( "L %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
 						(ostype &)(os | fmt | "" | fmt2); \
 						sepOff( os ); \
 						fmt2.flags.left = true;	\
-						int msigd = ceiling( high1( fmt.val ), 3 ) + 1; \
-						fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd) - 1; \
+						int msigd = ceiling( high1( fmt.val ), 3 ); \
+						fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \
+						if ( ! fmt.flags.nobsdp ) fmt2.wd -= 1; /* compensate for 0 base specifier */ \
 						if ( (int)fmt2.wd < 21 ) fmt2.wd = 21; /* cast deals with negative value */ \
 						fmt2.flags.pc = true; fmt2.pc = 21; \
 					} else { \
 						if ( fmt.wd > 22 ) fmt.wd -= 22; \
-						/* compensate for leading 0 */ \
-						/*if ( ! fmt.flags.nobsdp && fmt.pc < fmt.wd ) fmt.wd -= 1;*/ \
-						fmt2.wd = 1; \
+						else fmt.wd = 1; \
 						/* printf( "R %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
 						(ostype &)(os | fmt | "" | fmt2); \
@@ -636,26 +627,23 @@
 					/* printf( "\nC %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
 					(ostype &)(os | fmt2); \
-				} else { \
-					if ( fmt.flags.pc && fmt.pc > 16 ) fmt.pc -= 16; \
+				} else { /* f.base == 'x'  | f.base == 'X' */ \
+					if ( fmt.flags.pc && fmt.pc > 16 ) fmt.pc -= 16; else { fmt.flags.pc = false; fmt.pc = 0; } \
 					if ( fmt.flags.left ) { \
-						fmt2.wd = fmt.wd; \
-						if ( fmt2.wd <= 16 ) { \
-							fmt2.wd = 16; \
-						} else { \
-							if ( fmt.pc > 0 ) { \
-								fmt2.wd -= fmt.pc; \
-							} else { \
-								fmt2.wd = fmt.wd - ceiling2( high1( msig ), 4 ) / 4; \
-							} /* if */ \
-							if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; \
-							if ( fmt2.wd < 0 ) fmt2.wd = 0; \
-							fmt2.flags.left = true; \
-							fmt.wd = 0; \
-						} /* if */ \
+						fmt.flags.left = false; \
+						fmt.wd = 0; \
+						/* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+						fmt2.flags.left = true;	\
+						int msigd = high1( msig ); \
+						fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \
+						if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0x base specifier */ \
+						if ( (int)fmt2.wd < 16 ) fmt2.wd = 16; /* cast deals with negative value */ \
+						fmt2.flags.pc = true; fmt2.pc = 16; \
 					} else { \
+						if ( fmt.wd > 16 ) fmt.wd -= 16; \
+						else fmt.wd = 1; \
+						/* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
 						fmt2.wd = 16; \
-						if ( fmt.wd > 16 ) fmt.wd -= 16; \
 					} /* if */ \
-					fmt2.pc = 16; fmt2.flags.pc = true; \
+					/* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
 					(ostype &)(os | fmt | "" | fmt2); \
 				} /* if */ \
Index: libcfa/src/startup.cfa
===================================================================
--- libcfa/src/startup.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ libcfa/src/startup.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -14,5 +14,6 @@
 //
 
-#include <time.h>										// tzset
+#include <time.h>	         // tzset
+#include <locale.h>        // setlocale
 #include "startup.hfa"
 
@@ -21,4 +22,5 @@
     void __cfaabi_appready_startup( void ) {
 		tzset();										// initialize time global variables
+		setlocale(LC_NUMERIC, "");
 		#ifdef __CFA_DEBUG__
 		extern void heapAppStart();
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ src/Parser/parser.yy	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar  6 17:26:45 2020
-// Update Count     : 4474
+// Last Modified On : Mon Apr 27 12:25:42 2020
+// Update Count     : 4483
 //
 
@@ -966,7 +966,11 @@
 
 tuple_expression_list:
-	assignment_expression_opt
-	| tuple_expression_list ',' assignment_expression_opt
+	assignment_expression
+	| '@'												// CFA
+		{ SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
+	| tuple_expression_list ',' assignment_expression
 		{ $$ = (ExpressionNode *)($1->set_last( $3 )); }
+	| tuple_expression_list ',' '@'
+		{ SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
 	;
 
Index: tests/exceptions/.expect/data-except.txt
===================================================================
--- tests/exceptions/.expect/data-except.txt	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
+++ tests/exceptions/.expect/data-except.txt	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -0,0 +1,4 @@
+paired(3, 13)
+paired(3, 13)
+paired(3, 13)
+paired(4, 13)
Index: tests/exceptions/conditional.cfa
===================================================================
--- tests/exceptions/conditional.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ tests/exceptions/conditional.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -4,8 +4,8 @@
 // up the non-trivial exception is reasonable to do.
 
-#include "except-mac.hfa"
+#include <exception.hfa>
 #include <stdio.h>
 
-DECLARE_EXCEPT(num_error, BASE_EXCEPT,
+VTABLE_DECLARATION(num_error)(
 	int (*code)(num_error *this);
 );
@@ -36,7 +36,4 @@
     this.num = other.num;
 }
-void copy(num_error * this, num_error * other) {
-	*this = *other;
-}
 void ^?{}(num_error & this) {
     if( this.msg ) free( this.msg );
@@ -46,6 +43,7 @@
 }
 
-VTABLE_INSTANCE(num_error, BASE_EXCEPT, copy, ^?{},
-	num_error_msg, num_error_code
+VTABLE_INSTANCE(num_error)(
+	num_error_msg,
+	num_error_code,
 );
 
@@ -58,5 +56,5 @@
 
 	try {
-		THROW(&exc);
+		throw &exc;
 	} catch (num_error * error ; 3 == error->virtual_table->code( error )) {
 		caught_num_error(3, error);
@@ -66,5 +64,5 @@
 
 	try {
-		THROW_RESUME(&exc);
+		throwResume &exc;
 	} catchResume (num_error * error ; 3 == error->virtual_table->code( error )) {
 		caught_num_error(3, error);
Index: tests/exceptions/data-except.cfa
===================================================================
--- tests/exceptions/data-except.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
+++ tests/exceptions/data-except.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -0,0 +1,50 @@
+// Test exceptions that add data but no functionality.
+
+#include <exception.hfa>
+
+DATA_EXCEPTION(paired)(
+	int first;
+	int second;
+);
+
+void ?{}(paired & this, int first, int second) {
+	VTABLE_INIT(this, paired);
+	this.first = first;
+	this.second = second;
+}
+
+void copy(paired * this, paired * other) {
+	*this = *other;
+}
+
+const char * paired_msg(paired * this) {
+	return "paired";
+}
+
+VTABLE_INSTANCE(paired)(paired_msg);
+
+void throwPaired(int first, int second) {
+	paired exc = {first, second};
+}
+
+int main(int argc, char * argv[]) {
+	paired except = {3, 13};
+
+	try {
+		throw &except;
+	} catch (paired * exc) {
+		printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
+		++exc->first;
+	}
+
+	printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second);
+
+	try {
+		throwResume &except;
+	} catchResume (paired * exc) {
+		printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
+		++exc->first;
+	}
+
+	printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second);
+}
Index: sts/exceptions/except-mac.hfa
===================================================================
--- tests/exceptions/except-mac.hfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ 	(revision )
@@ -1,81 +1,0 @@
-// Macros to try and make declaring and using exceptions easier
-// No, these are not part of the language, they replace the virtual system.
-
-// Internal use:
-#define GLUE2(left, right) left##right
-#define GLUE3(left, middle, right) left##middle##right
-
-// The fully qualified name of the base exception type:
-#define BASE_EXCEPT __cfaehm_base_exception_t
-
-// Get the name of the vtable type and vtable instance for an exception type:
-#define TABLE(name) GLUE2(name,_vtable)
-#define INSTANCE(name) GLUE3(_,name,_vtable_instance)
-
-// Throws and the bit of overhead:
-#define THROW(expr) throw ((BASE_EXCEPT *)(expr))
-#define THROW_RESUME(expr) throwResume ((BASE_EXCEPT *)(expr))
-
-
-
-// The following macros are for defining your own new exception types.
-
-// Declare vtable and forward declare the exception type and vtable instance.
-// This should start a new exception declaration.
-// ... argument is the additional vtable fields.
-#define DECLARE_EXCEPT(except_name,parent_name,...) \
-struct except_name; \
-struct TABLE(except_name) { \
-	struct TABLE(parent_name) const * parent; \
-	size_t size; \
-	void (*copy)(except_name *this, except_name * other); \
-	void (*free)(except_name &this); \
-	const char * (*msg)(except_name *this); \
-	__VA_ARGS__ \
-}; \
-extern TABLE(except_name) INSTANCE(except_name)
-
-// The first field of the exception structure should be created with this.
-#define VTABLE_FIELD(except_name) \
-struct TABLE(except_name) const * virtual_table
-
-// In each constructor the vtable must be initialized.
-#define VTABLE_INIT(this_name,except_name) \
-this_name.virtual_table = &INSTANCE(except_name)
-
-// Declare the vtable instance. This should end an exception declaration.
-// ... argument is the remaining vtable field values.
-#define VTABLE_INSTANCE(except_name,parent_name,copy,free,msg,...) \
-TABLE(except_name) INSTANCE(except_name) @= { \
-	&INSTANCE(parent_name), sizeof(except_name), \
-	copy, free, msg, ## __VA_ARGS__ \
-}
-
-// Same, but used declarators for arguments.
-#define VTABLE_INSTANCE_KEY(except_name,parent_name,copy,free,msg,...) \
-TABLE(except_name) INSTANCE(except_name) @= { \
-	.parent : &INSTANCE(parent_name), .size : sizeof(except_name), \
-	.copy : copy, .free : free, .msg : msg, ## __VA_ARGS__ \
-}
-
-
-
-// Declare a trivial exception, one that adds no features:
-#define _TRIVIAL_EXCEPTION(name, parent_name, ...) \
-DECLARE_EXCEPT(name,parent_name,); \
-struct name { \
-	VTABLE_FIELD(name); \
-}; \
-const char * GLUE2(name,_msg)(name * this) { \
-    return #name; \
-} \
-void GLUE2(name,_copy)(name * this, name * other) { \
-    this->virtual_table = other->virtual_table; \
-} \
-void ?{}(name & this) { \
-	VTABLE_INIT(this,name); \
-} \
-VTABLE_INSTANCE(name,parent_name,GLUE2(name,_copy),^?{},GLUE2(name,_msg),)
-
-// TRIVIAL_EXCEPTION(name_of_exception, [parent_exception])
-#define TRIVIAL_EXCEPTION(...) _TRIVIAL_EXCEPTION(__VA_ARGS__,BASE_EXCEPT,)
Index: tests/exceptions/finally.cfa
===================================================================
--- tests/exceptions/finally.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ tests/exceptions/finally.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -1,5 +1,5 @@
 // Finally Clause Tests
 
-#include "except-mac.hfa"
+#include <exception.hfa>
 #include "except-io.hfa"
 
@@ -12,5 +12,5 @@
 		try {
 			printf("termination throw\n");
-			THROW(&exc);
+			throw &exc;
 		} finally {
 			loud_exit a = "termination inner finally";
@@ -28,5 +28,5 @@
 		try {
 			printf("resumption throw\n");
-			THROW_RESUME(&exc);
+			throwResume &exc;
 		} finally {
 			loud_exit a = "resumption inner finally";
Index: tests/exceptions/interact.cfa
===================================================================
--- tests/exceptions/interact.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ tests/exceptions/interact.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -1,5 +1,5 @@
 // Testing Interactions Between Termination and Resumption
 
-#include "except-mac.hfa"
+#include <exception.hfa>
 #include "except-io.hfa"
 
@@ -10,5 +10,5 @@
 	// Resume falls back to terminate.
 	try {
-		THROW_RESUME(&(star){});
+		throwResume &(star){};
 	} catch (star *) {
 		printf("caught as termination\n");
@@ -17,5 +17,5 @@
 	try {
 		loud_region a = "try block with resume throw";
-		THROW_RESUME(&(star){});
+		throwResume &(star){};
 	} catch (star *) {
 		printf("caught as termination\n");
@@ -29,5 +29,5 @@
 	try {
 		try {
-			THROW(&(star){});
+			throw &(star){};
 		} catchResume (star *) {
 			printf("resume catch on terminate\n");
@@ -43,5 +43,5 @@
 	try {
 		try {
-			THROW_RESUME(&(star){});
+			throwResume &(star){};
 		} catch (star *) {
 			printf("terminate catch on resume\n");
@@ -58,5 +58,5 @@
 		try {
 			try {
-				THROW(&(star){});
+				throw &(star){};
 			} catchResume (star *) {
 				printf("inner resume catch (error)\n");
@@ -64,5 +64,5 @@
 		} catch (star * error) {
 			printf("termination catch, will resume\n");
-			THROW_RESUME(error);
+			throwResume error;
 		}
 	} catchResume (star *) {
@@ -75,5 +75,5 @@
 		try {
 			try {
-				THROW_RESUME(&(star){});
+				throwResume &(star){};
 			} catch (star *) {
 				printf("inner termination catch\n");
@@ -81,5 +81,5 @@
 		} catchResume (star * error) {
 			printf("resumption catch, will terminate\n");
-			THROW(error);
+			throw error;
 		}
 	} catch (star *) {
@@ -94,10 +94,10 @@
 				try {
 					printf("throwing resume moon\n");
-					THROW_RESUME(&(moon){});
+					throwResume &(moon){};
 				} catch (star *) {
 					printf("termination catch\n");
 				}
 				printf("throwing resume star\n");
-				THROW_RESUME(&(star){});
+				throwResume &(star){};
 			} catchResume (star *) {
 				printf("resumption star catch\n");
@@ -105,5 +105,5 @@
 		} catchResume (moon *) {
 			printf("resumption moon catch, will terminate\n");
-			THROW(&(star){});
+			throw &(star){};
 		}
 	} catchResume (star *) {
Index: tests/exceptions/resume.cfa
===================================================================
--- tests/exceptions/resume.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ tests/exceptions/resume.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -1,5 +1,5 @@
 // Resumption Exception Tests
 
-#include "except-mac.hfa"
+#include <exception.hfa>
 #include "except-io.hfa"
 
@@ -14,5 +14,5 @@
 		loud_exit a = "simple try clause";
 		printf("simple throw\n");
-		THROW_RESUME(&(zen){});
+		throwResume &(zen){};
 		printf("end of try clause\n");
 	} catchResume (zen * error) {
@@ -25,5 +25,5 @@
 	try {
 		printf("throwing child exception\n");
-		THROW_RESUME(&(moment_of){});
+		throwResume &(moment_of){};
 	} catchResume (zen *) {
 		printf("inner parent match\n");
@@ -36,5 +36,5 @@
 	try {
 		try {
-			THROW_RESUME(&(yin){});
+			throwResume &(yin){};
 		} catchResume (zen *) {
 			printf("caught yin as zen\n");
@@ -52,5 +52,5 @@
 			loud_exit a = "rethrow inner try";
 			printf("rethrow inner try\n");
-			THROW_RESUME(&(zen){});
+			throwResume &(zen){};
 		} catchResume (zen *) {
 			loud_exit a = "rethrowing catch clause";
@@ -67,8 +67,8 @@
 	try {
 		try {
-			THROW_RESUME(&(yin){});
+			throwResume &(yin){};
 		} catchResume (yin *) {
 			printf("caught yin, will throw yang\n");
-			THROW_RESUME(&(yang){});
+			throwResume &(yang){};
 		} catchResume (yang *) {
 			printf("caught exception from same try\n");
@@ -83,10 +83,10 @@
 		try {
 			printf("throwing first exception\n");
-			THROW_RESUME(&(yin){});
+			throwResume &(yin){};
 		} catchResume (yin *) {
 			printf("caught first exception\n");
 			try {
 				printf("throwing second exception\n");
-				THROW_RESUME(&(yang){});
+				throwResume &(yang){};
 			} catchResume (yang *) {
 				printf("caught second exception\n");
@@ -104,10 +104,10 @@
 	try {
 		try {
-			THROW_RESUME(&(zen){});
-			THROW_RESUME(&(zen){});
+			throwResume &(zen){};
+			throwResume &(zen){};
 		} catchResume (zen *) {
 			printf("inner catch\n");
 		}
-		THROW_RESUME(&(zen){});
+		throwResume &(zen){};
 	} catchResume (zen *) {
 		printf("outer catch\n");
Index: tests/exceptions/terminate.cfa
===================================================================
--- tests/exceptions/terminate.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ tests/exceptions/terminate.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -1,5 +1,5 @@
 // Termination Exception Tests
 
-#include "except-mac.hfa"
+#include <exception.hfa>
 #include "except-io.hfa"
 
@@ -14,5 +14,5 @@
 		loud_exit a = "simple try clause";
 		printf("simple throw\n");
-		THROW(&(zen){});
+		throw &(zen){};
 		printf("end of try clause\n");
 	} catch (zen * error) {
@@ -25,5 +25,5 @@
 	try {
 		printf("throwing child exception\n");
-		THROW(&(moment_of){});
+		throw &(moment_of){};
 	} catch (zen *) {
 		printf("inner parent match\n");
@@ -36,5 +36,5 @@
 	try {
 		try {
-			THROW(&(yin){});
+			throw &(yin){};
 		} catch (zen *) {
 			printf("caught yin as zen\n");
@@ -52,5 +52,5 @@
 			loud_exit a = "rethrow inner try";
 			printf("rethrow inner try\n");
-			THROW(&(zen){});
+			throw &(zen){};
 		} catch (zen *) {
 			loud_exit a = "rethrowing catch clause";
@@ -67,8 +67,8 @@
 	try {
 		try {
-			THROW(&(yin){});
+			throw &(yin){};
 		} catch (yin *) {
 			printf("caught yin, will throw yang\n");
-			THROW(&(yang){});
+			throw &(yang){};
 		} catch (yang *) {
 			printf("caught exception from same try\n");
@@ -83,10 +83,10 @@
 		try {
 			printf("throwing first exception\n");
-			THROW(&(yin){});
+			throw &(yin){};
 		} catch (yin *) {
 			printf("caught first exception\n");
 			try {
 				printf("throwing second exception\n");
-				THROW(&(yang){});
+				throw &(yang){};
 			} catch (yang *) {
 				printf("caught second exception\n");
@@ -104,10 +104,10 @@
 	try {
 		try {
-			THROW(&(zen){});
-			THROW(&(zen){});
+			throw &(zen){};
+			throw &(zen){};
 		} catch (zen *) {
 			printf("inner catch\n");
 		}
-		THROW(&(zen){});
+		throw &(zen){};
 	} catch (zen *) {
 		printf("outer catch\n");
Index: tests/manipulatorsOutput1.cfa
===================================================================
--- tests/manipulatorsOutput1.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ tests/manipulatorsOutput1.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -7,6 +7,6 @@
 // Created On       : Sat Jun  8 18:04:11 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun 10 12:37:28 2019
-// Update Count     : 8
+// Last Modified On : Fri May  1 11:51:44 2020
+// Update Count     : 9
 // 
 
@@ -17,43 +17,60 @@
 	signed char sc = -12;
 	printf( "%hhd %2hhd %5.2hhd %-5.2hhd %hho %#hho %hhx %#hhx %#8hhx %#8.10hhx %#8.3hhX %+-8.3hhd %08hhd\n", sc, sc, sc, sc, sc, sc, sc, sc, sc, sc, sc, sc, sc );
-	sout | sc | wd(2,sc) | wd(5,2,sc) | left(wd(5,2,sc)) | nobase(oct(sc)) | oct(sc) | nobase(hex(sc)) | hex(sc) | wd(8,hex(sc)) | wd(8,10,hex(sc)) | upcase(wd(8,3,hex(sc))) | left(sign(upcase(wd(8,3,sc)))) | pad0(wd(8,sc));
+	sout | sc | wd(2,sc) | wd(5,2,sc) | left(wd(5,2,sc)) | nobase(oct(sc)) | oct(sc) | nonl;
+	sout | nobase(hex(sc)) | hex(sc) | wd(8,hex(sc)) | wd(8,10,hex(sc)) | upcase(wd(8,3,hex(sc))) | nonl;
+	sout | left(sign(upcase(wd(8,3,sc)))) | pad0(wd(8,sc));
 
 	sout | "unsigned char";
 	unsigned char usc = 12;
 	printf( "%hhu %2hhu %5.2hhu %-5.2hhu %hho %#hho %hhx %#hhx %#8hhx %#8.10hhx %#8.3hhX %-8.3hhu %08hhu\n", usc, usc, usc, usc, usc, usc, usc, usc, usc, usc, usc, usc, usc );
-	sout | usc | wd(2,usc) | wd(5,2,usc) | left(wd(5,2,usc)) | nobase(oct(usc)) | oct(usc) | nobase(hex(usc)) | hex(usc) | wd(8,hex(usc)) | wd(8,10,hex(usc)) | upcase(wd(8,3,hex(usc))) | left(upcase(wd(8,3,usc))) | pad0(wd(8,usc));
+	sout | usc | wd(2,usc) | wd(5,2,usc) | left(wd(5,2,usc)) | nobase(oct(usc)) | oct(usc) | nonl;
+	sout | nobase(hex(usc)) | hex(usc) | wd(8,hex(usc)) | wd(8,10,hex(usc)) | upcase(wd(8,3,hex(usc))) | nonl;
+	sout | left(upcase(wd(8,3,usc))) | pad0(wd(8,usc));
 
 	sout | "signed short int";
 	signed short int si = -12;
 	printf( "%hd %2hd %5.2hd %-5.2hd %ho %#ho %hx %#hx %#8hx %#8.10hx %#8.3hX %+-8.3hd %08hd\n", si, si, si, si, si, si, si, si, si, si, si, si, si );
-	sout | si | wd(2,si) | wd(5,2,si) | left(wd(5,2,si)) | nobase(oct(si)) | oct(si) | nobase(hex(si)) | hex(si) | wd(8,hex(si)) | wd(8,10,hex(si)) | upcase(wd(8,3,hex(si))) | left(sign(upcase(wd(8,3,si)))) | pad0(wd(8,si));
+	sout | si | wd(2,si) | wd(5,2,si) | left(wd(5,2,si)) | nobase(oct(si)) | oct(si) | nonl;
+	sout | nobase(hex(si)) | hex(si) | wd(8,hex(si)) | wd(8,10,hex(si)) | upcase(wd(8,3,hex(si))) | nonl;
+	sout | left(sign(upcase(wd(8,3,si)))) | pad0(wd(8,si));
 
 	sout | "unsigned short int";
 	unsigned short int usi = 12;
 	printf( "%hu %2hu %5.2hu %-5.2hu %ho %#ho %hx %#hx %#8hx %#8.10hx %#8.3hX %-8.3hu %08hu\n", usi, usi, usi, usi, usi, usi, usi, usi, usi, usi, usi, usi, usi );
-	sout | usi | wd(2,usi) | wd(5,2,usi) | left(wd(5,2,usi)) | nobase(oct(usi)) | oct(usi) | nobase(hex(usi)) | hex(usi) | wd(8,hex(usi)) | wd(8,10,hex(usi)) | upcase(wd(8,3,hex(usi))) | left(upcase(wd(8,3,usi))) | pad0(wd(8,usi));
+	sout | usi | wd(2,usi) | wd(5,2,usi) | left(wd(5,2,usi)) | nobase(oct(usi)) | oct(usi) | nonl;
+	sout | nobase(hex(usi)) | hex(usi) | wd(8,hex(usi)) | wd(8,10,hex(usi)) | upcase(wd(8,3,hex(usi))) | nonl;
+	sout | left(upcase(wd(8,3,usi))) | pad0(wd(8,usi));
 
 	sout | "signed int";
 	signed int i = -12;
 	printf( "%d %2d %5.2d %-5.2d %o %#o %x %#x %#8x %#8.10x %#8.3X %+-8.3d %08d\n", i, i, i, i, i, i, i, i, i, i, i, i, i );
-	sout | i | wd(2,i) | wd(5,2,i) | left(wd(5,2,i)) | nobase(oct(i)) | oct(i) | nobase(hex(i)) | hex(i) | wd(8,hex(i)) | wd(8,10,hex(i)) | upcase(wd(8,3,hex(i))) | left(sign(upcase(wd(8,3,i)))) | pad0(wd(8,i));
+	sout | i | wd(2,i) | wd(5,2,i) | left(wd(5,2,i)) | nobase(oct(i)) | oct(i) | nonl;
+	sout | nobase(hex(i)) | hex(i) | wd(8,hex(i)) | wd(8,10,hex(i)) | upcase(wd(8,3,hex(i))) | nonl;
+	sout | left(sign(upcase(wd(8,3,i)))) | pad0(wd(8,i));
 
 	sout | "unsigned int";
 	unsigned int ui = 12;
 	printf( "%u %2u %5.2u %-5.2u %o %#o %x %#x %#8x %#8.10x %#8.3X %-8.3u %08u\n", ui, ui, ui, ui, ui, ui, ui, ui, ui, ui, ui, ui, ui );
-	sout | ui | wd(2,ui) | wd(5,2,ui) | left(wd(5,2,ui)) | nobase(oct(ui)) | oct(ui) | nobase(hex(ui)) | hex(ui) | wd(8,hex(ui)) | wd(8,10,hex(ui)) | upcase(wd(8,3,hex(ui))) | left(upcase(wd(8,3,ui))) | pad0(wd(8,ui));
+	sout | ui | wd(2,ui) | wd(5,2,ui) | left(wd(5,2,ui)) | nobase(oct(ui)) | oct(ui) | nonl;
+	sout | nobase(hex(ui)) | hex(ui) | wd(8,hex(ui)) | wd(8,10,hex(ui)) | upcase(wd(8,3,hex(ui))) | nonl;
+	sout | left(upcase(wd(8,3,ui))) | pad0(wd(8,ui));
 
 	sout | "signed long long int";
 	signed long long int lli = -12;
 	printf( "%lld %2lld %5.2lld %-5.2lld %llo %#llo %llx %#llx %#8llx %#8.10llx %#8.3llX %+-8.3lld %08lld\n", lli, lli, lli, lli, lli, lli, lli, lli, lli, lli, lli, lli, lli );
-	sout | lli | wd(2,lli) | wd(5,2,lli) | left(wd(5,2,lli)) | nobase(oct(lli)) | oct(lli) | nobase(hex(lli)) | hex(lli) | wd(8,hex(lli)) | wd(8,10,hex(lli)) | upcase(wd(8,3,hex(lli))) | left(sign(upcase(wd(8,3,lli)))) | pad0(wd(8,lli));
+	sout | lli | wd(2,lli) | wd(5,2,lli) | left(wd(5,2,lli)) | nobase(oct(lli)) | oct(lli) | nonl;
+	sout | nobase(hex(lli)) | hex(lli) | wd(8,hex(lli)) | wd(8,10,hex(lli)) | upcase(wd(8,3,hex(lli))) | nonl;
+	sout | left(sign(upcase(wd(8,3,lli)))) | pad0(wd(8,lli));
 
 	sout | "unsigned long long int";
 	unsigned long long int ulli = 12;
 	printf( "%llu %2llu %5.2llu %-5.2llu %llo %#llo %llx %#llx %#8llx %#8.10llx %#8.3llX %-8.3llu %08llu\n", ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli );
-	sout | ulli | wd(2,ulli) | wd(5,2,ulli) | left(wd(5,2,ulli)) | nobase(oct(ulli)) | oct(ulli) | nobase(hex(ulli)) | hex(ulli) | wd(8,hex(ulli)) | wd(8,10,hex(ulli)) | upcase(wd(8,3,hex(ulli))) | left(upcase(wd(8,3,ulli))) | pad0(wd(8,ulli));
+	sout | ulli | wd(2,ulli) | wd(5,2,ulli) | left(wd(5,2,ulli)) | nobase(oct(ulli)) | oct(ulli) | nonl;
+	sout | nobase(hex(ulli)) | hex(ulli) | wd(8,hex(ulli)) | wd(8,10,hex(ulli)) | upcase(wd(8,3,hex(ulli))) | nonl;
+	sout | left(upcase(wd(8,3,ulli))) | pad0(wd(8,ulli));
 
 	sout | nl | "binary integral";
-	sout | bin(0) | bin(13) | upcase(bin(13)) | nobase(bin(13)) | left(wd(8,bin(13))) | wd(8,bin(13)) | pad0(left(wd(8,bin(13)))) | pad0(wd(8,bin(13))) | pad0(wd(8,10,bin(13))) | pad0(wd(8,6,bin(13)));
+	sout | bin(0) | bin(13) | upcase(bin(13)) | nobase(bin(13)) | left(wd(8,bin(13))) | wd(8,bin(13)) | nonl;
+	sout | pad0(left(wd(8,bin(13)))) | pad0(wd(8,bin(13))) | pad0(wd(8,10,bin(13))) | pad0(wd(8,6,bin(13)));
 
 
@@ -62,5 +79,7 @@
 	printf( "%g  %8g %#8g %g %8g %8.0g %#8.0g %8.2g %#8.2g %-8.2g %-8.2g %-#8.2g %-+8.2g %-+#8.2g %08.2g %8.2E %8.2a %#8.2A %#8.2e\n",
 		    0.0,3.0F,3.0F, f,  f,    f,     f,    f,     f,  3.0F,      f,      f,      f,       f,     f,    f,    f,     f,     f );
-	sout | 0.0 | wd(8, 3.0F) | nodp(wd(8, 3.0F)) | f | wd(8, f) | ws(8,0, f) | nodp(ws(8,0, f)) | ws(8,2, f) | nodp(ws(8,2, f)) | left(ws(8,2, 3.0F)) | left(ws(8,2, f)) | left(nodp(ws(8,2, f))) | left(sign(ws(8,2, f))) | left(sign(nodp(ws(8,2, f)))) | pad0(ws(8,2, f)) | upcase(wd(8,2, sci(f))) | wd(8,2, hex(f)) | upcase(wd(8,2, hex(f))) | nodp(wd(8,2, sci(f)));
+	sout | 0.0 | wd(8, 3.0F) | nodp(wd(8, 3.0F)) | f | wd(8, f) | ws(8,0, f) | nodp(ws(8,0, f)) | ws(8,2, f) | nodp(ws(8,2, f)) | nonl;
+	sout | left(ws(8,2, 3.0F)) | left(ws(8,2, f)) | left(nodp(ws(8,2, f))) | left(sign(ws(8,2, f))) | left(sign(nodp(ws(8,2, f)))) | nonl;
+	sout | pad0(ws(8,2, f)) | upcase(wd(8,2, sci(f))) | wd(8,2, hex(f)) | upcase(wd(8,2, hex(f))) | nodp(wd(8,2, sci(f)));
 
 	sout | "double";
@@ -68,5 +87,6 @@
 	printf( "%g  %#8f %g %8f %#8.0f %8.0f %8.2f %-8.2f %-+#8.2f %08.2F %8.2E %8.2a %8.2A %8.2e\n",
 			0.0,  3.0, d,  d,     d,    d,    d,     d,       d,     d,    d,    d,    d,    d );
-	sout | 0.0 | wd(8, 3.0) | d | wd(8, d) | nodp(wd(8,0, d)) | wd(8,0, d) | wd(8,2, d) | left(wd(8,2, d)) | left(sign(wd(8,2, d))) | pad0(upcase(wd(8,2, d))) | upcase(wd(8,2, sci(d))) | wd(8,2, hex(d)) | upcase(wd(8,2, hex(d))) | wd(8,2, sci(d));
+	sout | 0.0 | wd(8, 3.0) | d | wd(8, d) | nodp(wd(8,0, d)) | wd(8,0, d) | wd(8,2, d) | nonl;
+	sout | left(wd(8,2, d)) | left(sign(wd(8,2, d))) | pad0(upcase(wd(8,2, d))) | upcase(wd(8,2, sci(d))) | wd(8,2, hex(d)) | upcase(wd(8,2, hex(d))) | wd(8,2, sci(d));
 
 	sout | "long double";
@@ -74,5 +94,6 @@
 	printf( "%Lg  %#8Lf %Lg %8Lf %#8.0Lf %8.0Lf %8.2Lf %-8.2Lf %-+#8.2Lf %08.2LF %8.2LE %8.2La %8.2LA %8.2Le\n",
 			0.0L,  3.0L, ld,  ld,     ld,    ld,    ld,     ld,       ld,     ld,    ld,    ld,    ld,    ld );
-	sout | 0.0L | wd(8, 3.0L) | ld | wd(8, ld) | nodp(wd(8,0, ld)) | wd(8,0, ld) | wd(8,2, ld) | left(wd(8,2, ld)) | left(sign(wd(8,2, ld))) | pad0(upcase(wd(8,2, ld))) | upcase(wd(8,2, sci(ld))) | wd(8,2, hex(ld)) | upcase(wd(8,2, hex(ld))) | wd(8,2, sci(ld));
+	sout | 0.0L | wd(8, 3.0L) | ld | wd(8, ld) | nodp(wd(8,0, ld)) | wd(8,0, ld) | wd(8,2, ld) | nonl;
+	sout | left(wd(8,2, ld)) | left(sign(wd(8,2, ld))) | pad0(upcase(wd(8,2, ld))) | upcase(wd(8,2, sci(ld))) | wd(8,2, hex(ld)) | upcase(wd(8,2, hex(ld))) | wd(8,2, sci(ld));
 
 
@@ -80,5 +101,6 @@
 	char c = 'a';
 	printf( "%c %2c %5c %-5c %hho %#hho %hhx %#hhx %#8hhx %#8hhX %-8c %8c\n", c, c, c, c, c, c, c, c, c, c, c, c );
-	sout | c | ' ' | wd(2,c) | wd(5,c) | left(wd(5,c)) | nobase(oct(c)) | oct(c) | nobase(hex(c)) | hex(c) | wd(8,hex(c)) | upcase(wd(8,hex(c))) | left(wd(8,c)) | wd(8,c);
+	sout | c | ' ' | wd(2,c) | wd(5,c) | left(wd(5,c)) | nobase(oct(c)) | oct(c) | nonl;
+	sout | nobase(hex(c)) | hex(c) | wd(8,hex(c)) | upcase(wd(8,hex(c))) | left(wd(8,c)) | wd(8,c);
 
 	sout | nl | "string";
Index: tests/manipulatorsOutput3.cfa
===================================================================
--- tests/manipulatorsOutput3.cfa	(revision 6ec07e5f9016c92f73237be92c20ecdd0fba5795)
+++ tests/manipulatorsOutput3.cfa	(revision af7acb9c31520a9956bf84e617377d94a46b8baa)
@@ -52,6 +52,9 @@
     sout | left(wd( 10,40, oct(y) )) | 'X';
 
-    y = 123456789;
+    y = 01234567;
     sout | left(wd( 45, 49, oct(y) )) | 'X';
+    y = -y;
+    sout | wd(0, oct(y)) | 'Y';
+    sout | left(wd(0, oct(y))) | 'Y';
     sout | nl;
 
@@ -66,11 +69,33 @@
     sout | left(wd( 45,49, upcase(hex(x)) )) | 'X';
 
-    sout | nl | nl;
+    sout | nl;
 
     int128 divisor = 0x4b3b4ca85a86c47a;
     divisor <<= 16;
     divisor += 0x98a224000000000;
+    
+    // base 2
+    sout | "base 2";
+    sout | bin(divisor);
+    sout | upcase(bin(divisor));
+    sout | wd(38, upcase(bin(divisor)));
+    sout | wd(40, upcase(bin(divisor)));
+    sout | wd(40, 38, upcase(bin(divisor)));
+    sout | wd(40, 30, upcase(bin(divisor)));
+    sout | pad0(sign(wd(40, 38, upcase(bin(divisor)))));
+    sout | nl;
+    
+    // oct
+    sout | "base 8";
+    sout | upcase(oct(divisor));
+    sout | wd(38, upcase(oct(divisor)));
+    sout | wd(40, upcase(oct(divisor)));
+    sout | wd(40, 38, upcase(oct(divisor)));
+    sout | wd(40, 30, upcase(oct(divisor)));
+    sout | pad0(sign(wd(40, 38, upcase(oct(divisor)))));
+    sout | nl;
 
-    // base 10
+    // decimal
+    sout | "base 10";
     sout | divisor;
     sout | wd(2, divisor);
@@ -87,22 +112,8 @@
     sout | pad0(wd(40, divisor));
     sout | pad0(sign(wd(40,divisor)));
-    
-    // base 2
-    sout | upcase(bin(divisor));
-    sout | wd(38, upcase(bin(divisor)));
-    sout | wd(40, upcase(bin(divisor)));
-    sout | wd(40, 38, upcase(bin(divisor)));
-    sout | wd(40, 30, upcase(bin(divisor)));
-    sout | pad0(sign(wd(40, 38, upcase(bin(divisor)))));
-    
-    // oct
-    sout | upcase(oct(divisor));
-    sout | wd(38, upcase(oct(divisor)));
-    sout | wd(40, upcase(oct(divisor)));
-    sout | wd(40, 38, upcase(oct(divisor)));
-    sout | wd(40, 30, upcase(oct(divisor)));
-    sout | pad0(sign(wd(40, 38, upcase(oct(divisor)))));
+    sout | nl;
     
     // hex
+    sout | "base 16";
     sout | upcase(hex(divisor));
     sout | wd(38, upcase(hex(divisor)));
@@ -111,4 +122,5 @@
     sout | wd(40, 30, upcase(hex(divisor)));
     sout | pad0(sign(wd(40, 38, upcase(hex(divisor)))));
+    sout | nl;