Index: src/CodeGen/CodeGenerator.cc
===================================================================
--- src/CodeGen/CodeGenerator.cc	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/CodeGen/CodeGenerator.cc	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -1002,4 +1002,13 @@
 } // namespace CodeGen
 
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
+	if ( node ) {
+		node->print( out );
+	} else {
+		out << "nullptr";
+	}
+	return out;
+}
+
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/BaseSyntaxNode.h
===================================================================
--- src/SynTree/BaseSyntaxNode.h	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/BaseSyntaxNode.h	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -26,5 +26,9 @@
 
 	virtual void accept( Visitor & v ) = 0;
+
+	virtual void print( std::ostream &os, int indent = 0 ) const = 0;
 };
+
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node );
 
 // Local Variables: //
Index: src/SynTree/Declaration.cc
===================================================================
--- src/SynTree/Declaration.cc	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Declaration.cc	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -59,13 +59,4 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
-	if ( decl ){
-		decl->print( out );
-	} else {
-		out << "nullptr";
-	}
-	return out;
-}
-
 
 AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Declaration.h	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -62,7 +62,7 @@
 	void fixUniqueId( void );
 	virtual Declaration *clone() const = 0;
-	virtual void accept( Visitor &v ) = 0;
+	virtual void accept( Visitor &v ) override = 0;
 	virtual Declaration *acceptMutator( Mutator &m ) = 0;
-	virtual void print( std::ostream &os, int indent = 0 ) const = 0;
+	virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
 	virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
 
@@ -106,6 +106,6 @@
 	//void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
 
-	virtual DeclarationWithType *clone() const = 0;
-	virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
+	virtual DeclarationWithType *clone() const override = 0;
+	virtual DeclarationWithType *acceptMutator( Mutator &m )  override = 0;
 
 	virtual Type * get_type() const = 0;
@@ -128,6 +128,6 @@
 	virtual ~ObjectDecl();
 
-	virtual Type * get_type() const { return type; }
-	virtual void set_type(Type *newType) { type = newType; }
+	virtual Type * get_type() const override { return type; }
+	virtual void set_type(Type *newType) override { type = newType; }
 
 	Initializer *get_init() const { return init; }
@@ -139,9 +139,9 @@
 	static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
 
-	virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-	virtual void printShort( std::ostream &os, int indent = 0 ) const;
+	virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
+	virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -157,6 +157,6 @@
 	virtual ~FunctionDecl();
 
-	Type * get_type() const { return type; }
-	virtual void set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
+	virtual Type * get_type() const override { return type; }
+	virtual void set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }
 
 	FunctionType * get_functionType() const { return type; }
@@ -165,9 +165,9 @@
 	void set_statements( CompoundStmt *newValue ) { statements = newValue; }
 
-	virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-	virtual void printShort( std::ostream &os, int indent = 0 ) const;
+	virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
+	virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -190,7 +190,7 @@
 	virtual std::string typeString() const = 0;
 
-	virtual NamedTypeDecl *clone() const = 0;
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-	virtual void printShort( std::ostream &os, int indent = 0 ) const;
+	virtual NamedTypeDecl *clone() const override = 0;
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
+	virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -227,11 +227,11 @@
 	TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
 
-	virtual std::string typeString() const;
+	virtual std::string typeString() const override;
 	virtual std::string genTypeString() const;
 
-	virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 
   private:
@@ -245,9 +245,9 @@
 	TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
 
-	virtual std::string typeString() const;
-
-	virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+	virtual std::string typeString() const override;
+
+	virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
 };
@@ -274,6 +274,6 @@
 	AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
 
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-	virtual void printShort( std::ostream &os, int indent = 0 ) const;
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
+	virtual void printShort( std::ostream &os, int indent = 0 ) const override;
   protected:
 	virtual std::string typeString() const = 0;
@@ -290,10 +290,10 @@
 	bool is_thread() { return kind == DeclarationNode::Thread; }
 
