Index: src/ControlStruct/MLEMutator.cc
===================================================================
--- src/ControlStruct/MLEMutator.cc	(revision 6a37d13df78628db4154171dbe8466281b284003)
+++ src/ControlStruct/MLEMutator.cc	(revision 3f869f0ffd7b467d53412bd6d1ddf2097487e768)
@@ -9,15 +9,14 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Mon Jul 20 13:58:35 2015
-// Update Count     : 176
-//
-
-// NOTE: There are two known subtle differences from the code that uC++
-// generates for the same input
-// -CFA puts the break label inside at the end of a switch, uC++ puts it after
-// -CFA puts the break label after a block, uC++ puts it inside at the end
-// we don't yet know if these differences are important, but if they are then
-// the fix would go in this file, since this is where these labels are generated.
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jul  6 17:40:02 2016
+// Update Count     : 196
+//
+
+// NOTE: There are two known subtle differences from the code that uC++ generates for the same input
+//   -CFA puts the break label inside at the end of a switch, uC++ puts it after
+//   -CFA puts the break label after a block, uC++ puts it inside at the end
+// It is unclear if these differences are important, but if they are, then the fix would go in this file, since this is
+// where these labels are generated.
 
 #include <cassert>
@@ -38,8 +37,7 @@
 	}
 
-	// break labels have to come after the statement they break out of,
-	// so mutate a statement, then if they inform us through the breakLabel field
-	// tha they need a place to jump to on a break statement, add the break label
-	// to the body of statements
+	// break labels have to come after the statement they break out of, so mutate a statement, then if they inform us
+	// through the breakLabel field tha they need a place to jump to on a break statement, add the break label to the
+	// body of statements
 	void MLEMutator::fixBlock( std::list< Statement * > &kids ) {
 		for ( std::list< Statement * >::iterator k = kids.begin(); k != kids.end(); k++ ) {
@@ -62,6 +60,5 @@
 		} // if
 
-		// a child statement may set the break label
-		// - if they do, attach it to the next statement
+		// a child statement may set the break label - if they do, attach it to the next statement
 		std::list< Statement * > &kids = cmpndStmt->get_kids();
 		fixBlock( kids );
@@ -71,5 +68,5 @@
 			if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
 				set_breakLabel( enclosingControlStructures.back().useBreakExit() );
-			}
+			} // if
 			enclosingControlStructures.pop_back();
 		} // if
@@ -80,8 +77,7 @@
 	template< typename LoopClass >
 	Statement *MLEMutator::handleLoopStmt( LoopClass *loopStmt ) {
-		// remember this as the most recent enclosing loop, then mutate
-		// the body of the loop -- this will determine whether brkLabel
-		// and contLabel are used with branch statements
-		// and will recursively do the same to nested loops
+		// remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine
+		// whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
+		// loops
 		Label brkLabel = generator->newLabel("loopBreak");
 		Label contLabel = generator->newLabel("loopContinue");
@@ -89,10 +85,9 @@
 		loopStmt->set_body ( loopStmt->get_body()->acceptMutator( *this ) );
 
+		Entry &e = enclosingControlStructures.back();
 		// sanity check that the enclosing loops have been popped correctly
-		Entry &e = enclosingControlStructures.back();
 		assert ( e == loopStmt );
 
-		// this will take the necessary steps to add definitions of the previous
-		// two labels, if they are used.
+		// this will take the necessary steps to add definitions of the previous two labels, if they are used.
 		loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) );
 		enclosingControlStructures.pop_back();
@@ -106,4 +101,24 @@
 
 		return caseStmt;
