Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/DeclarationNode.cc	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun 26 23:36:03 2015
-// Update Count     : 105
+// Last Modified On : Thu May 21 09:28:54 2015
+// Update Count     : 13
 //
 
@@ -21,20 +21,14 @@
 
 #include "TypeData.h"
-
-#include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
 
-#include "Parser.h"
-#include "TypedefTable.h"
-extern TypedefTable typedefTable;
 
 using namespace std;
 
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
-const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "" };
 const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" };
 const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary" };
-const char *DeclarationNode::modifierName[]  = { "signed", "unsigned", "short", "long" };
-const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" };
+const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" };
+const char *DeclarationNode::tyConName[] = { "struct", "union", "context" };
 const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" };
 
@@ -69,32 +63,42 @@
 }
 
+const char *storageClassName[] = {
+	// order must correspond with DeclarationNode::StorageClass
+	"extern",
+	"static",
+	"auto",
+	"register",
+	"inline",
+	"fortran",
+};
+
 void DeclarationNode::print( std::ostream &os, int indent ) const {
-	os << string( indent, ' ' );
+	os << string(indent, ' ' );
 	if ( name == "" ) {
 		os << "unnamed: ";
 	} else {
 		os << name << ": ";
-	} // if
+	}
 
 	if ( linkage != LinkageSpec::Cforall ) {
 		os << LinkageSpec::toString( linkage ) << " ";
-	} // if
-
-	printEnums( storageClasses.begin(), storageClasses.end(), DeclarationNode::storageName, os );
+	}
+
+	printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os );
 	if ( type ) {
 		type->print( os, indent );
 	} else {
 		os << "untyped entity ";
-	} // if
+	}
 
 	if ( bitfieldWidth ) {
-		os << endl << string( indent + 2, ' ' ) << "with bitfield width ";
+		os << endl << string(indent+2,  ' ') << "with bitfield width ";
 		bitfieldWidth->printOneLine( os );
-	} // if
+	}
 
 	if ( initializer != 0 ) {
-		os << endl << string( indent + 2, ' ' ) << "with initializer ";
+		os << endl << string(indent+2,  ' ') << "with initializer ";
 		initializer->printOneLine( os );
-	} // if
+	}
 
 	os << endl;
@@ -105,5 +109,5 @@
 	if ( hasEllipsis ) {
 		os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
-	} // if
+	}
 }
 
@@ -119,5 +123,5 @@
 	if ( body ) {
 		newnode->type->function->hasBody = true;
-	} // if
+	}
 
 	if ( ret ) {
@@ -125,5 +129,5 @@
 		ret->type = 0;
 		delete ret;
-	} // if
+	}
 
 	return newnode;
@@ -137,5 +141,5 @@
 }
 
-DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
+DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) {
 	DeclarationNode *newnode = new DeclarationNode;
 	newnode->storageClasses.push_back( sc );
@@ -157,5 +161,5 @@
 }
 
-DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) {
+DeclarationNode *DeclarationNode::newForall( DeclarationNode* forall ) {
 	DeclarationNode *newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Unknown );
@@ -164,5 +168,5 @@
 }
 
-DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) {
+DeclarationNode *DeclarationNode::newFromTypedef( std::string* name ) {
 	DeclarationNode *newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::SymbolicInst );
@@ -173,5 +177,5 @@
 }
 
-DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, std::string *name, ExpressionNode *actuals, DeclarationNode *fields ) {
+DeclarationNode *DeclarationNode::newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
 	DeclarationNode *newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Aggregate );
@@ -180,15 +184,8 @@
 	if ( newnode->type->aggregate->name == "" ) {
 		newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
-	} // if
-
-	// SKULLDUGGERY: generate a typedef for the aggregate name so that the aggregate does not have to be qualified by
-	// "struct"
-	typedefTable.addToEnclosingScope( newnode->type->aggregate->name, TypedefTable::TD );
-	DeclarationNode *typedf = new DeclarationNode;
-	typedf->name = newnode->type->aggregate->name;
-	newnode->appendList( typedf->addType( newnode->clone() )->addTypedef() );
-
+	}
+	newnode->type->aggregate->params = formals;
 	newnode->type->aggregate->actuals = actuals;
-	newnode->type->aggregate->fields = fields;
+	newnode->type->aggregate->members = fields;
 	return newnode;
 }
@@ -201,18 +198,10 @@
 	if ( newnode->type->enumeration->name == "" ) {
 		newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
-	} // if
-
-	// SKULLDUGGERY: generate a typedef for the enumeration name so that the enumeration does not have to be qualified
-	// by "enum"
-	typedefTable.addToEnclosingScope( newnode->type->enumeration->name, TypedefTable::TD );
-	DeclarationNode *typedf = new DeclarationNode;
-	typedf->name = newnode->type->enumeration->name;
-	newnode->appendList( typedf->addType( newnode->clone() )->addTypedef() );
-
+	}
 	newnode->type->enumeration->constants = constants;
 	return newnode;
 }
 
-DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) {
+DeclarationNode *DeclarationNode::newEnumConstant( std::string* name, ExpressionNode *constant ) {
 	DeclarationNode *newnode = new DeclarationNode;
 	newnode->name = assign_strptr( name );
@@ -221,5 +210,5 @@
 }
 
-DeclarationNode *DeclarationNode::newName( std::string *name ) {
+DeclarationNode *DeclarationNode::newName( std::string* name ) {
 	DeclarationNode *newnode = new DeclarationNode;
 	newnode->name = assign_strptr( name );
@@ -227,5 +216,5 @@
 }
 
-DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
+DeclarationNode *DeclarationNode::newFromTypeGen( std::string* name, ExpressionNode *params ) {
 	DeclarationNode *newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::SymbolicInst );
@@ -236,5 +225,5 @@
 }
 
-DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
+DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string* name ) {
 	DeclarationNode *newnode = new DeclarationNode;
 	newnode->name = assign_strptr( name );
@@ -250,5 +239,5 @@
 	newnode->type->aggregate->kind = Context;
 	newnode->type->aggregate->params = params;
-	newnode->type->aggregate->fields = asserts;
+	newnode->type->aggregate->members = asserts;
 	newnode->type->aggregate->name = assign_strptr( name );
 	return newnode;
@@ -342,7 +331,7 @@
 			} else {
 				dst->forall = src->forall;
-			} // if
+			}
 			src->forall = 0;
-		} // if
+		}
 		if ( dst->base ) {
 			addQualifiersToType( src, dst->base );
@@ -352,6 +341,6 @@
 		} else {
 			dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
-		} // if
-	} // if
+		}
+	}
 }
 	  
@@ -362,5 +351,5 @@
 			if ( ! type ) {
 				type = new TypeData;
-			} // if
+			}
 			addQualifiersToType( q->type, type );
 			if ( q->type && q->type->forall ) {
@@ -368,16 +357,10 @@
 					type->forall->appendList( q->type->forall );
 				} else {
-					if ( type->kind == TypeData::Aggregate ) {
-						type->aggregate->params = q->type->forall;
-						// change implicit typedef from TYPEDEFname to TYPEGENname
-						typedefTable.changeKind( type->aggregate->name, TypedefTable::TG );
-					} else {
-						type->forall = q->type->forall;
-					} // if
-				} // if
+					type->forall = q->type->forall;
+				}
 				q->type->forall = 0;
-			} // if
-		} // if
-	} // if
+			}
+		}
+	}
 	delete q;
 	return this;
@@ -396,7 +379,7 @@
 			} else {
 				dst->forall = src->forall;
-			} // if
+			}
 			src->forall = 0;
-		} // if
+		}
 		if ( dst->base ) {
 			addTypeToType( src, dst->base );
@@ -408,4 +391,5 @@
 				src = 0;
 				break;
+
 			  case TypeData::Basic:
 				dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
@@ -414,6 +398,7 @@
 					dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
 					dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
-				} // if
+				}
 				break;
+
 			  default:
 				switch ( src->kind ) {
@@ -424,8 +409,9 @@
 					if ( src->kind == TypeData::Aggregate ) {
 						dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
-					} // if
+					}
 					dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers );
 					src = 0;
 					break;
+
 				  default:
 					if ( dst->forall ) {
@@ -433,12 +419,12 @@
 					} else {
 						dst->forall = src->forall;
-					} // if
+					}
 					src->forall = 0;
 					dst->base = src;
 					src = 0;
-				} // switch
-			} // switch
-		} // if
-	} // if
+				}
+			}
+		}
+	}
 }
 
@@ -453,18 +439,18 @@
 					if ( o->type->kind == TypeData::Aggregate ) {
 						type->aggInst->params = maybeClone( o->type->aggregate->actuals );
-					} // if
+					}
 					type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers );
 				} else {
 					type = o->type;
-				} // if
+				}
 				o->type = 0;
 			} else {
 				addTypeToType( o->type, type );
-			} // if
-		} // if
+			}
+		}
 		if ( o->bitfieldWidth ) {
 			bitfieldWidth = o->bitfieldWidth;
-		} // if
-	} // if
+		}
+	}
 	delete o;
 	return this;
@@ -481,5 +467,5 @@
 }
 
-DeclarationNode *DeclarationNode::addAssertions( DeclarationNode *assertions ) {
+DeclarationNode *DeclarationNode::addAssertions( DeclarationNode* assertions ) {
 	assert( type );
 	switch ( type->kind ) {
@@ -489,6 +475,7 @@
 		} else {
 			type->symbolic->assertions = assertions;
-		} // if
+		}
 		break;
+	
 	  case TypeData::Variable:
 		if ( type->variable->assertions ) {
@@ -496,14 +483,15 @@
 		} else {
 			type->variable->assertions = assertions;
-		} // if
+		}
 		break;
+	
 	  default:
 		assert( false );
-	} // switch
+	}
 	
 	return this;
 }
 
-DeclarationNode *DeclarationNode::addName( std::string *newname ) {
+DeclarationNode *DeclarationNode::addName( std::string* newname ) {
 	name = assign_strptr( newname );
 	return this;
@@ -538,5 +526,6 @@
 }
 
-static void setBase( TypeData *&type, TypeData *newType ) {
+static void
+setBase( TypeData *&type, TypeData *newType ) {
 	if ( type ) {
 		TypeData *prevBase = type;
@@ -545,9 +534,9 @@
 			prevBase = curBase;
 			curBase = curBase->base;
-		} // while
+		}
 		prevBase->base = newType;
 	} else {
 		type = newType;
-	} // if
+	}
 }
 
@@ -558,5 +547,5 @@
 		p->type = 0;
 		delete p;
-	} // if
+	}
 	return this;
 }
@@ -568,5 +557,5 @@
 		a->type = 0;
 		delete a;
-	} // if
+	}
 	return this;
 }
@@ -583,5 +572,5 @@
 				if ( type->kind == TypeData::Aggregate ) {
 					p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
-				} // if
+				}
 				p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers );
 				break;
@@ -589,12 +578,12 @@
 			  default:
 				p->type->base = type;
-			} // switch
+			}
 			type = 0;
-		} // if
+		}
 		delete this;
 		return p;
 	} else {
 		return this;
-	} // if
+	}
 }
 
@@ -604,5 +593,5 @@
 	while ( cur->base ) {
 		cur = cur->base;
-	} // while
+	}
 	return cur;
 }
@@ -620,17 +609,17 @@
 				if ( type->kind == TypeData::Aggregate ) {
 					lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
-				} // if
+				}
 				lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers );
 				break;
 			  default:
 				lastArray->base = type;
-			} // switch
+			}
 			type = 0;
-		} // if
+		}
 		delete this;
 		return a;
 	} else {
 		return this;
-	} // if
+	}
 }
 
@@ -648,5 +637,5 @@
 		} else {
 			type->function->idList = ids;
-		} // if
+		}
 		return type;
 	} else {
@@ -654,5 +643,5 @@
 		newtype->function->idList = ids;
 		return newtype;
-	} // if
+	}
 }
 	
@@ -673,5 +662,5 @@
 	while ( srcType->base ) {
 		srcType = srcType->base;
-	} // while
+	}
 	newnode->type = maybeClone( srcType );
 	if ( newnode->type->kind == TypeData::AggregateInst ) {
@@ -682,8 +671,8 @@
 		} else {
 			assert( newnode->type->aggInst->aggregate->kind == TypeData::Aggregate );
-			delete newnode->type->aggInst->aggregate->aggregate->fields;
-			newnode->type->aggInst->aggregate->aggregate->fields = 0;
-		} // if
-	} // if
+			delete newnode->type->aggInst->aggregate->aggregate->members;
+			newnode->type->aggInst->aggregate->aggregate->members = 0;
+		}
+	}
 	newnode->type->forall = maybeClone( type->forall );
 	newnode->storageClasses = storageClasses;
@@ -699,5 +688,5 @@
 			while ( srcType->base ) {
 				srcType = srcType->base;
-			} // while
+			}
 			TypeData *newType = srcType->clone();
 			if ( newType->kind == TypeData::AggregateInst ) {
@@ -708,8 +697,8 @@
 				} else {
 					assert( newType->aggInst->aggregate->kind == TypeData::Aggregate );
-					delete newType->aggInst->aggregate->aggregate->fields;
-					newType->aggInst->aggregate->aggregate->fields = 0;
-				} // if
-			} // if
+					delete newType->aggInst->aggregate->aggregate->members;
+					newType->aggInst->aggregate->aggregate->members = 0;
+				}
+			}
 			newType->forall = maybeClone( type->forall );
 			if ( ! o->type ) {
@@ -718,7 +707,7 @@
 				addTypeToType( newType, o->type );
 				delete newType;
-			} // if
-		} // if
-	} // if
+			}
+		}
+	}
 	return o;
 }
@@ -742,7 +731,7 @@
 				addTypeToType( newType, o->type );
 				delete newType;
-			} // if
-		} // if
-	} // if
+			}
+		}
+	}
 	return o;
 }
@@ -751,5 +740,5 @@
 	if ( node != 0 ) {
 		set_link( node );
-	} // if
+	}
 	return this;
 }
@@ -767,7 +756,7 @@
 }
 
-void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) {
+void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList ) {
 	SemanticError errors;
-	std::back_insert_iterator< std::list< Declaration *> > out( outputList );
+	std::back_insert_iterator< std::list< Declaration* > > out( outputList );
 	const DeclarationNode *cur = firstNode;
 	while ( cur ) {
@@ -787,5 +776,5 @@
 			errors.append( e );
 		} // try
-		cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+		cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
 	} // while
 	if ( ! errors.isEmpty() ) {
@@ -794,7 +783,7 @@
 }
 
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList ) {
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList ) {
 	SemanticError errors;
-	std::back_insert_iterator< std::list< DeclarationWithType *> > out( outputList );
+	std::back_insert_iterator< std::list< DeclarationWithType* > > out( outputList );
 	const DeclarationNode *cur = firstNode;
 	while ( cur ) {
@@ -810,13 +799,13 @@
 			Declaration *decl = cur->build();
 			if ( decl ) {
-				if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType *>( decl ) ) {
+				if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
 					*out++ = dwt;
-				} else if ( StructDecl *agg = dynamic_cast< StructDecl *>( decl ) ) {
+				} else if ( StructDecl *agg = dynamic_cast< StructDecl* >( decl ) ) {
 					StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
-					*out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
+					*out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
 					delete agg;
-				} else if ( UnionDecl *agg = dynamic_cast< UnionDecl *>( decl ) ) {
+				} else if ( UnionDecl *agg = dynamic_cast< UnionDecl* >( decl ) ) {
 					UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
-					*out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
+					*out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
 				} // if
 			} // if
@@ -824,5 +813,5 @@
 			errors.append( e );
 		} // try
-		cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+		cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
 	} // while
 	if ( ! errors.isEmpty() ) {
@@ -831,7 +820,7 @@
 }
 
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList ) {
+void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList ) {
 	SemanticError errors;
-	std::back_insert_iterator< std::list< Type *> > out( outputList );
+	std::back_insert_iterator< std::list< Type* > > out( outputList );
 	const DeclarationNode *cur = firstNode;
 	while ( cur ) {
@@ -841,5 +830,5 @@
 			errors.append( e );
 		} // try
-		cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+		cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
 	} // while
 	if ( ! errors.isEmpty() ) {
@@ -850,11 +839,11 @@
 Declaration *DeclarationNode::build() const {
 	if ( type ) {
-		Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildFuncSpecifier( Inline ), buildFuncSpecifier( Noreturn ), linkage, maybeBuild< Initializer >(initializer) );
+		Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) );
 		return newDecl;
 	} // if
-	if ( ! buildFuncSpecifier( Inline ) && ! buildFuncSpecifier( Noreturn ) ) {
+	if ( ! buildInline() ) {
 		return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
 	} // if
-	throw SemanticError( "invalid function specifier in declaration of ", this );
+	throw SemanticError( "invalid inline specification in declaration of ", this );
 }
 
@@ -893,22 +882,32 @@
 }
 
-DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const {
-	DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass;
-	for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
-	  if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers
-	  if ( ret != DeclarationNode::NoStorageClass ) {	// already have a valid storage class ?
+Declaration::StorageClass DeclarationNode::buildStorageClass() const {
+	static const Declaration::StorageClass scMap[] = {  
+		Declaration::Extern,
+		Declaration::Static,
+		Declaration::Auto,
+		Declaration::Register,
+		Declaration::Inline,
+		Declaration::Fortran
+	};  
+  
+	Declaration::StorageClass ret = Declaration::NoStorageClass;
+	for ( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
+		assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) );
+	  if ( *i == Inline ) continue;
+	  if ( ret != Declaration::NoStorageClass ) {
 			throw SemanticError( "invalid combination of storage classes in declaration of ", this );
-		} // if
-		ret = *i;
-	} // for
+		}
+		ret = scMap[ *i ];
+	}
 	return ret;
 }
 
-bool DeclarationNode::buildFuncSpecifier( DeclarationNode::StorageClass key ) const {
-	std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), key );
-  if ( first == storageClasses.end() ) return false;	// not found
-	first = std::find( ++first, storageClasses.end(), key ); // found
-  if ( first == storageClasses.end() ) return true;		// not found again
-	throw SemanticError( "duplicate function specifier in declaration of ", this );
+bool DeclarationNode::buildInline() const {
+	std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
+  if ( first == storageClasses.end() ) return false;
+	std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
+  if ( next == storageClasses.end() ) return true;
+	throw SemanticError( "duplicate inline specification in declaration of ", this );
 }
 
Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/ExpressionNode.cc	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -9,7 +9,7 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:17:07 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Jun 24 16:20:00 2015
-// Update Count     : 158
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 13:19:35 2015
+// Update Count     : 2
 // 
 
@@ -17,11 +17,10 @@
 #include <cctype>
 #include <algorithm>
-#include <sstream>
-#include <cstdio>
-#include <climits>
 
 #include "ParseNode.h"
+#include "SynTree/Type.h"
 #include "SynTree/Constant.h"
 #include "SynTree/Expression.h"
+#include "SynTree/Declaration.h"
 #include "UnimplementedError.h"
 #include "parseutility.h"
@@ -32,5 +31,7 @@
 ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}
 
-ExpressionNode::ExpressionNode( const string *name_ ) : ParseNode( name_ ), argName( 0 ) {}
+ExpressionNode::ExpressionNode( string *name_) : ParseNode( *name_ ), argName( 0 ) {
+	delete name_;
+}
 
 ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ) {
@@ -42,5 +43,5 @@
 }
 
-ExpressionNode * ExpressionNode::set_asArgName( const std::string *aName ) {
+ExpressionNode * ExpressionNode::set_asArgName( std::string *aName ) {
 	argName = new VarRefNode( aName );
 	return this;
@@ -54,5 +55,5 @@
 void ExpressionNode::printDesignation( std::ostream &os, int indent ) const {
 	if ( argName ) {
-		os << string( indent, ' ' ) << "(designated by:  ";
+		os << string(' ', indent ) << "(designated by:  ";
 		argName->printOneLine( os, indent );
 		os << ")" << std::endl;
@@ -60,6 +61,4 @@
 }
 
-//##############################################################################
-
 NullExprNode::NullExprNode() {}
 
@@ -86,151 +85,115 @@
 }
 
-//##############################################################################
-
-static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
-static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
-static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
-static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
-
-// Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
-//
-//		prefix action constant action suffix
-//
-// Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
-//
-//		constant BEGIN CONT ...
-//		<CONT>(...)? BEGIN 0 ... // possible empty suffix
-//
-// because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
-// type.
-
-ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), value( *inVal ) {
-	// lexing divides constants into 4 kinds
+//  enum ConstantNode::Type =  { Integer, Float, Character, String, Range }
+
+ConstantNode::ConstantNode( void ) : ExpressionNode(), sign( true ), longs(0), size(0) {}
+
+ConstantNode::ConstantNode( string *name_) : ExpressionNode( name_), sign( true ), longs(0), size(0) {}
+
+ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), sign( true ), longs(0), size(0) {
+	if ( inVal ) {
+		value = *inVal;
+		delete inVal;
+	} else {
+		value = "";
+	} // if
+
+	classify( value );
+}
+
+ConstantNode::ConstantNode( const ConstantNode &other ) : ExpressionNode( other ), type( other.type ), value( other.value ), sign( other.sign ),
+														  base( other.base ), longs( other.longs ), size( other.size ) {
+}
+
+// for some reason, std::tolower doesn't work as an argument to std::transform in g++ 3.1
+inline char tolower_hack( char c ) {
+	return std::tolower( c );
+}
+
+void ConstantNode::classify( std::string &str ) {
 	switch ( type ) {
 	  case Integer:
-		{
-			static const BasicType::Kind kind[2][3] = {
-				{ BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
-				{ BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
-			};
-			size_t last = value.length() - 1;			// last character of constant
-			unsigned long long v;						// converted integral value
-			bool dec = true, Unsigned = false;			// decimal, unsigned constant
-			int size;									// 0 => int, 1 => long, 2 => long long
-
-			if ( value[0] == '0' ) {					// octal constant ?
-				dec = false;
-				if ( last != 0 && checkX( value[1] ) ) { // hex constant ?
-					sscanf( (char *)value.c_str(), "%llx", &v );
-					//printf( "%llx %llu\n", v, v );
-				} else {
-					sscanf( (char *)value.c_str(), "%llo", &v );
-					//printf( "%llo %llu\n", v, v );
-				} // if
-			} else {									// decimal constant ?
-				sscanf( (char *)value.c_str(), "%llu", &v );
-				//printf( "%llu %llu\n", v, v );
-			} // if
-
-			if ( v <= INT_MAX ) {						// signed int
-				size = 0;
-			} else if ( v <= UINT_MAX && ! dec ) {		// unsigned int
-				size = 0;
-				Unsigned = true;						// unsigned
-			} else if ( v <= LONG_MAX ) {				// signed long int
-				size = 1;
-			} else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
-				size = 1;
-				Unsigned = true;						// unsigned long int
-			} else if ( v <= LLONG_MAX ) {				// signed long long int
-				size = 2;
-			} else {									// unsigned long long int
-				size = 2;
-				Unsigned = true;						// unsigned long long int
-			} // if
-
-			if ( checkU( value[last] ) ) {				// suffix 'u' ?
-				Unsigned = true;
-				if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'l' ?
-					size = 1;
-					if ( last > 1 && checkL( value[ last - 2 ] ) ) { // suffix 'll' ?
-						size = 2;
-					} // if
-				} // if
-			} else if ( checkL( value[ last ] ) ) {		// suffix 'l' ?
-				size = 1;
-				if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'll' ?
-					size = 2;
-					if ( last > 1 && checkU( value[ last - 2 ] ) ) { // suffix 'u' ?
-						Unsigned = true;
-					} // if
-				} else {
-					if ( last > 0 && checkU( value[ last - 1 ] ) ) { // suffix 'u' ?
-						Unsigned = true;
-					} // if
-				} // if
-			} // if
-			btype = kind[Unsigned][size];				// lookup constant type
-			break;
-		}
 	  case Float:
 		{
-			size_t len = value.length() - 1;
-
-			btype = BasicType::Double;					// default
-			if ( checkF( value[len] ) ) {				// float ?
-				btype = BasicType::Float;
+			std::string sfx("");
+			char c;
+			int i = str.length() - 1;
+
+			while ( i >= 0 && ! isxdigit( c = str.at( i--)) )
+				sfx += c;
+
+			value = str.substr( 0, i + 2 );
+
+			// get rid of underscores
+			value.erase( remove( value.begin(), value.end(), '_'), value.end());
+
+			std::transform( sfx.begin(), sfx.end(), sfx.begin(), tolower_hack );
+
+			if ( sfx.find("ll") != string::npos ) {
+				longs = 2;
+			} else if ( sfx.find("l") != string::npos ) {
+				longs = 1;
 			} // if
-			if ( checkL( value[len] ) ) {				// long double ?
-				btype = BasicType::LongDouble;
-			} // if
+
+			assert(( longs >= 0) && ( longs <= 2));
+
+			if ( sfx.find("u") != string::npos )
+				sign = false;
+
 			break;
 		}
 	  case Character:
-		btype = BasicType::Char;						// default
-		if ( string( "LUu" ).find( value[0] ) != string::npos ) {
-			// ???
-		} // if
+		{
+			// remove underscores from hex and oct escapes
+			if ( str.substr(1,2) == "\\x")
+				value.erase( remove( value.begin(), value.end(), '_'), value.end());
+
+			break;
+		}
+	  default:
+		// shouldn't be here
+		;
+	}
+}
+
+ConstantNode::Type ConstantNode::get_type( void ) const {
+	return type;
+}
+
+ConstantNode *ConstantNode::append( std::string *newValue ) {
+	if ( newValue ) {
+		if ( type == String ) {
+			std::string temp = *newValue;
+			value.resize( value.size() - 1 );
+			value += newValue->substr(1, newValue->size());
+		} else
+			value += *newValue;
+
+		delete newValue;
+	} // if
+	return this;
+}
+
+void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
+	os << string( indent, ' ');
+	printDesignation( os );
+
+	switch ( type ) {
+		/* integers */
+	  case Integer:
+		os << value ;
 		break;
-	  case String:
-		// array of char
-		if ( string( "LUu" ).find( value[0] ) != string::npos ) {
-			if ( value[0] == 'u' && value[1] == '8' ) {
-				// ???
-			} else {
-				// ???
-			} // if
-		} // if
-		break;
-	} // switch
-} // ConstantNode::ConstantNode
-
-ConstantNode *ConstantNode::appendstr( const std::string *newValue ) {
-	assert( newValue != 0 );
-	assert( type == String );
-
-	// "abc" "def" "ghi" => "abcdefghi", so remove new text from quotes and insert before last quote in old string.
-	value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) );
-	
-	delete newValue;									// allocated by lexer
-	return this;
-}
-
-void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
-	os << string( indent, ' ' );
-	printDesignation( os );
-
-	switch ( type ) {
-	  case Integer:
 	  case Float:
 		os << value ;
 		break;
+
 	  case Character:
 		os << "'" << value << "'";
 		break;
+
 	  case String:
 		os << '"' << value << '"';
 		break;
-	} // switch
+	}
 
 	os << ' ';
@@ -243,27 +206,35 @@
 
 Expression *ConstantNode::build() const {
-	::Type::Qualifiers q;								// no qualifiers on constants
-
-	switch ( get_type() ) {
+	::Type::Qualifiers q;
+	BasicType *bt;
+
+	switch ( get_type()) {
+	  case Integer:
+		/* Cfr. standard 6.4.4.1 */
+		//bt.set_kind( BasicType::SignedInt );
+		bt = new BasicType( q, BasicType::SignedInt );
+		break;
+	  case Float:
+		bt = new BasicType( q, BasicType::Float );
+		break;
+	  case Character:
+		bt = new BasicType( q, BasicType::Char );
+		break;
 	  case String:
-		{
-			// string should probably be a primitive type
-			ArrayType *at = new ArrayType( q, new BasicType( q, BasicType::Char ),
-										   new ConstantExpr(
-											   Constant( new BasicType( q, BasicType::UnsignedInt ),
-														 toString( value.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
-										   false, false );
-			return new ConstantExpr( Constant( at, value ), maybeBuild< Expression >( get_argName() ) );
-		}
-	  default:
-		return new ConstantExpr( Constant( new BasicType( q, btype ), get_value() ), maybeBuild< Expression >( get_argName() ) );
+		// string should probably be a primitive type
+		ArrayType *at;
+		std::string value = get_value();
+		at = new ArrayType( q, new BasicType( q, BasicType::Char ),
+							new ConstantExpr( Constant( new BasicType( q, BasicType::SignedInt ),
+														toString( value.size() - 1 ) ) ),  // account for '\0'
+							false, false );
+		return new ConstantExpr( Constant( at, value ), maybeBuild< Expression >( get_argName() ) );
 	}
-}
-
-//##############################################################################
+	return new ConstantExpr(  Constant( bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
+}
 
 VarRefNode::VarRefNode() : isLabel( false ) {}
 
-VarRefNode::VarRefNode( const string *name_, bool labelp ) : ExpressionNode( name_ ), isLabel( labelp ) {}
+VarRefNode::VarRefNode( string *name_, bool labelp ) : ExpressionNode( name_), isLabel( labelp ) {}
 
 VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {
@@ -281,11 +252,9 @@
 void VarRefNode::print( std::ostream &os, int indent ) const {
 	printDesignation( os );
-	os << string( indent, ' ' ) << "Referencing: ";
+	os << '\r' << string( indent, ' ') << "Referencing: ";
 	os << "Variable: " << get_name();
 	os << endl;
 }
 
-//##############################################################################
-
 OperatorNode::OperatorNode( Type t ) : type( t ) {}
 
@@ -306,10 +275,10 @@
 void OperatorNode::print( std::ostream &os, int indent ) const{
 	printDesignation( os );
-	os << string( indent, ' ' ) << "Operator: " << OpName[type] << endl;
+	os << '\r' << string( indent, ' ') << "Operator: " << OpName[type] << endl;
 	return;
 }
 
-const char *OperatorNode::get_typename( void ) const{
-	return OpName[ type ];
+std::string OperatorNode::get_typename( void ) const{
+	return string( OpName[ type ]);
 }
 
@@ -319,5 +288,5 @@
 	"Cond",   "NCond",
 	// diadic
-	"SizeOf",     "AlignOf", "Attr", "CompLit", "Plus",    "Minus",   "Mul",     "Div",     "Mod",      "Or",
+	"SizeOf",      "AlignOf", "Attr", "CompLit", "Plus",    "Minus",   "Mul",     "Div",     "Mod",      "Or",
 	"And",       "BitOr",   "BitAnd",  "Xor",     "Cast",    "LShift",  "RShift",  "LThan",   "GThan",
 	"LEThan",    "GEThan", "Eq",      "Neq",     "Assign",  "MulAssn", "DivAssn", "ModAssn", "PlusAssn",
@@ -328,10 +297,8 @@
 };
 
-//##############################################################################
-
 CompositeExprNode::CompositeExprNode( void ) : ExpressionNode(), function( 0 ), arguments( 0 ) {
 }
 
-CompositeExprNode::CompositeExprNode( const string *name_ ) : ExpressionNode( name_ ), function( 0 ), arguments( 0 ) {
+CompositeExprNode::CompositeExprNode( string *name_) : ExpressionNode( name_), function( 0 ), arguments( 0 ) {
 }
 
@@ -364,13 +331,13 @@
 // the names that users use to define operator functions
 static const char *opFuncName[] = {
-	"",		"",		"",
-	"",		"",
-	//diadic
-	"",		"",		"",		"",		"?+?",		"?-?",	"?*?",	"?/?",	"?%?",	"",		 "",
-	"?|?",		"?&?",		"?^?",	"",		"?<<?",	"?>>?",	"?<?",	"?>?",	"?<=?",
-	"?>=?",		"?==?",		"?!=?",	"?=?",	"?*=?",	"?/=?",	"?%=?",	"?+=?",	"?-=?",
-	"?<<=?",	"?>>=?",	"?&=?",	"?^=?",	"?|=?",	"?[?]",	"",		"",		"Range",
-	//monadic
-	"+?",		"-?",		"",		"*?",	"!?",	"~?",	"++?",	"?++",	"--?",	"?--",	"&&"
+	"",  "", "",
+	"",   "",
+	// diadic
+	"",   "", "", "", "?+?",    "?-?",   "?*?",     "?/?",     "?%?",     "",       "",
+	"?|?",  "?&?",  "?^?",     "",    "?<<?",  "?>>?",  "?<?",   "?>?",    "?<=?",
+	"?>=?", "?==?",      "?!=?",     "?=?",  "?*=?", "?/=?", "?%=?", "?+=?", "?-=?",
+	"?<<=?", "?>>=?",  "?&=?", "?^=?",  "?|=?",  "?[?]",   "","","Range",
+	// monadic
+	"+?", "-?", "", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "LabAddress"
 };
 
@@ -383,191 +350,192 @@
 	buildList( get_args(), args );
 
-	if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator
+	if ( ! ( op = dynamic_cast<OperatorNode *>( function )) ) {
+		// a function as opposed to an operator
 		return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
-	} // if
-
-	switch ( op->get_type()) {
-	  case OperatorNode::Incr:
-	  case OperatorNode::Decr:
-	  case OperatorNode::IncrPost:
-	  case OperatorNode::DecrPost:
-	  case OperatorNode::Assign:
-	  case OperatorNode::MulAssn:
-	  case OperatorNode::DivAssn:
-	  case OperatorNode::ModAssn:
-	  case OperatorNode::PlusAssn:
-	  case OperatorNode::MinusAssn:
-	  case OperatorNode::LSAssn:
-	  case OperatorNode::RSAssn:
-	  case OperatorNode::AndAssn:
-	  case OperatorNode::ERAssn:
-	  case OperatorNode::OrAssn:
-		// the rewrite rules for these expressions specify that the first argument has its address taken
-		assert( ! args.empty() );
-		args.front() = new AddressExpr( args.front() );
-		break;
-	  default:
-		/* do nothing */
-		;
-	}
-
-	switch ( op->get_type() ) {
-	  case OperatorNode::Incr:
-	  case OperatorNode::Decr:
-	  case OperatorNode::IncrPost:
-	  case OperatorNode::DecrPost:
-	  case OperatorNode::Assign:
-	  case OperatorNode::MulAssn:
-	  case OperatorNode::DivAssn:
-	  case OperatorNode::ModAssn:
-	  case OperatorNode::PlusAssn:
-	  case OperatorNode::MinusAssn:
-	  case OperatorNode::LSAssn:
-	  case OperatorNode::RSAssn:
-	  case OperatorNode::AndAssn:
-	  case OperatorNode::ERAssn:
-	  case OperatorNode::OrAssn:
-	  case OperatorNode::Plus:
-	  case OperatorNode::Minus:
-	  case OperatorNode::Mul:
-	  case OperatorNode::Div:
-	  case OperatorNode::Mod:
-	  case OperatorNode::BitOr:
-	  case OperatorNode::BitAnd:
-	  case OperatorNode::Xor:
-	  case OperatorNode::LShift:
-	  case OperatorNode::RShift:
-	  case OperatorNode::LThan:
-	  case OperatorNode::GThan:
-	  case OperatorNode::LEThan:
-	  case OperatorNode::GEThan:
-	  case OperatorNode::Eq:
-	  case OperatorNode::Neq:
-	  case OperatorNode::Index:
-	  case OperatorNode::Range:
-	  case OperatorNode::UnPlus:
-	  case OperatorNode::UnMinus:
-	  case OperatorNode::PointTo:
-	  case OperatorNode::Neg:
-	  case OperatorNode::BitNeg:
-	  case OperatorNode::LabelAddress:
-		return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
-	  case OperatorNode::AddressOf:
-		assert( args.size() == 1 );
-		assert( args.front() );
-
-		return new AddressExpr( args.front() );
-	  case OperatorNode::Cast:
-		{
-			TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
-			assert( arg );
-
-			DeclarationNode *decl_node = arg->get_decl();
-			ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
-
-			Type *targetType = decl_node->buildType();
-			if ( dynamic_cast< VoidType* >( targetType ) ) {
-				delete targetType;
-				return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
-			} else {
-				return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
-			} // if
+	} else {
+		switch ( op->get_type()) {
+		  case OperatorNode::Incr:
+		  case OperatorNode::Decr:
+		  case OperatorNode::IncrPost:
+		  case OperatorNode::DecrPost:
+		  case OperatorNode::Assign:
+		  case OperatorNode::MulAssn:
+		  case OperatorNode::DivAssn:
+		  case OperatorNode::ModAssn:
+		  case OperatorNode::PlusAssn:
+		  case OperatorNode::MinusAssn:
+		  case OperatorNode::LSAssn:
+		  case OperatorNode::RSAssn:
+		  case OperatorNode::AndAssn:
+		  case OperatorNode::ERAssn:
+		  case OperatorNode::OrAssn:
+			// the rewrite rules for these expressions specify that the first argument has its address taken
+			assert( ! args.empty() );
+			args.front() = new AddressExpr( args.front() );
+			break;
+		  default:
+			/* do nothing */
+			;
 		}
-	  case OperatorNode::FieldSel:
-		{
-			assert( args.size() == 2 );
-
-			NameExpr *member = dynamic_cast<NameExpr *>( args.back());
-			// TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
-
-			if ( member != 0 ) {
-				UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
+
+		switch ( op->get_type() ) {
+		  case OperatorNode::Incr:
+		  case OperatorNode::Decr:
+		  case OperatorNode::IncrPost:
+		  case OperatorNode::DecrPost:
+		  case OperatorNode::Assign:
+		  case OperatorNode::MulAssn:
+		  case OperatorNode::DivAssn:
+		  case OperatorNode::ModAssn:
+		  case OperatorNode::PlusAssn:
+		  case OperatorNode::MinusAssn:
+		  case OperatorNode::LSAssn:
+		  case OperatorNode::RSAssn:
+		  case OperatorNode::AndAssn:
+		  case OperatorNode::ERAssn:
+		  case OperatorNode::OrAssn:
+		  case OperatorNode::Plus:
+		  case OperatorNode::Minus:
+		  case OperatorNode::Mul:
+		  case OperatorNode::Div:
+		  case OperatorNode::Mod:
+		  case OperatorNode::BitOr:
+		  case OperatorNode::BitAnd:
+		  case OperatorNode::Xor:
+		  case OperatorNode::LShift:
+		  case OperatorNode::RShift:
+		  case OperatorNode::LThan:
+		  case OperatorNode::GThan:
+		  case OperatorNode::LEThan:
+		  case OperatorNode::GEThan:
+		  case OperatorNode::Eq:
+		  case OperatorNode::Neq:
+		  case OperatorNode::Index:
+		  case OperatorNode::Range:
+		  case OperatorNode::UnPlus:
+		  case OperatorNode::UnMinus:
+		  case OperatorNode::PointTo:
+		  case OperatorNode::Neg:
+		  case OperatorNode::BitNeg:
+		  case OperatorNode::LabelAddress:
+			return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
+		  case OperatorNode::AddressOf:
+			assert( args.size() == 1 );
+			assert( args.front() );
+
+			return new AddressExpr( args.front() );
+		  case OperatorNode::Cast:
+			{
+				TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
+				assert( arg );
+
+				DeclarationNode *decl_node = arg->get_decl();
+				ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
+
+				Type *targetType = decl_node->buildType();
+				if ( dynamic_cast< VoidType* >( targetType ) ) {
+					delete targetType;
+					return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
+				} else {
+					return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
+				} // if
+			}
+		  case OperatorNode::FieldSel:
+			{
+				assert( args.size() == 2 );
+
+				NameExpr *member = dynamic_cast<NameExpr *>( args.back());
+				// TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
+
+				if ( member != 0 ) {
+					UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
+					delete member;
+					return ret;
+					/* else if ( memberTup != 0 )
+					   {
+					   UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
+					   delete member;
+					   return ret;
+					   } */
+				} else
+					assert( false );
+			}
+		  case OperatorNode::PFieldSel:
+			{
+				assert( args.size() == 2 );
+
+				NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
+				assert( member != 0 );
+
+				UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+				deref->get_args().push_back( args.front() );
+
+				UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
 				delete member;
 				return ret;
-				/* else if ( memberTup != 0 )
-				   {
-				   UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
-				   delete member;
-				   return ret;
-				   } */
-			} else
-				assert( false );
+			}
+		  case OperatorNode::AlignOf:
+		  case OperatorNode::SizeOf:
+			{
+/// 	bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf );
+
+				if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
+					return new SizeofExpr( arg->get_decl()->buildType());
+				} else {
+					return new SizeofExpr( args.front());
+				} // if
+			}
+		  case OperatorNode::Attr:
+			{
+				VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
+				assert( var );
+				if ( ! get_args()->get_link() ) {
+					return new AttrExpr( var->build(), ( Expression*)0);
+				} else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
+					return new AttrExpr( var->build(), arg->get_decl()->buildType());
+				} else {
+					return new AttrExpr( var->build(), args.back());
+				} // if
+			}
+		  case OperatorNode::CompLit:
+			throw UnimplementedError( "C99 compound literals" );
+			// the short-circuited operators
+		  case OperatorNode::Or:
+		  case OperatorNode::And:
+			assert( args.size() == 2);
+			return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) );
+		  case OperatorNode::Cond:
+			{
+				assert( args.size() == 3);
+				std::list< Expression* >::const_iterator i = args.begin();
+				Expression *arg1 = notZeroExpr( *i++ );
+				Expression *arg2 = *i++;
+				Expression *arg3 = *i++;
+				return new ConditionalExpr( arg1, arg2, arg3 );
+			}
+		  case OperatorNode::NCond:
+			throw UnimplementedError( "GNU 2-argument conditional expression" );
+		  case OperatorNode::Comma:
+			{
+				assert( args.size() == 2);
+				std::list< Expression* >::const_iterator i = args.begin();
+				Expression *ret = *i++;
+				while ( i != args.end() ) {
+					ret = new CommaExpr( ret, *i++ );
+				}
+				return ret;
+			}
+			// Tuples
+		  case OperatorNode::TupleC:
+			{
+				TupleExpr *ret = new TupleExpr();
+				std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
+				return ret;
+			}
+		  default:
+			// shouldn't happen
+			return 0;
 		}
-	  case OperatorNode::PFieldSel:
-		{
-			assert( args.size() == 2 );
-
-			NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
-			assert( member != 0 );
-
-			UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-			deref->get_args().push_back( args.front() );
-
-			UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
-			delete member;
-			return ret;
-		}
-	  case OperatorNode::AlignOf:
-	  case OperatorNode::SizeOf:
-		{
-/// 	bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf );
-
-			if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
-				return new SizeofExpr( arg->get_decl()->buildType());
-			} else {
-				return new SizeofExpr( args.front());
-			} // if
-		}
-	  case OperatorNode::Attr:
-		{
-			VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
-			assert( var );
-			if ( ! get_args()->get_link() ) {
-				return new AttrExpr( var->build(), ( Expression*)0);
-			} else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
-				return new AttrExpr( var->build(), arg->get_decl()->buildType());
-			} else {
-				return new AttrExpr( var->build(), args.back());
-			} // if
-		}
-	  case OperatorNode::CompLit:
-		throw UnimplementedError( "C99 compound literals" );
-		// the short-circuited operators
-	  case OperatorNode::Or:
-	  case OperatorNode::And:
-		assert( args.size() == 2);
-		return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) );
-	  case OperatorNode::Cond:
-		{
-			assert( args.size() == 3);
-			std::list< Expression* >::const_iterator i = args.begin();
-			Expression *arg1 = notZeroExpr( *i++ );
-			Expression *arg2 = *i++;
-			Expression *arg3 = *i++;
-			return new ConditionalExpr( arg1, arg2, arg3 );
-		}
-	  case OperatorNode::NCond:
-		throw UnimplementedError( "GNU 2-argument conditional expression" );
-	  case OperatorNode::Comma:
-		{
-			assert( args.size() == 2);
-			std::list< Expression* >::const_iterator i = args.begin();
-			Expression *ret = *i++;
-			while ( i != args.end() ) {
-				ret = new CommaExpr( ret, *i++ );
-			}
-			return ret;
-		}
-		// Tuples
-	  case OperatorNode::TupleC:
-		{
-			TupleExpr *ret = new TupleExpr();
-			std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
-			return ret;
-		}
-	  default:
-		// shouldn't happen
-		return 0;
-	} // switch
+	}
 }
 
@@ -584,8 +552,8 @@
 void CompositeExprNode::print( std::ostream &os, int indent ) const {
 	printDesignation( os );
-	os << string( indent, ' ' ) << "Application of: " << endl;
+	os << '\r' << string( indent, ' ') << "Application of: " << endl;
 	function->print( os, indent + ParseNode::indent_by );
 
-	os << string( indent, ' ' ) ;
+	os << '\r' << string( indent, ' ') ;
 	if ( arguments ) {
 		os << "... on arguments: " << endl;
@@ -618,6 +586,4 @@
 }
 
-//##############################################################################
-
 CommaExprNode::CommaExprNode(): CompositeExprNode( new OperatorNode( OperatorNode::Comma )) {}
 
@@ -637,6 +603,4 @@
 }
 
-//##############################################################################
-
 ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {}
 
@@ -650,5 +614,5 @@
 void ValofExprNode::print( std::ostream &os, int indent ) const {
 	printDesignation( os );
-	os << string( indent, ' ' ) << "Valof Expression:" << std::endl;
+	os << string( indent, ' ') << "Valof Expression:" << std::endl;
 	get_body()->print( os, indent + 4);
 }
@@ -661,6 +625,4 @@
 	return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) );
 }
-
-//##############################################################################
 
 ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
@@ -671,5 +633,5 @@
 		ExpressionNode *exp;
 
-		if (( decl = dynamic_cast<DeclarationNode *>(init_) ) != 0)
+		if (( decl = dynamic_cast<DeclarationNode *>( init_)) != 0)
 			init = new StatementNode( decl );
 		else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
@@ -697,16 +659,16 @@
 
 void ForCtlExprNode::print( std::ostream &os, int indent ) const{
-	os << string( indent,' ' ) << "For Control Expression -- :" << endl;
-
-	os << string( indent + 2, ' ' ) << "initialization:" << endl;
-	if ( init != 0 )
-		init->printList( os, indent + 4 );
-
-	os << string( indent + 2, ' ' ) << "condition: " << endl;
-	if ( condition != 0 )
-		condition->print( os, indent + 4 );
-	os << string( indent + 2, ' ' ) << "increment: " << endl;
-	if ( change != 0 )
-		change->print( os, indent + 4 );
+	os << string( indent,' ') << "For Control Expression -- : " << endl;
+
+	os << "\r" << string( indent + 2,' ') << "initialization: ";
+	if ( init != 0)
+		init->print( os, indent + 4);
+
+	os << "\n\r" << string( indent + 2,' ') << "condition: ";
+	if ( condition != 0)
+		condition->print( os, indent + 4);
+	os << "\n\r" << string( indent + 2,' ') << "increment: ";
+	if ( change != 0)
+		change->print( os, indent + 4);
 }
 
@@ -715,10 +677,10 @@
 }
 
-//##############################################################################
-
-TypeValueNode::TypeValueNode( DeclarationNode *decl ) : decl( decl ) {
-}
-
-TypeValueNode::TypeValueNode( const TypeValueNode &other ) : ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
+TypeValueNode::TypeValueNode( DeclarationNode *decl )
+	: decl( decl ) {
+}
+
+TypeValueNode::TypeValueNode( const TypeValueNode &other )
+	: ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
 }
 
@@ -738,12 +700,14 @@
 
 ExpressionNode *flattenCommas( ExpressionNode *list ) {
-	if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
-		OperatorNode *op;
-		if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) {
-			if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
-				composite->add_arg( next );
-			return flattenCommas( composite->get_args() );
-		} // if
-	} // if
+	if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) )
+		{
+			OperatorNode *op;
+			if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) )
+				{
+					if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
+						composite->add_arg( next );
+					return flattenCommas( composite->get_args() );
+				}
+		}
 
 	if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
@@ -758,5 +722,5 @@
 		if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )
 			return composite->get_args();
-	} // if
+	}
 	return tuple;
 }
Index: src/Parser/InitializerNode.cc
===================================================================
--- src/Parser/InitializerNode.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/InitializerNode.cc	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun  6 15:49:42 2015
-// Update Count     : 3
+// Last Modified On : Sat May 16 13:21:40 2015
+// Update Count     : 2
 // 
 
@@ -48,5 +48,5 @@
 
 void InitializerNode::print( std::ostream &os, int indent ) const {
-	os << std::string( indent, ' ' ) << "Initializer expression" << std::endl;
+	os << std::string(indent, ' ') << "Initializer expression" << std::endl;
 }
 
Index: src/Parser/ParseNode.cc
===================================================================
--- src/Parser/ParseNode.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/ParseNode.cc	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:26:29 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun  6 20:17:58 2015
-// Update Count     : 23
+// Last Modified On : Tue May 19 16:48:30 2015
+// Update Count     : 3
 // 
 
@@ -20,16 +20,32 @@
 int ParseNode::indent_by = 4;
 
-ParseNode::ParseNode() : name( 0 ), next( 0 ) {};
-ParseNode::ParseNode( const string *name_ ) : name( name_ ), next( 0 ) {}
+ParseNode::ParseNode( void ) : next( 0 ) {};
+ParseNode::ParseNode( string _name ) : name( _name ), next( 0 ) {}
 
-ParseNode::~ParseNode() {
+ParseNode *ParseNode::set_name( string _name ) {
+	name = _name;
+	return this;
+}
+
+ParseNode *ParseNode::set_name( string *_name ) {
+	name = *_name; // deep copy
+	delete _name;
+
+	return this;
+}
+
+ParseNode::~ParseNode( void ) {
 	delete next;
 };
 
-ParseNode *ParseNode::get_link() const {
+string ParseNode::get_name( void ) {
+	return name;
+}
+
+ParseNode *ParseNode::get_link( void ) const {
 	return next;
 }
 
-ParseNode *ParseNode::get_last() {
+ParseNode *ParseNode::get_last(void) {
 	ParseNode *current = this;
 
@@ -40,16 +56,20 @@
 }
 
-ParseNode *ParseNode::set_link( ParseNode *next_ ) {
+ParseNode *ParseNode::set_link(ParseNode *_next) {
 	ParseNode *follow;
 
-	if ( next_ == 0 ) return this;
+	if ( _next == 0 ) return this;
 
 	for ( follow = this; follow->next != 0; follow = follow->next );
-	follow->next = next_;
+	follow->next = _next;
 
 	return this;
 }
 
-void ParseNode::print( std::ostream &os, int indent ) const {}
+const string ParseNode::get_name(void) const {
+	return name;
+}
+
+void ParseNode::print(std::ostream &os, int indent) const {}
 
 
@@ -58,6 +78,6 @@
 
 	if ( next ) {
-		next->printList( os, indent );
-	} // if
+	next->printList( os, indent );
+	}
 }
 
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/ParseNode.h	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 25 17:27:42 2015
-// Update Count     : 83
+// Last Modified On : Sat May 16 13:30:24 2015
+// Update Count     : 3
 //
 
@@ -22,7 +22,5 @@
 
 #include "utility.h"
-#include "Parser/LinkageSpec.h"
-#include "SynTree/Type.h"
-//#include "SynTree/Declaration.h"
+#include "SynTree/Declaration.h"
 #include "UniqueName.h"
 
@@ -38,10 +36,15 @@
 class ParseNode {
   public:
-	ParseNode();
-	ParseNode( const std::string * );
-	virtual ~ParseNode();
-
-	ParseNode *get_link() const;
-	ParseNode *get_last();
+	ParseNode( void );
+	ParseNode ( std::string );
+	virtual ~ParseNode( void );
+
+	ParseNode *set_name ( std::string ) ;
+	ParseNode *set_name ( std::string * ) ;
+
+	std::string get_name( void );
+
+	ParseNode *get_link( void ) const;
+	ParseNode *get_last( void );
 	ParseNode *set_link( ParseNode * );
 	void set_next( ParseNode *newlink ) { next = newlink; }
@@ -49,5 +52,5 @@
 	virtual ParseNode *clone() const { return 0; };
 
-	const std::string &get_name() const { return *name; }
+	const std::string get_name( void ) const;
 	virtual void print( std::ostream &, int indent = 0 ) const;
 	virtual void printList( std::ostream &, int indent = 0 ) const;
@@ -55,5 +58,5 @@
 	ParseNode &operator,( ParseNode &);
   protected:
-	const std::string *name;
+	std::string name;
 	ParseNode *next;
 	static int indent_by;
@@ -65,5 +68,5 @@
   public:
 	ExpressionNode();
-	ExpressionNode( const std::string * );
+	ExpressionNode( std::string * );
 	ExpressionNode( const ExpressionNode &other );
 	virtual ~ExpressionNode() {} // cannot delete asArgName because it might be referenced elsewhere
@@ -74,5 +77,5 @@
 
 	ExpressionNode *get_argName() const { return argName; }
-	ExpressionNode *set_asArgName( const std::string *aName );
+	ExpressionNode *set_asArgName( std::string *aName );
 	ExpressionNode *set_asArgName( ExpressionNode *aDesignator );
 
@@ -102,21 +105,30 @@
 class ConstantNode : public ExpressionNode {
   public:
-	enum Type { Integer, Float, Character, String };
-
+	enum Type {
+		Integer, Float, Character, String /* , Range, EnumConstant  */
+	};
+
+	ConstantNode( void );
+	ConstantNode( std::string * );
 	ConstantNode( Type, std::string * );
+	ConstantNode( const ConstantNode &other );
 
 	virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
-	Type get_type( void ) const { return type; }
+
+	Type get_type( void ) const ;
 	virtual void print( std::ostream &, int indent = 0) const;
 	virtual void printOneLine( std::ostream &, int indent = 0) const;
 
-	const std::string &get_value() const { return value; }
-	ConstantNode *appendstr( const std::string *newValue );
+	std::string get_value() const { return value; }
+	ConstantNode *append( std::string *newValue );
 
 	Expression *build() const;
   private:
+	void classify( std::string &);
 	Type type;
-	BasicType::Kind btype;
-	std::string &value;
+	std::string value;
+	bool sign;
+	short base;
+	int longs, size;
 };
 
@@ -124,5 +136,5 @@
   public:
 	VarRefNode();
-	VarRefNode( const std::string *, bool isLabel = false );
+	VarRefNode( std::string *, bool isLabel = false );
 	VarRefNode( const VarRefNode &other );
 
@@ -131,6 +143,6 @@
 	virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
 
-	virtual void print( std::ostream &, int indent = 0 ) const;
-	virtual void printOneLine( std::ostream &, int indent = 0 ) const;
+	virtual void print( std::ostream &, int indent = 0) const;
+	virtual void printOneLine( std::ostream &, int indent = 0) const;
   private:
 	bool isLabel;
@@ -171,6 +183,6 @@
 	virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
 
-	Type get_type() const;
-	const char *get_typename() const;
+	Type get_type( void ) const;
+	std::string get_typename( void ) const;
 
 	virtual void print( std::ostream &, int indent = 0) const;
@@ -186,6 +198,6 @@
 class CompositeExprNode : public ExpressionNode {
   public:
-	CompositeExprNode();
-	CompositeExprNode( const std::string * );
+	CompositeExprNode( void );
+	CompositeExprNode( std::string * );
 	CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 );
 	CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 );
@@ -266,15 +278,14 @@
   public:
 	enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Attribute };
-	enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
+	enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran };
 	enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
-	enum Modifier  { Signed, Unsigned, Short, Long };
-	enum Aggregate { Struct, Union, Context };
+	enum Modifier { Signed, Unsigned, Short, Long };
+	enum TyCon { Struct, Union, Context };
 	enum TypeClass { Type, Dtype, Ftype };
 
-	static const char *storageName[];  
 	static const char *qualifierName[];
 	static const char *basicTypeName[];
 	static const char *modifierName[];
-	static const char *aggregateName[];
+	static const char *tyConName[];
 	static const char *typeClassName[];
 
@@ -287,9 +298,9 @@
 	static DeclarationNode *newForall( DeclarationNode *);
 	static DeclarationNode *newFromTypedef( std::string *);
-	static DeclarationNode *newAggregate( Aggregate kind, std::string *name, ExpressionNode *actuals, DeclarationNode *fields );
+	static DeclarationNode *newAggregate( TyCon kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields );
 	static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
 	static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
 	static DeclarationNode *newName( std::string *);
-	static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
+	static DeclarationNode *newFromTypeGen( std::string*, ExpressionNode *params );
 	static DeclarationNode *newTypeParam( TypeClass, std::string *);
 	static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
@@ -302,6 +313,6 @@
 	static DeclarationNode *newTuple( DeclarationNode *members );
 	static DeclarationNode *newTypeof( ExpressionNode *expr );
-	static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
-	static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
+	static DeclarationNode *newAttr( std::string*, ExpressionNode *expr );
+	static DeclarationNode *newAttr( std::string*, DeclarationNode *type );
 
 	DeclarationNode *addQualifiers( DeclarationNode *);
@@ -329,5 +340,5 @@
 	DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
 
-	DeclarationNode *appendList( DeclarationNode * );
+	DeclarationNode *appendList( DeclarationNode  *);
 
 	DeclarationNode *clone() const;
@@ -339,5 +350,5 @@
 
 	bool get_hasEllipsis() const;
-	const std::string &get_name() const { return name; }
+	std::string get_name() const { return name; }
 	LinkageSpec::Type get_linkage() const { return linkage; }
 	DeclarationNode *extractAggregate() const;
@@ -346,6 +357,6 @@
 	~DeclarationNode();
   private:
-	StorageClass buildStorageClass() const;
-	bool buildFuncSpecifier( StorageClass key ) const;
+	Declaration::StorageClass buildStorageClass() const;
+	bool buildInline() const;
 
 	TypeData *type;
@@ -369,6 +380,6 @@
 	};
 
-	StatementNode();
-	StatementNode( const std::string * );
+	StatementNode( void );
+	StatementNode( std::string );
 	StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 );
 	StatementNode( Type, std::string *target );
@@ -376,7 +387,7 @@
 
 
-	~StatementNode();
-
-	static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
+	~StatementNode( void );
+
+	static StatementNode  *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
 
 	void set_control( ExpressionNode * );
@@ -385,7 +396,7 @@
 	ExpressionNode *get_control() const ;
 	StatementNode *get_block() const;
-	StatementNode::Type get_type() const;
-
-	StatementNode *add_label( const std::string * );
+	StatementNode::Type get_type( void ) const;
+
+	StatementNode *add_label( std::string * );
 	std::list<std::string> *get_labels() const;
 
@@ -418,6 +429,6 @@
 class CompoundStmtNode : public StatementNode {
   public:
-	CompoundStmtNode();
-	CompoundStmtNode( const std::string * );
+	CompoundStmtNode( void );
+	CompoundStmtNode( std::string * );
 	CompoundStmtNode( StatementNode * );
 	~CompoundStmtNode();
@@ -488,7 +499,7 @@
 
 // in DeclarationNode.cc
-void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
+void buildList( const DeclarationNode *firstNode, std::list< Declaration *> &outputList );
 void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
+void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList );
 
 // in ExpressionNode.cc
Index: src/Parser/Parser.cc
===================================================================
--- src/Parser/Parser.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/Parser.cc	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 14:54:28 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 31 23:45:19 2015
-// Update Count     : 4
+// Last Modified On : Sat May 16 14:55:59 2015
+// Update Count     : 2
 // 
 
@@ -17,5 +17,5 @@
 #include "TypedefTable.h"
 #include "lex.h"
-#include "parser.h"
+#include "cfa.tab.h"
 
 // global variables in cfa.y
Index: src/Parser/StatementNode.cc
===================================================================
--- src/Parser/StatementNode.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/StatementNode.cc	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun  6 23:25:41 2015
-// Update Count     : 19
+// Last Modified On : Sat May 16 15:10:45 2015
+// Update Count     : 7
 //
 
@@ -36,5 +36,5 @@
 StatementNode::StatementNode() : ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
 
-StatementNode::StatementNode( const string *name_ ) : ParseNode( name_ ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
+StatementNode::StatementNode( string name_) : ParseNode( name_), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
 
 StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), isCatchRest ( false ) {
@@ -49,13 +49,13 @@
 				next->set_next( new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ) );
 				decl->set_next( 0 );
-			} // if
+			}
 		} else {
 			if ( decl->get_link() ) {
 				next = new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) );
 				decl->set_next( 0 );
-			} // if
+			}
 			this->decl = decl;
-		} // if
-	} // if
+		}
+	}
 }
 
@@ -67,5 +67,5 @@
 
 StatementNode::StatementNode( Type t, string *_target ) :
-		type( t ), control( 0 ), block( 0 ), labels( 0 ), target(_target ), decl( 0 ), isCatchRest ( false ) {}
+		type( t ), control( 0 ), block( 0 ),   labels( 0 ), target(_target ), decl( 0 ), isCatchRest ( false ) {}
 
 StatementNode::~StatementNode() {
@@ -98,5 +98,5 @@
 	} else {
 		newnode->target = 0;
-	} // if
+	}
 	newnode->decl = maybeClone( decl );
 	return newnode;
@@ -125,5 +125,5 @@
 }
 
-StatementNode *StatementNode::add_label( const std::string *l ) {
+StatementNode *StatementNode::add_label( std::string *l ) {
 	if ( l != 0 ) {
 		if ( labels == 0 )
@@ -132,5 +132,5 @@
 		labels->push_front(*l ); 
 		delete l;
-	} // if
+	}
 	return this;
 }
@@ -151,5 +151,5 @@
 		else
 			block->set_link( stmt );
-	} // if
+	}
 	return this;
 }
@@ -165,19 +165,18 @@
 			else
 				block->set_link( stmt );
-	} // if
+	}
 	return this;
 }
 
 void StatementNode::print( std::ostream &os, int indent ) const {
-	if ( labels != 0 ) {
+	if ( labels != 0 )
 		if ( ! labels->empty()) {
 			std::list<std::string>::const_iterator i;
 
-			os << string( indent, ' ' );
+			os << '\r' << string( indent, ' ');
 			for ( i = labels->begin(); i != labels->end(); i++ )
 				os << *i << ":";
 			os << endl;
-		} // if
-	} // if
+		}
 
 	switch ( type ) {
@@ -194,28 +193,28 @@
 		break;
 	  default:
-		os << string( indent, ' ' ) << StatementNode::StType[type] << endl;
+		os << '\r' << string( indent, ' ') << StatementNode::StType[type] << endl;
 		if ( type == Catch ) {
 			if ( decl ) {
-				os << string( indent + ParseNode::indent_by, ' ' ) << "Declaration: " << endl;
+				os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Declaration: " << endl;
 				decl->print( os, indent + 2*ParseNode::indent_by );
 			} else if ( isCatchRest ) {
-				os << string( indent + ParseNode::indent_by, ' ' ) << "Catches the rest " << endl;
+				os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Catches the rest " << endl;
 			} else {
 				; // should never reach here
-			} // if
-		} // if
+			}
+		}
 		if ( control ) {
-			os << string( indent + ParseNode::indent_by, ' ' ) << "Expression: " << endl;
+			os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Expression: " << endl;
 			control->printList( os, indent + 2*ParseNode::indent_by );
-		} // if
+		}
 		if ( block ) {
-			os << string( indent + ParseNode::indent_by, ' ' ) << "Branches of execution: " << endl;
+			os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Branches of execution: " << endl;
 			block->printList( os, indent + 2*ParseNode::indent_by );  
-		} // if
+		}
 		if ( target ) {
-			os << string( indent + ParseNode::indent_by, ' ' ) << "Target: " << get_target() << endl;
-		} // if
+			os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Target: " << get_target() << endl;
+		}
 		break;
-	} // switch
+	}
 }
 
@@ -228,5 +227,5 @@
 		std::back_insert_iterator< std::list<Label> > lab_it( labs );
 		copy( labels->begin(), labels->end(), lab_it );
-	} // if
+	}
 
 	// try {
@@ -255,5 +254,5 @@
 				elseb = branches.front();
 				branches.pop_front();
-			} // if
+			}
 			return new IfStmt( labs, notZeroExpr( get_control()->build() ), thenb, elseb );
 		}
@@ -300,5 +299,5 @@
 				assert( get_control() != 0 );
 				return new BranchStmt( labs, get_control()->build(), BranchStmt::Goto );
-			} // if
+			}
 
 			return new BranchStmt( labs, get_target(), BranchStmt::Goto );
@@ -323,5 +322,5 @@
 			if ( ( finallyBlock = dynamic_cast<FinallyStmt *>( branches.back())) ) {
 				branches.pop_back();
-			} // if
+			}
 			return new TryStmt( labs, tryBlock, branches, finallyBlock );
 		}
@@ -343,17 +342,19 @@
 		// shouldn't be here
 		return 0;
-	} // switch
-}
-
-CompoundStmtNode::CompoundStmtNode() : first( 0 ), last( 0 ) {}
-
-CompoundStmtNode::CompoundStmtNode( const string *name_ ) : StatementNode( name_ ), first( 0 ), last( 0 ) {}
-
-CompoundStmtNode::CompoundStmtNode( StatementNode *stmt ) : first( stmt ) {
+	}
+}
+
+CompoundStmtNode::CompoundStmtNode() : first( 0 ), last( 0 ) {
+}
+
+CompoundStmtNode::CompoundStmtNode( string *name_) : StatementNode(*name_), first( 0 ), last( 0 ) {
+}
+
+CompoundStmtNode::CompoundStmtNode( StatementNode *stmt ): first( stmt ) {
 	if ( first ) {
 		last = ( StatementNode *)( stmt->get_last());
 	} else {
 		last = 0;
-	} // if
+	}
 }
 
@@ -366,5 +367,5 @@
 		last->set_link( stmt );
 		last = ( StatementNode *)( stmt->get_link());
-	} // if
+	}
 }
 
@@ -372,5 +373,5 @@
 	if ( first ) {
 		first->printList( os, indent+2 );
-	} // if
+	}
 }
 
@@ -382,5 +383,5 @@
 		std::back_insert_iterator< std::list<Label> > lab_it( labs );
 		copy( labels->begin(), labels->end(), lab_it );
-	} // if
+	}
 
 	CompoundStmt *cs = new CompoundStmt( labs );
@@ -390,5 +391,5 @@
 
 void NullStmtNode::print( ostream &os, int indent ) const {
-	os << string( indent, ' ' ) << "Null Statement:" << endl;
+	os << "\r" << string( indent, ' ') << "Null Statement:" << endl;
 }
 
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/TypeData.cc	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun 26 07:30:06 2015
-// Update Count     : 26
+// Last Modified On : Sat May 16 15:17:56 2015
+// Update Count     : 4
 //
 
@@ -53,5 +53,5 @@
 		aggregate->params = 0;
 		aggregate->actuals = 0;
-		aggregate->fields = 0;
+		aggregate->members = 0;
 		break;
 	  case AggregateInst:
@@ -89,5 +89,5 @@
 		attr->type = 0;
 		break;
-	} // switch
+	}
 }
 
@@ -119,5 +119,5 @@
 		delete aggregate->params;
 		delete aggregate->actuals;
-		delete aggregate->fields;
+		delete aggregate->members;
 		delete aggregate;
 		break;
@@ -155,5 +155,5 @@
 		delete attr;
 		break;
-	} // switch
+	}
 }
 
@@ -190,5 +190,5 @@
 		newtype->aggregate->params = maybeClone( aggregate->params );
 		newtype->aggregate->actuals = maybeClone( aggregate->actuals );
-		newtype->aggregate->fields = maybeClone( aggregate->fields );
+		newtype->aggregate->members = maybeClone( aggregate->members );
 		newtype->aggregate->name = aggregate->name;
 		newtype->aggregate->kind = aggregate->kind;
@@ -225,5 +225,5 @@
 		newtype->attr->type = maybeClone( attr->type );
 		break;
-	} // switch
+	}
 	return newtype;
 }
@@ -237,6 +237,6 @@
 	if ( forall ) {
 		os << "forall " << endl;
-		forall->printList( os, indent + 4 );
-	} // if
+		forall->printList( os, indent+4 );
+	}
 
 	switch ( kind ) {
@@ -249,5 +249,5 @@
 			os << "to ";
 			base->print( os, indent );
-		} // if
+		}
 		break;
 	  case EnumConstant:
@@ -261,5 +261,5 @@
 		if ( array->isStatic ) {
 			os << "static ";
-		} // if
+		}
 		if ( array->dimension ) {
 			os << "array of ";
@@ -269,55 +269,55 @@
 		} else {
 			os << "open array of ";
-		} // if
+		}
 		if ( base ) {
 			base->print( os, indent );
-		} // if
+		}
 		break;
 	  case Function:
 		os << "function" << endl;
 		if ( function->params ) {
-			os << string( indent + 2, ' ' ) << "with parameters " << endl;
-			function->params->printList( os, indent + 4 );
+			os << string( indent+2, ' ' ) << "with parameters " << endl;
+			function->params->printList( os, indent+4 );
 		} else {
-			os << string( indent + 2, ' ' ) << "with no parameters " << endl;
-		} // if
+			os << string( indent+2, ' ' ) << "with no parameters " << endl;
+		}
 		if ( function->idList ) {
-			os << string( indent + 2, ' ' ) << "with old-style identifier list " << endl;
-			function->idList->printList( os, indent + 4 );
-		} // if
+			os << string( indent+2, ' ' ) << "with old-style identifier list " << endl;
+			function->idList->printList( os, indent+4 );
+		}
 		if ( function->oldDeclList ) {
-			os << string( indent + 2, ' ' ) << "with old-style declaration list " << endl;
-			function->oldDeclList->printList( os, indent + 4 );
-		} // if
-		os << string( indent + 2, ' ' ) << "returning ";
+			os << string( indent+2, ' ' ) << "with old-style declaration list " << endl;
+			function->oldDeclList->printList( os, indent+4 );
+		}
+		os << string( indent+2, ' ' ) << "returning ";
 		if ( base ) {
-			base->print( os, indent + 4 );
+			base->print( os, indent+4 );
 		} else {
 			os << "nothing ";
-		} // if
+		}
 		os << endl;
 		if ( function->hasBody ) {
-			os << string( indent + 2, ' ' ) << "with body " << endl;
-		} // if
+			os << string( indent+2, ' ' ) << "with body " << endl;
+		}
 		if ( function->body ) {
-			function->body->printList( os, indent + 2 );
-		} // if
+			function->body->printList( os, indent+2 );
+		}
 		break;
 	  case Aggregate:
-		os << DeclarationNode::aggregateName[ aggregate->kind ] << ' ' << aggregate->name << endl;
+		os << DeclarationNode::tyConName[ aggregate->kind ] << ' ' << aggregate->name << endl;
 		if ( aggregate->params ) {
-			os << string( indent + 2, ' ' ) << "with type parameters " << endl;
-			aggregate->params->printList( os, indent + 4 );
-		} // if
+			os << string( indent+2, ' ' ) << "with type parameters " << endl;
+			aggregate->params->printList( os, indent+4 );
+		}
 		if ( aggregate->actuals ) {
-			os << string( indent + 2, ' ' ) << "instantiated with actual parameters " << endl;
-			aggregate->actuals->printList( os, indent + 4 );
-		} // if
-		if ( aggregate->fields ) {
-			os << string( indent + 2, ' ' ) << "with members " << endl;
-			aggregate->fields->printList( os, indent + 4 );
+			os << string( indent+2, ' ' ) << "instantiated with actual parameters " << endl;
+			aggregate->actuals->printList( os, indent+4 );
+		}
+		if ( aggregate->members ) {
+			os << string( indent+2, ' ' ) << "with members " << endl;
+			aggregate->members->printList( os, indent+4 );
 ///     } else {
-///       os << string( indent + 2, ' ' ) << "with no members " << endl;
-		} // if
+///       os << string( indent+2, ' ' ) << "with no members " << endl;
+		}
 		break;
 	  case AggregateInst:
@@ -327,9 +327,9 @@
 		} else {
 			os << "instance of an unspecified aggregate ";
-		} // if
+		}
 		if ( aggInst->params ) {
-			os << string( indent + 2, ' ' ) << "with parameters " << endl;
-			aggInst->params->printList( os, indent + 2 );
-		} // if
+			os << string( indent+2, ' ' ) << "with parameters " << endl;
+			aggInst->params->printList( os, indent+2 );
+		}
 		break;
 	  case Enum:
@@ -337,6 +337,6 @@
 		if ( enumeration->constants ) {
 			os << "with constants" << endl;
-			enumeration->constants->printList( os, indent + 2 );
-		} // if
+			enumeration->constants->printList( os, indent+2 );
+		}
 		break;
 	  case SymbolicInst:
@@ -345,5 +345,5 @@
 			os << " with parameters" << endl;
 			symbolic->actuals->printList( os, indent + 2 );
-		} // if
+		}
 		break;
 	  case Symbolic:
@@ -352,26 +352,26 @@
 		} else {
 			os << "type definition ";
-		} // if
+		}
 		if ( symbolic->params ) {
-			os << endl << string( indent + 2, ' ' ) << "with parameters" << endl;
+			os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
 			symbolic->params->printList( os, indent + 2 );
-		} // if
+		}
 		if ( symbolic->assertions ) {
-			os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
+			os << endl << string( indent+2, ' ' ) << "with assertions" << endl;
 			symbolic->assertions->printList( os, indent + 4 );
-			os << string( indent + 2, ' ' );
-		} // if
+			os << string( indent+2, ' ' );
+		}
 		if ( base ) {
 			os << "for ";
 			base->print( os, indent + 2 );
-		} // if
+		}
 		break;
 	  case Variable:
 		os << DeclarationNode::typeClassName[ variable->tyClass ] << " variable ";
 		if ( variable->assertions ) {
-			os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
+			os << endl << string( indent+2, ' ' ) << "with assertions" << endl;
 			variable->assertions->printList( os, indent + 4 );
-			os << string( indent + 2, ' ' );
-		} // if
+			os << string( indent+2, ' ' );
+		}
 		break;
 	  case Tuple:
@@ -380,5 +380,5 @@
 			os << "with members " << endl;
 			tuple->members->printList( os, indent + 2 );
-		} // if
+		}
 		break;
 	  case Typeof:
@@ -386,5 +386,5 @@
 		if ( typeexpr->expr ) {
 			typeexpr->expr->print( os, indent + 2 );
-		} // if
+		}
 		break;
 	  case Attr:
@@ -392,10 +392,10 @@
 		if ( attr->expr ) {
 			attr->expr->print( os, indent + 2 );
-		} // if
+		}
 		if ( attr->type ) {
 			attr->type->print( os, indent + 2 );
-		} // if
-		break;
-	} // switch
+		}
+		break;
+	}
 }
 
@@ -405,8 +405,8 @@
 	switch ( kind ) {
 	  case Aggregate:
-		if ( ! toplevel && aggregate->fields ) {
+		if ( ! toplevel && aggregate->members ) {
 			ret = clone();
 			ret->qualifiers.clear();
-		} // if
+		}
 		break;
 	  case Enum:
@@ -414,16 +414,16 @@
 			ret = clone();
 			ret->qualifiers.clear();
-		} // if
+		}
 		break;
 	  case AggregateInst:
 		if ( aggInst->aggregate ) {
 			ret = aggInst->aggregate->extractAggregate( false );
-		} // if
+		}
 		break;
 	  default:
 		if ( base ) {
 			ret = base->extractAggregate( false );
-		} // if
-	} // switch
+		}
+	}
 	return ret;
 }
@@ -434,13 +434,13 @@
 		if ( (*i)->get_kind() == TypeDecl::Any ) {
 			FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
-			assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
-			assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
-			assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
-			(*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) );
-		} // if
-	} // for
-}
-
-Declaration *TypeData::buildDecl( std::string name, DeclarationNode::StorageClass sc, Expression *bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Type linkage, Initializer *init ) const {
+			assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
+			assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
+			assignType->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
+			(*i)->get_assertions().push_front( new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false ) );
+		}
+	}
+}
+
+Declaration *TypeData::buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init ) const {
 	if ( kind == TypeData::Function ) {
 		FunctionDecl *decl;
@@ -450,17 +450,17 @@
 				CompoundStmt *body = dynamic_cast< CompoundStmt* >( stmt );
 				assert( body );
-				decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline, isNoreturn );
+				decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline );
 			} else {
 				// std::list<Label> ls;
-				decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline, isNoreturn );
-			} // if
+				decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline );
+			}
 		} else {
-			decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline, isNoreturn );
-		} // if
+			decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline );
+		}
 		for ( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_link() ) ) {
 			if ( cur->get_name() != "" ) {
 				decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
-			} // if
-		} // for
+			}
+		}
 		buildList( function->oldDeclList, decl->get_oldDecls() );
 		return decl;
@@ -474,10 +474,10 @@
 		return buildVariable();
 	} else {
-		if ( isInline || isNoreturn ) {
-			throw SemanticError( "invalid inline or _Noreturn specification in declaration of ", this );
+		if ( isInline ) {
+			throw SemanticError( "invalid inline specification in declaration of ", this );
 		} else {
 			return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init );
-		} // if
-	} // if
+		}
+	}
 	return 0;
 }
@@ -514,5 +514,6 @@
 	  case Variable:
 		assert( false );
-	} // switch
+	}
+
 	return 0;
 }
@@ -540,6 +541,6 @@
 			q.isAttribute = true;
 			break;
-		} // switch
-	} // for
+		}
+	}
 	return q;
 }
@@ -562,8 +563,8 @@
 				} else {
 					return new VoidType( buildQualifiers() );
-				} // if
+				}
 			} else {
 				ret = kindMap[ *i ];
-			} // if
+			}
 		} else {
 			switch ( *i ) {
@@ -581,6 +582,6 @@
 					  default:
 						throw SemanticError( "invalid type specifier \"float\" in type: ", this );
-					} // switch
-				} // if
+					}
+				}
 				break;
 			  case DeclarationNode::Double:
@@ -594,7 +595,8 @@
 					  default:
 						throw SemanticError( "invalid type specifier \"double\" in type: ", this );
-					} // switch
-				} // if
+					}
+				}
 				break;
+	
 			  case DeclarationNode::Complex:
 				switch ( ret ) {
@@ -607,5 +609,5 @@
 				  default:
 					throw SemanticError( "invalid type specifier \"_Complex\" in type: ", this );
-				} // switch
+				}
 				break;
 			  case DeclarationNode::Imaginary:
@@ -619,14 +621,14 @@
 				  default:
 					throw SemanticError( "invalid type specifier \"_Imaginary\" in type: ", this );
-				} // switch
+				}
 				break;
 			  default:
 				throw SemanticError( std::string( "invalid type specifier \"" ) + DeclarationNode::basicTypeName[ *i ] + "\" in type: ", this );
-			} // switch
-		} // if
+			}
+		}
 		if ( *i == DeclarationNode::Double ) {
 			sawDouble = true;
-		} // if
-	} // for
+		}
+	}
 
 	for ( std::list< DeclarationNode::Modifier >::const_iterator i = basic->modifiers.begin(); i != basic->modifiers.end(); ++i ) {
@@ -661,6 +663,6 @@
 				  default:
 					throw SemanticError( "invalid type modifier \"long\" in type: ", this );
-				} // switch
-			} // if
+				}
+			}
 			break;
 		  case DeclarationNode::Short:
@@ -678,6 +680,6 @@
 				  default:
 					throw SemanticError( "invalid type modifier \"short\" in type: ", this );
-				} // switch
-			} // if
+				}
+			}
 			break;
 		  case DeclarationNode::Signed:
@@ -689,5 +691,5 @@
 			} else {
 				switch ( ret ) {
-				  case BasicType::LongLongSignedInt:
+				  case BasicType::LongLongSignedInt:	// PAB
 					ret = BasicType::LongLongUnsignedInt;
 					break;
@@ -703,6 +705,6 @@
 				  default:
 					throw SemanticError( "invalid type modifer \"signed\" in type: ", this );
-				} // switch
-			} // if
+				}
+			}
 			break;
 		  case DeclarationNode::Unsigned:
@@ -714,5 +716,5 @@
 			} else {
 				switch ( ret ) {
-				  case BasicType::LongLongSignedInt:
+				  case BasicType::LongLongSignedInt:	// PAB
 					ret = BasicType::LongLongUnsignedInt;
 					break;
@@ -731,13 +733,13 @@
 				  default:
 					throw SemanticError( "invalid type modifer \"unsigned\" in type: ", this );
-				} // switch
-			} // if
-			break;
-		} // switch
+				}
+			}
+			break;
+		}
 
 		if ( *i == DeclarationNode::Signed ) {
 			sawSigned = true;
-		} // if
-	} // for
+		}
+	}
 
 	BasicType *bt;
@@ -746,5 +748,5 @@
 	} else {
 		bt = new BasicType( buildQualifiers(), ret );
-	} // if
+	}
 	buildForall( forall, bt->get_forall() );
 	return bt;
@@ -758,5 +760,5 @@
 	} else {
 		pt = new PointerType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
-	} // if
+	}
 	buildForall( forall, pt->get_forall() );
 	return pt;
@@ -771,5 +773,5 @@
 		at = new ArrayType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
 							maybeBuild< Expression >( array->dimension ), array->isVarLen, array->isStatic );
-	} // if
+	}
 	buildForall( forall, at->get_forall() );
 	return at;
@@ -789,9 +791,9 @@
 			break;
 		  default:
-			ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", DeclarationNode::NoStorageClass, 0, false, false, LinkageSpec::Cforall ) ) );
-		} // switch
+			ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", Declaration::NoStorageClass, 0, false, LinkageSpec::Cforall ) ) );
+		}
 	} else {
-		ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
-	} // if
+		ft->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
+	}
 	return ft;
 }
@@ -804,15 +806,18 @@
 		at = new StructDecl( aggregate->name );
 		break;
+	
 	  case DeclarationNode::Union:
 		at = new UnionDecl( aggregate->name );
 		break;
+	
 	  case DeclarationNode::Context:
 		at = new ContextDecl( aggregate->name );
 		break;
+	
 	  default:
 		assert( false );
-	} // switch
+	}
 	buildList( aggregate->params, at->get_parameters() );
-	buildList( aggregate->fields, at->get_members() );
+	buildList( aggregate->members, at->get_members() );
 
 	return at;
@@ -833,4 +838,5 @@
 ReferenceToType *TypeData::buildAggInst() const {
 	assert( kind == AggregateInst );
+	std::string name;
 
 	ReferenceToType *ret;
@@ -851,6 +857,6 @@
 		  default:
 			assert( false );
-		} // switch
-	} // if
+		}
+	}
 	buildList( aggInst->params, ret->get_parameters() );
 	buildForall( forall, ret->get_forall() );
@@ -858,5 +864,5 @@
 }
 
-NamedTypeDecl *TypeData::buildSymbolic( const std::string &name, DeclarationNode::StorageClass sc ) const {
+NamedTypeDecl *TypeData::buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const {
 	assert( kind == Symbolic );
 	NamedTypeDecl *ret;
@@ -865,5 +871,5 @@
 	} else {
 		ret = new TypeDecl( name, sc, maybeBuild< Type >( base ), TypeDecl::Any );
-	} // if
+	}
 	buildList( symbolic->params, ret->get_parameters() );
 	buildList( symbolic->assertions, ret->get_assertions() );
@@ -875,6 +881,7 @@
 	static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
 
-	TypeDecl *ret = new TypeDecl( variable->name, DeclarationNode::NoStorageClass, 0, kindMap[ variable->tyClass ] );
+	TypeDecl *ret = new TypeDecl( variable->name, Declaration::NoStorageClass, 0, kindMap[ variable->tyClass ] );
 	buildList( variable->assertions, ret->get_assertions() );
+	
 	return ret;
 }
@@ -884,4 +891,5 @@
 	EnumDecl *ret = new EnumDecl( enumeration->name );
 	buildList( enumeration->constants, ret->get_members() );
+
 	return ret;
 }
@@ -892,4 +900,5 @@
 	buildList( symbolic->actuals, ret->get_parameters() );
 	buildForall( forall, ret->get_forall() );
+
 	return ret;
 }
@@ -900,4 +909,5 @@
 	buildTypeList( tuple->members, ret->get_types() );
 	buildForall( forall, ret->get_forall() );
+
 	return ret;
 }
@@ -908,4 +918,5 @@
 	assert( typeexpr->expr );
 	TypeofType *ret = new TypeofType( buildQualifiers(), typeexpr->expr->build() );
+
 	return ret;
 }
@@ -920,5 +931,6 @@
 		assert( attr->type );
 		ret = new AttrType( buildQualifiers(), attr->name, attr->type->buildType() );
-	} // if
+	}
+
 	return ret;
 }
Index: src/Parser/TypeData.h
===================================================================
--- src/Parser/TypeData.h	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/TypeData.h	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun 26 23:39:03 2015
-// Update Count     : 16
+// Last Modified On : Sat May 16 15:20:00 2015
+// Update Count     : 2
 //
 
@@ -44,9 +44,9 @@
 
 	struct Aggregate_t {
-		DeclarationNode::Aggregate kind;
+		DeclarationNode::TyCon kind;
 		std::string name;
 		DeclarationNode *params;
-		ExpressionNode  *actuals;						// holds actual parameters later applied to AggInst
-		DeclarationNode *fields;
+		ExpressionNode *actuals;						// holds actual parameters later applied to AggInst
+		DeclarationNode *members;
 	};
 
@@ -78,5 +78,5 @@
 	struct Symbolic_t {
 		std::string name;
-		bool isTypedef;									// false => TYPEGENname, true => TYPEDEFname
+		bool isTypedef;
 		DeclarationNode *params;
 		ExpressionNode *actuals;
@@ -120,13 +120,13 @@
 	TypeData *extractAggregate( bool toplevel = true ) const;
 	// helper function for DeclNodeImpl::build
-	Declaration * buildDecl( std::string name, DeclarationNode::StorageClass sc, Expression *bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Type linkage, Initializer *init = 0 ) const;
+	Declaration * buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init = 0 ) const;
 	// helper functions for build()
 	Type::Qualifiers buildQualifiers() const;
-	Type * buildBasicType() const;
+	Type *buildBasicType() const;
 	PointerType * buildPointer() const;
 	ArrayType * buildArray() const;
 	AggregateDecl * buildAggregate() const;
 	ReferenceToType * buildAggInst() const;
-	NamedTypeDecl * buildSymbolic( const std::string &name, DeclarationNode::StorageClass sc ) const;
+	NamedTypeDecl * buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const;
 	TypeDecl* buildVariable() const;
 	EnumDecl* buildEnum() const;
Index: src/Parser/TypedefTable.cc
===================================================================
--- src/Parser/TypedefTable.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/TypedefTable.cc	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun 26 07:30:16 2015
-// Update Count     : 19
+// Last Modified On : Sat May 16 15:24:03 2015
+// Update Count     : 2
 //
 
@@ -22,5 +22,5 @@
 #if 0
 #include <iostream>
-#define debugPrint( x ) cerr << x
+#define debugPrint(x ) cerr << x
 #else
 #define debugPrint( x )
@@ -29,32 +29,22 @@
 TypedefTable::TypedefTable() : currentScope( 0 ) {}
 
-void TypedefTable::changeKind( const string &identifier, kind_t kind ) {
-	tableType::iterator id_pos = table.find( identifier );
-	if ( id_pos == table.end() ) {
-		return;
-	} else {
-		(*((*id_pos ).second.begin())).kind = kind;
-		return;
-	} // if
-}
-
-bool TypedefTable::isKind( const string &identifier, kind_t kind ) const {
+bool TypedefTable::isKind( string identifier, kind_t kind ) const {
 	tableType::const_iterator id_pos = table.find( identifier );
-	if ( id_pos == table.end() ) {
+	if ( id_pos == table.end()) {
 		return true;
 	} else {
 		return (*((*id_pos ).second.begin())).kind == kind;
-	} // if
+	}
 }
 
-bool TypedefTable::isIdentifier( const string &identifier ) const {
+bool TypedefTable::isIdentifier( string identifier ) const {
 	return isKind( identifier, ID );
 }
 
-bool TypedefTable::isTypedef( const string &identifier ) const {
+bool TypedefTable::isTypedef( string identifier ) const {
 	return isKind( identifier, TD );
 }
 
-bool TypedefTable::isTypegen( const string &identifier ) const {
+bool TypedefTable::isTypegen( string identifier ) const {
 	return isKind( identifier, TG );
 }
@@ -65,5 +55,5 @@
 		contexts[currentContext].push_back( entry );
 	} else {
-		debugPrint( "Adding " << identifier << " as kind " << kind << " scope " << scope << " from scope " << currentScope << endl );
+		debugPrint( "Adding " << identifier << " as type " << kind << " scope " << scope << " from scope " << currentScope << endl );
 		Entry newEntry = { scope, kind };
 		tableType::iterator curPos = table.find( identifier );
@@ -76,8 +66,8 @@
 			while ( listPos != (*curPos ).second.end() && listPos->scope > scope ) {
 				listPos++;
-			} // while
+			}
 			(*curPos ).second.insert( listPos, newEntry );
-		} // if
-	} // if
+		}
+	}
 }
 
@@ -112,5 +102,5 @@
 }
 
-void TypedefTable::openContext( const std::string &contextName ) {
+void TypedefTable::openContext( std::string contextName ) {
 	map< string, deferListType >::iterator i = contexts.find( contextName );
 	if ( i != contexts.end() ) {
@@ -118,9 +108,9 @@
 		for ( deferListType::iterator i = entries.begin(); i != entries.end(); i++) {
 			addToEnclosingScope( i->identifier, i->kind );
-		} // for
-	} // if
+		}
+	}
 }
 
-void TypedefTable::enterScope() {
+void TypedefTable::enterScope( void ) {
 	currentScope += 1;
 	deferListStack.push( deferListType() );
@@ -129,20 +119,19 @@
 }
 
-void TypedefTable::leaveScope() {
+void TypedefTable::leaveScope( void ) {
 	debugPrint( "Leaving scope " << currentScope << endl );
 	for ( tableType::iterator i = table.begin(); i != table.end(); ) {
-		list<Entry> &declList = (*i).second;
+		list<Entry> &declList = (*i ).second;
 		while ( ! declList.empty() && declList.front().scope == currentScope ) {
 			declList.pop_front();
 		}
-		if ( declList.empty() ) {						// standard idom for erasing during traversal
+		if ( declList.empty() ) {			// standard idom for erasing during traversal
 			table.erase( i++ );
-		} else
-			++i;
-	} // for
+		} else ++i;
+	}
 	currentScope -= 1;
-	for ( deferListType::iterator i = deferListStack.top().begin(); i != deferListStack.top().end(); i++ ) {
+	for ( deferListType::iterator i = deferListStack.top().begin(); i != deferListStack.top().end(); i++) {
 		addToCurrentScope( i->identifier, i->kind );
-	} // for
+	}
 	deferListStack.pop();
 	debugPrint( "nextIdentifiers size is " << nextIdentifiers.size() << " top is " << nextIdentifiers.top() << endl );
@@ -150,10 +139,10 @@
 }
 
-void TypedefTable::enterContext( const std::string &contextName ) {
+void TypedefTable::enterContext( std::string contextName ) {
 	currentContext = contextName;
 	contextScope = currentScope;
 }
 
-void TypedefTable::leaveContext() {
+void TypedefTable::leaveContext( void ) {
 	currentContext = "";
 }
@@ -162,10 +151,10 @@
 	for ( tableType::const_iterator i = table.begin(); i != table.end(); i++) {
 		debugPrint( (*i ).first << ": " );
-		list<Entry> declList = (*i).second;
+		list<Entry> declList = (*i ).second;
 		for ( list<Entry>::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
-			debugPrint( "(" << (*j).scope << " " << (*j).kind << ") " );
+			debugPrint( "(" << (*j ).scope << " " << (*j).kind << ") " );
 		}
 		debugPrint( endl );
-	} // for
+	}
 }
 
Index: src/Parser/TypedefTable.h
===================================================================
--- src/Parser/TypedefTable.h	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/TypedefTable.h	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 25 22:52:15 2015
-// Update Count     : 11
+// Last Modified On : Sat May 16 15:25:59 2015
+// Update Count     : 3
 //
 
@@ -49,19 +49,17 @@
 	std::stack< std::string > nextIdentifiers;
 
-	bool isKind( const std::string &identifier, kind_t kind ) const;
+	bool isKind( std::string identifier, kind_t kind ) const;
 	void addToScope( const std::string &identifier, kind_t kind, int scope );
   public:
 	TypedefTable();
 
-	bool isIdentifier( const std::string &identifier ) const;
-	bool isTypedef( const std::string &identifier ) const;
-	bool isTypegen( const std::string &identifier ) const;
-
-	void changeKind( const std::string &identifier, kind_t kind );
+	bool isIdentifier( std::string identifier ) const;
+	bool isTypedef( std::string identifier ) const;
+	bool isTypegen( std::string identifier ) const;
 	
-	// "addToCurrentScope" adds the identifier/type pair to the current scope. This does less than you think it does,
+	// "addToCurrentScope" adds the identifier/type pair to the current scope This does less than you think it does,
 	// since each declaration is within its own scope.  Mostly useful for type parameters.
 	void addToCurrentScope( const std::string &identifier, kind_t kind );
-	void addToCurrentScope( kind_t kind );			// use nextIdentifiers.top()
+	void addToCurrentScope( kind_t kind );		// use nextIdentifiers.top()
 
 	// "addToEnclosingScope" adds the identifier/type pair to the scope that encloses the current one.  This is the
@@ -79,9 +77,9 @@
 	
 	// dump the definitions from a pre-defined context into the current scope
-	void openContext( const std::string &contextName );
+	void openContext( std::string contextName );
 	
 	void enterScope();
 	void leaveScope();
-	void enterContext( const std::string &contextName );
+	void enterContext( std::string contextName );
 	void leaveContext();
 
Index: src/Parser/cfa.y
===================================================================
--- src/Parser/cfa.y	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
+++ src/Parser/cfa.y	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -0,0 +1,2735 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// cfa.y -- 
+// 
+// Author           : Peter A. Buhr
+// Created On       : Sat Sep  1 20:22:55 2001
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 11:55:39 2015
+// Update Count     : 975
+// 
+
+// This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on
+// the C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS.  While
+// parts have been copied, important changes have been made in all sections; these changes are sufficient to
+// constitute a new grammar.  In particular, this grammar attempts to be more syntactically precise, i.e., it
+// parses less incorrect language syntax that must be subsequently rejected by semantic checks.  Nevertheless,
+// there are still several semantic checks required and many are noted in the grammar. Finally, the grammar is
+// extended with GCC and CFA language extensions.
+
+// Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got
+// stuck with the grammar.
+
+// The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for:
+//
+// 1. designation with '=' (use ':' instead)
+//
+// Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This
+// grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions, except for:
+//
+// 1. nested functions
+// 2. generalized lvalues
+// 3. designation with and without '=' (use ':' instead)
+// 4. attributes not allowed in parenthesis of declarator
+//
+// All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for
+// Cforall (CFA), which fixes several of C's outstanding problems and extends C with many modern language
+// concepts. All of the syntactic extensions for CFA C are marked with the comment "CFA". As noted above,
+// there is one unreconcileable parsing problem between C99 and CFA with respect to designators; this is
+// discussed in detail before the "designation" grammar rule.
+
+%{
+#define YYDEBUG_LEXER_TEXT (yylval)						// lexer loads this up each time
+#define YYDEBUG 1										// get the pretty debugging code to compile
+
+#undef __GNUC_MINOR__
+
+#include <cstdio>
+#include <stack>
+#include "TypedefTable.h"
+#include "lex.h"
+#include "ParseNode.h"
+#include "LinkageSpec.h"
+
+DeclarationNode *theTree = 0;							// the resulting parse tree
+LinkageSpec::Type linkage = LinkageSpec::Cforall;
+std::stack< LinkageSpec::Type > linkageStack;
+TypedefTable typedefTable;
+%}
+
+//************************* TERMINAL TOKENS ********************************
+
+// keywords
+%token TYPEDEF
+%token AUTO EXTERN REGISTER STATIC
+%token INLINE											// C99
+%token FORTRAN											// C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
+%token CONST VOLATILE
+%token RESTRICT											// C99
+%token FORALL LVALUE									// CFA
+%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
+%token BOOL COMPLEX IMAGINARY							// C99
+%token TYPEOF LABEL										// GCC
+%token ENUM STRUCT UNION
+%token TYPE FTYPE DTYPE CONTEXT							// CFA
+%token SIZEOF
+%token ATTRIBUTE EXTENSION								// GCC
+%token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
+%token CHOOSE FALLTHRU TRY CATCH FINALLY THROW			// CFA
+%token ASM												// C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
+%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL // C11
+
+// names and constants: lexer differentiates between identifier and typedef names
+%token<tok> IDENTIFIER			QUOTED_IDENTIFIER		TYPEDEFname				TYPEGENname
+%token<tok> ATTR_IDENTIFIER		ATTR_TYPEDEFname		ATTR_TYPEGENname
+%token<tok> INTEGERconstant		FLOATINGconstant		CHARACTERconstant		STRINGliteral
+%token<tok> ZERO				ONE						// CFA
+
+// multi-character operators
+%token ARROW											// ->
+%token ICR DECR											// ++	--
+%token LS RS											// <<	>>
+%token LE GE EQ NE										// <=	>=	==	!=
+%token ANDAND OROR										// &&	||
+%token ELLIPSIS											// ...
+
+%token MULTassign	DIVassign	MODassign				// *=	/=	%=/
+%token PLUSassign	MINUSassign							// +=	-=
+%token LSassign		RSassign							// <<=	>>=
+%token ANDassign	ERassign	ORassign				// &=	^=	|=
+
+// Types declaration
+%union
+{
+	Token tok;
+	ParseNode *pn;
+	ExpressionNode *en;
+	DeclarationNode *decl;
+	DeclarationNode::TyCon aggKey;
+	DeclarationNode::TypeClass tclass;
+	StatementNode *sn;
+	ConstantNode *constant;
+	InitializerNode *in;
+}
+
+%type<tok> zero_one  identifier  no_attr_identifier  no_01_identifier
+%type<tok> identifier_or_typedef_name  no_attr_identifier_or_typedef_name  no_01_identifier_or_typedef_name
+%type<constant> string_literal_list
+
+// expressions
+%type<constant> constant
+%type<en> tuple							tuple_expression_list
+%type<en> unary_operator				assignment_operator
+%type<en> primary_expression			postfix_expression			unary_expression
+%type<en> cast_expression				multiplicative_expression	additive_expression			shift_expression
+%type<en> relational_expression			equality_expression			AND_expression				exclusive_OR_expression
+%type<en> inclusive_OR_expression		logical_AND_expression		logical_OR_expression		conditional_expression
+%type<en> constant_expression			assignment_expression		assignment_expression_opt
+%type<en> comma_expression				comma_expression_opt
+%type<en> argument_expression_list		argument_expression			for_control_expression		assignment_opt
+%type<en> subrange
+
+// statements
+%type<sn> labeled_statement				compound_statement			expression_statement		selection_statement
+%type<sn> iteration_statement			jump_statement				exception_statement			asm_statement
+%type<sn> fall_through_opt				fall_through
+%type<sn> statement						statement_list
+%type<sn> block_item_list				block_item
+%type<sn> case_clause
+%type<en> case_value					case_value_list
+%type<sn> case_label					case_label_list
+%type<sn> switch_clause_list_opt		switch_clause_list			choose_clause_list_opt		choose_clause_list
+%type<pn> handler_list					handler_clause				finally_clause
+
+// declarations
+%type<decl> abstract_array abstract_declarator abstract_function abstract_parameter_array
+%type<decl> abstract_parameter_declaration abstract_parameter_declarator abstract_parameter_function
+%type<decl> abstract_parameter_ptr abstract_ptr
+
+%type<aggKey> aggregate_key
+%type<decl>  aggregate_name
+
+%type<decl> array_dimension array_parameter_1st_dimension array_parameter_dimension multi_array_dimension
+
+%type<decl> assertion assertion_list_opt
+
+%type<en>   bit_subrange_size_opt bit_subrange_size
+
+%type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type_name indirect_type_name
+
+%type<decl> context_declaration context_declaration_list context_declaring_list context_specifier
+
+%type<decl> declaration declaration_list declaration_list_opt declaration_qualifier_list
+%type<decl> declaration_specifier declarator declaring_list
+
+%type<decl> elaborated_type_name
+
+%type<decl> enumerator_list enum_name
+%type<en> enumerator_value_opt
+
+%type<decl> exception_declaration external_definition external_definition_list external_definition_list_opt
+
+%type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
+%type<en> field field_list
+
+%type<decl> function_array function_declarator function_definition function_no_ptr function_ptr
+
+%type<decl> identifier_parameter_array identifier_parameter_declarator identifier_parameter_function
+%type<decl> identifier_parameter_ptr identifier_list
+
+%type<decl> new_abstract_array new_abstract_declarator_no_tuple new_abstract_declarator_tuple
+%type<decl> new_abstract_function new_abstract_parameter_declaration new_abstract_parameter_list
+%type<decl> new_abstract_ptr new_abstract_tuple
+
+%type<decl> new_array_parameter_1st_dimension
+
+%type<decl> new_context_declaring_list new_declaration new_field_declaring_list
+%type<decl> new_function_declaration new_function_return new_function_specifier
+
+%type<decl> new_identifier_parameter_array new_identifier_parameter_declarator_no_tuple
+%type<decl> new_identifier_parameter_declarator_tuple new_identifier_parameter_ptr
+
+%type<decl> new_parameter_declaration new_parameter_list new_parameter_type_list new_parameter_type_list_opt
+
+%type<decl> new_typedef_declaration new_variable_declaration new_variable_specifier
+
+%type<decl> old_declaration old_declaration_list old_declaration_list_opt old_function_array
+%type<decl> old_function_declarator old_function_no_ptr old_function_ptr
+
+%type<decl> parameter_declaration parameter_list parameter_type_list
+%type<decl> parameter_type_list_opt
+
+%type<decl> paren_identifier paren_typedef
+
+%type<decl> storage_class storage_class_name storage_class_list
+
+%type<decl> sue_declaration_specifier sue_type_specifier
+
+%type<tclass> type_class
+%type<decl> type_declarator type_declarator_name type_declaring_list
+
+%type<decl> typedef typedef_array typedef_declaration typedef_declaration_specifier typedef_expression
+%type<decl> typedef_function typedef_parameter_array typedef_parameter_function typedef_parameter_ptr
+%type<decl> typedef_parameter_redeclarator typedef_ptr typedef_redeclarator typedef_type_specifier
+%type<decl> typegen_declaration_specifier typegen_type_specifier
+
+%type<decl> type_name type_name_no_function
+%type<decl> type_parameter type_parameter_list
+
+%type<en> type_name_list
+
+%type<decl> type_qualifier type_qualifier_name type_qualifier_list type_qualifier_list_opt type_specifier
+
+%type<decl> variable_abstract_array variable_abstract_declarator variable_abstract_function
+%type<decl> variable_abstract_ptr variable_array variable_declarator variable_function variable_ptr
+
+// initializers
+%type<in>  initializer initializer_list initializer_opt
+
+// designators
+%type<en>  designator designator_list designation
+
+
+// Handle single shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string
+// is ambiguous:
+// .---------.				matches IF '(' comma_expression ')' statement
+// if ( C ) S1 else S2
+// `-----------------'		matches IF '(' comma_expression ')' statement ELSE statement */
+
+%nonassoc THEN	// rule precedence for IF '(' comma_expression ')' statement
+%nonassoc ELSE	// token precedence for start of else clause in IF statement
+
+%start translation_unit									// parse-tree root
+
+%%
+//************************* Namespace Management ********************************
+
+// The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal
+// symbols "identifier" and "TYPEDEFname" that are lexically identical.  While it is possible to write a
+// purely context-free grammar, such a grammar would obscure the relationship between syntactic and semantic
+// constructs.  Hence, this grammar uses the ANSI style.
+//
+// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance,
+// those introduced through "forall" qualifiers), and by introducing "type generators" -- parametrized types.
+// This latter type name creates a third class of identifiers that must be distinguished by the scanner.
+//
+// Since the scanner cannot distinguish among the different classes of identifiers without some context
+// information, it accesses a data structure (the TypedefTable) to allow classification of an identifier that
+// it has just read.  Semantic actions during the parser update this data structure when the class of
+// identifiers change.
+//
+// Because the Cforall language is block-scoped, there is the possibility that an identifier can change its
+// class in a local scope; it must revert to its original class at the end of the block.  Since type names can
+// be local to a particular declaration, each declaration is itself a scope.  This requires distinguishing
+// between type names that are local to the current declaration scope and those that persist past the end of
+// the declaration (i.e., names defined in "typedef" or "type" declarations).
+//
+// The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and
+// closing of scopes.  Every push must have a matching pop, although it is regrettable the matching pairs do
+// not always occur within the same rule.  These non-terminals may appear in more contexts than strictly
+// necessary from a semantic point of view.  Unfortunately, these extra rules are necessary to prevent parsing
+// conflicts -- the parser may not have enough context and look-ahead information to decide whether a new
+// scope is necessary, so the effect of these extra rules is to open a new scope unconditionally.  As the
+// grammar evolves, it may be neccesary to add or move around "push" and "pop" nonterminals to resolve
+// conflicts of this sort.
+
+push:
+				{
+					typedefTable.enterScope();
+				}
+		;
+
+pop:
+				{
+					typedefTable.leaveScope();
+				}
+		;
+
+//************************* CONSTANTS ********************************
+
+constant:
+				// ENUMERATIONconstant is not included here; it is treated as a variable with type
+				// "enumeration constant".
+		INTEGERconstant									{ $$ = new ConstantNode(ConstantNode::Integer, $1); }
+		| FLOATINGconstant								{ $$ = new ConstantNode(ConstantNode::Float, $1); }
+		| CHARACTERconstant								{ $$ = new ConstantNode(ConstantNode::Character, $1); }
+		;
+
+identifier:
+		IDENTIFIER
+		| ATTR_IDENTIFIER								// CFA
+		| zero_one										// CFA
+		;
+
+no_01_identifier:
+		IDENTIFIER
+		| ATTR_IDENTIFIER								// CFA
+		;
+
+no_attr_identifier:
+		IDENTIFIER
+		;
+
+zero_one:												// CFA
+		ZERO
+		| ONE
+		;
+
+string_literal_list:									// juxtaposed strings are concatenated
+		STRINGliteral									{ $$ = new ConstantNode(ConstantNode::String, $1); }
+		| string_literal_list STRINGliteral				{ $$ = $1->append( $2 ); }
+		;
+
+//************************* EXPRESSIONS ********************************
+
+primary_expression:
+		IDENTIFIER										// typedef name cannot be used as a variable name
+				{ $$ = new VarRefNode($1); }
+		| zero_one
+				{ $$ = new VarRefNode($1); }
+		| constant
+				{ $$ = $1; }
+		| string_literal_list
+				{ $$ = $1; }
+		| '(' comma_expression ')'
+				{ $$ = $2; }
+		| '(' compound_statement ')'					// GCC, lambda expression
+				{ $$ = new ValofExprNode($2); }
+		;
+
+postfix_expression:
+		primary_expression
+		| postfix_expression '[' push assignment_expression pop ']'
+				// CFA, comma_expression disallowed in the context because it results in a commom user error:
+				// subscripting a matrix with x[i,j] instead of x[i][j]. While this change is not backwards
+				// compatible, there seems to be little advantage to this feature and many disadvantages. It
+				// is possible to write x[(i,j)] in CFA, which is equivalent to the old x[i,j].
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Index), $1, $4); }
+		| postfix_expression '(' argument_expression_list ')'
+				{ $$ = new CompositeExprNode($1, $3); }
+		| postfix_expression '.' no_attr_identifier
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), $1, new VarRefNode($3)); }
+		| postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
+		| postfix_expression ARROW no_attr_identifier
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), $1, new VarRefNode($3)); }
+		| postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
+		| postfix_expression ICR
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::IncrPost), $1); }
+		| postfix_expression DECR
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::DecrPost), $1); }
+				// GCC has priority: cast_expression
+		| '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
+				{ $$ = 0; }
+		;
+
+argument_expression_list:
+		argument_expression
+		| argument_expression_list ',' argument_expression
+				{ $$ = (ExpressionNode *)($1->set_link($3)); }
+		;
+
+argument_expression:
+		// empty
+				{ $$ = 0; }								// use default argument
+		| assignment_expression
+		| no_attr_identifier ':' assignment_expression
+				{ $$ = $3->set_asArgName($1); }
+				// Only a list of no_attr_identifier_or_typedef_name is allowed in this context. However,
+				// there is insufficient look ahead to distinguish between this list of parameter names and a
+				// tuple, so the tuple form must be used with an appropriate semantic check.
+		| '[' push assignment_expression pop ']' ':' assignment_expression
+				{ $$ = $7->set_asArgName($3); }
+		| '[' push assignment_expression ',' tuple_expression_list pop ']' ':' assignment_expression
+				{ $$ = $9->set_asArgName(new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 )))); }
+		;
+
+field_list:												// CFA, tuple field selector
+		field
+		| field_list ',' field							{ $$ = (ExpressionNode *)$1->set_link( $3 ); }
+		;
+
+field:													// CFA, tuple field selector
+		no_attr_identifier
+				{ $$ = new VarRefNode( $1 ); }
+		| no_attr_identifier '.' field
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( $1 ), $3); }
+		| no_attr_identifier '.' '[' push field_list pop ']'
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::FieldSel), new VarRefNode( $1 ), $5); }
+		| no_attr_identifier ARROW field
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( $1 ), $3); }
+		| no_attr_identifier ARROW '[' push field_list pop ']'
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PFieldSel), new VarRefNode( $1 ), $5); }
+		;
+
+unary_expression:
+		postfix_expression
+		| ICR unary_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Incr), $2); }
+		| DECR unary_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Decr), $2); }
+		| EXTENSION cast_expression						// GCC
+				{ $$ = $2; }
+		| unary_operator cast_expression
+				{ $$ = new CompositeExprNode($1, $2); }
+		| '!' cast_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Neg), $2); }
+		| '*' cast_expression							// CFA
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::PointTo), $2); }
+				// '*' is is separated from unary_operator because of shift/reduce conflict in:
+				//		{ * X; } // dereference X
+				//		{ * int X; } // CFA declaration of pointer to int
+				// '&' must be moved here if C++ reference variables are supported.
+		| SIZEOF unary_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), $2); }
+		| SIZEOF '(' type_name_no_function ')'
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::SizeOf), new TypeValueNode($3)); }
+		| ATTR_IDENTIFIER
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1)); }
+		| ATTR_IDENTIFIER '(' type_name ')'
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1), new TypeValueNode($3)); }
+		| ATTR_IDENTIFIER '(' argument_expression ')'
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Attr), new VarRefNode($1), $3); }
+		| ALIGNOF unary_expression						// GCC, variable alignment
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), $2); }
+		| ALIGNOF '(' type_name_no_function ')'			// GCC, type alignment
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::AlignOf), new TypeValueNode($3)); }
+		| ANDAND no_attr_identifier						// GCC, address of label
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LabelAddress), new VarRefNode($2, true)); }
+		;
+
+unary_operator:
+		'&'												{ $$ = new OperatorNode(OperatorNode::AddressOf); }
+		| '+'											{ $$ = new OperatorNode(OperatorNode::UnPlus); }
+		| '-'											{ $$ = new OperatorNode(OperatorNode::UnMinus); }
+		| '~'											{ $$ = new OperatorNode(OperatorNode::BitNeg); }
+		;
+
+cast_expression:
+		unary_expression
+		| '(' type_name_no_function ')' cast_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode($2), $4); }
+		| '(' type_name_no_function ')' tuple
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cast), new TypeValueNode($2), $4); }
+		;
+
+multiplicative_expression:
+		cast_expression
+		| multiplicative_expression '*' cast_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Mul),$1,$3); }
+		| multiplicative_expression '/' cast_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Div),$1,$3); }
+		| multiplicative_expression '%' cast_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Mod),$1,$3); }
+		;
+
+additive_expression:
+		multiplicative_expression
+		| additive_expression '+' multiplicative_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Plus),$1,$3); }
+		| additive_expression '-' multiplicative_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Minus),$1,$3); }
+		;
+
+shift_expression:
+		additive_expression
+		| shift_expression LS additive_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LShift),$1,$3); }
+		| shift_expression RS additive_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::RShift),$1,$3); }
+		;
+
+relational_expression:
+		shift_expression
+		| relational_expression '<' shift_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LThan),$1,$3); }
+		| relational_expression '>' shift_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::GThan),$1,$3); }
+		| relational_expression LE shift_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::LEThan),$1,$3); }
+		| relational_expression GE shift_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::GEThan),$1,$3); }
+		;
+
+equality_expression:
+		relational_expression
+		| equality_expression EQ relational_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Eq), $1, $3); }
+		| equality_expression NE relational_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Neq), $1, $3); }
+		;
+
+AND_expression:
+		equality_expression
+		| AND_expression '&' equality_expression
+				{ $$ =new CompositeExprNode(new OperatorNode(OperatorNode::BitAnd), $1, $3); }
+		;
+
+exclusive_OR_expression:
+		AND_expression
+		| exclusive_OR_expression '^' AND_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Xor), $1, $3); }
+		;
+
+inclusive_OR_expression:
+		exclusive_OR_expression
+		| inclusive_OR_expression '|' exclusive_OR_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::BitOr), $1, $3); }
+		;
+
+logical_AND_expression:
+		inclusive_OR_expression
+		| logical_AND_expression ANDAND inclusive_OR_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::And), $1, $3); }
+		;
+
+logical_OR_expression:
+		logical_AND_expression
+		| logical_OR_expression OROR logical_AND_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Or), $1, $3); }
+		;
+
+conditional_expression:
+		logical_OR_expression
+		| logical_OR_expression '?' comma_expression ':' conditional_expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList((*$1,*$3,*$5))); }
+		| logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
+				{ $$=new CompositeExprNode(new OperatorNode(OperatorNode::NCond),$1,$4); }
+		| logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Cond), (ExpressionNode *)mkList(( *$1, *$3, *$5 ))); }
+		;
+
+constant_expression:
+		conditional_expression
+		;
+
+assignment_expression:
+				// CFA, assignment is separated from assignment_operator to ensure no assignment operations
+				// for tuples
+		conditional_expression
+		| unary_expression '=' assignment_expression
+				{ $$ =new CompositeExprNode(new OperatorNode(OperatorNode::Assign), $1, $3); }
+		| unary_expression assignment_operator assignment_expression
+				{ $$ =new CompositeExprNode($2, $1, $3); }
+		| tuple assignment_opt							// CFA, tuple expression
+				{ $$ = ($2 == 0) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); }
+		;
+
+assignment_expression_opt:
+		// empty
+				{ $$ = new NullExprNode; }
+		| assignment_expression
+		;
+
+tuple:													// CFA, tuple
+				// CFA, one assignment_expression is factored out of comma_expression to eliminate a
+				// shift/reduce conflict with comma_expression in new_identifier_parameter_array and
+				// new_abstract_array
+		'[' push pop ']'
+				{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
+		| '[' push assignment_expression pop ']'
+				{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), $3 ); }
+		| '[' push ',' tuple_expression_list pop ']'
+				{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( $4 ) ); }
+		| '[' push assignment_expression ',' tuple_expression_list pop ']'
+				{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 ) ) ); }
+		;
+
+tuple_expression_list:
+		assignment_expression_opt
+		| tuple_expression_list ',' assignment_expression_opt
+				{ $$ = (ExpressionNode *)$1->set_link( $3 ); }
+		;
+
+assignment_operator:
+		MULTassign										{ $$ = new OperatorNode(OperatorNode::MulAssn); }
+		| DIVassign										{ $$ = new OperatorNode(OperatorNode::DivAssn); }
+		| MODassign										{ $$ = new OperatorNode(OperatorNode::ModAssn); }
+		| PLUSassign									{ $$ = new OperatorNode(OperatorNode::PlusAssn); }
+		| MINUSassign									{ $$ = new OperatorNode(OperatorNode::MinusAssn); }
+		| LSassign										{ $$ = new OperatorNode(OperatorNode::LSAssn); }
+		| RSassign										{ $$ = new OperatorNode(OperatorNode::RSAssn); }
+		| ANDassign										{ $$ = new OperatorNode(OperatorNode::AndAssn); }
+		| ERassign										{ $$ = new OperatorNode(OperatorNode::ERAssn); }
+		| ORassign										{ $$ = new OperatorNode(OperatorNode::OrAssn); }
+		;
+
+comma_expression:
+		assignment_expression
+		| comma_expression ',' assignment_expression	// { $$ = (ExpressionNode *)$1->add_to_list($3); }
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Comma),$1,$3); }
+		;
+
+comma_expression_opt:
+		// empty
+				{ $$ = 0; }
+		| comma_expression
+		;
+
+//*************************** STATEMENTS *******************************
+
+statement:
+		labeled_statement
+		| compound_statement
+		| expression_statement							{ $$ = $1; }
+		| selection_statement
+		| iteration_statement
+		| jump_statement
+		| exception_statement
+		| asm_statement
+		;
+
+labeled_statement:
+		no_attr_identifier ':' attribute_list_opt statement
+				{ $$ = $4->add_label($1);}
+		;
+
+compound_statement:
+		'{' '}'
+				{ $$ = new CompoundStmtNode( (StatementNode *)0 ); }
+		| '{'
+				// Two scopes are necessary because the block itself has a scope, but every declaration within
+				// the block also requires its own scope
+		  push push
+		  label_declaration_opt							// GCC, local labels
+		  block_item_list pop '}'						// C99, intermix declarations and statements
+				{ $$ = new CompoundStmtNode( $5 ); }
+		;
+
+block_item_list:										// C99
+		block_item
+		| block_item_list push block_item
+				{ if ($1 != 0) { $1->set_link($3); $$ = $1; } }
+		;
+
+block_item:
+		declaration										// CFA, new & old style declarations
+				{ $$ = new StatementNode( $1 ); }
+		| EXTENSION declaration							// GCC
+				{ $$ = new StatementNode( $2 ); }
+		| statement pop
+		;
+
+statement_list:
+		statement
+		| statement_list statement
+				{ if ($1 != 0) { $1->set_link($2); $$ = $1; } }
+		;
+
+expression_statement:
+		comma_expression_opt ';'
+				{ $$ = new StatementNode(StatementNode::Exp, $1, 0); }
+		;
+
+selection_statement:
+		IF '(' comma_expression ')' statement				%prec THEN
+				// explicitly deal with the shift/reduce conflict on if/else
+				{ $$ = new StatementNode(StatementNode::If, $3, $5); }
+		| IF '(' comma_expression ')' statement ELSE statement
+				{ $$ = new StatementNode(StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7)) ); }
+		| SWITCH '(' comma_expression ')' case_clause	// CFA
+				{ $$ = new StatementNode(StatementNode::Switch, $3, $5); }
+		| SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
+				{ $$ = new StatementNode(StatementNode::Switch, $3, $8); /* xxx */ }
+				// The semantics of the declaration list is changed to include any associated initialization,
+				// which is performed *before* the transfer to the appropriate case clause.  Statements after
+				// the initial declaration list can never be executed, and therefore, are removed from the
+				// grammar even though C allows it.
+		| CHOOSE '(' comma_expression ')' case_clause	// CFA
+				{ $$ = new StatementNode(StatementNode::Choose, $3, $5); }
+		| CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' // CFA
+				{ $$ = new StatementNode(StatementNode::Choose, $3, $8); }
+		;
+
+// CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a
+// case clause allows a list of values and subranges.
+
+case_value:												// CFA
+		constant_expression								{ $$ = $1; }
+		| constant_expression ELLIPSIS constant_expression // GCC, subrange
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range),$1,$3); }
+		| subrange										// CFA, subrange
+		;
+
+case_value_list:										// CFA
+		case_value
+		| case_value_list ',' case_value
+				{ $$ = new CompositeExprNode(new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(tupleContents($1))->set_link($3) ); }
+		;
+
+case_label:												// CFA
+		CASE case_value_list ':'						{ $$ = new StatementNode(StatementNode::Case, $2, 0); }
+		| DEFAULT ':'								    { $$ = new StatementNode(StatementNode::Default); }
+				// A semantic check is required to ensure only one default clause per switch/choose statement.
+		;
+
+case_label_list:										// CFA
+		case_label
+		| case_label_list case_label					{ $$ = (StatementNode *)($1->set_link($2)); }
+		;
+
+case_clause:											// CFA
+		case_label_list statement						{ $$ = $1->append_last_case($2); }
+		;
+
+switch_clause_list_opt:									// CFA
+		// empty
+				{ $$ = 0; }
+		| switch_clause_list
+		;
+
+switch_clause_list:										// CFA
+		case_label_list statement_list
+				{ $$ = $1->append_last_case($2); }
+		| switch_clause_list case_label_list statement_list
+				{ $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); }
+		;
+
+choose_clause_list_opt:									// CFA
+		// empty
+				{ $$ = 0; }
+		| choose_clause_list
+		;
+
+choose_clause_list:										// CFA
+		case_label_list fall_through
+				{ $$ = $1->append_last_case($2); }
+		| case_label_list statement_list fall_through_opt
+				{ $$ = $1->append_last_case((StatementNode *)mkList((*$2,*$3))); }
+		| choose_clause_list case_label_list fall_through
+				{ $$ = (StatementNode *)($1->set_link($2->append_last_case($3))); }
+		| choose_clause_list case_label_list statement_list fall_through_opt
+				{ $$ = (StatementNode *)($1->set_link($2->append_last_case((StatementNode *)mkList((*$3,*$4))))); }
+		;
+
+fall_through_opt:										// CFA
+		// empty
+				{ $$ = 0; }
+		| fall_through
+		;
+
+fall_through:											// CFA
+		FALLTHRU										{ $$ = new StatementNode(StatementNode::Fallthru, 0, 0); }
+		| FALLTHRU ';'									{ $$ = new StatementNode(StatementNode::Fallthru, 0, 0); }
+		;
+
+iteration_statement:
+		WHILE '(' comma_expression ')' statement
+				{ $$ = new StatementNode(StatementNode::While, $3, $5); }
+		| DO statement WHILE '(' comma_expression ')' ';'
+				{ $$ = new StatementNode(StatementNode::Do, $5, $2); }
+		| FOR '(' push for_control_expression ')' statement
+				{ $$ = new StatementNode(StatementNode::For, $4, $6); }
+		;
+
+for_control_expression:
+		comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt
+				{ $$ = new ForCtlExprNode($1, $4, $6); }
+		| declaration comma_expression_opt ';' comma_expression_opt // C99
+				// Like C++, the loop index can be declared local to the loop.
+				{ $$ = new ForCtlExprNode($1, $2, $4); }
+		;
+
+jump_statement:
+		GOTO no_attr_identifier ';'
+				{ $$ = new StatementNode(StatementNode::Goto, $2); }
+		| GOTO '*' comma_expression ';'				// GCC, computed goto
+				// The syntax for the GCC computed goto violates normal expression precedence, e.g., goto
+				// *i+3; => goto *(i+3); whereas normal operator precedence yields goto (*i)+3;
+				{ $$ = new StatementNode(StatementNode::Goto, $3); }
+		| CONTINUE ';'
+				// A semantic check is required to ensure this statement appears only in the body of an
+				// iteration statement.
+				{ $$ = new StatementNode(StatementNode::Continue, 0, 0); }
+		| CONTINUE no_attr_identifier ';'		// CFA, multi-level continue
+				// A semantic check is required to ensure this statement appears only in the body of an
+				// iteration statement, and the target of the transfer appears only at the start of an
+				// iteration statement.
+				{ $$ = new StatementNode(StatementNode::Continue, $2); }
+		| BREAK ';'
+				// A semantic check is required to ensure this statement appears only in the body of an
+				// iteration statement.
+				{ $$ = new StatementNode(StatementNode::Break, 0, 0); }
+		| BREAK no_attr_identifier ';'				// CFA, multi-level exit
+				// A semantic check is required to ensure this statement appears only in the body of an
+				// iteration statement, and the target of the transfer appears only at the start of an
+				// iteration statement.
+				{ $$ = new StatementNode(StatementNode::Break, $2 ); }
+		| RETURN comma_expression_opt ';'
+				{ $$ = new StatementNode(StatementNode::Return, $2, 0); }
+		| THROW assignment_expression ';'
+				{ $$ = new StatementNode(StatementNode::Throw, $2, 0); }
+		| THROW ';'
+				{ $$ = new StatementNode(StatementNode::Throw, 0, 0); }
+		;
+
+exception_statement:
+		TRY compound_statement handler_list
+				{ $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); }
+		| TRY compound_statement finally_clause
+				{ $$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3)))); }
+		| TRY compound_statement handler_list finally_clause
+				{ 
+					$3->set_link($4);
+					$$ = new StatementNode(StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3))));
+				}
+		;
+
+handler_list:
+				// There must be at least one catch clause
+		handler_clause
+				// ISO/IEC 9899:1999 Section 15.3(6) If present, a "..." handler shall be the last handler for
+				// its try block.
+		| CATCH '(' ELLIPSIS ')' compound_statement
+				{ $$ = StatementNode::newCatchStmt( 0, $5, true ); }
+		| handler_clause CATCH '(' ELLIPSIS ')' compound_statement
+				{ $$ = $1->set_link( StatementNode::newCatchStmt( 0, $6, true ) ); }
+		;
+
+handler_clause:
+		CATCH '(' push push exception_declaration pop ')' compound_statement pop
+				{ $$ = StatementNode::newCatchStmt($5, $8); }
+		| handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop
+				{ $$ = $1->set_link( StatementNode::newCatchStmt($6, $9) ); }
+		;
+
+finally_clause:
+		FINALLY compound_statement
+				{ $$ = new StatementNode(StatementNode::Finally, 0, $2);
+					std::cout << "Just created a finally node" << std::endl;
+				}
+		;
+
+exception_declaration:
+				// A semantic check is required to ensure type_specifier does not create a new type, e.g.:
+				//
+				//		catch ( struct { int i; } x ) ...
+				//
+				// This new type cannot catch any thrown type because of name equivalence among types.
+		type_specifier
+		| type_specifier declarator
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = $2->addType( $1 );
+				}
+		| type_specifier variable_abstract_declarator
+				{ $$ = $2->addType( $1 ); }
+		| new_abstract_declarator_tuple no_attr_identifier // CFA
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = $1->addName( $2 );
+				}
+		| new_abstract_declarator_tuple					// CFA
+		;
+
+asm_statement:
+		ASM type_qualifier_list_opt '(' constant_expression ')' ';'
+				{ $$ = new StatementNode(StatementNode::Asm, 0, 0); }
+		| ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ')' ';' // remaining GCC
+				{ $$ = new StatementNode(StatementNode::Asm, 0, 0); }
+		| ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ')' ';'
+				{ $$ = new StatementNode(StatementNode::Asm, 0, 0); }
+		| ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ':'
+						asm_clobbers_list ')' ';'
+				{ $$ = new StatementNode(StatementNode::Asm, 0, 0); }
+		;
+
+asm_operands_opt:										// GCC
+		// empty
+		| asm_operands_list
+		;
+
+asm_operands_list:										// GCC
+		asm_operand
+		| asm_operands_list ',' asm_operand
+		;
+
+asm_operand:											// GCC
+		STRINGliteral '(' constant_expression ')'		{}
+		;
+
+asm_clobbers_list:										// GCC
+		STRINGliteral									{}
+		| asm_clobbers_list ',' STRINGliteral
+		;
+
+//******************************* DECLARATIONS *********************************
+
+declaration_list_opt:									// used at beginning of switch statement
+		pop
+				{ $$ = 0; }
+		| declaration_list
+		;
+
+declaration_list:
+		declaration
+		| declaration_list push declaration
+				{ $$ = $1->appendList( $3 ); }
+		;
+
+old_declaration_list_opt:								// used to declare parameter types in K&R style functions
+		pop
+				{ $$ = 0; }
+		| old_declaration_list
+		;
+
+old_declaration_list:
+		old_declaration
+		| old_declaration_list push old_declaration
+				{ $$ = $1->appendList( $3 ); }
+		;
+
+label_declaration_opt:									// GCC, local label
+		// empty
+		| label_declaration_list
+		;
+
+label_declaration_list:									// GCC, local label
+		LABEL label_list ';'
+		| label_declaration_list LABEL label_list ';'
+		;
+
+label_list:												// GCC, local label
+		no_attr_identifier_or_typedef_name				{}
+		| label_list ',' no_attr_identifier_or_typedef_name {}
+		;
+
+declaration:											// CFA, new & old style declarations
+		new_declaration
+		| old_declaration
+		;
+
+// C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and
+// function declarations. CFA declarations use the same declaration tokens as in C; however, CFA places
+// declaration modifiers to the left of the base type, while C declarations place modifiers to the right of
+// the base type. CFA declaration modifiers are interpreted from left to right and the entire type
+// specification is distributed across all variables in the declaration list (as in Pascal).  ANSI C and the
+// new CFA declarations may appear together in the same program block, but cannot be mixed within a specific
+// declaration.
+//
+//			CFA					C
+//		[10] int x;			int x[10];		// array of 10 integers
+//		[10] * char y;		char *y[10];	// array of 10 pointers to char
+
+new_declaration:										// CFA
+		new_variable_declaration pop ';'
+		| new_typedef_declaration pop ';'
+		| new_function_declaration pop ';'
+		| type_declaring_list pop ';'
+		| context_specifier pop ';'
+		;
+
+new_variable_declaration:								// CFA
+		new_variable_specifier initializer_opt
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = $1;
+				}
+		| declaration_qualifier_list new_variable_specifier initializer_opt
+				// declaration_qualifier_list also includes type_qualifier_list, so a semantic check is
+				// necessary to preclude them as a type_qualifier cannot appear in that context.
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = $2->addQualifiers( $1 );
+				}
+		| new_variable_declaration pop ',' push identifier_or_typedef_name initializer_opt
+				{
+					typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
+					$$ = $1->appendList( $1->cloneType( $5 ) );
+				}
+		;
+
+new_variable_specifier:									// CFA
+				// A semantic check is required to ensure asm_name only appears on declarations with implicit
+				// or explicit static storage-class
+		new_abstract_declarator_no_tuple identifier_or_typedef_name asm_name_opt
+				{
+					typedefTable.setNextIdentifier( *$2 );
+					$$ = $1->addName( $2 );
+				}
+		| new_abstract_tuple identifier_or_typedef_name asm_name_opt
+				{
+					typedefTable.setNextIdentifier( *$2 );
+					$$ = $1->addName( $2 );
+				}
+		| type_qualifier_list new_abstract_tuple identifier_or_typedef_name asm_name_opt
+				{
+					typedefTable.setNextIdentifier( *$3 );
+					$$ = $2->addQualifiers( $1 )->addName( $3 );
+				}
+		;
+
+new_function_declaration:								// CFA
+		new_function_specifier
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = $1;
+				}
+		| declaration_qualifier_list new_function_specifier
+				// declaration_qualifier_list also includes type_qualifier_list, so a semantic check is
+				// necessary to preclude them as a type_qualifier cannot appear in this context.
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = $2->addQualifiers( $1 );
+				}
+		| new_function_declaration pop ',' push identifier_or_typedef_name
+				{
+					typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
+					$$ = $1->appendList( $1->cloneType( $5 ) );
+				}
+		;
+
+new_function_specifier:									// CFA
+		'[' push pop ']' identifier '(' push new_parameter_type_list_opt pop ')'
+				{
+					typedefTable.setNextIdentifier( *($5) );
+					$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
+				}
+		| '[' push pop ']' TYPEDEFname '(' push new_parameter_type_list_opt pop ')'
+				{
+					typedefTable.setNextIdentifier( *($5) );
+					$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
+				}
+				// identifier_or_typedef_name must be broken apart because of the sequence:
+				//
+				//   '[' ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')'
+				//   '[' ']' type_specifier
+				//
+				// type_specifier can resolve to just TYPEDEFname (e.g. typedef int T; int f( T );). Therefore
+				// this must be flattened to allow lookahead to the '(' without having to reduce
+				// identifier_or_typedef_name.
+		| new_abstract_tuple identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')'
+				// To obtain LR(1), this rule must be factored out from function return type (see
+				//   new_abstract_declarator).
+				{
+					$$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
+				}
+		| new_function_return identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')'
+				{
+					$$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
+				}
+		;
+
+new_function_return:									// CFA
+		'[' push new_parameter_list pop ']'
+				{ $$ = DeclarationNode::newTuple( $3 ); }
+		| '[' push new_parameter_list pop ',' push new_abstract_parameter_list pop ']'
+				// To obtain LR(1), the last new_abstract_parameter_list is added into this flattened rule to
+				// lookahead to the ']'.
+				{ $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); }
+		;
+
+new_typedef_declaration:								// CFA
+		TYPEDEF new_variable_specifier
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::TD);
+					$$ = $2->addTypedef();
+				}
+		| TYPEDEF new_function_specifier
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::TD);
+					$$ = $2->addTypedef();
+				}
+		| new_typedef_declaration pop ',' push no_attr_identifier
+				{
+					typedefTable.addToEnclosingScope( *$5, TypedefTable::TD);
+					$$ = $1->appendList( $1->cloneType( $5 ) );
+				}
+		;
+
+// Traditionally typedef is part of storage-class specifier for syntactic convenience only. Here, it is
+// factored out as a separate form of declaration, which syntactically precludes storage-class specifiers and
+// initialization.
+
+typedef_declaration:
+		TYPEDEF type_specifier declarator
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::TD);
+					$$ = $3->addType( $2 )->addTypedef();
+				}
+		| typedef_declaration pop ',' push declarator
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::TD);
+					$$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
+				}
+		| type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2)
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::TD);
+					$$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
+				}
+		| type_specifier TYPEDEF declarator
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::TD);
+					$$ = $3->addType( $1 )->addTypedef();
+				}
+		| type_specifier TYPEDEF type_qualifier_list declarator
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::TD);
+					$$ = $4->addQualifiers($1)->addTypedef()->addType($1);
+				}
+		;
+
+typedef_expression:										// GCC, naming expression type
+		TYPEDEF no_attr_identifier '=' assignment_expression
+				{
+					typedefTable.addToEnclosingScope(*($2), TypedefTable::TD);
+					$$ = DeclarationNode::newName( 0 ); // XXX
+				}
+		| typedef_expression pop ',' push no_attr_identifier '=' assignment_expression
+				{
+					typedefTable.addToEnclosingScope(*($5), TypedefTable::TD);
+					$$ = DeclarationNode::newName( 0 ); // XXX
+				}
+		;
+
+old_declaration:
+		declaring_list pop ';'
+		| typedef_declaration pop ';'
+		| typedef_expression pop ';'					// GCC, naming expression type
+		| sue_declaration_specifier pop ';'
+		;
+
+declaring_list:
+				// A semantic check is required to ensure asm_name only appears on declarations with implicit
+				// or explicit static storage-class
+		declaration_specifier declarator asm_name_opt initializer_opt
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = ($2->addType( $1 ))->addInitializer($4);
+				}
+		| declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = $1->appendList( $1->cloneBaseType( $4->addInitializer($6) ) );
+				}
+		;
+
+declaration_specifier:									// type specifier + storage class
+		basic_declaration_specifier
+		| sue_declaration_specifier
+		| typedef_declaration_specifier
+		| typegen_declaration_specifier
+		;
+
+type_specifier:											// declaration specifier - storage class
+		basic_type_specifier
+		| sue_type_specifier
+		| typedef_type_specifier
+		| typegen_type_specifier
+		;
+
+type_qualifier_list_opt:								// GCC, used in asm_statement
+		// empty
+				{ $$ = 0; }
+		| type_qualifier_list
+		;
+
+type_qualifier_list:
+				// A semantic check is necessary to ensure a type qualifier is appropriate for the kind of
+				// declaration.
+				//
+				// ISO/IEC 9899:1999 Section 6.7.3(4) : If the same qualifier appears more than once in the
+				// same specifier-qualifier-list, either directly or via one or more typedefs, the behavior is
+				// the same as if it appeared only once.
+		type_qualifier
+		| type_qualifier_list type_qualifier
+				{ $$ = $1->addQualifiers( $2 ); }
+		;
+
+type_qualifier:
+		type_qualifier_name
+		| attribute
+				{ $$ = DeclarationNode::newQualifier( DeclarationNode::Attribute ); }
+		;
+
+type_qualifier_name:
+		CONST
+				{ $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); }
+		| RESTRICT
+				{ $$ = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
+		| VOLATILE
+				{ $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
+		| LVALUE										// CFA
+				{ $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
+		| ATOMIC
+				{ $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
+		| FORALL '('
+				{
+					typedefTable.enterScope();
+				}
+		  type_parameter_list ')'						// CFA
+				{
+					typedefTable.leaveScope();
+					$$ = DeclarationNode::newForall( $4 );
+				}
+		;
+
+declaration_qualifier_list:
+		storage_class_list
+		| type_qualifier_list storage_class_list		// remaining OBSOLESCENT (see 2)
+				{ $$ = $1->addQualifiers( $2 ); }
+		| declaration_qualifier_list type_qualifier_list storage_class_list
+				{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
+		;
+
+storage_class_list:
+				// A semantic check is necessary to ensure a storage class is appropriate for the kind of
+				// declaration and that only one of each is specified, except for inline, which can appear
+				// with the others.
+				//
+				// ISO/IEC 9899:1999 Section 6.7.1(2) : At most, one storage-class specifier may be given in
+				// the declaration specifiers in a declaration.
+		storage_class
+		| storage_class_list storage_class
+				{ $$ = $1->addQualifiers( $2 ); }
+		;
+
+storage_class:
+		storage_class_name
+		;
+
+storage_class_name:
+		EXTERN
+				{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
+		| STATIC
+				{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
+		| AUTO
+				{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
+		| REGISTER
+				{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
+		| INLINE										// C99
+				// INLINE is essentially a storage class specifier for functions, and hence, belongs here.
+				{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
+		| FORTRAN										// C99
+				{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
+		;
+
+basic_type_name:
+		CHAR
+				{ $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); }
+		| DOUBLE
+				{ $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
+		| FLOAT
+				{ $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+		| INT
+				{ $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+		| LONG
+				{ $$ = DeclarationNode::newModifier( DeclarationNode::Long ); }
+		| SHORT
+				{ $$ = DeclarationNode::newModifier( DeclarationNode::Short ); }
+		| SIGNED
+				{ $$ = DeclarationNode::newModifier( DeclarationNode::Signed ); }
+		| UNSIGNED
+				{ $$ = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
+		| VOID
+				{ $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+		| BOOL											// C99
+				{ $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+		| COMPLEX										// C99
+				{ $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
+		| IMAGINARY										// C99
+				{ $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
+		;
+
+basic_declaration_specifier:
+				// A semantic check is necessary for conflicting storage classes.
+		basic_type_specifier
+		| declaration_qualifier_list basic_type_specifier
+				{ $$ = $2->addQualifiers( $1 ); }
+		| basic_declaration_specifier storage_class		// remaining OBSOLESCENT (see 2)
+				{ $$ = $1->addQualifiers( $2 ); }
+		| basic_declaration_specifier storage_class type_qualifier_list
+				{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
+		| basic_declaration_specifier storage_class basic_type_specifier
+				{ $$ = $3->addQualifiers( $2 )->addType( $1 ); }
+		;
+
+basic_type_specifier:
+		direct_type_name
+		| type_qualifier_list_opt indirect_type_name type_qualifier_list_opt
+				{ $$ = $2->addQualifiers( $1 )->addQualifiers( $3 ); }
+		;
+
+direct_type_name:
+				// A semantic check is necessary for conflicting type qualifiers.
+		basic_type_name
+		| type_qualifier_list basic_type_name
+				{ $$ = $2->addQualifiers( $1 ); }
+		| direct_type_name type_qualifier
+				{ $$ = $1->addQualifiers( $2 ); }
+		| direct_type_name basic_type_name
+				{ $$ = $1->addType( $2 ); }
+		;
+
+indirect_type_name:
+		TYPEOF '(' type_name ')'						// GCC: typeof(x) y;
+				{ $$ = $3; }
+		| TYPEOF '(' comma_expression ')'				// GCC: typeof(a+b) y;
+				{ $$ = DeclarationNode::newTypeof( $3 ); }
+		| ATTR_TYPEGENname '(' type_name ')'			// CFA: e.g., @type(x) y;
+				{ $$ = DeclarationNode::newAttr( $1, $3 ); }
+		| ATTR_TYPEGENname '(' comma_expression ')'		// CFA: e.g., @type(a+b) y;
+				{ $$ = DeclarationNode::newAttr( $1, $3 ); }
+		;
+
+sue_declaration_specifier:
+		sue_type_specifier
+		| declaration_qualifier_list sue_type_specifier
+				{ $$ = $2->addQualifiers( $1 ); }
+		| sue_declaration_specifier storage_class		// remaining OBSOLESCENT (see 2)
+				{ $$ = $1->addQualifiers( $2 ); }
+		| sue_declaration_specifier storage_class type_qualifier_list
+				{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
+		;
+
+sue_type_specifier:
+		elaborated_type_name							// struct, union, enum
+		| type_qualifier_list elaborated_type_name
+				{ $$ = $2->addQualifiers( $1 ); }
+		| sue_type_specifier type_qualifier
+				{ $$ = $1->addQualifiers( $2 ); }
+		;
+
+typedef_declaration_specifier:
+		typedef_type_specifier
+		| declaration_qualifier_list typedef_type_specifier
+				{ $$ = $2->addQualifiers( $1 ); }
+		| typedef_declaration_specifier storage_class	// remaining OBSOLESCENT (see 2)
+				{ $$ = $1->addQualifiers( $2 ); }
+		| typedef_declaration_specifier storage_class type_qualifier_list
+				{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
+		;
+
+typedef_type_specifier:									// typedef types
+		TYPEDEFname
+				{ $$ = DeclarationNode::newFromTypedef( $1 ); }
+		| type_qualifier_list TYPEDEFname
+				{ $$ = DeclarationNode::newFromTypedef( $2 )->addQualifiers( $1 ); }
+		| typedef_type_specifier type_qualifier
+				{ $$ = $1->addQualifiers( $2 ); }
+		;
+
+elaborated_type_name:
+		aggregate_name
+		| enum_name
+		;
+
+aggregate_name:
+		aggregate_key '{' field_declaration_list '}'
+				{ $$ = DeclarationNode::newAggregate( $1, 0, 0, 0, $3 ); }
+		| aggregate_key no_attr_identifier_or_typedef_name
+				{ $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, 0 ); }
+		| aggregate_key no_attr_identifier_or_typedef_name '{' field_declaration_list '}'
+				{ $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, $4 ); }
+		| aggregate_key '(' push type_parameter_list pop ')' '{' field_declaration_list '}' // CFA
+				{ $$ = DeclarationNode::newAggregate( $1, 0, $4, 0, $8 ); }
+		| aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name // CFA
+				{ $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, 0 ); }
+		| aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA
+				{ $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, $9 ); }
+		| aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' '{' field_declaration_list '}' // CFA
+				{ $$ = DeclarationNode::newAggregate( $1, 0, $4, $8, $11 ); }
+		| aggregate_key '(' push type_name_list pop ')' no_attr_identifier_or_typedef_name // CFA
+				// push and pop are only to prevent S/R conflicts
+				{ $$ = DeclarationNode::newAggregate( $1, $7, 0, $4, 0 ); }
+		| aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA
+				{ $$ = DeclarationNode::newAggregate( $1, $10, $4, $8, $12 ); }
+		;
+
+aggregate_key:
+		STRUCT attribute_list_opt
+				{ $$ = DeclarationNode::Struct; }
+		| UNION attribute_list_opt
+				{ $$ = DeclarationNode::Union; }
+		;
+
+field_declaration_list:
+		field_declaration
+				{ $$ = $1; }
+		| field_declaration_list field_declaration
+				{ $$ = $1->appendList( $2 ); }
+		;
+
+field_declaration:
+		new_field_declaring_list ';'					// CFA, new style field declaration
+		| EXTENSION new_field_declaring_list ';'		// GCC
+				{ $$ = $2; }
+		| field_declaring_list ';'
+		| EXTENSION field_declaring_list ';'			// GCC
+				{ $$ = $2; }
+		;
+
+new_field_declaring_list:								// CFA, new style field declaration
+		new_abstract_declarator_tuple					// CFA, no field name
+		| new_abstract_declarator_tuple no_attr_identifier_or_typedef_name
+				{ $$ = $1->addName( $2 ); }
+		| new_field_declaring_list ',' no_attr_identifier_or_typedef_name
+				{ $$ = $1->appendList( $1->cloneType( $3 ) ); }
+		| new_field_declaring_list ','					// CFA, no field name
+				{ $$ = $1->appendList( $1->cloneType( 0 ) ); }
+		;
+
+field_declaring_list:
+		type_specifier field_declarator
+				{ $$ = $2->addType( $1 ); }
+		| field_declaring_list ',' attribute_list_opt field_declarator
+				{ $$ = $1->appendList( $1->cloneBaseType( $4 ) ); }
+		;
+
+field_declarator:
+		// empty
+				{ $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
+		| bit_subrange_size								// no field name
+				{ $$ = DeclarationNode::newBitfield( $1 ); }
+		| variable_declarator bit_subrange_size_opt
+				// A semantic check is required to ensure bit_subrange only appears on base type int.
+				{ $$ = $1->addBitfield( $2 ); }
+		| typedef_redeclarator bit_subrange_size_opt
+				// A semantic check is required to ensure bit_subrange only appears on base type int.
+				{ $$ = $1->addBitfield( $2 ); }
+		| variable_abstract_declarator					// CFA, no field name
+		;
+
+bit_subrange_size_opt:
+		// empty
+				{ $$ = 0; }
+		| bit_subrange_size
+				{ $$ = $1; }
+		;
+
+bit_subrange_size:
+		':' constant_expression
+				{ $$ = $2; }
+		;
+
+enum_key:
+		ENUM attribute_list_opt
+		;
+
+enum_name:
+		enum_key '{' enumerator_list comma_opt '}'
+				{ $$ = DeclarationNode::newEnum( 0, $3 ); }
+		| enum_key no_attr_identifier_or_typedef_name '{' enumerator_list comma_opt '}'
+				{ $$ = DeclarationNode::newEnum( $2, $4 ); }
+		| enum_key no_attr_identifier_or_typedef_name
+				{ $$ = DeclarationNode::newEnum( $2, 0 ); }
+		;
+
+enumerator_list:
+		no_attr_identifier_or_typedef_name enumerator_value_opt
+				{ $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
+		| enumerator_list ',' no_attr_identifier_or_typedef_name enumerator_value_opt
+				{ $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
+		;
+
+enumerator_value_opt:
+		// empty
+				{ $$ = 0; }
+		| '=' constant_expression
+				{ $$ = $2; }
+		;
+
+// Minimum of one parameter after which ellipsis is allowed only at the end.
+
+new_parameter_type_list_opt:							// CFA
+		// empty
+				{ $$ = 0; }
+		| new_parameter_type_list
+		;
+
+new_parameter_type_list:								// CFA, abstract + real
+		new_abstract_parameter_list
+		| new_parameter_list
+		| new_parameter_list pop ',' push new_abstract_parameter_list
+				{ $$ = $1->appendList( $5 ); }
+		| new_abstract_parameter_list pop ',' push ELLIPSIS
+				{ $$ = $1->addVarArgs(); }
+		| new_parameter_list pop ',' push ELLIPSIS
+				{ $$ = $1->addVarArgs(); }
+		;
+
+new_parameter_list:										// CFA
+				// To obtain LR(1) between new_parameter_list and new_abstract_tuple, the last
+				// new_abstract_parameter_list is factored out from new_parameter_list, flattening the rules
+				// to get lookahead to the ']'.
+		new_parameter_declaration
+		| new_abstract_parameter_list pop ',' push new_parameter_declaration
+				{ $$ = $1->appendList( $5 ); }
+		| new_parameter_list pop ',' push new_parameter_declaration
+				{ $$ = $1->appendList( $5 ); }
+		| new_parameter_list pop ',' push new_abstract_parameter_list pop ',' push new_parameter_declaration
+				{ $$ = $1->appendList( $5 )->appendList( $9 ); }
+		;
+
+new_abstract_parameter_list:							// CFA, new & old style abstract
+		new_abstract_parameter_declaration
+		| new_abstract_parameter_list pop ',' push new_abstract_parameter_declaration
+				{ $$ = $1->appendList( $5 ); }
+		;
+
+parameter_type_list_opt:
+		// empty
+				{ $$ = 0; }
+		| parameter_type_list
+		;
+
+parameter_type_list:
+		parameter_list
+		| parameter_list pop ',' push ELLIPSIS
+				{ $$ = $1->addVarArgs(); }
+		;
+
+parameter_list:											// abstract + real
+		abstract_parameter_declaration
+		| parameter_declaration
+		| parameter_list pop ',' push abstract_parameter_declaration
+				{ $$ = $1->appendList( $5 ); }
+		| parameter_list pop ',' push parameter_declaration
+				{ $$ = $1->appendList( $5 ); }
+		;
+
+// Provides optional identifier names (abstract_declarator/variable_declarator), no initialization, different
+// semantics for typedef name by using typedef_parameter_redeclarator instead of typedef_redeclarator, and
+// function prototypes.
+
+new_parameter_declaration:								// CFA, new & old style parameter declaration
+		parameter_declaration
+		| new_identifier_parameter_declarator_no_tuple identifier_or_typedef_name assignment_opt
+				{ $$ = $1->addName( $2 ); }
+		| new_abstract_tuple identifier_or_typedef_name assignment_opt
+				// To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator).
+				{ $$ = $1->addName( $2 ); }
+		| type_qualifier_list new_abstract_tuple identifier_or_typedef_name assignment_opt
+				{ $$ = $2->addName( $3 )->addQualifiers( $1 ); }
+		| new_function_specifier
+		;
+
+new_abstract_parameter_declaration:						// CFA, new & old style parameter declaration
+		abstract_parameter_declaration
+		| new_identifier_parameter_declarator_no_tuple
+		| new_abstract_tuple
+				// To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator).
+		| type_qualifier_list new_abstract_tuple
+				{ $$ = $2->addQualifiers( $1 ); }
+		| new_abstract_function
+		;
+
+parameter_declaration:
+		declaration_specifier identifier_parameter_declarator assignment_opt
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) );
+				}
+		| declaration_specifier typedef_parameter_redeclarator assignment_opt
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					$$ = $2->addType( $1 )->addInitializer( new InitializerNode($3) );
+				}
+		;
+
+abstract_parameter_declaration:
+		declaration_specifier
+		| declaration_specifier abstract_parameter_declarator
+				{ $$ = $2->addType( $1 ); }
+		;
+
+// ISO/IEC 9899:1999 Section 6.9.1(6) : "An identifier declared as a typedef name shall not be redeclared as a
+// parameter." Because the scope of the K&R-style parameter-list sees the typedef first, the following is
+// based only on identifiers.  The ANSI-style parameter-list can redefine a typedef name.
+
+identifier_list:										// K&R-style parameter list => no types
+		no_attr_identifier
+				{ $$ = DeclarationNode::newName( $1 ); }
+		| identifier_list ',' no_attr_identifier
+				{ $$ = $1->appendList( DeclarationNode::newName( $3 ) ); }
+		;
+
+identifier_or_typedef_name:
+		identifier
+		| TYPEDEFname
+		| TYPEGENname
+		;
+
+no_01_identifier_or_typedef_name:
+		no_01_identifier
+		| TYPEDEFname
+		| TYPEGENname
+		;
+
+no_attr_identifier_or_typedef_name:
+		no_attr_identifier
+		| TYPEDEFname
+		| TYPEGENname
+		;
+
+type_name_no_function:									// sizeof, alignof, cast (constructor)
+		new_abstract_declarator_tuple					// CFA
+		| type_specifier
+		| type_specifier variable_abstract_declarator
+				{ $$ = $2->addType( $1 ); }
+		;
+
+type_name:												// typeof, assertion
+		new_abstract_declarator_tuple					// CFA
+		| new_abstract_function							// CFA
+		| type_specifier
+		| type_specifier abstract_declarator
+				{ $$ = $2->addType( $1 ); }
+		;
+
+initializer_opt:
+		// empty
+				{ $$ = 0; }
+		| '=' initializer								{ $$ = $2; }
+		;
+
+initializer:
+		assignment_expression							{ $$ = new InitializerNode($1); }
+		| '{' initializer_list comma_opt '}'			{ $$ = new InitializerNode($2, true); }
+		;
+
+initializer_list:
+		initializer
+		| designation initializer						{ $$ = $2->set_designators( $1 ); }
+		| initializer_list ',' initializer				{ $$ = (InitializerNode *)( $1->set_link($3) ); }
+		| initializer_list ',' designation initializer
+				{ $$ = (InitializerNode *)( $1->set_link( $4->set_designators($3) ) ); }
+		;
+
+// There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem is
+// use of '=' to separator the designator from the initializer value, as in:
+//
+//		int x[10] = { [1] = 3 };
+//
+// The string "[1] = 3" can be parsed as a designator assignment or a tuple assignment.  To disambiguate this
+// case, CFA changes the syntax from "=" to ":" as the separator between the designator and initializer. GCC
+// does uses ":" for field selection. The optional use of the "=" in GCC, or in this case ":", cannot be
+// supported either due to shift/reduce conflicts
+
+designation:
+		designator_list ':'								// C99, CFA uses ":" instead of "="
+		| no_attr_identifier_or_typedef_name ':'		// GCC, field name
+						{ $$ = new VarRefNode( $1 ); }
+		;
+
+designator_list:										// C99
+		designator
+		| designator_list designator						{ $$ = (ExpressionNode *)($1->set_link( $2 )); }
+		;
+
+designator:
+		'.' no_attr_identifier_or_typedef_name			// C99, field name
+				{ $$ = new VarRefNode( $2 ); }
+		| '[' push assignment_expression pop ']'		// C99, single array element
+				// assignment_expression used instead of constant_expression because of shift/reduce conflicts
+				// with tuple.
+				{ $$ = $3; }
+		| '[' push subrange pop ']'						// CFA, multiple array elements
+				{ $$ = $3; }
+		| '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $3, $5); }
+		| '.' '[' push field_list pop ']'				// CFA, tuple field selector
+				{ $$ = $4; }
+		;
+
+// The CFA type system is based on parametric polymorphism, the ability to declare functions with type
+// parameters, rather than an object-oriented type system. This required four groups of extensions:
+//
+// Overloading: function, data, and operator identifiers may be overloaded.
+//
+// Type declarations: "type" is used to generate new types for declaring objects. Similarly, "dtype" is used
+//     for object and incomplete types, and "ftype" is used for function types. Type declarations with
+//     initializers provide definitions of new types. Type declarations with storage class "extern" provide
+//     opaque types.
+//
+// Polymorphic functions: A forall clause declares a type parameter. The corresponding argument is inferred at
+//     the call site. A polymorphic function is not a template; it is a function, with an address and a type.
+//
+// Specifications and Assertions: Specifications are collections of declarations parameterized by one or more
+//     types. They serve many of the purposes of abstract classes, and specification hierarchies resemble
+//     subclass hierarchies. Unlike classes, they can define relationships between types.  Assertions declare
+//     that a type or types provide the operations declared by a specification.  Assertions are normally used
+//     to declare requirements on type arguments of polymorphic functions.
+
+typegen_declaration_specifier:							// CFA
+		typegen_type_specifier
+		| declaration_qualifier_list typegen_type_specifier
+				{ $$ = $2->addQualifiers( $1 ); }
+		| typegen_declaration_specifier storage_class	// remaining OBSOLESCENT (see 2)
+				{ $$ = $1->addQualifiers( $2 ); }
+		| typegen_declaration_specifier storage_class type_qualifier_list
+				{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
+		;
+
+typegen_type_specifier:									// CFA
+		TYPEGENname '(' type_name_list ')'
+				{ $$ = DeclarationNode::newFromTypeGen( $1, $3 ); }
+		| type_qualifier_list TYPEGENname '(' type_name_list ')'
+				{ $$ = DeclarationNode::newFromTypeGen( $2, $4 )->addQualifiers( $1 ); }
+		| typegen_type_specifier type_qualifier
+				{ $$ = $1->addQualifiers( $2 ); }
+		;
+
+type_parameter_list:									// CFA
+		type_parameter assignment_opt
+		| type_parameter_list ',' type_parameter assignment_opt
+				{ $$ = $1->appendList( $3 ); }
+		;
+
+type_parameter:											// CFA
+		type_class no_attr_identifier_or_typedef_name
+				{ typedefTable.addToEnclosingScope(*($2), TypedefTable::TD); }
+		  assertion_list_opt
+				{ $$ = DeclarationNode::newTypeParam( $1, $2 )->addAssertions( $4 ); }
+		| type_specifier identifier_parameter_declarator
+		;
+
+type_class:												// CFA
+		TYPE
+				{ $$ = DeclarationNode::Type; }
+		| DTYPE
+				{ $$ = DeclarationNode::Ftype; }
+		| FTYPE
+				{ $$ = DeclarationNode::Dtype; }
+		;
+
+assertion_list_opt:										// CFA
+		// empty
+				{ $$ = 0; }
+		| assertion_list_opt assertion
+				{ $$ = $1 == 0 ? $2 : $1->appendList( $2 ); }
+		;
+
+assertion:												// CFA
+		'|' no_attr_identifier_or_typedef_name '(' type_name_list ')'
+				{
+					typedefTable.openContext( *($2) );
+					$$ = DeclarationNode::newContextUse( $2, $4 );
+				}
+		| '|' '{' push context_declaration_list '}'
+				{ $$ = $4; }
+		| '|' '(' push type_parameter_list pop ')' '{' push context_declaration_list '}' '(' type_name_list ')'
+				{ $$ = 0; }
+		;
+
+type_name_list:											// CFA
+		type_name
+				{ $$ = new TypeValueNode( $1 ); }
+		| assignment_expression
+		| type_name_list ',' type_name
+				{ $$ = (ExpressionNode *)($1->set_link(new TypeValueNode( $3 ))); }
+		| type_name_list ',' assignment_expression
+				{ $$ = (ExpressionNode *)($1->set_link($3)); }
+		;
+
+type_declaring_list:									// CFA
+		TYPE type_declarator
+				{ $$ = $2; }
+		| storage_class_list TYPE type_declarator
+				{ $$ = $3->addQualifiers( $1 ); }
+		| type_declaring_list ',' type_declarator
+				{ $$ = $1->appendList( $3->copyStorageClasses( $1 ) ); }
+		;
+
+type_declarator:										// CFA
+		type_declarator_name assertion_list_opt
+				{ $$ = $1->addAssertions( $2 ); }
+		| type_declarator_name assertion_list_opt '=' type_name
+				{ $$ = $1->addAssertions( $2 )->addType( $4 ); }
+		;
+
+type_declarator_name:									// CFA
+		no_attr_identifier_or_typedef_name
+				{
+					typedefTable.addToEnclosingScope(*($1), TypedefTable::TD);
+					$$ = DeclarationNode::newTypeDecl( $1, 0 );
+				}
+		| no_01_identifier_or_typedef_name '(' push type_parameter_list pop ')'
+				{
+					typedefTable.addToEnclosingScope(*($1), TypedefTable::TG);
+					$$ = DeclarationNode::newTypeDecl( $1, $4 );
+				}
+		;
+
+context_specifier:										// CFA
+		CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{' '}'
+				{
+					typedefTable.addToEnclosingScope(*($2), TypedefTable::ID );
+					$$ = DeclarationNode::newContext( $2, $5, 0 );
+				}
+		| CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{'
+				{
+					typedefTable.enterContext( *($2) );
+					typedefTable.enterScope();
+				}
+		  context_declaration_list '}'
+				{
+					typedefTable.leaveContext();
+					typedefTable.addToEnclosingScope(*($2), TypedefTable::ID );
+					$$ = DeclarationNode::newContext( $2, $5, $10 );
+				}
+		;
+
+context_declaration_list:								// CFA
+		context_declaration
+		| context_declaration_list push context_declaration
+				{ $$ = $1->appendList( $3 ); }
+		;
+
+context_declaration:									// CFA
+		new_context_declaring_list pop ';'
+		| context_declaring_list pop ';'
+		;
+
+new_context_declaring_list:								// CFA
+		new_variable_specifier
+				{
+					typedefTable.addToEnclosingScope2( TypedefTable::ID );
+					$$ = $1;
+				}
+		| new_function_specifier
+				{
+					typedefTable.addToEnclosingScope2( TypedefTable::ID );
+					$$ = $1;
+				}
+		| new_context_declaring_list pop ',' push identifier_or_typedef_name
+				{
+					typedefTable.addToEnclosingScope2( *($5), TypedefTable::ID );
+					$$ = $1->appendList( $1->cloneType( $5 ) );
+				}
+		;
+
+context_declaring_list:									// CFA
+		type_specifier declarator
+				{
+					typedefTable.addToEnclosingScope2( TypedefTable::ID );
+					$$ = $2->addType( $1 );
+				}
+		| context_declaring_list pop ',' push declarator
+				{
+					typedefTable.addToEnclosingScope2( TypedefTable::ID );
+					$$ = $1->appendList( $1->cloneBaseType( $5 ) );
+				}
+		;
+
+//***************************** EXTERNAL DEFINITIONS *****************************
+
+translation_unit:
+		// empty
+				{}										// empty input file
+		| external_definition_list
+				{
+					if ( theTree ) {
+						theTree->appendList( $1 );
+					} else {
+						theTree = $1;
+					}
+				}
+		;
+
+external_definition_list:
+		external_definition
+		| external_definition_list push external_definition
+				{ $$ = ($1 != NULL ) ? $1->appendList( $3 ) : $3; }
+		;
+
+external_definition_list_opt:
+		// empty
+				{ $$ = 0; }
+		| external_definition_list
+		;
+
+external_definition:
+		declaration
+		| function_definition
+		| asm_statement									// GCC, global assembler statement
+				{}
+		| EXTERN STRINGliteral
+				{
+					linkageStack.push( linkage );
+					linkage = LinkageSpec::fromString( *$2 );
+				}
+		  '{' external_definition_list_opt '}'			// C++-style linkage specifier
+				{
+					linkage = linkageStack.top();
+					linkageStack.pop();
+					$$ = $5;
+				}
+		| EXTENSION external_definition
+				{ $$ = $2; }
+		;
+
+function_definition:
+		new_function_specifier compound_statement		// CFA
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $1->addFunctionBody( $2 );
+				}
+		| declaration_qualifier_list new_function_specifier compound_statement // CFA
+				// declaration_qualifier_list also includes type_qualifier_list, so a semantic check is
+				// necessary to preclude them as a type_qualifier cannot appear in this context.
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
+				}
+
+		| declaration_specifier function_declarator compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $2->addFunctionBody( $3 )->addType( $1 );
+				}
+
+				// These rules are a concession to the "implicit int" type_specifier because there is a
+				// significant amount of code with functions missing a type-specifier on the return type.
+				// Parsing is possible because function_definition does not appear in the context of an
+				// expression (nested functions would preclude this concession). A function prototype
+				// declaration must still have a type_specifier. OBSOLESCENT (see 1)
+		| function_declarator compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $1->addFunctionBody( $2 );
+				}
+		| type_qualifier_list function_declarator compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
+				}
+		| declaration_qualifier_list function_declarator compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
+				}
+		| declaration_qualifier_list type_qualifier_list function_declarator compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $3->addFunctionBody( $4 )->addQualifiers( $2 )->addQualifiers( $1 );
+				}
+
+				// Old-style K&R function definition, OBSOLESCENT (see 4)
+		| declaration_specifier old_function_declarator push old_declaration_list_opt compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addType( $1 );
+				}
+		| old_function_declarator push old_declaration_list_opt compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $1->addOldDeclList( $3 )->addFunctionBody( $4 );
+				}
+		| type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
+				}
+
+				// Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4)
+		| declaration_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
+				}
+		| declaration_qualifier_list type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
+				{
+					typedefTable.addToEnclosingScope( TypedefTable::ID );
+					typedefTable.leaveScope();
+					$$ = $3->addOldDeclList( $5 )->addFunctionBody( $6 )->addQualifiers( $2 )->addQualifiers( $1 );
+				}
+		;
+
+declarator:
+		variable_declarator
+		| function_declarator
+		| typedef_redeclarator
+		;
+
+subrange:
+		constant_expression '~' constant_expression		// CFA, integer subrange
+				{ $$ = new CompositeExprNode(new OperatorNode(OperatorNode::Range), $1, $3); }
+		;
+
+asm_name_opt:											// GCC
+		// empty
+		| ASM '(' string_literal_list ')' attribute_list_opt
+		;
+
+attribute_list_opt:										// GCC
+		// empty
+		| attribute_list
+		;
+
+attribute_list:											// GCC
+		attribute
+		| attribute_list attribute
+		;
+
+attribute:												// GCC
+		ATTRIBUTE '(' '(' attribute_parameter_list ')' ')'
+		;
+
+attribute_parameter_list:								// GCC
+		attrib
+		| attribute_parameter_list ',' attrib
+		;
+
+attrib:													// GCC
+		// empty
+		| any_word
+		| any_word '(' comma_expression_opt ')'
+		;
+
+any_word:												// GCC
+		identifier_or_typedef_name {}
+		| storage_class_name {}
+		| basic_type_name {}
+		| type_qualifier {}
+		;
+
+// ============================================================================
+// The following sections are a series of grammar patterns used to parse declarators. Multiple patterns are
+// necessary because the type of an identifier in wrapped around the identifier in the same form as its usage
+// in an expression, as in:
+//
+//		int (*f())[10] { ... };
+//		... (*f())[3] += 1;		// definition mimics usage
+//
+// Because these patterns are highly recursive, changes at a lower level in the recursion require copying some
+// or all of the pattern. Each of these patterns has some subtle variation to ensure correct syntax in a
+// particular context.
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// The set of valid declarators before a compound statement for defining a function is less than the set of
+// declarators to define a variable or function prototype, e.g.:
+//
+//		valid declaration		invalid definition
+//		-----------------		------------------
+//		int f;						int f {}
+//		int *f;						int *f {}
+//		int f[10];				int f[10] {}
+//		int (*f)(int);				int (*f)(int) {}
+//
+// To preclude this syntactic anomaly requires separating the grammar rules for variable and function
+// declarators, hence variable_declarator and function_declarator.
+// ----------------------------------------------------------------------------
+
+// This pattern parses a declaration of a variable that is not redefining a typedef name. The pattern
+// precludes declaring an array of functions versus a pointer to an array of functions.
+
+variable_declarator:
+		paren_identifier attribute_list_opt
+		| variable_ptr
+		| variable_array attribute_list_opt
+		| variable_function attribute_list_opt
+		;
+
+paren_identifier:
+		identifier
+				{
+					typedefTable.setNextIdentifier( *($1) );
+					$$ = DeclarationNode::newName( $1 );
+				}
+		| '(' paren_identifier ')'						// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+variable_ptr:
+		'*' variable_declarator
+				{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		| '*' type_qualifier_list variable_declarator
+				{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+		| '(' variable_ptr ')'
+				{ $$ = $2; }
+		;
+
+variable_array:
+		paren_identifier array_dimension
+				{ $$ = $1->addArray( $2 ); }
+		| '(' variable_ptr ')' array_dimension
+				{ $$ = $2->addArray( $4 ); }
+		| '(' variable_array ')' multi_array_dimension	// redundant parenthesis
+				{ $$ = $2->addArray( $4 ); }
+		| '(' variable_array ')'						// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+variable_function:
+		'(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $2->addParamList( $6 ); }
+		| '(' variable_function ')'						// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+// This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot
+// be nested, there is no context where a function definition can redefine a typedef name. To allow nested
+// functions requires further separation of variable and function declarators in typedef_redeclarator.  The
+// pattern precludes returning arrays and functions versus pointers to arrays and functions.
+
+function_declarator:
+		function_no_ptr attribute_list_opt
+		| function_ptr
+		| function_array attribute_list_opt
+		;
+
+function_no_ptr:
+		paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $1->addParamList( $4 ); }
+		| '(' function_ptr ')' '(' push parameter_type_list_opt pop ')'
+				{ $$ = $2->addParamList( $6 ); }
+		| '(' function_no_ptr ')'						// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+function_ptr:
+		'*' function_declarator
+				{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		| '*' type_qualifier_list function_declarator
+				{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+		| '(' function_ptr ')'
+				{ $$ = $2; }
+		;
+
+function_array:
+		'(' function_ptr ')' array_dimension
+				{ $$ = $2->addArray( $4 ); }
+		| '(' function_array ')' multi_array_dimension	// redundant parenthesis
+				{ $$ = $2->addArray( $4 ); }
+		| '(' function_array ')'						// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+// This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4) that is not redefining a
+// typedef name (see function_declarator for additional comments). The pattern precludes returning arrays and
+// functions versus pointers to arrays and functions.
+
+old_function_declarator:
+		old_function_no_ptr
+		| old_function_ptr
+		| old_function_array
+		;
+
+old_function_no_ptr:
+		paren_identifier '(' identifier_list ')'		// function_declarator handles empty parameter
+				{ $$ = $1->addIdList( $3 ); }
+		| '(' old_function_ptr ')' '(' identifier_list ')'
+				{ $$ = $2->addIdList( $5 ); }
+		| '(' old_function_no_ptr ')'					// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+old_function_ptr:
+		'*' old_function_declarator
+				{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		| '*' type_qualifier_list old_function_declarator
+				{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+		| '(' old_function_ptr ')'
+				{ $$ = $2; }
+		;
+
+old_function_array:
+		'(' old_function_ptr ')' array_dimension
+				{ $$ = $2->addArray( $4 ); }
+		| '(' old_function_array ')' multi_array_dimension // redundant parenthesis
+				{ $$ = $2->addArray( $4 ); }
+		| '(' old_function_array ')'					// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+// This pattern parses a declaration for a variable or function prototype that redefines a typedef name, e.g.:
+//
+//		typedef int foo;
+//		{
+//		   int foo; // redefine typedef name in new scope
+//		}
+//
+// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and
+// returning arrays and functions versus pointers to arrays and functions.
+
+typedef_redeclarator:
+		paren_typedef attribute_list_opt
+		| typedef_ptr
+		| typedef_array attribute_list_opt
+		| typedef_function attribute_list_opt
+		;
+
+paren_typedef:
+		TYPEDEFname
+				{
+				typedefTable.setNextIdentifier( *($1) );
+				$$ = DeclarationNode::newName( $1 );
+				}
+		| '(' paren_typedef ')'
+				{ $$ = $2; }
+		;
+
+typedef_ptr:
+		'*' typedef_redeclarator
+				{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		| '*' type_qualifier_list typedef_redeclarator
+				{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+		| '(' typedef_ptr ')'
+				{ $$ = $2; }
+		;
+
+typedef_array:
+		paren_typedef array_dimension
+				{ $$ = $1->addArray( $2 ); }
+		| '(' typedef_ptr ')' array_dimension
+				{ $$ = $2->addArray( $4 ); }
+		| '(' typedef_array ')' multi_array_dimension	// redundant parenthesis
+				{ $$ = $2->addArray( $4 ); }
+		| '(' typedef_array ')'							// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+typedef_function:
+		paren_typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $1->addParamList( $4 ); }
+		| '(' typedef_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $2->addParamList( $6 ); }
+		| '(' typedef_function ')'						// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+// This pattern parses a declaration for a parameter variable or function prototype that is not redefining a
+// typedef name and allows the C99 array options, which can only appear in a parameter list.  The pattern
+// precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
+// and functions versus pointers to arrays and functions.
+
+identifier_parameter_declarator:
+		paren_identifier attribute_list_opt
+		| identifier_parameter_ptr
+		| identifier_parameter_array attribute_list_opt
+		| identifier_parameter_function attribute_list_opt
+		;
+
+identifier_parameter_ptr:
+		'*' identifier_parameter_declarator
+				{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		| '*' type_qualifier_list identifier_parameter_declarator
+				{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+		| '(' identifier_parameter_ptr ')'
+				{ $$ = $2; }
+		;
+
+identifier_parameter_array:
+		paren_identifier array_parameter_dimension
+				{ $$ = $1->addArray( $2 ); }
+		| '(' identifier_parameter_ptr ')' array_dimension
+				{ $$ = $2->addArray( $4 ); }
+		| '(' identifier_parameter_array ')' multi_array_dimension // redundant parenthesis
+				{ $$ = $2->addArray( $4 ); }
+		| '(' identifier_parameter_array ')'			// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+identifier_parameter_function:
+		paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $1->addParamList( $4 ); }
+		| '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $2->addParamList( $6 ); }
+		| '(' identifier_parameter_function ')'			// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+// This pattern parses a declaration for a parameter variable or function prototype that is redefining a
+// typedef name, e.g.:
+//
+//		typedef int foo;
+//		int f( int foo ); // redefine typedef name in new scope
+//
+// and allows the C99 array options, which can only appear in a parameter list.  In addition, the pattern
+// handles the special meaning of parenthesis around a typedef name:
+//
+//		ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in
+//		parentheses is taken to be an abstract declarator that specifies a function with a single parameter,
+//		not as redundant parentheses around the identifier."
+//
+// which precludes the following cases:
+//
+//		typedef float T;
+//		int f( int ( T [5] ) );						// see abstract_parameter_declarator
+//		int g( int ( T ( int ) ) );				// see abstract_parameter_declarator
+//		int f( int f1( T a[5] ) );				// see identifier_parameter_declarator
+//		int g( int g1( T g2( int p ) ) );		// see identifier_parameter_declarator
+//
+// In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type
+// list, and not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes
+// declaring an array of functions versus a pointer to an array of functions, and returning arrays and
+// functions versus pointers to arrays and functions.
+
+typedef_parameter_redeclarator:
+		typedef attribute_list_opt
+		| typedef_parameter_ptr
+		| typedef_parameter_array attribute_list_opt
+		| typedef_parameter_function attribute_list_opt
+		;
+
+typedef:
+		TYPEDEFname
+				{
+					typedefTable.setNextIdentifier( *($1) );
+					$$ = DeclarationNode::newName( $1 );
+				}
+		;
+
+typedef_parameter_ptr:
+		'*' typedef_parameter_redeclarator
+				{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		| '*' type_qualifier_list typedef_parameter_redeclarator
+				{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+		| '(' typedef_parameter_ptr ')'
+				{ $$ = $2; }
+		;
+
+typedef_parameter_array:
+		typedef array_parameter_dimension
+				{ $$ = $1->addArray( $2 ); }
+		| '(' typedef_parameter_ptr ')' array_parameter_dimension
+				{ $$ = $2->addArray( $4 ); }
+		;
+
+typedef_parameter_function:
+		typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $1->addParamList( $4 ); }
+		| '(' typedef_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $2->addParamList( $6 ); }
+		;
+
+// This pattern parses a declaration of an abstract variable or function prototype, i.e., there is no
+// identifier to which the type applies, e.g.:
+//
+//		sizeof( int );
+//		sizeof( int [10] );
+//
+// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and
+// returning arrays and functions versus pointers to arrays and functions.
+
+abstract_declarator:
+		abstract_ptr
+		| abstract_array attribute_list_opt
+		| abstract_function attribute_list_opt
+		;
+
+abstract_ptr:
+		'*'
+				{ $$ = DeclarationNode::newPointer( 0 ); }
+		| '*' type_qualifier_list
+				{ $$ = DeclarationNode::newPointer( $2 ); }
+		| '*' abstract_declarator
+				{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		| '*' type_qualifier_list abstract_declarator
+				{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+		| '(' abstract_ptr ')'
+				{ $$ = $2; }
+		;
+
+abstract_array:
+		array_dimension
+		| '(' abstract_ptr ')' array_dimension
+				{ $$ = $2->addArray( $4 ); }
+		| '(' abstract_array ')' multi_array_dimension	// redundant parenthesis
+				{ $$ = $2->addArray( $4 ); }
+		| '(' abstract_array ')'						// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+abstract_function:
+		'(' push parameter_type_list_opt pop ')'		// empty parameter list OBSOLESCENT (see 3)
+				{ $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); }
+		| '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $2->addParamList( $6 ); }
+		| '(' abstract_function ')'						// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+array_dimension:
+				// Only the first dimension can be empty.
+		'[' push pop ']'
+				{ $$ = DeclarationNode::newArray( 0, 0, false ); }
+		| '[' push pop ']' multi_array_dimension
+				{ $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $5 ); }
+		| multi_array_dimension
+		;
+
+multi_array_dimension:
+		'[' push assignment_expression pop ']'
+				{ $$ = DeclarationNode::newArray( $3, 0, false ); }
+		| '[' push '*' pop ']'								// C99
+				{ $$ = DeclarationNode::newVarArray( 0 ); }
+		| multi_array_dimension '[' push assignment_expression pop ']'
+				{ $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
+		| multi_array_dimension '[' push '*' pop ']'		// C99
+				{ $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
+		;
+
+// This pattern parses a declaration of a parameter abstract variable or function prototype, i.e., there is no
+// identifier to which the type applies, e.g.:
+//
+//		int f( int );			// abstract variable parameter; no parameter name specified
+//		int f( int (int) );		// abstract function-prototype parameter; no parameter name specified
+//
+// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and
+// returning arrays and functions versus pointers to arrays and functions.
+
+abstract_parameter_declarator:
+		abstract_parameter_ptr
+		| abstract_parameter_array attribute_list_opt
+		| abstract_parameter_function attribute_list_opt
+		;
+
+abstract_parameter_ptr:
+		'*'
+				{ $$ = DeclarationNode::newPointer( 0 ); }
+		| '*' type_qualifier_list
+				{ $$ = DeclarationNode::newPointer( $2 ); }
+		| '*' abstract_parameter_declarator
+				{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		| '*' type_qualifier_list abstract_parameter_declarator
+				{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+		| '(' abstract_parameter_ptr ')'
+				{ $$ = $2; }
+		;
+
+abstract_parameter_array:
+		array_parameter_dimension
+		| '(' abstract_parameter_ptr ')' array_parameter_dimension
+				{ $$ = $2->addArray( $4 ); }
+		| '(' abstract_parameter_array ')' multi_array_dimension // redundant parenthesis
+				{ $$ = $2->addArray( $4 ); }
+		| '(' abstract_parameter_array ')'				// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+abstract_parameter_function:
+		'(' push parameter_type_list_opt pop ')'		// empty parameter list OBSOLESCENT (see 3)
+				{ $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); }
+		| '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $2->addParamList( $6 ); }
+		| '(' abstract_parameter_function ')'			// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+array_parameter_dimension:
+				// Only the first dimension can be empty or have qualifiers.
+		array_parameter_1st_dimension
+		| array_parameter_1st_dimension multi_array_dimension
+				{ $$ = $1->addArray( $2 ); }
+		| multi_array_dimension
+		;
+
+// The declaration of an array parameter has additional syntax over arrays in normal variable declarations:
+//
+//		ISO/IEC 9899:1999 Section 6.7.5.2(1) : "The optional type qualifiers and the keyword static shall
+//		appear only in a declaration of a function parameter with an array type, and then only in the
+//		outermost array type derivation."
+
+array_parameter_1st_dimension:
+		'[' push pop ']'
+				{ $$ = DeclarationNode::newArray( 0, 0, false ); }
+		// multi_array_dimension handles the '[' '*' ']' case
+		| '[' push type_qualifier_list '*' pop ']'		// remaining C99
+				{ $$ = DeclarationNode::newVarArray( $3 ); }
+		| '[' push type_qualifier_list pop ']'
+				{ $$ = DeclarationNode::newArray( 0, $3, false ); }
+		// multi_array_dimension handles the '[' assignment_expression ']' case
+		| '[' push type_qualifier_list assignment_expression pop ']'
+				{ $$ = DeclarationNode::newArray( $4, $3, false ); }
+		| '[' push STATIC type_qualifier_list_opt assignment_expression pop ']'
+				{ $$ = DeclarationNode::newArray( $5, $4, true ); }
+		| '[' push type_qualifier_list STATIC assignment_expression pop ']'
+				{ $$ = DeclarationNode::newArray( $5, $3, true ); }
+		;
+
+// This pattern parses a declaration of an abstract variable, i.e., there is no identifier to which the type
+// applies, e.g.:
+//
+//		sizeof( int ); // abstract variable; no identifier name specified
+//
+// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and
+// returning arrays and functions versus pointers to arrays and functions.
+
+variable_abstract_declarator:
+		variable_abstract_ptr
+		| variable_abstract_array attribute_list_opt
+		| variable_abstract_function attribute_list_opt
+		;
+
+variable_abstract_ptr:
+		'*'
+				{ $$ = DeclarationNode::newPointer( 0 ); }
+		| '*' type_qualifier_list
+				{ $$ = DeclarationNode::newPointer( $2 ); }
+		| '*' variable_abstract_declarator
+				{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		| '*' type_qualifier_list variable_abstract_declarator
+				{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+		| '(' variable_abstract_ptr ')'
+				{ $$ = $2; }
+		;
+
+variable_abstract_array:
+		array_dimension
+		| '(' variable_abstract_ptr ')' array_dimension
+				{ $$ = $2->addArray( $4 ); }
+		| '(' variable_abstract_array ')' multi_array_dimension // redundant parenthesis
+				{ $$ = $2->addArray( $4 ); }
+		| '(' variable_abstract_array ')'				// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+variable_abstract_function:
+		'(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+				{ $$ = $2->addParamList( $6 ); }
+		| '(' variable_abstract_function ')'			// redundant parenthesis
+				{ $$ = $2; }
+		;
+
+// This pattern parses a new-style declaration for a parameter variable or function prototype that is either
+// an identifier or typedef name and allows the C99 array options, which can only appear in a parameter list.
+
+new_identifier_parameter_declarator_tuple:				// CFA
+		new_identifier_parameter_declarator_no_tuple
+		| new_abstract_tuple
+		| type_qualifier_list new_abstract_tuple
+				{ $$ = $2->addQualifiers( $1 ); }
+		;
+
+new_identifier_parameter_declarator_no_tuple:			// CFA
+		new_identifier_parameter_ptr
+		| new_identifier_parameter_array
+		;
+
+new_identifier_parameter_ptr:							// CFA
+		'*' type_specifier
+				{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+		| type_qualifier_list '*' type_specifier
+				{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+		| '*' new_abstract_function
+				{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+		| type_qualifier_list '*' new_abstract_function
+				{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+		| '*' new_identifier_parameter_declarator_tuple
+				{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+		| type_qualifier_list '*' new_identifier_parameter_declarator_tuple
+				{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+		;
+
+new_identifier_parameter_array:							// CFA
+				// Only the first dimension can be empty or have qualifiers. Empty dimension must be factored
+				// out due to shift/reduce conflict with new-style empty (void) function return type.
+		'[' push pop ']' type_specifier
+				{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		| new_array_parameter_1st_dimension type_specifier
+				{ $$ = $2->addNewArray( $1 ); }
+		| '[' push pop ']' multi_array_dimension type_specifier
+				{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		| new_array_parameter_1st_dimension multi_array_dimension type_specifier
+				{ $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
+		| multi_array_dimension type_specifier
+				{ $$ = $2->addNewArray( $1 ); }
+		| '[' push pop ']' new_identifier_parameter_ptr
+				{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		| new_array_parameter_1st_dimension new_identifier_parameter_ptr
+				{ $$ = $2->addNewArray( $1 ); }
+		| '[' push pop ']' multi_array_dimension new_identifier_parameter_ptr
+				{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		| new_array_parameter_1st_dimension multi_array_dimension new_identifier_parameter_ptr
+				{ $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
+		| multi_array_dimension new_identifier_parameter_ptr
+				{ $$ = $2->addNewArray( $1 ); }
+		;
+
+new_array_parameter_1st_dimension:
+		'[' push type_qualifier_list '*' pop ']'		// remaining C99
+				{ $$ = DeclarationNode::newVarArray( $3 ); }
+		| '[' push type_qualifier_list assignment_expression pop ']'
+				{ $$ = DeclarationNode::newArray( $4, $3, false ); }
+		| '[' push declaration_qualifier_list assignment_expression pop ']'
+				// declaration_qualifier_list must be used because of shift/reduce conflict with
+				// assignment_expression, so a semantic check is necessary to preclude them as a
+				// type_qualifier cannot appear in this context.
+				{ $$ = DeclarationNode::newArray( $4, $3, true ); }
+		| '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']'
+				{ $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); }
+		;
+
+// This pattern parses a new-style declaration of an abstract variable or function prototype, i.e., there is
+// no identifier to which the type applies, e.g.:
+//
+//		[int] f( int );				// abstract variable parameter; no parameter name specified
+//		[int] f( [int] (int) );		// abstract function-prototype parameter; no parameter name specified
+//
+// These rules need LR(3):
+//
+//		new_abstract_tuple identifier_or_typedef_name
+//		'[' new_parameter_list ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')'
+//
+// since a function return type can be syntactically identical to a tuple type:
+//
+//		[int, int] t;
+//		[int, int] f( int );
+//
+// Therefore, it is necessary to look at the token after identifier_or_typedef_name to know when to reduce
+// new_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow the
+// necessary lookahead. To accomplish this, new_abstract_declarator has an entry point without tuple, and
+// tuple declarations are duplicated when appearing with new_function_specifier.
+
+new_abstract_declarator_tuple:							// CFA
+		new_abstract_tuple
+		| type_qualifier_list new_abstract_tuple
+				{ $$ = $2->addQualifiers( $1 ); }
+		| new_abstract_declarator_no_tuple
+		;
+
+new_abstract_declarator_no_tuple:						// CFA
+		new_abstract_ptr
+		| new_abstract_array
+		;
+
+new_abstract_ptr:										// CFA
+		'*' type_specifier
+				{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+		| type_qualifier_list '*' type_specifier
+				{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+		| '*' new_abstract_function
+				{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+		| type_qualifier_list '*' new_abstract_function
+				{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+		| '*' new_abstract_declarator_tuple
+				{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+		| type_qualifier_list '*' new_abstract_declarator_tuple
+				{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+		;
+
+new_abstract_array:										// CFA
+				// Only the first dimension can be empty. Empty dimension must be factored out due to
+				// shift/reduce conflict with empty (void) function return type.
+		'[' push pop ']' type_specifier
+				{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		| '[' push pop ']' multi_array_dimension type_specifier
+				{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		| multi_array_dimension type_specifier
+				{ $$ = $2->addNewArray( $1 ); }
+		| '[' push pop ']' new_abstract_ptr
+				{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		| '[' push pop ']' multi_array_dimension new_abstract_ptr
+				{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		| multi_array_dimension new_abstract_ptr
+				{ $$ = $2->addNewArray( $1 ); }
+		;
+
+new_abstract_tuple:										// CFA
+		'[' push new_abstract_parameter_list pop ']'
+				{ $$ = DeclarationNode::newTuple( $3 ); }
+		;
+
+new_abstract_function:									// CFA
+		'[' push pop ']' '(' new_parameter_type_list_opt ')'
+				{ $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $6, 0 ); }
+		| new_abstract_tuple '(' push new_parameter_type_list_opt pop ')'
+				{ $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); }
+		| new_function_return '(' push new_parameter_type_list_opt pop ')'
+				{ $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); }
+		;
+
+// 1) ISO/IEC 9899:1999 Section 6.7.2(2) : "At least one type specifier shall be given in the declaration
+//    specifiers in each declaration, and in the specifier-qualifier list in each structure declaration and
+//    type name."
+//
+// 2) ISO/IEC 9899:1999 Section 6.11.5(1) : "The placement of a storage-class specifier other than at the
+//    beginning of the declaration specifiers in a declaration is an obsolescent feature."
+//
+// 3) ISO/IEC 9899:1999 Section 6.11.6(1) : "The use of function declarators with empty parentheses (not
+//    prototype-format parameter type declarators) is an obsolescent feature."
+//
+// 4) ISO/IEC 9899:1999 Section 6.11.7(1) : "The use of function definitions with separate parameter
+//    identifier and declaration lists (not prototype-format parameter type and identifier declarators) is an
+//    obsolescent feature.
+
+//************************* MISCELLANEOUS ********************************
+
+comma_opt:												// redundant comma
+		// empty
+		| ','
+		;
+
+assignment_opt:
+		// empty
+				{ $$ = 0; }
+		| '=' assignment_expression
+				{ $$ = $2; }
+		;
+
+%%
+// ----end of grammar----
+
+void yyerror( char *string ) {
+	using std::cout;
+	using std::endl;
+	cout << "Error ";
+	if ( yyfilename ) {
+		cout << "in file " << yyfilename << " ";
+	}
+	cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << endl;
+}
+
+// Local Variables: //
+// fill-column: 110 //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/Parser/lex.cc
===================================================================
--- src/Parser/lex.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ 	(revision )
@@ -1,3658 +1,0 @@
-
-#line 3 "Parser/lex.cc"
-
-#define  YY_INT_ALIGNED short int
-
-/* A lexical scanner generated by flex */
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 35
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-/* First, we deal with  platform-specific or compiler-specific issues. */
-
-/* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-/* end standard C headers. */
-
-/* flex integer type definitions */
-
-#ifndef FLEXINT_H
-#define FLEXINT_H
-
-/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types. 
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#include <inttypes.h>
-typedef int8_t flex_int8_t;
-typedef uint8_t flex_uint8_t;
-typedef int16_t flex_int16_t;
-typedef uint16_t flex_uint16_t;
-typedef int32_t flex_int32_t;
-typedef uint32_t flex_uint32_t;
-#else
-typedef signed char flex_int8_t;
-typedef short int flex_int16_t;
-typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t; 
-typedef unsigned short int flex_uint16_t;
-typedef unsigned int flex_uint32_t;
-
-/* Limits of integral types. */
-#ifndef INT8_MIN
-#define INT8_MIN               (-128)
-#endif
-#ifndef INT16_MIN
-#define INT16_MIN              (-32767-1)
-#endif
-#ifndef INT32_MIN
-#define INT32_MIN              (-2147483647-1)
-#endif
-#ifndef INT8_MAX
-#define INT8_MAX               (127)
-#endif
-#ifndef INT16_MAX
-#define INT16_MAX              (32767)
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX              (2147483647)
-#endif
-#ifndef UINT8_MAX
-#define UINT8_MAX              (255U)
-#endif
-#ifndef UINT16_MAX
-#define UINT16_MAX             (65535U)
-#endif
-#ifndef UINT32_MAX
-#define UINT32_MAX             (4294967295U)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-#ifdef __cplusplus
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
-
-#else	/* ! __cplusplus */
-
-/* C99 requires __STDC__ to be defined as 1. */
-#if defined (__STDC__)
-
-#define YY_USE_CONST
-
-#endif	/* defined (__STDC__) */
-#endif	/* ! __cplusplus */
-
-#ifdef YY_USE_CONST
-#define yyconst const
-#else
-#define yyconst
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an unsigned
- * integer for use as an array index.  If the signed char is negative,
- * we want to instead treat it as an 8-bit unsigned char, hence the
- * double cast.
- */
-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
-
-/* Enter a start condition.  This macro really ought to take a parameter,
- * but we do it the disgusting crufty way forced on us by the ()-less
- * definition of BEGIN.
- */
-#define BEGIN (yy_start) = 1 + 2 *
-
-/* Translate the current start state into a value that can be later handed
- * to BEGIN to return to the state.  The YYSTATE alias is for lex
- * compatibility.
- */
-#define YY_START (((yy_start) - 1) / 2)
-#define YYSTATE YY_START
-
-/* Action number for EOF rule of a given start state. */
-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-
-/* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart(yyin  )
-
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-/* The state buf must be large enough to hold one state per character in the main buffer.
- */
-#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-extern int yyleng;
-
-extern FILE *yyin, *yyout;
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-
-    /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
-     *       access to the local variable yy_act. Since yyless() is a macro, it would break
-     *       existing scanners that call yyless() from OUTSIDE yylex. 
-     *       One obvious solution it to make yy_act a global. I tried that, and saw
-     *       a 5% performance hit in a non-yylineno scanner, because yy_act is
-     *       normally declared as a register variable-- so it is not worth it.
-     */
-    #define  YY_LESS_LINENO(n) \
-            do { \
-                int yyl;\
-                for ( yyl = n; yyl < yyleng; ++yyl )\
-                    if ( yytext[yyl] == '\n' )\
-                        --yylineno;\
-            }while(0)
-    
-/* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		*yy_cp = (yy_hold_char); \
-		YY_RESTORE_YY_MORE_OFFSET \
-		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-		} \
-	while ( 0 )
-
-#define unput(c) yyunput( c, (yytext_ptr)  )
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#ifndef YY_STRUCT_YY_BUFFER_STATE
-#define YY_STRUCT_YY_BUFFER_STATE
-struct yy_buffer_state
-	{
-	FILE *yy_input_file;
-
-	char *yy_ch_buf;		/* input buffer */
-	char *yy_buf_pos;		/* current position in input buffer */
-
-	/* Size of input buffer in bytes, not including room for EOB
-	 * characters.
-	 */
-	yy_size_t yy_buf_size;
-
-	/* Number of characters read into yy_ch_buf, not including EOB
-	 * characters.
-	 */
-	int yy_n_chars;
-
-	/* Whether we "own" the buffer - i.e., we know we created it,
-	 * and can realloc() it to grow it, and should free() it to
-	 * delete it.
-	 */
-	int yy_is_our_buffer;
-
-	/* Whether this is an "interactive" input source; if so, and
-	 * if we're using stdio for input, then we want to use getc()
-	 * instead of fread(), to make sure we stop fetching input after
-	 * each newline.
-	 */
-	int yy_is_interactive;
-
-	/* Whether we're considered to be at the beginning of a line.
-	 * If so, '^' rules will be active on the next match, otherwise
-	 * not.
-	 */
-	int yy_at_bol;
-
-    int yy_bs_lineno; /**< The line count. */
-    int yy_bs_column; /**< The column count. */
-    
-	/* Whether to try to fill the input buffer when we reach the
-	 * end of it.
-	 */
-	int yy_fill_buffer;
-
-	int yy_buffer_status;
-
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
-	/* When an EOF's been seen but there's still some text to process
-	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-	 * shouldn't try reading from the input source any more.  We might
-	 * still have a bunch of tokens to match, though, because of
-	 * possible backing-up.
-	 *
-	 * When we actually see the EOF, we change the status to "new"
-	 * (via yyrestart()), so that the user can continue scanning by
-	 * just pointing yyin at a new input file.
-	 */
-#define YY_BUFFER_EOF_PENDING 2
-
-	};
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-/* Stack of input buffers. */
-static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
-static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
-static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
-
-/* We provide macros for accessing buffer states in case in the
- * future we want to put the buffer states in a more general
- * "scanner state".
- *
- * Returns the top of the stack, or NULL.
- */
-#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
-                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
-                          : NULL)
-
-/* Same as previous macro, but useful when we know that the buffer stack is not
- * NULL or when we need an lvalue. For internal use only.
- */
-#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
-
-/* yy_hold_char holds the character lost when yytext is formed. */
-static char yy_hold_char;
-static int yy_n_chars;		/* number of characters read into yy_ch_buf */
-int yyleng;
-
-/* Points to current character in buffer. */
-static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 0;		/* whether we need to initialize */
-static int yy_start = 0;	/* start state number */
-
-/* Flag which is used to allow yywrap()'s to do buffer switches
- * instead of setting up a fresh yyin.  A bit of a hack ...
- */
-static int yy_did_buffer_switch_on_eof;
-
-void yyrestart (FILE *input_file  );
-void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
-YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
-void yy_delete_buffer (YY_BUFFER_STATE b  );
-void yy_flush_buffer (YY_BUFFER_STATE b  );
-void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
-void yypop_buffer_state (void );
-
-static void yyensure_buffer_stack (void );
-static void yy_load_buffer_state (void );
-static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
-
-#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
-
-YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
-YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
-YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
-
-void *yyalloc (yy_size_t  );
-void *yyrealloc (void *,yy_size_t  );
-void yyfree (void *  );
-
-#define yy_new_buffer yy_create_buffer
-
-#define yy_set_interactive(is_interactive) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){ \
-        yyensure_buffer_stack (); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer(yyin,YY_BUF_SIZE ); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-	}
-
-#define yy_set_bol(at_bol) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){\
-        yyensure_buffer_stack (); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer(yyin,YY_BUF_SIZE ); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-	}
-
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-
-/* Begin user sect3 */
-
-typedef unsigned char YY_CHAR;
-
-FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
-
-typedef int yy_state_type;
-
-extern int yylineno;
-
-int yylineno = 1;
-
-extern char *yytext;
-#define yytext_ptr yytext
-
-static yy_state_type yy_get_previous_state (void );
-static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
-static int yy_get_next_buffer (void );
-static void yy_fatal_error (yyconst char msg[]  );
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
-	(yytext_ptr) = yy_bp; \
-	yyleng = (size_t) (yy_cp - yy_bp); \
-	(yy_hold_char) = *yy_cp; \
-	*yy_cp = '\0'; \
-	(yy_c_buf_p) = yy_cp;
-
-#define YY_NUM_RULES 171
-#define YY_END_OF_BUFFER 172
-/* This struct is not used in this scanner,
-   but its presence is necessary. */
-struct yy_trans_info
-	{
-	flex_int32_t yy_verify;
-	flex_int32_t yy_nxt;
-	};
-static yyconst flex_int16_t yy_accept[826] =
-    {   0,
-        0,    0,    0,    0,    0,    0,  108,  108,  111,  111,
-      172,  170,    7,    9,    8,  131,  110,   95,  136,  139,
-      107,  118,  119,  134,  132,  122,  133,  125,  135,  100,
-      101,  102,  123,  124,  141,  143,  142,  144,  170,   95,
-      116,  170,  117,  137,   95,   97,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,  120,  140,  121,  138,    7,  170,    4,    4,  171,
-       98,  171,   99,  108,  109,  115,  111,  112,    7,    9,
-        0,    8,  148,  166,   95,    0,  160,  130,  153,  161,
-      158,  145,  156,  146,  157,  155,    0,  105,    3,    0,
-
-      159,  105,  103,    0,    0,  103,  103,    0,    0,  103,
-      102,  102,  102,    0,  102,  128,  129,  127,  149,  151,
-      147,  152,  150,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,   96,    0,
-      110,  107,   95,    0,    0,  163,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   36,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   53,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,  162,
-      154,    7,    0,    0,    0,    2,    0,    5,   98,    0,
-
-        0,    0,  108,    0,  114,  113,  113,    0,    0,    0,
-      111,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,  126,  105,    0,  105,
-        0,    0,    6,    0,  103,    0,    0,    0,  105,    0,
-      103,  103,  103,  103,    0,  104,    0,    0,  102,  102,
-      102,  102,    0,  164,  165,    0,  168,  167,    0,    0,
-        0,   96,    0,    0,    0,    0,    0,    0,    0,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   14,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-
-       95,   95,   95,   95,   95,   47,   95,   95,   95,   60,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       95,   95,   82,   95,   95,   95,   95,   95,   95,   95,
-        0,    0,    0,    0,    0,    0,    0,    0,  113,    0,
-        0,    0,    0,    0,  113,    0,    0,  169,    0,    0,
-        0,    0,    0,    0,    0,    0,  105,    0,    0,    0,
-      105,    0,  103,  103,    0,    0,  104,  104,    0,  104,
-        0,  104,  102,  102,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-
-       95,   95,   95,   95,   95,   95,   20,   95,   23,   95,
-       25,   95,   95,   95,   95,   95,   95,   39,   40,   95,
-       95,   95,   95,   95,   95,   95,   52,   95,   63,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-       83,   95,   95,   90,   95,   95,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-      113,    0,    0,    0,    0,    0,  105,    0,    0,    0,
-        0,    0,    0,  104,  104,    0,  106,    0,  104,  104,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,   95,   95,   21,   95,   95,   95,   95,
-
-       95,   95,   95,   15,   95,   95,   95,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   22,   24,   95,
-       30,   95,   95,   95,   95,   38,   95,   95,   95,   45,
-       95,   95,   50,   95,   95,   95,   95,   95,   71,   95,
-       95,   95,   95,   95,   81,   95,   95,   88,   95,   95,
-       94,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-      106,    0,    0,  104,  106,  106,    0,  104,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,   95,    0,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
-
-       95,   95,   95,   95,   95,   55,   95,   95,   95,   95,
-       95,   95,   95,   26,   95,   95,   95,   37,   42,   95,
-       95,   48,   95,   57,   64,   95,   95,   70,   72,   75,
-       76,   78,   79,   95,   85,   95,   95,    0,    1,    0,
-        0,    0,    0,    0,    0,   98,    0,    0,    0,  113,
-        0,    0,    0,    0,  106,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,   95,   95,   17,   95,   95,
-       95,   95,   95,   95,   95,   16,   95,   95,   31,   95,
-       95,   95,   95,   95,   95,   95,   95,   95,   95,   33,
-       95,   35,   95,   44,   49,   95,   95,   84,   95,   95,
-
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,   10,   11,   27,   51,   95,   95,   95,
-       95,   95,   95,   95,   95,   95,   95,   56,   58,   61,
-       95,   95,   73,   86,   95,   34,   43,   66,   67,   89,
-       91,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,   95,   65,   95,   95,   12,   95,   28,
-       32,   95,   95,   95,   62,   95,   95,   95,   95,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,   54,   95,   95,   95,   95,   95,   95,   46,
-       59,   68,   74,   87,   92,    0,    0,    0,    0,    0,
-
-        0,    0,    0,   95,   95,   13,   18,   29,   95,   95,
-       95,    0,    0,   95,   95,   95,   95,   69,   93,   95,
-       80,   19,   41,   77,    0
-    } ;
-
-static yyconst flex_int32_t yy_ec[256] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-        4,    5,    6,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    7,    8,    9,   10,   11,   12,   13,   14,   15,
-       16,   17,   18,   19,   20,   21,   22,   23,   24,   25,
-       26,   26,   26,   26,   26,   27,   28,   29,   30,   31,
-       32,   33,   34,   35,   36,   37,   38,   39,   40,   41,
-       42,   11,   43,   11,   11,   44,   11,   45,   11,   46,
-       11,   11,   47,   48,   49,   11,   11,   50,   11,   11,
-       51,   52,   53,   54,   55,   56,   57,   58,   59,   60,
-
-       61,   62,   63,   64,   65,   11,   66,   67,   68,   69,
-       70,   71,   11,   72,   73,   74,   75,   76,   77,   78,
-       79,   80,   81,   82,   83,   84,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1
-    } ;
-
-static yyconst flex_int32_t yy_meta[85] =
-    {   0,
-        1,    1,    2,    1,    1,    1,    1,    1,    3,    1,
-        4,    1,    1,    5,    1,    1,    1,    1,    1,    1,
-        6,    1,    7,    7,    7,    7,    7,    7,    1,    1,
-        1,    1,    1,    1,    1,    8,    8,    8,    8,    8,
-        8,    4,    4,    9,    4,   10,    4,    4,    9,    4,
-        1,   11,    1,    1,   12,    1,    8,    8,    8,    8,
-        8,    8,    4,    4,    4,    4,    9,    4,    4,    4,
-       10,    4,    4,    4,    9,    4,    4,    4,    4,    4,
-        1,    1,    1,    1
-    } ;
-
-static yyconst flex_int16_t yy_base[999] =
-    {   0,
-        0,   83, 2266, 2265,   93,    0,  175,  176,  177,  178,
-     2281, 2568,  189, 2568,  195,   54, 2568, 2223,   59,  171,
-     2568, 2568, 2568,   55,  186, 2568,  189,  187,  202,  214,
-      272,    0, 2241, 2568,  214, 2241,  150,  340, 2215,  222,
-     2568,  157, 2568, 2234,  277, 2568,  192,  133,  196,  198,
-      204,  271,  155,  218,  181,  200,  266,  238,  337,  224,
-      227, 2568,  223, 2568, 2231,  372,  400, 2568, 2237, 2568,
-     2206,  213, 2568,    0, 2568,  427,    0, 2568,  363, 2568,
-      381,  393, 2568,  498, 2205,  229, 2568, 2568, 2568, 2568,
-     2568, 2217, 2568, 2216, 2568, 2568, 2228,  558, 2568, 2240,
-
-     2568,  603,  385,  443,  419,  259,  239,  280,  399,  406,
-        0,  305,  240,  335,  411, 2568, 2568, 2568, 2210, 2568,
-     2568, 2568, 2209, 2188,  215,  277, 2203,  310,  383,  384,
-      327,  425,  380,  399, 2180,  448, 2130,  458, 2160,  288,
-     2568, 2568,  486, 2151, 2150, 2568,  420,  423,  439,  456,
-      445,  455,  460,  329,  483,  469,  462,  467,  480,  494,
-      396,  471,  472,  487,  470,  513,  489,  506,  508,  509,
-      386,  510,  516, 2152,  520,  522,  518,  541,  526,  543,
-      540,  551,  549,  553,  565,  598,  572,  581,  557, 2568,
-     2568,  669,  659, 2195,  686, 2568,  692, 2568, 2145,  559,
-
-     2141, 2135,    0,  649, 2568, 2568,  679, 2134, 2133, 2127,
-        0, 2149,  535,  606,  607,  674,  635,  625,  646,  664,
-      689, 2146,  692,  693, 2119, 2118, 2568,  712,  723, 2568,
-     2117, 2165, 2568,  714,    0,  555,  705,  759,  765,  776,
-      593, 2568, 2123, 2099,    0,  784, 2141,  787,  632, 2568,
-     2116, 2087,  798, 2568, 2568, 2119, 2568, 2568,  710,  725,
-     2099, 2094,  720, 2090, 2089, 2085,    0, 2084,    0,  712,
-      548,  710,  766,  767,  597,  745,  711,  777,  764,  788,
-      720,  783,  792,  713,  639,  789,  611,  793, 2086,  794,
-      791,  795,  810,  800,  805,  813,  814,  361,  818,  815,
-
-      816,  821,  825,  822,  826,  828,  829,  836,  838, 2080,
-      841,  842,  843,  839,  844,  845,  846,  849,  847,  853,
-      855,  860, 2079,  859,  905,  864,  866,  872,  870,  871,
-      933,  930, 2075, 2069, 2068,    0, 2067,    0,  920,  924,
-     2061,    0, 2060,    0, 2059,    0, 2074, 2568,  919,  920,
-     2054, 2051,    0, 2045,    0,  935,  941,  953,  963,  974,
-      986,  996, 2568, 2568,  960,  961, 1013,  989, 1047,  926,
-     1045,  968, 2568, 2568, 2044, 2043, 2037,    0, 2036,    0,
-     2035,    0, 2014,    0,  874,  873,  987,  903,  931,  932,
-      984,  920,  994,  995,  974,  976, 1009, 1024, 1017,  992,
-
-     1029, 1027,  952, 1030, 1034, 1040, 2016, 1031, 2011, 1047,
-     2010, 1049, 1043, 1054, 1038, 1056, 1057, 2009, 2003, 1052,
-     1058, 1062, 1069, 1073, 1074, 1075, 2002, 1076, 2001, 1078,
-     1079, 1082, 1083, 1085, 1081, 1086, 1092, 1089, 1099,  583,
-     1108, 1095, 1087, 1995, 1097, 1109, 1160, 1991,    0, 1990,
-        0, 1984,    0, 1983,    0, 1149, 1982,    0, 1978,    0,
-     1977, 1976, 1972,    0, 1971,    0, 1156, 1162, 1207, 1121,
-     1218, 1149, 1120, 1144, 2568, 1224, 1230, 1241, 1981, 1954,
-     1959, 1957,    0, 1953,    0, 1951,    0, 1945,    0, 1944,
-        0, 1943,    0, 1125, 1144, 1940, 1146, 1149, 1147, 1153,
-
-     1150, 1218, 1162, 1110, 1156, 1155, 1164, 1211, 1224, 1225,
-     1226,  164, 1228, 1208, 1170, 1232, 1238, 1939, 1938, 1235,
-     1932, 1227, 1231, 1234, 1242, 1931, 1246, 1247, 1250, 1930,
-     1252, 1255, 1924, 1257, 1261, 1254, 1256, 1258, 1923, 1264,
-      709, 1271, 1262, 1268, 1922, 1273, 1277, 1916, 1274, 1279,
-     1915, 1963, 1905,    0, 1904,    0, 1903,    0, 1897,    0,
-     1896,    0, 1895,    0, 1891,    0, 1890,    0, 1322, 1328,
-     1334, 1345, 1889, 2568, 1356, 2568, 1380, 2568, 1885,    0,
-     1884,    0, 1883,    0, 1850,    0,    0,    0, 1852,    0,
-     1342, 1281, 1315, 1322, 1333, 1289, 1283, 1338, 1340, 1336,
-
-     1361, 1343, 1341, 1362, 1364, 1365, 1367, 1397, 1373, 1314,
-     1376, 1375, 1377, 1847, 1378, 1380, 1382, 1846, 1845, 1381,
-     1387, 1839, 1389, 1838, 1837, 1396, 1391, 1833, 1832, 1831,
-     1827, 1826, 1825, 1392, 1818, 1407, 1394, 1846, 2568, 1793,
-        0, 1792,    0,    0,    0, 1791,    0,    0,    0, 2568,
-        0,    0,    0,    0, 1446, 1452, 1497, 1787,    0, 1786,
-        0,    0,    0,    0, 1782, 1408, 1430, 1784, 1410, 1432,
-     1437, 1411, 1412, 1443, 1433, 1783, 1447, 1445, 1457, 1413,
-     1476, 1463, 1450, 1477, 1475, 1474, 1480, 1479, 1481, 1779,
-     1482, 1778, 1483, 1777, 1773, 1464, 1485, 1772, 1490, 1486,
-
-        0,    0, 1768, 1764, 1763, 1762, 1537,    0, 1758, 1757,
-     1756, 1752, 1751, 1753, 1749, 1748, 1747, 1496, 1497, 1499,
-     1502, 1493, 1492, 1501, 1518, 1519, 1547, 1738, 1522, 1737,
-     1523, 1458, 1528, 1530, 1524, 1734, 1733, 1732, 1715, 1707,
-     1706, 1700, 1694, 1691, 1683, 1682, 1663, 1662, 1661, 1653,
-     1652, 1613, 1612, 1529, 1614, 1534, 1535, 1538, 1536, 1542,
-     1613, 1543, 1562, 1546, 1612, 1544, 1548, 1554, 1550, 1608,
-     1607, 1606, 1605, 1604, 1603, 1602, 1601, 1600, 1598, 1597,
-     1567, 1566, 1505, 1552, 1560, 1565, 1563, 1571, 1564, 1286,
-     1285, 1575, 1188, 1158, 1576, 1001,  997,  950,  901,  753,
-
-      752,  642,  556, 1577, 1580,  519, 1584,  475, 1588, 1589,
-     1590,  471,  407, 1582, 1583, 1594, 1596,  353,  298, 1595,
-      274,  234,  233,  165, 2568, 1669, 1681, 1693, 1702, 1711,
-     1723, 1732, 1744, 1756, 1768, 1775, 1784, 1790, 1796, 1802,
-     1808, 1814, 1820, 1826, 1832, 1838, 1850, 1856, 1859, 1866,
-     1868, 1874, 1880, 1886, 1888, 1894, 1899, 1911, 1923, 1929,
-     1935, 1941, 1947, 1949, 1955, 1957, 1963, 1965, 1971, 1973,
-     1979, 1981, 1987, 1989, 1995, 1997, 2003, 2010, 2016, 2022,
-     2028, 2034, 2036, 2042, 2044, 2050, 2052, 2058, 2063, 2075,
-     2081, 2087, 2089, 2095, 2097, 2103, 2105, 2111, 2113, 2119,
-
-     2121, 2127, 2129, 2135, 2141, 2143, 2149, 2151, 2157, 2163,
-     2169, 2171, 2177, 2179, 2185, 2187, 2193, 2195, 2201, 2203,
-     2209, 2214, 2226, 2232, 2238, 2240, 2246, 2248, 2254, 2256,
-     2262, 2264, 2270, 2272, 2278, 2280, 2286, 2288, 2294, 2296,
-     2302, 2308, 2310, 2316, 2318, 2324, 2326, 2332, 2334, 2336,
-     2341, 2347, 2355, 2361, 2367, 2369, 2375, 2377, 2379, 2384,
-     2390, 2392, 2394, 2396, 2398, 2400, 2402, 2404, 2410, 2412,
-     2418, 2420, 2422, 2424, 2426, 2435, 2441, 2443, 2445, 2451,
-     2457, 2463, 2465, 2471, 2477, 2483, 2489, 2495, 2501, 2507,
-     2513, 2519, 2525, 2531, 2537, 2543, 2549, 2555
-
-    } ;
-
-static yyconst flex_int16_t yy_def[999] =
-    {   0,
-      825,    1,  826,  826,  825,    5,  827,  827,  828,  828,
-      825,  825,  825,  825,  825,  825,  825,  829,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,   31,  825,  825,  825,  825,  825,  825,  830,  829,
-      825,  825,  825,  825,  829,  825,  829,  829,  829,  829,
-      829,  829,  829,  829,  829,  829,  829,  829,  829,  829,
-      829,  825,  825,  825,  825,  825,  831,  825,  825,  825,
-      832,  825,  825,  833,  825,  825,  834,  825,  825,  825,
-      825,  825,  825,  825,  829,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  835,
-
-      825,  825,   30,  825,  825,  825,  825,  836,   30,  825,
-       31,  825,  825,   31,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  837,  825,
-      825,  825,  829,  838,  839,  825,  829,  829,  829,  829,
-      829,  829,  829,  829,  829,  829,  829,  829,  829,  829,
-      829,  829,  829,  829,  829,  829,  829,  829,  829,  829,
-      829,  829,  829,  829,  829,  829,  829,  829,  829,  829,
-      829,  829,  829,  829,  829,  829,  829,  829,  829,  825,
-      825,  825,  831,  831,  831,  825,  831,  825,  832,  825,
-
-      840,  841,  833,  825,  825,  825,  825,  842,  843,  844,
-      834,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  845,  846,  825,  825,  825,  825,
-      228,  847,  825,  825,  103,  103,  825,  825,  825,  825,
-      825,  825,  825,  825,  848,  849,  850,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  837,  825,  851,  852,  853,  854,  855,  856,  857,
-      857,  857,  857,  857,  857,  857,  857,  857,  857,  857,
-      857,  857,  857,  857,  857,  857,  857,  857,  857,  857,
-      857,  857,  857,  857,  857,  857,  857,  857,  857,  857,
-
-      857,  857,  857,  857,  857,  857,  857,  857,  857,  857,
-      857,  857,  857,  857,  857,  857,  857,  857,  857,  857,
-      857,  857,  857,  857,  857,  857,  857,  857,  857,  857,
-      858,  859,  860,  861,  862,  863,  864,  865,  825,  825,
-      866,  867,  868,  869,  870,  871,  825,  825,  825,  825,
-      825,  872,  873,  874,  875,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  876,  877,  878,  825,  825,  825,
-      878,  825,  825,  825,  879,  880,  881,  882,  883,  884,
-      885,  886,  887,  888,  889,  889,  889,  889,  889,  889,
-      889,  889,  889,  889,  889,  889,  889,  889,  889,  889,
-
-      889,  889,  889,  889,  889,  889,  889,  889,  889,  889,
-      889,  889,  889,  889,  889,  889,  889,  889,  889,  889,
-      889,  889,  889,  889,  889,  889,  889,  889,  889,  889,
-      889,  889,  889,  889,  889,  889,  889,  889,  889,  889,
-      889,  889,  889,  889,  889,  889,  890,  891,  892,  893,
-      894,  895,  896,  897,  898,  825,  899,  900,  901,  902,
-      903,  903,  904,  905,  906,  907,  825,  825,  825,  908,
-      825,  908,  825,  825,  825,  825,  825,  825,  825,  825,
-      909,  910,  911,  912,  913,  914,  915,  916,  917,  918,
-      919,  920,  921,  922,  922,  922,  922,  922,  922,  922,
-
-      922,  922,  922,  922,  922,  922,  922,  922,  922,  922,
-      922,  922,  922,  922,  922,  922,  922,  922,  922,  922,
-      922,  922,  922,  922,  922,  922,  922,  922,  922,  922,
-      922,  922,  922,  922,  922,  922,  922,  922,  922,  922,
-      922,  922,  922,  922,  922,  922,  922,  922,  922,  922,
-      922,  923,  924,  925,  926,  927,  928,  929,  930,  931,
-      932,  933,  934,  935,  936,  937,  938,  939,  825,  825,
-      825,  825,  940,  825,  825,  825,  825,  825,  941,  942,
-      943,  944,  945,  946,  947,  948,  949,  950,  951,  952,
-      951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
-
-      951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
-      951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
-      951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
-      951,  951,  951,  951,  951,  951,  951,  953,  825,  954,
-      955,  956,  957,  958,  959,  960,  961,  962,  963,  825,
-      964,  965,  966,  967,  825,  825,  825,  968,  969,  970,
-      971,  972,  973,  974,  975,  976,  976,  976,  976,  976,
-      976,  976,  976,  976,  976,  976,  976,  976,  976,  976,
-      976,  976,  976,  976,  976,  976,  976,  976,  976,  976,
-      976,  976,  976,  976,  976,  976,  976,  976,  976,  976,
-
-      977,  978,  956,  979,  980,  981,  825,  982,  968,  970,
-      983,  984,  975,  976,  976,  976,  976,  976,  976,  976,
-      976,  976,  976,  976,  976,  976,  976,  976,  976,  976,
-      976,  976,  976,  976,  976,  976,  976,  976,  976,  976,
-      976,  985,  986,  979,  987,  980,  988,  981,  989,  990,
-      983,  991,  984,  976,  976,  976,  976,  976,  976,  976,
-      976,  976,  976,  976,  976,  976,  976,  976,  976,  992,
-      985,  993,  986,  994,  987,  995,  988,  996,  989,  997,
-      990,  991,  976,  976,  976,  976,  976,  976,  976,  976,
-      976,  976,  976,  976,  976,  998,  992,  993,  994,  995,
-
-      970,  996,  997,  976,  976,  976,  976,  976,  976,  976,
-      976,  998,  970,  976,  976,  976,  976,  976,  976,  976,
-      976,  976,  976,  976,    0,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825
-
-    } ;
-
-static yyconst flex_int16_t yy_nxt[2653] =
-    {   0,
-       12,   13,   14,   15,   15,   15,   13,   16,   17,   12,
-       18,   19,   20,   21,   22,   23,   24,   25,   26,   27,
-       28,   29,   30,   31,   32,   32,   32,   32,   33,   34,
-       35,   36,   37,   38,   39,   18,   18,   18,   18,   18,
-       18,   18,   18,   40,   18,   18,   18,   18,   40,   18,
-       41,   42,   43,   44,   45,   46,   47,   48,   49,   50,
-       51,   52,   53,   18,   54,   18,   55,   18,   18,   18,
-       18,   56,   57,   58,   59,   60,   61,   18,   18,   18,
-       62,   63,   64,   65,   66,   83,   91,   84,   84,   66,
-       87,   88,   67,   70,   70,   70,   70,   70,   70,   70,
-
-       70,   70,   70,   71,   70,   70,   70,   70,   70,   70,
-       70,   70,   70,   70,   70,   70,   70,   70,   70,   70,
-       70,   70,   70,   70,   70,   70,   70,   70,   71,   71,
-       71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
-       71,   71,   71,   70,   72,   70,   70,   71,   73,   71,
-       71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
-       71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
-       71,   71,   71,   70,   70,   70,   70,   75,   75,   78,
-       78,  122,  123,   89,   86,   78,   78,  608,   75,   75,
-       79,   80,   81,   81,   81,   79,   81,   80,   82,   82,
-
-       82,   81,   90,   92,  158,  144,   86,   97,   94,   98,
-       98,   98,   98,   98,   98,   86,   86,   93,   99,   84,
-       95,   96,   84,  100,  173,  117,   76,   76,   76,   76,
-      141,  145,   86,  101,  102,  142,  103,  103,  103,  103,
-      104,  104,  118,   86,  119,  120,  256,   86,  257,   86,
-      176,   86,  159,  105,  190,   86,  177,  106,  162,  160,
-      178,  201,  107,  108,  156,  161,  157,  163,  109,   86,
-      165,  164,  166,   86,  105,   86,  143,  225,   86,  174,
-      110,  167,  243,  251,   86,   86,  175,  202,  107,   86,
-      189,  108,  102,  188,  111,  111,  111,  111,  111,  111,
-
-      245,  183,  241,  226,  191,  244,  252,  242,  256,  184,
-      257,  105,  147,  148,  149,  112,  185,   86,  150,  151,
-      113,  152,   86,  153,  154,   86,  114,  168,   86,  179,
-      180,  155,  105,  242,  247,  169,  264,  170,  115,  181,
-      171,  256,  182,  257,  172,  141,  113,  124,  249,   86,
-      142,  125,  126,  250,  127,  825,  128,  129,  256,  130,
-      257,  131,  265,  186,   79,   80,   81,   81,   81,   79,
-      132,  133,  134,  192,   80,   81,   81,   81,  192,  250,
-       86,  193,   81,   80,   81,   81,   81,   81,   86,  253,
-      135,  143,  278,  136,   81,   80,   82,   82,   82,   81,
-
-      258,  195,  196,  258,   86,  187,  195,  235,  235,  235,
-      235,  256,   86,  257,  256,  256,  257,  257,  416,  825,
-      137,  138,  197,  197,  197,  197,  197,  197,  204,  205,
-      256,  260,  257,  204,  825,  206,  238,   86,  238,  236,
-      206,  239,  239,  239,  239,  239,  239,   86,  825,  207,
-      207,  207,  207,  248,  242,  259,  256,  306,  257,  250,
-      206,  825,  825,  102,  296,  104,  104,  104,  104,  104,
-      104,   86,  241,  240,   86,  208,  825,  249,  206,  256,
-      242,  257,  105,  206,  206,  250,  270,  206,  206,  256,
-       86,  257,  272,  271,  141,  206,   86,  237,  206,  142,
-
-      206,  209,  206,  105,  210,  212,   86,   86,  273,  213,
-      214,   86,  275,   86,  215,  216,  274,  217,   86,  218,
-       86,   86,   86,   86,  276,  825,   86,  291,  219,  220,
-      221,   86,  297,  277,   86,  290,  289,   86,   86,  279,
-       86,  280,  300,  281,  282,   86,  298,  283,  222,  284,
-      294,  223,  292,  293,  285,  286,  287,   86,  288,   86,
-       86,   86,  302,  295,   86,  299,  347,   86,  348,   86,
-       86,   86,  303,   86,  312,  825,  304,   86,  305,  224,
-      228,  228,  228,  228,  228,  228,  309,  301,  307,  308,
-      311,   86,   86,  310,   86,  316,  319,  229,  230,   86,
-
-       86,  230,   86,  313,   86,  317,  141,  333,   86,  360,
-      825,  320,  231,  314,  315,  321,   86,  386,  229,  230,
-      322,  330,  318,   86,  230,   98,   98,   98,   98,   98,
-       98,  323,   86,  334,   86,  324,  326,  347,  347,  348,
-      348,  363,  229,  230,  327,  328,  230,  329,   86,   86,
-      204,  205,  325,  390,  348,  204,  347,  234,  348,  545,
-      195,  196,   86,  229,  230,  195,  347,  363,  348,  230,
-      192,   80,   81,   81,   81,  192,  349,  347,  193,  348,
-      373,  197,  197,  197,  197,  197,  197,  195,  196,  405,
-       86,  348,  195,  331,  196,  347,  825,  348,  331,  403,
-
-      332,  339,  339,  339,  339,  347,  373,  348,  197,  197,
-      197,  197,  197,  197,  197,  197,  197,  197,  197,  197,
-      347,  350,  348,  347,  347,  348,  348,  104,  104,  104,
-      104,  104,  104,  340,  228,  228,  228,  228,  228,  228,
-      356,  256,  356,  257,  105,  357,  357,  357,  357,  357,
-      357,  229,  230,  229,  230,  230,  256,  230,  257,  248,
-       86,   86,   86,   86,   86,  105,  231,  392,  375,  402,
-      630,   86,  229,  230,  229,  230,  385,  358,  230,  387,
-      230,  239,  239,  239,  239,  239,  239,  361,  361,  361,
-      361,  361,  361,  238,  376,  238,   86,  398,  239,  239,
-
-      239,  239,  239,  239,  366,  230,  813,  825,  230,  104,
-      104,  104,  104,  104,  104,   86,  391,   86,   86,  362,
-      111,  111,  111,  111,  111,  111,  230,  368,   86,  369,
-      394,  230,  370,  388,   86,  389,  395,  396,  371,   86,
-       86,  248,   86,   86,   86,   86,   86,  408,  393,  399,
-      372,   86,  253,  404,  369,  409,   86,  397,  370,  400,
-      401,   86,  406,  407,   86,   86,   86,   86,  410,   86,
-      415,  411,   86,   86,  412,  418,   86,   86,  422,   86,
-       86,  420,  423,  419,  424,  413,  414,   86,  417,   86,
-       86,  421,   86,   86,   86,   86,   86,   86,   86,  426,
-
-       86,  425,  428,  429,   86,  427,   86,  431,  430,  436,
-       86,   86,  432,  141,  435,   86,  434,   86,  433,  441,
-      437,   86,   86,   86,   86,   86,  445,  438,  439,  440,
-      443,  444,  196,  442,  331,  196,  494,  446,  194,  331,
-      495,  332,  206,  206,  206,  206,  339,  339,  339,  339,
-      347,  347,  348,  348,   86,  825,   86,  357,  357,  357,
-      357,  357,  357,  467,  467,  467,  467,  467,  467,  479,
-      356,   86,  356,  497,  456,  357,  357,  357,  357,  357,
-      357,  230,   86,   86,  230,  228,  228,  228,  228,  228,
-      228,  498,  480,  501,  499,  468,  235,  235,  235,  235,
-
-      104,  104,  230,   86,  825,  471,  471,  230,  361,  361,
-      361,  361,  361,  361,  472,  473,  475,  359,  361,  361,
-      361,  361,  361,  361,  514,   86,  230,   86,  360,  230,
-      471,  471,  474,  366,  474,   86,  230,  475,   86,  230,
-      362,  504,  475,   86,  500,   86,   86,  230,  510,  505,
-      469,  825,  230,  496,  502,  812,  368,  230,  369,  503,
-       86,  370,  230,  475,  476,  825,  476,  371,   86,  477,
-      477,  477,  477,  477,  477,   86,  506,  507,   86,  372,
-       86,   86,   86,  369,  513,   86,  509,  370,  368,   86,
-      369,   86,  515,  370,   86,  511,  518,  508,   86,  481,
-
-       86,  478,  512,   86,  516,   86,  517,   86,   86,   86,
-      519,  372,  524,   86,  522,  369,  521,  526,  523,  370,
-       86,  520,  525,  527,   86,   86,   86,   86,  529,   86,
-       86,  528,   86,   86,   86,  533,   86,   86,   86,  531,
-       86,  540,  530,   86,  534,  532,   86,  543,   86,  549,
-       86,  536,  535,  537,  538,  541,  542,  544,  539,   86,
-       86,   86,  196,  548,  600,  471,  471,  546,  552,  551,
-      550,  206,  206,  206,  206,  472,   86,  547,  467,  467,
-      467,  467,  467,  467,  467,  467,  467,  467,  467,  467,
-      471,  471,  574,  591,  471,   86,  230,   86,   86,  230,
-
-       86,   86,  230,  573,   86,  230,   86,   86,  592,   86,
-      468,  595,  593,   86,  597,   86,  569,  230,  574,  471,
-      594,   86,  230,  230,  599,  602,  596,  601,  230,  361,
-      361,  361,  361,  361,  361,  570,  603,  570,  611,   86,
-      571,  571,  571,  571,  571,  571,  477,  477,  477,  477,
-      477,  477,  575,  575,  575,  575,  575,  575,  476,   86,
-      476,  469,   86,  477,  477,  477,  477,  477,  477,   86,
-      576,  604,  572,  576,  598,   86,   86,   86,   86,   86,
-      605,  610,   86,   86,  577,   86,   86,  606,  609,   86,
-      607,  576,  612,   86,  613,  614,  576,   86,   86,  616,
-
-      617,   86,  618,   86,  615,   86,   86,   86,   86,   86,
-      620,  623,   86,   86,  619,   86,  621,  624,  622,   86,
-      627,  625,   86,  629,   86,   86,  628,  626,   86,  631,
-       86,  633,   86,  634,   86,  632,   86,   86,  635,  668,
-       86,  673,  636,  637,  467,  467,  467,  467,  467,  467,
-      571,  571,  571,  571,  571,  571,  655,  655,  655,  655,
-      655,  655,  570,  672,  570,   86,   86,  571,  571,  571,
-      571,  571,  571,   86,  576,  669,  569,  576,  575,  575,
-      575,  575,  575,  575,   86,  686,  670,   86,  656,   86,
-      676,   86,   86,   86,   86,  576,  576,  674,  666,  576,
-
-      576,  671,  575,  575,  575,  575,  575,  575,  675,  678,
-      577,  667,   86,   86,  679,   86,   86,  576,   86,  682,
-      576,  684,  576,  576,   86,  677,   86,   86,   86,   86,
-      680,   86,   86,   86,  657,  683,  687,  681,   86,  685,
-       86,  576,   86,   86,  688,   86,  576,   86,   86,  697,
-      689,  690,  693,  698,  691,  692,  696,  695,   86,   86,
-      700,   86,   86,   86,   86,  694,  720,  699,  655,  655,
-      655,  655,  655,  655,  655,  655,  655,  655,  655,  655,
-      714,   86,  719,   86,   86,  726,  576,  716,   86,  576,
-      717,  715,  576,  718,   86,  576,   86,  721,   86,  727,
-
-      656,   86,  722,  730,  723,  724,  707,  576,   86,   86,
-      729,  725,  576,  576,   86,   86,  766,  728,  576,  575,
-      575,  575,  575,  575,  575,   86,   86,   86,   86,  731,
-       86,   86,   86,   86,   86,  738,   86,   86,  732,  733,
-      734,   86,  736,   86,   86,  735,  741,   86,   86,  740,
-       86,  657,   86,   86,  758,  756,   86,  737,  739,  655,
-      655,  655,  655,  655,  655,  755,  759,  754,  757,   86,
-       86,  763,  761,   86,   86,   86,  764,  765,  760,   86,
-       86,   86,  767,  762,  768,   86,   86,   86,  790,   86,
-      769,  707,  786,   86,   86,   86,  788,   86,   86,   86,
-
-      791,   86,  793,   86,  785,   86,  784,  783,  794,  787,
-      795,   86,  789,   86,   86,   86,   86,  792,  805,  806,
-      825,  825,   86,  807,  804,  808,   86,   86,   86,  810,
-      811,   86,  809,   86,   86,   86,  815,  814,  816,   86,
-       86,   86,  817,  818,  819,   86,   86,   86,  822,  821,
-      823,  803,  825,  820,  802,  825,  800,  825,  799,  825,
-      798,  825,  797,   86,   86,   86,  825,  782,  824,   68,
-       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
-       68,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   77,   77,   77,   77,   77,   77,   77,
-
-       77,   77,   77,   77,   77,   85,  825,  781,   85,   85,
-       85,   85,   85,   85,  139,  779,  825,  777,  139,  139,
-      139,  139,  139,  194,  194,  194,  194,  194,  194,  194,
-      194,  194,  194,  194,  194,  199,  825,  775,  199,  199,
-      199,  199,  199,  199,  203,  825,  203,  203,  773,  203,
-      203,  203,  203,  203,  771,  203,  211,   86,   86,  211,
-      211,  211,  211,  211,  211,  211,   86,  211,  232,  232,
-      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
-      246,  246,  246,   86,   86,   86,  246,  262,   86,   86,
-      262,  262,  262,  262,  262,  262,  266,  266,   86,   86,
-
-       86,  266,  268,  268,   86,  825,  753,  268,  335,  335,
-      751,  825,  825,  335,  337,  337,  748,  746,  744,  337,
-      341,  341,  825,   86,   86,  341,  343,  343,   86,   86,
-       86,  343,  345,  345,   86,   86,  713,  345,  352,  352,
-      710,  709,  200,  352,  354,  354,  703,  702,  639,  354,
-      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
-      232,  232,  365,  365,  367,  367,  367,  367,  367,   86,
-      367,  246,  246,  246,  377,  377,   86,   86,   86,  377,
-      379,  379,   86,   86,   86,  379,  381,  381,   86,   86,
-       86,  381,  266,  266,  383,  383,   86,   86,   86,  383,
-
-      268,  268,   85,   86,  664,   85,   85,   85,   85,   85,
-       85,  194,  194,  194,  194,  194,  194,  194,  194,  194,
-      194,  194,  194,  447,  447,  447,  447,  447,  447,  447,
-      447,  447,  447,  447,  447,  448,  448,  663,  661,  659,
-      448,  450,  450,  573,  654,  653,  450,  452,  452,  651,
-      649,  647,  452,  335,  335,  454,  454,  645,  643,  641,
-      454,  337,  337,  457,  457,  639,   86,   86,  457,  341,
-      341,  459,  459,   86,   86,   86,  459,  343,  343,  461,
-      461,   86,   86,   86,  461,  345,  345,  463,  463,   86,
-       86,   86,  463,  352,  352,  465,  465,  590,  588,  586,
-
-      465,  354,  354,  470,  470,  584,  470,  582,  470,  365,
-      365,  580,  365,  481,  365,  367,  367,  367,  367,  367,
-      578,  367,  482,  482,  578,  568,  566,  482,  484,  484,
-      462,  462,  564,  484,  486,  486,  562,  560,  558,  486,
-      377,  377,  488,  488,  556,  554,   86,  488,  379,  379,
-      490,  490,   86,   86,   86,  490,  381,  381,  492,  492,
-       86,   86,   86,  492,  383,  383,   85,   86,  493,   85,
-       85,   85,   85,   85,   85,  447,  447,  447,  447,  447,
-      447,  447,  447,  447,  447,  447,  447,  553,  553,  491,
-      489,  487,  553,  448,  448,  555,  555,  485,  483,  466,
-
-      555,  450,  450,  557,  557,  464,  348,  348,  557,  452,
-      452,  559,  559,  462,  460,  458,  559,  454,  454,  561,
-      561,  455,  453,  451,  561,  457,  457,  563,  563,  449,
-       86,   86,  563,  459,  459,  461,  461,   86,  384,  382,
-      461,  565,  565,  380,  378,  263,  565,  463,  463,  567,
-      567,  258,  257,  374,  567,  465,  465,  470,  470,  374,
-      470,  245,  470,  367,  367,  364,  364,  233,  367,  579,
-      579,  359,  355,  353,  579,  482,  482,  581,  581,  351,
-      347,  346,  581,  484,  484,  583,  583,  344,  342,  338,
-      583,  486,  486,  585,  585,  336,  200,  196,  585,  488,
-
-      488,  587,  587,   86,  269,  267,  587,  490,  490,  589,
-      589,  263,  258,  261,  589,  492,  492,   85,  258,  256,
-       85,   85,   85,   85,   85,   85,  638,  638,  638,  638,
-      638,  638,  638,  638,  638,  638,  638,  638,  640,  640,
-      255,  254,  233,  640,  553,  553,  642,  642,  227,   84,
-       84,  642,  555,  555,  644,  644,   86,  200,  198,  644,
-      557,  557,  646,  646,   84,  146,  140,  646,  559,  559,
-      648,  648,  121,  116,   86,  648,  561,  561,  650,  650,
-      825,   69,   69,  650,  563,  563,  652,  652,  825,  825,
-      825,  652,  565,  565,   85,   85,  825,  825,  825,   85,
-
-      567,  567,  470,  470,  825,  825,  825,  470,  658,  658,
-      825,  825,  825,  658,  579,  579,  660,  660,  825,  825,
-      825,  660,  581,  581,  662,  662,  825,  825,  825,  662,
-      583,  583,  139,  139,  825,  825,  825,  139,  585,  585,
-      665,  665,  587,  587,   85,  825,  825,   85,   85,   85,
-       85,   85,   85,  589,  589,  638,  638,  638,  638,  638,
-      638,  638,  638,  638,  638,  638,  638,  701,  701,  825,
-      825,  825,  701,  640,  640,  199,  199,  825,  825,  825,
-      199,  642,  642,  704,  704,  644,  644,  199,  825,  825,
-      199,  199,  199,  199,  199,  199,  646,  646,  705,  705,
-
-      648,  648,  650,  650,  706,  706,  652,  652,   85,   85,
-      708,  708,  825,  825,  825,  708,  658,  658,  262,  262,
-      825,  825,  825,  262,  660,  660,  711,  711,  662,  662,
-      139,  139,  712,  712,  825,  825,  825,  712,   85,  825,
-      825,   85,   85,   85,   85,   85,   85,  742,  742,  701,
-      701,  743,  743,  825,  825,  825,  743,  745,  745,  825,
-      825,  825,  745,  747,  747,  825,  825,  825,  747,  749,
-      749,  750,  750,  825,  825,  825,  750,  752,  752,  825,
-      825,  825,  752,  770,  770,  825,  825,  825,  770,  772,
-      772,  825,  825,  825,  772,  774,  774,  825,  825,  825,
-
-      774,  776,  776,  825,  825,  825,  776,  778,  778,  825,
-      825,  825,  778,  780,  780,  825,  825,  825,  780,  589,
-      589,  825,  825,  825,  589,  796,  796,  825,  825,  825,
-      796,  646,  646,  825,  825,  825,  646,  650,  650,  825,
-      825,  825,  650,   85,   85,  825,  825,  825,   85,  801,
-      801,  825,  825,  825,  801,  139,  139,  825,  825,  825,
-      139,  199,  199,  825,  825,  825,  199,   11,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825
-    } ;
-
-static yyconst flex_int16_t yy_chk[2653] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    2,   16,   24,   16,   24,    2,
-       19,   19,    2,    5,    5,    5,    5,    5,    5,    5,
-
-        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,    5,    7,    8,    9,
-       10,   37,   37,   20,   48,    9,   10,  512,    7,    8,
-       13,   13,   13,   13,   13,   13,   15,   15,   15,   15,
-
-       15,   15,   20,   25,   48,   42,   53,   28,   27,   28,
-       28,   28,   28,   28,   28,  512,  824,   25,   29,   25,
-       27,   27,   27,   29,   53,   35,    7,    8,    9,   10,
-       40,   42,   55,   29,   30,   40,   30,   30,   30,   30,
-       30,   30,   35,   47,   35,   35,  125,   49,  125,   50,
-       55,   56,   49,   30,   63,   51,   55,   30,   50,   49,
-       56,   72,   30,   30,   47,   49,   47,   50,   30,   54,
-       51,   50,   51,   40,   30,   60,   40,   86,   61,   54,
-       30,   51,  107,  113,  823,  822,   54,   72,   30,   58,
-       61,   30,   31,   60,   31,   31,   31,   31,   31,   31,
-
-      108,   58,  106,   86,   63,  107,  113,  106,  126,   58,
-      126,   31,   45,   45,   45,   31,   58,   57,   45,   45,
-       31,   45,   52,   45,   45,  821,   31,   52,   45,   57,
-       57,   45,   31,  106,  108,   52,  140,   52,   31,   57,
-       52,  128,   57,  128,   52,   59,   31,   38,  112,  819,
-       59,   38,   38,  112,   38,  114,   38,   38,  131,   38,
-      131,   38,  140,   59,   79,   79,   79,   79,   79,   79,
-       38,   38,   38,   66,   66,   66,   66,   66,   66,  112,
-      154,   66,   81,   81,   81,   81,   81,   81,   59,  114,
-       38,   59,  154,   38,   82,   82,   82,   82,   82,   82,
-
-      129,   67,   67,  130,  818,   59,   67,  103,  103,  103,
-      103,  133,  298,  133,  129,  130,  129,  130,  298,  109,
-       38,   38,   67,   67,   67,   67,   67,   67,   76,   76,
-      134,  134,  134,   76,  103,   76,  105,  171,  105,  103,
-       76,  105,  105,  105,  105,  105,  105,  161,  109,   76,
-       76,   76,   76,  109,  110,  132,  132,  171,  132,  115,
-       76,  813,  103,  104,  161,  104,  104,  104,  104,  104,
-      104,  147,  110,  105,  148,   76,  109,  115,   76,  136,
-      110,  136,  104,   76,   76,  115,  147,   76,   76,  138,
-      149,  138,  148,  147,  143,   76,  151,  104,   76,  143,
-
-       76,   76,   76,  104,   76,   84,  152,  150,  149,   84,
-       84,  153,  151,  157,   84,   84,  150,   84,  158,   84,
-      156,  165,  162,  163,  152,  812,  808,  158,   84,   84,
-       84,  159,  162,  153,  155,  157,  156,  143,  164,  155,
-      167,  155,  165,  155,  155,  160,  163,  155,   84,  155,
-      160,   84,  159,  159,  155,  155,  155,  168,  155,  169,
-      170,  172,  167,  160,  166,  164,  213,  173,  213,  177,
-      806,  175,  168,  176,  177,  236,  169,  179,  170,   84,
-       98,   98,   98,   98,   98,   98,  175,  166,  172,  173,
-      176,  181,  178,  175,  180,  179,  181,   98,   98,  271,
-
-      183,   98,  182,  178,  184,  180,  186,  200,  189,  236,
-      803,  181,   98,  178,  178,  182,  185,  271,   98,   98,
-      183,  189,  180,  187,   98,  102,  102,  102,  102,  102,
-      102,  184,  188,  200,  440,  185,  187,  214,  215,  214,
-      215,  241,  102,  102,  187,  188,  102,  188,  275,  186,
-      204,  204,  186,  275,  217,  204,  218,  102,  218,  440,
-      193,  193,  287,  102,  102,  193,  217,  241,  217,  102,
-      192,  192,  192,  192,  192,  192,  219,  219,  192,  219,
-      249,  193,  193,  193,  193,  193,  193,  195,  195,  287,
-      285,  216,  195,  197,  197,  220,  802,  220,  197,  285,
-
-      197,  207,  207,  207,  207,  216,  249,  216,  195,  195,
-      195,  195,  195,  195,  197,  197,  197,  197,  197,  197,
-      221,  221,  221,  223,  224,  223,  224,  237,  237,  237,
-      237,  237,  237,  207,  228,  228,  228,  228,  228,  228,
-      229,  259,  229,  259,  237,  229,  229,  229,  229,  229,
-      229,  228,  228,  234,  234,  228,  260,  234,  260,  237,
-      541,  272,  277,  270,  284,  237,  228,  277,  263,  284,
-      541,  281,  228,  228,  234,  234,  270,  229,  228,  272,
-      234,  238,  238,  238,  238,  238,  238,  239,  239,  239,
-      239,  239,  239,  240,  263,  240,  276,  281,  240,  240,
-
-      240,  240,  240,  240,  246,  239,  801,  800,  239,  248,
-      248,  248,  248,  248,  248,  279,  276,  273,  274,  239,
-      253,  253,  253,  253,  253,  253,  239,  246,  278,  246,
-      279,  239,  246,  273,  282,  274,  279,  279,  246,  280,
-      286,  248,  291,  283,  288,  290,  292,  291,  278,  282,
-      246,  294,  253,  286,  246,  292,  295,  280,  246,  283,
-      283,  293,  288,  290,  296,  297,  300,  301,  293,  299,
-      297,  294,  302,  304,  295,  300,  303,  305,  304,  306,
-      307,  302,  305,  301,  306,  296,  296,  308,  299,  309,
-      314,  303,  311,  312,  313,  315,  316,  317,  319,  307,
-
-      318,  306,  309,  311,  320,  308,  321,  313,  312,  318,
-      324,  322,  314,  325,  317,  326,  316,  327,  315,  324,
-      319,  329,  330,  328,  386,  385,  329,  320,  321,  322,
-      327,  328,  332,  326,  331,  331,  385,  330,  332,  331,
-      386,  331,  339,  339,  339,  339,  340,  340,  340,  340,
-      349,  350,  349,  350,  388,  799,  325,  356,  356,  356,
-      356,  356,  356,  357,  357,  357,  357,  357,  357,  370,
-      358,  392,  358,  388,  339,  358,  358,  358,  358,  358,
-      358,  357,  389,  390,  357,  359,  359,  359,  359,  359,
-      359,  389,  370,  392,  390,  357,  360,  360,  360,  360,
-
-      360,  360,  357,  403,  798,  365,  366,  357,  361,  361,
-      361,  361,  361,  361,  365,  366,  372,  359,  362,  362,
-      362,  362,  362,  362,  403,  395,  361,  396,  360,  361,
-      365,  366,  368,  367,  372,  391,  362,  368,  387,  362,
-      361,  395,  372,  400,  391,  393,  394,  361,  400,  396,
-      362,  797,  361,  387,  393,  796,  367,  362,  367,  394,
-      397,  367,  362,  368,  369,  371,  369,  367,  399,  369,
-      369,  369,  369,  369,  369,  398,  397,  397,  402,  367,
-      401,  404,  408,  367,  402,  405,  399,  367,  371,  415,
-      371,  406,  404,  371,  413,  401,  408,  398,  410,  371,
-
-      412,  369,  401,  420,  405,  414,  406,  416,  417,  421,
-      410,  371,  415,  422,  414,  371,  413,  417,  414,  371,
-      423,  412,  416,  420,  424,  425,  426,  428,  422,  430,
-      431,  421,  435,  432,  433,  426,  434,  436,  443,  424,
-      438,  435,  423,  437,  428,  425,  442,  438,  445,  443,
-      439,  431,  430,  432,  433,  436,  437,  439,  434,  441,
-      446,  504,  447,  442,  504,  473,  470,  441,  447,  446,
-      445,  456,  456,  456,  456,  470,  494,  441,  467,  467,
-      467,  467,  467,  467,  468,  468,  468,  468,  468,  468,
-      473,  470,  474,  494,  472,  495,  467,  497,  499,  467,
-
-      498,  501,  468,  472,  500,  468,  506,  505,  495,  794,
-      467,  499,  497,  503,  501,  507,  468,  467,  474,  472,
-      498,  515,  467,  468,  503,  506,  500,  505,  468,  469,
-      469,  469,  469,  469,  469,  471,  507,  471,  515,  793,
-      471,  471,  471,  471,  471,  471,  476,  476,  476,  476,
-      476,  476,  477,  477,  477,  477,  477,  477,  478,  514,
-      478,  469,  508,  478,  478,  478,  478,  478,  478,  502,
-      477,  508,  471,  477,  502,  509,  510,  511,  522,  513,
-      509,  514,  523,  516,  477,  524,  520,  510,  513,  517,
-      511,  477,  516,  525,  517,  520,  477,  527,  528,  523,
-
-      524,  529,  525,  531,  522,  536,  532,  537,  534,  538,
-      528,  532,  535,  543,  527,  540,  529,  534,  531,  544,
-      537,  535,  542,  540,  546,  549,  538,  536,  547,  542,
-      550,  544,  592,  546,  597,  543,  791,  790,  547,  592,
-      596,  597,  549,  550,  569,  569,  569,  569,  569,  569,
-      570,  570,  570,  570,  570,  570,  571,  571,  571,  571,
-      571,  571,  572,  596,  572,  610,  593,  572,  572,  572,
-      572,  572,  572,  594,  571,  593,  569,  571,  575,  575,
-      575,  575,  575,  575,  595,  610,  594,  600,  571,  598,
-      600,  599,  603,  591,  602,  571,  575,  598,  591,  575,
-
-      571,  595,  577,  577,  577,  577,  577,  577,  599,  602,
-      575,  591,  601,  604,  603,  605,  606,  575,  607,  606,
-      577,  608,  575,  577,  609,  601,  612,  611,  613,  615,
-      604,  616,  620,  617,  577,  607,  611,  605,  621,  609,
-      623,  577,  627,  634,  612,  637,  577,  626,  608,  627,
-      613,  615,  620,  634,  616,  617,  626,  623,  636,  666,
-      637,  669,  672,  673,  680,  621,  673,  636,  655,  655,
-      655,  655,  655,  655,  656,  656,  656,  656,  656,  656,
-      666,  667,  672,  670,  675,  680,  655,  669,  671,  655,
-      670,  667,  656,  671,  674,  656,  678,  674,  677,  681,
-
-      655,  683,  675,  684,  677,  678,  656,  655,  679,  732,
-      683,  679,  655,  656,  682,  696,  732,  682,  656,  657,
-      657,  657,  657,  657,  657,  686,  685,  681,  684,  685,
-      688,  687,  689,  691,  693,  696,  697,  700,  686,  687,
-      688,  699,  691,  723,  722,  689,  700,  718,  719,  699,
-      720,  657,  724,  721,  722,  720,  783,  693,  697,  707,
-      707,  707,  707,  707,  707,  719,  723,  718,  721,  725,
-      726,  727,  725,  729,  731,  735,  729,  731,  724,  733,
-      754,  734,  733,  726,  734,  756,  757,  759,  763,  758,
-      735,  707,  758,  760,  762,  766,  760,  764,  727,  767,
-
-      764,  769,  767,  784,  757,  768,  756,  754,  768,  759,
-      769,  785,  762,  763,  787,  789,  786,  766,  785,  786,
-      782,  781,  788,  787,  784,  788,  792,  795,  804,  792,
-      795,  805,  789,  814,  815,  807,  805,  804,  807,  809,
-      810,  811,  809,  810,  811,  816,  820,  817,  816,  815,
-      817,  780,  779,  814,  778,  777,  776,  775,  774,  773,
-      772,  771,  770,  765,  761,  755,  753,  752,  820,  826,
-      826,  826,  826,  826,  826,  826,  826,  826,  826,  826,
-      826,  827,  827,  827,  827,  827,  827,  827,  827,  827,
-      827,  827,  827,  828,  828,  828,  828,  828,  828,  828,
-
-      828,  828,  828,  828,  828,  829,  751,  750,  829,  829,
-      829,  829,  829,  829,  830,  749,  748,  747,  830,  830,
-      830,  830,  830,  831,  831,  831,  831,  831,  831,  831,
-      831,  831,  831,  831,  831,  832,  746,  745,  832,  832,
-      832,  832,  832,  832,  833,  744,  833,  833,  743,  833,
-      833,  833,  833,  833,  742,  833,  834,  741,  740,  834,
-      834,  834,  834,  834,  834,  834,  739,  834,  835,  835,
-      835,  835,  835,  835,  835,  835,  835,  835,  835,  835,
-      836,  836,  836,  738,  737,  736,  836,  837,  730,  728,
-      837,  837,  837,  837,  837,  837,  838,  838,  717,  716,
-
-      715,  838,  839,  839,  714,  713,  712,  839,  840,  840,
-      711,  710,  709,  840,  841,  841,  706,  705,  704,  841,
-      842,  842,  703,  698,  695,  842,  843,  843,  694,  692,
-      690,  843,  844,  844,  676,  668,  665,  844,  845,  845,
-      660,  658,  646,  845,  846,  846,  642,  640,  638,  846,
-      847,  847,  847,  847,  847,  847,  847,  847,  847,  847,
-      847,  847,  848,  848,  849,  849,  849,  849,  849,  635,
-      849,  850,  850,  850,  851,  851,  633,  632,  631,  851,
-      852,  852,  630,  629,  628,  852,  853,  853,  625,  624,
-      622,  853,  854,  854,  855,  855,  619,  618,  614,  855,
-
-      856,  856,  857,  589,  585,  857,  857,  857,  857,  857,
-      857,  858,  858,  858,  858,  858,  858,  858,  858,  858,
-      858,  858,  858,  859,  859,  859,  859,  859,  859,  859,
-      859,  859,  859,  859,  859,  860,  860,  583,  581,  579,
-      860,  861,  861,  573,  567,  565,  861,  862,  862,  563,
-      561,  559,  862,  863,  863,  864,  864,  557,  555,  553,
-      864,  865,  865,  866,  866,  552,  551,  548,  866,  867,
-      867,  868,  868,  545,  539,  533,  868,  869,  869,  870,
-      870,  530,  526,  521,  870,  871,  871,  872,  872,  519,
-      518,  496,  872,  873,  873,  874,  874,  492,  490,  488,
-
-      874,  875,  875,  876,  876,  486,  876,  484,  876,  877,
-      877,  482,  877,  481,  877,  878,  878,  878,  878,  878,
-      480,  878,  879,  879,  479,  465,  463,  879,  880,  880,
-      462,  461,  459,  880,  881,  881,  457,  454,  452,  881,
-      882,  882,  883,  883,  450,  448,  444,  883,  884,  884,
-      885,  885,  429,  427,  419,  885,  886,  886,  887,  887,
-      418,  411,  409,  887,  888,  888,  889,  407,  383,  889,
-      889,  889,  889,  889,  889,  890,  890,  890,  890,  890,
-      890,  890,  890,  890,  890,  890,  890,  891,  891,  381,
-      379,  377,  891,  892,  892,  893,  893,  376,  375,  354,
-
-      893,  894,  894,  895,  895,  352,  351,  347,  895,  896,
-      896,  897,  897,  345,  343,  341,  897,  898,  898,  899,
-      899,  337,  335,  334,  899,  900,  900,  901,  901,  333,
-      323,  310,  901,  902,  902,  903,  903,  289,  268,  266,
-      903,  904,  904,  265,  264,  262,  904,  905,  905,  906,
-      906,  261,  256,  252,  906,  907,  907,  908,  908,  251,
-      908,  247,  908,  909,  909,  244,  243,  232,  909,  910,
-      910,  231,  226,  225,  910,  911,  911,  912,  912,  222,
-      212,  210,  912,  913,  913,  914,  914,  209,  208,  202,
-      914,  915,  915,  916,  916,  201,  199,  194,  916,  917,
-
-      917,  918,  918,  174,  145,  144,  918,  919,  919,  920,
-      920,  139,  137,  135,  920,  921,  921,  922,  127,  124,
-      922,  922,  922,  922,  922,  922,  923,  923,  923,  923,
-      923,  923,  923,  923,  923,  923,  923,  923,  924,  924,
-      123,  119,  100,  924,  925,  925,  926,  926,   97,   94,
-       92,  926,  927,  927,  928,  928,   85,   71,   69,  928,
-      929,  929,  930,  930,   65,   44,   39,  930,  931,  931,
-      932,  932,   36,   33,   18,  932,  933,  933,  934,  934,
-       11,    4,    3,  934,  935,  935,  936,  936,    0,    0,
-        0,  936,  937,  937,  938,  938,    0,    0,    0,  938,
-
-      939,  939,  940,  940,    0,    0,    0,  940,  941,  941,
-        0,    0,    0,  941,  942,  942,  943,  943,    0,    0,
-        0,  943,  944,  944,  945,  945,    0,    0,    0,  945,
-      946,  946,  947,  947,    0,    0,    0,  947,  948,  948,
-      949,  949,  950,  950,  951,    0,    0,  951,  951,  951,
-      951,  951,  951,  952,  952,  953,  953,  953,  953,  953,
-      953,  953,  953,  953,  953,  953,  953,  954,  954,    0,
-        0,    0,  954,  955,  955,  956,  956,    0,    0,    0,
-      956,  957,  957,  958,  958,  959,  959,  960,    0,    0,
-      960,  960,  960,  960,  960,  960,  961,  961,  962,  962,
-
-      963,  963,  964,  964,  965,  965,  966,  966,  967,  967,
-      968,  968,    0,    0,    0,  968,  969,  969,  970,  970,
-        0,    0,    0,  970,  971,  971,  972,  972,  973,  973,
-      974,  974,  975,  975,    0,    0,    0,  975,  976,    0,
-        0,  976,  976,  976,  976,  976,  976,  977,  977,  978,
-      978,  979,  979,    0,    0,    0,  979,  980,  980,    0,
-        0,    0,  980,  981,  981,    0,    0,    0,  981,  982,
-      982,  983,  983,    0,    0,    0,  983,  984,  984,    0,
-        0,    0,  984,  985,  985,    0,    0,    0,  985,  986,
-      986,    0,    0,    0,  986,  987,  987,    0,    0,    0,
-
-      987,  988,  988,    0,    0,    0,  988,  989,  989,    0,
-        0,    0,  989,  990,  990,    0,    0,    0,  990,  991,
-      991,    0,    0,    0,  991,  992,  992,    0,    0,    0,
-      992,  993,  993,    0,    0,    0,  993,  994,  994,    0,
-        0,    0,  994,  995,  995,    0,    0,    0,  995,  996,
-      996,    0,    0,    0,  996,  997,  997,    0,    0,    0,
-      997,  998,  998,    0,    0,    0,  998,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825,  825,  825,  825,  825,  825,  825,  825,  825,
-      825,  825
-    } ;
-
-/* Table of booleans, true if rule could match eol. */
-static yyconst flex_int32_t yy_rule_can_match_eol[172] =
-    {   0,
-1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,     };
-
-static yy_state_type yy_last_accepting_state;
-static char *yy_last_accepting_cpos;
-
-extern int yy_flex_debug;
-int yy_flex_debug = 0;
-
-/* The intent behind this definition is that it'll catch
- * any uses of REJECT which flex missed.
- */
-#define REJECT reject_used_but_not_detected
-#define yymore() yymore_used_but_not_detected
-#define YY_MORE_ADJ 0
-#define YY_RESTORE_YY_MORE_OFFSET
-char *yytext;
-#line 1 "lex.ll"
-/*
- * Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
- *
- * The contents of this file are covered under the licence agreement in the
- * file "LICENCE" distributed with Cforall.
- * 
- * lex.l -- 
- * 
- * Author           : Peter A. Buhr
- * Created On       : Sat Sep 22 08:58:10 2001
- * Last Modified By : Peter A. Buhr
- * Last Modified On : Fri Jun 19 11:10:14 2015
- * Update Count     : 392
- */
-#line 20 "lex.ll"
-// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor directive have been
-// performed and removed from the source. The only exceptions are preprocessor directives passed to the compiler (e.g.,
-// line-number directives) and C/C++ style comments, which are ignored.
-
-//**************************** Includes and Defines ****************************
-
-#include <string>
-
-#include "lex.h"
-#include "ParseNode.h"
-#include "parser.h"										// YACC generated definitions based on C++ grammar
-
-char *yyfilename;
-std::string *strtext;									// accumulate parts of character and string constant value
-
-#define RETURN_LOCN(x)		yylval.tok.loc.file = yyfilename; yylval.tok.loc.line = yylineno; return( x )
-#define RETURN_VAL(x)		yylval.tok.str = new std::string( yytext ); RETURN_LOCN( x )
-#define RETURN_CHAR(x)		yylval.tok.str = NULL; RETURN_LOCN( x )
-#define RETURN_STR(x)		yylval.tok.str = strtext; RETURN_LOCN( x )
-
-#define WHITE_RETURN(x)									// do nothing
-#define NEWLINE_RETURN()	WHITE_RETURN( '\n' )
-#define ASCIIOP_RETURN()	RETURN_CHAR( (int)yytext[0] ) // single character operator
-#define NAMEDOP_RETURN(x)	RETURN_VAL( x )				// multichar operator, with a name
-#define NUMERIC_RETURN(x)	rm_underscore(); RETURN_VAL( x ) // numeric constant
-#define KEYWORD_RETURN(x)	RETURN_CHAR( x )			// keyword
-#define IDENTIFIER_RETURN()	RETURN_VAL( (typedefTable.isIdentifier( yytext ) ? IDENTIFIER : typedefTable.isTypedef( yytext ) ? TYPEDEFname : TYPEGENname ) )
-#define ATTRIBUTE_RETURN()	RETURN_VAL( ATTR_IDENTIFIER )
-
-void rm_underscore() {
-	// remove underscores in numeric constant
-	int j = 0;
-	for ( int i = 0; yytext[i] != '\0'; i += 1 ) {
-		if ( yytext[i] != '_' ) {
-			yytext[j] = yytext[i];
-			j += 1;
-		} // if
-	} // for
-	yyleng = j;
-	yytext[yyleng] = '\0';
-}
-
-// identifier, GCC: $ in identifier
-// quoted identifier
-// attribute identifier, GCC: $ in identifier
-// numeric constants, CFA: '_' in constant
-// character escape sequence, GCC: \e => esc character
-// ' stop highlighting
-// display/white-space characters
-// operators
-
-
-
-
-#line 1451 "Parser/lex.cc"
-
-#define INITIAL 0
-#define COMMENT 1
-#define BKQUOTE 2
-#define QUOTE 3
-#define STRING 4
-
-#ifndef YY_NO_UNISTD_H
-/* Special case for "unistd.h", since it is non-ANSI. We include it way
- * down here because we want the user's section 1 to have been scanned first.
- * The user has a chance to override it with an option.
- */
-#include <unistd.h>
-#endif
-
-#ifndef YY_EXTRA_TYPE
-#define YY_EXTRA_TYPE void *
-#endif
-
-static int yy_init_globals (void );
-
-/* Accessor methods to globals.
-   These are made visible to non-reentrant scanners for convenience. */
-
-int yylex_destroy (void );
-
-int yyget_debug (void );
-
-void yyset_debug (int debug_flag  );
-
-YY_EXTRA_TYPE yyget_extra (void );
-
-void yyset_extra (YY_EXTRA_TYPE user_defined  );
-
-FILE *yyget_in (void );
-
-void yyset_in  (FILE * in_str  );
-
-FILE *yyget_out (void );
-
-void yyset_out  (FILE * out_str  );
-
-int yyget_leng (void );
-
-char *yyget_text (void );
-
-int yyget_lineno (void );
-
-void yyset_lineno (int line_number  );
-
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int yywrap (void );
-#else
-extern int yywrap (void );
-#endif
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char *,yyconst char *,int );
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * );
-#endif
-
-#ifndef YY_NO_INPUT
-
-#ifdef __cplusplus
-static int yyinput (void );
-#else
-static int input (void );
-#endif
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Copy whatever the last rule matched to the standard output. */
-#ifndef ECHO
-/* This used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite().
- */
-#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
-#endif
-
-/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
- * is returned in "result".
- */
-#ifndef YY_INPUT
-#define YY_INPUT(buf,result,max_size) \
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-		{ \
-		int c = '*'; \
-		size_t n; \
-		for ( n = 0; n < max_size && \
-			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
-			buf[n] = (char) c; \
-		if ( c == '\n' ) \
-			buf[n++] = (char) c; \
-		if ( c == EOF && ferror( yyin ) ) \
-			YY_FATAL_ERROR( "input in flex scanner failed" ); \
-		result = n; \
-		} \
-	else \
-		{ \
-		errno=0; \
-		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
-			{ \
-			if( errno != EINTR) \
-				{ \
-				YY_FATAL_ERROR( "input in flex scanner failed" ); \
-				break; \
-				} \
-			errno=0; \
-			clearerr(yyin); \
-			} \
-		}\
-\
-
-#endif
-
-/* No semi-colon after return; correct usage is to write "yyterminate();" -
- * we don't want an extra ';' after the "return" because that will cause
- * some compilers to complain about unreachable statements.
- */
-#ifndef yyterminate
-#define yyterminate() return YY_NULL
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
-#endif
-
-/* end tables serialization structures and prototypes */
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL_IS_OURS 1
-
-extern int yylex (void);
-
-#define YY_DECL int yylex (void)
-#endif /* !YY_DECL */
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * have been set up.
- */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
-#endif
-
-/* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK break;
-#endif
-
-#define YY_RULE_SETUP \
-	if ( yyleng > 0 ) \
-		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
-				(yytext[yyleng - 1] == '\n'); \
-	YY_USER_ACTION
-
-/** The main scanner function which does all the work.
- */
-YY_DECL
-{
-	register yy_state_type yy_current_state;
-	register char *yy_cp, *yy_bp;
-	register int yy_act;
-    
-#line 136 "lex.ll"
-
-				   /* line directives */
-#line 1646 "Parser/lex.cc"
-
-	if ( !(yy_init) )
-		{
-		(yy_init) = 1;
-
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
-#endif
-
-		if ( ! (yy_start) )
-			(yy_start) = 1;	/* first start state */
-
-		if ( ! yyin )
-			yyin = stdin;
-
-		if ( ! yyout )
-			yyout = stdout;
-
-		if ( ! YY_CURRENT_BUFFER ) {
-			yyensure_buffer_stack ();
-			YY_CURRENT_BUFFER_LVALUE =
-				yy_create_buffer(yyin,YY_BUF_SIZE );
-		}
-
-		yy_load_buffer_state( );
-		}
-
-	while ( 1 )		/* loops until end-of-file is reached */
-		{
-		yy_cp = (yy_c_buf_p);
-
-		/* Support of yytext. */
-		*yy_cp = (yy_hold_char);
-
-		/* yy_bp points to the position in yy_ch_buf of the start of
-		 * the current run.
-		 */
-		yy_bp = yy_cp;
-
-		yy_current_state = (yy_start);
-		yy_current_state += YY_AT_BOL();
-yy_match:
-		do
-			{
-			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-			if ( yy_accept[yy_current_state] )
-				{
-				(yy_last_accepting_state) = yy_current_state;
-				(yy_last_accepting_cpos) = yy_cp;
-				}
-			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-				{
-				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 826 )
-					yy_c = yy_meta[(unsigned int) yy_c];
-				}
-			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-			++yy_cp;
-			}
-		while ( yy_base[yy_current_state] != 2568 );
-
-yy_find_action:
-		yy_act = yy_accept[yy_current_state];
-		if ( yy_act == 0 )
-			{ /* have to back up */
-			yy_cp = (yy_last_accepting_cpos);
-			yy_current_state = (yy_last_accepting_state);
-			yy_act = yy_accept[yy_current_state];
-			}
-
-		YY_DO_BEFORE_ACTION;
-
-		if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
-			{
-			int yyl;
-			for ( yyl = 0; yyl < yyleng; ++yyl )
-				if ( yytext[yyl] == '\n' )
-					   
-    yylineno++;
-;
-			}
-
-do_action:	/* This label is used only to access EOF actions. */
-
-		switch ( yy_act )
-	{ /* beginning of action switch */
-			case 0: /* must back up */
-			/* undo the effects of YY_DO_BEFORE_ACTION */
-			*yy_cp = (yy_hold_char);
-			yy_cp = (yy_last_accepting_cpos);
-			yy_current_state = (yy_last_accepting_state);
-			goto yy_find_action;
-
-case 1:
-/* rule 1 can match eol */
-YY_RULE_SETUP
-#line 138 "lex.ll"
-{
-	/* " stop highlighting */
-	char *end_num;
-	char *begin_string, *end_string;
-	char *filename;
-	long lineno, length;
-	lineno = strtol( yytext + 1, &end_num, 0 );
-	begin_string = strchr( end_num, '"' );
-	if ( begin_string ) {
-		end_string = strchr( begin_string + 1, '"' );
-		if ( end_string ) {
-			length = end_string - begin_string - 1;
-			filename = new char[ length + 1 ];
-			memcpy( filename, begin_string + 1, length );
-			filename[ length ] = '\0';
-			//std::cout << "file " << filename << " line " << lineno << std::endl;
-			yylineno = lineno;
-			yyfilename = filename;
-		} // if
-	} // if
-}
-	YY_BREAK
-/* ignore preprocessor directives (for now) */
-case 2:
-/* rule 2 can match eol */
-YY_RULE_SETUP
-#line 161 "lex.ll"
-;
-	YY_BREAK
-/* ignore C style comments (ALSO HANDLED BY CPP) */
-case 3:
-YY_RULE_SETUP
-#line 164 "lex.ll"
-{ BEGIN COMMENT; }
-	YY_BREAK
-case 4:
-/* rule 4 can match eol */
-YY_RULE_SETUP
-#line 165 "lex.ll"
-;
-	YY_BREAK
-case 5:
-YY_RULE_SETUP
-#line 166 "lex.ll"
-{ BEGIN 0; }
-	YY_BREAK
-/* ignore C++ style comments (ALSO HANDLED BY CPP) */
-case 6:
-/* rule 6 can match eol */
-YY_RULE_SETUP
-#line 169 "lex.ll"
-;
-	YY_BREAK
-/* ignore whitespace */
-case 7:
-YY_RULE_SETUP
-#line 172 "lex.ll"
-{ WHITE_RETURN(' '); }
-	YY_BREAK
-case 8:
-YY_RULE_SETUP
-#line 173 "lex.ll"
-{ WHITE_RETURN(' '); }
-	YY_BREAK
-case 9:
-/* rule 9 can match eol */
-YY_RULE_SETUP
-#line 174 "lex.ll"
-{ NEWLINE_RETURN(); }
-	YY_BREAK
-/* keywords */
-case 10:
-YY_RULE_SETUP
-#line 177 "lex.ll"
-{ KEYWORD_RETURN(ALIGNAS); }			// C11
-	YY_BREAK
-case 11:
-YY_RULE_SETUP
-#line 178 "lex.ll"
-{ KEYWORD_RETURN(ALIGNOF); }			// C11
-	YY_BREAK
-case 12:
-YY_RULE_SETUP
-#line 179 "lex.ll"
-{ KEYWORD_RETURN(ALIGNOF); }			// GCC
-	YY_BREAK
-case 13:
-YY_RULE_SETUP
-#line 180 "lex.ll"
-{ KEYWORD_RETURN(ALIGNOF); }			// GCC
-	YY_BREAK
-case 14:
-YY_RULE_SETUP
-#line 181 "lex.ll"
-{ KEYWORD_RETURN(ASM); }
-	YY_BREAK
-case 15:
-YY_RULE_SETUP
-#line 182 "lex.ll"
-{ KEYWORD_RETURN(ASM); }				// GCC
-	YY_BREAK
-case 16:
-YY_RULE_SETUP
-#line 183 "lex.ll"
-{ KEYWORD_RETURN(ASM); }				// GCC
-	YY_BREAK
-case 17:
-YY_RULE_SETUP
-#line 184 "lex.ll"
-{ KEYWORD_RETURN(ATOMIC); }				// C11
-	YY_BREAK
-case 18:
-YY_RULE_SETUP
-#line 185 "lex.ll"
-{ KEYWORD_RETURN(ATTRIBUTE); }			// GCC
-	YY_BREAK
-case 19:
-YY_RULE_SETUP
-#line 186 "lex.ll"
-{ KEYWORD_RETURN(ATTRIBUTE); }			// GCC
-	YY_BREAK
-case 20:
-YY_RULE_SETUP
-#line 187 "lex.ll"
-{ KEYWORD_RETURN(AUTO); }
-	YY_BREAK
-case 21:
-YY_RULE_SETUP
-#line 188 "lex.ll"
-{ KEYWORD_RETURN(BOOL); }				// C99
-	YY_BREAK
-case 22:
-YY_RULE_SETUP
-#line 189 "lex.ll"
-{ KEYWORD_RETURN(BREAK); }
-	YY_BREAK
-case 23:
-YY_RULE_SETUP
-#line 190 "lex.ll"
-{ KEYWORD_RETURN(CASE); }
-	YY_BREAK
-case 24:
-YY_RULE_SETUP
-#line 191 "lex.ll"
-{ KEYWORD_RETURN(CATCH); }				// CFA
-	YY_BREAK
-case 25:
-YY_RULE_SETUP
-#line 192 "lex.ll"
-{ KEYWORD_RETURN(CHAR); }
-	YY_BREAK
-case 26:
-YY_RULE_SETUP
-#line 193 "lex.ll"
-{ KEYWORD_RETURN(CHOOSE); }				// CFA
-	YY_BREAK
-case 27:
-YY_RULE_SETUP
-#line 194 "lex.ll"
-{ KEYWORD_RETURN(COMPLEX); }			// C99
-	YY_BREAK
-case 28:
-YY_RULE_SETUP
-#line 195 "lex.ll"
-{ KEYWORD_RETURN(COMPLEX); }			// GCC
-	YY_BREAK
-case 29:
-YY_RULE_SETUP
-#line 196 "lex.ll"
-{ KEYWORD_RETURN(COMPLEX); }			// GCC
-	YY_BREAK
-case 30:
-YY_RULE_SETUP
-#line 197 "lex.ll"
-{ KEYWORD_RETURN(CONST); }
-	YY_BREAK
-case 31:
-YY_RULE_SETUP
-#line 198 "lex.ll"
-{ KEYWORD_RETURN(CONST); }				// GCC
-	YY_BREAK
-case 32:
-YY_RULE_SETUP
-#line 199 "lex.ll"
-{ KEYWORD_RETURN(CONST); }				// GCC
-	YY_BREAK
-case 33:
-YY_RULE_SETUP
-#line 200 "lex.ll"
-{ KEYWORD_RETURN(CONTEXT); }			// CFA
-	YY_BREAK
-case 34:
-YY_RULE_SETUP
-#line 201 "lex.ll"
-{ KEYWORD_RETURN(CONTINUE); }
-	YY_BREAK
-case 35:
-YY_RULE_SETUP
-#line 202 "lex.ll"
-{ KEYWORD_RETURN(DEFAULT); }
-	YY_BREAK
-case 36:
-YY_RULE_SETUP
-#line 203 "lex.ll"
-{ KEYWORD_RETURN(DO); }
-	YY_BREAK
-case 37:
-YY_RULE_SETUP
-#line 204 "lex.ll"
-{ KEYWORD_RETURN(DOUBLE); }
-	YY_BREAK
-case 38:
-YY_RULE_SETUP
-#line 205 "lex.ll"
-{ KEYWORD_RETURN(DTYPE); }				// CFA
-	YY_BREAK
-case 39:
-YY_RULE_SETUP
-#line 206 "lex.ll"
-{ KEYWORD_RETURN(ELSE); }
-	YY_BREAK
-case 40:
-YY_RULE_SETUP
-#line 207 "lex.ll"
-{ KEYWORD_RETURN(ENUM); }
-	YY_BREAK
-case 41:
-YY_RULE_SETUP
-#line 208 "lex.ll"
-{ KEYWORD_RETURN(EXTENSION); }			// GCC
-	YY_BREAK
-case 42:
-YY_RULE_SETUP
-#line 209 "lex.ll"
-{ KEYWORD_RETURN(EXTERN); }
-	YY_BREAK
-case 43:
-YY_RULE_SETUP
-#line 210 "lex.ll"
-{ KEYWORD_RETURN(FALLTHRU); }			// CFA
-	YY_BREAK
-case 44:
-YY_RULE_SETUP
-#line 211 "lex.ll"
-{ KEYWORD_RETURN(FINALLY); }			// CFA
-	YY_BREAK
-case 45:
-YY_RULE_SETUP
-#line 212 "lex.ll"
-{ KEYWORD_RETURN(FLOAT); }
-	YY_BREAK
-case 46:
-YY_RULE_SETUP
-#line 213 "lex.ll"
-{ KEYWORD_RETURN(FLOAT); }				// GCC
-	YY_BREAK
-case 47:
-YY_RULE_SETUP
-#line 214 "lex.ll"
-{ KEYWORD_RETURN(FOR); }
-	YY_BREAK
-case 48:
-YY_RULE_SETUP
-#line 215 "lex.ll"
-{ KEYWORD_RETURN(FORALL); }				// CFA
-	YY_BREAK
-case 49:
-YY_RULE_SETUP
-#line 216 "lex.ll"
-{ KEYWORD_RETURN(FORTRAN); }
-	YY_BREAK
-case 50:
-YY_RULE_SETUP
-#line 217 "lex.ll"
-{ KEYWORD_RETURN(FTYPE); }				// CFA
-	YY_BREAK
-case 51:
-YY_RULE_SETUP
-#line 218 "lex.ll"
-{ KEYWORD_RETURN(GENERIC); }			// C11
-	YY_BREAK
-case 52:
-YY_RULE_SETUP
-#line 219 "lex.ll"
-{ KEYWORD_RETURN(GOTO); }
-	YY_BREAK
-case 53:
-YY_RULE_SETUP
-#line 220 "lex.ll"
-{ KEYWORD_RETURN(IF); }
-	YY_BREAK
-case 54:
-YY_RULE_SETUP
-#line 221 "lex.ll"
-{ KEYWORD_RETURN(IMAGINARY); }			// C99
-	YY_BREAK
-case 55:
-YY_RULE_SETUP
-#line 222 "lex.ll"
-{ KEYWORD_RETURN(IMAGINARY); }			// GCC
-	YY_BREAK
-case 56:
-YY_RULE_SETUP
-#line 223 "lex.ll"
-{ KEYWORD_RETURN(IMAGINARY); }			// GCC
-	YY_BREAK
-case 57:
-YY_RULE_SETUP
-#line 224 "lex.ll"
-{ KEYWORD_RETURN(INLINE); }				// C99
-	YY_BREAK
-case 58:
-YY_RULE_SETUP
-#line 225 "lex.ll"
-{ KEYWORD_RETURN(INLINE); }				// GCC
-	YY_BREAK
-case 59:
-YY_RULE_SETUP
-#line 226 "lex.ll"
-{ KEYWORD_RETURN(INLINE); }				// GCC
-	YY_BREAK
-case 60:
-YY_RULE_SETUP
-#line 227 "lex.ll"
-{ KEYWORD_RETURN(INT); }
-	YY_BREAK
-case 61:
-YY_RULE_SETUP
-#line 228 "lex.ll"
-{ KEYWORD_RETURN(INT); }				// GCC
-	YY_BREAK
-case 62:
-YY_RULE_SETUP
-#line 229 "lex.ll"
-{ KEYWORD_RETURN(LABEL); }				// GCC
-	YY_BREAK
-case 63:
-YY_RULE_SETUP
-#line 230 "lex.ll"
-{ KEYWORD_RETURN(LONG); }
-	YY_BREAK
-case 64:
-YY_RULE_SETUP
-#line 231 "lex.ll"
-{ KEYWORD_RETURN(LVALUE); }				// CFA
-	YY_BREAK
-case 65:
-YY_RULE_SETUP
-#line 232 "lex.ll"
-{ KEYWORD_RETURN(NORETURN); }			// C11
-	YY_BREAK
-case 66:
-YY_RULE_SETUP
-#line 233 "lex.ll"
-{ KEYWORD_RETURN(REGISTER); }
-	YY_BREAK
-case 67:
-YY_RULE_SETUP
-#line 234 "lex.ll"
-{ KEYWORD_RETURN(RESTRICT); }			// C99
-	YY_BREAK
-case 68:
-YY_RULE_SETUP
-#line 235 "lex.ll"
-{ KEYWORD_RETURN(RESTRICT); }			// GCC
-	YY_BREAK
-case 69:
-YY_RULE_SETUP
-#line 236 "lex.ll"
-{ KEYWORD_RETURN(RESTRICT); }			// GCC
-	YY_BREAK
-case 70:
-YY_RULE_SETUP
-#line 237 "lex.ll"
-{ KEYWORD_RETURN(RETURN); }
-	YY_BREAK
-case 71:
-YY_RULE_SETUP
-#line 238 "lex.ll"
-{ KEYWORD_RETURN(SHORT); }
-	YY_BREAK
-case 72:
-YY_RULE_SETUP
-#line 239 "lex.ll"
-{ KEYWORD_RETURN(SIGNED); }
-	YY_BREAK
-case 73:
-YY_RULE_SETUP
-#line 240 "lex.ll"
-{ KEYWORD_RETURN(SIGNED); }				// GCC
-	YY_BREAK
-case 74:
-YY_RULE_SETUP
-#line 241 "lex.ll"
-{ KEYWORD_RETURN(SIGNED); }				// GCC
-	YY_BREAK
-case 75:
-YY_RULE_SETUP
-#line 242 "lex.ll"
-{ KEYWORD_RETURN(SIZEOF); }
-	YY_BREAK
-case 76:
-YY_RULE_SETUP
-#line 243 "lex.ll"
-{ KEYWORD_RETURN(STATIC); }
-	YY_BREAK
-case 77:
-YY_RULE_SETUP
-#line 244 "lex.ll"
-{ KEYWORD_RETURN(STATICASSERT); }		// C11
-	YY_BREAK
-case 78:
-YY_RULE_SETUP
-#line 245 "lex.ll"
-{ KEYWORD_RETURN(STRUCT); }
-	YY_BREAK
-case 79:
-YY_RULE_SETUP
-#line 246 "lex.ll"
-{ KEYWORD_RETURN(SWITCH); }
-	YY_BREAK
-case 80:
-YY_RULE_SETUP
-#line 247 "lex.ll"
-{ KEYWORD_RETURN(THREADLOCAL); }		// C11
-	YY_BREAK
-case 81:
-YY_RULE_SETUP
-#line 248 "lex.ll"
-{ KEYWORD_RETURN(THROW); }				// CFA
-	YY_BREAK
-case 82:
-YY_RULE_SETUP
-#line 249 "lex.ll"
-{ KEYWORD_RETURN(TRY); }				// CFA
-	YY_BREAK
-case 83:
-YY_RULE_SETUP
-#line 250 "lex.ll"
-{ KEYWORD_RETURN(TYPE); }				// CFA
-	YY_BREAK
-case 84:
-YY_RULE_SETUP
-#line 251 "lex.ll"
-{ KEYWORD_RETURN(TYPEDEF); }
-	YY_BREAK
-case 85:
-YY_RULE_SETUP
-#line 252 "lex.ll"
-{ KEYWORD_RETURN(TYPEOF); }				// GCC
-	YY_BREAK
-case 86:
-YY_RULE_SETUP
-#line 253 "lex.ll"
-{ KEYWORD_RETURN(TYPEOF); }				// GCC
-	YY_BREAK
-case 87:
-YY_RULE_SETUP
-#line 254 "lex.ll"
-{ KEYWORD_RETURN(TYPEOF); }				// GCC
-	YY_BREAK
-case 88:
-YY_RULE_SETUP
-#line 255 "lex.ll"
-{ KEYWORD_RETURN(UNION); }
-	YY_BREAK
-case 89:
-YY_RULE_SETUP
-#line 256 "lex.ll"
-{ KEYWORD_RETURN(UNSIGNED); }
-	YY_BREAK
-case 90:
-YY_RULE_SETUP
-#line 257 "lex.ll"
-{ KEYWORD_RETURN(VOID); }
-	YY_BREAK
-case 91:
-YY_RULE_SETUP
-#line 258 "lex.ll"
-{ KEYWORD_RETURN(VOLATILE); }
-	YY_BREAK
-case 92:
-YY_RULE_SETUP
-#line 259 "lex.ll"
-{ KEYWORD_RETURN(VOLATILE); }			// GCC
-	YY_BREAK
-case 93:
-YY_RULE_SETUP
-#line 260 "lex.ll"
-{ KEYWORD_RETURN(VOLATILE); }			// GCC
-	YY_BREAK
-case 94:
-YY_RULE_SETUP
-#line 261 "lex.ll"
-{ KEYWORD_RETURN(WHILE); }
-	YY_BREAK
-/* identifier */
-case 95:
-YY_RULE_SETUP
-#line 264 "lex.ll"
-{ IDENTIFIER_RETURN(); }
-	YY_BREAK
-case 96:
-YY_RULE_SETUP
-#line 265 "lex.ll"
-{ ATTRIBUTE_RETURN(); }
-	YY_BREAK
-case 97:
-YY_RULE_SETUP
-#line 266 "lex.ll"
-{ BEGIN BKQUOTE; }
-	YY_BREAK
-case 98:
-YY_RULE_SETUP
-#line 267 "lex.ll"
-{ IDENTIFIER_RETURN(); }
-	YY_BREAK
-case 99:
-YY_RULE_SETUP
-#line 268 "lex.ll"
-{ BEGIN 0; }
-	YY_BREAK
-/* numeric constants */
-case 100:
-YY_RULE_SETUP
-#line 271 "lex.ll"
-{ NUMERIC_RETURN(ZERO); }				// CFA
-	YY_BREAK
-case 101:
-YY_RULE_SETUP
-#line 272 "lex.ll"
-{ NUMERIC_RETURN(ONE); }				// CFA
-	YY_BREAK
-case 102:
-YY_RULE_SETUP
-#line 273 "lex.ll"
-{ NUMERIC_RETURN(INTEGERconstant); }
-	YY_BREAK
-case 103:
-YY_RULE_SETUP
-#line 274 "lex.ll"
-{ NUMERIC_RETURN(INTEGERconstant); }
-	YY_BREAK
-case 104:
-YY_RULE_SETUP
-#line 275 "lex.ll"
-{ NUMERIC_RETURN(INTEGERconstant); }
-	YY_BREAK
-case 105:
-YY_RULE_SETUP
-#line 276 "lex.ll"
-{ NUMERIC_RETURN(FLOATINGconstant); }
-	YY_BREAK
-case 106:
-YY_RULE_SETUP
-#line 277 "lex.ll"
-{ NUMERIC_RETURN(FLOATINGconstant); }
-	YY_BREAK
-/* character constant, allows empty value */
-case 107:
-YY_RULE_SETUP
-#line 280 "lex.ll"
-{ BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
-	YY_BREAK
-case 108:
-YY_RULE_SETUP
-#line 281 "lex.ll"
-{ *strtext += std::string( yytext ); }
-	YY_BREAK
-case 109:
-/* rule 109 can match eol */
-YY_RULE_SETUP
-#line 282 "lex.ll"
-{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
-	YY_BREAK
-/* ' stop highlighting */
-/* string constant */
-case 110:
-YY_RULE_SETUP
-#line 286 "lex.ll"
-{ BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
-	YY_BREAK
-case 111:
-YY_RULE_SETUP
-#line 287 "lex.ll"
-{ *strtext += std::string( yytext ); }
-	YY_BREAK
-case 112:
-/* rule 112 can match eol */
-YY_RULE_SETUP
-#line 288 "lex.ll"
-{ BEGIN 0; *strtext += std::string( yytext ); RETURN_STR(STRINGliteral); }
-	YY_BREAK
-/* " stop highlighting */
-/* common character/string constant */
-case 113:
-YY_RULE_SETUP
-#line 292 "lex.ll"
-{ rm_underscore(); *strtext += std::string( yytext ); }
-	YY_BREAK
-case 114:
-/* rule 114 can match eol */
-YY_RULE_SETUP
-#line 293 "lex.ll"
-{}						// continuation (ALSO HANDLED BY CPP)
-	YY_BREAK
-case 115:
-YY_RULE_SETUP
-#line 294 "lex.ll"
-{ *strtext += std::string( yytext ); } // unknown escape character
-	YY_BREAK
-/* punctuation */
-case 116:
-YY_RULE_SETUP
-#line 297 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 117:
-YY_RULE_SETUP
-#line 298 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 118:
-YY_RULE_SETUP
-#line 299 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 119:
-YY_RULE_SETUP
-#line 300 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 120:
-YY_RULE_SETUP
-#line 301 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 121:
-YY_RULE_SETUP
-#line 302 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 122:
-YY_RULE_SETUP
-#line 303 "lex.ll"
-{ ASCIIOP_RETURN(); }					// also operator
-	YY_BREAK
-case 123:
-YY_RULE_SETUP
-#line 304 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 124:
-YY_RULE_SETUP
-#line 305 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 125:
-YY_RULE_SETUP
-#line 306 "lex.ll"
-{ ASCIIOP_RETURN(); }					// also operator
-	YY_BREAK
-case 126:
-YY_RULE_SETUP
-#line 307 "lex.ll"
-{ NAMEDOP_RETURN(ELLIPSIS); }
-	YY_BREAK
-/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
-case 127:
-YY_RULE_SETUP
-#line 310 "lex.ll"
-{ RETURN_VAL('['); }
-	YY_BREAK
-case 128:
-YY_RULE_SETUP
-#line 311 "lex.ll"
-{ RETURN_VAL(']'); }
-	YY_BREAK
-case 129:
-YY_RULE_SETUP
-#line 312 "lex.ll"
-{ RETURN_VAL('{'); }
-	YY_BREAK
-case 130:
-YY_RULE_SETUP
-#line 313 "lex.ll"
-{ RETURN_VAL('}'); }
-	YY_BREAK
-/* operators */
-case 131:
-YY_RULE_SETUP
-#line 316 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 132:
-YY_RULE_SETUP
-#line 317 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 133:
-YY_RULE_SETUP
-#line 318 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 134:
-YY_RULE_SETUP
-#line 319 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 135:
-YY_RULE_SETUP
-#line 320 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 136:
-YY_RULE_SETUP
-#line 321 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 137:
-YY_RULE_SETUP
-#line 322 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 138:
-YY_RULE_SETUP
-#line 323 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 139:
-YY_RULE_SETUP
-#line 324 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 140:
-YY_RULE_SETUP
-#line 325 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 141:
-YY_RULE_SETUP
-#line 326 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 142:
-YY_RULE_SETUP
-#line 327 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 143:
-YY_RULE_SETUP
-#line 328 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 144:
-YY_RULE_SETUP
-#line 329 "lex.ll"
-{ ASCIIOP_RETURN(); }
-	YY_BREAK
-case 145:
-YY_RULE_SETUP
-#line 331 "lex.ll"
-{ NAMEDOP_RETURN(ICR); }
-	YY_BREAK
-case 146:
-YY_RULE_SETUP
-#line 332 "lex.ll"
-{ NAMEDOP_RETURN(DECR); }
-	YY_BREAK
-case 147:
-YY_RULE_SETUP
-#line 333 "lex.ll"
-{ NAMEDOP_RETURN(EQ); }
-	YY_BREAK
-case 148:
-YY_RULE_SETUP
-#line 334 "lex.ll"
-{ NAMEDOP_RETURN(NE); }
-	YY_BREAK
-case 149:
-YY_RULE_SETUP
-#line 335 "lex.ll"
-{ NAMEDOP_RETURN(LS); }
-	YY_BREAK
-case 150:
-YY_RULE_SETUP
-#line 336 "lex.ll"
-{ NAMEDOP_RETURN(RS); }
-	YY_BREAK
-case 151:
-YY_RULE_SETUP
-#line 337 "lex.ll"
-{ NAMEDOP_RETURN(LE); }
-	YY_BREAK
-case 152:
-YY_RULE_SETUP
-#line 338 "lex.ll"
-{ NAMEDOP_RETURN(GE); }
-	YY_BREAK
-case 153:
-YY_RULE_SETUP
-#line 339 "lex.ll"
-{ NAMEDOP_RETURN(ANDAND); }
-	YY_BREAK
-case 154:
-YY_RULE_SETUP
-#line 340 "lex.ll"
-{ NAMEDOP_RETURN(OROR); }
-	YY_BREAK
-case 155:
-YY_RULE_SETUP
-#line 341 "lex.ll"
-{ NAMEDOP_RETURN(ARROW); }
-	YY_BREAK
-case 156:
-YY_RULE_SETUP
-#line 342 "lex.ll"
-{ NAMEDOP_RETURN(PLUSassign); }
-	YY_BREAK
-case 157:
-YY_RULE_SETUP
-#line 343 "lex.ll"
-{ NAMEDOP_RETURN(MINUSassign); }
-	YY_BREAK
-case 158:
-YY_RULE_SETUP
-#line 344 "lex.ll"
-{ NAMEDOP_RETURN(MULTassign); }
-	YY_BREAK
-case 159:
-YY_RULE_SETUP
-#line 345 "lex.ll"
-{ NAMEDOP_RETURN(DIVassign); }
-	YY_BREAK
-case 160:
-YY_RULE_SETUP
-#line 346 "lex.ll"
-{ NAMEDOP_RETURN(MODassign); }
-	YY_BREAK
-case 161:
-YY_RULE_SETUP
-#line 347 "lex.ll"
-{ NAMEDOP_RETURN(ANDassign); }
-	YY_BREAK
-case 162:
-YY_RULE_SETUP
-#line 348 "lex.ll"
-{ NAMEDOP_RETURN(ORassign); }
-	YY_BREAK
-case 163:
-YY_RULE_SETUP
-#line 349 "lex.ll"
-{ NAMEDOP_RETURN(ERassign); }
-	YY_BREAK
-case 164:
-YY_RULE_SETUP
-#line 350 "lex.ll"
-{ NAMEDOP_RETURN(LSassign); }
-	YY_BREAK
-case 165:
-YY_RULE_SETUP
-#line 351 "lex.ll"
-{ NAMEDOP_RETURN(RSassign); }
-	YY_BREAK
-/* CFA, operator identifier */
-case 166:
-YY_RULE_SETUP
-#line 354 "lex.ll"
-{ IDENTIFIER_RETURN(); }				// unary
-	YY_BREAK
-case 167:
-YY_RULE_SETUP
-#line 355 "lex.ll"
-{ IDENTIFIER_RETURN(); }
-	YY_BREAK
-case 168:
-YY_RULE_SETUP
-#line 356 "lex.ll"
-{ IDENTIFIER_RETURN(); }		// binary
-	YY_BREAK
-/*
-	  This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?"
-	  can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed
-	  to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator
-	  identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first
-	  case is for the function-call identifier "?()":
-
-	  int * ?()();	// declaration: space required after '*'
-	  * ?()();	// expression: space required after '*'
-
-	  Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning
-	  ahead to determine if there is a '(', which is the start of an argument/parameter list.
-
-	  The 4 remaining cases occur in expressions:
-
-	  i++?i:0;		// space required before '?'
-	  i--?i:0;		// space required before '?'
-	  i?++i:0;		// space required after '?'
-	  i?--i:0;		// space required after '?'
-
-	  In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or
-	  "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument
-	  list.  In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as
-	  "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of
-	  an argument list.
-	*/
-case 169:
-YY_RULE_SETUP
-#line 383 "lex.ll"
-{
-	// 1 or 2 character unary operator ?
-	int i = yytext[1] == '?' ? 1 : 2;
-	yyless( i );		// put back characters up to first '?'
-	if ( i > 1 ) {
-		NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR );
-	} else {
-		ASCIIOP_RETURN();
-	} // if
-}
-	YY_BREAK
-/* unknown characters */
-case 170:
-YY_RULE_SETUP
-#line 395 "lex.ll"
-{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
-	YY_BREAK
-case 171:
-YY_RULE_SETUP
-#line 397 "lex.ll"
-ECHO;
-	YY_BREAK
-#line 2675 "Parser/lex.cc"
-case YY_STATE_EOF(INITIAL):
-case YY_STATE_EOF(COMMENT):
-case YY_STATE_EOF(BKQUOTE):
-case YY_STATE_EOF(QUOTE):
-case YY_STATE_EOF(STRING):
-	yyterminate();
-
-	case YY_END_OF_BUFFER:
-		{
-		/* Amount of text matched not including the EOB char. */
-		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
-
-		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-		*yy_cp = (yy_hold_char);
-		YY_RESTORE_YY_MORE_OFFSET
-
-		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-			{
-			/* We're scanning a new file or input source.  It's
-			 * possible that this happened because the user
-			 * just pointed yyin at a new source and called
-			 * yylex().  If so, then we have to assure
-			 * consistency between YY_CURRENT_BUFFER and our
-			 * globals.  Here is the right place to do so, because
-			 * this is the first action (other than possibly a
-			 * back-up) that will match for the new input source.
-			 */
-			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-			}
-
-		/* Note that here we test for yy_c_buf_p "<=" to the position
-		 * of the first EOB in the buffer, since yy_c_buf_p will
-		 * already have been incremented past the NUL character
-		 * (since all states make transitions on EOB to the
-		 * end-of-buffer state).  Contrast this with the test
-		 * in input().
-		 */
-		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-			{ /* This was really a NUL. */
-			yy_state_type yy_next_state;
-
-			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
-
-			yy_current_state = yy_get_previous_state(  );
-
-			/* Okay, we're now positioned to make the NUL
-			 * transition.  We couldn't have
-			 * yy_get_previous_state() go ahead and do it
-			 * for us because it doesn't know how to deal
-			 * with the possibility of jamming (and we don't
-			 * want to build jamming into it because then it
-			 * will run more slowly).
-			 */
-
-			yy_next_state = yy_try_NUL_trans( yy_current_state );
-
-			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-
-			if ( yy_next_state )
-				{
-				/* Consume the NUL. */
-				yy_cp = ++(yy_c_buf_p);
-				yy_current_state = yy_next_state;
-				goto yy_match;
-				}
-
-			else
-				{
-				yy_cp = (yy_c_buf_p);
-				goto yy_find_action;
-				}
-			}
-
-		else switch ( yy_get_next_buffer(  ) )
-			{
-			case EOB_ACT_END_OF_FILE:
-				{
-				(yy_did_buffer_switch_on_eof) = 0;
-
-				if ( yywrap( ) )
-					{
-					/* Note: because we've taken care in
-					 * yy_get_next_buffer() to have set up
-					 * yytext, we can now set up
-					 * yy_c_buf_p so that if some total
-					 * hoser (like flex itself) wants to
-					 * call the scanner after we return the
-					 * YY_NULL, it'll still work - another
-					 * YY_NULL will get returned.
-					 */
-					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
-
-					yy_act = YY_STATE_EOF(YY_START);
-					goto do_action;
-					}
-
-				else
-					{
-					if ( ! (yy_did_buffer_switch_on_eof) )
-						YY_NEW_FILE;
-					}
-				break;
-				}
-
-			case EOB_ACT_CONTINUE_SCAN:
-				(yy_c_buf_p) =
-					(yytext_ptr) + yy_amount_of_matched_text;
-
-				yy_current_state = yy_get_previous_state(  );
-
-				yy_cp = (yy_c_buf_p);
-				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-				goto yy_match;
-
-			case EOB_ACT_LAST_MATCH:
-				(yy_c_buf_p) =
-				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
-
-				yy_current_state = yy_get_previous_state(  );
-
-				yy_cp = (yy_c_buf_p);
-				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-				goto yy_find_action;
-			}
-		break;
-		}
-
-	default:
-		YY_FATAL_ERROR(
-			"fatal flex scanner internal error--no action found" );
-	} /* end of action switch */
-		} /* end of scanning one token */
-} /* end of yylex */
-
-/* yy_get_next_buffer - try to read in a new buffer
- *
- * Returns a code representing an action:
- *	EOB_ACT_LAST_MATCH -
- *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *	EOB_ACT_END_OF_FILE - end of file
- */
-static int yy_get_next_buffer (void)
-{
-    	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-	register char *source = (yytext_ptr);
-	register int number_to_move, i;
-	int ret_val;
-
-	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
-		YY_FATAL_ERROR(
-		"fatal flex scanner internal error--end of buffer missed" );
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-		{ /* Don't try to fill the buffer, so this is an EOF. */
-		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
-			{
-			/* We matched a single character, the EOB, so
-			 * treat this as a final EOF.
-			 */
-			return EOB_ACT_END_OF_FILE;
-			}
-
-		else
-			{
-			/* We matched some text prior to the EOB, first
-			 * process it.
-			 */
-			return EOB_ACT_LAST_MATCH;
-			}
-		}
-
-	/* Try to read more data. */
-
-	/* First move last chars to start of buffer. */
-	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
-
-	for ( i = 0; i < number_to_move; ++i )
-		*(dest++) = *(source++);
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-		/* don't do the read, it's not guaranteed to return an EOF,
-		 * just force an EOF
-		 */
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
-
-	else
-		{
-			int num_to_read =
-			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
-		while ( num_to_read <= 0 )
-			{ /* Not enough room in the buffer - grow it. */
-
-			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
-
-			int yy_c_buf_p_offset =
-				(int) ((yy_c_buf_p) - b->yy_ch_buf);
-
-			if ( b->yy_is_our_buffer )
-				{
-				int new_size = b->yy_buf_size * 2;
-
-				if ( new_size <= 0 )
-					b->yy_buf_size += b->yy_buf_size / 8;
-				else
-					b->yy_buf_size *= 2;
-
-				b->yy_ch_buf = (char *)
-					/* Include room in for 2 EOB chars. */
-					yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
-				}
-			else
-				/* Can't grow it, we don't own it. */
-				b->yy_ch_buf = 0;
-
-			if ( ! b->yy_ch_buf )
-				YY_FATAL_ERROR(
-				"fatal error - scanner input buffer overflow" );
-
-			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
-
-			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-						number_to_move - 1;
-
-			}
-
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
-
-		/* Read in more data. */
-		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			(yy_n_chars), (size_t) num_to_read );
-
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-		}
-
-	if ( (yy_n_chars) == 0 )
-		{
-		if ( number_to_move == YY_MORE_ADJ )
-			{
-			ret_val = EOB_ACT_END_OF_FILE;
-			yyrestart(yyin  );
-			}
-
-		else
-			{
-			ret_val = EOB_ACT_LAST_MATCH;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
-			}
-		}
-
-	else
-		ret_val = EOB_ACT_CONTINUE_SCAN;
-
-	if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-		/* Extend the array by 50%, plus the number we really need. */
-		yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
-		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
-		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-	}
-
-	(yy_n_chars) += number_to_move;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
-
-	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
-	return ret_val;
-}
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-    static yy_state_type yy_get_previous_state (void)
-{
-	register yy_state_type yy_current_state;
-	register char *yy_cp;
-    
-	yy_current_state = (yy_start);
-	yy_current_state += YY_AT_BOL();
-
-	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
-		{
-		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-		if ( yy_accept[yy_current_state] )
-			{
-			(yy_last_accepting_state) = yy_current_state;
-			(yy_last_accepting_cpos) = yy_cp;
-			}
-		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-			{
-			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 826 )
-				yy_c = yy_meta[(unsigned int) yy_c];
-			}
-		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-		}
-
-	return yy_current_state;
-}
-
-/* yy_try_NUL_trans - try to make a transition on the NUL character
- *
- * synopsis
- *	next_state = yy_try_NUL_trans( current_state );
- */
-    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
-{
-	register int yy_is_jam;
-    	register char *yy_cp = (yy_c_buf_p);
-
-	register YY_CHAR yy_c = 1;
-	if ( yy_accept[yy_current_state] )
-		{
-		(yy_last_accepting_state) = yy_current_state;
-		(yy_last_accepting_cpos) = yy_cp;
-		}
-	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-		{
-		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 826 )
-			yy_c = yy_meta[(unsigned int) yy_c];
-		}
-	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 825);
-
-	return yy_is_jam ? 0 : yy_current_state;
-}
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-    static int yyinput (void)
-#else
-    static int input  (void)
-#endif
-
-{
-	int c;
-    
-	*(yy_c_buf_p) = (yy_hold_char);
-
-	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
-		{
-		/* yy_c_buf_p now points to the character we want to return.
-		 * If this occurs *before* the EOB characters, then it's a
-		 * valid NUL; if not, then we've hit the end of the buffer.
-		 */
-		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-			/* This was really a NUL. */
-			*(yy_c_buf_p) = '\0';
-
-		else
-			{ /* need more input */
-			int offset = (yy_c_buf_p) - (yytext_ptr);
-			++(yy_c_buf_p);
-
-			switch ( yy_get_next_buffer(  ) )
-				{
-				case EOB_ACT_LAST_MATCH:
-					/* This happens because yy_g_n_b()
-					 * sees that we've accumulated a
-					 * token and flags that we need to
-					 * try matching the token before
-					 * proceeding.  But for input(),
-					 * there's no matching to consider.
-					 * So convert the EOB_ACT_LAST_MATCH
-					 * to EOB_ACT_END_OF_FILE.
-					 */
-
-					/* Reset buffer status. */
-					yyrestart(yyin );
-
-					/*FALLTHROUGH*/
-
-				case EOB_ACT_END_OF_FILE:
-					{
-					if ( yywrap( ) )
-						return EOF;
-
-					if ( ! (yy_did_buffer_switch_on_eof) )
-						YY_NEW_FILE;
-#ifdef __cplusplus
-					return yyinput();
-#else
-					return input();
-#endif
-					}
-
-				case EOB_ACT_CONTINUE_SCAN:
-					(yy_c_buf_p) = (yytext_ptr) + offset;
-					break;
-				}
-			}
-		}
-
-	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
-	*(yy_c_buf_p) = '\0';	/* preserve yytext */
-	(yy_hold_char) = *++(yy_c_buf_p);
-
-	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
-		   
-    yylineno++;
-;
-
-	return c;
-}
-#endif	/* ifndef YY_NO_INPUT */
-
-/** Immediately switch to a different input stream.
- * @param input_file A readable stream.
- * 
- * @note This function does not reset the start condition to @c INITIAL .
- */
-    void yyrestart  (FILE * input_file )
-{
-    
-	if ( ! YY_CURRENT_BUFFER ){
-        yyensure_buffer_stack ();
-		YY_CURRENT_BUFFER_LVALUE =
-            yy_create_buffer(yyin,YY_BUF_SIZE );
-	}
-
-	yy_init_buffer(YY_CURRENT_BUFFER,input_file );
-	yy_load_buffer_state( );
-}
-
-/** Switch to a different input buffer.
- * @param new_buffer The new input buffer.
- * 
- */
-    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
-{
-    
-	/* TODO. We should be able to replace this entire function body
-	 * with
-	 *		yypop_buffer_state();
-	 *		yypush_buffer_state(new_buffer);
-     */
-	yyensure_buffer_stack ();
-	if ( YY_CURRENT_BUFFER == new_buffer )
-		return;
-
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*(yy_c_buf_p) = (yy_hold_char);
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-		}
-
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-	yy_load_buffer_state( );
-
-	/* We don't actually know whether we did this switch during
-	 * EOF (yywrap()) processing, but the only time this flag
-	 * is looked at is after yywrap() is called, so it's safe
-	 * to go ahead and always set it.
-	 */
-	(yy_did_buffer_switch_on_eof) = 1;
-}
-
-static void yy_load_buffer_state  (void)
-{
-    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-	(yy_hold_char) = *(yy_c_buf_p);
-}
-
-/** Allocate and initialize an input buffer state.
- * @param file A readable stream.
- * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
- * 
- * @return the allocated buffer state.
- */
-    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
-{
-	YY_BUFFER_STATE b;
-    
-	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
-	b->yy_buf_size = size;
-
-	/* yy_ch_buf has to be 2 characters longer than the size given because
-	 * we need to put in 2 end-of-buffer characters.
-	 */
-	b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
-	if ( ! b->yy_ch_buf )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
-	b->yy_is_our_buffer = 1;
-
-	yy_init_buffer(b,file );
-
-	return b;
-}
-
-/** Destroy the buffer.
- * @param b a buffer created with yy_create_buffer()
- * 
- */
-    void yy_delete_buffer (YY_BUFFER_STATE  b )
-{
-    
-	if ( ! b )
-		return;
-
-	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
-
-	if ( b->yy_is_our_buffer )
-		yyfree((void *) b->yy_ch_buf  );
-
-	yyfree((void *) b  );
-}
-
-#ifndef __cplusplus
-extern int isatty (int );
-#endif /* __cplusplus */
-    
-/* Initializes or reinitializes a buffer.
- * This function is sometimes called more than once on the same buffer,
- * such as during a yyrestart() or at EOF.
- */
-    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
-
-{
-	int oerrno = errno;
-    
-	yy_flush_buffer(b );
-
-	b->yy_input_file = file;
-	b->yy_fill_buffer = 1;
-
-    /* If b is the current buffer, then yy_init_buffer was _probably_
-     * called from yyrestart() or through yy_get_next_buffer.
-     * In that case, we don't want to reset the lineno or column.
-     */
-    if (b != YY_CURRENT_BUFFER){
-        b->yy_bs_lineno = 1;
-        b->yy_bs_column = 0;
-    }
-
-        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-    
-	errno = oerrno;
-}
-
-/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
- * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
- * 
- */
-    void yy_flush_buffer (YY_BUFFER_STATE  b )
-{
-    	if ( ! b )
-		return;
-
-	b->yy_n_chars = 0;
-
-	/* We always need two end-of-buffer characters.  The first causes
-	 * a transition to the end-of-buffer state.  The second causes
-	 * a jam in that state.
-	 */
-	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-
-	b->yy_buf_pos = &b->yy_ch_buf[0];
-
-	b->yy_at_bol = 1;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	if ( b == YY_CURRENT_BUFFER )
-		yy_load_buffer_state( );
-}
-
-/** Pushes the new state onto the stack. The new state becomes
- *  the current state. This function will allocate the stack
- *  if necessary.
- *  @param new_buffer The new state.
- *  
- */
-void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
-{
-    	if (new_buffer == NULL)
-		return;
-
-	yyensure_buffer_stack();
-
-	/* This block is copied from yy_switch_to_buffer. */
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*(yy_c_buf_p) = (yy_hold_char);
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-		}
-
-	/* Only push if top exists. Otherwise, replace top. */
-	if (YY_CURRENT_BUFFER)
-		(yy_buffer_stack_top)++;
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
-	/* copied from yy_switch_to_buffer. */
-	yy_load_buffer_state( );
-	(yy_did_buffer_switch_on_eof) = 1;
-}
-
-/** Removes and deletes the top of the stack, if present.
- *  The next element becomes the new top.
- *  
- */
-void yypop_buffer_state (void)
-{
-    	if (!YY_CURRENT_BUFFER)
-		return;
-
-	yy_delete_buffer(YY_CURRENT_BUFFER );
-	YY_CURRENT_BUFFER_LVALUE = NULL;
-	if ((yy_buffer_stack_top) > 0)
-		--(yy_buffer_stack_top);
-
-	if (YY_CURRENT_BUFFER) {
-		yy_load_buffer_state( );
-		(yy_did_buffer_switch_on_eof) = 1;
-	}
-}
-
-/* Allocates the stack if it does not exist.
- *  Guarantees space for at least one push.
- */
-static void yyensure_buffer_stack (void)
-{
-	int num_to_alloc;
-    
-	if (!(yy_buffer_stack)) {
-
-		/* First allocation is just for 2 elements, since we don't know if this
-		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
-		 * immediate realloc on the next call.
-         */
-		num_to_alloc = 1;
-		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
-								(num_to_alloc * sizeof(struct yy_buffer_state*)
-								);
-		if ( ! (yy_buffer_stack) )
-			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-								  
-		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-				
-		(yy_buffer_stack_max) = num_to_alloc;
-		(yy_buffer_stack_top) = 0;
-		return;
-	}
-
-	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
-
-		/* Increase the buffer to prepare for a possible push. */
-		int grow_size = 8 /* arbitrary grow size */;
-
-		num_to_alloc = (yy_buffer_stack_max) + grow_size;
-		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
-								((yy_buffer_stack),
-								num_to_alloc * sizeof(struct yy_buffer_state*)
-								);
-		if ( ! (yy_buffer_stack) )
-			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
-		/* zero only the new slots.*/
-		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
-		(yy_buffer_stack_max) = num_to_alloc;
-	}
-}
-
-/** Setup the input buffer state to scan directly from a user-specified character buffer.
- * @param base the character buffer
- * @param size the size in bytes of the character buffer
- * 
- * @return the newly allocated buffer state object. 
- */
-YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
-{
-	YY_BUFFER_STATE b;
-    
-	if ( size < 2 ||
-	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
-	     base[size-1] != YY_END_OF_BUFFER_CHAR )
-		/* They forgot to leave room for the EOB's. */
-		return 0;
-
-	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
-
-	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
-	b->yy_buf_pos = b->yy_ch_buf = base;
-	b->yy_is_our_buffer = 0;
-	b->yy_input_file = 0;
-	b->yy_n_chars = b->yy_buf_size;
-	b->yy_is_interactive = 0;
-	b->yy_at_bol = 1;
-	b->yy_fill_buffer = 0;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	yy_switch_to_buffer(b  );
-
-	return b;
-}
-
-/** Setup the input buffer state to scan a string. The next call to yylex() will
- * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
- * 
- * @return the newly allocated buffer state object.
- * @note If you want to scan bytes that may contain NUL values, then use
- *       yy_scan_bytes() instead.
- */
-YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
-{
-    
-	return yy_scan_bytes(yystr,strlen(yystr) );
-}
-
-/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
- * scan from a @e copy of @a bytes.
- * @param yybytes the byte buffer to scan
- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
- * 
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
-{
-	YY_BUFFER_STATE b;
-	char *buf;
-	yy_size_t n;
-	int i;
-    
-	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = _yybytes_len + 2;
-	buf = (char *) yyalloc(n  );
-	if ( ! buf )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
-
-	for ( i = 0; i < _yybytes_len; ++i )
-		buf[i] = yybytes[i];
-
-	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-
-	b = yy_scan_buffer(buf,n );
-	if ( ! b )
-		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
-
-	/* It's okay to grow etc. this buffer, and we should throw it
-	 * away when we're done.
-	 */
-	b->yy_is_our_buffer = 1;
-
-	return b;
-}
-
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
-
-static void yy_fatal_error (yyconst char* msg )
-{
-    	(void) fprintf( stderr, "%s\n", msg );
-	exit( YY_EXIT_FAILURE );
-}
-
-/* Redefine yyless() so it works in section 3 code. */
-
-#undef yyless
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		yytext[yyleng] = (yy_hold_char); \
-		(yy_c_buf_p) = yytext + yyless_macro_arg; \
-		(yy_hold_char) = *(yy_c_buf_p); \
-		*(yy_c_buf_p) = '\0'; \
-		yyleng = yyless_macro_arg; \
-		} \
-	while ( 0 )
-
-/* Accessor  methods (get/set functions) to struct members. */
-
-/** Get the current line number.
- * 
- */
-int yyget_lineno  (void)
-{
-        
-    return yylineno;
-}
-
-/** Get the input stream.
- * 
- */
-FILE *yyget_in  (void)
-{
-        return yyin;
-}
-
-/** Get the output stream.
- * 
- */
-FILE *yyget_out  (void)
-{
-        return yyout;
-}
-
-/** Get the length of the current token.
- * 
- */
-int yyget_leng  (void)
-{
-        return yyleng;
-}
-
-/** Get the current token.
- * 
- */
-
-char *yyget_text  (void)
-{
-        return yytext;
-}
-
-/** Set the current line number.
- * @param line_number
- * 
- */
-void yyset_lineno (int  line_number )
-{
-    
-    yylineno = line_number;
-}
-
-/** Set the input stream. This does not discard the current
- * input buffer.
- * @param in_str A readable stream.
- * 
- * @see yy_switch_to_buffer
- */
-void yyset_in (FILE *  in_str )
-{
-        yyin = in_str ;
-}
-
-void yyset_out (FILE *  out_str )
-{
-        yyout = out_str ;
-}
-
-int yyget_debug  (void)
-{
-        return yy_flex_debug;
-}
-
-void yyset_debug (int  bdebug )
-{
-        yy_flex_debug = bdebug ;
-}
-
-static int yy_init_globals (void)
-{
-        /* Initialization is the same as for the non-reentrant scanner.
-     * This function is called from yylex_destroy(), so don't allocate here.
-     */
-
-    /* We do not touch yylineno unless the option is enabled. */
-    yylineno =  1;
-    
-    (yy_buffer_stack) = 0;
-    (yy_buffer_stack_top) = 0;
-    (yy_buffer_stack_max) = 0;
-    (yy_c_buf_p) = (char *) 0;
-    (yy_init) = 0;
-    (yy_start) = 0;
-
-/* Defined in main.c */
-#ifdef YY_STDINIT
-    yyin = stdin;
-    yyout = stdout;
-#else
-    yyin = (FILE *) 0;
-    yyout = (FILE *) 0;
-#endif
-
-    /* For future reference: Set errno on error, since we are called by
-     * yylex_init()
-     */
-    return 0;
-}
-
-/* yylex_destroy is for both reentrant and non-reentrant scanners. */
-int yylex_destroy  (void)
-{
-    
-    /* Pop the buffer stack, destroying each element. */
-	while(YY_CURRENT_BUFFER){
-		yy_delete_buffer(YY_CURRENT_BUFFER  );
-		YY_CURRENT_BUFFER_LVALUE = NULL;
-		yypop_buffer_state();
-	}
-
-	/* Destroy the stack itself. */
-	yyfree((yy_buffer_stack) );
-	(yy_buffer_stack) = NULL;
-
-    /* Reset the globals. This is important in a non-reentrant scanner so the next time
-     * yylex() is called, initialization will occur. */
-    yy_init_globals( );
-
-    return 0;
-}
-
-/*
- * Internal utility routines.
- */
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
-{
-	register int i;
-	for ( i = 0; i < n; ++i )
-		s1[i] = s2[i];
-}
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * s )
-{
-	register int n;
-	for ( n = 0; s[n]; ++n )
-		;
-
-	return n;
-}
-#endif
-
-void *yyalloc (yy_size_t  size )
-{
-	return (void *) malloc( size );
-}
-
-void *yyrealloc  (void * ptr, yy_size_t  size )
-{
-	/* The cast to (char *) in the following accommodates both
-	 * implementations that use char* generic pointers, and those
-	 * that use void* generic pointers.  It works with the latter
-	 * because both ANSI C and C++ allow castless assignment from
-	 * any pointer type to void*, and deal with argument conversions
-	 * as though doing an assignment.
-	 */
-	return (void *) realloc( (char *) ptr, size );
-}
-
-void yyfree (void * ptr )
-{
-	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
-}
-
-#define YYTABLES_NAME "yytables"
-
-#line 397 "lex.ll"
-
-
-
-// Local Variables: //
-// mode: c++ //
-// tab-width: 4 //
-// compile-command: "make install" //
-// End: //
-
Index: src/Parser/lex.h
===================================================================
--- src/Parser/lex.h	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/lex.h	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep 22 08:58:10 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun  8 20:28:48 2015
-// Update Count     : 341
+// Last Modified On : Sat May 16 12:18:48 2015
+// Update Count     : 334
 //
 
@@ -18,5 +18,5 @@
 
 int yylex();
-void yyerror( const char * );
+void yyerror(char *);
 
 // External declarations for information sharing between lexer and scanner
@@ -35,5 +35,5 @@
 class Token {
   public:
-    std::string *str;									// must be pointer as used in union
+    std::string *str;
     Location loc;
 
@@ -44,4 +44,5 @@
 
 // Local Variables: //
+// fill-column: 110 //
 // tab-width: 4 //
 // mode: c++ //
Index: src/Parser/lex.l
===================================================================
--- src/Parser/lex.l	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
+++ src/Parser/lex.l	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -0,0 +1,406 @@
+/*
+ * Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+ *
+ * The contents of this file are covered under the licence agreement in the
+ * file "LICENCE" distributed with Cforall.
+ * 
+ * lex.l -- 
+ * 
+ * Author           : Peter A. Buhr
+ * Created On       : Sat Sep 22 08:58:10 2001
+ * Last Modified By : Peter A. Buhr
+ * Last Modified On : Tue May 19 15:41:54 2015
+ * Update Count     : 331
+ */
+
+%option yylineno
+
+%{
+// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor directive
+// have been performed and removed from the source. The only exceptions are preprocessor directives passed to
+// the compiler (e.g., line-number directives) and C/C++ style comments, which are ignored.
+
+//**************************** Includes and Defines ****************************
+
+#include <string>
+
+#include "lex.h"
+#include "ParseNode.h"
+#include "cfa.tab.h"									// YACC generated definitions based on C++ grammar
+
+char *yyfilename;
+std::string *strtext;									// accumulate parts of character and string constant value
+
+#define WHITE_RETURN(x)									// do nothing
+#define NEWLINE_RETURN()	WHITE_RETURN('\n')
+#define RETURN_VAL(x)		yylval.tok.str = new std::string(yytext); \
+		                        yylval.tok.loc.file = yyfilename; \
+		                        yylval.tok.loc.line = yylineno; \
+		                        return(x)
+#define RETURN_STR(x)		yylval.tok.str = strtext; \
+		                        yylval.tok.loc.file = yyfilename; \
+		                        yylval.tok.loc.line = yylineno; \
+		                        return(x)
+
+#define KEYWORD_RETURN(x)	RETURN_VAL(x)				// keyword
+#define IDENTIFIER_RETURN()	RETURN_VAL((typedefTable.isIdentifier(yytext) ? IDENTIFIER : typedefTable.isTypedef(yytext) ? TYPEDEFname : TYPEGENname))
+//#define ATTRIBUTE_RETURN()	RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname))
+#define ATTRIBUTE_RETURN()	RETURN_VAL(ATTR_IDENTIFIER)
+
+#define ASCIIOP_RETURN()	RETURN_VAL((int)yytext[0])	// single character operator
+#define NAMEDOP_RETURN(x)	RETURN_VAL(x)				// multichar operator, with a name
+
+#define NUMERIC_RETURN(x)	rm_underscore(); RETURN_VAL(x) // numeric constant
+
+void rm_underscore() {
+	// remove underscores in numeric constant
+	int j = 0;
+	for ( int i = 0; yytext[i] != '\0'; i += 1 ) {
+		if ( yytext[i] != '_' ) {
+			yytext[j] = yytext[i];
+			j += 1;
+		} // if
+	} // for
+	yyleng = j;
+	yytext[yyleng] = '\0';
+}
+
+%}
+
+octal [0-7]
+nonzero [1-9]
+decimal [0-9]
+hex [0-9a-fA-F]
+universal_char "\\"((u"_"?{hex_quad})|(U"_"?{hex_quad}{2}))
+
+				// identifier, GCC: $ in identifier
+identifier ([a-zA-Z_$]|{universal_char})([0-9a-zA-Z_$]|{universal_char})*
+
+				// quoted identifier
+quoted_identifier "`"{identifier}"`"
+
+				// attribute identifier, GCC: $ in identifier
+attr_identifier "@"{identifier}
+
+				// numeric constants, CFA: '_' in constant
+hex_quad {hex}("_"?{hex}){3}
+integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?)
+
+octal_digits ({octal})|({octal}({octal}|"_")*{octal})
+octal_prefix "0""_"?
+octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix}?
+
+nonzero_digits ({nonzero})|({nonzero}({decimal}|"_")*{decimal})
+decimal_constant {nonzero_digits}{integer_suffix}?
+
+hex_digits ({hex})|({hex}({hex}|"_")*{hex})
+hex_prefix "0"[xX]"_"?
+hex_constant {hex_prefix}{hex_digits}{integer_suffix}?
+
+decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
+fractional_constant ({decimal_digits}?"."{decimal_digits})|({decimal_digits}".")
+exponent "_"?[eE]"_"?[+-]?{decimal_digits}
+floating_suffix "_"?[flFL]
+floating_constant (({fractional_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix}?
+
+binary_exponent "_"?[pP]"_"?[+-]?{decimal_digits}
+hex_fractional_constant ({hex_digits}?"."{hex_digits})|({hex_digits}".")
+hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})|({hex_digits}{binary_exponent})){floating_suffix}?
+
+				// character escape sequence, GCC: \e => esc character
+simple_escape "\\"[abefnrtv'"?\\]
+				// ' stop highlighting
+octal_escape "\\"{octal}("_"?{octal}){0,2}
+hex_escape "\\""x""_"?{hex_digits}
+escape_seq {simple_escape}|{octal_escape}|{hex_escape}|{universal_char}
+
+				// display/white-space characters
+h_tab [\011]
+form_feed [\014]
+v_tab [\013]
+c_return [\015]
+h_white [ ]|{h_tab}
+
+				// operators
+op_unary_only "~"|"!"
+op_unary_binary "+"|"-"|"*"
+op_unary_pre_post "++"|"--"
+op_unary {op_unary_only}|{op_unary_binary}|{op_unary_pre_post}
+
+op_binary_only "/"|"%"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"&="|"|="|"^="|"<<="|">>="
+op_binary_over {op_unary_binary}|{op_binary_only}
+op_binary_not_over "?"|"->"|"&&"|"||"
+operator {op_unary_pre_post}|{op_binary_over}|{op_binary_not_over}
+
+%x COMMENT
+%x BKQUOTE
+%x QUOTE
+%x STRING
+
+%%
+				   /* line directives */
+^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["][^\n]*"\n" {
+	/* " stop highlighting */
+	char *end_num;
+	char *begin_string, *end_string;
+	char *filename;
+	long lineno, length;
+	lineno = strtol( yytext + 1, &end_num, 0 );
+	begin_string = strchr( end_num, '"' );
+	if ( begin_string ) {
+		end_string = strchr( begin_string + 1, '"' );
+		if ( end_string ) {
+			length = end_string - begin_string - 1;
+			filename = new char[ length + 1 ];
+			memcpy( filename, begin_string + 1, length );
+			filename[ length ] = '\0';
+			//std::cout << "file " << filename << " line " << lineno << std::endl;
+			yylineno = lineno;
+			yyfilename = filename;
+		} // if
+	} // if
+}
+
+				/* ignore preprocessor directives (for now) */
+^{h_white}*"#"[^\n]*"\n" ;
+
+				/* ignore C style comments */
+"/*"			{ BEGIN COMMENT; }
+<COMMENT>.|\n		;
+<COMMENT>"*/"		{ BEGIN 0; }
+
+				/* ignore C++ style comments */
+"//"[^\n]*"\n"		;
+
+				/* ignore whitespace */
+{h_white}+		{ WHITE_RETURN(' '); }
+({v_tab}|{c_return}|{form_feed})+ { WHITE_RETURN(' '); }
+({h_white}|{v_tab}|{c_return}|{form_feed})*"\n" { NEWLINE_RETURN(); }
+
+				/* keywords */
+_Alignas		{ KEYWORD_RETURN(ALIGNAS); }			// C11
+_Alignof		{ KEYWORD_RETURN(ALIGNOF); }			// C11
+__alignof		{ KEYWORD_RETURN(ALIGNOF); }			// GCC
+__alignof__		{ KEYWORD_RETURN(ALIGNOF); }			// GCC
+asm				{ KEYWORD_RETURN(ASM); }
+__asm			{ KEYWORD_RETURN(ASM); }				// GCC
+__asm__			{ KEYWORD_RETURN(ASM); }				// GCC
+_Atomic			{ KEYWORD_RETURN(ATOMIC); }				// C11
+__attribute		{ KEYWORD_RETURN(ATTRIBUTE); }			// GCC
+__attribute__	{ KEYWORD_RETURN(ATTRIBUTE); }			// GCC
+auto			{ KEYWORD_RETURN(AUTO); }
+_Bool			{ KEYWORD_RETURN(BOOL); }				// C99
+break			{ KEYWORD_RETURN(BREAK); }
+case			{ KEYWORD_RETURN(CASE); }
+catch			{ KEYWORD_RETURN(CATCH); }				// CFA
+char			{ KEYWORD_RETURN(CHAR); }
+choose			{ KEYWORD_RETURN(CHOOSE); }				// CFA
+_Complex		{ KEYWORD_RETURN(COMPLEX); }			// C99
+__complex		{ KEYWORD_RETURN(COMPLEX); }			// GCC
+__complex__		{ KEYWORD_RETURN(COMPLEX); }			// GCC
+const			{ KEYWORD_RETURN(CONST); }
+__const			{ KEYWORD_RETURN(CONST); }				// GCC
+__const__		{ KEYWORD_RETURN(CONST); }				// GCC
+context			{ KEYWORD_RETURN(CONTEXT); }			// CFA
+continue		{ KEYWORD_RETURN(CONTINUE); }
+default			{ KEYWORD_RETURN(DEFAULT); }
+do				{ KEYWORD_RETURN(DO); }
+double			{ KEYWORD_RETURN(DOUBLE); }
+dtype			{ KEYWORD_RETURN(DTYPE); }				// CFA
+else			{ KEYWORD_RETURN(ELSE); }
+enum			{ KEYWORD_RETURN(ENUM); }
+__extension__	{ KEYWORD_RETURN(EXTENSION); }			// GCC
+extern			{ KEYWORD_RETURN(EXTERN); }
+fallthru		{ KEYWORD_RETURN(FALLTHRU); }			// CFA
+finally			{ KEYWORD_RETURN(FINALLY); }			// CFA
+float			{ KEYWORD_RETURN(FLOAT); }
+__float128		{ KEYWORD_RETURN(FLOAT); }				// GCC
+for				{ KEYWORD_RETURN(FOR); }
+forall			{ KEYWORD_RETURN(FORALL); }				// CFA
+fortran			{ KEYWORD_RETURN(FORTRAN); }
+ftype			{ KEYWORD_RETURN(FTYPE); }				// CFA
+_Generic		{ KEYWORD_RETURN(GENERIC); }			// C11
+goto			{ KEYWORD_RETURN(GOTO); }
+if				{ KEYWORD_RETURN(IF); }
+_Imaginary		{ KEYWORD_RETURN(IMAGINARY); }			// C99
+__imag			{ KEYWORD_RETURN(IMAGINARY); }			// GCC
+__imag__		{ KEYWORD_RETURN(IMAGINARY); }			// GCC
+inline			{ KEYWORD_RETURN(INLINE); }				// C99
+__inline		{ KEYWORD_RETURN(INLINE); }				// GCC
+__inline__		{ KEYWORD_RETURN(INLINE); }				// GCC
+int				{ KEYWORD_RETURN(INT); }
+__int128		{ KEYWORD_RETURN(INT); }				// GCC
+__label__		{ KEYWORD_RETURN(LABEL); }				// GCC
+long			{ KEYWORD_RETURN(LONG); }
+lvalue			{ KEYWORD_RETURN(LVALUE); }				// CFA
+_Noreturn		{ KEYWORD_RETURN(NORETURN); }			// C11
+register		{ KEYWORD_RETURN(REGISTER); }
+restrict		{ KEYWORD_RETURN(RESTRICT); }			// C99
+__restrict		{ KEYWORD_RETURN(RESTRICT); }			// GCC
+__restrict__	{ KEYWORD_RETURN(RESTRICT); }			// GCC
+return			{ KEYWORD_RETURN(RETURN); }
+short			{ KEYWORD_RETURN(SHORT); }
+signed			{ KEYWORD_RETURN(SIGNED); }
+__signed		{ KEYWORD_RETURN(SIGNED); }				// GCC
+__signed__		{ KEYWORD_RETURN(SIGNED); }				// GCC
+sizeof			{ KEYWORD_RETURN(SIZEOF); }
+static			{ KEYWORD_RETURN(STATIC); }
+_Static_assert	{ KEYWORD_RETURN(STATICASSERT); }		// C11
+struct			{ KEYWORD_RETURN(STRUCT); }
+switch			{ KEYWORD_RETURN(SWITCH); }
+_Thread_local	{ KEYWORD_RETURN(THREADLOCAL); }		// C11
+throw			{ KEYWORD_RETURN(THROW); }				// CFA
+try				{ KEYWORD_RETURN(TRY); }				// CFA
+type			{ KEYWORD_RETURN(TYPE); }				// CFA
+typedef			{ KEYWORD_RETURN(TYPEDEF); }
+typeof			{ KEYWORD_RETURN(TYPEOF); }				// GCC
+__typeof		{ KEYWORD_RETURN(TYPEOF); }				// GCC
+__typeof__		{ KEYWORD_RETURN(TYPEOF); }				// GCC
+union			{ KEYWORD_RETURN(UNION); }
+unsigned		{ KEYWORD_RETURN(UNSIGNED); }
+void			{ KEYWORD_RETURN(VOID); }
+volatile		{ KEYWORD_RETURN(VOLATILE); }
+__volatile		{ KEYWORD_RETURN(VOLATILE); }			// GCC
+__volatile__	{ KEYWORD_RETURN(VOLATILE); }			// GCC
+while			{ KEYWORD_RETURN(WHILE); }
+
+				/* identifier */
+{identifier}	{ IDENTIFIER_RETURN(); }
+{attr_identifier} { ATTRIBUTE_RETURN(); }
+"`"			{ BEGIN BKQUOTE; }
+<BKQUOTE>{identifier} { IDENTIFIER_RETURN(); }
+<BKQUOTE>"`"	{ BEGIN 0; }
+
+				/* numeric constants */
+"0"				{ NUMERIC_RETURN(ZERO); }				// CFA
+"1"				{ NUMERIC_RETURN(ONE); }				// CFA
+{decimal_constant}	{ NUMERIC_RETURN(INTEGERconstant); }
+{octal_constant}	{ NUMERIC_RETURN(INTEGERconstant); }
+{hex_constant}		{ NUMERIC_RETURN(INTEGERconstant); }
+{floating_constant}	{ NUMERIC_RETURN(FLOATINGconstant); }
+{hex_floating_constant}	{ NUMERIC_RETURN(FLOATINGconstant); }
+
+				/* character constant, allows empty value */
+"L"?"_"?[']		{ BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
+<QUOTE>[^'\\\n]* { *strtext += std::string( yytext ); }
+<QUOTE>['\n]	{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
+				/* ' stop highlighting */
+
+				/* string constant */
+"L"?"_"?["]		{ BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
+<STRING>[^"\\\n]* { *strtext += std::string( yytext ); }
+<STRING>["\n]	{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(STRINGliteral); }
+				/* " stop highlighting */
+
+<QUOTE,STRING>{escape_seq} { rm_underscore(); *strtext += std::string( yytext ); }
+<QUOTE,STRING>[\\]	{ *strtext += std::string( yytext ); } // unknown escape character
+
+				/* punctuation */
+"["				{ ASCIIOP_RETURN(); }
+"]"				{ ASCIIOP_RETURN(); }
+"("				{ ASCIIOP_RETURN(); }
+")"				{ ASCIIOP_RETURN(); }
+"{"				{ ASCIIOP_RETURN(); }
+"}"				{ ASCIIOP_RETURN(); }
+","				{ ASCIIOP_RETURN(); }					// also operator
+":"				{ ASCIIOP_RETURN(); }
+";"				{ ASCIIOP_RETURN(); }
+"."				{ ASCIIOP_RETURN(); }					// also operator
+"..."			{ NAMEDOP_RETURN(ELLIPSIS); }
+
+				/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
+"<:"			{ RETURN_VAL('['); }
+":>"			{ RETURN_VAL(']'); }
+"<%"			{ RETURN_VAL('{'); }
+"%>"			{ RETURN_VAL('}'); }
+
+				/* operators */
+"!"				{ ASCIIOP_RETURN(); }
+"+"				{ ASCIIOP_RETURN(); }
+"-"				{ ASCIIOP_RETURN(); }
+"*"				{ ASCIIOP_RETURN(); }
+"/"				{ ASCIIOP_RETURN(); }
+"%"				{ ASCIIOP_RETURN(); }
+"^"				{ ASCIIOP_RETURN(); }
+"~"				{ ASCIIOP_RETURN(); }
+"&"				{ ASCIIOP_RETURN(); }
+"|"				{ ASCIIOP_RETURN(); }
+"<"				{ ASCIIOP_RETURN(); }
+">"				{ ASCIIOP_RETURN(); }
+"="				{ ASCIIOP_RETURN(); }
+"?"				{ ASCIIOP_RETURN(); }
+
+"++"			{ NAMEDOP_RETURN(ICR); }
+"--"			{ NAMEDOP_RETURN(DECR); }
+"=="			{ NAMEDOP_RETURN(EQ); }
+"!="			{ NAMEDOP_RETURN(NE); }
+"<<"			{ NAMEDOP_RETURN(LS); }
+">>"			{ NAMEDOP_RETURN(RS); }
+"<="			{ NAMEDOP_RETURN(LE); }
+">="			{ NAMEDOP_RETURN(GE); }
+"&&"			{ NAMEDOP_RETURN(ANDAND); }
+"||"			{ NAMEDOP_RETURN(OROR); }
+"->"			{ NAMEDOP_RETURN(ARROW); }
+"+="			{ NAMEDOP_RETURN(PLUSassign); }
+"-="			{ NAMEDOP_RETURN(MINUSassign); }
+"*="			{ NAMEDOP_RETURN(MULTassign); }
+"/="			{ NAMEDOP_RETURN(DIVassign); }
+"%="			{ NAMEDOP_RETURN(MODassign); }
+"&="			{ NAMEDOP_RETURN(ANDassign); }
+"|="			{ NAMEDOP_RETURN(ORassign); }
+"^="			{ NAMEDOP_RETURN(ERassign); }
+"<<="			{ NAMEDOP_RETURN(LSassign); }
+">>="			{ NAMEDOP_RETURN(RSassign); }
+
+				/* CFA, operator identifier */
+{op_unary}"?"	{ IDENTIFIER_RETURN(); }				// unary
+"?"({op_unary_pre_post}|"()"|"[?]") { IDENTIFIER_RETURN(); }
+"?"{op_binary_over}"?"	{ IDENTIFIER_RETURN(); }		// binary
+	/*
+	  This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?"
+	  can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed
+	  to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator
+	  identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first
+	  case is for the function-call identifier "?()":
+
+	  int * ?()();	// declaration: space required after '*'
+	  * ?()();	// expression: space required after '*'
+
+	  Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning
+	  ahead to determine if there is a '(', which is the start of an argument/parameter list.
+
+	  The 4 remaining cases occur in expressions:
+
+	  i++?i:0;		// space required before '?'
+	  i--?i:0;		// space required before '?'
+	  i?++i:0;		// space required after '?'
+	  i?--i:0;		// space required after '?'
+
+	  In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or
+	  "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument
+	  list.  In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as
+	  "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of
+	  an argument list.
+	*/
+{op_unary}"?"(({op_unary_pre_post}|"[?]")|({op_binary_over}"?")) {
+	// 1 or 2 character unary operator ?
+	int i = yytext[1] == '?' ? 1 : 2;
+	yyless( i );		// put back characters up to first '?'
+	if ( i > 1 ) {
+		NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR );
+	} else {
+		ASCIIOP_RETURN();
+	} // if
+}
+
+				/* unknown characters */
+.			{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
+
+%%
+
+// Local Variables: //
+// fill-column: 110 //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/Parser/lex.ll
===================================================================
--- src/Parser/lex.ll	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ 	(revision )
@@ -1,403 +1,0 @@
-/*
- * Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
- *
- * The contents of this file are covered under the licence agreement in the
- * file "LICENCE" distributed with Cforall.
- * 
- * lex.l -- 
- * 
- * Author           : Peter A. Buhr
- * Created On       : Sat Sep 22 08:58:10 2001
- * Last Modified By : Peter A. Buhr
- * Last Modified On : Fri Jun 19 11:10:14 2015
- * Update Count     : 392
- */
-
-%option yylineno
-%option nounput
-
-%{
-// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor directive have been
-// performed and removed from the source. The only exceptions are preprocessor directives passed to the compiler (e.g.,
-// line-number directives) and C/C++ style comments, which are ignored.
-
-//**************************** Includes and Defines ****************************
-
-#include <string>
-
-#include "lex.h"
-#include "ParseNode.h"
-#include "parser.h"										// YACC generated definitions based on C++ grammar
-
-char *yyfilename;
-std::string *strtext;									// accumulate parts of character and string constant value
-
-#define RETURN_LOCN(x)		yylval.tok.loc.file = yyfilename; yylval.tok.loc.line = yylineno; return( x )
-#define RETURN_VAL(x)		yylval.tok.str = new std::string( yytext ); RETURN_LOCN( x )
-#define RETURN_CHAR(x)		yylval.tok.str = NULL; RETURN_LOCN( x )
-#define RETURN_STR(x)		yylval.tok.str = strtext; RETURN_LOCN( x )
-
-#define WHITE_RETURN(x)									// do nothing
-#define NEWLINE_RETURN()	WHITE_RETURN( '\n' )
-#define ASCIIOP_RETURN()	RETURN_CHAR( (int)yytext[0] ) // single character operator
-#define NAMEDOP_RETURN(x)	RETURN_VAL( x )				// multichar operator, with a name
-#define NUMERIC_RETURN(x)	rm_underscore(); RETURN_VAL( x ) // numeric constant
-#define KEYWORD_RETURN(x)	RETURN_CHAR( x )			// keyword
-#define IDENTIFIER_RETURN()	RETURN_VAL( (typedefTable.isIdentifier( yytext ) ? IDENTIFIER : typedefTable.isTypedef( yytext ) ? TYPEDEFname : TYPEGENname ) )
-#define ATTRIBUTE_RETURN()	RETURN_VAL( ATTR_IDENTIFIER )
-
-void rm_underscore() {
-	// remove underscores in numeric constant
-	int j = 0;
-	for ( int i = 0; yytext[i] != '\0'; i += 1 ) {
-		if ( yytext[i] != '_' ) {
-			yytext[j] = yytext[i];
-			j += 1;
-		} // if
-	} // for
-	yyleng = j;
-	yytext[yyleng] = '\0';
-}
-
-%}
-
-octal [0-7]
-nonzero [1-9]
-decimal [0-9]
-hex [0-9a-fA-F]
-universal_char "\\"((u"_"?{hex_quad})|(U"_"?{hex_quad}{2}))
-
-				// identifier, GCC: $ in identifier
-identifier ([a-zA-Z_$]|{universal_char})([0-9a-zA-Z_$]|{universal_char})*
-
-				// quoted identifier
-quoted_identifier "`"{identifier}"`"
-
-				// attribute identifier, GCC: $ in identifier
-attr_identifier "@"{identifier}
-
-				// numeric constants, CFA: '_' in constant
-hex_quad {hex}("_"?{hex}){3}
-integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?)
-
-octal_digits ({octal})|({octal}({octal}|"_")*{octal})
-octal_prefix "0""_"?
-octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix}?
-
-nonzero_digits ({nonzero})|({nonzero}({decimal}|"_")*{decimal})
-decimal_constant {nonzero_digits}{integer_suffix}?
-
-hex_digits ({hex})|({hex}({hex}|"_")*{hex})
-hex_prefix "0"[xX]"_"?
-hex_constant {hex_prefix}{hex_digits}{integer_suffix}?
-
-decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
-fractional_constant ({decimal_digits}?"."{decimal_digits})|({decimal_digits}".")
-exponent "_"?[eE]"_"?[+-]?{decimal_digits}
-floating_suffix "_"?[flFL]
-floating_constant (({fractional_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix}?
-
-binary_exponent "_"?[pP]"_"?[+-]?{decimal_digits}
-hex_fractional_constant ({hex_digits}?"."{hex_digits})|({hex_digits}".")
-hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})|({hex_digits}{binary_exponent})){floating_suffix}?
-
-				// character escape sequence, GCC: \e => esc character
-simple_escape "\\"[abefnrtv'"?\\]
-				// ' stop highlighting
-octal_escape "\\"{octal}("_"?{octal}){0,2}
-hex_escape "\\""x""_"?{hex_digits}
-escape_seq {simple_escape}|{octal_escape}|{hex_escape}|{universal_char}
-cwide_prefix "L"|"U"|"u"
-swide_prefix {cwide_prefix}|"u8"
-
-				// display/white-space characters
-h_tab [\011]
-form_feed [\014]
-v_tab [\013]
-c_return [\015]
-h_white [ ]|{h_tab}
-
-				// operators
-op_unary_only "~"|"!"
-op_unary_binary "+"|"-"|"*"
-op_unary_pre_post "++"|"--"
-op_unary {op_unary_only}|{op_unary_binary}|{op_unary_pre_post}
-
-op_binary_only "/"|"%"|"^"|"&"|"|"|"<"|">"|"="|"=="|"!="|"<<"|">>"|"<="|">="|"+="|"-="|"*="|"/="|"%="|"&="|"|="|"^="|"<<="|">>="
-op_binary_over {op_unary_binary}|{op_binary_only}
-op_binary_not_over "?"|"->"|"&&"|"||"
-operator {op_unary_pre_post}|{op_binary_over}|{op_binary_not_over}
-
-%x COMMENT
-%x BKQUOTE
-%x QUOTE
-%x STRING
-
-%%
-				   /* line directives */
-^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["][^\n]*"\n" {
-	/* " stop highlighting */
-	char *end_num;
-	char *begin_string, *end_string;
-	char *filename;
-	long lineno, length;
-	lineno = strtol( yytext + 1, &end_num, 0 );
-	begin_string = strchr( end_num, '"' );
-	if ( begin_string ) {
-		end_string = strchr( begin_string + 1, '"' );
-		if ( end_string ) {
-			length = end_string - begin_string - 1;
-			filename = new char[ length + 1 ];
-			memcpy( filename, begin_string + 1, length );
-			filename[ length ] = '\0';
-			//std::cout << "file " << filename << " line " << lineno << std::endl;
-			yylineno = lineno;
-			yyfilename = filename;
-		} // if
-	} // if
-}
-
-				/* ignore preprocessor directives (for now) */
-^{h_white}*"#"[^\n]*"\n" ;
-
-				/* ignore C style comments (ALSO HANDLED BY CPP) */
-"/*"			{ BEGIN COMMENT; }
-<COMMENT>.|\n	;
-<COMMENT>"*/"	{ BEGIN 0; }
-
-				/* ignore C++ style comments (ALSO HANDLED BY CPP) */
-"//"[^\n]*"\n"	;
-
-				/* ignore whitespace */
-{h_white}+		{ WHITE_RETURN(' '); }
-({v_tab}|{c_return}|{form_feed})+ { WHITE_RETURN(' '); }
-({h_white}|{v_tab}|{c_return}|{form_feed})*"\n" { NEWLINE_RETURN(); }
-
-				/* keywords */
-_Alignas		{ KEYWORD_RETURN(ALIGNAS); }			// C11
-_Alignof		{ KEYWORD_RETURN(ALIGNOF); }			// C11
-__alignof		{ KEYWORD_RETURN(ALIGNOF); }			// GCC
-__alignof__		{ KEYWORD_RETURN(ALIGNOF); }			// GCC
-asm				{ KEYWORD_RETURN(ASM); }
-__asm			{ KEYWORD_RETURN(ASM); }				// GCC
-__asm__			{ KEYWORD_RETURN(ASM); }				// GCC
-_Atomic			{ KEYWORD_RETURN(ATOMIC); }				// C11
-__attribute		{ KEYWORD_RETURN(ATTRIBUTE); }			// GCC
-__attribute__	{ KEYWORD_RETURN(ATTRIBUTE); }			// GCC
-auto			{ KEYWORD_RETURN(AUTO); }
-_Bool			{ KEYWORD_RETURN(BOOL); }				// C99
-break			{ KEYWORD_RETURN(BREAK); }
-case			{ KEYWORD_RETURN(CASE); }
-catch			{ KEYWORD_RETURN(CATCH); }				// CFA
-char			{ KEYWORD_RETURN(CHAR); }
-choose			{ KEYWORD_RETURN(CHOOSE); }				// CFA
-_Complex		{ KEYWORD_RETURN(COMPLEX); }			// C99
-__complex		{ KEYWORD_RETURN(COMPLEX); }			// GCC
-__complex__		{ KEYWORD_RETURN(COMPLEX); }			// GCC
-const			{ KEYWORD_RETURN(CONST); }
-__const			{ KEYWORD_RETURN(CONST); }				// GCC
-__const__		{ KEYWORD_RETURN(CONST); }				// GCC
-context			{ KEYWORD_RETURN(CONTEXT); }			// CFA
-continue		{ KEYWORD_RETURN(CONTINUE); }
-default			{ KEYWORD_RETURN(DEFAULT); }
-do				{ KEYWORD_RETURN(DO); }
-double			{ KEYWORD_RETURN(DOUBLE); }
-dtype			{ KEYWORD_RETURN(DTYPE); }				// CFA
-else			{ KEYWORD_RETURN(ELSE); }
-enum			{ KEYWORD_RETURN(ENUM); }
-__extension__	{ KEYWORD_RETURN(EXTENSION); }			// GCC
-extern			{ KEYWORD_RETURN(EXTERN); }
-fallthru		{ KEYWORD_RETURN(FALLTHRU); }			// CFA
-finally			{ KEYWORD_RETURN(FINALLY); }			// CFA
-float			{ KEYWORD_RETURN(FLOAT); }
-__float128		{ KEYWORD_RETURN(FLOAT); }				// GCC
-for				{ KEYWORD_RETURN(FOR); }
-forall			{ KEYWORD_RETURN(FORALL); }				// CFA
-fortran			{ KEYWORD_RETURN(FORTRAN); }
-ftype			{ KEYWORD_RETURN(FTYPE); }				// CFA
-_Generic		{ KEYWORD_RETURN(GENERIC); }			// C11
-goto			{ KEYWORD_RETURN(GOTO); }
-if				{ KEYWORD_RETURN(IF); }
-_Imaginary		{ KEYWORD_RETURN(IMAGINARY); }			// C99
-__imag			{ KEYWORD_RETURN(IMAGINARY); }			// GCC
-__imag__		{ KEYWORD_RETURN(IMAGINARY); }			// GCC
-inline			{ KEYWORD_RETURN(INLINE); }				// C99
-__inline		{ KEYWORD_RETURN(INLINE); }				// GCC
-__inline__		{ KEYWORD_RETURN(INLINE); }				// GCC
-int				{ KEYWORD_RETURN(INT); }
-__int128		{ KEYWORD_RETURN(INT); }				// GCC
-__label__		{ KEYWORD_RETURN(LABEL); }				// GCC
-long			{ KEYWORD_RETURN(LONG); }
-lvalue			{ KEYWORD_RETURN(LVALUE); }				// CFA
-_Noreturn		{ KEYWORD_RETURN(NORETURN); }			// C11
-register		{ KEYWORD_RETURN(REGISTER); }
-restrict		{ KEYWORD_RETURN(RESTRICT); }			// C99
-__restrict		{ KEYWORD_RETURN(RESTRICT); }			// GCC
-__restrict__	{ KEYWORD_RETURN(RESTRICT); }			// GCC
-return			{ KEYWORD_RETURN(RETURN); }
-short			{ KEYWORD_RETURN(SHORT); }
-signed			{ KEYWORD_RETURN(SIGNED); }
-__signed		{ KEYWORD_RETURN(SIGNED); }				// GCC
-__signed__		{ KEYWORD_RETURN(SIGNED); }				// GCC
-sizeof			{ KEYWORD_RETURN(SIZEOF); }
-static			{ KEYWORD_RETURN(STATIC); }
-_Static_assert	{ KEYWORD_RETURN(STATICASSERT); }		// C11
-struct			{ KEYWORD_RETURN(STRUCT); }
-switch			{ KEYWORD_RETURN(SWITCH); }
-_Thread_local	{ KEYWORD_RETURN(THREADLOCAL); }		// C11
-throw			{ KEYWORD_RETURN(THROW); }				// CFA
-try				{ KEYWORD_RETURN(TRY); }				// CFA
-type			{ KEYWORD_RETURN(TYPE); }				// CFA
-typedef			{ KEYWORD_RETURN(TYPEDEF); }
-typeof			{ KEYWORD_RETURN(TYPEOF); }				// GCC
-__typeof		{ KEYWORD_RETURN(TYPEOF); }				// GCC
-__typeof__		{ KEYWORD_RETURN(TYPEOF); }				// GCC
-union			{ KEYWORD_RETURN(UNION); }
-unsigned		{ KEYWORD_RETURN(UNSIGNED); }
-void			{ KEYWORD_RETURN(VOID); }
-volatile		{ KEYWORD_RETURN(VOLATILE); }
-__volatile		{ KEYWORD_RETURN(VOLATILE); }			// GCC
-__volatile__	{ KEYWORD_RETURN(VOLATILE); }			// GCC
-while			{ KEYWORD_RETURN(WHILE); }
-
-				/* identifier */
-{identifier}	{ IDENTIFIER_RETURN(); }
-{attr_identifier} { ATTRIBUTE_RETURN(); }
-"`"			{ BEGIN BKQUOTE; }
-<BKQUOTE>{identifier} { IDENTIFIER_RETURN(); }
-<BKQUOTE>"`"	{ BEGIN 0; }
-
-				/* numeric constants */
-"0"				{ NUMERIC_RETURN(ZERO); }				// CFA
-"1"				{ NUMERIC_RETURN(ONE); }				// CFA
-{decimal_constant} { NUMERIC_RETURN(INTEGERconstant); }
-{octal_constant} { NUMERIC_RETURN(INTEGERconstant); }
-{hex_constant}	{ NUMERIC_RETURN(INTEGERconstant); }
-{floating_constant}	{ NUMERIC_RETURN(FLOATINGconstant); }
-{hex_floating_constant}	{ NUMERIC_RETURN(FLOATINGconstant); }
-
-				/* character constant, allows empty value */
-({cwide_prefix}[_]?)?['] { BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
-<QUOTE>[^'\\\n]* { *strtext += std::string( yytext ); }
-<QUOTE>['\n]	{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
-				/* ' stop highlighting */
-
-				/* string constant */
-({swide_prefix}[_]?)?["] { BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
-<STRING>[^"\\\n]* { *strtext += std::string( yytext ); }
-<STRING>["\n]	{ BEGIN 0; *strtext += std::string( yytext ); RETURN_STR(STRINGliteral); }
-				/* " stop highlighting */
-
-				/* common character/string constant */
-<QUOTE,STRING>{escape_seq} { rm_underscore(); *strtext += std::string( yytext ); }
-<QUOTE,STRING>"\\"{h_white}*"\n" {}						// continuation (ALSO HANDLED BY CPP)
-<QUOTE,STRING>"\\" { *strtext += std::string( yytext ); } // unknown escape character
-
-				/* punctuation */
-"["				{ ASCIIOP_RETURN(); }
-"]"				{ ASCIIOP_RETURN(); }
-"("				{ ASCIIOP_RETURN(); }
-")"				{ ASCIIOP_RETURN(); }
-"{"				{ ASCIIOP_RETURN(); }
-"}"				{ ASCIIOP_RETURN(); }
-","				{ ASCIIOP_RETURN(); }					// also operator
-":"				{ ASCIIOP_RETURN(); }
-";"				{ ASCIIOP_RETURN(); }
-"."				{ ASCIIOP_RETURN(); }					// also operator
-"..."			{ NAMEDOP_RETURN(ELLIPSIS); }
-
-				/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
-"<:"			{ RETURN_VAL('['); }
-":>"			{ RETURN_VAL(']'); }
-"<%"			{ RETURN_VAL('{'); }
-"%>"			{ RETURN_VAL('}'); }
-
-				/* operators */
-"!"				{ ASCIIOP_RETURN(); }
-"+"				{ ASCIIOP_RETURN(); }
-"-"				{ ASCIIOP_RETURN(); }
-"*"				{ ASCIIOP_RETURN(); }
-"/"				{ ASCIIOP_RETURN(); }
-"%"				{ ASCIIOP_RETURN(); }
-"^"				{ ASCIIOP_RETURN(); }
-"~"				{ ASCIIOP_RETURN(); }
-"&"				{ ASCIIOP_RETURN(); }
-"|"				{ ASCIIOP_RETURN(); }
-"<"				{ ASCIIOP_RETURN(); }
-">"				{ ASCIIOP_RETURN(); }
-"="				{ ASCIIOP_RETURN(); }
-"?"				{ ASCIIOP_RETURN(); }
-
-"++"			{ NAMEDOP_RETURN(ICR); }
-"--"			{ NAMEDOP_RETURN(DECR); }
-"=="			{ NAMEDOP_RETURN(EQ); }
-"!="			{ NAMEDOP_RETURN(NE); }
-"<<"			{ NAMEDOP_RETURN(LS); }
-">>"			{ NAMEDOP_RETURN(RS); }
-"<="			{ NAMEDOP_RETURN(LE); }
-">="			{ NAMEDOP_RETURN(GE); }
-"&&"			{ NAMEDOP_RETURN(ANDAND); }
-"||"			{ NAMEDOP_RETURN(OROR); }
-"->"			{ NAMEDOP_RETURN(ARROW); }
-"+="			{ NAMEDOP_RETURN(PLUSassign); }
-"-="			{ NAMEDOP_RETURN(MINUSassign); }
-"*="			{ NAMEDOP_RETURN(MULTassign); }
-"/="			{ NAMEDOP_RETURN(DIVassign); }
-"%="			{ NAMEDOP_RETURN(MODassign); }
-"&="			{ NAMEDOP_RETURN(ANDassign); }
-"|="			{ NAMEDOP_RETURN(ORassign); }
-"^="			{ NAMEDOP_RETURN(ERassign); }
-"<<="			{ NAMEDOP_RETURN(LSassign); }
-">>="			{ NAMEDOP_RETURN(RSassign); }
-
-				/* CFA, operator identifier */
-{op_unary}"?"	{ IDENTIFIER_RETURN(); }				// unary
-"?"({op_unary_pre_post}|"()"|"[?]"|"{}") { IDENTIFIER_RETURN(); }
-"?"{op_binary_over}"?"	{ IDENTIFIER_RETURN(); }		// binary
-	/*
-	  This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?"
-	  can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed
-	  to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator
-	  identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first
-	  case is for the function-call identifier "?()":
-
-	  int * ?()();	// declaration: space required after '*'
-	  * ?()();	// expression: space required after '*'
-
-	  Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning
-	  ahead to determine if there is a '(', which is the start of an argument/parameter list.
-
-	  The 4 remaining cases occur in expressions:
-
-	  i++?i:0;		// space required before '?'
-	  i--?i:0;		// space required before '?'
-	  i?++i:0;		// space required after '?'
-	  i?--i:0;		// space required after '?'
-
-	  In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or
-	  "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument
-	  list.  In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as
-	  "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of
-	  an argument list.
-	*/
-{op_unary}"?"(({op_unary_pre_post}|"[?]")|({op_binary_over}"?")) {
-	// 1 or 2 character unary operator ?
-	int i = yytext[1] == '?' ? 1 : 2;
-	yyless( i );		// put back characters up to first '?'
-	if ( i > 1 ) {
-		NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR );
-	} else {
-		ASCIIOP_RETURN();
-	} // if
-}
-
-				/* unknown characters */
-.			{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
-
-%%
-
-// Local Variables: //
-// mode: c++ //
-// tab-width: 4 //
-// compile-command: "make install" //
-// End: //
Index: src/Parser/module.mk
===================================================================
--- src/Parser/module.mk	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/module.mk	(revision 09d789c493c816483fb88c49a900967b7addbd2c)
@@ -8,19 +8,18 @@
 ## module.mk -- 
 ##
-## Author           : Peter A. Buhr
+## Author           : Richard C. Bilson
 ## Created On       : Sat May 16 15:29:09 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Mon Jun  8 20:23:47 2015
-## Update Count     : 87
+## Last Modified On : Thu May 21 21:17:07 2015
+## Update Count     : 2
 ###############################################################################
 
-BUILT_SOURCES = Parser/parser.h
+YACC=bison
+YFLAGS=-d --debug -v
+LEX=flex
+LFLAGS=
 
-AM_YFLAGS = -d -t -v
-cfa_cpp_LDADD = ${LEXLIB}	# yywrap
-MAINTAINERCLEANFILES = Parser/parser.output
-
-SRC += Parser/parser.yy \
-       Parser/lex.ll \
+SRC += Parser/cfa.y \
+       Parser/lex.l \
        Parser/TypedefTable.cc \
        Parser/ParseNode.cc \
@@ -33,2 +32,23 @@
        Parser/parseutility.cc \
        Parser/Parser.cc
+
+EXTRA_OUTPUT += Parser/cfa.tab.cc \
+                Parser/cfa.tab.h \
+		Parser/lex.yy.cc \
+		Parser/cfa.output
+
+LIBS += -lfl
+
+Parser/Parser.cc: Parser/cfa.tab.h
+
+Parser/cfa.tab.cc: Parser/cfa.y
+	$(YACC) $(YFLAGS) $< --file-prefix=Parser/cfa
+	-mv Parser/cfa.tab.c Parser/cfa.tab.cc
+
+Parser/cfa.tab.h: Parser/cfa.tab.cc
+
+Parser/lex.yy.cc: Parser/lex.l Parser/cfa.tab.h Parser/TypedefTable.h
+	$(LEX) $(LFLAGS) -o$@ $< 
+
+Parser/lex.yy.o: Parser/lex.yy.cc Parser/ParseNode.h
+	$(CXX) $(CXXFLAGS) -Wno-unused -c -o $@ $<
Index: src/Parser/parser.cc
===================================================================
--- src/Parser/parser.cc	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ 	(revision )
@@ -1,9133 +1,0 @@
-/* A Bison parser, made by GNU Bison 2.5.  */
-
-/* Bison implementation for Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-   
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* C LALR(1) parser skeleton written by Richard Stallman, by
-   simplifying the original so-called "semantic" parser.  */
-
-/* All symbols defined below should begin with yy or YY, to avoid
-   infringing on user name space.  This should be done even for local
-   variables, as they might otherwise be expanded by user macros.
-   There are some unavoidable exceptions within include files to
-   define necessary library symbols; they are noted "INFRINGES ON
-   USER NAME SPACE" below.  */
-
-/* Identify Bison output.  */
-#define YYBISON 1
-
-/* Bison version.  */
-#define YYBISON_VERSION "2.5"
-
-/* Skeleton name.  */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers.  */
-#define YYPURE 0
-
-/* Push parsers.  */
-#define YYPUSH 0
-
-/* Pull parsers.  */
-#define YYPULL 1
-
-/* Using locations.  */
-#define YYLSP_NEEDED 0
-
-
-
-/* Copy the first part of user declarations.  */
-
-/* Line 268 of yacc.c  */
-#line 44 "parser.yy"
-
-#define YYDEBUG_LEXER_TEXT (yylval)						// lexer loads this up each time
-#define YYDEBUG 1										// get the pretty debugging code to compile
-extern char *yytext;
-
-#undef __GNUC_MINOR__
-
-#include <cstdio>
-#include <stack>
-#include "TypedefTable.h"
-#include "lex.h"
-#include "ParseNode.h"
-#include "LinkageSpec.h"
-
-DeclarationNode *theTree = 0;							// the resulting parse tree
-LinkageSpec::Type linkage = LinkageSpec::Cforall;
-std::stack< LinkageSpec::Type > linkageStack;
-TypedefTable typedefTable;
-
-
-/* Line 268 of yacc.c  */
-#line 92 "Parser/parser.cc"
-
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 1
-#endif
-
-/* Enabling verbose error messages.  */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 0
-#endif
-
-/* Enabling the token table.  */
-#ifndef YYTOKEN_TABLE
-# define YYTOKEN_TABLE 0
-#endif
-
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     TYPEDEF = 258,
-     AUTO = 259,
-     EXTERN = 260,
-     REGISTER = 261,
-     STATIC = 262,
-     INLINE = 263,
-     FORTRAN = 264,
-     CONST = 265,
-     VOLATILE = 266,
-     RESTRICT = 267,
-     FORALL = 268,
-     LVALUE = 269,
-     VOID = 270,
-     CHAR = 271,
-     SHORT = 272,
-     INT = 273,
-     LONG = 274,
-     FLOAT = 275,
-     DOUBLE = 276,
-     SIGNED = 277,
-     UNSIGNED = 278,
-     BOOL = 279,
-     COMPLEX = 280,
-     IMAGINARY = 281,
-     TYPEOF = 282,
-     LABEL = 283,
-     ENUM = 284,
-     STRUCT = 285,
-     UNION = 286,
-     TYPE = 287,
-     FTYPE = 288,
-     DTYPE = 289,
-     CONTEXT = 290,
-     SIZEOF = 291,
-     ATTRIBUTE = 292,
-     EXTENSION = 293,
-     IF = 294,
-     ELSE = 295,
-     SWITCH = 296,
-     CASE = 297,
-     DEFAULT = 298,
-     DO = 299,
-     WHILE = 300,
-     FOR = 301,
-     BREAK = 302,
-     CONTINUE = 303,
-     GOTO = 304,
-     RETURN = 305,
-     CHOOSE = 306,
-     FALLTHRU = 307,
-     TRY = 308,
-     CATCH = 309,
-     FINALLY = 310,
-     THROW = 311,
-     ASM = 312,
-     ALIGNAS = 313,
-     ALIGNOF = 314,
-     ATOMIC = 315,
-     GENERIC = 316,
-     NORETURN = 317,
-     STATICASSERT = 318,
-     THREADLOCAL = 319,
-     IDENTIFIER = 320,
-     QUOTED_IDENTIFIER = 321,
-     TYPEDEFname = 322,
-     TYPEGENname = 323,
-     ATTR_IDENTIFIER = 324,
-     ATTR_TYPEDEFname = 325,
-     ATTR_TYPEGENname = 326,
-     INTEGERconstant = 327,
-     FLOATINGconstant = 328,
-     CHARACTERconstant = 329,
-     STRINGliteral = 330,
-     ZERO = 331,
-     ONE = 332,
-     ARROW = 333,
-     ICR = 334,
-     DECR = 335,
-     LS = 336,
-     RS = 337,
-     LE = 338,
-     GE = 339,
-     EQ = 340,
-     NE = 341,
-     ANDAND = 342,
-     OROR = 343,
-     ELLIPSIS = 344,
-     MULTassign = 345,
-     DIVassign = 346,
-     MODassign = 347,
-     PLUSassign = 348,
-     MINUSassign = 349,
-     LSassign = 350,
-     RSassign = 351,
-     ANDassign = 352,
-     ERassign = 353,
-     ORassign = 354,
-     THEN = 355
-   };
-#endif
-/* Tokens.  */
-#define TYPEDEF 258
-#define AUTO 259
-#define EXTERN 260
-#define REGISTER 261
-#define STATIC 262
-#define INLINE 263
-#define FORTRAN 264
-#define CONST 265
-#define VOLATILE 266
-#define RESTRICT 267
-#define FORALL 268
-#define LVALUE 269
-#define VOID 270
-#define CHAR 271
-#define SHORT 272
-#define INT 273
-#define LONG 274
-#define FLOAT 275
-#define DOUBLE 276
-#define SIGNED 277
-#define UNSIGNED 278
-#define BOOL 279
-#define COMPLEX 280
-#define IMAGINARY 281
-#define TYPEOF 282
-#define LABEL 283
-#define ENUM 284
-#define STRUCT 285
-#define UNION 286
-#define TYPE 287
-#define FTYPE 288
-#define DTYPE 289
-#define CONTEXT 290
-#define SIZEOF 291
-#define ATTRIBUTE 292
-#define EXTENSION 293
-#define IF 294
-#define ELSE 295
-#define SWITCH 296
-#define CASE 297
-#define DEFAULT 298
-#define DO 299
-#define WHILE 300
-#define FOR 301
-#define BREAK 302
-#define CONTINUE 303
-#define GOTO 304
-#define RETURN 305
-#define CHOOSE 306
-#define FALLTHRU 307
-#define TRY 308
-#define CATCH 309
-#define FINALLY 310
-#define THROW 311
-#define ASM 312
-#define ALIGNAS 313
-#define ALIGNOF 314
-#define ATOMIC 315
-#define GENERIC 316
-#define NORETURN 317
-#define STATICASSERT 318
-#define THREADLOCAL 319
-#define IDENTIFIER 320
-#define QUOTED_IDENTIFIER 321
-#define TYPEDEFname 322
-#define TYPEGENname 323
-#define ATTR_IDENTIFIER 324
-#define ATTR_TYPEDEFname 325
-#define ATTR_TYPEGENname 326
-#define INTEGERconstant 327
-#define FLOATINGconstant 328
-#define CHARACTERconstant 329
-#define STRINGliteral 330
-#define ZERO 331
-#define ONE 332
-#define ARROW 333
-#define ICR 334
-#define DECR 335
-#define LS 336
-#define RS 337
-#define LE 338
-#define GE 339
-#define EQ 340
-#define NE 341
-#define ANDAND 342
-#define OROR 343
-#define ELLIPSIS 344
-#define MULTassign 345
-#define DIVassign 346
-#define MODassign 347
-#define PLUSassign 348
-#define MINUSassign 349
-#define LSassign 350
-#define RSassign 351
-#define ANDassign 352
-#define ERassign 353
-#define ORassign 354
-#define THEN 355
-
-
-
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-{
-
-/* Line 293 of yacc.c  */
-#line 107 "parser.yy"
-
-	Token tok;
-	ParseNode *pn;
-	ExpressionNode *en;
-	DeclarationNode *decl;
-	DeclarationNode::Aggregate aggKey;
-	DeclarationNode::TypeClass tclass;
-	StatementNode *sn;
-	ConstantNode *constant;
-	InitializerNode *in;
-
-
-
-/* Line 293 of yacc.c  */
-#line 342 "Parser/parser.cc"
-} YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-/* Copy the second part of user declarations.  */
-
-
-/* Line 343 of yacc.c  */
-#line 354 "Parser/parser.cc"
-
-#ifdef short
-# undef short
-#endif
-
-#ifdef YYTYPE_UINT8
-typedef YYTYPE_UINT8 yytype_uint8;
-#else
-typedef unsigned char yytype_uint8;
-#endif
-
-#ifdef YYTYPE_INT8
-typedef YYTYPE_INT8 yytype_int8;
-#elif (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-typedef signed char yytype_int8;
-#else
-typedef short int yytype_int8;
-#endif
-
-#ifdef YYTYPE_UINT16
-typedef YYTYPE_UINT16 yytype_uint16;
-#else
-typedef unsigned short int yytype_uint16;
-#endif
-
-#ifdef YYTYPE_INT16
-typedef YYTYPE_INT16 yytype_int16;
-#else
-typedef short int yytype_int16;
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-#  define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-#  define YYSIZE_T size_t
-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# else
-#  define YYSIZE_T unsigned int
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-#  if ENABLE_NLS
-#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#   define YY_(msgid) dgettext ("bison-runtime", msgid)
-#  endif
-# endif
-# ifndef YY_
-#  define YY_(msgid) msgid
-# endif
-#endif
-
-/* Suppress unused-variable warnings by "using" E.  */
-#if ! defined lint || defined __GNUC__
-# define YYUSE(e) ((void) (e))
-#else
-# define YYUSE(e) /* empty */
-#endif
-
-/* Identity function, used to suppress warnings about constant conditions.  */
-#ifndef lint
-# define YYID(n) (n)
-#else
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static int
-YYID (int yyi)
-#else
-static int
-YYID (yyi)
-    int yyi;
-#endif
-{
-  return yyi;
-}
-#endif
-
-#if ! defined yyoverflow || YYERROR_VERBOSE
-
-/* The parser invokes alloca or malloc; define the necessary symbols.  */
-
-# ifdef YYSTACK_USE_ALLOCA
-#  if YYSTACK_USE_ALLOCA
-#   ifdef __GNUC__
-#    define YYSTACK_ALLOC __builtin_alloca
-#   elif defined __BUILTIN_VA_ARG_INCR
-#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-#   elif defined _AIX
-#    define YYSTACK_ALLOC __alloca
-#   elif defined _MSC_VER
-#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-#    define alloca _alloca
-#   else
-#    define YYSTACK_ALLOC alloca
-#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#     ifndef EXIT_SUCCESS
-#      define EXIT_SUCCESS 0
-#     endif
-#    endif
-#   endif
-#  endif
-# endif
-
-# ifdef YYSTACK_ALLOC
-   /* Pacify GCC's `empty if-body' warning.  */
-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-    /* The OS might guarantee only one guard page at the bottom of the stack,
-       and a page size can be as small as 4096 bytes.  So we cannot safely
-       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
-       to allow for a few compiler-allocated temporary stack slots.  */
-#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-#  endif
-# else
-#  define YYSTACK_ALLOC YYMALLOC
-#  define YYSTACK_FREE YYFREE
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-#  endif
-#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
-       && ! ((defined YYMALLOC || defined malloc) \
-	     && (defined YYFREE || defined free)))
-#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   ifndef EXIT_SUCCESS
-#    define EXIT_SUCCESS 0
-#   endif
-#  endif
-#  ifndef YYMALLOC
-#   define YYMALLOC malloc
-#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-#  ifndef YYFREE
-#   define YYFREE free
-#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-# endif
-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-
-
-#if (! defined yyoverflow \
-     && (! defined __cplusplus \
-	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member.  */
-union yyalloc
-{
-  yytype_int16 yyss_alloc;
-  YYSTYPE yyvs_alloc;
-};
-
-/* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
-   N elements.  */
-# define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
-      + YYSTACK_GAP_MAXIMUM)
-
-# define YYCOPY_NEEDED 1
-
-/* Relocate STACK from its old location to the new one.  The
-   local variables YYSIZE and YYSTACKSIZE give the old and new number of
-   elements in the stack, and YYPTR gives the new location of the
-   stack.  Advance YYPTR to a properly aligned location for the next
-   stack.  */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
-    do									\
-      {									\
-	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
-	Stack = &yyptr->Stack_alloc;					\
-	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
-	yyptr += yynewbytes / sizeof (*yyptr);				\
-      }									\
-    while (YYID (0))
-
-#endif
-
-#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from FROM to TO.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(To, From, Count) \
-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
-#  else
-#   define YYCOPY(To, From, Count)		\
-      do					\
-	{					\
-	  YYSIZE_T yyi;				\
-	  for (yyi = 0; yyi < (Count); yyi++)	\
-	    (To)[yyi] = (From)[yyi];		\
-	}					\
-      while (YYID (0))
-#  endif
-# endif
-#endif /* !YYCOPY_NEEDED */
-
-/* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  240
-/* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   11462
-
-/* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  125
-/* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  235
-/* YYNRULES -- Number of rules.  */
-#define YYNRULES  731
-/* YYNRULES -- Number of states.  */
-#define YYNSTATES  1529
-
-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-#define YYUNDEFTOK  2
-#define YYMAXUTOK   355
-
-#define YYTRANSLATE(YYX)						\
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-
-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
-static const yytype_uint8 yytranslate[] =
-{
-       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,   110,     2,     2,     2,   117,   112,     2,
-     101,   102,   111,   113,   108,   114,   105,   116,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,   109,   124,
-     118,   123,   119,   122,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,   103,     2,   104,   120,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,   106,   121,   107,   115,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,    99,   100
-};
-
-#if YYDEBUG
-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-   YYRHS.  */
-static const yytype_uint16 yyprhs[] =
-{
-       0,     0,     3,     4,     5,     7,     9,    11,    13,    15,
-      17,    19,    21,    23,    25,    27,    29,    32,    34,    36,
-      38,    40,    44,    48,    50,    57,    62,    66,    74,    78,
-      86,    89,    92,   100,   102,   106,   107,   109,   113,   121,
-     131,   133,   137,   139,   143,   151,   155,   163,   165,   168,
-     171,   174,   177,   180,   183,   186,   191,   193,   198,   203,
-     206,   211,   214,   216,   218,   220,   222,   224,   229,   234,
-     236,   240,   244,   248,   250,   254,   258,   260,   264,   268,
-     270,   274,   278,   282,   286,   288,   292,   296,   298,   302,
-     304,   308,   310,   314,   316,   320,   322,   326,   328,   334,
-     339,   345,   347,   349,   353,   357,   360,   361,   363,   368,
-     374,   381,   389,   391,   395,   397,   399,   401,   403,   405,
-     407,   409,   411,   413,   415,   417,   421,   422,   424,   426,
-     428,   430,   432,   434,   436,   438,   440,   445,   448,   456,
-     458,   462,   464,   467,   469,   472,   474,   477,   480,   486,
-     494,   500,   510,   516,   526,   528,   532,   534,   536,   540,
-     544,   547,   549,   552,   555,   556,   558,   561,   565,   566,
-     568,   571,   575,   579,   584,   585,   587,   589,   592,   598,
-     606,   613,   620,   625,   629,   634,   637,   641,   644,   648,
-     652,   656,   659,   663,   667,   672,   674,   680,   687,   697,
-     708,   711,   713,   716,   719,   722,   724,   731,   740,   751,
-     764,   765,   767,   769,   773,   778,   780,   784,   786,   788,
-     790,   794,   796,   798,   800,   804,   805,   807,   811,   816,
-     818,   822,   824,   826,   830,   834,   838,   842,   846,   849,
-     853,   860,   864,   868,   873,   875,   878,   881,   885,   891,
-     902,   913,   921,   929,   935,   945,   948,   951,   957,   961,
-     967,   972,   976,   981,   986,   994,   998,  1002,  1006,  1010,
-    1015,  1022,  1024,  1026,  1028,  1030,  1032,  1034,  1036,  1038,
-    1039,  1041,  1043,  1046,  1048,  1050,  1052,  1054,  1056,  1058,
-    1060,  1061,  1067,  1069,  1072,  1076,  1078,  1081,  1083,  1085,
-    1087,  1089,  1091,  1093,  1095,  1097,  1099,  1101,  1103,  1105,
-    1107,  1109,  1111,  1113,  1115,  1117,  1119,  1121,  1123,  1125,
-    1128,  1131,  1135,  1139,  1141,  1145,  1147,  1150,  1153,  1156,
-    1161,  1166,  1171,  1176,  1178,  1181,  1184,  1188,  1190,  1193,
-    1196,  1198,  1201,  1204,  1208,  1210,  1213,  1216,  1218,  1220,
-    1225,  1228,  1234,  1242,  1248,  1251,  1254,  1256,  1259,  1262,
-    1266,  1269,  1273,  1275,  1278,  1282,  1285,  1288,  1293,  1294,
-    1296,  1299,  1302,  1304,  1305,  1307,  1310,  1313,  1319,  1326,
-    1329,  1332,  1337,  1338,  1341,  1342,  1344,  1346,  1348,  1354,
-    1360,  1366,  1368,  1374,  1380,  1390,  1392,  1398,  1399,  1401,
-    1403,  1409,  1411,  1413,  1419,  1425,  1427,  1431,  1435,  1440,
-    1442,  1444,  1446,  1448,  1451,  1453,  1457,  1461,  1463,  1466,
-    1468,  1472,  1474,  1476,  1478,  1480,  1482,  1484,  1486,  1488,
-    1490,  1492,  1494,  1497,  1499,  1501,  1503,  1506,  1507,  1510,
-    1512,  1517,  1519,  1522,  1526,  1531,  1534,  1537,  1539,  1542,
-    1545,  1551,  1557,  1565,  1572,  1574,  1577,  1580,  1584,  1589,
-    1595,  1598,  1601,  1606,  1607,  1612,  1615,  1617,  1619,  1621,
-    1622,  1625,  1631,  1637,  1651,  1653,  1655,  1659,  1663,  1666,
-    1670,  1674,  1677,  1682,  1684,  1691,  1701,  1702,  1714,  1716,
-    1720,  1724,  1728,  1730,  1732,  1738,  1741,  1747,  1748,  1750,
-    1752,  1756,  1757,  1759,  1761,  1763,  1765,  1766,  1773,  1776,
-    1778,  1781,  1786,  1789,  1793,  1797,  1801,  1806,  1812,  1818,
-    1824,  1831,  1833,  1835,  1837,  1841,  1842,  1848,  1849,  1851,
-    1853,  1856,  1863,  1865,  1869,  1870,  1872,  1877,  1879,  1881,
-    1883,  1885,  1888,  1890,  1893,  1896,  1898,  1902,  1905,  1909,
-    1913,  1916,  1921,  1926,  1930,  1939,  1943,  1946,  1948,  1951,
-    1958,  1967,  1971,  1974,  1978,  1982,  1987,  1992,  1996,  1998,
-    2000,  2002,  2007,  2014,  2018,  2021,  2025,  2029,  2034,  2039,
-    2043,  2046,  2048,  2051,  2054,  2056,  2060,  2063,  2067,  2071,
-    2074,  2079,  2084,  2088,  2095,  2104,  2108,  2111,  2113,  2116,
-    2119,  2122,  2126,  2130,  2133,  2138,  2143,  2147,  2154,  2163,
-    2167,  2170,  2172,  2175,  2178,  2180,  2183,  2187,  2191,  2194,
-    2199,  2206,  2215,  2217,  2220,  2223,  2225,  2228,  2231,  2235,
-    2239,  2241,  2246,  2251,  2255,  2261,  2270,  2274,  2279,  2285,
-    2287,  2293,  2299,  2306,  2313,  2315,  2318,  2321,  2323,  2326,
-    2329,  2333,  2337,  2339,  2344,  2349,  2353,  2359,  2368,  2372,
-    2374,  2377,  2379,  2384,  2391,  2397,  2404,  2412,  2420,  2422,
-    2425,  2428,  2430,  2433,  2436,  2440,  2444,  2446,  2451,  2456,
-    2460,  2469,  2473,  2475,  2477,  2480,  2482,  2484,  2487,  2491,
-    2494,  2498,  2501,  2505,  2511,  2514,  2521,  2525,  2528,  2534,
-    2537,  2544,  2548,  2551,  2558,  2565,  2572,  2580,  2582,  2585,
-    2587,  2589,  2591,  2594,  2598,  2601,  2605,  2608,  2612,  2618,
-    2625,  2628,  2634,  2641,  2644,  2650,  2658,  2665,  2672,  2673,
-    2675,  2676
-};
-
-/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
-static const yytype_int16 yyrhs[] =
-{
-     288,     0,    -1,    -1,    -1,    72,    -1,    73,    -1,    74,
-      -1,    65,    -1,    69,    -1,   132,    -1,    65,    -1,    69,
-      -1,    65,    -1,    76,    -1,    77,    -1,    75,    -1,   133,
-      75,    -1,    65,    -1,   132,    -1,   128,    -1,   133,    -1,
-     101,   160,   102,    -1,   101,   164,   102,    -1,   134,    -1,
-     135,   103,   126,   155,   127,   104,    -1,   135,   101,   136,
-     102,    -1,   135,   105,   131,    -1,   135,   105,   103,   126,
-     138,   127,   104,    -1,   135,    78,   131,    -1,   135,    78,
-     103,   126,   138,   127,   104,    -1,   135,    79,    -1,   135,
-      80,    -1,   101,   262,   102,   106,   266,   358,   107,    -1,
-     137,    -1,   136,   108,   137,    -1,    -1,   155,    -1,   131,
-     109,   155,    -1,   103,   126,   155,   127,   104,   109,   155,
-      -1,   103,   126,   155,   108,   158,   127,   104,   109,   155,
-      -1,   139,    -1,   138,   108,   139,    -1,   131,    -1,   131,
-     105,   139,    -1,   131,   105,   103,   126,   138,   127,   104,
-      -1,   131,    78,   139,    -1,   131,    78,   103,   126,   138,
-     127,   104,    -1,   135,    -1,    79,   140,    -1,    80,   140,
-      -1,    38,   142,    -1,   141,   142,    -1,   110,   142,    -1,
-     111,   142,    -1,    36,   140,    -1,    36,   101,   262,   102,
-      -1,    69,    -1,    69,   101,   263,   102,    -1,    69,   101,
-     137,   102,    -1,    59,   140,    -1,    59,   101,   262,   102,
-      -1,    87,   131,    -1,   112,    -1,   113,    -1,   114,    -1,
-     115,    -1,   140,    -1,   101,   262,   102,   142,    -1,   101,
-     262,   102,   157,    -1,   142,    -1,   143,   111,   142,    -1,
-     143,   116,   142,    -1,   143,   117,   142,    -1,   143,    -1,
-     144,   113,   143,    -1,   144,   114,   143,    -1,   144,    -1,
-     145,    81,   144,    -1,   145,    82,   144,    -1,   145,    -1,
-     146,   118,   145,    -1,   146,   119,   145,    -1,   146,    83,
-     145,    -1,   146,    84,   145,    -1,   146,    -1,   147,    85,
-     146,    -1,   147,    86,   146,    -1,   147,    -1,   148,   112,
-     147,    -1,   148,    -1,   149,   120,   148,    -1,   149,    -1,
-     150,   121,   149,    -1,   150,    -1,   151,    87,   150,    -1,
-     151,    -1,   152,    88,   151,    -1,   152,    -1,   152,   122,
-     160,   109,   153,    -1,   152,   122,   109,   153,    -1,   152,
-     122,   160,   109,   157,    -1,   153,    -1,   153,    -1,   140,
-     123,   155,    -1,   140,   159,   155,    -1,   157,   359,    -1,
-      -1,   155,    -1,   103,   126,   127,   104,    -1,   103,   126,
-     155,   127,   104,    -1,   103,   126,   108,   158,   127,   104,
-      -1,   103,   126,   155,   108,   158,   127,   104,    -1,   156,
-      -1,   158,   108,   156,    -1,    90,    -1,    91,    -1,    92,
-      -1,    93,    -1,    94,    -1,    95,    -1,    96,    -1,    97,
-      -1,    98,    -1,    99,    -1,   155,    -1,   160,   108,   155,
-      -1,    -1,   160,    -1,   163,    -1,   164,    -1,   168,    -1,
-     169,    -1,   181,    -1,   183,    -1,   184,    -1,   189,    -1,
-     131,   109,   298,   162,    -1,   106,   107,    -1,   106,   126,
-     126,   198,   165,   127,   107,    -1,   166,    -1,   165,   126,
-     166,    -1,   201,    -1,    38,   201,    -1,   294,    -1,   162,
-     127,    -1,   162,    -1,   167,   162,    -1,   161,   124,    -1,
-      39,   101,   160,   102,   162,    -1,    39,   101,   160,   102,
-     162,    40,   162,    -1,    41,   101,   160,   102,   174,    -1,
-      41,   101,   160,   102,   106,   126,   194,   175,   107,    -1,
-      51,   101,   160,   102,   174,    -1,    51,   101,   160,   102,
-     106,   126,   194,   177,   107,    -1,   154,    -1,   154,    89,
-     154,    -1,   296,    -1,   170,    -1,   171,   108,   170,    -1,
-      42,   171,   109,    -1,    43,   109,    -1,   172,    -1,   173,
-     172,    -1,   173,   162,    -1,    -1,   176,    -1,   173,   167,
-      -1,   176,   173,   167,    -1,    -1,   178,    -1,   173,   180,
-      -1,   173,   167,   179,    -1,   178,   173,   180,    -1,   178,
-     173,   167,   179,    -1,    -1,   180,    -1,    52,    -1,    52,
-     124,    -1,    45,   101,   160,   102,   162,    -1,    44,   162,
-      45,   101,   160,   102,   124,    -1,    46,   101,   126,   182,
-     102,   162,    -1,   161,   127,   124,   161,   124,   161,    -1,
-     201,   161,   124,   161,    -1,    49,   131,   124,    -1,    49,
-     111,   160,   124,    -1,    48,   124,    -1,    48,   131,   124,
-      -1,    47,   124,    -1,    47,   131,   124,    -1,    50,   161,
-     124,    -1,    56,   155,   124,    -1,    56,   124,    -1,    53,
-     164,   185,    -1,    53,   164,   187,    -1,    53,   164,   185,
-     187,    -1,   186,    -1,    54,   101,    89,   102,   164,    -1,
-     186,    54,   101,    89,   102,   164,    -1,    54,   101,   126,
-     126,   188,   127,   102,   164,   127,    -1,   186,    54,   101,
-     126,   126,   188,   127,   102,   164,   127,    -1,    55,   164,
-      -1,   214,    -1,   214,   295,    -1,   214,   343,    -1,   352,
-     131,    -1,   352,    -1,    57,   215,   101,   154,   102,   124,
-      -1,    57,   215,   101,   154,   109,   190,   102,   124,    -1,
-      57,   215,   101,   154,   109,   190,   109,   190,   102,   124,
-      -1,    57,   215,   101,   154,   109,   190,   109,   190,   109,
-     193,   102,   124,    -1,    -1,   191,    -1,   192,    -1,   191,
-     108,   192,    -1,    75,   101,   154,   102,    -1,    75,    -1,
-     193,   108,    75,    -1,   127,    -1,   195,    -1,   201,    -1,
-     195,   126,   201,    -1,   127,    -1,   197,    -1,   211,    -1,
-     197,   126,   211,    -1,    -1,   199,    -1,    28,   200,   124,
-      -1,   199,    28,   200,   124,    -1,   261,    -1,   200,   108,
-     261,    -1,   202,    -1,   211,    -1,   203,   127,   124,    -1,
-     208,   127,   124,    -1,   205,   127,   124,    -1,   279,   127,
-     124,    -1,   282,   127,   124,    -1,   204,   264,    -1,   220,
-     204,   264,    -1,   203,   127,   108,   126,   259,   264,    -1,
-     353,   259,   297,    -1,   356,   259,   297,    -1,   216,   356,
-     259,   297,    -1,   206,    -1,   216,   206,    -1,   220,   206,
-      -1,   220,   216,   206,    -1,   205,   127,   108,   126,   259,
-      -1,   103,   126,   127,   104,   129,   101,   126,   247,   127,
-     102,    -1,   103,   126,   127,   104,    67,   101,   126,   247,
-     127,   102,    -1,   356,   259,   101,   126,   247,   127,   102,
-      -1,   207,   259,   101,   126,   247,   127,   102,    -1,   103,
-     126,   249,   127,   104,    -1,   103,   126,   249,   127,   108,
-     126,   250,   127,   104,    -1,     3,   204,    -1,     3,   206,
-      -1,   208,   127,   108,   126,   131,    -1,     3,   214,   295,
-      -1,   209,   127,   108,   126,   295,    -1,   216,     3,   214,
-     295,    -1,   214,     3,   295,    -1,   214,     3,   216,   295,
-      -1,     3,   131,   123,   155,    -1,   210,   127,   108,   126,
-     131,   123,   155,    -1,   212,   127,   124,    -1,   209,   127,
-     124,    -1,   210,   127,   124,    -1,   229,   127,   124,    -1,
-     213,   295,   297,   264,    -1,   212,   108,   298,   295,   297,
-     264,    -1,   225,    -1,   229,    -1,   231,    -1,   270,    -1,
-     226,    -1,   230,    -1,   232,    -1,   271,    -1,    -1,   216,
-      -1,   217,    -1,   216,   217,    -1,   218,    -1,   300,    -1,
-      10,    -1,    12,    -1,    11,    -1,    14,    -1,    60,    -1,
-      -1,    13,   101,   219,   272,   102,    -1,   221,    -1,   216,
-     221,    -1,   220,   216,   221,    -1,   222,    -1,   221,   222,
-      -1,   223,    -1,     5,    -1,     7,    -1,     4,    -1,     6,
-      -1,     8,    -1,     9,    -1,    62,    -1,    64,    -1,    16,
-      -1,    21,    -1,    20,    -1,    18,    -1,    19,    -1,    17,
-      -1,    22,    -1,    23,    -1,    15,    -1,    24,    -1,    25,
-      -1,    26,    -1,   226,    -1,   220,   226,    -1,   225,   222,
-      -1,   225,   222,   216,    -1,   225,   222,   226,    -1,   227,
-      -1,   215,   228,   215,    -1,   224,    -1,   216,   224,    -1,
-     227,   217,    -1,   227,   224,    -1,    27,   101,   263,   102,
-      -1,    27,   101,   160,   102,    -1,    71,   101,   263,   102,
-      -1,    71,   101,   160,   102,    -1,   230,    -1,   220,   230,
-      -1,   229,   222,    -1,   229,   222,   216,    -1,   233,    -1,
-     216,   233,    -1,   230,   217,    -1,   232,    -1,   220,   232,
-      -1,   231,   222,    -1,   231,   222,   216,    -1,    67,    -1,
-     216,    67,    -1,   232,   217,    -1,   234,    -1,   244,    -1,
-     235,   106,   236,   107,    -1,   235,   261,    -1,   235,   261,
-     106,   236,   107,    -1,   235,   101,   278,   102,   106,   236,
-     107,    -1,   235,   101,   278,   102,   261,    -1,    30,   298,
-      -1,    31,   298,    -1,   237,    -1,   236,   237,    -1,   238,
-     124,    -1,    38,   238,   124,    -1,   239,   124,    -1,    38,
-     239,   124,    -1,   352,    -1,   352,   261,    -1,   238,   108,
-     261,    -1,   238,   108,    -1,   214,   240,    -1,   239,   108,
-     298,   240,    -1,    -1,   242,    -1,   304,   241,    -1,   317,
-     241,    -1,   343,    -1,    -1,   242,    -1,   109,   154,    -1,
-      29,   298,    -1,   243,   106,   245,   358,   107,    -1,   243,
-     261,   106,   245,   358,   107,    -1,   243,   261,    -1,   261,
-     246,    -1,   245,   108,   261,   246,    -1,    -1,   123,   154,
-      -1,    -1,   248,    -1,   250,    -1,   249,    -1,   249,   127,
-     108,   126,   250,    -1,   250,   127,   108,   126,    89,    -1,
-     249,   127,   108,   126,    89,    -1,   254,    -1,   250,   127,
-     108,   126,   254,    -1,   249,   127,   108,   126,   254,    -1,
-     249,   127,   108,   126,   250,   127,   108,   126,   254,    -1,
-     255,    -1,   250,   127,   108,   126,   255,    -1,    -1,   252,
-      -1,   253,    -1,   253,   127,   108,   126,    89,    -1,   257,
-      -1,   256,    -1,   253,   127,   108,   126,   257,    -1,   253,
-     127,   108,   126,   256,    -1,   256,    -1,   348,   259,   359,
-      -1,   356,   259,   359,    -1,   216,   356,   259,   359,    -1,
-     206,    -1,   257,    -1,   348,    -1,   356,    -1,   216,   356,
-      -1,   357,    -1,   213,   322,   359,    -1,   213,   326,   359,
-      -1,   213,    -1,   213,   337,    -1,   131,    -1,   258,   108,
-     131,    -1,   129,    -1,    67,    -1,    68,    -1,   130,    -1,
-      67,    -1,    68,    -1,   131,    -1,    67,    -1,    68,    -1,
-     352,    -1,   214,    -1,   214,   343,    -1,   352,    -1,   357,
-      -1,   214,    -1,   214,   331,    -1,    -1,   123,   265,    -1,
-     155,    -1,   106,   266,   358,   107,    -1,   265,    -1,   267,
-     265,    -1,   266,   108,   265,    -1,   266,   108,   267,   265,
-      -1,   268,   109,    -1,   261,   109,    -1,   269,    -1,   268,
-     269,    -1,   105,   261,    -1,   103,   126,   155,   127,   104,
-      -1,   103,   126,   296,   127,   104,    -1,   103,   126,   154,
-      89,   154,   127,   104,    -1,   105,   103,   126,   138,   127,
-     104,    -1,   271,    -1,   220,   271,    -1,   270,   222,    -1,
-     270,   222,   216,    -1,    68,   101,   278,   102,    -1,   216,
-      68,   101,   278,   102,    -1,   271,   217,    -1,   273,   359,
-      -1,   272,   108,   273,   359,    -1,    -1,   275,   261,   274,
-     276,    -1,   214,   322,    -1,    32,    -1,    34,    -1,    33,
-      -1,    -1,   276,   277,    -1,   121,   261,   101,   278,   102,
-      -1,   121,   106,   126,   284,   107,    -1,   121,   101,   126,
-     272,   127,   102,   106,   126,   284,   107,   101,   278,   102,
-      -1,   263,    -1,   155,    -1,   278,   108,   263,    -1,   278,
-     108,   155,    -1,    32,   280,    -1,   221,    32,   280,    -1,
-     279,   108,   280,    -1,   281,   276,    -1,   281,   276,   123,
-     263,    -1,   261,    -1,   260,   101,   126,   272,   127,   102,
-      -1,    35,   261,   101,   126,   272,   127,   102,   106,   107,
-      -1,    -1,    35,   261,   101,   126,   272,   127,   102,   106,
-     283,   284,   107,    -1,   285,    -1,   284,   126,   285,    -1,
-     286,   127,   124,    -1,   287,   127,   124,    -1,   204,    -1,
-     206,    -1,   286,   127,   108,   126,   259,    -1,   214,   295,
-      -1,   287,   127,   108,   126,   295,    -1,    -1,   289,    -1,
-     291,    -1,   289,   126,   291,    -1,    -1,   289,    -1,   201,
-      -1,   293,    -1,   189,    -1,    -1,     5,    75,   292,   106,
-     290,   107,    -1,    38,   291,    -1,   294,    -1,   309,   164,
-      -1,   313,   126,   196,   164,    -1,   205,   164,    -1,   213,
-     309,   164,    -1,   216,   309,   164,    -1,   220,   309,   164,
-      -1,   220,   216,   309,   164,    -1,   213,   313,   126,   196,
-     164,    -1,   216,   313,   126,   196,   164,    -1,   220,   313,
-     126,   196,   164,    -1,   220,   216,   313,   126,   196,   164,
-      -1,   304,    -1,   309,    -1,   317,    -1,   154,   115,   154,
-      -1,    -1,    57,   101,   133,   102,   298,    -1,    -1,   299,
-      -1,   300,    -1,   299,   300,    -1,    37,   101,   101,   301,
-     102,   102,    -1,   302,    -1,   301,   108,   302,    -1,    -1,
-     303,    -1,   303,   101,   161,   102,    -1,   259,    -1,   223,
-      -1,   224,    -1,   217,    -1,   305,   298,    -1,   306,    -1,
-     307,   298,    -1,   308,   298,    -1,   129,    -1,   101,   305,
-     102,    -1,   111,   304,    -1,   111,   216,   304,    -1,   101,
-     306,   102,    -1,   305,   335,    -1,   101,   306,   102,   335,
-      -1,   101,   307,   102,   336,    -1,   101,   307,   102,    -1,
-     101,   306,   102,   101,   126,   251,   127,   102,    -1,   101,
-     308,   102,    -1,   310,   298,    -1,   311,    -1,   312,   298,
-      -1,   305,   101,   126,   251,   127,   102,    -1,   101,   311,
-     102,   101,   126,   251,   127,   102,    -1,   101,   310,   102,
-      -1,   111,   309,    -1,   111,   216,   309,    -1,   101,   311,
-     102,    -1,   101,   311,   102,   335,    -1,   101,   312,   102,
-     336,    -1,   101,   312,   102,    -1,   314,    -1,   315,    -1,
-     316,    -1,   305,   101,   258,   102,    -1,   101,   315,   102,
-     101,   258,   102,    -1,   101,   314,   102,    -1,   111,   313,
-      -1,   111,   216,   313,    -1,   101,   315,   102,    -1,   101,
-     315,   102,   335,    -1,   101,   316,   102,   336,    -1,   101,
-     316,   102,    -1,   318,   298,    -1,   319,    -1,   320,   298,
-      -1,   321,   298,    -1,    67,    -1,   101,   318,   102,    -1,
-     111,   317,    -1,   111,   216,   317,    -1,   101,   319,   102,
-      -1,   318,   335,    -1,   101,   319,   102,   335,    -1,   101,
-     320,   102,   336,    -1,   101,   320,   102,    -1,   318,   101,
-     126,   251,   127,   102,    -1,   101,   319,   102,   101,   126,
-     251,   127,   102,    -1,   101,   321,   102,    -1,   305,   298,
-      -1,   323,    -1,   324,   298,    -1,   325,   298,    -1,   111,
-     322,    -1,   111,   216,   322,    -1,   101,   323,   102,    -1,
-     305,   341,    -1,   101,   323,   102,   335,    -1,   101,   324,
-     102,   336,    -1,   101,   324,   102,    -1,   305,   101,   126,
-     251,   127,   102,    -1,   101,   323,   102,   101,   126,   251,
-     127,   102,    -1,   101,   325,   102,    -1,   327,   298,    -1,
-     328,    -1,   329,   298,    -1,   330,   298,    -1,    67,    -1,
-     111,   326,    -1,   111,   216,   326,    -1,   101,   328,   102,
-      -1,   327,   341,    -1,   101,   328,   102,   341,    -1,   327,
-     101,   126,   251,   127,   102,    -1,   101,   328,   102,   101,
-     126,   251,   127,   102,    -1,   332,    -1,   333,   298,    -1,
-     334,   298,    -1,   111,    -1,   111,   216,    -1,   111,   331,
-      -1,   111,   216,   331,    -1,   101,   332,   102,    -1,   335,
-      -1,   101,   332,   102,   335,    -1,   101,   333,   102,   336,
-      -1,   101,   333,   102,    -1,   101,   126,   251,   127,   102,
-      -1,   101,   332,   102,   101,   126,   251,   127,   102,    -1,
-     101,   334,   102,    -1,   103,   126,   127,   104,    -1,   103,
-     126,   127,   104,   336,    -1,   336,    -1,   103,   126,   155,
-     127,   104,    -1,   103,   126,   111,   127,   104,    -1,   336,
-     103,   126,   155,   127,   104,    -1,   336,   103,   126,   111,
-     127,   104,    -1,   338,    -1,   339,   298,    -1,   340,   298,
-      -1,   111,    -1,   111,   216,    -1,   111,   337,    -1,   111,
-     216,   337,    -1,   101,   338,   102,    -1,   341,    -1,   101,
-     338,   102,   341,    -1,   101,   339,   102,   336,    -1,   101,
-     339,   102,    -1,   101,   126,   251,   127,   102,    -1,   101,
-     338,   102,   101,   126,   251,   127,   102,    -1,   101,   340,
-     102,    -1,   342,    -1,   342,   336,    -1,   336,    -1,   103,
-     126,   127,   104,    -1,   103,   126,   216,   111,   127,   104,
-      -1,   103,   126,   216,   127,   104,    -1,   103,   126,   216,
-     155,   127,   104,    -1,   103,   126,     7,   215,   155,   127,
-     104,    -1,   103,   126,   216,     7,   155,   127,   104,    -1,
-     344,    -1,   345,   298,    -1,   346,   298,    -1,   111,    -1,
-     111,   216,    -1,   111,   343,    -1,   111,   216,   343,    -1,
-     101,   344,   102,    -1,   335,    -1,   101,   344,   102,   335,
-      -1,   101,   345,   102,   336,    -1,   101,   345,   102,    -1,
-     101,   344,   102,   101,   126,   251,   127,   102,    -1,   101,
-     346,   102,    -1,   348,    -1,   356,    -1,   216,   356,    -1,
-     349,    -1,   350,    -1,   111,   214,    -1,   216,   111,   214,
-      -1,   111,   357,    -1,   216,   111,   357,    -1,   111,   347,
-      -1,   216,   111,   347,    -1,   103,   126,   127,   104,   214,
-      -1,   351,   214,    -1,   103,   126,   127,   104,   336,   214,
-      -1,   351,   336,   214,    -1,   336,   214,    -1,   103,   126,
-     127,   104,   349,    -1,   351,   349,    -1,   103,   126,   127,
-     104,   336,   349,    -1,   351,   336,   349,    -1,   336,   349,
-      -1,   103,   126,   216,   111,   127,   104,    -1,   103,   126,
-     216,   155,   127,   104,    -1,   103,   126,   220,   155,   127,
-     104,    -1,   103,   126,   220,   216,   155,   127,   104,    -1,
-     356,    -1,   216,   356,    -1,   353,    -1,   354,    -1,   355,
-      -1,   111,   214,    -1,   216,   111,   214,    -1,   111,   357,
-      -1,   216,   111,   357,    -1,   111,   352,    -1,   216,   111,
-     352,    -1,   103,   126,   127,   104,   214,    -1,   103,   126,
-     127,   104,   336,   214,    -1,   336,   214,    -1,   103,   126,
-     127,   104,   354,    -1,   103,   126,   127,   104,   336,   354,
-      -1,   336,   354,    -1,   103,   126,   250,   127,   104,    -1,
-     103,   126,   127,   104,   101,   247,   102,    -1,   356,   101,
-     126,   247,   127,   102,    -1,   207,   101,   126,   247,   127,
-     102,    -1,    -1,   108,    -1,    -1,   123,   155,    -1
-};
-
-/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const yytype_uint16 yyrline[] =
-{
-       0,   279,   279,   285,   294,   295,   296,   300,   301,   302,
-     306,   307,   311,   315,   316,   320,   321,   327,   329,   331,
-     333,   335,   337,   342,   343,   349,   351,   353,   354,   356,
-     357,   359,   362,   367,   368,   374,   375,   376,   381,   383,
-     388,   389,   393,   395,   397,   399,   401,   406,   407,   409,
-     411,   413,   415,   417,   423,   425,   427,   429,   431,   433,
-     435,   437,   442,   443,   444,   445,   449,   450,   452,   457,
-     458,   460,   462,   467,   468,   470,   475,   476,   478,   483,
-     484,   486,   488,   490,   495,   496,   498,   503,   504,   509,
-     510,   515,   516,   521,   522,   527,   528,   533,   534,   536,
-     538,   543,   548,   549,   551,   553,   559,   560,   566,   568,
-     570,   572,   577,   578,   583,   584,   585,   586,   587,   588,
-     589,   590,   591,   592,   596,   597,   603,   604,   610,   611,
-     612,   613,   614,   615,   616,   617,   621,   626,   628,   638,
-     639,   644,   646,   648,   650,   654,   655,   660,   665,   668,
-     670,   672,   677,   679,   687,   688,   690,   694,   695,   700,
-     701,   706,   707,   711,   716,   717,   721,   723,   729,   730,
-     734,   736,   738,   740,   746,   747,   751,   752,   756,   758,
-     760,   765,   767,   772,   774,   778,   781,   785,   788,   792,
-     794,   796,   801,   803,   805,   814,   816,   818,   823,   825,
-     830,   843,   844,   849,   851,   856,   860,   862,   864,   866,
-     870,   872,   876,   877,   881,   885,   886,   892,   894,   898,
-     899,   904,   906,   910,   911,   915,   917,   921,   922,   926,
-     927,   931,   932,   947,   948,   949,   950,   951,   955,   960,
-     967,   977,   982,   987,   995,  1000,  1005,  1010,  1015,  1023,
-    1028,  1040,  1045,  1052,  1054,  1061,  1066,  1071,  1082,  1087,
-    1092,  1097,  1102,  1111,  1116,  1124,  1125,  1126,  1127,  1133,
-    1138,  1146,  1147,  1148,  1149,  1153,  1154,  1155,  1156,  1161,
-    1162,  1171,  1172,  1177,  1178,  1183,  1185,  1187,  1189,  1191,
-    1194,  1193,  1205,  1206,  1208,  1218,  1219,  1224,  1228,  1230,
-    1232,  1234,  1236,  1238,  1240,  1242,  1247,  1249,  1251,  1253,
-    1255,  1257,  1259,  1261,  1263,  1265,  1267,  1269,  1275,  1276,
-    1278,  1280,  1282,  1287,  1288,  1294,  1295,  1297,  1299,  1304,
-    1306,  1308,  1310,  1315,  1316,  1318,  1320,  1325,  1326,  1328,
-    1333,  1334,  1336,  1338,  1343,  1345,  1347,  1352,  1353,  1357,
-    1359,  1361,  1371,  1373,  1380,  1382,  1387,  1389,  1394,  1395,
-    1397,  1398,  1403,  1404,  1406,  1408,  1413,  1415,  1421,  1422,
-    1424,  1427,  1430,  1435,  1436,  1441,  1446,  1450,  1452,  1454,
-    1459,  1461,  1467,  1468,  1476,  1477,  1481,  1482,  1483,  1485,
-    1487,  1494,  1495,  1497,  1499,  1504,  1505,  1511,  1512,  1516,
-    1517,  1522,  1523,  1524,  1526,  1534,  1535,  1537,  1540,  1542,
-    1546,  1547,  1548,  1550,  1552,  1556,  1561,  1569,  1570,  1579,
-    1581,  1586,  1587,  1588,  1592,  1593,  1594,  1598,  1599,  1600,
-    1604,  1605,  1606,  1611,  1612,  1613,  1614,  1620,  1621,  1625,
-    1626,  1630,  1631,  1632,  1633,  1648,  1649,  1654,  1655,  1660,
-    1662,  1665,  1667,  1669,  1692,  1693,  1695,  1697,  1702,  1704,
-    1706,  1711,  1712,  1718,  1717,  1721,  1725,  1727,  1729,  1735,
-    1736,  1741,  1746,  1748,  1753,  1755,  1756,  1758,  1763,  1765,
-    1767,  1772,  1774,  1779,  1784,  1792,  1798,  1797,  1811,  1812,
-    1817,  1818,  1822,  1827,  1832,  1840,  1845,  1856,  1857,  1868,
-    1869,  1875,  1876,  1880,  1881,  1882,  1885,  1884,  1895,  1900,
-    1906,  1912,  1921,  1927,  1933,  1939,  1945,  1953,  1959,  1967,
-    1973,  1982,  1983,  1984,  1988,  1992,  1994,  1997,  1999,  2003,
-    2004,  2008,  2012,  2013,  2016,  2018,  2019,  2023,  2024,  2025,
-    2026,  2060,  2061,  2062,  2063,  2067,  2072,  2077,  2079,  2081,
-    2086,  2088,  2090,  2092,  2097,  2099,  2109,  2110,  2111,  2115,
-    2117,  2119,  2124,  2126,  2128,  2133,  2135,  2137,  2146,  2147,
-    2148,  2152,  2154,  2156,  2161,  2163,  2165,  2170,  2172,  2174,
-    2189,  2190,  2191,  2192,  2196,  2201,  2206,  2208,  2210,  2215,
-    2217,  2219,  2221,  2226,  2228,  2230,  2240,  2241,  2242,  2243,
-    2247,  2249,  2251,  2256,  2258,  2260,  2262,  2267,  2269,  2271,
-    2302,  2303,  2304,  2305,  2309,  2317,  2319,  2321,  2326,  2328,
-    2333,  2335,  2349,  2350,  2351,  2355,  2357,  2359,  2361,  2363,
-    2368,  2369,  2371,  2373,  2378,  2380,  2382,  2388,  2390,  2392,
-    2396,  2398,  2400,  2402,  2416,  2417,  2418,  2422,  2424,  2426,
-    2428,  2430,  2435,  2436,  2438,  2440,  2445,  2447,  2449,  2455,
-    2456,  2458,  2467,  2470,  2472,  2475,  2477,  2479,  2492,  2493,
-    2494,  2498,  2500,  2502,  2504,  2506,  2511,  2512,  2514,  2516,
-    2521,  2523,  2531,  2532,  2533,  2538,  2539,  2543,  2545,  2547,
-    2549,  2551,  2553,  2560,  2562,  2564,  2566,  2568,  2570,  2572,
-    2574,  2576,  2578,  2583,  2585,  2587,  2592,  2618,  2619,  2621,
-    2625,  2626,  2630,  2632,  2634,  2636,  2638,  2640,  2647,  2649,
-    2651,  2653,  2655,  2657,  2662,  2667,  2669,  2671,  2689,  2691,
-    2696,  2697
-};
-#endif
-
-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
-static const char *const yytname[] =
-{
-  "$end", "error", "$undefined", "TYPEDEF", "AUTO", "EXTERN", "REGISTER",
-  "STATIC", "INLINE", "FORTRAN", "CONST", "VOLATILE", "RESTRICT", "FORALL",
-  "LVALUE", "VOID", "CHAR", "SHORT", "INT", "LONG", "FLOAT", "DOUBLE",
-  "SIGNED", "UNSIGNED", "BOOL", "COMPLEX", "IMAGINARY", "TYPEOF", "LABEL",
-  "ENUM", "STRUCT", "UNION", "TYPE", "FTYPE", "DTYPE", "CONTEXT", "SIZEOF",
-  "ATTRIBUTE", "EXTENSION", "IF", "ELSE", "SWITCH", "CASE", "DEFAULT",
-  "DO", "WHILE", "FOR", "BREAK", "CONTINUE", "GOTO", "RETURN", "CHOOSE",
-  "FALLTHRU", "TRY", "CATCH", "FINALLY", "THROW", "ASM", "ALIGNAS",
-  "ALIGNOF", "ATOMIC", "GENERIC", "NORETURN", "STATICASSERT",
-  "THREADLOCAL", "IDENTIFIER", "QUOTED_IDENTIFIER", "TYPEDEFname",
-  "TYPEGENname", "ATTR_IDENTIFIER", "ATTR_TYPEDEFname", "ATTR_TYPEGENname",
-  "INTEGERconstant", "FLOATINGconstant", "CHARACTERconstant",
-  "STRINGliteral", "ZERO", "ONE", "ARROW", "ICR", "DECR", "LS", "RS", "LE",
-  "GE", "EQ", "NE", "ANDAND", "OROR", "ELLIPSIS", "MULTassign",
-  "DIVassign", "MODassign", "PLUSassign", "MINUSassign", "LSassign",
-  "RSassign", "ANDassign", "ERassign", "ORassign", "THEN", "'('", "')'",
-  "'['", "']'", "'.'", "'{'", "'}'", "','", "':'", "'!'", "'*'", "'&'",
-  "'+'", "'-'", "'~'", "'/'", "'%'", "'<'", "'>'", "'^'", "'|'", "'?'",
-  "'='", "';'", "$accept", "push", "pop", "constant", "identifier",
-  "no_01_identifier", "no_attr_identifier", "zero_one",
-  "string_literal_list", "primary_expression", "postfix_expression",
-  "argument_expression_list", "argument_expression", "field_list", "field",
-  "unary_expression", "unary_operator", "cast_expression",
-  "multiplicative_expression", "additive_expression", "shift_expression",
-  "relational_expression", "equality_expression", "AND_expression",
-  "exclusive_OR_expression", "inclusive_OR_expression",
-  "logical_AND_expression", "logical_OR_expression",
-  "conditional_expression", "constant_expression", "assignment_expression",
-  "assignment_expression_opt", "tuple", "tuple_expression_list",
-  "assignment_operator", "comma_expression", "comma_expression_opt",
-  "statement", "labeled_statement", "compound_statement",
-  "block_item_list", "block_item", "statement_list",
-  "expression_statement", "selection_statement", "case_value",
-  "case_value_list", "case_label", "case_label_list", "case_clause",
-  "switch_clause_list_opt", "switch_clause_list", "choose_clause_list_opt",
-  "choose_clause_list", "fall_through_opt", "fall_through",
-  "iteration_statement", "for_control_expression", "jump_statement",
-  "exception_statement", "handler_list", "handler_clause",
-  "finally_clause", "exception_declaration", "asm_statement",
-  "asm_operands_opt", "asm_operands_list", "asm_operand",
-  "asm_clobbers_list", "declaration_list_opt", "declaration_list",
-  "old_declaration_list_opt", "old_declaration_list",
-  "label_declaration_opt", "label_declaration_list", "label_list",
-  "declaration", "new_declaration", "new_variable_declaration",
-  "new_variable_specifier", "new_function_declaration",
-  "new_function_specifier", "new_function_return",
-  "new_typedef_declaration", "typedef_declaration", "typedef_expression",
-  "old_declaration", "declaring_list", "declaration_specifier",
-  "type_specifier", "type_qualifier_list_opt", "type_qualifier_list",
-  "type_qualifier", "type_qualifier_name", "$@1",
-  "declaration_qualifier_list", "storage_class_list", "storage_class",
-  "storage_class_name", "basic_type_name", "basic_declaration_specifier",
-  "basic_type_specifier", "direct_type_name", "indirect_type_name",
-  "sue_declaration_specifier", "sue_type_specifier",
-  "typedef_declaration_specifier", "typedef_type_specifier",
-  "elaborated_type_name", "aggregate_name", "aggregate_key",
-  "field_declaration_list", "field_declaration",
-  "new_field_declaring_list", "field_declaring_list", "field_declarator",
-  "bit_subrange_size_opt", "bit_subrange_size", "enum_key", "enum_name",
-  "enumerator_list", "enumerator_value_opt", "new_parameter_type_list_opt",
-  "new_parameter_type_list", "new_parameter_list",
-  "new_abstract_parameter_list", "parameter_type_list_opt",
-  "parameter_type_list", "parameter_list", "new_parameter_declaration",
-  "new_abstract_parameter_declaration", "parameter_declaration",
-  "abstract_parameter_declaration", "identifier_list",
-  "identifier_or_typedef_name", "no_01_identifier_or_typedef_name",
-  "no_attr_identifier_or_typedef_name", "type_name_no_function",
-  "type_name", "initializer_opt", "initializer", "initializer_list",
-  "designation", "designator_list", "designator",
-  "typegen_declaration_specifier", "typegen_type_specifier",
-  "type_parameter_list", "type_parameter", "$@2", "type_class",
-  "assertion_list_opt", "assertion", "type_name_list",
-  "type_declaring_list", "type_declarator", "type_declarator_name",
-  "context_specifier", "$@3", "context_declaration_list",
-  "context_declaration", "new_context_declaring_list",
-  "context_declaring_list", "translation_unit", "external_definition_list",
-  "external_definition_list_opt", "external_definition", "$@4",
-  "external_function_definition", "function_definition", "declarator",
-  "subrange", "asm_name_opt", "attribute_list_opt", "attribute_list",
-  "attribute", "attribute_parameter_list", "attrib", "any_word",
-  "variable_declarator", "paren_identifier", "variable_ptr",
-  "variable_array", "variable_function", "function_declarator",
-  "function_no_ptr", "function_ptr", "function_array",
-  "old_function_declarator", "old_function_no_ptr", "old_function_ptr",
-  "old_function_array", "typedef_redeclarator", "paren_typedef",
-  "typedef_ptr", "typedef_array", "typedef_function",
-  "identifier_parameter_declarator", "identifier_parameter_ptr",
-  "identifier_parameter_array", "identifier_parameter_function",
-  "typedef_parameter_redeclarator", "typedef", "typedef_parameter_ptr",
-  "typedef_parameter_array", "typedef_parameter_function",
-  "abstract_declarator", "abstract_ptr", "abstract_array",
-  "abstract_function", "array_dimension", "multi_array_dimension",
-  "abstract_parameter_declarator", "abstract_parameter_ptr",
-  "abstract_parameter_array", "abstract_parameter_function",
-  "array_parameter_dimension", "array_parameter_1st_dimension",
-  "variable_abstract_declarator", "variable_abstract_ptr",
-  "variable_abstract_array", "variable_abstract_function",
-  "new_identifier_parameter_declarator_tuple",
-  "new_identifier_parameter_declarator_no_tuple",
-  "new_identifier_parameter_ptr", "new_identifier_parameter_array",
-  "new_array_parameter_1st_dimension", "new_abstract_declarator_tuple",
-  "new_abstract_declarator_no_tuple", "new_abstract_ptr",
-  "new_abstract_array", "new_abstract_tuple", "new_abstract_function",
-  "comma_opt", "assignment_opt", 0
-};
-#endif
-
-# ifdef YYPRINT
-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-   token YYLEX-NUM.  */
-static const yytype_uint16 yytoknum[] =
-{
-       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
-     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
-     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
-     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
-     355,    40,    41,    91,    93,    46,   123,   125,    44,    58,
-      33,    42,    38,    43,    45,   126,    47,    37,    60,    62,
-      94,   124,    63,    61,    59
-};
-# endif
-
-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const yytype_uint16 yyr1[] =
-{
-       0,   125,   126,   127,   128,   128,   128,   129,   129,   129,
-     130,   130,   131,   132,   132,   133,   133,   134,   134,   134,
-     134,   134,   134,   135,   135,   135,   135,   135,   135,   135,
-     135,   135,   135,   136,   136,   137,   137,   137,   137,   137,
-     138,   138,   139,   139,   139,   139,   139,   140,   140,   140,
-     140,   140,   140,   140,   140,   140,   140,   140,   140,   140,
-     140,   140,   141,   141,   141,   141,   142,   142,   142,   143,
-     143,   143,   143,   144,   144,   144,   145,   145,   145,   146,
-     146,   146,   146,   146,   147,   147,   147,   148,   148,   149,
-     149,   150,   150,   151,   151,   152,   152,   153,   153,   153,
-     153,   154,   155,   155,   155,   155,   156,   156,   157,   157,
-     157,   157,   158,   158,   159,   159,   159,   159,   159,   159,
-     159,   159,   159,   159,   160,   160,   161,   161,   162,   162,
-     162,   162,   162,   162,   162,   162,   163,   164,   164,   165,
-     165,   166,   166,   166,   166,   167,   167,   168,   169,   169,
-     169,   169,   169,   169,   170,   170,   170,   171,   171,   172,
-     172,   173,   173,   174,   175,   175,   176,   176,   177,   177,
-     178,   178,   178,   178,   179,   179,   180,   180,   181,   181,
-     181,   182,   182,   183,   183,   183,   183,   183,   183,   183,
-     183,   183,   184,   184,   184,   185,   185,   185,   186,   186,
-     187,   188,   188,   188,   188,   188,   189,   189,   189,   189,
-     190,   190,   191,   191,   192,   193,   193,   194,   194,   195,
-     195,   196,   196,   197,   197,   198,   198,   199,   199,   200,
-     200,   201,   201,   202,   202,   202,   202,   202,   203,   203,
-     203,   204,   204,   204,   205,   205,   205,   205,   205,   206,
-     206,   206,   206,   207,   207,   208,   208,   208,   209,   209,
-     209,   209,   209,   210,   210,   211,   211,   211,   211,   212,
-     212,   213,   213,   213,   213,   214,   214,   214,   214,   215,
-     215,   216,   216,   217,   217,   218,   218,   218,   218,   218,
-     219,   218,   220,   220,   220,   221,   221,   222,   223,   223,
-     223,   223,   223,   223,   223,   223,   224,   224,   224,   224,
-     224,   224,   224,   224,   224,   224,   224,   224,   225,   225,
-     225,   225,   225,   226,   226,   227,   227,   227,   227,   228,
-     228,   228,   228,   229,   229,   229,   229,   230,   230,   230,
-     231,   231,   231,   231,   232,   232,   232,   233,   233,   234,
-     234,   234,   234,   234,   235,   235,   236,   236,   237,   237,
-     237,   237,   238,   238,   238,   238,   239,   239,   240,   240,
-     240,   240,   240,   241,   241,   242,   243,   244,   244,   244,
-     245,   245,   246,   246,   247,   247,   248,   248,   248,   248,
-     248,   249,   249,   249,   249,   250,   250,   251,   251,   252,
-     252,   253,   253,   253,   253,   254,   254,   254,   254,   254,
-     255,   255,   255,   255,   255,   256,   256,   257,   257,   258,
-     258,   259,   259,   259,   260,   260,   260,   261,   261,   261,
-     262,   262,   262,   263,   263,   263,   263,   264,   264,   265,
-     265,   266,   266,   266,   266,   267,   267,   268,   268,   269,
-     269,   269,   269,   269,   270,   270,   270,   270,   271,   271,
-     271,   272,   272,   274,   273,   273,   275,   275,   275,   276,
-     276,   277,   277,   277,   278,   278,   278,   278,   279,   279,
-     279,   280,   280,   281,   281,   282,   283,   282,   284,   284,
-     285,   285,   286,   286,   286,   287,   287,   288,   288,   289,
-     289,   290,   290,   291,   291,   291,   292,   291,   291,   293,
-     293,   293,   294,   294,   294,   294,   294,   294,   294,   294,
-     294,   295,   295,   295,   296,   297,   297,   298,   298,   299,
-     299,   300,   301,   301,   302,   302,   302,   303,   303,   303,
-     303,   304,   304,   304,   304,   305,   305,   306,   306,   306,
-     307,   307,   307,   307,   308,   308,   309,   309,   309,   310,
-     310,   310,   311,   311,   311,   312,   312,   312,   313,   313,
-     313,   314,   314,   314,   315,   315,   315,   316,   316,   316,
-     317,   317,   317,   317,   318,   318,   319,   319,   319,   320,
-     320,   320,   320,   321,   321,   321,   322,   322,   322,   322,
-     323,   323,   323,   324,   324,   324,   324,   325,   325,   325,
-     326,   326,   326,   326,   327,   328,   328,   328,   329,   329,
-     330,   330,   331,   331,   331,   332,   332,   332,   332,   332,
-     333,   333,   333,   333,   334,   334,   334,   335,   335,   335,
-     336,   336,   336,   336,   337,   337,   337,   338,   338,   338,
-     338,   338,   339,   339,   339,   339,   340,   340,   340,   341,
-     341,   341,   342,   342,   342,   342,   342,   342,   343,   343,
-     343,   344,   344,   344,   344,   344,   345,   345,   345,   345,
-     346,   346,   347,   347,   347,   348,   348,   349,   349,   349,
-     349,   349,   349,   350,   350,   350,   350,   350,   350,   350,
-     350,   350,   350,   351,   351,   351,   351,   352,   352,   352,
-     353,   353,   354,   354,   354,   354,   354,   354,   355,   355,
-     355,   355,   355,   355,   356,   357,   357,   357,   358,   358,
-     359,   359
-};
-
-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-static const yytype_uint8 yyr2[] =
-{
-       0,     2,     0,     0,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     2,     1,     1,     1,
-       1,     3,     3,     1,     6,     4,     3,     7,     3,     7,
-       2,     2,     7,     1,     3,     0,     1,     3,     7,     9,
-       1,     3,     1,     3,     7,     3,     7,     1,     2,     2,
-       2,     2,     2,     2,     2,     4,     1,     4,     4,     2,
-       4,     2,     1,     1,     1,     1,     1,     4,     4,     1,
-       3,     3,     3,     1,     3,     3,     1,     3,     3,     1,
-       3,     3,     3,     3,     1,     3,     3,     1,     3,     1,
-       3,     1,     3,     1,     3,     1,     3,     1,     5,     4,
-       5,     1,     1,     3,     3,     2,     0,     1,     4,     5,
-       6,     7,     1,     3,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     3,     0,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     4,     2,     7,     1,
-       3,     1,     2,     1,     2,     1,     2,     2,     5,     7,
-       5,     9,     5,     9,     1,     3,     1,     1,     3,     3,
-       2,     1,     2,     2,     0,     1,     2,     3,     0,     1,
-       2,     3,     3,     4,     0,     1,     1,     2,     5,     7,
-       6,     6,     4,     3,     4,     2,     3,     2,     3,     3,
-       3,     2,     3,     3,     4,     1,     5,     6,     9,    10,
-       2,     1,     2,     2,     2,     1,     6,     8,    10,    12,
-       0,     1,     1,     3,     4,     1,     3,     1,     1,     1,
-       3,     1,     1,     1,     3,     0,     1,     3,     4,     1,
-       3,     1,     1,     3,     3,     3,     3,     3,     2,     3,
-       6,     3,     3,     4,     1,     2,     2,     3,     5,    10,
-      10,     7,     7,     5,     9,     2,     2,     5,     3,     5,
-       4,     3,     4,     4,     7,     3,     3,     3,     3,     4,
-       6,     1,     1,     1,     1,     1,     1,     1,     1,     0,
-       1,     1,     2,     1,     1,     1,     1,     1,     1,     1,
-       0,     5,     1,     2,     3,     1,     2,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
-       2,     3,     3,     1,     3,     1,     2,     2,     2,     4,
-       4,     4,     4,     1,     2,     2,     3,     1,     2,     2,
-       1,     2,     2,     3,     1,     2,     2,     1,     1,     4,
-       2,     5,     7,     5,     2,     2,     1,     2,     2,     3,
-       2,     3,     1,     2,     3,     2,     2,     4,     0,     1,
-       2,     2,     1,     0,     1,     2,     2,     5,     6,     2,
-       2,     4,     0,     2,     0,     1,     1,     1,     5,     5,
-       5,     1,     5,     5,     9,     1,     5,     0,     1,     1,
-       5,     1,     1,     5,     5,     1,     3,     3,     4,     1,
-       1,     1,     1,     2,     1,     3,     3,     1,     2,     1,
-       3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     2,     1,     1,     1,     2,     0,     2,     1,
-       4,     1,     2,     3,     4,     2,     2,     1,     2,     2,
-       5,     5,     7,     6,     1,     2,     2,     3,     4,     5,
-       2,     2,     4,     0,     4,     2,     1,     1,     1,     0,
-       2,     5,     5,    13,     1,     1,     3,     3,     2,     3,
-       3,     2,     4,     1,     6,     9,     0,    11,     1,     3,
-       3,     3,     1,     1,     5,     2,     5,     0,     1,     1,
-       3,     0,     1,     1,     1,     1,     0,     6,     2,     1,
-       2,     4,     2,     3,     3,     3,     4,     5,     5,     5,
-       6,     1,     1,     1,     3,     0,     5,     0,     1,     1,
-       2,     6,     1,     3,     0,     1,     4,     1,     1,     1,
-       1,     2,     1,     2,     2,     1,     3,     2,     3,     3,
-       2,     4,     4,     3,     8,     3,     2,     1,     2,     6,
-       8,     3,     2,     3,     3,     4,     4,     3,     1,     1,
-       1,     4,     6,     3,     2,     3,     3,     4,     4,     3,
-       2,     1,     2,     2,     1,     3,     2,     3,     3,     2,
-       4,     4,     3,     6,     8,     3,     2,     1,     2,     2,
-       2,     3,     3,     2,     4,     4,     3,     6,     8,     3,
-       2,     1,     2,     2,     1,     2,     3,     3,     2,     4,
-       6,     8,     1,     2,     2,     1,     2,     2,     3,     3,
-       1,     4,     4,     3,     5,     8,     3,     4,     5,     1,
-       5,     5,     6,     6,     1,     2,     2,     1,     2,     2,
-       3,     3,     1,     4,     4,     3,     5,     8,     3,     1,
-       2,     1,     4,     6,     5,     6,     7,     7,     1,     2,
-       2,     1,     2,     2,     3,     3,     1,     4,     4,     3,
-       8,     3,     1,     1,     2,     1,     1,     2,     3,     2,
-       3,     2,     3,     5,     2,     6,     3,     2,     5,     2,
-       6,     3,     2,     6,     6,     6,     7,     1,     2,     1,
-       1,     1,     2,     3,     2,     3,     2,     3,     5,     6,
-       2,     5,     6,     2,     5,     7,     6,     6,     0,     1,
-       0,     2
-};
-
-/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
-   Performed when YYTABLE doesn't specify something else to do.  Zero
-   means the default is an error.  */
-static const yytype_uint16 yydefact[] =
-{
-     279,   279,   300,   298,   301,   299,   302,   303,   285,   287,
-     286,     0,   288,   314,   306,   311,   309,   310,   308,   307,
-     312,   313,   315,   316,   317,   527,   527,   527,     0,     0,
-       0,   279,   279,   289,   304,   305,     7,   344,     0,     8,
-      13,    14,     0,     2,   279,   545,     9,   505,   503,   231,
-       3,   437,     3,   244,     0,     3,     3,     3,   232,     3,
-       0,     0,     0,   280,   281,   283,   279,   292,   295,   297,
-     325,   271,   318,   323,   272,   333,   273,   340,   337,   347,
-       0,     0,   348,   274,   454,     3,     3,     0,     2,   499,
-     504,   509,   284,     0,     0,   527,   557,   527,     2,   568,
-     569,   570,   279,     0,   710,   711,     0,    12,   279,     0,
-     255,   256,     0,   280,   275,   276,   277,   278,   506,   290,
-     376,   528,   529,   354,   355,    12,   428,   429,    11,   424,
-     427,     0,   483,   478,   469,   428,   429,     0,     0,   508,
-       0,   280,   279,     0,     0,     0,     0,     0,     0,     0,
-       0,   279,     2,     0,   712,   280,   562,   574,   716,   709,
-     707,   714,     0,     0,   238,     2,     0,   512,   422,   423,
-     421,     0,     0,     0,     0,   527,     0,   584,     0,     0,
-     525,   521,   527,   542,   527,   527,   522,     2,   523,   527,
-     581,   527,   527,     0,     0,     0,   279,   279,   298,   345,
-       0,     2,   279,   245,   282,   293,   326,   338,     0,     2,
-       0,   437,   246,   280,   319,   334,   341,   455,     0,     2,
-       0,   296,   320,   327,   328,     0,   335,   339,   342,   346,
-     279,   279,   350,     0,   379,   456,   460,     0,     0,     0,
-       1,   279,     2,   510,   556,   558,   279,     2,   720,   280,
-     723,   525,   525,   280,     0,     0,     0,   258,   527,   522,
-       2,   279,     0,     0,   279,   530,     2,   481,     2,   534,
-       0,     0,     0,     0,    17,    56,     4,     5,     6,    15,
-       0,     0,     0,   279,     2,     0,   279,    62,    63,    64,
-      65,    19,    18,    20,    23,    47,    66,     0,    69,    73,
-      76,    79,    84,    87,    89,    91,    93,    95,    97,   102,
-     475,   730,   435,   474,     0,   433,   434,     0,   546,   561,
-     564,   567,   573,   576,   579,     2,   279,     0,     3,   409,
-       0,   417,   280,   279,   292,   318,   272,   333,   340,     3,
-       3,   391,   395,   405,   410,   454,   279,   411,   685,   686,
-     279,   412,   414,   279,     2,   563,   575,   708,     2,     2,
-     233,     2,     0,     0,   439,   438,   137,     2,     2,   235,
-       2,     2,   234,     2,   266,     2,   267,     0,   265,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   547,   586,
-       0,   437,     2,   541,   550,   639,   543,   544,   513,   279,
-       2,   580,   589,   582,   583,     0,   261,   279,   279,   324,
-       0,   280,   279,   279,   713,   717,   715,   514,   279,   525,
-     239,   247,   294,     0,     2,   515,   279,   479,   321,   322,
-     268,   336,   343,     0,   279,     2,   368,   279,   356,     0,
-       0,   362,   707,   279,   728,   382,     0,   457,   480,   236,
-     237,   500,   279,   419,     0,   279,   221,     0,     2,   223,
-       0,   280,     0,   241,     2,   242,   263,     0,     0,     2,
-     279,   525,   279,   466,   468,   467,     0,     0,   730,     0,
-     279,     0,   279,   470,   279,   540,   538,   539,   537,     0,
-     532,   535,    66,   101,     0,   279,    54,    50,   279,    59,
-     279,   279,    48,    49,    61,     2,   124,     0,     0,   431,
-       0,   430,   279,    52,    53,    16,     0,    30,    31,    35,
-       2,     0,   114,   115,   116,   117,   118,   119,   120,   121,
-     122,   123,     0,     0,    51,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   105,     2,   625,   436,   622,
-     527,   527,   630,   458,   279,     2,   565,     2,   566,     0,
-     577,   578,   279,     2,   279,     0,   687,   280,   691,   682,
-     683,   689,   279,     0,   614,     2,     2,   647,   527,   730,
-     597,   527,   527,   730,   527,   611,   527,   527,   661,   418,
-     644,   527,   527,   652,   659,   279,   413,   280,     0,     0,
-     279,   697,   280,   702,   730,   694,   279,   699,   730,     0,
-     279,   279,     0,     3,    17,     2,     0,     0,   441,   728,
-       0,     0,   447,   225,     0,   279,     0,     0,     0,   525,
-     549,   553,   555,   585,   588,   592,   595,   548,   587,     0,
-     269,     3,     0,   279,   262,     0,     0,     0,     0,   260,
-       0,     2,     0,     0,   243,   516,   279,     0,     0,     0,
-       0,   279,     0,     0,   671,   366,   369,   373,   527,   373,
-     676,   372,   668,   527,   527,   349,   357,   365,   358,   527,
-     360,   363,   279,   729,     0,     0,   380,   728,   280,     3,
-     398,     3,   402,   401,   571,     0,   511,   279,     3,     3,
-     279,   417,   280,     3,   411,   412,     2,     0,     0,     0,
-     465,   291,   279,   461,   463,     3,     2,     2,     0,   482,
-       3,     0,   534,   126,     0,   210,     0,     0,     2,     0,
-       0,    36,     0,     0,   279,    21,     0,    22,     0,   671,
-     432,     0,   106,     0,     3,     2,    28,     2,     0,    33,
-       0,     2,    26,   103,   104,    70,    71,    72,    74,    75,
-      77,    78,    82,    83,    80,    81,    85,    86,    88,    90,
-      92,    94,    96,     0,     0,   731,   279,     0,     0,     0,
-     626,   627,   623,   624,   477,   476,   279,     0,     0,     0,
-     280,   279,   279,   641,   684,   344,     0,   718,   279,   721,
-     640,     2,   279,     0,     0,     0,     0,     0,     0,     0,
-       0,     3,   648,   600,   615,   649,     2,   596,   603,   415,
-     598,   599,   416,     2,   610,   618,   612,   613,   645,   646,
-     660,   688,   692,   690,   730,   253,     2,   724,     2,   406,
-     696,   701,   407,   279,     3,   385,     3,     3,     3,   437,
-       0,     3,     3,     2,   449,   446,   729,     0,   442,     2,
-     445,   448,     0,   279,   226,   248,     3,   257,   259,     0,
-     437,     2,   551,   552,     2,   590,   591,     0,     3,     0,
-     517,     3,   330,   329,   332,   331,   459,   279,     0,   518,
-       0,   519,   279,   353,   359,   361,     2,     0,     0,     0,
-       0,     0,   375,   672,   673,   370,   374,   371,   669,   670,
-     364,   368,   351,   382,   377,   383,     0,     0,     0,   420,
-     224,     0,     0,     3,     2,   647,   413,     0,   507,     0,
-     730,   469,     0,   279,   279,   279,     0,   531,   533,   127,
-       0,   206,     0,     0,   211,   212,    55,    60,   279,     0,
-      58,    57,     0,     0,   125,   672,     0,    67,    68,   107,
-     112,     3,   108,   106,     0,     0,     3,    25,    35,     3,
-       0,    99,     0,     3,   629,   633,   636,   628,     3,   572,
-     108,     2,   279,     3,     3,   280,     0,     2,     2,   719,
-     722,     0,     3,   602,   606,   609,   617,   651,   655,   658,
-     279,     0,     3,   601,   616,   650,   279,   279,   408,   279,
-     279,   279,     0,     0,     0,     0,   240,   108,     0,   101,
-       0,     3,     3,     0,   443,     0,   440,     0,     0,   229,
-     279,     0,     0,   126,     0,     0,     0,     0,     0,   126,
-       0,     0,     0,     2,     0,     0,     3,   128,   129,     2,
-     139,   130,   131,   132,   133,   134,   135,   141,   143,     0,
-       0,     0,   270,   279,   279,   527,   637,     0,     0,     0,
-     520,   279,   279,   279,   675,   679,   681,   674,   367,   381,
-     378,   559,     2,   643,   642,     0,   648,     2,   462,   464,
-     484,     3,   492,   493,     0,     2,   488,     3,     3,     0,
-       0,   536,     0,     0,   210,     0,     3,    37,   108,   728,
-     106,     0,     3,   640,    42,     3,    40,     3,    34,     0,
-       3,    98,   100,     0,     2,   631,   632,     0,   693,   279,
-     698,   279,     0,     0,     0,     3,   279,   279,   279,   617,
-       0,     2,   604,   605,     2,   619,     2,   653,   654,     0,
-     662,     0,     3,     0,     3,     3,     3,     3,   393,   392,
-     396,     0,   727,     2,     2,   726,   109,     0,     0,     0,
-       0,     3,   444,     3,     0,   227,   142,     3,   280,   279,
-       0,     0,     0,     0,     2,   187,     0,   185,     0,     0,
-       0,     0,     0,     0,   191,     0,   279,   527,   147,   144,
-     279,     0,     0,   252,   264,     3,     3,   526,   638,   593,
-     279,   352,     0,     2,   677,   678,   279,   251,   279,     0,
-     495,   472,   279,     0,     0,   471,   486,     0,   207,     0,
-     213,   106,     0,     0,   113,   110,     0,     0,     0,     0,
-       0,     0,    24,     0,   634,   279,   560,   695,   700,   703,
-     704,   705,     0,     3,     3,   656,   279,   279,   279,     3,
-       3,     0,   664,     0,     0,     0,     0,   725,   279,   279,
-       3,   524,   109,   451,     0,     0,   230,   280,     0,     0,
-       0,     0,   279,   188,   186,     0,   183,   189,     0,     0,
-       0,   192,   195,   193,   190,     0,   126,   140,   138,   228,
-       0,     0,   108,   279,   400,   404,   403,     0,   489,     2,
-     490,     2,   491,   485,   279,   214,     0,     0,     3,   640,
-      32,   111,     2,    45,     2,    43,    41,    29,   109,    27,
-       3,   706,     0,     0,     3,     3,     3,     0,     0,   663,
-     665,   607,   620,   254,     2,   390,     3,   389,     0,   453,
-     450,   126,     0,     0,   126,     3,     0,   126,   184,     0,
-       2,   200,   194,     0,   108,   136,   554,   594,     3,     2,
-       0,     0,     2,   208,   215,     0,     0,     0,     0,     0,
-       0,   250,   249,     0,     0,     0,   666,   667,   279,     0,
-     452,   148,     0,     0,     2,   161,   126,   150,     0,   178,
-       0,   126,     0,     2,   152,     0,     2,     2,     0,   279,
-     494,   496,   487,     0,     0,   111,    38,     3,     3,   635,
-     608,   621,   657,   394,   126,   154,   157,     0,   156,   160,
-       3,   163,   162,     0,   126,   180,   126,     3,     0,   279,
-       0,     2,   680,     2,   209,   216,     0,     0,     0,   149,
-       0,     0,   159,   217,   164,     2,   219,   179,     0,   182,
-     168,   196,     3,   201,   205,     0,   279,     0,    39,    46,
-      44,   155,   158,   126,     0,   165,   279,   126,   126,     0,
-     169,     0,     0,   671,   202,   203,   204,   197,     3,   279,
-     145,   166,   151,   126,   220,   181,   176,   174,   170,   153,
-     126,     0,   672,     0,     0,   146,   167,   177,   171,   175,
-     174,   172,     3,     0,   473,   173,   198,     3,   199
-};
-
-/* YYDEFGOTO[NTERM-NUM].  */
-static const yytype_int16 yydefgoto[] =
-{
-      -1,   812,   456,   291,    45,   129,   130,   292,   293,   294,
-     295,   758,   740,  1125,  1126,   296,   297,   298,   299,   300,
-     301,   302,   303,   304,   305,   306,   307,   308,   309,  1030,
-     506,   970,   311,   971,   533,   949,  1055,  1500,  1057,  1058,
-    1059,  1060,  1501,  1061,  1062,  1436,  1437,  1405,  1406,  1407,
-    1484,  1485,  1489,  1490,  1518,  1519,  1063,  1366,  1064,  1065,
-    1301,  1302,  1303,  1472,  1066,   953,   954,   955,  1385,  1464,
-    1465,   457,   458,   873,   874,  1038,    48,    49,    50,    51,
-      52,   329,   153,    55,    56,    57,    58,    59,   331,    61,
-      62,   253,    64,    65,   264,   333,   334,    68,    69,    70,
-      71,   114,    73,   196,   336,   115,    76,   116,    78,    79,
-      80,   437,   438,   439,   440,   675,   915,   676,    81,    82,
-     444,   696,   854,   855,   339,   340,   699,   700,   701,   341,
-     342,   343,   344,   454,   171,   131,   132,   510,   313,   164,
-     628,   629,   630,   631,   632,    83,   117,   477,   478,   941,
-     479,   267,   483,   314,    85,   133,   134,    86,  1324,  1105,
-    1106,  1107,  1108,    87,    88,   717,    89,   263,    90,    91,
-     180,  1032,   664,   393,   121,    92,   489,   490,   491,   181,
-     258,   183,   184,   185,   259,    95,    96,    97,    98,    99,
-     100,   101,   188,   189,   190,   191,   192,   823,   590,   591,
-     592,   593,   594,   595,   596,   597,   558,   559,   560,   561,
-     680,   102,   599,   600,   601,   602,   603,   604,   914,   682,
-     683,   684,   578,   347,   348,   349,   350,   315,   159,   104,
-     105,   351,   352,   694,   555
-};
-
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-   STATE-NUM.  */
-#define YYPACT_NINF -1282
-static const yytype_int16 yypact[] =
-{
-    6907,  3842, -1282,     1, -1282, -1282, -1282, -1282, -1282, -1282,
-   -1282,   -10, -1282, -1282, -1282, -1282, -1282, -1282, -1282, -1282,
-   -1282, -1282, -1282, -1282, -1282,   136,   136,   136,  1007,   747,
-     138,  7125,   631, -1282, -1282, -1282, -1282, -1282,   165, -1282,
-   -1282, -1282,   345, -1282,  8928, -1282, -1282, -1282, -1282, -1282,
-   -1282,   159,   189, -1282,   806, -1282, -1282, -1282, -1282,   201,
-     317,   311,    94,  7234, -1282, -1282,  8997,  1005, -1282, -1282,
-   -1282,   897,   331,  6148,   801,  1179,   897,  1220, -1282, -1282,
-     383,   664, -1282,   897,  1643,   235, -1282,   351,   370, -1282,
-   -1282, -1282, -1282,   274,   189,   136, -1282,   136, -1282, -1282,
-   -1282, -1282,  9564,   806, -1282, -1282,   806, -1282,  9623,   255,
-   -1282, -1282,   546,  9682, -1282,   631,   631,   631, -1282, -1282,
-   -1282,   136, -1282, -1282, -1282,   287,   318,   341, -1282, -1282,
-   -1282,   406, -1282, -1282, -1282, -1282, -1282,   415,   439, -1282,
-     447,   631,  8436,  2364,   389,   451,   472,   499,   502,   515,
-     552,  6455, -1282,   581, -1282,  9065, -1282, -1282, -1282, -1282,
-     588, -1282,    55,  4976, -1282,   475,   111, -1282, -1282, -1282,
-   -1282,   611,   144,   234,   273,   136,   575, -1282,   317,  1977,
-     676, -1282,    41, -1282,   136,   136,   189, -1282, -1282,    67,
-   -1282,   136,   136,  2855,   615,   637,   631, 10424, -1282, -1282,
-     641, -1282,  8928, -1282, -1282,   897, -1282, -1282,   189, -1282,
-     806,   159, -1282,  7408, -1282,   631,   631,   631,   189, -1282,
-    1007, -1282,  3141, -1282, -1282,   638,   631, -1282,   631, -1282,
-    8436,  5322,   660,   747,   666,   631, -1282,  1007,   652,   667,
-   -1282,  7125,   719, -1282, -1282, -1282,  8867, -1282, -1282,  4559,
-   -1282,   676,    99,  9682, 10704,   546,  2855, -1282,    98, -1282,
-   -1282,  9623,   806,   682, 11366, -1282, -1282,    63, -1282, 11101,
-    3465,  4662,  3465, 10932, -1282,   694, -1282, -1282, -1282, -1282,
-   10989, 10989,   719,  8118, -1282,  3465,  8542, -1282, -1282, -1282,
-   -1282, -1282, -1282,   723, -1282,   885,  1800,  3465, -1282,   510,
-     450,   590,   569,   640,   705,   735,   743,   780,    45, -1282,
-   -1282,   758,   602, -1282,    26, -1282, -1282,  2364, -1282, -1282,
-     528,   787, -1282,   574,   787, -1282,  8224,   794, -1282, -1282,
-    1199,   870,  7864, 10424,   897, -1282,   897,   631,   631, -1282,
-   -1282, -1282, -1282, -1282, -1282,   631,  9741,   806, -1282, -1282,
-    9800,  1563, -1282,  6455, -1282, -1282, -1282, -1282, -1282, -1282,
-   -1282, -1282,  4863,  3465, -1282, -1282, -1282, -1282, -1282, -1282,
-   -1282, -1282, -1282, -1282, -1282, -1282, -1282,   546, -1282,   892,
-     814,   824,   846,   914,   866,   868,   873,  1977, -1282, -1282,
-     871,   159, -1282, -1282, -1282,   877, -1282, -1282, -1282,  8867,
-   -1282, -1282, -1282, -1282, -1282,  2855, -1282,  8436,  8436, -1282,
-     546, 11394,  8436,  7516, -1282, -1282, -1282, -1282,  8867,    99,
-   -1282, -1282,   897,   189, -1282, -1282,  8867, -1282,  6031, -1282,
-   -1282,   631,   631,   195,  9859, -1282,  1756,  9269, -1282,   301,
-     305,   747, -1282,  5322,   881,   875,   747,   631, -1282, -1282,
-   -1282, -1282, 10160, -1282,   491,  7784, -1282,   189,   898, -1282,
-     546, 11176, 10761, -1282, -1282, -1282, -1282,   938,  2855, -1282,
-    7929,   676,  7016, -1282, -1282, -1282,  1054,   512,   758,   747,
-   11366,   464,  9623, -1282, 11366, -1282, -1282, -1282, -1282,   598,
-   -1282,   933, -1282, -1282,   243,  8118, -1282, -1282,  8118, -1282,
-    8330,  8118, -1282, -1282, -1282, -1282, -1282,   609,   942,   657,
-     947, -1282,  6119, -1282, -1282, -1282,    71, -1282, -1282, 10818,
-   -1282,   182, -1282, -1282, -1282, -1282, -1282, -1282, -1282, -1282,
-   -1282, -1282, 10704, 10704, -1282,  3465,  3465,  3465,  3465,  3465,
-    3465,  3465,  3465,  3465,  3465,  3465,  3465,  3465,  3465,  3465,
-    3465,  3465,  3465,  5365, 10704, -1282,   602,  1011, -1282, -1282,
-     136,   136, -1282, -1282,  8436, -1282, -1282, -1282,   877,   719,
-   -1282,   877,  6119, -1282,  8648,   949, -1282,  9918, -1282, -1282,
-     588, -1282,  9201,   958, -1282,   297, -1282,  2232,   123,   758,
-   -1282,   136,   136,   758,   253, -1282,   136,   136,   877, -1282,
-   -1282,   136,   136, -1282,   787,  9977,   806, 11307,   145,   279,
-    9977, -1282,  5246, -1282,   758, -1282,  9741, -1282,    23,   964,
-    7581,  7581,   806,  5886,   969, -1282,   337,   975, -1282,   943,
-    4976,   555, -1282,  1045,   806,  7581,   719,   546,   719,   676,
-     767,   787, -1282, -1282,   783,   787, -1282, -1282, -1282,  1013,
-   -1282, 10875,   189, 10160, -1282,   633,   987,   644,   988, -1282,
-     645, -1282,   993,   189, -1282, -1282,  8867,   189,   683,   323,
-     328,  6567,  1152,  3465,  2456, -1282, -1282,   983,    24,   983,
-   -1282, -1282, -1282,   136,   136, -1282, -1282,   747, -1282,   136,
-   -1282, -1282,  9328,   747,   995,  3465, -1282,   881, 11307, -1282,
-   -1282,  1009, -1282, -1282, -1282,   719, -1282, 11242,  3465, -1282,
-    7581,   700,  7864, -1282, -1282,   588,  1014,  1020,  1054,  2940,
-   -1282, -1282, 11366, -1282, -1282,  1012, -1282, -1282,  1027, -1282,
-    1012,  1030, 11101, 10704,  1010,  1058,  1034,  1035, -1282,  1032,
-    1040, -1282,  1041,  1043,  6231, -1282, 10704, -1282,   657,  1148,
-   -1282, 10647, 10704,  1044,  1042, -1282, -1282, -1282,   659, -1282,
-   10704, -1282, -1282, -1282, -1282, -1282, -1282, -1282,   510,   510,
-     450,   450,   590,   590,   590,   590,   569,   569,   640,   705,
-     735,   743,   780,  3465,   751, -1282, 10160,  1049,  1052,  1061,
-    1011, -1282, -1282, -1282, -1282, -1282, 10160, 10875,   677,  1060,
-    6679,  8754,  6455, -1282, -1282,  1066,  1067, -1282,  9564, -1282,
-   -1282,   297, 10160,   979,  1070,  1071,  1073,  1076,  1077,  1078,
-    1079,  4326,  2232, -1282, -1282, -1282, -1282, -1282, -1282, -1282,
-   -1282, -1282, -1282, -1282, -1282, -1282, -1282, -1282, -1282, -1282,
-     877, -1282, -1282, -1282,   758, -1282, -1282, -1282, -1282, -1282,
-   -1282, -1282, -1282,  9446, -1282, -1282,  1082,  1085, -1282,   159,
-    1065,  1042,  5886, -1282, -1282, -1282,  4863,  1087, -1282, -1282,
-   -1282, -1282,   747,  5718,  1168, -1282, -1282, -1282, -1282,  1074,
-     159, -1282, -1282,   877, -1282, -1282,   877,   101,  3465,  1096,
-   -1282, -1282, -1282, -1282, -1282, -1282, -1282,  6455,   989, -1282,
-     189, -1282,  5322, -1282, -1282, -1282, -1282,  1097,   775,  1104,
-    1105,  1108, -1282,  2456, -1282, -1282, -1282, -1282, -1282, -1282,
-   -1282,  1756, -1282,   875, -1282, -1282,  1106,  1109,  1112, -1282,
-   -1282,  1110,  1120, -1282,   700,  1751, -1282,   355, -1282,  2940,
-     758, -1282,  1125, 11366, 10036,  8436,  1134, -1282, -1282,  1129,
-    1140, -1282,  1111,   394,  1135, -1282,  1138,  1138,  6119, 10704,
-   -1282, -1282,  1138,  1141, -1282,  1148,  4863, -1282, -1282, -1282,
-   -1282,  1142,  2180, 10704,  1161,   719,  5886, -1282, 10818, -1282,
-     719, -1282, 10704, -1282,   786,   787, -1282, -1282, -1282, -1282,
-    5608, -1282,  8224, -1282, -1282,  6791,  1165, -1282, -1282, -1282,
-   -1282,  1150, -1282,   793,   787, -1282,   809,   821,   787, -1282,
-     631,  1167,  4797, -1282, -1282, -1282, 10160, 10160, -1282,  7994,
-    7994,  7581,  1154,  1164,  1171,  1182, -1282, -1282,  1177,   378,
-     242,  1042, -1282,   719, -1282,  4976, -1282, 10704,   333, -1282,
-    6002,  1184,  1185, 10590,  1187,  1188,    28,    84,     8, 10704,
-    1190,   189,  4028, -1282,  1183,  1169, -1282, -1282, -1282,  1189,
-   -1282, -1282, -1282, -1282, -1282, -1282, -1282, -1282, -1282,   747,
-    1195, 10704, -1282, 10160, 10160,   136,   787,  1196,  1200,  1066,
-   -1282,  9387,  6119, 10095,   839,   787, -1282, -1282, -1282, -1282,
-   -1282, -1282, -1282, -1282, -1282,  1201,  1751, -1282, -1282,  1191,
-   -1282,  1012, -1282, -1282,   546,  1202, -1282, -1282, -1282,   717,
-    1204, -1282,  3465,  1192,  1058,  1058,  1203, -1282,  4247,   943,
-   10704,  1210,  1142,   371,   143,  1207, -1282,  1203, -1282,  1218,
-    1207, -1282, -1282,  1206, -1282, -1282,   877,  1221, -1282,  9741,
-   -1282,  6343,  1222,  1223,  1224, -1282,  9505,  7581,  7581, -1282,
-    1238, -1282, -1282,   877, -1282, -1282, -1282, -1282,   877, 10704,
-   -1282, 10704,  3465,  1240, -1282, -1282, -1282, -1282, -1282, -1282,
-   -1282,  1243, -1282, -1282, -1282, -1282, -1282,  3465,  3465,  1242,
-    1248,  1207, -1282, -1282,   747, -1282, -1282, -1282,  7343, 10036,
-   10704, 10704,  1297, 10704, -1282, -1282,  1229, -1282,  1231, 10704,
-    1233,  1234, 10704,   876, -1282,  1235,  6119,   136, -1282, -1282,
-    5718,  1257,   359, -1282, -1282, -1282, -1282, -1282,   877, -1282,
-    9133, -1282,  1265, -1282, -1282,   877, 10396, -1282,  7929,  1245,
-   -1282, -1282, 10036,   425,   426, -1282,  1263,  1269, -1282,   493,
-   -1282, 10704,  1274,  1266, -1282, -1282,  1275,   191,   219,   719,
-    1280,  1282, -1282,  1285, -1282, 10160, -1282, -1282, -1282, -1282,
-   -1282, -1282,  1288, -1282, -1282, -1282, 10160, 10160, 10160, -1282,
-   -1282,  1289, -1282,  1290,  1298,  1302,   542, -1282,  7648,  7756,
-   -1282, -1282,   560, -1282,  1303,  1307, -1282,  8059,   724,   726,
-    1305,   729,  5867, -1282, -1282,   430, -1282, -1282,   731,  1311,
-     189,  1359,  1361, -1282, -1282,  1313, 10590, -1282, -1282, -1282,
-    1318,  1319,  3716, 10160, -1282, -1282, -1282,  1316, -1282, -1282,
-   -1282, -1282, -1282, -1282, 10036, -1282,  1299,  1349,  1142,   321,
-   -1282, -1282, -1282, -1282, -1282, -1282, -1282, -1282,  1320, -1282,
-   -1282, -1282,  1325,  1330, -1282, -1282, -1282,  1332,  1335, -1282,
-   -1282, -1282, -1282, -1282, -1282, -1282,  1340, -1282,  1339, -1282,
-   -1282, 10590,    88, 10704, 10590, -1282,  1345, 10704, -1282,   119,
-    1360, -1282, -1282,  1333,  8895, -1282, -1282, -1282, -1282, -1282,
-     806,   546,  1341, -1282, -1282,   741,  1348, 10704,   719,   719,
-    1352, -1282, -1282,  1354,  1355,  1356, -1282, -1282,  7994,  1351,
-   -1282,  1420,  3465,  1357, -1282, -1282, 10510, -1282,   742, -1282,
-    1343, 10590,  1346, -1282, -1282,  1367, -1282,  1374,  1369, 10036,
-   -1282, -1282, -1282,  1350,  1401,  1370, -1282,  1207,  1207, -1282,
-   -1282, -1282, -1282, -1282, 10590,   250, -1282,   848, -1282, -1282,
-    4642, -1282, -1282,  1353, 10704, -1282, 10704,  4642,   189,  9859,
-    1376, -1282, -1282,  1373, -1282, -1282, 10704,  1379,  1380, -1282,
-    3465,  3465, -1282, -1282,   941,   285, -1282, -1282,  1364, -1282,
-     941, -1282, -1282,  1486,   719,   189,  9859,  1389, -1282, -1282,
-   -1282, -1282, -1282, 10510,  1384,   941,  5533, 10704, 10430,  1386,
-     941,  1394,  1486,  2735, -1282, -1282, -1282, -1282, -1282,  8436,
-   -1282, 10275, -1282, 10510, -1282, -1282,  1375, 10194, -1282, -1282,
-   10430,   189,  2735,  1396,   750, -1282, 10275, -1282, -1282, -1282,
-   10194, -1282, -1282,   189, -1282, -1282, -1282, -1282, -1282
-};
-
-/* YYPGOTO[NTERM-NUM].  */
-static const yytype_int16 yypgoto[] =
-{
-   -1282,  3627,  2947, -1282,   196, -1282,    -1,     2,   856, -1282,
-   -1282, -1282,  -501,  -954,  -132,  4826, -1282,   550,   462,   467,
-     565,   480,   962,   971,   961,   967,   974, -1282,   504,  -258,
-    4453,   393,  -677,  -933, -1282,   413,  -701,   218, -1282,   102,
-   -1282,   320,  -898, -1282, -1282,    66, -1282, -1281,  -919,   162,
-   -1282, -1282, -1282, -1282,    13, -1141, -1282, -1282, -1282, -1282,
-   -1282, -1282,   227,    64,    51,   431, -1282,   424, -1282,    97,
-   -1282,  -349, -1282, -1282, -1282,   477,  -807, -1282, -1282,     6,
-    -868,   230,  2325, -1282, -1282, -1282,   -59, -1282,   481,   454,
-     -19,  1139,  3236, -1282, -1282,   158,   220,   716,  -245,  1368,
-   -1282,  1437, -1282, -1282,   109,  1702, -1282,  2029,   506, -1282,
-   -1282,  -372,  -403,  1113,  1114,   639,   879,   266, -1282, -1282,
-    1118,   636,  -572, -1282,  -366,   -43,    83, -1282, -1282,  -918,
-    -966,   649,  1279,   997,   363, -1282,  1310,   185,  -290,  -186,
-    -142,   601,   702, -1282,   952, -1282,  2189,  -442,   847, -1282,
-   -1282,   632, -1282,  -222, -1282,   -94, -1282, -1282, -1282, -1269,
-     342, -1282, -1282, -1282,  1124, -1282,    29, -1282, -1282,  -830,
-     -98, -1233,  -171,  2043, -1282,  2998, -1282,   853, -1282,  -164,
-     122,  -172,  -168,  -167,     4,   -41,   -39,   -37,  1629,    33,
-      68,    81,  -150,  -161,  -159,  -158,  -155,  -301,  -486,  -482,
-    -474,  -542, -1282,  -470, -1282, -1282,  -499,  1022,  1024,  1036,
-    1804,  4208,  -559,  -544,  -538,  -533,  -397, -1282,  -377,  -641,
-    -636,  -635,  -566,  -299,  -293, -1282, -1282,   562,    89,   -80,
-   -1282,    85,   134,  -613,  -380
-};
-
-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-   positive, shift that token.  If negative, reduce the rule which
-   number is the opposite.  If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -503
-static const yytype_int16 yytable[] =
-{
-     109,   145,    46,   146,    94,   147,   380,   110,   433,   391,
-     381,   382,   494,   140,   257,   388,   867,   383,   759,   384,
-     385,   365,   250,   386,   486,   420,  1130,   579,   825,   389,
-     589,   909,   950,    46,   686,    94,   910,   911,   725,   842,
-    1122,   818,   730,  1068,    46,   824,    46,   819,   156,   858,
-     652,    47,   820,   613,  1170,  1382,    46,   617,   791,   681,
-     139,    30,    46,   876,   186,    46,  1067,   208,    46,   663,
-     218,   692,   211,   107,   968,   148,   118,   667,    30,  1181,
-     463,   465,    47,   380,   926,   106,   106,   381,   382,   103,
-     103,   119,   388,   107,   383,   406,   384,   385,   723,   814,
-     386,  1168,  1169,   815,    30,    46,   389,   909,    46,    74,
-     149,   816,   910,   911,    46,   817,   106,   656,   658,  1199,
-     103,   194,    93,   150,   464,  1442,   427,   392,   563,   160,
-    1402,  1403,   750,   552,   564,    30,   107,   145,   933,   146,
-      74,   147,   242,   448,   392,    46,   554,   156,   210,   107,
-    1453,   106,  1195,    93,   167,   103,   390,    46,    66,   355,
-      30,  1402,  1403,   359,   144,   195,    93,   553,   400,  1438,
-     392,   714,  1187,    30,   755,   720,   515,   409,   161,   360,
-      46,    46,   182,   156,   481,    93,   482,   459,    93,    66,
-     660,   828,   729,   160,  1404,    46,   243,   835,   262,   469,
-     464,   392,  1442,  1075,    46,   650,   156,  1442,  1197,   829,
-     742,   148,    46,   832,   145,    46,   146,   423,   147,   368,
-      67,  1247,  1442,   647,   826,  1413,   586,   160,  1438,  1442,
-      53,   111,   814,  1186,   849,   369,   815,   648,   852,   138,
-     357,   453,   161,    46,   816,    94,   149,   107,  1248,   845,
-     170,    67,   371,   846,   856,   856,   107,    46,    46,   150,
-     156,    53,  1170,  1015,    46,    93,   142,   818,   372,   856,
-     451,    46,   677,   819,   795,   579,   316,    93,   820,   639,
-    1014,   504,   163,   205,   107,   761,   679,   160,   398,   686,
-      30,   987,    47,   203,  1332,   165,   212,   668,   210,   170,
-     379,   182,   170,   564,   647,  1132,   579,   654,  1328,   175,
-     417,   579,   659,  1170,   193,   160,   442,   900,   648,    46,
-     425,   355,  1334,   851,    93,   814,   106,  -218,  -218,   815,
-     103,  1177,    46,    46,  -275,    93,   416,   816,   357,  1460,
-     459,  1001,   373,   237,   856,   734,   160,  1508,  1201,    46,
-      74,   240,   735,    46,   833,    74,   586,  1178,   374,   459,
-    1168,  1169,    36,    93,   316,  1178,    39,   459,   442,  1521,
-    -498,   160,   714,    40,    41,   242,   825,   467,   254,    46,
-    1068,   375,    36,   847,   177,   508,    39,   848,   -10,    46,
-     818,   355,  -218,    40,    41,   416,   819,   376,   811,    66,
-     586,   820,   107,  1067,   135,   136,   170,    46,   587,   687,
-      36,   580,    46,   689,    39,   912,   828,   606,   178,  -425,
-     161,    40,    41,  -109,  1187,   688,   842,   713,   179,   690,
-    1387,   687,  1170,   422,  1427,  1428,   689,   925,    46,    93,
-     863,  1184,  -426,   421,  -109,   714,    42,   904,   107,  1171,
-     135,   136,   905,   588,   109,   112,   143,  1185,   170,   847,
-     581,    67,    46,  1097,  1018,   170,   251,  1184,   880,   252,
-      46,    53,   355,  -109,    46,  -109,    94,  1128,    46,  -109,
-    1433,    60,  -102,  1309,   230,  1367,  -102,   486,   868,   231,
-     242,   318,   160,   160,  -109,  -109,  1113,   160,   154,   739,
-     380,  1101,   809,  1114,   381,   382,  1243,   266,    74,   182,
-     388,   383,    60,   384,   385,   756,   268,   386,   739,   442,
-     762,  1013,   442,    47,   389,   665,   170,    74,   442,   107,
-    1081,   135,   136,  1319,  1321,    74,  1087,  1015,   746,   878,
-     269,   316,   316,   170,   681,  1483,   316,   170,   270,  1320,
-    1322,  1488,   205,   319,  1368,   715,   248,   106,   678,   706,
-    1098,   103,   154,   538,   539,   726,  1503,   160,   453,   207,
-     727,  1510,  1187,   419,   320,  1263,  1264,   857,   857,  1187,
-     442,    74,   366,   442,    46,   160,   442,    46,  1087,    46,
-    1507,  1365,   857,   704,    93,  1326,   312,   508,   588,   705,
-     508,   321,  1327,   508,   322,  1516,   158,   459,    46,  1155,
-    1157,    36,  1520,   177,   721,    39,   316,   323,  1187,   207,
-     722,   535,    40,    41,    46,   471,   536,   537,   713,   565,
-      66,   392,   488,  1466,   316,   877,    46,   879,  1013,    46,
-    1466,     8,     9,    10,    11,    12,  1353,   255,   930,   160,
-    1354,   410,   542,   543,   324,   856,   414,   256,   869,   580,
-     626,   207,   804,  -450,   870,  -450,  1412,   857,    30,  -450,
-     158,   540,   541,  1026,    46,   569,    46,   392,   686,  1504,
-     736,   205,   354,   737,   312,   436,   743,   544,   545,   358,
-     580,    33,    67,   579,  1072,   580,   507,  1140,   316,   378,
-     731,   713,    53,   556,   929,   392,   732,   813,   581,   588,
-     614,   745,   370,   557,   618,   414,   407,   746,   476,   207,
-      46,    46,    60,  1109,  1034,   546,   547,   460,  1000,   107,
-     801,   135,   136,   390,    46,   892,   891,   509,   408,   843,
-     154,   746,   412,  1468,   581,  1469,   894,   896,   107,   647,
-     135,   136,   746,   564,   890,   207,   715,   677,   748,   207,
-     392,   977,   430,   648,   415,   899,   443,   978,   749,   901,
-     233,   679,   446,   809,   493,    74,   449,   442,   806,   989,
-     576,   856,   856,   221,   107,   705,  1505,   222,   472,   902,
-     226,   450,   228,   441,   908,   500,   678,   936,   515,   235,
-     611,   934,   170,   586,   615,     2,   198,     4,     5,     6,
-       7,   935,   107,    46,   135,   136,    74,   548,   170,  1235,
-     655,   657,   497,   415,    46,   564,  1361,   422,  1362,   715,
-     170,  1364,   746,  1369,   746,   513,   514,   746,   207,   746,
-     813,   588,   714,  1423,  1443,   511,  1258,   534,   158,  1424,
-     746,   909,  1524,  1140,  1237,   549,   910,   911,   564,   746,
-     982,   312,   312,    34,   550,    35,   312,   551,   881,   983,
-     392,    36,  1054,   168,   169,    39,   514,   318,   392,   988,
-     460,   554,    40,    41,   884,   606,   392,  1134,   436,   392,
-     567,   436,   809,  1182,  1151,  1002,   392,   436,   582,   460,
-      46,     2,   198,     4,     5,     6,     7,   460,   507,   112,
-    1154,   507,   586,   514,   507,    46,   640,   207,   205,  1280,
-    1281,   221,  1156,    46,   586,    -3,   641,  1140,   170,   714,
-    1299,  1300,   205,   813,   476,    36,   312,   584,   476,    39,
-    1223,    46,   392,   916,   588,   916,    40,    41,   642,   509,
-    1102,   711,   509,    60,   312,   509,  1461,  1462,   106,    34,
-     801,    35,   103,   516,   517,   518,   784,   207,   644,   844,
-     645,   585,   649,   586,  1124,   646,  1167,   739,   857,  1124,
-     247,   587,    74,  1402,  1403,   859,   519,   442,   520,   693,
-     521,  1159,    46,   242,   318,   392,   441,   875,   695,   441,
-     768,   769,  1080,   809,  -222,   441,  1230,   770,   771,     2,
-     198,     4,     5,     6,     7,   400,   643,   392,   312,  1140,
-     205,     8,     9,    10,    11,    12,   776,   777,   576,   106,
-     160,    66,  1124,   103,   733,   678,   807,   220,   809,   469,
-     318,   392,  1054,   678,   747,  1196,  1198,  1200,    30,   751,
-     221,   866,   226,   803,    36,   801,  1079,   511,    39,   841,
-     511,   588,   810,   511,   576,    40,    41,    34,   853,    35,
-     850,    33,   125,   872,   126,   127,   128,   580,   -12,   316,
-     826,   318,   586,   207,   865,   765,   766,   767,   279,   893,
-     895,  1056,   673,    67,   806,   488,  1495,   898,   713,  1165,
-    1166,   702,   924,    53,   857,   857,    46,   772,   773,   774,
-     775,  -399,   556,   207,   392,  1333,  1335,  1336,   207,    36,
-     722,  -502,   557,    39,   514,   106,   843,   938,   945,   103,
-      40,    41,   947,   952,   951,  1087,   956,   957,   221,    63,
-     113,   959,   960,   961,  1435,   962,   436,   460,   972,    74,
-     973,   984,   711,  1203,   985,   718,  1215,  1216,     8,     9,
-      10,    11,    12,   986,   990,   719,   442,   997,   998,  1027,
-      63,   141,  1003,  1004,  1103,  1005,   476,   493,  1006,  1007,
-    1008,  1009,  -276,   155,  -387,    30,   806,  -386,   460,     8,
-       9,    10,    11,    12,  1036,   211,  1069,  1071,  1189,   493,
-    1076,  1083,  1481,  1435,   207,   213,  1084,  1085,    33,  1054,
-    1086,  1091,  1112,  1090,  1093,   422,    30,    36,   207,   177,
-    1092,    39,    46,  -277,  1094,   711,   715,  1100,    40,    41,
-       8,     9,    10,    11,    12,  1356,  1110,   746,  1102,    33,
-     801,   249,  1111,  1115,   966,  1118,  1124,  1124,  1124,   748,
-    1120,   392,  1149,   672,   441,   392,  1172,    30,   514,   749,
-      67,  1192,   999,   674,    36,  1123,   168,   169,    39,  1146,
-      53,  1160,  1173,   210,   106,    40,    41,  1514,   103,  1174,
-      33,  1176,   317,  1421,  1175,  1190,  1191,   981,  1193,  1194,
-     332,  1202,  1207,  1208,   809,   106,    -3,  1213,  1219,   103,
-     354,   967,   702,  1227,  1220,  1054,   207,   807,  1254,  1231,
-    1236,  1241,   481,   715,  1245,  1249,  1238,   106,   387,    74,
-     380,   103,  1252,  1256,   381,   382,  1259,  1260,  1261,   388,
-    1102,   383,   405,   384,   385,   141,   411,   386,  1340,   137,
-    1265,   155,  1290,   389,  1272,  1277,  1282,  1317,   647,  1344,
-    1345,  1346,  1283,  1293,    60,  1294,   436,  1296,  1297,  1304,
-    1054,   428,   648,  1054,  1308,   431,  1029,   432,    66,  1312,
-    1323,  1325,   210,  1330,   447,  1494,    46,   106,  1329,  1331,
-      63,   103,    46,    46,  1337,   461,  1338,  1124,  1124,  1339,
-     232,   234,  1341,  1349,  1350,   468,  1378,   476,  1104,   312,
-    1351,    74,  1371,   411,  1352,  1054,  1363,  1359,   205,   106,
-    1054,  1360,  1370,   103,  1300,  1373,   806,  1374,   203,   212,
-    1376,  1377,  1379,  1383,  1384,  1102,   807,  1391,  1056,  1387,
-      67,   206,  1392,  1054,  1417,   702,  1396,    72,   514,  1397,
-      53,   224,  -388,  1400,  1138,   702,   841,  1411,  1422,  1415,
-    1189,   145,  1425,   146,  1429,   147,  1430,  1431,  1432,  1354,
-    1434,   702,  1103,  1450,   441,   577,  1439,  1444,    72,  1448,
-    1446,  1452,   607,  1496,  1454,    46,  1455,  1467,  1475,  1456,
-    1477,   206,  1054,  1479,  1480,   612,  1131,  1054,  1487,   612,
-    1499,  1502,   332,  1509,    46,    46,  1511,   156,  1523,  1517,
-    1054,   207,  1054,   214,   106,   887,  1054,   422,   103,  1054,
-     778,   780,    67,  1244,    46,  1054,   355,   421,   781,  1054,
-     779,   460,    53,   206,  1375,   106,   782,  1482,  1372,   103,
-    1307,  1414,   106,  1525,   442,   436,   103,   807,   461,  1240,
-    1498,  1029,   514,   445,  1470,  1239,  1212,   669,   670,    74,
-    1471,    36,   332,   177,  1103,    39,    74,   461,   917,  1089,
-    1088,   442,    40,    41,   697,   461,   798,  1119,  1035,   940,
-     806,   106,   807,  1099,  1318,   103,   170,  1497,   787,  1401,
-     788,   206,  1409,   871,   160,   948,     0,  1492,   335,   392,
-     497,   698,   789,  1257,   411,    74,   716,  1493,  1189,     0,
-    1138,     0,     0,  1288,  1289,  1189,  1291,     0,     0,   712,
-       0,    63,  1295,  1522,   467,  1298,   493,   206,     0,   411,
-       0,   206,   711,   411,  1441,  1527,     0,     0,    36,  1445,
-     168,   169,    39,   316,     0,     0,     0,   487,     0,    40,
-      41,     0,     0,   441,  1189,     0,  -278,     0,     0,  1103,
-       0,   332,  1459,     8,     9,    10,    11,    12,     0,   429,
-      67,     0,     0,     0,   358,   702,   702,    67,     0,     0,
-      53,     0,   627,   157,  1138,     0,     0,    53,    72,     0,
-      30,   493,   493,    72,     0,     0,  1104,     0,     0,   187,
-       0,    60,   209,     0,   207,   219,   790,     0,     0,     0,
-     206,     0,    75,    33,     0,     0,    67,     0,     0,   711,
-       0,   800,   514,   577,     0,     0,    53,     0,     0,  1515,
-       0,   249,   702,   702,     0,  1515,   822,     0,     0,     0,
-       0,   703,     0,    75,  1515,     0,     0,     0,  1515,     0,
-       0,     0,     0,  1420,   577,     0,     0,     0,     0,   577,
-       0,   691,     0,     0,     0,   612,   445,     0,     0,   332,
-     332,     8,     9,    10,    11,    12,  1138,     0,   215,     0,
-     214,     0,   157,   460,   332,     0,  1408,     0,  1104,   206,
-       0,     0,     0,     0,   356,     0,     0,     0,    30,   724,
-     335,   728,   698,   207,     0,     0,   206,     0,     0,     0,
-       0,     0,     0,     0,     0,   461,     0,     0,   157,     0,
-     712,    33,     0,   913,     0,     0,     0,     0,     0,     0,
-       0,    36,     0,   177,     0,    39,     0,     0,   807,   206,
-       0,   157,    40,    41,     0,     0,    72,     0,     0,     0,
-       0,     0,   424,     0,     0,     0,   461,     0,     0,   332,
-     335,     0,   934,   337,   586,    72,     0,   672,   939,   392,
-       0,   411,   935,    72,     0,   673,     0,   674,     0,     0,
-       0,     0,     0,  1104,     0,  1315,     0,     0,     0,     0,
-       0,     0,     0,   712,     0,     0,     0,     0,   965,   335,
-     522,   523,   524,   525,   526,   527,   528,   529,   530,   531,
-       0,     0,     0,  1473,   702,     0,   493,   335,     0,    72,
-       0,     0,     0,     0,     0,   702,   702,   702,     0,     0,
-       0,   460,     0,   532,     0,   698,     0,     0,   460,     0,
-    1473,     0,   703,     0,     0,   698,   864,     0,     0,     0,
-     995,   800,     0,    75,     0,   206,   356,   249,    75,   335,
-       0,   698,     0,   312,     0,     0,     0,     0,     0,     0,
-    1012,     0,   702,     0,   493,   493,     0,   460,     0,     0,
-       0,     0,     0,     0,     0,   206,     0,     0,   903,     0,
-     206,     0,     0,     0,     0,     0,   394,     8,     9,    10,
-      11,    12,   249,   402,     0,     0,     0,   920,     0,     0,
-       0,     0,     0,   923,     0,     0,     0,     0,     0,   335,
-       0,  1474,    63,     0,    30,     0,   356,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    77,
-       0,     0,     0,     0,     0,   215,   800,    33,  1474,     0,
-       0,     0,    36,     0,   177,     0,    39,     0,     0,     0,
-       0,     0,     0,    40,    41,   337,     0,   335,   335,     0,
-      77,     0,   394,     0,     0,   703,   206,     0,   120,   123,
-     124,     0,   335,     0,  1096,   703,     0,     0,   178,     0,
-     206,     0,   411,   113,     0,     0,     0,     0,   179,     0,
-     335,   703,     0,     0,     0,   216,     0,   332,     0,     0,
-     487,    75,     0,    72,     0,     0,     0,     0,   335,     0,
-       0,   249,     0,     0,     0,   337,   562,     0,     0,     0,
-      75,     0,     0,     0,   566,     0,     0,   570,    75,   612,
-       0,   577,     0,     0,     0,     0,     0,     0,   244,     0,
-     245,     0,     0,     0,    72,     0,     0,   335,     0,   141,
-       0,     0,     0,     0,   337,   698,   698,     0,   332,   332,
-     332,     0,     0,     0,     0,     0,     0,     0,   206,     0,
-       0,     0,   337,     0,    75,     0,   627,     0,     0,  1188,
-     338,   335,  1039,   394,     0,     0,     0,   402,     0,    84,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,  -279,     0,    25,
-      26,    27,   698,   698,   337,     0,     0,    30,   377,     0,
-      84,   800,   249,   335,     0,     0,     0,   396,   397,     0,
-       0,     0,   401,   335,   403,   404,     0,     0,   214,   335,
-      33,     0,     8,     9,    10,    11,    12,    37,    38,   335,
-       0,  -279,     0,     0,     0,   217,     0,   249,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    30,
-      77,   394,     0,     0,   337,    77,   627,     0,   612,     0,
-     712,  1021,     0,   567,     0,   612,   332,   332,     0,     0,
-       0,   108,    33,     0,     0,   703,   703,    36,     0,   584,
-       0,    39,     0,     0,     0,     0,     0,     0,    40,    41,
-      72,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   337,   337,     0,    54,    54,     0,  1287,     0,
-       0,     0,     0,   585,   335,   586,     0,   337,     0,     0,
-     345,     0,     0,   587,     0,   332,     0,     0,     0,    63,
-       0,     0,   703,   703,     0,   337,    54,     0,     0,   612,
-     562,   562,   216,   206,     0,   698,     0,   712,    75,     0,
-       0,   113,     0,   337,     8,     9,    10,    11,    12,  1039,
-       0,     0,   338,     0,     0,     0,     0,     0,    54,     0,
-       0,    54,     0,     0,   698,   335,     0,     0,     0,     0,
-       0,    30,     0,     0,     0,   698,   698,   698,     0,    75,
-       0,     0,   337,     0,     0,     0,     0,   332,   332,     0,
-       0,     0,     0,     0,    33,     0,     0,     0,    77,    36,
-      84,  1188,     0,    39,     0,    84,     0,     0,     0,     0,
-      40,    41,   338,     0,   882,     0,   337,    77,   885,     0,
-       0,   612,   698,   335,   335,    77,   335,   335,   335,     0,
-       0,     0,     0,   113,     0,    42,     8,     9,    10,    11,
-      12,     0,     0,     0,     0,   143,   330,    72,     0,     0,
-       0,   338,   394,     0,     0,     0,     0,     0,   337,     0,
-       0,     0,     0,    30,  1286,     0,     0,     0,   337,   338,
-       0,    77,     0,   215,   337,  1316,     0,     0,     0,     0,
-     335,   335,     0,   249,   337,     0,    33,     0,     0,   335,
-       0,    36,   217,   177,     0,    39,     0,     0,     0,     0,
-       0,     0,    40,    41,   703,     0,     0,   332,    54,     0,
-       0,   338,   345,     0,     0,   703,   703,   703,     0,     0,
-       0,     0,     0,     0,     0,     0,   206,   672,   113,   392,
-       0,     0,     0,     0,     0,     0,    54,   674,     0,     0,
-       0,     0,     0,     0,     0,    75,     0,     0,   335,  1188,
-       0,     0,     0,     0,   335,   335,  1188,     0,    84,     0,
-       0,     0,   703,     0,   562,     0,     0,     0,     0,   337,
-       0,   338,   345,   792,   793,     0,     0,    84,     0,     0,
-       0,     0,     0,     0,     0,    84,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1188,   214,     0,     0,     0,
-       0,   827,  1512,     0,   830,   831,     0,   834,     0,   836,
-     837,   345,     0,   335,   838,   839,     0,    72,     0,   338,
-     338,     0,     0,     0,     0,   206,     0,     0,     0,   345,
-     337,    84,     0,   335,   338,   335,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   330,     0,
-       0,     0,   338,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   335,     0,     0,    77,     0,     0,     0,     0,
-     338,   345,     0,   335,   335,   335,     0,     0,     0,     0,
-       0,     0,   394,     0,     0,   335,   335,     0,   337,   337,
-       0,   337,   337,   337,     0,     0,   918,   919,     0,    72,
-       0,     0,   921,     0,     0,     0,    77,     0,   330,   338,
-       0,     0,    75,     0,     0,     8,     9,    10,    11,    12,
-     335,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   345,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    30,   338,     0,   337,   337,     0,     0,     0,
-       0,     0,     0,     0,   337,     0,     0,     0,  1135,     0,
-       0,     0,     0,     0,     0,    33,     0,    54,     0,     0,
-      36,     0,   177,     0,    39,     0,     0,  1152,     0,   345,
-     345,    40,    41,     0,     0,   338,     0,     0,     0,     0,
-       0,     0,     0,     0,   345,   338,     0,     0,     0,     0,
-     216,   338,     0,     0,     0,   335,  1492,   330,   392,     0,
-       0,   338,   345,   337,     0,     0,  1493,     0,     0,   337,
-     337,     0,     0,     0,     0,    84,     0,     0,     0,     0,
-     345,     0,     0,     0,     0,     8,     9,    10,    11,    12,
-       0,     0,     0,     0,     0,     0,     0,    72,     0,     0,
-       0,     0,     0,     0,    72,     0,     0,     0,  1224,     0,
-       0,   215,    30,     0,     0,     0,    84,   330,     0,   345,
-       0,     0,    77,     0,     0,     0,     0,     0,   337,     0,
-       0,     0,    75,     0,     0,    33,     0,     0,     0,     0,
-      36,     0,   177,    72,    39,     0,   338,     0,   337,     0,
-     337,    40,    41,   345,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   330,   330,     0,     0,     0,
-       8,     9,    10,    11,    12,     0,   255,   337,     0,     0,
-     330,     0,     0,     0,     0,     0,   256,     0,   337,   337,
-     337,     0,     0,     0,     0,   345,     0,    30,     0,     0,
-     337,   337,     0,     0,     0,   345,     0,   338,     0,     0,
-     217,   345,     0,     0,    75,     0,     0,   162,     0,   166,
-      33,   345,   172,   173,   174,    36,   176,     0,     0,    39,
-       0,     0,     0,     0,     0,   337,    40,    41,     0,     0,
-       0,   225,     0,   122,   122,   122,     0,     0,     0,     0,
-       0,     0,   238,   239,     0,   330,     0,     0,     0,     0,
-       0,   718,     0,     0,     0,   338,   338,     0,   338,   338,
-     338,   719,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    84,     0,     0,     0,     0,     0,     0,    77,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   345,     0,     0,     0,
-       0,     0,     0,   122,     0,   122,     0,     0,   327,     0,
-     337,     0,   338,   338,     0,     0,     0,     0,     0,     0,
-       0,   338,     0,     0,     0,     0,     0,     0,  1217,   265,
-       0,     0,     0,     0,     0,     0,     0,   330,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    75,     0,     0,     0,     0,   345,     0,    75,
-       0,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,  -279,     0,
-     338,     0,     0,   122,     0,     0,   338,   338,    30,     0,
-     122,     0,   122,   122,     0,     0,     0,   122,    75,   122,
-     122,     0,     0,     0,     0,     0,     0,     0,    54,     0,
-       0,    33,     0,     0,     0,   345,   345,     0,   345,   345,
-     345,     0,  -279,     0,     0,     0,     0,     0,   216,     0,
-       0,     0,   330,     0,     0,     0,     0,     0,     0,    84,
-       0,     0,     0,     0,     0,   338,     0,     0,     0,    77,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1306,     0,     0,     0,     0,   338,   122,   338,     0,     0,
-       0,     0,   345,   345,     0,     0,     0,     0,     0,    54,
-       0,   345,     0,   575,     0,   583,     0,     0,     0,     0,
-       0,     0,     0,   330,   338,     0,   608,   609,     0,     0,
-       0,     0,     0,     0,     0,   338,   338,   338,     0,   204,
-     619,     0,     0,     0,     0,     0,     0,   338,   338,   223,
-       0,   227,     0,   229,     0,     0,     0,     0,     0,     0,
-     236,    77,     0,     0,     0,     0,     0,     0,     0,     0,
-     345,     0,     0,     0,     0,     0,   345,   345,     0,     0,
-       0,     0,   338,     0,   330,   330,   330,     0,     0,   204,
-       0,   227,   229,   236,     0,     0,     0,     0,     0,     0,
-     662,     0,     0,     0,     0,    54,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   204,   217,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   204,     0,     0,     0,   345,     0,     0,     0,    84,
-       0,     0,     0,     0,     0,     0,     0,   330,     0,     0,
-       0,     0,     0,     0,     0,   345,     0,   345,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   338,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   345,     0,     0,     0,     0,   204,
-       0,   227,   229,   236,     0,   345,   345,   345,     0,   753,
-       0,     0,     0,     0,     0,     0,     0,   345,   345,    77,
-       0,     0,   330,   330,     0,     0,    77,     0,     0,     0,
-       0,    84,     0,     0,     0,   204,     0,     0,     0,   204,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   271,   345,   272,     0,   485,     0,     0,     0,     0,
-       0,     0,     0,    54,    54,    77,     0,     0,     0,   799,
-       0,     0,     0,     0,   273,     0,     0,     0,     0,     0,
-     274,   330,     0,     0,   275,    54,     0,   276,   277,   278,
-     279,    40,    41,     0,   280,   281,     0,     0,     0,     0,
-       0,     0,   282,   204,     0,     0,     0,    54,   122,   122,
-       0,     0,     0,     0,     0,     0,   283,     0,   204,     0,
-     860,     0,     0,   227,   229,   285,   363,   287,   288,   289,
-     290,   236,     0,     0,     0,     0,   122,   345,     0,   122,
-     122,     0,   122,     0,   122,   122,     0,     0,   889,   122,
-     122,     0,     0,   330,   330,     0,     0,     0,     0,     0,
-       0,     0,    54,     0,     0,     0,     0,    54,   907,     0,
-       0,     0,     0,   204,     0,     0,     0,     0,     0,    84,
-       0,     0,     0,     0,     0,     0,    84,     0,     0,     0,
-       0,   204,     0,     0,     0,     0,   927,   204,   928,    54,
-       0,     0,     0,     0,     0,   931,   932,     0,     0,     0,
-     937,     0,     0,     0,   204,     0,     0,   204,   204,     0,
-     151,     0,   942,     0,     0,    84,   122,   946,     0,     0,
-       0,   122,   122,   204,     0,     0,     0,   122,     0,     0,
-       0,   963,     0,     0,     0,     0,     0,   204,     0,     0,
-       0,   974,     0,     0,   204,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   241,     0,     0,     0,     0,
-       0,     0,     0,   330,     0,   246,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,  -279,    54,    25,    26,    27,     0,   996,
-       0,     0,     0,    30,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    54,     0,     0,  1011,     0,
-       0,     0,    54,     0,     0,     0,    33,     0,     0,   353,
-       0,     0,     0,    37,    38,     0,     0,  -279,     0,     0,
-       0,     0,   367,     0,     0,     0,     0,     0,     0,     0,
-       0,  1022,     0,  1023,  1024,  1025,     0,     0,  1028,   860,
-       0,    54,     0,   204,   399,     0,     0,  1021,     0,   567,
-       0,     0,     0,  1070,     0,     0,     0,   610,   413,     0,
-       0,     0,     0,     0,     0,   575,   418,     0,  1077,     0,
-       0,     0,     0,   204,  1078,     0,   426,     0,   204,     0,
-       0,     0,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,   452,
-       0,    25,    26,    27,   462,     0,     0,     0,     0,    30,
-    1095,     0,     0,     0,     0,     0,     0,   470,     0,     0,
-       0,     0,     0,   480,     0,   484,     0,     0,     0,     0,
-       0,     0,    33,     0,     0,   753,     0,   107,     0,    37,
-      38,   512,     0,     0,     0,     0,     0,     0,  1121,     0,
-       0,     0,     0,   860,     0,     0,  1129,     0,     0,     0,
-    1133,     0,     0,     0,   204,  1137,     0,     0,     0,  1142,
-    1143,  1144,     0,     0,     0,    43,     0,     0,   204,  1150,
-       0,     0,   572,   108,     0,     0,     0,     0,     0,  1163,
-       0,     0,     0,     0,     0,     0,     0,     0,   485,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1179,  1180,
-       0,   620,     0,     0,     0,   621,   622,     0,   623,     0,
-       0,     0,     0,     0,   633,   634,     0,   635,   636,     0,
-     637,     0,   638,  1209,     0,     0,  1211,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   651,
-       0,     0,     0,     0,     0,     0,   204,   653,     0,  1222,
-       0,     0,     0,     0,     0,     0,   204,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1229,     0,
-       0,   666,     0,     0,  1233,  1234,     0,     0,   204,     0,
-       0,     0,   671,  1242,   271,     0,   272,     0,     0,  1246,
-       0,     0,  1250,   122,  1251,     0,     0,  1253,     0,     0,
-       0,     0,     0,     0,     0,   707,     0,   273,   860,     0,
-       0,   710,  1262,   274,     0,     0,   452,   275,     0,     0,
-     276,   277,   278,   279,    40,    41,     0,   280,   281,  1271,
-       0,  1273,  1274,  1275,  1276,   282,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1284,   283,
-    1285,   361,   744,     0,   166,     0,     0,     0,   285,   363,
-     287,   288,   289,   290,     0,     0,     0,   760,     0,   204,
-       0,     0,  1204,  1305,     0,     0,     0,     0,     0,     0,
-       0,     0,  1310,  1311,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   204,     0,     0,     0,     0,
-       0,     0,     0,   786,     0,     0,     0,     0,     0,     0,
-       0,     0,   796,     0,   797,     0,     0,     0,     0,     0,
-     802,   204,     0,     0,     0,   122,     0,     0,     0,     0,
-    1342,  1343,     0,   821,     0,     0,  1347,  1348,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1358,     0,     0,
-       0,   204,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   204,     0,
-       0,     0,   862,     0,     0,     0,     0,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,  -279,  1386,    25,    26,    27,     0,
-       0,     0,     0,     0,    30,     0,     0,  1390,   897,     0,
-       0,  1393,  1394,  1395,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  1399,     0,     0,     0,    33,     0,     0,
-       0,     0,  1410,     0,    37,    38,     0,     0,  -279,     0,
-       0,     0,     0,     0,     0,  1418,     0,     0,     0,     0,
-       0,     0,   204,  1010,     0,     0,     8,     9,    10,    11,
-      12,     0,     0,   241,     0,     0,     0,     0,     0,     0,
-     567,     0,     0,   943,   944,     0,     0,     0,   108,   346,
-       0,     0,   271,    30,   272,   958,     0,     0,     0,     0,
-       0,     0,     0,     0,  1457,  1458,     0,     0,     0,     0,
-       0,     0,   975,     0,   976,   273,    33,  1463,   980,     0,
-     395,   274,     0,     0,  1463,   275,     0,   395,   276,   277,
-     278,   279,    40,    41,     0,   280,   281,     0,     0,     0,
-       0,     0,     0,   282,     0,     0,     0,     0,     0,  1491,
-       0,     0,     0,     0,   204,     0,     0,   283,     0,   361,
-       0,     0,     0,     0,     0,     0,   285,   888,   287,   288,
-     289,   290,     0,     0,     0,  1513,     0,     0,     0,     0,
-       0,     0,     0,  1016,     0,     0,     0,     0,     0,     0,
-    1017,     0,     0,     0,     0,     0,   395,     0,     0,  1526,
-       0,     0,     0,  1019,  1528,  1020,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1033,     0,     0,     0,     0,     0,  1037,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  1073,     0,
-       0,  1074,     0,     0,     0,     0,     0,     0,     0,     0,
-     395,     0,     0,   204,     0,     0,     0,     0,   395,   568,
-       0,   395,   571,  1082,   346,     0,     0,     0,     0,   598,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   616,     0,
-       0,   346,     0,     0,     0,     0,     0,     0,     0,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,     0,   395,    25,    26,
-      27,   395,     0,     0,     0,   310,    30,     0,     0,     0,
-       0,     0,     0,     0,   328,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   364,     0,  1141,    33,
-       0,   346,     0,     0,  1147,  1148,   199,   200,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   395,     1,     2,   198,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,  -279,
-     261,    25,    26,    27,    28,   395,     0,    29,   346,    30,
-    1206,     0,     0,   310,     0,     0,  1210,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   271,     0,
-     272,     0,    33,     0,    34,     0,    35,   466,     0,    37,
-      38,     0,     0,  -279,     0,     0,     0,   395,     0,  1226,
-     346,   273,     0,     0,  1228,     0,     0,   274,     0,     0,
-       0,   275,  1232,     0,   276,   277,   278,   279,    40,    41,
-       0,   280,   281,     0,     0,    43,     0,     0,   204,   282,
-       0,     0,     0,   108,     0,     0,     0,     0,     0,     0,
-       0,  1255,     0,   495,   395,   395,     0,     0,     0,     0,
-       0,     0,   285,   363,   287,   288,   289,   290,  1266,     0,
-     346,  1267,   346,  1268,     0,     0,     0,     0,     0,     0,
-     808,     0,     0,   598,     0,   598,   598,     0,     0,     0,
-    1278,  1279,   598,     0,  1161,     0,   328,     8,     9,    10,
-      11,    12,   840,   346,     0,   364,     0,     0,   346,     0,
-       0,  1292,     0,     0,     0,     0,     0,     0,   346,   346,
-       0,     0,     0,   271,    30,   272,     0,     0,     0,     0,
-       0,     0,     0,   346,     0,     0,     0,     0,   395,   883,
-    1313,     0,   395,   886,     0,     0,   273,    33,     0,     0,
-       0,     0,   274,     0,     0,   310,   275,     0,     0,   276,
-     277,   278,   279,    40,    41,     0,   280,   281,     0,   346,
-     395,     0,   395,     0,   282,     0,   395,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   283,   271,
-     361,   272,     0,     0,     0,     0,     0,   285,  1162,   287,
-     288,   289,   290,     0,     0,   709,     0,     0,   346,   598,
-       0,     0,   273,     0,     0,     0,     0,     0,   624,     0,
-     135,   136,   275,     0,     0,   276,   277,   278,   279,    40,
-      41,     0,   280,   281,     0,     0,  1380,     0,  1381,     0,
-     282,     0,   346,   741,     0,     0,   395,   395,     0,  1388,
-       0,  1389,     0,     0,   283,   754,   625,     0,   626,   362,
-       0,     0,   741,   285,   363,   287,   288,   289,   290,     0,
-       0,  1398,     0,     0,     0,   763,   764,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1416,   395,     0,
-       0,     0,     0,     0,     0,     0,  1419,   785,     0,  1232,
-     346,     0,   271,     0,   272,     0,     0,   794,     0,   598,
-       0,   598,     0,     0,     0,   754,     0,     0,     0,     0,
-     598,  1440,     0,     0,     0,   273,     0,     0,     0,     0,
-    1447,   274,     0,  1449,  1451,   275,     0,     0,   276,   277,
-     278,   279,    40,    41,     0,   280,   281,     0,     0,     0,
-       0,   808,     0,   282,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   861,   283,  1476,   361,
-    1232,     0,   362,   364,     0,     0,   285,   363,   287,   288,
-     289,   290,  1486,     0,     0,     0,   492,   496,   492,   499,
-       0,     0,     0,     0,   328,   346,   502,   503,     0,     0,
-       0,   492,   492,     0,     0,     0,   395,     0,     0,     0,
-       0,   395,     0,   492,   328,     0,     0,     0,     0,   395,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   598,   598,     0,     0,     0,     0,     0,     0,
-       0,     0,   492,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   346,     0,     0,     0,
-       0,     0,     0,   395,     0,     0,     0,     0,     0,     0,
-     808,     0,     0,     0,     0,     0,     0,     0,     0,   492,
-       0,     0,   395,  1136,     0,     0,     0,   754,  1139,   964,
-     346,     0,     0,     0,     0,   969,     0,     0,     0,     0,
-       0,   395,  1153,   979,   598,   598,  1158,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   346,   346,   346,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     328,     0,     0,   993,   994,   328,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,   328,    25,    26,    27,     0,     0,
-       0,     0,     0,    30,  1218,     0,     0,     0,     0,     0,
-     346,   808,   395,  1225,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   598,     0,    33,     0,     0,     0,
-       0,     0,     0,   199,   200,  1031,     0,     0,     0,   364,
-       0,     0,     0,     0,     0,     0,   808,     0,     0,     0,
-       0,     0,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,   346,
-     328,    25,    26,    27,  1139,   346,   346,   605,     0,    30,
-     434,   492,   492,   492,   492,   492,   492,   492,   492,   492,
-     492,   492,   492,   492,   492,   492,   492,   492,   492,     0,
-       0,     0,    33,     0,     0,     0,     0,     0,     0,    37,
-      38,     0,     0,     0,     0,     0,     0,     0,   310,     0,
-     492,   271,     0,   272,     0,     0,     0,     0,     0,     0,
-       0,  1116,  1117,     0,   346,     0,     0,     0,     0,   364,
-       0,     0,     0,     0,   273,   435,   969,     0,  1139,  1127,
-     274,   741,     0,   108,   275,     0,   346,   276,   277,   278,
-     279,    40,    41,     0,   280,   281,     0,     0,  1145,     0,
-       0,     0,   282,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  1164,   283,     0,   361,     0,
-       0,     0,     0,     0,   783,   285,   363,   287,   288,   289,
-     290,     0,     0,     0,     0,     0,   346,   346,   364,     0,
-    1183,     0,     0,     0,     0,     0,     0,     0,     0,   492,
-       0,     0,     0,     0,     0,  1205,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    1139,   492,     0,     0,  1214,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   492,   754,     1,     2,   198,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-       0,     0,    25,    26,    27,    28,     0,     0,    29,     0,
-      30,     0,     0,   969,     0,     0,     0,   492,     0,     0,
-       0,     0,   808,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    33,   861,    34,     0,    35,     0,     0,
-      37,    38,     0,     0,     0,     0,   346,     0,     0,   492,
-       0,     0,  1269,     0,  1270,     0,     0,     0,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,  -279,    43,    25,    26,    27,
-       0,     0,     0,     0,   108,    30,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   754,
-       0,     0,     0,     0,     0,     0,     0,     0,    33,     0,
-       0,     0,     0,    36,     0,   805,    38,    39,     0,  -279,
-       0,   395,     0,     0,    40,    41,     0,     0,     0,     0,
-       0,     0,     0,     0,   969,     0,     0,     0,     0,     0,
-     395,   395,     0,     0,     0,     0,     0,     0,     0,  1021,
-       0,   567,     0,     0,   492,     0,     0,     0,     0,   610,
-     395,     1,     2,   198,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,    25,    26,    27,
-      28,     0,     0,    29,   271,    30,  1040,  1041,     0,  1042,
-       0,     0,  1043,  1044,  1045,  1046,  1047,  1048,  1049,  1050,
-       0,  1051,     0,     0,  1052,    32,     0,   273,    33,     0,
-      34,     0,    35,   624,     0,    37,    38,   275,     0,     0,
-     276,   277,   278,   279,    40,    41,     0,   280,   281,     0,
-       0,     0,     0,     0,     0,   282,     0,     0,   492,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   492,   283,
-       0,  1053,     0,     0,   165,     0,     0,     0,   285,   286,
-     287,   288,   289,   290,     0,     0,     0,     0,     0,     0,
-    1426,     0,  -126,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   492,     0,     0,     0,
-       1,     2,   198,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,     0,     0,    25,    26,    27,    28,
-       0,     0,    29,   271,    30,   272,     0,     0,     0,  1478,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   271,     0,   272,     0,   273,    33,     0,    34,
-       0,    35,   274,     0,    37,    38,   275,     0,   492,   276,
-     277,   278,   279,    40,    41,   273,   280,   281,     0,     0,
-       0,   274,   310,     0,   282,   275,     0,     0,   276,   277,
-     278,   279,    40,    41,     0,   280,   281,     0,   283,     0,
-    1053,     0,     0,   282,     0,     0,     0,   285,   286,   287,
-     288,   289,   290,     0,     0,     0,     0,   283,   492,   361,
-       0,  -126,     0,     0,   752,     0,   285,   363,   287,   288,
-     289,   290,     0,   492,   492,     1,     2,   198,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,     0,
-       0,    25,    26,    27,    28,     0,     0,    29,   271,    30,
-     272,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,  -280,     0,
-       0,   273,    33,     0,    34,     0,    35,   274,    30,    37,
-      38,   275,     0,     0,   276,   277,   278,   279,    40,    41,
-       0,   280,   281,     0,     0,     0,     0,     0,     0,   282,
-       0,    33,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  -280,   283,     0,    43,     0,     0,     0,     0,
-       0,     0,   285,   286,   287,   288,   289,   290,     0,     0,
-       0,     0,     0,     2,   198,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,     0,     0,    25,    26,
-      27,     0,     0,     0,     0,   271,    30,   272,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,     0,   273,    33,
-       0,    34,     0,    35,   274,    30,    37,    38,   275,     0,
-       0,   276,   277,   278,   279,    40,    41,     0,   280,   281,
-       0,     0,     0,     0,     0,     0,   282,     0,    33,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     283,     0,   325,    -3,     0,     0,     0,   752,   492,   285,
-     326,   287,   288,   289,   290,     2,   198,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,     0,     0,
-      25,    26,    27,     0,     0,     0,     0,   271,    30,   272,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   492,   492,     0,     0,
-     273,    33,     0,    34,     0,    35,   274,     0,    37,    38,
-     275,     0,     0,   276,   277,   278,   279,    40,    41,     0,
-     280,   281,     0,     0,     0,     0,     0,     0,   282,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   283,     0,   906,    -3,     0,     0,     0,   752,
-       0,   285,   326,   287,   288,   289,   290,     2,   198,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-       0,     0,    25,    26,    27,     0,     0,     0,     0,   271,
-      30,   272,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   273,    33,     0,    34,     0,    35,   274,     0,
-      37,    38,   275,     0,     0,   276,   277,   278,   279,    40,
-      41,     0,   280,   281,     0,     0,     0,     0,     0,     0,
-     282,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   283,     0,   906,    -3,     0,     0,
-       0,   752,     0,   285,   574,   287,   288,   289,   290,     2,
-     198,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,     0,     0,    25,    26,    27,     0,     0,     0,
-       0,   271,    30,   272,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   273,    33,     0,    34,     0,    35,
-     274,     0,    37,    38,   275,     0,     0,   276,   277,   278,
-     279,    40,    41,     0,   280,   281,     0,     0,     0,     0,
-       0,     0,   282,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   283,     0,   325,    -3,
-       0,     0,     0,     0,     0,   285,   326,   287,   288,   289,
-     290,     2,   198,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,     0,     0,    25,    26,    27,     0,
-       0,     0,     0,   271,    30,   272,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   273,    33,     0,    34,
-       0,    35,   274,     0,    37,    38,   275,     0,     0,   276,
-     277,   278,   279,    40,    41,     0,   280,   281,     0,     0,
-       0,     0,     0,     0,   282,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   283,     0,
-     906,    -3,     0,     0,     0,     0,     0,   285,   326,   287,
-     288,   289,   290,     2,   198,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,     0,     0,    25,    26,
-      27,     0,     0,     0,     0,   271,    30,   272,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   273,    33,
-       0,    34,     0,    35,   274,     0,   199,   200,   275,     0,
-       0,   276,   277,   278,   279,    40,    41,     0,   280,   281,
-       0,     0,     0,     0,     0,     0,   282,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     283,     0,   991,     0,     0,     0,     0,     0,     0,   285,
-     992,   287,   288,   289,   290,     2,   198,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,     0,     0,
-      25,    26,    27,     0,     0,     0,     0,   271,    30,   272,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     273,    33,     0,    34,     0,    35,   274,     0,   199,   200,
-     275,     0,     0,   276,   277,   278,   279,    40,    41,     0,
-     280,   281,     0,     0,     0,     0,     0,     0,   282,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   283,     0,   361,     0,     0,     0,     0,     0,
-       0,   285,   363,   287,   288,   289,   290,  -497,     0,     0,
-       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,     0,     0,    25,    26,    27,    28,
-       0,     0,    29,     0,    30,    31,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    32,     0,     0,    33,     0,    34,
-       0,    35,    36,     0,    37,    38,    39,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    42,     0,
-      43,     0,     0,     0,     0,     0,     0,     0,    44,     1,
-       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,    25,    26,    27,    28,     0,
-       0,    29,     0,    30,    31,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    32,     0,     0,    33,     0,    34,     0,
-      35,    36,     0,    37,    38,    39,     0,     0,     0,     0,
-       0,     0,    40,    41,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    42,     0,    43,
-       0,     0,     0,  -501,     0,     0,     0,    44,     1,     2,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,     0,     0,    25,    26,    27,    28,     0,     0,
-      29,     0,    30,    31,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    32,     0,     0,    33,     0,    34,     0,    35,
-      36,     0,    37,    38,    39,     0,     0,     0,     0,     0,
-       0,    40,    41,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    42,     0,    43,     0,
-       0,     0,     0,     0,     0,     0,    44,   197,     2,   198,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,    25,    26,    27,     0,     0,     0,     0,
-       0,    30,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    33,     0,    34,     0,    35,    36,
-       0,   199,   200,    39,     0,     0,     0,     0,     0,     0,
-      40,    41,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    42,     0,   201,     0,     0,
-       0,     0,     0,     0,     0,   202,   197,     2,   198,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-       0,     0,    25,    26,    27,     0,     0,     0,     0,     0,
-      30,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    33,     0,    34,     0,    35,     0,     0,
-     199,   200,     2,   198,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,    25,    26,    27,
-       0,     0,     0,     0,     0,    30,   201,     0,     0,     0,
-       0,     0,     0,     0,   261,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    33,     0,
-      34,     0,    35,    36,     0,   199,   200,    39,     0,     0,
-       0,     0,     0,     0,    40,    41,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    42,
-       0,   201,     0,     0,     0,     0,     0,     0,     0,   202,
-       2,   198,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,    25,    26,    27,     0,     0,
-       0,     0,     0,    30,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    33,     0,    34,     0,
-      35,     0,     0,    37,    38,     2,   198,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,     0,     0,
-      25,    26,    27,     0,     0,     0,     0,     0,    30,   661,
-      -3,     0,     0,     0,     0,     0,     0,   610,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    33,     0,    34,     0,    35,     0,     0,    37,    38,
-       0,     0,     2,   198,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,    25,    26,    27,
-       0,     0,     0,  -384,   661,    30,     0,     0,     0,     0,
-       0,     0,   610,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    33,     0,
-      34,     0,    35,     0,     0,    37,    38,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  1355,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   661,     0,     0,     0,     0,     0,     0,     0,   610,
-       2,   198,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,    25,    26,    27,     0,     0,
-       0,     0,     0,    30,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,    25,    26,    27,    33,     0,    34,     0,
-      35,    30,     0,    37,    38,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    33,  1357,     0,     0,     0,   107,
-       0,    37,    38,     0,     0,     0,     0,     0,     0,   661,
-       0,     0,     0,     0,     0,     0,     0,   610,     2,   198,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,    25,    26,    27,     0,     0,     0,     0,
-       0,    30,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    33,     0,    34,     0,    35,     0,
-       0,   199,   200,     2,   198,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,     0,     0,    25,    26,
-      27,     0,     0,     0,     0,     0,    30,   260,     0,     0,
-       0,     0,     0,     0,     0,   605,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    33,
-       0,    34,     0,    35,     0,     0,    37,    38,     2,   198,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,    25,    26,    27,     0,     0,     0,     0,
-       0,    30,   573,     0,     0,     0,     0,     0,     0,     0,
-     610,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    33,     0,    34,     0,    35,     0,
-       0,    37,    38,     2,   198,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,     0,     0,    25,    26,
-      27,     0,     0,     0,     0,     0,    30,   661,     0,     0,
-       0,     0,     0,     0,     0,   610,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    33,
-       0,    34,     0,    35,     0,     0,   199,   200,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,    25,    26,    27,
-       0,     0,     0,     0,   271,    30,   272,     0,     0,     0,
-       0,     0,   201,     0,     0,     0,     0,     0,     0,     0,
-     261,     0,     0,     0,     0,     0,     0,   273,    33,     0,
-       0,     0,     0,   274,     0,    37,    38,   275,     0,     0,
-     276,   277,   278,   279,    40,    41,     0,   280,   281,     0,
-       0,     0,     0,     0,     0,   282,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   283,
-       0,   505,     0,     0,   165,     0,     0,     0,   285,   286,
-     287,   288,   289,   290,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,    25,    26,    27,     0,     0,     0,     0,
-     271,    30,   272,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   273,    33,     0,     0,     0,     0,   274,
-       0,    37,    38,   275,     0,     0,   276,   277,   278,   279,
-      40,    41,     0,   280,   281,     0,     0,     0,     0,     0,
-       0,   282,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   283,     0,   573,    -3,     0,
-       0,     0,     0,     0,   285,   574,   287,   288,   289,   290,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,     0,     0,    25,
-      26,    27,     0,     0,     0,     0,   271,    30,   272,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   273,
-      33,     0,     0,     0,     0,   624,     0,    37,    38,   275,
-       0,     0,   276,   277,   278,   279,    40,    41,     0,   280,
-     281,     0,     0,     0,     0,     0,     0,   282,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   283,   -35,   738,     0,     0,     0,     0,     0,     0,
-     285,   286,   287,   288,   289,   290,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,    25,    26,    27,     0,     0,
-       0,     0,   271,    30,   272,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   273,    33,     0,     0,     0,
-       0,   274,     0,    37,    38,   275,     0,     0,   276,   277,
-     278,   279,    40,    41,     0,   280,   281,     0,     0,     0,
-       0,     0,     0,   282,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   283,     0,   284,
-       0,     0,     0,     0,     0,     0,   285,   286,   287,   288,
-     289,   290,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,     0,
-       0,    25,    26,    27,     0,     0,     0,     0,   271,    30,
-     272,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   273,    33,     0,     0,     0,     0,   274,     0,    37,
-      38,   275,     0,     0,   276,   277,   278,   279,    40,    41,
-       0,   280,   281,     0,     0,     0,     0,     0,     0,   282,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   283,     0,   152,     0,     0,     0,     0,
-       0,     0,   285,   286,   287,   288,   289,   290,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,    25,    26,    27,
-       0,     0,     0,     0,   271,    30,   272,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   273,    33,     0,
-       0,     0,     0,   274,     0,    37,    38,   275,     0,     0,
-     276,   277,   278,   279,    40,    41,     0,   280,   281,     0,
-       0,     0,     0,     0,     0,   282,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   283,
-       0,   573,     0,     0,     0,     0,     0,     0,   285,   574,
-     287,   288,   289,   290,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,    25,    26,    27,     0,     0,     0,     0,
-     271,    30,   272,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   273,    33,     0,     0,     0,     0,   274,
-       0,    37,    38,   275,     0,     0,   276,   277,   278,   279,
-      40,    41,     0,   280,   281,     0,     0,     0,     0,     0,
-       0,   282,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   283,     0,   361,     0,     0,
-       0,     0,     0,     0,   285,   363,   287,   288,   289,   290,
-     455,     2,   198,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,     0,     0,    25,    26,    27,     0,
-       0,     0,     0,     0,    30,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,  -279,     0,    25,    26,    27,    33,     0,    34,
-       0,    35,    30,     0,    37,    38,     0,     0,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    33,     0,    25,    26,    27,
-      36,     0,   805,    38,    39,    30,  -279,     0,     0,     0,
-       0,    40,    41,    -3,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    33,     0,
-       0,     0,     0,    36,     0,    37,    38,    39,   567,     0,
-       0,     0,     0,     0,    40,    41,   108,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,     0,     0,    25,    26,    27,    42,
-       0,   152,     0,     0,    30,     0,     0,     0,     0,    44,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    33,     0,     0,
-       0,     0,    36,     0,    37,    38,    39,     0,     0,     0,
-       0,     0,     0,    40,    41,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,     0,     0,    25,    26,    27,     0,    42,     0,
-      43,     0,    30,     0,     0,     0,     0,     0,    44,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    33,     0,     0,     0,     0,
-      36,     0,   199,   200,    39,     0,     0,     0,     0,     0,
-       0,    40,    41,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-       0,     0,    25,    26,    27,     0,    42,     0,   260,     0,
-      30,     0,     0,     0,     0,     0,   202,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    33,     0,     0,     0,     0,    36,     0,
-     805,    38,    39,     0,     0,     0,     0,     0,     0,    40,
-      41,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,     0,     0,
-      25,    26,    27,     0,  1021,     0,   567,     0,    30,     0,
-       0,     0,     0,     0,   610,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    33,     0,     0,     0,     0,    36,     0,   805,    38,
-      39,     0,     0,     0,     0,     0,     0,    40,    41,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,     0,     0,    25,    26,
-      27,     0,     0,     0,   567,     0,    30,   434,     0,     0,
-       0,     0,   108,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    33,
-       0,     0,     0,     0,     0,     0,    37,    38,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,    25,    26,    27,
-       0,     0,     0,     0,     0,    30,   434,     0,     0,     0,
-       0,     0,   435,     0,     0,     0,   685,     0,     0,     0,
-     108,     0,     0,     0,     0,     0,     0,     0,    33,     0,
-       0,     0,     0,     0,     0,    37,    38,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,     0,     0,    25,    26,    27,     0,
-       0,     0,     0,     0,    30,   434,     0,     0,     0,     0,
-       0,   435,     0,     0,     0,   922,     0,     0,     0,   108,
-       0,     0,     0,     0,     0,     0,     0,    33,     0,     0,
-       0,     0,     0,     0,    37,    38,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,    25,    26,    27,     0,     0,
-       0,     0,     0,    30,     0,     0,     0,     0,     0,     0,
-     435,     0,     0,     0,  1221,     0,     0,     0,   108,     0,
-       0,     0,     0,     0,     0,     0,    33,     0,     0,     0,
-       0,     0,     0,    37,    38,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,     0,     0,    25,    26,    27,     0,     0,     0,
-       0,     0,    30,     0,     0,     0,     0,  1021,     0,   567,
-       0,     0,     0,     0,     0,     0,     0,   108,     0,     0,
-       0,     0,     0,     0,     0,    33,     0,     0,     0,     0,
-       0,     0,    37,    38,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,    25,    26,    27,     0,     0,     0,     0,
-       0,    30,     0,     0,     0,     0,  1021,     0,   567,     0,
-       0,     0,     0,     0,     0,     0,   610,     0,     0,     0,
-       0,     0,     0,     0,    33,     0,     0,     0,     0,     0,
-       0,    37,    38,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-       0,     0,    25,    26,    27,     0,     0,     0,     0,     0,
-      30,     0,     0,     0,     0,     0,     0,   247,     0,     0,
-       0,     0,     0,     0,     0,   108,     0,     0,     0,     0,
-       0,     0,     0,    33,     0,     0,     0,     0,     0,     0,
-      37,    38,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,     0,
-       0,    25,    26,    27,     0,     0,     0,     0,     0,    30,
-       0,     0,     0,     0,     0,     0,   152,     0,     0,     0,
-       0,     0,     0,     0,   108,     0,     0,     0,     0,     0,
-       0,     0,    33,     0,     0,     0,     0,     0,     0,   199,
-     200,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,     0,     0,
-      25,    26,    27,     0,     0,     0,     0,     0,    30,     0,
-       0,     0,     0,     0,     0,   260,     0,     0,     0,     0,
-       0,     0,     0,   261,     0,     0,     0,     0,     0,     0,
-       0,    33,     0,     0,     0,     0,     0,     0,    37,    38,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,     0,     0,    25,
-      26,    27,     0,     0,     0,     0,     0,    30,     0,     0,
-       0,     0,     0,     0,   247,     0,     0,     0,     0,     0,
-       0,     0,   610,     0,     0,     0,     0,     0,     0,     0,
-      33,     0,     0,     0,     0,     0,     0,    37,    38,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,     0,     0,    25,    26,
-      27,     0,     0,     0,     0,     0,    30,     0,     0,     0,
-       0,     0,     0,   567,     0,     0,     0,     0,     0,     0,
-       0,   610,     0,     0,     0,     0,     0,     0,     0,    33,
-       0,     0,     0,     0,     0,     0,    37,    38,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,     0,     0,    25,    26,    27,
-       0,     0,     0,     0,     0,    30,     0,     0,     0,     0,
-       0,     0,   435,     0,     0,     0,     0,     0,     0,     0,
-     108,     0,     0,     0,     0,     0,     0,     0,    33,     0,
-       0,     0,     0,     0,     0,   199,   200,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,     0,     0,    25,    26,    27,     0,
-       0,     0,     0,     0,    30,     0,     0,     0,     0,     0,
-       0,   260,     0,     0,     0,     0,     0,     0,     0,   605,
-       0,     0,     0,     0,     0,     0,     0,    33,     0,     0,
-       0,     0,     0,     0,    37,    38,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,    25,    26,    27,     0,     0,
-       0,     0,     0,    30,     0,     0,     0,     0,     0,     0,
-     573,     0,     0,     0,     0,     0,     0,     0,   610,     0,
-       0,     0,     0,     0,     0,     0,    33,     0,     0,     0,
-       0,     0,     0,    37,    38,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,     0,     0,    25,    26,    27,     0,     0,     0,
-       0,     0,    30,     0,     0,     0,     0,     0,     0,    43,
-       0,     0,     0,     0,     0,     0,     0,   108,     0,     0,
-       0,     0,     0,     0,     0,    33,     0,     0,     0,     0,
-       0,     0,    37,    38,     2,   198,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,     0,     0,    25,
-      26,    27,     0,     0,     0,     0,     0,    30,   567,     0,
-       0,     0,     0,     0,     0,     0,   108,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      33,     0,    34,     0,    35,     0,     0,    37,    38,     0,
-     271,     0,   272,  1041,     0,  1042,     0,     0,  1043,  1044,
-    1045,  1046,  1047,  1048,  1049,  1050,  1506,  1051,     0,     0,
-    1052,    32,     0,   273,     0,     0,     0,     0,     0,   624,
-       0,     0,  -397,   275,     0,     0,   276,   277,   278,   279,
-      40,    41,     0,   280,   281,     0,     0,     0,     0,     0,
-       0,   282,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   283,     0,   361,     0,     0,
-     165,     0,     0,     0,   285,   363,   287,   288,   289,   290,
-       0,   271,     0,   272,  1041,     0,  1042,     0,  -126,  1043,
-    1044,  1045,  1046,  1047,  1048,  1049,  1050,     0,  1051,     0,
-       0,  1052,    32,     0,   273,     0,     0,     0,     0,     0,
-     624,     0,     0,     0,   275,     0,     0,   276,   277,   278,
-     279,    40,    41,     0,   280,   281,     0,     0,     0,     0,
-       0,     0,   282,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   283,     0,   361,     0,
-       0,   165,     0,     0,     0,   285,   363,   287,   288,   289,
-     290,     0,     0,     0,     0,     0,     0,     0,     0,  -126,
-       2,   198,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,    25,    26,    27,     0,     0,
-       0,     0,     0,    30,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,    25,    26,    27,    33,     0,    34,     0,
-      35,    30,     0,    37,    38,     0,   271,     0,   272,  1041,
-       0,  1042,  1402,  1403,  1043,  1044,  1045,  1046,  1047,  1048,
-    1049,  1050,  1506,  1051,    33,  1314,  1052,    32,     0,   273,
-       0,    37,    38,     0,     0,   624,     0,     0,     0,   275,
-       0,     0,   276,   277,   278,   279,    40,    41,     0,   280,
-     281,     0,     0,     0,     0,     0,     0,   282,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   283,     0,   361,     0,     0,   165,     0,     0,     0,
-     285,   363,   287,   288,   289,   290,   271,     0,   272,  1041,
-       0,  1042,  1402,  1403,  1043,  1044,  1045,  1046,  1047,  1048,
-    1049,  1050,     0,  1051,     0,     0,  1052,    32,     0,   273,
-       0,     0,     0,     0,     0,   624,     0,     0,     0,   275,
-       0,     0,   276,   277,   278,   279,    40,    41,     0,   280,
-     281,     0,     0,     0,     0,     0,     0,   282,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   283,     0,   361,     0,     0,   165,     0,     0,     0,
-     285,   363,   287,   288,   289,   290,   271,     0,   272,  1041,
-       0,  1042,     0,     0,  1043,  1044,  1045,  1046,  1047,  1048,
-    1049,  1050,     0,  1051,     0,     0,  1052,    32,     0,   273,
-       0,     0,     0,     0,     0,   624,     0,     0,     0,   275,
-       0,     0,   276,   277,   278,   279,    40,    41,     0,   280,
-     281,     0,     0,     0,     0,     0,     0,   282,     0,     0,
-       0,     0,     0,   271,     0,   272,     0,     0,     0,     0,
-       0,   283,     0,   361,     0,     0,   165,     0,     0,     0,
-     285,   363,   287,   288,   289,   290,   273,     0,     0,     0,
-       0,     0,   274,     0,     0,     0,   275,     0,     0,   276,
-     277,   278,   279,    40,    41,     0,   280,   281,     0,     0,
-       0,     0,     0,     0,   282,     0,     0,     0,     0,     0,
-     271,     0,   272,     0,     0,     0,     0,     0,   283,     0,
-     361,     0,     0,   966,     0,     0,     0,   285,   363,   287,
-     288,   289,   290,   273,     0,     0,     0,     0,     0,   274,
-       0,     0,     0,   275,     0,     0,   276,   277,   278,   279,
-      40,    41,     0,   280,   281,     0,     0,     0,     0,     0,
-       0,   282,     0,     0,     0,     0,     0,   271,     0,   272,
-       0,     0,     0,     0,     0,   283,     0,   361,     0,     0,
-       0,     0,     0,     0,   285,   363,   287,   288,   289,   290,
-     273,     0,     0,     0,     0,     0,   274,     0,     0,     0,
-     275,     0,     0,   276,   277,   278,   279,    40,    41,     0,
-     280,   281,     0,     0,     0,     0,     0,     0,   282,     0,
-       0,     0,     0,     0,   271,     0,   272,     0,     0,     0,
-       0,     0,   283,     0,   361,     0,     0,     0,     0,     0,
-       0,   285,   708,   287,   288,   289,   290,   273,     0,     0,
-       0,     0,     0,   624,     0,     0,     0,   275,     0,     0,
-     276,   277,   278,   279,    40,    41,     0,   280,   281,     0,
-       0,     0,     0,     0,     0,   282,     0,     0,     0,     0,
-       0,   271,     0,   272,     0,     0,     0,     0,     0,   283,
-       0,   757,     0,     0,     0,     0,     0,     0,   285,   363,
-     287,   288,   289,   290,   273,     0,     0,     0,     0,     0,
-     274,     0,     0,     0,   275,     0,     0,   276,   277,   278,
-     279,    40,    41,     0,   280,   281,     0,     0,     0,     0,
-       0,     0,   282,     0,     0,     0,     0,     0,   271,     0,
-     272,     0,     0,     0,     0,     0,   283,     0,   361,     0,
-       0,     0,     0,     0,     0,   285,   888,   287,   288,   289,
-     290,   273,     0,     0,     0,     0,     0,   274,     0,     0,
-       0,   275,     0,     0,   276,   277,   278,   279,    40,    41,
-       0,   280,   281,     0,     0,     0,     0,     0,     0,   282,
-       0,     0,     0,     0,     0,   271,     0,   272,     0,     0,
-       0,     0,     0,   498,     0,     0,     0,     0,     0,     0,
-       0,     0,   285,   363,   287,   288,   289,   290,   273,     0,
-       0,     0,     0,     0,   274,     0,     0,     0,   275,     0,
-       0,   276,   277,   278,   279,    40,    41,     0,   280,   281,
-       0,     0,     0,     0,     0,     0,   282,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     501,     0,     0,     0,     0,     0,     0,     0,     0,   285,
-     363,   287,   288,   289,   290,     2,   198,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    30,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    33,     0,    34,     0,    35,    36,     0,   168,   169,
-      39,     0,     0,     0,     0,     0,     0,    40,    41,   197,
-       2,   198,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,    25,    26,    27,     0,     0,
-       0,     0,     0,    30,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    33,     0,    34,     0,
-      35,     0,     0,   199,   200,   455,     2,   198,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,     0,
-       0,    25,    26,    27,     0,     0,     0,     0,     0,    30,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    33,     0,    34,     0,    35,     0,     0,    37,
-      38,     2,   198,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,     0,     0,    25,    26,    27,     0,
-       0,     0,     0,     0,    30,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    33,     0,    34,
-       0,    35,     0,     0,   199,   200,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,     0,     0,    25,    26,    27,   473,   474,
-     475,     0,     0,    30,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,     0,     0,    25,    26,    27,    33,     0,     0,     0,
-       0,    30,     0,    37,    38,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    33,     0,     0,     0,     0,     0,
-       0,   199,   200
-};
-
-#define yypact_value_is_default(yystate) \
-  ((yystate) == (-1282))
-
-#define yytable_value_is_error(yytable_value) \
-  YYID (0)
-
-static const yytype_int16 yycheck[] =
-{
-       1,    42,     0,    42,     0,    42,   178,     1,   230,   180,
-     178,   178,   270,    32,   112,   179,   629,   178,   519,   178,
-     178,   163,   102,   178,   269,   211,   980,   326,   587,   179,
-     331,   672,   733,    31,   437,    31,   672,   672,   480,   605,
-     973,   585,   484,   873,    42,   587,    44,   585,    44,   621,
-     399,     0,   585,   346,  1020,  1324,    54,   350,   557,   436,
-      31,    37,    60,   635,    60,    63,   873,    63,    66,   418,
-      66,   443,    66,    65,   751,    42,    75,   426,    37,  1033,
-     251,   252,    31,   255,   697,     0,     1,   255,   255,     0,
-       1,   101,   256,    65,   255,   193,   255,   255,   478,   585,
-     255,  1019,  1020,   585,    37,   103,   256,   748,   106,     0,
-      42,   585,   748,   748,   112,   585,    31,   407,   408,   111,
-      31,    27,     0,    42,   101,  1406,   220,   103,   102,    44,
-      42,    43,   509,    88,   108,    37,    65,   178,   710,   178,
-      31,   178,   101,   237,   103,   143,   123,   143,    63,    65,
-    1419,    66,   124,    31,    52,    66,    57,   155,     0,   155,
-      37,    42,    43,   108,    42,    71,    44,   122,   101,  1402,
-     103,   470,  1040,    37,   103,   476,    75,   196,    44,   124,
-     178,   179,    60,   179,   121,    63,   123,   246,    66,    31,
-     412,   588,   482,   108,   106,   193,    94,   594,   113,   101,
-     101,   103,  1483,   102,   202,   391,   202,  1488,   124,   589,
-     500,   178,   210,   593,   255,   213,   255,   213,   255,   108,
-       0,    78,  1503,   387,   101,   106,   103,   142,  1461,  1510,
-       0,     1,   718,  1040,   614,   124,   718,   387,   618,   101,
-     155,   242,   108,   241,   718,   241,   178,    65,   105,   104,
-      54,    31,   108,   108,   620,   621,    65,   255,   256,   178,
-     256,    31,  1228,   822,   262,   143,   101,   811,   124,   635,
-     241,   269,   436,   811,   564,   574,   142,   155,   811,   377,
-     822,   282,   123,    63,    65,   103,   436,   202,   186,   692,
-      37,   790,   241,    63,   103,   106,    66,   102,   213,   103,
-     178,   179,   106,   108,   468,   982,   605,   405,  1241,   108,
-     208,   610,   410,  1279,     3,   230,   231,   666,   468,   317,
-     218,   317,   103,   616,   202,   811,   241,    42,    43,   811,
-     241,    89,   330,   331,     3,   213,   202,   811,   253,    89,
-     399,   811,   108,   108,   710,   102,   261,  1488,  1049,   347,
-     241,     0,   109,   351,   101,   246,   103,   115,   124,   418,
-    1278,  1279,    65,   241,   230,   115,    69,   426,   283,  1510,
-       0,   286,   671,    76,    77,   101,   935,   255,   123,   377,
-    1210,   108,    65,   104,    67,   283,    69,   108,   101,   387,
-     934,   387,   107,    76,    77,   261,   934,   124,   101,   241,
-     103,   934,    65,  1210,    67,    68,   210,   405,   111,   108,
-      65,   326,   410,   108,    69,   673,   813,   332,   101,   101,
-     286,    76,    77,   102,  1292,   124,   992,   470,   111,   124,
-     109,   108,  1398,   213,  1388,  1389,   108,   695,   436,   317,
-     103,   108,   101,   213,   123,   744,   101,   124,    65,  1021,
-      67,    68,   124,   331,   455,     1,   111,   124,   262,   104,
-     326,   241,   460,   108,   844,   269,   103,   108,   639,   106,
-     468,   241,   468,   102,   472,   104,   472,   978,   476,   108,
-    1398,     0,   104,   124,   101,  1292,   108,   732,   630,   106,
-     101,   102,   407,   408,   123,   124,   102,   412,    44,   500,
-     672,   943,   582,   109,   672,   672,  1119,   101,   399,   387,
-     674,   672,    31,   672,   672,   516,   101,   672,   519,   434,
-     521,   822,   437,   472,   674,   423,   330,   418,   443,    65,
-     902,    67,    68,   108,   108,   426,   913,  1096,   108,   637,
-     101,   407,   408,   347,   921,  1464,   412,   351,   101,   124,
-     124,  1470,   332,   102,   124,   470,   102,   472,   436,   457,
-     940,   472,   108,   113,   114,   101,  1485,   482,   569,    63,
-     106,  1490,  1440,   210,   102,  1147,  1148,   620,   621,  1447,
-     495,   472,   107,   498,   582,   500,   501,   585,   965,   587,
-    1488,  1292,   635,   102,   472,   102,   142,   495,   476,   108,
-     498,   102,   109,   501,   102,  1503,    44,   666,   606,  1006,
-    1007,    65,  1510,    67,   102,    69,   482,   102,  1486,   113,
-     108,   111,    76,    77,   622,   262,   116,   117,   671,   101,
-     472,   103,   269,  1440,   500,   636,   634,   638,   939,   637,
-    1447,    10,    11,    12,    13,    14,   104,   101,   707,   564,
-     108,   197,    83,    84,   102,  1021,   202,   111,   103,   574,
-     105,   155,   577,   103,   109,   105,  1367,   710,    37,   109,
-     108,    81,    82,   859,   672,   101,   674,   103,  1081,  1486,
-     495,   461,   101,   498,   230,   231,   501,   118,   119,   101,
-     605,    60,   472,   992,   880,   610,   283,   990,   564,   124,
-     102,   744,   472,   101,   705,   103,   108,   585,   574,   587,
-     347,   102,   101,   111,   351,   261,   101,   108,   264,   213,
-     718,   719,   241,   945,   866,    85,    86,   246,   808,    65,
-     572,    67,    68,    57,   732,   102,   653,   283,   101,   605,
-     286,   108,   101,  1444,   610,  1446,   102,   102,    65,   913,
-      67,    68,   108,   108,   652,   249,   671,   921,   101,   253,
-     103,   102,   124,   913,   202,   663,   106,   108,   111,   667,
-     106,   921,   106,   853,   270,   666,   124,   692,   582,   102,
-     326,  1147,  1148,    67,    65,   108,  1487,    71,   106,   106,
-      74,   124,    76,   231,   672,   101,   674,   712,    75,    83,
-     346,   101,   606,   103,   350,     4,     5,     6,     7,     8,
-       9,   111,    65,   811,    67,    68,   707,   112,   622,   102,
-     407,   408,   272,   261,   822,   108,   102,   607,   102,   744,
-     634,   102,   108,   102,   108,   285,   286,   108,   332,   108,
-     718,   719,  1141,   102,   102,   283,  1139,   297,   286,   108,
-     108,  1492,   102,  1146,  1112,   120,  1492,  1492,   108,   108,
-     109,   407,   408,    62,   121,    64,   412,    87,   101,   786,
-     103,    65,   873,    67,    68,    69,   326,   102,   103,   796,
-     399,   123,    76,    77,   101,   800,   103,   101,   434,   103,
-     103,   437,   972,  1035,   101,   812,   103,   443,   104,   418,
-     898,     4,     5,     6,     7,     8,     9,   426,   495,   455,
-     101,   498,   103,   363,   501,   913,   102,   411,   698,  1177,
-    1178,   205,   101,   921,   103,   124,   102,  1220,   732,  1228,
-      54,    55,   712,   811,   480,    65,   482,    67,   484,    69,
-     101,   939,   103,   677,   822,   679,    76,    77,   102,   495,
-     944,   470,   498,   472,   500,   501,   108,   109,   873,    62,
-     802,    64,   873,    78,    79,    80,   553,   461,   102,   606,
-     102,   101,   101,   103,   975,   102,  1019,   978,  1021,   980,
-     103,   111,   873,    42,    43,   622,   101,   902,   103,   108,
-     105,  1010,   990,   101,   102,   103,   434,   634,   123,   437,
-     538,   539,   900,  1083,   106,   443,  1104,   540,   541,     4,
-       5,     6,     7,     8,     9,   101,   102,   103,   564,  1312,
-     800,    10,    11,    12,    13,    14,   546,   547,   574,   944,
-     945,   873,  1033,   944,   101,   913,   582,    32,  1118,   101,
-     102,   103,  1043,   921,   102,  1046,  1047,  1048,    37,   102,
-     334,   108,   336,   104,    65,   897,    67,   495,    69,   605,
-     498,   939,   104,   501,   610,    76,    77,    62,   104,    64,
-     616,    60,    65,    28,    67,    68,    69,   992,   109,   945,
-     101,   102,   103,   577,   109,   535,   536,   537,    75,   102,
-     102,   873,   109,   873,   898,   732,  1473,   104,  1141,  1016,
-    1017,   452,   107,   873,  1147,  1148,  1104,   542,   543,   544,
-     545,   102,   101,   607,   103,  1247,  1248,  1249,   612,    65,
-     108,   107,   111,    69,   574,  1040,   992,   107,   101,  1040,
-      76,    77,   102,    75,   124,  1512,   102,   102,   422,     0,
-       1,   109,   102,   102,  1402,   102,   692,   666,   104,  1040,
-     108,   102,   671,  1051,   102,   101,  1073,  1074,    10,    11,
-      12,    13,    14,   102,   104,   111,  1081,   101,   101,   104,
-      31,    32,   102,   102,   944,   102,   722,   673,   102,   102,
-     102,   102,     3,    44,   102,    37,   990,   102,   707,    10,
-      11,    12,    13,    14,   107,  1189,    28,   123,  1040,   695,
-     104,   104,  1460,  1461,   698,    66,   102,   102,    60,  1210,
-     102,   102,   101,   107,   104,   995,    37,    65,   712,    67,
-     108,    69,  1220,     3,   104,   744,  1141,   102,    76,    77,
-      10,    11,    12,    13,    14,  1278,   102,   108,  1232,    60,
-    1082,   102,   102,   108,   106,   104,  1247,  1248,  1249,   101,
-     108,   103,   102,   101,   692,   103,   102,    37,   708,   111,
-    1040,  1043,   808,   111,    65,   104,    67,    68,    69,   104,
-    1040,   104,   108,  1188,  1189,    76,    77,  1499,  1189,   108,
-      60,   104,   143,  1381,   102,   101,   101,   783,   101,   101,
-     151,   101,   109,   124,  1374,  1210,   107,   102,   102,  1210,
-     101,   751,   653,   102,   104,  1306,   800,   853,   102,   107,
-     106,   108,   121,  1228,   104,   108,   124,  1232,   179,  1210,
-    1492,  1232,   104,   102,  1492,  1492,   104,   104,   104,  1493,
-    1324,  1492,   193,  1492,  1492,   196,   197,  1492,  1255,    29,
-     102,   202,    45,  1493,   104,   102,   104,   102,  1512,  1266,
-    1267,  1268,   104,   124,   873,   124,   902,   124,   124,   124,
-    1361,   222,  1512,  1364,   107,   226,   862,   228,  1210,   104,
-     107,   102,  1287,   107,   235,  1473,  1374,  1292,   104,   104,
-     241,  1292,  1380,  1381,   104,   246,   104,  1388,  1389,   104,
-      80,    81,   104,   104,   104,   256,  1313,   943,   944,   945,
-     102,  1292,  1300,   264,   102,  1406,   101,   104,  1188,  1324,
-    1411,   104,   101,  1324,    55,    54,  1220,   104,  1188,  1189,
-     102,   102,   106,   124,    75,  1419,   972,   102,  1210,   109,
-    1210,    63,   102,  1434,   101,   786,   104,     0,   888,   104,
-    1210,    73,   102,   104,   990,   796,   992,   102,   107,    89,
-    1292,  1492,   104,  1492,   102,  1492,   102,   102,   102,   108,
-      40,   812,  1232,    89,   902,   326,   109,   124,    31,   102,
-     124,   102,   333,  1474,   124,  1473,    75,   124,   102,   109,
-     107,   113,  1483,   104,   104,   346,   982,  1488,   124,   350,
-     101,   107,   353,   107,  1492,  1493,   102,  1493,   102,   124,
-    1501,   995,  1503,    66,  1419,   649,  1507,  1287,  1419,  1510,
-     548,   550,  1292,  1120,  1512,  1516,  1512,  1287,   551,  1520,
-     549,  1040,  1292,   155,  1306,  1440,   552,  1461,  1301,  1440,
-    1210,  1369,  1447,  1520,  1449,  1081,  1447,  1083,   399,  1115,
-    1476,  1037,   992,   233,  1447,  1114,  1069,   434,   434,  1440,
-    1448,    65,   413,    67,  1324,    69,  1447,   418,   679,   923,
-     921,  1476,    76,    77,   446,   426,   569,   966,   866,   722,
-    1374,  1486,  1118,   941,  1232,  1486,  1380,  1475,   556,  1361,
-     556,   213,  1364,   631,  1499,   732,    -1,   101,   151,   103,
-    1040,   452,   556,  1139,   455,  1486,   472,   111,  1440,    -1,
-    1146,    -1,    -1,  1190,  1191,  1447,  1193,    -1,    -1,   470,
-      -1,   472,  1199,  1511,  1492,  1202,  1112,   249,    -1,   480,
-      -1,   253,  1141,   484,  1406,  1523,    -1,    -1,    65,  1411,
-      67,    68,    69,  1499,    -1,    -1,    -1,   269,    -1,    76,
-      77,    -1,    -1,  1081,  1486,    -1,     3,    -1,    -1,  1419,
-      -1,   512,  1434,    10,    11,    12,    13,    14,    -1,   222,
-    1440,    -1,    -1,    -1,   101,  1016,  1017,  1447,    -1,    -1,
-    1440,    -1,   362,    44,  1220,    -1,    -1,  1447,   241,    -1,
-      37,  1177,  1178,   246,    -1,    -1,  1232,    -1,    -1,    60,
-      -1,  1210,    63,    -1,  1188,    66,   557,    -1,    -1,    -1,
-     332,    -1,     0,    60,    -1,    -1,  1486,    -1,    -1,  1228,
-      -1,   572,  1162,   574,    -1,    -1,  1486,    -1,    -1,  1501,
-      -1,   582,  1073,  1074,    -1,  1507,   587,    -1,    -1,    -1,
-      -1,   452,    -1,    31,  1516,    -1,    -1,    -1,  1520,    -1,
-      -1,    -1,    -1,  1380,   605,    -1,    -1,    -1,    -1,   610,
-      -1,   441,    -1,    -1,    -1,   616,   446,    -1,    -1,   620,
-     621,    10,    11,    12,    13,    14,  1312,    -1,    66,    -1,
-     333,    -1,   143,  1292,   635,    -1,  1363,    -1,  1324,   411,
-      -1,    -1,    -1,    -1,   155,    -1,    -1,    -1,    37,   479,
-     353,   481,   653,  1287,    -1,    -1,   428,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   666,    -1,    -1,   179,    -1,
-     671,    60,    -1,   674,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    65,    -1,    67,    -1,    69,    -1,    -1,  1374,   461,
-      -1,   202,    76,    77,    -1,    -1,   399,    -1,    -1,    -1,
-      -1,    -1,   213,    -1,    -1,    -1,   707,    -1,    -1,   710,
-     413,    -1,   101,   151,   103,   418,    -1,   101,   719,   103,
-      -1,   722,   111,   426,    -1,   109,    -1,   111,    -1,    -1,
-      -1,    -1,    -1,  1419,    -1,  1226,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   744,    -1,    -1,    -1,    -1,   749,   452,
-      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-      -1,    -1,    -1,  1449,  1255,    -1,  1402,   470,    -1,   472,
-      -1,    -1,    -1,    -1,    -1,  1266,  1267,  1268,    -1,    -1,
-      -1,  1440,    -1,   123,    -1,   786,    -1,    -1,  1447,    -1,
-    1476,    -1,   653,    -1,    -1,   796,   626,    -1,    -1,    -1,
-     801,   802,    -1,   241,    -1,   577,   317,   808,   246,   512,
-      -1,   812,    -1,  1499,    -1,    -1,    -1,    -1,    -1,    -1,
-     821,    -1,  1313,    -1,  1460,  1461,    -1,  1486,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   607,    -1,    -1,   668,    -1,
-     612,    -1,    -1,    -1,    -1,    -1,   182,    10,    11,    12,
-      13,    14,   853,   189,    -1,    -1,    -1,   687,    -1,    -1,
-      -1,    -1,    -1,   693,    -1,    -1,    -1,    -1,    -1,   572,
-      -1,  1449,   873,    -1,    37,    -1,   387,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     0,
-      -1,    -1,    -1,    -1,    -1,   333,   897,    60,  1476,    -1,
-      -1,    -1,    65,    -1,    67,    -1,    69,    -1,    -1,    -1,
-      -1,    -1,    -1,    76,    77,   353,    -1,   620,   621,    -1,
-      31,    -1,   258,    -1,    -1,   786,   698,    -1,    25,    26,
-      27,    -1,   635,    -1,   935,   796,    -1,    -1,   101,    -1,
-     712,    -1,   943,   944,    -1,    -1,    -1,    -1,   111,    -1,
-     653,   812,    -1,    -1,    -1,    66,    -1,   958,    -1,    -1,
-     732,   399,    -1,   666,    -1,    -1,    -1,    -1,   671,    -1,
-      -1,   972,    -1,    -1,    -1,   413,   312,    -1,    -1,    -1,
-     418,    -1,    -1,    -1,   320,    -1,    -1,   323,   426,   990,
-      -1,   992,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,
-      97,    -1,    -1,    -1,   707,    -1,    -1,   710,    -1,  1010,
-      -1,    -1,    -1,    -1,   452,  1016,  1017,    -1,  1019,  1020,
-    1021,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   800,    -1,
-      -1,    -1,   470,    -1,   472,    -1,   866,    -1,    -1,  1040,
-     151,   744,   872,   379,    -1,    -1,    -1,   383,    -1,     0,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    27,    -1,    29,
-      30,    31,  1073,  1074,   512,    -1,    -1,    37,   175,    -1,
-      31,  1082,  1083,   786,    -1,    -1,    -1,   184,   185,    -1,
-      -1,    -1,   189,   796,   191,   192,    -1,    -1,   801,   802,
-      60,    -1,    10,    11,    12,    13,    14,    67,    68,   812,
-      -1,    71,    -1,    -1,    -1,    66,    -1,  1118,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,
-     241,   467,    -1,    -1,   572,   246,   966,    -1,  1139,    -1,
-    1141,   101,    -1,   103,    -1,  1146,  1147,  1148,    -1,    -1,
-      -1,   111,    60,    -1,    -1,  1016,  1017,    65,    -1,    67,
-      -1,    69,    -1,    -1,    -1,    -1,    -1,    -1,    76,    77,
-     873,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   620,   621,    -1,     0,     1,    -1,  1189,    -1,
-      -1,    -1,    -1,   101,   897,   103,    -1,   635,    -1,    -1,
-     151,    -1,    -1,   111,    -1,  1206,    -1,    -1,    -1,  1210,
-      -1,    -1,  1073,  1074,    -1,   653,    31,    -1,    -1,  1220,
-     556,   557,   333,   995,    -1,  1226,    -1,  1228,   666,    -1,
-      -1,  1232,    -1,   671,    10,    11,    12,    13,    14,  1069,
-      -1,    -1,   353,    -1,    -1,    -1,    -1,    -1,    63,    -1,
-      -1,    66,    -1,    -1,  1255,   958,    -1,    -1,    -1,    -1,
-      -1,    37,    -1,    -1,    -1,  1266,  1267,  1268,    -1,   707,
-      -1,    -1,   710,    -1,    -1,    -1,    -1,  1278,  1279,    -1,
-      -1,    -1,    -1,    -1,    60,    -1,    -1,    -1,   399,    65,
-     241,  1292,    -1,    69,    -1,   246,    -1,    -1,    -1,    -1,
-      76,    77,   413,    -1,   640,    -1,   744,   418,   644,    -1,
-      -1,  1312,  1313,  1016,  1017,   426,  1019,  1020,  1021,    -1,
-      -1,    -1,    -1,  1324,    -1,   101,    10,    11,    12,    13,
-      14,    -1,    -1,    -1,    -1,   111,   151,  1040,    -1,    -1,
-      -1,   452,   678,    -1,    -1,    -1,    -1,    -1,   786,    -1,
-      -1,    -1,    -1,    37,  1184,    -1,    -1,    -1,   796,   470,
-      -1,   472,    -1,   801,   802,  1226,    -1,    -1,    -1,    -1,
-    1073,  1074,    -1,  1374,   812,    -1,    60,    -1,    -1,  1082,
-      -1,    65,   333,    67,    -1,    69,    -1,    -1,    -1,    -1,
-      -1,    -1,    76,    77,  1255,    -1,    -1,  1398,   213,    -1,
-      -1,   512,   353,    -1,    -1,  1266,  1267,  1268,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1188,   101,  1419,   103,
-      -1,    -1,    -1,    -1,    -1,    -1,   241,   111,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   873,    -1,    -1,  1141,  1440,
-      -1,    -1,    -1,    -1,  1147,  1148,  1447,    -1,   399,    -1,
-      -1,    -1,  1313,    -1,   790,    -1,    -1,    -1,    -1,   897,
-      -1,   572,   413,   560,   561,    -1,    -1,   418,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   426,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  1486,  1189,    -1,    -1,    -1,
-      -1,   588,  1493,    -1,   591,   592,    -1,   594,    -1,   596,
-     597,   452,    -1,  1206,   601,   602,    -1,  1210,    -1,   620,
-     621,    -1,    -1,    -1,    -1,  1287,    -1,    -1,    -1,   470,
-     958,   472,    -1,  1226,   635,  1228,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   353,    -1,
-      -1,    -1,   653,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1255,    -1,    -1,   666,    -1,    -1,    -1,    -1,
-     671,   512,    -1,  1266,  1267,  1268,    -1,    -1,    -1,    -1,
-      -1,    -1,   908,    -1,    -1,  1278,  1279,    -1,  1016,  1017,
-      -1,  1019,  1020,  1021,    -1,    -1,   683,   684,    -1,  1292,
-      -1,    -1,   689,    -1,    -1,    -1,   707,    -1,   413,   710,
-      -1,    -1,  1040,    -1,    -1,    10,    11,    12,    13,    14,
-    1313,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   572,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    37,   744,    -1,  1073,  1074,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  1082,    -1,    -1,    -1,   984,    -1,
-      -1,    -1,    -1,    -1,    -1,    60,    -1,   472,    -1,    -1,
-      65,    -1,    67,    -1,    69,    -1,    -1,  1003,    -1,   620,
-     621,    76,    77,    -1,    -1,   786,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   635,   796,    -1,    -1,    -1,    -1,
-     801,   802,    -1,    -1,    -1,  1398,   101,   512,   103,    -1,
-      -1,   812,   653,  1141,    -1,    -1,   111,    -1,    -1,  1147,
-    1148,    -1,    -1,    -1,    -1,   666,    -1,    -1,    -1,    -1,
-     671,    -1,    -1,    -1,    -1,    10,    11,    12,    13,    14,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1440,    -1,    -1,
-      -1,    -1,    -1,    -1,  1447,    -1,    -1,    -1,  1084,    -1,
-      -1,  1189,    37,    -1,    -1,    -1,   707,   572,    -1,   710,
-      -1,    -1,   873,    -1,    -1,    -1,    -1,    -1,  1206,    -1,
-      -1,    -1,  1210,    -1,    -1,    60,    -1,    -1,    -1,    -1,
-      65,    -1,    67,  1486,    69,    -1,   897,    -1,  1226,    -1,
-    1228,    76,    77,   744,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   620,   621,    -1,    -1,    -1,
-      10,    11,    12,    13,    14,    -1,   101,  1255,    -1,    -1,
-     635,    -1,    -1,    -1,    -1,    -1,   111,    -1,  1266,  1267,
-    1268,    -1,    -1,    -1,    -1,   786,    -1,    37,    -1,    -1,
-    1278,  1279,    -1,    -1,    -1,   796,    -1,   958,    -1,    -1,
-     801,   802,    -1,    -1,  1292,    -1,    -1,    50,    -1,    52,
-      60,   812,    55,    56,    57,    65,    59,    -1,    -1,    69,
-      -1,    -1,    -1,    -1,    -1,  1313,    76,    77,    -1,    -1,
-      -1,    74,    -1,    25,    26,    27,    -1,    -1,    -1,    -1,
-      -1,    -1,    85,    86,    -1,   710,    -1,    -1,    -1,    -1,
-      -1,   101,    -1,    -1,    -1,  1016,  1017,    -1,  1019,  1020,
-    1021,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   873,    -1,    -1,    -1,    -1,    -1,    -1,  1040,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   897,    -1,    -1,    -1,
-      -1,    -1,    -1,    95,    -1,    97,    -1,    -1,   151,    -1,
-    1398,    -1,  1073,  1074,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  1082,    -1,    -1,    -1,    -1,    -1,    -1,  1075,   121,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   802,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1440,    -1,    -1,    -1,    -1,   958,    -1,  1447,
-      -1,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-    1141,    -1,    -1,   175,    -1,    -1,  1147,  1148,    37,    -1,
-     182,    -1,   184,   185,    -1,    -1,    -1,   189,  1486,   191,
-     192,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   873,    -1,
-      -1,    60,    -1,    -1,    -1,  1016,  1017,    -1,  1019,  1020,
-    1021,    -1,    71,    -1,    -1,    -1,    -1,    -1,  1189,    -1,
-      -1,    -1,   897,    -1,    -1,    -1,    -1,    -1,    -1,  1040,
-      -1,    -1,    -1,    -1,    -1,  1206,    -1,    -1,    -1,  1210,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    1207,    -1,    -1,    -1,    -1,  1226,   258,  1228,    -1,    -1,
-      -1,    -1,  1073,  1074,    -1,    -1,    -1,    -1,    -1,   944,
-      -1,  1082,    -1,   326,    -1,   328,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   958,  1255,    -1,   339,   340,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  1266,  1267,  1268,    -1,    63,
-     353,    -1,    -1,    -1,    -1,    -1,    -1,  1278,  1279,    73,
-      -1,    75,    -1,    77,    -1,    -1,    -1,    -1,    -1,    -1,
-      84,  1292,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    1141,    -1,    -1,    -1,    -1,    -1,  1147,  1148,    -1,    -1,
-      -1,    -1,  1313,    -1,  1019,  1020,  1021,    -1,    -1,   113,
-      -1,   115,   116,   117,    -1,    -1,    -1,    -1,    -1,    -1,
-     413,    -1,    -1,    -1,    -1,  1040,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,  1189,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   155,    -1,    -1,    -1,  1206,    -1,    -1,    -1,  1210,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1082,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  1226,    -1,  1228,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1398,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  1255,    -1,    -1,    -1,    -1,   213,
-      -1,   215,   216,   217,    -1,  1266,  1267,  1268,    -1,   512,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1278,  1279,  1440,
-      -1,    -1,  1147,  1148,    -1,    -1,  1447,    -1,    -1,    -1,
-      -1,  1292,    -1,    -1,    -1,   249,    -1,    -1,    -1,   253,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    36,  1313,    38,    -1,   269,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1188,  1189,  1486,    -1,    -1,    -1,   572,
-      -1,    -1,    -1,    -1,    59,    -1,    -1,    -1,    -1,    -1,
-      65,  1206,    -1,    -1,    69,  1210,    -1,    72,    73,    74,
-      75,    76,    77,    -1,    79,    80,    -1,    -1,    -1,    -1,
-      -1,    -1,    87,   317,    -1,    -1,    -1,  1232,   560,   561,
-      -1,    -1,    -1,    -1,    -1,    -1,   101,    -1,   332,    -1,
-     623,    -1,    -1,   337,   338,   110,   111,   112,   113,   114,
-     115,   345,    -1,    -1,    -1,    -1,   588,  1398,    -1,   591,
-     592,    -1,   594,    -1,   596,   597,    -1,    -1,   651,   601,
-     602,    -1,    -1,  1278,  1279,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1287,    -1,    -1,    -1,    -1,  1292,   671,    -1,
-      -1,    -1,    -1,   387,    -1,    -1,    -1,    -1,    -1,  1440,
-      -1,    -1,    -1,    -1,    -1,    -1,  1447,    -1,    -1,    -1,
-      -1,   405,    -1,    -1,    -1,    -1,   699,   411,   701,  1324,
-      -1,    -1,    -1,    -1,    -1,   708,   709,    -1,    -1,    -1,
-     713,    -1,    -1,    -1,   428,    -1,    -1,   431,   432,    -1,
-      43,    -1,   725,    -1,    -1,  1486,   678,   730,    -1,    -1,
-      -1,   683,   684,   447,    -1,    -1,    -1,   689,    -1,    -1,
-      -1,   744,    -1,    -1,    -1,    -1,    -1,   461,    -1,    -1,
-      -1,   754,    -1,    -1,   468,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    88,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1398,    -1,    98,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    27,  1419,    29,    30,    31,    -1,   802,
-      -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  1440,    -1,    -1,   821,    -1,
-      -1,    -1,  1447,    -1,    -1,    -1,    60,    -1,    -1,   152,
-      -1,    -1,    -1,    67,    68,    -1,    -1,    71,    -1,    -1,
-      -1,    -1,   165,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   854,    -1,   856,   857,   858,    -1,    -1,   861,   862,
-      -1,  1486,    -1,   577,   187,    -1,    -1,   101,    -1,   103,
-      -1,    -1,    -1,   876,    -1,    -1,    -1,   111,   201,    -1,
-      -1,    -1,    -1,    -1,    -1,   888,   209,    -1,   891,    -1,
-      -1,    -1,    -1,   607,   897,    -1,   219,    -1,   612,    -1,
-      -1,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,   242,
-      -1,    29,    30,    31,   247,    -1,    -1,    -1,    -1,    37,
-     933,    -1,    -1,    -1,    -1,    -1,    -1,   260,    -1,    -1,
-      -1,    -1,    -1,   266,    -1,   268,    -1,    -1,    -1,    -1,
-      -1,    -1,    60,    -1,    -1,   958,    -1,    65,    -1,    67,
-      68,   284,    -1,    -1,    -1,    -1,    -1,    -1,   971,    -1,
-      -1,    -1,    -1,   976,    -1,    -1,   979,    -1,    -1,    -1,
-     983,    -1,    -1,    -1,   698,   988,    -1,    -1,    -1,   992,
-     993,   994,    -1,    -1,    -1,   103,    -1,    -1,   712,  1002,
-      -1,    -1,   325,   111,    -1,    -1,    -1,    -1,    -1,  1012,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   732,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1031,  1032,
-      -1,   354,    -1,    -1,    -1,   358,   359,    -1,   361,    -1,
-      -1,    -1,    -1,    -1,   367,   368,    -1,   370,   371,    -1,
-     373,    -1,   375,  1056,    -1,    -1,  1059,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   392,
-      -1,    -1,    -1,    -1,    -1,    -1,   790,   400,    -1,  1082,
-      -1,    -1,    -1,    -1,    -1,    -1,   800,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1101,    -1,
-      -1,   424,    -1,    -1,  1107,  1108,    -1,    -1,   822,    -1,
-      -1,    -1,   435,  1116,    36,    -1,    38,    -1,    -1,  1122,
-      -1,    -1,  1125,  1075,  1127,    -1,    -1,  1130,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   458,    -1,    59,  1141,    -1,
-      -1,   464,  1145,    65,    -1,    -1,   469,    69,    -1,    -1,
-      72,    73,    74,    75,    76,    77,    -1,    79,    80,  1162,
-      -1,  1164,  1165,  1166,  1167,    87,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1181,   101,
-    1183,   103,   505,    -1,  1187,    -1,    -1,    -1,   110,   111,
-     112,   113,   114,   115,    -1,    -1,    -1,   520,    -1,   913,
-      -1,    -1,   124,  1206,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,  1215,  1216,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   939,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   556,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   565,    -1,   567,    -1,    -1,    -1,    -1,    -1,
-     573,   965,    -1,    -1,    -1,  1207,    -1,    -1,    -1,    -1,
-    1263,  1264,    -1,   586,    -1,    -1,  1269,  1270,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1280,    -1,    -1,
-      -1,   995,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1012,    -1,
-      -1,    -1,   625,    -1,    -1,    -1,    -1,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    27,  1328,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    37,    -1,    -1,  1340,   661,    -1,
-      -1,  1344,  1345,  1346,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,  1356,    -1,    -1,    -1,    60,    -1,    -1,
-      -1,    -1,  1365,    -1,    67,    68,    -1,    -1,    71,    -1,
-      -1,    -1,    -1,    -1,    -1,  1378,    -1,    -1,    -1,    -1,
-      -1,    -1,  1096,     7,    -1,    -1,    10,    11,    12,    13,
-      14,    -1,    -1,   716,    -1,    -1,    -1,    -1,    -1,    -1,
-     103,    -1,    -1,   726,   727,    -1,    -1,    -1,   111,   151,
-      -1,    -1,    36,    37,    38,   738,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  1427,  1428,    -1,    -1,    -1,    -1,
-      -1,    -1,   755,    -1,   757,    59,    60,  1440,   761,    -1,
-     182,    65,    -1,    -1,  1447,    69,    -1,   189,    72,    73,
-      74,    75,    76,    77,    -1,    79,    80,    -1,    -1,    -1,
-      -1,    -1,    -1,    87,    -1,    -1,    -1,    -1,    -1,  1472,
-      -1,    -1,    -1,    -1,  1188,    -1,    -1,   101,    -1,   103,
-      -1,    -1,    -1,    -1,    -1,    -1,   110,   111,   112,   113,
-     114,   115,    -1,    -1,    -1,  1498,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   826,    -1,    -1,    -1,    -1,    -1,    -1,
-     833,    -1,    -1,    -1,    -1,    -1,   258,    -1,    -1,  1522,
-      -1,    -1,    -1,   846,  1527,   848,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     863,    -1,    -1,    -1,    -1,    -1,   869,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   881,    -1,
-      -1,   884,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     312,    -1,    -1,  1287,    -1,    -1,    -1,    -1,   320,   321,
-      -1,   323,   324,   906,   326,    -1,    -1,    -1,    -1,   331,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   350,    -1,
-      -1,   353,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,   379,    29,    30,
-      31,   383,    -1,    -1,    -1,   142,    37,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   151,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   163,    -1,   991,    60,
-      -1,   413,    -1,    -1,   997,   998,    67,    68,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   436,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-     111,    29,    30,    31,    32,   467,    -1,    35,   470,    37,
-    1053,    -1,    -1,   230,    -1,    -1,  1059,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    36,    -1,
-      38,    -1,    60,    -1,    62,    -1,    64,   254,    -1,    67,
-      68,    -1,    -1,    71,    -1,    -1,    -1,   509,    -1,  1092,
-     512,    59,    -1,    -1,  1097,    -1,    -1,    65,    -1,    -1,
-      -1,    69,  1105,    -1,    72,    73,    74,    75,    76,    77,
-      -1,    79,    80,    -1,    -1,   103,    -1,    -1,  1512,    87,
-      -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,  1134,    -1,   101,   556,   557,    -1,    -1,    -1,    -1,
-      -1,    -1,   110,   111,   112,   113,   114,   115,  1151,    -1,
-     572,  1154,   574,  1156,    -1,    -1,    -1,    -1,    -1,    -1,
-     582,    -1,    -1,   585,    -1,   587,   588,    -1,    -1,    -1,
-    1173,  1174,   594,    -1,     7,    -1,   353,    10,    11,    12,
-      13,    14,   604,   605,    -1,   362,    -1,    -1,   610,    -1,
-      -1,  1194,    -1,    -1,    -1,    -1,    -1,    -1,   620,   621,
-      -1,    -1,    -1,    36,    37,    38,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   635,    -1,    -1,    -1,    -1,   640,   641,
-    1223,    -1,   644,   645,    -1,    -1,    59,    60,    -1,    -1,
-      -1,    -1,    65,    -1,    -1,   412,    69,    -1,    -1,    72,
-      73,    74,    75,    76,    77,    -1,    79,    80,    -1,   671,
-     672,    -1,   674,    -1,    87,    -1,   678,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   101,    36,
-     103,    38,    -1,    -1,    -1,    -1,    -1,   110,   111,   112,
-     113,   114,   115,    -1,    -1,   462,    -1,    -1,   710,   711,
-      -1,    -1,    59,    -1,    -1,    -1,    -1,    -1,    65,    -1,
-      67,    68,    69,    -1,    -1,    72,    73,    74,    75,    76,
-      77,    -1,    79,    80,    -1,    -1,  1319,    -1,  1321,    -1,
-      87,    -1,   744,   500,    -1,    -1,   748,   749,    -1,  1332,
-      -1,  1334,    -1,    -1,   101,   512,   103,    -1,   105,   106,
-      -1,    -1,   519,   110,   111,   112,   113,   114,   115,    -1,
-      -1,  1354,    -1,    -1,    -1,   532,   533,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1370,   790,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1379,   554,    -1,  1382,
-     802,    -1,    36,    -1,    38,    -1,    -1,   564,    -1,   811,
-      -1,   813,    -1,    -1,    -1,   572,    -1,    -1,    -1,    -1,
-     822,  1404,    -1,    -1,    -1,    59,    -1,    -1,    -1,    -1,
-    1413,    65,    -1,  1416,  1417,    69,    -1,    -1,    72,    73,
-      74,    75,    76,    77,    -1,    79,    80,    -1,    -1,    -1,
-      -1,   853,    -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   623,   101,  1451,   103,
-    1453,    -1,   106,   630,    -1,    -1,   110,   111,   112,   113,
-     114,   115,  1465,    -1,    -1,    -1,   270,   271,   272,   273,
-      -1,    -1,    -1,    -1,   651,   897,   280,   281,    -1,    -1,
-      -1,   285,   286,    -1,    -1,    -1,   908,    -1,    -1,    -1,
-      -1,   913,    -1,   297,   671,    -1,    -1,    -1,    -1,   921,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   934,   935,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   326,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   958,    -1,    -1,    -1,
-      -1,    -1,    -1,   965,    -1,    -1,    -1,    -1,    -1,    -1,
-     972,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   363,
-      -1,    -1,   984,   985,    -1,    -1,    -1,   744,   990,   746,
-     992,    -1,    -1,    -1,    -1,   752,    -1,    -1,    -1,    -1,
-      -1,  1003,  1004,   760,  1006,  1007,  1008,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1019,  1020,  1021,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     797,    -1,    -1,   800,   801,   802,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,   821,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    37,  1076,    -1,    -1,    -1,    -1,    -1,
-    1082,  1083,  1084,  1085,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  1096,    -1,    60,    -1,    -1,    -1,
-      -1,    -1,    -1,    67,    68,   862,    -1,    -1,    -1,   866,
-      -1,    -1,    -1,    -1,    -1,    -1,  1118,    -1,    -1,    -1,
-      -1,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,  1141,
-     897,    29,    30,    31,  1146,  1147,  1148,   111,    -1,    37,
-      38,   535,   536,   537,   538,   539,   540,   541,   542,   543,
-     544,   545,   546,   547,   548,   549,   550,   551,   552,    -1,
-      -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,    67,
-      68,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   945,    -1,
-     574,    36,    -1,    38,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   958,   959,    -1,  1206,    -1,    -1,    -1,    -1,   966,
-      -1,    -1,    -1,    -1,    59,   103,   973,    -1,  1220,   976,
-      65,   978,    -1,   111,    69,    -1,  1228,    72,    73,    74,
-      75,    76,    77,    -1,    79,    80,    -1,    -1,   995,    -1,
-      -1,    -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,  1012,   101,    -1,   103,    -1,
-      -1,    -1,    -1,    -1,   109,   110,   111,   112,   113,   114,
-     115,    -1,    -1,    -1,    -1,    -1,  1278,  1279,  1035,    -1,
-    1037,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   673,
-      -1,    -1,    -1,    -1,    -1,  1052,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    1312,   695,    -1,    -1,  1071,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   708,  1082,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    30,    31,    32,    -1,    -1,    35,    -1,
-      37,    -1,    -1,  1120,    -1,    -1,    -1,   751,    -1,    -1,
-      -1,    -1,  1374,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    60,  1141,    62,    -1,    64,    -1,    -1,
-      67,    68,    -1,    -1,    -1,    -1,  1398,    -1,    -1,   783,
-      -1,    -1,  1159,    -1,  1161,    -1,    -1,    -1,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    27,   103,    29,    30,    31,
-      -1,    -1,    -1,    -1,   111,    37,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1206,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,
-      -1,    -1,    -1,    65,    -1,    67,    68,    69,    -1,    71,
-      -1,  1473,    -1,    -1,    76,    77,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,  1241,    -1,    -1,    -1,    -1,    -1,
-    1492,  1493,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   101,
-      -1,   103,    -1,    -1,   888,    -1,    -1,    -1,    -1,   111,
-    1512,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    29,    30,    31,
-      32,    -1,    -1,    35,    36,    37,    38,    39,    -1,    41,
-      -1,    -1,    44,    45,    46,    47,    48,    49,    50,    51,
-      -1,    53,    -1,    -1,    56,    57,    -1,    59,    60,    -1,
-      62,    -1,    64,    65,    -1,    67,    68,    69,    -1,    -1,
-      72,    73,    74,    75,    76,    77,    -1,    79,    80,    -1,
-      -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,   982,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   992,   101,
-      -1,   103,    -1,    -1,   106,    -1,    -1,    -1,   110,   111,
-     112,   113,   114,   115,    -1,    -1,    -1,    -1,    -1,    -1,
-    1387,    -1,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1040,    -1,    -1,    -1,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    -1,    -1,    29,    30,    31,    32,
-      -1,    -1,    35,    36,    37,    38,    -1,    -1,    -1,  1456,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    36,    -1,    38,    -1,    59,    60,    -1,    62,
-      -1,    64,    65,    -1,    67,    68,    69,    -1,  1112,    72,
-      73,    74,    75,    76,    77,    59,    79,    80,    -1,    -1,
-      -1,    65,  1499,    -1,    87,    69,    -1,    -1,    72,    73,
-      74,    75,    76,    77,    -1,    79,    80,    -1,   101,    -1,
-     103,    -1,    -1,    87,    -1,    -1,    -1,   110,   111,   112,
-     113,   114,   115,    -1,    -1,    -1,    -1,   101,  1162,   103,
-      -1,   124,    -1,    -1,   108,    -1,   110,   111,   112,   113,
-     114,   115,    -1,  1177,  1178,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    29,    30,    31,    32,    -1,    -1,    35,    36,    37,
-      38,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
-      -1,    59,    60,    -1,    62,    -1,    64,    65,    37,    67,
-      68,    69,    -1,    -1,    72,    73,    74,    75,    76,    77,
-      -1,    79,    80,    -1,    -1,    -1,    -1,    -1,    -1,    87,
-      -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    71,   101,    -1,   103,    -1,    -1,    -1,    -1,
-      -1,    -1,   110,   111,   112,   113,   114,   115,    -1,    -1,
-      -1,    -1,    -1,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    36,    37,    38,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    -1,    59,    60,
-      -1,    62,    -1,    64,    65,    37,    67,    68,    69,    -1,
-      -1,    72,    73,    74,    75,    76,    77,    -1,    79,    80,
-      -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    60,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     101,    -1,   103,   104,    -1,    -1,    -1,   108,  1402,   110,
-     111,   112,   113,   114,   115,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    36,    37,    38,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,  1460,  1461,    -1,    -1,
-      59,    60,    -1,    62,    -1,    64,    65,    -1,    67,    68,
-      69,    -1,    -1,    72,    73,    74,    75,    76,    77,    -1,
-      79,    80,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   101,    -1,   103,   104,    -1,    -1,    -1,   108,
-      -1,   110,   111,   112,   113,   114,   115,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    36,
-      37,    38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    59,    60,    -1,    62,    -1,    64,    65,    -1,
-      67,    68,    69,    -1,    -1,    72,    73,    74,    75,    76,
-      77,    -1,    79,    80,    -1,    -1,    -1,    -1,    -1,    -1,
-      87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   101,    -1,   103,   104,    -1,    -1,
-      -1,   108,    -1,   110,   111,   112,   113,   114,   115,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    36,    37,    38,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    59,    60,    -1,    62,    -1,    64,
-      65,    -1,    67,    68,    69,    -1,    -1,    72,    73,    74,
-      75,    76,    77,    -1,    79,    80,    -1,    -1,    -1,    -1,
-      -1,    -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   101,    -1,   103,   104,
-      -1,    -1,    -1,    -1,    -1,   110,   111,   112,   113,   114,
-     115,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    -1,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    36,    37,    38,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    59,    60,    -1,    62,
-      -1,    64,    65,    -1,    67,    68,    69,    -1,    -1,    72,
-      73,    74,    75,    76,    77,    -1,    79,    80,    -1,    -1,
-      -1,    -1,    -1,    -1,    87,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   101,    -1,
-     103,   104,    -1,    -1,    -1,    -1,    -1,   110,   111,   112,
-     113,   114,   115,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    36,    37,    38,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    59,    60,
-      -1,    62,    -1,    64,    65,    -1,    67,    68,    69,    -1,
-      -1,    72,    73,    74,    75,    76,    77,    -1,    79,    80,
-      -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     101,    -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,   110,
-     111,   112,   113,   114,   115,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    36,    37,    38,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      59,    60,    -1,    62,    -1,    64,    65,    -1,    67,    68,
-      69,    -1,    -1,    72,    73,    74,    75,    76,    77,    -1,
-      79,    80,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   101,    -1,   103,    -1,    -1,    -1,    -1,    -1,
-      -1,   110,   111,   112,   113,   114,   115,     0,    -1,    -1,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    -1,    -1,    29,    30,    31,    32,
-      -1,    -1,    35,    -1,    37,    38,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    57,    -1,    -1,    60,    -1,    62,
-      -1,    64,    65,    -1,    67,    68,    69,    -1,    -1,    -1,
-      -1,    -1,    -1,    76,    77,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   101,    -1,
-     103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    29,    30,    31,    32,    -1,
-      -1,    35,    -1,    37,    38,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    57,    -1,    -1,    60,    -1,    62,    -1,
-      64,    65,    -1,    67,    68,    69,    -1,    -1,    -1,    -1,
-      -1,    -1,    76,    77,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   101,    -1,   103,
-      -1,    -1,    -1,   107,    -1,    -1,    -1,   111,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    -1,    -1,    29,    30,    31,    32,    -1,    -1,
-      35,    -1,    37,    38,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    57,    -1,    -1,    60,    -1,    62,    -1,    64,
-      65,    -1,    67,    68,    69,    -1,    -1,    -1,    -1,    -1,
-      -1,    76,    77,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   101,    -1,   103,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   111,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    60,    -1,    62,    -1,    64,    65,
-      -1,    67,    68,    69,    -1,    -1,    -1,    -1,    -1,    -1,
-      76,    77,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   101,    -1,   103,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   111,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
-      37,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    60,    -1,    62,    -1,    64,    -1,    -1,
-      67,    68,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    37,   103,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,
-      62,    -1,    64,    65,    -1,    67,    68,    69,    -1,    -1,
-      -1,    -1,    -1,    -1,    76,    77,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   101,
-      -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,    62,    -1,
-      64,    -1,    -1,    67,    68,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    37,   103,
-     104,    -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    60,    -1,    62,    -1,    64,    -1,    -1,    67,    68,
-      -1,    -1,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    29,    30,    31,
-      -1,    -1,    -1,   102,   103,    37,    -1,    -1,    -1,    -1,
-      -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,
-      62,    -1,    64,    -1,    -1,    67,    68,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    89,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    37,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    29,    30,    31,    60,    -1,    62,    -1,
-      64,    37,    -1,    67,    68,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    60,    89,    -1,    -1,    -1,    65,
-      -1,    67,    68,    -1,    -1,    -1,    -1,    -1,    -1,   103,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    60,    -1,    62,    -1,    64,    -1,
-      -1,    67,    68,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    37,   103,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,
-      -1,    62,    -1,    64,    -1,    -1,    67,    68,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    37,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    60,    -1,    62,    -1,    64,    -1,
-      -1,    67,    68,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    37,   103,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,
-      -1,    62,    -1,    64,    -1,    -1,    67,    68,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    36,    37,    38,    -1,    -1,    -1,
-      -1,    -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     111,    -1,    -1,    -1,    -1,    -1,    -1,    59,    60,    -1,
-      -1,    -1,    -1,    65,    -1,    67,    68,    69,    -1,    -1,
-      72,    73,    74,    75,    76,    77,    -1,    79,    80,    -1,
-      -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   101,
-      -1,   103,    -1,    -1,   106,    -1,    -1,    -1,   110,   111,
-     112,   113,   114,   115,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      36,    37,    38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    59,    60,    -1,    -1,    -1,    -1,    65,
-      -1,    67,    68,    69,    -1,    -1,    72,    73,    74,    75,
-      76,    77,    -1,    79,    80,    -1,    -1,    -1,    -1,    -1,
-      -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   101,    -1,   103,   104,    -1,
-      -1,    -1,    -1,    -1,   110,   111,   112,   113,   114,   115,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    29,
-      30,    31,    -1,    -1,    -1,    -1,    36,    37,    38,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    59,
-      60,    -1,    -1,    -1,    -1,    65,    -1,    67,    68,    69,
-      -1,    -1,    72,    73,    74,    75,    76,    77,    -1,    79,
-      80,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
-     110,   111,   112,   113,   114,   115,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    36,    37,    38,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    59,    60,    -1,    -1,    -1,
-      -1,    65,    -1,    67,    68,    69,    -1,    -1,    72,    73,
-      74,    75,    76,    77,    -1,    79,    80,    -1,    -1,    -1,
-      -1,    -1,    -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   101,    -1,   103,
-      -1,    -1,    -1,    -1,    -1,    -1,   110,   111,   112,   113,
-     114,   115,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    29,    30,    31,    -1,    -1,    -1,    -1,    36,    37,
-      38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    59,    60,    -1,    -1,    -1,    -1,    65,    -1,    67,
-      68,    69,    -1,    -1,    72,    73,    74,    75,    76,    77,
-      -1,    79,    80,    -1,    -1,    -1,    -1,    -1,    -1,    87,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   101,    -1,   103,    -1,    -1,    -1,    -1,
-      -1,    -1,   110,   111,   112,   113,   114,   115,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    36,    37,    38,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    59,    60,    -1,
-      -1,    -1,    -1,    65,    -1,    67,    68,    69,    -1,    -1,
-      72,    73,    74,    75,    76,    77,    -1,    79,    80,    -1,
-      -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   101,
-      -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,   110,   111,
-     112,   113,   114,   115,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      36,    37,    38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    59,    60,    -1,    -1,    -1,    -1,    65,
-      -1,    67,    68,    69,    -1,    -1,    72,    73,    74,    75,
-      76,    77,    -1,    79,    80,    -1,    -1,    -1,    -1,    -1,
-      -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   101,    -1,   103,    -1,    -1,
-      -1,    -1,    -1,    -1,   110,   111,   112,   113,   114,   115,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    -1,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    37,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    31,    60,    -1,    62,
-      -1,    64,    37,    -1,    67,    68,    -1,    -1,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    60,    -1,    29,    30,    31,
-      65,    -1,    67,    68,    69,    37,    71,    -1,    -1,    -1,
-      -1,    76,    77,   106,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,
-      -1,    -1,    -1,    65,    -1,    67,    68,    69,   103,    -1,
-      -1,    -1,    -1,    -1,    76,    77,   111,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    -1,    -1,    29,    30,    31,   101,
-      -1,   103,    -1,    -1,    37,    -1,    -1,    -1,    -1,   111,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,    -1,
-      -1,    -1,    65,    -1,    67,    68,    69,    -1,    -1,    -1,
-      -1,    -1,    -1,    76,    77,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    -1,    -1,    29,    30,    31,    -1,   101,    -1,
-     103,    -1,    37,    -1,    -1,    -1,    -1,    -1,   111,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    60,    -1,    -1,    -1,    -1,
-      65,    -1,    67,    68,    69,    -1,    -1,    -1,    -1,    -1,
-      -1,    76,    77,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    30,    31,    -1,   101,    -1,   103,    -1,
-      37,    -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    60,    -1,    -1,    -1,    -1,    65,    -1,
-      67,    68,    69,    -1,    -1,    -1,    -1,    -1,    -1,    76,
-      77,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
-      29,    30,    31,    -1,   101,    -1,   103,    -1,    37,    -1,
-      -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    60,    -1,    -1,    -1,    -1,    65,    -1,    67,    68,
-      69,    -1,    -1,    -1,    -1,    -1,    -1,    76,    77,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    -1,    29,    30,
-      31,    -1,    -1,    -1,   103,    -1,    37,    38,    -1,    -1,
-      -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,
-      -1,    -1,    -1,    -1,    -1,    -1,    67,    68,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    -1,    -1,
-      -1,    -1,   103,    -1,    -1,    -1,   107,    -1,    -1,    -1,
-     111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,
-      -1,    -1,    -1,    -1,    -1,    67,    68,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    -1,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    37,    38,    -1,    -1,    -1,    -1,
-      -1,   103,    -1,    -1,    -1,   107,    -1,    -1,    -1,   111,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,    -1,
-      -1,    -1,    -1,    -1,    67,    68,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,
-     103,    -1,    -1,    -1,   107,    -1,    -1,    -1,   111,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,    -1,    -1,
-      -1,    -1,    -1,    67,    68,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    37,    -1,    -1,    -1,    -1,   101,    -1,   103,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    60,    -1,    -1,    -1,    -1,
-      -1,    -1,    67,    68,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
-      -1,    37,    -1,    -1,    -1,    -1,   101,    -1,   103,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,
-      -1,    67,    68,    10,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,
-      37,    -1,    -1,    -1,    -1,    -1,    -1,   103,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,
-      67,    68,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    37,
-      -1,    -1,    -1,    -1,    -1,    -1,   103,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,    67,
-      68,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
-      29,    30,    31,    -1,    -1,    -1,    -1,    -1,    37,    -1,
-      -1,    -1,    -1,    -1,    -1,   103,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,    67,    68,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    29,
-      30,    31,    -1,    -1,    -1,    -1,    -1,    37,    -1,    -1,
-      -1,    -1,    -1,    -1,   103,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      60,    -1,    -1,    -1,    -1,    -1,    -1,    67,    68,    10,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    -1,    29,    30,
-      31,    -1,    -1,    -1,    -1,    -1,    37,    -1,    -1,    -1,
-      -1,    -1,    -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,
-      -1,    -1,    -1,    -1,    -1,    -1,    67,    68,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    -1,    -1,    29,    30,    31,
-      -1,    -1,    -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,
-      -1,    -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,
-      -1,    -1,    -1,    -1,    -1,    67,    68,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    -1,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,
-      -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,    -1,
-      -1,    -1,    -1,    -1,    67,    68,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,
-     103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,    -1,    -1,
-      -1,    -1,    -1,    67,    68,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,
-      -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,   103,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    60,    -1,    -1,    -1,    -1,
-      -1,    -1,    67,    68,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    29,
-      30,    31,    -1,    -1,    -1,    -1,    -1,    37,   103,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      60,    -1,    62,    -1,    64,    -1,    -1,    67,    68,    -1,
-      36,    -1,    38,    39,    -1,    41,    -1,    -1,    44,    45,
-      46,    47,    48,    49,    50,    51,    52,    53,    -1,    -1,
-      56,    57,    -1,    59,    -1,    -1,    -1,    -1,    -1,    65,
-      -1,    -1,   102,    69,    -1,    -1,    72,    73,    74,    75,
-      76,    77,    -1,    79,    80,    -1,    -1,    -1,    -1,    -1,
-      -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   101,    -1,   103,    -1,    -1,
-     106,    -1,    -1,    -1,   110,   111,   112,   113,   114,   115,
-      -1,    36,    -1,    38,    39,    -1,    41,    -1,   124,    44,
-      45,    46,    47,    48,    49,    50,    51,    -1,    53,    -1,
-      -1,    56,    57,    -1,    59,    -1,    -1,    -1,    -1,    -1,
-      65,    -1,    -1,    -1,    69,    -1,    -1,    72,    73,    74,
-      75,    76,    77,    -1,    79,    80,    -1,    -1,    -1,    -1,
-      -1,    -1,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   101,    -1,   103,    -1,
-      -1,   106,    -1,    -1,    -1,   110,   111,   112,   113,   114,
-     115,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   124,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    37,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    29,    30,    31,    60,    -1,    62,    -1,
-      64,    37,    -1,    67,    68,    -1,    36,    -1,    38,    39,
-      -1,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    60,    89,    56,    57,    -1,    59,
-      -1,    67,    68,    -1,    -1,    65,    -1,    -1,    -1,    69,
-      -1,    -1,    72,    73,    74,    75,    76,    77,    -1,    79,
-      80,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   101,    -1,   103,    -1,    -1,   106,    -1,    -1,    -1,
-     110,   111,   112,   113,   114,   115,    36,    -1,    38,    39,
-      -1,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      50,    51,    -1,    53,    -1,    -1,    56,    57,    -1,    59,
-      -1,    -1,    -1,    -1,    -1,    65,    -1,    -1,    -1,    69,
-      -1,    -1,    72,    73,    74,    75,    76,    77,    -1,    79,
-      80,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   101,    -1,   103,    -1,    -1,   106,    -1,    -1,    -1,
-     110,   111,   112,   113,   114,   115,    36,    -1,    38,    39,
-      -1,    41,    -1,    -1,    44,    45,    46,    47,    48,    49,
-      50,    51,    -1,    53,    -1,    -1,    56,    57,    -1,    59,
-      -1,    -1,    -1,    -1,    -1,    65,    -1,    -1,    -1,    69,
-      -1,    -1,    72,    73,    74,    75,    76,    77,    -1,    79,
-      80,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,
-      -1,    -1,    -1,    36,    -1,    38,    -1,    -1,    -1,    -1,
-      -1,   101,    -1,   103,    -1,    -1,   106,    -1,    -1,    -1,
-     110,   111,   112,   113,   114,   115,    59,    -1,    -1,    -1,
-      -1,    -1,    65,    -1,    -1,    -1,    69,    -1,    -1,    72,
-      73,    74,    75,    76,    77,    -1,    79,    80,    -1,    -1,
-      -1,    -1,    -1,    -1,    87,    -1,    -1,    -1,    -1,    -1,
-      36,    -1,    38,    -1,    -1,    -1,    -1,    -1,   101,    -1,
-     103,    -1,    -1,   106,    -1,    -1,    -1,   110,   111,   112,
-     113,   114,   115,    59,    -1,    -1,    -1,    -1,    -1,    65,
-      -1,    -1,    -1,    69,    -1,    -1,    72,    73,    74,    75,
-      76,    77,    -1,    79,    80,    -1,    -1,    -1,    -1,    -1,
-      -1,    87,    -1,    -1,    -1,    -1,    -1,    36,    -1,    38,
-      -1,    -1,    -1,    -1,    -1,   101,    -1,   103,    -1,    -1,
-      -1,    -1,    -1,    -1,   110,   111,   112,   113,   114,   115,
-      59,    -1,    -1,    -1,    -1,    -1,    65,    -1,    -1,    -1,
-      69,    -1,    -1,    72,    73,    74,    75,    76,    77,    -1,
-      79,    80,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,
-      -1,    -1,    -1,    -1,    36,    -1,    38,    -1,    -1,    -1,
-      -1,    -1,   101,    -1,   103,    -1,    -1,    -1,    -1,    -1,
-      -1,   110,   111,   112,   113,   114,   115,    59,    -1,    -1,
-      -1,    -1,    -1,    65,    -1,    -1,    -1,    69,    -1,    -1,
-      72,    73,    74,    75,    76,    77,    -1,    79,    80,    -1,
-      -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,    -1,    -1,
-      -1,    36,    -1,    38,    -1,    -1,    -1,    -1,    -1,   101,
-      -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,   110,   111,
-     112,   113,   114,   115,    59,    -1,    -1,    -1,    -1,    -1,
-      65,    -1,    -1,    -1,    69,    -1,    -1,    72,    73,    74,
-      75,    76,    77,    -1,    79,    80,    -1,    -1,    -1,    -1,
-      -1,    -1,    87,    -1,    -1,    -1,    -1,    -1,    36,    -1,
-      38,    -1,    -1,    -1,    -1,    -1,   101,    -1,   103,    -1,
-      -1,    -1,    -1,    -1,    -1,   110,   111,   112,   113,   114,
-     115,    59,    -1,    -1,    -1,    -1,    -1,    65,    -1,    -1,
-      -1,    69,    -1,    -1,    72,    73,    74,    75,    76,    77,
-      -1,    79,    80,    -1,    -1,    -1,    -1,    -1,    -1,    87,
-      -1,    -1,    -1,    -1,    -1,    36,    -1,    38,    -1,    -1,
-      -1,    -1,    -1,   101,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   110,   111,   112,   113,   114,   115,    59,    -1,
-      -1,    -1,    -1,    -1,    65,    -1,    -1,    -1,    69,    -1,
-      -1,    72,    73,    74,    75,    76,    77,    -1,    79,    80,
-      -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     101,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,
-     111,   112,   113,   114,   115,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    60,    -1,    62,    -1,    64,    65,    -1,    67,    68,
-      69,    -1,    -1,    -1,    -1,    -1,    -1,    76,    77,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,
-      -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,    62,    -1,
-      64,    -1,    -1,    67,    68,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    29,    30,    31,    -1,    -1,    -1,    -1,    -1,    37,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    60,    -1,    62,    -1,    64,    -1,    -1,    67,
-      68,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-      23,    24,    25,    26,    -1,    -1,    29,    30,    31,    -1,
-      -1,    -1,    -1,    -1,    37,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    60,    -1,    62,
-      -1,    64,    -1,    -1,    67,    68,    10,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
-      24,    25,    26,    -1,    -1,    29,    30,    31,    32,    33,
-      34,    -1,    -1,    37,    10,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-      26,    -1,    -1,    29,    30,    31,    60,    -1,    -1,    -1,
-      -1,    37,    -1,    67,    68,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,
-      -1,    67,    68
-};
-
-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-   symbol of state STATE-NUM.  */
-static const yytype_uint16 yystos[] =
-{
-       0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    26,    29,    30,    31,    32,    35,
-      37,    38,    57,    60,    62,    64,    65,    67,    68,    69,
-      76,    77,   101,   103,   111,   129,   132,   189,   201,   202,
-     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
-     213,   214,   215,   216,   217,   218,   220,   221,   222,   223,
-     224,   225,   226,   227,   229,   230,   231,   232,   233,   234,
-     235,   243,   244,   270,   271,   279,   282,   288,   289,   291,
-     293,   294,   300,   305,   309,   310,   311,   312,   313,   314,
-     315,   316,   336,   353,   354,   355,   356,    65,   111,   131,
-     204,   206,   214,   216,   226,   230,   232,   271,    75,   101,
-     298,   299,   300,   298,   298,    65,    67,    68,    69,   130,
-     131,   260,   261,   280,   281,    67,    68,   261,   101,   291,
-     215,   216,   101,   111,   305,   310,   311,   312,   314,   315,
-     316,   126,   103,   207,   214,   216,   309,   313,   352,   353,
-     356,   357,   127,   123,   264,   106,   127,   164,    67,    68,
-     129,   259,   127,   127,   127,   108,   127,    67,   101,   111,
-     295,   304,   305,   306,   307,   308,   309,   313,   317,   318,
-     319,   320,   321,     3,    27,    71,   228,     3,     5,    67,
-      68,   103,   111,   206,   217,   221,   224,   233,   309,   313,
-     356,   204,   206,   216,   226,   230,   232,   271,   309,   313,
-      32,   222,   222,   217,   224,   127,   222,   217,   222,   217,
-     101,   106,   261,   106,   261,   222,   217,   108,   127,   127,
-       0,   126,   101,   164,   298,   298,   126,   103,   214,   216,
-     354,   259,   259,   216,   123,   101,   111,   295,   305,   309,
-     103,   111,   356,   292,   219,   300,   101,   276,   101,   101,
-     101,    36,    38,    59,    65,    69,    72,    73,    74,    75,
-      79,    80,    87,   101,   103,   110,   111,   112,   113,   114,
-     115,   128,   132,   133,   134,   135,   140,   141,   142,   143,
-     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
-     155,   157,   214,   263,   278,   352,   357,   216,   102,   102,
-     102,   102,   102,   102,   102,   103,   111,   127,   155,   206,
-     207,   213,   216,   220,   221,   226,   229,   230,   232,   249,
-     250,   254,   255,   256,   257,   271,   336,   348,   349,   350,
-     351,   356,   357,   126,   101,   309,   313,   356,   101,   108,
-     124,   103,   106,   111,   155,   265,   107,   126,   108,   124,
-     101,   108,   124,   108,   124,   108,   124,   298,   124,   305,
-     306,   307,   308,   318,   319,   320,   321,   216,   304,   317,
-      57,   297,   103,   298,   335,   336,   298,   298,   164,   126,
-     101,   298,   335,   298,   298,   216,   295,   101,   101,   215,
-     214,   216,   101,   126,   214,   352,   357,   164,   126,   259,
-     264,   206,   221,   309,   313,   164,   126,   280,   216,   226,
-     124,   216,   216,   278,    38,   103,   214,   236,   237,   238,
-     239,   352,   356,   106,   245,   261,   106,   216,   280,   124,
-     124,   291,   126,   131,   258,     3,   127,   196,   197,   211,
-     213,   216,   126,   297,   101,   297,   155,   305,   216,   101,
-     126,   259,   106,    32,    33,    34,   214,   272,   273,   275,
-     126,   121,   123,   277,   126,   217,   223,   224,   259,   301,
-     302,   303,   140,   153,   154,   101,   140,   142,   101,   140,
-     101,   101,   140,   140,   131,   103,   155,   160,   164,   214,
-     262,   352,   126,   142,   142,    75,    78,    79,    80,   101,
-     103,   105,    90,    91,    92,    93,    94,    95,    96,    97,
-      98,    99,   123,   159,   142,   111,   116,   117,   113,   114,
-      81,    82,    83,    84,   118,   119,    85,    86,   112,   120,
-     121,    87,    88,   122,   123,   359,   101,   111,   331,   332,
-     333,   334,   335,   102,   108,   101,   335,   103,   336,   101,
-     335,   336,   126,   103,   111,   127,   214,   216,   347,   348,
-     356,   357,   104,   127,    67,   101,   103,   111,   305,   322,
-     323,   324,   325,   326,   327,   328,   329,   330,   336,   337,
-     338,   339,   340,   341,   342,   111,   356,   216,   127,   127,
-     111,   214,   216,   349,   259,   214,   336,   349,   259,   127,
-     126,   126,   126,   126,    65,   103,   105,   261,   265,   266,
-     267,   268,   269,   126,   126,   126,   126,   126,   126,   295,
-     102,   102,   102,   102,   102,   102,   102,   304,   317,   101,
-     264,   126,   196,   126,   295,   160,   263,   160,   263,   295,
-     278,   103,   127,   196,   297,   164,   126,   196,   102,   238,
-     239,   126,   101,   109,   111,   240,   242,   304,   305,   317,
-     335,   343,   344,   345,   346,   107,   237,   108,   124,   108,
-     124,   261,   236,   108,   358,   123,   246,   245,   216,   251,
-     252,   253,   256,   257,   102,   108,   164,   126,   111,   155,
-     126,   213,   216,   250,   348,   356,   289,   290,   101,   111,
-     322,   102,   108,   359,   261,   272,   101,   106,   261,   263,
-     272,   102,   108,   101,   102,   109,   262,   262,   103,   131,
-     137,   155,   263,   262,   126,   102,   108,   102,   101,   111,
-     343,   102,   108,   127,   155,   103,   131,   103,   136,   137,
-     126,   103,   131,   155,   155,   142,   142,   142,   143,   143,
-     144,   144,   145,   145,   145,   145,   146,   146,   147,   148,
-     149,   150,   151,   109,   160,   155,   126,   332,   333,   334,
-     216,   331,   298,   298,   155,   263,   126,   126,   258,   127,
-     216,   220,   126,   104,   356,    67,   129,   214,   336,   354,
-     104,   101,   126,   305,   323,   324,   325,   328,   338,   339,
-     340,   126,   216,   322,   326,   337,   101,   298,   341,   359,
-     298,   298,   359,   101,   298,   341,   298,   298,   298,   298,
-     336,   214,   347,   357,   259,   104,   108,   104,   108,   359,
-     214,   349,   359,   104,   247,   248,   249,   250,   247,   259,
-     127,   155,   126,   103,   261,   109,   108,   358,   265,   103,
-     109,   269,    28,   198,   199,   259,   247,   131,   295,   131,
-     297,   101,   335,   336,   101,   335,   336,   133,   111,   127,
-     164,   251,   102,   102,   102,   102,   102,   126,   104,   164,
-     196,   164,   106,   261,   124,   124,   103,   127,   305,   344,
-     345,   346,   154,   216,   343,   241,   242,   241,   298,   298,
-     261,   298,   107,   261,   107,   154,   358,   127,   127,   131,
-     211,   127,   127,   247,   101,   111,   356,   127,   107,   216,
-     273,   274,   127,   126,   126,   101,   127,   102,   302,   160,
-     161,   124,    75,   190,   191,   192,   102,   102,   126,   109,
-     102,   102,   102,   127,   155,   216,   106,   142,   157,   155,
-     156,   158,   104,   108,   127,   126,   126,   102,   108,   155,
-     126,   153,   109,   251,   102,   102,   102,   331,   251,   102,
-     104,   103,   111,   155,   155,   216,   127,   101,   101,   214,
-     354,   328,   251,   102,   102,   102,   102,   102,   102,   102,
-       7,   127,   216,   322,   326,   337,   126,   126,   359,   126,
-     126,   101,   127,   127,   127,   127,   264,   104,   127,   153,
-     154,   155,   296,   126,   265,   267,   107,   126,   200,   261,
-      38,    39,    41,    44,    45,    46,    47,    48,    49,    50,
-      51,    53,    56,   103,   131,   161,   162,   163,   164,   165,
-     166,   168,   169,   181,   183,   184,   189,   201,   294,    28,
-     127,   123,   264,   126,   126,   102,   104,   127,   127,    67,
-     164,   236,   126,   104,   102,   102,   102,   343,   240,   246,
-     107,   102,   108,   104,   104,   127,   216,   108,   359,   276,
-     102,   272,   204,   206,   214,   284,   285,   286,   287,   278,
-     102,   102,   101,   102,   109,   108,   155,   155,   104,   266,
-     108,   127,   158,   104,   131,   138,   139,   155,   137,   127,
-     138,   153,   157,   127,   101,   335,   336,   127,   214,   336,
-     349,   126,   127,   127,   127,   155,   104,   126,   126,   102,
-     127,   101,   335,   336,   101,   341,   101,   341,   336,   215,
-     104,     7,   111,   127,   155,   251,   251,   250,   254,   254,
-     255,   247,   102,   108,   108,   102,   104,    89,   115,   127,
-     127,   138,   265,   155,   108,   124,   201,   205,   216,   220,
-     101,   101,   162,   101,   101,   124,   131,   124,   131,   111,
-     131,   161,   101,   164,   124,   155,   126,   109,   124,   127,
-     126,   127,   200,   102,   155,   251,   251,   298,   336,   102,
-     104,   107,   127,   101,   335,   336,   126,   102,   126,   127,
-     295,   107,   126,   127,   127,   102,   106,   154,   124,   190,
-     192,   108,   127,   358,   156,   104,   127,    78,   105,   108,
-     127,   127,   104,   127,   102,   126,   102,   214,   349,   104,
-     104,   104,   127,   247,   247,   102,   126,   126,   126,   155,
-     155,   127,   104,   127,   127,   127,   127,   102,   126,   126,
-     154,   154,   104,   104,   127,   127,   261,   216,   160,   160,
-      45,   160,   126,   124,   124,   160,   124,   124,   160,    54,
-      55,   185,   186,   187,   124,   127,   298,   166,   107,   124,
-     127,   127,   104,   126,    89,   256,   257,   102,   285,   108,
-     124,   108,   124,   107,   283,   102,   102,   109,   158,   104,
-     107,   104,   103,   139,   103,   139,   139,   104,   104,   104,
-     251,   104,   127,   127,   251,   251,   251,   127,   127,   104,
-     104,   102,   102,   104,   108,    89,   250,    89,   127,   104,
-     104,   102,   102,   101,   102,   161,   182,   201,   124,   102,
-     101,   164,   187,    54,   104,   162,   102,   102,   251,   106,
-     126,   126,   284,   124,    75,   193,   127,   109,   126,   126,
-     127,   102,   102,   127,   127,   127,   104,   104,   126,   127,
-     104,   162,    42,    43,   106,   172,   173,   174,   160,   162,
-     127,   102,   161,   106,   174,    89,   126,   101,   127,   126,
-     259,   295,   107,   102,   108,   104,   155,   138,   138,   102,
-     102,   102,   102,   254,    40,   154,   170,   171,   296,   109,
-     126,   162,   172,   102,   124,   162,   124,   126,   102,   126,
-      89,   126,   102,   284,   124,    75,   109,   127,   127,   162,
-      89,   108,   109,   127,   194,   195,   201,   124,   161,   161,
-     194,   164,   188,   214,   352,   102,   126,   107,   155,   104,
-     104,   154,   170,   173,   175,   176,   126,   124,   173,   177,
-     178,   127,   101,   111,   295,   343,   131,   164,   188,   101,
-     162,   167,   107,   173,   201,   161,    52,   167,   180,   107,
-     173,   102,   216,   127,   278,   162,   167,   124,   179,   180,
-     167,   180,   164,   102,   102,   179,   127,   164,   127
-};
-
-#define yyerrok		(yyerrstatus = 0)
-#define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		(-2)
-#define YYEOF		0
-
-#define YYACCEPT	goto yyacceptlab
-#define YYABORT		goto yyabortlab
-#define YYERROR		goto yyerrorlab
-
-
-/* Like YYERROR except do call yyerror.  This remains here temporarily
-   to ease the transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  However,
-   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
-   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
-   discussed.  */
-
-#define YYFAIL		goto yyerrlab
-#if defined YYFAIL
-  /* This is here to suppress warnings from the GCC cpp's
-     -Wunused-macros.  Normally we don't worry about that warning, but
-     some users do, and we want to make it easy for users to remove
-     YYFAIL uses, which will produce warnings from Bison 2.5.  */
-#endif
-
-#define YYRECOVERING()  (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value)					\
-do								\
-  if (yychar == YYEMPTY && yylen == 1)				\
-    {								\
-      yychar = (Token);						\
-      yylval = (Value);						\
-      YYPOPSTACK (1);						\
-      goto yybackup;						\
-    }								\
-  else								\
-    {								\
-      yyerror (YY_("syntax error: cannot back up")); \
-      YYERROR;							\
-    }								\
-while (YYID (0))
-
-
-#define YYTERROR	1
-#define YYERRCODE	256
-
-
-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
-   If N is 0, then set CURRENT to the empty location which ends
-   the previous symbol: RHS[0] (always defined).  */
-
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)				\
-    do									\
-      if (YYID (N))                                                    \
-	{								\
-	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
-	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
-	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
-	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
-	}								\
-      else								\
-	{								\
-	  (Current).first_line   = (Current).last_line   =		\
-	    YYRHSLOC (Rhs, 0).last_line;				\
-	  (Current).first_column = (Current).last_column =		\
-	    YYRHSLOC (Rhs, 0).last_column;				\
-	}								\
-    while (YYID (0))
-#endif
-
-
-/* This macro is provided for backward compatibility. */
-
-#ifndef YY_LOCATION_PRINT
-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-#endif
-
-
-/* YYLEX -- calling `yylex' with the right arguments.  */
-
-#ifdef YYLEX_PARAM
-# define YYLEX yylex (YYLEX_PARAM)
-#else
-# define YYLEX yylex ()
-#endif
-
-/* Enable debugging if requested.  */
-#if YYDEBUG
-
-# ifndef YYFPRINTF
-#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args)			\
-do {						\
-  if (yydebug)					\
-    YYFPRINTF Args;				\
-} while (YYID (0))
-
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
-do {									  \
-  if (yydebug)								  \
-    {									  \
-      YYFPRINTF (stderr, "%s ", Title);					  \
-      yy_symbol_print (stderr,						  \
-		  Type, Value); \
-      YYFPRINTF (stderr, "\n");						  \
-    }									  \
-} while (YYID (0))
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
-#else
-static void
-yy_symbol_value_print (yyoutput, yytype, yyvaluep)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-#endif
-{
-  if (!yyvaluep)
-    return;
-# ifdef YYPRINT
-  if (yytype < YYNTOKENS)
-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# else
-  YYUSE (yyoutput);
-# endif
-  switch (yytype)
-    {
-      default:
-	break;
-    }
-}
-
-
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
-#else
-static void
-yy_symbol_print (yyoutput, yytype, yyvaluep)
-    FILE *yyoutput;
-    int yytype;
-    YYSTYPE const * const yyvaluep;
-#endif
-{
-  if (yytype < YYNTOKENS)
-    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
-  else
-    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
-
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
-  YYFPRINTF (yyoutput, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included).                                                   |
-`------------------------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
-#else
-static void
-yy_stack_print (yybottom, yytop)
-    yytype_int16 *yybottom;
-    yytype_int16 *yytop;
-#endif
-{
-  YYFPRINTF (stderr, "Stack now");
-  for (; yybottom <= yytop; yybottom++)
-    {
-      int yybot = *yybottom;
-      YYFPRINTF (stderr, " %d", yybot);
-    }
-  YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top)				\
-do {								\
-  if (yydebug)							\
-    yy_stack_print ((Bottom), (Top));				\
-} while (YYID (0))
-
-
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced.  |
-`------------------------------------------------*/
-
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
-#else
-static void
-yy_reduce_print (yyvsp, yyrule)
-    YYSTYPE *yyvsp;
-    int yyrule;
-#endif
-{
-  int yynrhs = yyr2[yyrule];
-  int yyi;
-  unsigned long int yylno = yyrline[yyrule];
-  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
-	     yyrule - 1, yylno);
-  /* The symbols being reduced.  */
-  for (yyi = 0; yyi < yynrhs; yyi++)
-    {
-      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
-      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
-		       &(yyvsp[(yyi + 1) - (yynrhs)])
-		       		       );
-      YYFPRINTF (stderr, "\n");
-    }
-}
-
-# define YY_REDUCE_PRINT(Rule)		\
-do {					\
-  if (yydebug)				\
-    yy_reduce_print (yyvsp, Rule); \
-} while (YYID (0))
-
-/* Nonzero means print parse trace.  It is left uninitialized so that
-   multiple parsers can coexist.  */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args)
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks.  */
-#ifndef	YYINITDEPTH
-# define YYINITDEPTH 200
-#endif
-
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
-   if the built-in stack extension method is used).
-
-   Do not make this value too large; the results are undefined if
-   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
-   evaluated with infinite-precision integer arithmetic.  */
-
-#ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
-#endif
-
-
-#if YYERROR_VERBOSE
-
-# ifndef yystrlen
-#  if defined __GLIBC__ && defined _STRING_H
-#   define yystrlen strlen
-#  else
-/* Return the length of YYSTR.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static YYSIZE_T
-yystrlen (const char *yystr)
-#else
-static YYSIZE_T
-yystrlen (yystr)
-    const char *yystr;
-#endif
-{
-  YYSIZE_T yylen;
-  for (yylen = 0; yystr[yylen]; yylen++)
-    continue;
-  return yylen;
-}
-#  endif
-# endif
-
-# ifndef yystpcpy
-#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
-#   define yystpcpy stpcpy
-#  else
-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
-   YYDEST.  */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static char *
-yystpcpy (char *yydest, const char *yysrc)
-#else
-static char *
-yystpcpy (yydest, yysrc)
-    char *yydest;
-    const char *yysrc;
-#endif
-{
-  char *yyd = yydest;
-  const char *yys = yysrc;
-
-  while ((*yyd++ = *yys++) != '\0')
-    continue;
-
-  return yyd - 1;
-}
-#  endif
-# endif
-
-# ifndef yytnamerr
-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
-   quotes and backslashes, so that it's suitable for yyerror.  The
-   heuristic is that double-quoting is unnecessary unless the string
-   contains an apostrophe, a comma, or backslash (other than
-   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
-   null, do not copy; instead, return the length of what the result
-   would have been.  */
-static YYSIZE_T
-yytnamerr (char *yyres, const char *yystr)
-{
-  if (*yystr == '"')
-    {
-      YYSIZE_T yyn = 0;
-      char const *yyp = yystr;
-
-      for (;;)
-	switch (*++yyp)
-	  {
-	  case '\'':
-	  case ',':
-	    goto do_not_strip_quotes;
-
-	  case '\\':
-	    if (*++yyp != '\\')
-	      goto do_not_strip_quotes;
-	    /* Fall through.  */
-	  default:
-	    if (yyres)
-	      yyres[yyn] = *yyp;
-	    yyn++;
-	    break;
-
-	  case '"':
-	    if (yyres)
-	      yyres[yyn] = '\0';
-	    return yyn;
-	  }
-    do_not_strip_quotes: ;
-    }
-
-  if (! yyres)
-    return yystrlen (yystr);
-
-  return yystpcpy (yyres, yystr) - yyres;
-}
-# endif
-
-/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
-   about the unexpected token YYTOKEN for the state stack whose top is
-   YYSSP.
-
-   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
-   not large enough to hold the message.  In that case, also set
-   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
-   required number of bytes is too large to store.  */
-static int
-yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
-                yytype_int16 *yyssp, int yytoken)
-{
-  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
-  YYSIZE_T yysize = yysize0;
-  YYSIZE_T yysize1;
-  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
-  /* Internationalized format string. */
-  const char *yyformat = 0;
-  /* Arguments of yyformat. */
-  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-  /* Number of reported tokens (one for the "unexpected", one per
-     "expected"). */
-  int yycount = 0;
-
-  /* There are many possibilities here to consider:
-     - Assume YYFAIL is not used.  It's too flawed to consider.  See
-       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
-       for details.  YYERROR is fine as it does not invoke this
-       function.
-     - If this state is a consistent state with a default action, then
-       the only way this function was invoked is if the default action
-       is an error action.  In that case, don't check for expected
-       tokens because there are none.
-     - The only way there can be no lookahead present (in yychar) is if
-       this state is a consistent state with a default action.  Thus,
-       detecting the absence of a lookahead is sufficient to determine
-       that there is no unexpected or expected token to report.  In that
-       case, just report a simple "syntax error".
-     - Don't assume there isn't a lookahead just because this state is a
-       consistent state with a default action.  There might have been a
-       previous inconsistent state, consistent state with a non-default
-       action, or user semantic action that manipulated yychar.
-     - Of course, the expected token list depends on states to have
-       correct lookahead information, and it depends on the parser not
-       to perform extra reductions after fetching a lookahead from the
-       scanner and before detecting a syntax error.  Thus, state merging
-       (from LALR or IELR) and default reductions corrupt the expected
-       token list.  However, the list is correct for canonical LR with
-       one exception: it will still contain any token that will not be
-       accepted due to an error action in a later state.
-  */
-  if (yytoken != YYEMPTY)
-    {
-      int yyn = yypact[*yyssp];
-      yyarg[yycount++] = yytname[yytoken];
-      if (!yypact_value_is_default (yyn))
-        {
-          /* Start YYX at -YYN if negative to avoid negative indexes in
-             YYCHECK.  In other words, skip the first -YYN actions for
-             this state because they are default actions.  */
-          int yyxbegin = yyn < 0 ? -yyn : 0;
-          /* Stay within bounds of both yycheck and yytname.  */
-          int yychecklim = YYLAST - yyn + 1;
-          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-          int yyx;
-
-          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
-                && !yytable_value_is_error (yytable[yyx + yyn]))
-              {
-                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
-                  {
-                    yycount = 1;
-                    yysize = yysize0;
-                    break;
-                  }
-                yyarg[yycount++] = yytname[yyx];
-                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
-                if (! (yysize <= yysize1
-                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-                  return 2;
-                yysize = yysize1;
-              }
-        }
-    }
-
-  switch (yycount)
-    {
-# define YYCASE_(N, S)                      \
-      case N:                               \
-        yyformat = S;                       \
-      break
-      YYCASE_(0, YY_("syntax error"));
-      YYCASE_(1, YY_("syntax error, unexpected %s"));
-      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
-      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
-      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
-      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
-# undef YYCASE_
-    }
-
-  yysize1 = yysize + yystrlen (yyformat);
-  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-    return 2;
-  yysize = yysize1;
-
-  if (*yymsg_alloc < yysize)
-    {
-      *yymsg_alloc = 2 * yysize;
-      if (! (yysize <= *yymsg_alloc
-             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
-        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
-      return 1;
-    }
-
-  /* Avoid sprintf, as that infringes on the user's name space.
-     Don't have undefined behavior even if the translation
-     produced a string with the wrong number of "%s"s.  */
-  {
-    char *yyp = *yymsg;
-    int yyi = 0;
-    while ((*yyp = *yyformat) != '\0')
-      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
-        {
-          yyp += yytnamerr (yyp, yyarg[yyi++]);
-          yyformat += 2;
-        }
-      else
-        {
-          yyp++;
-          yyformat++;
-        }
-  }
-  return 0;
-}
-#endif /* YYERROR_VERBOSE */
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-/*ARGSUSED*/
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
-#else
-static void
-yydestruct (yymsg, yytype, yyvaluep)
-    const char *yymsg;
-    int yytype;
-    YYSTYPE *yyvaluep;
-#endif
-{
-  YYUSE (yyvaluep);
-
-  if (!yymsg)
-    yymsg = "Deleting";
-  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
-
-  switch (yytype)
-    {
-
-      default:
-	break;
-    }
-}
-
-
-/* Prevent warnings from -Wmissing-prototypes.  */
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-
-/* The lookahead symbol.  */
-int yychar;
-
-/* The semantic value of the lookahead symbol.  */
-YYSTYPE yylval;
-
-/* Number of syntax errors so far.  */
-int yynerrs;
-
-
-/*----------.
-| yyparse.  |
-`----------*/
-
-#ifdef YYPARSE_PARAM
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (void *YYPARSE_PARAM)
-#else
-int
-yyparse (YYPARSE_PARAM)
-    void *YYPARSE_PARAM;
-#endif
-#else /* ! YYPARSE_PARAM */
-#if (defined __STDC__ || defined __C99__FUNC__ \
-     || defined __cplusplus || defined _MSC_VER)
-int
-yyparse (void)
-#else
-int
-yyparse ()
-
-#endif
-#endif
-{
-    int yystate;
-    /* Number of tokens to shift before error messages enabled.  */
-    int yyerrstatus;
-
-    /* The stacks and their tools:
-       `yyss': related to states.
-       `yyvs': related to semantic values.
-
-       Refer to the stacks thru separate pointers, to allow yyoverflow
-       to reallocate them elsewhere.  */
-
-    /* The state stack.  */
-    yytype_int16 yyssa[YYINITDEPTH];
-    yytype_int16 *yyss;
-    yytype_int16 *yyssp;
-
-    /* The semantic value stack.  */
-    YYSTYPE yyvsa[YYINITDEPTH];
-    YYSTYPE *yyvs;
-    YYSTYPE *yyvsp;
-
-    YYSIZE_T yystacksize;
-
-  int yyn;
-  int yyresult;
-  /* Lookahead token as an internal (translated) token number.  */
-  int yytoken;
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-
-#if YYERROR_VERBOSE
-  /* Buffer for error messages, and its allocated size.  */
-  char yymsgbuf[128];
-  char *yymsg = yymsgbuf;
-  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
-#endif
-
-#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
-
-  /* The number of symbols on the RHS of the reduced rule.
-     Keep to zero when no symbol should be popped.  */
-  int yylen = 0;
-
-  yytoken = 0;
-  yyss = yyssa;
-  yyvs = yyvsa;
-  yystacksize = YYINITDEPTH;
-
-  YYDPRINTF ((stderr, "Starting parse\n"));
-
-  yystate = 0;
-  yyerrstatus = 0;
-  yynerrs = 0;
-  yychar = YYEMPTY; /* Cause a token to be read.  */
-
-  /* Initialize stack pointers.
-     Waste one element of value and location stack
-     so that they stay on the same level as the state stack.
-     The wasted elements are never initialized.  */
-  yyssp = yyss;
-  yyvsp = yyvs;
-
-  goto yysetstate;
-
-/*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
-`------------------------------------------------------------*/
- yynewstate:
-  /* In all cases, when you get here, the value and location stacks
-     have just been pushed.  So pushing a state here evens the stacks.  */
-  yyssp++;
-
- yysetstate:
-  *yyssp = yystate;
-
-  if (yyss + yystacksize - 1 <= yyssp)
-    {
-      /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
-
-#ifdef yyoverflow
-      {
-	/* Give user a chance to reallocate the stack.  Use copies of
-	   these so that the &'s don't force the real ones into
-	   memory.  */
-	YYSTYPE *yyvs1 = yyvs;
-	yytype_int16 *yyss1 = yyss;
-
-	/* Each stack pointer address is followed by the size of the
-	   data in use in that stack, in bytes.  This used to be a
-	   conditional around just the two extra args, but that might
-	   be undefined if yyoverflow is a macro.  */
-	yyoverflow (YY_("memory exhausted"),
-		    &yyss1, yysize * sizeof (*yyssp),
-		    &yyvs1, yysize * sizeof (*yyvsp),
-		    &yystacksize);
-
-	yyss = yyss1;
-	yyvs = yyvs1;
-      }
-#else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyexhaustedlab;
-# else
-      /* Extend the stack our own way.  */
-      if (YYMAXDEPTH <= yystacksize)
-	goto yyexhaustedlab;
-      yystacksize *= 2;
-      if (YYMAXDEPTH < yystacksize)
-	yystacksize = YYMAXDEPTH;
-
-      {
-	yytype_int16 *yyss1 = yyss;
-	union yyalloc *yyptr =
-	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
-	if (! yyptr)
-	  goto yyexhaustedlab;
-	YYSTACK_RELOCATE (yyss_alloc, yyss);
-	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-#  undef YYSTACK_RELOCATE
-	if (yyss1 != yyssa)
-	  YYSTACK_FREE (yyss1);
-      }
-# endif
-#endif /* no yyoverflow */
-
-      yyssp = yyss + yysize - 1;
-      yyvsp = yyvs + yysize - 1;
-
-      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-		  (unsigned long int) yystacksize));
-
-      if (yyss + yystacksize - 1 <= yyssp)
-	YYABORT;
-    }
-
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
-
-  if (yystate == YYFINAL)
-    YYACCEPT;
-
-  goto yybackup;
-
-/*-----------.
-| yybackup.  |
-`-----------*/
-yybackup:
-
-  /* Do appropriate processing given the current state.  Read a
-     lookahead token if we need one and don't already have one.  */
-
-  /* First try to decide what to do without reference to lookahead token.  */
-  yyn = yypact[yystate];
-  if (yypact_value_is_default (yyn))
-    goto yydefault;
-
-  /* Not known => get a lookahead token if don't already have one.  */
-
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
-  if (yychar == YYEMPTY)
-    {
-      YYDPRINTF ((stderr, "Reading a token: "));
-      yychar = YYLEX;
-    }
-
-  if (yychar <= YYEOF)
-    {
-      yychar = yytoken = YYEOF;
-      YYDPRINTF ((stderr, "Now at end of input.\n"));
-    }
-  else
-    {
-      yytoken = YYTRANSLATE (yychar);
-      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
-    }
-
-  /* If the proper action on seeing token YYTOKEN is to reduce or to
-     detect an error, take that action.  */
-  yyn += yytoken;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
-    goto yydefault;
-  yyn = yytable[yyn];
-  if (yyn <= 0)
-    {
-      if (yytable_value_is_error (yyn))
-        goto yyerrlab;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-
-  /* Count tokens shifted since error; after three, turn off error
-     status.  */
-  if (yyerrstatus)
-    yyerrstatus--;
-
-  /* Shift the lookahead token.  */
-  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
-
-  /* Discard the shifted token.  */
-  yychar = YYEMPTY;
-
-  yystate = yyn;
-  *++yyvsp = yylval;
-
-  goto yynewstate;
-
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state.  |
-`-----------------------------------------------------------*/
-yydefault:
-  yyn = yydefact[yystate];
-  if (yyn == 0)
-    goto yyerrlab;
-  goto yyreduce;
-
-
-/*-----------------------------.
-| yyreduce -- Do a reduction.  |
-`-----------------------------*/
-yyreduce:
-  /* yyn is the number of a rule to reduce with.  */
-  yylen = yyr2[yyn];
-
-  /* If YYLEN is nonzero, implement the default value of the action:
-     `$$ = $1'.
-
-     Otherwise, the following line sets YYVAL to garbage.
-     This behavior is undocumented and Bison
-     users should not rely upon it.  Assigning to YYVAL
-     unconditionally makes the parser a bit smaller, and it avoids a
-     GCC warning that YYVAL may be used uninitialized.  */
-  yyval = yyvsp[1-yylen];
-
-
-  YY_REDUCE_PRINT (yyn);
-  switch (yyn)
-    {
-        case 2:
-
-/* Line 1806 of yacc.c  */
-#line 279 "parser.yy"
-    {
-			typedefTable.enterScope();
-		}
-    break;
-
-  case 3:
-
-/* Line 1806 of yacc.c  */
-#line 285 "parser.yy"
-    {
-			typedefTable.leaveScope();
-		}
-    break;
-
-  case 4:
-
-/* Line 1806 of yacc.c  */
-#line 294 "parser.yy"
-    { (yyval.constant) = new ConstantNode( ConstantNode::Integer, (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 5:
-
-/* Line 1806 of yacc.c  */
-#line 295 "parser.yy"
-    { (yyval.constant) = new ConstantNode( ConstantNode::Float, (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 6:
-
-/* Line 1806 of yacc.c  */
-#line 296 "parser.yy"
-    { (yyval.constant) = new ConstantNode( ConstantNode::Character, (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 15:
-
-/* Line 1806 of yacc.c  */
-#line 320 "parser.yy"
-    { (yyval.constant) = new ConstantNode( ConstantNode::String, (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 16:
-
-/* Line 1806 of yacc.c  */
-#line 321 "parser.yy"
-    { (yyval.constant) = (yyvsp[(1) - (2)].constant)->appendstr( (yyvsp[(2) - (2)].tok) ); }
-    break;
-
-  case 17:
-
-/* Line 1806 of yacc.c  */
-#line 328 "parser.yy"
-    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 18:
-
-/* Line 1806 of yacc.c  */
-#line 330 "parser.yy"
-    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 19:
-
-/* Line 1806 of yacc.c  */
-#line 332 "parser.yy"
-    { (yyval.en) = (yyvsp[(1) - (1)].constant); }
-    break;
-
-  case 20:
-
-/* Line 1806 of yacc.c  */
-#line 334 "parser.yy"
-    { (yyval.en) = (yyvsp[(1) - (1)].constant); }
-    break;
-
-  case 21:
-
-/* Line 1806 of yacc.c  */
-#line 336 "parser.yy"
-    { (yyval.en) = (yyvsp[(2) - (3)].en); }
-    break;
-
-  case 22:
-
-/* Line 1806 of yacc.c  */
-#line 338 "parser.yy"
-    { (yyval.en) = new ValofExprNode( (yyvsp[(2) - (3)].sn) ); }
-    break;
-
-  case 24:
-
-/* Line 1806 of yacc.c  */
-#line 348 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Index ), (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ); }
-    break;
-
-  case 25:
-
-/* Line 1806 of yacc.c  */
-#line 350 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 26:
-
-/* Line 1806 of yacc.c  */
-#line 352 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); }
-    break;
-
-  case 28:
-
-/* Line 1806 of yacc.c  */
-#line 355 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); }
-    break;
-
-  case 30:
-
-/* Line 1806 of yacc.c  */
-#line 358 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::IncrPost ), (yyvsp[(1) - (2)].en) ); }
-    break;
-
-  case 31:
-
-/* Line 1806 of yacc.c  */
-#line 360 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), (yyvsp[(1) - (2)].en) ); }
-    break;
-
-  case 32:
-
-/* Line 1806 of yacc.c  */
-#line 363 "parser.yy"
-    { (yyval.en) = 0; }
-    break;
-
-  case 34:
-
-/* Line 1806 of yacc.c  */
-#line 369 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
-    break;
-
-  case 35:
-
-/* Line 1806 of yacc.c  */
-#line 374 "parser.yy"
-    { (yyval.en) = 0; }
-    break;
-
-  case 37:
-
-/* Line 1806 of yacc.c  */
-#line 377 "parser.yy"
-    { (yyval.en) = (yyvsp[(3) - (3)].en)->set_asArgName( (yyvsp[(1) - (3)].tok) ); }
-    break;
-
-  case 38:
-
-/* Line 1806 of yacc.c  */
-#line 382 "parser.yy"
-    { (yyval.en) = (yyvsp[(7) - (7)].en)->set_asArgName( (yyvsp[(3) - (7)].en) ); }
-    break;
-
-  case 39:
-
-/* Line 1806 of yacc.c  */
-#line 384 "parser.yy"
-    { (yyval.en) = (yyvsp[(9) - (9)].en)->set_asArgName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (9)].en)->set_link( flattenCommas( (yyvsp[(5) - (9)].en) )))); }
-    break;
-
-  case 41:
-
-/* Line 1806 of yacc.c  */
-#line 389 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 42:
-
-/* Line 1806 of yacc.c  */
-#line 394 "parser.yy"
-    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 43:
-
-/* Line 1806 of yacc.c  */
-#line 396 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( (yyvsp[(1) - (3)].tok) ), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 44:
-
-/* Line 1806 of yacc.c  */
-#line 398 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en) ); }
-    break;
-
-  case 45:
-
-/* Line 1806 of yacc.c  */
-#line 400 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( (yyvsp[(1) - (3)].tok) ), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 46:
-
-/* Line 1806 of yacc.c  */
-#line 402 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en) ); }
-    break;
-
-  case 48:
-
-/* Line 1806 of yacc.c  */
-#line 408 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Incr ), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 49:
-
-/* Line 1806 of yacc.c  */
-#line 410 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Decr ), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 50:
-
-/* Line 1806 of yacc.c  */
-#line 412 "parser.yy"
-    { (yyval.en) = (yyvsp[(2) - (2)].en); }
-    break;
-
-  case 51:
-
-/* Line 1806 of yacc.c  */
-#line 414 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 52:
-
-/* Line 1806 of yacc.c  */
-#line 416 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Neg ), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 53:
-
-/* Line 1806 of yacc.c  */
-#line 418 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PointTo ), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 54:
-
-/* Line 1806 of yacc.c  */
-#line 424 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 55:
-
-/* Line 1806 of yacc.c  */
-#line 426 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), new TypeValueNode( (yyvsp[(3) - (4)].decl) )); }
-    break;
-
-  case 56:
-
-/* Line 1806 of yacc.c  */
-#line 428 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (1)].tok) )); }
-    break;
-
-  case 57:
-
-/* Line 1806 of yacc.c  */
-#line 430 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), new TypeValueNode( (yyvsp[(3) - (4)].decl) )); }
-    break;
-
-  case 58:
-
-/* Line 1806 of yacc.c  */
-#line 432 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 59:
-
-/* Line 1806 of yacc.c  */
-#line 434 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 60:
-
-/* Line 1806 of yacc.c  */
-#line 436 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), new TypeValueNode( (yyvsp[(3) - (4)].decl) )); }
-    break;
-
-  case 61:
-
-/* Line 1806 of yacc.c  */
-#line 438 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( (yyvsp[(2) - (2)].tok), true )); }
-    break;
-
-  case 62:
-
-/* Line 1806 of yacc.c  */
-#line 442 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::AddressOf ); }
-    break;
-
-  case 63:
-
-/* Line 1806 of yacc.c  */
-#line 443 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::UnPlus ); }
-    break;
-
-  case 64:
-
-/* Line 1806 of yacc.c  */
-#line 444 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::UnMinus ); }
-    break;
-
-  case 65:
-
-/* Line 1806 of yacc.c  */
-#line 445 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::BitNeg ); }
-    break;
-
-  case 67:
-
-/* Line 1806 of yacc.c  */
-#line 451 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ); }
-    break;
-
-  case 68:
-
-/* Line 1806 of yacc.c  */
-#line 453 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ); }
-    break;
-
-  case 70:
-
-/* Line 1806 of yacc.c  */
-#line 459 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Mul ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 71:
-
-/* Line 1806 of yacc.c  */
-#line 461 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Div ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 72:
-
-/* Line 1806 of yacc.c  */
-#line 463 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Mod ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 74:
-
-/* Line 1806 of yacc.c  */
-#line 469 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Plus ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 75:
-
-/* Line 1806 of yacc.c  */
-#line 471 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Minus ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 77:
-
-/* Line 1806 of yacc.c  */
-#line 477 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LShift ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 78:
-
-/* Line 1806 of yacc.c  */
-#line 479 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::RShift ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 80:
-
-/* Line 1806 of yacc.c  */
-#line 485 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 81:
-
-/* Line 1806 of yacc.c  */
-#line 487 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::GThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 82:
-
-/* Line 1806 of yacc.c  */
-#line 489 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LEThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 83:
-
-/* Line 1806 of yacc.c  */
-#line 491 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::GEThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 85:
-
-/* Line 1806 of yacc.c  */
-#line 497 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Eq ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 86:
-
-/* Line 1806 of yacc.c  */
-#line 499 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Neq ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 88:
-
-/* Line 1806 of yacc.c  */
-#line 505 "parser.yy"
-    { (yyval.en) =new CompositeExprNode( new OperatorNode( OperatorNode::BitAnd ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 90:
-
-/* Line 1806 of yacc.c  */
-#line 511 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Xor ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 92:
-
-/* Line 1806 of yacc.c  */
-#line 517 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::BitOr ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 94:
-
-/* Line 1806 of yacc.c  */
-#line 523 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::And ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 96:
-
-/* Line 1806 of yacc.c  */
-#line 529 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Or ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 98:
-
-/* Line 1806 of yacc.c  */
-#line 535 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*(yyvsp[(1) - (5)].en), *(yyvsp[(3) - (5)].en), *(yyvsp[(5) - (5)].en) ) ) ); }
-    break;
-
-  case 99:
-
-/* Line 1806 of yacc.c  */
-#line 537 "parser.yy"
-    { (yyval.en)=new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ); }
-    break;
-
-  case 100:
-
-/* Line 1806 of yacc.c  */
-#line 539 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*(yyvsp[(1) - (5)].en), *(yyvsp[(3) - (5)].en), *(yyvsp[(5) - (5)].en) ) ) ); }
-    break;
-
-  case 103:
-
-/* Line 1806 of yacc.c  */
-#line 550 "parser.yy"
-    { (yyval.en) =new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 104:
-
-/* Line 1806 of yacc.c  */
-#line 552 "parser.yy"
-    { (yyval.en) =new CompositeExprNode( (yyvsp[(2) - (3)].en), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 105:
-
-/* Line 1806 of yacc.c  */
-#line 554 "parser.yy"
-    { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 106:
-
-/* Line 1806 of yacc.c  */
-#line 559 "parser.yy"
-    { (yyval.en) = new NullExprNode; }
-    break;
-
-  case 108:
-
-/* Line 1806 of yacc.c  */
-#line 567 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
-    break;
-
-  case 109:
-
-/* Line 1806 of yacc.c  */
-#line 569 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (yyvsp[(3) - (5)].en) ); }
-    break;
-
-  case 110:
-
-/* Line 1806 of yacc.c  */
-#line 571 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ); }
-    break;
-
-  case 111:
-
-/* Line 1806 of yacc.c  */
-#line 573 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( flattenCommas( (yyvsp[(5) - (7)].en) ) ) ); }
-    break;
-
-  case 113:
-
-/* Line 1806 of yacc.c  */
-#line 579 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 114:
-
-/* Line 1806 of yacc.c  */
-#line 583 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::MulAssn ); }
-    break;
-
-  case 115:
-
-/* Line 1806 of yacc.c  */
-#line 584 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::DivAssn ); }
-    break;
-
-  case 116:
-
-/* Line 1806 of yacc.c  */
-#line 585 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::ModAssn ); }
-    break;
-
-  case 117:
-
-/* Line 1806 of yacc.c  */
-#line 586 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::PlusAssn ); }
-    break;
-
-  case 118:
-
-/* Line 1806 of yacc.c  */
-#line 587 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::MinusAssn ); }
-    break;
-
-  case 119:
-
-/* Line 1806 of yacc.c  */
-#line 588 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::LSAssn ); }
-    break;
-
-  case 120:
-
-/* Line 1806 of yacc.c  */
-#line 589 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::RSAssn ); }
-    break;
-
-  case 121:
-
-/* Line 1806 of yacc.c  */
-#line 590 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::AndAssn ); }
-    break;
-
-  case 122:
-
-/* Line 1806 of yacc.c  */
-#line 591 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::ERAssn ); }
-    break;
-
-  case 123:
-
-/* Line 1806 of yacc.c  */
-#line 592 "parser.yy"
-    { (yyval.en) = new OperatorNode( OperatorNode::OrAssn ); }
-    break;
-
-  case 125:
-
-/* Line 1806 of yacc.c  */
-#line 598 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 126:
-
-/* Line 1806 of yacc.c  */
-#line 603 "parser.yy"
-    { (yyval.en) = 0; }
-    break;
-
-  case 130:
-
-/* Line 1806 of yacc.c  */
-#line 612 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
-    break;
-
-  case 136:
-
-/* Line 1806 of yacc.c  */
-#line 622 "parser.yy"
-    { (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );}
-    break;
-
-  case 137:
-
-/* Line 1806 of yacc.c  */
-#line 627 "parser.yy"
-    { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
-    break;
-
-  case 138:
-
-/* Line 1806 of yacc.c  */
-#line 634 "parser.yy"
-    { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
-    break;
-
-  case 140:
-
-/* Line 1806 of yacc.c  */
-#line 640 "parser.yy"
-    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
-    break;
-
-  case 141:
-
-/* Line 1806 of yacc.c  */
-#line 645 "parser.yy"
-    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
-    break;
-
-  case 142:
-
-/* Line 1806 of yacc.c  */
-#line 647 "parser.yy"
-    { (yyval.sn) = new StatementNode( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 143:
-
-/* Line 1806 of yacc.c  */
-#line 649 "parser.yy"
-    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
-    break;
-
-  case 146:
-
-/* Line 1806 of yacc.c  */
-#line 656 "parser.yy"
-    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
-    break;
-
-  case 147:
-
-/* Line 1806 of yacc.c  */
-#line 661 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); }
-    break;
-
-  case 148:
-
-/* Line 1806 of yacc.c  */
-#line 667 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
-    break;
-
-  case 149:
-
-/* Line 1806 of yacc.c  */
-#line 669 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); }
-    break;
-
-  case 150:
-
-/* Line 1806 of yacc.c  */
-#line 671 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
-    break;
-
-  case 151:
-
-/* Line 1806 of yacc.c  */
-#line 673 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ); /* xxx */ }
-    break;
-
-  case 152:
-
-/* Line 1806 of yacc.c  */
-#line 678 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Choose, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
-    break;
-
-  case 153:
-
-/* Line 1806 of yacc.c  */
-#line 680 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Choose, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ); }
-    break;
-
-  case 154:
-
-/* Line 1806 of yacc.c  */
-#line 687 "parser.yy"
-    { (yyval.en) = (yyvsp[(1) - (1)].en); }
-    break;
-
-  case 155:
-
-/* Line 1806 of yacc.c  */
-#line 689 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 158:
-
-/* Line 1806 of yacc.c  */
-#line 696 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(tupleContents( (yyvsp[(1) - (3)].en) ))->set_link( (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 159:
-
-/* Line 1806 of yacc.c  */
-#line 700 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(2) - (3)].en), 0 ); }
-    break;
-
-  case 160:
-
-/* Line 1806 of yacc.c  */
-#line 701 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Default ); }
-    break;
-
-  case 162:
-
-/* Line 1806 of yacc.c  */
-#line 707 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
-    break;
-
-  case 163:
-
-/* Line 1806 of yacc.c  */
-#line 711 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
-    break;
-
-  case 164:
-
-/* Line 1806 of yacc.c  */
-#line 716 "parser.yy"
-    { (yyval.sn) = 0; }
-    break;
-
-  case 166:
-
-/* Line 1806 of yacc.c  */
-#line 722 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
-    break;
-
-  case 167:
-
-/* Line 1806 of yacc.c  */
-#line 724 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
-    break;
-
-  case 168:
-
-/* Line 1806 of yacc.c  */
-#line 729 "parser.yy"
-    { (yyval.sn) = 0; }
-    break;
-
-  case 170:
-
-/* Line 1806 of yacc.c  */
-#line 735 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
-    break;
-
-  case 171:
-
-/* Line 1806 of yacc.c  */
-#line 737 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case((StatementNode *)mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].sn) ))); }
-    break;
-
-  case 172:
-
-/* Line 1806 of yacc.c  */
-#line 739 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
-    break;
-
-  case 173:
-
-/* Line 1806 of yacc.c  */
-#line 741 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_link( (yyvsp[(2) - (4)].sn)->append_last_case((StatementNode *)mkList((*(yyvsp[(3) - (4)].sn),*(yyvsp[(4) - (4)].sn) ))))); }
-    break;
-
-  case 174:
-
-/* Line 1806 of yacc.c  */
-#line 746 "parser.yy"
-    { (yyval.sn) = 0; }
-    break;
-
-  case 176:
-
-/* Line 1806 of yacc.c  */
-#line 751 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Fallthru, 0, 0 ); }
-    break;
-
-  case 177:
-
-/* Line 1806 of yacc.c  */
-#line 752 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Fallthru, 0, 0 ); }
-    break;
-
-  case 178:
-
-/* Line 1806 of yacc.c  */
-#line 757 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
-    break;
-
-  case 179:
-
-/* Line 1806 of yacc.c  */
-#line 759 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
-    break;
-
-  case 180:
-
-/* Line 1806 of yacc.c  */
-#line 761 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
-    break;
-
-  case 181:
-
-/* Line 1806 of yacc.c  */
-#line 766 "parser.yy"
-    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
-    break;
-
-  case 182:
-
-/* Line 1806 of yacc.c  */
-#line 768 "parser.yy"
-    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
-    break;
-
-  case 183:
-
-/* Line 1806 of yacc.c  */
-#line 773 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
-    break;
-
-  case 184:
-
-/* Line 1806 of yacc.c  */
-#line 777 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 185:
-
-/* Line 1806 of yacc.c  */
-#line 780 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Continue, 0, 0 ); }
-    break;
-
-  case 186:
-
-/* Line 1806 of yacc.c  */
-#line 784 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
-    break;
-
-  case 187:
-
-/* Line 1806 of yacc.c  */
-#line 787 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Break, 0, 0 ); }
-    break;
-
-  case 188:
-
-/* Line 1806 of yacc.c  */
-#line 791 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
-    break;
-
-  case 189:
-
-/* Line 1806 of yacc.c  */
-#line 793 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
-    break;
-
-  case 190:
-
-/* Line 1806 of yacc.c  */
-#line 795 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
-    break;
-
-  case 191:
-
-/* Line 1806 of yacc.c  */
-#line 797 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Throw, 0, 0 ); }
-    break;
-
-  case 192:
-
-/* Line 1806 of yacc.c  */
-#line 802 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
-    break;
-
-  case 193:
-
-/* Line 1806 of yacc.c  */
-#line 804 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
-    break;
-
-  case 194:
-
-/* Line 1806 of yacc.c  */
-#line 806 "parser.yy"
-    {
-			(yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
-			(yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (4)].sn),*(yyvsp[(3) - (4)].pn) ))));
-		}
-    break;
-
-  case 196:
-
-/* Line 1806 of yacc.c  */
-#line 817 "parser.yy"
-    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
-    break;
-
-  case 197:
-
-/* Line 1806 of yacc.c  */
-#line 819 "parser.yy"
-    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
-    break;
-
-  case 198:
-
-/* Line 1806 of yacc.c  */
-#line 824 "parser.yy"
-    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
-    break;
-
-  case 199:
-
-/* Line 1806 of yacc.c  */
-#line 826 "parser.yy"
-    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
-    break;
-
-  case 200:
-
-/* Line 1806 of yacc.c  */
-#line 831 "parser.yy"
-    {
-			(yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
-			std::cout << "Just created a finally node" << std::endl;
-		}
-    break;
-
-  case 202:
-
-/* Line 1806 of yacc.c  */
-#line 845 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) );
-		}
-    break;
-
-  case 203:
-
-/* Line 1806 of yacc.c  */
-#line 850 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 204:
-
-/* Line 1806 of yacc.c  */
-#line 852 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) );
-		}
-    break;
-
-  case 206:
-
-/* Line 1806 of yacc.c  */
-#line 861 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Asm, 0, 0 ); }
-    break;
-
-  case 207:
-
-/* Line 1806 of yacc.c  */
-#line 863 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Asm, 0, 0 ); }
-    break;
-
-  case 208:
-
-/* Line 1806 of yacc.c  */
-#line 865 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Asm, 0, 0 ); }
-    break;
-
-  case 209:
-
-/* Line 1806 of yacc.c  */
-#line 867 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Asm, 0, 0 ); }
-    break;
-
-  case 214:
-
-/* Line 1806 of yacc.c  */
-#line 881 "parser.yy"
-    {}
-    break;
-
-  case 215:
-
-/* Line 1806 of yacc.c  */
-#line 885 "parser.yy"
-    {}
-    break;
-
-  case 217:
-
-/* Line 1806 of yacc.c  */
-#line 893 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 220:
-
-/* Line 1806 of yacc.c  */
-#line 900 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 221:
-
-/* Line 1806 of yacc.c  */
-#line 905 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 224:
-
-/* Line 1806 of yacc.c  */
-#line 912 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 229:
-
-/* Line 1806 of yacc.c  */
-#line 926 "parser.yy"
-    {}
-    break;
-
-  case 230:
-
-/* Line 1806 of yacc.c  */
-#line 927 "parser.yy"
-    {}
-    break;
-
-  case 238:
-
-/* Line 1806 of yacc.c  */
-#line 956 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (2)].decl);
-		}
-    break;
-
-  case 239:
-
-/* Line 1806 of yacc.c  */
-#line 963 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) );
-		}
-    break;
-
-  case 240:
-
-/* Line 1806 of yacc.c  */
-#line 968 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (6)].decl)->appendList( (yyvsp[(1) - (6)].decl)->cloneType( (yyvsp[(5) - (6)].tok) ) );
-		}
-    break;
-
-  case 241:
-
-/* Line 1806 of yacc.c  */
-#line 978 "parser.yy"
-    {
-			typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
-			(yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) );
-		}
-    break;
-
-  case 242:
-
-/* Line 1806 of yacc.c  */
-#line 983 "parser.yy"
-    {
-			typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
-			(yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) );
-		}
-    break;
-
-  case 243:
-
-/* Line 1806 of yacc.c  */
-#line 988 "parser.yy"
-    {
-			typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
-			(yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(1) - (4)].decl) )->addName( (yyvsp[(3) - (4)].tok) );
-		}
-    break;
-
-  case 244:
-
-/* Line 1806 of yacc.c  */
-#line 996 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (1)].decl);
-		}
-    break;
-
-  case 245:
-
-/* Line 1806 of yacc.c  */
-#line 1001 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) );
-		}
-    break;
-
-  case 246:
-
-/* Line 1806 of yacc.c  */
-#line 1006 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) );
-		}
-    break;
-
-  case 247:
-
-/* Line 1806 of yacc.c  */
-#line 1011 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(2) - (3)].decl) );
-		}
-    break;
-
-  case 248:
-
-/* Line 1806 of yacc.c  */
-#line 1016 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneType( (yyvsp[(5) - (5)].tok) ) );
-		}
-    break;
-
-  case 249:
-
-/* Line 1806 of yacc.c  */
-#line 1024 "parser.yy"
-    {
-			typedefTable.setNextIdentifier( *( (yyvsp[(5) - (10)].tok) ) );
-			(yyval.decl) = DeclarationNode::newFunction( (yyvsp[(5) - (10)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(8) - (10)].decl), 0, true );
-		}
-    break;
-
-  case 250:
-
-/* Line 1806 of yacc.c  */
-#line 1029 "parser.yy"
-    {
-			typedefTable.setNextIdentifier( *( (yyvsp[(5) - (10)].tok) ) );
-			(yyval.decl) = DeclarationNode::newFunction( (yyvsp[(5) - (10)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(8) - (10)].decl), 0, true );
-		}
-    break;
-
-  case 251:
-
-/* Line 1806 of yacc.c  */
-#line 1042 "parser.yy"
-    {
-			(yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
-		}
-    break;
-
-  case 252:
-
-/* Line 1806 of yacc.c  */
-#line 1046 "parser.yy"
-    {
-			(yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
-		}
-    break;
-
-  case 253:
-
-/* Line 1806 of yacc.c  */
-#line 1053 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
-    break;
-
-  case 254:
-
-/* Line 1806 of yacc.c  */
-#line 1057 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
-    break;
-
-  case 255:
-
-/* Line 1806 of yacc.c  */
-#line 1062 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			(yyval.decl) = (yyvsp[(2) - (2)].decl)->addTypedef();
-		}
-    break;
-
-  case 256:
-
-/* Line 1806 of yacc.c  */
-#line 1067 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			(yyval.decl) = (yyvsp[(2) - (2)].decl)->addTypedef();
-		}
-    break;
-
-  case 257:
-
-/* Line 1806 of yacc.c  */
-#line 1072 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
-			(yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneType( (yyvsp[(5) - (5)].tok) ) );
-		}
-    break;
-
-  case 258:
-
-/* Line 1806 of yacc.c  */
-#line 1083 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			(yyval.decl) = (yyvsp[(3) - (3)].decl)->addType( (yyvsp[(2) - (3)].decl) )->addTypedef();
-		}
-    break;
-
-  case 259:
-
-/* Line 1806 of yacc.c  */
-#line 1088 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			(yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneBaseType( (yyvsp[(5) - (5)].decl) )->addTypedef() );
-		}
-    break;
-
-  case 260:
-
-/* Line 1806 of yacc.c  */
-#line 1093 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			(yyval.decl) = (yyvsp[(4) - (4)].decl)->addType( (yyvsp[(3) - (4)].decl) )->addQualifiers( (yyvsp[(1) - (4)].decl) )->addTypedef();
-		}
-    break;
-
-  case 261:
-
-/* Line 1806 of yacc.c  */
-#line 1098 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			(yyval.decl) = (yyvsp[(3) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addTypedef();
-		}
-    break;
-
-  case 262:
-
-/* Line 1806 of yacc.c  */
-#line 1103 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			(yyval.decl) = (yyvsp[(4) - (4)].decl)->addQualifiers( (yyvsp[(1) - (4)].decl) )->addTypedef()->addType( (yyvsp[(1) - (4)].decl) );
-		}
-    break;
-
-  case 263:
-
-/* Line 1806 of yacc.c  */
-#line 1112 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
-			(yyval.decl) = DeclarationNode::newName( 0 ); // XXX
-		}
-    break;
-
-  case 264:
-
-/* Line 1806 of yacc.c  */
-#line 1117 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
-			(yyval.decl) = DeclarationNode::newName( 0 ); // XXX
-		}
-    break;
-
-  case 269:
-
-/* Line 1806 of yacc.c  */
-#line 1134 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = ( (yyvsp[(2) - (4)].decl)->addType( (yyvsp[(1) - (4)].decl) ))->addInitializer( (yyvsp[(4) - (4)].in) );
-		}
-    break;
-
-  case 270:
-
-/* Line 1806 of yacc.c  */
-#line 1139 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (6)].decl)->appendList( (yyvsp[(1) - (6)].decl)->cloneBaseType( (yyvsp[(4) - (6)].decl)->addInitializer( (yyvsp[(6) - (6)].in) ) ) );
-		}
-    break;
-
-  case 279:
-
-/* Line 1806 of yacc.c  */
-#line 1161 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 282:
-
-/* Line 1806 of yacc.c  */
-#line 1173 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 284:
-
-/* Line 1806 of yacc.c  */
-#line 1179 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Attribute ); }
-    break;
-
-  case 285:
-
-/* Line 1806 of yacc.c  */
-#line 1184 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
-    break;
-
-  case 286:
-
-/* Line 1806 of yacc.c  */
-#line 1186 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
-    break;
-
-  case 287:
-
-/* Line 1806 of yacc.c  */
-#line 1188 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
-    break;
-
-  case 288:
-
-/* Line 1806 of yacc.c  */
-#line 1190 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
-    break;
-
-  case 289:
-
-/* Line 1806 of yacc.c  */
-#line 1192 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
-    break;
-
-  case 290:
-
-/* Line 1806 of yacc.c  */
-#line 1194 "parser.yy"
-    {
-			typedefTable.enterScope();
-		}
-    break;
-
-  case 291:
-
-/* Line 1806 of yacc.c  */
-#line 1198 "parser.yy"
-    {
-			typedefTable.leaveScope();
-			(yyval.decl) = DeclarationNode::newForall( (yyvsp[(4) - (5)].decl) );
-		}
-    break;
-
-  case 293:
-
-/* Line 1806 of yacc.c  */
-#line 1207 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 294:
-
-/* Line 1806 of yacc.c  */
-#line 1209 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 296:
-
-/* Line 1806 of yacc.c  */
-#line 1220 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 298:
-
-/* Line 1806 of yacc.c  */
-#line 1229 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
-    break;
-
-  case 299:
-
-/* Line 1806 of yacc.c  */
-#line 1231 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
-    break;
-
-  case 300:
-
-/* Line 1806 of yacc.c  */
-#line 1233 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
-    break;
-
-  case 301:
-
-/* Line 1806 of yacc.c  */
-#line 1235 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
-    break;
-
-  case 302:
-
-/* Line 1806 of yacc.c  */
-#line 1237 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
-    break;
-
-  case 303:
-
-/* Line 1806 of yacc.c  */
-#line 1239 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
-    break;
-
-  case 304:
-
-/* Line 1806 of yacc.c  */
-#line 1241 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
-    break;
-
-  case 305:
-
-/* Line 1806 of yacc.c  */
-#line 1243 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
-    break;
-
-  case 306:
-
-/* Line 1806 of yacc.c  */
-#line 1248 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
-    break;
-
-  case 307:
-
-/* Line 1806 of yacc.c  */
-#line 1250 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
-    break;
-
-  case 308:
-
-/* Line 1806 of yacc.c  */
-#line 1252 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
-    break;
-
-  case 309:
-
-/* Line 1806 of yacc.c  */
-#line 1254 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
-    break;
-
-  case 310:
-
-/* Line 1806 of yacc.c  */
-#line 1256 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
-    break;
-
-  case 311:
-
-/* Line 1806 of yacc.c  */
-#line 1258 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
-    break;
-
-  case 312:
-
-/* Line 1806 of yacc.c  */
-#line 1260 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
-    break;
-
-  case 313:
-
-/* Line 1806 of yacc.c  */
-#line 1262 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
-    break;
-
-  case 314:
-
-/* Line 1806 of yacc.c  */
-#line 1264 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
-    break;
-
-  case 315:
-
-/* Line 1806 of yacc.c  */
-#line 1266 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
-    break;
-
-  case 316:
-
-/* Line 1806 of yacc.c  */
-#line 1268 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
-    break;
-
-  case 317:
-
-/* Line 1806 of yacc.c  */
-#line 1270 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
-    break;
-
-  case 319:
-
-/* Line 1806 of yacc.c  */
-#line 1277 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 320:
-
-/* Line 1806 of yacc.c  */
-#line 1279 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 321:
-
-/* Line 1806 of yacc.c  */
-#line 1281 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 322:
-
-/* Line 1806 of yacc.c  */
-#line 1283 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
-    break;
-
-  case 324:
-
-/* Line 1806 of yacc.c  */
-#line 1289 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 326:
-
-/* Line 1806 of yacc.c  */
-#line 1296 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 327:
-
-/* Line 1806 of yacc.c  */
-#line 1298 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 328:
-
-/* Line 1806 of yacc.c  */
-#line 1300 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 329:
-
-/* Line 1806 of yacc.c  */
-#line 1305 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
-    break;
-
-  case 330:
-
-/* Line 1806 of yacc.c  */
-#line 1307 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 331:
-
-/* Line 1806 of yacc.c  */
-#line 1309 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
-    break;
-
-  case 332:
-
-/* Line 1806 of yacc.c  */
-#line 1311 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 334:
-
-/* Line 1806 of yacc.c  */
-#line 1317 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 335:
-
-/* Line 1806 of yacc.c  */
-#line 1319 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 336:
-
-/* Line 1806 of yacc.c  */
-#line 1321 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 338:
-
-/* Line 1806 of yacc.c  */
-#line 1327 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 339:
-
-/* Line 1806 of yacc.c  */
-#line 1329 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 341:
-
-/* Line 1806 of yacc.c  */
-#line 1335 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 342:
-
-/* Line 1806 of yacc.c  */
-#line 1337 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 343:
-
-/* Line 1806 of yacc.c  */
-#line 1339 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 344:
-
-/* Line 1806 of yacc.c  */
-#line 1344 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 345:
-
-/* Line 1806 of yacc.c  */
-#line 1346 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 346:
-
-/* Line 1806 of yacc.c  */
-#line 1348 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 349:
-
-/* Line 1806 of yacc.c  */
-#line 1358 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl) ); }
-    break;
-
-  case 350:
-
-/* Line 1806 of yacc.c  */
-#line 1360 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), 0, 0 ); }
-    break;
-
-  case 351:
-
-/* Line 1806 of yacc.c  */
-#line 1362 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (5)].aggKey), (yyvsp[(2) - (5)].tok), 0, (yyvsp[(4) - (5)].decl) ); }
-    break;
-
-  case 352:
-
-/* Line 1806 of yacc.c  */
-#line 1372 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl) ); }
-    break;
-
-  case 353:
-
-/* Line 1806 of yacc.c  */
-#line 1374 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (5)].aggKey), (yyvsp[(5) - (5)].tok), (yyvsp[(3) - (5)].en), 0 ); }
-    break;
-
-  case 354:
-
-/* Line 1806 of yacc.c  */
-#line 1381 "parser.yy"
-    { (yyval.aggKey) = DeclarationNode::Struct; }
-    break;
-
-  case 355:
-
-/* Line 1806 of yacc.c  */
-#line 1383 "parser.yy"
-    { (yyval.aggKey) = DeclarationNode::Union; }
-    break;
-
-  case 356:
-
-/* Line 1806 of yacc.c  */
-#line 1388 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (1)].decl); }
-    break;
-
-  case 357:
-
-/* Line 1806 of yacc.c  */
-#line 1390 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 359:
-
-/* Line 1806 of yacc.c  */
-#line 1396 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 361:
-
-/* Line 1806 of yacc.c  */
-#line 1399 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 363:
-
-/* Line 1806 of yacc.c  */
-#line 1405 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
-    break;
-
-  case 364:
-
-/* Line 1806 of yacc.c  */
-#line 1407 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
-    break;
-
-  case 365:
-
-/* Line 1806 of yacc.c  */
-#line 1409 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
-    break;
-
-  case 366:
-
-/* Line 1806 of yacc.c  */
-#line 1414 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 367:
-
-/* Line 1806 of yacc.c  */
-#line 1416 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
-    break;
-
-  case 368:
-
-/* Line 1806 of yacc.c  */
-#line 1421 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
-    break;
-
-  case 369:
-
-/* Line 1806 of yacc.c  */
-#line 1423 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
-    break;
-
-  case 370:
-
-/* Line 1806 of yacc.c  */
-#line 1426 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 371:
-
-/* Line 1806 of yacc.c  */
-#line 1429 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 373:
-
-/* Line 1806 of yacc.c  */
-#line 1435 "parser.yy"
-    { (yyval.en) = 0; }
-    break;
-
-  case 374:
-
-/* Line 1806 of yacc.c  */
-#line 1437 "parser.yy"
-    { (yyval.en) = (yyvsp[(1) - (1)].en); }
-    break;
-
-  case 375:
-
-/* Line 1806 of yacc.c  */
-#line 1442 "parser.yy"
-    { (yyval.en) = (yyvsp[(2) - (2)].en); }
-    break;
-
-  case 377:
-
-/* Line 1806 of yacc.c  */
-#line 1451 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
-    break;
-
-  case 378:
-
-/* Line 1806 of yacc.c  */
-#line 1453 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (6)].tok), (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 379:
-
-/* Line 1806 of yacc.c  */
-#line 1455 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (2)].tok), 0 ); }
-    break;
-
-  case 380:
-
-/* Line 1806 of yacc.c  */
-#line 1460 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 381:
-
-/* Line 1806 of yacc.c  */
-#line 1462 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
-    break;
-
-  case 382:
-
-/* Line 1806 of yacc.c  */
-#line 1467 "parser.yy"
-    { (yyval.en) = 0; }
-    break;
-
-  case 383:
-
-/* Line 1806 of yacc.c  */
-#line 1469 "parser.yy"
-    { (yyval.en) = (yyvsp[(2) - (2)].en); }
-    break;
-
-  case 384:
-
-/* Line 1806 of yacc.c  */
-#line 1476 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 388:
-
-/* Line 1806 of yacc.c  */
-#line 1484 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
-    break;
-
-  case 389:
-
-/* Line 1806 of yacc.c  */
-#line 1486 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
-    break;
-
-  case 390:
-
-/* Line 1806 of yacc.c  */
-#line 1488 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
-    break;
-
-  case 392:
-
-/* Line 1806 of yacc.c  */
-#line 1496 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
-    break;
-
-  case 393:
-
-/* Line 1806 of yacc.c  */
-#line 1498 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
-    break;
-
-  case 394:
-
-/* Line 1806 of yacc.c  */
-#line 1500 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
-    break;
-
-  case 396:
-
-/* Line 1806 of yacc.c  */
-#line 1506 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
-    break;
-
-  case 397:
-
-/* Line 1806 of yacc.c  */
-#line 1511 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 400:
-
-/* Line 1806 of yacc.c  */
-#line 1518 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
-    break;
-
-  case 403:
-
-/* Line 1806 of yacc.c  */
-#line 1525 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
-    break;
-
-  case 404:
-
-/* Line 1806 of yacc.c  */
-#line 1527 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
-    break;
-
-  case 406:
-
-/* Line 1806 of yacc.c  */
-#line 1536 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
-    break;
-
-  case 407:
-
-/* Line 1806 of yacc.c  */
-#line 1539 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
-    break;
-
-  case 408:
-
-/* Line 1806 of yacc.c  */
-#line 1541 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
-    break;
-
-  case 413:
-
-/* Line 1806 of yacc.c  */
-#line 1551 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 415:
-
-/* Line 1806 of yacc.c  */
-#line 1557 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(2) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addInitializer( new InitializerNode( (yyvsp[(3) - (3)].en) ) );
-		}
-    break;
-
-  case 416:
-
-/* Line 1806 of yacc.c  */
-#line 1562 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(2) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addInitializer( new InitializerNode( (yyvsp[(3) - (3)].en) ) );
-		}
-    break;
-
-  case 418:
-
-/* Line 1806 of yacc.c  */
-#line 1571 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 419:
-
-/* Line 1806 of yacc.c  */
-#line 1580 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 420:
-
-/* Line 1806 of yacc.c  */
-#line 1582 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
-    break;
-
-  case 432:
-
-/* Line 1806 of yacc.c  */
-#line 1607 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 436:
-
-/* Line 1806 of yacc.c  */
-#line 1615 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 437:
-
-/* Line 1806 of yacc.c  */
-#line 1620 "parser.yy"
-    { (yyval.in) = 0; }
-    break;
-
-  case 438:
-
-/* Line 1806 of yacc.c  */
-#line 1621 "parser.yy"
-    { (yyval.in) = (yyvsp[(2) - (2)].in); }
-    break;
-
-  case 439:
-
-/* Line 1806 of yacc.c  */
-#line 1625 "parser.yy"
-    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
-    break;
-
-  case 440:
-
-/* Line 1806 of yacc.c  */
-#line 1626 "parser.yy"
-    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
-    break;
-
-  case 442:
-
-/* Line 1806 of yacc.c  */
-#line 1631 "parser.yy"
-    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
-    break;
-
-  case 443:
-
-/* Line 1806 of yacc.c  */
-#line 1632 "parser.yy"
-    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
-    break;
-
-  case 444:
-
-/* Line 1806 of yacc.c  */
-#line 1634 "parser.yy"
-    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
-    break;
-
-  case 446:
-
-/* Line 1806 of yacc.c  */
-#line 1650 "parser.yy"
-    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); }
-    break;
-
-  case 448:
-
-/* Line 1806 of yacc.c  */
-#line 1655 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); }
-    break;
-
-  case 449:
-
-/* Line 1806 of yacc.c  */
-#line 1661 "parser.yy"
-    { (yyval.en) = new VarRefNode( (yyvsp[(2) - (2)].tok) ); }
-    break;
-
-  case 450:
-
-/* Line 1806 of yacc.c  */
-#line 1664 "parser.yy"
-    { (yyval.en) = (yyvsp[(3) - (5)].en); }
-    break;
-
-  case 451:
-
-/* Line 1806 of yacc.c  */
-#line 1666 "parser.yy"
-    { (yyval.en) = (yyvsp[(3) - (5)].en); }
-    break;
-
-  case 452:
-
-/* Line 1806 of yacc.c  */
-#line 1668 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ); }
-    break;
-
-  case 453:
-
-/* Line 1806 of yacc.c  */
-#line 1670 "parser.yy"
-    { (yyval.en) = (yyvsp[(4) - (6)].en); }
-    break;
-
-  case 455:
-
-/* Line 1806 of yacc.c  */
-#line 1694 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 456:
-
-/* Line 1806 of yacc.c  */
-#line 1696 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 457:
-
-/* Line 1806 of yacc.c  */
-#line 1698 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 458:
-
-/* Line 1806 of yacc.c  */
-#line 1703 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 459:
-
-/* Line 1806 of yacc.c  */
-#line 1705 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(2) - (5)].tok), (yyvsp[(4) - (5)].en) )->addQualifiers( (yyvsp[(1) - (5)].decl) ); }
-    break;
-
-  case 460:
-
-/* Line 1806 of yacc.c  */
-#line 1707 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 462:
-
-/* Line 1806 of yacc.c  */
-#line 1713 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
-    break;
-
-  case 463:
-
-/* Line 1806 of yacc.c  */
-#line 1718 "parser.yy"
-    { typedefTable.addToEnclosingScope(*( (yyvsp[(2) - (2)].tok) ), TypedefTable::TD ); }
-    break;
-
-  case 464:
-
-/* Line 1806 of yacc.c  */
-#line 1720 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 466:
-
-/* Line 1806 of yacc.c  */
-#line 1726 "parser.yy"
-    { (yyval.tclass) = DeclarationNode::Type; }
-    break;
-
-  case 467:
-
-/* Line 1806 of yacc.c  */
-#line 1728 "parser.yy"
-    { (yyval.tclass) = DeclarationNode::Ftype; }
-    break;
-
-  case 468:
-
-/* Line 1806 of yacc.c  */
-#line 1730 "parser.yy"
-    { (yyval.tclass) = DeclarationNode::Dtype; }
-    break;
-
-  case 469:
-
-/* Line 1806 of yacc.c  */
-#line 1735 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 470:
-
-/* Line 1806 of yacc.c  */
-#line 1737 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl) == 0 ? (yyvsp[(2) - (2)].decl) : (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 471:
-
-/* Line 1806 of yacc.c  */
-#line 1742 "parser.yy"
-    {
-			typedefTable.openContext( *( (yyvsp[(2) - (5)].tok) ) );
-			(yyval.decl) = DeclarationNode::newContextUse( (yyvsp[(2) - (5)].tok), (yyvsp[(4) - (5)].en) );
-		}
-    break;
-
-  case 472:
-
-/* Line 1806 of yacc.c  */
-#line 1747 "parser.yy"
-    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
-    break;
-
-  case 473:
-
-/* Line 1806 of yacc.c  */
-#line 1749 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 474:
-
-/* Line 1806 of yacc.c  */
-#line 1754 "parser.yy"
-    { (yyval.en) = new TypeValueNode( (yyvsp[(1) - (1)].decl) ); }
-    break;
-
-  case 476:
-
-/* Line 1806 of yacc.c  */
-#line 1757 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); }
-    break;
-
-  case 477:
-
-/* Line 1806 of yacc.c  */
-#line 1759 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
-    break;
-
-  case 478:
-
-/* Line 1806 of yacc.c  */
-#line 1764 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
-    break;
-
-  case 479:
-
-/* Line 1806 of yacc.c  */
-#line 1766 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
-    break;
-
-  case 480:
-
-/* Line 1806 of yacc.c  */
-#line 1768 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 481:
-
-/* Line 1806 of yacc.c  */
-#line 1773 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 482:
-
-/* Line 1806 of yacc.c  */
-#line 1775 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 483:
-
-/* Line 1806 of yacc.c  */
-#line 1780 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
-			(yyval.decl) = DeclarationNode::newTypeDecl( (yyvsp[(1) - (1)].tok), 0 );
-		}
-    break;
-
-  case 484:
-
-/* Line 1806 of yacc.c  */
-#line 1785 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
-			(yyval.decl) = DeclarationNode::newTypeDecl( (yyvsp[(1) - (6)].tok), (yyvsp[(4) - (6)].decl) );
-		}
-    break;
-
-  case 485:
-
-/* Line 1806 of yacc.c  */
-#line 1793 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
-			(yyval.decl) = DeclarationNode::newContext( (yyvsp[(2) - (9)].tok), (yyvsp[(5) - (9)].decl), 0 );
-		}
-    break;
-
-  case 486:
-
-/* Line 1806 of yacc.c  */
-#line 1798 "parser.yy"
-    {
-			typedefTable.enterContext( *(yyvsp[(2) - (8)].tok) );
-			typedefTable.enterScope();
-		}
-    break;
-
-  case 487:
-
-/* Line 1806 of yacc.c  */
-#line 1803 "parser.yy"
-    {
-			typedefTable.leaveContext();
-			typedefTable.addToEnclosingScope( *(yyvsp[(2) - (11)].tok), TypedefTable::ID );
-			(yyval.decl) = DeclarationNode::newContext( (yyvsp[(2) - (11)].tok), (yyvsp[(5) - (11)].decl), (yyvsp[(10) - (11)].decl) );
-		}
-    break;
-
-  case 489:
-
-/* Line 1806 of yacc.c  */
-#line 1813 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 492:
-
-/* Line 1806 of yacc.c  */
-#line 1823 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope2( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (1)].decl);
-		}
-    break;
-
-  case 493:
-
-/* Line 1806 of yacc.c  */
-#line 1828 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope2( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (1)].decl);
-		}
-    break;
-
-  case 494:
-
-/* Line 1806 of yacc.c  */
-#line 1833 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneType( (yyvsp[(5) - (5)].tok) ) );
-		}
-    break;
-
-  case 495:
-
-/* Line 1806 of yacc.c  */
-#line 1841 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope2( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) );
-		}
-    break;
-
-  case 496:
-
-/* Line 1806 of yacc.c  */
-#line 1846 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope2( TypedefTable::ID );
-			(yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(1) - (5)].decl)->cloneBaseType( (yyvsp[(5) - (5)].decl) ) );
-		}
-    break;
-
-  case 497:
-
-/* Line 1806 of yacc.c  */
-#line 1856 "parser.yy"
-    {}
-    break;
-
-  case 498:
-
-/* Line 1806 of yacc.c  */
-#line 1858 "parser.yy"
-    {
-			if ( theTree ) {
-				theTree->appendList( (yyvsp[(1) - (1)].decl) );
-			} else {
-				theTree = (yyvsp[(1) - (1)].decl);
-			}
-		}
-    break;
-
-  case 500:
-
-/* Line 1806 of yacc.c  */
-#line 1870 "parser.yy"
-    { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
-    break;
-
-  case 501:
-
-/* Line 1806 of yacc.c  */
-#line 1875 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 505:
-
-/* Line 1806 of yacc.c  */
-#line 1883 "parser.yy"
-    {}
-    break;
-
-  case 506:
-
-/* Line 1806 of yacc.c  */
-#line 1885 "parser.yy"
-    {
-			linkageStack.push( linkage );
-			linkage = LinkageSpec::fromString( *(yyvsp[(2) - (2)].tok) );
-		}
-    break;
-
-  case 507:
-
-/* Line 1806 of yacc.c  */
-#line 1890 "parser.yy"
-    {
-			linkage = linkageStack.top();
-			linkageStack.pop();
-			(yyval.decl) = (yyvsp[(5) - (6)].decl);
-		}
-    break;
-
-  case 508:
-
-/* Line 1806 of yacc.c  */
-#line 1896 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
-    break;
-
-  case 510:
-
-/* Line 1806 of yacc.c  */
-#line 1907 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(1) - (2)].decl)->addFunctionBody( (yyvsp[(2) - (2)].sn) );
-		}
-    break;
-
-  case 511:
-
-/* Line 1806 of yacc.c  */
-#line 1913 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(1) - (4)].decl)->addOldDeclList( (yyvsp[(3) - (4)].decl) )->addFunctionBody( (yyvsp[(4) - (4)].sn) );
-		}
-    break;
-
-  case 512:
-
-/* Line 1806 of yacc.c  */
-#line 1922 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(1) - (2)].decl)->addFunctionBody( (yyvsp[(2) - (2)].sn) );
-		}
-    break;
-
-  case 513:
-
-/* Line 1806 of yacc.c  */
-#line 1928 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addType( (yyvsp[(1) - (3)].decl) );
-		}
-    break;
-
-  case 514:
-
-/* Line 1806 of yacc.c  */
-#line 1934 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
-		}
-    break;
-
-  case 515:
-
-/* Line 1806 of yacc.c  */
-#line 1940 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
-		}
-    break;
-
-  case 516:
-
-/* Line 1806 of yacc.c  */
-#line 1946 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(3) - (4)].decl)->addFunctionBody( (yyvsp[(4) - (4)].sn) )->addQualifiers( (yyvsp[(2) - (4)].decl) )->addQualifiers( (yyvsp[(1) - (4)].decl) );
-		}
-    break;
-
-  case 517:
-
-/* Line 1806 of yacc.c  */
-#line 1954 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(2) - (5)].decl)->addOldDeclList( (yyvsp[(4) - (5)].decl) )->addFunctionBody( (yyvsp[(5) - (5)].sn) )->addType( (yyvsp[(1) - (5)].decl) );
-		}
-    break;
-
-  case 518:
-
-/* Line 1806 of yacc.c  */
-#line 1960 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(2) - (5)].decl)->addOldDeclList( (yyvsp[(4) - (5)].decl) )->addFunctionBody( (yyvsp[(5) - (5)].sn) )->addQualifiers( (yyvsp[(1) - (5)].decl) );
-		}
-    break;
-
-  case 519:
-
-/* Line 1806 of yacc.c  */
-#line 1968 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(2) - (5)].decl)->addOldDeclList( (yyvsp[(4) - (5)].decl) )->addFunctionBody( (yyvsp[(5) - (5)].sn) )->addQualifiers( (yyvsp[(1) - (5)].decl) );
-		}
-    break;
-
-  case 520:
-
-/* Line 1806 of yacc.c  */
-#line 1974 "parser.yy"
-    {
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			(yyval.decl) = (yyvsp[(3) - (6)].decl)->addOldDeclList( (yyvsp[(5) - (6)].decl) )->addFunctionBody( (yyvsp[(6) - (6)].sn) )->addQualifiers( (yyvsp[(2) - (6)].decl) )->addQualifiers( (yyvsp[(1) - (6)].decl) );
-		}
-    break;
-
-  case 524:
-
-/* Line 1806 of yacc.c  */
-#line 1989 "parser.yy"
-    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 537:
-
-/* Line 1806 of yacc.c  */
-#line 2023 "parser.yy"
-    {}
-    break;
-
-  case 538:
-
-/* Line 1806 of yacc.c  */
-#line 2024 "parser.yy"
-    {}
-    break;
-
-  case 539:
-
-/* Line 1806 of yacc.c  */
-#line 2025 "parser.yy"
-    {}
-    break;
-
-  case 540:
-
-/* Line 1806 of yacc.c  */
-#line 2026 "parser.yy"
-    {}
-    break;
-
-  case 545:
-
-/* Line 1806 of yacc.c  */
-#line 2068 "parser.yy"
-    {
-			typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
-			(yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) );
-		}
-    break;
-
-  case 546:
-
-/* Line 1806 of yacc.c  */
-#line 2073 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 547:
-
-/* Line 1806 of yacc.c  */
-#line 2078 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 548:
-
-/* Line 1806 of yacc.c  */
-#line 2080 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 549:
-
-/* Line 1806 of yacc.c  */
-#line 2082 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 550:
-
-/* Line 1806 of yacc.c  */
-#line 2087 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 551:
-
-/* Line 1806 of yacc.c  */
-#line 2089 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 552:
-
-/* Line 1806 of yacc.c  */
-#line 2091 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 553:
-
-/* Line 1806 of yacc.c  */
-#line 2093 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 554:
-
-/* Line 1806 of yacc.c  */
-#line 2098 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 555:
-
-/* Line 1806 of yacc.c  */
-#line 2100 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 559:
-
-/* Line 1806 of yacc.c  */
-#line 2116 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 560:
-
-/* Line 1806 of yacc.c  */
-#line 2118 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 561:
-
-/* Line 1806 of yacc.c  */
-#line 2120 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 562:
-
-/* Line 1806 of yacc.c  */
-#line 2125 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 563:
-
-/* Line 1806 of yacc.c  */
-#line 2127 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 564:
-
-/* Line 1806 of yacc.c  */
-#line 2129 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 565:
-
-/* Line 1806 of yacc.c  */
-#line 2134 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 566:
-
-/* Line 1806 of yacc.c  */
-#line 2136 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 567:
-
-/* Line 1806 of yacc.c  */
-#line 2138 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 571:
-
-/* Line 1806 of yacc.c  */
-#line 2153 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
-    break;
-
-  case 572:
-
-/* Line 1806 of yacc.c  */
-#line 2155 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
-    break;
-
-  case 573:
-
-/* Line 1806 of yacc.c  */
-#line 2157 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 574:
-
-/* Line 1806 of yacc.c  */
-#line 2162 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 575:
-
-/* Line 1806 of yacc.c  */
-#line 2164 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 576:
-
-/* Line 1806 of yacc.c  */
-#line 2166 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 577:
-
-/* Line 1806 of yacc.c  */
-#line 2171 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 578:
-
-/* Line 1806 of yacc.c  */
-#line 2173 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 579:
-
-/* Line 1806 of yacc.c  */
-#line 2175 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 584:
-
-/* Line 1806 of yacc.c  */
-#line 2197 "parser.yy"
-    {
-			typedefTable.setNextIdentifier( *( (yyvsp[(1) - (1)].tok) ) );
-			(yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) );
-		}
-    break;
-
-  case 585:
-
-/* Line 1806 of yacc.c  */
-#line 2202 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 586:
-
-/* Line 1806 of yacc.c  */
-#line 2207 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 587:
-
-/* Line 1806 of yacc.c  */
-#line 2209 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 588:
-
-/* Line 1806 of yacc.c  */
-#line 2211 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 589:
-
-/* Line 1806 of yacc.c  */
-#line 2216 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 590:
-
-/* Line 1806 of yacc.c  */
-#line 2218 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 591:
-
-/* Line 1806 of yacc.c  */
-#line 2220 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 592:
-
-/* Line 1806 of yacc.c  */
-#line 2222 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 593:
-
-/* Line 1806 of yacc.c  */
-#line 2227 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 594:
-
-/* Line 1806 of yacc.c  */
-#line 2229 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 595:
-
-/* Line 1806 of yacc.c  */
-#line 2231 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 600:
-
-/* Line 1806 of yacc.c  */
-#line 2248 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 601:
-
-/* Line 1806 of yacc.c  */
-#line 2250 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 602:
-
-/* Line 1806 of yacc.c  */
-#line 2252 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 603:
-
-/* Line 1806 of yacc.c  */
-#line 2257 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 604:
-
-/* Line 1806 of yacc.c  */
-#line 2259 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 605:
-
-/* Line 1806 of yacc.c  */
-#line 2261 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 606:
-
-/* Line 1806 of yacc.c  */
-#line 2263 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 607:
-
-/* Line 1806 of yacc.c  */
-#line 2268 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 608:
-
-/* Line 1806 of yacc.c  */
-#line 2270 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 609:
-
-/* Line 1806 of yacc.c  */
-#line 2272 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 614:
-
-/* Line 1806 of yacc.c  */
-#line 2310 "parser.yy"
-    {
-			typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
-			(yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) );
-		}
-    break;
-
-  case 615:
-
-/* Line 1806 of yacc.c  */
-#line 2318 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 616:
-
-/* Line 1806 of yacc.c  */
-#line 2320 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 617:
-
-/* Line 1806 of yacc.c  */
-#line 2322 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 618:
-
-/* Line 1806 of yacc.c  */
-#line 2327 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 619:
-
-/* Line 1806 of yacc.c  */
-#line 2329 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 620:
-
-/* Line 1806 of yacc.c  */
-#line 2334 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 621:
-
-/* Line 1806 of yacc.c  */
-#line 2336 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 625:
-
-/* Line 1806 of yacc.c  */
-#line 2356 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
-    break;
-
-  case 626:
-
-/* Line 1806 of yacc.c  */
-#line 2358 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 627:
-
-/* Line 1806 of yacc.c  */
-#line 2360 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 628:
-
-/* Line 1806 of yacc.c  */
-#line 2362 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 629:
-
-/* Line 1806 of yacc.c  */
-#line 2364 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 631:
-
-/* Line 1806 of yacc.c  */
-#line 2370 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 632:
-
-/* Line 1806 of yacc.c  */
-#line 2372 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 633:
-
-/* Line 1806 of yacc.c  */
-#line 2374 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 634:
-
-/* Line 1806 of yacc.c  */
-#line 2379 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
-    break;
-
-  case 635:
-
-/* Line 1806 of yacc.c  */
-#line 2381 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 636:
-
-/* Line 1806 of yacc.c  */
-#line 2383 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 637:
-
-/* Line 1806 of yacc.c  */
-#line 2389 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
-    break;
-
-  case 638:
-
-/* Line 1806 of yacc.c  */
-#line 2391 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(5) - (5)].decl) ); }
-    break;
-
-  case 640:
-
-/* Line 1806 of yacc.c  */
-#line 2397 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
-    break;
-
-  case 641:
-
-/* Line 1806 of yacc.c  */
-#line 2399 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
-    break;
-
-  case 642:
-
-/* Line 1806 of yacc.c  */
-#line 2401 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
-    break;
-
-  case 643:
-
-/* Line 1806 of yacc.c  */
-#line 2403 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
-    break;
-
-  case 647:
-
-/* Line 1806 of yacc.c  */
-#line 2423 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
-    break;
-
-  case 648:
-
-/* Line 1806 of yacc.c  */
-#line 2425 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 649:
-
-/* Line 1806 of yacc.c  */
-#line 2427 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 650:
-
-/* Line 1806 of yacc.c  */
-#line 2429 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 651:
-
-/* Line 1806 of yacc.c  */
-#line 2431 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 653:
-
-/* Line 1806 of yacc.c  */
-#line 2437 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 654:
-
-/* Line 1806 of yacc.c  */
-#line 2439 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 655:
-
-/* Line 1806 of yacc.c  */
-#line 2441 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 656:
-
-/* Line 1806 of yacc.c  */
-#line 2446 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
-    break;
-
-  case 657:
-
-/* Line 1806 of yacc.c  */
-#line 2448 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 658:
-
-/* Line 1806 of yacc.c  */
-#line 2450 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 660:
-
-/* Line 1806 of yacc.c  */
-#line 2457 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 662:
-
-/* Line 1806 of yacc.c  */
-#line 2468 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
-    break;
-
-  case 663:
-
-/* Line 1806 of yacc.c  */
-#line 2471 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
-    break;
-
-  case 664:
-
-/* Line 1806 of yacc.c  */
-#line 2473 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
-    break;
-
-  case 665:
-
-/* Line 1806 of yacc.c  */
-#line 2476 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
-    break;
-
-  case 666:
-
-/* Line 1806 of yacc.c  */
-#line 2478 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
-    break;
-
-  case 667:
-
-/* Line 1806 of yacc.c  */
-#line 2480 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
-    break;
-
-  case 671:
-
-/* Line 1806 of yacc.c  */
-#line 2499 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
-    break;
-
-  case 672:
-
-/* Line 1806 of yacc.c  */
-#line 2501 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 673:
-
-/* Line 1806 of yacc.c  */
-#line 2503 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 674:
-
-/* Line 1806 of yacc.c  */
-#line 2505 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 675:
-
-/* Line 1806 of yacc.c  */
-#line 2507 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 677:
-
-/* Line 1806 of yacc.c  */
-#line 2513 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 678:
-
-/* Line 1806 of yacc.c  */
-#line 2515 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 679:
-
-/* Line 1806 of yacc.c  */
-#line 2517 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 680:
-
-/* Line 1806 of yacc.c  */
-#line 2522 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 681:
-
-/* Line 1806 of yacc.c  */
-#line 2524 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 684:
-
-/* Line 1806 of yacc.c  */
-#line 2534 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 687:
-
-/* Line 1806 of yacc.c  */
-#line 2544 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 688:
-
-/* Line 1806 of yacc.c  */
-#line 2546 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 689:
-
-/* Line 1806 of yacc.c  */
-#line 2548 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 690:
-
-/* Line 1806 of yacc.c  */
-#line 2550 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 691:
-
-/* Line 1806 of yacc.c  */
-#line 2552 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 692:
-
-/* Line 1806 of yacc.c  */
-#line 2554 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 693:
-
-/* Line 1806 of yacc.c  */
-#line 2561 "parser.yy"
-    { (yyval.decl) = (yyvsp[(5) - (5)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 694:
-
-/* Line 1806 of yacc.c  */
-#line 2563 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 695:
-
-/* Line 1806 of yacc.c  */
-#line 2565 "parser.yy"
-    { (yyval.decl) = (yyvsp[(6) - (6)].decl)->addNewArray( (yyvsp[(5) - (6)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 696:
-
-/* Line 1806 of yacc.c  */
-#line 2567 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
-    break;
-
-  case 697:
-
-/* Line 1806 of yacc.c  */
-#line 2569 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 698:
-
-/* Line 1806 of yacc.c  */
-#line 2571 "parser.yy"
-    { (yyval.decl) = (yyvsp[(5) - (5)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 699:
-
-/* Line 1806 of yacc.c  */
-#line 2573 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 700:
-
-/* Line 1806 of yacc.c  */
-#line 2575 "parser.yy"
-    { (yyval.decl) = (yyvsp[(6) - (6)].decl)->addNewArray( (yyvsp[(5) - (6)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 701:
-
-/* Line 1806 of yacc.c  */
-#line 2577 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
-    break;
-
-  case 702:
-
-/* Line 1806 of yacc.c  */
-#line 2579 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 703:
-
-/* Line 1806 of yacc.c  */
-#line 2584 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
-    break;
-
-  case 704:
-
-/* Line 1806 of yacc.c  */
-#line 2586 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
-    break;
-
-  case 705:
-
-/* Line 1806 of yacc.c  */
-#line 2591 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
-    break;
-
-  case 706:
-
-/* Line 1806 of yacc.c  */
-#line 2593 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
-    break;
-
-  case 708:
-
-/* Line 1806 of yacc.c  */
-#line 2620 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 712:
-
-/* Line 1806 of yacc.c  */
-#line 2631 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 713:
-
-/* Line 1806 of yacc.c  */
-#line 2633 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 714:
-
-/* Line 1806 of yacc.c  */
-#line 2635 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 715:
-
-/* Line 1806 of yacc.c  */
-#line 2637 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 716:
-
-/* Line 1806 of yacc.c  */
-#line 2639 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 717:
-
-/* Line 1806 of yacc.c  */
-#line 2641 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 718:
-
-/* Line 1806 of yacc.c  */
-#line 2648 "parser.yy"
-    { (yyval.decl) = (yyvsp[(5) - (5)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 719:
-
-/* Line 1806 of yacc.c  */
-#line 2650 "parser.yy"
-    { (yyval.decl) = (yyvsp[(6) - (6)].decl)->addNewArray( (yyvsp[(5) - (6)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 720:
-
-/* Line 1806 of yacc.c  */
-#line 2652 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 721:
-
-/* Line 1806 of yacc.c  */
-#line 2654 "parser.yy"
-    { (yyval.decl) = (yyvsp[(5) - (5)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 722:
-
-/* Line 1806 of yacc.c  */
-#line 2656 "parser.yy"
-    { (yyval.decl) = (yyvsp[(6) - (6)].decl)->addNewArray( (yyvsp[(5) - (6)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 723:
-
-/* Line 1806 of yacc.c  */
-#line 2658 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 724:
-
-/* Line 1806 of yacc.c  */
-#line 2663 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
-    break;
-
-  case 725:
-
-/* Line 1806 of yacc.c  */
-#line 2668 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (7)].decl), 0 ); }
-    break;
-
-  case 726:
-
-/* Line 1806 of yacc.c  */
-#line 2670 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
-    break;
-
-  case 727:
-
-/* Line 1806 of yacc.c  */
-#line 2672 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
-    break;
-
-  case 730:
-
-/* Line 1806 of yacc.c  */
-#line 2696 "parser.yy"
-    { (yyval.en) = 0; }
-    break;
-
-  case 731:
-
-/* Line 1806 of yacc.c  */
-#line 2698 "parser.yy"
-    { (yyval.en) = (yyvsp[(2) - (2)].en); }
-    break;
-
-
-
-/* Line 1806 of yacc.c  */
-#line 8886 "Parser/parser.cc"
-      default: break;
-    }
-  /* User semantic actions sometimes alter yychar, and that requires
-     that yytoken be updated with the new translation.  We take the
-     approach of translating immediately before every use of yytoken.
-     One alternative is translating here after every semantic action,
-     but that translation would be missed if the semantic action invokes
-     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
-     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
-     incorrect destructor might then be invoked immediately.  In the
-     case of YYERROR or YYBACKUP, subsequent parser actions might lead
-     to an incorrect destructor call or verbose syntax error message
-     before the lookahead is translated.  */
-  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
-
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-
-  *++yyvsp = yyval;
-
-  /* Now `shift' the result of the reduction.  Determine what state
-     that goes to, based on the state we popped back to and the rule
-     number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
-
-  goto yynewstate;
-
-
-/*------------------------------------.
-| yyerrlab -- here on detecting error |
-`------------------------------------*/
-yyerrlab:
-  /* Make sure we have latest lookahead translation.  See comments at
-     user semantic actions for why this is necessary.  */
-  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
-
-  /* If not already recovering from an error, report this error.  */
-  if (!yyerrstatus)
-    {
-      ++yynerrs;
-#if ! YYERROR_VERBOSE
-      yyerror (YY_("syntax error"));
-#else
-# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
-                                        yyssp, yytoken)
-      {
-        char const *yymsgp = YY_("syntax error");
-        int yysyntax_error_status;
-        yysyntax_error_status = YYSYNTAX_ERROR;
-        if (yysyntax_error_status == 0)
-          yymsgp = yymsg;
-        else if (yysyntax_error_status == 1)
-          {
-            if (yymsg != yymsgbuf)
-              YYSTACK_FREE (yymsg);
-            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
-            if (!yymsg)
-              {
-                yymsg = yymsgbuf;
-                yymsg_alloc = sizeof yymsgbuf;
-                yysyntax_error_status = 2;
-              }
-            else
-              {
-                yysyntax_error_status = YYSYNTAX_ERROR;
-                yymsgp = yymsg;
-              }
-          }
-        yyerror (yymsgp);
-        if (yysyntax_error_status == 2)
-          goto yyexhaustedlab;
-      }
-# undef YYSYNTAX_ERROR
-#endif
-    }
-
-
-
-  if (yyerrstatus == 3)
-    {
-      /* If just tried and failed to reuse lookahead token after an
-	 error, discard it.  */
-
-      if (yychar <= YYEOF)
-	{
-	  /* Return failure if at end of input.  */
-	  if (yychar == YYEOF)
-	    YYABORT;
-	}
-      else
-	{
-	  yydestruct ("Error: discarding",
-		      yytoken, &yylval);
-	  yychar = YYEMPTY;
-	}
-    }
-
-  /* Else will try to reuse lookahead token after shifting the error
-     token.  */
-  goto yyerrlab1;
-
-
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR.  |
-`---------------------------------------------------*/
-yyerrorlab:
-
-  /* Pacify compilers like GCC when the user code never invokes
-     YYERROR and the label yyerrorlab therefore never appears in user
-     code.  */
-  if (/*CONSTCOND*/ 0)
-     goto yyerrorlab;
-
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYERROR.  */
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-  yystate = *yyssp;
-  goto yyerrlab1;
-
-
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR.  |
-`-------------------------------------------------------------*/
-yyerrlab1:
-  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
-
-  for (;;)
-    {
-      yyn = yypact[yystate];
-      if (!yypact_value_is_default (yyn))
-	{
-	  yyn += YYTERROR;
-	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
-	    {
-	      yyn = yytable[yyn];
-	      if (0 < yyn)
-		break;
-	    }
-	}
-
-      /* Pop the current state because it cannot handle the error token.  */
-      if (yyssp == yyss)
-	YYABORT;
-
-
-      yydestruct ("Error: popping",
-		  yystos[yystate], yyvsp);
-      YYPOPSTACK (1);
-      yystate = *yyssp;
-      YY_STACK_PRINT (yyss, yyssp);
-    }
-
-  *++yyvsp = yylval;
-
-
-  /* Shift the error token.  */
-  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
-
-  yystate = yyn;
-  goto yynewstate;
-
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here.  |
-`-------------------------------------*/
-yyacceptlab:
-  yyresult = 0;
-  goto yyreturn;
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here.  |
-`-----------------------------------*/
-yyabortlab:
-  yyresult = 1;
-  goto yyreturn;
-
-#if !defined(yyoverflow) || YYERROR_VERBOSE
-/*-------------------------------------------------.
-| yyexhaustedlab -- memory exhaustion comes here.  |
-`-------------------------------------------------*/
-yyexhaustedlab:
-  yyerror (YY_("memory exhausted"));
-  yyresult = 2;
-  /* Fall through.  */
-#endif
-
-yyreturn:
-  if (yychar != YYEMPTY)
-    {
-      /* Make sure we have latest lookahead translation.  See comments at
-         user semantic actions for why this is necessary.  */
-      yytoken = YYTRANSLATE (yychar);
-      yydestruct ("Cleanup: discarding lookahead",
-                  yytoken, &yylval);
-    }
-  /* Do not reclaim the symbols of the rule which action triggered
-     this YYABORT or YYACCEPT.  */
-  YYPOPSTACK (yylen);
-  YY_STACK_PRINT (yyss, yyssp);
-  while (yyssp != yyss)
-    {
-      yydestruct ("Cleanup: popping",
-		  yystos[*yyssp], yyvsp);
-      YYPOPSTACK (1);
-    }
-#ifndef yyoverflow
-  if (yyss != yyssa)
-    YYSTACK_FREE (yyss);
-#endif
-#if YYERROR_VERBOSE
-  if (yymsg != yymsgbuf)
-    YYSTACK_FREE (yymsg);
-#endif
-  /* Make sure YYID is used.  */
-  return YYID (yyresult);
-}
-
-
-
-/* Line 2067 of yacc.c  */
-#line 2701 "parser.yy"
-
-// ----end of grammar----
-
-void yyerror( const char * ) {
-	std::cout << "Error ";
-	if ( yyfilename ) {
-	    std::cout << "in file " << yyfilename << " ";
-	} // if
-	std::cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << std::endl;
-}
-
-// Local Variables: //
-// mode: c++ //
-// tab-width: 4 //
-// compile-command: "make install" //
-// End: //
-
Index: src/Parser/parser.h
===================================================================
--- src/Parser/parser.h	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ 	(revision )
@@ -1,272 +1,0 @@
-/* A Bison parser, made by GNU Bison 2.5.  */
-
-/* Bison interface for Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-   
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-   
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     TYPEDEF = 258,
-     AUTO = 259,
-     EXTERN = 260,
-     REGISTER = 261,
-     STATIC = 262,
-     INLINE = 263,
-     FORTRAN = 264,
-     CONST = 265,
-     VOLATILE = 266,
-     RESTRICT = 267,
-     FORALL = 268,
-     LVALUE = 269,
-     VOID = 270,
-     CHAR = 271,
-     SHORT = 272,
-     INT = 273,
-     LONG = 274,
-     FLOAT = 275,
-     DOUBLE = 276,
-     SIGNED = 277,
-     UNSIGNED = 278,
-     BOOL = 279,
-     COMPLEX = 280,
-     IMAGINARY = 281,
-     TYPEOF = 282,
-     LABEL = 283,
-     ENUM = 284,
-     STRUCT = 285,
-     UNION = 286,
-     TYPE = 287,
-     FTYPE = 288,
-     DTYPE = 289,
-     CONTEXT = 290,
-     SIZEOF = 291,
-     ATTRIBUTE = 292,
-     EXTENSION = 293,
-     IF = 294,
-     ELSE = 295,
-     SWITCH = 296,
-     CASE = 297,
-     DEFAULT = 298,
-     DO = 299,
-     WHILE = 300,
-     FOR = 301,
-     BREAK = 302,
-     CONTINUE = 303,
-     GOTO = 304,
-     RETURN = 305,
-     CHOOSE = 306,
-     FALLTHRU = 307,
-     TRY = 308,
-     CATCH = 309,
-     FINALLY = 310,
-     THROW = 311,
-     ASM = 312,
-     ALIGNAS = 313,
-     ALIGNOF = 314,
-     ATOMIC = 315,
-     GENERIC = 316,
-     NORETURN = 317,
-     STATICASSERT = 318,
-     THREADLOCAL = 319,
-     IDENTIFIER = 320,
-     QUOTED_IDENTIFIER = 321,
-     TYPEDEFname = 322,
-     TYPEGENname = 323,
-     ATTR_IDENTIFIER = 324,
-     ATTR_TYPEDEFname = 325,
-     ATTR_TYPEGENname = 326,
-     INTEGERconstant = 327,
-     FLOATINGconstant = 328,
-     CHARACTERconstant = 329,
-     STRINGliteral = 330,
-     ZERO = 331,
-     ONE = 332,
-     ARROW = 333,
-     ICR = 334,
-     DECR = 335,
-     LS = 336,
-     RS = 337,
-     LE = 338,
-     GE = 339,
-     EQ = 340,
-     NE = 341,
-     ANDAND = 342,
-     OROR = 343,
-     ELLIPSIS = 344,
-     MULTassign = 345,
-     DIVassign = 346,
-     MODassign = 347,
-     PLUSassign = 348,
-     MINUSassign = 349,
-     LSassign = 350,
-     RSassign = 351,
-     ANDassign = 352,
-     ERassign = 353,
-     ORassign = 354,
-     THEN = 355
-   };
-#endif
-/* Tokens.  */
-#define TYPEDEF 258
-#define AUTO 259
-#define EXTERN 260
-#define REGISTER 261
-#define STATIC 262
-#define INLINE 263
-#define FORTRAN 264
-#define CONST 265
-#define VOLATILE 266
-#define RESTRICT 267
-#define FORALL 268
-#define LVALUE 269
-#define VOID 270
-#define CHAR 271
-#define SHORT 272
-#define INT 273
-#define LONG 274
-#define FLOAT 275
-#define DOUBLE 276
-#define SIGNED 277
-#define UNSIGNED 278
-#define BOOL 279
-#define COMPLEX 280
-#define IMAGINARY 281
-#define TYPEOF 282
-#define LABEL 283
-#define ENUM 284
-#define STRUCT 285
-#define UNION 286
-#define TYPE 287
-#define FTYPE 288
-#define DTYPE 289
-#define CONTEXT 290
-#define SIZEOF 291
-#define ATTRIBUTE 292
-#define EXTENSION 293
-#define IF 294
-#define ELSE 295
-#define SWITCH 296
-#define CASE 297
-#define DEFAULT 298
-#define DO 299
-#define WHILE 300
-#define FOR 301
-#define BREAK 302
-#define CONTINUE 303
-#define GOTO 304
-#define RETURN 305
-#define CHOOSE 306
-#define FALLTHRU 307
-#define TRY 308
-#define CATCH 309
-#define FINALLY 310
-#define THROW 311
-#define ASM 312
-#define ALIGNAS 313
-#define ALIGNOF 314
-#define ATOMIC 315
-#define GENERIC 316
-#define NORETURN 317
-#define STATICASSERT 318
-#define THREADLOCAL 319
-#define IDENTIFIER 320
-#define QUOTED_IDENTIFIER 321
-#define TYPEDEFname 322
-#define TYPEGENname 323
-#define ATTR_IDENTIFIER 324
-#define ATTR_TYPEDEFname 325
-#define ATTR_TYPEGENname 326
-#define INTEGERconstant 327
-#define FLOATINGconstant 328
-#define CHARACTERconstant 329
-#define STRINGliteral 330
-#define ZERO 331
-#define ONE 332
-#define ARROW 333
-#define ICR 334
-#define DECR 335
-#define LS 336
-#define RS 337
-#define LE 338
-#define GE 339
-#define EQ 340
-#define NE 341
-#define ANDAND 342
-#define OROR 343
-#define ELLIPSIS 344
-#define MULTassign 345
-#define DIVassign 346
-#define MODassign 347
-#define PLUSassign 348
-#define MINUSassign 349
-#define LSassign 350
-#define RSassign 351
-#define ANDassign 352
-#define ERassign 353
-#define ORassign 354
-#define THEN 355
-
-
-
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-{
-
-/* Line 2068 of yacc.c  */
-#line 107 "parser.yy"
-
-	Token tok;
-	ParseNode *pn;
-	ExpressionNode *en;
-	DeclarationNode *decl;
-	DeclarationNode::Aggregate aggKey;
-	DeclarationNode::TypeClass tclass;
-	StatementNode *sn;
-	ConstantNode *constant;
-	InitializerNode *in;
-
-
-
-/* Line 2068 of yacc.c  */
-#line 264 "Parser/parser.h"
-} YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-extern YYSTYPE yylval;
-
-
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ 	(revision )
@@ -1,2716 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// cfa.y -- 
-// 
-// Author           : Peter A. Buhr
-// Created On       : Sat Sep  1 20:22:55 2001
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 25 22:36:33 2015
-// Update Count     : 1120
-// 
-
-// This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on the C
-// grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS.  While parts have been
-// copied, important changes have been made in all sections; these changes are sufficient to constitute a new grammar.
-// In particular, this grammar attempts to be more syntactically precise, i.e., it parses less incorrect language syntax
-// that must be subsequently rejected by semantic checks.  Nevertheless, there are still several semantic checks
-// required and many are noted in the grammar. Finally, the grammar is extended with GCC and CFA language extensions.
-
-// Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got stuck with
-// the grammar.
-
-// The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for:
-//
-// 1. designation with '=' (use ':' instead)
-//
-// Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This grammar also has
-// two levels of extensions. The first extensions cover most of the GCC C extensions, except for:
-//
-// 1. nested functions
-// 2. generalized lvalues
-// 3. designation with and without '=' (use ':' instead)
-// 4. attributes not allowed in parenthesis of declarator
-//
-// All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall
-// (CFA), which fixes several of C's outstanding problems and extends C with many modern language concepts. All of the
-// syntactic extensions for CFA C are marked with the comment "CFA". As noted above, there is one unreconcileable
-// parsing problem between C99 and CFA with respect to designators; this is discussed in detail before the "designation"
-// grammar rule.
-
-%{
-#define YYDEBUG_LEXER_TEXT (yylval)						// lexer loads this up each time
-#define YYDEBUG 1										// get the pretty debugging code to compile
-extern char *yytext;
-
-#undef __GNUC_MINOR__
-
-#include <cstdio>
-#include <stack>
-#include "TypedefTable.h"
-#include "lex.h"
-#include "ParseNode.h"
-#include "LinkageSpec.h"
-
-DeclarationNode *theTree = 0;							// the resulting parse tree
-LinkageSpec::Type linkage = LinkageSpec::Cforall;
-std::stack< LinkageSpec::Type > linkageStack;
-TypedefTable typedefTable;
-%}
-
-//************************* TERMINAL TOKENS ********************************
-
-// keywords
-%token TYPEDEF
-%token AUTO EXTERN REGISTER STATIC
-%token INLINE											// C99
-%token FORTRAN											// C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
-%token CONST VOLATILE
-%token RESTRICT											// C99
-%token FORALL LVALUE									// CFA
-%token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
-%token BOOL COMPLEX IMAGINARY							// C99
-%token TYPEOF LABEL										// GCC
-%token ENUM STRUCT UNION
-%token TYPE FTYPE DTYPE CONTEXT							// CFA
-%token SIZEOF
-%token ATTRIBUTE EXTENSION								// GCC
-%token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
-%token CHOOSE FALLTHRU TRY CATCH FINALLY THROW			// CFA
-%token ASM												// C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
-%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL // C11
-
-// names and constants: lexer differentiates between identifier and typedef names
-%token<tok> IDENTIFIER			QUOTED_IDENTIFIER		TYPEDEFname				TYPEGENname
-%token<tok> ATTR_IDENTIFIER		ATTR_TYPEDEFname		ATTR_TYPEGENname
-%token<tok> INTEGERconstant		FLOATINGconstant		CHARACTERconstant		STRINGliteral
-%token<tok> ZERO				ONE						// CFA
-
-// multi-character operators
-%token ARROW											// ->
-%token ICR DECR											// ++	--
-%token LS RS											// <<	>>
-%token LE GE EQ NE										// <=	>=	==	!=
-%token ANDAND OROR										// &&	||
-%token ELLIPSIS											// ...
-
-%token MULTassign	DIVassign	MODassign				// *=	/=	%=/
-%token PLUSassign	MINUSassign							// +=	-=
-%token LSassign		RSassign							// <<=	>>=
-%token ANDassign	ERassign	ORassign				// &=	^=	|=
-
-// Types declaration
-%union
-{
-	Token tok;
-	ParseNode *pn;
-	ExpressionNode *en;
-	DeclarationNode *decl;
-	DeclarationNode::Aggregate aggKey;
-	DeclarationNode::TypeClass tclass;
-	StatementNode *sn;
-	ConstantNode *constant;
-	InitializerNode *in;
-}
-
-%type<tok> zero_one  identifier  no_attr_identifier  no_01_identifier
-%type<tok> identifier_or_typedef_name  no_attr_identifier_or_typedef_name  no_01_identifier_or_typedef_name
-%type<constant> string_literal_list
-
-// expressions
-%type<constant> constant
-%type<en> tuple							tuple_expression_list
-%type<en> unary_operator				assignment_operator
-%type<en> primary_expression			postfix_expression			unary_expression
-%type<en> cast_expression				multiplicative_expression	additive_expression			shift_expression
-%type<en> relational_expression			equality_expression			AND_expression				exclusive_OR_expression
-%type<en> inclusive_OR_expression		logical_AND_expression		logical_OR_expression		conditional_expression
-%type<en> constant_expression			assignment_expression		assignment_expression_opt
-%type<en> comma_expression				comma_expression_opt
-%type<en> argument_expression_list		argument_expression			for_control_expression		assignment_opt
-%type<en> subrange
-
-// statements
-%type<sn> labeled_statement				compound_statement			expression_statement		selection_statement
-%type<sn> iteration_statement			jump_statement				exception_statement			asm_statement
-%type<sn> fall_through_opt				fall_through
-%type<sn> statement						statement_list
-%type<sn> block_item_list				block_item
-%type<sn> case_clause
-%type<en> case_value					case_value_list
-%type<sn> case_label					case_label_list
-%type<sn> switch_clause_list_opt		switch_clause_list			choose_clause_list_opt		choose_clause_list
-%type<pn> handler_list					handler_clause				finally_clause
-
-// declarations
-%type<decl> abstract_array abstract_declarator abstract_function abstract_parameter_array
-%type<decl> abstract_parameter_declaration abstract_parameter_declarator abstract_parameter_function
-%type<decl> abstract_parameter_ptr abstract_ptr
-
-%type<aggKey> aggregate_key
-%type<decl>  aggregate_name
-
-%type<decl> array_dimension array_parameter_1st_dimension array_parameter_dimension multi_array_dimension
-
-%type<decl> assertion assertion_list_opt
-
-%type<en>   bit_subrange_size_opt bit_subrange_size
-
-%type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type_name indirect_type_name
-
-%type<decl> context_declaration context_declaration_list context_declaring_list context_specifier
-
-%type<decl> declaration declaration_list declaration_list_opt declaration_qualifier_list
-%type<decl> declaration_specifier declarator declaring_list
-
-%type<decl> elaborated_type_name
-
-%type<decl> enumerator_list enum_name
-%type<en> enumerator_value_opt
-
-%type<decl> exception_declaration external_definition external_definition_list external_definition_list_opt
-
-%type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
-%type<en> field field_list
-
-%type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
-
-%type<decl> identifier_parameter_array identifier_parameter_declarator identifier_parameter_function
-%type<decl> identifier_parameter_ptr identifier_list
-
-%type<decl> new_abstract_array new_abstract_declarator_no_tuple new_abstract_declarator_tuple
-%type<decl> new_abstract_function new_abstract_parameter_declaration new_abstract_parameter_list
-%type<decl> new_abstract_ptr new_abstract_tuple
-
-%type<decl> new_array_parameter_1st_dimension
-
-%type<decl> new_context_declaring_list new_declaration new_field_declaring_list
-%type<decl> new_function_declaration new_function_return new_function_specifier
-
-%type<decl> new_identifier_parameter_array new_identifier_parameter_declarator_no_tuple
-%type<decl> new_identifier_parameter_declarator_tuple new_identifier_parameter_ptr
-
-%type<decl> new_parameter_declaration new_parameter_list new_parameter_type_list new_parameter_type_list_opt
-
-%type<decl> new_typedef_declaration new_variable_declaration new_variable_specifier
-
-%type<decl> old_declaration old_declaration_list old_declaration_list_opt old_function_array
-%type<decl> old_function_declarator old_function_no_ptr old_function_ptr
-
-%type<decl> parameter_declaration parameter_list parameter_type_list
-%type<decl> parameter_type_list_opt
-
-%type<decl> paren_identifier paren_typedef
-
-%type<decl> storage_class storage_class_name storage_class_list
-
-%type<decl> sue_declaration_specifier sue_type_specifier
-
-%type<tclass> type_class
-%type<decl> type_declarator type_declarator_name type_declaring_list
-
-%type<decl> typedef typedef_array typedef_declaration typedef_declaration_specifier typedef_expression
-%type<decl> typedef_function typedef_parameter_array typedef_parameter_function typedef_parameter_ptr
-%type<decl> typedef_parameter_redeclarator typedef_ptr typedef_redeclarator typedef_type_specifier
-%type<decl> typegen_declaration_specifier typegen_type_specifier
-
-%type<decl> type_name type_name_no_function
-%type<decl> type_parameter type_parameter_list
-
-%type<en> type_name_list
-
-%type<decl> type_qualifier type_qualifier_name type_qualifier_list type_qualifier_list_opt type_specifier
-
-%type<decl> variable_abstract_array variable_abstract_declarator variable_abstract_function
-%type<decl> variable_abstract_ptr variable_array variable_declarator variable_function variable_ptr
-
-// initializers
-%type<in>  initializer initializer_list initializer_opt
-
-// designators
-%type<en>  designator designator_list designation
-
-
-// Handle single shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string
-// is ambiguous:
-// .---------.				matches IF '(' comma_expression ')' statement
-// if ( C ) S1 else S2
-// `-----------------'		matches IF '(' comma_expression ')' statement ELSE statement */
-
-%nonassoc THEN	// rule precedence for IF '(' comma_expression ')' statement
-%nonassoc ELSE	// token precedence for start of else clause in IF statement
-
-%start translation_unit									// parse-tree root
-
-%%
-//************************* Namespace Management ********************************
-
-// The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal symbols
-// "identifier" and "TYPEDEFname" that are lexically identical.  While it is possible to write a purely context-free
-// grammar, such a grammar would obscure the relationship between syntactic and semantic constructs.  Hence, this
-// grammar uses the ANSI style.
-//
-// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, those
-// introduced through "forall" qualifiers), and by introducing "type generators" -- parametrized types.  This latter
-// type name creates a third class of identifiers that must be distinguished by the scanner.
-//
-// Since the scanner cannot distinguish among the different classes of identifiers without some context information, it
-// accesses a data structure (the TypedefTable) to allow classification of an identifier that it has just read.
-// Semantic actions during the parser update this data structure when the class of identifiers change.
-//
-// Because the Cforall language is block-scoped, there is the possibility that an identifier can change its class in a
-// local scope; it must revert to its original class at the end of the block.  Since type names can be local to a
-// particular declaration, each declaration is itself a scope.  This requires distinguishing between type names that are
-// local to the current declaration scope and those that persist past the end of the declaration (i.e., names defined in
-// "typedef" or "type" declarations).
-//
-// The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and closing of
-// scopes.  Every push must have a matching pop, although it is regrettable the matching pairs do not always occur
-// within the same rule.  These non-terminals may appear in more contexts than strictly necessary from a semantic point
-// of view.  Unfortunately, these extra rules are necessary to prevent parsing conflicts -- the parser may not have
-// enough context and look-ahead information to decide whether a new scope is necessary, so the effect of these extra
-// rules is to open a new scope unconditionally.  As the grammar evolves, it may be neccesary to add or move around
-// "push" and "pop" nonterminals to resolve conflicts of this sort.
-
-push:
-		{
-			typedefTable.enterScope();
-		}
-	;
-
-pop:
-		{
-			typedefTable.leaveScope();
-		}
-	;
-
-//************************* CONSTANTS ********************************
-
-constant:
-		// ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
-	INTEGERconstant								{ $$ = new ConstantNode( ConstantNode::Integer, $1 ); }
-	| FLOATINGconstant							{ $$ = new ConstantNode( ConstantNode::Float, $1 ); }
-	| CHARACTERconstant							{ $$ = new ConstantNode( ConstantNode::Character, $1 ); }
-	;
-
-identifier:
-	IDENTIFIER
-	| ATTR_IDENTIFIER									// CFA
-	| zero_one											// CFA
-	;
-
-no_01_identifier:
-	IDENTIFIER
-	| ATTR_IDENTIFIER									// CFA
-	;
-
-no_attr_identifier:
-	IDENTIFIER
-	;
-
-zero_one:												// CFA
-	ZERO
-	| ONE
-	;
-
-string_literal_list:									// juxtaposed strings are concatenated
-	STRINGliteral								{ $$ = new ConstantNode( ConstantNode::String, $1 ); }
-	| string_literal_list STRINGliteral			{ $$ = $1->appendstr( $2 ); }
-	;
-
-//************************* EXPRESSIONS ********************************
-
-primary_expression:
-	IDENTIFIER											// typedef name cannot be used as a variable name
-		{ $$ = new VarRefNode( $1 ); }
-	| zero_one
-		{ $$ = new VarRefNode( $1 ); }
-	| constant
-		{ $$ = $1; }
-	| string_literal_list
-		{ $$ = $1; }
-	| '(' comma_expression ')'
-		{ $$ = $2; }
-	| '(' compound_statement ')'						// GCC, lambda expression
-		{ $$ = new ValofExprNode( $2 ); }
-	;
-
-postfix_expression:
-	primary_expression
-	| postfix_expression '[' push assignment_expression pop ']'
-		// CFA, comma_expression disallowed in the context because it results in a commom user error: subscripting a
-		// matrix with x[i,j] instead of x[i][j]. While this change is not backwards compatible, there seems to be
-		// little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
-		// equivalent to the old x[i,j].
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Index ), $1, $4 ); }
-	| postfix_expression '(' argument_expression_list ')'
-		{ $$ = new CompositeExprNode( $1, $3 ); }
-	| postfix_expression '.' no_attr_identifier
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), $1, new VarRefNode( $3 )); }
-	| postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
-	| postfix_expression ARROW no_attr_identifier
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), $1, new VarRefNode( $3 )); }
-	| postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
-	| postfix_expression ICR
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::IncrPost ), $1 ); }
-	| postfix_expression DECR
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), $1 ); }
-		// GCC has priority: cast_expression
-	| '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
-		{ $$ = 0; }
-	;
-
-argument_expression_list:
-	argument_expression
-	| argument_expression_list ',' argument_expression
-		{ $$ = (ExpressionNode *)( $1->set_link( $3 )); }
-	;
-
-argument_expression:
-	// empty
-		{ $$ = 0; }										// use default argument
-	| assignment_expression
-	| no_attr_identifier ':' assignment_expression
-		{ $$ = $3->set_asArgName( $1 ); }
-		// Only a list of no_attr_identifier_or_typedef_name is allowed in this context. However, there is insufficient
-		// look ahead to distinguish between this list of parameter names and a tuple, so the tuple form must be used
-		// with an appropriate semantic check.
-	| '[' push assignment_expression pop ']' ':' assignment_expression
-		{ $$ = $7->set_asArgName( $3 ); }
-	| '[' push assignment_expression ',' tuple_expression_list pop ']' ':' assignment_expression
-		{ $$ = $9->set_asArgName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 )))); }
-	;
-
-field_list:												// CFA, tuple field selector
-	field
-	| field_list ',' field						{ $$ = (ExpressionNode *)$1->set_link( $3 ); }
-	;
-
-field:													// CFA, tuple field selector
-	no_attr_identifier
-		{ $$ = new VarRefNode( $1 ); }
-	| no_attr_identifier '.' field
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( $1 ), $3 ); }
-	| no_attr_identifier '.' '[' push field_list pop ']'
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( $1 ), $5 ); }
-	| no_attr_identifier ARROW field
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( $1 ), $3 ); }
-	| no_attr_identifier ARROW '[' push field_list pop ']'
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( $1 ), $5 ); }
-	;
-
-unary_expression:
-	postfix_expression
-	| ICR unary_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Incr ), $2 ); }
-	| DECR unary_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Decr ), $2 ); }
-	| EXTENSION cast_expression							// GCC
-		{ $$ = $2; }
-	| unary_operator cast_expression
-		{ $$ = new CompositeExprNode( $1, $2 ); }
-	| '!' cast_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Neg ), $2 ); }
-	| '*' cast_expression								// CFA
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::PointTo ), $2 ); }
-		// '*' is is separated from unary_operator because of shift/reduce conflict in:
-		//		{ * X; } // dereference X
-		//		{ * int X; } // CFA declaration of pointer to int
-		// '&' must be moved here if C++ reference variables are supported.
-	| SIZEOF unary_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), $2 ); }
-	| SIZEOF '(' type_name_no_function ')'
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), new TypeValueNode( $3 )); }
-	| ATTR_IDENTIFIER
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 )); }
-	| ATTR_IDENTIFIER '(' type_name ')'
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), new TypeValueNode( $3 )); }
-	| ATTR_IDENTIFIER '(' argument_expression ')'
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), $3 ); }
-	| ALIGNOF unary_expression							// GCC, variable alignment
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), $2 ); }
-	| ALIGNOF '(' type_name_no_function ')'				// GCC, type alignment
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), new TypeValueNode( $3 )); }
-	| ANDAND no_attr_identifier							// GCC, address of label
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true )); }
-	;
-
-unary_operator:
-	'&'											{ $$ = new OperatorNode( OperatorNode::AddressOf ); }
-	| '+'										{ $$ = new OperatorNode( OperatorNode::UnPlus ); }
-	| '-'										{ $$ = new OperatorNode( OperatorNode::UnMinus ); }
-	| '~'										{ $$ = new OperatorNode( OperatorNode::BitNeg ); }
-	;
-
-cast_expression:
-	unary_expression
-	| '(' type_name_no_function ')' cast_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( $2 ), $4 ); }
-	| '(' type_name_no_function ')' tuple
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( $2 ), $4 ); }
-	;
-
-multiplicative_expression:
-	cast_expression
-	| multiplicative_expression '*' cast_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Mul ), $1, $3 ); }
-	| multiplicative_expression '/' cast_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Div ), $1, $3 ); }
-	| multiplicative_expression '%' cast_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Mod ), $1, $3 ); }
-	;
-
-additive_expression:
-	multiplicative_expression
-	| additive_expression '+' multiplicative_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Plus ), $1, $3 ); }
-	| additive_expression '-' multiplicative_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Minus ), $1, $3 ); }
-	;
-
-shift_expression:
-	additive_expression
-	| shift_expression LS additive_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LShift ), $1, $3 ); }
-	| shift_expression RS additive_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::RShift ), $1, $3 ); }
-	;
-
-relational_expression:
-	shift_expression
-	| relational_expression '<' shift_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LThan ), $1, $3 ); }
-	| relational_expression '>' shift_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::GThan ), $1, $3 ); }
-	| relational_expression LE shift_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LEThan ), $1, $3 ); }
-	| relational_expression GE shift_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::GEThan ), $1, $3 ); }
-	;
-
-equality_expression:
-	relational_expression
-	| equality_expression EQ relational_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Eq ), $1, $3 ); }
-	| equality_expression NE relational_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Neq ), $1, $3 ); }
-	;
-
-AND_expression:
-	equality_expression
-	| AND_expression '&' equality_expression
-		{ $$ =new CompositeExprNode( new OperatorNode( OperatorNode::BitAnd ), $1, $3 ); }
-	;
-
-exclusive_OR_expression:
-	AND_expression
-	| exclusive_OR_expression '^' AND_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Xor ), $1, $3 ); }
-	;
-
-inclusive_OR_expression:
-	exclusive_OR_expression
-	| inclusive_OR_expression '|' exclusive_OR_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::BitOr ), $1, $3 ); }
-	;
-
-logical_AND_expression:
-	inclusive_OR_expression
-	| logical_AND_expression ANDAND inclusive_OR_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::And ), $1, $3 ); }
-	;
-
-logical_OR_expression:
-	logical_AND_expression
-	| logical_OR_expression OROR logical_AND_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Or ), $1, $3 ); }
-	;
-
-conditional_expression:
-	logical_OR_expression
-	| logical_OR_expression '?' comma_expression ':' conditional_expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*$1, *$3, *$5 ) ) ); }
-	| logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
-		{ $$=new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), $1, $4 ); }
-	| logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*$1, *$3, *$5 ) ) ); }
-	;
-
-constant_expression:
-	conditional_expression
-	;
-
-assignment_expression:
-		// CFA, assignment is separated from assignment_operator to ensure no assignment operations for tuples
-	conditional_expression
-	| unary_expression '=' assignment_expression
-		{ $$ =new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $3 ); }
-	| unary_expression assignment_operator assignment_expression
-		{ $$ =new CompositeExprNode( $2, $1, $3 ); }
-	| tuple assignment_opt								// CFA, tuple expression
-		{ $$ = ( $2 == 0 ) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); }
-	;
-
-assignment_expression_opt:
-	// empty
-		{ $$ = new NullExprNode; }
-	| assignment_expression
-	;
-
-tuple:													// CFA, tuple
-		// CFA, one assignment_expression is factored out of comma_expression to eliminate a shift/reduce conflict with
-		// comma_expression in new_identifier_parameter_array and new_abstract_array
-	'[' push pop ']'
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
-	| '[' push assignment_expression pop ']'
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), $3 ); }
-	| '[' push ',' tuple_expression_list pop ']'
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( $4 ) ); }
-	| '[' push assignment_expression ',' tuple_expression_list pop ']'
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 ) ) ); }
-	;
-
-tuple_expression_list:
-	assignment_expression_opt
-	| tuple_expression_list ',' assignment_expression_opt
-		{ $$ = (ExpressionNode *)$1->set_link( $3 ); }
-	;
-
-assignment_operator:
-	MULTassign									{ $$ = new OperatorNode( OperatorNode::MulAssn ); }
-	| DIVassign									{ $$ = new OperatorNode( OperatorNode::DivAssn ); }
-	| MODassign									{ $$ = new OperatorNode( OperatorNode::ModAssn ); }
-	| PLUSassign								{ $$ = new OperatorNode( OperatorNode::PlusAssn ); }
-	| MINUSassign								{ $$ = new OperatorNode( OperatorNode::MinusAssn ); }
-	| LSassign									{ $$ = new OperatorNode( OperatorNode::LSAssn ); }
-	| RSassign									{ $$ = new OperatorNode( OperatorNode::RSAssn ); }
-	| ANDassign									{ $$ = new OperatorNode( OperatorNode::AndAssn ); }
-	| ERassign									{ $$ = new OperatorNode( OperatorNode::ERAssn ); }
-	| ORassign									{ $$ = new OperatorNode( OperatorNode::OrAssn ); }
-	;
-
-comma_expression:
-	assignment_expression
-	| comma_expression ',' assignment_expression	// { $$ = (ExpressionNode *)$1->add_to_list( $3 ); }
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), $1, $3 ); }
-	;
-
-comma_expression_opt:
-	// empty
-		{ $$ = 0; }
-	| comma_expression
-	;
-
-//*************************** STATEMENTS *******************************
-
-statement:
-	labeled_statement
-	| compound_statement
-	| expression_statement						{ $$ = $1; }
-	| selection_statement
-	| iteration_statement
-	| jump_statement
-	| exception_statement
-	| asm_statement
-	;
-
-labeled_statement:
-	no_attr_identifier ':' attribute_list_opt statement
-		{ $$ = $4->add_label( $1 );}
-	;
-
-compound_statement:
-	'{' '}'
-		{ $$ = new CompoundStmtNode( (StatementNode *)0 ); }
-	| '{'
-		// Two scopes are necessary because the block itself has a scope, but every declaration within the block also
-		// requires its own scope
-	  push push
-	  label_declaration_opt								// GCC, local labels
-	  block_item_list pop '}'							// C99, intermix declarations and statements
-		{ $$ = new CompoundStmtNode( $5 ); }
-	;
-
-block_item_list:										// C99
-	block_item
-	| block_item_list push block_item
-		{ if ( $1 != 0 ) { $1->set_link( $3 ); $$ = $1; } }
-	;
-
-block_item:
-	declaration											// CFA, new & old style declarations
-		{ $$ = new StatementNode( $1 ); }
-	| EXTENSION declaration								// GCC
-		{ $$ = new StatementNode( $2 ); }
-	| function_definition
-		{ $$ = new StatementNode( $1 ); }
-	| statement pop
-	;
-
-statement_list:
-	statement
-	| statement_list statement
-		{ if ( $1 != 0 ) { $1->set_link( $2 ); $$ = $1; } }
-	;
-
-expression_statement:
-	comma_expression_opt ';'
-		{ $$ = new StatementNode( StatementNode::Exp, $1, 0 ); }
-	;
-
-selection_statement:
-	IF '(' comma_expression ')' statement				%prec THEN
-		// explicitly deal with the shift/reduce conflict on if/else
-		{ $$ = new StatementNode( StatementNode::If, $3, $5 ); }
-	| IF '(' comma_expression ')' statement ELSE statement
-		{ $$ = new StatementNode( StatementNode::If, $3, (StatementNode *)mkList((*$5, *$7 )) ); }
-	| SWITCH '(' comma_expression ')' case_clause		// CFA
-		{ $$ = new StatementNode( StatementNode::Switch, $3, $5 ); }
-	| SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
-		{ $$ = new StatementNode( StatementNode::Switch, $3, $8 ); /* xxx */ }
-		// The semantics of the declaration list is changed to include any associated initialization, which is performed
-		// *before* the transfer to the appropriate case clause.  Statements after the initial declaration list can
-		// never be executed, and therefore, are removed from the grammar even though C allows it.
-	| CHOOSE '(' comma_expression ')' case_clause		// CFA
-		{ $$ = new StatementNode( StatementNode::Choose, $3, $5 ); }
-	| CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' // CFA
-		{ $$ = new StatementNode( StatementNode::Choose, $3, $8 ); }
-	;
-
-// CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a case
-// clause allows a list of values and subranges.
-
-case_value:												// CFA
-	constant_expression							{ $$ = $1; }
-	| constant_expression ELLIPSIS constant_expression	// GCC, subrange
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), $1, $3 ); }
-	| subrange											// CFA, subrange
-	;
-
-case_value_list:										// CFA
-	case_value
-	| case_value_list ',' case_value
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(tupleContents( $1 ))->set_link( $3 ) ); }
-	;
-
-case_label:												// CFA
-	CASE case_value_list ':'					{ $$ = new StatementNode( StatementNode::Case, $2, 0 ); }
-	| DEFAULT ':'								{ $$ = new StatementNode( StatementNode::Default ); }
-		// A semantic check is required to ensure only one default clause per switch/choose statement.
-	;
-
-case_label_list:										// CFA
-	case_label
-	| case_label_list case_label				{ $$ = (StatementNode *)( $1->set_link( $2 )); }
-	;
-
-case_clause:											// CFA
-	case_label_list statement					{ $$ = $1->append_last_case( $2 ); }
-	;
-
-switch_clause_list_opt:									// CFA
-	// empty
-		{ $$ = 0; }
-	| switch_clause_list
-	;
-
-switch_clause_list:										// CFA
-	case_label_list statement_list
-		{ $$ = $1->append_last_case( $2 ); }
-	| switch_clause_list case_label_list statement_list
-		{ $$ = (StatementNode *)( $1->set_link( $2->append_last_case( $3 ))); }
-	;
-
-choose_clause_list_opt:									// CFA
-	// empty
-		{ $$ = 0; }
-	| choose_clause_list
-	;
-
-choose_clause_list:										// CFA
-	case_label_list fall_through
-		{ $$ = $1->append_last_case( $2 ); }
-	| case_label_list statement_list fall_through_opt
-		{ $$ = $1->append_last_case((StatementNode *)mkList((*$2,*$3 ))); }
-	| choose_clause_list case_label_list fall_through
-		{ $$ = (StatementNode *)( $1->set_link( $2->append_last_case( $3 ))); }
-	| choose_clause_list case_label_list statement_list fall_through_opt
-		{ $$ = (StatementNode *)( $1->set_link( $2->append_last_case((StatementNode *)mkList((*$3,*$4 ))))); }
-	;
-
-fall_through_opt:										// CFA
-	// empty
-		{ $$ = 0; }
-	| fall_through
-	;
-
-fall_through:											// CFA
-	FALLTHRU									{ $$ = new StatementNode( StatementNode::Fallthru, 0, 0 ); }
-	| FALLTHRU ';'								{ $$ = new StatementNode( StatementNode::Fallthru, 0, 0 ); }
-	;
-
-iteration_statement:
-	WHILE '(' comma_expression ')' statement
-		{ $$ = new StatementNode( StatementNode::While, $3, $5 ); }
-	| DO statement WHILE '(' comma_expression ')' ';'
-		{ $$ = new StatementNode( StatementNode::Do, $5, $2 ); }
-	| FOR '(' push for_control_expression ')' statement
-		{ $$ = new StatementNode( StatementNode::For, $4, $6 ); }
-	;
-
-for_control_expression:
-	comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt
-		{ $$ = new ForCtlExprNode( $1, $4, $6 ); }
-	| declaration comma_expression_opt ';' comma_expression_opt // C99
-		{ $$ = new ForCtlExprNode( $1, $2, $4 ); }
-	;
-
-jump_statement:
-	GOTO no_attr_identifier ';'
-		{ $$ = new StatementNode( StatementNode::Goto, $2 ); }
-	| GOTO '*' comma_expression ';'						// GCC, computed goto
-		// The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => goto *(i+3 );
-		// whereas normal operator precedence yields goto (*i)+3;
-		{ $$ = new StatementNode( StatementNode::Goto, $3 ); }
-	| CONTINUE ';'
-		// A semantic check is required to ensure this statement appears only in the body of an iteration statement.
-		{ $$ = new StatementNode( StatementNode::Continue, 0, 0 ); }
-	| CONTINUE no_attr_identifier ';'					// CFA, multi-level continue
-		// A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
-		// the target of the transfer appears only at the start of an iteration statement.
-		{ $$ = new StatementNode( StatementNode::Continue, $2 ); }
-	| BREAK ';'
-		// A semantic check is required to ensure this statement appears only in the body of an iteration statement.
-		{ $$ = new StatementNode( StatementNode::Break, 0, 0 ); }
-	| BREAK no_attr_identifier ';'						// CFA, multi-level exit
-		// A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
-		// the target of the transfer appears only at the start of an iteration statement.
-		{ $$ = new StatementNode( StatementNode::Break, $2 ); }
-	| RETURN comma_expression_opt ';'
-		{ $$ = new StatementNode( StatementNode::Return, $2, 0 ); }
-	| THROW assignment_expression ';'
-		{ $$ = new StatementNode( StatementNode::Throw, $2, 0 ); }
-	| THROW ';'
-		{ $$ = new StatementNode( StatementNode::Throw, 0, 0 ); }
-	;
-
-exception_statement:
-	TRY compound_statement handler_list
-		{ $$ = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3 )))); }
-	| TRY compound_statement finally_clause
-		{ $$ = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3 )))); }
-	| TRY compound_statement handler_list finally_clause
-		{
-			$3->set_link( $4 );
-			$$ = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3 ))));
-		}
-	;
-
-handler_list:
-		// There must be at least one catch clause
-	handler_clause
-		// ISO/IEC 9899:1999 Section 15.3(6 ) If present, a "..." handler shall be the last handler for its try block.
-	| CATCH '(' ELLIPSIS ')' compound_statement
-		{ $$ = StatementNode::newCatchStmt( 0, $5, true ); }
-	| handler_clause CATCH '(' ELLIPSIS ')' compound_statement
-		{ $$ = $1->set_link( StatementNode::newCatchStmt( 0, $6, true ) ); }
-	;
-
-handler_clause:
-	CATCH '(' push push exception_declaration pop ')' compound_statement pop
-		{ $$ = StatementNode::newCatchStmt( $5, $8 ); }
-	| handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop
-		{ $$ = $1->set_link( StatementNode::newCatchStmt( $6, $9 ) ); }
-	;
-
-finally_clause:
-	FINALLY compound_statement
-		{
-			$$ = new StatementNode( StatementNode::Finally, 0, $2 );
-			std::cout << "Just created a finally node" << std::endl;
-		}
-	;
-
-exception_declaration:
-		// A semantic check is required to ensure type_specifier does not create a new type, e.g.:
-		//
-		//		catch ( struct { int i; } x ) ...
-		//
-		// This new type cannot catch any thrown type because of name equivalence among types.
-	type_specifier
-	| type_specifier declarator
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $2->addType( $1 );
-		}
-	| type_specifier variable_abstract_declarator
-		{ $$ = $2->addType( $1 ); }
-	| new_abstract_declarator_tuple no_attr_identifier	// CFA
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $1->addName( $2 );
-		}
-	| new_abstract_declarator_tuple						// CFA
-	;
-
-asm_statement:
-	ASM type_qualifier_list_opt '(' constant_expression ')' ';'
-		{ $$ = new StatementNode( StatementNode::Asm, 0, 0 ); }
-	| ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ')' ';' // remaining GCC
-		{ $$ = new StatementNode( StatementNode::Asm, 0, 0 ); }
-	| ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ')' ';'
-		{ $$ = new StatementNode( StatementNode::Asm, 0, 0 ); }
-	| ASM type_qualifier_list_opt '(' constant_expression ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list ')' ';'
-		{ $$ = new StatementNode( StatementNode::Asm, 0, 0 ); }
-	;
-
-asm_operands_opt:										// GCC
-	// empty
-	| asm_operands_list
-	;
-
-asm_operands_list:										// GCC
-	asm_operand
-	| asm_operands_list ',' asm_operand
-	;
-
-asm_operand:											// GCC
-	STRINGliteral '(' constant_expression ')'	{}
-	;
-
-asm_clobbers_list:										// GCC
-	STRINGliteral								{}
-	| asm_clobbers_list ',' STRINGliteral
-	;
-
-//******************************* DECLARATIONS *********************************
-
-declaration_list_opt:									// used at beginning of switch statement
-	pop
-		{ $$ = 0; }
-	| declaration_list
-	;
-
-declaration_list:
-	declaration
-	| declaration_list push declaration
-		{ $$ = $1->appendList( $3 ); }
-	;
-
-old_declaration_list_opt:								// used to declare parameter types in K&R style functions
-	pop
-		{ $$ = 0; }
-	| old_declaration_list
-	;
-
-old_declaration_list:
-	old_declaration
-	| old_declaration_list push old_declaration
-		{ $$ = $1->appendList( $3 ); }
-	;
-
-label_declaration_opt:									// GCC, local label
-	// empty
-	| label_declaration_list
-	;
-
-label_declaration_list:									// GCC, local label
-	LABEL label_list ';'
-	| label_declaration_list LABEL label_list ';'
-	;
-
-label_list:												// GCC, local label
-	no_attr_identifier_or_typedef_name			{}
-	| label_list ',' no_attr_identifier_or_typedef_name {}
-	;
-
-declaration:											// CFA, new & old style declarations
-	new_declaration
-	| old_declaration
-	;
-
-// C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
-// declarations. CFA declarations use the same declaration tokens as in C; however, CFA places declaration modifiers to
-// the left of the base type, while C declarations place modifiers to the right of the base type. CFA declaration
-// modifiers are interpreted from left to right and the entire type specification is distributed across all variables in
-// the declaration list (as in Pascal).  ANSI C and the new CFA declarations may appear together in the same program
-// block, but cannot be mixed within a specific declaration.
-//
-//			CFA					C
-//		[10] int x;			int x[10];		// array of 10 integers
-//		[10] * char y;		char *y[10];	// array of 10 pointers to char
-
-new_declaration:										// CFA
-	new_variable_declaration pop ';'
-	| new_typedef_declaration pop ';'
-	| new_function_declaration pop ';'
-	| type_declaring_list pop ';'
-	| context_specifier pop ';'
-	;
-
-new_variable_declaration:								// CFA
-	new_variable_specifier initializer_opt
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $1;
-		}
-	| declaration_qualifier_list new_variable_specifier initializer_opt
-		// declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to preclude
-		// them as a type_qualifier cannot appear in that context.
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $2->addQualifiers( $1 );
-		}
-	| new_variable_declaration pop ',' push identifier_or_typedef_name initializer_opt
-		{
-			typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
-			$$ = $1->appendList( $1->cloneType( $5 ) );
-		}
-	;
-
-new_variable_specifier:									// CFA
-		// A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
-		// storage-class
-	new_abstract_declarator_no_tuple identifier_or_typedef_name asm_name_opt
-		{
-			typedefTable.setNextIdentifier( *$2 );
-			$$ = $1->addName( $2 );
-		}
-	| new_abstract_tuple identifier_or_typedef_name asm_name_opt
-		{
-			typedefTable.setNextIdentifier( *$2 );
-			$$ = $1->addName( $2 );
-		}
-	| type_qualifier_list new_abstract_tuple identifier_or_typedef_name asm_name_opt
-		{
-			typedefTable.setNextIdentifier( *$3 );
-			$$ = $2->addQualifiers( $1 )->addName( $3 );
-		}
-	;
-
-new_function_declaration:								// CFA
-	new_function_specifier
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $1;
-		}
-	| type_qualifier_list new_function_specifier
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $2->addQualifiers( $1 );
-		}
-	| declaration_qualifier_list new_function_specifier
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $2->addQualifiers( $1 );
-		}
-	| declaration_qualifier_list type_qualifier_list new_function_specifier
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $3->addQualifiers( $1 )->addQualifiers( $2 );
-		}
-	| new_function_declaration pop ',' push identifier_or_typedef_name
-		{
-			typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
-			$$ = $1->appendList( $1->cloneType( $5 ) );
-		}
-	;
-
-new_function_specifier:									// CFA
-	'[' push pop ']' identifier '(' push new_parameter_type_list_opt pop ')'
-		{
-			typedefTable.setNextIdentifier( *( $5 ) );
-			$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
-		}
-	| '[' push pop ']' TYPEDEFname '(' push new_parameter_type_list_opt pop ')'
-		{
-			typedefTable.setNextIdentifier( *( $5 ) );
-			$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
-		}
-		// identifier_or_typedef_name must be broken apart because of the sequence:
-		//
-		//   '[' ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')'
-		//   '[' ']' type_specifier
-		//
-		// type_specifier can resolve to just TYPEDEFname (e.g. typedef int T; int f( T );). Therefore this must be
-		// flattened to allow lookahead to the '(' without having to reduce identifier_or_typedef_name.
-	| new_abstract_tuple identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')'
-		// To obtain LR(1 ), this rule must be factored out from function return type (see new_abstract_declarator).
-		{
-			$$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
-		}
-	| new_function_return identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')'
-		{
-			$$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
-		}
-	;
-
-new_function_return:									// CFA
-	'[' push new_parameter_list pop ']'
-		{ $$ = DeclarationNode::newTuple( $3 ); }
-	| '[' push new_parameter_list pop ',' push new_abstract_parameter_list pop ']'
-		// To obtain LR(1 ), the last new_abstract_parameter_list is added into this flattened rule to lookahead to the
-		// ']'.
-		{ $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); }
-	;
-
-new_typedef_declaration:								// CFA
-	TYPEDEF new_variable_specifier
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			$$ = $2->addTypedef();
-		}
-	| TYPEDEF new_function_specifier
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			$$ = $2->addTypedef();
-		}
-	| new_typedef_declaration pop ',' push no_attr_identifier
-		{
-			typedefTable.addToEnclosingScope( *$5, TypedefTable::TD );
-			$$ = $1->appendList( $1->cloneType( $5 ) );
-		}
-	;
-
-// Traditionally typedef is part of storage-class specifier for syntactic convenience only. Here, it is factored out as
-// a separate form of declaration, which syntactically precludes storage-class specifiers and initialization.
-
-typedef_declaration:
-	TYPEDEF type_specifier declarator
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			$$ = $3->addType( $2 )->addTypedef();
-		}
-	| typedef_declaration pop ',' push declarator
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			$$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
-		}
-	| type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			$$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
-		}
-	| type_specifier TYPEDEF declarator
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			$$ = $3->addType( $1 )->addTypedef();
-		}
-	| type_specifier TYPEDEF type_qualifier_list declarator
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::TD );
-			$$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
-		}
-	;
-
-typedef_expression:
-		// GCC, naming expression type: typedef name = exp; gives a name to the type of an expression
-	TYPEDEF no_attr_identifier '=' assignment_expression
-		{
-			typedefTable.addToEnclosingScope( *$2, TypedefTable::TD );
-			$$ = DeclarationNode::newName( 0 ); // XXX
-		}
-	| typedef_expression pop ',' push no_attr_identifier '=' assignment_expression
-		{
-			typedefTable.addToEnclosingScope( *$5, TypedefTable::TD );
-			$$ = DeclarationNode::newName( 0 ); // XXX
-		}
-	;
-
-old_declaration:
-	declaring_list pop ';'
-	| typedef_declaration pop ';'
-	| typedef_expression pop ';'						// GCC, naming expression type
-	| sue_declaration_specifier pop ';'
-	;
-
-declaring_list:
-		// A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
-		// storage-class
-	declaration_specifier declarator asm_name_opt initializer_opt
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = ( $2->addType( $1 ))->addInitializer( $4 );
-		}
-	| declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $1->appendList( $1->cloneBaseType( $4->addInitializer( $6 ) ) );
-		}
-	;
-
-declaration_specifier:									// type specifier + storage class
-	basic_declaration_specifier
-	| sue_declaration_specifier
-	| typedef_declaration_specifier
-	| typegen_declaration_specifier
-	;
-
-type_specifier:											// declaration specifier - storage class
-	basic_type_specifier
-	| sue_type_specifier
-	| typedef_type_specifier
-	| typegen_type_specifier
-	;
-
-type_qualifier_list_opt:								// GCC, used in asm_statement
-	// empty
-		{ $$ = 0; }
-	| type_qualifier_list
-	;
-
-type_qualifier_list:
-		// A semantic check is necessary to ensure a type qualifier is appropriate for the kind of declaration.
-		//
-		// ISO/IEC 9899:1999 Section 6.7.3(4 ) : If the same qualifier appears more than once in the same
-		// specifier-qualifier-list, either directly or via one or more typedefs, the behavior is the same as if it
-		// appeared only once.
-	type_qualifier
-	| type_qualifier_list type_qualifier
-		{ $$ = $1->addQualifiers( $2 ); }
-	;
-
-type_qualifier:
-	type_qualifier_name
-	| attribute
-		{ $$ = DeclarationNode::newQualifier( DeclarationNode::Attribute ); }
-	;
-
-type_qualifier_name:
-	CONST
-		{ $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); }
-	| RESTRICT
-		{ $$ = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
-	| VOLATILE
-		{ $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
-	| LVALUE											// CFA
-		{ $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
-	| ATOMIC
-		{ $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
-	| FORALL '('
-		{
-			typedefTable.enterScope();
-		}
-	  type_parameter_list ')'							// CFA
-		{
-			typedefTable.leaveScope();
-			$$ = DeclarationNode::newForall( $4 );
-		}
-	;
-
-declaration_qualifier_list:
-	storage_class_list
-	| type_qualifier_list storage_class_list			// remaining OBSOLESCENT (see 2 )
-		{ $$ = $1->addQualifiers( $2 ); }
-	| declaration_qualifier_list type_qualifier_list storage_class_list
-		{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
-	;
-
-storage_class_list:
-		// A semantic check is necessary to ensure a storage class is appropriate for the kind of declaration and that
-		// only one of each is specified, except for inline, which can appear with the others.
-		//
-		// ISO/IEC 9899:1999 Section 6.7.1(2) : At most, one storage-class specifier may be given in the declaration
-		// specifiers in a declaration.
-	storage_class
-	| storage_class_list storage_class
-		{ $$ = $1->addQualifiers( $2 ); }
-	;
-
-storage_class:
-	storage_class_name
-	;
-
-storage_class_name:
-	EXTERN
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
-	| STATIC
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
-	| AUTO
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
-	| REGISTER
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
-	| INLINE											// C99
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
-	| FORTRAN											// C99
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
-	| NORETURN											// C11
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
-	| THREADLOCAL										// C11
-		{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
-	;
-
-basic_type_name:
-	CHAR
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); }
-	| DOUBLE
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
-	| FLOAT
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
-	| INT
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
-	| LONG
-		{ $$ = DeclarationNode::newModifier( DeclarationNode::Long ); }
-	| SHORT
-		{ $$ = DeclarationNode::newModifier( DeclarationNode::Short ); }
-	| SIGNED
-		{ $$ = DeclarationNode::newModifier( DeclarationNode::Signed ); }
-	| UNSIGNED
-		{ $$ = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
-	| VOID
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
-	| BOOL												// C99
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
-	| COMPLEX											// C99
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
-	| IMAGINARY											// C99
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
-	;
-
-basic_declaration_specifier:
-		// A semantic check is necessary for conflicting storage classes.
-	basic_type_specifier
-	| declaration_qualifier_list basic_type_specifier
-		{ $$ = $2->addQualifiers( $1 ); }
-	| basic_declaration_specifier storage_class			// remaining OBSOLESCENT (see 2)
-		{ $$ = $1->addQualifiers( $2 ); }
-	| basic_declaration_specifier storage_class type_qualifier_list
-		{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
-	| basic_declaration_specifier storage_class basic_type_specifier
-		{ $$ = $3->addQualifiers( $2 )->addType( $1 ); }
-	;
-
-basic_type_specifier:
-	direct_type_name
-	| type_qualifier_list_opt indirect_type_name type_qualifier_list_opt
-		{ $$ = $2->addQualifiers( $1 )->addQualifiers( $3 ); }
-	;
-
-direct_type_name:
-		// A semantic check is necessary for conflicting type qualifiers.
-	basic_type_name
-	| type_qualifier_list basic_type_name
-		{ $$ = $2->addQualifiers( $1 ); }
-	| direct_type_name type_qualifier
-		{ $$ = $1->addQualifiers( $2 ); }
-	| direct_type_name basic_type_name
-		{ $$ = $1->addType( $2 ); }
-	;
-
-indirect_type_name:
-	TYPEOF '(' type_name ')'							// GCC: typeof(x) y;
-		{ $$ = $3; }
-	| TYPEOF '(' comma_expression ')'					// GCC: typeof(a+b) y;
-		{ $$ = DeclarationNode::newTypeof( $3 ); }
-	| ATTR_TYPEGENname '(' type_name ')'				// CFA: e.g., @type(x) y;
-		{ $$ = DeclarationNode::newAttr( $1, $3 ); }
-	| ATTR_TYPEGENname '(' comma_expression ')'			// CFA: e.g., @type(a+b) y;
-		{ $$ = DeclarationNode::newAttr( $1, $3 ); }
-	;
-
-sue_declaration_specifier:
-	sue_type_specifier
-	| declaration_qualifier_list sue_type_specifier
-		{ $$ = $2->addQualifiers( $1 ); }
-	| sue_declaration_specifier storage_class			// remaining OBSOLESCENT (see 2)
-		{ $$ = $1->addQualifiers( $2 ); }
-	| sue_declaration_specifier storage_class type_qualifier_list
-		{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
-	;
-
-sue_type_specifier:
-	elaborated_type_name								// struct, union, enum
-	| type_qualifier_list elaborated_type_name
-		{ $$ = $2->addQualifiers( $1 ); }
-	| sue_type_specifier type_qualifier
-		{ $$ = $1->addQualifiers( $2 ); }
-	;
-
-typedef_declaration_specifier:
-	typedef_type_specifier
-	| declaration_qualifier_list typedef_type_specifier
-		{ $$ = $2->addQualifiers( $1 ); }
-	| typedef_declaration_specifier storage_class		// remaining OBSOLESCENT (see 2)
-		{ $$ = $1->addQualifiers( $2 ); }
-	| typedef_declaration_specifier storage_class type_qualifier_list
-		{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
-	;
-
-typedef_type_specifier:									// typedef types
-	TYPEDEFname
-		{ $$ = DeclarationNode::newFromTypedef( $1 ); }
-	| type_qualifier_list TYPEDEFname
-		{ $$ = DeclarationNode::newFromTypedef( $2 )->addQualifiers( $1 ); }
-	| typedef_type_specifier type_qualifier
-		{ $$ = $1->addQualifiers( $2 ); }
-	;
-
-elaborated_type_name:
-	aggregate_name
-	| enum_name
-	;
-
-aggregate_name:
-	aggregate_key '{' field_declaration_list '}'
-		{ $$ = DeclarationNode::newAggregate( $1, 0, 0, $3 ); }
-	| aggregate_key no_attr_identifier_or_typedef_name
-	 	{ $$ = DeclarationNode::newAggregate( $1, $2, 0, 0 ); }
-	| aggregate_key no_attr_identifier_or_typedef_name '{' field_declaration_list '}'
-	 	{ $$ = DeclarationNode::newAggregate( $1, $2, 0, $4 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' '{' field_declaration_list '}' // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, 0, $4, 0, $8 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, 0 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, $9 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' '{' field_declaration_list '}' // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, 0, $4, $8, $11 ); }
-	| aggregate_key '(' type_name_list ')' '{' field_declaration_list '}' // CFA
-	 	{ $$ = DeclarationNode::newAggregate( $1, 0, $3, $6 ); }
-	| aggregate_key '(' type_name_list ')' no_attr_identifier_or_typedef_name // CFA
-	 	{ $$ = DeclarationNode::newAggregate( $1, $5, $3, 0 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, $10, $4, $8, $12 ); }
-	;
-
-aggregate_key:
-	STRUCT attribute_list_opt
-		{ $$ = DeclarationNode::Struct; }
-	| UNION attribute_list_opt
-		{ $$ = DeclarationNode::Union; }
-	;
-
-field_declaration_list:
-	field_declaration
-		{ $$ = $1; }
-	| field_declaration_list field_declaration
-		{ $$ = $1->appendList( $2 ); }
-	;
-
-field_declaration:
-	new_field_declaring_list ';'						// CFA, new style field declaration
-	| EXTENSION new_field_declaring_list ';'			// GCC
-		{ $$ = $2; }
-	| field_declaring_list ';'
-	| EXTENSION field_declaring_list ';'				// GCC
-		{ $$ = $2; }
-	;
-
-new_field_declaring_list:								// CFA, new style field declaration
-	new_abstract_declarator_tuple						// CFA, no field name
-	| new_abstract_declarator_tuple no_attr_identifier_or_typedef_name
-		{ $$ = $1->addName( $2 ); }
-	| new_field_declaring_list ',' no_attr_identifier_or_typedef_name
-		{ $$ = $1->appendList( $1->cloneType( $3 ) ); }
-	| new_field_declaring_list ','						// CFA, no field name
-		{ $$ = $1->appendList( $1->cloneType( 0 ) ); }
-	;
-
-field_declaring_list:
-	type_specifier field_declarator
-		{ $$ = $2->addType( $1 ); }
-	| field_declaring_list ',' attribute_list_opt field_declarator
-		{ $$ = $1->appendList( $1->cloneBaseType( $4 ) ); }
-	;
-
-field_declarator:
-	// empty
-		{ $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
-	| bit_subrange_size									// no field name
-		{ $$ = DeclarationNode::newBitfield( $1 ); }
-	| variable_declarator bit_subrange_size_opt
-		// A semantic check is required to ensure bit_subrange only appears on base type int.
-		{ $$ = $1->addBitfield( $2 ); }
-	| typedef_redeclarator bit_subrange_size_opt
-		// A semantic check is required to ensure bit_subrange only appears on base type int.
-		{ $$ = $1->addBitfield( $2 ); }
-	| variable_abstract_declarator						// CFA, no field name
-	;
-
-bit_subrange_size_opt:
-	// empty
-		{ $$ = 0; }
-	| bit_subrange_size
-		{ $$ = $1; }
-	;
-
-bit_subrange_size:
-	':' constant_expression
-		{ $$ = $2; }
-	;
-
-enum_key:
-	ENUM attribute_list_opt
-	;
-
-enum_name:
-	enum_key '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( 0, $3 ); }
-	| enum_key no_attr_identifier_or_typedef_name '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( $2, $4 ); }
-	| enum_key no_attr_identifier_or_typedef_name
-		{ $$ = DeclarationNode::newEnum( $2, 0 ); }
-	;
-
-enumerator_list:
-	no_attr_identifier_or_typedef_name enumerator_value_opt
-		{ $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
-	| enumerator_list ',' no_attr_identifier_or_typedef_name enumerator_value_opt
-		{ $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
-	;
-
-enumerator_value_opt:
-	// empty
-		{ $$ = 0; }
-	| '=' constant_expression
-		{ $$ = $2; }
-	;
-
-// Minimum of one parameter after which ellipsis is allowed only at the end.
-
-new_parameter_type_list_opt:							// CFA
-	// empty
-		{ $$ = 0; }
-	| new_parameter_type_list
-	;
-
-new_parameter_type_list:								// CFA, abstract + real
-	new_abstract_parameter_list
-	| new_parameter_list
-	| new_parameter_list pop ',' push new_abstract_parameter_list
-		{ $$ = $1->appendList( $5 ); }
-	| new_abstract_parameter_list pop ',' push ELLIPSIS
-		{ $$ = $1->addVarArgs(); }
-	| new_parameter_list pop ',' push ELLIPSIS
-		{ $$ = $1->addVarArgs(); }
-	;
-
-new_parameter_list:										// CFA
-		// To obtain LR(1) between new_parameter_list and new_abstract_tuple, the last new_abstract_parameter_list is
-		// factored out from new_parameter_list, flattening the rules to get lookahead to the ']'.
-	new_parameter_declaration
-	| new_abstract_parameter_list pop ',' push new_parameter_declaration
-		{ $$ = $1->appendList( $5 ); }
-	| new_parameter_list pop ',' push new_parameter_declaration
-		{ $$ = $1->appendList( $5 ); }
-	| new_parameter_list pop ',' push new_abstract_parameter_list pop ',' push new_parameter_declaration
-		{ $$ = $1->appendList( $5 )->appendList( $9 ); }
-	;
-
-new_abstract_parameter_list:							// CFA, new & old style abstract
-	new_abstract_parameter_declaration
-	| new_abstract_parameter_list pop ',' push new_abstract_parameter_declaration
-		{ $$ = $1->appendList( $5 ); }
-	;
-
-parameter_type_list_opt:
-	// empty
-		{ $$ = 0; }
-	| parameter_type_list
-	;
-
-parameter_type_list:
-	parameter_list
-	| parameter_list pop ',' push ELLIPSIS
-		{ $$ = $1->addVarArgs(); }
-	;
-
-parameter_list:											// abstract + real
-	abstract_parameter_declaration
-	| parameter_declaration
-	| parameter_list pop ',' push abstract_parameter_declaration
-		{ $$ = $1->appendList( $5 ); }
-	| parameter_list pop ',' push parameter_declaration
-		{ $$ = $1->appendList( $5 ); }
-	;
-
-// Provides optional identifier names (abstract_declarator/variable_declarator), no initialization, different semantics
-// for typedef name by using typedef_parameter_redeclarator instead of typedef_redeclarator, and function prototypes.
-
-new_parameter_declaration:								// CFA, new & old style parameter declaration
-	parameter_declaration
-	| new_identifier_parameter_declarator_no_tuple identifier_or_typedef_name assignment_opt
-		{ $$ = $1->addName( $2 ); }
-	| new_abstract_tuple identifier_or_typedef_name assignment_opt
-		// To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator).
-		{ $$ = $1->addName( $2 ); }
-	| type_qualifier_list new_abstract_tuple identifier_or_typedef_name assignment_opt
-		{ $$ = $2->addName( $3 )->addQualifiers( $1 ); }
-	| new_function_specifier
-	;
-
-new_abstract_parameter_declaration:						// CFA, new & old style parameter declaration
-	abstract_parameter_declaration
-	| new_identifier_parameter_declarator_no_tuple
-	| new_abstract_tuple
-		// To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator).
-	| type_qualifier_list new_abstract_tuple
-		{ $$ = $2->addQualifiers( $1 ); }
-	| new_abstract_function
-	;
-
-parameter_declaration:
-	declaration_specifier identifier_parameter_declarator assignment_opt
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $2->addType( $1 )->addInitializer( new InitializerNode( $3 ) );
-		}
-	| declaration_specifier typedef_parameter_redeclarator assignment_opt
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $2->addType( $1 )->addInitializer( new InitializerNode( $3 ) );
-		}
-	;
-
-abstract_parameter_declaration:
-	declaration_specifier
-	| declaration_specifier abstract_parameter_declarator
-		{ $$ = $2->addType( $1 ); }
-	;
-
-// ISO/IEC 9899:1999 Section 6.9.1(6) : "An identifier declared as a typedef name shall not be redeclared as a
-// parameter." Because the scope of the K&R-style parameter-list sees the typedef first, the following is based only on
-// identifiers.  The ANSI-style parameter-list can redefine a typedef name.
-
-identifier_list:										// K&R-style parameter list => no types
-	no_attr_identifier
-		{ $$ = DeclarationNode::newName( $1 ); }
-	| identifier_list ',' no_attr_identifier
-		{ $$ = $1->appendList( DeclarationNode::newName( $3 ) ); }
-	;
-
-identifier_or_typedef_name:
-	identifier
-	| TYPEDEFname
-	| TYPEGENname
-	;
-
-no_01_identifier_or_typedef_name:
-	no_01_identifier
-	| TYPEDEFname
-	| TYPEGENname
-	;
-
-no_attr_identifier_or_typedef_name:
-	no_attr_identifier
-	| TYPEDEFname
-	| TYPEGENname
-	;
-
-type_name_no_function:									// sizeof, alignof, cast (constructor)
-	new_abstract_declarator_tuple						// CFA
-	| type_specifier
-	| type_specifier variable_abstract_declarator
-		{ $$ = $2->addType( $1 ); }
-	;
-
-type_name:												// typeof, assertion
-	new_abstract_declarator_tuple						// CFA
-	| new_abstract_function								// CFA
-	| type_specifier
-	| type_specifier abstract_declarator
-		{ $$ = $2->addType( $1 ); }
-	;
-
-initializer_opt:
-	// empty
-		{ $$ = 0; }
-	| '=' initializer							{ $$ = $2; }
-	;
-
-initializer:
-	assignment_expression						{ $$ = new InitializerNode( $1 ); }
-	| '{' initializer_list comma_opt '}'		{ $$ = new InitializerNode( $2, true ); }
-	;
-
-initializer_list:
-	initializer
-	| designation initializer					{ $$ = $2->set_designators( $1 ); }
-	| initializer_list ',' initializer			{ $$ = (InitializerNode *)( $1->set_link( $3 ) ); }
-	| initializer_list ',' designation initializer
-		{ $$ = (InitializerNode *)( $1->set_link( $4->set_designators( $3 ) ) ); }
-	;
-
-// There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem is use of
-// '=' to separator the designator from the initializer value, as in:
-//
-//		int x[10] = { [1] = 3 };
-//
-// The string "[1] = 3" can be parsed as a designator assignment or a tuple assignment.  To disambiguate this case, CFA
-// changes the syntax from "=" to ":" as the separator between the designator and initializer. GCC does uses ":" for
-// field selection. The optional use of the "=" in GCC, or in this case ":", cannot be supported either due to
-// shift/reduce conflicts
-
-designation:
-	designator_list ':'									// C99, CFA uses ":" instead of "="
-	| no_attr_identifier_or_typedef_name ':'			// GCC, field name
-				{ $$ = new VarRefNode( $1 ); }
-	;
-
-designator_list:										// C99
-	designator
-	| designator_list designator					{ $$ = (ExpressionNode *)( $1->set_link( $2 )); }
-	//| designator_list designator						{ $$ = new CompositeExprNode( $1, $2 ); }
-	;
-
-designator:
-	'.' no_attr_identifier_or_typedef_name				// C99, field name
-		{ $$ = new VarRefNode( $2 ); }
-	| '[' push assignment_expression pop ']'			// C99, single array element
-		// assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
-		{ $$ = $3; }
-	| '[' push subrange pop ']'							// CFA, multiple array elements
-		{ $$ = $3; }
-	| '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), $3, $5 ); }
-	| '.' '[' push field_list pop ']'					// CFA, tuple field selector
-		{ $$ = $4; }
-	;
-
-// The CFA type system is based on parametric polymorphism, the ability to declare functions with type parameters,
-// rather than an object-oriented type system. This required four groups of extensions:
-//
-// Overloading: function, data, and operator identifiers may be overloaded.
-//
-// Type declarations: "type" is used to generate new types for declaring objects. Similarly, "dtype" is used for object
-//     and incomplete types, and "ftype" is used for function types. Type declarations with initializers provide
-//     definitions of new types. Type declarations with storage class "extern" provide opaque types.
-//
-// Polymorphic functions: A forall clause declares a type parameter. The corresponding argument is inferred at the call
-//     site. A polymorphic function is not a template; it is a function, with an address and a type.
-//
-// Specifications and Assertions: Specifications are collections of declarations parameterized by one or more
-//     types. They serve many of the purposes of abstract classes, and specification hierarchies resemble subclass
-//     hierarchies. Unlike classes, they can define relationships between types.  Assertions declare that a type or
-//     types provide the operations declared by a specification.  Assertions are normally used to declare requirements
-//     on type arguments of polymorphic functions.
-
-typegen_declaration_specifier:							// CFA
-	typegen_type_specifier
-	| declaration_qualifier_list typegen_type_specifier
-		{ $$ = $2->addQualifiers( $1 ); }
-	| typegen_declaration_specifier storage_class		// remaining OBSOLESCENT (see 2)
-		{ $$ = $1->addQualifiers( $2 ); }
-	| typegen_declaration_specifier storage_class type_qualifier_list
-		{ $$ = $1->addQualifiers( $2 )->addQualifiers( $3 ); }
-	;
-
-typegen_type_specifier:									// CFA
-	TYPEGENname '(' type_name_list ')'
-		{ $$ = DeclarationNode::newFromTypeGen( $1, $3 ); }
-	| type_qualifier_list TYPEGENname '(' type_name_list ')'
-		{ $$ = DeclarationNode::newFromTypeGen( $2, $4 )->addQualifiers( $1 ); }
-	| typegen_type_specifier type_qualifier
-		{ $$ = $1->addQualifiers( $2 ); }
-	;
-
-type_parameter_list:									// CFA
-	type_parameter assignment_opt
-	| type_parameter_list ',' type_parameter assignment_opt
-		{ $$ = $1->appendList( $3 ); }
-	;
-
-type_parameter:											// CFA
-	type_class no_attr_identifier_or_typedef_name
-		{ typedefTable.addToEnclosingScope(*( $2 ), TypedefTable::TD ); }
-	  assertion_list_opt
-		{ $$ = DeclarationNode::newTypeParam( $1, $2 )->addAssertions( $4 ); }
-	| type_specifier identifier_parameter_declarator
-	;
-
-type_class:												// CFA
-	TYPE
-		{ $$ = DeclarationNode::Type; }
-	| DTYPE
-		{ $$ = DeclarationNode::Ftype; }
-	| FTYPE
-		{ $$ = DeclarationNode::Dtype; }
-	;
-
-assertion_list_opt:										// CFA
-	// empty
-		{ $$ = 0; }
-	| assertion_list_opt assertion
-		{ $$ = $1 == 0 ? $2 : $1->appendList( $2 ); }
-	;
-
-assertion:												// CFA
-	'|' no_attr_identifier_or_typedef_name '(' type_name_list ')'
-		{
-			typedefTable.openContext( *( $2 ) );
-			$$ = DeclarationNode::newContextUse( $2, $4 );
-		}
-	| '|' '{' push context_declaration_list '}'
-		{ $$ = $4; }
-	| '|' '(' push type_parameter_list pop ')' '{' push context_declaration_list '}' '(' type_name_list ')'
-		{ $$ = 0; }
-	;
-
-type_name_list:											// CFA
-	type_name
-		{ $$ = new TypeValueNode( $1 ); }
-	| assignment_expression
-	| type_name_list ',' type_name
-		{ $$ = (ExpressionNode *)( $1->set_link( new TypeValueNode( $3 ))); }
-	| type_name_list ',' assignment_expression
-		{ $$ = (ExpressionNode *)( $1->set_link( $3 )); }
-	;
-
-type_declaring_list:									// CFA
-	TYPE type_declarator
-		{ $$ = $2; }
-	| storage_class_list TYPE type_declarator
-		{ $$ = $3->addQualifiers( $1 ); }
-	| type_declaring_list ',' type_declarator
-		{ $$ = $1->appendList( $3->copyStorageClasses( $1 ) ); }
-	;
-
-type_declarator:										// CFA
-	type_declarator_name assertion_list_opt
-		{ $$ = $1->addAssertions( $2 ); }
-	| type_declarator_name assertion_list_opt '=' type_name
-		{ $$ = $1->addAssertions( $2 )->addType( $4 ); }
-	;
-
-type_declarator_name:									// CFA
-	no_attr_identifier_or_typedef_name
-		{
-			typedefTable.addToEnclosingScope( *$1, TypedefTable::TD );
-			$$ = DeclarationNode::newTypeDecl( $1, 0 );
-		}
-	| no_01_identifier_or_typedef_name '(' push type_parameter_list pop ')'
-		{
-			typedefTable.addToEnclosingScope( *$1, TypedefTable::TG );
-			$$ = DeclarationNode::newTypeDecl( $1, $4 );
-		}
-	;
-
-context_specifier:										// CFA
-	CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{' '}'
-		{
-			typedefTable.addToEnclosingScope( *$2, TypedefTable::ID );
-			$$ = DeclarationNode::newContext( $2, $5, 0 );
-		}
-	| CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{'
-		{
-			typedefTable.enterContext( *$2 );
-			typedefTable.enterScope();
-		}
-	  context_declaration_list '}'
-		{
-			typedefTable.leaveContext();
-			typedefTable.addToEnclosingScope( *$2, TypedefTable::ID );
-			$$ = DeclarationNode::newContext( $2, $5, $10 );
-		}
-	;
-
-context_declaration_list:								// CFA
-	context_declaration
-	| context_declaration_list push context_declaration
-		{ $$ = $1->appendList( $3 ); }
-	;
-
-context_declaration:									// CFA
-	new_context_declaring_list pop ';'
-	| context_declaring_list pop ';'
-	;
-
-new_context_declaring_list:								// CFA
-	new_variable_specifier
-		{
-			typedefTable.addToEnclosingScope2( TypedefTable::ID );
-			$$ = $1;
-		}
-	| new_function_specifier
-		{
-			typedefTable.addToEnclosingScope2( TypedefTable::ID );
-			$$ = $1;
-		}
-	| new_context_declaring_list pop ',' push identifier_or_typedef_name
-		{
-			typedefTable.addToEnclosingScope2( *$5, TypedefTable::ID );
-			$$ = $1->appendList( $1->cloneType( $5 ) );
-		}
-	;
-
-context_declaring_list:									// CFA
-	type_specifier declarator
-		{
-			typedefTable.addToEnclosingScope2( TypedefTable::ID );
-			$$ = $2->addType( $1 );
-		}
-	| context_declaring_list pop ',' push declarator
-		{
-			typedefTable.addToEnclosingScope2( TypedefTable::ID );
-			$$ = $1->appendList( $1->cloneBaseType( $5 ) );
-		}
-	;
-
-//***************************** EXTERNAL DEFINITIONS *****************************
-
-translation_unit:
-	// empty
-		{}												// empty input file
-	| external_definition_list
-		{
-			if ( theTree ) {
-				theTree->appendList( $1 );
-			} else {
-				theTree = $1;
-			}
-		}
-	;
-
-external_definition_list:
-	external_definition
-	| external_definition_list push external_definition
-		{ $$ = ( $1 != NULL ) ? $1->appendList( $3 ) : $3; }
-	;
-
-external_definition_list_opt:
-	// empty
-		{ $$ = 0; }
-	| external_definition_list
-	;
-
-external_definition:
-	declaration
-	| external_function_definition
-	| asm_statement										// GCC, global assembler statement
-		{}
-	| EXTERN STRINGliteral
-		{
-			linkageStack.push( linkage );
-			linkage = LinkageSpec::fromString( *$2 );
-		}
-	  '{' external_definition_list_opt '}'				// C++-style linkage specifier
-		{
-			linkage = linkageStack.top();
-			linkageStack.pop();
-			$$ = $5;
-		}
-	| EXTENSION external_definition
-		{ $$ = $2; }
-	;
-
-external_function_definition:
-	function_definition
-
-		// These rules are a concession to the "implicit int" type_specifier because there is a significant amount of
-		// code with functions missing a type-specifier on the return type.  Parsing is possible because
-		// function_definition does not appear in the context of an expression (nested functions would preclude this
-		// concession). A function prototype declaration must still have a type_specifier.  OBSOLESCENT (see 1)
-	| function_declarator compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $1->addFunctionBody( $2 );
-		}
-	| old_function_declarator push old_declaration_list_opt compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $1->addOldDeclList( $3 )->addFunctionBody( $4 );
-		}
-	;
-
-function_definition:
-	new_function_declaration compound_statement			// CFA
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $1->addFunctionBody( $2 );
-		}
-	| declaration_specifier function_declarator compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $2->addFunctionBody( $3 )->addType( $1 );
-		}
-	| type_qualifier_list function_declarator compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
-		}
-	| declaration_qualifier_list function_declarator compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $2->addFunctionBody( $3 )->addQualifiers( $1 );
-		}
-	| declaration_qualifier_list type_qualifier_list function_declarator compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $3->addFunctionBody( $4 )->addQualifiers( $2 )->addQualifiers( $1 );
-		}
-
-		// Old-style K&R function definition, OBSOLESCENT (see 4)
-	| declaration_specifier old_function_declarator push old_declaration_list_opt compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addType( $1 );
-		}
-	| type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
-		}
-
-		// Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4)
-	| declaration_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
-		}
-	| declaration_qualifier_list type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
-		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			typedefTable.leaveScope();
-			$$ = $3->addOldDeclList( $5 )->addFunctionBody( $6 )->addQualifiers( $2 )->addQualifiers( $1 );
-		}
-	;
-
-declarator:
-	variable_declarator
-	| function_declarator
-	| typedef_redeclarator
-	;
-
-subrange:
-	constant_expression '~' constant_expression			// CFA, integer subrange
-		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), $1, $3 ); }
-	;
-
-asm_name_opt:											// GCC
-	// empty
-	| ASM '(' string_literal_list ')' attribute_list_opt
-	;
-
-attribute_list_opt:										// GCC
-	// empty
-	| attribute_list
-	;
-
-attribute_list:											// GCC
-	attribute
-	| attribute_list attribute
-	;
-
-attribute:												// GCC
-	ATTRIBUTE '(' '(' attribute_parameter_list ')' ')'
-	;
-
-attribute_parameter_list:								// GCC
-	attrib
-	| attribute_parameter_list ',' attrib
-	;
-
-attrib:													// GCC
-	// empty
-	| any_word
-	| any_word '(' comma_expression_opt ')'
-	;
-
-any_word:												// GCC
-	identifier_or_typedef_name {}
-	| storage_class_name {}
-	| basic_type_name {}
-	| type_qualifier {}
-	;
-
-// ============================================================================
-// The following sections are a series of grammar patterns used to parse declarators. Multiple patterns are necessary
-// because the type of an identifier in wrapped around the identifier in the same form as its usage in an expression, as
-// in:
-//
-//		int (*f())[10] { ... };
-//		... (*f())[3] += 1;		// definition mimics usage
-//
-// Because these patterns are highly recursive, changes at a lower level in the recursion require copying some or all of
-// the pattern. Each of these patterns has some subtle variation to ensure correct syntax in a particular context.
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// The set of valid declarators before a compound statement for defining a function is less than the set of declarators
-// to define a variable or function prototype, e.g.:
-//
-//		valid declaration		invalid definition
-//		-----------------		------------------
-//		int f;					int f {}
-//		int *f;					int *f {}
-//		int f[10];				int f[10] {}
-//		int (*f)(int);			int (*f)(int) {}
-//
-// To preclude this syntactic anomaly requires separating the grammar rules for variable and function declarators, hence
-// variable_declarator and function_declarator.
-// ----------------------------------------------------------------------------
-
-// This pattern parses a declaration of a variable that is not redefining a typedef name. The pattern precludes
-// declaring an array of functions versus a pointer to an array of functions.
-
-variable_declarator:
-	paren_identifier attribute_list_opt
-	| variable_ptr
-	| variable_array attribute_list_opt
-	| variable_function attribute_list_opt
-	;
-
-paren_identifier:
-	identifier
-		{
-			typedefTable.setNextIdentifier( *$1 );
-			$$ = DeclarationNode::newName( $1 );
-		}
-	| '(' paren_identifier ')'							// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-variable_ptr:
-	'*' variable_declarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list variable_declarator
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' variable_ptr ')'
-		{ $$ = $2; }
-	;
-
-variable_array:
-	paren_identifier array_dimension
-		{ $$ = $1->addArray( $2 ); }
-	| '(' variable_ptr ')' array_dimension
-		{ $$ = $2->addArray( $4 ); }
-	| '(' variable_array ')' multi_array_dimension		// redundant parenthesis
-		{ $$ = $2->addArray( $4 ); }
-	| '(' variable_array ')'							// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-variable_function:
-	'(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $6 ); }
-	| '(' variable_function ')'							// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-// This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot be nested,
-// there is no context where a function definition can redefine a typedef name. To allow nested functions requires
-// further separation of variable and function declarators in typedef_redeclarator.  The pattern precludes returning
-// arrays and functions versus pointers to arrays and functions.
-
-function_declarator:
-	function_no_ptr attribute_list_opt
-	| function_ptr
-	| function_array attribute_list_opt
-	;
-
-function_no_ptr:
-	paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $1->addParamList( $4 ); }
-	| '(' function_ptr ')' '(' push parameter_type_list_opt pop ')'
-		{ $$ = $2->addParamList( $6 ); }
-	| '(' function_no_ptr ')'							// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-function_ptr:
-	'*' function_declarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list function_declarator
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' function_ptr ')'
-		{ $$ = $2; }
-	;
-
-function_array:
-	'(' function_ptr ')' array_dimension
-		{ $$ = $2->addArray( $4 ); }
-	| '(' function_array ')' multi_array_dimension		// redundant parenthesis
-		{ $$ = $2->addArray( $4 ); }
-	| '(' function_array ')'							// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-// This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4) that is not redefining a typedef name
-// (see function_declarator for additional comments). The pattern precludes returning arrays and functions versus
-// pointers to arrays and functions.
-
-old_function_declarator:
-	old_function_no_ptr
-	| old_function_ptr
-	| old_function_array
-	;
-
-old_function_no_ptr:
-	paren_identifier '(' identifier_list ')'			// function_declarator handles empty parameter
-		{ $$ = $1->addIdList( $3 ); }
-	| '(' old_function_ptr ')' '(' identifier_list ')'
-		{ $$ = $2->addIdList( $5 ); }
-	| '(' old_function_no_ptr ')'						// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-old_function_ptr:
-	'*' old_function_declarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list old_function_declarator
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' old_function_ptr ')'
-		{ $$ = $2; }
-	;
-
-old_function_array:
-	'(' old_function_ptr ')' array_dimension
-		{ $$ = $2->addArray( $4 ); }
-	| '(' old_function_array ')' multi_array_dimension	// redundant parenthesis
-		{ $$ = $2->addArray( $4 ); }
-	| '(' old_function_array ')'						// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-// This pattern parses a declaration for a variable or function prototype that redefines a typedef name, e.g.:
-//
-//		typedef int foo;
-//		{
-//		   int foo; // redefine typedef name in new scope
-//		}
-//
-// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
-// and functions versus pointers to arrays and functions.
-
-typedef_redeclarator:
-	paren_typedef attribute_list_opt
-	| typedef_ptr
-	| typedef_array attribute_list_opt
-	| typedef_function attribute_list_opt
-	;
-
-paren_typedef:
-	TYPEDEFname
-		{
-			typedefTable.setNextIdentifier( *( $1 ) );
-			$$ = DeclarationNode::newName( $1 );
-		}
-	| '(' paren_typedef ')'
-		{ $$ = $2; }
-	;
-
-typedef_ptr:
-	'*' typedef_redeclarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list typedef_redeclarator
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' typedef_ptr ')'
-		{ $$ = $2; }
-	;
-
-typedef_array:
-	paren_typedef array_dimension
-		{ $$ = $1->addArray( $2 ); }
-	| '(' typedef_ptr ')' array_dimension
-		{ $$ = $2->addArray( $4 ); }
-	| '(' typedef_array ')' multi_array_dimension		// redundant parenthesis
-		{ $$ = $2->addArray( $4 ); }
-	| '(' typedef_array ')'								// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-typedef_function:
-	paren_typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $1->addParamList( $4 ); }
-	| '(' typedef_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $6 ); }
-	| '(' typedef_function ')'							// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-// This pattern parses a declaration for a parameter variable or function prototype that is not redefining a typedef
-// name and allows the C99 array options, which can only appear in a parameter list.  The pattern precludes declaring an
-// array of functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to
-// arrays and functions.
-
-identifier_parameter_declarator:
-	paren_identifier attribute_list_opt
-	| identifier_parameter_ptr
-	| identifier_parameter_array attribute_list_opt
-	| identifier_parameter_function attribute_list_opt
-	;
-
-identifier_parameter_ptr:
-	'*' identifier_parameter_declarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list identifier_parameter_declarator
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' identifier_parameter_ptr ')'
-		{ $$ = $2; }
-	;
-
-identifier_parameter_array:
-	paren_identifier array_parameter_dimension
-		{ $$ = $1->addArray( $2 ); }
-	| '(' identifier_parameter_ptr ')' array_dimension
-		{ $$ = $2->addArray( $4 ); }
-	| '(' identifier_parameter_array ')' multi_array_dimension // redundant parenthesis
-		{ $$ = $2->addArray( $4 ); }
-	| '(' identifier_parameter_array ')'				// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-identifier_parameter_function:
-	paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $1->addParamList( $4 ); }
-	| '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $6 ); }
-	| '(' identifier_parameter_function ')'				// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-// This pattern parses a declaration for a parameter variable or function prototype that is redefining a typedef name,
-// e.g.:
-//
-//		typedef int foo;
-//		int f( int foo ); // redefine typedef name in new scope
-//
-// and allows the C99 array options, which can only appear in a parameter list.  In addition, the pattern handles the
-// special meaning of parenthesis around a typedef name:
-//
-//		ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in
-//		parentheses is taken to be an abstract declarator that specifies a function with a single parameter,
-//		not as redundant parentheses around the identifier."
-//
-// which precludes the following cases:
-//
-//		typedef float T;
-//		int f( int ( T [5] ) );					// see abstract_parameter_declarator
-//		int g( int ( T ( int ) ) );				// see abstract_parameter_declarator
-//		int f( int f1( T a[5] ) );				// see identifier_parameter_declarator
-//		int g( int g1( T g2( int p ) ) );		// see identifier_parameter_declarator
-//
-// In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type list, and
-// not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes declaring an array of
-// functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to arrays and
-// functions.
-
-typedef_parameter_redeclarator:
-	typedef attribute_list_opt
-	| typedef_parameter_ptr
-	| typedef_parameter_array attribute_list_opt
-	| typedef_parameter_function attribute_list_opt
-	;
-
-typedef:
-	TYPEDEFname
-		{
-			typedefTable.setNextIdentifier( *$1 );
-			$$ = DeclarationNode::newName( $1 );
-		}
-	;
-
-typedef_parameter_ptr:
-	'*' typedef_parameter_redeclarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list typedef_parameter_redeclarator
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' typedef_parameter_ptr ')'
-		{ $$ = $2; }
-	;
-
-typedef_parameter_array:
-	typedef array_parameter_dimension
-		{ $$ = $1->addArray( $2 ); }
-	| '(' typedef_parameter_ptr ')' array_parameter_dimension
-		{ $$ = $2->addArray( $4 ); }
-	;
-
-typedef_parameter_function:
-	typedef '(' push parameter_type_list_opt pop ')'	// empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $1->addParamList( $4 ); }
-	| '(' typedef_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $6 ); }
-	;
-
-// This pattern parses a declaration of an abstract variable or function prototype, i.e., there is no identifier to
-// which the type applies, e.g.:
-//
-//		sizeof( int );
-//		sizeof( int [10] );
-//
-// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
-// and functions versus pointers to arrays and functions.
-
-abstract_declarator:
-	abstract_ptr
-	| abstract_array attribute_list_opt
-	| abstract_function attribute_list_opt
-	;
-
-abstract_ptr:
-	'*'
-		{ $$ = DeclarationNode::newPointer( 0 ); }
-	| '*' type_qualifier_list
-		{ $$ = DeclarationNode::newPointer( $2 ); }
-	| '*' abstract_declarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list abstract_declarator
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' abstract_ptr ')'
-		{ $$ = $2; }
-	;
-
-abstract_array:
-	array_dimension
-	| '(' abstract_ptr ')' array_dimension
-		{ $$ = $2->addArray( $4 ); }
-	| '(' abstract_array ')' multi_array_dimension		// redundant parenthesis
-		{ $$ = $2->addArray( $4 ); }
-	| '(' abstract_array ')'							// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-abstract_function:
-	'(' push parameter_type_list_opt pop ')'			// empty parameter list OBSOLESCENT (see 3)
-		{ $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); }
-	| '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $6 ); }
-	| '(' abstract_function ')'							// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-array_dimension:
-		// Only the first dimension can be empty.
-	'[' push pop ']'
-		{ $$ = DeclarationNode::newArray( 0, 0, false ); }
-	| '[' push pop ']' multi_array_dimension
-		{ $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $5 ); }
-	| multi_array_dimension
-	;
-
-multi_array_dimension:
-	'[' push assignment_expression pop ']'
-		{ $$ = DeclarationNode::newArray( $3, 0, false ); }
-	| '[' push '*' pop ']'								// C99
-		{ $$ = DeclarationNode::newVarArray( 0 ); }
-	| multi_array_dimension '[' push assignment_expression pop ']'
-		{ $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
-	| multi_array_dimension '[' push '*' pop ']'		// C99
-		{ $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
-	;
-
-// This pattern parses a declaration of a parameter abstract variable or function prototype, i.e., there is no
-// identifier to which the type applies, e.g.:
-//
-//		int f( int );			// abstract variable parameter; no parameter name specified
-//		int f( int (int) );		// abstract function-prototype parameter; no parameter name specified
-//
-// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
-// and functions versus pointers to arrays and functions.
-
-abstract_parameter_declarator:
-	abstract_parameter_ptr
-	| abstract_parameter_array attribute_list_opt
-	| abstract_parameter_function attribute_list_opt
-	;
-
-abstract_parameter_ptr:
-	'*'
-		{ $$ = DeclarationNode::newPointer( 0 ); }
-	| '*' type_qualifier_list
-		{ $$ = DeclarationNode::newPointer( $2 ); }
-	| '*' abstract_parameter_declarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list abstract_parameter_declarator
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' abstract_parameter_ptr ')'
-		{ $$ = $2; }
-	;
-
-abstract_parameter_array:
-	array_parameter_dimension
-	| '(' abstract_parameter_ptr ')' array_parameter_dimension
-		{ $$ = $2->addArray( $4 ); }
-	| '(' abstract_parameter_array ')' multi_array_dimension // redundant parenthesis
-		{ $$ = $2->addArray( $4 ); }
-	| '(' abstract_parameter_array ')'					// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-abstract_parameter_function:
-	'(' push parameter_type_list_opt pop ')'			// empty parameter list OBSOLESCENT (see 3)
-		{ $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); }
-	| '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $6 ); }
-	| '(' abstract_parameter_function ')'				// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-array_parameter_dimension:
-		// Only the first dimension can be empty or have qualifiers.
-	array_parameter_1st_dimension
-	| array_parameter_1st_dimension multi_array_dimension
-		{ $$ = $1->addArray( $2 ); }
-	| multi_array_dimension
-	;
-
-// The declaration of an array parameter has additional syntax over arrays in normal variable declarations:
-//
-//		ISO/IEC 9899:1999 Section 6.7.5.2(1) : "The optional type qualifiers and the keyword static shall appear only in
-//		a declaration of a function parameter with an array type, and then only in the outermost array type derivation."
-
-array_parameter_1st_dimension:
-	'[' push pop ']'
-		{ $$ = DeclarationNode::newArray( 0, 0, false ); }
-	// multi_array_dimension handles the '[' '*' ']' case
-	| '[' push type_qualifier_list '*' pop ']'			// remaining C99
-		{ $$ = DeclarationNode::newVarArray( $3 ); }
-	| '[' push type_qualifier_list pop ']'
-		{ $$ = DeclarationNode::newArray( 0, $3, false ); }
-	// multi_array_dimension handles the '[' assignment_expression ']' case
-	| '[' push type_qualifier_list assignment_expression pop ']'
-		{ $$ = DeclarationNode::newArray( $4, $3, false ); }
-	| '[' push STATIC type_qualifier_list_opt assignment_expression pop ']'
-		{ $$ = DeclarationNode::newArray( $5, $4, true ); }
-	| '[' push type_qualifier_list STATIC assignment_expression pop ']'
-		{ $$ = DeclarationNode::newArray( $5, $3, true ); }
-	;
-
-// This pattern parses a declaration of an abstract variable, i.e., there is no identifier to which the type applies,
-// e.g.:
-//
-//		sizeof( int ); // abstract variable; no identifier name specified
-//
-// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
-// and functions versus pointers to arrays and functions.
-
-variable_abstract_declarator:
-	variable_abstract_ptr
-	| variable_abstract_array attribute_list_opt
-	| variable_abstract_function attribute_list_opt
-	;
-
-variable_abstract_ptr:
-	'*'
-		{ $$ = DeclarationNode::newPointer( 0 ); }
-	| '*' type_qualifier_list
-		{ $$ = DeclarationNode::newPointer( $2 ); }
-	| '*' variable_abstract_declarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list variable_abstract_declarator
-		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' variable_abstract_ptr ')'
-		{ $$ = $2; }
-	;
-
-variable_abstract_array:
-	array_dimension
-	| '(' variable_abstract_ptr ')' array_dimension
-		{ $$ = $2->addArray( $4 ); }
-	| '(' variable_abstract_array ')' multi_array_dimension // redundant parenthesis
-		{ $$ = $2->addArray( $4 ); }
-	| '(' variable_abstract_array ')'					// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-variable_abstract_function:
-	'(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $6 ); }
-	| '(' variable_abstract_function ')'				// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-// This pattern parses a new-style declaration for a parameter variable or function prototype that is either an
-// identifier or typedef name and allows the C99 array options, which can only appear in a parameter list.
-
-new_identifier_parameter_declarator_tuple:				// CFA
-	new_identifier_parameter_declarator_no_tuple
-	| new_abstract_tuple
-	| type_qualifier_list new_abstract_tuple
-		{ $$ = $2->addQualifiers( $1 ); }
-	;
-
-new_identifier_parameter_declarator_no_tuple:			// CFA
-	new_identifier_parameter_ptr
-	| new_identifier_parameter_array
-	;
-
-new_identifier_parameter_ptr:							// CFA
-	'*' type_specifier
-		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list '*' type_specifier
-		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	| '*' new_abstract_function
-		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list '*' new_abstract_function
-		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	| '*' new_identifier_parameter_declarator_tuple
-		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list '*' new_identifier_parameter_declarator_tuple
-		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	;
-
-new_identifier_parameter_array:							// CFA
-		// Only the first dimension can be empty or have qualifiers. Empty dimension must be factored out due to
-		// shift/reduce conflict with new-style empty (void) function return type.
-	'[' push pop ']' type_specifier
-		{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| new_array_parameter_1st_dimension type_specifier
-		{ $$ = $2->addNewArray( $1 ); }
-	| '[' push pop ']' multi_array_dimension type_specifier
-		{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| new_array_parameter_1st_dimension multi_array_dimension type_specifier
-		{ $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
-	| multi_array_dimension type_specifier
-		{ $$ = $2->addNewArray( $1 ); }
-	| '[' push pop ']' new_identifier_parameter_ptr
-		{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| new_array_parameter_1st_dimension new_identifier_parameter_ptr
-		{ $$ = $2->addNewArray( $1 ); }
-	| '[' push pop ']' multi_array_dimension new_identifier_parameter_ptr
-		{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| new_array_parameter_1st_dimension multi_array_dimension new_identifier_parameter_ptr
-		{ $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
-	| multi_array_dimension new_identifier_parameter_ptr
-		{ $$ = $2->addNewArray( $1 ); }
-	;
-
-new_array_parameter_1st_dimension:
-	'[' push type_qualifier_list '*' pop ']'			// remaining C99
-		{ $$ = DeclarationNode::newVarArray( $3 ); }
-	| '[' push type_qualifier_list assignment_expression pop ']'
-		{ $$ = DeclarationNode::newArray( $4, $3, false ); }
-	| '[' push declaration_qualifier_list assignment_expression pop ']'
-		// declaration_qualifier_list must be used because of shift/reduce conflict with
-		// assignment_expression, so a semantic check is necessary to preclude them as a type_qualifier cannot
-		// appear in this context.
-		{ $$ = DeclarationNode::newArray( $4, $3, true ); }
-	| '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']'
-		{ $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); }
-	;
-
-// This pattern parses a new-style declaration of an abstract variable or function prototype, i.e., there is no
-// identifier to which the type applies, e.g.:
-//
-//		[int] f( int );				// abstract variable parameter; no parameter name specified
-//		[int] f( [int] (int) );		// abstract function-prototype parameter; no parameter name specified
-//
-// These rules need LR(3):
-//
-//		new_abstract_tuple identifier_or_typedef_name
-//		'[' new_parameter_list ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')'
-//
-// since a function return type can be syntactically identical to a tuple type:
-//
-//		[int, int] t;
-//		[int, int] f( int );
-//
-// Therefore, it is necessary to look at the token after identifier_or_typedef_name to know when to reduce
-// new_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow the necessary
-// lookahead. To accomplish this, new_abstract_declarator has an entry point without tuple, and tuple declarations are
-// duplicated when appearing with new_function_specifier.
-
-new_abstract_declarator_tuple:							// CFA
-	new_abstract_tuple
-	| type_qualifier_list new_abstract_tuple
-		{ $$ = $2->addQualifiers( $1 ); }
-	| new_abstract_declarator_no_tuple
-	;
-
-new_abstract_declarator_no_tuple:						// CFA
-	new_abstract_ptr
-	| new_abstract_array
-	;
-
-new_abstract_ptr:										// CFA
-	'*' type_specifier
-		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list '*' type_specifier
-		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	| '*' new_abstract_function
-		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list '*' new_abstract_function
-		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	| '*' new_abstract_declarator_tuple
-		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list '*' new_abstract_declarator_tuple
-		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	;
-
-new_abstract_array:										// CFA
-		// Only the first dimension can be empty. Empty dimension must be factored out due to shift/reduce conflict with
-		// empty (void) function return type.
-	'[' push pop ']' type_specifier
-		{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| '[' push pop ']' multi_array_dimension type_specifier
-		{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| multi_array_dimension type_specifier
-		{ $$ = $2->addNewArray( $1 ); }
-	| '[' push pop ']' new_abstract_ptr
-		{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| '[' push pop ']' multi_array_dimension new_abstract_ptr
-		{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| multi_array_dimension new_abstract_ptr
-		{ $$ = $2->addNewArray( $1 ); }
-	;
-
-new_abstract_tuple:										// CFA
-	'[' push new_abstract_parameter_list pop ']'
-		{ $$ = DeclarationNode::newTuple( $3 ); }
-	;
-
-new_abstract_function:									// CFA
-	'[' push pop ']' '(' new_parameter_type_list_opt ')'
-		{ $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $6, 0 ); }
-	| new_abstract_tuple '(' push new_parameter_type_list_opt pop ')'
-		{ $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); }
-	| new_function_return '(' push new_parameter_type_list_opt pop ')'
-		{ $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); }
-	;
-
-// 1) ISO/IEC 9899:1999 Section 6.7.2(2) : "At least one type specifier shall be given in the declaration specifiers in
-//    each declaration, and in the specifier-qualifier list in each structure declaration and type name."
-//
-// 2) ISO/IEC 9899:1999 Section 6.11.5(1) : "The placement of a storage-class specifier other than at the beginning of
-//    the declaration specifiers in a declaration is an obsolescent feature."
-//
-// 3) ISO/IEC 9899:1999 Section 6.11.6(1) : "The use of function declarators with empty parentheses (not
-//    prototype-format parameter type declarators) is an obsolescent feature."
-//
-// 4) ISO/IEC 9899:1999 Section 6.11.7(1) : "The use of function definitions with separate parameter identifier and
-//    declaration lists (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
-
-//************************* MISCELLANEOUS ********************************
-
-comma_opt:												// redundant comma
-	// empty
-	| ','
-	;
-
-assignment_opt:
-	// empty
-		{ $$ = 0; }
-	| '=' assignment_expression
-		{ $$ = $2; }
-	;
-
-%%
-// ----end of grammar----
-
-void yyerror( const char * ) {
-	std::cout << "Error ";
-	if ( yyfilename ) {
-	    std::cout << "in file " << yyfilename << " ";
-	} // if
-	std::cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << std::endl;
-}
-
-// Local Variables: //
-// mode: c++ //
-// tab-width: 4 //
-// compile-command: "make install" //
-// End: //