Changeset 7756647


Ignore:
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, 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:
11 added
20 edited

Legend:

Unmodified
Added
Removed
  • doc/aaron_comp_II/comp_II.tex

    rac9ca96 r7756647  
    400400
    401401\section{Expression Resolution}
     402\subsection{Analysis}
    402403The 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).
    403404Assuming 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.
     
    409410The 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.
    410411
     412\subsection{Expression Costs}
     413The 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.
     414With 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.
     415In \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.
     416These 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.
     417
     418\begin{lstlisting}
     419void f(char, long);  // $f_1$ - cost (2, 0, 1)
     420forall(otype T) void f(T, long); // $f_2$ - cost (0, 1, 1)
     421void f(long, long); // $f_{3a}$ - cost (0, 0, 2)
     422void f(int, float); // $f_{3b}$ - cost (0, 0, 2)
     423void f(int, long);  // $f_4$ - cost (0, 0, 1)
     424
     425f(7, 11);
     426\end{lstlisting}
     427
     428In the example above, the expression resolves to $f_4$.
     429$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©).
     430Neither $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.
     431If 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}$.
     432
     433In 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.
     434
     435\subsection{Objectives}
    411436The 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.
    412437The 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

    rac9ca96 r7756647  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun  8 14:38:53 2015
    13 // Update Count     : 4
     12// Last Modified On : Sat Sep 24 15:13:42 2016
     13// Update Count     : 5
    1414//
    1515
     
    4646}
    4747
    48 
    4948#endif // SEMANTICERROR_H
    5049
  • src/Common/module.mk

    rac9ca96 r7756647  
    1111## Created On       : Mon Jun  1 17:49:17 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Thu Aug 18 13:29:04 2016
    14 ## Update Count     : 2
     13## Last Modified On : Tue Sep 27 11:06:38 2016
     14## Update Count     : 4
    1515###############################################################################
    1616
    1717SRC += Common/SemanticError.cc \
    1818       Common/UniqueName.cc \
     19       Common/DebugMalloc.cc \
    1920       Common/Assert.cc
  • src/Common/utility.h

    rac9ca96 r7756647  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun  8 17:33:59 2016
    13 // Update Count     : 22
     12// Last Modified On : Fri Sep 23 11:46:47 2016
     13// Update Count     : 28
    1414//
    1515
     
    2525#include <sstream>
    2626#include <string>
     27#include <cassert>
    2728
    2829template< typename T >
     
    101102                } // if
    102103        } // for
    103 }
    104 
    105 static inline std::string assign_strptr( const std::string *str ) {
    106         if ( str == 0 ) {
    107                 return "";
    108         } else {
    109                 std::string tmp;
    110                 tmp = *str;
    111                 delete str;
    112                 return tmp;
    113         } // if
    114104}
    115105
     
    141131
    142132template < typename T >
    143 void toString_single ( std::ostream & os, const T & value ) {
     133void toString_single( std::ostream & os, const T & value ) {
    144134        os << value;
    145135}
    146136
    147137template < typename T, typename... Params >
    148 void toString_single ( std::ostream & os, const T & value, const Params & ... params ) {
     138void toString_single( std::ostream & os, const T & value, const Params & ... params ) {
    149139        os << value;
    150140        toString_single( os, params ... );
     
    152142
    153143template < typename ... Params >
    154 std::string toString ( const Params & ... params ) {
     144std::string toString( const Params & ... params ) {
    155145        std::ostringstream os;
    156146        toString_single( os, params... );
  • src/Makefile.am

    rac9ca96 r7756647  
    1111## Created On       : Sun May 31 08:51:46 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Sat Aug 20 11:13:12 2016
    14 ## Update Count     : 71
     13## Last Modified On : Sat Sep 24 15:03:52 2016
     14## Update Count     : 73
    1515###############################################################################
    1616
     
    4040cfa_cpplib_PROGRAMS = driver/cfa-cpp
    4141driver_cfa_cpp_SOURCES = ${SRC}
    42 driver_cfa_cpp_LDADD = ${LEXLIB}                        # yywrap
     42driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
    4343driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include
    4444
  • src/Makefile.in

    rac9ca96 r7756647  
    9898        Common/driver_cfa_cpp-SemanticError.$(OBJEXT) \
    9999        Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \
     100        Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) \
    100101        Common/driver_cfa_cpp-Assert.$(OBJEXT) \
    101102        ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT) \
     
    358359        CodeGen/CodeGenerator.cc CodeGen/GenType.cc \
    359360        CodeGen/FixNames.cc CodeGen/OperatorTable.cc \
    360         Common/SemanticError.cc Common/UniqueName.cc Common/Assert.cc \
     361        Common/SemanticError.cc Common/UniqueName.cc \
     362        Common/DebugMalloc.cc Common/Assert.cc \
    361363        ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
    362364        ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
     
    412414cfa_cpplibdir = ${libdir}
    413415driver_cfa_cpp_SOURCES = ${SRC}
    414 driver_cfa_cpp_LDADD = ${LEXLIB}                        # yywrap
     416driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
    415417driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include
    416418all: $(BUILT_SOURCES)
     
    512514        Common/$(DEPDIR)/$(am__dirstamp)
    513515Common/driver_cfa_cpp-UniqueName.$(OBJEXT): Common/$(am__dirstamp) \
     516        Common/$(DEPDIR)/$(am__dirstamp)
     517Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \
    514518        Common/$(DEPDIR)/$(am__dirstamp)
    515519Common/driver_cfa_cpp-Assert.$(OBJEXT): Common/$(am__dirstamp) \
     
    784788        -rm -f CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT)
    785789        -rm -f Common/driver_cfa_cpp-Assert.$(OBJEXT)
     790        -rm -f Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT)
    786791        -rm -f Common/driver_cfa_cpp-SemanticError.$(OBJEXT)
    787792        -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT)
     
    889894@AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/driver_cfa_cpp-OperatorTable.Po@am__quote@
    890895@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po@am__quote@
     896@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po@am__quote@
    891897@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Po@am__quote@
    892898@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@
     
    11251131@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`
    11261132
     1133Common/driver_cfa_cpp-DebugMalloc.o: Common/DebugMalloc.cc
     1134@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
     1135@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po
     1136@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.o' libtool=no @AMDEPBACKSLASH@
     1137@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1138@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
     1139
     1140Common/driver_cfa_cpp-DebugMalloc.obj: Common/DebugMalloc.cc
     1141@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`
     1142@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po
     1143@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.obj' libtool=no @AMDEPBACKSLASH@
     1144@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1145@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`
     1146
    11271147Common/driver_cfa_cpp-Assert.o: Common/Assert.cc
    11281148@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

    rac9ca96 r7756647  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Sep 14 23:13:28 2016
    13 // Update Count     : 502
     12// Last Modified On : Mon Oct  3 18:03:08 2016
     13// Update Count     : 651
    1414//
    1515
     
    3131
    3232// These must remain in the same order as the corresponding DeclarationNode enumerations.
    33 const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
    34 const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
    35 const char *DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
    36 const char *DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
    37 const char *DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
    38 const char *DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
    39 const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" };
    40 const char *DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
    41 const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
     33const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
     34const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
     35const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
     36const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
     37const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
     38const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
     39const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" };
     40const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
     41const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
    4242
    4343UniqueName DeclarationNode::anonymous( "__anonymous" );
     
    4646
    4747DeclarationNode::DeclarationNode() :
    48                 type( 0 ),
     48                type( nullptr ),
    4949                storageClass( NoStorageClass ),
    5050                isInline( false ),
    5151                isNoreturn( false ),
    52                 bitfieldWidth( 0 ),
    53                 initializer( 0 ),
     52                bitfieldWidth( nullptr ),
     53                initializer( nullptr ),
    5454                hasEllipsis( false ),
    5555                linkage( ::linkage ),
    5656                extension( false ) {
    57         variable.tyClass = DeclarationNode::Otype;
     57
     58//      variable.name = nullptr;
     59        variable.tyClass = NoTypeClass;
    5860        variable.assertions = nullptr;
    5961
     62//      attr.name = nullptr;
    6063        attr.expr = nullptr;
    6164        attr.type = nullptr;
     
    6366
    6467DeclarationNode::~DeclarationNode() {
     68//      delete attr.name;
    6569        delete attr.expr;
    6670        delete attr.type;
     71
     72//      delete variable.name;
     73        delete variable.assertions;
     74
    6775        delete type;
    6876        delete bitfieldWidth;
     
    7078}
    7179
    72 DeclarationNode *DeclarationNode::clone() const {
    73         DeclarationNode *newnode = new DeclarationNode;
     80DeclarationNode * DeclarationNode::clone() const {
     81        DeclarationNode * newnode = new DeclarationNode;
    7482        newnode->type = maybeClone( type );
    75         newnode->name = name;
     83        newnode->name = name ? new string( *name ) : nullptr;
    7684        newnode->storageClass = storageClass;
    7785        newnode->isInline = isInline;
     
    8391        newnode->linkage = linkage;
    8492
     93//      newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
     94        newnode->variable.tyClass = variable.tyClass;
    8595        newnode->variable.assertions = maybeClone( variable.assertions );
    86         newnode->variable.name = variable.name;
    87         newnode->variable.tyClass = variable.tyClass;
    88 
     96
     97//      newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
    8998        newnode->attr.expr = maybeClone( attr.expr );
    9099        newnode->attr.type = maybeClone( attr.type );
     
    98107void DeclarationNode::print( std::ostream &os, int indent ) const {
    99108        os << string( indent, ' ' );
    100         if ( name == "" ) {
     109        if ( name ) {
     110                os << *name << ": ";
     111        } else {
    101112                os << "unnamed: ";
    102         } else {
    103                 os << name << ": ";
    104113        } // if
    105114
    106115        if ( linkage != LinkageSpec::Cforall ) {
    107                 os << LinkageSpec::toString( linkage ) << " ";
     116                os << LinkageSpec::linkageName( linkage ) << " ";
    108117        } // if
    109118
     
    122131        } // if
    123132
    124         if ( initializer != 0 ) {
     133        if ( initializer ) {
    125134                os << endl << string( indent + 2, ' ' ) << "with initializer ";
    126135                initializer->printOneLine( os );
     
    139148}
    140149
    141 DeclarationNode *DeclarationNode::newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) {
    142         DeclarationNode *newnode = new DeclarationNode;
    143         newnode->name = assign_strptr( name );
    144 
     150DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) {
     151        DeclarationNode * newnode = new DeclarationNode;
     152        newnode->name = name;
    145153        newnode->type = new TypeData( TypeData::Function );
    146154        newnode->type->function.params = param;
    147155        newnode->type->function.newStyle = newStyle;
    148156        newnode->type->function.body = body;
    149         typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
     157        // ignore unnamed routine declarations: void p( int (*)(int) );
     158        if ( newnode->name ) {
     159                typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
     160        } // if
    150161
    151162        if ( body ) {
     
    155166        if ( ret ) {
    156167                newnode->type->base = ret->type;
    157                 ret->type = 0;
     168                ret->type = nullptr;
    158169                delete ret;
    159170        } // if
     
    163174
    164175DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) {
    165         DeclarationNode *newnode = new DeclarationNode;
     176        DeclarationNode * newnode = new DeclarationNode;
    166177        newnode->type = new TypeData();
    167178        newnode->type->qualifiers[ q ] = 1;
     
    169180} // DeclarationNode::newQualifier
    170181
    171 DeclarationNode * DeclarationNode::newForall( DeclarationNode *forall ) {
    172         DeclarationNode *newnode = new DeclarationNode;
     182DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {
     183        DeclarationNode * newnode = new DeclarationNode;
    173184        newnode->type = new TypeData( TypeData::Unknown );
    174185        newnode->type->forall = forall;
     
    177188
    178189DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
    179         DeclarationNode *newnode = new DeclarationNode;
    180         //switch (sc) {
    181         //      case Inline: newnode->isInline = true; break;
    182         //      case Noreturn: newnode->isNoreturn = true; break;
    183         //      default: newnode->storageClass = sc; break;
    184         //}
     190        DeclarationNode * newnode = new DeclarationNode;
    185191        newnode->storageClass = sc;
    186192        return newnode;
     
    188194
    189195DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
    190         DeclarationNode *newnode = new DeclarationNode;
     196        DeclarationNode * newnode = new DeclarationNode;
    191197        newnode->type = new TypeData( TypeData::Basic );
    192198        newnode->type->basictype = bt;
     
    195201
    196202DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
    197         DeclarationNode *newnode = new DeclarationNode;
     203        DeclarationNode * newnode = new DeclarationNode;
    198204        newnode->type = new TypeData( TypeData::Basic );
    199205        newnode->type->complextype = ct;
     
    202208
    203209DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
    204         DeclarationNode *newnode = new DeclarationNode;
     210        DeclarationNode * newnode = new DeclarationNode;
    205211        newnode->type = new TypeData( TypeData::Basic );
    206212        newnode->type->signedness = sn;
     
    209215
    210216DeclarationNode * DeclarationNode::newLength( Length lnth ) {
    211         DeclarationNode *newnode = new DeclarationNode;
     217        DeclarationNode * newnode = new DeclarationNode;
    212218        newnode->type = new TypeData( TypeData::Basic );
    213219        newnode->type->length = lnth;
     
    215221} // DeclarationNode::newLength
    216222
    217 DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) {
    218         DeclarationNode *newnode = new DeclarationNode;
     223DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
     224        DeclarationNode * newnode = new DeclarationNode;
    219225        newnode->type = new TypeData( TypeData::SymbolicInst );
    220         newnode->type->symbolic.name = assign_strptr( name );
     226        newnode->type->symbolic.name = name;
    221227        newnode->type->symbolic.isTypedef = true;
    222         newnode->type->symbolic.params = 0;
     228        newnode->type->symbolic.params = nullptr;
    223229        return newnode;
    224230} // DeclarationNode::newFromTypedef
    225231
    226 DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) {
    227         DeclarationNode *newnode = new DeclarationNode;
     232DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
     233        DeclarationNode * newnode = new DeclarationNode;
    228234        newnode->type = new TypeData( TypeData::Aggregate );
    229235        newnode->type->aggregate.kind = kind;
    230         newnode->type->aggregate.name = assign_strptr( name );
    231         if ( newnode->type->aggregate.name == "" ) {            // anonymous aggregate ?
    232                 newnode->type->aggregate.name = anonymous.newName();
     236        if ( name ) {
     237                newnode->type->aggregate.name = name;
     238        } else {                                                                                        // anonymous aggregate ?
     239                newnode->type->aggregate.name = new string( anonymous.newName() );
    233240        } // if
    234241        newnode->type->aggregate.actuals = actuals;
     
    238245} // DeclarationNode::newAggregate
    239246
    240 DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
    241         DeclarationNode *newnode = new DeclarationNode;
    242         newnode->name = assign_strptr( name );
     247DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants ) {
     248        DeclarationNode * newnode = new DeclarationNode;
    243249        newnode->type = new TypeData( TypeData::Enum );
    244         newnode->type->enumeration.name = newnode->name;
    245         if ( newnode->type->enumeration.name == "" ) {          // anonymous enumeration ?
    246                 newnode->type->enumeration.name = DeclarationNode::anonymous.newName();
     250        if ( name ) {
     251                newnode->type->enumeration.name = name;
     252        } else {                                                                                        // anonymous aggregate ?
     253                newnode->type->enumeration.name = new string( anonymous.newName() );
    247254        } // if
    248255        newnode->type->enumeration.constants = constants;
     
    250257} // DeclarationNode::newEnum
    251258
    252 DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) {
    253         DeclarationNode *newnode = new DeclarationNode;
    254         newnode->name = assign_strptr( name );
     259DeclarationNode * DeclarationNode::newEnumConstant( string * name, ExpressionNode * constant ) {
     260        DeclarationNode * newnode = new DeclarationNode;
     261        newnode->name = name;
    255262        newnode->enumeratorValue.reset( constant );
    256         typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
     263        typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
    257264        return newnode;
    258265} // DeclarationNode::newEnumConstant
    259266
    260 DeclarationNode *DeclarationNode::newName( std::string *name ) {
    261         DeclarationNode *newnode = new DeclarationNode;
    262         newnode->name = assign_strptr( name );
     267DeclarationNode * DeclarationNode::newName( string * name ) {
     268        DeclarationNode * newnode = new DeclarationNode;
     269        newnode->name = name;
    263270        return newnode;
    264271} // DeclarationNode::newName
    265272
    266 DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
    267         DeclarationNode *newnode = new DeclarationNode;
     273DeclarationNode * DeclarationNode::newFromTypeGen( string * name, ExpressionNode * params ) {
     274        DeclarationNode * newnode = new DeclarationNode;
    268275        newnode->type = new TypeData( TypeData::SymbolicInst );
    269         newnode->type->symbolic.name = assign_strptr( name );
     276        newnode->type->symbolic.name = name;
    270277        newnode->type->symbolic.isTypedef = false;
    271278        newnode->type->symbolic.actuals = params;
     
    273280} // DeclarationNode::newFromTypeGen
    274281
    275 DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
    276         DeclarationNode *newnode = new DeclarationNode;
    277         newnode->name = assign_strptr( name );
    278         newnode->type = new TypeData( TypeData::Variable );
     282DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, string * name ) {
     283        DeclarationNode * newnode = new DeclarationNode;
     284        newnode->type = nullptr;
     285        assert( ! newnode->name );
     286//      newnode->variable.name = name;
     287        newnode->name = name;
    279288        newnode->variable.tyClass = tc;
    280         newnode->variable.name = newnode->name;
     289        newnode->variable.assertions = nullptr;
    281290        return newnode;
    282291} // DeclarationNode::newTypeParam
    283292
    284 DeclarationNode *DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
    285         DeclarationNode *newnode = new DeclarationNode;
     293DeclarationNode * DeclarationNode::newTrait( const string * name, DeclarationNode * params, DeclarationNode * asserts ) {
     294        DeclarationNode * newnode = new DeclarationNode;
    286295        newnode->type = new TypeData( TypeData::Aggregate );
     296        newnode->type->aggregate.name = name;
    287297        newnode->type->aggregate.kind = Trait;
    288298        newnode->type->aggregate.params = params;
    289299        newnode->type->aggregate.fields = asserts;
    290         newnode->type->aggregate.name = assign_strptr( name );
    291300        return newnode;
    292301} // DeclarationNode::newTrait
    293302
    294 DeclarationNode *DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) {
    295         DeclarationNode *newnode = new DeclarationNode;
     303DeclarationNode * DeclarationNode::newTraitUse( const string * name, ExpressionNode * params ) {
     304        DeclarationNode * newnode = new DeclarationNode;
    296305        newnode->type = new TypeData( TypeData::AggregateInst );
    297306        newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate );
    298307        newnode->type->aggInst.aggregate->aggregate.kind = Trait;
    299         newnode->type->aggInst.aggregate->aggregate.name = assign_strptr( name );
     308        newnode->type->aggInst.aggregate->aggregate.name = name;
    300309        newnode->type->aggInst.params = params;
    301310        return newnode;
    302311} // DeclarationNode::newTraitUse
    303312
    304 DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) {
    305         DeclarationNode *newnode = new DeclarationNode;
    306         newnode->name = assign_strptr( name );
     313DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) {
     314        DeclarationNode * newnode = new DeclarationNode;
    307315        newnode->type = new TypeData( TypeData::Symbolic );
    308316        newnode->type->symbolic.isTypedef = false;
    309317        newnode->type->symbolic.params = typeParams;
    310         newnode->type->symbolic.name = newnode->name;
     318        newnode->type->symbolic.name = name;
    311319        return newnode;
    312320} // DeclarationNode::newTypeDecl
    313321
    314 DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
    315         DeclarationNode *newnode = new DeclarationNode;
     322DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) {
     323        DeclarationNode * newnode = new DeclarationNode;
    316324        newnode->type = new TypeData( TypeData::Pointer );
    317325        return newnode->addQualifiers( qualifiers );
    318326} // DeclarationNode::newPointer
    319327
    320 DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
    321         DeclarationNode *newnode = new DeclarationNode;
     328DeclarationNode * DeclarationNode::newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ) {
     329        DeclarationNode * newnode = new DeclarationNode;
    322330        newnode->type = new TypeData( TypeData::Array );
    323331        newnode->type->array.dimension = size;
    324332        newnode->type->array.isStatic = isStatic;
    325         if ( newnode->type->array.dimension == 0 || newnode->type->array.dimension->isExpressionType<ConstantExpr *>() ) {
     333        if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ConstantExpr * >() ) {
    326334                newnode->type->array.isVarLen = false;
    327335        } else {
     
    331339} // DeclarationNode::newArray
    332340
    333 DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
    334         DeclarationNode *newnode = new DeclarationNode;
     341DeclarationNode * DeclarationNode::newVarArray( DeclarationNode * qualifiers ) {
     342        DeclarationNode * newnode = new DeclarationNode;
    335343        newnode->type = new TypeData( TypeData::Array );
    336         newnode->type->array.dimension = 0;
     344        newnode->type->array.dimension = nullptr;
    337345        newnode->type->array.isStatic = false;
    338346        newnode->type->array.isVarLen = true;
     
    340348}
    341349
    342 DeclarationNode *DeclarationNode::newBitfield( ExpressionNode *size ) {
    343         DeclarationNode *newnode = new DeclarationNode;
     350DeclarationNode * DeclarationNode::newBitfield( ExpressionNode * size ) {
     351        DeclarationNode * newnode = new DeclarationNode;
    344352        newnode->bitfieldWidth = size;
    345353        return newnode;
    346354}
    347355
    348 DeclarationNode *DeclarationNode::newTuple( DeclarationNode *members ) {
    349         DeclarationNode *newnode = new DeclarationNode;
     356DeclarationNode * DeclarationNode::newTuple( DeclarationNode * members ) {
     357        DeclarationNode * newnode = new DeclarationNode;
    350358        newnode->type = new TypeData( TypeData::Tuple );
    351359        newnode->type->tuple = members;
     
    353361}
    354362
    355 DeclarationNode *DeclarationNode::newTypeof( ExpressionNode *expr ) {
    356         DeclarationNode *newnode = new DeclarationNode;
     363DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) {
     364        DeclarationNode * newnode = new DeclarationNode;
    357365        newnode->type = new TypeData( TypeData::Typeof );
    358366        newnode->type->typeexpr = expr;
     
    361369
    362370DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) {
    363         DeclarationNode *newnode = new DeclarationNode;
     371        DeclarationNode * newnode = new DeclarationNode;
    364372        newnode->type = new TypeData( TypeData::Builtin );
    365373        newnode->builtin = bt;
     
    367375} // DeclarationNode::newBuiltinType
    368376
    369 DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) {
    370         DeclarationNode *newnode = new DeclarationNode;
    371         newnode->type = new TypeData( TypeData::Attr );
    372         newnode->attr.name = assign_strptr( name );
     377DeclarationNode * DeclarationNode::newAttr( string * name, ExpressionNode * expr ) {
     378        DeclarationNode * newnode = new DeclarationNode;
     379        newnode->type = nullptr;
     380//      newnode->attr.name = name;
     381        newnode->name = name;
    373382        newnode->attr.expr = expr;
    374383        return newnode;
    375384}
    376385
    377 DeclarationNode *DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) {
    378         DeclarationNode *newnode = new DeclarationNode;
    379         newnode->type = new TypeData( TypeData::Attr );
    380         newnode->attr.name = assign_strptr( name );
     386DeclarationNode * DeclarationNode::newAttr( string * name, DeclarationNode * type ) {
     387        DeclarationNode * newnode = new DeclarationNode;
     388        newnode->type = nullptr;
     389//      newnode->attr.name = name;
     390        newnode->name = name;
    381391        newnode->attr.type = type;
    382392        return newnode;
     
    389399} // appendError
    390400
    391 void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) {
     401void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
    392402        TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
    393403
     
    401411} // DeclarationNode::checkQualifiers
    402412
    403 void DeclarationNode::checkStorageClasses( DeclarationNode *q ) {
     413void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {
    404414        if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
    405415                if ( storageClass == q->storageClass ) {                // duplicate qualifier
     
    413423} // DeclarationNode::copyStorageClasses
    414424
    415 DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
     425DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
    416426        isInline = isInline || q->isInline;
    417427        isNoreturn = isNoreturn || q->isNoreturn;
     
    424434} // DeclarationNode::copyStorageClasses
    425435
    426 static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
     436static void addQualifiersToType( TypeData *&src, TypeData * dst ) {
    427437        if ( src->forall && dst->kind == TypeData::Function ) {
    428438                if ( dst->forall ) {
     
    431441                        dst->forall = src->forall;
    432442                } // if
    433                 src->forall = 0;
     443                src->forall = nullptr;
    434444        } // if
    435445        if ( dst->base ) {
     
    437447        } else if ( dst->kind == TypeData::Function ) {
    438448                dst->base = src;
    439                 src = 0;
     449                src = nullptr;
    440450        } else {
    441451                dst->qualifiers |= src->qualifiers;
     
    443453} // addQualifiersToType
    444454
    445 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
    446         if ( ! q ) return this;
     455DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode * q ) {
     456        if ( ! q ) { delete q; return this; }
    447457
    448458        checkStorageClasses( q );
    449459        copyStorageClasses( q );
    450460
    451         if ( ! q->type ) { delete q; return this; }
     461        if ( ! q->type ) {
     462                delete q;
     463                return this;
     464        } // if
    452465
    453466        if ( ! type ) {
    454 //              type = new TypeData;
    455                 type = q->type;
     467                type = q->type;                                                                 // reuse this structure
     468                q->type = nullptr;
     469                delete q;
    456470                return this;
    457471        } // if
     
    467481                                type->aggregate.params = q->type->forall;
    468482                                // change implicit typedef from TYPEDEFname to TYPEGENname
    469                                 typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );
     483                                typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG );
    470484                        } else {
    471485                                type->forall = q->type->forall;
    472486                        } // if
    473487                } // if
    474                 q->type->forall = 0;
     488                q->type->forall = nullptr;
    475489        } // if
    476490        delete q;
     
    485499                        dst->forall = src->forall;
    486500                } // if
    487                 src->forall = 0;
     501                src->forall = nullptr;
    488502        } // if
    489503        if ( dst->base ) {
     
    494508                        src->qualifiers |= dst->qualifiers;
    495509                        dst = src;
    496                         src = 0;
     510                        src = nullptr;
    497511                        break;
    498512                  case TypeData::Basic:
     
    504518                                        dst->basictype = src->basictype;
    505519                                } else if ( src->basictype != DeclarationNode::NoBasicType )
    506                                         throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
     520                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
    507521
    508522                                if ( dst->complextype == DeclarationNode::NoComplexType ) {
    509523                                        dst->complextype = src->complextype;
    510524                                } else if ( src->complextype != DeclarationNode::NoComplexType )
    511                                         throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
     525                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
    512526
    513527                                if ( dst->signedness == DeclarationNode::NoSignedness ) {
    514528                                        dst->signedness = src->signedness;
    515529                                } else if ( src->signedness != DeclarationNode::NoSignedness )
    516                                         throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
     530                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
    517531
    518532                                if ( dst->length == DeclarationNode::NoLength ) {
     
    521535                                        dst->length = DeclarationNode::LongLong;
    522536                                } else if ( src->length != DeclarationNode::NoLength )
    523                                         throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
     537                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
    524538                        } // if
    525539                        break;
     
    534548                                } // if
    535549                                dst->base->qualifiers |= src->qualifiers;
    536                                 src = 0;
     550                                src = nullptr;
    537551                                break;
    538552                          default:
     
    542556                                        dst->forall = src->forall;
    543557                                } // if
    544                                 src->forall = 0;
     558                                src->forall = nullptr;
    545559                                dst->base = src;
    546                                 src = 0;
     560                                src = nullptr;
    547561                        } // switch
    548562                } // switch
     
    550564}
    551565
    552 DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
     566DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) {
    553567        if ( o ) {
    554568                checkStorageClasses( o );
     
    566580                                        type = o->type;
    567581                                } // if
    568                                 o->type = 0;
     582                                o->type = nullptr;
    569583                        } else {
    570584                                addTypeToType( o->type, type );
     
    584598}
    585599
    586 DeclarationNode *DeclarationNode::addTypedef() {
    587         TypeData *newtype = new TypeData( TypeData::Symbolic );
    588         newtype->symbolic.params = 0;
     600DeclarationNode * DeclarationNode::addTypedef() {
     601        TypeData * newtype = new TypeData( TypeData::Symbolic );
     602        newtype->symbolic.params = nullptr;
    589603        newtype->symbolic.isTypedef = true;
    590         newtype->symbolic.name = name;
     604        newtype->symbolic.name = name ? new string( *name ) : nullptr;
    591605        newtype->base = type;
    592606        type = newtype;
     
    594608}
    595609
    596 DeclarationNode *DeclarationNode::addAssertions( DeclarationNode *assertions ) {
     610DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
     611        if ( variable.tyClass != NoTypeClass ) {
     612                if ( variable.assertions ) {
     613                        variable.assertions->appendList( assertions );
     614                } else {
     615                        variable.assertions = assertions;
     616                } // if
     617                return this;
     618        } // if
     619
    597620        assert( type );
    598621        switch ( type->kind ) {
     
    604627                } // if
    605628                break;
    606           case TypeData::Variable:
    607                 if ( variable.assertions ) {
    608                         variable.assertions->appendList( assertions );
    609                 } else {
    610                         variable.assertions = assertions;
    611                 } // if
    612                 break;
    613629          default:
    614630                assert( false );
     
    618634}
    619635
    620 DeclarationNode *DeclarationNode::addName( std::string *newname ) {
    621         name = assign_strptr( newname );
    622         return this;
    623 }
    624 
    625 DeclarationNode *DeclarationNode::addBitfield( ExpressionNode *size ) {
     636DeclarationNode * DeclarationNode::addName( string * newname ) {
     637        assert( ! name );
     638        name = newname;
     639        return this;
     640}
     641
     642DeclarationNode * DeclarationNode::addBitfield( ExpressionNode * size ) {
    626643        bitfieldWidth = size;
    627644        return this;
    628645}
    629646
    630 DeclarationNode *DeclarationNode::addVarArgs() {
     647DeclarationNode * DeclarationNode::addVarArgs() {
    631648        assert( type );
    632649        hasEllipsis = true;
     
    634651}
    635652
    636 DeclarationNode *DeclarationNode::addFunctionBody( StatementNode *body ) {
     653DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body ) {
    637654        assert( type );
    638655        assert( type->kind == TypeData::Function );
    639         assert( type->function.body == 0 );
     656        assert( ! type->function.body );
    640657        type->function.body = body;
    641658        type->function.hasBody = true;
     
    643660}
    644661
    645 DeclarationNode *DeclarationNode::addOldDeclList( DeclarationNode *list ) {
     662DeclarationNode * DeclarationNode::addOldDeclList( DeclarationNode * list ) {
    646663        assert( type );
    647664        assert( type->kind == TypeData::Function );
    648         assert( type->function.oldDeclList == 0 );
     665        assert( ! type->function.oldDeclList );
    649666        type->function.oldDeclList = list;
    650667        return this;
    651668}
    652669
    653 static void setBase( TypeData *&type, TypeData *newType ) {
     670static void setBase( TypeData *&type, TypeData * newType ) {
    654671        if ( type ) {
    655                 TypeData *prevBase = type;
    656                 TypeData *curBase = type->base;
    657                 while ( curBase != 0 ) {
     672                TypeData * prevBase = type;
     673                TypeData * curBase = type->base;
     674                while ( curBase != nullptr ) {
    658675                        prevBase = curBase;
    659676                        curBase = curBase->base;
     
    665682}
    666683
    667 DeclarationNode *DeclarationNode::addPointer( DeclarationNode *p ) {
     684DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) {
    668685        if ( p ) {
    669686                assert( p->type->kind == TypeData::Pointer );
    670687                setBase( type, p->type );
    671                 p->type = 0;
     688                p->type = nullptr;
    672689                delete p;
    673690        } // if
     
    675692}
    676693
    677 DeclarationNode *DeclarationNode::addArray( DeclarationNode *a ) {
     694DeclarationNode * DeclarationNode::addArray( DeclarationNode * a ) {
    678695        if ( a ) {
    679696                assert( a->type->kind == TypeData::Array );
    680697                setBase( type, a->type );
    681                 a->type = 0;
     698                a->type = nullptr;
    682699                delete a;
    683700        } // if
     
    685702}
    686703
    687 DeclarationNode *DeclarationNode::addNewPointer( DeclarationNode *p ) {
     704DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) {
    688705        if ( p ) {
    689706                assert( p->type->kind == TypeData::Pointer );
     
    703720                                p->type->base = type;
    704721                        } // switch
    705                         type = 0;
     722                        type = nullptr;
    706723                } // if
    707724                delete this;
     
    712729}
    713730
    714 static TypeData *findLast( TypeData *a ) {
     731static TypeData * findLast( TypeData * a ) {
    715732        assert( a );
    716         TypeData *cur = a;
     733        TypeData * cur = a;
    717734        while ( cur->base ) {
    718735                cur = cur->base;
     
    721738}
    722739
    723 DeclarationNode *DeclarationNode::addNewArray( DeclarationNode *a ) {
     740DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
    724741        if ( a ) {
    725742                assert( a->type->kind == TypeData::Array );
    726                 TypeData *lastArray = findLast( a->type );
     743                TypeData * lastArray = findLast( a->type );
    727744                if ( type ) {
    728745                        switch ( type->kind ) {
     
    739756                                lastArray->base = type;
    740757                        } // switch
    741                         type = 0;
     758                        type = nullptr;
    742759                } // if
    743760                delete this;
     
    748765}
    749766
    750 DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) {
    751         TypeData *ftype = new TypeData( TypeData::Function );
     767DeclarationNode * DeclarationNode::addParamList( DeclarationNode * params ) {
     768        TypeData * ftype = new TypeData( TypeData::Function );
    752769        ftype->function.params = params;
    753770        setBase( type, ftype );
     
    755772}
    756773
    757 static TypeData *addIdListToType( TypeData *type, DeclarationNode *ids ) {
     774static TypeData * addIdListToType( TypeData * type, DeclarationNode * ids ) {
    758775        if ( type ) {
    759776                if ( type->kind != TypeData::Function ) {
     
    764781                return type;
    765782        } else {
    766                 TypeData *newtype = new TypeData( TypeData::Function );
     783                TypeData * newtype = new TypeData( TypeData::Function );
    767784                newtype->function.idList = ids;
    768785                return newtype;
    769786        } // if
    770 }
    771 
    772 DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) {
     787} // addIdListToType
     788
     789DeclarationNode * DeclarationNode::addIdList( DeclarationNode * ids ) {
    773790        type = addIdListToType( type, ids );
    774791        return this;
    775792}
    776793
    777 DeclarationNode *DeclarationNode::addInitializer( InitializerNode *init ) {
    778         //assert
     794DeclarationNode * DeclarationNode::addInitializer( InitializerNode * init ) {
    779795        initializer = init;
    780796        return this;
    781797}
    782798
    783 DeclarationNode *DeclarationNode::cloneBaseType( string *newName ) {
    784         DeclarationNode *newnode = new DeclarationNode;
    785         TypeData *srcType = type;
    786         while ( srcType->base ) {
    787                 srcType = srcType->base;
    788         } // while
    789         newnode->type = maybeClone( srcType );
    790         if ( newnode->type->kind == TypeData::AggregateInst ) {
    791                 // don't duplicate members
    792                 if ( newnode->type->aggInst.aggregate->kind == TypeData::Enum ) {
    793                         delete newnode->type->aggInst.aggregate->enumeration.constants;
    794                         newnode->type->aggInst.aggregate->enumeration.constants = 0;
    795                 } else {
    796                         assert( newnode->type->aggInst.aggregate->kind == TypeData::Aggregate );
    797                         delete newnode->type->aggInst.aggregate->aggregate.fields;
    798                         newnode->type->aggInst.aggregate->aggregate.fields = 0;
    799                 } // if
    800         } // if
    801         newnode->type->forall = maybeClone( type->forall );
    802         assert( storageClass == NoStorageClass );
    803         newnode->copyStorageClasses( this );
    804         newnode->name = assign_strptr( newName );
    805         return newnode;
    806 }
    807 
    808 DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
    809         if ( o ) {
    810                 o->copyStorageClasses( this );
    811                 if ( type ) {
    812                         TypeData *srcType = type;
    813                         while ( srcType->base ) {
    814                                 srcType = srcType->base;
    815                         } // while
    816                         TypeData *newType = srcType->clone();
    817                         if ( newType->kind == TypeData::AggregateInst ) {
    818                                 // don't duplicate members
    819                                 if ( newType->aggInst.aggregate->kind == TypeData::Enum ) {
    820                                         delete newType->aggInst.aggregate->enumeration.constants;
    821                                         newType->aggInst.aggregate->enumeration.constants = 0;
    822                                 } else {
    823                                         assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
    824                                         delete newType->aggInst.aggregate->aggregate.fields;
    825                                         newType->aggInst.aggregate->aggregate.fields = 0;
    826                                 } // if
    827                         } // if
    828                         newType->forall = maybeClone( type->forall );
    829                         if ( ! o->type ) {
    830                                 o->type = newType;
    831                         } else {
    832                                 addTypeToType( newType, o->type );
    833                                 delete newType;
    834                         } // if
    835                 } // if
    836         } // if
    837         return o;
    838 }
    839 
    840 DeclarationNode *DeclarationNode::cloneType( string *newName ) {
    841         DeclarationNode *newnode = new DeclarationNode;
     799DeclarationNode * DeclarationNode::cloneType( string * newName ) {
     800        DeclarationNode * newnode = new DeclarationNode;
    842801        newnode->type = maybeClone( type );
    843802        assert( storageClass == NoStorageClass );
    844803        newnode->copyStorageClasses( this );
    845         newnode->name = assign_strptr( newName );
    846         return newnode;
    847 }
    848 
    849 DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
    850         if ( o ) {
    851                 assert( storageClass == NoStorageClass );
    852                 o->copyStorageClasses( this );
    853                 if ( type ) {
    854                         TypeData *newType = type->clone();
    855                         if ( ! o->type ) {
    856                                 o->type = newType;
     804        assert( newName );
     805        newnode->name = newName;
     806        return newnode;
     807}
     808
     809DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) {
     810        if ( ! o ) return nullptr;
     811
     812        o->copyStorageClasses( this );
     813        if ( type ) {
     814                TypeData * srcType = type;
     815
     816                while ( srcType->base ) {
     817                        srcType = srcType->base;
     818                } // while
     819
     820                TypeData * newType = srcType->clone();
     821                if ( newType->kind == TypeData::AggregateInst ) {
     822                        // don't duplicate members
     823                        if ( newType->aggInst.aggregate->kind == TypeData::Enum ) {
     824                                delete newType->aggInst.aggregate->enumeration.constants;
     825                                newType->aggInst.aggregate->enumeration.constants = nullptr;
    857826                        } else {
    858                                 addTypeToType( newType, o->type );
    859                                 delete newType;
     827                                assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
     828                                delete newType->aggInst.aggregate->aggregate.fields;
     829                                newType->aggInst.aggregate->aggregate.fields = nullptr;
    860830                        } // if
    861831                } // if
    862         } // if
    863         delete o;
     832
     833                newType->forall = maybeClone( type->forall );
     834                if ( ! o->type ) {
     835                        o->type = newType;
     836                } else {
     837                        addTypeToType( newType, o->type );
     838                        delete newType;
     839                } // if
     840        } // if
    864841        return o;
    865842}
    866843
    867 DeclarationNode *DeclarationNode::extractAggregate() const {
     844DeclarationNode * DeclarationNode::extractAggregate() const {
    868845        if ( type ) {
    869                 TypeData *ret = typeextractAggregate( type );
     846                TypeData * ret = typeextractAggregate( type );
    870847                if ( ret ) {
    871                         DeclarationNode *newnode = new DeclarationNode;
     848                        DeclarationNode * newnode = new DeclarationNode;
    872849                        newnode->type = ret;
    873850                        return newnode;
    874851                } // if
    875852        } // if
    876         return 0;
    877 }
    878 
    879 void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) {
     853        return nullptr;
     854}
     855
     856void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList ) {
    880857        SemanticError errors;
    881858        std::back_insert_iterator< std::list< Declaration * > > out( outputList );
    882         const DeclarationNode *cur = firstNode;
     859        const DeclarationNode * cur = firstNode;
     860
    883861        while ( cur ) {
    884862                try {
    885                         if ( DeclarationNode *extr = cur->extractAggregate() ) {
     863                        if ( DeclarationNode * extr = cur->extractAggregate() ) {
    886864                                // handle the case where a structure declaration is contained within an object or type declaration
    887                                 Declaration *decl = extr->build();
     865                                Declaration * decl = extr->build();
    888866                                if ( decl ) {
    889                                         *out++ = decl;
     867                                        * out++ = decl;
    890868                                } // if
    891869                                delete extr;
    892870                        } // if
    893                         Declaration *decl = cur->build();
     871
     872                        Declaration * decl = cur->build();
    894873                        if ( decl ) {
    895                                 *out++ = decl;
     874                                * out++ = decl;
    896875                        } // if
    897876                } catch( SemanticError &e ) {
     
    900879                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
    901880        } // while
     881
    902882        if ( ! errors.isEmpty() ) {
    903883                throw errors;
    904884        } // if
    905 }
    906 
    907 void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ) {
     885} // buildList
     886
     887void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {
    908888        SemanticError errors;
    909889        std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
    910         const DeclarationNode *cur = firstNode;
     890        const DeclarationNode * cur = firstNode;
    911891        while ( cur ) {
    912892                try {
    913                         Declaration *decl = cur->build();
     893                        Declaration * decl = cur->build();
    914894                        if ( decl ) {
    915                                 if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
    916                                         *out++ = dwt;
    917                                 } else if ( StructDecl *agg = dynamic_cast< StructDecl * >( decl ) ) {
    918                                         StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
    919                                         *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
     895                                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
     896                                        * out++ = dwt;
     897                                } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
     898                                        StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
     899                                        * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
    920900                                        delete agg;
    921                                 } else if ( UnionDecl *agg = dynamic_cast< UnionDecl * >( decl ) ) {
    922                                         UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
    923                                         *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
     901                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
     902                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
     903                                        * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
    924904                                } // if
    925905                        } // if
     
    932912                throw errors;
    933913        } // if
    934 }
    935 
    936 void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ) {
     914} // buildList
     915
     916void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ) {
    937917        SemanticError errors;
    938918        std::back_insert_iterator< std::list< Type * > > out( outputList );
    939         const DeclarationNode *cur = firstNode;
     919        const DeclarationNode * cur = firstNode;
     920
    940921        while ( cur ) {
    941922                try {
    942                         *out++ = cur->buildType();
     923                        * out++ = cur->buildType();
    943924                } catch( SemanticError &e ) {
    944925                        errors.append( e );
     
    946927                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
    947928        } // while
     929
    948930        if ( ! errors.isEmpty() ) {
    949931                throw errors;
    950932        } // if
    951 }
    952 
    953 Declaration *DeclarationNode::build() const {
     933} // buildTypeList
     934
     935Declaration * DeclarationNode::build() const {
    954936        if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this );
     937
     938//      if ( variable.name ) {
     939        if ( variable.tyClass != NoTypeClass ) {
     940                static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
     941//              TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
     942                TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
     943                buildList( variable.assertions, ret->get_assertions() );
     944                return ret;
     945        } // if
     946
    955947        if ( type ) {
    956                 if ( type->kind == TypeData::Variable ) {
    957                         static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
    958                         TypeDecl * ret = new TypeDecl( variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ variable.tyClass ] );
    959                         buildList( variable.assertions, ret->get_assertions() );
    960                         return ret;
    961                 } else {
    962                         return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
    963                 } // if
    964         } // if
     948                return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
     949        } // if
     950
    965951        if ( ! isInline && ! isNoreturn ) {
    966                 return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
    967         } // if
     952                assertf( name, "ObjectDecl are assumed to have names\n" );
     953                return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
     954        } // if
     955
    968956        throw SemanticError( "invalid function specifier ", this );
    969957}
    970958
    971 Type *DeclarationNode::buildType() const {
     959Type * DeclarationNode::buildType() const {
    972960        assert( type );
     961
     962        if ( attr.expr ) {
     963//              return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
     964                return new AttrType( buildQualifiers( type ), *name, attr.expr->build() );
     965        } else if ( attr.type ) {
     966//              return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
     967                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType() );
     968        } // if
    973969
    974970        switch ( type->kind ) {
    975971          case TypeData::Enum:
    976                 return new EnumInstType( buildQualifiers( type ), type->enumeration.name );
     972                return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
    977973          case TypeData::Aggregate: {
    978                   ReferenceToType *ret;
     974                  ReferenceToType * ret;
    979975                  switch ( type->aggregate.kind ) {
    980976                        case DeclarationNode::Struct:
    981                           ret = new StructInstType( buildQualifiers( type ), type->aggregate.name );
     977                          ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
    982978                          break;
    983979                        case DeclarationNode::Union:
    984                           ret = new UnionInstType( buildQualifiers( type ), type->aggregate.name );
     980                          ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
    985981                          break;
    986982                        case DeclarationNode::Trait:
    987                           ret = new TraitInstType( buildQualifiers( type ), type->aggregate.name );
     983                          ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
    988984                          break;
    989985                        default:
     
    994990          }
    995991          case TypeData::Symbolic: {
    996                   TypeInstType *ret = new TypeInstType( buildQualifiers( type ), type->symbolic.name, false );
     992                  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false );
    997993                  buildList( type->symbolic.actuals, ret->get_parameters() );
    998                   return ret;
    999           }
    1000           case TypeData::Attr: {
    1001                   assert( type->kind == TypeData::Attr );
    1002                   // assert( type->attr );
    1003                   AttrType * ret;
    1004                   if ( attr.expr ) {
    1005                           ret = new AttrType( buildQualifiers( type ), attr.name, attr.expr->build() );
    1006                   } else {
    1007                           assert( attr.type );
    1008                           ret = new AttrType( buildQualifiers( type ), attr.name, attr.type->buildType() );
    1009                   } // if
    1010994                  return ret;
    1011995          }
  • src/Parser/ExpressionNode.cc

    rac9ca96 r7756647  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 25 21:39:40 2016
    13 // Update Count     : 503
     12// Last Modified On : Fri Sep 16 16:27:44 2016
     13// Update Count     : 508
    1414//
    1515
     
    3131
    3232using namespace std;
    33 
    34 ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.get_name() ), extension( other.extension ) {}
    3533
    3634//##############################################################################
  • src/Parser/InitializerNode.cc

    rac9ca96 r7756647  
    1010// Created On       : Sat May 16 13:20:24 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 15 18:27:02 2016
    13 // Update Count     : 20
     12// Last Modified On : Sat Oct  1 23:09:51 2016
     13// Update Count     : 21
    1414//
    1515
     
    2323
    2424InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des )
    25         : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
     25                : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
    2626        if ( aggrp )
    2727                kids = dynamic_cast< InitializerNode * >( get_next() );
     
    3232
    3333InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des )
    34         : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
     34                : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
    3535        if ( init != 0 )
    3636                set_last( init );
     
    7979
    8080Initializer *InitializerNode::build() const {
    81         // if ( get_expression() == 0 ) return 0;  // XXX (?)
    82 
    8381        if ( aggregate ) {
    84                 //assert( next_init() != 0 );
    85 
    8682                std::list< Initializer * > initlist;
    8783                buildList< Initializer, InitializerNode >( next_init(), initlist );
  • src/Parser/LinkageSpec.cc

    rac9ca96 r7756647  
    1010// Created On       : Sat May 16 13:22:09 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Aug 21 12:32:53 2016
    13 // Update Count     : 17
     12// Last Modified On : Sun Oct  2 23:16:21 2016
     13// Update Count     : 23
    1414//
    1515
     
    1717#include <string>
    1818#include <cassert>
     19using namespace std;
    1920
    2021#include "LinkageSpec.h"
    2122#include "Common/SemanticError.h"
    2223
    23 LinkageSpec::Spec LinkageSpec::fromString( const std::string &spec ) {
    24         std::unique_ptr<const std::string> guard(&spec);                // allocated by lexer
    25         if ( spec == "\"Cforall\"" ) {
     24LinkageSpec::Spec LinkageSpec::linkageCheck( const string * spec ) {
     25        unique_ptr<const string> guard( spec ); // allocated by lexer
     26        if ( *spec == "\"Cforall\"" ) {
    2627                return Cforall;
    27         } else if ( spec == "\"C\"" ) {
     28        } else if ( *spec == "\"C\"" ) {
    2829                return C;
    2930        } else {
    30                 throw SemanticError( "Invalid linkage specifier " + spec );
     31                throw SemanticError( "Invalid linkage specifier " + *spec );
    3132        } // if
    3233}
    3334
    34 std::string LinkageSpec::toString( LinkageSpec::Spec linkage ) {
    35         assert( linkage >= 0 && linkage < LinkageSpec::NoOfSpecs );
     35string LinkageSpec::linkageName( LinkageSpec::Spec linkage ) {
     36        assert( 0 <= linkage && linkage < LinkageSpec::NoOfSpecs );
    3637        static const char *linkageKinds[LinkageSpec::NoOfSpecs] = {
    3738                "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in",
     
    4142
    4243bool LinkageSpec::isDecoratable( Spec spec ) {
    43         assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
     44        assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
    4445        static bool decoratable[LinkageSpec::NoOfSpecs] = {
    4546                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
     
    5051
    5152bool LinkageSpec::isGeneratable( Spec spec ) {
    52         assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
     53        assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs );
    5354        static bool generatable[LinkageSpec::NoOfSpecs] = {
    5455                //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
  • src/Parser/LinkageSpec.h

    rac9ca96 r7756647  
    1010// Created On       : Sat May 16 13:24:28 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 20 19:22:23 2016
    13 // Update Count     : 8
     12// Last Modified On : Sat Oct  1 23:03:17 2016
     13// Update Count     : 11
    1414//
    1515
     
    2929        };
    3030 
    31         static Spec fromString( const std::string & );
    32         static std::string toString( Spec );
     31        static Spec linkageCheck( const std::string * );
     32        static std::string linkageName( Spec );
    3333 
    3434        static bool isDecoratable( Spec );
  • src/Parser/ParseNode.cc

    rac9ca96 r7756647  
    1010// Created On       : Sat May 16 13:26:29 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 17 23:14:16 2016
    13 // Update Count     : 126
     12// Last Modified On : Sat Oct  1 23:10:43 2016
     13// Update Count     : 127
    1414//
    1515
     
    2020
    2121std::ostream & operator<<( std::ostream & out, const ParseNode * node ) {
    22   node->print( out );
    23   return out;
     22        node->print( out );
     23        return out;
    2424}
    2525
  • src/Parser/ParseNode.h

    rac9ca96 r7756647  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 12 08:00:05 2016
    13 // Update Count     : 603
     12// Last Modified On : Mon Oct  3 18:03:08 2016
     13// Update Count     : 636
    1414//
    1515
     
    4141  public:
    4242        ParseNode() {};
    43         ParseNode( const std::string * name ) : name( * name ) { assert( false ); delete name; }
    44         ParseNode( const std::string &name ) : name( name ) { assert( false ); }
    45         virtual ~ParseNode() { delete next; };
     43        virtual ~ParseNode() { delete next; delete name; };
    4644        virtual ParseNode * clone() const = 0;
    4745
    4846        ParseNode * get_next() const { return next; }
    4947        ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
     48
    5049        ParseNode * get_last() {
    5150                ParseNode * current;
    52                 for ( current = this; current->get_next() != 0; current = current->get_next() );
     51                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
    5352                return current;
    5453        }
    5554        ParseNode * set_last( ParseNode * newlast ) {
    56                 if ( newlast != 0 ) get_last()->set_next( newlast );
     55                if ( newlast != nullptr ) get_last()->set_next( newlast );
    5756                return this;
    5857        }
    59 
    60         const std::string &get_name() const { return name; }
    61         void set_name( const std::string &newValue ) { name = newValue; }
    6258
    6359        virtual void print( std::ostream &os, int indent = 0 ) const {}
    6460        virtual void printList( std::ostream &os, int indent = 0 ) const {}
    65   private:
     61
    6662        static int indent_by;
    6763
    6864        ParseNode * next = nullptr;
    69         std::string name;
     65        std::string * name = nullptr;
    7066}; // ParseNode
    7167
     
    7470class InitializerNode : public ParseNode {
    7571  public:
    76         InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = 0 );
    77         InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0 );
     72        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
     73        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
    7874        ~InitializerNode();
    7975        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
     
    106102  public:
    107103        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
    108         ExpressionNode( Expression * expr, const std::string * name ) : ParseNode( name ), expr( expr ) {}
    109104        ExpressionNode( const ExpressionNode &other );
    110105        virtual ~ExpressionNode() {}
     
    183178Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
    184179Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
    185 Expression * build_tuple( ExpressionNode * expr_node = 0 );
     180Expression * build_tuple( ExpressionNode * expr_node = nullptr );
    186181Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
    187182Expression * build_range( ExpressionNode * low, ExpressionNode * high );
     
    203198        enum Signedness { Signed, Unsigned, NoSignedness };
    204199        enum Length { Short, Long, LongLong, NoLength };
    205         enum Aggregate { Struct, Union, Trait };
    206         enum TypeClass { Otype, Dtype, Ftype };
     200        enum Aggregate { Struct, Union, Trait, NoAggregate };
     201        enum TypeClass { Otype, Dtype, Ftype, NoTypeClass };
    207202        enum BuiltinType { Valist };
    208203
     
    219214        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
    220215        static DeclarationNode * newQualifier( Qualifier );
    221         static DeclarationNode * newForall( DeclarationNode *);
     216        static DeclarationNode * newForall( DeclarationNode * );
    222217        static DeclarationNode * newStorageClass( StorageClass );
    223218        static DeclarationNode * newBasicType( BasicType );
     
    226221        static DeclarationNode * newLength( Length lnth );
    227222        static DeclarationNode * newBuiltinType( BuiltinType );
    228         static DeclarationNode * newFromTypedef( std::string *);
     223        static DeclarationNode * newFromTypedef( std::string * );
    229224        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
    230225        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
    231226        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
    232         static DeclarationNode * newName( std::string *);
     227        static DeclarationNode * newName( std::string * );
    233228        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
    234         static DeclarationNode * newTypeParam( TypeClass, std::string *);
    235         static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts );
    236         static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params );
     229        static DeclarationNode * newTypeParam( TypeClass, std::string * );
     230        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
     231        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
    237232        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
    238233        static DeclarationNode * newPointer( DeclarationNode * qualifiers );
     
    249244        DeclarationNode * clone() const;
    250245
    251         DeclarationNode * addQualifiers( DeclarationNode *);
     246        DeclarationNode * addQualifiers( DeclarationNode * );
    252247        void checkQualifiers( const TypeData *, const TypeData * );
    253         void checkStorageClasses( DeclarationNode *q );
    254         DeclarationNode * copyStorageClasses( DeclarationNode *);
    255         DeclarationNode * addType( DeclarationNode *);
     248        void checkStorageClasses( DeclarationNode * );
     249        DeclarationNode * copyStorageClasses( DeclarationNode * );
     250        DeclarationNode * addType( DeclarationNode * );
    256251        DeclarationNode * addTypedef();
    257         DeclarationNode * addAssertions( DeclarationNode *);
    258         DeclarationNode * addName( std::string *);
     252        DeclarationNode * addAssertions( DeclarationNode * );
     253        DeclarationNode * addName( std::string * );
    259254        DeclarationNode * addBitfield( ExpressionNode * size );
    260255        DeclarationNode * addVarArgs();
     
    270265
    271266        DeclarationNode * cloneType( std::string * newName );
    272         DeclarationNode * cloneType( DeclarationNode * existing );
    273         DeclarationNode * cloneType( int ) { return cloneType( ( std::string *)0 ); }
    274         DeclarationNode * cloneBaseType( std::string * newName );
    275267        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
    276268
     
    286278
    287279        bool get_hasEllipsis() const;
    288         const std::string &get_name() const { return name; }
    289280        LinkageSpec::Spec get_linkage() const { return linkage; }
    290281        DeclarationNode * extractAggregate() const;
     
    295286        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
    296287  public:
    297         // StorageClass buildStorageClass() const;
    298         // bool buildFuncSpecifier( StorageClass key ) const;
    299 
    300288        struct Variable_t {
     289//              const std::string * name;
    301290                DeclarationNode::TypeClass tyClass;
    302                 std::string name;
    303291                DeclarationNode * assertions;
    304292        };
     
    306294
    307295        struct Attr_t {
    308                 std::string name;
     296//              const std::string * name;
    309297                ExpressionNode * expr;
    310298                DeclarationNode * type;
     
    315303
    316304        TypeData * type;
    317         std::string name;
    318305        StorageClass storageClass;
    319306        bool isInline, isNoreturn;
     
    331318
    332319Type * buildType( TypeData * type );
    333 //Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers );
    334320
    335321static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
     
    393379Statement * build_finally( StatementNode * stmt );
    394380Statement * build_compound( StatementNode * first );
    395 Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0 );
     381Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
    396382
    397383//##############################################################################
  • src/Parser/TypeData.cc

    rac9ca96 r7756647  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 12 21:11:22 2016
    13 // Update Count     : 377
     12// Last Modified On : Sat Sep 24 11:14:26 2016
     13// Update Count     : 415
    1414//
    1515
     
    2424#include "SynTree/Statement.h"
    2525#include "SynTree/Initializer.h"
    26 
    27 TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) {
     26using namespace std;
     27
     28TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) {
    2829        switch ( kind ) {
    2930          case Unknown:
     
    3738          case Array:
    3839                // array = new Array_t;
    39                 array.dimension = 0;
     40                array.dimension = nullptr;
    4041                array.isVarLen = false;
    4142                array.isStatic = false;
     
    4344          case Function:
    4445                // function = new Function_t;
    45                 function.params = 0;
    46                 function.idList = 0;
    47                 function.oldDeclList = 0;
    48                 function.body = 0;
     46                function.params = nullptr;
     47                function.idList = nullptr;
     48                function.oldDeclList = nullptr;
     49                function.body = nullptr;
    4950                function.hasBody = false;
    5051                function.newStyle = false;
     
    5253          case Aggregate:
    5354                // aggregate = new Aggregate_t;
    54                 aggregate.params = 0;
    55                 aggregate.actuals = 0;
    56                 aggregate.fields = 0;
     55                aggregate.name = nullptr;
     56                aggregate.params = nullptr;
     57                aggregate.actuals = nullptr;
     58                aggregate.fields = nullptr;
    5759                break;
    5860          case AggregateInst:
    5961                // aggInst = new AggInst_t;
    60                 aggInst.aggregate = 0;
    61                 aggInst.params = 0;
     62                aggInst.aggregate = nullptr;
     63                aggInst.params = nullptr;
    6264                break;
    6365          case Enum:
    6466                // enumeration = new Enumeration_t;
    65                 enumeration.constants = 0;
     67                enumeration.name = nullptr;
     68                enumeration.constants = nullptr;
    6669                break;
    6770          case Symbolic:
    6871          case SymbolicInst:
    6972                // symbolic = new Symbolic_t;
    70                 symbolic.params = 0;
    71                 symbolic.actuals = 0;
    72                 symbolic.assertions = 0;
    73                 break;
    74           case Variable:
    75                 // variable = new Variable_t;
    76                 // variable.tyClass = DeclarationNode::Type;
    77                 // variable.assertions = 0;
     73                symbolic.name = nullptr;
     74                symbolic.params = nullptr;
     75                symbolic.actuals = nullptr;
     76                symbolic.assertions = nullptr;
    7877                break;
    7978          case Tuple:
     
    8483                // typeexpr = new Typeof_t;
    8584                typeexpr = nullptr;
    86                 break;
    87           case Attr:
    88                 // attr = new Attr_t;
    89                 // attr.expr = nullptr;
    90                 // attr.type = nullptr;
    9185                break;
    9286          case Builtin:
     
    121115                break;
    122116          case Aggregate:
     117                delete aggregate.name;
    123118                delete aggregate.params;
    124119                delete aggregate.actuals;
     
    132127                break;
    133128          case Enum:
     129                delete enumeration.name;
    134130                delete enumeration.constants;
    135131                // delete enumeration;
     
    137133          case Symbolic:
    138134          case SymbolicInst:
     135                delete symbolic.name;
    139136                delete symbolic.params;
    140137                delete symbolic.actuals;
     
    142139                // delete symbolic;
    143140                break;
    144           case Variable:
    145                 // delete variable.assertions;
    146                 // delete variable;
    147                 break;
    148141          case Tuple:
    149142                // delete tuple->members;
     
    153146                // delete typeexpr->expr;
    154147                delete typeexpr;
    155                 break;
    156           case Attr:
    157                 // delete attr.expr;
    158                 // delete attr.type;
    159                 // delete attr;
    160148                break;
    161149          case Builtin:
     
    197185                break;
    198186          case Aggregate:
     187                newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
    199188                newtype->aggregate.params = maybeClone( aggregate.params );
    200189                newtype->aggregate.actuals = maybeClone( aggregate.actuals );
    201190                newtype->aggregate.fields = maybeClone( aggregate.fields );
    202                 newtype->aggregate.name = aggregate.name;
    203191                newtype->aggregate.kind = aggregate.kind;
    204192                newtype->aggregate.body = aggregate.body;
     
    209197                break;
    210198          case Enum:
    211                 newtype->enumeration.name = enumeration.name;
     199                newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
    212200                newtype->enumeration.constants = maybeClone( enumeration.constants );
    213201                break;
    214202          case Symbolic:
    215203          case SymbolicInst:
     204                newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr;
    216205                newtype->symbolic.params = maybeClone( symbolic.params );
    217206                newtype->symbolic.actuals = maybeClone( symbolic.actuals );
    218207                newtype->symbolic.assertions = maybeClone( symbolic.assertions );
    219208                newtype->symbolic.isTypedef = symbolic.isTypedef;
    220                 newtype->symbolic.name = symbolic.name;
    221                 break;
    222           case Variable:
    223                 assert( false );
    224                 // newtype->variable.assertions = maybeClone( variable.assertions );
    225                 // newtype->variable.name = variable.name;
    226                 // newtype->variable.tyClass = variable.tyClass;
    227209                break;
    228210          case Tuple:
     
    231213          case Typeof:
    232214                newtype->typeexpr = maybeClone( typeexpr );
    233                 break;
    234           case Attr:
    235                 assert( false );
    236                 // newtype->attr.expr = maybeClone( attr.expr );
    237                 // newtype->attr.type = maybeClone( attr.type );
    238215                break;
    239216          case Builtin:
     
    245222} // TypeData::clone
    246223
    247 void TypeData::print( std::ostream &os, int indent ) const {
    248         using std::endl;
    249         using std::string;
    250 
     224void TypeData::print( ostream &os, int indent ) const {
    251225        for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) {
    252226                if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
     
    326300                break;
    327301          case Aggregate:
    328                 os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << aggregate.name << endl;
     302                os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl;
    329303                if ( aggregate.params ) {
    330304                        os << string( indent + 2, ' ' ) << "with type parameters " << endl;
     
    363337                break;
    364338          case SymbolicInst:
    365                 os << "instance of type " << symbolic.name;
     339                os << "instance of type " << *symbolic.name;
    366340                if ( symbolic.actuals ) {
    367341                        os << " with parameters" << endl;
     
    389363                } // if
    390364                break;
    391           case Variable:
    392                 // os << DeclarationNode::typeClassName[ variable.tyClass ] << " variable ";
    393                 // if ( variable.assertions ) {
    394                 //      os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
    395                 //      variable.assertions->printList( os, indent + 4 );
    396                 //      os << string( indent + 2, ' ' );
    397                 // } // if
    398                 break;
    399365          case Tuple:
    400366                os << "tuple ";
     
    409375                        typeexpr->print( os, indent + 2 );
    410376                } // if
    411                 break;
    412           case Attr:
    413                 // os << "attribute type decl " << attr.name << " applied to ";
    414                 // if ( attr.expr ) {
    415                 //      attr.expr->print( os, indent + 2 );
    416                 // } // if
    417                 // if ( attr.type ) {
    418                 //      attr.type->print( os, indent + 2 );
    419                 // } // if
    420377                break;
    421378          case Builtin:
     
    437394                        // add dtor:  void ^?{}(T *)
    438395                        FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
    439                         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 ) );
    440                         td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, 0, false, false ) );
     396                        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 ) );
     397                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
    441398
    442399                        // add copy ctor:  void ?{}(T *, T)
    443400                        FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
    444                         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 ) );
    445                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) );
    446                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, 0, false, false ) );
     401                        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 ) );
     402                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     403                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
    447404
    448405                        // add default ctor:  void ?{}(T *)
    449406                        FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
    450                         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 ) );
    451                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, 0, false, false ) );
     407                        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 ) );
     408                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
    452409
    453410                        // add assignment operator:  T * ?=?(T *, T)
    454411                        FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
    455                         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 ) );
    456                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) );
    457                         assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) );
    458                         td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) );
     412                        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 ) );
     413                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     414                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     415                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
    459416                } // if
    460417        } // for
     
    488445          case TypeData::Builtin:
    489446                return new VarArgsType( buildQualifiers( td ) );
    490           case TypeData::Attr:
    491                 assert( false );
    492                 return buildAttr( td );
    493447          case TypeData::Symbolic:
    494448          case TypeData::Enum:
    495449          case TypeData::Aggregate:
    496           case TypeData::Variable:
    497450                assert( false );
    498451        } // switch
    499         return 0;
     452        return nullptr;
    500453} // typebuild
    501454
    502455TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
    503         TypeData * ret = 0;
     456        TypeData * ret = nullptr;
    504457
    505458        switch ( td->kind ) {
     
    551504          case DeclarationNode::Bool:
    552505                if ( td->signedness != DeclarationNode::NoSignedness ) {
    553                         throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
     506                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
    554507                } // if
    555508                if ( td->length != DeclarationNode::NoLength ) {
    556                         throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
     509                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
    557510                } // if
    558511
     
    567520
    568521                if ( td->length != DeclarationNode::NoLength ) {
    569                         throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
     522                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
    570523                } // if
    571524
     
    597550          FloatingPoint: ;
    598551                if ( td->signedness != DeclarationNode::NoSignedness ) {
    599                         throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
     552                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
    600553                } // if
    601554                if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
    602                         throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
     555                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
    603556                } // if
    604557                if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
     
    657610        switch ( td->aggregate.kind ) {
    658611          case DeclarationNode::Struct:
    659                 at = new StructDecl( td->aggregate.name );
     612                at = new StructDecl( *td->aggregate.name );
    660613                buildForall( td->aggregate.params, at->get_parameters() );
    661614                break;
    662615          case DeclarationNode::Union:
    663                 at = new UnionDecl( td->aggregate.name );
     616                at = new UnionDecl( *td->aggregate.name );
    664617                buildForall( td->aggregate.params, at->get_parameters() );
    665618                break;
    666619          case DeclarationNode::Trait:
    667                 at = new TraitDecl( td->aggregate.name );
     620                at = new TraitDecl( *td->aggregate.name );
    668621                buildList( td->aggregate.params, at->get_parameters() );
    669622                break;
     
    683636        ReferenceToType * ret;
    684637        if ( td->aggInst.aggregate->kind == TypeData::Enum ) {
    685                 ret = new EnumInstType( buildQualifiers( td ), td->aggInst.aggregate->enumeration.name );
     638                ret = new EnumInstType( buildQualifiers( td ), *td->aggInst.aggregate->enumeration.name );
    686639        } else {
    687640                assert( td->aggInst.aggregate->kind == TypeData::Aggregate );
    688641                switch ( td->aggInst.aggregate->aggregate.kind ) {
    689642                  case DeclarationNode::Struct:
    690                         ret = new StructInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
     643                        assert( td->aggInst.aggregate->aggregate.name );
     644                        ret = new StructInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
    691645                        break;
    692646                  case DeclarationNode::Union:
    693                         ret = new UnionInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
     647                        ret = new UnionInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
    694648                        break;
    695649                  case DeclarationNode::Trait:
    696                         ret = new TraitInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
     650                        ret = new TraitInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
    697651                        break;
    698652                  default:
     
    705659} // buildAggInst
    706660
    707 NamedTypeDecl * buildSymbolic( const TypeData * td, const std::string & name, DeclarationNode::StorageClass sc ) {
     661NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) {
    708662        assert( td->kind == TypeData::Symbolic );
    709663        NamedTypeDecl * ret;
     
    719673} // buildSymbolic
    720674
    721 TypeDecl * buildVariable( const TypeData * td ) {
    722         assert( false );
    723         return nullptr;
    724         // assert( td->kind == TypeData::Variable );
    725         // static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
    726 
    727         // TypeDecl * ret = new TypeDecl( td->variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable.tyClass ] );
    728         // buildList( td->variable.assertions, ret->get_assertions() );
    729         // return ret;
    730 } // buildSymbolic
    731 
    732675EnumDecl * buildEnum( const TypeData * td ) {
    733676        assert( td->kind == TypeData::Enum );
    734         EnumDecl * ret = new EnumDecl( td->enumeration.name );
     677        EnumDecl * ret = new EnumDecl( *td->enumeration.name );
    735678        buildList( td->enumeration.constants, ret->get_members() );
    736         std::list< Declaration * >::iterator members = ret->get_members().begin();
     679        list< Declaration * >::iterator members = ret->get_members().begin();
    737680        for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
    738681                if ( cur->has_enumeratorValue() ) {
    739682                        ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
    740                         member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), std::list< Expression * >() ) );
     683                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) );
    741684                } // if
    742685        } // for
     
    746689TypeInstType * buildSymbolicInst( const TypeData * td ) {
    747690        assert( td->kind == TypeData::SymbolicInst );
    748         TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic.name, false );
     691        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false );
    749692        buildList( td->symbolic.actuals, ret->get_parameters() );
    750693        buildForall( td->forall, ret->get_forall() );
     
    767710} // buildTypeof
    768711
    769 AttrType * buildAttr( const TypeData * td ) {
    770         assert( false );
    771         return nullptr;
    772         // assert( td->kind == TypeData::Attr );
    773         // // assert( td->attr );
    774         // AttrType * ret;
    775         // if ( td->attr.expr ) {
    776         //      ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.expr->build() );
    777         // } else {
    778         //      assert( td->attr.type );
    779         //      ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.type->buildType() );
    780         // } // if
    781         // return ret;
    782 } // buildAttr
    783 
    784 Declaration * buildDecl( const TypeData * td, std::string name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) {
     712Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) {
    785713        if ( td->kind == TypeData::Function ) {
    786714                FunctionDecl * decl;
     
    792720                                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn );
    793721                        } else {
    794                                 // std::list< Label > ls;
    795                                 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( std::list< Label >() ), isInline, isNoreturn );
     722                                // list< Label > ls;
     723                                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( list< Label >() ), isInline, isNoreturn );
    796724                        } // if
    797725                } else {
    798                         decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), 0, isInline, isNoreturn );
    799                 } // if
    800                 for ( DeclarationNode * cur = td->function.idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
    801                         if ( cur->get_name() != "" ) {
    802                                 decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
     726                        decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), nullptr, isInline, isNoreturn );
     727                } // if
     728                for ( DeclarationNode * cur = td->function.idList; cur != nullptr; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
     729                        if ( cur->name ) {
     730                                decl->get_oldIdents().insert( decl->get_oldIdents().end(), *cur->name );
    803731                        } // if
    804732                } // for
     
    811739        } else if ( td->kind == TypeData::Symbolic ) {
    812740                return buildSymbolic( td, name, sc );
    813         } else if ( td->kind == TypeData::Variable ) {
    814                 assert( false );
    815                 return buildVariable( td );
    816741        } else {
    817                 return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, std::list< Attribute * >(), isInline, isNoreturn );
     742                return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, list< Attribute * >(), isInline, isNoreturn );
    818743        } // if
    819         return 0;
     744        return nullptr;
    820745} // buildDecl
    821746
     
    833758                        break;
    834759                  default:
    835                         ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, 0, false, false, LinkageSpec::Cforall ) ) );
     760                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall ) ) );
    836761                } // switch
    837762        } else {
    838                 ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
     763                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
    839764        } // if
    840765        return ft;
  • src/Parser/TypeData.h

    rac9ca96 r7756647  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 12 17:15:49 2016
    13 // Update Count     : 129
     12// Last Modified On : Mon Oct  3 12:34:08 2016
     13// Update Count     : 142
    1414//
    1515
     
    2323
    2424struct TypeData {
    25         enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst,
    26                                 Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr };
     25        enum Kind { Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
     26                                SymbolicInst, Tuple, Typeof, Builtin, Unknown };
    2727
    2828        struct Aggregate_t {
    2929                DeclarationNode::Aggregate kind;
    30                 std::string name;
     30                const std::string * name;
    3131                DeclarationNode * params;
    32                 ExpressionNode  * actuals;                                              // holds actual parameters later applied to AggInst
     32                ExpressionNode * actuals;                                               // holds actual parameters later applied to AggInst
    3333                DeclarationNode * fields;
    3434                bool body;
     
    4747
    4848        struct Enumeration_t {
    49                 std::string name;
     49                const std::string * name;
    5050                DeclarationNode * constants;
    5151        };
     
    6161
    6262        struct Symbolic_t {
    63                 std::string name;
     63                const std::string * name;
    6464                bool isTypedef;                                                                 // false => TYPEGENname, true => TYPEDEFname
    6565                DeclarationNode * params;
     
    8888                DeclarationNode * tuple;
    8989                ExpressionNode * typeexpr;
    90                 // Attr_t attr;
    9190                // DeclarationNode::BuiltinType builtin;
    9291
     
    111110TupleType * buildTuple( const TypeData * );
    112111TypeofType * buildTypeof( const TypeData * );
    113 AttrType * buildAttr( const TypeData * );
    114 Declaration * buildDecl( const TypeData *, std::string, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = 0 );
     112Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = nullptr );
    115113FunctionType * buildFunction( const TypeData * );
    116114
  • src/Parser/parser.cc

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