Index: doc/proposals/concurrency/thePlan.md
===================================================================
--- doc/proposals/concurrency/thePlan.md	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ doc/proposals/concurrency/thePlan.md	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -8,14 +8,14 @@
 _Phase 2_ : Minimum Viable Product
 done - Monitor type and enter/leave mutex member routines
-Monitors as a language feature (not calling enter/leave by hand)
+done - Multi monitors calls,
+done - Monitors as a language feature (not calling enter/leave by hand)
 Internal scheduling
 
 _Phase 3_ : Kernel features
+Preemption
 Detach thread
 Cluster migration
-Preemption
 
 _Phase 4_ : Monitor features
-Multi monitors calls,
 External scheduling
 
Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/Concurrency/Keywords.cc	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -17,4 +17,5 @@
 #include "Concurrency/Keywords.h"
 
+#include "SymTab/AddVisit.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
@@ -29,4 +30,5 @@
 	namespace {
 		const std::list<Label> noLabels;
+		const std::list< Attribute * > noAttributes;
 		Type::StorageClasses noStorage;
 		Type::Qualifiers noQualifiers;
@@ -63,8 +65,24 @@
 	//                                           void main( MyCoroutine * this );
 	//
-	class CoroutineKeyword final : public Mutator {
+	class CoroutineKeyword final : public Visitor {
+	    template< typename Visitor >
+	    friend void SymTab::acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
 	  public:
 
-		static void implement( std::list< Declaration * > & translationUnit ) {}
+		using Visitor::visit;
+		virtual void visit( StructDecl * decl ) override final;
+
+		void handle( StructDecl * );
+		Declaration * addField( StructDecl * );
+		void addRoutines( StructDecl *, Declaration * );
+
+		static void implement( std::list< Declaration * > & translationUnit ) {
+			CoroutineKeyword impl;
+			SymTab::acceptAndAdd( translationUnit, impl );
+		}
+
+	  private:
+		std::list< Declaration * > declsToAdd, declsToAddAfter;
+		StructDecl* coroutine_decl = nullptr;
 	};
 
@@ -97,6 +115,6 @@
 
 		using Visitor::visit;
-		virtual void visit( FunctionDecl *functionDecl ) override final;
-		virtual void visit(   StructDecl *functionDecl ) override final;
+		virtual void visit( FunctionDecl * decl ) override final;
+		virtual void visit(   StructDecl * decl ) override final;
 
 		std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
@@ -111,4 +129,5 @@
 	  private:
 	  	StructDecl* monitor_decl = nullptr;
+		StructDecl* guard_decl = nullptr;
 	};
 
@@ -124,4 +143,89 @@
 
 	//=============================================================================================
+	// Coroutine keyword implementation
+	//=============================================================================================
+	void CoroutineKeyword::visit(StructDecl * decl) {
+		if( decl->get_name() == "coroutine_desc" ) {
+			assert( !coroutine_decl );
+			coroutine_decl = decl;
+		}
+		else if ( false ) {
+			handle( decl );
+		}
+
+	}
+
+	void CoroutineKeyword::handle( StructDecl * decl ) {
+		if( ! decl->has_body() ) return;
+
+		if( !coroutine_decl ) throw SemanticError( "coroutine keyword requires coroutines to be in scope, add #include <coroutine>", decl );
+
+		Declaration * field = addField( decl );
+		addRoutines( decl, field );
+	}
+
+	Declaration * CoroutineKeyword::addField( StructDecl * decl ) {
+		Declaration * cor = new ObjectDecl(
+			"__cor",
+			noStorage,
+			LinkageSpec::Cforall,
+			nullptr,
+			new StructInstType(
+				noQualifiers,
+				coroutine_decl
+			),
+			nullptr
+		);
+
+		decl->get_members().push_front( cor );
+
+		return cor;
+	}
+
+	void CoroutineKeyword::addRoutines( StructDecl * decl, Declaration * field ) {
+		FunctionType * type = new FunctionType( noQualifiers, false );
+		type->get_parameters().push_back(
+			new ObjectDecl(
+				"this",
+				noStorage,
+				LinkageSpec::Cforall,
+				nullptr,
+				new PointerType(
+					noQualifiers,
+					new StructInstType(
+						noQualifiers,
+						decl
+					)
+				),
+				nullptr
+			)
+		);
+
+		CompoundStmt * statement = new CompoundStmt( noLabels );
+		statement->push_back( 
+			new ReturnStmt(
+				noLabels,
+				new UntypedMemberExpr(
+					new NameExpr( "__cor" ),
+					new NameExpr( "this" )
+				)
+			)
+		);
+
+		declsToAddAfter.push_back( 
+			new FunctionDecl(
+				"get_coroutine",
+				Type::Static,
+				LinkageSpec::Cforall,
+				type,
+				statement,
+				noAttributes,
+				Type::Inline
+			)
+		);
+	}
+	
+
+	//=============================================================================================
 	// Mutex keyword implementation
 	//=============================================================================================
@@ -137,5 +241,7 @@
 		if( ! body ) return;
 
-		assert(monitor_decl);
+		if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+		if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+
 		addStatments( body, mutexArgs );
 	}
