Index: libcfa/src/bits/defs.hfa
===================================================================
--- libcfa/src/bits/defs.hfa	(revision b38b22f035325393f7aa86402ade7a3554e3fee1)
+++ libcfa/src/bits/defs.hfa	(revision 82f40635c8c9c43fc9988add0ddb506e3c987f1b)
@@ -31,6 +31,8 @@
 #ifdef __cforall
 #define __cfa_anonymous_object(x) inline struct x
+#define __cfa_dlink(x) inline dlink(x)
 #else
 #define __cfa_anonymous_object(x) struct x __cfa_anonymous_object
+#define __cfa_dlink(x) struct { struct x * next; struct x * back; } __dlink_substitute
 #endif
 
Index: libcfa/src/bits/weakso_locks.hfa
===================================================================
--- libcfa/src/bits/weakso_locks.hfa	(revision b38b22f035325393f7aa86402ade7a3554e3fee1)
+++ libcfa/src/bits/weakso_locks.hfa	(revision 82f40635c8c9c43fc9988add0ddb506e3c987f1b)
@@ -21,4 +21,5 @@
 #include "bits/sequence.hfa"
 #include "bits/containers.hfa"
+#include "containers/list.hfa"
 
 struct $thread;
@@ -31,5 +32,5 @@
 
 	// List of blocked threads
-	Sequence( $thread ) blocked_threads;
+	dlist( $thread ) blocked_threads;
 
 	// Count of current blocked threads
Index: libcfa/src/concurrency/invoke.h
===================================================================
--- libcfa/src/concurrency/invoke.h	(revision b38b22f035325393f7aa86402ade7a3554e3fee1)
+++ libcfa/src/concurrency/invoke.h	(revision 82f40635c8c9c43fc9988add0ddb506e3c987f1b)
@@ -20,4 +20,5 @@
 
 #ifdef __cforall
+#include "containers/list.hfa"
 extern "C" {
 #endif
@@ -196,4 +197,7 @@
 		} seqable;
 
+		// used to put threads on dlist data structure
+		__cfa_dlink($thread);
+
 		struct {
 			struct $thread * next;
@@ -207,4 +211,7 @@
 		#endif
 	};
+	#ifdef __cforall
+		P9_EMBEDDED( $thread, dlink($thread) )
+	#endif
 	// Wrapper for gdb
 	struct cfathread_thread_t { struct $thread debug; };
