Index: src/benchmark/Makefile.am
===================================================================
--- src/benchmark/Makefile.am	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/benchmark/Makefile.am	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -59,4 +59,8 @@
 	@echo -e '\t"githash": "'${githash}'",'
 	@echo -e '\t"arch": "'   ${arch}   '",'
+	@echo -e '\t"compile": {'
+	@+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
+	@echo -e '\t\t"dummy" : {}'
+	@echo -e '\t},'
 	@echo -e '\t"ctxswitch": {'
 	@echo -en '\t\t"coroutine":'
Index: src/benchmark/Makefile.in
===================================================================
--- src/benchmark/Makefile.in	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/benchmark/Makefile.in	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -473,4 +473,8 @@
 	@echo -e '\t"githash": "'${githash}'",'
 	@echo -e '\t"arch": "'   ${arch}   '",'
+	@echo -e '\t"compile": {'
+	@+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
+	@echo -e '\t\t"dummy" : {}'
+	@echo -e '\t},'
 	@echo -e '\t"ctxswitch": {'
 	@echo -en '\t\t"coroutine":'
Index: src/driver/cfa.cc
===================================================================
--- src/driver/cfa.cc	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/driver/cfa.cc	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -10,6 +10,6 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct 31 11:40:44 2017
-// Update Count     : 160
+// Last Modified On : Tue Jan 30 15:46:15 2018
+// Update Count     : 161
 //
 
@@ -277,4 +277,8 @@
 		args[nargs] = "--undefined=__cfaabi_dbg_bits_write";
 		nargs += 1;
+		args[nargs] = "-Xlinker";
+		nargs += 1;
+		args[nargs] = "--undefined=__cfaabi_interpose_startup";
+		nargs += 1;
 
 	} // if
@@ -353,4 +357,6 @@
 		nargs += 1;
 		args[nargs] = "-D__int8_t_defined";				// prevent gcc type-size attributes
+		nargs += 1;
+		args[nargs] = "-D__NO_STRING_INLINES";			// prevent gcc strcmp unrolling
 		nargs += 1;
 		args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str();
Index: src/libcfa/bits/containers.h
===================================================================
--- src/libcfa/bits/containers.h	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/bits/containers.h	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -140,15 +140,16 @@
 
 #ifdef __cforall
+
 	forall(dtype T | is_node(T))
-	static inline void ?{}( __queue(T) & this ) {
-		(this.head){ NULL };
-		(this.tail){ &this.head };
+	static inline void ?{}( __queue(T) & this ) with( this ) {
+		head{ NULL };
+		tail{ &head };
 	}
 
 	forall(dtype T | is_node(T) | sized(T))
-	static inline void append( __queue(T) & this, T * val ) {
-		verify(this.tail != NULL);
-		*this.tail = val;
-		this.tail = &get_next( *val );
+	static inline void append( __queue(T) & this, T * val ) with( this ) {
+		verify(tail != NULL);
+		*tail = val;
+		tail = &get_next( *val );
 	}
 
@@ -167,5 +168,5 @@
 
 	forall(dtype T | is_node(T) | sized(T))
-	static inline T * remove( __queue(T) & this, T ** it ) {
+	static inline T * remove( __queue(T) & this, T ** it ) with( this ) {
 		T * val = *it;
 		verify( val );
@@ -173,13 +174,20 @@
 		(*it) = get_next( *val );
 
-		if( this.tail == &get_next( *val ) ) {
-			this.tail = it;
+		if( tail == &get_next( *val ) ) {
+			tail = it;
 		}
 
 		get_next( *val ) = NULL;
 
-		verify( (this.head == NULL) == (&this.head == this.tail) );
-		verify( *this.tail == NULL );
+		verify( (head == NULL) == (&head == tail) );
+		verify( *tail == NULL );
 		return val;
 	}
 #endif
+
+//-----------------------------------------------------------------------------
+// Tools
+//-----------------------------------------------------------------------------
+#ifdef __cforall
+
+#endif
Index: src/libcfa/bits/locks.h
===================================================================
--- src/libcfa/bits/locks.h	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/bits/locks.h	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -58,6 +58,12 @@
 
 #ifdef __cforall
+	extern "C" {
+		extern void disable_interrupts();
+		extern void enable_interrupts_noPoll();
+	}
+
 	extern void yield( unsigned int );
 	extern thread_local struct thread_desc *    volatile this_thread;
+	extern thread_local struct processor *      volatile this_processor;
 
 	static inline void ?{}( __spinlock_t & this ) {
@@ -68,10 +74,11 @@
 	static inline _Bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
 		_Bool result = __lock_test_and_test_and_set( this.lock );
-		__cfaabi_dbg_debug_do(
-			if( result ) {
+		if( result ) {
+			disable_interrupts();
+			__cfaabi_dbg_debug_do(
 				this.prev_name = caller;
 				this.prev_thrd = this_thread;
-			}
-		)
+			)
+		}
 		return result;
 	}
@@ -99,4 +106,5 @@
 			#endif
 		}
+		disable_interrupts();
 		__cfaabi_dbg_debug_do(
 			this.prev_name = caller;
@@ -105,17 +113,19 @@
 	}
 
-	// Lock the spinlock, spin if already acquired
-	static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
-		for ( unsigned int i = 1;; i += 1 ) {
-			if ( __lock_test_and_test_and_set( this.lock ) ) break;
-			yield( i );
-		}
-		__cfaabi_dbg_debug_do(
-			this.prev_name = caller;
-			this.prev_thrd = this_thread;
-		)
-	}
+	// // Lock the spinlock, yield if already acquired
+	// static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
+	// 	for ( unsigned int i = 1;; i += 1 ) {
+	// 		if ( __lock_test_and_test_and_set( this.lock ) ) break;
+	// 		yield( i );
+	// 	}
+	// 	disable_interrupts();
+	// 	__cfaabi_dbg_debug_do(
+	// 		this.prev_name = caller;
+	// 		this.prev_thrd = this_thread;
+	// 	)
+	// }
 
 	static inline void unlock( __spinlock_t & this ) {
+		enable_interrupts_noPoll();
 		__lock_release( this.lock );
 	}
Index: src/libcfa/bits/signal.h
===================================================================
--- src/libcfa/bits/signal.h	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
+++ src/libcfa/bits/signal.h	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -0,0 +1,65 @@
+//
+// 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/signal.h -- Helper functions and defines to use signals
+//
+// Author           : Thierry Delisle
+// Created On       : Thu Jan 25 16:06:29 2018
+// Last Modified By :
+// Last Modified On :
+// Update Count     :
+//
+
+#pragma once
+
+#include "bits/debug.h"
+#include "bits/defs.h"
+
+extern "C" {
+#include <errno.h>
+#define __USE_GNU
+#include <signal.h>
+#undef __USE_GNU
+#include <stdlib.h>
+#include <string.h>
+}
+
+// Short hands for signal context information
+#define __CFA_SIGCXT__ ucontext_t *
+#define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt
+
+// Sigaction wrapper : register an signal handler
+static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) {
+	struct sigaction act;
+
+	act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
+	act.sa_flags = flags;
+
+	if ( sigaction( sig, &act, NULL ) == -1 ) {
+		__cfaabi_dbg_print_buffer_decl(
+			" __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
+			sig, handler, flags, errno, strerror( errno )
+		);
+		_exit( EXIT_FAILURE );
+	}
+}
+
+// Sigaction wrapper : restore default handler
+static void __kernel_sigdefault( int sig ) {
+	struct sigaction act;
+
+	act.sa_handler = SIG_DFL;
+	act.sa_flags = 0;
+	sigemptyset( &act.sa_mask );
+
+	if ( sigaction( sig, &act, NULL ) == -1 ) {
+		__cfaabi_dbg_print_buffer_decl(
+			" __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
+			sig, errno, strerror( errno )
+		);
+		_exit( EXIT_FAILURE );
+	}
+}
Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/concurrency/coroutine.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -118,5 +118,5 @@
 } //ctxSwitchDirect
 