+	}
+
+	template< typename IfClass >
+	Statement *MLEMutator::handleIfStmt( IfClass *ifStmt ) {
+		// generate a label for breaking out of a labeled if
+		bool labeledBlock = !(ifStmt->get_labels().empty());
+		if ( labeledBlock ) {
+			Label brkLabel = generator->newLabel("blockBreak");
+			enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) );
+		} // if
+
+		Parent::mutate( ifStmt );
+		
+		if ( labeledBlock ) {
+			if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
+				set_breakLabel( enclosingControlStructures.back().useBreakExit() );
+			} // if
+			enclosingControlStructures.pop_back();
+		} // if
+		return ifStmt;
 	}
 
@@ -119,12 +134,12 @@
 
 		// only generate break label if labeled break is used
-		if (e.isBreakUsed()) {
-			// for the purposes of keeping switch statements uniform (i.e. all statements that are
-			// direct children of a switch should be CastStmts), append the exit label + break to the
-			// last case statement; create a default case if there are no cases
+		if ( e.isBreakUsed() ) {
+			// for the purposes of keeping switch statements uniform (i.e. all statements that are direct children of a
+			// switch should be CastStmts), append the exit label + break to the last case statement; create a default
+			// case if there are no cases
 			std::list< Statement * > &branches = switchStmt->get_branches();
 			if ( branches.empty() ) {
 				branches.push_back( CaseStmt::makeDefault() );
-			}
+			} // if
 
 			if ( CaseStmt * c = dynamic_cast< CaseStmt * >( branches.back() ) ) {
@@ -132,5 +147,5 @@
 				c->get_statements().push_back( new BranchStmt( temp, Label("brkLabel"), BranchStmt::Break ) );
 			} else assert(0); // as of this point, all branches of a switch are still CaseStmts
-		}
+		} // if
 
 		assert ( enclosingControlStructures.back() == switchStmt );
@@ -152,8 +167,8 @@
 				// labelled continue - lookup label in table ot find attached control structure
 				targetEntry = std::find( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), (*targetTable)[branchStmt->get_target()] );
-			}
+			} // if
 			if ( targetEntry == enclosingControlStructures.rend() || ! isLoop( targetEntry->get_controlStructure() ) ) {
 				throw SemanticError( "'continue' target must be an enclosing loop: " + originalTarget );
-			}
+			} // if
 		} else if ( branchStmt->get_type() == BranchStmt::Break ) {
 			if ( enclosingControlStructures.empty() ) throw SemanticError( "'break' outside a loop, switch, or labelled block" );
@@ -161,9 +176,9 @@
 		} else {
 			assert( false );
-		}
+		} // if
 
 		if ( branchStmt->get_target() != "" && targetTable->find( branchStmt->get_target() ) == targetTable->end() ) {
 			throw SemanticError("The label defined in the exit loop statement does not exist: " + originalTarget );  // shouldn't happen (since that's already checked)
-		}
+		} // if
 
 		// branch error checks, get the appropriate label name and create a goto
@@ -191,5 +206,5 @@
 			delete branchStmt;
 			return new BranchStmt( std::list<Label>(), exitLabel, BranchStmt::Goto );
-		}
+		} // if
 	}
 
@@ -208,11 +223,10 @@
 			std::list< Label > labels; labels.push_back( e.useContExit() );
 			newBody->get_kids().push_back( new NullStmt( labels ) );
-		}
+		} // if
 
 		if ( e.isBreakUsed() ) {
-			// break label goes after the loop -- it'll get set by the
-			// outer mutator if we do this
+			// break label goes after the loop -- it'll get set by the outer mutator if we do this
 			set_breakLabel( e.useBreakExit() );
-		}
+		} // if
 
 		return newBody;
@@ -227,4 +241,8 @@
 	}
 
+	Statement *MLEMutator::mutate( IfStmt *ifStmt ) {
+		return handleIfStmt( ifStmt );
+	}
+
 	Statement *MLEMutator::mutate( SwitchStmt *switchStmt ) {
 		return handleSwitchStmt( switchStmt );
@@ -234,5 +252,4 @@
 		return handleSwitchStmt( switchStmt );
 	}
-
 } // namespace ControlStruct
 
