Changeset 7756647

Timestamp:

Oct 13, 2016, 2:45:17 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

848ce71

Parents:

ac9ca96 (diff), d58a39a0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into tuples

Conflicts:

src/Parser/TypeData.cc
src/Parser/parser.cc
src/Parser/parser.yy

Files:

• doc/aaron_comp_II/Efficient Type Resolution in Cforall.pptx (added)
• doc/aaron_comp_II/comp_II.tex (modified) (2 diffs)
• doc/aaron_comp_II/conversion_dag.png (added)
• doc/aaron_comp_II/resolution_dag.png (added)
• doc/aaron_comp_II/resolution_dag2.odg (added)
• doc/aaron_comp_II/resolution_dag2.png (added)
• doc/proposals/concurrency/Makefile (added)
• doc/proposals/concurrency/concurrency.tex (added)
• doc/proposals/concurrency/glossary.tex (added)
• doc/proposals/concurrency/local.bib (added)
• src/Common/DebugMalloc.cc (added)
• src/Common/SemanticError.h (modified) (2 diffs)
• src/Common/module.mk (modified) (1 diff)
• src/Common/utility.h (modified) (5 diffs)
• src/Makefile.am (modified) (2 diffs)
• src/Makefile.in (modified) (7 diffs)
• src/Parser/DeclarationNode.cc (modified) (62 diffs)
• src/Parser/ExpressionNode.cc (modified) (2 diffs)
• src/Parser/InitializerNode.cc (modified) (4 diffs)
• src/Parser/LinkageSpec.cc (modified) (4 diffs)
• src/Parser/LinkageSpec.h (modified) (2 diffs)
• src/Parser/ParseNode.cc (modified) (2 diffs)
• src/Parser/ParseNode.h (modified) (16 diffs)
• src/Parser/TypeData.cc (modified) (33 diffs)
• src/Parser/TypeData.h (modified) (6 diffs)
• src/Parser/parser.cc (modified) (130 diffs)
• src/Parser/parser.h (modified) (1 diff)
• src/Parser/parser.yy (modified) (19 diffs)
• src/SynTree/FunctionDecl.cc (modified) (2 diffs)
• src/SynTree/ObjectDecl.cc (modified) (2 diffs)
• src/libcfa/memcheck.awk (added)

doc/aaron_comp_II/comp_II.tex

@@ -400 +400 @@
 
 \section{Expression Resolution}
+\subsection{Analysis}
 The expression resolution problem is determining an optimal match between some combination of argument interpretations and the parameter list of some overloaded instance of a function; the argument interpretations are produced by recursive invocations of expression resolution, where the base case is zero-argument functions (which are, for purposes of this discussion, semantically equivalent to named variables or constant literal expressions). 
 Assuming that the matching between a function's parameter list and a combination of argument interpretations can be done in $\bigO{p^k}$ time, where $p$ is the number of parameters and $k$ is some positive number, if there are $\bigO{i}$ valid interpretations for each subexpression, there will be $\bigO{i}$ candidate functions and $\bigO{i^p}$ possible argument combinations for each expression, so for a single recursive call expression resolution takes $\bigO{i^{p+1} \cdot p^k}$ time if it must compare all combinations, or $\bigO{i(p+1) \cdot p^k}$ time if argument-parameter matches can be chosen independently of each other. 
@@ -409 +410 @@
 The number of valid interpretations of any subexpression, $i$, is bounded by the number of types in the system, which is possibly infinite, though practical resolution algorithms for \CFA must be able to place some finite bound on $i$, possibly at the expense of type-system completeness. 
 
+\subsection{Expression Costs}
+The expression resolution problem involves minimization of a cost function; loosely defined, this cost function is the number of implicit conversions in the top-level expression interpretation. 
+With more specificity, the \emph{cost} of a particular expression interpretation is a lexicographically-ordered tuple, where each element of the tuple corresponds to a particular kind of conversion. 
+In \CFA today, cost is a three-tuple including the number of unsafe conversions, the number of polymorphic parameter bindings, and the number of safe conversions. 
+These counts include conversions used in subexpression interpretations, as well as those necessary to satisfy the type assertions of any polymorphic functions included in the interpretation. 
+
+\begin{lstlisting}
+void f(char, long);  // $f_1$ - cost (2, 0, 1)
+forall(otype T) void f(T, long); // $f_2$ - cost (0, 1, 1)
+void f(long, long); // $f_{3a}$ - cost (0, 0, 2)
+void f(int, float); // $f_{3b}$ - cost (0, 0, 2)
+void f(int, long);  // $f_4$ - cost (0, 0, 1)
+
+f(7, 11);
+\end{lstlisting}
+
+In the example above, the expression resolves to $f_4$. 
+$f_1$ has an unsafe conversion (from ©int© to ©char©), and is thus the highest cost, followed by $f_2$, which has a polymorphic binding (from ©int© to ©T©). 
+Neither $f_{3a}$, $f_{3b}$, or $f_4$ match exactly with the type of the call expression (©void (*)(int, int)©), each involving safe conversions, but in this case $f_4$ is cheaper than $f_{3a}$, because it converts fewer arguments, and is also cheaper than $f_{3b}$, because ©long© is a closer match for ©int© than ©float© is. 
+If the declaration of $f_4$ was missing, the expression would be ambiguous, because the two single-step ©int©-to-©long© conversions in $f_{3a}$ cost the same as the one double-step ©int©-to-©float© conversion in $f_{3b}$.
+
+In the course of this project I may modify the cost tuple,\footnote{I have considered adding an element to distinguish between cast expressions used as conversions and those used as type ascriptions, and another element to differentiate interpretations based on closer qualifier matches. The existing costing of polymorphic functions could also be made more precice than a bare count of parameter bindings.} but the essential nature of the cost calculation should remain the same.
+
+\subsection{Objectives}
 The research goal of this project is to develop a performant expression resolver for \CFA; this analysis suggests three primary areas of investigation to accomplish that end. 
 The first area of investigation is efficient argument-parameter matching; Bilson~\cite{Bilson03} mentions significant optimization opportunities available in the current literature to improve on the existing CFA compiler.

src/Common/SemanticError.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun  8 14:38:53 2015
-// Update Count     : 4
+// Last Modified On : Sat Sep 24 15:13:42 2016
+// Update Count     : 5
 //
 
@@ -46 +46 @@
 }
 
-
 #endif // SEMANTICERROR_H
 

src/Common/module.mk

@@ -11 +11 @@
 ## Created On       : Mon Jun  1 17:49:17 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Thu Aug 18 13:29:04 2016
-## Update Count     : 2
+## Last Modified On : Tue Sep 27 11:06:38 2016
+## Update Count     : 4
 ###############################################################################
 
 SRC += Common/SemanticError.cc \
        Common/UniqueName.cc \
+       Common/DebugMalloc.cc \
        Common/Assert.cc

src/Common/utility.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun  8 17:33:59 2016
-// Update Count     : 22
+// Last Modified On : Fri Sep 23 11:46:47 2016
+// Update Count     : 28
 //
 
@@ -25 +25 @@
 #include <sstream>
 #include <string>
+#include <cassert>
 
 template< typename T >
@@ -101 +102 @@
                 } // if
         } // for
-}
-
-static inline std::string assign_strptr( const std::string *str ) {
-        if ( str == 0 ) {
-                return "";
-        } else {
-                std::string tmp;
-                tmp = *str;
-                delete str;
-                return tmp;
-        } // if
 }
 
@@ -141 +131 @@
 
 template < typename T >
-void toString_single ( std::ostream & os, const T & value ) {
+void toString_single( std::ostream & os, const T & value ) {
         os << value;
 }
 
 template < typename T, typename... Params >
-void toString_single ( std::ostream & os, const T & value, const Params & ... params ) {
+void toString_single( std::ostream & os, const T & value, const Params & ... params ) {
         os << value;
         toString_single( os, params ... );
@@ -152 +142 @@
 
 template < typename ... Params >
-std::string toString ( const Params & ... params ) {
+std::string toString( const Params & ... params ) {
         std::ostringstream os;
         toString_single( os, params... );

src/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 08:51:46 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Sat Aug 20 11:13:12 2016
-## Update Count     : 71
+## Last Modified On : Sat Sep 24 15:03:52 2016
+## Update Count     : 73
 ###############################################################################
 
@@ -40 +40 @@
 cfa_cpplib_PROGRAMS = driver/cfa-cpp
 driver_cfa_cpp_SOURCES = ${SRC}
-driver_cfa_cpp_LDADD = ${LEXLIB}                        # yywrap
+driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include
 

src/Makefile.in

@@ -98 +98 @@
         Common/driver_cfa_cpp-SemanticError.$(OBJEXT) \
         Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \
+        Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) \
         Common/driver_cfa_cpp-Assert.$(OBJEXT) \
         ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT) \
@@ -358 +359 @@
         CodeGen/CodeGenerator.cc CodeGen/GenType.cc \
         CodeGen/FixNames.cc CodeGen/OperatorTable.cc \
-        Common/SemanticError.cc Common/UniqueName.cc Common/Assert.cc \
+        Common/SemanticError.cc Common/UniqueName.cc \
+        Common/DebugMalloc.cc Common/Assert.cc \
         ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
         ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
@@ -412 +414 @@
 cfa_cpplibdir = ${libdir}
 driver_cfa_cpp_SOURCES = ${SRC}
-driver_cfa_cpp_LDADD = ${LEXLIB}                        # yywrap
+driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include
 all: $(BUILT_SOURCES)
@@ -512 +514 @@
         Common/$(DEPDIR)/$(am__dirstamp)
 Common/driver_cfa_cpp-UniqueName.$(OBJEXT): Common/$(am__dirstamp) \
+        Common/$(DEPDIR)/$(am__dirstamp)
+Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
 Common/driver_cfa_cpp-Assert.$(OBJEXT): Common/$(am__dirstamp) \
@@ -784 +788 @@
         -rm -f CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT)
         -rm -f Common/driver_cfa_cpp-Assert.$(OBJEXT)
+        -rm -f Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT)
         -rm -f Common/driver_cfa_cpp-SemanticError.$(OBJEXT)
         -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT)
@@ -889 +894 @@
 @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/driver_cfa_cpp-OperatorTable.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@
@@ -1125 +1131 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-UniqueName.obj `if test -f 'Common/UniqueName.cc'; then $(CYGPATH_W) 'Common/UniqueName.cc'; else $(CYGPATH_W) '$(srcdir)/Common/UniqueName.cc'; fi`
 
