Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision 555af62e9161db43d53c22635e04d4d5edbb0662)
+++ libcfa/src/concurrency/io.cfa	(revision 9d47c1ff198f0f1775b2686ac233f78d06c5aedd)
@@ -594,8 +594,8 @@
 		lock( queue.lock __cfaabi_dbg_ctx2 );
 		{
-			was_empty = empty(queue.queue);
+			was_empty = queue.queue`isEmpty;
 
 			// Add our request to the list
-			add( queue.queue, item );
+			insert_last( queue.queue, item );
 
 			// Mark as pending
@@ -632,5 +632,5 @@
 	// notify the arbiter that new allocations are available
 	static void __ioarbiter_notify( io_arbiter$ & this, io_context$ * ctx ) {
-		/* paranoid */ verify( !empty(this.pending.queue) );
+		/* paranoid */ verify( !this.pending.queue`isEmpty );
 		/* paranoid */ verify( __preemption_enabled() );
 
@@ -642,8 +642,8 @@
 			// as long as there are pending allocations try to satisfy them
 			// for simplicity do it in FIFO order
-			while( !empty(this.pending.queue) ) {
+			while( !this.pending.queue`isEmpty ) {
 				// get first pending allocs
 				__u32 have = ctx->sq.free_ring.tail - ctx->sq.free_ring.head;
-				__pending_alloc & pa = (__pending_alloc&)head( this.pending.queue );
+				__pending_alloc & pa = (__pending_alloc&)(this.pending.queue`first);
 
 				// check if we have enough to satisfy the request
@@ -651,5 +651,5 @@
 
 				// if there are enough allocations it means we can drop the request
-				drop( this.pending.queue );
+				try_pop_front( this.pending.queue );
 
 				/* paranoid */__attribute__((unused)) bool ret =
@@ -727,7 +727,7 @@
 			// pop each operation one at a time.
 			// There is no wait morphing because of the io sq ring
-			while( !empty(ctx.ext_sq.queue) ) {
+			while( !ctx.ext_sq.queue`isEmpty ) {
 				// drop the element from the queue
-				__external_io & ei = (__external_io&)drop( ctx.ext_sq.queue );
+				__external_io & ei = (__external_io&)try_pop_front( ctx.ext_sq.queue );
 
 				// submit it
Index: libcfa/src/concurrency/io/types.hfa
===================================================================
--- libcfa/src/concurrency/io/types.hfa	(revision 555af62e9161db43d53c22635e04d4d5edbb0662)
+++ libcfa/src/concurrency/io/types.hfa	(revision 9d47c1ff198f0f1775b2686ac233f78d06c5aedd)
@@ -24,10 +24,8 @@
 
 #include "bits/locks.hfa"
-#include "bits/queue.hfa"
 #include "iofwd.hfa"
 #include "kernel/fwd.hfa"
 
 #if defined(CFA_HAVE_LINUX_IO_URING_H)
-	#include "bits/sequence.hfa"
 	#include "monitor.hfa"
 
@@ -120,10 +118,10 @@
 	struct __outstanding_io {
 		// intrusive link fields
-		inline Colable;
+		inline dlink(__outstanding_io);
 
 		// primitive on which to block until the io is processed
 		oneshot waitctx;
 	};
-	static inline __outstanding_io *& Next( __outstanding_io * n ) { return (__outstanding_io *)Next( (Colable *)n ); }
+    P9_EMBEDDED( __outstanding_io, dlink(__outstanding_io) )
 
 	// queue of operations that are outstanding
@@ -134,5 +132,5 @@
 
 		// the actual queue
-		Queue(__outstanding_io) queue;
+		dlist(__outstanding_io) queue;
 
 		// volatile used to avoid the need for taking the lock if it's empty
Index: libcfa/src/concurrency/pthread.cfa
===================================================================
--- libcfa/src/concurrency/pthread.cfa	(revision 555af62e9161db43d53c22635e04d4d5edbb0662)
+++ libcfa/src/concurrency/pthread.cfa	(revision 9d47c1ff198f0f1775b2686ac233f78d06c5aedd)
@@ -20,7 +20,4 @@
 #include <errno.h>
 #include "locks.hfa"
-#include "bits/stack.hfa"
-#include "bits/sequence.hfa"
-
 
 #define check_nonnull(x) asm("": "+rm"(x)); if( x == 0p ) return EINVAL;
@@ -34,23 +31,14 @@
 
 struct pthread_values{
-	inline Seqable;
+	inline dlink(pthread_values);
 	void * value;
 	bool in_use;
 };
-
-static inline {
-	pthread_values *& Back( pthread_values * n ) {
-		return (pthread_values *)Back( (Seqable *)n );
-	}
-
-	pthread_values *& Next( pthread_values * n ) {
-		return (pthread_values *)Next( (Colable *)n );
-	}
-}
+P9_EMBEDDED( pthread_values, dlink(pthread_values) )
 
 struct pthread_keys {
 	bool in_use;
 	void (* destructor)( void * );
-	Sequence(pthread_values) threads;
+    dlist( pthread_values ) threads;
 };
 
@@ -78,13 +66,10 @@
 
 struct Pthread_kernel_threads{
-	inline Colable;
+	inline dlink(Pthread_kernel_threads);
 	processor p;
 };
-
-Pthread_kernel_threads *& Next( Pthread_kernel_threads * n ) {
-	return (Pthread_kernel_threads *)Next( (Colable *)n );
-}
-
-static Stack(Pthread_kernel_threads) cfa_pthreads_kernel_threads;
+P9_EMBEDDED( Pthread_kernel_threads, dlink(Pthread_kernel_threads) )
+
+static dlist(Pthread_kernel_threads) cfa_pthreads_kernel_threads;
 static bool cfa_pthreads_kernel_threads_zero = false;	// set to zero ?
 static int cfa_pthreads_no_kernel_threads = 1;	// number of kernel threads
@@ -231,5 +216,6 @@
 					key = &cfa_pthread_keys[i];
 					value->in_use = false;
-					remove(key->threads, *value);
+					remove(*value);
+
 					// if  a  key  value  has  a  non-NULL  destructor pointer,  and  the  thread  has  a  non-NULL  value associated with that key,
 					// the value of the key is set to NULL, and then the function pointed to is called with the previously associated value as its sole argument.
@@ -551,10 +537,15 @@
 
 		// Remove key from all threads with a value.
-		pthread_values& p;
-		Sequence(pthread_values)& head = cfa_pthread_keys[key].threads;
-		for ( SeqIter(pthread_values) iter = { head }; iter | p; ) {
-			remove(head, p);
-			p.in_use = false;
-		}
+		
+		// Sequence(pthread_values)& head = cfa_pthread_keys[key].threads;
+		// for ( SeqIter(pthread_values) iter = { head }; iter | p; ) {
+		// 	remove(head, p);
+		// 	p.in_use = false;
+		// }
+        pthread_values * p = &try_pop_front( cfa_pthread_keys[key].threads );
+        for ( ; p; ) {            
+            p->in_use = false;
+            p = &try_pop_front( cfa_pthread_keys[key].threads );
+        }
 		unlock(key_lock);
 		return 0;
@@ -585,5 +576,5 @@
 		if ( ! entry.in_use ) {
 			entry.in_use = true;
-			add(cfa_pthread_keys[key].threads, entry);
+			insert_last(cfa_pthread_keys[key].threads, entry);
 		} // if
 		entry.value = (void *)value;
@@ -612,7 +603,8 @@
 	//######################### Parallelism #########################
 	void pthread_delete_kernel_threads_() __THROW {	// see uMain::~uMain
-		Pthread_kernel_threads& p;
-		for ( StackIter(Pthread_kernel_threads) iter = {cfa_pthreads_kernel_threads}; iter | p; ) {
-			delete(&p);
+		Pthread_kernel_threads * p = &try_pop_front(cfa_pthreads_kernel_threads);
+		for ( ; p; ) {
+            delete(p);
+			p = &try_pop_front(cfa_pthreads_kernel_threads);
 		} // for
 	} // pthread_delete_kernel_threads_
@@ -631,8 +623,8 @@
 		lock( concurrency_lock );
 		for ( ; new_level > cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads += 1 ) { // add processors ?
-			push(cfa_pthreads_kernel_threads, *new() );
+			insert_last(cfa_pthreads_kernel_threads, *new() );
 		} // for
 		for ( ; new_level < cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads -= 1 ) { // remove processors ?
-			delete(&pop(cfa_pthreads_kernel_threads));
+			delete(&try_pop_front(cfa_pthreads_kernel_threads));
 		} // for
 		unlock( concurrency_lock );