Index: src/ControlStruct/MLEMutator.h
===================================================================
--- src/ControlStruct/MLEMutator.h	(revision 6a37d13df78628db4154171dbe8466281b284003)
+++ src/ControlStruct/MLEMutator.h	(revision 3f869f0ffd7b467d53412bd6d1ddf2097487e768)
@@ -9,7 +9,7 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Jun 03 15:06:36 2015
-// Update Count     : 25
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jul  6 18:10:49 2016
+// Update Count     : 32
 //
 
@@ -30,4 +30,5 @@
 	class MLEMutator : public Mutator {
 		class Entry;
+		typedef Mutator Parent;
 	  public:
 		MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
@@ -38,6 +39,5 @@
 		virtual Statement *mutate( ForStmt *forStmt ) override;
 		virtual Statement *mutate( BranchStmt *branchStmt ) throw ( SemanticError ) override;
-
-		virtual Statement *mutate( CaseStmt *caseStmt ) override;
+		virtual Statement *mutate( IfStmt *ifStmt ) override;
 		virtual Statement *mutate( SwitchStmt *switchStmt ) override;
 		virtual Statement *mutate( ChooseStmt *switchStmt ) override;
@@ -65,5 +65,4 @@
 			bool isContUsed() const { return contUsed; }
 			bool isBreakUsed() const { return breakUsed; }
-
 		  private:
 			Statement *loop;
@@ -79,4 +78,7 @@
 		template< typename LoopClass >
 		Statement *handleLoopStmt( LoopClass *loopStmt );
+
+		template< typename IfClass >
+		Statement *handleIfStmt( IfClass *switchStmt );
 
 		template< typename SwitchClass >
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision 6a37d13df78628db4154171dbe8466281b284003)
+++ src/InitTweak/FixInit.cc	(revision 3f869f0ffd7b467d53412bd6d1ddf2097487e768)
@@ -9,7 +9,7 @@
 // Author           : Rob Schluntz
 // Created On       : Wed Jan 13 16:29:30 2016
-// Last Modified By : Rob Schluntz
-// Last Modified On : Fri May 13 11:44:26 2016
-// Update Count     : 30
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jul  6 17:34:46 2016
+// Update Count     : 33
 //
 
