Index: tests/concurrency/actors/dynamic.cfa
===================================================================
--- tests/concurrency/actors/dynamic.cfa	(revision 50be8af55788ecaebbb85845d1e11234cd6a5cb6)
+++ tests/concurrency/actors/dynamic.cfa	(revision 7edf912cbd74d5e5c4d9fd1c37e98e4fe117e7a4)
@@ -9,29 +9,29 @@
 struct derived_actor { inline actor; };
 struct derived_msg {
-    inline message;
-    int cnt;
+	inline message;
+	int cnt;
 };
 
 void ?{}( derived_msg & this, int cnt ) {
-    ((message &) this){ Delete };
-    this.cnt = cnt;
+	set_allocation( this, Delete );
+	this.cnt = cnt;
 }
 void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
 
 allocation receive( derived_actor & receiver, derived_msg & msg ) {
-    if ( msg.cnt >= Times ) {
-        sout | "Done";
-        return Delete;
-    }
-    derived_msg * d_msg = alloc();
-    (*d_msg){ msg.cnt + 1 };
-    derived_actor * d_actor = alloc();
-    (*d_actor){};
-    *d_actor | *d_msg;
-    return Delete;
+	if ( msg.cnt >= Times ) {
+		sout | "Done";
+		return Delete;
+	}
+	derived_msg * d_msg = alloc();
+	(*d_msg){ msg.cnt + 1 };
+	derived_actor * d_actor = alloc();
+	(*d_actor){};
+	*d_actor | *d_msg;
+	return Delete;
 }
 
 int main( int argc, char * argv[] ) {
-    switch ( argc ) {
+	switch ( argc ) {
 	  case 2:
 		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
@@ -45,23 +45,21 @@
 	} // switch
 
-    sout | "starting";
+	sout | "starting";
 
-    executor e{ 0, 1, 1, false };
-    start_actor_system( e );
+	executor e{ 0, 1, 1, false };
+	start_actor_system( e );
 
-    sout | "started";
+	sout | "started";
 
-    derived_msg * d_msg = alloc();
-    (*d_msg){};
-    derived_actor * d_actor = alloc();
-    (*d_actor){};
-    *d_actor | *d_msg;
+	derived_msg * d_msg = alloc();
+	(*d_msg){};
+	derived_actor * d_actor = alloc();
+	(*d_actor){};
+	*d_actor | *d_msg;
 
-    sout | "stopping";
+	sout | "stopping";
 
-    stop_actor_system();
+	stop_actor_system();
 
-    sout | "stopped";
-
-    return 0;
+	sout | "stopped";
 }
Index: tests/concurrency/actors/executor.cfa
===================================================================
--- tests/concurrency/actors/executor.cfa	(revision 50be8af55788ecaebbb85845d1e11234cd6a5cb6)
+++ tests/concurrency/actors/executor.cfa	(revision 7edf912cbd74d5e5c4d9fd1c37e98e4fe117e7a4)
@@ -10,14 +10,14 @@
 static int ids = 0;
 struct d_actor { 
-    inline actor;
-    d_actor * gstart;
-    int id, rounds, recs, sends;
+	inline actor;
+	d_actor * gstart;
+	int id, rounds, recs, sends;
 };
 void ?{}( d_actor & this ) with(this) {
-    id = ids++;
-    gstart = (&this + (id / Set * Set - id)); // remember group-start array-element
-    rounds = Set * Rounds;	// send at least one message to each group member
-    recs = 0;
-    sends = 0;
+	id = ids++;
+	gstart = (&this + (id / Set * Set - id)); // remember group-start array-element
+	rounds = Set * Rounds;	// send at least one message to each group member
+	recs = 0;
+	sends = 0;
 }
 
@@ -25,17 +25,17 @@
 
 allocation receive( d_actor & this, d_msg & msg ) with( this ) {
-    if ( recs == rounds ) return Finished;
-    if ( recs % Batch == 0 ) {
-        for ( i; Batch ) {
-            gstart[sends % Set] | shared_msg;
-            sends += 1;
-        }
-    }
-    recs += 1;
-    return Nodelete;
+	if ( recs == rounds ) return Finished;
+	if ( recs % Batch == 0 ) {
+		for ( i; Batch ) {
+			gstart[sends % Set] | shared_msg;
+			sends += 1;
+		}
+	}
+	recs += 1;
+	return Nodelete;
 }
 
 int main( int argc, char * argv[] ) {
-    switch ( argc ) {
+	switch ( argc ) {
 	  case 7:
 		if ( strcmp( argv[6], "d" ) != 0 ) {			// default ?
@@ -72,5 +72,5 @@
 	  default:
 		exit | "Usage: " | argv[0]
-             | " [ actors (> 0 && > set && actors % set == 0 ) | 'd' (default " | Actors
+			 | " [ actors (> 0 && > set && actors % set == 0 ) | 'd' (default " | Actors
 			 | ") ] [ set (> 0) | 'd' (default " | Set
 			 | ") ] [ rounds (> 0) | 'd' (default " | Rounds
@@ -81,13 +81,13 @@
 	} // switch
 
-    executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 512, true };
+	executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 512, true };
 
-    sout | "starting";
+	sout | "starting";
 
-    start_actor_system( e );
+	start_actor_system( e );
 
-    sout | "started";
+	sout | "started";
 
-    d_actor actors[ Actors ];
+	d_actor actors[ Actors ];
 
 	for ( i; Actors ) {
@@ -95,10 +95,8 @@
 	} // for
 
-    sout | "stopping";
+	sout | "stopping";
 
-    stop_actor_system();
+	stop_actor_system();
 
-    sout | "stopped";
-
-    return 0;
+	sout | "stopped";
 }
Index: tests/concurrency/actors/inherit.cfa
===================================================================
--- tests/concurrency/actors/inherit.cfa	(revision 50be8af55788ecaebbb85845d1e11234cd6a5cb6)
+++ tests/concurrency/actors/inherit.cfa	(revision 7edf912cbd74d5e5c4d9fd1c37e98e4fe117e7a4)
@@ -18,5 +18,5 @@
 
 allocation handle() {
-    return Finished;
+	return Finished;
 }
 
@@ -27,30 +27,30 @@
 
 int main() {
-    sout | "Start";
-    {
-        start_actor_system();
-        D_msg * dm = alloc();
-        (*dm){};
-        D_msg2 * dm2 = alloc();
-        (*dm2){};
-        Server2 * s = alloc();
-        (*s){};
-        Server2 * s2 = alloc();
-        (*s2){};
-        *s | *dm;
-        *s2 | *dm2;
-        stop_actor_system();
-    }
-    {
-        start_actor_system();
-        Server s[2];
-        D_msg * dm = alloc();
-        (*dm){};
-        D_msg2 * dm2 = alloc();
-        (*dm2){};
-        s[0] | *dm;
-        s[1] | *dm2;
-        stop_actor_system();
-    }
-    sout | "Finished";
+	sout | "Start";
+	{
+		start_actor_system();
+		D_msg * dm = alloc();
+		(*dm){};
+		D_msg2 * dm2 = alloc();
+		(*dm2){};
+		Server2 * s = alloc();
+		(*s){};
+		Server2 * s2 = alloc();
+		(*s2){};
+		*s | *dm;
+		*s2 | *dm2;
+		stop_actor_system();
+	}
+	{
+		start_actor_system();
+		Server s[2];
+		D_msg * dm = alloc();
+		(*dm){};
+		D_msg2 * dm2 = alloc();
+		(*dm2){};
+		s[0] | *dm;
+		s[1] | *dm2;
+		stop_actor_system();
+	}
+	sout | "Finished";
 }
Index: tests/concurrency/actors/inline.cfa
===================================================================
--- tests/concurrency/actors/inline.cfa	(revision 50be8af55788ecaebbb85845d1e11234cd6a5cb6)
+++ tests/concurrency/actors/inline.cfa	(revision 7edf912cbd74d5e5c4d9fd1c37e98e4fe117e7a4)
@@ -3,15 +3,15 @@
 
 struct d_actor {
-    inline actor;
+	inline actor;
 };
 struct msg_wrapper {
-    int b;
-    inline message;
+	int b;
+	inline message;
 };
 void ^?{}( msg_wrapper & this ) { sout | "msg_wrapper dtor"; }
 
 struct d_msg {
-    int m;
-    inline msg_wrapper;
+	int m;
+	inline msg_wrapper;
 };
 void ?{}( d_msg & this, int m, int b ) { this.m = m; this.b = b; set_allocation( this, Delete ); }
@@ -19,40 +19,40 @@
 
 allocation receive( d_actor &, d_msg & msg ) {
-    sout | msg.m;
-    sout | msg.b;
-    return Finished;
+	sout | msg.m;
+	sout | msg.b;
+	return Finished;
 }
 
 struct d_msg2 {
-    int m;
-    inline msg_wrapper;
+	int m;
+	inline msg_wrapper;
 };
 void ^?{}( d_msg2 & this ) { sout | "d_msg2 dtor";}
 
 allocation receive( d_actor &, d_msg2 & msg ) {
-    sout | msg.m;
-    return Finished;
+	sout | msg.m;
+	return Finished;
 }
 
 int main() {
-    processor p;
-    {
-        start_actor_system();                                // sets up executor
-        d_actor da;
-        d_msg * dm = alloc();
-        (*dm){ 42, 2423 };
-        da | *dm;
-        stop_actor_system();                                // waits until actors finish
-    }
-    {
-        start_actor_system();                                // sets up executor
-        d_actor da;
-        d_msg2 dm{ 29079 };
-        set_allocation( dm, Nodelete );
-        msg_wrapper * mw = &dm;
-        message * mg = &dm;
-        virtual_dtor * v = &dm;
-        da | dm;
-        stop_actor_system();                                // waits until actors finish
-    }
+	processor p;
+	{
+		start_actor_system();								// sets up executor
+		d_actor da;
+		d_msg * dm = alloc();
+		(*dm){ 42, 2423 };
+		da | *dm;
+		stop_actor_system();								// waits until actors finish
+	}
+	{
+		start_actor_system();								// sets up executor
+		d_actor da;
+		d_msg2 dm{ 29079 };
+		set_allocation( dm, Nodelete );
+		msg_wrapper * mw = &dm;
+		message * mg = &dm;
+		virtual_dtor * v = &dm;
+		da | dm;
+		stop_actor_system();								// waits until actors finish
+	}
 }
Index: tests/concurrency/actors/matrix.cfa
===================================================================
--- tests/concurrency/actors/matrix.cfa	(revision 50be8af55788ecaebbb85845d1e11234cd6a5cb6)
+++ tests/concurrency/actors/matrix.cfa	(revision 7edf912cbd74d5e5c4d9fd1c37e98e4fe117e7a4)
@@ -10,30 +10,30 @@
 
 struct derived_msg {
-    inline message;
-    int * Z;
+	inline message;
+	int * Z;
 	int * X;
-    int ** Y;
+	int ** Y;
 };
 
 void ?{}( derived_msg & this ) {}
 void ?{}( derived_msg & this, int * Z, int * X, int ** Y ) {
-    ((message &) this){ Nodelete };
-    this.Z = Z;
-    this.X = X;
-    this.Y = Y;
+	set_allocation( this, Nodelete );
+	this.Z = Z;
+	this.X = X;
+	this.Y = Y;
 }
 
 allocation receive( derived_actor & receiver, derived_msg & msg ) {
-    for ( unsigned int i = 0; i < yc; i += 1 ) { // multiply X_row by Y_col and sum products
-        msg.Z[i] = 0;
-        for ( unsigned int j = 0; j < xc; j += 1 ) {
-            msg.Z[i] += msg.X[j] * msg.Y[j][i];
-        } // for
-    } // for
-    return Finished;
+	for ( unsigned int i = 0; i < yc; i += 1 ) { // multiply X_row by Y_col and sum products
+		msg.Z[i] = 0;
+		for ( unsigned int j = 0; j < xc; j += 1 ) {
+			msg.Z[i] += msg.X[j] * msg.Y[j][i];
+		} // for
+	} // for
+	return Finished;
 }
 
 int main( int argc, char * argv[] ) {
-    switch ( argc ) {
+	switch ( argc ) {
 	  case 5:
 		if ( strcmp( argv[4], "d" ) != 0 ) {			// default ?
@@ -67,5 +67,5 @@
 	} // switch
 
-    unsigned int r, c;
+	unsigned int r, c;
 	int * Z[xr], * X[xr], * Y[xc];
 
@@ -86,15 +86,15 @@
 	} // for
 
-    executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 16, true };
+	executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 16, true };
 
-    sout | "starting";
+	sout | "starting";
 
-    start_actor_system( e );
+	start_actor_system( e );
 
-    sout | "started";
+	sout | "started";
 
-    derived_msg messages[xr];
+	derived_msg messages[xr];
 
-    derived_actor actors[xr];
+	derived_actor actors[xr];
 
 	for ( unsigned int r = 0; r < xr; r += 1 ) {
@@ -106,16 +106,16 @@
 	} // for
 
-    sout | "stopping";
+	sout | "stopping";
 
-    stop_actor_system();
+	stop_actor_system();
 
-    sout | "stopped";
+	sout | "stopped";
 
-    for ( r = 0; r < xr; r += 1 ) {						// deallocate X and Z matrices
+	for ( r = 0; r < xr; r += 1 ) {						// deallocate X and Z matrices
 		free( X[r] );
-        free( Z[r] );
+		free( Z[r] );
 	} // for
 	for ( r = 0; r < xc; r += 1 ) {						// deallocate Y matrix
-        free( Y[r] );
+		free( Y[r] );
 	} // for
 }
Index: tests/concurrency/actors/pingpong.cfa
===================================================================
--- tests/concurrency/actors/pingpong.cfa	(revision 50be8af55788ecaebbb85845d1e11234cd6a5cb6)
+++ tests/concurrency/actors/pingpong.cfa	(revision 7edf912cbd74d5e5c4d9fd1c37e98e4fe117e7a4)
@@ -10,8 +10,9 @@
 
 struct p_msg {
-    inline message;
-    size_t count;
+	inline message;
+	size_t count;
 };
-static inline void ?{}( p_msg & this ) { ((message &)this){}; this.count = 0; }
+//static inline void ?{}( p_msg & this ) { ((message &)this){}; this.count = 0; }
+static inline void ?{}( p_msg & this ) { this.count = 0; }
 
 ping * pi;
@@ -20,21 +21,21 @@
 
 allocation receive( ping & receiver, p_msg & msg ) {
-    msg.count++;
-    if ( msg.count > times ) return Finished;
+	msg.count++;
+	if ( msg.count > times ) return Finished;
 
-    allocation retval = Nodelete;
-    if ( msg.count == times ) retval = Finished;
-    *po | msg;
-    return retval;
+	allocation retval = Nodelete;
+	if ( msg.count == times ) retval = Finished;
+	*po | msg;
+	return retval;
 }
 
 allocation receive( pong & receiver, p_msg & msg ) {
-    msg.count++;
-    if ( msg.count > times ) return Finished;
-    
-    allocation retval = Nodelete;
-    if ( msg.count == times ) retval = Finished;
-    *pi | msg;
-    return retval;
+	msg.count++;
+	if ( msg.count > times ) return Finished;
+	
+	allocation retval = Nodelete;
+	if ( msg.count == times ) retval = Finished;
+	*pi | msg;
+	return retval;
 }
 
@@ -42,18 +43,17 @@
 
 int main( int argc, char * argv[] ) {
-    sout | "start";
+	sout | "start";
 
-    processor p[Processors - 1];
+	processor p[Processors - 1];
 
-    start_actor_system( Processors ); // test passing number of processors
+	start_actor_system( Processors ); // test passing number of processors
+	ping pi_actor;
+	pong po_actor;
+	po = &po_actor;
+	pi = &pi_actor;
+	p_msg m;
+	pi_actor | m;
+	stop_actor_system();
 
-    ping pi_actor;
-    pong po_actor;
-    po = &po_actor;
-    pi = &pi_actor;
-    p_msg m;
-    pi_actor | m;
-    stop_actor_system();
-
-    sout | "end";
+	sout | "end";
 }
Index: tests/concurrency/actors/poison.cfa
===================================================================
--- tests/concurrency/actors/poison.cfa	(revision 50be8af55788ecaebbb85845d1e11234cd6a5cb6)
+++ tests/concurrency/actors/poison.cfa	(revision 7edf912cbd74d5e5c4d9fd1c37e98e4fe117e7a4)
@@ -11,40 +11,39 @@
 
 int main() {
-    sout | "Start";
+	sout | "Start";
 
-    sout | "Finished";
-    {
-        start_actor_system();
-        Server s[10];
-        for ( i; 10 ) {
-            s[i] | finished_msg;
-        }
-        stop_actor_system();
-    }
+	sout | "Finished";
+	{
+		start_actor_system();
+		Server s[10];
+		for ( i; 10 ) {
+			s[i] | finished_msg;
+		}
+		stop_actor_system();
+	}
 
-    sout | "Delete";
-    {
-        start_actor_system();
-        for ( i; 10 ) {
-            Server * s = alloc();
-            (*s){};
-            (*s) | delete_msg;
-        }
-        stop_actor_system();
-    }
+	sout | "Delete";
+	{
+		start_actor_system();
+		for ( i; 10 ) {
+			Server * s = alloc();
+			(*s){};
+			(*s) | delete_msg;
+		}
+		stop_actor_system();
+	}
 
-    sout | "Destroy";
-    {
-        start_actor_system();
-        Server s[10];
-        for ( i; 10 )
-            s[i] | destroy_msg;
-        stop_actor_system();
-        for ( i; 10 )
-            if (s[i].val != 777)
-                sout | "Error: dtor not called correctly.";
-    }
+	sout | "Destroy";
+	{
+		start_actor_system();
+		Server s[10];
+		for ( i; 10 )
+			s[i] | destroy_msg;
+		stop_actor_system();
+		for ( i; 10 )
+			if (s[i].val != 777)
+				sout | "Error: dtor not called correctly.";
+	}
 
-    sout | "Done";
-    return 0;
+	sout | "Done";
 }
Index: tests/concurrency/actors/static.cfa
===================================================================
--- tests/concurrency/actors/static.cfa	(revision 50be8af55788ecaebbb85845d1e11234cd6a5cb6)
+++ tests/concurrency/actors/static.cfa	(revision 7edf912cbd74d5e5c4d9fd1c37e98e4fe117e7a4)
@@ -9,26 +9,26 @@
 struct derived_actor { inline actor; };
 struct derived_msg {
-    inline message;
-    int cnt;
+	inline message;
+	int cnt;
 };
 
 void ?{}( derived_msg & this, int cnt ) {
-    ((message &) this){ Nodelete };
-    this.cnt = cnt;
+	set_allocation( this, Nodelete );
+	this.cnt = cnt;
 }
 void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
 
 allocation receive( derived_actor & receiver, derived_msg & msg ) {
-    if ( msg.cnt >= Times ) {
-        sout | "Done";
-        return Finished;
-    }
-    msg.cnt++;
-    receiver | msg;
-    return Nodelete;
+	if ( msg.cnt >= Times ) {
+		sout | "Done";
+		return Finished;
+	}
+	msg.cnt++;
+	receiver | msg;
+	return Nodelete;
 }
 
 int main( int argc, char * argv[] ) {
-    switch ( argc ) {
+	switch ( argc ) {
 	  case 2:
 		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
@@ -42,23 +42,21 @@
 	} // switch
 
-    sout | "starting";
+	sout | "starting";
 
-    executor e{ 0, 1, 1, false };
-    start_actor_system( e );
+	executor e{ 0, 1, 1, false };
+	start_actor_system( e );
 
-    sout | "started";
+	sout | "started";
 
-    derived_msg msg;
+	derived_msg msg;
 
-    derived_actor actor;
+	derived_actor actor;
 
-    actor | msg;
+	actor | msg;
 
-    sout | "stopping";
+	sout | "stopping";
 
-    stop_actor_system();
+	stop_actor_system();
 
-    sout | "stopped";
-
-    return 0;
+	sout | "stopped";
 }
Index: tests/concurrency/actors/types.cfa
===================================================================
--- tests/concurrency/actors/types.cfa	(revision 50be8af55788ecaebbb85845d1e11234cd6a5cb6)
+++ tests/concurrency/actors/types.cfa	(revision 7edf912cbd74d5e5c4d9fd1c37e98e4fe117e7a4)
@@ -9,34 +9,34 @@
 
 struct derived_actor {
-    inline actor;
-    int counter;
+	inline actor;
+	int counter;
 };
 static inline void ?{}( derived_actor & this ) { ((actor &)this){}; this.counter = 0; }
 
 struct d_msg {
-    inline message;
-    int num;
+	inline message;
+	int num;
 };
 
 // this isn't a valid receive routine since int is not a message type
 allocation receive( derived_actor & receiver, int i ) with( receiver ) {
-    mutex(sout) sout | i;
-    counter++;
-    if ( counter == 2 ) return Finished;
-    return Nodelete; 
+	mutex(sout) sout | i;
+	counter++;
+	if ( counter == 2 ) return Finished;
+	return Nodelete; 
 }
 
 allocation receive( derived_actor & receiver, d_msg & msg ) {
-    return receive( receiver, msg.num );
+	return receive( receiver, msg.num );
 }
 
 struct derived_actor2 {
-    struct nested { int i; }; // testing nested before inline
-    inline actor;
+	struct nested { int i; }; // testing nested before inline
+	inline actor;
 };
 
 allocation receive( derived_actor2 & receiver, d_msg & msg ) {
-    mutex(sout) sout | msg.num;
-    return Finished;
+	mutex(sout) sout | msg.num;
+	return Finished;
 }
 
@@ -44,17 +44,17 @@
 struct derived_actor4 { inline derived_actor3; };
 struct d_msg2 {
-    inline message;
-    int num;
+	inline message;
+	int num;
 };
 
 allocation receive( derived_actor3 & receiver, d_msg & msg ) {
-    mutex(sout) sout | msg.num;
-    if ( msg.num == -1 ) return Nodelete;
-    return Finished;
+	mutex(sout) sout | msg.num;
+	if ( msg.num == -1 ) return Nodelete;
+	return Finished;
 }
 
 allocation receive( derived_actor3 & receiver, d_msg2 & msg ) {
-    mutex(sout) sout | msg.num;
-    return Finished;
+	mutex(sout) sout | msg.num;
+	return Finished;
 }
 
@@ -62,66 +62,66 @@
 
 int main( int argc, char * argv[] ) {
-    sout | "start";
+	sout | "start";
 
-    processor p[Processors - 1];
+	processor p[Processors - 1];
 
-    sout | "basic test"; 
-    start_actor_system( Processors ); // test passing number of processors
-    derived_actor a;
-    d_msg b, c;
-    b.num = 1;
-    c.num = 2;
-    a | b | c;
-    stop_actor_system();
+	sout | "basic test"; 
+	start_actor_system( Processors ); // test passing number of processors
+	derived_actor a;
+	d_msg b, c;
+	b.num = 1;
+	c.num = 2;
+	a | b | c;
+	stop_actor_system();
 
-    sout | "same message and different actors test";
-    start_actor_system(); // let system detect # of processors
-    derived_actor2 d_ac2_0, d_ac2_1;
-    d_msg d_ac2_msg;
-    d_ac2_msg.num = 3;
-    d_ac2_0 | d_ac2_msg;
-    d_ac2_1 | d_ac2_msg;
-    stop_actor_system();
+	sout | "same message and different actors test";
+	start_actor_system(); // let system detect # of processors
+	derived_actor2 d_ac2_0, d_ac2_1;
+	d_msg d_ac2_msg;
+	d_ac2_msg.num = 3;
+	d_ac2_0 | d_ac2_msg;
+	d_ac2_1 | d_ac2_msg;
+	stop_actor_system();
 
-    
-    {
-        sout | "same message and different actor types test";
-        executor e{ 0, Processors, Processors == 1 ? 1 : Processors * 4, false };
-        start_actor_system( e ); // pass an explicit executor
-        derived_actor2 d_ac2_2;
-        derived_actor3 d_ac3_0;
-        d_msg d_ac23_msg;
-        d_ac23_msg.num = 4;
-        d_ac3_0 | d_ac23_msg;
-        d_ac2_2 | d_ac23_msg;
-        stop_actor_system();
-    } // RAII to clean up executor
+	
+	{
+		sout | "same message and different actor types test";
+		executor e{ 0, Processors, Processors == 1 ? 1 : Processors * 4, false };
+		start_actor_system( e ); // pass an explicit executor
+		derived_actor2 d_ac2_2;
+		derived_actor3 d_ac3_0;
+		d_msg d_ac23_msg;
+		d_ac23_msg.num = 4;
+		d_ac3_0 | d_ac23_msg;
+		d_ac2_2 | d_ac23_msg;
+		stop_actor_system();
+	} // RAII to clean up executor
 
-    {
-        sout | "different message types, one actor test";
-        executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
-        start_actor_system( Processors );
-        derived_actor3 a3;
-        d_msg b1;
-        d_msg2 c2;
-        b1.num = -1;
-        c2.num = 5;
-        a3 | b1 | c2;
-        stop_actor_system();
-    } // RAII to clean up executor
+	{
+		sout | "different message types, one actor test";
+		executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
+		start_actor_system( Processors );
+		derived_actor3 a3;
+		d_msg b1;
+		d_msg2 c2;
+		b1.num = -1;
+		c2.num = 5;
+		a3 | b1 | c2;
+		stop_actor_system();
+	} // RAII to clean up executor
 
-    {
-        sout | "nested inheritance actor test";
-        executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
-        start_actor_system( Processors );
-        derived_actor4 a4;
-        d_msg b1;
-        d_msg2 c2;
-        b1.num = -1;
-        c2.num = 5;
-        a4 | b1 | c2;
-        stop_actor_system();
-    } // RAII to clean up executor
+	{
+		sout | "nested inheritance actor test";
+		executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
+		start_actor_system( Processors );
+		derived_actor4 a4;
+		d_msg b1;
+		d_msg2 c2;
+		b1.num = -1;
+		c2.num = 5;
+		a4 | b1 | c2;
+		stop_actor_system();
+	} // RAII to clean up executor
 
-    sout | "end";
+	sout | "end";
 }