Index: libcfa/src/concurrency/invoke.h
===================================================================
--- libcfa/src/concurrency/invoke.h	(revision 9b1dcc2f454a40116801b690de79c7b7c402765c)
+++ libcfa/src/concurrency/invoke.h	(revision ff79d5e0c1b8084b524b4eea26224b2ddde2512a)
@@ -92,5 +92,5 @@
 	};
 
-	enum coroutine_state { Halted, Start, Primed, Blocked, Ready, Active, Rerun };
+	enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active };
 	enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION, __MANUAL_PREEMPTION };
 
@@ -106,5 +106,5 @@
 
 		// current execution status for coroutine
-		enum coroutine_state state;
+		enum __Coroutine_State state;
 
 		// first coroutine to resume this one
@@ -175,6 +175,7 @@
 
 		// current execution status for coroutine
-		volatile int state;
-		enum __Preemption_Reason preempted;
+		volatile int ticket;
+		enum __Coroutine_State state:8;
+		enum __Preemption_Reason preempted:8;
 
 		//SKULLDUGGERY errno is not save in the thread data structure because returnToKernel appears to be the only function to require saving and restoring it
@@ -210,8 +211,10 @@
 			// previous function to park/unpark the thread
 			const char * park_caller;
-			enum coroutine_state park_result;
+			int park_result;
+			enum __Coroutine_State park_state;
 			bool park_stale;
 			const char * unpark_caller;
-			enum coroutine_state unpark_result;
+			int unpark_result;
+			enum __Coroutine_State unpark_state;
 			bool unpark_stale;
 		#endif
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 9b1dcc2f454a40116801b690de79c7b7c402765c)
+++ libcfa/src/concurrency/kernel.cfa	(revision ff79d5e0c1b8084b524b4eea26224b2ddde2512a)
@@ -192,4 +192,5 @@
 
 void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
+	ticket = 1;
 	state = Start;
 	self_cor{ info };
@@ -378,11 +379,6 @@
 	// Actually run the thread
 	RUNNING:  while(true) {
-		if(unlikely(thrd_dst->preempted)) {
-			thrd_dst->preempted = __NO_PREEMPTION;
-			verify(thrd_dst->state == Active  || thrd_dst->state == Rerun);
-		} else {
-			verify(thrd_dst->state == Blocked || thrd_dst->state == Ready); // Ready means scheduled normally, blocked means rerun
-			thrd_dst->state = Active;
-		}
+		thrd_dst->preempted = __NO_PREEMPTION;
+		thrd_dst->state = Active;
 
 		__cfaabi_dbg_debug_do(
@@ -420,21 +416,23 @@
 		}
 
+		if(unlikely(thrd_dst->state == Halted)) {
+			// The thread has halted, it should never be scheduled/run again
+			// We may need to wake someone up here since
+			unpark( this->destroyer __cfaabi_dbg_ctx2 );
+			this->destroyer = 0p;
+			break RUNNING;
+		}
+
+		/* paranoid */ verify( thrd_dst->state == Active );
+		thrd_dst->state = Blocked;
+
 		// set state of processor coroutine to active and the thread to inactive
-		static_assert(sizeof(thrd_dst->state) == sizeof(int));
-		enum coroutine_state old_state = __atomic_exchange_n(&thrd_dst->state, Blocked, __ATOMIC_SEQ_CST);
-		__cfaabi_dbg_debug_do( thrd_dst->park_result = old_state; )
-		switch(old_state) {
-			case Halted:
-				// The thread has halted, it should never be scheduled/run again, leave it back to Halted and move on
-				thrd_dst->state = Halted;
-
-				// We may need to wake someone up here since
-				unpark( this->destroyer __cfaabi_dbg_ctx2 );
-				this->destroyer = 0p;
-				break RUNNING;
-			case Active:
+		int old_ticket = __atomic_fetch_sub(&thrd_dst->ticket, 1, __ATOMIC_SEQ_CST);
+		__cfaabi_dbg_debug_do( thrd_dst->park_result = old_ticket; )
+		switch(old_ticket) {
+			case 1:
 				// This is case 1, the regular case, nothing more is needed
 				break RUNNING;
-			case Rerun:
+			case 2:
 				// This is case 2, the racy case, someone tried to run this thread before it finished blocking
 				// In this case, just run it again.
@@ -442,5 +440,5 @@
 			default:
 				// This makes no sense, something is wrong abort
-				abort("Finished running a thread that was Blocked/Start/Primed %d\n", old_state);
+				abort();
 		}
 	}
@@ -616,5 +614,5 @@
 	/* paranoid */ 	if( thrd->state == Blocked || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
 					"Error inactive thread marked as preempted, state %d, preemption %d\n", thrd->state, thrd->preempted );
-	/* paranoid */ 	if( thrd->preempted != __NO_PREEMPTION ) assertf(thrd->state == Active || thrd->state == Rerun,
+	/* paranoid */ 	if( thrd->preempted != __NO_PREEMPTION ) assertf(thrd->state == Active,
 					"Error preempted thread marked as not currently running, state %d, preemption %d\n", thrd->state, thrd->preempted );
 	/* paranoid */ #endif
@@ -646,29 +644,21 @@
 // KERNEL ONLY unpark with out disabling interrupts
 void __unpark(  struct __processor_id_t * id, $thread * thrd __cfaabi_dbg_ctx_param2 ) {
-	static_assert(sizeof(thrd->state) == sizeof(int));
-
 	// record activity
 	__cfaabi_dbg_debug_do( char * old_caller = thrd->unpark_caller; )
 	__cfaabi_dbg_record_thrd( *thrd, false, caller );
 
-	enum coroutine_state old_state = __atomic_exchange_n(&thrd->state, Rerun, __ATOMIC_SEQ_CST);
-	__cfaabi_dbg_debug_do( thrd->unpark_result = old_state; )
-	switch(old_state) {
-		case Active:
+	int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
+	__cfaabi_dbg_debug_do( thrd->unpark_result = old_ticket; thrd->unpark_state = thrd->state; )
+	switch(old_ticket) {
+		case 1:
 			// Wake won the race, the thread will reschedule/rerun itself
 			break;
-		case Blocked:
+		case 0:
 			/* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
+			/* paranoid */ verify( thrd->state == Blocked );
 
 			// Wake lost the race,
-			thrd->state = Blocked;
 			__schedule_thread( id, thrd );
 			break;
-		case Rerun:
-			abort("More than one thread attempted to schedule thread %p\n", thrd);
-			break;
-		case Halted:
-		case Start:
-		case Primed:
 		default:
 			// This makes no sense, something is wrong abort
@@ -716,5 +706,5 @@
 
 	$thread * thrd = kernelTLS.this_thread;
-	/* paranoid */ verify(thrd->state == Active || thrd->state == Rerun);
+	/* paranoid */ verify(thrd->state == Active);
 
 	// SKULLDUGGERY: It is possible that we are preempting this thread just before
Index: libcfa/src/concurrency/thread.cfa
===================================================================
--- libcfa/src/concurrency/thread.cfa	(revision 9b1dcc2f454a40116801b690de79c7b7c402765c)
+++ libcfa/src/concurrency/thread.cfa	(revision ff79d5e0c1b8084b524b4eea26224b2ddde2512a)
@@ -28,4 +28,5 @@
 	context{ 0p, 0p };
 	self_cor{ name, storage, storageSize };
+	ticket = 1;
 	state = Start;
 	preempted = __NO_PREEMPTION;