@@ -47,7 +47,6 @@
 		class InsertImplicitCalls : public GenPoly::PolyMutator {
 		public:
-			/// wrap function application expressions as ImplicitCopyCtorExpr nodes
-			/// so that it is easy to identify which function calls need their parameters
-			/// to be copy constructed
+			/// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
+			/// function calls need their parameters to be copy constructed
 			static void insert( std::list< Declaration * > & translationUnit );
 
@@ -57,7 +56,7 @@
 		class ResolveCopyCtors : public SymTab::Indexer {
 		public:
-			/// generate temporary ObjectDecls for each argument and return value of each
-			/// ImplicitCopyCtorExpr, generate/resolve copy construction expressions for each,
-			/// and generate/resolve destructors for both arguments and return value temporaries
+			/// generate temporary ObjectDecls for each argument and return value of each ImplicitCopyCtorExpr,
+			/// generate/resolve copy construction expressions for each, and generate/resolve destructors for both
+			/// arguments and return value temporaries
 			static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
 
@@ -93,5 +92,5 @@
 			for ( ObjectDecl * obj : set.objs ) {
 				out << obj->get_name() << ", " ;
-			}
+			} // for
 			out << " }";
 			return out;
@@ -108,10 +107,8 @@
 
 			// xxx - This needs to be done better.
-			// allow some generalization among different kinds of nodes with
-			// with similar parentage (e.g. all expressions, all statements, etc.)
-			// important to have this to provide a single entry point so that as
-			// new subclasses are added, there is only one place that the code has
-			// to be updated, rather than ensure that every specialized class knows
-			// about every new kind of statement that might be added.
+			// allow some generalization among different kinds of nodes with with similar parentage (e.g. all
+			// expressions, all statements, etc.)  important to have this to provide a single entry point so that as new
+			// subclasses are added, there is only one place that the code has to be updated, rather than ensure that
+			// every specialized class knows about every new kind of statement that might be added.
 			virtual void visit( CompoundStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
 			virtual void visit( ExprStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
@@ -136,6 +133,6 @@
 		class InsertDtors : public ObjDeclCollector {
 		public:
-			/// insert destructor calls at the appropriate places.
-			/// must happen before CtorInit nodes are removed (currently by FixInit)
+			/// insert destructor calls at the appropriate places.  must happen before CtorInit nodes are removed
+			/// (currently by FixInit)
 			static void insert( std::list< Declaration * > & translationUnit );
 
@@ -168,6 +165,6 @@
 		class FixCopyCtors : public GenPoly::PolyMutator {
 		  public:
-			/// expand ImplicitCopyCtorExpr nodes into the temporary declarations, copy constructors,
-			/// call expression, and destructors
+			/// expand ImplicitCopyCtorExpr nodes into the temporary declarations, copy constructors, call expression,
+			/// and destructors
 			static void fixCopyCtors( std::list< Declaration * > &translationUnit );
 
@@ -235,11 +232,11 @@
 							// assignment operator
 							return appExpr;
-						}
+						} // if
 					} else if ( funcDecl->get_name() == "^?{}" ) {
 						// correctness: never copy construct arguments to a destructor
 						return appExpr;
-					}
-				}
-			}
+					} // if
+				} // if
+			} // if
 			CP_CTOR_PRINT( std::cerr << "InsertImplicitCalls: adding a wrapper " << appExpr << std::endl; )
 
@@ -270,11 +267,11 @@
 
 			// resolve copy constructor
-			// should only be one alternative for copy ctor and dtor expressions, since
-			// all arguments are fixed (VariableExpr and already resolved expression)
+			// should only be one alternative for copy ctor and dtor expressions, since all arguments are fixed
+			// (VariableExpr and already resolved expression)
 			CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
 			ApplicationExpr * resolved = dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untyped, *this ) );
 			if ( resolved->get_env() ) {
 				env->add( *resolved->get_env() );
-			}
+			} // if
 
 			assert( resolved );
@@ -319,14 +316,13 @@
 					impCpCtorExpr->get_tempDecls().push_back( tmp );
 					impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
-				}
-			}
-
-			// each return value from the call needs to be connected with an ObjectDecl
-			// at the call site, which is initialized with the return value and is destructed
-			// later
+				} // if
+			} // for
+
+			// each return value from the call needs to be connected with an ObjectDecl at the call site, which is
+			// initialized with the return value and is destructed later
 			// xxx - handle multiple return values
 			ApplicationExpr * callExpr = impCpCtorExpr->get_callExpr();
-			// xxx - is this right? callExpr may not have the right environment, because it was attached
-			// at a higher level. Trying to pass that environment along.
+			// xxx - is this right? callExpr may not have the right environment, because it was attached at a higher
+			// level. Trying to pass that environment along.
 			callExpr->set_env( impCpCtorExpr->get_env()->clone() );
 			for ( Type * result : appExpr->get_results() ) {
@@ -338,5 +334,5 @@
 				CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
 				impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
-			}
+			} // for
 			CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
 		}
@@ -356,13 +352,13 @@
 			for ( ObjectDecl * obj : tempDecls ) {
 				stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
-			}
+			} // for
 			for ( ObjectDecl * obj : returnDecls ) {
 				stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
-			}
+			} // for
 
 			// add destructors after current statement
 			for ( Expression * dtor : dtors ) {
 				stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
-			}
+			} // for
 
 			// xxx - update to work with multiple return values