@@ -236,5 +243,5 @@
 
 		static inline $thread *& Next( $thread * this ) __attribute__((const)) {
-			return this->seqable.next;
+				return this->seqable.next;
 		}
 
Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision b38b22f035325393f7aa86402ade7a3554e3fee1)
+++ libcfa/src/concurrency/locks.cfa	(revision 82f40635c8c9c43fc9988add0ddb506e3c987f1b)
@@ -27,6 +27,6 @@
 forall(L & | is_blocking_lock(L)) {
 	struct info_thread {
-		// used to put info_thread on a dl queue (aka sequence)
-		inline Seqable;
+		// used to put info_thread on a dl queue
+		inline dlink(info_thread(L));
 
 		// waiting thread
@@ -42,7 +42,7 @@
 		bool signalled;
 	};
+	P9_EMBEDDED( info_thread(L), dlink(info_thread(L)) )
 
 	void ?{}( info_thread(L) & this, $thread * t, uintptr_t info, L * l ) {
-		((Seqable &) this){};
 		this.t = t;
 		this.info = info;
@@ -51,12 +51,4 @@
 
 	void ^?{}( info_thread(L) & this ) {}
-
-	info_thread(L) *& Back( info_thread(L) * this ) {
-		return (info_thread(L) *)Back( (Seqable *)this );
-	}
-
-	info_thread(L) *& Next( info_thread(L) * this ) {
-		return (info_thread(L) *)Next( (Colable *)this );
-	}
 }
 
@@ -85,5 +77,5 @@
 	// lock is held by some other thread
 	if ( owner != 0p && owner != thrd ) {
-		addTail( blocked_threads, *thrd );
+		insert_last( blocked_threads, *thrd );
 		wait_count++;
 		unlock( lock );
@@ -124,5 +116,5 @@
 
 void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
-	$thread * t = &dropHead( blocked_threads );
+	$thread * t = &try_pop_front( blocked_threads );
 	owner = t;
 	recursion_count = ( t ? 1 : 0 );
@@ -153,5 +145,5 @@
 	// lock held
 	if ( owner != 0p ) {
-		addTail( blocked_threads, *t );
+		insert_last( blocked_threads, *t );
 		wait_count++;
 		unlock( lock );
@@ -206,8 +198,8 @@
 		// 	may still be called after a thread has been removed from the queue but
 		// 	before the alarm is unregistered
-		if ( listed(info_thd) ) {	// is thread on queue
+		if ( (*info_thd)`isListed ) {	// is thread on queue
 			info_thd->signalled = false;
 			// remove this thread O(1)
-			remove( cond->blocked_threads, *info_thd );
+			remove( *info_thd );
 			cond->count--;
 			if( info_thd->lock ) {
@@ -254,6 +246,6 @@
 	bool notify_one( condition_variable(L) & this ) with( this ) {
 		lock( lock __cfaabi_dbg_ctx2 );
-		bool ret = !empty(blocked_threads);
-		process_popped(this, dropHead( blocked_threads ));
+		bool ret = ! blocked_threads`isEmpty;
+		process_popped(this, try_pop_front( blocked_threads ));
 		unlock( lock );
 		return ret;
@@ -262,7 +254,7 @@
 	bool notify_all( condition_variable(L) & this ) with(this) {
 		lock( lock __cfaabi_dbg_ctx2 );
-		bool ret = !empty(blocked_threads);
-		while( !empty(blocked_threads) ) {
-			process_popped(this, dropHead( blocked_threads ));
+		bool ret = ! blocked_threads`isEmpty;
+		while( ! blocked_threads`isEmpty ) {
+			process_popped(this, try_pop_front( blocked_threads ));
 		}
 		unlock( lock );
@@ -271,10 +263,10 @@
 
 	uintptr_t front( condition_variable(L) & this ) with(this) {
-		return empty(blocked_threads) ? NULL : head(blocked_threads).info;
+		return blocked_threads`isEmpty ? NULL : blocked_threads`first.info;
 	}
 
 	bool empty( condition_variable(L) & this ) with(this) {
 		lock( lock __cfaabi_dbg_ctx2 );
-		bool ret = empty(blocked_threads);
+		bool ret = blocked_threads`isEmpty;
 		unlock( lock );
 		return ret;
@@ -285,5 +277,5 @@
 	size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
 		// add info_thread to waiting queue
-		addTail( blocked_threads, *i );
+		insert_last( blocked_threads, *i );
 		count++;
 		size_t recursion_count = 0;
Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision b38b22f035325393f7aa86402ade7a3554e3fee1)
+++ libcfa/src/concurrency/locks.hfa	(revision 82f40635c8c9c43fc9988add0ddb506e3c987f1b)
@@ -21,4 +21,5 @@
 #include "bits/weakso_locks.hfa"
 #include "containers/queueLockFree.hfa"
+#include "containers/list.hfa"
 
 #include "thread.hfa"
@@ -40,6 +41,6 @@
 
 static inline bool P(Semaphore0nary & this, $thread * thrd) {
-	/* paranoid */ verify(!(thrd->seqable.next));
-	/* paranoid */ verify(!(thrd`next));
+	/* paranoid */ verify(!thrd`next);
+	/* paranoid */ verify(!(&(*thrd)`next));
 
 	push(this.queue, thrd);
@@ -250,13 +251,13 @@
 
 //-----------------------------------------------------------------------------
-// info_thread
-// the info thread is a wrapper around a thread used
-// to store extra data for use in the condition variable
+// // info_thread
+// // the info thread is a wrapper around a thread used
+// // to store extra data for use in the condition variable
 forall(L & | is_blocking_lock(L)) {
 	struct info_thread;
 
-	// for use by sequence
-	info_thread(L) *& Back( info_thread(L) * this );
-	info_thread(L) *& Next( info_thread(L) * this );
+	// // for use by sequence
+	// info_thread(L) *& Back( info_thread(L) * this );
+	// info_thread(L) *& Next( info_thread(L) * this );
 }
 
@@ -269,9 +270,10 @@
 
 		// List of blocked threads
-		Sequence( info_thread(L) ) blocked_threads;
+		dlist( info_thread(L) ) blocked_threads;
 
 		// Count of current blocked threads
 		int count;
 	};
+	
 
 	void  ?{}( condition_variable(L) & this );