Index: libcfa/src/bits/queue.hfa
===================================================================
--- libcfa/src/bits/queue.hfa	(revision 27b1ca17f81ccc20c840eef940088ae8724aaa3d)
+++ libcfa/src/bits/queue.hfa	(revision c74e60192ab933411aa2834a374ef0049feae8ea)
@@ -11,6 +11,6 @@
 	inline {
 		// wrappers to make Collection have T
-		T * head( Queue(T) & q ) with( q ) {
-			return (T *)head( (Collection &)q );
+		T & head( Queue(T) & q ) with( q ) {
+			return *(T *)head( (Collection &)q );
 		} // post: empty() & head() == 0 | !empty() & head() in *q
 
@@ -23,69 +23,69 @@
 		} // post: empty()
 
-		T * tail( Queue(T) & q ) with( q ) {
-			return last;
+		T & tail( Queue(T) & q ) with( q ) {
+			return *last;
 		}
 
-		T * succ( Queue(T) & q, T * n ) with( q ) {		// pre: *n in *q
+		T & succ( Queue(T) & q, T & n ) with( q ) {		// pre: *n in *q
 #ifdef __CFA_DEBUG__
-			if ( ! listed( n ) ) abort( "(Queue &)%p.succ( %p ) : Node is not on a list.", &q, n );
+			if ( ! listed( &n ) ) abort( "(Queue &)%p.succ( %p ) : Node is not on a list.", &q, &n );
 #endif // __CFA_DEBUG__
-			return (Next( n ) == n) ? 0p : Next( n );
+			return (Next( &n ) == &n) ? *0p : *Next( &n );
 		} // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *q
 
-		void addHead( Queue(T) & q, T * n ) with( q ) {
+		void addHead( Queue(T) & q, T & n ) with( q ) {
 #ifdef __CFA_DEBUG__
-			if ( listed( n ) ) abort( "(Queue &)%p.addHead( %p ) : Node is already on another list.", &q, n );
+			if ( listed( &n ) ) abort( "(Queue &)%p.addHead( %p ) : Node is already on another list.", &q, &n );
 #endif // __CFA_DEBUG__
 			if ( last ) {
-				Next( n ) = head( q );
-				q.root = n;
+				Next( &n ) = &head( q );
+				q.root = &n;
 			} else {
-				root = last = n;
-				Next( n ) = n;							// last node points to itself
+				root = last = &n;
+				Next( &n ) = &n;							// last node points to itself
 			}
 		}
 
-		void addTail( Queue(T) & q, T * n ) with( q ) {
+		void addTail( Queue(T) & q, T & n ) with( q ) {
 #ifdef __CFA_DEBUG__
-			if ( listed( n ) ) abort( "(Queue &)%p.addTail( %p ) : Node is already on another list.", &q, n );
+			if ( listed( &n ) ) abort( "(Queue &)%p.addTail( %p ) : Node is already on another list.", &q, &n );
 #endif // __CFA_DEBUG__
-			if ( last ) Next( last ) = n;
-			else root = n;
-			last = n;
-			Next( n ) = n;								// last node points to itself
+			if ( last ) Next( last ) = &n;
+			else root = &n;
+			last = &n;
+			Next( &n ) = &n;								// last node points to itself
 		}
 
-		void add( Queue(T) & q, T * n ) with( q ) {
+		void add( Queue(T) & q, T & n ) with( q ) {
 			addTail( q, n );
 		}
 
-		T * dropHead( Queue(T) & q ) with( q ) {
-			T * t = head( q );
+		T & dropHead( Queue(T) & q ) with( q ) {
+			T * t = &head( q );
 			if ( root ) {
 				root = Next( root );
-				if ( head( q ) == t ) {
+				if ( &head( q ) == t ) {
 					root = last = 0p;					// only one element
 				}
 				Next( t ) = 0p;
 			}
-			return t;
+			return *t;
 		}
 
-		T * drop( Queue(T) & q ) with( q ) {
+		T & drop( Queue(T) & q ) with( q ) {
 			return dropHead( q );
 		}
 
-		void remove( Queue(T) & q, T * n ) with( q ) {	// O(n)
+		void remove( Queue(T) & q, T & n ) with( q ) {	// O(n)
 #ifdef __CFA_DEBUG__
-			if ( ! listed( (Colable &)(*n) ) ) abort( "(Queue &)%p.remove( %p ) : Node is not on a list.", &q, n );
+			if ( ! listed( (Colable &)n ) ) abort( "(Queue &)%p.remove( %p ) : Node is not on a list.", &q, &n );
 #endif // __CFA_DEBUG__
 			T * prev = 0;
 			T * curr = (T *)root;
 			for ( ;; ) {
-				if (n == curr) {						// found => remove
-					if ((T *)root == n) {
+				if (&n == curr) {						// found => remove
+					if ((T *)root == &n) {
 						dropHead( q );
-					} else if (last == n) {
+					} else if (last == &n) {
 						last = prev;
 						Next( last ) = last;
@@ -93,10 +93,10 @@
 						Next( prev ) = Next( curr );
 					}
-					Next( n ) = 0p;
+					Next( &n ) = 0p;
 					break;
 				}
 #ifdef __CFA_DEBUG__
 				// not found => error
-				if (curr == last) abort( "(Queue &)%p.remove( %p ) : Node is not in list.", &q, n );
+				if (curr == last) abort( "(Queue &)%p.remove( %p ) : Node is not in list.", &q, &n );
 #endif // __CFA_DEBUG__
 				prev = curr;
@@ -105,7 +105,7 @@
 		} // post: ! listed( n )
 
-		T * dropTail( Queue(T) & q ) with( q ) { // O(n)
-			T * n = tail( q );
-			return n ? remove( q, n ), n : 0p;
+		T & dropTail( Queue(T) & q ) with( q ) { // O(n)
+			T & n = tail( q );
+			return &n ? remove( q, n ), n : *0p;
 		}
 
@@ -116,5 +116,5 @@
 				root = from.root;
 			} else {									// "to" list not empty
-				Next( last ) = head( from );
+				Next( last ) = &head( from );
 			}
 			last = from.last;
@@ -124,16 +124,16 @@
 		// Transfer the "from" list up to node "n" to the end of queue list; the "from" list becomes the list after node "n".
 		// Node "n" must be in the "from" list.
-		void split( Queue(T) & q, Queue(T) & from, T * n ) with( q ) {
+		void split( Queue(T) & q, Queue(T) & from, T & n ) with( q ) {
 #ifdef __CFA_DEBUG__
-			if ( ! listed( (Colable &)(*n) ) ) abort( "(Queue &)%p.split( %p ) : Node is not on a list.", &q, n );
+			if ( ! listed( (Colable &)n ) ) abort( "(Queue &)%p.split( %p ) : Node is not on a list.", &q, &n );
 #endif // __CFA_DEBUG__
 			Queue(T) to;
 			to.root = from.root;						// start of "to" list
-			to.last = n;								// end of "to" list
-			from.root = Next( n );						// start of "from" list
-			if ( n == head( from ) ) {					// last node in list ?
+			to.last = &n;								// end of "to" list
+			from.root = Next( &n );						// start of "from" list
+			if ( &n == &head( from ) ) {					// last node in list ?
 				from.root = from.last = 0p;				// mark "from" list empty
 			} else {
-				Next( n ) = n;							// fix end of "to" list
+				Next( &n ) = &n;							// fix end of "to" list
 			}
 			transfer( q, to );
@@ -154,14 +154,14 @@
 		// create an iterator active in Queue q
 		void ?{}( QueueIter(T) & qi, Queue(T) & q ) with( qi ) {
-			curr = head( q );
+			curr = &head( q );
 		} // post: curr = {e in q}
 
-		void ?{}( QueueIter(T) & qi, T * start ) with( qi ) {
-			curr = start;
+		void ?{}( QueueIter(T) & qi, T & start ) with( qi ) {
+			curr = &start;
 		} // post: curr = {e in q}
 
 		// make existing iterator active in Queue q
 		void over( QueueIter(T) & qi, Queue(T) & q ) with( qi ) {
-			curr = head( q );
+			curr = &head( q );
 		} // post: curr = {e in q}
 
Index: libcfa/src/bits/queue_example.cfa
===================================================================
--- libcfa/src/bits/queue_example.cfa	(revision 27b1ca17f81ccc20c840eef940088ae8724aaa3d)
+++ libcfa/src/bits/queue_example.cfa	(revision c74e60192ab933411aa2834a374ef0049feae8ea)
@@ -27,5 +27,5 @@
 	
 	for ( i; 10 ) {
-		add( fred, new( 2 * i ) );
+		add( fred, *new( 2 * i ) );
 	}
 
@@ -36,5 +36,5 @@
 
 	for ( i; 9 ) {
-		delete( drop( fred ) );
+		delete( &drop( fred ) );
 	}
 
@@ -45,5 +45,5 @@
 	
 	for ( i; 10 ) {
-		add( fred, new( 2 * i + 1 ) );
+		add( fred, *new( 2 * i + 1 ) );
 	}
 	for ( over( fredIter, fred ); fredIter >> f; ) {
@@ -78,5 +78,5 @@
 	
 	for ( i; 10 ) {
-		add( mary, new( 2 * i ) );
+		add( mary, *new( 2 * i ) );
 	}
 
@@ -87,5 +87,5 @@
 	
 	for ( i; 9 ) {
-		delete( drop( mary ) );
+		delete( &drop( mary ) );
 	}
 
@@ -96,5 +96,5 @@
 	
 	for ( i; 10 ) {
-		add( mary, new( 2 * i + 1 ) );
+		add( mary, *new( 2 * i + 1 ) );
 	}
 	for ( over( maryIter, mary ); maryIter >> m; ) {
Index: libcfa/src/bits/sequence.hfa
===================================================================
--- libcfa/src/bits/sequence.hfa	(revision 27b1ca17f81ccc20c840eef940088ae8724aaa3d)
+++ libcfa/src/bits/sequence.hfa	(revision c74e60192ab933411aa2834a374ef0049feae8ea)
@@ -2,4 +2,6 @@
 
 #include "collection.hfa"
+#include <stdlib.hfa>
+#include <stdio.h>
 
 struct Seqable {
@@ -14,6 +16,6 @@
 	} // post: ! listed()
 
-	Seqable * getBack( Seqable & sq ) with( sq ) {
-		return back;
+	Seqable & getBack( Seqable & sq ) with( sq ) {
+		return *back;
 	}
 
@@ -30,6 +32,6 @@
 	inline {
 		// wrappers to make Collection have T
-		T * head( Sequence(T) & s ) with( s ) {
-			return (T *)head( (Collection &)s );
+		T & head( Sequence(T) & s ) with( s ) {
+			return *(T *)head( (Collection &)s );
 		} // post: empty() & head() == 0 | !empty() & head() in *s
 
@@ -47,21 +49,21 @@
 		// Return a pointer to the last sequence element, without removing it.	
 		T & tail( Sequence(T) & s ) with( s ) {
-			return root ? (T &)Back( head( s ) ) : *0p;	// needs cast?
-		}	// post: empty() & tail() == 0 | !empty() & tail() in *s
+			return root ? (T &)*Back( &head( s ) ) : *0p;
+		}	// post: empty() & tail() == 0 | !empty() & tail() in *s\
 
 		// Return a pointer to the element after *n, or 0p if there isn't one.
-		T * succ( Sequence(T) & s, T * n ) with( s ) {	// pre: *n in *s
-#ifdef __CFA_DEBUG__
-			if ( ! listed( n ) ) abort( "(Sequence &)%p.succ( %p ) : Node is not on a list.", &s, n );
-#endif // __CFA_DEBUG__
-			return Next( n ) == head( s ) ? 0p : Next( n );
+		T & succ( Sequence(T) & s, T & n ) with( s ) {	// pre: *n in *s
+#ifdef __CFA_DEBUG__
+			if ( ! listed( &n ) ) abort( "(Sequence &)%p.succ( %p ) : Node is not on a list.", &s, &n );
+#endif // __CFA_DEBUG__
+			return Next( &n ) == &head( s ) ? *0p : *Next( &n );
 		}	// post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *s
 
 		// Return a pointer to the element before *n, or 0p if there isn't one.
-		T * pred( Sequence(T) & s, T * n ) with( s ) {	// pre: *n in *s
-#ifdef __CFA_DEBUG__
-			if ( ! listed( n ) ) abort( "(Sequence &)%p.pred( %p ) : Node is not on a list.", &s, n );
-#endif // __CFA_DEBUG__
-			return n == head( s ) ? 0p : Back( n );
+		T & pred( Sequence(T) & s, T & n ) with( s ) {	// pre: *n in *s
+#ifdef __CFA_DEBUG__
+			if ( ! listed( &n ) ) abort( "(Sequence &)%p.pred( %p ) : Node is not on a list.", &s, &n );
+#endif // __CFA_DEBUG__
+			return &n == &head( s ) ? *0p : *Back( &n );
 		}	// post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
 
@@ -72,11 +74,11 @@
 			if ( listed( &n ) ) abort( "(Sequence &)%p.insertBef( %p, %p ) : Node is already on another list.", &s, n, &bef );
 #endif // __CFA_DEBUG__
-			if ( &bef == head( s ) ) {					// must change root
+			if ( &bef == &head( s ) ) {					// must change root
 				if ( root ) {
-					Next( &n ) = head( s );
-					Back( &n ) = Back( head( s ) );
+					Next( &n ) = &head( s );
+					Back( &n ) = Back( &head( s ) );
 					// inserted node must be consistent before it is seen
 					asm( "" : : : "memory" );			// prevent code movement across barrier
-					Back( head( s ) ) = &n;
+					Back( &head( s ) ) = &n;
 					Next( Back( &n ) ) = &n;
 				} else {
@@ -88,5 +90,5 @@
 				root = &n;
 			} else {
-				if ( ! &bef ) &bef = head( s );
+				if ( ! &bef ) &bef = &head( s );
 				Next( &n ) = &bef;
 				Back( &n ) = Back( &bef );
@@ -106,9 +108,9 @@
 			if ( ! &aft ) {								// must change root
 				if ( root ) {
-					Next( &n ) = head( s );
-					Back( &n ) = Back( head( s ) );
+					Next( &n ) = &head( s );
+					Back( &n ) = Back( &head( s ) );
 					// inserted node must be consistent before it is seen
 					asm( "" : : : "memory" );			// prevent code movement across barrier
-					Back( head( s ) ) = &n;
+					Back( &head( s ) ) = &n;
 					Next( Back( &n ) ) = &n;
 				} else {
@@ -133,7 +135,7 @@
 			if ( ! listed( &n ) ) abort( "(Sequence &)%p.remove( %p ) : Node is not on a list.", &s, &n );
 #endif // __CFA_DEBUG__
-			if ( &n == head( s ) ) {
-				if ( Next( head( s ) ) == head( s ) ) root = 0p;
-				else root = Next( head(s ) );
+			if ( &n == &head( s ) ) {
+				if ( Next( &head( s ) ) == &head( s ) ) root = 0p;
+				else root = Next( &head(s ) );
 			} // if
 			Back( Next( &n ) ) = Back( &n );
@@ -156,6 +158,6 @@
 		// Remove and return the head element in the sequence.
 		T & dropHead( Sequence(T) & s ) {
-			T * n = head( s );
-			return n ? remove( s, *n ), *n : *0p;
+			T & n = head( s );
+			return &n ? remove( s, n ), n : *0p;
 		}
 		// Remove and return the head element in the sequence.
@@ -175,10 +177,10 @@
 				root = from.root;
 			} else {									// "to" list not empty
-				T * toEnd = Back( head( s ) );
-				T * fromEnd = Back( head( from ) );
+				T * toEnd = Back( &head( s ) );
+				T * fromEnd = Back( &head( from ) );
 				Back( root ) = fromEnd;
-				Next( fromEnd ) = head( s );
+				Next( fromEnd ) = &head( s );
 				Back( from.root ) = toEnd;
-				Next( toEnd ) = head( from );
+				Next( toEnd ) = &head( from );
 			} // if
 			from.root = 0p;								// mark "from" list empty
@@ -187,18 +189,18 @@
 		// Transfer the "from" list up to node "n" to the end of s list; the "from" list becomes the sequence after node "n".
 		// Node "n" must be in the "from" list.
-		void split( Sequence(T) & s, Sequence(T) & from, T * n ) with( s ) {
-#ifdef __CFA_DEBUG__
-			if ( ! listed( n ) ) abort( "(Sequence &)%p.split( %p ) : Node is not on a list.", &s, n );
+		void split( Sequence(T) & s, Sequence(T) & from, T & n ) with( s ) {
+#ifdef __CFA_DEBUG__
+			if ( ! listed( &n ) ) abort( "(Sequence &)%p.split( %p ) : Node is not on a list.", &s, &n );
 #endif // __CFA_DEBUG__
 			Sequence(T) to;
 			to.root = from.root;						// start of "to" list
-			from.root = Next( n );						// start of "from" list
+			from.root = Next( &n );						// start of "from" list
 			if ( to.root == from.root ) {				// last node in list ?
 				from.root = 0p;							// mark "from" list empty
 			} else {
-				Back( head( from ) ) = Back( head( to ) ); // fix "from" list
-		 		Next( Back( head( to ) ) ) = head( from );
-				Next( n ) = head( to );					// fix "to" list
-				Back( head( to ) ) = n;
+				Back( &head( from ) ) = Back( &head( to ) ); // fix "from" list
+		 		Next( Back( &head( to ) ) ) = &head( from );
+				Next( &n ) = &head( to );					// fix "to" list
+				Back( &head( to ) ) = &n;
 			} // if
 			transfer( s, to );
@@ -223,10 +225,10 @@
 			((ColIter &) si){};
 			seq = &s;
-			curr = head( s );
+			curr = &head( s );
 		} // post: elts = null.
 		
 		void over( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
 			seq = &s;
-			curr = head( s );
+			curr = &head( s );
 		} // post: elts = {e in s}.
 
@@ -234,6 +236,6 @@
 			if ( curr ) {
 				&tp = Curr( si );
-				T * n = succ( *seq, Curr( si ) );
-				curr = n == head( *seq ) ? 0p : n;
+				T * n = &succ( *seq, *Curr( si ) );
+				curr = n == &head( *seq ) ? 0p : n;
 			} else &tp = 0p;
 			return &tp != 0p;
@@ -268,5 +270,5 @@
 			if ( curr ) {
 				&tp = Curr( si );
-				T * n = pred( *seq, Curr( si ) );
+				T * n = &pred( *seq, *Curr( si ) );
 				curr = n == &tail( *seq ) ? 0p : n;
 			} else &tp = 0p;
Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision 27b1ca17f81ccc20c840eef940088ae8724aaa3d)
+++ libcfa/src/concurrency/locks.cfa	(revision c74e60192ab933411aa2834a374ef0049feae8ea)
@@ -11,6 +11,8 @@
 //// info_thread
 ///////////////////////////////////////////////////////////////////
+
 forall(dtype L | is_blocking_lock(L)) {
 	void ?{}( info_thread(L) & this, $thread * t ) {
+		((Seqable &) this){};
 		this.t = t;
 		this.lock = 0p;
@@ -19,4 +21,5 @@
 
 	void ?{}( info_thread(L) & this, $thread * t, uintptr_t info ) {
+		((Seqable &) this){};
 		this.t = t;
 		this.info = info;
@@ -25,12 +28,7 @@
 	}
 
-	void ^?{}( info_thread(L) & this ){
-		// default
-	}
-
-	info_thread(L) *& get_next( info_thread(L) & this ) {
-		return this.next;
-	}
-}
+	void ^?{}( info_thread(L) & this ){ }
+}
+
 ///////////////////////////////////////////////////////////////////
 //// Blocking Locks
@@ -47,37 +45,16 @@
 }
 
-void ^?{}( blocking_lock & this ) {
-	// default
-}
-
-void ?{}( single_acquisition_lock & this ) {
-	((blocking_lock &)this){ false, false };
-}
-
-void ^?{}( single_acquisition_lock & this ) {
-	// default
-}
-
-void ?{}( owner_lock & this ) {
-	((blocking_lock &)this){ true, true };
-}
-
-void ^?{}( owner_lock & this ) {
-	// default
-}
-
-void ?{}( multiple_acquisition_lock & this ) {
-	((blocking_lock &)this){ true, false };
-}
-
-void ^?{}( multiple_acquisition_lock & this ) {
-	// default
-}
+void ^?{}( blocking_lock & this ) {}
+void ?{}( single_acquisition_lock & this ) {((blocking_lock &)this){ false, false };}
+void ^?{}( single_acquisition_lock & this ) {}
+void ?{}( owner_lock & this ) {((blocking_lock &)this){ true, true };}
+void ^?{}( owner_lock & this ) {}
+void ?{}( multiple_acquisition_lock & this ) {((blocking_lock &)this){ true, false };}
+void ^?{}( multiple_acquisition_lock & this ) {}
 
 void lock( blocking_lock & this ) with( this ) {
 	lock( lock __cfaabi_dbg_ctx2 );
 	if ( owner == active_thread() && !multi_acquisition) {
-		fprintf(stderr, "A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock."); // Possibly throw instead
-    	exit(EXIT_FAILURE);
+		abort("A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock.");
 	} else if ( owner != 0p && owner != active_thread() ) {
 		append( blocked_threads, active_thread() );
@@ -110,20 +87,26 @@
 }
 
+void unlock_error_check( blocking_lock & this ) with( this ) {
+	if ( owner == 0p ){ // no owner implies lock isn't held
+		abort( "There was an attempt to release a lock that isn't held" ); 
+	} else if ( strict_owner && owner != active_thread() ) {
+		abort( "A thread other than the owner attempted to release an owner lock" ); 
+	}
+}
+
+void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
+	$thread * t = pop_head( blocked_threads );
+	owner = t;
+	recursion_count = ( t ? 1 : 0 );
+	wait_count--;
+	unpark( t );
+}
+
 void unlock( blocking_lock & this ) with( this ) {
 	lock( lock __cfaabi_dbg_ctx2 );
-	if ( owner == 0p ){ // no owner implies lock isn't held
-		fprintf( stderr, "There was an attempt to release a lock that isn't held" ); 
-		return;
-	} else if ( strict_owner && owner != active_thread() ) {
-		fprintf( stderr, "A thread other than the owner attempted to release an owner lock" ); 
-		return;
-	}
+	unlock_error_check( this );
 	recursion_count--;
 	if ( recursion_count == 0 ) {
-		$thread * thrd = pop_head( blocked_threads );
-		owner = thrd;
-		recursion_count = ( thrd ? 1 : 0 );
-		wait_count--;
-		unpark( thrd );
+		pop_and_set_new_owner( this );
 	}
 	unlock( lock );
@@ -133,5 +116,4 @@
 	return wait_count;
 }
-
 
 void set_recursion_count( blocking_lock & this, size_t recursion ) with( this ) {
@@ -152,7 +134,4 @@
 		owner = t;
 		recursion_count = 1;
-		#if !defined( __CFA_NO_STATISTICS__ )
-			//kernelTLS.this_stats = t->curr_cluster->stats;
-		#endif
 		unpark( t );
 		unlock( lock );
@@ -162,15 +141,6 @@
 void remove_( blocking_lock & this ) with( this ) {
     lock( lock __cfaabi_dbg_ctx2 );
-	if ( owner == 0p ){ // no owner implies lock isn't held
-		fprintf( stderr, "A lock that is not held was passed to a synchronization lock" ); 
-	} else if ( strict_owner && owner != active_thread() ) {
-		fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" ); 
-	} else {
-		$thread * thrd = pop_head( blocked_threads );
-		owner = thrd;
-		recursion_count = ( thrd ? 1 : 0 );
-		wait_count--;
-		unpark( thrd );
-	}
+	unlock_error_check( this );
+	pop_and_set_new_owner( this );
 	unlock( lock );
 }
@@ -182,75 +152,24 @@
 // This is temporary until an inheritance bug is fixed
 
-void lock( single_acquisition_lock & this ){
-	lock( (blocking_lock &)this );
-}
-
-void unlock( single_acquisition_lock & this ){
-	unlock( (blocking_lock &)this );
-}
-
-void add_( single_acquisition_lock & this, struct $thread * t ){
-	add_( (blocking_lock &)this, t );
-}
-
-void remove_( single_acquisition_lock & this ){
-	remove_( (blocking_lock &)this );
-}
-
-void set_recursion_count( single_acquisition_lock & this, size_t recursion ){
-	set_recursion_count( (blocking_lock &)this, recursion );
-}
-
-size_t get_recursion_count( single_acquisition_lock & this ){
-	return get_recursion_count( (blocking_lock &)this );
-}
-
-void lock( owner_lock & this ){
-	lock( (blocking_lock &)this );
-}
-
-void unlock( owner_lock & this ){
-	unlock( (blocking_lock &)this );
-}
-
-void add_( owner_lock & this, struct $thread * t ){
-	add_( (blocking_lock &)this, t );
-}
-
-void remove_( owner_lock & this ){
-	remove_( (blocking_lock &)this );
-}
-
-void set_recursion_count( owner_lock & this, size_t recursion ){
-	set_recursion_count( (blocking_lock &)this, recursion );
-}
-
-size_t get_recursion_count( owner_lock & this ){
-	return get_recursion_count( (blocking_lock &)this );
-}
-
-void lock( multiple_acquisition_lock & this ){
-	lock( (blocking_lock &)this );
-}
-
-void unlock( multiple_acquisition_lock & this ){
-	unlock( (blocking_lock &)this );
-}
-
-void add_( multiple_acquisition_lock & this, struct $thread * t ){
-	add_( (blocking_lock &)this, t );
-}
-
-void remove_( multiple_acquisition_lock & this ){
-	remove_( (blocking_lock &)this );
-}
-
-void set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){
-	set_recursion_count( (blocking_lock &)this, recursion );
-}
-
-size_t get_recursion_count( multiple_acquisition_lock & this ){
-	return get_recursion_count( (blocking_lock &)this );
-}
+void lock( single_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
+void unlock( single_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
+void add_( single_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
+void remove_( single_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
+void set_recursion_count( single_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
+size_t get_recursion_count( single_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
+
+void lock( owner_lock & this ){ lock( (blocking_lock &)this ); }
+void unlock( owner_lock & this ){ unlock( (blocking_lock &)this ); }
+void add_( owner_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
+void remove_( owner_lock & this ){ remove_( (blocking_lock &)this ); }
+void set_recursion_count( owner_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
+size_t get_recursion_count( owner_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
+
+void lock( multiple_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
+void unlock( multiple_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
+void add_( multiple_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
+void remove_( multiple_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
+void set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
+size_t get_recursion_count( multiple_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
 
 ///////////////////////////////////////////////////////////////////
@@ -263,15 +182,13 @@
     	// This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
 	    lock( cond->lock __cfaabi_dbg_ctx2 );
-	    if ( (*i)->listed ) {			// is thread on queue
-	    	info_thread(L) * copy = *i;
-			remove( cond->blocked_threads, i );		 //remove this thread O(1)
+	    
+	    if ( i->listed ) {			// is thread on queue
+	    	cond->last_thread = i;		// REMOVE THIS AFTER DEBUG
+			remove( cond->blocked_threads, *i );		 //remove this thread O(1)
 			cond->count--;
-			if( !copy->lock ) {
-				#if !defined( __CFA_NO_STATISTICS__ )
-					//kernelTLS.this_stats = copy->t->curr_cluster->stats;
-				#endif
-				unpark( copy->t );
+			if( !i->lock ) {
+				unpark( i->t );
 	    	} else {
-	    		add_(*copy->lock, copy->t);			// call lock's add_
+	    		add_(*i->lock, i->t);			// call lock's add_
 	    	}
 	    }
@@ -279,7 +196,5 @@
 	}
 
-	void alarm_node_wrap_cast( alarm_node_t & a ) {
-		timeout_handler( (alarm_node_wrap(L) &)a );
-	}
+	void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }
 
 	void ?{}( condition_variable(L) & this ){
@@ -287,9 +202,8 @@
 		this.blocked_threads{};
 		this.count = 0;
-	}
-
-	void ^?{}( condition_variable(L) & this ){
-		// default
-	}
+		this.last_thread = 0p; // REMOVE AFTER DEBUG
+	}
+
+	void ^?{}( condition_variable(L) & this ){ }
 
 	void ?{}( alarm_node_wrap(L) & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback ) {
@@ -297,21 +211,22 @@
 	}
 
-	void ^?{}( alarm_node_wrap(L) & this ) {
-		// default
+	void ^?{}( alarm_node_wrap(L) & this ) { }
+
+	void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
+		if(&popped != 0p) {
+			popped.listed = false;
+			count--;
+			if (popped.lock) {
+				add_(*popped.lock, popped.t);
+			} else {
+				unpark(popped.t);
+			}
+		}
 	}
 
 	bool notify_one( condition_variable(L) & this ) with( this ) {
 		lock( lock __cfaabi_dbg_ctx2 );
-		bool ret = !!blocked_threads;
-		info_thread(L) * popped = pop_head( blocked_threads );
-		if(popped != 0p) {
-			popped->listed = false;
-			count--;
-			if (popped->lock) {
-				add_(*popped->lock, popped->t);
-			} else {
-				unpark(popped->t);
-			}
-		}
+		bool ret = !empty(blocked_threads);
+		process_popped(this, dropHead( blocked_threads ));
 		unlock( lock );
 		return ret;
@@ -320,16 +235,7 @@
 	bool notify_all( condition_variable(L) & this ) with(this) {
 		lock( lock __cfaabi_dbg_ctx2 );
-		bool ret = blocked_threads ? true : false;
-		while( blocked_threads ) {
-			info_thread(L) * popped = pop_head( blocked_threads );
-			if(popped != 0p){
-				popped->listed = false;
-				count--;
-				if (popped->lock) {
-					add_(*popped->lock, popped->t);
-				} else {
-					unpark(popped->t);
-				}
-			}
+		bool ret = !empty(blocked_threads);
+		while( !empty(blocked_threads) ) {
+			process_popped(this, dropHead( blocked_threads ));
 		}
 		unlock( lock );
@@ -338,31 +244,30 @@
 
 	uintptr_t front( condition_variable(L) & this ) with(this) {
-		if(!blocked_threads) return NULL;
-		return peek(blocked_threads)->info;
-	}
-
-	bool empty( condition_variable(L) & this ) with(this) {
-		return blocked_threads ? false : true;
-	}
-
-	int counter( condition_variable(L) & this ) with(this) {
-		return count;
-	}
-
-	// helper for wait()'s' without a timeout
+		return empty(blocked_threads) ? NULL : head(blocked_threads).info;
+	}
+
+	bool empty( condition_variable(L) & this ) with(this) { return empty(blocked_threads); }
+
+	int counter( condition_variable(L) & this ) with(this) { return count; }
+
+	size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
+		addTail( blocked_threads, *i );
+		count++;
+		i->listed = true;
+		size_t recursion_count = 0;
+		if (i->lock) {
+			i->t->link.next = 1p;
+			recursion_count = get_recursion_count(*i->lock);
+			remove_( *i->lock );
+		}
+		return recursion_count;
+	}
+
+	// helper for wait()'s' with no timeout
 	void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
 		lock( lock __cfaabi_dbg_ctx2 );
-		append( this.blocked_threads, &i );
-		count++;
-		i.listed = true;
-		size_t recursion_count;
-		if (i.lock) {
-			recursion_count = get_recursion_count(*i.lock);
-			remove_( *i.lock );
-		}
-		
+		size_t recursion_count = queue_and_get_recursion(this, &i);
 		unlock( lock );
 		park( ); // blocks here
-
 		if (i.lock) set_recursion_count(*i.lock, recursion_count); // resets recursion count here after waking
 	}
@@ -371,26 +276,12 @@
 	void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Time t ) with(this) {
 		lock( lock __cfaabi_dbg_ctx2 );
-
-		info_thread(L) * queue_ptr = &info;
-
+		size_t recursion_count = queue_and_get_recursion(this, &info);
 		alarm_node_wrap(L) node_wrap = { info.t, t, 0`s, alarm_node_wrap_cast };
 		node_wrap.cond = &this;
-		node_wrap.i = &queue_ptr;
-
+		node_wrap.i = &info;
 		register_self( &node_wrap.alarm_node );
-
-		append( blocked_threads, queue_ptr );
-		info.listed = true;
-		count++;
-
-		size_t recursion_count;
-		if (info.lock) {
-			recursion_count = get_recursion_count(*info.lock);
-			remove_( *info.lock );
-		}
-
 		unlock( lock );
 		park();
-
+		unregister_self( &node_wrap.alarm_node );
 		if (info.lock) set_recursion_count(*info.lock, recursion_count);
 	}
@@ -462,54 +353,2 @@
 	}
 }
-
-// thread T1 {};
-// thread T2 {};
-
-// multiple_acquisition_lock m;
-// condition_variable( multiple_acquisition_lock ) c;
-
-// void main( T1 & this ) {
-// 	printf("T1 start\n");
-// 	lock(m);
-// 	printf("%d\n", counter(c));
-// 	if(empty(c)) {
-// 		printf("T1 wait\n");
-// 		wait(c,m,12);
-// 	}else{
-// 		printf("%d\n", front(c));
-// 		notify_one(c);
-// 	}
-// 	unlock(m);
-// 	printf("curr thd in main %p \n", active_thread());
-// 	printf("T1 waits for 2s\n");
-// 	lock(m);
-// 	wait( c, m, 2`s );
-// 	unlock(m);
-// 	printf("T1 wakes\n");
-// 	printf("T1 done\n");
-// }
-
-// void main( T2 & this ) {
-// 	printf("T2 start\n");
-// 	lock(m);
-// 	printf("%d\n", counter(c));
-// 	if(empty(c)) {
-// 		printf("T2 wait\n");
-// 		wait(c,m,12);
-// 	}else{
-// 		printf("%d\n", front(c));
-// 		notify_one(c);
-// 	}
-// 	unlock(m);
-// 	printf("T2 done\n");
-// }
-
-// int main() {
-// 	printf("start\n");
-// 	processor p[2];
-// 	{
-// 		T1 t1;
-// 		T2 t2;
-// 	}
-// 	printf("done\n");
-// }
Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision 27b1ca17f81ccc20c840eef940088ae8724aaa3d)
+++ libcfa/src/concurrency/locks.hfa	(revision c74e60192ab933411aa2834a374ef0049feae8ea)
@@ -5,4 +5,5 @@
 #include "bits/algorithm.hfa"
 #include "bits/locks.hfa"
+#include "bits/sequence.hfa"
 #include "bits/containers.hfa"
 
@@ -31,7 +32,7 @@
 forall(dtype L | is_blocking_lock(L)) {
 	struct info_thread {
+		inline Seqable;
 		struct $thread * t;
 		uintptr_t info;
-		info_thread(L) * next;
 		L * lock;
 		bool listed;					// true if info_thread is on queue, false otherwise;
@@ -42,6 +43,4 @@
 	void ?{}( info_thread(L) & this, $thread * t, uintptr_t info );
 	void ^?{}( info_thread(L) & this );
-
-	info_thread(L) *& get_next( info_thread(L) & this );
 }
 
@@ -50,4 +49,14 @@
 ///////////////////////////////////////////////////////////////////
 
+// struct lock_thread {
+// 	struct $thread * t;
+// 	lock_thread * next;
+// };
+
+// void ?{}( lock_thread & this, struct $thread * thd );
+// void ^?{}( lock_thread & this );
+
+// lock_thread *& get_next( lock_thread & );
+
 struct blocking_lock {
 	// Spin lock used for mutual exclusion
@@ -55,5 +64,5 @@
 
 	// List of blocked threads
-	__queue_t( struct $thread ) blocked_threads;
+	__queue_t( $thread ) blocked_threads;
 
 	// Count of current blocked threads
@@ -135,6 +144,8 @@
 		__spinlock_t lock;
 
+		info_thread(L) * last_thread;
+
 		// List of blocked threads
-		__queue_t( info_thread(L) ) blocked_threads;
+		Sequence( info_thread(L) ) blocked_threads;
 
 		// Count of current blocked threads
@@ -150,5 +161,5 @@
 		condition_variable(L) * cond;
 
-		info_thread(L) ** i;
+		info_thread(L) * i;
 	};