@@ -390,10 +386,9 @@
 				Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
 				if ( callExpr->get_results().front()->get_isLvalue() ) {
-					// lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any
-					// lvalue returning non-intrinsic function. Add an AddressExpr to the call to negate
-					// the derefence and change the type of the return temporary from T to T* to properly
-					// capture the return value. Then dereference the result of the comma expression, since
-					// the lvalue returning call was originally wrapped with an AddressExpr.
-					// Effectively, this turns
+					// lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
+					// non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
+					// type of the return temporary from T to T* to properly capture the return value. Then dereference
+					// the result of the comma expression, since the lvalue returning call was originally wrapped with
+					// an AddressExpr.  Effectively, this turns
 					//   lvalue T f();
 					//   &*f()
@@ -410,5 +405,5 @@
 					deref->add_result( resultType );
 					retExpr = deref;
-				}
+				} // if
 				// xxx - might need to set env on retExpr...
 				// retExpr->set_env( env->clone() );
@@ -416,10 +411,10 @@
 			} else {
 				return callExpr;
-			}
+			} // if
 		}
 
 		DeclarationWithType *FixInit::mutate( ObjectDecl *objDecl ) {
-			// first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors
-			// when the init is removed from the ObjectDecl
+			// first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors when the init
+			// is removed from the ObjectDecl
 			objDecl = dynamic_cast< ObjectDecl * >( Mutator::mutate( objDecl ) );
 
@@ -474,5 +469,5 @@
 					} else {
 						stmtsToAddAfter.push_back( ctor );
-					}
+					} // if
 					objDecl->set_init( NULL );
 					ctorInit->set_ctor( NULL );
@@ -483,7 +478,7 @@
 					// no constructor and no initializer, which is okay
 					objDecl->set_init( NULL );
-				}
+				} // if
 				delete ctorInit;
-			}
+			} // if
 			return objDecl;
 		}
@@ -499,5 +494,5 @@
 			if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) {
 				curVars.insert( objDecl );
-			}
+			} // if
 			Parent::visit( stmt );
 		}
@@ -507,5 +502,5 @@
 			for ( Label l : stmt->get_labels() ) {
 				vars[l] = curVars;
-			}
+			} // for
 		}
 
@@ -513,15 +508,13 @@
 		void insertDtors( Iterator begin, Iterator end, OutputIterator out ) {
 			for ( Iterator it = begin ; it != end ; ++it ) {
-				// extract destructor statement from the object decl and
-				// insert it into the output. Note that this is only called
-				// on lists of non-static objects with implicit non-intrinsic
-				// dtors, so if the user manually calls an intrinsic dtor
-				// then the call must (and will) still be generated since
-				// the argument may contain side effects.
+				// extract destructor statement from the object decl and insert it into the output. Note that this is
+				// only called on lists of non-static objects with implicit non-intrinsic dtors, so if the user manually
+				// calls an intrinsic dtor then the call must (and will) still be generated since the argument may
+				// contain side effects.
 				ObjectDecl * objDecl = *it;
 				ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() );
 				assert( ctorInit && ctorInit->get_dtor() );
 				*out++ = ctorInit->get_dtor()->clone();
-			}
+			} // for
 		}
 
@@ -537,15 +530,14 @@
 						// non-intrinsic dtors must be called
 						reverseDeclOrder.front().push_front( objDecl );
