Index: translator/Tuples/AssignExpand.cc
===================================================================
--- translator/Tuples/AssignExpand.cc	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/Tuples/AssignExpand.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
@@ -24,5 +24,5 @@
     CompoundStmt *newSt = 0;
     if (! extra.empty() ) {
-      if ( !newSt )
+      if ( ! newSt )
 	newSt= new CompoundStmt(std::list<Label>());
 
@@ -31,5 +31,5 @@
 
     if (! extra2.empty() ) {
-      if ( !newSt )
+      if ( ! newSt )
 	newSt= new CompoundStmt(std::list<Label>());
 
@@ -38,5 +38,5 @@
 
     if (! replace.empty() ) {
-      if ( !newSt )
+      if ( ! newSt )
 	newSt= new CompoundStmt(std::list<Label>());
 
@@ -45,5 +45,5 @@
     }
 
-    if( newSt ) return newSt; else return exprStmt;
+    if ( newSt ) return newSt; else return exprStmt;
   }
 
@@ -72,9 +72,9 @@
 		   tupleExpr->get_type() == SolvedTupleExpr::MASS ) */ {
       std::list<Expression *> &comps = tupleExpr->get_exprs();
-      for( std::list<Expression *>::iterator i = comps.begin(); i != comps.end(); ++i ) {
+      for ( std::list<Expression *>::iterator i = comps.begin(); i != comps.end(); ++i ) {
 	std::list<Statement *> decls;
 	std::list<Statement *> temps;
 	std::list<Statement *> assigns;
-	if( ApplicationExpr *app = dynamic_cast< ApplicationExpr * >(*i) ) {
+	if ( ApplicationExpr *app = dynamic_cast< ApplicationExpr * >(*i) ) {
 	  assert( app->get_args().size() == 2 );
 
Index: translator/Tuples/FunctionChecker.cc
===================================================================
--- translator/Tuples/FunctionChecker.cc	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/Tuples/FunctionChecker.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
@@ -23,6 +23,6 @@
 
   FunctionChecker::FunctionChecker( bool _topLevel, UniqueName *_nameGen ) : topLevel( _topLevel ), nameGen( _nameGen ) {
-    if( topLevel) {
-      assert( !nameGen );
+    if ( topLevel) {
+      assert( ! nameGen );
       nameGen = new UniqueName("_MVR_");
     } else
@@ -31,5 +31,5 @@
 
   FunctionChecker::~FunctionChecker() {
-    if( topLevel) {
+    if ( topLevel) {
       delete nameGen;
       nameGen = 0;
@@ -39,12 +39,12 @@
   Statement* FunctionChecker::mutate(ExprStmt *exprStmt) {
     exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
-    if ( !tempExpr.empty() ) {
-      assert ( !temporaries.empty() );
+    if ( ! tempExpr.empty() ) {
+      assert ( ! temporaries.empty() );
       CompoundStmt *newBlock = new CompoundStmt( std::list< Label >() );
       // declarations
-      for( std::list< ObjectDecl *>::iterator d = temporaries.begin(); d != temporaries.end(); ++d )
+      for ( std::list< ObjectDecl *>::iterator d = temporaries.begin(); d != temporaries.end(); ++d )
 	newBlock->get_kids().push_back( new DeclStmt( std::list<Label>(), *d ) );
       // new expression statements
-      for( std::list< Expression *>::iterator e = tempExpr.begin(); e != tempExpr.end(); ++e )
+      for ( std::list< Expression *>::iterator e = tempExpr.begin(); e != tempExpr.end(); ++e )
 	newBlock->get_kids().push_back( new ExprStmt( std::list<Label>(), *e ) );
 
@@ -69,12 +69,12 @@
 
     std::list< Expression * > newArgs;
-    for( std::list< Expression *>::iterator e = applicationExpr->get_args().begin(); e != applicationExpr->get_args().end(); ++e ) {
+    for ( std::list< Expression *>::iterator e = applicationExpr->get_args().begin(); e != applicationExpr->get_args().end(); ++e ) {
       FunctionChecker rec( false, nameGen );
       (*e)->acceptMutator( rec );
 
-      if ( !rec.temporaries.empty() ) {
+      if ( ! rec.temporaries.empty() ) {
 	TupleExpr *lhs = new TupleExpr;
 	std::list< Expression * > &tmem = lhs->get_exprs();
-	for( std::list<ObjectDecl *>::iterator d = rec.temporaries.begin();  d != rec.temporaries.end(); ++d ) {
+	for ( std::list<ObjectDecl *>::iterator d = rec.temporaries.begin();  d != rec.temporaries.end(); ++d ) {
 	  tmem.push_back( new VariableExpr( *d ) );
 	  newArgs.push_back( new VariableExpr( *d ) );
@@ -100,12 +100,12 @@
 
   Expression* TupleDistrib::mutate(UntypedExpr *expr) {
-    if(  NameExpr *assgnop = dynamic_cast< NameExpr * >(expr->get_function()) ) {
-      if( assgnop->get_name() == std::string("?=?") ) {
+    if (  NameExpr *assgnop = dynamic_cast< NameExpr * >(expr->get_function()) ) {
+      if ( assgnop->get_name() == std::string("?=?") ) {
 	std::list<Expression *> &args = expr->get_args();
 	assert(args.size() == 2);
 	//if args.front() points to a tuple and if args.back() is already resolved
-	if( AddressExpr *addr = dynamic_cast<AddressExpr *>(args.front()) )
-	  if( TupleExpr *lhs = dynamic_cast<TupleExpr *>(addr->get_arg()) )
-	    if( ApplicationExpr *rhs = dynamic_cast<ApplicationExpr *>( args.back() ) ) {
+	if ( AddressExpr *addr = dynamic_cast<AddressExpr *>(args.front()) )
+	  if ( TupleExpr *lhs = dynamic_cast<TupleExpr *>(addr->get_arg()) )
+	    if ( ApplicationExpr *rhs = dynamic_cast<ApplicationExpr *>( args.back() ) ) {
 	      for ( std::list<Expression *>::iterator tc = lhs->get_exprs().begin(); tc != lhs->get_exprs().end(); ++tc )
 		rhs->get_args().push_back( new AddressExpr( *tc ) );
Index: translator/Tuples/FunctionFixer.cc
===================================================================
--- translator/Tuples/FunctionFixer.cc	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/Tuples/FunctionFixer.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
@@ -40,11 +40,11 @@
     Expression *rhs = 0;
     // also check if returning multiple values
-    if( CastExpr *cst = dynamic_cast<CastExpr *>( retStmt->get_expr() ) ) {
-      if( ApplicationExpr *app = dynamic_cast<ApplicationExpr *>( cst->get_arg() ) ) {
-	if( app->get_results().size() > 1 ) { // doesn't need to be ApplicationExpr
+    if ( CastExpr *cst = dynamic_cast<CastExpr *>( retStmt->get_expr() ) ) {
+      if ( ApplicationExpr *app = dynamic_cast<ApplicationExpr *>( cst->get_arg() ) ) {
+	if ( app->get_results().size() > 1 ) { // doesn't need to be ApplicationExpr
 	  tupleReturn = true;
 	  rhs = app;
 	}
-      } else if( TupleExpr *t = dynamic_cast<TupleExpr *>( cst->get_arg() ) ) {
+      } else if ( TupleExpr *t = dynamic_cast<TupleExpr *>( cst->get_arg() ) ) {
 	tupleReturn = true;
 	assert( rets.size() == t->get_exprs().size() ); // stupid check, resolve expression
@@ -52,8 +52,8 @@
       }
 
-      if( tupleReturn ) {
+      if ( tupleReturn ) {
 	assert ( rhs != 0 );
 	std::list< Expression * > lhs;
-	for( std::list< DeclarationWithType * >::iterator d = rets.begin(); d != rets.end(); ++d ) {
+	for ( std::list< DeclarationWithType * >::iterator d = rets.begin(); d != rets.end(); ++d ) {
 	  std::list<Expression *> largs;
 	  largs.push_back(new VariableExpr( *d ));
@@ -81,5 +81,5 @@
     if ( rets.empty() ) return variableExpr;
     mutateAll( variableExpr->get_results(), *this );
-    if( std::find( rets.begin(), rets.end(), variableExpr->get_var() ) != rets.end() )
+    if ( std::find( rets.begin(), rets.end(), variableExpr->get_var() ) != rets.end() )
 //      if ( PointerType *ptr = dynamic_cast<PointerType *>(variableExpr->get_var()->get_type()) ) {
       if ( dynamic_cast<PointerType *>(variableExpr->get_var()->get_type()) != 0 ) {
@@ -88,5 +88,5 @@
 	  Expression *expr = ResolvExpr::resolveInVoidContext( /*new CastExpr(*/new UntypedExpr( new NameExpr( "*?" ), largs )/*,
 																 ptr->get_base()),*/, index);
-	  if( ApplicationExpr *app = dynamic_cast< ApplicationExpr * >( expr ) ) {
+	  if ( ApplicationExpr *app = dynamic_cast< ApplicationExpr * >( expr ) ) {
 	    assert( app->get_args().size() == 1 );
 	    app->get_args().pop_front();
Index: translator/Tuples/MultRet.cc
===================================================================
--- translator/Tuples/MultRet.cc	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/Tuples/MultRet.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
@@ -35,10 +35,10 @@
       // copy variables
       Statements &vars = toplevel.getVars()->get_kids();
-      for( Statements::iterator i = vars.begin(); i != vars.end(); i++ )
+      for ( Statements::iterator i = vars.begin(); i != vars.end(); i++ )
 	code->get_kids().push_back( *i );
 
       // copy statements
       Statements &block = toplevel.getCode()->get_kids();
-      for( Statements::iterator i = block.begin(); i != block.end(); i++ )
+      for ( Statements::iterator i = block.begin(); i != block.end(); i++ )
 	code->get_kids().push_back( *i );
 
@@ -66,5 +66,5 @@
       mulretp = true;
 
-      if( newVars == 0 )
+      if ( newVars == 0 )
 	newVars = new CompoundStmt( std::list<Label>(0) );
 
@@ -81,5 +81,5 @@
     Exprs &args = appExpr->get_args();
     std::list< Expression * > newArgs;
-    for( Exprs::iterator i = args.begin(); i != args.end(); i++ ) {
+    for ( Exprs::iterator i = args.begin(); i != args.end(); i++ ) {
       MVRMutator next;
       Expression *mutated = (*i)->acceptMutator( next );
@@ -93,10 +93,10 @@
 	if (newVars == 0)
 	  newVars = new CompoundStmt( std::list< Label >() );
-	for( Stmts::iterator i = vars.begin(); i != vars.end(); i++ )  // std::splice? -- need to append lists
+	for ( Stmts::iterator i = vars.begin(); i != vars.end(); i++ )  // std::splice? -- need to append lists
 	  newVars->get_kids().push_back( *i );
 
 	if (newCode == 0)
 	  newCode = new CompoundStmt( std::list< Label >() );
-	for( Stmts::iterator i = block.begin(); i != block.end(); i++ )
+	for ( Stmts::iterator i = block.begin(); i != block.end(); i++ )
 	  newCode->get_kids().push_back( *i );
 
@@ -105,5 +105,5 @@
       if ( next.hasResults() ) {
 	Exprs &res = next.get_results();
-	for( Exprs::iterator i = res.begin(); i != res.end(); i++ )
+	for ( Exprs::iterator i = res.begin(); i != res.end(); i++ )
 	  newArgs.push_back( *i );
       } else
@@ -117,5 +117,5 @@
       // add 'out' parameters
       if ( ! argsToAdd.empty() )
-	for(std::list< Expression *>::iterator i = argsToAdd.begin(); i != argsToAdd.end(); i++)
+	for (std::list< Expression *>::iterator i = argsToAdd.begin(); i != argsToAdd.end(); i++)
 	  (appExpr->get_args()).push_back( *i );
       // clear 'out' parameters ( so that the list can be reused -- substitute by auto_ptr later? )
Index: translator/Tuples/NameMatcher.cc
===================================================================
--- translator/Tuples/NameMatcher.cc	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/Tuples/NameMatcher.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
@@ -6,5 +6,5 @@
     : current( 0 ) {
     int cnt = 0;
-    for( std::list< DeclarationWithType *>::const_iterator f = formals.begin(); f != formals.end(); ++f ) {
+    for ( std::list< DeclarationWithType *>::const_iterator f = formals.begin(); f != formals.end(); ++f ) {
       table.insert( std::pair< std::string, int >( (*f)->get_name(), cnt++ ) );
       index.push_back(*f);
@@ -16,9 +16,9 @@
 
   void NameMatcher::match( ResolvExpr::AltList &alternatives ) throw (NoMatch) {
-    if( alternatives.size() != index.size() )
+    if ( alternatives.size() != index.size() )
       throw NoMatch("Length of actuals and formals differ");
 
-    for( ResolvExpr::AltList::const_iterator a = alternatives.begin(); a != alternatives.end(); ++a ) {
-      if( a->expr->get_argName() != 0 )
+    for ( ResolvExpr::AltList::const_iterator a = alternatives.begin(); a != alternatives.end(); ++a ) {
+      if ( a->expr->get_argName() != 0 )
 	if ( NameExpr *name = dynamic_cast<NameExpr *>( a->expr->get_argName() ) ) {
 	  if ( table.find( name->get_name() ) != table.end() ) {
@@ -27,5 +27,5 @@
 	  } else
 	    throw NoMatch( name->get_name() + "no such  designation" );
-	} /*else if( TupleExpr *tup = dynamic_cast<TupleExpr *>( a->expr->get_argName() ) )
+	} /*else if ( TupleExpr *tup = dynamic_cast<TupleExpr *>( a->expr->get_argName() ) )
 	    std::cerr << "Designated expression" << std::endl; */
       exprs.push_back( &(*a) );
@@ -41,5 +41,5 @@
 
   ResolvExpr::Alternative &NameMatcher::get_next() throw (NoMoreElements) {
-    if( current++ >= (int)(index.size()) )
+    if ( current++ >= (int)(index.size()) )
       throw NoMoreElements();
     return *(new ResolvExpr::Alternative());
Index: translator/Tuples/TupleAssignment.cc
===================================================================
--- translator/Tuples/TupleAssignment.cc	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/Tuples/TupleAssignment.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
@@ -19,6 +19,6 @@
   bool TupleAssignSpotter::pointsToTuple( Expression *expr ) {
     // also check for function returning tuple of reference types
-    if(AddressExpr *addr = dynamic_cast<AddressExpr *>(expr) )
-      if( isTuple(addr->get_arg() ) )
+    if (AddressExpr *addr = dynamic_cast<AddressExpr *>(expr) )
+      if ( isTuple(addr->get_arg() ) )
 	return true;
     return false;
@@ -26,5 +26,5 @@
 
   bool TupleAssignSpotter::isTupleVar( DeclarationWithType *decl ) {
-    if( dynamic_cast<TupleType *>(decl->get_type()) )
+    if ( dynamic_cast<TupleType *>(decl->get_type()) )
       return true;
     return false;
@@ -33,10 +33,10 @@
   bool TupleAssignSpotter::isTuple( Expression *expr, bool isRight ) {
     // true if `expr' is an expression returning a tuple: tuple, tuple variable or MRV function
-    if ( !expr ) return false;
-
-    if( dynamic_cast<TupleExpr *>(expr) )
-      return true;
-    else if( VariableExpr *var = dynamic_cast<VariableExpr *>(expr) ) {
-      if( isTupleVar(var->get_var()) )
+    if ( ! expr ) return false;
+
+    if ( dynamic_cast<TupleExpr *>(expr) )
+      return true;
+    else if ( VariableExpr *var = dynamic_cast<VariableExpr *>(expr) ) {
+      if ( isTupleVar(var->get_var()) )
 	return true;
     }
@@ -52,7 +52,7 @@
       return false;
 
-    if( new_assigns.empty() ) return false;
+    if ( new_assigns.empty() ) return false;
     /*return */matcher->solve( new_assigns );
-    if( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
+    if ( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
       // now resolve new assignments
       std::list< Expression * > solved_assigns;
@@ -61,5 +61,5 @@
 
       ResolvExpr::AltList current;
-      for( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+      for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
 	//try {
 	ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
@@ -80,5 +80,5 @@
       return true;
     } else { // mass assignment
-      //if( new_assigns.empty() ) return false;
+      //if ( new_assigns.empty() ) return false;
       std::list< Expression * > solved_assigns;
       ResolvExpr::AltList solved_alts;
@@ -87,9 +87,9 @@
       ResolvExpr::AltList current;
       if ( optMass.empty() ) {
-	for( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
+	for ( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
 	  optMass.push_back( ResolvExpr::AltList() );
       }
       int cnt = 0;
-      for( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
+      for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
 
 	ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
@@ -110,5 +110,5 @@
 
   bool TupleAssignSpotter::isMVR( Expression *expr ) {
-    if( expr->get_results().size() > 1 ) {
+    if ( expr->get_results().size() > 1 ) {
       // MVR processing
       return true;
@@ -118,17 +118,17 @@
 
   bool TupleAssignSpotter::isTupleAssignment( UntypedExpr * expr, std::list<ResolvExpr::AltList> &possibilities ) {
-    if(  NameExpr *assgnop = dynamic_cast< NameExpr * >(expr->get_function()) ) {
-
-      if( assgnop->get_name() == std::string("?=?") ) {
-
-	for( std::list<ResolvExpr::AltList>::iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
+    if (  NameExpr *assgnop = dynamic_cast< NameExpr * >(expr->get_function()) ) {
+
+      if ( assgnop->get_name() == std::string("?=?") ) {
+
+	for ( std::list<ResolvExpr::AltList>::iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
 	  assert( ali->size() == 2 );
 	  ResolvExpr::AltList::iterator opit = ali->begin();
 	  ResolvExpr::Alternative op1 = *opit, op2 = *(++opit);
 
-	  if( pointsToTuple(op1.expr) ) { // also handles tuple vars
+	  if ( pointsToTuple(op1.expr) ) { // also handles tuple vars
 	    if ( isTuple( op2.expr, true ) )
 	      matcher = new MultipleAssignMatcher(op1.expr, op2.expr);
-	    else if( isMVR( op2.expr ) ) {
+	    else if ( isMVR( op2.expr ) ) {
 	      // handle MVR differently
 	    } else
@@ -137,7 +137,7 @@
 
 	    std::list< ResolvExpr::AltList > options;
-	    if( match() )
+	    if ( match() )
 	      /*
-	      if( hasMatched ) {
+	      if ( hasMatched ) {
 		// throw SemanticError("Ambiguous tuple assignment");
 	      } else {*/
@@ -150,11 +150,11 @@
 	}
 
-	if( hasMatched ) {
-	  if( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
+	if ( hasMatched ) {
+	  if ( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
 	    //options.print( std::cerr );
 	    std::list< ResolvExpr::AltList >best = options.get_best();
-	    if( best.size() == 1 ) {
+	    if ( best.size() == 1 ) {
 	      std::list<Expression *> solved_assigns;
-	      for( ResolvExpr::AltList::iterator i = best.front().begin(); i != best.front().end(); ++i ){
+	      for ( ResolvExpr::AltList::iterator i = best.front().begin(); i != best.front().end(); ++i ){
 		solved_assigns.push_back( i->expr );
 	      }
@@ -165,9 +165,9 @@
 	    assert(! optMass.empty() );
 	    ResolvExpr::AltList winners;
-	    for( std::vector< ResolvExpr::AltList >::iterator i = optMass.begin(); i != optMass.end(); ++i )
+	    for ( std::vector< ResolvExpr::AltList >::iterator i = optMass.begin(); i != optMass.end(); ++i )
 	      findMinCostAlt( i->begin(), i->end(), back_inserter(winners) );
 
 	    std::list< Expression *> solved_assigns;
-	    for( ResolvExpr::AltList::iterator i = winners.begin(); i != winners.end(); ++i )
+	    for ( ResolvExpr::AltList::iterator i = winners.begin(); i != winners.end(); ++i )
 	      solved_assigns.push_back( i->expr );
 	    currentFinder->get_alternatives().push_front( ResolvExpr::Alternative(new SolvedTupleExpr(solved_assigns/*, SolvedTupleExpr::MASS*/), currentFinder->get_environ(), ResolvExpr::Cost() ) );
@@ -181,6 +181,6 @@
   void TupleAssignSpotter::Matcher::init( Expression *_lhs, Expression *_rhs ) {
     lhs.clear();
-    if(AddressExpr *addr = dynamic_cast<AddressExpr *>(_lhs) )
-      if( TupleExpr *tuple = dynamic_cast<TupleExpr *>(addr->get_arg()) )
+    if (AddressExpr *addr = dynamic_cast<AddressExpr *>(_lhs) )
+      if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(addr->get_arg()) )
 	std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(lhs) );
 
@@ -195,5 +195,5 @@
     init(_lhs,_rhs);
 
-    if( TupleExpr *tuple = dynamic_cast<TupleExpr *>(_rhs) )
+    if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(_rhs) )
       std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(rhs) );
   }
@@ -211,5 +211,5 @@
     if ( lhs.empty() || (rhs.size() != 1) ) return false;
 
-    for( std::list< Expression * >::iterator l = lhs.begin(); l != lhs.end(); l++ ) {
+    for ( std::list< Expression * >::iterator l = lhs.begin(); l != lhs.end(); l++ ) {
       std::list< Expression * > args;
       args.push_back( new AddressExpr(*l) );
@@ -229,9 +229,9 @@
     ResolvExpr::AltList current;
     if ( optMass.empty() ) {
-      for( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
+      for ( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
 	optMass.push_back( ResolvExpr::AltList() );
     }
     int cnt = 0;
-    for( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
+    for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
 
       ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
@@ -250,5 +250,5 @@
   bool TupleAssignSpotter::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
     // need more complicated matching
-    if( lhs.size() == rhs.size() ) {
+    if ( lhs.size() == rhs.size() ) {
       zipWith( lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), back_inserter(out), TupleAssignSpotter::Matcher::createAssgn );
       return true;
@@ -265,5 +265,5 @@
 
     ResolvExpr::AltList current;
-    for( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+    for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
       //try {
       ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
@@ -297,9 +297,9 @@
     // transpose matrix
     if ( costMatrix.empty() )
-      for( unsigned int i = 0; i< opt.size(); ++i)
+      for ( unsigned int i = 0; i< opt.size(); ++i)
 	costMatrix.push_back( vector<ResolvExpr::Cost>() );
 
     int cnt = 0;
-    for( ResolvExpr::AltList::iterator i = opt.begin(); i != opt.end(); ++i, cnt++ )
+    for ( ResolvExpr::AltList::iterator i = opt.begin(); i != opt.end(); ++i, cnt++ )
       costMatrix[cnt].push_back( i->cost );
 
@@ -312,5 +312,5 @@
     list< ResolvExpr::AltList > ret;
     list< multiset<int> > solns;
-    for( vector< vector<Cost> >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
+    for ( vector< vector<Cost> >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
       list<int> current;
       findMinCost( i->begin(), i->end(), back_inserter(current) );
@@ -320,5 +320,5 @@
     multiset<int> result;
     lift_intersection( solns.begin(), solns.end(), inserter( result, result.begin() ) );
-    if( result.size() != 1 )
+    if ( result.size() != 1 )
       throw SemanticError("Ambiguous tuple expression");
     ret.push_back(get_option( *(result.begin() )));
@@ -329,6 +329,6 @@
     using namespace std;
 
-    for( vector< vector < ResolvExpr::Cost > >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
-      for( vector < ResolvExpr::Cost >::iterator j = i->begin(); j != i->end(); ++j )
+    for ( vector< vector < ResolvExpr::Cost > >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
+      for ( vector < ResolvExpr::Cost >::iterator j = i->begin(); j != i->end(); ++j )
 	ostr << *j << " " ;
       ostr << std::endl;
@@ -352,10 +352,10 @@
     Cost minCost = Cost::infinity;
     unsigned int index = 0;
-    for( InputIterator i = begin; i != end; ++i, index++ ) {
-      if( *i < minCost ) {
+    for ( InputIterator i = begin; i != end; ++i, index++ ) {
+      if ( *i < minCost ) {
         minCost = *i;
         alternatives.clear();
         alternatives.push_back( index );
-      } else if( *i == minCost ) {
+      } else if ( *i == minCost ) {
         alternatives.push_back( index );
       }
@@ -366,8 +366,8 @@
   template< class InputIterator, class OutputIterator >
   void TupleAssignSpotter::Options::lift_intersection( InputIterator begin, InputIterator end, OutputIterator out ){
-    if( begin == end ) return;
+    if ( begin == end ) return;
     InputIterator test = begin;
 
-    if(++test == end)
+    if (++test == end)
       { copy(begin->begin(), begin->end(), out); return; }
 
@@ -376,5 +376,5 @@
     copy( begin->begin(), begin->end(), inserter( cur, cur.begin() ) );
 
-    while( test != end ) {
+    while ( test != end ) {
       std::multiset<int> temp;
       set_intersection( cur.begin(), cur.end(), test->begin(), test->end(), inserter(temp,temp.begin()) );
@@ -390,8 +390,8 @@
 
   ResolvExpr::AltList TupleAssignSpotter::Options::get_option( std::list< ResolvExpr::AltList >::size_type index ) {
-    if( index >= options.size() )
+    if ( index >= options.size() )
       throw 0; // XXX
     std::list< ResolvExpr::AltList >::iterator it = options.begin();
-    for( std::list< ResolvExpr::AltList >::size_type i = 0; i < index; ++i, ++it );
+    for ( std::list< ResolvExpr::AltList >::size_type i = 0; i < index; ++i, ++it );
     return *it;
   }
Index: translator/Tuples/TupleAssignment.h
===================================================================
--- translator/Tuples/TupleAssignment.h	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/Tuples/TupleAssignment.h	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
@@ -102,11 +102,11 @@
     // select the alternatives that have the minimum parameter cost
     Cost minCost = Cost::infinity;
-    for( AltList::iterator i = begin; i != end; ++i ) {
-      if( i->cost < minCost ) {
+    for ( AltList::iterator i = begin; i != end; ++i ) {
+      if ( i->cost < minCost ) {
         minCost = i->cost;
         i->cost = i->cvtCost;
         alternatives.clear();
         alternatives.push_back( *i );
-      } else if( i->cost == minCost ) {
+      } else if ( i->cost == minCost ) {
         i->cost = i->cvtCost;
         alternatives.push_back( *i );