-	virtual StructDecl *clone() const { return new StructDecl( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+	virtual StructDecl *clone() const override { return new StructDecl( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
 	DeclarationNode::Aggregate kind;
-	virtual std::string typeString() const;
+	virtual std::string typeString() const override;
 };
 
@@ -304,9 +304,9 @@
 	UnionDecl( const UnionDecl &other ) : Parent( other ) {}
 
-	virtual UnionDecl *clone() const { return new UnionDecl( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-  private:
-	virtual std::string typeString() const;
+	virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+	virtual std::string typeString() const override;
 };
 
@@ -317,9 +317,9 @@
 	EnumDecl( const EnumDecl &other ) : Parent( other ) {}
 
-	virtual EnumDecl *clone() const { return new EnumDecl( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-  private:
-	virtual std::string typeString() const;
+	virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+	virtual std::string typeString() const override;
 };
 
@@ -332,9 +332,9 @@
 	TraitDecl( const TraitDecl &other ) : Parent( other ) {}
 
-	virtual TraitDecl *clone() const { return new TraitDecl( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-  private:
-	virtual std::string typeString() const;
+	virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+	virtual std::string typeString() const override;
 };
 
@@ -350,12 +350,11 @@
 	void set_stmt( AsmStmt *newValue ) { stmt = newValue; }
 
-	virtual AsmDecl *clone() const { return new AsmDecl( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual AsmDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-	virtual void printShort( std::ostream &os, int indent = 0 ) const;
-};
-
-std::ostream & operator<<( std::ostream & out, const Declaration * decl );
+	virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
+	virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+};
+
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
 
Index: src/SynTree/Expression.cc
===================================================================
--- src/SynTree/Expression.cc	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Expression.cc	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -741,14 +741,4 @@
 }
 
-
-std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
-	if ( expr ) {
-		expr->print( out );
-	} else {
-		out << "nullptr";
-	}
-	return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/Expression.h
===================================================================
--- src/SynTree/Expression.h	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Expression.h	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -821,7 +821,4 @@
 };
 
-
-std::ostream & operator<<( std::ostream & out, const Expression * expr );
-
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/Initializer.cc
===================================================================
--- src/SynTree/Initializer.cc	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Initializer.cc	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -137,22 +137,4 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Initializer * init ) {
-	if ( init ) {
-		init->print( out );
-	} else {
-		out << "nullptr";
-	}
-	return out;
-}
-
-std::ostream & operator<<( std::ostream & out, const Designation * des ) {
-	if ( des ) {
-		des->print( out );
-	} else {
-		out << "nullptr";
-	}
-	return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/Initializer.h
===================================================================
--- src/SynTree/Initializer.h	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Initializer.h	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -38,7 +38,7 @@
 
 	virtual Designation * clone() const { return new Designation( *this ); };
-	virtual void accept( Visitor &v ) { v.visit( this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
 	virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -55,7 +55,7 @@
 
 	virtual Initializer *clone() const = 0;
-	virtual void accept( Visitor &v ) = 0;
+	virtual void accept( Visitor &v ) override = 0;
 	virtual Initializer *acceptMutator( Mutator &m ) = 0;
-	virtual void print( std::ostream &os, int indent = 0 ) const = 0;
+	virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
   private:
 	bool maybeConstructed;
@@ -75,8 +75,8 @@
 	void set_value( Expression *newValue ) { value = newValue; }
 
-	virtual SingleInit *clone() const { return new SingleInit( *this); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual SingleInit *clone() const override { return new SingleInit( *this); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -103,8 +103,8 @@
 	const_iterator end() const { return initializers.end(); }
 
-	virtual ListInit *clone() const { return new ListInit( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual ListInit *clone() const override { return new ListInit( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -129,8 +129,8 @@
 	Initializer * get_init() const { return init; }
 
-	ConstructorInit *clone() const { return new ConstructorInit( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	ConstructorInit *clone() const override { return new ConstructorInit( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 
   private:
@@ -140,7 +140,4 @@
 };
 
-std::ostream & operator<<( std::ostream & out, const Initializer * init );
-std::ostream & operator<<( std::ostream & out, const Designation * des );
-
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/Statement.cc
===================================================================
--- src/SynTree/Statement.cc	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Statement.cc	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -497,13 +497,4 @@
 }
 
-std::ostream & operator<<( std::ostream & out, const Statement * statement ) {
-	if ( statement ) {
-		statement->print( out );
-	} else {
-		out << "nullptr";
-	}
-	return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/Statement.h
===================================================================
--- src/SynTree/Statement.h	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Statement.h	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -44,7 +44,7 @@
 
 	virtual Statement *clone() const = 0;
-	virtual void accept( Visitor &v ) = 0;
+	virtual void accept( Visitor &v ) override = 0;
 	virtual Statement *acceptMutator( Mutator &m ) = 0;
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -61,8 +61,8 @@
 	void push_front( Statement * stmt ) { kids.push_front( stmt ); }
 
-	virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -72,8 +72,8 @@
 	NullStmt( std::list<Label> labels );
 
-	virtual NullStmt *clone() const { return new NullStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual NullStmt *clone() const override { return new NullStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -89,8 +89,8 @@
 	void set_expr( Expression *newValue ) { expr = newValue; }
 
-	virtual ExprStmt *clone() const { return new ExprStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -146,8 +146,8 @@
 	void set_elsePart( Statement *newValue ) { elsePart = newValue; }
 
-	virtual IfStmt *clone() const { return new IfStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual IfStmt *clone() const override { return new IfStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -166,9 +166,9 @@
 	std::list<Statement *> & get_statements() { return statements; }
 
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-	virtual SwitchStmt *clone() const { return new SwitchStmt( *this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+
+	virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 
 };
@@ -194,9 +194,9 @@
 	void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
 
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-	virtual CaseStmt *clone() const { return new CaseStmt( *this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+
+	virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
   private:
 	bool _isDefault;
@@ -221,8 +221,8 @@
 	void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
 
-	virtual WhileStmt *clone() const { return new WhileStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual WhileStmt *clone() const override { return new WhileStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -247,8 +247,8 @@
 	void set_body( Statement *newValue ) { body = newValue; }
 
-	virtual ForStmt *clone() const { return new ForStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual ForStmt *clone() const override { return new ForStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -276,8 +276,8 @@
 	const char *get_typename() { return brType[ type ]; }
 
-	virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual BranchStmt *clone() const override { return new BranchStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
   private:
 	static const char *brType[];
@@ -295,8 +295,8 @@
 	void set_expr( Expression *newValue ) { expr = newValue; }
 
-	virtual ReturnStmt *clone() const { return new ReturnStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual ReturnStmt *clone() const override { return new ReturnStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -319,8 +319,8 @@
 	void set_target( Expression * newTarget ) { target = newTarget; }
 
-	virtual ThrowStmt *clone() const { return new ThrowStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual ThrowStmt *clone() const override { return new ThrowStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -342,8 +342,8 @@
 	void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
 
-	virtual TryStmt *clone() const { return new TryStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual TryStmt *clone() const override { return new TryStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -370,8 +370,8 @@
 	void set_body( Statement *newValue ) { body = newValue; }
 
-	virtual CatchStmt *clone() const { return new CatchStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual CatchStmt *clone() const override { return new CatchStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -387,8 +387,8 @@
 	void set_block( CompoundStmt *newValue ) { block = newValue; }
 
-	virtual FinallyStmt *clone() const { return new FinallyStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual FinallyStmt *clone() const override { return new FinallyStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -424,8 +424,8 @@
 	} orelse;
 
-	virtual WaitForStmt *clone() const { return new WaitForStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual WaitForStmt *clone() const override { return new WaitForStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 
 };
@@ -444,8 +444,8 @@
 	void set_decl( Declaration *newValue ) { decl = newValue; }
 
-	virtual DeclStmt *clone() const { return new DeclStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual DeclStmt *clone() const override { return new DeclStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 
@@ -466,12 +466,9 @@
 	void set_callStmt( Statement * newValue ) { callStmt = newValue; }
 
-	virtual ImplicitCtorDtorStmt *clone() const { return new ImplicitCtorDtorStmt( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-};
-
-
-std::ostream & operator<<( std::ostream & out, const Statement * statement );
+	virtual ImplicitCtorDtorStmt *clone() const override { return new ImplicitCtorDtorStmt( *this ); }
+	virtual void accept( Visitor &v ) override { v.visit( this ); }
+	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
+};
 
 // Local Variables: //
Index: src/SynTree/Type.cc
===================================================================
--- src/SynTree/Type.cc	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Type.cc	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -99,13 +99,4 @@
 const Type::Qualifiers noQualifiers;
 
-std::ostream & operator<<( std::ostream & out, const Type * type ) {
-	if ( type ) {
-		type->print( out );
-	} else {
-		out << "nullptr";
-	} // if
-	return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/Type.h
===================================================================
--- src/SynTree/Type.h	(revision 310e5b7a73ac432e83f04a8d32b171a31ac8c68f)
+++ src/SynTree/Type.h	(revision e149f77d332b3ccb4f2dc3c40b4f03808877e80c)
@@ -192,11 +192,11 @@
 	VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 
-	virtual unsigned size() const { return 0; };
-	virtual bool isComplete() const { return false; }
-
-	virtual VoidType *clone() const { return new VoidType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual unsigned size() const override { return 0; };
+	virtual bool isComplete() const override { return false; }
+
+	virtual VoidType *clone() const override { return new VoidType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -235,8 +235,8 @@
 	void set_kind( Kind newValue ) { kind = newValue; }
 
-	virtual BasicType *clone() const { return new BasicType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual BasicType *clone() const override { return new BasicType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 
 	bool isInteger() const;
@@ -268,10 +268,10 @@
 	bool is_array() const { return isStatic || isVarLen || dimension; }
 
-	virtual bool isComplete() const { return ! isVarLen; }
-
-	virtual PointerType *clone() const { return new PointerType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual bool isComplete() const override { return ! isVarLen; }
+
+	virtual PointerType *clone() const override { return new PointerType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -296,10 +296,10 @@
 	void set_isStatic( bool newValue ) { isStatic = newValue; }
 
-	virtual bool isComplete() const { return ! isVarLen; }
-
-	virtual ArrayType *clone() const { return new ArrayType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual bool isComplete() const override { return ! isVarLen; }
+
+	virtual ArrayType *clone() const override { return new ArrayType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -315,15 +315,15 @@
 	void set_base( Type *newValue ) { base = newValue; }
 
-	virtual int referenceDepth() const;
+	virtual int referenceDepth() const override;
 
 	// Since reference types act like value types, their size is the size of the base.
 	// This makes it simple to cast the empty tuple to a reference type, since casts that increase
 	// the number of values are disallowed.
-	virtual unsigned size() const { return base->size(); }
-
-	virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual unsigned size() const override { return base->size(); }
+
+	virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -349,8 +349,8 @@
 	bool isTtype() const;
 
-	virtual FunctionType *clone() const { return new FunctionType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual FunctionType *clone() const override { return new FunctionType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -371,8 +371,8 @@
 	void set_hoistType( bool newValue ) { hoistType = newValue; }
 
-	virtual ReferenceToType *clone() const = 0;
-	virtual void accept( Visitor & v ) = 0;
-	virtual Type *acceptMutator( Mutator & m ) = 0;
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual ReferenceToType *clone() const override = 0;
+	virtual void accept( Visitor & v ) override = 0;
+	virtual Type *acceptMutator( Mutator & m ) override = 0;
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 
 	virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
@@ -398,17 +398,17 @@
 	std::list<TypeDecl*> * get_baseParameters();
 
-	virtual bool isComplete() const;
+	virtual bool isComplete() const override;
 
 	/// Looks up the members of this struct named "name" and places them into "foundDecls".
 	/// Clones declarations into "foundDecls", caller responsible for freeing
-	void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
-
-	virtual StructInstType *clone() const { return new StructInstType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+
+	virtual StructInstType *clone() const override { return new StructInstType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
-	virtual std::string typeString() const;
+	virtual std::string typeString() const override;
 };
 
@@ -430,17 +430,17 @@
 	std::list< TypeDecl * > * get_baseParameters();
 
-	virtual bool isComplete() const;
+	virtual bool isComplete() const override;
 
 	/// looks up the members of this union named "name" and places them into "foundDecls"
 	/// Clones declarations into "foundDecls", caller responsible for freeing
-	void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
-
-	virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+
+	virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
-	virtual std::string typeString() const;
+	virtual std::string typeString() const override;
 };
 
@@ -459,11 +459,11 @@
 	void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
 
-	virtual bool isComplete() const;
-
-	virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual bool isComplete() const override;
+
+	virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
-	virtual std::string typeString() const;
+	virtual std::string typeString() const override;
 };
 
@@ -480,11 +480,11 @@
 	~TraitInstType();
 
-	virtual bool isComplete() const;
-
-	virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual bool isComplete() const override;
+
+	virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
-	virtual std::string typeString() const;
+	virtual std::string typeString() const override;
 };
 
@@ -507,12 +507,12 @@
 	void set_isFtype( bool newValue ) { isFtype = newValue; }
 
-	virtual bool isComplete() const;
-
-	virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual bool isComplete() const override;
+
+	virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
-	virtual std::string typeString() const;
+	virtual std::string typeString() const override;
 };
 
@@ -530,5 +530,5 @@
 
 	std::list<Type *> & get_types() { return types; }
-	virtual unsigned size() const { return types.size(); };
+	virtual unsigned size() const override { return types.size(); };
 
 	// For now, this is entirely synthetic -- tuple types always have unnamed members.
@@ -539,15 +539,15 @@
 	iterator end() { return types.end(); }
 
-	virtual Type * getComponent( unsigned i ) {
+	virtual Type * getComponent( unsigned i ) override {
 		assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
 		return *(begin()+i);
 	}
 
-	// virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
-
-	virtual TupleType *clone() const { return new TupleType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	// virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
+
+	virtual TupleType *clone() const override { return new TupleType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -563,10 +563,10 @@
 	void set_expr( Expression *newValue ) { expr = newValue; }
 
-	virtual bool isComplete() const { assert( false ); return false; }
-
-	virtual TypeofType *clone() const { return new TypeofType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual bool isComplete() const override { assert( false ); return false; }
+
+	virtual TypeofType *clone() const override { return new TypeofType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -592,10 +592,10 @@
 	void set_isType( bool newValue ) { isType = newValue; }
 
-	virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
-
-	virtual AttrType *clone() const { return new AttrType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
+
+	virtual AttrType *clone() const override { return new AttrType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -606,10 +606,10 @@
 	VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 
-	virtual bool isComplete() const{ return true; } // xxx - is this right?
-
-	virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual bool isComplete() const override{ return true; } // xxx - is this right?
+
+	virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -620,8 +620,8 @@
 	ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 
-	virtual ZeroType *clone() const { return new ZeroType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual ZeroType *clone() const override { return new ZeroType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -632,11 +632,9 @@
 	OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 
-	virtual OneType *clone() const { return new OneType( *this ); }
-	virtual void accept( Visitor & v ) { v.visit( this ); }
-	virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-	virtual void print( std::ostream & os, int indent = 0 ) const;
-};
-
-std::ostream & operator<<( std::ostream & out, const Type * type );
+	virtual OneType *clone() const override { return new OneType( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const override;
+};
 
 // Local Variables: //