-					}
-				}
-			}
+					} // if
+				} // if
+			} // if
 			Parent::visit( objDecl );
 		}
 
 		void InsertDtors::visit( CompoundStmt * compoundStmt ) {
-			// visit statements - this will also populate reverseDeclOrder list.
-			// don't want to dump all destructors when block is left,
-			// just the destructors associated with variables defined in this block,
-			// so push a new list to the top of the stack so that we can differentiate scopes
+			// visit statements - this will also populate reverseDeclOrder list.  don't want to dump all destructors
+			// when block is left, just the destructors associated with variables defined in this block, so push a new
+			// list to the top of the stack so that we can differentiate scopes
 			reverseDeclOrder.push_front( OrderedDecls() );
 			Parent::visit( compoundStmt );
@@ -561,14 +553,11 @@
 			for ( OrderedDecls & od : reverseDeclOrder ) {
 				insertDtors( od.begin(), od.end(), back_inserter( stmtsToAdd ) );
-			}
-		}
-
-		// Handle break/continue/goto in the same manner as C++.
-		// Basic idea: any objects that are in scope at the BranchStmt
-		// but not at the labelled (target) statement must be destructed.
-		// If there are any objects in scope at the target location but
-		// not at the BranchStmt then those objects would be uninitialized
-		// so notify the user of the error.
-		// See C++ Reference 6.6 Jump Statements for details.
+			} // for
+		}
+
+		// Handle break/continue/goto in the same manner as C++.  Basic idea: any objects that are in scope at the
+		// BranchStmt but not at the labelled (target) statement must be destructed.  If there are any objects in scope
+		// at the target location but not at the BranchStmt then those objects would be uninitialized so notify the user
+		// of the error.  See C++ Reference 6.6 Jump Statements for details.
 		void InsertDtors::handleGoto( BranchStmt * stmt ) {
 			assert( stmt->get_target() != "" && "BranchStmt missing a label" );
@@ -591,5 +580,5 @@
 			if ( ! diff.empty() ) {
 				throw SemanticError( std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " ", stmt );
-			}
+			} // if
 			// S_G-S_L results in set of objects that must be destructed
 			diff.clear();
@@ -604,22 +593,21 @@
 					// add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
 					copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return diff.count( objDecl ); } );
-				}
+				} // for
 				insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) );
-			}
+			} // if
 		}
 
 		void InsertDtors::visit( BranchStmt * stmt ) {
 			switch( stmt->get_type() ) {
-				case BranchStmt::Continue:
-				case BranchStmt::Break:
-				// could optimize the break/continue case, because the S_L-S_G check
-				// is unnecessary (this set should always be empty), but it serves
-				// as a small sanity check.
-				case BranchStmt::Goto:
-					handleGoto( stmt );
-					break;
-				default:
-					assert( false );
-			}
+			  case BranchStmt::Continue:
+			  case BranchStmt::Break:
+				// could optimize the break/continue case, because the S_L-S_G check is unnecessary (this set should
+				// always be empty), but it serves as a small sanity check.
+			  case BranchStmt::Goto:
+				handleGoto( stmt );
+				break;
+			  default:
+				assert( false );
+			} // switch
 		}
 	} // namespace
Index: src/tests/.expect/random.txt
===================================================================
--- src/tests/.expect/random.txt	(revision 3f869f0ffd7b467d53412bd6d1ddf2097487e768)
+++ src/tests/.expect/random.txt	(revision 3f869f0ffd7b467d53412bd6d1ddf2097487e768)
@@ -0,0 +1,10 @@
+ë
+1950506212
+1626226846
+-911259971
+1562848336
+0.401356
+0.573743785402566
+0.90158+0.0967396i
+0.787170420226857+0.32472417295666i
+0.629480269495140021+0.967221734609655215i
Index: src/tests/random.c
===================================================================
--- src/tests/random.c	(revision 6a37d13df78628db4154171dbe8466281b284003)
+++ src/tests/random.c	(revision 3f869f0ffd7b467d53412bd6d1ddf2097487e768)
@@ -10,6 +10,6 @@
 // Created On       : Tue Jul  5 21:29:30 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul  5 21:29:54 2016
-// Update Count     : 1
+// Last Modified On : Wed Jul  6 18:00:29 2016
+// Update Count     : 3
 // 
 
@@ -19,5 +19,6 @@
 
 int main() {
-	rand48seed( getpid() );								// set random seed
+	//rand48seed( getpid() );								// set random seed
+	rand48seed( 1003 );									// fixed seed for repeatable tests
 
 	// test polymorphic calls to random and stream