@@ -146,4 +252,8 @@
 			monitor_decl = decl;
 		}
+		else if( decl->get_name() == "monitor_guard_t" ) {
+			assert( !guard_decl );
+			guard_decl = decl;
+		}
 	}
 
@@ -179,5 +289,4 @@
 
 	void MutexKeyword::addStatments( CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
-
 		ObjectDecl * monitors = new ObjectDecl(
 			"__monitors",
@@ -218,5 +327,5 @@
 				new StructInstType(
 					noQualifiers,
-					"monitor_guard_t"
+					guard_decl
 				),
 				new ListInit(
@@ -224,10 +333,12 @@
 						new SingleInit( new VariableExpr( monitors ) ),
 						new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
-					}
+					},
+					noDesignators,
+					true
 				)
 			))
 		);
 
-		//monitor_desc * __monitors[] = { a, b };
+		//monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
 		body->push_front( new DeclStmt( noLabels, monitors) );
 	}
Index: src/benchmark/CorCtxSwitch.c
===================================================================
--- src/benchmark/CorCtxSwitch.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/benchmark/CorCtxSwitch.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -24,5 +24,5 @@
 
 struct GreatSuspender {
-	coroutine_desc c;
+	coroutine_desc __cor;
 };
 
Index: src/benchmark/bench.c
===================================================================
--- src/benchmark/bench.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/benchmark/bench.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -86,5 +86,5 @@
 //=======================================
 
-struct CoroutineDummy { coroutine_desc c; };
+struct CoroutineDummy { coroutine_desc __cor; };
 DECL_COROUTINE(CoroutineDummy);
 void main(CoroutineDummy * this) {}
@@ -119,5 +119,5 @@
 struct CoroutineResume {
     int N;
-    coroutine_desc c;
+    coroutine_desc __cor;
 };
 
@@ -150,5 +150,5 @@
 //=======================================
 
-struct ThreadDummy { thread_desc t; };
+struct ThreadDummy { thread_desc __thrd; };
 DECL_THREAD(ThreadDummy);
 void main(ThreadDummy * this) {}
@@ -180,5 +180,5 @@
     int N;
     long long result;
-    thread_desc t;
+    thread_desc __thrd;
 };
 
Index: src/benchmark/csv-data.c
===================================================================
--- src/benchmark/csv-data.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/benchmark/csv-data.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -26,5 +26,5 @@
 
 struct GreatSuspender {
-	coroutine_desc c;
+	coroutine_desc __cor;
 };
 
Index: src/examples/multicore.c
===================================================================
--- src/examples/multicore.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/examples/multicore.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -2,5 +2,5 @@
 #include <thread>
 
-struct MyThread { thread_desc t; };
+struct MyThread { thread_desc __thrd; };
 
 DECL_THREAD(MyThread);
Index: src/libcfa/concurrency/coroutine
===================================================================
--- src/libcfa/concurrency/coroutine	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/libcfa/concurrency/coroutine	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -30,5 +30,5 @@
 };
 
-#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->c; } void main(X* this)
+#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this)
 
 //-----------------------------------------------------------------------------