+Common/driver_cfa_cpp-DebugMalloc.o: Common/DebugMalloc.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc
+
+Common/driver_cfa_cpp-DebugMalloc.obj: Common/DebugMalloc.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.obj -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi`
+
 Common/driver_cfa_cpp-Assert.o: Common/Assert.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-Assert.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo -c -o Common/driver_cfa_cpp-Assert.o `test -f 'Common/Assert.cc' || echo '$(srcdir)/'`Common/Assert.cc

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Sep 14 23:13:28 2016
-// Update Count     : 502
+// Last Modified On : Mon Oct  3 18:03:08 2016
+// Update Count     : 651
 //
 
@@ -31 +31 @@
 
 // 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", "NoStorageClass" };
-const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
-const char *DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
-const char *DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
-const char *DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
-const char *DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
-const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" };
-const char *DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
-const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
+const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
+const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
+const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
+const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
+const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
+const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
+const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" };
+const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
+const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
 
 UniqueName DeclarationNode::anonymous( "__anonymous" );
@@ -46 +46 @@
 
 DeclarationNode::DeclarationNode() :
-                type( 0 ),
+                type( nullptr ),
                 storageClass( NoStorageClass ),
                 isInline( false ),
                 isNoreturn( false ),
-                bitfieldWidth( 0 ),
-                initializer( 0 ),
+                bitfieldWidth( nullptr ),
+                initializer( nullptr ),
                 hasEllipsis( false ),
                 linkage( ::linkage ),
                 extension( false ) {
-        variable.tyClass = DeclarationNode::Otype;
+
+//      variable.name = nullptr;
+        variable.tyClass = NoTypeClass;
         variable.assertions = nullptr;
 
+//      attr.name = nullptr;
         attr.expr = nullptr;
         attr.type = nullptr;
@@ -63 +66 @@
 
 DeclarationNode::~DeclarationNode() {
+//      delete attr.name;
         delete attr.expr;
         delete attr.type;
+
+//      delete variable.name;
+        delete variable.assertions;
+
         delete type;
         delete bitfieldWidth;
@@ -70 +78 @@
 }
 
-DeclarationNode *DeclarationNode::clone() const {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::clone() const {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
-        newnode->name = name;
+        newnode->name = name ? new string( *name ) : nullptr;
         newnode->storageClass = storageClass;
         newnode->isInline = isInline;
@@ -83 +91 @@
         newnode->linkage = linkage;
 
+//      newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
+        newnode->variable.tyClass = variable.tyClass;
         newnode->variable.assertions = maybeClone( variable.assertions );
-        newnode->variable.name = variable.name;
-        newnode->variable.tyClass = variable.tyClass;
-
+
+//      newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
         newnode->attr.expr = maybeClone( attr.expr );
         newnode->attr.type = maybeClone( attr.type );
@@ -98 +107 @@
 void DeclarationNode::print( std::ostream &os, int indent ) const {
         os << string( indent, ' ' );
-        if ( name == "" ) {
+        if ( name ) {
+                os << *name << ": ";
+        } else {
                 os << "unnamed: ";
-        } else {
-                os << name << ": ";
         } // if
 
         if ( linkage != LinkageSpec::Cforall ) {
-                os << LinkageSpec::toString( linkage ) << " ";
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
 
@@ -122 +131 @@
         } // if
 
-        if ( initializer != 0 ) {
+        if ( initializer ) {
                 os << endl << string( indent + 2, ' ' ) << "with initializer ";
                 initializer->printOneLine( os );
@@ -139 +148 @@
 }
 
-DeclarationNode *DeclarationNode::newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
-
+DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
         newnode->type = new TypeData( TypeData::Function );
         newnode->type->function.params = param;
         newnode->type->function.newStyle = newStyle;
         newnode->type->function.body = body;
-        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
+        // ignore unnamed routine declarations: void p( int (*)(int) );
+        if ( newnode->name ) {
+                typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
+        } // if
 
         if ( body ) {
@@ -155 +166 @@
         if ( ret ) {
                 newnode->type->base = ret->type;
-                ret->type = 0;
+                ret->type = nullptr;
                 delete ret;
         } // if
@@ -163 +174 @@
 
 DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData();
         newnode->type->qualifiers[ q ] = 1;
@@ -169 +180 @@
 } // DeclarationNode::newQualifier
 
-DeclarationNode * DeclarationNode::newForall( DeclarationNode *forall ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Unknown );
         newnode->type->forall = forall;
@@ -177 +188 @@
 
 DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        //switch (sc) {
-        //      case Inline: newnode->isInline = true; break;
-        //      case Noreturn: newnode->isNoreturn = true; break;
-        //      default: newnode->storageClass = sc; break;
-        //}
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->storageClass = sc;
         return newnode;
@@ -188 +194 @@
 
 DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
         newnode->type->basictype = bt;
@@ -195 +201 @@
 
 DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
         newnode->type->complextype = ct;
@@ -202 +208 @@
 
 DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
         newnode->type->signedness = sn;
@@ -209 +215 @@
 
 DeclarationNode * DeclarationNode::newLength( Length lnth ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
         newnode->type->length = lnth;
@@ -215 +221 @@
 } // DeclarationNode::newLength
 
-DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::SymbolicInst );
-        newnode->type->symbolic.name = assign_strptr( name );
+        newnode->type->symbolic.name = name;
         newnode->type->symbolic.isTypedef = true;
-        newnode->type->symbolic.params = 0;
+        newnode->type->symbolic.params = nullptr;
         return newnode;
 } // DeclarationNode::newFromTypedef
 
-DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.kind = kind;
-        newnode->type->aggregate.name = assign_strptr( name );
-        if ( newnode->type->aggregate.name == "" ) {            // anonymous aggregate ?
-                newnode->type->aggregate.name = anonymous.newName();
+        if ( name ) {
+                newnode->type->aggregate.name = name;
+        } else {                                                                                        // anonymous aggregate ?
+                newnode->type->aggregate.name = new string( anonymous.newName() );
         } // if
         newnode->type->aggregate.actuals = actuals;
@@ -238 +245 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
-        newnode->type->enumeration.name = newnode->name;
-        if ( newnode->type->enumeration.name == "" ) {          // anonymous enumeration ?
-                newnode->type->enumeration.name = DeclarationNode::anonymous.newName();
+        if ( name ) {
+                newnode->type->enumeration.name = name;
+        } else {                                                                                        // anonymous aggregate ?
+                newnode->type->enumeration.name = new string( anonymous.newName() );
         } // if
         newnode->type->enumeration.constants = constants;
@@ -250 +257 @@
 } // DeclarationNode::newEnum
 
-DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newEnumConstant( string * name, ExpressionNode * constant ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
         newnode->enumeratorValue.reset( constant );
-        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
+        typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
         return newnode;
 } // DeclarationNode::newEnumConstant
 
-DeclarationNode *DeclarationNode::newName( std::string *name ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newName( string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
         return newnode;
 } // DeclarationNode::newName
 
-DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newFromTypeGen( string * name, ExpressionNode * params ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::SymbolicInst );
-        newnode->type->symbolic.name = assign_strptr( name );
+        newnode->type->symbolic.name = name;
         newnode->type->symbolic.isTypedef = false;
         newnode->type->symbolic.actuals = params;
@@ -273 +280 @@
 } // DeclarationNode::newFromTypeGen
 
-DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
-        newnode->type = new TypeData( TypeData::Variable );
+DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = nullptr;
+        assert( ! newnode->name ); 
+//      newnode->variable.name = name;
+        newnode->name = name;
         newnode->variable.tyClass = tc;
-        newnode->variable.name = newnode->name;
+        newnode->variable.assertions = nullptr;
         return newnode;
 } // DeclarationNode::newTypeParam
 
-DeclarationNode *DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newTrait( const string * name, DeclarationNode * params, DeclarationNode * asserts ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
+        newnode->type->aggregate.name = name;
         newnode->type->aggregate.kind = Trait;
         newnode->type->aggregate.params = params;
         newnode->type->aggregate.fields = asserts;
-        newnode->type->aggregate.name = assign_strptr( name );
         return newnode;
 } // DeclarationNode::newTrait
 
-DeclarationNode *DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newTraitUse( const string * name, ExpressionNode * params ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::AggregateInst );
         newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate );
         newnode->type->aggInst.aggregate->aggregate.kind = Trait;
-        newnode->type->aggInst.aggregate->aggregate.name = assign_strptr( name );
+        newnode->type->aggInst.aggregate->aggregate.name = name;
         newnode->type->aggInst.params = params;
         return newnode;
 } // DeclarationNode::newTraitUse
 
-DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Symbolic );
         newnode->type->symbolic.isTypedef = false;
         newnode->type->symbolic.params = typeParams;
-        newnode->type->symbolic.name = newnode->name;
+        newnode->type->symbolic.name = name;
         return newnode;
 } // DeclarationNode::newTypeDecl
 
-DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Pointer );
         return newnode->addQualifiers( qualifiers );
 } // DeclarationNode::newPointer
 
-DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Array );
         newnode->type->array.dimension = size;
         newnode->type->array.isStatic = isStatic;
-        if ( newnode->type->array.dimension == 0 || newnode->type->array.dimension->isExpressionType<ConstantExpr *>() ) {
+        if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ConstantExpr * >() ) {
                 newnode->type->array.isVarLen = false;
         } else {
@@ -331 +339 @@
 } // DeclarationNode::newArray
 
-DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newVarArray( DeclarationNode * qualifiers ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Array );
-        newnode->type->array.dimension = 0;
+        newnode->type->array.dimension = nullptr;
         newnode->type->array.isStatic = false;
         newnode->type->array.isVarLen = true;
@@ -340 +348 @@
 }
 
-DeclarationNode *DeclarationNode::newBitfield( ExpressionNode *size ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newBitfield( ExpressionNode * size ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->bitfieldWidth = size;
         return newnode;
 }
 
-DeclarationNode *DeclarationNode::newTuple( DeclarationNode *members ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newTuple( DeclarationNode * members ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Tuple );
         newnode->type->tuple = members;
@@ -353 +361 @@
 }
 
-DeclarationNode *DeclarationNode::newTypeof( ExpressionNode *expr ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Typeof );
         newnode->type->typeexpr = expr;
@@ -361 +369 @@
 
 DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Builtin );
         newnode->builtin = bt;
@@ -367 +375 @@
 } // DeclarationNode::newBuiltinType
 
-DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Attr );
-        newnode->attr.name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newAttr( string * name, ExpressionNode * expr ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = nullptr;
+//      newnode->attr.name = name;
+        newnode->name = name;
         newnode->attr.expr = expr;
         return newnode;
 }
 
-DeclarationNode *DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Attr );
-        newnode->attr.name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newAttr( string * name, DeclarationNode * type ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = nullptr;
+//      newnode->attr.name = name;
+        newnode->name = name;
         newnode->attr.type = type;
         return newnode;
@@ -389 +399 @@
 } // appendError
 
-void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) {
+void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
         TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
 
@@ -401 +411 @@
 } // DeclarationNode::checkQualifiers
 
-void DeclarationNode::checkStorageClasses( DeclarationNode *q ) {
+void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {
         if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
                 if ( storageClass == q->storageClass ) {                // duplicate qualifier
@@ -413 +423 @@
 } // DeclarationNode::copyStorageClasses
 
-DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
+DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
         isInline = isInline || q->isInline;
         isNoreturn = isNoreturn || q->isNoreturn;
@@ -424 +434 @@
 } // DeclarationNode::copyStorageClasses
 
-static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
+static void addQualifiersToType( TypeData *&src, TypeData * dst ) {
         if ( src->forall && dst->kind == TypeData::Function ) {
                 if ( dst->forall ) {
@@ -431 +441 @@
                         dst->forall = src->forall;
                 } // if
-                src->forall = 0;
+                src->forall = nullptr;
         } // if
         if ( dst->base ) {
@@ -437 +447 @@
         } else if ( dst->kind == TypeData::Function ) {
                 dst->base = src;
-                src = 0;
+                src = nullptr;
         } else {
                 dst->qualifiers |= src->qualifiers;
@@ -443 +453 @@
 } // addQualifiersToType
 
-DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
-        if ( ! q ) return this;
+DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode * q ) {
+        if ( ! q ) { delete q; return this; }
 
         checkStorageClasses( q );
         copyStorageClasses( q );
 
-        if ( ! q->type ) { delete q; return this; }
+        if ( ! q->type ) {
+                delete q;
+                return this;
+        } // if
 
         if ( ! type ) {
-//              type = new TypeData;
-                type = q->type;
+                type = q->type;                                                                 // reuse this structure
+                q->type = nullptr;
+                delete q;
                 return this;
         } // if
@@ -467 +481 @@
                                 type->aggregate.params = q->type->forall;
                                 // change implicit typedef from TYPEDEFname to TYPEGENname
-                                typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );
+                                typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG );
                         } else {
                                 type->forall = q->type->forall;
                         } // if
                 } // if
-                q->type->forall = 0;
+                q->type->forall = nullptr;
         } // if
         delete q;
@@ -485 +499 @@
                         dst->forall = src->forall;
                 } // if
-                src->forall = 0;
+                src->forall = nullptr;
         } // if
         if ( dst->base ) {
@@ -494 +508 @@
                         src->qualifiers |= dst->qualifiers;
                         dst = src;
-                        src = 0;
+                        src = nullptr;
                         break;
                   case TypeData::Basic:
@@ -504 +518 @@
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
 
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
 
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
 
                                 if ( dst->length == DeclarationNode::NoLength ) {
@@ -521 +535 @@
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
-                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
                         } // if
                         break;
@@ -534 +548 @@
                                 } // if
                                 dst->base->qualifiers |= src->qualifiers;
-                                src = 0;
+                                src = nullptr;
                                 break;
                           default:
@@ -542 +556 @@
                                         dst->forall = src->forall;
                                 } // if
-                                src->forall = 0;
+                                src->forall = nullptr;
                                 dst->base = src;
-                                src = 0;
+                                src = nullptr;
                         } // switch
                 } // switch
@@ -550 +564 @@
 }
 
-DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
+DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) {
         if ( o ) {
                 checkStorageClasses( o );
@@ -566 +580 @@
                                         type = o->type;
                                 } // if
-                                o->type = 0;
+                                o->type = nullptr;
                         } else {
                                 addTypeToType( o->type, type );
@@ -584 +598 @@
 }
 
-DeclarationNode *DeclarationNode::addTypedef() {
-        TypeData *newtype = new TypeData( TypeData::Symbolic );
-        newtype->symbolic.params = 0;
+DeclarationNode * DeclarationNode::addTypedef() {
+        TypeData * newtype = new TypeData( TypeData::Symbolic );
+        newtype->symbolic.params = nullptr;
         newtype->symbolic.isTypedef = true;
-        newtype->symbolic.name = name;
+        newtype->symbolic.name = name ? new string( *name ) : nullptr;
         newtype->base = type;
         type = newtype;
@@ -594 +608 @@
 }
 
-DeclarationNode *DeclarationNode::addAssertions( DeclarationNode *assertions ) {
+DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
+        if ( variable.tyClass != NoTypeClass ) {
+                if ( variable.assertions ) {
+                        variable.assertions->appendList( assertions );
+                } else {
+                        variable.assertions = assertions;
+                } // if
+                return this;
+        } // if
+
         assert( type );
         switch ( type->kind ) {
@@ -604 +627 @@
                 } // if
                 break;
-          case TypeData::Variable:
-                if ( variable.assertions ) {
-                        variable.assertions->appendList( assertions );
-                } else {
-                        variable.assertions = assertions;
-                } // if
-                break;
           default:
                 assert( false );
@@ -618 +634 @@
 }
 
-DeclarationNode *DeclarationNode::addName( std::string *newname ) {
-        name = assign_strptr( newname );
-        return this;
-}
-
-DeclarationNode *DeclarationNode::addBitfield( ExpressionNode *size ) {
+DeclarationNode * DeclarationNode::addName( string * newname ) {
+        assert( ! name );
+        name = newname;
+        return this;
+}
+
+DeclarationNode * DeclarationNode::addBitfield( ExpressionNode * size ) {
         bitfieldWidth = size;
         return this;
 }
 
-DeclarationNode *DeclarationNode::addVarArgs() {
+DeclarationNode * DeclarationNode::addVarArgs() {
         assert( type );
         hasEllipsis = true;
@@ -634 +651 @@
 }
 
-DeclarationNode *DeclarationNode::addFunctionBody( StatementNode *body ) {
+DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body ) {
         assert( type );
         assert( type->kind == TypeData::Function );
-        assert( type->function.body == 0 );
+        assert( ! type->function.body );
         type->function.body = body;
         type->function.hasBody = true;
@@ -643 +660 @@
 }
 
-DeclarationNode *DeclarationNode::addOldDeclList( DeclarationNode *list ) {
+DeclarationNode * DeclarationNode::addOldDeclList( DeclarationNode * list ) {
         assert( type );
         assert( type->kind == TypeData::Function );
-        assert( type->function.oldDeclList == 0 );
+        assert( ! type->function.oldDeclList );
         type->function.oldDeclList = list;
         return this;
 }
 
-static void setBase( TypeData *&type, TypeData *newType ) {
+static void setBase( TypeData *&type, TypeData * newType ) {
         if ( type ) {
-                TypeData *prevBase = type;
-                TypeData *curBase = type->base;
-                while ( curBase != 0 ) {
+                TypeData * prevBase = type;
+                TypeData * curBase = type->base;
+                while ( curBase != nullptr ) {
                         prevBase = curBase;
                         curBase = curBase->base;
@@ -665 +682 @@
 }
 
-DeclarationNode *DeclarationNode::addPointer( DeclarationNode *p ) {
+DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) {
         if ( p ) {
                 assert( p->type->kind == TypeData::Pointer );
                 setBase( type, p->type );
-                p->type = 0;
+                p->type = nullptr;
                 delete p;
         } // if
@@ -675 +692 @@
 }
 
-DeclarationNode *DeclarationNode::addArray( DeclarationNode *a ) {
+DeclarationNode * DeclarationNode::addArray( DeclarationNode * a ) {
         if ( a ) {
                 assert( a->type->kind == TypeData::Array );
                 setBase( type, a->type );
-                a->type = 0;
+                a->type = nullptr;
                 delete a;
         } // if
@@ -685 +702 @@
 }
 
-DeclarationNode *DeclarationNode::addNewPointer( DeclarationNode *p ) {
+DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) {
         if ( p ) {
                 assert( p->type->kind == TypeData::Pointer );
@@ -703 +720 @@
                                 p->type->base = type;
                         } // switch
-                        type = 0;
+                        type = nullptr;
                 } // if
                 delete this;
@@ -712 +729 @@
 }
 
-static TypeData *findLast( TypeData *a ) {
+static TypeData * findLast( TypeData * a ) {
         assert( a );
-        TypeData *cur = a;
+        TypeData * cur = a;
         while ( cur->base ) {
                 cur = cur->base;
@@ -721 +738 @@
 }
 
-DeclarationNode *DeclarationNode::addNewArray( DeclarationNode *a ) {
+DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
         if ( a ) {
                 assert( a->type->kind == TypeData::Array );
-                TypeData *lastArray = findLast( a->type );
+                TypeData * lastArray = findLast( a->type );
                 if ( type ) {
                         switch ( type->kind ) {
@@ -739 +756 @@
                                 lastArray->base = type;
                         } // switch
-                        type = 0;
+                        type = nullptr;
                 } // if
                 delete this;
@@ -748 +765 @@
 }
 
-DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) {
-        TypeData *ftype = new TypeData( TypeData::Function );
+DeclarationNode * DeclarationNode::addParamList( DeclarationNode * params ) {
+        TypeData * ftype = new TypeData( TypeData::Function );
         ftype->function.params = params;
         setBase( type, ftype );
@@ -755 +772 @@
 }
 
-static TypeData *addIdListToType( TypeData *type, DeclarationNode *ids ) {
+static TypeData * addIdListToType( TypeData * type, DeclarationNode * ids ) {
         if ( type ) {
                 if ( type->kind != TypeData::Function ) {
@@ -764 +781 @@
                 return type;
         } else {
-                TypeData *newtype = new TypeData( TypeData::Function );
+                TypeData * newtype = new TypeData( TypeData::Function );
                 newtype->function.idList = ids;
                 return newtype;
         } // if
-}
-
-DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) {
+} // addIdListToType
+
+DeclarationNode * DeclarationNode::addIdList( DeclarationNode * ids ) {
         type = addIdListToType( type, ids );
         return this;
 }
 
-DeclarationNode *DeclarationNode::addInitializer( InitializerNode *init ) {
-        //assert
+DeclarationNode * DeclarationNode::addInitializer( InitializerNode * init ) {
         initializer = init;
         return this;
 }
 
-DeclarationNode *DeclarationNode::cloneBaseType( string *newName ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        TypeData *srcType = type;
-        while ( srcType->base ) {
-                srcType = srcType->base;
-        } // while
-        newnode->type = maybeClone( srcType );
-        if ( newnode->type->kind == TypeData::AggregateInst ) {
-                // don't duplicate members
-                if ( newnode->type->aggInst.aggregate->kind == TypeData::Enum ) {
-                        delete newnode->type->aggInst.aggregate->enumeration.constants;
-                        newnode->type->aggInst.aggregate->enumeration.constants = 0;
-                } 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
-        newnode->type->forall = maybeClone( type->forall );
-        assert( storageClass == NoStorageClass );
-        newnode->copyStorageClasses( this );
-        newnode->name = assign_strptr( newName );
-        return newnode;
-}
-
-DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
-        if ( o ) {
-                o->copyStorageClasses( this );
-                if ( type ) {
-                        TypeData *srcType = type;
-                        while ( srcType->base ) {
-                                srcType = srcType->base;
-                        } // while
-                        TypeData *newType = srcType->clone();
-                        if ( newType->kind == TypeData::AggregateInst ) {
-                                // don't duplicate members
-                                if ( newType->aggInst.aggregate->kind == TypeData::Enum ) {
-                                        delete newType->aggInst.aggregate->enumeration.constants;
-                                        newType->aggInst.aggregate->enumeration.constants = 0;
-                                } else {
-                                        assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
-                                        delete newType->aggInst.aggregate->aggregate.fields;
-                                        newType->aggInst.aggregate->aggregate.fields = 0;
-                                } // if
-                        } // if
-                        newType->forall = maybeClone( type->forall );
-                        if ( ! o->type ) {
-                                o->type = newType;
-                        } else {
-                                addTypeToType( newType, o->type );
-                                delete newType;
-                        } // if
-                } // if
-        } // if
-        return o;
-}
-
-DeclarationNode *DeclarationNode::cloneType( string *newName ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::cloneType( string * newName ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
         assert( storageClass == NoStorageClass );
         newnode->copyStorageClasses( this );
-        newnode->name = assign_strptr( newName );
-        return newnode;
-}
-
-DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
-        if ( o ) {
-                assert( storageClass == NoStorageClass );
-                o->copyStorageClasses( this );
-                if ( type ) {
-                        TypeData *newType = type->clone();
-                        if ( ! o->type ) {
-                                o->type = newType;
+        assert( newName );
+        newnode->name = newName;
+        return newnode;
+}
+
+DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) {
+        if ( ! o ) return nullptr;
+
+        o->copyStorageClasses( this );
+        if ( type ) {
+                TypeData * srcType = type;
+
+                while ( srcType->base ) {
+                        srcType = srcType->base;
+                } // while
+
+                TypeData * newType = srcType->clone();
+                if ( newType->kind == TypeData::AggregateInst ) {
+                        // don't duplicate members
+                        if ( newType->aggInst.aggregate->kind == TypeData::Enum ) {
+                                delete newType->aggInst.aggregate->enumeration.constants;
+                                newType->aggInst.aggregate->enumeration.constants = nullptr;
                         } else {
-                                addTypeToType( newType, o->type );
-                                delete newType;
+                                assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
+                                delete newType->aggInst.aggregate->aggregate.fields;
+                                newType->aggInst.aggregate->aggregate.fields = nullptr;
                         } // if
                 } // if
-        } // if
-        delete o;
+
+                newType->forall = maybeClone( type->forall );
+                if ( ! o->type ) {
+                        o->type = newType;
+                } else {
+                        addTypeToType( newType, o->type );
+                        delete newType;
+                } // if
+        } // if
         return o;
 }
 
-DeclarationNode *DeclarationNode::extractAggregate() const {
+DeclarationNode * DeclarationNode::extractAggregate() const {
         if ( type ) {
-                TypeData *ret = typeextractAggregate( type );
+                TypeData * ret = typeextractAggregate( type );
                 if ( ret ) {
-                        DeclarationNode *newnode = new DeclarationNode;
+                        DeclarationNode * newnode = new DeclarationNode;
                         newnode->type = ret;
                         return newnode;
                 } // if
         } // if
-        return 0;
-}
-
-void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) {
+        return nullptr;
+}
+
+void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList ) {
         SemanticError errors;
         std::back_insert_iterator< std::list< Declaration * > > out( outputList );
-        const DeclarationNode *cur = firstNode;
+        const DeclarationNode * cur = firstNode;
+
         while ( cur ) {
                 try {
-                        if ( DeclarationNode *extr = cur->extractAggregate() ) {
+                        if ( DeclarationNode * extr = cur->extractAggregate() ) {
                                 // handle the case where a structure declaration is contained within an object or type declaration
-                                Declaration *decl = extr->build();
+                                Declaration * decl = extr->build();
                                 if ( decl ) {
-                                        *out++ = decl;
+                                        * out++ = decl;
                                 } // if
                                 delete extr;
                         } // if
-                        Declaration *decl = cur->build();
+
+                        Declaration * decl = cur->build();
                         if ( decl ) {
-                                *out++ = decl;
+                                * out++ = decl;
                         } // if
                 } catch( SemanticError &e ) {
@@ -900 +879 @@
                 cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
+
         if ( ! errors.isEmpty() ) {
                 throw errors;
         } // if
-}
-
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ) {
+} // buildList
+
+void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {
         SemanticError errors;
         std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
-        const DeclarationNode *cur = firstNode;
+        const DeclarationNode * cur = firstNode;
         while ( cur ) {
                 try {
-                        Declaration *decl = cur->build();
+                        Declaration * decl = cur->build();
                         if ( decl ) {
-                                if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
-                                        *out++ = dwt;
-                                } 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 );
+                                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                                        * out++ = dwt;
+                                } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
+                                        StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
+                                        * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
                                         delete agg;
-                                } 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 );
+                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
+                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
+                                        * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
                                 } // if
                         } // if
@@ -932 +912 @@
                 throw errors;
         } // if
-}
-
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ) {
+} // buildList
+
+void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ) {
         SemanticError errors;
         std::back_insert_iterator< std::list< Type * > > out( outputList );
-        const DeclarationNode *cur = firstNode;
+        const DeclarationNode * cur = firstNode;
+
         while ( cur ) {
                 try {
-                        *out++ = cur->buildType();
+                        * out++ = cur->buildType();
                 } catch( SemanticError &e ) {
                         errors.append( e );
@@ -946 +927 @@
                 cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
+
         if ( ! errors.isEmpty() ) {
                 throw errors;
         } // if
-}
-
-Declaration *DeclarationNode::build() const {
+} // buildTypeList
+
+Declaration * DeclarationNode::build() const {
         if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this );
+
+//      if ( variable.name ) {
+        if ( variable.tyClass != NoTypeClass ) {
+                static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
+//              TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
+                TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
+                buildList( variable.assertions, ret->get_assertions() );
+                return ret;
+        } // if
+
         if ( type ) {
-                if ( type->kind == TypeData::Variable ) {
-                        static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
-                        TypeDecl * ret = new TypeDecl( variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ variable.tyClass ] );
-                        buildList( variable.assertions, ret->get_assertions() );
-                        return ret;
-                } else {
-                        return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
-                } // if
-        } // if
+                return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
+        } // if
+
         if ( ! isInline && ! isNoreturn ) {
-                return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
-        } // if
+                assertf( name, "ObjectDecl are assumed to have names\n" );
+                return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
+        } // if
+
         throw SemanticError( "invalid function specifier ", this );
 }
 
-Type *DeclarationNode::buildType() const {
+Type * DeclarationNode::buildType() const {
         assert( type );
+
+        if ( attr.expr ) {
+//              return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
+                return new AttrType( buildQualifiers( type ), *name, attr.expr->build() );
+        } else if ( attr.type ) {
+//              return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
+                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType() );
+        } // if
 
         switch ( type->kind ) {
           case TypeData::Enum:
-                return new EnumInstType( buildQualifiers( type ), type->enumeration.name );
+                return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
           case TypeData::Aggregate: {
-                  ReferenceToType *ret;
+                  ReferenceToType * ret;
                   switch ( type->aggregate.kind ) {
                         case DeclarationNode::Struct:
-                          ret = new StructInstType( buildQualifiers( type ), type->aggregate.name );
+                          ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
                         case DeclarationNode::Union:
-                          ret = new UnionInstType( buildQualifiers( type ), type->aggregate.name );
+                          ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
                         case DeclarationNode::Trait:
-                          ret = new TraitInstType( buildQualifiers( type ), type->aggregate.name );
+                          ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
                         default:
@@ -994 +990 @@
           }
           case TypeData::Symbolic: {
-                  TypeInstType *ret = new TypeInstType( buildQualifiers( type ), type->symbolic.name, false );
+                  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false );
                   buildList( type->symbolic.actuals, ret->get_parameters() );
-                  return ret;
-          }
-          case TypeData::Attr: {
-                  assert( type->kind == TypeData::Attr );
-                  // assert( type->attr );
-                  AttrType * ret;
-                  if ( attr.expr ) {
-                          ret = new AttrType( buildQualifiers( type ), attr.name, attr.expr->build() );
-                  } else {
-                          assert( attr.type );
-                          ret = new AttrType( buildQualifiers( type ), attr.name, attr.type->buildType() );
-                  } // if
                   return ret;
           }

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 25 21:39:40 2016
-// Update Count     : 503
+// Last Modified On : Fri Sep 16 16:27:44 2016
+// Update Count     : 508
 //
 
@@ -31 +31 @@
 
 using namespace std;
-
-ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.get_name() ), extension( other.extension ) {}
 
 //##############################################################################

src/Parser/InitializerNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 15 18:27:02 2016
-// Update Count     : 20
+// Last Modified On : Sat Oct  1 23:09:51 2016
+// Update Count     : 21
 //
 
@@ -23 +23 @@
 
 InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des )
-        : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
+                : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
         if ( aggrp )
                 kids = dynamic_cast< InitializerNode * >( get_next() );
@@ -32 +32 @@
 
 InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des )
-        : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
+                : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
         if ( init != 0 )
                 set_last( init );
@@ -79 +79 @@
 
 Initializer *InitializerNode::build() const {
-        // if ( get_expression() == 0 ) return 0;  // XXX (?)
-
         if ( aggregate ) {
-                //assert( next_init() != 0 );
-
                 std::list< Initializer * > initlist;
                 buildList< Initializer, InitializerNode >( next_init(), initlist );

src/Parser/LinkageSpec.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:22:09 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Aug 21 12:32:53 2016
-// Update Count     : 17
+// Last Modified On : Sun Oct  2 23:16:21 2016
+// Update Count     : 23
 //
 
@@ -17 +17 @@
 #include <string>
 #include <cassert>
+using namespace std;
 
 #include "LinkageSpec.h"
 #include "Common/SemanticError.h"
 
-LinkageSpec::Spec LinkageSpec::fromString( const std::string &spec ) {
-        std::unique_ptr<const std::string> guard(&spec);                // allocated by lexer
-        if ( spec == "\"Cforall\"" ) {
+LinkageSpec::Spec LinkageSpec::linkageCheck( const string * spec ) {
+        unique_ptr<const string> guard( spec ); // allocated by lexer
+        if ( *spec == "\"Cforall\"" ) {
                 return Cforall;
-        } else if ( spec == "\"C\"" ) {
+        } else if ( *spec == "\"C\"" ) {
                 return C;
         } else {
-                throw SemanticError( "Invalid linkage specifier " + spec );
+                throw SemanticError( "Invalid linkage specifier " + *spec );
         } // if
 }
 
-std::string LinkageSpec::toString( LinkageSpec::Spec linkage ) {
-        assert( linkage >= 0 && linkage < LinkageSpec::NoOfSpecs );
+string LinkageSpec::linkageName( LinkageSpec::Spec linkage ) {
+        assert( 0 <= linkage && linkage < LinkageSpec::NoOfSpecs );
         static const char *linkageKinds[LinkageSpec::NoOfSpecs] = {
                 "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in",
@@ -41 +42 @@
 
 bool LinkageSpec::isDecoratable( Spec spec ) {
-        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
+        assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
         static bool decoratable[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
@@ -50 +51 @@
 
 bool LinkageSpec::isGeneratable( Spec spec ) {
-        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
+        assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
         static bool generatable[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler

src/Parser/LinkageSpec.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:24:28 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug 20 19:22:23 2016
-// Update Count     : 8
+// Last Modified On : Sat Oct  1 23:03:17 2016
+// Update Count     : 11
 //
 
@@ -29 +29 @@
         };
   
-        static Spec fromString( const std::string & );
-        static std::string toString( Spec );
+        static Spec linkageCheck( const std::string * );
+        static std::string linkageName( Spec );
   
         static bool isDecoratable( Spec );

src/Parser/ParseNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:26:29 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 17 23:14:16 2016
-// Update Count     : 126
+// Last Modified On : Sat Oct  1 23:10:43 2016
+// Update Count     : 127
 //
 
@@ -20 +20 @@
 
 std::ostream & operator<<( std::ostream & out, const ParseNode * node ) {
-  node->print( out );
-  return out;
+        node->print( out );
+        return out;
 }
 

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 12 08:00:05 2016
-// Update Count     : 603
+// Last Modified On : Mon Oct  3 18:03:08 2016
+// Update Count     : 636
 //
 
@@ -41 +41 @@
   public:
         ParseNode() {};
-        ParseNode( const std::string * name ) : name( * name ) { assert( false ); delete name; }
-        ParseNode( const std::string &name ) : name( name ) { assert( false ); }
-        virtual ~ParseNode() { delete next; };
+        virtual ~ParseNode() { delete next; delete name; };
         virtual ParseNode * clone() const = 0;
 
         ParseNode * get_next() const { return next; }
         ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
+
         ParseNode * get_last() {
                 ParseNode * current;
-                for ( current = this; current->get_next() != 0; current = current->get_next() );
+                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
                 return current;
         }
         ParseNode * set_last( ParseNode * newlast ) {
-                if ( newlast != 0 ) get_last()->set_next( newlast );
+                if ( newlast != nullptr ) get_last()->set_next( newlast );
                 return this;
         }
-
-        const std::string &get_name() const { return name; }
-        void set_name( const std::string &newValue ) { name = newValue; }
 
         virtual void print( std::ostream &os, int indent = 0 ) const {}
         virtual void printList( std::ostream &os, int indent = 0 ) const {}
-  private:
+
         static int indent_by;
 
         ParseNode * next = nullptr;
-        std::string name;
+        std::string * name = nullptr;
 }; // ParseNode
 
@@ -74 +70 @@
 class InitializerNode : public ParseNode {
   public:
-        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = 0 );
-        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0 );
+        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
+        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
         ~InitializerNode();
         virtual InitializerNode * clone() const { assert( false ); return nullptr; }
@@ -106 +102 @@
   public:
         ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
-        ExpressionNode( Expression * expr, const std::string * name ) : ParseNode( name ), expr( expr ) {}
         ExpressionNode( const ExpressionNode &other );
         virtual ~ExpressionNode() {}
@@ -183 +178 @@
 Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
 Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
-Expression * build_tuple( ExpressionNode * expr_node = 0 );
+Expression * build_tuple( ExpressionNode * expr_node = nullptr );
 Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
 Expression * build_range( ExpressionNode * low, ExpressionNode * high );
@@ -203 +198 @@
         enum Signedness { Signed, Unsigned, NoSignedness };
         enum Length { Short, Long, LongLong, NoLength };
-        enum Aggregate { Struct, Union, Trait };
-        enum TypeClass { Otype, Dtype, Ftype };
+        enum Aggregate { Struct, Union, Trait, NoAggregate };
+        enum TypeClass { Otype, Dtype, Ftype, NoTypeClass };
         enum BuiltinType { Valist };
 
@@ -219 +214 @@
         static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
         static DeclarationNode * newQualifier( Qualifier );
-        static DeclarationNode * newForall( DeclarationNode *);
+        static DeclarationNode * newForall( DeclarationNode * );
         static DeclarationNode * newStorageClass( StorageClass );
         static DeclarationNode * newBasicType( BasicType );
@@ -226 +221 @@
         static DeclarationNode * newLength( Length lnth );
         static DeclarationNode * newBuiltinType( BuiltinType );
-        static DeclarationNode * newFromTypedef( std::string *);
+        static DeclarationNode * newFromTypedef( std::string * );
         static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
         static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
         static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
-        static DeclarationNode * newName( std::string *);
+        static DeclarationNode * newName( std::string * );
         static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
-        static DeclarationNode * newTypeParam( TypeClass, std::string *);
-        static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts );
-        static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params );
+        static DeclarationNode * newTypeParam( TypeClass, std::string * );
+        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
+        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
         static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
         static DeclarationNode * newPointer( DeclarationNode * qualifiers );
@@ -249 +244 @@
         DeclarationNode * clone() const;
 
-        DeclarationNode * addQualifiers( DeclarationNode *);
+        DeclarationNode * addQualifiers( DeclarationNode * );
         void checkQualifiers( const TypeData *, const TypeData * );
-        void checkStorageClasses( DeclarationNode *q );
-        DeclarationNode * copyStorageClasses( DeclarationNode *);
-        DeclarationNode * addType( DeclarationNode *);
+        void checkStorageClasses( DeclarationNode * );
+        DeclarationNode * copyStorageClasses( DeclarationNode * );
+        DeclarationNode * addType( DeclarationNode * );
         DeclarationNode * addTypedef();
-        DeclarationNode * addAssertions( DeclarationNode *);
-        DeclarationNode * addName( std::string *);
+        DeclarationNode * addAssertions( DeclarationNode * );
+        DeclarationNode * addName( std::string * );
         DeclarationNode * addBitfield( ExpressionNode * size );
         DeclarationNode * addVarArgs();
@@ -270 +265 @@
 
         DeclarationNode * cloneType( std::string * newName );
-        DeclarationNode * cloneType( DeclarationNode * existing );
-        DeclarationNode * cloneType( int ) { return cloneType( ( std::string *)0 ); }
-        DeclarationNode * cloneBaseType( std::string * newName );
         DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
 
@@ -286 +278 @@
 
         bool get_hasEllipsis() const;
-        const std::string &get_name() const { return name; }
         LinkageSpec::Spec get_linkage() const { return linkage; }
         DeclarationNode * extractAggregate() const;
@@ -295 +286 @@
         DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
   public:
-        // StorageClass buildStorageClass() const;
-        // bool buildFuncSpecifier( StorageClass key ) const;
-
         struct Variable_t {
+//              const std::string * name;
                 DeclarationNode::TypeClass tyClass;
-                std::string name;
                 DeclarationNode * assertions;
         };
@@ -306 +294 @@
 
         struct Attr_t {
-                std::string name;
+//              const std::string * name;
                 ExpressionNode * expr;
                 DeclarationNode * type;
@@ -315 +303 @@
 
         TypeData * type;
-        std::string name;
         StorageClass storageClass;
         bool isInline, isNoreturn;
@@ -331 +318 @@
 
 Type * buildType( TypeData * type );
-//Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers );
 
 static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
@@ -393 +379 @@
 Statement * build_finally( StatementNode * stmt );
 Statement * build_compound( StatementNode * first );
-Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0 );
+Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
 
 //##############################################################################

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 12 21:11:22 2016
-// Update Count     : 377
+// Last Modified On : Sat Sep 24 11:14:26 2016
+// Update Count     : 415
 //
 
@@ -24 +24 @@
 #include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
-
-TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) {
+using namespace std;
+
+TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) {
         switch ( kind ) {
           case Unknown:
@@ -37 +38 @@
           case Array:
                 // array = new Array_t;
-                array.dimension = 0;
+                array.dimension = nullptr;
                 array.isVarLen = false;
                 array.isStatic = false;
@@ -43 +44 @@
           case Function:
                 // function = new Function_t;
-                function.params = 0;
-                function.idList = 0;
-                function.oldDeclList = 0;
-                function.body = 0;
+                function.params = nullptr;
+                function.idList = nullptr;
+                function.oldDeclList = nullptr;
+                function.body = nullptr;
                 function.hasBody = false;
                 function.newStyle = false;
@@ -52 +53 @@
           case Aggregate:
                 // aggregate = new Aggregate_t;
-                aggregate.params = 0;
-                aggregate.actuals = 0;
-                aggregate.fields = 0;
+                aggregate.name = nullptr;
+                aggregate.params = nullptr;
+                aggregate.actuals = nullptr;
+                aggregate.fields = nullptr;
                 break;
           case AggregateInst:
                 // aggInst = new AggInst_t;
-                aggInst.aggregate = 0;
-                aggInst.params = 0;
+                aggInst.aggregate = nullptr;
+                aggInst.params = nullptr;
                 break;
           case Enum:
                 // enumeration = new Enumeration_t;
-                enumeration.constants = 0;
+                enumeration.name = nullptr;
+                enumeration.constants = nullptr;
                 break;
           case Symbolic:
           case SymbolicInst:
                 // symbolic = new Symbolic_t;
-                symbolic.params = 0;
-                symbolic.actuals = 0;
-                symbolic.assertions = 0;
-                break;
-          case Variable:
-                // variable = new Variable_t;
-                // variable.tyClass = DeclarationNode::Type;
-                // variable.assertions = 0;
+                symbolic.name = nullptr;
+                symbolic.params = nullptr;
+                symbolic.actuals = nullptr;
+                symbolic.assertions = nullptr;
                 break;
           case Tuple:
@@ -84 +83 @@
                 // typeexpr = new Typeof_t;
                 typeexpr = nullptr;
-                break;
-          case Attr:
-                // attr = new Attr_t;
-                // attr.expr = nullptr;
-                // attr.type = nullptr;
                 break;
           case Builtin:
@@ -121 +115 @@
                 break;
           case Aggregate:
+                delete aggregate.name;
                 delete aggregate.params;
                 delete aggregate.actuals;
@@ -132 +127 @@
                 break;
           case Enum:
+                delete enumeration.name;
                 delete enumeration.constants;
                 // delete enumeration;
@@ -137 +133 @@
           case Symbolic:
           case SymbolicInst:
+                delete symbolic.name;
                 delete symbolic.params;
                 delete symbolic.actuals;
@@ -142 +139 @@
                 // delete symbolic;
                 break;
-          case Variable:
-                // delete variable.assertions;
-                // delete variable;
-                break;
           case Tuple:
                 // delete tuple->members;
@@ -153 +146 @@
                 // delete typeexpr->expr;
                 delete typeexpr;
-                break;
-          case Attr:
-                // delete attr.expr;
-                // delete attr.type;
-                // delete attr;
                 break;
           case Builtin:
@@ -197 +185 @@
                 break;
           case Aggregate:
+                newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
                 newtype->aggregate.params = maybeClone( aggregate.params );
                 newtype->aggregate.actuals = maybeClone( aggregate.actuals );
                 newtype->aggregate.fields = maybeClone( aggregate.fields );
-                newtype->aggregate.name = aggregate.name;
                 newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.body = aggregate.body;
@@ -209 +197 @@
                 break;
           case Enum:
-                newtype->enumeration.name = enumeration.name;
+                newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
                 newtype->enumeration.constants = maybeClone( enumeration.constants );
                 break;
           case Symbolic:
           case SymbolicInst:
+                newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr;
                 newtype->symbolic.params = maybeClone( symbolic.params );
                 newtype->symbolic.actuals = maybeClone( symbolic.actuals );
                 newtype->symbolic.assertions = maybeClone( symbolic.assertions );
                 newtype->symbolic.isTypedef = symbolic.isTypedef;
-                newtype->symbolic.name = symbolic.name;
-                break;
-          case Variable:
-                assert( false );
-                // newtype->variable.assertions = maybeClone( variable.assertions );
-                // newtype->variable.name = variable.name;
-                // newtype->variable.tyClass = variable.tyClass;
                 break;
           case Tuple:
@@ -231 +213 @@
           case Typeof:
                 newtype->typeexpr = maybeClone( typeexpr );
-                break;
-          case Attr:
-                assert( false );
-                // newtype->attr.expr = maybeClone( attr.expr );
-                // newtype->attr.type = maybeClone( attr.type );
                 break;
           case Builtin:
@@ -245 +222 @@
 } // TypeData::clone
 
-void TypeData::print( std::ostream &os, int indent ) const {
-        using std::endl;
-        using std::string;
-
+void TypeData::print( ostream &os, int indent ) const {
         for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) {
                 if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
@@ -326 +300 @@
                 break;
           case Aggregate:
-                os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << aggregate.name << endl;
+                os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters " << endl;
@@ -363 +337 @@
                 break;
           case SymbolicInst:
-                os << "instance of type " << symbolic.name;
+                os << "instance of type " << *symbolic.name;
                 if ( symbolic.actuals ) {
                         os << " with parameters" << endl;
@@ -389 +363 @@
                 } // if
                 break;
-          case Variable:
-                // os << DeclarationNode::typeClassName[ variable.tyClass ] << " variable ";
-                // if ( variable.assertions ) {
-                //      os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
-                //      variable.assertions->printList( os, indent + 4 );
-                //      os << string( indent + 2, ' ' );
-                // } // if
-                break;
           case Tuple:
                 os << "tuple ";
@@ -409 +375 @@
                         typeexpr->print( os, indent + 2 );
                 } // if
-                break;
-          case Attr:
-                // os << "attribute type decl " << attr.name << " applied to ";
-                // if ( attr.expr ) {
-                //      attr.expr->print( os, indent + 2 );
-                // } // if
-                // if ( attr.type ) {
-                //      attr.type->print( os, indent + 2 );
-                // } // if
                 break;
           case Builtin:
@@ -437 +394 @@
                         // add dtor:  void ^?{}(T *)
                         FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
-                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) );
-                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, 0, false, false ) );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
 
                         // add copy ctor:  void ?{}(T *, T)
                         FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
-                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) );
-                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, 0, false, false ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
 
                         // add default ctor:  void ?{}(T *)
                         FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
-                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, 0, false, false ) );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
 
                         // add assignment operator:  T * ?=?(T *, T)
                         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(), td->get_name(), td ) ), 0 ) );
-                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) );
-                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
                 } // if
         } // for
@@ -488 +445 @@
           case TypeData::Builtin:
                 return new VarArgsType( buildQualifiers( td ) );
-          case TypeData::Attr:
-                assert( false );
-                return buildAttr( td );
           case TypeData::Symbolic:
           case TypeData::Enum:
           case TypeData::Aggregate:
-          case TypeData::Variable:
                 assert( false );
         } // switch
-        return 0;
+        return nullptr;
 } // typebuild
 
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
-        TypeData * ret = 0;
+        TypeData * ret = nullptr;
 
         switch ( td->kind ) {
@@ -551 +504 @@
           case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
                 } // if
 
@@ -567 +520 @@
 
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
                 } // if
 
@@ -597 +550 @@
           FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
                 } // if
                 if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
@@ -657 +610 @@
         switch ( td->aggregate.kind ) {
           case DeclarationNode::Struct:
-                at = new StructDecl( td->aggregate.name );
+                at = new StructDecl( *td->aggregate.name );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
           case DeclarationNode::Union:
-                at = new UnionDecl( td->aggregate.name );
+                at = new UnionDecl( *td->aggregate.name );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
           case DeclarationNode::Trait:
-                at = new TraitDecl( td->aggregate.name );
+                at = new TraitDecl( *td->aggregate.name );
                 buildList( td->aggregate.params, at->get_parameters() );
                 break;
@@ -683 +636 @@
         ReferenceToType * ret;
         if ( td->aggInst.aggregate->kind == TypeData::Enum ) {
-                ret = new EnumInstType( buildQualifiers( td ), td->aggInst.aggregate->enumeration.name );
+                ret = new EnumInstType( buildQualifiers( td ), *td->aggInst.aggregate->enumeration.name );
         } else {
                 assert( td->aggInst.aggregate->kind == TypeData::Aggregate );
                 switch ( td->aggInst.aggregate->aggregate.kind ) {
                   case DeclarationNode::Struct:
-                        ret = new StructInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+                        assert( td->aggInst.aggregate->aggregate.name );
+                        ret = new StructInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
                         break;
                   case DeclarationNode::Union:
-                        ret = new UnionInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+                        ret = new UnionInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
                         break;
                   case DeclarationNode::Trait:
-                        ret = new TraitInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+                        ret = new TraitInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
                         break;
                   default:
@@ -705 +659 @@
 } // buildAggInst
 
-NamedTypeDecl * buildSymbolic( const TypeData * td, const std::string & name, DeclarationNode::StorageClass sc ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
@@ -719 +673 @@
 } // buildSymbolic
 
-TypeDecl * buildVariable( const TypeData * td ) {
-        assert( false );
-        return nullptr;
-        // assert( td->kind == TypeData::Variable );
-        // static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
-
-        // TypeDecl * ret = new TypeDecl( td->variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable.tyClass ] );
-        // buildList( td->variable.assertions, ret->get_assertions() );
-        // return ret;
-} // buildSymbolic
-
 EnumDecl * buildEnum( const TypeData * td ) {
         assert( td->kind == TypeData::Enum );
-        EnumDecl * ret = new EnumDecl( td->enumeration.name );
+        EnumDecl * ret = new EnumDecl( *td->enumeration.name );
         buildList( td->enumeration.constants, ret->get_members() );
-        std::list< Declaration * >::iterator members = ret->get_members().begin();
+        list< Declaration * >::iterator members = ret->get_members().begin();
         for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
-                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), std::list< Expression * >() ) );
+                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) );
                 } // if
         } // for
@@ -746 +689 @@
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
         assert( td->kind == TypeData::SymbolicInst );
-        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic.name, false );
+        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false );
         buildList( td->symbolic.actuals, ret->get_parameters() );
         buildForall( td->forall, ret->get_forall() );
@@ -767 +710 @@
 } // buildTypeof
 
-AttrType * buildAttr( const TypeData * td ) {
-        assert( false );
-        return nullptr;
-        // assert( td->kind == TypeData::Attr );
-        // // assert( td->attr );
-        // AttrType * ret;
-        // if ( td->attr.expr ) {
-        //      ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.expr->build() );
-        // } else {
-        //      assert( td->attr.type );
-        //      ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.type->buildType() );
-        // } // if
-        // return ret;
-} // buildAttr
-
-Declaration * buildDecl( const TypeData * td, std::string name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) {
+Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) {
         if ( td->kind == TypeData::Function ) {
                 FunctionDecl * decl;
@@ -792 +720 @@
                                 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn );
                         } else {
-                                // std::list< Label > ls;
-                                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( std::list< Label >() ), isInline, isNoreturn );
+                                // list< Label > ls;
+                                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( list< Label >() ), isInline, isNoreturn );
                         } // if
                 } else {
-                        decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), 0, isInline, isNoreturn );
-                } // if
-                for ( DeclarationNode * cur = td->function.idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
-                        if ( cur->get_name() != "" ) {
-                                decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
+                        decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), nullptr, isInline, isNoreturn );
+                } // if
+                for ( DeclarationNode * cur = td->function.idList; cur != nullptr; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
+                        if ( cur->name ) {
+                                decl->get_oldIdents().insert( decl->get_oldIdents().end(), *cur->name );
                         } // if
                 } // for
@@ -811 +739 @@
         } else if ( td->kind == TypeData::Symbolic ) {
                 return buildSymbolic( td, name, sc );
-        } else if ( td->kind == TypeData::Variable ) {
-                assert( false );
-                return buildVariable( td );
         } else {
-                return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, std::list< Attribute * >(), isInline, isNoreturn );
+                return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, list< Attribute * >(), isInline, isNoreturn );
         } // if
-        return 0;
+        return nullptr;
 } // buildDecl
 
@@ -833 +758 @@
                         break;
                   default:
-                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, 0, false, false, LinkageSpec::Cforall ) ) );
+                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall ) ) );
                 } // switch
         } else {
-                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
+                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
         } // if
         return ft;

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 12 17:15:49 2016
-// Update Count     : 129
+// Last Modified On : Mon Oct  3 12:34:08 2016
+// Update Count     : 142
 //
 
@@ -23 +23 @@
 
 struct TypeData {
-        enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst,
-                                Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr };
+        enum Kind { Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
+                                SymbolicInst, Tuple, Typeof, Builtin, Unknown };
 
         struct Aggregate_t {
                 DeclarationNode::Aggregate kind;
-                std::string name;
+                const std::string * name;
                 DeclarationNode * params;
-                ExpressionNode  * actuals;                                              // holds actual parameters later applied to AggInst
+                ExpressionNode * actuals;                                               // holds actual parameters later applied to AggInst
                 DeclarationNode * fields;
                 bool body;
@@ -47 +47 @@
 
         struct Enumeration_t {
-                std::string name;
+                const std::string * name;
                 DeclarationNode * constants;
         };
@@ -61 +61 @@
 
         struct Symbolic_t {
-                std::string name;
+                const std::string * name;
                 bool isTypedef;                                                                 // false => TYPEGENname, true => TYPEDEFname
                 DeclarationNode * params;
@@ -88 +88 @@
                 DeclarationNode * tuple;
                 ExpressionNode * typeexpr;
-                // Attr_t attr;
                 // DeclarationNode::BuiltinType builtin;
 
@@ -111 +110 @@
 TupleType * buildTuple( const TypeData * );
 TypeofType * buildTypeof( const TypeData * );
-AttrType * buildAttr( const TypeData * );
-Declaration * buildDecl( const TypeData *, std::string, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = 0 );
+Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = nullptr );
 FunctionType * buildFunction( const TypeData * );
 

src/Parser/parser.cc

@@ -82 +82 @@
 #include "TypeData.h"
 #include "LinkageSpec.h"
+using namespace std;
 
 extern DeclarationNode * parseTree;
@@ -87 +88 @@
 extern TypedefTable typedefTable;
 
-std::stack< LinkageSpec::Spec > linkageStack;
-
-void appendStr( std::string *to, std::string *from ) {
+stack< LinkageSpec::Spec > linkageStack;
+
+void appendStr( string *to, string *from ) {
         // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
         to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) );
@@ -96 +97 @@
 
 /* Line 268 of yacc.c  */
-#line 99 "Parser/parser.cc"
+#line 100 "Parser/parser.cc"
 
 /* Enabling traces.  */
@@ -347 +348 @@
 
 /* Line 293 of yacc.c  */
-#line 115 "parser.yy"
+#line 116 "parser.yy"
 
         Token tok;
@@ -367 +368 @@
 
 /* Line 293 of yacc.c  */
-#line 370 "Parser/parser.cc"
+#line 371 "Parser/parser.cc"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
@@ -379 +380 @@
 
 /* Line 343 of yacc.c  */
-#line 382 "Parser/parser.cc"
+#line 383 "Parser/parser.cc"
 
 #ifdef short
@@ -598 +599 @@
 #define YYFINAL  250
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   10863
+#define YYLAST   10888
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  133
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  241
+#define YYNNTS  242
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  751
+#define YYNRULES  754
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  1555
+#define YYNSTATES  1558
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
@@ -666 +667 @@
       17,    19,    21,    23,    25,    27,    29,    31,    33,    36,
       38,    40,    44,    48,    50,    57,    62,    66,    74,    78,
-      86,    89,    92,   100,   105,   107,   111,   112,   114,   116,
-     120,   122,   126,   134,   138,   146,   148,   150,   152,   155,
-     158,   161,   164,   167,   170,   175,   178,   183,   190,   192,
-     197,   202,   204,   206,   208,   210,   212,   214,   216,   221,
-     226,   228,   232,   236,   240,   242,   246,   250,   252,   256,
-     260,   262,   266,   270,   274,   278,   280,   284,   288,   290,
-     294,   296,   300,   302,   306,   308,   312,   314,   318,   320,
-     326,   331,   337,   339,   341,   345,   348,   349,   351,   353,
-     355,   357,   359,   361,   363,   365,   367,   369,   371,   373,
-     375,   378,   384,   391,   399,   401,   405,   407,   411,   412,
-     414,   416,   418,   420,   422,   424,   426,   428,   430,   437,
-     442,   445,   453,   455,   459,   461,   464,   466,   469,   471,
-     474,   477,   483,   491,   497,   507,   513,   523,   525,   529,
-     531,   533,   537,   541,   544,   546,   549,   552,   553,   555,
-     558,   562,   563,   565,   568,   572,   576,   581,   582,   584,
-     586,   589,   595,   603,   610,   617,   622,   626,   631,   634,
-     638,   641,   645,   649,   653,   657,   663,   667,   671,   676,
-     678,   684,   691,   697,   704,   714,   725,   735,   746,   749,
-     751,   754,   757,   760,   762,   769,   778,   789,   802,   817,
-     818,   820,   821,   823,   825,   829,   834,   842,   843,   845,
-     849,   851,   855,   857,   859,   861,   865,   867,   869,   871,
-     875,   876,   878,   882,   887,   889,   893,   895,   897,   901,
-     905,   909,   913,   917,   920,   924,   931,   935,   939,   944,
-     946,   949,   952,   956,   962,   971,   979,   987,   993,  1003,
-    1006,  1009,  1015,  1019,  1025,  1030,  1034,  1039,  1044,  1052,
-    1056,  1060,  1064,  1068,  1073,  1080,  1082,  1084,  1086,  1088,
-    1090,  1092,  1094,  1096,  1097,  1099,  1101,  1104,  1106,  1108,
-    1110,  1112,  1114,  1116,  1118,  1119,  1125,  1127,  1130,  1134,
-    1136,  1139,  1141,  1143,  1145,  1147,  1149,  1151,  1153,  1155,
-    1157,  1159,  1161,  1163,  1165,  1167,  1169,  1171,  1173,  1175,
-    1177,  1179,  1181,  1183,  1186,  1189,  1193,  1197,  1199,  1203,
-    1205,  1208,  1211,  1214,  1219,  1224,  1229,  1234,  1236,  1239,
-    1242,  1246,  1248,  1251,  1254,  1256,  1259,  1262,  1266,  1268,
-    1271,  1274,  1276,  1278,  1283,  1286,  1287,  1294,  1302,  1305,
-    1308,  1311,  1312,  1315,  1318,  1322,  1325,  1329,  1331,  1334,
-    1338,  1341,  1344,  1349,  1350,  1352,  1355,  1358,  1360,  1361,
-    1363,  1366,  1369,  1375,  1378,  1379,  1387,  1390,  1395,  1396,
-    1399,  1400,  1402,  1404,  1406,  1412,  1418,  1424,  1426,  1432,
-    1438,  1448,  1450,  1456,  1457,  1459,  1461,  1467,  1469,  1471,
-    1477,  1483,  1485,  1489,  1493,  1498,  1500,  1502,  1504,  1506,
-    1509,  1511,  1515,  1519,  1521,  1524,  1526,  1530,  1532,  1534,
-    1536,  1538,  1540,  1542,  1544,  1546,  1548,  1550,  1552,  1555,
-    1557,  1559,  1561,  1564,  1565,  1568,  1571,  1573,  1578,  1579,
-    1581,  1584,  1588,  1593,  1596,  1599,  1601,  1604,  1607,  1613,
-    1619,  1627,  1634,  1636,  1639,  1642,  1646,  1648,  1651,  1654,
-    1659,  1662,  1667,  1668,  1673,  1676,  1678,  1680,  1682,  1683,
-    1686,  1692,  1698,  1712,  1714,  1716,  1720,  1724,  1727,  1731,
-    1735,  1738,  1743,  1745,  1752,  1762,  1763,  1775,  1777,  1781,
-    1785,  1789,  1791,  1793,  1799,  1802,  1808,  1809,  1811,  1813,
-    1817,  1818,  1820,  1822,  1824,  1826,  1827,  1834,  1837,  1839,
-    1842,  1847,  1850,  1854,  1858,  1862,  1867,  1873,  1879,  1885,
-    1892,  1894,  1896,  1898,  1902,  1903,  1909,  1910,  1912,  1914,
-    1917,  1924,  1926,  1930,  1931,  1933,  1938,  1940,  1942,  1944,
-    1946,  1949,  1951,  1954,  1957,  1959,  1963,  1966,  1970,  1974,
-    1977,  1982,  1987,  1991,  2000,  2004,  2007,  2009,  2012,  2019,
-    2028,  2032,  2035,  2039,  2043,  2048,  2053,  2057,  2059,  2061,
-    2063,  2068,  2075,  2079,  2082,  2086,  2090,  2095,  2100,  2104,
-    2107,  2109,  2112,  2115,  2117,  2121,  2124,  2128,  2132,  2135,
-    2140,  2145,  2149,  2156,  2165,  2169,  2172,  2174,  2177,  2180,
-    2183,  2187,  2191,  2194,  2199,  2204,  2208,  2215,  2224,  2228,
-    2231,  2233,  2236,  2239,  2241,  2243,  2246,  2250,  2254,  2257,
-    2262,  2269,  2278,  2280,  2283,  2286,  2288,  2291,  2294,  2298,
-    2302,  2304,  2309,  2314,  2318,  2324,  2333,  2337,  2340,  2344,
-    2346,  2352,  2358,  2365,  2372,  2374,  2377,  2380,  2382,  2385,
-    2388,  2392,  2396,  2398,  2403,  2408,  2412,  2418,  2427,  2431,
-    2433,  2436,  2438,  2441,  2448,  2454,  2461,  2469,  2477,  2479,
-    2482,  2485,  2487,  2490,  2493,  2497,  2501,  2503,  2508,  2513,
-    2517,  2526,  2530,  2532,  2534,  2537,  2539,  2541,  2544,  2548,
-    2551,  2555,  2558,  2562,  2566,  2569,  2574,  2578,  2581,  2585,
-    2588,  2593,  2597,  2600,  2607,  2614,  2621,  2629,  2631,  2634,
-    2636,  2638,  2640,  2643,  2647,  2650,  2654,  2657,  2661,  2665,
-    2670,  2673,  2677,  2682,  2685,  2691,  2697,  2704,  2711,  2712,
-    2714,  2715
+      82,    90,    93,    96,   104,   109,   111,   115,   116,   118,
+     120,   124,   126,   130,   138,   142,   150,   152,   154,   156,
+     158,   160,   163,   166,   169,   172,   175,   178,   183,   186,
+     191,   198,   200,   205,   210,   212,   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,   356,
+     357,   359,   361,   363,   365,   367,   369,   371,   373,   375,
+     377,   379,   381,   383,   386,   392,   399,   407,   409,   413,
+     415,   419,   420,   422,   424,   426,   428,   430,   432,   434,
+     436,   438,   445,   450,   453,   461,   463,   467,   469,   472,
+     474,   477,   479,   482,   485,   491,   499,   505,   515,   521,
+     531,   533,   537,   539,   541,   545,   549,   552,   554,   557,
+     560,   561,   563,   566,   570,   571,   573,   576,   580,   584,
+     589,   590,   592,   594,   597,   603,   611,   618,   625,   630,
+     634,   639,   642,   646,   649,   653,   657,   661,   665,   671,
+     675,   679,   684,   686,   692,   699,   705,   712,   722,   733,
+     743,   754,   757,   759,   762,   765,   768,   770,   777,   786,
+     797,   810,   825,   826,   828,   829,   831,   833,   837,   842,
+     850,   851,   853,   857,   859,   863,   865,   867,   869,   873,
+     875,   877,   879,   883,   884,   886,   890,   895,   897,   901,
+     903,   905,   909,   913,   917,   921,   925,   928,   932,   939,
+     943,   947,   952,   954,   957,   960,   964,   970,   979,   987,
+     995,  1001,  1011,  1014,  1017,  1023,  1027,  1033,  1038,  1042,
+    1047,  1052,  1060,  1064,  1068,  1072,  1076,  1081,  1088,  1090,
+    1092,  1094,  1096,  1098,  1100,  1102,  1104,  1105,  1107,  1109,
+    1112,  1114,  1116,  1118,  1120,  1122,  1124,  1126,  1127,  1133,
+    1135,  1138,  1142,  1144,  1147,  1149,  1151,  1153,  1155,  1157,
+    1159,  1161,  1163,  1165,  1167,  1169,  1171,  1173,  1175,  1177,
+    1179,  1181,  1183,  1185,  1187,  1189,  1191,  1194,  1197,  1201,
+    1205,  1207,  1211,  1213,  1216,  1219,  1222,  1227,  1232,  1237,
+    1242,  1244,  1247,  1250,  1254,  1256,  1259,  1262,  1264,  1267,
+    1270,  1274,  1276,  1279,  1282,  1284,  1286,  1291,  1294,  1295,
+    1302,  1310,  1313,  1316,  1319,  1320,  1323,  1326,  1330,  1333,
+    1337,  1339,  1342,  1346,  1349,  1352,  1357,  1358,  1360,  1363,
+    1366,  1368,  1369,  1371,  1374,  1377,  1383,  1386,  1387,  1395,
+    1398,  1403,  1404,  1407,  1408,  1410,  1412,  1414,  1420,  1426,
+    1432,  1434,  1440,  1446,  1456,  1458,  1464,  1465,  1467,  1469,
+    1475,  1477,  1479,  1485,  1491,  1493,  1497,  1501,  1506,  1508,
+    1510,  1512,  1514,  1517,  1519,  1523,  1527,  1529,  1532,  1534,
+    1538,  1540,  1542,  1544,  1546,  1548,  1550,  1552,  1554,  1556,
+    1558,  1560,  1563,  1565,  1567,  1569,  1572,  1573,  1576,  1579,
+    1581,  1586,  1587,  1589,  1592,  1596,  1601,  1604,  1607,  1609,
+    1612,  1615,  1621,  1627,  1635,  1642,  1644,  1647,  1650,  1654,
+    1656,  1659,  1662,  1667,  1670,  1675,  1676,  1681,  1684,  1686,
+    1688,  1690,  1691,  1694,  1700,  1706,  1720,  1722,  1724,  1728,
+    1732,  1735,  1739,  1743,  1746,  1751,  1753,  1760,  1770,  1771,
+    1783,  1785,  1789,  1793,  1797,  1799,  1801,  1807,  1810,  1816,
+    1817,  1819,  1821,  1825,  1826,  1828,  1830,  1832,  1834,  1835,
+    1842,  1845,  1847,  1850,  1855,  1858,  1862,  1866,  1870,  1875,
+    1881,  1887,  1893,  1900,  1902,  1904,  1906,  1910,  1911,  1917,
+    1918,  1920,  1922,  1925,  1932,  1934,  1938,  1939,  1941,  1946,
+    1948,  1950,  1952,  1954,  1957,  1959,  1962,  1965,  1967,  1971,
+    1974,  1978,  1982,  1985,  1990,  1995,  1999,  2008,  2012,  2015,
+    2017,  2020,  2027,  2036,  2040,  2043,  2047,  2051,  2056,  2061,
+    2065,  2067,  2069,  2071,  2076,  2083,  2087,  2090,  2094,  2098,
+    2103,  2108,  2112,  2115,  2117,  2120,  2123,  2125,  2129,  2132,
+    2136,  2140,  2143,  2148,  2153,  2157,  2164,  2173,  2177,  2180,
+    2182,  2185,  2188,  2191,  2195,  2199,  2202,  2207,  2212,  2216,
+    2223,  2232,  2236,  2239,  2241,  2244,  2247,  2249,  2251,  2254,
+    2258,  2262,  2265,  2270,  2277,  2286,  2288,  2291,  2294,  2296,
+    2299,  2302,  2306,  2310,  2312,  2317,  2322,  2326,  2332,  2341,
+    2345,  2348,  2352,  2354,  2360,  2366,  2373,  2380,  2382,  2385,
+    2388,  2390,  2393,  2396,  2400,  2404,  2406,  2411,  2416,  2420,
+    2426,  2435,  2439,  2441,  2444,  2446,  2449,  2456,  2462,  2469,
+    2477,  2485,  2487,  2490,  2493,  2495,  2498,  2501,  2505,  2509,
+    2511,  2516,  2521,  2525,  2534,  2538,  2540,  2542,  2545,  2547,
+    2549,  2552,  2556,  2559,  2563,  2566,  2570,  2574,  2577,  2582,
+    2586,  2589,  2593,  2596,  2601,  2605,  2608,  2615,  2622,  2629,
+    2637,  2639,  2642,  2644,  2646,  2648,  2651,  2655,  2658,  2662,
+    2665,  2669,  2673,  2678,  2681,  2685,  2690,  2693,  2699,  2705,
+    2712,  2719,  2720,  2722,  2723
 };
 
@@ -744 +745 @@
 static const yytype_int16 yyrhs[] =
 {
-     302,     0,    -1,    -1,    -1,    79,    -1,    80,    -1,    81,
+     303,     0,    -1,    -1,    -1,    79,    -1,    80,    -1,    81,
       -1,    72,    -1,    76,    -1,   140,    -1,    72,    -1,    76,
       -1,    72,    -1,   140,    -1,    83,    -1,    84,    -1,   142,
       -1,    82,    -1,   142,    82,    -1,    72,    -1,   140,    -1,
-     109,   170,   110,    -1,   109,   174,   110,    -1,   143,    -1,
-     144,   111,   134,   165,   135,   112,    -1,   144,   109,   145,
+     109,   171,   110,    -1,   109,   175,   110,    -1,   143,    -1,
+     144,   111,   134,   166,   135,   112,    -1,   144,   109,   145,
      110,    -1,   144,   113,   139,    -1,   144,   113,   111,   134,
-     147,   135,   112,    -1,   144,    85,   139,    -1,   144,    85,
-     111,   134,   147,   135,   112,    -1,   144,    86,    -1,   144,
-      87,    -1,   109,   275,   110,   114,   279,   372,   115,    -1,
-     144,   114,   145,   115,    -1,   146,    -1,   145,   116,   146,
-      -1,    -1,   165,    -1,   148,    -1,   147,   116,   148,    -1,
-     139,    -1,   139,   113,   148,    -1,   139,   113,   111,   134,
-     147,   135,   112,    -1,   139,    85,   148,    -1,   139,    85,
-     111,   134,   147,   135,   112,    -1,   144,    -1,   136,    -1,
-     141,    -1,    40,   152,    -1,   150,   152,    -1,   151,   152,
-      -1,    86,   149,    -1,    87,   149,    -1,    37,   149,    -1,
-      37,   109,   275,   110,    -1,    66,   149,    -1,    66,   109,
-     275,   110,    -1,    38,   109,   275,   116,   139,   110,    -1,
-      76,    -1,    76,   109,   146,   110,    -1,    76,   109,   276,
-     110,    -1,   117,    -1,   118,    -1,   119,    -1,   120,    -1,
-     121,    -1,   122,    -1,   149,    -1,   109,   275,   110,   152,
-      -1,   109,   275,   110,   168,    -1,   152,    -1,   153,   117,
-     152,    -1,   153,   123,   152,    -1,   153,   124,   152,    -1,
-     153,    -1,   154,   119,   153,    -1,   154,   120,   153,    -1,
-     154,    -1,   155,    88,   154,    -1,   155,    89,   154,    -1,
-     155,    -1,   156,   125,   155,    -1,   156,   126,   155,    -1,
-     156,    90,   155,    -1,   156,    91,   155,    -1,   156,    -1,
-     157,    92,   156,    -1,   157,    93,   156,    -1,   157,    -1,
-     158,   118,   157,    -1,   158,    -1,   159,   127,   158,    -1,
-     159,    -1,   160,   128,   159,    -1,   160,    -1,   161,    94,
-     160,    -1,   161,    -1,   162,    95,   161,    -1,   162,    -1,
-     162,   129,   170,   130,   163,    -1,   162,   129,   130,   163,
-      -1,   162,   129,   170,   130,   168,    -1,   163,    -1,   163,
-      -1,   149,   167,   165,    -1,   168,   373,    -1,    -1,   165,
-      -1,   131,    -1,   107,    -1,    97,    -1,    98,    -1,    99,
-      -1,   100,    -1,   101,    -1,   102,    -1,   103,    -1,   104,
-      -1,   105,    -1,   106,    -1,   111,   112,    -1,   111,   134,
-     165,   135,   112,    -1,   111,   134,   116,   169,   135,   112,
-      -1,   111,   134,   165,   116,   169,   135,   112,    -1,   166,
-      -1,   169,   116,   166,    -1,   165,    -1,   170,   116,   165,
-      -1,    -1,   170,    -1,   173,    -1,   174,    -1,   178,    -1,
-     179,    -1,   191,    -1,   193,    -1,   194,    -1,   199,    -1,
-     127,   144,   114,   145,   115,   132,    -1,    72,   130,   312,
-     172,    -1,   114,   115,    -1,   114,   134,   134,   210,   175,
-     135,   115,    -1,   176,    -1,   175,   134,   176,    -1,   213,
-      -1,    40,   213,    -1,   308,    -1,   172,   135,    -1,   172,
-      -1,   177,   172,    -1,   171,   132,    -1,    41,   109,   170,
-     110,   172,    -1,    41,   109,   170,   110,   172,    42,   172,
-      -1,    43,   109,   170,   110,   184,    -1,    43,   109,   170,
-     110,   114,   134,   206,   185,   115,    -1,    53,   109,   170,
-     110,   184,    -1,    53,   109,   170,   110,   114,   134,   206,
-     187,   115,    -1,   164,    -1,   164,    96,   164,    -1,   310,
-      -1,   180,    -1,   181,   116,   180,    -1,    44,   181,   130,
-      -1,    45,   130,    -1,   182,    -1,   183,   182,    -1,   183,
-     172,    -1,    -1,   186,    -1,   183,   177,    -1,   186,   183,
-     177,    -1,    -1,   188,    -1,   183,   190,    -1,   183,   177,
-     189,    -1,   188,   183,   190,    -1,   188,   183,   177,   189,
-      -1,    -1,   190,    -1,    56,    -1,    56,   132,    -1,    47,
-     109,   170,   110,   172,    -1,    46,   172,    47,   109,   170,
-     110,   132,    -1,    48,   109,   134,   192,   110,   172,    -1,
-     171,   135,   132,   171,   132,   171,    -1,   213,   171,   132,
-     171,    -1,    51,    72,   132,    -1,    51,   117,   170,   132,
-      -1,    50,   132,    -1,    50,    72,   132,    -1,    49,   132,
-      -1,    49,    72,   132,    -1,    52,   171,   132,    -1,    61,
-     166,   132,    -1,    62,   166,   132,    -1,    62,   166,    63,
-     165,   132,    -1,    57,   174,   195,    -1,    57,   174,   197,
-      -1,    57,   174,   195,   197,    -1,   196,    -1,    58,   109,
-      96,   110,   174,    -1,   196,    58,   109,    96,   110,   174,
-      -1,    59,   109,    96,   110,   174,    -1,   196,    59,   109,
-      96,   110,   174,    -1,    58,   109,   134,   134,   198,   135,
-     110,   174,   135,    -1,   196,    58,   109,   134,   134,   198,
-     135,   110,   174,   135,    -1,    59,   109,   134,   134,   198,
-     135,   110,   174,   135,    -1,   196,    59,   109,   134,   134,
-     198,   135,   110,   174,   135,    -1,    60,   174,    -1,   226,
-      -1,   226,   309,    -1,   226,   357,    -1,   366,   139,    -1,
-     366,    -1,    64,   200,   109,   141,   110,   132,    -1,    64,
-     200,   109,   141,   130,   201,   110,   132,    -1,    64,   200,
-     109,   141,   130,   201,   130,   201,   110,   132,    -1,    64,
-     200,   109,   141,   130,   201,   130,   201,   130,   204,   110,
-     132,    -1,    64,   200,    51,   109,   141,   130,   130,   201,
-     130,   204,   130,   205,   110,   132,    -1,    -1,    11,    -1,
-      -1,   202,    -1,   203,    -1,   202,   116,   203,    -1,   141,
-     109,   164,   110,    -1,   111,   164,   112,   141,   109,   164,
-     110,    -1,    -1,   141,    -1,   204,   116,   141,    -1,   139,
-      -1,   205,   116,   139,    -1,   135,    -1,   207,    -1,   213,
-      -1,   207,   134,   213,    -1,   135,    -1,   209,    -1,   223,
-      -1,   209,   134,   223,    -1,    -1,   211,    -1,    29,   212,
-     132,    -1,   211,    29,   212,   132,    -1,   274,    -1,   212,
-     116,   274,    -1,   214,    -1,   223,    -1,   215,   135,   132,
-      -1,   220,   135,   132,    -1,   217,   135,   132,    -1,   293,
-     135,   132,    -1,   296,   135,   132,    -1,   216,   277,    -1,
-     232,   216,   277,    -1,   215,   135,   116,   134,   272,   277,
-      -1,   367,   272,   311,    -1,   370,   272,   311,    -1,   228,
-     370,   272,   311,    -1,   218,    -1,   228,   218,    -1,   232,
-     218,    -1,   232,   228,   218,    -1,   217,   135,   116,   134,
-     272,    -1,   111,   112,   272,   109,   134,   260,   135,   110,
-      -1,   370,   272,   109,   134,   260,   135,   110,    -1,   219,
-     272,   109,   134,   260,   135,   110,    -1,   111,   134,   262,
-     135,   112,    -1,   111,   134,   262,   135,   116,   134,   263,
-     135,   112,    -1,     3,   216,    -1,     3,   218,    -1,   220,
-     135,   116,   134,   139,    -1,     3,   226,   309,    -1,   221,
-     135,   116,   134,   309,    -1,   228,     3,   226,   309,    -1,
-     226,     3,   309,    -1,   226,     3,   228,   309,    -1,     3,
-     139,   131,   165,    -1,   222,   135,   116,   134,   139,   131,
-     165,    -1,   224,   135,   132,    -1,   221,   135,   132,    -1,
-     222,   135,   132,    -1,   240,   135,   132,    -1,   225,   309,
-     311,   277,    -1,   224,   116,   312,   309,   311,   277,    -1,
-     236,    -1,   240,    -1,   242,    -1,   283,    -1,   237,    -1,
-     241,    -1,   243,    -1,   284,    -1,    -1,   228,    -1,   229,
-      -1,   228,   229,    -1,   230,    -1,   314,    -1,    10,    -1,
-      12,    -1,    11,    -1,    14,    -1,    67,    -1,    -1,    13,
-     109,   231,   286,   110,    -1,   233,    -1,   228,   233,    -1,
-     232,   228,   233,    -1,   234,    -1,   233,   234,    -1,     5,
-      -1,     7,    -1,     4,    -1,     6,    -1,     8,    -1,     9,
-      -1,    69,    -1,    71,    -1,    16,    -1,    21,    -1,    20,
-      -1,    18,    -1,    19,    -1,    17,    -1,    22,    -1,    23,
-      -1,    15,    -1,    25,    -1,    26,    -1,    27,    -1,    24,
-      -1,   237,    -1,   232,   237,    -1,   236,   234,    -1,   236,
-     234,   228,    -1,   236,   234,   237,    -1,   238,    -1,   227,
-     239,   227,    -1,   235,    -1,   228,   235,    -1,   238,   229,
-      -1,   238,   235,    -1,    28,   109,   276,   110,    -1,    28,
-     109,   170,   110,    -1,    78,   109,   276,   110,    -1,    78,
-     109,   170,   110,    -1,   241,    -1,   232,   241,    -1,   240,
-     234,    -1,   240,   234,   228,    -1,   244,    -1,   228,   244,
-      -1,   241,   229,    -1,   243,    -1,   232,   243,    -1,   242,
-     234,    -1,   242,   234,   228,    -1,    74,    -1,   228,    74,
-      -1,   243,   229,    -1,   245,    -1,   256,    -1,   247,   114,
-     248,   115,    -1,   247,   274,    -1,    -1,   247,   274,   246,
-     114,   248,   115,    -1,   247,   109,   292,   110,   114,   248,
-     115,    -1,   247,   285,    -1,    31,   312,    -1,    32,   312,
-      -1,    -1,   248,   249,    -1,   250,   132,    -1,    40,   250,
-     132,    -1,   251,   132,    -1,    40,   251,   132,    -1,   366,
-      -1,   366,   274,    -1,   250,   116,   274,    -1,   250,   116,
-      -1,   226,   252,    -1,   251,   116,   312,   252,    -1,    -1,
-     254,    -1,   318,   253,    -1,   331,   253,    -1,   357,    -1,
-      -1,   254,    -1,   130,   164,    -1,    30,   312,    -1,   255,
-     114,   258,   372,   115,    -1,   255,   274,    -1,    -1,   255,
-     274,   257,   114,   258,   372,   115,    -1,   274,   259,    -1,
-     258,   116,   274,   259,    -1,    -1,   131,   164,    -1,    -1,
-     261,    -1,   263,    -1,   262,    -1,   262,   135,   116,   134,
-     263,    -1,   263,   135,   116,   134,    96,    -1,   262,   135,
-     116,   134,    96,    -1,   267,    -1,   263,   135,   116,   134,
-     267,    -1,   262,   135,   116,   134,   267,    -1,   262,   135,
-     116,   134,   263,   135,   116,   134,   267,    -1,   268,    -1,
-     263,   135,   116,   134,   268,    -1,    -1,   265,    -1,   266,
-      -1,   266,   135,   116,   134,    96,    -1,   270,    -1,   269,
-      -1,   266,   135,   116,   134,   270,    -1,   266,   135,   116,
-     134,   269,    -1,   269,    -1,   362,   272,   373,    -1,   370,
-     272,   373,    -1,   228,   370,   272,   373,    -1,   218,    -1,
-     270,    -1,   362,    -1,   370,    -1,   228,   370,    -1,   371,
-      -1,   225,   336,   373,    -1,   225,   340,   373,    -1,   225,
-      -1,   225,   351,    -1,   139,    -1,   271,   116,   139,    -1,
-     137,    -1,    74,    -1,    75,    -1,   138,    -1,    74,    -1,
-      75,    -1,   139,    -1,    74,    -1,    75,    -1,   366,    -1,
-     226,    -1,   226,   357,    -1,   366,    -1,   371,    -1,   226,
-      -1,   226,   345,    -1,    -1,   131,   278,    -1,   107,   278,
-      -1,   165,    -1,   114,   279,   372,   115,    -1,    -1,   278,
-      -1,   280,   278,    -1,   279,   116,   278,    -1,   279,   116,
-     280,   278,    -1,   281,   130,    -1,   274,   130,    -1,   282,
-      -1,   281,   282,    -1,   113,   274,    -1,   111,   134,   165,
-     135,   112,    -1,   111,   134,   310,   135,   112,    -1,   111,
-     134,   164,    96,   164,   135,   112,    -1,   113,   111,   134,
-     147,   135,   112,    -1,   284,    -1,   232,   284,    -1,   283,
-     234,    -1,   283,   234,   228,    -1,   285,    -1,   228,   285,
-      -1,   284,   229,    -1,    75,   109,   292,   110,    -1,   287,
-     373,    -1,   286,   116,   287,   373,    -1,    -1,   289,   274,
-     288,   290,    -1,   226,   336,    -1,    33,    -1,    35,    -1,
-      34,    -1,    -1,   290,   291,    -1,   128,   274,   109,   292,
-     110,    -1,   128,   114,   134,   298,   115,    -1,   128,   109,
-     134,   286,   135,   110,   114,   134,   298,   115,   109,   292,
-     110,    -1,   276,    -1,   165,    -1,   292,   116,   276,    -1,
-     292,   116,   165,    -1,    33,   294,    -1,   233,    33,   294,
-      -1,   293,   116,   294,    -1,   295,   290,    -1,   295,   290,
-     131,   276,    -1,   274,    -1,   273,   109,   134,   286,   135,
-     110,    -1,    36,   274,   109,   134,   286,   135,   110,   114,
-     115,    -1,    -1,    36,   274,   109,   134,   286,   135,   110,
-     114,   297,   298,   115,    -1,   299,    -1,   298,   134,   299,
-      -1,   300,   135,   132,    -1,   301,   135,   132,    -1,   216,
-      -1,   218,    -1,   300,   135,   116,   134,   272,    -1,   226,
-     309,    -1,   301,   135,   116,   134,   309,    -1,    -1,   303,
-      -1,   305,    -1,   303,   134,   305,    -1,    -1,   303,    -1,
-     213,    -1,   307,    -1,   199,    -1,    -1,     5,    82,   306,
-     114,   304,   115,    -1,    40,   305,    -1,   308,    -1,   323,
-     174,    -1,   327,   134,   208,   174,    -1,   217,   174,    -1,
-     225,   323,   174,    -1,   228,   323,   174,    -1,   232,   323,
-     174,    -1,   232,   228,   323,   174,    -1,   225,   327,   134,
-     208,   174,    -1,   228,   327,   134,   208,   174,    -1,   232,
-     327,   134,   208,   174,    -1,   232,   228,   327,   134,   208,
-     174,    -1,   318,    -1,   331,    -1,   323,    -1,   164,   122,
-     164,    -1,    -1,    64,   109,   142,   110,   312,    -1,    -1,
-     313,    -1,   314,    -1,   313,   314,    -1,    39,   109,   109,
-     315,   110,   110,    -1,   316,    -1,   315,   116,   316,    -1,
-      -1,   317,    -1,   317,   109,   171,   110,    -1,   272,    -1,
-     234,    -1,   235,    -1,   229,    -1,   319,   312,    -1,   320,
-      -1,   321,   312,    -1,   322,   312,    -1,   137,    -1,   109,
-     319,   110,    -1,   150,   318,    -1,   150,   228,   318,    -1,
-     109,   320,   110,    -1,   319,   349,    -1,   109,   320,   110,
-     349,    -1,   109,   321,   110,   350,    -1,   109,   321,   110,
-      -1,   109,   320,   110,   109,   134,   264,   135,   110,    -1,
-     109,   322,   110,    -1,   324,   312,    -1,   325,    -1,   326,
-     312,    -1,   319,   109,   134,   264,   135,   110,    -1,   109,
-     325,   110,   109,   134,   264,   135,   110,    -1,   109,   324,
-     110,    -1,   150,   323,    -1,   150,   228,   323,    -1,   109,
-     325,   110,    -1,   109,   325,   110,   349,    -1,   109,   326,
-     110,   350,    -1,   109,   326,   110,    -1,   328,    -1,   329,
-      -1,   330,    -1,   319,   109,   271,   110,    -1,   109,   329,
-     110,   109,   271,   110,    -1,   109,   328,   110,    -1,   150,
-     327,    -1,   150,   228,   327,    -1,   109,   329,   110,    -1,
-     109,   329,   110,   349,    -1,   109,   330,   110,   350,    -1,
-     109,   330,   110,    -1,   332,   312,    -1,   333,    -1,   334,
-     312,    -1,   335,   312,    -1,   341,    -1,   109,   332,   110,
-      -1,   150,   331,    -1,   150,   228,   331,    -1,   109,   333,
-     110,    -1,   332,   349,    -1,   109,   333,   110,   349,    -1,
-     109,   334,   110,   350,    -1,   109,   334,   110,    -1,   332,
-     109,   134,   264,   135,   110,    -1,   109,   333,   110,   109,
-     134,   264,   135,   110,    -1,   109,   335,   110,    -1,   319,
-     312,    -1,   337,    -1,   338,   312,    -1,   339,   312,    -1,
-     150,   336,    -1,   150,   228,   336,    -1,   109,   337,   110,
-      -1,   319,   355,    -1,   109,   337,   110,   349,    -1,   109,
-     338,   110,   350,    -1,   109,   338,   110,    -1,   319,   109,
-     134,   264,   135,   110,    -1,   109,   337,   110,   109,   134,
-     264,   135,   110,    -1,   109,   339,   110,    -1,   341,   312,
-      -1,   342,    -1,   343,   312,    -1,   344,   312,    -1,    74,
-      -1,    75,    -1,   150,   340,    -1,   150,   228,   340,    -1,
-     109,   342,   110,    -1,   341,   355,    -1,   109,   342,   110,
-     355,    -1,   341,   109,   134,   264,   135,   110,    -1,   109,
-     342,   110,   109,   134,   264,   135,   110,    -1,   346,    -1,
-     347,   312,    -1,   348,   312,    -1,   150,    -1,   150,   228,
-      -1,   150,   345,    -1,   150,   228,   345,    -1,   109,   346,
-     110,    -1,   349,    -1,   109,   346,   110,   349,    -1,   109,
-     347,   110,   350,    -1,   109,   347,   110,    -1,   109,   134,
-     264,   135,   110,    -1,   109,   346,   110,   109,   134,   264,
-     135,   110,    -1,   109,   348,   110,    -1,   111,   112,    -1,
-     111,   112,   350,    -1,   350,    -1,   111,   134,   165,   135,
-     112,    -1,   111,   134,   117,   135,   112,    -1,   350,   111,
-     134,   165,   135,   112,    -1,   350,   111,   134,   117,   135,
-     112,    -1,   352,    -1,   353,   312,    -1,   354,   312,    -1,
-     150,    -1,   150,   228,    -1,   150,   351,    -1,   150,   228,
-     351,    -1,   109,   352,   110,    -1,   355,    -1,   109,   352,
-     110,   355,    -1,   109,   353,   110,   350,    -1,   109,   353,
-     110,    -1,   109,   134,   264,   135,   110,    -1,   109,   352,
-     110,   109,   134,   264,   135,   110,    -1,   109,   354,   110,
-      -1,   356,    -1,   356,   350,    -1,   350,    -1,   111,   112,
-      -1,   111,   134,   228,   117,   135,   112,    -1,   111,   134,
-     228,   135,   112,    -1,   111,   134,   228,   165,   135,   112,
-      -1,   111,   134,     7,   227,   165,   135,   112,    -1,   111,
-     134,   228,     7,   165,   135,   112,    -1,   358,    -1,   359,
-     312,    -1,   360,   312,    -1,   150,    -1,   150,   228,    -1,
-     150,   357,    -1,   150,   228,   357,    -1,   109,   358,   110,
-      -1,   349,    -1,   109,   358,   110,   349,    -1,   109,   359,
-     110,   350,    -1,   109,   359,   110,    -1,   109,   358,   110,
-     109,   134,   264,   135,   110,    -1,   109,   360,   110,    -1,
-     362,    -1,   370,    -1,   228,   370,    -1,   363,    -1,   364,
-      -1,   150,   226,    -1,   228,   150,   226,    -1,   150,   371,
-      -1,   228,   150,   371,    -1,   150,   361,    -1,   228,   150,
-     361,    -1,   111,   112,   226,    -1,   365,   226,    -1,   111,
-     112,   350,   226,    -1,   365,   350,   226,    -1,   350,   226,
-      -1,   111,   112,   363,    -1,   365,   363,    -1,   111,   112,
-     350,   363,    -1,   365,   350,   363,    -1,   350,   363,    -1,
-     111,   134,   228,   117,   135,   112,    -1,   111,   134,   228,
-     165,   135,   112,    -1,   111,   134,   232,   165,   135,   112,
-      -1,   111,   134,   232,   228,   165,   135,   112,    -1,   370,
-      -1,   228,   370,    -1,   367,    -1,   368,    -1,   369,    -1,
-     150,   226,    -1,   228,   150,   226,    -1,   150,   371,    -1,
-     228,   150,   371,    -1,   150,   366,    -1,   228,   150,   366,
-      -1,   111,   112,   226,    -1,   111,   112,   350,   226,    -1,
-     350,   226,    -1,   111,   112,   368,    -1,   111,   112,   350,
-     368,    -1,   350,   368,    -1,   111,   134,   263,   135,   112,
-      -1,   111,   112,   109,   260,   110,    -1,   370,   109,   134,
-     260,   135,   110,    -1,   219,   109,   134,   260,   135,   110,
-      -1,    -1,   116,    -1,    -1,   131,   165,    -1
+     147,   135,   112,    -1,   144,   113,    79,    -1,   144,    85,
+     139,    -1,   144,    85,   111,   134,   147,   135,   112,    -1,
+     144,    86,    -1,   144,    87,    -1,   109,   276,   110,   114,
+     280,   373,   115,    -1,   144,   114,   145,   115,    -1,   146,
+      -1,   145,   116,   146,    -1,    -1,   166,    -1,   148,    -1,
+     147,   116,   148,    -1,   149,    -1,   149,   113,   148,    -1,
+     149,   113,   111,   134,   147,   135,   112,    -1,   149,    85,
+     148,    -1,   149,    85,   111,   134,   147,   135,   112,    -1,
+     139,    -1,    79,    -1,   144,    -1,   136,    -1,   141,    -1,
+      40,   153,    -1,   151,   153,    -1,   152,   153,    -1,    86,
+     150,    -1,    87,   150,    -1,    37,   150,    -1,    37,   109,
+     276,   110,    -1,    66,   150,    -1,    66,   109,   276,   110,
+      -1,    38,   109,   276,   116,   139,   110,    -1,    76,    -1,
+      76,   109,   146,   110,    -1,    76,   109,   277,   110,    -1,
+     117,    -1,   118,    -1,   119,    -1,   120,    -1,   121,    -1,
+     122,    -1,   150,    -1,   109,   276,   110,   153,    -1,   109,
+     276,   110,   169,    -1,   153,    -1,   154,   117,   153,    -1,
+     154,   123,   153,    -1,   154,   124,   153,    -1,   154,    -1,
+     155,   119,   154,    -1,   155,   120,   154,    -1,   155,    -1,
+     156,    88,   155,    -1,   156,    89,   155,    -1,   156,    -1,
+     157,   125,   156,    -1,   157,   126,   156,    -1,   157,    90,
+     156,    -1,   157,    91,   156,    -1,   157,    -1,   158,    92,
+     157,    -1,   158,    93,   157,    -1,   158,    -1,   159,   118,
+     158,    -1,   159,    -1,   160,   127,   159,    -1,   160,    -1,
+     161,   128,   160,    -1,   161,    -1,   162,    94,   161,    -1,
+     162,    -1,   163,    95,   162,    -1,   163,    -1,   163,   129,
+     171,   130,   164,    -1,   163,   129,   130,   164,    -1,   163,
+     129,   171,   130,   169,    -1,   164,    -1,   164,    -1,   150,
+     168,   166,    -1,   169,   374,    -1,    -1,   166,    -1,   131,
+      -1,   107,    -1,    97,    -1,    98,    -1,    99,    -1,   100,
+      -1,   101,    -1,   102,    -1,   103,    -1,   104,    -1,   105,
+      -1,   106,    -1,   111,   112,    -1,   111,   134,   166,   135,
+     112,    -1,   111,   134,   116,   170,   135,   112,    -1,   111,
+     134,   166,   116,   170,   135,   112,    -1,   167,    -1,   170,
+     116,   167,    -1,   166,    -1,   171,   116,   166,    -1,    -1,
+     171,    -1,   174,    -1,   175,    -1,   179,    -1,   180,    -1,
+     192,    -1,   194,    -1,   195,    -1,   200,    -1,   127,   144,
+     114,   145,   115,   132,    -1,    72,   130,   313,   173,    -1,
+     114,   115,    -1,   114,   134,   134,   211,   176,   135,   115,
+      -1,   177,    -1,   176,   134,   177,    -1,   214,    -1,    40,
+     214,    -1,   309,    -1,   173,   135,    -1,   173,    -1,   178,
+     173,    -1,   172,   132,    -1,    41,   109,   171,   110,   173,
+      -1,    41,   109,   171,   110,   173,    42,   173,    -1,    43,
+     109,   171,   110,   185,    -1,    43,   109,   171,   110,   114,
+     134,   207,   186,   115,    -1,    53,   109,   171,   110,   185,
+      -1,    53,   109,   171,   110,   114,   134,   207,   188,   115,
+      -1,   165,    -1,   165,    96,   165,    -1,   311,    -1,   181,
+      -1,   182,   116,   181,    -1,    44,   182,   130,    -1,    45,
+     130,    -1,   183,    -1,   184,   183,    -1,   184,   173,    -1,
+      -1,   187,    -1,   184,   178,    -1,   187,   184,   178,    -1,
+      -1,   189,    -1,   184,   191,    -1,   184,   178,   190,    -1,
+     189,   184,   191,    -1,   189,   184,   178,   190,    -1,    -1,
+     191,    -1,    56,    -1,    56,   132,    -1,    47,   109,   171,
+     110,   173,    -1,    46,   173,    47,   109,   171,   110,   132,
+      -1,    48,   109,   134,   193,   110,   173,    -1,   172,   135,
+     132,   172,   132,   172,    -1,   214,   172,   132,   172,    -1,
+      51,    72,   132,    -1,    51,   117,   171,   132,    -1,    50,
+     132,    -1,    50,    72,   132,    -1,    49,   132,    -1,    49,
+      72,   132,    -1,    52,   172,   132,    -1,    61,   167,   132,
+      -1,    62,   167,   132,    -1,    62,   167,    63,   166,   132,
+      -1,    57,   175,   196,    -1,    57,   175,   198,    -1,    57,
+     175,   196,   198,    -1,   197,    -1,    58,   109,    96,   110,
+     175,    -1,   197,    58,   109,    96,   110,   175,    -1,    59,
+     109,    96,   110,   175,    -1,   197,    59,   109,    96,   110,
+     175,    -1,    58,   109,   134,   134,   199,   135,   110,   175,
+     135,    -1,   197,    58,   109,   134,   134,   199,   135,   110,
+     175,   135,    -1,    59,   109,   134,   134,   199,   135,   110,
+     175,   135,    -1,   197,    59,   109,   134,   134,   199,   135,
+     110,   175,   135,    -1,    60,   175,    -1,   227,    -1,   227,
+     310,    -1,   227,   358,    -1,   367,   139,    -1,   367,    -1,
+      64,   201,   109,   141,   110,   132,    -1,    64,   201,   109,
+     141,   130,   202,   110,   132,    -1,    64,   201,   109,   141,
+     130,   202,   130,   202,   110,   132,    -1,    64,   201,   109,
+     141,   130,   202,   130,   202,   130,   205,   110,   132,    -1,
+      64,   201,    51,   109,   141,   130,   130,   202,   130,   205,
+     130,   206,   110,   132,    -1,    -1,    11,    -1,    -1,   203,
+      -1,   204,    -1,   203,   116,   204,    -1,   141,   109,   165,
+     110,    -1,   111,   165,   112,   141,   109,   165,   110,    -1,
+      -1,   141,    -1,   205,   116,   141,    -1,   139,    -1,   206,
+     116,   139,    -1,   135,    -1,   208,    -1,   214,    -1,   208,
+     134,   214,    -1,   135,    -1,   210,    -1,   224,    -1,   210,
+     134,   224,    -1,    -1,   212,    -1,    29,   213,   132,    -1,
+     212,    29,   213,   132,    -1,   275,    -1,   213,   116,   275,
+      -1,   215,    -1,   224,    -1,   216,   135,   132,    -1,   221,
+     135,   132,    -1,   218,   135,   132,    -1,   294,   135,   132,
+      -1,   297,   135,   132,    -1,   217,   278,    -1,   233,   217,
+     278,    -1,   216,   135,   116,   134,   273,   278,    -1,   368,
+     273,   312,    -1,   371,   273,   312,    -1,   229,   371,   273,
+     312,    -1,   219,    -1,   229,   219,    -1,   233,   219,    -1,
+     233,   229,   219,    -1,   218,   135,   116,   134,   273,    -1,
+     111,   112,   273,   109,   134,   261,   135,   110,    -1,   371,
+     273,   109,   134,   261,   135,   110,    -1,   220,   273,   109,
+     134,   261,   135,   110,    -1,   111,   134,   263,   135,   112,
+      -1,   111,   134,   263,   135,   116,   134,   264,   135,   112,
+      -1,     3,   217,    -1,     3,   219,    -1,   221,   135,   116,
+     134,   139,    -1,     3,   227,   310,    -1,   222,   135,   116,
+     134,   310,    -1,   229,     3,   227,   310,    -1,   227,     3,
+     310,    -1,   227,     3,   229,   310,    -1,     3,   139,   131,
+     166,    -1,   223,   135,   116,   134,   139,   131,   166,    -1,
+     225,   135,   132,    -1,   222,   135,   132,    -1,   223,   135,
+     132,    -1,   241,   135,   132,    -1,   226,   310,   312,   278,
+      -1,   225,   116,   313,   310,   312,   278,    -1,   237,    -1,
+     241,    -1,   243,    -1,   284,    -1,   238,    -1,   242,    -1,
+     244,    -1,   285,    -1,    -1,   229,    -1,   230,    -1,   229,
+     230,    -1,   231,    -1,   315,    -1,    10,    -1,    12,    -1,
+      11,    -1,    14,    -1,    67,    -1,    -1,    13,   109,   232,
+     287,   110,    -1,   234,    -1,   229,   234,    -1,   233,   229,
+     234,    -1,   235,    -1,   234,   235,    -1,     5,    -1,     7,
+      -1,     4,    -1,     6,    -1,     8,    -1,     9,    -1,    69,
+      -1,    71,    -1,    16,    -1,    21,    -1,    20,    -1,    18,
+      -1,    19,    -1,    17,    -1,    22,    -1,    23,    -1,    15,
+      -1,    25,    -1,    26,    -1,    27,    -1,    24,    -1,   238,
+      -1,   233,   238,    -1,   237,   235,    -1,   237,   235,   229,
+      -1,   237,   235,   238,    -1,   239,    -1,   228,   240,   228,
+      -1,   236,    -1,   229,   236,    -1,   239,   230,    -1,   239,
+     236,    -1,    28,   109,   277,   110,    -1,    28,   109,   171,
+     110,    -1,    78,   109,   277,   110,    -1,    78,   109,   171,
+     110,    -1,   242,    -1,   233,   242,    -1,   241,   235,    -1,
+     241,   235,   229,    -1,   245,    -1,   229,   245,    -1,   242,
+     230,    -1,   244,    -1,   233,   244,    -1,   243,   235,    -1,
+     243,   235,   229,    -1,    74,    -1,   229,    74,    -1,   244,
+     230,    -1,   246,    -1,   257,    -1,   248,   114,   249,   115,
+      -1,   248,   275,    -1,    -1,   248,   275,   247,   114,   249,
+     115,    -1,   248,   109,   293,   110,   114,   249,   115,    -1,
+     248,   286,    -1,    31,   313,    -1,    32,   313,    -1,    -1,
+     249,   250,    -1,   251,   132,    -1,    40,   251,   132,    -1,
+     252,   132,    -1,    40,   252,   132,    -1,   367,    -1,   367,
+     275,    -1,   251,   116,   275,    -1,   251,   116,    -1,   227,
+     253,    -1,   252,   116,   313,   253,    -1,    -1,   255,    -1,
+     319,   254,    -1,   332,   254,    -1,   358,    -1,    -1,   255,
+      -1,   130,   165,    -1,    30,   313,    -1,   256,   114,   259,
+     373,   115,    -1,   256,   275,    -1,    -1,   256,   275,   258,
+     114,   259,   373,   115,    -1,   275,   260,    -1,   259,   116,
+     275,   260,    -1,    -1,   131,   165,    -1,    -1,   262,    -1,
+     264,    -1,   263,    -1,   263,   135,   116,   134,   264,    -1,
+     264,   135,   116,   134,    96,    -1,   263,   135,   116,   134,
+      96,    -1,   268,    -1,   264,   135,   116,   134,   268,    -1,
+     263,   135,   116,   134,   268,    -1,   263,   135,   116,   134,
+     264,   135,   116,   134,   268,    -1,   269,    -1,   264,   135,
+     116,   134,   269,    -1,    -1,   266,    -1,   267,    -1,   267,
+     135,   116,   134,    96,    -1,   271,    -1,   270,    -1,   267,
+     135,   116,   134,   271,    -1,   267,   135,   116,   134,   270,
+      -1,   270,    -1,   363,   273,   374,    -1,   371,   273,   374,
+      -1,   229,   371,   273,   374,    -1,   219,    -1,   271,    -1,
+     363,    -1,   371,    -1,   229,   371,    -1,   372,    -1,   226,
+     337,   374,    -1,   226,   341,   374,    -1,   226,    -1,   226,
+     352,    -1,   139,    -1,   272,   116,   139,    -1,   137,    -1,
+      74,    -1,    75,    -1,   138,    -1,    74,    -1,    75,    -1,
+     139,    -1,    74,    -1,    75,    -1,   367,    -1,   227,    -1,
+     227,   358,    -1,   367,    -1,   372,    -1,   227,    -1,   227,
+     346,    -1,    -1,   131,   279,    -1,   107,   279,    -1,   166,
+      -1,   114,   280,   373,   115,    -1,    -1,   279,    -1,   281,
+     279,    -1,   280,   116,   279,    -1,   280,   116,   281,   279,
+      -1,   282,   130,    -1,   275,   130,    -1,   283,    -1,   282,
+     283,    -1,   113,   275,    -1,   111,   134,   166,   135,   112,
+      -1,   111,   134,   311,   135,   112,    -1,   111,   134,   165,
+      96,   165,   135,   112,    -1,   113,   111,   134,   147,   135,
+     112,    -1,   285,    -1,   233,   285,    -1,   284,   235,    -1,
+     284,   235,   229,    -1,   286,    -1,   229,   286,    -1,   285,
+     230,    -1,    75,   109,   293,   110,    -1,   288,   374,    -1,
+     287,   116,   288,   374,    -1,    -1,   290,   275,   289,   291,
+      -1,   227,   337,    -1,    33,    -1,    35,    -1,    34,    -1,
+      -1,   291,   292,    -1,   128,   275,   109,   293,   110,    -1,
+     128,   114,   134,   299,   115,    -1,   128,   109,   134,   287,
+     135,   110,   114,   134,   299,   115,   109,   293,   110,    -1,
+     277,    -1,   166,    -1,   293,   116,   277,    -1,   293,   116,
+     166,    -1,    33,   295,    -1,   234,    33,   295,    -1,   294,
+     116,   295,    -1,   296,   291,    -1,   296,   291,   131,   277,
+      -1,   275,    -1,   274,   109,   134,   287,   135,   110,    -1,
+      36,   275,   109,   134,   287,   135,   110,   114,   115,    -1,
+      -1,    36,   275,   109,   134,   287,   135,   110,   114,   298,
+     299,   115,    -1,   300,    -1,   299,   134,   300,    -1,   301,
+     135,   132,    -1,   302,   135,   132,    -1,   217,    -1,   219,
+      -1,   301,   135,   116,   134,   273,    -1,   227,   310,    -1,
+     302,   135,   116,   134,   310,    -1,    -1,   304,    -1,   306,
+      -1,   304,   134,   306,    -1,    -1,   304,    -1,   214,    -1,
+     308,    -1,   200,    -1,    -1,     5,    82,   307,   114,   305,
+     115,    -1,    40,   306,    -1,   309,    -1,   324,   175,    -1,
+     328,   134,   209,   175,    -1,   218,   175,    -1,   226,   324,
+     175,    -1,   229,   324,   175,    -1,   233,   324,   175,    -1,
+     233,   229,   324,   175,    -1,   226,   328,   134,   209,   175,
+      -1,   229,   328,   134,   209,   175,    -1,   233,   328,   134,
+     209,   175,    -1,   233,   229,   328,   134,   209,   175,    -1,
+     319,    -1,   332,    -1,   324,    -1,   165,   122,   165,    -1,
+      -1,    64,   109,   142,   110,   313,    -1,    -1,   314,    -1,
+     315,    -1,   314,   315,    -1,    39,   109,   109,   316,   110,
+     110,    -1,   317,    -1,   316,   116,   317,    -1,    -1,   318,
+      -1,   318,   109,   172,   110,    -1,   273,    -1,   235,    -1,
+     236,    -1,   230,    -1,   320,   313,    -1,   321,    -1,   322,
+     313,    -1,   323,   313,    -1,   137,    -1,   109,   320,   110,
+      -1,   151,   319,    -1,   151,   229,   319,    -1,   109,   321,
+     110,    -1,   320,   350,    -1,   109,   321,   110,   350,    -1,
+     109,   322,   110,   351,    -1,   109,   322,   110,    -1,   109,
+     321,   110,   109,   134,   265,   135,   110,    -1,   109,   323,
+     110,    -1,   325,   313,    -1,   326,    -1,   327,   313,    -1,
+     320,   109,   134,   265,   135,   110,    -1,   109,   326,   110,
+     109,   134,   265,   135,   110,    -1,   109,   325,   110,    -1,
+     151,   324,    -1,   151,   229,   324,    -1,   109,   326,   110,
+      -1,   109,   326,   110,   350,    -1,   109,   327,   110,   351,
+      -1,   109,   327,   110,    -1,   329,    -1,   330,    -1,   331,
+      -1,   320,   109,   272,   110,    -1,   109,   330,   110,   109,
+     272,   110,    -1,   109,   329,   110,    -1,   151,   328,    -1,
+     151,   229,   328,    -1,   109,   330,   110,    -1,   109,   330,
+     110,   350,    -1,   109,   331,   110,   351,    -1,   109,   331,
+     110,    -1,   333,   313,    -1,   334,    -1,   335,   313,    -1,
+     336,   313,    -1,   342,    -1,   109,   333,   110,    -1,   151,
+     332,    -1,   151,   229,   332,    -1,   109,   334,   110,    -1,
+     333,   350,    -1,   109,   334,   110,   350,    -1,   109,   335,
+     110,   351,    -1,   109,   335,   110,    -1,   333,   109,   134,
+     265,   135,   110,    -1,   109,   334,   110,   109,   134,   265,
+     135,   110,    -1,   109,   336,   110,    -1,   320,   313,    -1,
+     338,    -1,   339,   313,    -1,   340,   313,    -1,   151,   337,
+      -1,   151,   229,   337,    -1,   109,   338,   110,    -1,   320,
+     356,    -1,   109,   338,   110,   350,    -1,   109,   339,   110,
+     351,    -1,   109,   339,   110,    -1,   320,   109,   134,   265,
+     135,   110,    -1,   109,   338,   110,   109,   134,   265,   135,
+     110,    -1,   109,   340,   110,    -1,   342,   313,    -1,   343,
+      -1,   344,   313,    -1,   345,   313,    -1,    74,    -1,    75,
+      -1,   151,   341,    -1,   151,   229,   341,    -1,   109,   343,
+     110,    -1,   342,   356,    -1,   109,   343,   110,   356,    -1,
+     342,   109,   134,   265,   135,   110,    -1,   109,   343,   110,
+     109,   134,   265,   135,   110,    -1,   347,    -1,   348,   313,
+      -1,   349,   313,    -1,   151,    -1,   151,   229,    -1,   151,
+     346,    -1,   151,   229,   346,    -1,   109,   347,   110,    -1,
+     350,    -1,   109,   347,   110,   350,    -1,   109,   348,   110,
+     351,    -1,   109,   348,   110,    -1,   109,   134,   265,   135,
+     110,    -1,   109,   347,   110,   109,   134,   265,   135,   110,
+      -1,   109,   349,   110,    -1,   111,   112,    -1,   111,   112,
+     351,    -1,   351,    -1,   111,   134,   166,   135,   112,    -1,
+     111,   134,   117,   135,   112,    -1,   351,   111,   134,   166,
+     135,   112,    -1,   351,   111,   134,   117,   135,   112,    -1,
+     353,    -1,   354,   313,    -1,   355,   313,    -1,   151,    -1,
+     151,   229,    -1,   151,   352,    -1,   151,   229,   352,    -1,
+     109,   353,   110,    -1,   356,    -1,   109,   353,   110,   356,
+      -1,   109,   354,   110,   351,    -1,   109,   354,   110,    -1,
+     109,   134,   265,   135,   110,    -1,   109,   353,   110,   109,
+     134,   265,   135,   110,    -1,   109,   355,   110,    -1,   357,
+      -1,   357,   351,    -1,   351,    -1,   111,   112,    -1,   111,
+     134,   229,   117,   135,   112,    -1,   111,   134,   229,   135,
+     112,    -1,   111,   134,   229,   166,   135,   112,    -1,   111,
+     134,     7,   228,   166,   135,   112,    -1,   111,   134,   229,
+       7,   166,   135,   112,    -1,   359,    -1,   360,   313,    -1,
+     361,   313,    -1,   151,    -1,   151,   229,    -1,   151,   358,
+      -1,   151,   229,   358,    -1,   109,   359,   110,    -1,   350,
+      -1,   109,   359,   110,   350,    -1,   109,   360,   110,   351,
+      -1,   109,   360,   110,    -1,   109,   359,   110,   109,   134,
+     265,   135,   110,    -1,   109,   361,   110,    -1,   363,    -1,
+     371,    -1,   229,   371,    -1,   364,    -1,   365,    -1,   151,
+     227,    -1,   229,   151,   227,    -1,   151,   372,    -1,   229,
+     151,   372,    -1,   151,   362,    -1,   229,   151,   362,    -1,
+     111,   112,   227,    -1,   366,   227,    -1,   111,   112,   351,
+     227,    -1,   366,   351,   227,    -1,   351,   227,    -1,   111,
+     112,   364,    -1,   366,   364,    -1,   111,   112,   351,   364,
+      -1,   366,   351,   364,    -1,   351,   364,    -1,   111,   134,
+     229,   117,   135,   112,    -1,   111,   134,   229,   166,   135,
+     112,    -1,   111,   134,   233,   166,   135,   112,    -1,   111,
+     134,   233,   229,   166,   135,   112,    -1,   371,    -1,   229,
+     371,    -1,   368,    -1,   369,    -1,   370,    -1,   151,   227,
+      -1,   229,   151,   227,    -1,   151,   372,    -1,   229,   151,
+     372,    -1,   151,   367,    -1,   229,   151,   367,    -1,   111,
+     112,   227,    -1,   111,   112,   351,   227,    -1,   351,   227,
+      -1,   111,   112,   369,    -1,   111,   112,   351,   369,    -1,
+     351,   369,    -1,   111,   134,   264,   135,   112,    -1,   111,
+     112,   109,   261,   110,    -1,   371,   109,   134,   261,   135,
+     110,    -1,   220,   109,   134,   261,   135,   110,    -1,    -1,
+     116,    -1,    -1,   131,   166,    -1
 };
 
@@ -1021 +1023 @@
 static const yytype_uint16 yyrline[] =
 {
-       0,   300,   300,   304,   311,   312,   313,   317,   318,   319,
-     323,   324,   328,   329,   333,   334,   338,   342,   343,   354,
-     356,   358,   360,   365,   366,   372,   376,   378,   380,   382,
-     384,   386,   388,   390,   399,   400,   406,   407,   411,   412,
-     416,   420,   422,   424,   426,   431,   434,   436,   438,   443,
-     456,   458,   460,   462,   464,   466,   468,   470,   472,   474,
-     476,   483,   484,   490,   491,   492,   493,   497,   498,   500,
-     505,   506,   508,   510,   515,   516,   518,   523,   524,   526,
-     531,   532,   534,   536,   538,   543,   544,   546,   551,   552,
-     557,   558,   563,   564,   569,   570,   575,   576,   581,   582,
-     585,   587,   592,   597,   598,   600,   606,   607,   611,   612,
-     613,   614,   615,   616,   617,   618,   619,   620,   621,   622,
-     628,   630,   632,   634,   639,   640,   645,   646,   652,   653,
-     659,   660,   661,   662,   663,   664,   665,   666,   667,   677,
-     684,   686,   696,   697,   702,   704,   710,   712,   716,   717,
-     722,   727,   730,   732,   734,   744,   746,   757,   758,   760,
-     764,   766,   770,   771,   776,   777,   781,   786,   787,   791,
-     793,   799,   800,   804,   806,   808,   810,   816,   817,   821,
-     823,   828,   830,   832,   837,   839,   844,   846,   850,   853,
-     857,   860,   864,   866,   868,   870,   875,   877,   879,   884,
-     886,   888,   890,   892,   897,   899,   901,   903,   908,   920,
-     921,   926,   928,   933,   937,   939,   941,   943,   945,   951,
-     952,   958,   959,   963,   964,   969,   971,   977,   978,   980,
-     985,   990,  1000,  1002,  1006,  1007,  1012,  1014,  1018,  1019,
-    1023,  1025,  1029,  1030,  1034,  1035,  1039,  1040,  1055,  1056,
-    1057,  1058,  1059,  1063,  1068,  1075,  1085,  1090,  1095,  1103,
-    1108,  1113,  1118,  1123,  1131,  1153,  1158,  1165,  1167,  1174,
-    1179,  1184,  1195,  1200,  1205,  1210,  1215,  1224,  1229,  1237,
-    1238,  1239,  1240,  1246,  1251,  1259,  1260,  1261,  1262,  1266,
-    1267,  1268,  1269,  1274,  1275,  1284,  1285,  1290,  1291,  1296,
-    1298,  1300,  1302,  1304,  1307,  1306,  1318,  1319,  1321,  1331,
-    1332,  1337,  1339,  1341,  1343,  1345,  1348,  1350,  1353,  1358,
-    1360,  1362,  1364,  1366,  1368,  1370,  1372,  1374,  1376,  1378,
-    1380,  1382,  1388,  1389,  1391,  1393,  1395,  1400,  1401,  1407,
-    1408,  1410,  1412,  1417,  1419,  1421,  1423,  1428,  1429,  1431,
-    1433,  1438,  1439,  1441,  1446,  1447,  1449,  1451,  1456,  1458,
-    1460,  1465,  1466,  1470,  1472,  1478,  1477,  1481,  1483,  1488,
-    1490,  1496,  1497,  1502,  1503,  1505,  1506,  1515,  1516,  1518,
-    1520,  1525,  1527,  1533,  1534,  1536,  1539,  1542,  1547,  1548,
-    1553,  1558,  1562,  1564,  1570,  1569,  1576,  1578,  1584,  1585,
-    1593,  1594,  1598,  1599,  1600,  1602,  1604,  1611,  1612,  1614,
-    1616,  1621,  1622,  1628,  1629,  1633,  1634,  1639,  1640,  1641,
-    1643,  1651,  1652,  1654,  1657,  1659,  1663,  1664,  1665,  1667,
-    1669,  1673,  1678,  1686,  1687,  1696,  1698,  1703,  1704,  1705,
-    1709,  1710,  1711,  1715,  1716,  1717,  1721,  1722,  1723,  1728,
-    1729,  1730,  1731,  1737,  1738,  1740,  1745,  1746,  1751,  1752,
-    1753,  1754,  1755,  1770,  1771,  1776,  1777,  1783,  1785,  1788,
-    1790,  1792,  1815,  1816,  1818,  1820,  1825,  1826,  1828,  1833,
-    1838,  1839,  1845,  1844,  1848,  1852,  1854,  1856,  1862,  1863,
-    1868,  1873,  1875,  1880,  1882,  1883,  1885,  1890,  1892,  1894,
-    1899,  1901,  1906,  1911,  1919,  1925,  1924,  1938,  1939,  1944,
-    1945,  1949,  1954,  1959,  1967,  1972,  1983,  1984,  1989,  1990,
-    1996,  1997,  2001,  2002,  2003,  2006,  2005,  2016,  2025,  2031,
-    2037,  2046,  2052,  2058,  2064,  2070,  2078,  2084,  2092,  2098,
-    2107,  2108,  2109,  2113,  2117,  2119,  2124,  2125,  2129,  2130,
-    2135,  2141,  2142,  2145,  2147,  2148,  2152,  2153,  2154,  2155,
-    2189,  2191,  2192,  2194,  2199,  2204,  2209,  2211,  2213,  2218,
-    2220,  2222,  2224,  2229,  2231,  2240,  2242,  2243,  2248,  2250,
-    2252,  2257,  2259,  2261,  2266,  2268,  2270,  2279,  2280,  2281,
-    2285,  2287,  2289,  2294,  2296,  2298,  2303,  2305,  2307,  2322,
-    2324,  2325,  2327,  2332,  2333,  2338,  2340,  2342,  2347,  2349,
-    2351,  2353,  2358,  2360,  2362,  2372,  2374,  2375,  2377,  2382,
-    2384,  2386,  2391,  2393,  2395,  2397,  2402,  2404,  2406,  2437,
-    2439,  2440,  2442,  2447,  2452,  2460,  2462,  2464,  2469,  2471,
-    2476,  2478,  2492,  2493,  2495,  2500,  2502,  2504,  2506,  2508,
-    2513,  2514,  2516,  2518,  2523,  2525,  2527,  2533,  2535,  2537,
-    2541,  2543,  2545,  2547,  2561,  2562,  2564,  2569,  2571,  2573,
-    2575,  2577,  2582,  2583,  2585,  2587,  2592,  2594,  2596,  2602,
-    2603,  2605,  2614,  2617,  2619,  2622,  2624,  2626,  2639,  2640,
-    2642,  2647,  2649,  2651,  2653,  2655,  2660,  2661,  2663,  2665,
-    2670,  2672,  2680,  2681,  2682,  2687,  2688,  2692,  2694,  2696,
-    2698,  2700,  2702,  2709,  2711,  2713,  2715,  2717,  2719,  2721,
-    2723,  2725,  2727,  2732,  2734,  2736,  2741,  2767,  2768,  2770,
-    2774,  2775,  2779,  2781,  2783,  2785,  2787,  2789,  2796,  2798,
-    2800,  2802,  2804,  2806,  2811,  2816,  2818,  2820,  2838,  2840,
-    2845,  2846
+       0,   302,   302,   306,   313,   314,   315,   319,   320,   321,
+     325,   326,   330,   331,   335,   336,   340,   344,   345,   356,
+     358,   360,   362,   367,   368,   374,   378,   380,   382,   384,
+     386,   388,   390,   392,   394,   403,   404,   410,   411,   415,
+     416,   420,   424,   426,   428,   430,   435,   436,   440,   443,
+     445,   447,   452,   465,   467,   469,   471,   473,   475,   477,
+     479,   481,   483,   485,   492,   493,   499,   500,   501,   502,
+     506,   507,   509,   514,   515,   517,   519,   524,   525,   527,
+     532,   533,   535,   540,   541,   543,   545,   547,   552,   553,
+     555,   560,   561,   566,   567,   572,   573,   578,   579,   584,
+     585,   590,   591,   594,   596,   601,   606,   607,   609,   615,
+     616,   620,   621,   622,   623,   624,   625,   626,   627,   628,
+     629,   630,   631,   637,   639,   641,   643,   648,   649,   654,
+     655,   661,   662,   668,   669,   670,   671,   672,   673,   674,
+     675,   676,   686,   693,   695,   705,   706,   711,   713,   719,
+     721,   725,   726,   731,   736,   739,   741,   743,   753,   755,
+     766,   767,   769,   773,   775,   779,   780,   785,   786,   790,
+     795,   796,   800,   802,   808,   809,   813,   815,   817,   819,
+     825,   826,   830,   832,   837,   839,   841,   846,   848,   853,
+     855,   859,   862,   866,   869,   873,   875,   877,   879,   884,
+     886,   888,   893,   895,   897,   899,   901,   906,   908,   910,
+     912,   917,   929,   930,   935,   937,   942,   946,   948,   950,
+     952,   954,   960,   961,   967,   968,   972,   973,   978,   980,
+     986,   987,   989,   994,   999,  1009,  1011,  1015,  1016,  1021,
+    1023,  1027,  1028,  1032,  1034,  1038,  1039,  1043,  1044,  1048,
+    1049,  1064,  1065,  1066,  1067,  1068,  1072,  1077,  1084,  1094,
+    1099,  1104,  1112,  1117,  1122,  1127,  1132,  1140,  1162,  1167,
+    1174,  1176,  1183,  1188,  1193,  1204,  1209,  1214,  1219,  1224,
+    1233,  1238,  1246,  1247,  1248,  1249,  1255,  1260,  1268,  1269,
+    1270,  1271,  1275,  1276,  1277,  1278,  1283,  1284,  1293,  1294,
+    1299,  1300,  1305,  1307,  1309,  1311,  1313,  1316,  1315,  1327,
+    1328,  1330,  1340,  1341,  1346,  1348,  1350,  1352,  1354,  1357,
+    1359,  1362,  1367,  1369,  1371,  1373,  1375,  1377,  1379,  1381,
+    1383,  1385,  1387,  1389,  1391,  1397,  1398,  1400,  1402,  1404,
+    1409,  1410,  1416,  1417,  1419,  1421,  1426,  1428,  1430,  1432,
+    1437,  1438,  1440,  1442,  1447,  1448,  1450,  1455,  1456,  1458,
+    1460,  1465,  1467,  1469,  1474,  1475,  1479,  1481,  1487,  1486,
+    1490,  1492,  1497,  1499,  1505,  1506,  1511,  1512,  1514,  1515,
+    1524,  1525,  1527,  1529,  1534,  1536,  1542,  1543,  1545,  1548,
+    1551,  1556,  1557,  1562,  1567,  1571,  1573,  1579,  1578,  1585,
+    1587,  1593,  1594,  1602,  1603,  1607,  1608,  1609,  1611,  1613,
+    1620,  1621,  1623,  1625,  1630,  1631,  1637,  1638,  1642,  1643,
+    1648,  1649,  1650,  1652,  1660,  1661,  1663,  1666,  1668,  1672,
+    1673,  1674,  1676,  1678,  1682,  1687,  1695,  1696,  1705,  1707,
+    1712,  1713,  1714,  1718,  1719,  1720,  1724,  1725,  1726,  1730,
+    1731,  1732,  1737,  1738,  1739,  1740,  1746,  1747,  1749,  1754,
+    1755,  1760,  1761,  1762,  1763,  1764,  1779,  1780,  1785,  1786,
+    1792,  1794,  1797,  1799,  1801,  1824,  1825,  1827,  1829,  1834,
+    1835,  1837,  1842,  1847,  1848,  1854,  1853,  1857,  1861,  1863,
+    1865,  1871,  1872,  1877,  1882,  1884,  1889,  1891,  1892,  1894,
+    1899,  1901,  1903,  1908,  1910,  1915,  1920,  1928,  1934,  1933,
+    1947,  1948,  1953,  1954,  1958,  1963,  1968,  1976,  1981,  1992,
+    1993,  1998,  1999,  2005,  2006,  2010,  2011,  2012,  2015,  2014,
+    2025,  2034,  2040,  2046,  2055,  2061,  2067,  2073,  2079,  2087,
+    2093,  2101,  2107,  2116,  2117,  2118,  2122,  2126,  2128,  2133,
+    2134,  2138,  2139,  2144,  2150,  2151,  2154,  2156,  2157,  2161,
+    2162,  2163,  2164,  2198,  2200,  2201,  2203,  2208,  2213,  2218,
+    2220,  2222,  2227,  2229,  2231,  2233,  2238,  2240,  2249,  2251,
+    2252,  2257,  2259,  2261,  2266,  2268,  2270,  2275,  2277,  2279,
+    2288,  2289,  2290,  2294,  2296,  2298,  2303,  2305,  2307,  2312,
+    2314,  2316,  2331,  2333,  2334,  2336,  2341,  2342,  2347,  2349,
+    2351,  2356,  2358,  2360,  2362,  2367,  2369,  2371,  2381,  2383,
+    2384,  2386,  2391,  2393,  2395,  2400,  2402,  2404,  2406,  2411,
+    2413,  2415,  2446,  2448,  2449,  2451,  2456,  2461,  2469,  2471,
+    2473,  2478,  2480,  2485,  2487,  2501,  2502,  2504,  2509,  2511,
+    2513,  2515,  2517,  2522,  2523,  2525,  2527,  2532,  2534,  2536,
+    2542,  2544,  2546,  2550,  2552,  2554,  2556,  2570,  2571,  2573,
+    2578,  2580,  2582,  2584,  2586,  2591,  2592,  2594,  2596,  2601,
+    2603,  2605,  2611,  2612,  2614,  2623,  2626,  2628,  2631,  2633,
+    2635,  2648,  2649,  2651,  2656,  2658,  2660,  2662,  2664,  2669,
+    2670,  2672,  2674,  2679,  2681,  2689,  2690,  2691,  2696,  2697,
+    2701,  2703,  2705,  2707,  2709,  2711,  2718,  2720,  2722,  2724,
+    2726,  2728,  2730,  2732,  2734,  2736,  2741,  2743,  2745,  2750,
+    2776,  2777,  2779,  2783,  2784,  2788,  2790,  2792,  2794,  2796,
+    2798,  2805,  2807,  2809,  2811,  2813,  2815,  2820,  2825,  2827,
+    2829,  2847,  2849,  2854,  2855
 };
 #endif
@@ -1128 +1130 @@
   "string_literal", "string_literal_list", "primary_expression",
   "postfix_expression", "argument_expression_list", "argument_expression",
-  "field_list", "field", "unary_expression", "ptrref_operator",
-  "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",
-  "assignment_operator", "tuple", "tuple_expression_list",
-  "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_volatile_opt",
-  "asm_operands_opt", "asm_operands_list", "asm_operand",
-  "asm_clobbers_list_opt", "label_list", "declaration_list_opt",
-  "declaration_list", "old_declaration_list_opt", "old_declaration_list",
-  "local_label_declaration_opt", "local_label_declaration_list",
-  "local_label_list", "declaration", "new_declaration",
-  "new_variable_declaration", "new_variable_specifier",
+  "field_list", "field", "field_name", "unary_expression",
+  "ptrref_operator", "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", "assignment_operator", "tuple",
+  "tuple_expression_list", "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_volatile_opt", "asm_operands_opt", "asm_operands_list",
+  "asm_operand", "asm_clobbers_list_opt", "label_list",
+  "declaration_list_opt", "declaration_list", "old_declaration_list_opt",
+  "old_declaration_list", "local_label_declaration_opt",
+  "local_label_declaration_list", "local_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",
@@ -1241 +1243 @@
      138,   138,   139,   139,   140,   140,   141,   142,   142,   143,
      143,   143,   143,   144,   144,   144,   144,   144,   144,   144,
-     144,   144,   144,   144,   145,   145,   146,   146,   147,   147,
-     148,   148,   148,   148,   148,   149,   149,   149,   149,   149,
-     149,   149,   149,   149,   149,   149,   149,   149,   149,   149,
-     149,   150,   150,   151,   151,   151,   151,   152,   152,   152,
-     153,   153,   153,   153,   154,   154,   154,   155,   155,   155,
-     156,   156,   156,   156,   156,   157,   157,   157,   158,   158,
-     159,   159,   160,   160,   161,   161,   162,   162,   163,   163,
-     163,   163,   164,   165,   165,   165,   166,   166,   167,   167,
-     167,   167,   167,   167,   167,   167,   167,   167,   167,   167,
-     168,   168,   168,   168,   169,   169,   170,   170,   171,   171,
-     172,   172,   172,   172,   172,   172,   172,   172,   172,   173,
-     174,   174,   175,   175,   176,   176,   176,   176,   177,   177,
-     178,   179,   179,   179,   179,   179,   179,   180,   180,   180,
-     181,   181,   182,   182,   183,   183,   184,   185,   185,   186,
-     186,   187,   187,   188,   188,   188,   188,   189,   189,   190,
-     190,   191,   191,   191,   192,   192,   193,   193,   193,   193,
-     193,   193,   193,   193,   193,   193,   194,   194,   194,   195,
-     195,   195,   195,   195,   196,   196,   196,   196,   197,   198,
-     198,   198,   198,   198,   199,   199,   199,   199,   199,   200,
-     200,   201,   201,   202,   202,   203,   203,   204,   204,   204,
-     205,   205,   206,   206,   207,   207,   208,   208,   209,   209,
-     210,   210,   211,   211,   212,   212,   213,   213,   214,   214,
-     214,   214,   214,   215,   215,   215,   216,   216,   216,   217,
-     217,   217,   217,   217,   218,   218,   218,   219,   219,   220,
-     220,   220,   221,   221,   221,   221,   221,   222,   222,   223,
-     223,   223,   223,   224,   224,   225,   225,   225,   225,   226,
-     226,   226,   226,   227,   227,   228,   228,   229,   229,   230,
-     230,   230,   230,   230,   231,   230,   232,   232,   232,   233,
-     233,   234,   234,   234,   234,   234,   234,   234,   234,   235,
-     235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
-     235,   235,   236,   236,   236,   236,   236,   237,   237,   238,
-     238,   238,   238,   239,   239,   239,   239,   240,   240,   240,
-     240,   241,   241,   241,   242,   242,   242,   242,   243,   243,
-     243,   244,   244,   245,   245,   246,   245,   245,   245,   247,
-     247,   248,   248,   249,   249,   249,   249,   250,   250,   250,
-     250,   251,   251,   252,   252,   252,   252,   252,   253,   253,
-     254,   255,   256,   256,   257,   256,   258,   258,   259,   259,
-     260,   260,   261,   261,   261,   261,   261,   262,   262,   262,
-     262,   263,   263,   264,   264,   265,   265,   266,   266,   266,
-     266,   267,   267,   267,   267,   267,   268,   268,   268,   268,
-     268,   269,   269,   270,   270,   271,   271,   272,   272,   272,
+     144,   144,   144,   144,   144,   145,   145,   146,   146,   147,
+     147,   148,   148,   148,   148,   148,   149,   149,   150,   150,
+     150,   150,   150,   150,   150,   150,   150,   150,   150,   150,
+     150,   150,   150,   150,   151,   151,   152,   152,   152,   152,
+     153,   153,   153,   154,   154,   154,   154,   155,   155,   155,
+     156,   156,   156,   157,   157,   157,   157,   157,   158,   158,
+     158,   159,   159,   160,   160,   161,   161,   162,   162,   163,
+     163,   164,   164,   164,   164,   165,   166,   166,   166,   167,
+     167,   168,   168,   168,   168,   168,   168,   168,   168,   168,
+     168,   168,   168,   169,   169,   169,   169,   170,   170,   171,
+     171,   172,   172,   173,   173,   173,   173,   173,   173,   173,
+     173,   173,   174,   175,   175,   176,   176,   177,   177,   177,
+     177,   178,   178,   179,   180,   180,   180,   180,   180,   180,
+     181,   181,   181,   182,   182,   183,   183,   184,   184,   185,
+     186,   186,   187,   187,   188,   188,   189,   189,   189,   189,
+     190,   190,   191,   191,   192,   192,   192,   193,   193,   194,
+     194,   194,   194,   194,   194,   194,   194,   194,   194,   195,
+     195,   195,   196,   196,   196,   196,   196,   197,   197,   197,
+     197,   198,   199,   199,   199,   199,   199,   200,   200,   200,
+     200,   200,   201,   201,   202,   202,   203,   203,   204,   204,
+     205,   205,   205,   206,   206,   207,   207,   208,   208,   209,
+     209,   210,   210,   211,   211,   212,   212,   213,   213,   214,
+     214,   215,   215,   215,   215,   215,   216,   216,   216,   217,
+     217,   217,   218,   218,   218,   218,   218,   219,   219,   219,
+     220,   220,   221,   221,   221,   222,   222,   222,   222,   222,
+     223,   223,   224,   224,   224,   224,   225,   225,   226,   226,
+     226,   226,   227,   227,   227,   227,   228,   228,   229,   229,
+     230,   230,   231,   231,   231,   231,   231,   232,   231,   233,
+     233,   233,   234,   234,   235,   235,   235,   235,   235,   235,
+     235,   235,   236,   236,   236,   236,   236,   236,   236,   236,
+     236,   236,   236,   236,   236,   237,   237,   237,   237,   237,
+     238,   238,   239,   239,   239,   239,   240,   240,   240,   240,
+     241,   241,   241,   241,   242,   242,   242,   243,   243,   243,
+     243,   244,   244,   244,   245,   245,   246,   246,   247,   246,
+     246,   246,   248,   248,   249,   249,   250,   250,   250,   250,
+     251,   251,   251,   251,   252,   252,   253,   253,   253,   253,
+     253,   254,   254,   255,   256,   257,   257,   258,   257,   259,
+     259,   260,   260,   261,   261,   262,   262,   262,   262,   262,
+     263,   263,   263,   263,   264,   264,   265,   265,   266,   266,
+     267,   267,   267,   267,   268,   268,   268,   268,   268,   269,
+     269,   269,   269,   269,   270,   270,   271,   271,   272,   272,
      273,   273,   273,   274,   274,   274,   275,   275,   275,   276,
-     276,   276,   276,   277,   277,   277,   278,   278,   279,   279,
-     279,   279,   279,   280,   280,   281,   281,   282,   282,   282,
-     282,   282,   283,   283,   283,   283,   284,   284,   284,   285,
-     286,   286,   288,   287,   287,   289,   289,   289,   290,   290,
-     291,   291,   291,   292,   292,   292,   292,   293,   293,   293,
-     294,   294,   295,   295,   296,   297,   296,   298,   298,   299,
-     299,   300,   300,   300,   301,   301,   302,   302,   303,   303,
-     304,   304,   305,   305,   305,   306,   305,   305,   307,   307,
-     307,   308,   308,   308,   308,   308,   308,   308,   308,   308,
-     309,   309,   309,   310,   311,   311,   312,   312,   313,   313,
-     314,   315,   315,   316,   316,   316,   317,   317,   317,   317,
-     318,   318,   318,   318,   319,   319,   320,   320,   320,   321,
-     321,   321,   321,   322,   322,   323,   323,   323,   324,   324,
+     276,   276,   277,   277,   277,   277,   278,   278,   278,   279,
+     279,   280,   280,   280,   280,   280,   281,   281,   282,   282,
+     283,   283,   283,   283,   283,   284,   284,   284,   284,   285,
+     285,   285,   286,   287,   287,   289,   288,   288,   290,   290,
+     290,   291,   291,   292,   292,   292,   293,   293,   293,   293,
+     294,   294,   294,   295,   295,   296,   296,   297,   298,   297,
+     299,   299,   300,   300,   301,   301,   301,   302,   302,   303,
+     303,   304,   304,   305,   305,   306,   306,   306,   307,   306,
+     306,   308,   308,   308,   309,   309,   309,   309,   309,   309,
+     309,   309,   309,   310,   310,   310,   311,   312,   312,   313,
+     313,   314,   314,   315,   316,   316,   317,   317,   317,   318,
+     318,   318,   318,   319,   319,   319,   319,   320,   320,   321,
+     321,   321,   322,   322,   322,   322,   323,   323,   324,   324,
      324,   325,   325,   325,   326,   326,   326,   327,   327,   327,
      328,   328,   328,   329,   329,   329,   330,   330,   330,   331,
-     331,   331,   331,   332,   332,   333,   333,   333,   334,   334,
-     334,   334,   335,   335,   335,   336,   336,   336,   336,   337,
-     337,   337,   338,   338,   338,   338,   339,   339,   339,   340,
-     340,   340,   340,   341,   341,   342,   342,   342,   343,   343,
-     344,   344,   345,   345,   345,   346,   346,   346,   346,   346,
-     347,   347,   347,   347,   348,   348,   348,   349,   349,   349,
-     350,   350,   350,   350,   351,   351,   351,   352,   352,   352,
-     352,   352,   353,   353,   353,   353,   354,   354,   354,   355,
-     355,   355,   356,   356,   356,   356,   356,   356,   357,   357,
-     357,   358,   358,   358,   358,   358,   359,   359,   359,   359,
-     360,   360,   361,   361,   361,   362,   362,   363,   363,   363,
-     363,   363,   363,   364,   364,   364,   364,   364,   364,   364,
-     364,   364,   364,   365,   365,   365,   365,   366,   366,   366,
-     367,   367,   368,   368,   368,   368,   368,   368,   369,   369,
-     369,   369,   369,   369,   370,   371,   371,   371,   372,   372,
-     373,   373
+     331,   331,   332,   332,   332,   332,   333,   333,   334,   334,
+     334,   335,   335,   335,   335,   336,   336,   336,   337,   337,
+     337,   337,   338,   338,   338,   339,   339,   339,   339,   340,
+     340,   340,   341,   341,   341,   341,   342,   342,   343,   343,
+     343,   344,   344,   345,   345,   346,   346,   346,   347,   347,
+     347,   347,   347,   348,   348,   348,   348,   349,   349,   349,
+     350,   350,   350,   351,   351,   351,   351,   352,   352,   352,
+     353,   353,   353,   353,   353,   354,   354,   354,   354,   355,
+     355,   355,   356,   356,   356,   357,   357,   357,   357,   357,
+     357,   358,   358,   358,   359,   359,   359,   359,   359,   360,
+     360,   360,   360,   361,   361,   362,   362,   362,   363,   363,
+     364,   364,   364,   364,   364,   364,   365,   365,   365,   365,
+     365,   365,   365,   365,   365,   365,   366,   366,   366,   366,
+     367,   367,   367,   368,   368,   369,   369,   369,   369,   369,
+     369,   370,   370,   370,   370,   370,   370,   371,   372,   372,
+     372,   373,   373,   374,   374
 };
 
@@ -1321 +1323 @@
        0,     2,     0,     0,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     2,     1,
-       1,     3,     3,     1,     6,     4,     3,     7,     3,     7,
-       2,     2,     7,     4,     1,     3,     0,     1,     1,     3,
-       1,     3,     7,     3,     7,     1,     1,     1,     2,     2,
-       2,     2,     2,     2,     4,     2,     4,     6,     1,     4,
-       4,     1,     1,     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,     2,     0,     1,     1,     1,
+       1,     3,     3,     1,     6,     4,     3,     7,     3,     3,
+       7,     2,     2,     7,     4,     1,     3,     0,     1,     1,
+       3,     1,     3,     7,     3,     7,     1,     1,     1,     1,
+       1,     2,     2,     2,     2,     2,     2,     4,     2,     4,
+       6,     1,     4,     4,     1,     1,     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,     2,     0,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       2,     5,     6,     7,     1,     3,     1,     3,     0,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     6,     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,     3,     5,     3,     3,     4,     1,
-       5,     6,     5,     6,     9,    10,     9,    10,     2,     1,
-       2,     2,     2,     1,     6,     8,    10,    12,    14,     0,
-       1,     0,     1,     1,     3,     4,     7,     0,     1,     3,
-       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,     8,     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,     2,     5,     6,     7,     1,     3,     1,
+       3,     0,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     6,     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,     3,     5,     3,
+       3,     4,     1,     5,     6,     5,     6,     9,    10,     9,
+      10,     2,     1,     2,     2,     2,     1,     6,     8,    10,
+      12,    14,     0,     1,     0,     1,     1,     3,     4,     7,
+       0,     1,     3,     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,     8,     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,     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,     0,     6,     7,     2,     2,
-       2,     0,     2,     2,     3,     2,     3,     1,     2,     3,
-       2,     2,     4,     0,     1,     2,     2,     1,     0,     1,
-       2,     2,     5,     2,     0,     7,     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,     2,     1,     4,     0,     1,
-       2,     3,     4,     2,     2,     1,     2,     2,     5,     5,
-       7,     6,     1,     2,     2,     3,     1,     2,     2,     4,
-       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,     1,     2,     3,     3,     2,     4,
-       6,     8,     1,     2,     2,     1,     2,     2,     3,     3,
-       1,     4,     4,     3,     5,     8,     3,     2,     3,     1,
-       5,     5,     6,     6,     1,     2,     2,     1,     2,     2,
-       3,     3,     1,     4,     4,     3,     5,     8,     3,     1,
-       2,     1,     2,     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,     3,     2,     4,     3,     2,     3,     2,
-       4,     3,     2,     6,     6,     6,     7,     1,     2,     1,
-       1,     1,     2,     3,     2,     3,     2,     3,     3,     4,
-       2,     3,     4,     2,     5,     5,     6,     6,     0,     1,
-       0,     2
+       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,     0,     6,
+       7,     2,     2,     2,     0,     2,     2,     3,     2,     3,
+       1,     2,     3,     2,     2,     4,     0,     1,     2,     2,
+       1,     0,     1,     2,     2,     5,     2,     0,     7,     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,     2,     1,
+       4,     0,     1,     2,     3,     4,     2,     2,     1,     2,
+       2,     5,     5,     7,     6,     1,     2,     2,     3,     1,
+       2,     2,     4,     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,     1,     2,     3,
+       3,     2,     4,     6,     8,     1,     2,     2,     1,     2,
+       2,     3,     3,     1,     4,     4,     3,     5,     8,     3,
+       2,     3,     1,     5,     5,     6,     6,     1,     2,     2,
+       1,     2,     2,     3,     3,     1,     4,     4,     3,     5,
+       8,     3,     1,     2,     1,     2,     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,     3,     2,     4,     3,
+       2,     3,     2,     4,     3,     2,     6,     6,     6,     7,
+       1,     2,     1,     1,     1,     2,     3,     2,     3,     2,
+       3,     3,     4,     2,     3,     4,     2,     5,     5,     6,
+       6,     0,     1,     0,     2
 };
 
@@ -1402 +1404 @@
 static const yytype_uint16 yydefact[] =
 {
-     293,   293,   313,   311,   314,   312,   315,   316,   299,   301,
-     300,     0,   302,   327,   319,   324,   322,   323,   321,   320,
-     325,   326,   331,   328,   329,   330,   546,   546,   546,     0,
-       0,     0,   293,   219,   303,   317,   318,     7,   358,     0,
-       8,    14,    15,     0,     2,    61,    62,   564,     9,   293,
-     524,   522,   246,     3,   453,     3,   259,     0,     3,     3,
-       3,   247,     3,     0,     0,     0,   294,   295,   297,   293,
-     306,   309,   339,   285,   332,   337,   286,   347,   287,   354,
-     351,   361,     0,     0,   362,   288,   472,   476,     3,     3,
-       0,     2,   518,   523,   528,   298,     0,     0,   546,   576,
-     546,     2,   587,   588,   589,   293,     0,   730,   731,     0,
-      12,     0,    13,   293,   269,   270,     0,   294,   289,   290,
-     291,   292,   525,   304,   391,   547,   548,   369,   370,    12,
-     444,   445,    11,   440,   443,     0,   502,   497,   488,   444,
-     445,     0,     0,   527,   220,     0,   293,     0,     0,     0,
-       0,     0,     0,     0,     0,   293,   293,     2,     0,   732,
-     294,   581,   593,   736,   729,   727,   734,     0,     0,     0,
-     253,     2,     0,   531,   438,   439,   437,     0,     0,     0,
-       0,   546,     0,   633,   634,     0,     0,   544,   540,   546,
-     561,   546,   546,   542,     2,   541,   546,   600,   546,   546,
-     603,     0,     0,     0,   293,   293,   311,   359,     2,   293,
-     260,   296,   307,   340,   352,   477,     0,     2,     0,   453,
-     261,   294,   333,   348,   355,   473,     0,     2,     0,   310,
-     334,   341,   342,     0,   349,   353,   356,   360,   445,   293,
-     371,   364,   368,     0,   393,   474,   478,     0,     0,     0,
-       1,   293,     2,   529,   575,   577,   293,     2,   740,   294,
-     743,   544,   544,     0,   294,     0,     0,   272,   546,   542,
-       2,   293,     0,     0,   293,   549,     2,   500,     2,   553,
-       0,     0,     0,     0,     0,     0,    19,    58,     4,     5,
-       6,    17,     0,     0,   293,     2,    63,    64,    65,    66,
-      46,    20,    47,    16,    23,    45,    67,   293,     0,    70,
-      74,    77,    80,    85,    88,    90,    92,    94,    96,    98,
-     103,   494,   750,   451,   493,     0,   449,   450,     0,   565,
-     580,   583,   586,   592,   595,   598,   358,     0,     2,   738,
-       0,   293,   741,     2,    61,   293,     3,   425,     0,   433,
-     294,   293,   306,   332,   286,   347,   354,     3,     3,   407,
-     411,   421,   426,   472,   293,   427,   705,   706,   293,   428,
-     430,   293,     2,   582,   594,   728,     2,     2,   248,     2,
-     458,     0,   456,   455,   454,   140,     2,     2,   250,     2,
-       2,   249,     2,   280,     2,   281,     0,   279,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   566,   605,     0,
-     453,     2,   560,   569,   659,   562,   563,   532,   293,     2,
-     599,   608,   601,   602,     0,   275,   293,   293,   338,   294,
-       0,   294,     0,   293,   733,   737,   735,   533,   293,   544,
-     254,   262,   308,     0,     2,   534,   293,   498,   335,   336,
-     282,   350,   357,     0,   293,     0,   748,   398,     0,   475,
-     499,   251,   252,   519,   293,   435,     0,   293,   236,     0,
-       2,   238,     0,   294,     0,   256,     2,   257,   277,     0,
-       0,     2,   293,   544,   293,   485,   487,   486,     0,     0,
-     750,     0,   293,     0,   293,   489,   293,   559,   557,   558,
-     556,     0,   551,   554,     0,     0,   293,    53,   293,    67,
-      48,   293,    55,   293,   293,    51,    52,     2,   126,     0,
-       0,   447,     0,   446,   727,   120,   293,    18,     0,    30,
-      31,    36,     2,     0,    36,   110,   111,   112,   113,   114,
-     115,   116,   117,   118,   119,   109,   108,     0,    49,    50,
+     296,   296,   316,   314,   317,   315,   318,   319,   302,   304,
+     303,     0,   305,   330,   322,   327,   325,   326,   324,   323,
+     328,   329,   334,   331,   332,   333,   549,   549,   549,     0,
+       0,     0,   296,   222,   306,   320,   321,     7,   361,     0,
+       8,    14,    15,     0,     2,    64,    65,   567,     9,   296,
+     527,   525,   249,     3,   456,     3,   262,     0,     3,     3,
+       3,   250,     3,     0,     0,     0,   297,   298,   300,   296,
+     309,   312,   342,   288,   335,   340,   289,   350,   290,   357,
+     354,   364,     0,     0,   365,   291,   475,   479,     3,     3,
+       0,     2,   521,   526,   531,   301,     0,     0,   549,   579,
+     549,     2,   590,   591,   592,   296,     0,   733,   734,     0,
+      12,     0,    13,   296,   272,   273,     0,   297,   292,   293,
+     294,   295,   528,   307,   394,   550,   551,   372,   373,    12,
+     447,   448,    11,   443,   446,     0,   505,   500,   491,   447,
+     448,     0,     0,   530,   223,     0,   296,     0,     0,     0,
+       0,     0,     0,     0,     0,   296,   296,     2,     0,   735,
+     297,   584,   596,   739,   732,   730,   737,     0,     0,     0,
+     256,     2,     0,   534,   441,   442,   440,     0,     0,     0,
+       0,   549,     0,   636,   637,     0,     0,   547,   543,   549,
+     564,   549,   549,   545,     2,   544,   549,   603,   549,   549,
+     606,     0,     0,     0,   296,   296,   314,   362,     2,   296,
+     263,   299,   310,   343,   355,   480,     0,     2,     0,   456,
+     264,   297,   336,   351,   358,   476,     0,     2,     0,   313,
+     337,   344,   345,     0,   352,   356,   359,   363,   448,   296,
+     374,   367,   371,     0,   396,   477,   481,     0,     0,     0,
+       1,   296,     2,   532,   578,   580,   296,     2,   743,   297,
+     746,   547,   547,     0,   297,     0,     0,   275,   549,   545,
+       2,   296,     0,     0,   296,   552,     2,   503,     2,   556,
+       0,     0,     0,     0,     0,     0,    19,    61,     4,     5,
+       6,    17,     0,     0,   296,     2,    66,    67,    68,    69,
+      49,    20,    50,    16,    23,    48,    70,   296,     0,    73,
+      77,    80,    83,    88,    91,    93,    95,    97,    99,   101,
+     106,   497,   753,   454,   496,     0,   452,   453,     0,   568,
+     583,   586,   589,   595,   598,   601,   361,     0,     2,   741,
+       0,   296,   744,     2,    64,   296,     3,   428,     0,   436,
+     297,   296,   309,   335,   289,   350,   357,     3,     3,   410,
+     414,   424,   429,   475,   296,   430,   708,   709,   296,   431,
+     433,   296,     2,   585,   597,   731,     2,     2,   251,     2,
+     461,     0,   459,   458,   457,   143,     2,     2,   253,     2,
+       2,   252,     2,   283,     2,   284,     0,   282,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   569,   608,     0,
+     456,     2,   563,   572,   662,   565,   566,   535,   296,     2,
+     602,   611,   604,   605,     0,   278,   296,   296,   341,   297,
+       0,   297,     0,   296,   736,   740,   738,   536,   296,   547,
+     257,   265,   311,     0,     2,   537,   296,   501,   338,   339,
+     285,   353,   360,     0,   296,     0,   751,   401,     0,   478,
+     502,   254,   255,   522,   296,   438,     0,   296,   239,     0,
+       2,   241,     0,   297,     0,   259,     2,   260,   280,     0,
+       0,     2,   296,   547,   296,   488,   490,   489,     0,     0,
+     753,     0,   296,     0,   296,   492,   296,   562,   560,   561,
+     559,     0,   554,   557,     0,     0,   296,    56,   296,    70,
+      51,   296,    58,   296,   296,    54,    55,     2,   129,     0,
+       0,   450,     0,   449,   730,   123,   296,    18,     0,    31,
+      32,    37,     2,     0,    37,   113,   114,   115,   116,   117,
+     118,   119,   120,   121,   122,   112,   111,     0,    52,    53,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     105,     2,   645,   452,   642,   546,   546,   650,   479,   293,
-       2,   584,   585,     0,   596,   597,     0,     2,   739,   742,
-     120,   293,     0,     2,   707,   294,   711,   702,   703,   709,
-       0,     2,     2,   667,   546,   750,   616,   546,   546,   750,
-     546,   630,   546,   546,   681,   434,   664,   546,   546,   672,
-     679,   293,   429,   294,     0,     0,   293,   717,   294,   722,
-     750,   714,   293,   719,   750,   293,   293,   293,     0,   120,
-       0,    19,     2,     0,    20,     0,   459,   748,     0,     0,
-     465,   240,     0,   293,     0,     0,     0,   544,   568,   572,
-     574,   604,   607,   611,   614,   567,   606,     0,   283,   657,
-       0,   293,   276,     0,     0,     0,     0,   274,     2,     0,
-     258,   535,   293,     0,     0,   293,     2,   363,   383,   372,
-       0,     0,   377,   371,   749,     0,     0,   396,     0,   294,
-       3,   414,     3,   418,   417,   590,     0,   530,   293,    61,
-       3,   293,   433,   294,     3,   427,   428,     2,     0,     0,
-       0,   484,   305,   293,   480,   482,     3,     2,     2,     0,
-     501,     3,     0,   553,   128,     0,     0,   221,     0,     0,
-       0,     0,    37,     0,     0,   120,   293,    21,     0,    22,
-       0,   691,   696,   448,   688,   546,   546,     0,   106,     3,
-       2,    28,     0,    34,     0,     2,    26,     0,   104,    71,
-      72,    73,    75,    76,    78,    79,    83,    84,    81,    82,
-      86,    87,    89,    91,    93,    95,    97,     0,     0,   751,
-     293,     0,     0,     0,   646,   647,   643,   644,   496,   495,
-     293,     0,   293,   713,   293,   718,   294,   293,   661,   293,
-     293,   704,   660,     2,   293,     0,     0,     0,     0,     0,
-       0,     0,     0,   682,     0,   668,   619,   635,   669,     2,
-     615,   622,   431,   617,   618,   432,     2,   629,   638,   631,
-     632,   665,   666,   680,   708,   712,   710,   750,   267,     2,
-     744,     2,   422,   716,   721,   423,     0,   401,     3,     3,
-       3,     3,   453,     3,     0,     2,   467,   464,   749,     0,
-     460,     2,   463,   466,     0,   293,   241,   263,     3,   271,
-     273,     0,   453,     2,   570,   571,     2,   609,   610,     0,
-     658,   536,     3,   344,   343,   346,   345,   293,   537,     0,
-     538,   371,     0,     0,   293,   293,     0,     0,   691,   381,
-     384,   388,   546,   388,   387,   380,   373,   546,   375,   378,
-     293,   398,   392,   102,   399,   748,     0,     0,   436,   239,
-       0,     0,     3,     2,   667,   429,     0,   526,     0,   750,
-     488,     0,   293,   293,   293,     0,   550,   552,   129,     0,
-       0,   214,     0,     0,     0,   222,   223,    54,     0,    56,
-      59,    60,     0,     2,   127,     0,     0,     0,   692,   693,
-     689,   690,   458,    68,    69,   107,   124,     3,   106,     0,
-       0,    25,    36,     3,     0,    33,   100,     0,     3,   649,
-     653,   656,   648,     3,   591,     3,   715,   720,     2,    61,
-     293,     3,     3,   294,     0,     3,   621,   625,   628,   637,
-     671,   675,   678,   293,     3,   620,   636,   670,   293,   293,
-     424,   293,   293,   745,     0,     0,     0,     0,   255,     0,
-     102,     0,     3,     3,     0,   461,     0,   457,     0,     0,
-     244,   293,     0,     0,   128,     0,     0,     0,     0,     0,
-     128,     0,     0,   106,   106,    19,     2,     0,     0,     3,
-     130,   131,     2,   142,   132,   133,   134,   135,   136,   137,
-     144,   146,     0,     0,     0,   284,   293,   293,   546,     0,
-     539,   293,   374,   376,     0,   390,   692,   385,   389,   386,
-     379,   383,   366,   397,     0,   578,     2,   663,   662,     0,
-     668,     2,   481,   483,   503,     3,   511,   512,     0,     2,
-     507,     3,     3,     0,     0,   555,   221,     0,     0,     0,
-     221,     0,     0,   120,   695,   699,   701,   694,   748,   106,
-       0,     3,   660,    40,     3,    38,    35,     0,     3,    99,
-     101,     0,     2,   651,   652,     0,     0,   293,     0,     0,
-       0,     3,   637,     0,     2,   623,   624,     2,   639,     2,
-     673,   674,     0,     0,    61,     0,     3,     3,     3,     3,
-     409,   408,   412,     2,     2,   747,   746,   121,     0,     0,
-       0,     0,     3,   462,     3,     0,   242,   145,     3,   294,
-     293,     0,     0,     0,     0,     2,     0,   190,     0,   188,
-       0,     0,     0,     0,     0,     0,     0,   546,   120,     0,
-     150,   147,   293,     0,     0,   266,   278,     3,     3,   545,
-     612,   367,   382,   395,   293,   265,   293,     0,   514,   491,
-     293,     0,     0,   490,   505,     0,     0,     0,   215,     0,
-     224,    57,     2,   697,   698,     0,   125,   122,     0,     0,
-       0,     0,     0,    24,     0,   654,   293,   579,   264,   723,
-     724,   725,     0,   676,   293,   293,   293,     3,     3,     0,
-     684,     0,     0,     0,     0,   293,   293,     3,   543,   121,
-     469,     0,     0,   245,   294,     0,     0,     0,     0,   293,
-     191,   189,   186,     0,   192,     0,     0,     0,     0,   196,
-     199,   197,   193,     0,   194,   128,    36,   143,   141,   243,
-       0,     0,   416,   420,   419,     0,   508,     2,   509,     2,
-     510,   504,   293,   227,     0,   225,     0,   227,   293,    32,
-     123,     2,    43,     2,    41,    39,    29,    27,     3,   726,
-       3,     3,     3,     0,     0,   683,   685,   626,   640,   268,
-       2,   406,     3,   405,     0,   471,   468,   128,     0,     0,
-     128,     3,     0,   128,   187,     0,     2,     2,   208,   198,
-       0,     0,     0,   139,     0,   573,   613,     2,     0,     0,
-       2,   228,     0,     0,   216,     0,     3,     0,     0,     0,
-       0,     0,     0,   686,   687,   293,     0,   470,   151,     0,
-       0,     2,   164,   128,   153,     0,   181,     0,   128,     0,
-       2,   155,     0,     2,     0,     2,     2,     2,   195,    33,
-     293,   513,   515,   506,     0,     0,     0,     0,     0,     3,
-       3,   655,   627,   641,   677,   410,   128,   157,   160,     0,
-     159,   163,     3,   166,   165,     0,   128,   183,   128,     3,
-       0,   293,     0,   293,     0,     2,     0,     2,   138,     2,
-     229,   230,     0,   226,   217,   700,     0,     0,   152,     0,
-       0,   162,   232,   167,     2,   234,   182,     0,   185,   171,
-     200,     3,   209,   213,   202,     3,     0,   293,     0,   293,
-       0,     0,     0,    44,    42,   158,   161,   128,     0,   168,
-     293,   128,   128,     0,   172,     0,     0,   691,   210,   211,
-     212,     0,   201,     3,   203,     3,   293,   218,   231,   148,
-     169,   154,   128,   235,   184,   179,   177,   173,   156,   128,
-       0,   692,     0,     0,     0,     0,   149,   170,   180,   174,
-     178,   177,   175,     3,     3,     0,     0,   492,   176,   204,
-     206,     3,     3,   205,   207
+     108,     2,   648,   455,   645,   549,   549,   653,   482,   296,
+       2,   587,   588,     0,   599,   600,     0,     2,   742,   745,
+     123,   296,     0,     2,   710,   297,   714,   705,   706,   712,
+       0,     2,     2,   670,   549,   753,   619,   549,   549,   753,
+     549,   633,   549,   549,   684,   437,   667,   549,   549,   675,
+     682,   296,   432,   297,     0,     0,   296,   720,   297,   725,
+     753,   717,   296,   722,   753,   296,   296,   296,     0,   123,
+       0,    19,     2,     0,    20,     0,   462,   751,     0,     0,
+     468,   243,     0,   296,     0,     0,     0,   547,   571,   575,
+     577,   607,   610,   614,   617,   570,   609,     0,   286,   660,
+       0,   296,   279,     0,     0,     0,     0,   277,     2,     0,
+     261,   538,   296,     0,     0,   296,     2,   366,   386,   375,
+       0,     0,   380,   374,   752,     0,     0,   399,     0,   297,
+       3,   417,     3,   421,   420,   593,     0,   533,   296,    64,
+       3,   296,   436,   297,     3,   430,   431,     2,     0,     0,
+       0,   487,   308,   296,   483,   485,     3,     2,     2,     0,
+     504,     3,     0,   556,   131,     0,     0,   224,     0,     0,
+       0,     0,    38,     0,     0,   123,   296,    21,     0,    22,
+       0,   694,   699,   451,   691,   549,   549,     0,   109,     3,
+       2,    29,     0,    35,     0,    28,     2,    26,     0,   107,
+      74,    75,    76,    78,    79,    81,    82,    86,    87,    84,
+      85,    89,    90,    92,    94,    96,    98,   100,     0,     0,
+     754,   296,     0,     0,     0,   649,   650,   646,   647,   499,
+     498,   296,     0,   296,   716,   296,   721,   297,   296,   664,
+     296,   296,   707,   663,     2,   296,     0,     0,     0,     0,
+       0,     0,     0,     0,   685,     0,   671,   622,   638,   672,
+       2,   618,   625,   434,   620,   621,   435,     2,   632,   641,
+     634,   635,   668,   669,   683,   711,   715,   713,   753,   270,
+       2,   747,     2,   425,   719,   724,   426,     0,   404,     3,
+       3,     3,     3,   456,     3,     0,     2,   470,   467,   752,
+       0,   463,     2,   466,   469,     0,   296,   244,   266,     3,
+     274,   276,     0,   456,     2,   573,   574,     2,   612,   613,
+       0,   661,   539,     3,   347,   346,   349,   348,   296,   540,
+       0,   541,   374,     0,     0,   296,   296,     0,     0,   694,
+     384,   387,   391,   549,   391,   390,   383,   376,   549,   378,
+     381,   296,   401,   395,   105,   402,   751,     0,     0,   439,
+     242,     0,     0,     3,     2,   670,   432,     0,   529,     0,
+     753,   491,     0,   296,   296,   296,     0,   553,   555,   132,
+       0,     0,   217,     0,     0,     0,   225,   226,    57,     0,
+      59,    62,    63,     0,     2,   130,     0,     0,     0,   695,
+     696,   692,   693,   461,    71,    72,   110,   127,     3,   109,
+       0,     0,    25,    37,     3,     0,    34,   103,     0,     3,
+     652,   656,   659,   651,     3,   594,     3,   718,   723,     2,
+      64,   296,     3,     3,   297,     0,     3,   624,   628,   631,
+     640,   674,   678,   681,   296,     3,   623,   639,   673,   296,
+     296,   427,   296,   296,   748,     0,     0,     0,     0,   258,
+       0,   105,     0,     3,     3,     0,   464,     0,   460,     0,
+       0,   247,   296,     0,     0,   131,     0,     0,     0,     0,
+       0,   131,     0,     0,   109,   109,    19,     2,     0,     0,
+       3,   133,   134,     2,   145,   135,   136,   137,   138,   139,
+     140,   147,   149,     0,     0,     0,   287,   296,   296,   549,
+       0,   542,   296,   377,   379,     0,   393,   695,   388,   392,
+     389,   382,   386,   369,   400,     0,   581,     2,   666,   665,
+       0,   671,     2,   484,   486,   506,     3,   514,   515,     0,
+       2,   510,     3,     3,     0,     0,   558,   224,     0,     0,
+       0,   224,     0,     0,   123,   698,   702,   704,   697,   751,
+     109,     0,     3,   663,    47,    46,     3,    39,    41,    36,
+       0,     3,   102,   104,     0,     2,   654,   655,     0,     0,
+     296,     0,     0,     0,     3,   640,     0,     2,   626,   627,
+       2,   642,     2,   676,   677,     0,     0,    64,     0,     3,
+       3,     3,     3,   412,   411,   415,     2,     2,   750,   749,
+     124,     0,     0,     0,     0,     3,   465,     3,     0,   245,
+     148,     3,   297,   296,     0,     0,     0,     0,     2,     0,
+     193,     0,   191,     0,     0,     0,     0,     0,     0,     0,
+     549,   123,     0,   153,   150,   296,     0,     0,   269,   281,
+       3,     3,   548,   615,   370,   385,   398,   296,   268,   296,
+       0,   517,   494,   296,     0,     0,   493,   508,     0,     0,
+       0,   218,     0,   227,    60,     2,   700,   701,     0,   128,
+     125,     0,     0,     0,     0,     0,    24,     0,   657,   296,
+     582,   267,   726,   727,   728,     0,   679,   296,   296,   296,
+       3,     3,     0,   687,     0,     0,     0,     0,   296,   296,
+       3,   546,   124,   472,     0,     0,   248,   297,     0,     0,
+       0,     0,   296,   194,   192,   189,     0,   195,     0,     0,
+       0,     0,   199,   202,   200,   196,     0,   197,   131,    37,
+     146,   144,   246,     0,     0,   419,   423,   422,     0,   511,
+       2,   512,     2,   513,   507,   296,   230,     0,   228,     0,
+     230,   296,    33,   126,    40,    30,     2,    44,     2,    42,
+      27,     3,   729,     3,     3,     3,     0,     0,   686,   688,
+     629,   643,   271,     2,   409,     3,   408,     0,   474,   471,
+     131,     0,     0,   131,     3,     0,   131,   190,     0,     2,
+       2,   211,   201,     0,     0,     0,   142,     0,   576,   616,
+       2,     0,     0,     2,   231,     0,     0,   219,     0,     3,
+       0,     0,     0,     0,     0,     0,   689,   690,   296,     0,
+     473,   154,     0,     0,     2,   167,   131,   156,     0,   184,
+       0,   131,     0,     2,   158,     0,     2,     0,     2,     2,
+       2,   198,    34,   296,   516,   518,   509,     0,     0,     0,
+       0,     0,     3,     3,   658,   630,   644,   680,   413,   131,
+     160,   163,     0,   162,   166,     3,   169,   168,     0,   131,
+     186,   131,     3,     0,   296,     0,   296,     0,     2,     0,
+       2,   141,     2,   232,   233,     0,   229,   220,   703,     0,
+       0,   155,     0,     0,   165,   235,   170,     2,   237,   185,
+       0,   188,   174,   203,     3,   212,   216,   205,     3,     0,
+     296,     0,   296,     0,     0,     0,    45,    43,   161,   164,
+     131,     0,   171,   296,   131,   131,     0,   175,     0,     0,
+     694,   213,   214,   215,     0,   204,     3,   206,     3,   296,
+     221,   234,   151,   172,   157,   131,   238,   187,   182,   180,
+     176,   159,   131,     0,   695,     0,     0,     0,     0,   152,
+     173,   183,   177,   181,   180,   178,     3,     3,     0,     0,
+     495,   179,   207,   209,     3,     3,   208,   210
 };
 
@@ -1563 +1565 @@
 static const yytype_int16 yydefgoto[] =
 {
-      -1,   814,   468,   300,    47,   133,   134,   301,   302,   303,
-     304,   305,   762,   763,  1134,  1135,   306,   381,   308,   309,
-     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
-     320,  1031,   518,   976,   547,   322,   977,   948,  1058,  1519,
-    1060,  1061,  1062,  1063,  1520,  1064,  1065,  1438,  1439,  1402,
-    1403,  1404,  1498,  1499,  1503,  1504,  1539,  1540,  1066,  1362,
-    1067,  1068,  1299,  1300,  1301,  1481,  1069,   145,   954,   955,
-     956,  1382,  1462,  1473,  1474,   469,   470,   875,   876,  1039,
-      51,    52,    53,    54,    55,   347,   158,    58,    59,    60,
-      61,    62,   349,    64,    65,   264,    67,    68,   274,   351,
-     352,    71,    72,    73,   118,    75,   204,   354,   119,    78,
-     120,    80,    81,   455,    82,   454,   689,   690,   691,   909,
-    1087,   910,    83,    84,   458,   456,   697,   856,   857,   858,
-     859,   700,   701,   702,   359,   360,   361,   362,   466,   340,
-     135,   136,   522,   324,   170,   646,   647,   648,   649,   650,
-      85,   121,    87,   489,   490,   940,   491,   277,   495,   325,
-      88,   137,   138,    89,  1322,  1109,  1110,  1111,  1112,    90,
-      91,   718,    92,   273,    93,    94,   187,  1033,   680,   412,
-     125,    95,   501,   502,   503,   188,   268,   190,   191,   192,
-     269,    98,    99,   100,   101,   102,   103,   104,   195,   196,
-     197,   198,   199,   826,   606,   607,   608,   609,   200,   611,
-     612,   613,   573,   574,   575,   576,   752,   105,   615,   616,
-     617,   618,   619,   620,   969,   754,   755,   756,   596,   365,
-     366,   367,   368,   326,   164,   107,   108,   109,   370,   695,
-     570
+      -1,   815,   468,   300,    47,   133,   134,   301,   302,   303,
+     304,   305,   762,   763,  1136,  1137,  1138,   306,   381,   308,
+     309,   310,   311,   312,   313,   314,   315,   316,   317,   318,
+     319,   320,  1032,   518,   977,   547,   322,   978,   949,  1059,
+    1522,  1061,  1062,  1063,  1064,  1523,  1065,  1066,  1441,  1442,
+    1405,  1406,  1407,  1501,  1502,  1506,  1507,  1542,  1543,  1067,
+    1365,  1068,  1069,  1302,  1303,  1304,  1484,  1070,   145,   955,
+     956,   957,  1385,  1465,  1476,  1477,   469,   470,   876,   877,
+    1040,    51,    52,    53,    54,    55,   347,   158,    58,    59,
+      60,    61,    62,   349,    64,    65,   264,    67,    68,   274,
+     351,   352,    71,    72,    73,   118,    75,   204,   354,   119,
+      78,   120,    80,    81,   455,    82,   454,   689,   690,   691,
+     910,  1088,   911,    83,    84,   458,   456,   697,   857,   858,
+     859,   860,   700,   701,   702,   359,   360,   361,   362,   466,
+     340,   135,   136,   522,   324,   170,   646,   647,   648,   649,
+     650,    85,   121,    87,   489,   490,   941,   491,   277,   495,
+     325,    88,   137,   138,    89,  1325,  1110,  1111,  1112,  1113,
+      90,    91,   718,    92,   273,    93,    94,   187,  1034,   680,
+     412,   125,    95,   501,   502,   503,   188,   268,   190,   191,
+     192,   269,    98,    99,   100,   101,   102,   103,   104,   195,
+     196,   197,   198,   199,   827,   606,   607,   608,   609,   200,
+     611,   612,   613,   573,   574,   575,   576,   752,   105,   615,
+     616,   617,   618,   619,   620,   970,   754,   755,   756,   596,
+     365,   366,   367,   368,   326,   164,   107,   108,   109,   370,
+     695,   570
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -1323
+#define YYPACT_NINF -1338
 static const yytype_int16 yypact[] =
 {
-    7329,  8828, -1323,    37, -1323, -1323, -1323, -1323, -1323, -1323,
-   -1323,   109, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323,
-   -1323, -1323, -1323, -1323, -1323, -1323,    85,    85,    85,   873,
-     733,   178,  7561,   370, -1323, -1323, -1323, -1323, -1323,   191,
-   -1323, -1323, -1323,   614,   225, -1323, -1323, -1323, -1323,  4615,
-   -1323, -1323, -1323, -1323,   229,   285, -1323,   934, -1323, -1323,
-   -1323, -1323,   435,  1196,   579,   110,  7677, -1323, -1323,  4858,
-    1038, -1323, -1323,   580,   596,  6761,  1021,   875,   580,  1103,
-   -1323, -1323,  1317,   308, -1323,   580,  1224, -1323,   495, -1323,
-     616,   623, -1323, -1323, -1323, -1323,   547,   285,    85, -1323,
-      85, -1323, -1323, -1323, -1323,  9174,   934, -1323, -1323,   934,
-   -1323,   551, -1323,  9403, -1323, -1323,  1899,  9436, -1323,   844,
-     844,   844, -1323, -1323, -1323,    85, -1323, -1323, -1323,   584,
-     608,   632, -1323, -1323, -1323,   646, -1323, -1323, -1323, -1323,
-   -1323,   664,   687, -1323, -1323,   -28,  8797,  2908,   117,   701,
-     717,   726,   771,   786,   799,  8715,  6849,   731,   757, -1323,
-    5600, -1323, -1323, -1323, -1323,   804, -1323,   223,  5225,  5225,
-   -1323,   802,   365, -1323, -1323, -1323, -1323,   816,   443,   480,
-     534,    85,   827, -1323, -1323,  1196,  4341,   868, -1323,    50,
-   -1323,    85,    85,   285, -1323, -1323,    61, -1323,    85,    85,
-   -1323,  4647,   857,   864,   844,  6523, -1323, -1323,   869,  4615,
-   -1323, -1323,   580, -1323, -1323, -1323,   285, -1323,   934,   229,
-   -1323,  7868, -1323,   844,   844,   844,   285, -1323,   873, -1323,
-    5676, -1323, -1323,   852,   844, -1323,   844, -1323,   191,  8797,
-   -1323,   884, -1323,   733,   890,   844, -1323,   873,   888,   892,
-   -1323,  7561,   631, -1323, -1323, -1323,  9256, -1323, -1323,  9621,
-   -1323,   868,   151, 10214,  9436,  1899,  4647, -1323,    88, -1323,
-   -1323,  9403,   934,   891,  7708, -1323, -1323,   347, -1323, 10561,
-     922,   956, 10347,   945, 10366, 10423, -1323,   954, -1323, -1323,
-   -1323, -1323, 10442, 10442,  8571,   952, -1323, -1323, -1323, -1323,
-   -1323, -1323, -1323,   988, -1323,   966,  1946,  8910, 10366, -1323,
-     756,   338,   485,   411,   635,   955,   947,   957,   984,   237,
-   -1323, -1323,   962,   647, -1323,   302, -1323, -1323,  2908, -1323,
-   -1323,   235,   985, -1323,   312,   985,   989,   191, -1323, -1323,
-     990,  9174, -1323,   999,  1006,  9023, -1323, -1323,  1335,  2030,
-    8286,  6523,   580, -1323,   580,   844,   844, -1323, -1323, -1323,
-   -1323, -1323, -1323,   844,  9174,   934, -1323, -1323,  9474,  1575,
-   -1323,  8017, -1323, -1323, -1323, -1323, -1323, -1323, -1323,  1008,
-    5958, 10366, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323,
-   -1323, -1323, -1323, -1323, -1323, -1323,  1899, -1323,   973,   991,
-     992,  1012,   978,  1017,  1018,  1020,  4341, -1323, -1323,  1029,
-     229,  1031, -1323, -1323,  1033, -1323, -1323, -1323,  9256, -1323,
-   -1323, -1323, -1323, -1323,  4647, -1323,  8797,  8797, -1323,   844,
-    1899,  6642,   934,  8359, -1323, -1323, -1323, -1323,  9256,   151,
-   -1323, -1323,   580,   285, -1323, -1323,  9256, -1323,  5770, -1323,
-   -1323,   844,   844,   337,  8204,  1032,  1036,  1023,  1042,   844,
-   -1323, -1323, -1323, -1323,  9660, -1323,   367,  6404, -1323,   285,
-    1044, -1323,  1899, 10643, 10271, -1323, -1323, -1323, -1323,  1015,
-    4647, -1323,  8432,   868,  7445, -1323, -1323, -1323,   843,   436,
-     962,   733,  7708,  1341,  9403, -1323,  7708, -1323, -1323, -1323,
-   -1323,   508, -1323,  1051,   956,   248,  8571, -1323,  9512, -1323,
-   -1323,  8571, -1323,  8684,  8571, -1323, -1323,  1049, -1323,   606,
-    1057,   682,  1059, -1323, -1323,  3527,  6492, -1323,   362, -1323,
-   -1323, 10214, -1323,   368, 10214, -1323, -1323, -1323, -1323, -1323,
-   -1323, -1323, -1323, -1323, -1323, -1323, -1323, 10214, -1323, -1323,
-   10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366,
-   10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366,  3593, 10214,
-   -1323,   647,  1677, -1323, -1323,    85,    85, -1323, -1323,  8797,
-   -1323, -1323,  1033,   631, -1323,  1033, 10290, -1323, -1323, -1323,
-    5046,  6492,  1060,  1063, -1323,  9436, -1323, -1323,   804, -1323,
-    1067,   750,  1068,  2627,   125,   962, -1323,    85,    85,   962,
-     132, -1323,    85,    85,  1033, -1323, -1323,    85,    85, -1323,
-     985,  9545,   934, 10788,   532,   656,  9545, -1323,  9621, -1323,
-     962, -1323,  9174, -1323,   238,  7983,  7983,  7983,   934, -1323,
-    5791,  1047,  1008,   493,  1058,  1061, -1323,  1076,  5225,   528,
-   -1323,  1165,   934,  7983,   631,  1899,   631,   868,   430,   985,
-   -1323, -1323,   536,   985, -1323, -1323, -1323,   956, -1323,   985,
-     285,  9660, -1323,   619,  1086,   633,  1088, -1323,  1087,   285,
-   -1323, -1323,  9256,   285,  1089,  9512,  1092, -1323,  1065, -1323,
-     538,   552,   733, -1323,   733,  1085, 10366, -1323,   733, 10788,
-   -1323, -1323,  1096, -1323, -1323, -1323,   631, -1323, 10716,  1006,
-   -1323,  7983,   703,  8286, -1323, -1323,   804,  1095,  1098,   843,
-    5016, -1323, -1323,  7708, -1323, -1323,  1091, -1323, -1323,  1102,
-   -1323,  1091,  1104, 10561, 10214,  1090,  1093,    94,  1109,  1107,
-    1111,  1114, -1323,  1118,  1129,  9365,  6611, -1323, 10214, -1323,
-     682,  1717, -1323, -1323, -1323,    85,    85, 10157, 10214,  1125,
-   -1323, -1323,   653, -1323, 10214, -1323, -1323,   736, -1323, -1323,
-   -1323, -1323,   756,   756,   338,   338,   485,   485,   485,   485,
-     411,   411,   635,   955,   947,   957,   984, 10366,   260, -1323,
-    9660,  1132,  1136,  1137,  1677, -1323, -1323, -1323, -1323, -1323,
-    9660,   708,  7983, -1323,  9174, -1323,  6968,  9136, -1323,  8017,
-    6849, -1323, -1323,   750,  9660,  1022,  1140,  1141,  1142,  1143,
-    1146,  1149,  1154, -1323,  3715,  2627, -1323, -1323, -1323, -1323,
-   -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323,
-   -1323, -1323, -1323,  1033, -1323, -1323, -1323,   962, -1323, -1323,
-   -1323, -1323, -1323, -1323, -1323, -1323,  1155, -1323,  1157,  1159,
-   -1323, -1323,   229,  1125,  5791, -1323, -1323, -1323,  5958,  1158,
-   -1323, -1323, -1323, -1323,   733,  6174,  1248, -1323, -1323, -1323,
-   -1323,  1151,   229, -1323, -1323,  1033, -1323, -1323,  1033,    84,
-    1033, -1323, -1323, -1323, -1323, -1323, -1323,  9327, -1323,   285,
-   -1323, -1323,   559,   562,  9474,  7087,  2137, 10366,  3114, -1323,
-   -1323,  1156,    51,  1156, -1323,   733, -1323,    85, -1323, -1323,
-    8941,  1023, -1323, -1323, -1323,  1036,  1175,  1171, -1323, -1323,
-    1178,  1181, -1323,   703,  1901, -1323,   672, -1323,  5016,   962,
-   -1323,  1184,  7708,  9583,  8797,  1185, -1323, -1323,  1180,  1187,
-    1170, -1323, 10366,  1197,   326,  1194, -1323,  1202,   631,  1202,
-   -1323, -1323,  1202,  1199, -1323,  1208,  1210,  1211,  1717, -1323,
-   -1323, -1323,  5958, -1323, -1323, -1323, -1323,  1209, 10214,  1212,
-     631, -1323, 10214, -1323,   631, -1323, -1323, 10214, -1323,   558,
-     985, -1323, -1323, -1323, -1323, -1323, -1323, -1323,  1008,  1006,
-    9023, -1323, -1323,  7206,  1218, -1323,   674,   985, -1323,   813,
-     861,   985, -1323,   844,  4029, -1323, -1323, -1323,  9660,  9660,
-   -1323,  8359,  8359, -1323,  1215,  1216,  1225,  1230, -1323,  1232,
-     685,    82,  1125, -1323,   631, -1323,  5225, -1323, 10214,   564,
-   -1323,  6373,  1236,  1240, 10100,  1242,  1243,    70,    79,    96,
-   10214,  1244,   285, 10214, 10214,  1227,  1249,   522,  1222, -1323,
-   -1323, -1323,  1250, -1323, -1323, -1323, -1323, -1323, -1323, -1323,
-   -1323, -1323,   733,  1254, 10214, -1323,  9660,  9660,    85,  1257,
-   -1323,  9054, -1323, -1323,   752, -1323,  3114, -1323, -1323, -1323,
-   -1323,  1065, -1323, -1323,  1255, -1323, -1323, -1323, -1323,  1258,
-    1901, -1323, -1323,  1245, -1323,  1091, -1323, -1323,  1899,  1260,
-   -1323, -1323, -1323,   713,  1264, -1323,    94,  1269, 10366,  1252,
-      94,    94,  1262,  3527,   879,   985, -1323, -1323,  1076, 10214,
-    1273,  1209,   358,   204,  1270, -1323, -1323,  1275,  1270, -1323,
-   -1323,  1278, -1323, -1323,  1033,  1280,  1284,  6730,  1285,  1290,
-    1291, -1323, -1323,  1286, -1323, -1323,  1033, -1323, -1323, -1323,
-   -1323,  1033, 10214, 10214,  1006,  1294, -1323, -1323, -1323, -1323,
-   -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 10366, 10366,
-    1300,  1302,  1270, -1323, -1323,   733, -1323, -1323, -1323,  5213,
-    9583, 10214, 10214,  1374, 10214, -1323,  1295, -1323,  1296, -1323,
-    1297, 10214,  1301, 10214,  1105,  1304,    12,    85,  9289,  1625,
-   -1323, -1323,  6174,  1322,   573, -1323, -1323, -1323, -1323, -1323,
-   -1323, -1323, -1323, -1323,  9920, -1323,  8432,  1330, -1323, -1323,
-    9583,   576,   602, -1323,  1331,  1315,   956,  1337, -1323,   329,
-   -1323, -1323, -1323, -1323,  1033,  1339, -1323, -1323,  1320,   486,
-     509,   631,  1340, -1323,  1344, -1323,  9660, -1323, -1323, -1323,
-   -1323, -1323,  1347, -1323,  9660,  9660,  9660, -1323, -1323,  1348,
-   -1323,  1351,  1354,  1355,   716,  8056,  8171, -1323, -1323,   529,
-   -1323,  1357,  1362, -1323,  8505,   721,   730,  1358,   761,  3837,
-   -1323, -1323, -1323,   605, -1323,   766,  1366,  1367,   285,  1419,
-     834, -1323, -1323, 10214, -1323, 10100, 10214, -1323, -1323, -1323,
-    1370,  1375, -1323, -1323, -1323,  1372, -1323, -1323, -1323, -1323,
-   -1323, -1323,  9583,   956,  1379, -1323,  1352,   956,  9660, -1323,
-   -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323,
-   -1323, -1323, -1323,  1378,  1382, -1323, -1323, -1323, -1323, -1323,
-   -1323, -1323,  1387, -1323,  1386, -1323, -1323, 10100,   289, 10214,
-   10100, -1323,  1389, 10214, -1323,   318,  1405,  1406, -1323, -1323,
-    1399,  1400,  1380, -1323,   821, -1323, -1323, -1323,   934,  1899,
-    1396, -1323,   402, 10366, -1323,   785, -1323,   631,   631,  1407,
-    1408,  1413,  1415, -1323, -1323,  8359,  1414, -1323,  1490, 10366,
-    1385, -1323, -1323, 10012, -1323,   800, -1323,  1402, 10100,  1403,
-   -1323, -1323,  1426, -1323,  1427, -1323,  1445,  1446, -1323,  1411,
-    9583, -1323, -1323, -1323,   956,   631,  1434,  1417,  1435,  1270,
-    1270, -1323, -1323, -1323, -1323, -1323, 10100,   107, -1323,   433,
-   -1323, -1323,  7793, -1323, -1323,  1418, 10214, -1323, 10214,  7793,