-void create_stack( coStack_t* this, unsigned int storageSize ) {
+void create_stack( coStack_t* this, unsigned int storageSize ) with( *this ) {
 	//TEMP HACK do this on proper kernel startup
 	if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
@@ -124,40 +124,40 @@
 	size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
 
-	if ( (intptr_t)this->storage == 0 ) {
-		this->userStack = false;
-		this->size = libCeiling( storageSize, 16 );
+	if ( (intptr_t)storage == 0 ) {
+		userStack = false;
+		size = libCeiling( storageSize, 16 );
 		// use malloc/memalign because "new" raises an exception for out-of-memory
 
 		// assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
-		__cfaabi_dbg_debug_do( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
-		__cfaabi_dbg_no_debug_do( this->storage = malloc( cxtSize + this->size + 8 ) );
+		__cfaabi_dbg_debug_do( storage = memalign( pageSize, cxtSize + size + pageSize ) );
+		__cfaabi_dbg_no_debug_do( storage = malloc( cxtSize + size + 8 ) );
 
 		__cfaabi_dbg_debug_do(
-			if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) {
+			if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) {
 				abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
 			} // if
 		);
 
-		if ( (intptr_t)this->storage == 0 ) {
-			abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", this->size );
+		if ( (intptr_t)storage == 0 ) {
+			abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", size );
 		} // if
 
-		__cfaabi_dbg_debug_do( this->limit = (char *)this->storage + pageSize );
-		__cfaabi_dbg_no_debug_do( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
+		__cfaabi_dbg_debug_do( limit = (char *)storage + pageSize );
+		__cfaabi_dbg_no_debug_do( limit = (char *)libCeiling( (unsigned long)storage, 16 ) ); // minimum alignment
 
 	} else {
-		assertf( ((size_t)this->storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", this->storage, (int)libAlign() );
-		this->userStack = true;
-		this->size = storageSize - cxtSize;
+		assertf( ((size_t)storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", storage, (int)libAlign() );
+		userStack = true;
+		size = storageSize - cxtSize;
 
-		if ( this->size % 16 != 0u ) this->size -= 8;
+		if ( size % 16 != 0u ) size -= 8;
 
-		this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ); // minimum alignment
+		limit = (char *)libCeiling( (unsigned long)storage, 16 ); // minimum alignment
 	} // if
-	assertf( this->size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
+	assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
 
-	this->base = (char *)this->limit + this->size;
-	this->context = this->base;
-	this->top = (char *)this->context + cxtSize;
+	base = (char *)limit + size;
+	context = base;
+	top = (char *)context + cxtSize;
 }
 
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/concurrency/invoke.h	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -134,4 +134,10 @@
 		// instrusive link field for threads
 		struct thread_desc * next;
+
+		__cfaabi_dbg_debug_do(
+			// instrusive link field for debugging
+			struct thread_desc * dbg_next;
+			struct thread_desc * dbg_prev;
+		)
      };
 
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/concurrency/kernel.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -87,24 +87,24 @@
 }
 
-void ?{}( coStack_t & this, current_stack_info_t * info) {
-	this.size = info->size;
-	this.storage = info->storage;
-	this.limit = info->limit;
-	this.base = info->base;
-	this.context = info->context;
-	this.top = info->top;
-	this.userStack = true;
-}
-
-void ?{}( coroutine_desc & this, current_stack_info_t * info) {
-	(this.stack){ info };
-	this.name = "Main Thread";
-	this.errno_ = 0;
-	this.state = Start;
-	this.starter = NULL;
-}
-
-void ?{}( thread_desc & this, current_stack_info_t * info) {
-	(this.self_cor){ info };
+void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
+	size      = info->size;
+	storage   = info->storage;
+	limit     = info->limit;
+	base      = info->base;
+	context   = info->context;
+	top       = info->top;
+	userStack = true;
+}
+
+void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
+	stack{ info };
+	name = "Main Thread";
+	errno_ = 0;
+	state = Start;
+	starter = NULL;
+}
+
+void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
+	self_cor{ info };
 }
 
@@ -133,5 +133,5 @@
 void ?{}(processor & this, cluster * cltr) {
 	this.cltr = cltr;
-	(this.terminated){ 0 };
+	this.terminated{ 0 };
 	this.do_terminate = false;
 	this.preemption_alarm = NULL;
@@ -143,5 +143,5 @@
 void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
 	this.cltr = cltr;
-	(this.terminated){ 0 };
+	this.terminated{ 0 };
 	this.do_terminate = false;
 	this.preemption_alarm = NULL;
@@ -154,18 +154,18 @@
 }
 
-void ^?{}(processor & this) {
-	if( ! this.do_terminate ) {
+void ^?{}(processor & this) with( this ){
+	if( ! do_terminate ) {
 		__cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
-		this.do_terminate = true;
-		P( this.terminated );
-		pthread_join( this.kernel_thread, NULL );
-	}
-}
-
-void ?{}(cluster & this) {
-	(this.ready_queue){};
-	( this.ready_queue_lock ){};
-
-	this.preemption = default_preemption();
+		do_terminate = true;
+		P( terminated );
+		pthread_join( kernel_thread, NULL );
+	}
+}
+
+void ?{}(cluster & this) with( this ) {
+	ready_queue{};
+	ready_queue_lock{};
+
+	preemption = default_preemption();
 }
 
@@ -240,30 +240,33 @@
 // Once a thread has finished running, some of
 // its final actions must be executed from the kernel
-void finishRunning(processor * this) {
-	if( this->finish.action_code == Release ) {
-		unlock( *this->finish.lock );
-	}
-	else if( this->finish.action_code == Schedule ) {
-		ScheduleThread( this->finish.thrd );
-	}
-	else if( this->finish.action_code == Release_Schedule ) {
-		unlock( *this->finish.lock );
-		ScheduleThread( this->finish.thrd );
-	}
-	else if( this->finish.action_code == Release_Multi ) {
-		for(int i = 0; i < this->finish.lock_count; i++) {
-			unlock( *this->finish.locks[i] );
+void finishRunning(processor * this) with( this->finish ) {
+	if( action_code == Release ) {
+		verify( disable_preempt_count > 1 );
+		unlock( *lock );
+	}
+	else if( action_code == Schedule ) {
+		ScheduleThread( thrd );
+	}
+	else if( action_code == Release_Schedule ) {
+		verify( disable_preempt_count > 1 );
+		unlock( *lock );
+		ScheduleThread( thrd );
+	}
+	else if( action_code == Release_Multi ) {
+		verify( disable_preempt_count > lock_count );
+		for(int i = 0; i < lock_count; i++) {
+			unlock( *locks[i] );
 		}
 	}
-	else if( this->finish.action_code == Release_Multi_Schedule ) {
-		for(int i = 0; i < this->finish.lock_count; i++) {
-			unlock( *this->finish.locks[i] );
+	else if( action_code == Release_Multi_Schedule ) {
+		for(int i = 0; i < lock_count; i++) {
+			unlock( *locks[i] );
 		}
-		for(int i = 0; i < this->finish.thrd_count; i++) {
-			ScheduleThread( this->finish.thrds[i] );
+		for(int i = 0; i < thrd_count; i++) {
+			ScheduleThread( thrds[i] );
 		}
 	}
 	else {
-		assert(this->finish.action_code == No_Action);
+		assert(action_code == No_Action);
 	}
 }
@@ -334,16 +337,18 @@
 	verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-	lock(   this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 );
-	append( this_processor->cltr->ready_queue, thrd );
-	unlock( this_processor->cltr->ready_queue_lock );
-
-	verify( disable_preempt_count > 0 );
-}
-
-thread_desc * nextThread(cluster * this) {
-	verify( disable_preempt_count > 0 );
-	lock( this->ready_queue_lock __cfaabi_dbg_ctx2 );
-	thread_desc * head = pop_head( this->ready_queue );
-	unlock( this->ready_queue_lock );
+	with( *this_processor->cltr ) {
+		lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+		append( ready_queue, thrd );
+		unlock( ready_queue_lock );
+	}
+
+	verify( disable_preempt_count > 0 );
+}
+
+thread_desc * nextThread(cluster * this) with( *this ) {
+	verify( disable_preempt_count > 0 );
+	lock( ready_queue_lock __cfaabi_dbg_ctx2 );
+	thread_desc * head = pop_head( ready_queue );
+	unlock( ready_queue_lock );
 	verify( disable_preempt_count > 0 );
 	return head;
@@ -361,7 +366,7 @@
 	disable_interrupts();
 	this_processor->finish.action_code = Release;
-	this_processor->finish.lock = lock;
-
-	verify( disable_preempt_count > 0 );
+	this_processor->finish.lock        = lock;
+
+	verify( disable_preempt_count > 1 );
 	suspend();
 	verify( disable_preempt_count > 0 );
@@ -371,9 +376,7 @@
 
 void BlockInternal( thread_desc * thrd ) {
-	assert(thrd);
 	disable_interrupts();
-	assert( thrd->self_cor.state != Halted );
 	this_processor->finish.action_code = Schedule;
-	this_processor->finish.thrd = thrd;
+	this_processor->finish.thrd        = thrd;
 
 	verify( disable_preempt_count > 0 );
@@ -388,8 +391,8 @@
 	disable_interrupts();
 	this_processor->finish.action_code = Release_Schedule;
-	this_processor->finish.lock = lock;
-	this_processor->finish.thrd = thrd;
-
-	verify( disable_preempt_count > 0 );
+	this_processor->finish.lock        = lock;
+	this_processor->finish.thrd        = thrd;
+
+	verify( disable_preempt_count > 1 );
 	suspend();
 	verify( disable_preempt_count > 0 );
@@ -401,6 +404,6 @@
 	disable_interrupts();
 	this_processor->finish.action_code = Release_Multi;
-	this_processor->finish.locks = locks;
-	this_processor->finish.lock_count = count;
+	this_processor->finish.locks       = locks;
+	this_processor->finish.lock_count  = count;
 
 	verify( disable_preempt_count > 0 );
@@ -414,8 +417,8 @@
 	disable_interrupts();
 	this_processor->finish.action_code = Release_Multi_Schedule;
-	this_processor->finish.locks = locks;
-	this_processor->finish.lock_count = lock_count;
-	this_processor->finish.thrds = thrds;
-	this_processor->finish.thrd_count = thrd_count;
+	this_processor->finish.locks       = locks;
+	this_processor->finish.lock_count  = lock_count;
+	this_processor->finish.thrds       = thrds;
+	this_processor->finish.thrd_count  = thrd_count;
 
 	verify( disable_preempt_count > 0 );
@@ -429,6 +432,6 @@
 	verify( disable_preempt_count > 0 );
 	this_processor->finish.action_code = thrd ? Release_Schedule : Release;
-	this_processor->finish.lock = lock;
-	this_processor->finish.thrd = thrd;
+	this_processor->finish.lock        = lock;
+	this_processor->finish.thrd        = thrd;
 
 	suspend();
@@ -516,4 +519,9 @@
 }
 
+//=============================================================================================
+// Unexpected Terminating logic
+//=============================================================================================
+
+
 static __spinlock_t kernel_abort_lock;
 static __spinlock_t kernel_debug_lock;
@@ -581,29 +589,29 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore & this) {
-	lock( this.lock __cfaabi_dbg_ctx2 );
-	this.count -= 1;
-	if ( this.count < 0 ) {
+void P(semaphore & this) with( this ){
+	lock( lock __cfaabi_dbg_ctx2 );
+	count -= 1;
+	if ( count < 0 ) {
 		// queue current task
-		append( this.waiting, (thread_desc *)this_thread );
+		append( waiting, (thread_desc *)this_thread );
 
 		// atomically release spin lock and block
-		BlockInternal( &this.lock );
+		BlockInternal( &lock );
 	}
 	else {
-	    unlock( this.lock );
-	}
-}
-
-void V(semaphore & this) {
+	    unlock( lock );
+	}
+}
+
+void V(semaphore & this) with( this ) {
 	thread_desc * thrd = NULL;
-	lock( this.lock __cfaabi_dbg_ctx2 );
-	this.count += 1;
-	if ( this.count <= 0 ) {
+	lock( lock __cfaabi_dbg_ctx2 );
+	count += 1;
+	if ( count <= 0 ) {
 		// remove task at head of waiting list
-		thrd = pop_head( this.waiting );
-	}
-
-	unlock( this.lock );
+		thrd = pop_head( waiting );
+	}
+
+	unlock( lock );
 
 	// make new owner
@@ -611,4 +619,37 @@
 }
 
+//-----------------------------------------------------------------------------
+// Debug
+__cfaabi_dbg_debug_do(
+	struct {
+		thread_desc * tail;
+	} __cfaabi_dbg_thread_list = { NULL };
+
+	void __cfaabi_dbg_thread_register( thread_desc * thrd ) {
+		if( !__cfaabi_dbg_thread_list.tail ) {
+			__cfaabi_dbg_thread_list.tail = thrd;
+			return;
+		}
+		__cfaabi_dbg_thread_list.tail->dbg_next = thrd;
+		thrd->dbg_prev = __cfaabi_dbg_thread_list.tail;
+		__cfaabi_dbg_thread_list.tail = thrd;
+	}
+
+	void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) {
+		thread_desc * prev = thrd->dbg_prev;
+		thread_desc * next = thrd->dbg_next;
+
+		if( next ) { next->dbg_prev = prev; }
+		else       {
+			assert( __cfaabi_dbg_thread_list.tail == thrd );
+			__cfaabi_dbg_thread_list.tail = prev;
+		}
+
+		if( prev ) { prev->dbg_next = next; }
+
+		thrd->dbg_prev = NULL;
+		thrd->dbg_next = NULL;
+	}
+)
 // Local Variables: //
 // mode: c //
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/concurrency/kernel_private.h	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -85,4 +85,9 @@
 extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
 
+__cfaabi_dbg_debug_do(
+	extern void __cfaabi_dbg_thread_register  ( thread_desc * thrd );
+	extern void __cfaabi_dbg_thread_unregister( thread_desc * thrd );
+)
+
 //-----------------------------------------------------------------------------
 // Utils
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/concurrency/monitor.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -53,10 +53,4 @@
 static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
 
-#ifndef __CFA_LOCK_NO_YIELD
-#define DO_LOCK lock_yield
-#else
-#define DO_LOCK lock
-#endif
-
 //-----------------------------------------------------------------------------
 // Useful defines
@@ -90,6 +84,8 @@
 	static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
 		// Lock the monitor spinlock
-		DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+		lock( this->lock __cfaabi_dbg_ctx2 );
 		thread_desc * thrd = this_thread;
+
+		verify( disable_preempt_count > 0 );
 
 		__cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
@@ -121,4 +117,7 @@
 			// Some one else has the monitor, wait in line for it
 			append( this->entry_queue, thrd );
+
+			verify( disable_preempt_count > 0 );
+
 			BlockInternal( &this->lock );
 
@@ -138,5 +137,5 @@
 	static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
 		// Lock the monitor spinlock
-		DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+		lock( this->lock __cfaabi_dbg_ctx2 );
 		thread_desc * thrd = this_thread;
 
@@ -201,6 +200,6 @@
 	// Leave single monitor
 	void __leave_monitor_desc( monitor_desc * this ) {
-		// Lock the monitor spinlock, DO_LOCK to reduce contention
-		DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+		// Lock the monitor spinlock
+		lock( this->lock __cfaabi_dbg_ctx2 );
 
 		__cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
@@ -248,5 +247,5 @@
 
 		// Lock the monitor now
-		DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+		lock( this->lock __cfaabi_dbg_ctx2 );
 
 		disable_interrupts();
@@ -397,6 +396,11 @@
 	append( this.blocked, &waiter );
 
+	verify( disable_preempt_count == 0 );
+
 	// Lock all monitors (aggregates the locks as well)
 	lock_all( monitors, locks, count );
+
+	// verifyf( disable_preempt_count == count, "Got %d, expected %d\n", disable_preempt_count, count );
+	if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); }
 
 	// Find the next thread(s) to run
@@ -473,6 +477,12 @@
 	monitor_ctx( this.monitors, this.monitor_count );
 
+	verify( disable_preempt_count == 0 );
+
 	// Lock all monitors (aggregates the locks them as well)
 	lock_all( monitors, locks, count );
+
+	// verify( disable_preempt_count == count );
+	if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); }
+
 
 	// Create the node specific to this wait operation
@@ -737,5 +747,5 @@
 static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) {
 	for( __lock_size_t i = 0; i < count; i++ ) {
-		DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 );
+		lock( *locks[i] __cfaabi_dbg_ctx2 );
 	}
 }
@@ -744,5 +754,5 @@
 	for( __lock_size_t i = 0; i < count; i++ ) {
 		__spinlock_t * l = &source[i]->lock;
-		DO_LOCK( *l __cfaabi_dbg_ctx2 );
+		lock( *l __cfaabi_dbg_ctx2 );
 		if(locks) locks[i] = l;
 	}
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/concurrency/preemption.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -19,8 +19,4 @@
 extern "C" {
 #include <errno.h>
-#include <execinfo.h>
-#define __USE_GNU
-#include <signal.h>
-#undef __USE_GNU
 #include <stdio.h>
 #include <string.h>
@@ -29,7 +25,5 @@
 #undef ftype
 
-#ifdef __USE_STREAM__
-#include "fstream"
-#endif
+#include "bits/signal.h"
 
 //TODO move to defaults
@@ -40,8 +34,4 @@
 	return __CFA_DEFAULT_PREEMPTION__;
 }
-
-// Short hands for signal context information
-#define __CFA_SIGCXT__ ucontext_t *
-#define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt
 
 // FwdDeclarations : timeout handlers
@@ -53,7 +43,4 @@
 void sigHandler_segv     ( __CFA_SIGPARMS__ );
 void sigHandler_abort    ( __CFA_SIGPARMS__ );
-
-// FwdDeclarations : sigaction wrapper
-static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags );
 
 // FwdDeclarations : alarm thread main
@@ -73,7 +60,7 @@
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
 
-void ?{}(event_kernel_t & this) {
-	(this.alarms){};
-	(this.lock){};
+void ?{}(event_kernel_t & this) with( this ) {
+	alarms{};
+	lock{};
 }
 
@@ -162,5 +149,5 @@
 	// If counter reaches 0, execute any pending CtxSwitch
 	void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-		processor * proc   = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
+		processor   * proc = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
 		thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
 
@@ -182,5 +169,5 @@
 	void enable_interrupts_noPoll() {
 		__attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
-		verify( prev != 0u );                     // If this triggers someone is enabled already enabled interrupts
+		verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
 	}
 }
@@ -246,6 +233,4 @@
 	// Setup proper signal handlers
 	__kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART );         // CtxSwitch handler
-	// __kernel_sigaction( SIGSEGV, sigHandler_segv     , SA_SIGINFO );      // Failure handler
-	// __kernel_sigaction( SIGBUS , sigHandler_segv     , SA_SIGINFO );      // Failure handler
 
 	signal_block( SIGALRM );
@@ -308,5 +293,5 @@
 	if( !preemption_ready() ) { return; }
 
-	// __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
+	__cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
 
 	preemption_in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
@@ -380,133 +365,4 @@
 }
 
-// Sigaction wrapper : register an signal handler
-static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) {
-	struct sigaction act;
-
-	act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
-	act.sa_flags = flags;
-
-	if ( sigaction( sig, &act, NULL ) == -1 ) {
-		__cfaabi_dbg_print_buffer_decl(
-			" __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
-			sig, handler, flags, errno, strerror( errno )
-		);
-		_exit( EXIT_FAILURE );
-	}
-}
-
-// Sigaction wrapper : restore default handler
-static void __kernel_sigdefault( int sig ) {
-	struct sigaction act;
-
-	act.sa_handler = SIG_DFL;
-	act.sa_flags = 0;
-	sigemptyset( &act.sa_mask );
-
-	if ( sigaction( sig, &act, NULL ) == -1 ) {
-		__cfaabi_dbg_print_buffer_decl(
-			" __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
-			sig, errno, strerror( errno )
-		);
-		_exit( EXIT_FAILURE );
-	}
-}
-
-//=============================================================================================
-// Terminating Signals logic
-//=============================================================================================
-
-__cfaabi_dbg_debug_do(
-	static void __kernel_backtrace( int start ) {
-		// skip first N stack frames
-
-		enum { Frames = 50 };
-		void * array[Frames];
-		int size = backtrace( array, Frames );
-		char ** messages = backtrace_symbols( array, size );
-
-		// find executable name
-		*index( messages[0], '(' ) = '\0';
-		#ifdef __USE_STREAM__
-		serr | "Stack back trace for:" | messages[0] | endl;
-		#else
-		fprintf( stderr, "Stack back trace for: %s\n", messages[0]);
-		#endif
-
-		// skip last 2 stack frames after main
-		for ( int i = start; i < size && messages != NULL; i += 1 ) {
-			char * name = NULL;
-			char * offset_begin = NULL;
-			char * offset_end = NULL;
-
-			for ( char *p = messages[i]; *p; ++p ) {
-				// find parantheses and +offset
-				if ( *p == '(' ) {
-					name = p;
-				}
-				else if ( *p == '+' ) {
-					offset_begin = p;
-				}
-				else if ( *p == ')' ) {
-					offset_end = p;
-					break;
-				}
-			}
-
-			// if line contains symbol print it
-			int frameNo = i - start;
-			if ( name && offset_begin && offset_end && name < offset_begin ) {
-				// delimit strings
-				*name++ = '\0';
-				*offset_begin++ = '\0';
-				*offset_end++ = '\0';
-
-				#ifdef __USE_STREAM__
-				serr 	| "("  | frameNo | ")" | messages[i] | ":"
-					| name | "+" | offset_begin | offset_end | endl;
-				#else
-				fprintf( stderr, "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end);
-				#endif
-			}
-			// otherwise, print the whole line
-			else {
-				#ifdef __USE_STREAM__
-				serr | "(" | frameNo | ")" | messages[i] | endl;
-				#else
-				fprintf( stderr, "(%i) %s\n", frameNo, messages[i] );
-				#endif
-			}
-		}
-
-		free( messages );
-	}
-)
-
-// void sigHandler_segv( __CFA_SIGPARMS__ ) {
-// 	__cfaabi_dbg_debug_do(
-// 		#ifdef __USE_STREAM__
-// 		serr 	| "*CFA runtime error* program cfa-cpp terminated with"
-// 			| (sig == SIGSEGV ? "segment fault." : "bus error.")
-// 			| endl;
-// 		#else
-// 		fprintf( stderr, "*CFA runtime error* program cfa-cpp terminated with %s\n", sig == SIGSEGV ? "segment fault." : "bus error." );
-// 		#endif
-
-// 		// skip first 2 stack frames
-// 		__kernel_backtrace( 1 );
-// 	)
-// 	exit( EXIT_FAILURE );
-// }
-
-// void sigHandler_abort( __CFA_SIGPARMS__ ) {
-// 	// skip first 6 stack frames
-// 	__cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); )
-
-// 	// reset default signal handler
-// 	__kernel_sigdefault( SIGABRT );
-
-// 	raise( SIGABRT );
-// }
-
 // Local Variables: //
 // mode: c //
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/concurrency/thread.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -31,34 +31,39 @@
 // Thread ctors and dtors
 
-void ?{}(thread_desc& this) {
-	(this.self_cor){};
-	this.self_cor.name = "Anonymous Coroutine";
-	this.self_mon.owner = &this;
-	this.self_mon.recursion = 1;
-	this.self_mon_p = &this.self_mon;
-	this.next = NULL;
+void ?{}(thread_desc& this) with( this ) {
+	self_cor{};
+	self_cor.name = "Anonymous Coroutine";
+	self_mon.owner = &this;
+	self_mon.recursion = 1;
+	self_mon_p = &self_mon;
+	next = NULL;
+	__cfaabi_dbg_debug_do(
+		dbg_next = NULL;
+		dbg_prev = NULL;
+		__cfaabi_dbg_thread_register(&this);
+	)
 
-	(this.monitors){ &this.self_mon_p, 1, (fptr_t)0 };
+	monitors{ &self_mon_p, 1, (fptr_t)0 };
 }
 
-void ^?{}(thread_desc& this) {
-	^(this.self_cor){};
+void ^?{}(thread_desc& this) with( this ) {
+	^self_cor{};
 }
 
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
-void ?{}( scoped(T)& this ) {
-	(this.handle){};
-	__thrd_start(this.handle);
+void ?{}( scoped(T)& this ) with( this ) {
+	handle{};
+	__thrd_start(handle);
 }
 
 forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
-void ?{}( scoped(T)& this, P params ) {
-	(this.handle){ params };
-	__thrd_start(this.handle);
+void ?{}( scoped(T)& this, P params ) with( this ) {
+	handle{ params };
+	__thrd_start(handle);
 }
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)& this ) {
-	^(this.handle){};
+void ^?{}( scoped(T)& this ) with( this ) {
+	^handle{};
 }
 
@@ -68,5 +73,5 @@
 void __thrd_start( T& this ) {
 	coroutine_desc* thrd_c = get_coroutine(this);
-	thread_desc*  thrd_h = get_thread   (this);
+	thread_desc   * thrd_h = get_thread   (this);
 	thrd_c->last = this_coroutine;
 
Index: src/libcfa/interpose.c
===================================================================
--- src/libcfa/interpose.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/interpose.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -22,11 +22,16 @@
 #include <dlfcn.h>
 #include <unistd.h>
+#define __USE_GNU
+#include <signal.h>
+#undef __USE_GNU
+#include <execinfo.h>
 }
 
 #include "bits/debug.h"
 #include "bits/defs.h"
+#include "bits/signal.h"
 #include "startup.h"
 
-void interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
+void __cfaabi_interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
 
 typedef void (*generic_fptr_t)(void);
@@ -84,10 +89,21 @@
 #define INIT_REALRTN( x, ver ) assign_ptr( (void**)&libc_##x, #x, ver)
 
-void interpose_startup() {
+void sigHandler_segv ( __CFA_SIGPARMS__ );
+void sigHandler_abort( __CFA_SIGPARMS__ );
+
+void __cfaabi_interpose_startup() {
 	const char *version = NULL;
 
 	INIT_REALRTN( abort, version );
 	INIT_REALRTN( exit, version );
-}
+
+	__kernel_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO );      // Failure handler
+	__kernel_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO );      // Failure handler
+	__kernel_sigaction( SIGABRT, sigHandler_abort, SA_SIGINFO );      // Failure handler
+}
+
+//=============================================================================================
+// Terminating Signals logic
+//=============================================================================================
 
 extern "C" {
@@ -137,4 +153,71 @@
 		libc_abort();
 	}
+}
+
+// skip first 6 stack frames by default
+static void __kernel_backtrace() {
+	// skip first N stack frames
+	int start = 6;
+
+	enum { Frames = 50 };
+	void * array[Frames];
+	int size = backtrace( array, Frames );
+	char ** messages = backtrace_symbols( array, size );
+
+	// find executable name
+	*index( messages[0], '(' ) = '\0';
+	__cfaabi_dbg_bits_print_nolock( "Stack back trace for: %s\n", messages[0]);
+
+	// skip last 2 stack frames after main
+	for ( int i = start; i < size && messages != NULL; i += 1 ) {
+		char * name = NULL;
+		char * offset_begin = NULL;
+		char * offset_end = NULL;
+
+		for ( char *p = messages[i]; *p; ++p ) {
+			// find parantheses and +offset
+			if ( *p == '(' ) {
+				name = p;
+			}
+			else if ( *p == '+' ) {
+				offset_begin = p;
+			}
+			else if ( *p == ')' ) {
+				offset_end = p;
+				break;
+			}
+		}
+
+		// if line contains symbol print it
+		int frameNo = i - start;
+		if ( name && offset_begin && offset_end && name < offset_begin ) {
+			// delimit strings
+			*name++ = '\0';
+			*offset_begin++ = '\0';
+			*offset_end++ = '\0';
+
+			__cfaabi_dbg_bits_print_nolock( "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end);
+		}
+		// otherwise, print the whole line
+		else {
+			__cfaabi_dbg_bits_print_nolock( "(%i) %s\n", frameNo, messages[i] );
+		}
+	}
+
+	free( messages );
+}
+
+void sigHandler_segv( __CFA_SIGPARMS__ ) {
+	// skip first only 1 stack frames in case of segfault.
+	abortf( "*CFA runtime error* program cfa-cpp terminated with %s\n", sig == SIGSEGV ? "segment fault." : "bus error." );
+}
+
+void sigHandler_abort( __CFA_SIGPARMS__ ) {
+	__kernel_backtrace();
+
+	// reset default signal handler
+	__kernel_sigdefault( SIGABRT );
+
+	raise( SIGABRT );
 }
 
Index: src/libcfa/interpose.h
===================================================================
--- src/libcfa/interpose.h	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/libcfa/interpose.h	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -16,5 +16,5 @@
 #pragma once
 
-void * interpose_symbol( const char* symbol, , const char *version );
+void * interpose_symbol( const char* symbol, const char *version );
 
 extern __typeof__( abort ) libc_abort __attribute__(( noreturn ));
Index: src/prelude/prelude.cf
===================================================================
--- src/prelude/prelude.cf	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/prelude/prelude.cf	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -39,6 +39,4 @@
 // ------------------------------------------------------------
 
-_Bool			?++( _Bool & ),				?++( volatile _Bool & );
-_Bool			?--( _Bool & ),				?--( volatile _Bool & );
 signed short		?++( signed short & ),			?++( volatile signed short & );
 signed short		?--( signed short & ),			?--( volatile signed short & );
@@ -94,5 +92,4 @@
 // ------------------------------------------------------------
 
-_Bool			++?( _Bool & ),				--?( _Bool & );
 signed short	++?( signed short & ),			--?( signed short & );
 signed int		++?( signed int & ),			--?( signed int & );
@@ -125,5 +122,5 @@
 forall( ftype FT ) FT &		 *?( FT * );
 
-_Bool			+?( _Bool ),			-?( _Bool ),			~?( _Bool );
+_Bool			+?( _Bool ),			-?( _Bool );
 signed int		+?( signed int ),		-?( signed int ),		~?( signed int );
 unsigned int		+?( unsigned int ),		-?( unsigned int ),		~?( unsigned int );
@@ -157,5 +154,4 @@
 // ------------------------------------------------------------
 
-_Bool			?*?( _Bool, _Bool ),					?/?( _Bool, _Bool ),				?%?( _Bool, _Bool );
 signed int		?*?( signed int, signed int ),				?/?( signed int, signed int ),			?%?( signed int, signed int );
 unsigned int		?*?( unsigned int, unsigned int ),			?/?( unsigned int, unsigned int ),		?%?( unsigned int, unsigned int );
@@ -215,5 +211,4 @@
 // ------------------------------------------------------------
 
-_Bool			?<<?( _Bool, _Bool ),					?>>?( _Bool, _Bool );
 signed int		?<<?( signed int, signed int ),				?>>?( signed int, signed int );
 unsigned int		?<<?( unsigned int, unsigned int ),			?>>?( unsigned int, unsigned int );
@@ -467,5 +462,4 @@
 
 
-_Bool			?*=?( _Bool &, _Bool ),					?*=?( volatile _Bool &, _Bool );
 char			?*=?( char &, char ),					?*=?( volatile char &, char );
 char signed		?*=?( char signed &, char signed ),			?*=?( volatile char signed &, char signed );
@@ -534,5 +528,4 @@
 unsigned long long int	?-=?( unsigned long long int &, unsigned long long int ), ?-=?( volatile unsigned long long int &, unsigned long long int );
 
-_Bool			?<<=?( _Bool &, _Bool ),				?<<=?( volatile _Bool &, _Bool );
 char			?<<=?( char &, char ),					?<<=?( volatile char &, char );
 char signed		?<<=?( char signed &, char signed ),			?<<=?( volatile char signed &, char signed );
@@ -547,5 +540,4 @@
 unsigned long long int	?<<=?( unsigned long long int &, unsigned long long int ), ?<<=?( volatile unsigned long long int &, unsigned long long int );
 
-_Bool			?>>=?( _Bool &, _Bool ),				?>>=?( volatile _Bool &, _Bool );
 char			?>>=?( char &, char ),					?>>=?( volatile char &, char );
 char signed		?>>=?( char signed &, char signed ),			?>>=?( volatile char signed &, char signed );
Index: src/tests/Makefile.am
===================================================================
--- src/tests/Makefile.am	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/Makefile.am	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -65,5 +65,5 @@
 
 concurrency :
-	@+python test.py --debug=${debug} ${concurrent} ${concurrent_test}
+	@+python test.py --debug=${debug} -Iconcurrent
 
 .dummy : .dummy.c @CFA_BINDIR@/@CFA_NAME@
Index: src/tests/Makefile.in
===================================================================
--- src/tests/Makefile.in	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/Makefile.in	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -743,5 +743,5 @@
 
 concurrency :
-	@+python test.py --debug=${debug} ${concurrent} ${concurrent_test}
+	@+python test.py --debug=${debug} -Iconcurrent
 
 .dummy : .dummy.c @CFA_BINDIR@/@CFA_NAME@
Index: src/tests/concurrent/examples/quickSort.c
===================================================================
--- src/tests/concurrent/examples/quickSort.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/concurrent/examples/quickSort.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -9,6 +9,6 @@
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 29 08:41:37 2018
-// Update Count     : 155
+// Last Modified On : Tue Jan 30 15:58:58 2018
+// Update Count     : 162
 //
 
@@ -100,6 +100,5 @@
 	if ( argc != 1 ) {									// do not use defaults
 		if ( argc < 2 || argc > 4 ) usage( argv );		// wrong number of options
-//		if ( strcmp( argv[1], "-t" ) == 0 ) {			// timing ?
-		if ( argv[1][0] == '-' && argv[1][1] == 't' ) {	// timing ?
+		if ( strcmp( argv[1], "-t" ) == 0 ) {			// timing ?
 			&unsortedfile = (ifstream *)0;				// no input
 			choose ( argc ) {
Index: src/tests/functions.c
===================================================================
--- src/tests/functions.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/functions.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -10,6 +10,6 @@
 // Created On       : Wed Aug 17 08:39:58 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Nov 27 18:08:54 2017
-// Update Count     : 11
+// Last Modified On : Wed Jan 17 22:44:12 2018
+// Update Count     : 12
 // 
 
@@ -25,5 +25,5 @@
 	void g(void)
 	) {
-	(*g)();
+	(* g)();
 	g();
 	g = h;
@@ -32,14 +32,14 @@
 int f1() {}
 int (f2()) {}
-int (*f3())() {}
-int *((f4())) {}
-int ((*f5()))() {}
-int *f6() {}
-int *(f7)() {}
-int **f8() {}
-int * const *(f9)() {}
-int (*f10())[] {}
-int (*f11())[][3] {}
-int ((*f12())[])[3] {}
+int (* f3())() {}
+int * ((f4())) {}
+int ((* f5()))() {}
+int * f6() {}
+int * (f7)() {}
+int ** f8() {}
+int * const * (f9)() {}
+int (* f10())[] {}
+int (* f11())[][3] {}
+int ((* f12())[])[3] {}
 
 // "implicit int" otype specifier (not ANSI)
@@ -50,9 +50,9 @@
 extern const fII4( int i ) {}
 
-*fII5() {}
-const *fII6() {}
-const long *fII7() {}
-static const long *fII8() {}
-const static long *fII9() {}
+* fII5() {}
+const * fII6() {}
+const long * fII7() {}
+static const long * fII8() {}
+const static long * fII9() {}
 
 // K&R function definitions
@@ -117,10 +117,10 @@
 	[int](int)
 	) {
-	int (*(*pc)[][10])[][3];
+	int (* (* pc)[][10])[][3];
 	* [][10] * [][3] int p;
 	* [] * [int](int) p;
 }
 
-static const int *f1() {}
+static const int * f1() {}
 static [ const int ] f2() {}
 static inline [ const * int ] f3() {}
@@ -133,7 +133,7 @@
 	int (),
 
-	int *(),
-	int **(),
-	int * const *(),
+	int * (),
+	int ** (),
+	int * const * (),
 	int * const * const (),
 
@@ -141,10 +141,10 @@
 	int ([10]),
 
-	int *([]),
-	int *([10]),
-	int **([]),
-	int **([10]),
-	int * const *([]),
-	int * const *([10]),
+	int * ([]),
+	int * ([10]),
+	int ** ([]),
+	int ** ([10]),
+	int * const * ([]),
+	int * const * ([10]),
 	int * const * const ([]),
 	int * const * const ([10])
@@ -154,7 +154,7 @@
 	int (),
 
-	int *(),
-	int **(),
-	int * const *(),
+	int * (),
+	int ** (),
+	int * const * (),
 	int * const * const (),
 
@@ -162,10 +162,10 @@
 	int ([10]),
 
-	int *([]),
-	int *([10]),
-	int **([]),
-	int **([10]),
-	int * const *([]),
-	int * const *([10]),
+	int * ([]),
+	int * ([10]),
+	int ** ([]),
+	int ** ([10]),
+	int * const * ([]),
+	int * const * ([10]),
 	int * const * const ([]),
 	int * const * const ([10])
@@ -175,5 +175,5 @@
 typedef int T;
 
-int f( T (*f), T t ) {
+int f( T (* f), T t ) {
 	T (T);
 }
@@ -184,5 +184,5 @@
 //int (f[])() {}
 //int f[]() {}
-//int ((*f15())())[] {}
+//int ((* f15())())[] {}
 
 // Local Variables: //
Index: src/tests/identFuncDeclarator.c
===================================================================
--- src/tests/identFuncDeclarator.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/identFuncDeclarator.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -10,6 +10,6 @@
 // Created On       : Wed Aug 17 08:36:34 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 17 08:37:06 2016
-// Update Count     : 1
+// Last Modified On : Wed Jan 17 22:39:13 2018
+// Update Count     : 2
 // 
 
@@ -18,17 +18,17 @@
 	int (f2);
 
-	int *f3;
-	int **f4;
-	int * const *f5;
+	int * f3;
+	int ** f4;
+	int * const * f5;
 	int * const * const f6;
 
-	int *(f7);
-	int **(f8);
-	int * const *(f9);
+	int * (f7);
+	int ** (f8);
+	int * const * (f9);
 	int * const * const (f10);
 
-	int (*f11);
-	int (**f12);
-	int (* const *f13);
+	int (* f11);
+	int (** f12);
+	int (* const * f13);
 	int (* const * const f14);
 
@@ -38,28 +38,28 @@
 	int (f18[10]);
 
-	int *f19[2];
-	int *f20[10];
-	int **f21[2];
-	int **f22[10];
-	int * const *f23[2];
-	int * const *f24[10];
+	int * f19[2];
+	int * f20[10];
+	int ** f21[2];
+	int ** f22[10];
+	int * const * f23[2];
+	int * const * f24[10];
 	int * const * const f25[2];
 	int * const * const f26[10];
 
-	int *(f27[2]);
-	int *(f28[10]);
-	int **(f29[2]);
-	int **(f30[10]);
-	int * const *(f31[2]);
-	int * const *(f32[10]);
+	int * (f27[2]);
+	int * (f28[10]);
+	int ** (f29[2]);
+	int ** (f30[10]);
+	int * const * (f31[2]);
+	int * const * (f32[10]);
 	int * const * const (f33[2]);
 	int * const * const (f34[10]);
 
-	int (*f35[2]);
-	int (*f36[10]);
-	int (**f37[2]);
-	int (**f38[10]);
-	int (* const *f39[2]);
-	int (* const *f40[10]);
+	int (* f35[2]);
+	int (* f36[10]);
+	int (** f37[2]);
+	int (** f38[10]);
+	int (* const * f39[2]);
+	int (* const * f40[10]);
 	int (* const * const f41[2]);
 	int (* const * const f42[10]);
@@ -72,19 +72,19 @@
 	int ((f48[3]))[3];
 
-	int *f49[2][3];
-	int *f50[3][3];
-	int **f51[2][3];
-	int **f52[3][3];
-	int * const *f53[2][3];
-	int * const *f54[3][3];
+	int * f49[2][3];
+	int * f50[3][3];
+	int ** f51[2][3];
+	int ** f52[3][3];
+	int * const * f53[2][3];
+	int * const * f54[3][3];
 	int * const * const f55[2][3];
 	int * const * const f56[3][3];
 
-	int (*f57[2][3]);
-	int (*f58[3][3]);
-	int (**f59[2][3]);
-	int (**f60[3][3]);
-	int (* const *f61[2][3]);
-	int (* const *f62[3][3]);
+	int (* f57[2][3]);
+	int (* f58[3][3]);
+	int (** f59[2][3]);
+	int (** f60[3][3]);
+	int (* const * f61[2][3]);
+	int (* const * f62[3][3]);
 	int (* const * const f63[2][3]);
 	int (* const * const f64[3][3]);
@@ -93,21 +93,21 @@
 	int (f66)(int);
 
-	int *f67(int);
-	int **f68(int);
-	int * const *f69(int);
+	int * f67(int);
+	int ** f68(int);
+	int * const * f69(int);
 	int * const * const f70(int);
 
-	int *(f71)(int);
-	int **(f72)(int);
-	int * const *(f73)(int);
+	int * (f71)(int);
+	int ** (f72)(int);
+	int * const * (f73)(int);
 	int * const * const (f74)(int);
 
-	int (*f75)(int);
-	int (**f76)(int);
-	int (* const *f77)(int);
+	int (* f75)(int);
+	int (** f76)(int);
+	int (* const * f77)(int);
 	int (* const * const f78)(int);
 
-	int (*(*f79)(int))();
-	int (*(* const f80)(int))();
+	int (* (* f79)(int))();
+	int (* (* const f80)(int))();
 	int (* const(* const f81)(int))();
 }
Index: src/tests/identParamDeclarator.c
===================================================================
--- src/tests/identParamDeclarator.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/identParamDeclarator.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -10,9 +10,9 @@
 // Created On       : Wed Aug 17 08:37:56 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 17 08:38:42 2016
-// Update Count     : 1
+// Last Modified On : Wed Jan 17 22:36:11 2018
+// Update Count     : 2
 // 
 
-int fred(
+int fred (
 	int f1,
 	int (f2),
@@ -157,7 +157,5 @@
     );
 
-//Dummy main
-int main(int argc, char const *argv[])
-{
+int main( int argc, char const *argv[] ) {				// dummy main
 	return 0;
 }
Index: src/tests/preempt_longrun/Makefile.am
===================================================================
--- src/tests/preempt_longrun/Makefile.am	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/Makefile.am	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -19,5 +19,6 @@
 preempt=1_000ul
 
-REPEAT = ${abs_top_srcdir}/tools/repeat -s
+REPEAT = ${abs_top_srcdir}/tools/repeat
+TIME = /usr/bin/time -f "%E"
 
 BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -debug -O2 -DPREEMPTION_RATE=${preempt}
@@ -37,6 +38,14 @@
 	${AM_V_GEN}${CC} ${CFLAGS} ${<} -o ${@}
 
-%.run : %
-	@ time ${REPEAT} $(repeats) timeout ${max_time} ./${<}
+%.run : % ${REPEAT}
+	@ time ${REPEAT} -r out.log -i -s $(repeats) timeout ${max_time} ./${<}
 	@ rm ${<}
 	@ echo -e "${<}: SUCCESS\n"
+
+%.time : % ${REPEAT}
+	@ ${REPEAT} -i -s -- $(repeats) $(TIME) -a -o times.log ./${<}
+	@ rm ${<}
+	@ echo -e "${<}: SUCCESS\n"
+
+${REPEAT}:
+	@+make -C ${abs_top_srcdir}/tools/
Index: src/tests/preempt_longrun/Makefile.in
===================================================================
--- src/tests/preempt_longrun/Makefile.in	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/Makefile.in	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -451,5 +451,6 @@
 max_time = 600
 preempt = 1_000ul
-REPEAT = ${abs_top_srcdir}/tools/repeat -s
+REPEAT = ${abs_top_srcdir}/tools/repeat
+TIME = /usr/bin/time -f "%E"
 BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -debug -O2 -DPREEMPTION_RATE=${preempt}
 TESTS = block create disjoint enter enter3 processor stack wait yield
@@ -874,8 +875,16 @@
 	${AM_V_GEN}${CC} ${CFLAGS} ${<} -o ${@}
 
-%.run : %
-	@ time ${REPEAT} $(repeats) timeout ${max_time} ./${<}
+%.run : % ${REPEAT}
+	@ time ${REPEAT} -r out.log -i -s $(repeats) timeout ${max_time} ./${<}
 	@ rm ${<}
 	@ echo -e "${<}: SUCCESS\n"
+
+%.time : % ${REPEAT}
+	@ ${REPEAT} -i -s -- $(repeats) $(TIME) -a -o times.log ./${<}
+	@ rm ${<}
+	@ echo -e "${<}: SUCCESS\n"
+
+${REPEAT}:
+	@+make -C ${abs_top_srcdir}/tools/
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
Index: src/tests/preempt_longrun/block.c
===================================================================
--- src/tests/preempt_longrun/block.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/block.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -1,1 +1,1 @@
-../sched-int-block.c
+../concurrent/signal/block.c
Index: src/tests/preempt_longrun/create.c
===================================================================
--- src/tests/preempt_longrun/create.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/create.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -14,5 +14,5 @@
 thread worker_t {};
 
-void main(worker_t * this) {}
+void main(worker_t & this) {}
 
 int main(int argc, char* argv[]) {
Index: src/tests/preempt_longrun/disjoint.c
===================================================================
--- src/tests/preempt_longrun/disjoint.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/disjoint.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -1,1 +1,1 @@
-../sched-int-disjoint.c
+../concurrent/signal/disjoint.c
Index: src/tests/preempt_longrun/enter.c
===================================================================
--- src/tests/preempt_longrun/enter.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/enter.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -17,11 +17,11 @@
 mon_t mon;
 
-void foo( mon_t * mutex this ) {}
+void foo( mon_t & mutex this ) {}
 
 thread worker_t {};
 
-void main( worker_t * this ) {
+void main( worker_t & this ) {
 	for( unsigned long i = 0; i < N; i++ ) {
-		foo( &mon );
+		foo( mon );
 	}
 }
Index: src/tests/preempt_longrun/enter3.c
===================================================================
--- src/tests/preempt_longrun/enter3.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/enter3.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -17,11 +17,11 @@
 mon_t mon1, mon2, mon3;
 
-void foo( mon_t * mutex a, mon_t * mutex b, mon_t * mutex c ) {}
+void foo( mon_t & mutex a, mon_t & mutex b, mon_t & mutex c ) {}
 
 thread worker_t {};
 
-void main( worker_t * this ) {
+void main( worker_t & this ) {
 	for( unsigned long i = 0; i < N; i++ ) {
-		foo( &mon1, &mon2, &mon3 );
+		foo( mon1, mon2, mon3 );
 	}
 }
Index: src/tests/preempt_longrun/processor.c
===================================================================
--- src/tests/preempt_longrun/processor.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/processor.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -14,5 +14,5 @@
 thread worker_t {};
 
-void main(worker_t * this) {}
+void main(worker_t & this) {}
 
 int main(int argc, char* argv[]) {
Index: src/tests/preempt_longrun/stack.c
===================================================================
--- src/tests/preempt_longrun/stack.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/stack.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -14,5 +14,5 @@
 thread worker_t {};
 
-void main(worker_t * this) {
+void main(worker_t & this) {
 	volatile long long p = 5_021_609ul;
 	volatile long long a = 326_417ul;
Index: src/tests/preempt_longrun/wait.c
===================================================================
--- src/tests/preempt_longrun/wait.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/wait.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -1,1 +1,1 @@
-../sched-int-wait.c
+../concurrent/signal/wait.c
Index: src/tests/preempt_longrun/yield.c
===================================================================
--- src/tests/preempt_longrun/yield.c	(revision bc6f9183d7f12eaeee38caea9daf1b32b27f002a)
+++ src/tests/preempt_longrun/yield.c	(revision e2e7330de2695ce8f95408c682ce20f6f31239db)
@@ -14,5 +14,5 @@
 thread worker_t {};
 
-void main(worker_t * this) {
+void main(worker_t & this) {
 	for(int i = 0; i < N; i++) {
 		yield();