Index: src/libcfa/concurrency/invoke.c
===================================================================
--- src/libcfa/concurrency/invoke.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/libcfa/concurrency/invoke.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -56,4 +56,5 @@
 
 void CtxInvokeThread(
+      void (*dtor)(void *), 
       void (*main)(void *), 
       struct thread_desc *(*get_thread)(void *), 
@@ -63,5 +64,5 @@
 
       struct thread_desc* thrd = get_thread( this );
-      struct coroutine_desc* cor = &thrd->c;
+      struct coroutine_desc* cor = &thrd->cor;
       cor->state = Active;
 
@@ -91,7 +92,7 @@
 	struct FakeStack {
 	    void *fixedRegisters[3];		  	// fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant)
-	    uint32_t mxcr;                              // SSE Status and Control bits (control bits are preserved across function calls)
-            uint16_t fcw;                               // X97 FPU control word (preserved across function calls)
-	    void *rturn;                                // where to go on return from uSwitch
+	    uint32_t mxcr;                        // SSE Status and Control bits (control bits are preserved across function calls)
+          uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
+	    void *rturn;                          // where to go on return from uSwitch
 	    void *dummyReturn;				// fake return compiler would have pushed on call to uInvoke
 	    void *argument[3];				// for 16-byte ABI, 16-byte alignment starts here
@@ -105,13 +106,15 @@
 	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this;     // argument to invoke
 	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke;
+      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
+      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7 
 
 #elif defined( __x86_64__ )
 
       struct FakeStack {
-            void *fixedRegisters[5];			// fixed registers rbx, r12, r13, r14, r15
-            uint32_t mxcr;                              // SSE Status and Control bits (control bits are preserved across function calls)
-            uint16_t fcw;                               // X97 FPU control word (preserved across function calls)
-            void *rturn;                                // where to go on return from uSwitch
-            void *dummyReturn;				// NULL return address to provide proper alignment
+            void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
+            uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
+            uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
+            void *rturn;                        // where to go on return from uSwitch
+            void *dummyReturn;                  // NULL return address to provide proper alignment
       };
 
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/libcfa/concurrency/invoke.h	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -28,5 +28,4 @@
       #define unlikely(x)    __builtin_expect(!!(x), 0)
       #define thread_local _Thread_local
-      #define SCHEDULER_CAPACITY 10
 
       struct spinlock {
@@ -60,11 +59,11 @@
 
       struct coStack_t {
-            unsigned int size;		      // size of stack
-            void *storage;			      // pointer to stack
-            void *limit;			      // stack grows towards stack limit
-            void *base;				      // base of stack
-            void *context;			      // address of cfa_context_t
-            void *top;				      // address of top of storage
-            bool userStack;	
+            unsigned int size;                  // size of stack
+            void *storage;                      // pointer to stack
+            void *limit;                        // stack grows towards stack limit
+            void *base;                         // base of stack
+            void *context;                      // address of cfa_context_t
+            void *top;                          // address of top of storage
+            bool userStack;                     // whether or not the user allocated the stack
       };
 
@@ -72,16 +71,16 @@
 
       struct coroutine_desc {
-            struct coStack_t stack;
-            const char *name;			      // textual name for coroutine/task, initialized by uC++ generated code
-            int errno_;				      // copy of global UNIX variable errno
-            enum coroutine_state state;	      // current execution status for coroutine
-            struct coroutine_desc *starter;	      // first coroutine to resume this one
-            struct coroutine_desc *last;		      // last coroutine to resume this one
+            struct coStack_t stack;             // stack information of the coroutine
+            const char *name;                   // textual name for coroutine/task, initialized by uC++ generated code
+            int errno_;                         // copy of global UNIX variable errno
+            enum coroutine_state state;         // current execution status for coroutine
+            struct coroutine_desc *starter;     // first coroutine to resume this one
+            struct coroutine_desc *last;	      // last coroutine to resume this one
       };
 
       struct thread_desc {
-            struct coroutine_desc c;                 // coroutine body used to store context
+            struct coroutine_desc cor;            // coroutine body used to store context
             struct signal_once terminated;      // indicate if execuation state is not halted
-            struct thread_desc * next;               // instrusive link field for threads
+            struct thread_desc * next;          // instrusive link field for threads
       };
 
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/libcfa/concurrency/kernel.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -107,5 +107,5 @@
 
 void ?{}( thread_desc * this, current_stack_info_t * info) {
-	(&this->c){ info };
+	(&this->cor){ info };
 }
 
@@ -113,5 +113,5 @@
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
-	(&this->c){};
+	(&this->__cor){};
 	this->proc = proc;
 	proc->runner = this;
@@ -119,5 +119,5 @@
 
 void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
-	(&this->c){ info };
+	(&this->__cor){ info };
 	this->proc = proc;
 	proc->runner = this;
@@ -255,8 +255,8 @@
 	processorCtx_t proc_cor_storage = { proc, &info };
 
-	LIB_DEBUG_PRINTF("Coroutine : created stack %p\n", proc_cor_storage.c.stack.base);
+	LIB_DEBUG_PRINTF("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
 
 	//Set global state
-	proc->current_coroutine = &proc->runner->c;
+	proc->current_coroutine = &proc->runner->__cor;
 	proc->current_thread = NULL;
 
@@ -268,7 +268,7 @@
 	// back to here. Instead directly call the main since we already are on the 
 	// appropriate stack.
-	proc_cor_storage.c.state = Active;
+	proc_cor_storage.__cor.state = Active;
       main( &proc_cor_storage );
-      proc_cor_storage.c.state = Halted;
+      proc_cor_storage.__cor.state = Halted;
 
 	// Main routine of the core returned, the core is now fully terminated
@@ -359,5 +359,5 @@
 	this_processor = systemProcessor;
 	this_processor->current_thread = mainThread;
-	this_processor->current_coroutine = &mainThread->c;
+	this_processor->current_coroutine = &mainThread->cor;
 
 	// SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/libcfa/concurrency/kernel_private.h	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -35,5 +35,5 @@
 struct processorCtx_t {
 	processor * proc;
-	coroutine_desc c;
+	coroutine_desc __cor;
 };
 
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/libcfa/concurrency/monitor	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -34,8 +34,4 @@
 }
 
-//Basic entering routine
-void enter(monitor_desc *);
-void leave(monitor_desc *);
-
 //Array entering routine
 void enter(monitor_desc **, int count);
@@ -49,10 +45,4 @@
 static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
 	return ((intptr_t)lhs) < ((intptr_t)rhs);
-}
-
-static inline void ?{}( monitor_guard_t * this, monitor_desc ** m ) {
-	this->m = m;
-	this->count = 1;
-	enter( *this->m );
 }
 
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/libcfa/concurrency/monitor.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -74,5 +74,4 @@
 void enter(monitor_desc ** monitors, int count) {
 	for(int i = 0; i < count; i++) {
-		// printf("%d\n", i);
 		enter( monitors[i] );
 	}
@@ -81,5 +80,4 @@
 void leave(monitor_desc ** monitors, int count) {
 	for(int i = count - 1; i >= 0; i--) {
-		// printf("%d\n", i);
 		leave( monitors[i] );
 	}
Index: src/libcfa/concurrency/thread
===================================================================
--- src/libcfa/concurrency/thread	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/libcfa/concurrency/thread	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -28,17 +28,18 @@
 // Anything that is resumed is a coroutine.
 trait is_thread(dtype T) {
+      void ^?{}(T* this);
       void main(T* this);
       thread_desc* get_thread(T* this);
 };
 
-#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->t; } void main(X* this)
+#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->__thrd; } void main(X* this)
 
 forall( dtype T | is_thread(T) )
 static inline coroutine_desc* get_coroutine(T* this) {
-	return &get_thread(this)->c;
+	return &get_thread(this)->cor;
 }
 
 static inline coroutine_desc* get_coroutine(thread_desc* this) {
-	return &this->c;
+	return &this->cor;
 }
 
@@ -64,5 +65,5 @@
 void ?{}( scoped(T)* this, P params );
 
-forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } )
+forall( dtype T | sized(T) | is_thread(T) )
 void ^?{}( scoped(T)* this );
 
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/libcfa/concurrency/thread.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -42,6 +42,6 @@
 
 void ?{}(thread_desc* this) {
-	(&this->c){};
-	this->c.name = "Anonymous Coroutine";
+	(&this->cor){};
+	this->cor.name = "Anonymous Coroutine";
 	(&this->terminated){};
 	this->next = NULL;
@@ -49,5 +49,5 @@
 
 void ^?{}(thread_desc* this) {
-	^(&this->c){};
+	^(&this->cor){};
 }
 
@@ -64,5 +64,5 @@
 }
 
-forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } )
+forall( dtype T | sized(T) | is_thread(T) )
 void ^?{}( scoped(T)* this ) {
 	stop(&this->handle);
@@ -120,5 +120,5 @@
 extern "C" {
 	void __thread_signal_termination( thread_desc * this ) {
-		this->c.state = Halted;
+		this->cor.state = Halted;
 		LIB_DEBUG_PRINTF("Thread end : %p\n", this);
 		signal( &this->terminated );	
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/main.cc	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -241,5 +241,5 @@
 		OPTPRINT( "fixNames" )
 		CodeGen::fixNames( translationUnit );
-		OPTPRINT( "tweakInit" )
+		OPTPRINT( "genInit" )
 		InitTweak::genInit( translationUnit );
 		OPTPRINT( "expandMemberTuples" );
Index: src/tests/coroutine.c
===================================================================
--- src/tests/coroutine.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/tests/coroutine.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -4,5 +4,5 @@
 struct Fibonacci {
       int fn; // used for communication
-      coroutine_desc c;
+      coroutine_desc __cor;
 };
 
@@ -12,5 +12,5 @@
 
 coroutine_desc* get_coroutine(Fibonacci* this) {
-      return &this->c;
+      return &this->__cor;
 }
 
@@ -18,5 +18,5 @@
 #ifdef MORE_DEBUG
       sout | "Starting main of coroutine " | this | endl;
-      sout | "Started from " | this->c.last | endl;
+      sout | "Started from " | this->__cor.last | endl;
 #endif
       int fn1, fn2; 		// retained between resumes
Index: src/tests/monitor.c
===================================================================
--- src/tests/monitor.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/tests/monitor.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -13,19 +13,23 @@
 }
 
+monitor_desc * get_monitor( global_t * this ) {
+	return &this->m;
+}
+
 static global_t global;
 
-void increment( /*mutex*/ global_t * this ) {
-	monitor_desc * mon = &this->m;
-	monitor_guard_t g1 = { &mon };
-	{
-		monitor_guard_t g2 = { &mon };
-		{
-			monitor_guard_t g3 = { &mon };
-			this->value += 1;
-		}
-	}
+void increment3( global_t * mutex this ) {
+	this->value += 1;
 }
 
-struct MyThread { thread_desc t; };
+void increment2( global_t * mutex this ) {
+	increment3( this );
+}
+
+void increment( global_t * mutex this ) {
+	increment2( this );
+}
+
+struct MyThread { thread_desc __thrd; };
 
 DECL_THREAD(MyThread);
Index: src/tests/multi-monitor.c
===================================================================
--- src/tests/multi-monitor.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/tests/multi-monitor.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -6,14 +6,20 @@
 static int global12, global23, global13;
 
-static monitor_desc m1, m2, m3;
+struct monitor_t {
+	monitor_desc m;
+};
 
-void increment( /*mutex*/ monitor_desc * p1, /*mutex*/ monitor_desc * p2, int * value ) {
-	monitor_desc * mons[] = { p1, p2 };
-	monitor_guard_t g = { mons, 2 };
+monitor_desc * get_monitor( monitor_t * this ) {
+	return &this->m;
+}
+
+static monitor_t m1, m2, m3;
+
+void increment( monitor_t * mutex p1, monitor_t * mutex p2, int * value ) {
 	*value += 1;
 }
 
 struct MyThread { 
-	thread_desc t; 
+	thread_desc __thrd; 
 	int target;
 };
Index: src/tests/thread.c
===================================================================
--- src/tests/thread.c	(revision 6e8f1df912597d389d23009410574a462589e1f7)
+++ src/tests/thread.c	(revision 31ce3d6b3b66f7fe2acde378a39107b39c636552)
@@ -4,6 +4,6 @@
 #include <thread>
 
-struct First { thread_desc t; signal_once* lock; };
-struct Second { thread_desc t; signal_once* lock; };
+struct First { thread_desc __thrd; signal_once* lock; };
+struct Second { thread_desc __thrd; signal_once* lock; };
 
 DECL_THREAD(First);