Index: src/Common/DebugMalloc.cc =================================================================== --- src/Common/DebugMalloc.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) +++ src/Common/DebugMalloc.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -0,0 +1,71 @@ +#if 0 +#include +#include +#include + +bool recursion = false; + +static char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; + +static union { + void *addr; + unsigned char bytes[sizeof(void *)]; +}; + +struct Mallocmsg { + const char start[9]; + char addr[16]; + const char sep[3]; + char size[16]; + const char end[1]; +} mallocmsg = { + 'm', 'a', 'l', 'l', 'o', 'c', ' ', '0', 'x', + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ' ', '0', 'x', + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + '\n' +}; + +void * malloc( size_t size ) { + if ( recursion ) { write( STDERR_FILENO, "recursion\n", 10 ); abort(); } + recursion = true; + __typeof__( ::malloc ) *libc_malloc = (__typeof__( ::malloc ) *)dlsym(RTLD_NEXT, "malloc"); + addr = (void *)size; + for ( int i = 0, j = 7; i < 16; i += 2, j -= 1 ) { + mallocmsg.size[i] = hex[bytes[j] >> 4]; + mallocmsg.size[i + 1] = hex[bytes[j] & 0x0f]; + } // for + addr = libc_malloc( size ); + for ( int i = 0, j = 7; i < 16; i += 2, j -= 1 ) { + mallocmsg.addr[i] = hex[bytes[j] >> 4]; + mallocmsg.addr[i + 1] = hex[bytes[j] & 0x0f]; + } // for + write( STDERR_FILENO, &mallocmsg, sizeof(mallocmsg) ); + recursion = false; + return addr; +} + +struct Freemsg { + const char start[7]; + char addr[16]; + const char end[1]; +} freemsg = { + 'f', 'r', 'e', 'e', ' ', '0', 'x', + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + '\n' +}; + +void free( void * x ) { + if ( recursion ) { write( STDERR_FILENO, "recursion\n", 10 ); abort(); } + recursion = true; + __typeof__( ::free ) *libc_free = (__typeof__( ::free ) *)dlsym(RTLD_NEXT, "free"); + addr = x; + for ( int i = 0, j = 7; i < 16; i += 2, j -= 1 ) { + freemsg.addr[i] = hex[bytes[j] >> 4]; + freemsg.addr[i + 1] = hex[bytes[j] & 0x0f]; + } // for + write( STDERR_FILENO, &freemsg, sizeof(freemsg) ); + recursion = false; + libc_free( addr ); +} +#endif // 0 Index: src/Common/SemanticError.h =================================================================== --- src/Common/SemanticError.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Common/SemanticError.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jun 8 14:38:53 2015 -// Update Count : 4 +// Last Modified On : Sat Sep 24 15:13:42 2016 +// Update Count : 5 // @@ -46,5 +46,4 @@ } - #endif // SEMANTICERROR_H Index: src/Common/module.mk =================================================================== --- src/Common/module.mk (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Common/module.mk (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -11,9 +11,10 @@ ## Created On : Mon Jun 1 17:49:17 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Thu Aug 18 13:29:04 2016 -## Update Count : 2 +## Last Modified On : Tue Sep 27 11:06:38 2016 +## Update Count : 4 ############################################################################### SRC += Common/SemanticError.cc \ Common/UniqueName.cc \ + Common/DebugMalloc.cc \ Common/Assert.cc Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Common/utility.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jun 8 17:33:59 2016 -// Update Count : 22 +// Last Modified On : Fri Sep 23 11:46:47 2016 +// Update Count : 28 // @@ -25,4 +25,5 @@ #include #include +#include template< typename T > @@ -101,15 +102,4 @@ } // if } // for -} - -static inline std::string assign_strptr( const std::string *str ) { - if ( str == 0 ) { - return ""; - } else { - std::string tmp; - tmp = *str; - delete str; - return tmp; - } // if } @@ -141,10 +131,10 @@ template < typename T > -void toString_single ( std::ostream & os, const T & value ) { +void toString_single( std::ostream & os, const T & value ) { os << value; } template < typename T, typename... Params > -void toString_single ( std::ostream & os, const T & value, const Params & ... params ) { +void toString_single( std::ostream & os, const T & value, const Params & ... params ) { os << value; toString_single( os, params ... ); @@ -152,5 +142,5 @@ template < typename ... Params > -std::string toString ( const Params & ... params ) { +std::string toString( const Params & ... params ) { std::ostringstream os; toString_single( os, params... ); Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Makefile.am (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -11,6 +11,6 @@ ## Created On : Sun May 31 08:51:46 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Sat Aug 20 11:13:12 2016 -## Update Count : 71 +## Last Modified On : Sat Sep 24 15:03:52 2016 +## Update Count : 73 ############################################################################### @@ -40,5 +40,5 @@ cfa_cpplib_PROGRAMS = driver/cfa-cpp driver_cfa_cpp_SOURCES = ${SRC} -driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap +driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Makefile.in (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -98,4 +98,5 @@ Common/driver_cfa_cpp-SemanticError.$(OBJEXT) \ Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \ + Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) \ Common/driver_cfa_cpp-Assert.$(OBJEXT) \ ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT) \ @@ -358,5 +359,6 @@ CodeGen/CodeGenerator.cc CodeGen/GenType.cc \ CodeGen/FixNames.cc CodeGen/OperatorTable.cc \ - Common/SemanticError.cc Common/UniqueName.cc Common/Assert.cc \ + Common/SemanticError.cc Common/UniqueName.cc \ + Common/DebugMalloc.cc Common/Assert.cc \ ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \ ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \ @@ -412,5 +414,5 @@ cfa_cpplibdir = ${libdir} driver_cfa_cpp_SOURCES = ${SRC} -driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap +driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include all: $(BUILT_SOURCES) @@ -512,4 +514,6 @@ Common/$(DEPDIR)/$(am__dirstamp) Common/driver_cfa_cpp-UniqueName.$(OBJEXT): Common/$(am__dirstamp) \ + Common/$(DEPDIR)/$(am__dirstamp) +Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \ Common/$(DEPDIR)/$(am__dirstamp) Common/driver_cfa_cpp-Assert.$(OBJEXT): Common/$(am__dirstamp) \ @@ -784,4 +788,5 @@ -rm -f CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT) -rm -f Common/driver_cfa_cpp-Assert.$(OBJEXT) + -rm -f Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) -rm -f Common/driver_cfa_cpp-SemanticError.$(OBJEXT) -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT) @@ -889,4 +894,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/driver_cfa_cpp-OperatorTable.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@ @@ -1125,4 +1131,18 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-UniqueName.obj `if test -f 'Common/UniqueName.cc'; then $(CYGPATH_W) 'Common/UniqueName.cc'; else $(CYGPATH_W) '$(srcdir)/Common/UniqueName.cc'; fi` +Common/driver_cfa_cpp-DebugMalloc.o: Common/DebugMalloc.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc + +Common/driver_cfa_cpp-DebugMalloc.obj: Common/DebugMalloc.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.obj -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi` + Common/driver_cfa_cpp-Assert.o: Common/Assert.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-Assert.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo -c -o Common/driver_cfa_cpp-Assert.o `test -f 'Common/Assert.cc' || echo '$(srcdir)/'`Common/Assert.cc Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/DeclarationNode.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Sep 14 23:13:28 2016 -// Update Count : 502 +// Last Modified On : Mon Oct 3 18:03:08 2016 +// Update Count : 651 // @@ -31,13 +31,13 @@ // These must remain in the same order as the corresponding DeclarationNode enumerations. -const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" }; -const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" }; -const char *DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" }; -const char *DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" }; -const char *DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" }; -const char *DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" }; -const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" }; -const char *DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" }; -const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" }; +const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" }; +const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" }; +const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" }; +const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" }; +const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" }; +const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" }; +const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" }; +const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" }; +const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" }; UniqueName DeclarationNode::anonymous( "__anonymous" ); @@ -46,16 +46,19 @@ DeclarationNode::DeclarationNode() : - type( 0 ), + type( nullptr ), storageClass( NoStorageClass ), isInline( false ), isNoreturn( false ), - bitfieldWidth( 0 ), - initializer( 0 ), + bitfieldWidth( nullptr ), + initializer( nullptr ), hasEllipsis( false ), linkage( ::linkage ), extension( false ) { - variable.tyClass = DeclarationNode::Otype; + +// variable.name = nullptr; + variable.tyClass = NoTypeClass; variable.assertions = nullptr; +// attr.name = nullptr; attr.expr = nullptr; attr.type = nullptr; @@ -63,6 +66,11 @@ DeclarationNode::~DeclarationNode() { +// delete attr.name; delete attr.expr; delete attr.type; + +// delete variable.name; + delete variable.assertions; + delete type; delete bitfieldWidth; @@ -70,8 +78,8 @@ } -DeclarationNode *DeclarationNode::clone() const { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::clone() const { + DeclarationNode * newnode = new DeclarationNode; newnode->type = maybeClone( type ); - newnode->name = name; + newnode->name = name ? new string( *name ) : nullptr; newnode->storageClass = storageClass; newnode->isInline = isInline; @@ -83,8 +91,9 @@ newnode->linkage = linkage; +// newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr; + newnode->variable.tyClass = variable.tyClass; newnode->variable.assertions = maybeClone( variable.assertions ); - newnode->variable.name = variable.name; - newnode->variable.tyClass = variable.tyClass; - + +// newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr; newnode->attr.expr = maybeClone( attr.expr ); newnode->attr.type = maybeClone( attr.type ); @@ -98,12 +107,12 @@ void DeclarationNode::print( std::ostream &os, int indent ) const { os << string( indent, ' ' ); - if ( name == "" ) { + if ( name ) { + os << *name << ": "; + } else { os << "unnamed: "; - } else { - os << name << ": "; } // if if ( linkage != LinkageSpec::Cforall ) { - os << LinkageSpec::toString( linkage ) << " "; + os << LinkageSpec::linkageName( linkage ) << " "; } // if @@ -122,5 +131,5 @@ } // if - if ( initializer != 0 ) { + if ( initializer ) { os << endl << string( indent + 2, ' ' ) << "with initializer "; initializer->printOneLine( os ); @@ -139,13 +148,15 @@ } -DeclarationNode *DeclarationNode::newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); - +DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->name = name; newnode->type = new TypeData( TypeData::Function ); newnode->type->function.params = param; newnode->type->function.newStyle = newStyle; newnode->type->function.body = body; - typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID ); + // ignore unnamed routine declarations: void p( int (*)(int) ); + if ( newnode->name ) { + typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID ); + } // if if ( body ) { @@ -155,5 +166,5 @@ if ( ret ) { newnode->type->base = ret->type; - ret->type = 0; + ret->type = nullptr; delete ret; } // if @@ -163,5 +174,5 @@ DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData(); newnode->type->qualifiers[ q ] = 1; @@ -169,6 +180,6 @@ } // DeclarationNode::newQualifier -DeclarationNode * DeclarationNode::newForall( DeclarationNode *forall ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Unknown ); newnode->type->forall = forall; @@ -177,10 +188,5 @@ DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { - DeclarationNode *newnode = new DeclarationNode; - //switch (sc) { - // case Inline: newnode->isInline = true; break; - // case Noreturn: newnode->isNoreturn = true; break; - // default: newnode->storageClass = sc; break; - //} + DeclarationNode * newnode = new DeclarationNode; newnode->storageClass = sc; return newnode; @@ -188,5 +194,5 @@ DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); newnode->type->basictype = bt; @@ -195,5 +201,5 @@ DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); newnode->type->complextype = ct; @@ -202,5 +208,5 @@ DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); newnode->type->signedness = sn; @@ -209,5 +215,5 @@ DeclarationNode * DeclarationNode::newLength( Length lnth ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); newnode->type->length = lnth; @@ -215,20 +221,21 @@ } // DeclarationNode::newLength -DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newFromTypedef( string * name ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::SymbolicInst ); - newnode->type->symbolic.name = assign_strptr( name ); + newnode->type->symbolic.name = name; newnode->type->symbolic.isTypedef = true; - newnode->type->symbolic.params = 0; + newnode->type->symbolic.params = nullptr; return newnode; } // DeclarationNode::newFromTypedef -DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Aggregate ); newnode->type->aggregate.kind = kind; - newnode->type->aggregate.name = assign_strptr( name ); - if ( newnode->type->aggregate.name == "" ) { // anonymous aggregate ? - newnode->type->aggregate.name = anonymous.newName(); + if ( name ) { + newnode->type->aggregate.name = name; + } else { // anonymous aggregate ? + newnode->type->aggregate.name = new string( anonymous.newName() ); } // if newnode->type->aggregate.actuals = actuals; @@ -238,11 +245,11 @@ } // DeclarationNode::newAggregate -DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Enum ); - newnode->type->enumeration.name = newnode->name; - if ( newnode->type->enumeration.name == "" ) { // anonymous enumeration ? - newnode->type->enumeration.name = DeclarationNode::anonymous.newName(); + if ( name ) { + newnode->type->enumeration.name = name; + } else { // anonymous aggregate ? + newnode->type->enumeration.name = new string( anonymous.newName() ); } // if newnode->type->enumeration.constants = constants; @@ -250,22 +257,22 @@ } // DeclarationNode::newEnum -DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newEnumConstant( string * name, ExpressionNode * constant ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->name = name; newnode->enumeratorValue.reset( constant ); - typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID ); + typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID ); return newnode; } // DeclarationNode::newEnumConstant -DeclarationNode *DeclarationNode::newName( std::string *name ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newName( string * name ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->name = name; return newnode; } // DeclarationNode::newName -DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newFromTypeGen( string * name, ExpressionNode * params ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::SymbolicInst ); - newnode->type->symbolic.name = assign_strptr( name ); + newnode->type->symbolic.name = name; newnode->type->symbolic.isTypedef = false; newnode->type->symbolic.actuals = params; @@ -273,55 +280,56 @@ } // DeclarationNode::newFromTypeGen -DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); - newnode->type = new TypeData( TypeData::Variable ); +DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, string * name ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = nullptr; + assert( ! newnode->name ); +// newnode->variable.name = name; + newnode->name = name; newnode->variable.tyClass = tc; - newnode->variable.name = newnode->name; + newnode->variable.assertions = nullptr; return newnode; } // DeclarationNode::newTypeParam -DeclarationNode *DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newTrait( const string * name, DeclarationNode * params, DeclarationNode * asserts ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Aggregate ); + newnode->type->aggregate.name = name; newnode->type->aggregate.kind = Trait; newnode->type->aggregate.params = params; newnode->type->aggregate.fields = asserts; - newnode->type->aggregate.name = assign_strptr( name ); return newnode; } // DeclarationNode::newTrait -DeclarationNode *DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newTraitUse( const string * name, ExpressionNode * params ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::AggregateInst ); newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate ); newnode->type->aggInst.aggregate->aggregate.kind = Trait; - newnode->type->aggInst.aggregate->aggregate.name = assign_strptr( name ); + newnode->type->aggInst.aggregate->aggregate.name = name; newnode->type->aggInst.params = params; return newnode; } // DeclarationNode::newTraitUse -DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Symbolic ); newnode->type->symbolic.isTypedef = false; newnode->type->symbolic.params = typeParams; - newnode->type->symbolic.name = newnode->name; + newnode->type->symbolic.name = name; return newnode; } // DeclarationNode::newTypeDecl -DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Pointer ); return newnode->addQualifiers( qualifiers ); } // DeclarationNode::newPointer -DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Array ); newnode->type->array.dimension = size; newnode->type->array.isStatic = isStatic; - if ( newnode->type->array.dimension == 0 || newnode->type->array.dimension->isExpressionType() ) { + if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType() ) { newnode->type->array.isVarLen = false; } else { @@ -331,8 +339,8 @@ } // DeclarationNode::newArray -DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newVarArray( DeclarationNode * qualifiers ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Array ); - newnode->type->array.dimension = 0; + newnode->type->array.dimension = nullptr; newnode->type->array.isStatic = false; newnode->type->array.isVarLen = true; @@ -340,12 +348,12 @@ } -DeclarationNode *DeclarationNode::newBitfield( ExpressionNode *size ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newBitfield( ExpressionNode * size ) { + DeclarationNode * newnode = new DeclarationNode; newnode->bitfieldWidth = size; return newnode; } -DeclarationNode *DeclarationNode::newTuple( DeclarationNode *members ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newTuple( DeclarationNode * members ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Tuple ); newnode->type->tuple = members; @@ -353,6 +361,6 @@ } -DeclarationNode *DeclarationNode::newTypeof( ExpressionNode *expr ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Typeof ); newnode->type->typeexpr = expr; @@ -361,5 +369,5 @@ DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Builtin ); newnode->builtin = bt; @@ -367,16 +375,18 @@ } // DeclarationNode::newBuiltinType -DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Attr ); - newnode->attr.name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newAttr( string * name, ExpressionNode * expr ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = nullptr; +// newnode->attr.name = name; + newnode->name = name; newnode->attr.expr = expr; return newnode; } -DeclarationNode *DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Attr ); - newnode->attr.name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newAttr( string * name, DeclarationNode * type ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = nullptr; +// newnode->attr.name = name; + newnode->name = name; newnode->attr.type = type; return newnode; @@ -389,5 +399,5 @@ } // appendError -void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) { +void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) { TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization @@ -401,5 +411,5 @@ } // DeclarationNode::checkQualifiers -void DeclarationNode::checkStorageClasses( DeclarationNode *q ) { +void DeclarationNode::checkStorageClasses( DeclarationNode * q ) { if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) { if ( storageClass == q->storageClass ) { // duplicate qualifier @@ -413,5 +423,5 @@ } // DeclarationNode::copyStorageClasses -DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) { +DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) { isInline = isInline || q->isInline; isNoreturn = isNoreturn || q->isNoreturn; @@ -424,5 +434,5 @@ } // DeclarationNode::copyStorageClasses -static void addQualifiersToType( TypeData *&src, TypeData *dst ) { +static void addQualifiersToType( TypeData *&src, TypeData * dst ) { if ( src->forall && dst->kind == TypeData::Function ) { if ( dst->forall ) { @@ -431,5 +441,5 @@ dst->forall = src->forall; } // if - src->forall = 0; + src->forall = nullptr; } // if if ( dst->base ) { @@ -437,5 +447,5 @@ } else if ( dst->kind == TypeData::Function ) { dst->base = src; - src = 0; + src = nullptr; } else { dst->qualifiers |= src->qualifiers; @@ -443,15 +453,19 @@ } // addQualifiersToType -DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) { - if ( ! q ) return this; +DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode * q ) { + if ( ! q ) { delete q; return this; } checkStorageClasses( q ); copyStorageClasses( q ); - if ( ! q->type ) { delete q; return this; } + if ( ! q->type ) { + delete q; + return this; + } // if if ( ! type ) { -// type = new TypeData; - type = q->type; + type = q->type; // reuse this structure + q->type = nullptr; + delete q; return this; } // if @@ -467,10 +481,10 @@ type->aggregate.params = q->type->forall; // change implicit typedef from TYPEDEFname to TYPEGENname - typedefTable.changeKind( type->aggregate.name, TypedefTable::TG ); + typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG ); } else { type->forall = q->type->forall; } // if } // if - q->type->forall = 0; + q->type->forall = nullptr; } // if delete q; @@ -485,5 +499,5 @@ dst->forall = src->forall; } // if - src->forall = 0; + src->forall = nullptr; } // if if ( dst->base ) { @@ -494,5 +508,5 @@ src->qualifiers |= dst->qualifiers; dst = src; - src = 0; + src = nullptr; break; case TypeData::Basic: @@ -504,15 +518,15 @@ dst->basictype = src->basictype; } else if ( src->basictype != DeclarationNode::NoBasicType ) - throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src ); if ( dst->complextype == DeclarationNode::NoComplexType ) { dst->complextype = src->complextype; } else if ( src->complextype != DeclarationNode::NoComplexType ) - throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src ); if ( dst->signedness == DeclarationNode::NoSignedness ) { dst->signedness = src->signedness; } else if ( src->signedness != DeclarationNode::NoSignedness ) - throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src ); if ( dst->length == DeclarationNode::NoLength ) { @@ -521,5 +535,5 @@ dst->length = DeclarationNode::LongLong; } else if ( src->length != DeclarationNode::NoLength ) - throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src ); } // if break; @@ -534,5 +548,5 @@ } // if dst->base->qualifiers |= src->qualifiers; - src = 0; + src = nullptr; break; default: @@ -542,7 +556,7 @@ dst->forall = src->forall; } // if - src->forall = 0; + src->forall = nullptr; dst->base = src; - src = 0; + src = nullptr; } // switch } // switch @@ -550,5 +564,5 @@ } -DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) { +DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) { if ( o ) { checkStorageClasses( o ); @@ -566,5 +580,5 @@ type = o->type; } // if - o->type = 0; + o->type = nullptr; } else { addTypeToType( o->type, type ); @@ -584,9 +598,9 @@ } -DeclarationNode *DeclarationNode::addTypedef() { - TypeData *newtype = new TypeData( TypeData::Symbolic ); - newtype->symbolic.params = 0; +DeclarationNode * DeclarationNode::addTypedef() { + TypeData * newtype = new TypeData( TypeData::Symbolic ); + newtype->symbolic.params = nullptr; newtype->symbolic.isTypedef = true; - newtype->symbolic.name = name; + newtype->symbolic.name = name ? new string( *name ) : nullptr; newtype->base = type; type = newtype; @@ -594,5 +608,14 @@ } -DeclarationNode *DeclarationNode::addAssertions( DeclarationNode *assertions ) { +DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) { + if ( variable.tyClass != NoTypeClass ) { + if ( variable.assertions ) { + variable.assertions->appendList( assertions ); + } else { + variable.assertions = assertions; + } // if + return this; + } // if + assert( type ); switch ( type->kind ) { @@ -604,11 +627,4 @@ } // if break; - case TypeData::Variable: - if ( variable.assertions ) { - variable.assertions->appendList( assertions ); - } else { - variable.assertions = assertions; - } // if - break; default: assert( false ); @@ -618,15 +634,16 @@ } -DeclarationNode *DeclarationNode::addName( std::string *newname ) { - name = assign_strptr( newname ); - return this; -} - -DeclarationNode *DeclarationNode::addBitfield( ExpressionNode *size ) { +DeclarationNode * DeclarationNode::addName( string * newname ) { + assert( ! name ); + name = newname; + return this; +} + +DeclarationNode * DeclarationNode::addBitfield( ExpressionNode * size ) { bitfieldWidth = size; return this; } -DeclarationNode *DeclarationNode::addVarArgs() { +DeclarationNode * DeclarationNode::addVarArgs() { assert( type ); hasEllipsis = true; @@ -634,8 +651,8 @@ } -DeclarationNode *DeclarationNode::addFunctionBody( StatementNode *body ) { +DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body ) { assert( type ); assert( type->kind == TypeData::Function ); - assert( type->function.body == 0 ); + assert( ! type->function.body ); type->function.body = body; type->function.hasBody = true; @@ -643,17 +660,17 @@ } -DeclarationNode *DeclarationNode::addOldDeclList( DeclarationNode *list ) { +DeclarationNode * DeclarationNode::addOldDeclList( DeclarationNode * list ) { assert( type ); assert( type->kind == TypeData::Function ); - assert( type->function.oldDeclList == 0 ); + assert( ! type->function.oldDeclList ); type->function.oldDeclList = list; return this; } -static void setBase( TypeData *&type, TypeData *newType ) { +static void setBase( TypeData *&type, TypeData * newType ) { if ( type ) { - TypeData *prevBase = type; - TypeData *curBase = type->base; - while ( curBase != 0 ) { + TypeData * prevBase = type; + TypeData * curBase = type->base; + while ( curBase != nullptr ) { prevBase = curBase; curBase = curBase->base; @@ -665,9 +682,9 @@ } -DeclarationNode *DeclarationNode::addPointer( DeclarationNode *p ) { +DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) { if ( p ) { assert( p->type->kind == TypeData::Pointer ); setBase( type, p->type ); - p->type = 0; + p->type = nullptr; delete p; } // if @@ -675,9 +692,9 @@ } -DeclarationNode *DeclarationNode::addArray( DeclarationNode *a ) { +DeclarationNode * DeclarationNode::addArray( DeclarationNode * a ) { if ( a ) { assert( a->type->kind == TypeData::Array ); setBase( type, a->type ); - a->type = 0; + a->type = nullptr; delete a; } // if @@ -685,5 +702,5 @@ } -DeclarationNode *DeclarationNode::addNewPointer( DeclarationNode *p ) { +DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) { if ( p ) { assert( p->type->kind == TypeData::Pointer ); @@ -703,5 +720,5 @@ p->type->base = type; } // switch - type = 0; + type = nullptr; } // if delete this; @@ -712,7 +729,7 @@ } -static TypeData *findLast( TypeData *a ) { +static TypeData * findLast( TypeData * a ) { assert( a ); - TypeData *cur = a; + TypeData * cur = a; while ( cur->base ) { cur = cur->base; @@ -721,8 +738,8 @@ } -DeclarationNode *DeclarationNode::addNewArray( DeclarationNode *a ) { +DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) { if ( a ) { assert( a->type->kind == TypeData::Array ); - TypeData *lastArray = findLast( a->type ); + TypeData * lastArray = findLast( a->type ); if ( type ) { switch ( type->kind ) { @@ -739,5 +756,5 @@ lastArray->base = type; } // switch - type = 0; + type = nullptr; } // if delete this; @@ -748,6 +765,6 @@ } -DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) { - TypeData *ftype = new TypeData( TypeData::Function ); +DeclarationNode * DeclarationNode::addParamList( DeclarationNode * params ) { + TypeData * ftype = new TypeData( TypeData::Function ); ftype->function.params = params; setBase( type, ftype ); @@ -755,5 +772,5 @@ } -static TypeData *addIdListToType( TypeData *type, DeclarationNode *ids ) { +static TypeData * addIdListToType( TypeData * type, DeclarationNode * ids ) { if ( type ) { if ( type->kind != TypeData::Function ) { @@ -764,134 +781,96 @@ return type; } else { - TypeData *newtype = new TypeData( TypeData::Function ); + TypeData * newtype = new TypeData( TypeData::Function ); newtype->function.idList = ids; return newtype; } // if -} - -DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) { +} // addIdListToType + +DeclarationNode * DeclarationNode::addIdList( DeclarationNode * ids ) { type = addIdListToType( type, ids ); return this; } -DeclarationNode *DeclarationNode::addInitializer( InitializerNode *init ) { - //assert +DeclarationNode * DeclarationNode::addInitializer( InitializerNode * init ) { initializer = init; return this; } -DeclarationNode *DeclarationNode::cloneBaseType( string *newName ) { - DeclarationNode *newnode = new DeclarationNode; - TypeData *srcType = type; - while ( srcType->base ) { - srcType = srcType->base; - } // while - newnode->type = maybeClone( srcType ); - if ( newnode->type->kind == TypeData::AggregateInst ) { - // don't duplicate members - if ( newnode->type->aggInst.aggregate->kind == TypeData::Enum ) { - delete newnode->type->aggInst.aggregate->enumeration.constants; - newnode->type->aggInst.aggregate->enumeration.constants = 0; - } else { - assert( newnode->type->aggInst.aggregate->kind == TypeData::Aggregate ); - delete newnode->type->aggInst.aggregate->aggregate.fields; - newnode->type->aggInst.aggregate->aggregate.fields = 0; - } // if - } // if - newnode->type->forall = maybeClone( type->forall ); - assert( storageClass == NoStorageClass ); - newnode->copyStorageClasses( this ); - newnode->name = assign_strptr( newName ); - return newnode; -} - -DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) { - if ( o ) { - o->copyStorageClasses( this ); - if ( type ) { - TypeData *srcType = type; - while ( srcType->base ) { - srcType = srcType->base; - } // while - TypeData *newType = srcType->clone(); - if ( newType->kind == TypeData::AggregateInst ) { - // don't duplicate members - if ( newType->aggInst.aggregate->kind == TypeData::Enum ) { - delete newType->aggInst.aggregate->enumeration.constants; - newType->aggInst.aggregate->enumeration.constants = 0; - } else { - assert( newType->aggInst.aggregate->kind == TypeData::Aggregate ); - delete newType->aggInst.aggregate->aggregate.fields; - newType->aggInst.aggregate->aggregate.fields = 0; - } // if - } // if - newType->forall = maybeClone( type->forall ); - if ( ! o->type ) { - o->type = newType; - } else { - addTypeToType( newType, o->type ); - delete newType; - } // if - } // if - } // if - return o; -} - -DeclarationNode *DeclarationNode::cloneType( string *newName ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::cloneType( string * newName ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = maybeClone( type ); assert( storageClass == NoStorageClass ); newnode->copyStorageClasses( this ); - newnode->name = assign_strptr( newName ); - return newnode; -} - -DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) { - if ( o ) { - assert( storageClass == NoStorageClass ); - o->copyStorageClasses( this ); - if ( type ) { - TypeData *newType = type->clone(); - if ( ! o->type ) { - o->type = newType; + assert( newName ); + newnode->name = newName; + return newnode; +} + +DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) { + if ( ! o ) return nullptr; + + o->copyStorageClasses( this ); + if ( type ) { + TypeData * srcType = type; + + while ( srcType->base ) { + srcType = srcType->base; + } // while + + TypeData * newType = srcType->clone(); + if ( newType->kind == TypeData::AggregateInst ) { + // don't duplicate members + if ( newType->aggInst.aggregate->kind == TypeData::Enum ) { + delete newType->aggInst.aggregate->enumeration.constants; + newType->aggInst.aggregate->enumeration.constants = nullptr; } else { - addTypeToType( newType, o->type ); - delete newType; + assert( newType->aggInst.aggregate->kind == TypeData::Aggregate ); + delete newType->aggInst.aggregate->aggregate.fields; + newType->aggInst.aggregate->aggregate.fields = nullptr; } // if } // if - } // if - delete o; + + newType->forall = maybeClone( type->forall ); + if ( ! o->type ) { + o->type = newType; + } else { + addTypeToType( newType, o->type ); + delete newType; + } // if + } // if return o; } -DeclarationNode *DeclarationNode::extractAggregate() const { +DeclarationNode * DeclarationNode::extractAggregate() const { if ( type ) { - TypeData *ret = typeextractAggregate( type ); + TypeData * ret = typeextractAggregate( type ); if ( ret ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = ret; return newnode; } // if } // if - return 0; -} - -void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) { + return nullptr; +} + +void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList ) { SemanticError errors; std::back_insert_iterator< std::list< Declaration * > > out( outputList ); - const DeclarationNode *cur = firstNode; + const DeclarationNode * cur = firstNode; + while ( cur ) { try { - if ( DeclarationNode *extr = cur->extractAggregate() ) { + if ( DeclarationNode * extr = cur->extractAggregate() ) { // handle the case where a structure declaration is contained within an object or type declaration - Declaration *decl = extr->build(); + Declaration * decl = extr->build(); if ( decl ) { - *out++ = decl; + * out++ = decl; } // if delete extr; } // if - Declaration *decl = cur->build(); + + Declaration * decl = cur->build(); if ( decl ) { - *out++ = decl; + * out++ = decl; } // if } catch( SemanticError &e ) { @@ -900,26 +879,27 @@ cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); } // while + if ( ! errors.isEmpty() ) { throw errors; } // if -} - -void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ) { +} // buildList + +void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) { SemanticError errors; std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList ); - const DeclarationNode *cur = firstNode; + const DeclarationNode * cur = firstNode; while ( cur ) { try { - Declaration *decl = cur->build(); + Declaration * decl = cur->build(); if ( decl ) { - if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { - *out++ = dwt; - } else if ( StructDecl *agg = dynamic_cast< StructDecl * >( decl ) ) { - StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() ); - *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 ); + if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { + * out++ = dwt; + } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) { + StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() ); + * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr ); delete agg; - } else if ( UnionDecl *agg = dynamic_cast< UnionDecl * >( decl ) ) { - UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() ); - *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 ); + } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) { + UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() ); + * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr ); } // if } // if @@ -932,13 +912,14 @@ throw errors; } // if -} - -void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ) { +} // buildList + +void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ) { SemanticError errors; std::back_insert_iterator< std::list< Type * > > out( outputList ); - const DeclarationNode *cur = firstNode; + const DeclarationNode * cur = firstNode; + while ( cur ) { try { - *out++ = cur->buildType(); + * out++ = cur->buildType(); } catch( SemanticError &e ) { errors.append( e ); @@ -946,44 +927,59 @@ cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); } // while + if ( ! errors.isEmpty() ) { throw errors; } // if -} - -Declaration *DeclarationNode::build() const { +} // buildTypeList + +Declaration * DeclarationNode::build() const { if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this ); + +// if ( variable.name ) { + if ( variable.tyClass != NoTypeClass ) { + static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; +// TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] ); + TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] ); + buildList( variable.assertions, ret->get_assertions() ); + return ret; + } // if + if ( type ) { - if ( type->kind == TypeData::Variable ) { - static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; - TypeDecl * ret = new TypeDecl( variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ variable.tyClass ] ); - buildList( variable.assertions, ret->get_assertions() ); - return ret; - } else { - return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension ); - } // if - } // if + return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension ); + } // if + if ( ! isInline && ! isNoreturn ) { - return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension ); - } // if + assertf( name, "ObjectDecl are assumed to have names\n" ); + return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_extension( extension ); + } // if + throw SemanticError( "invalid function specifier ", this ); } -Type *DeclarationNode::buildType() const { +Type * DeclarationNode::buildType() const { assert( type ); + + if ( attr.expr ) { +// return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() ); + return new AttrType( buildQualifiers( type ), *name, attr.expr->build() ); + } else if ( attr.type ) { +// return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() ); + return new AttrType( buildQualifiers( type ), *name, attr.type->buildType() ); + } // if switch ( type->kind ) { case TypeData::Enum: - return new EnumInstType( buildQualifiers( type ), type->enumeration.name ); + return new EnumInstType( buildQualifiers( type ), *type->enumeration.name ); case TypeData::Aggregate: { - ReferenceToType *ret; + ReferenceToType * ret; switch ( type->aggregate.kind ) { case DeclarationNode::Struct: - ret = new StructInstType( buildQualifiers( type ), type->aggregate.name ); + ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name ); break; case DeclarationNode::Union: - ret = new UnionInstType( buildQualifiers( type ), type->aggregate.name ); + ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name ); break; case DeclarationNode::Trait: - ret = new TraitInstType( buildQualifiers( type ), type->aggregate.name ); + ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name ); break; default: @@ -994,18 +990,6 @@ } case TypeData::Symbolic: { - TypeInstType *ret = new TypeInstType( buildQualifiers( type ), type->symbolic.name, false ); + TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false ); buildList( type->symbolic.actuals, ret->get_parameters() ); - return ret; - } - case TypeData::Attr: { - assert( type->kind == TypeData::Attr ); - // assert( type->attr ); - AttrType * ret; - if ( attr.expr ) { - ret = new AttrType( buildQualifiers( type ), attr.name, attr.expr->build() ); - } else { - assert( attr.type ); - ret = new AttrType( buildQualifiers( type ), attr.name, attr.type->buildType() ); - } // if return ret; } Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/ExpressionNode.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 25 21:39:40 2016 -// Update Count : 503 +// Last Modified On : Fri Sep 16 16:27:44 2016 +// Update Count : 508 // @@ -31,6 +31,4 @@ using namespace std; - -ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.get_name() ), extension( other.extension ) {} //############################################################################## Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/InitializerNode.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:20:24 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 15 18:27:02 2016 -// Update Count : 20 +// Last Modified On : Sat Oct 1 23:09:51 2016 +// Update Count : 21 // @@ -23,5 +23,5 @@ InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des ) - : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { + : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { if ( aggrp ) kids = dynamic_cast< InitializerNode * >( get_next() ); @@ -32,5 +32,5 @@ InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des ) - : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { + : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { if ( init != 0 ) set_last( init ); @@ -79,9 +79,5 @@ Initializer *InitializerNode::build() const { - // if ( get_expression() == 0 ) return 0; // XXX (?) - if ( aggregate ) { - //assert( next_init() != 0 ); - std::list< Initializer * > initlist; buildList< Initializer, InitializerNode >( next_init(), initlist ); Index: src/Parser/LinkageSpec.cc =================================================================== --- src/Parser/LinkageSpec.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/LinkageSpec.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:22:09 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Aug 21 12:32:53 2016 -// Update Count : 17 +// Last Modified On : Sun Oct 2 23:16:21 2016 +// Update Count : 23 // @@ -17,21 +17,22 @@ #include #include +using namespace std; #include "LinkageSpec.h" #include "Common/SemanticError.h" -LinkageSpec::Spec LinkageSpec::fromString( const std::string &spec ) { - std::unique_ptr guard(&spec); // allocated by lexer - if ( spec == "\"Cforall\"" ) { +LinkageSpec::Spec LinkageSpec::linkageCheck( const string * spec ) { + unique_ptr guard( spec ); // allocated by lexer + if ( *spec == "\"Cforall\"" ) { return Cforall; - } else if ( spec == "\"C\"" ) { + } else if ( *spec == "\"C\"" ) { return C; } else { - throw SemanticError( "Invalid linkage specifier " + spec ); + throw SemanticError( "Invalid linkage specifier " + *spec ); } // if } -std::string LinkageSpec::toString( LinkageSpec::Spec linkage ) { - assert( linkage >= 0 && linkage < LinkageSpec::NoOfSpecs ); +string LinkageSpec::linkageName( LinkageSpec::Spec linkage ) { + assert( 0 <= linkage && linkage < LinkageSpec::NoOfSpecs ); static const char *linkageKinds[LinkageSpec::NoOfSpecs] = { "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in", @@ -41,5 +42,5 @@ bool LinkageSpec::isDecoratable( Spec spec ) { - assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs ); + assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs ); static bool decoratable[LinkageSpec::NoOfSpecs] = { // Intrinsic, Cforall, C, AutoGen, Compiler @@ -50,5 +51,5 @@ bool LinkageSpec::isGeneratable( Spec spec ) { - assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs ); + assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs ); static bool generatable[LinkageSpec::NoOfSpecs] = { // Intrinsic, Cforall, C, AutoGen, Compiler Index: src/Parser/LinkageSpec.h =================================================================== --- src/Parser/LinkageSpec.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/LinkageSpec.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:24:28 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Aug 20 19:22:23 2016 -// Update Count : 8 +// Last Modified On : Sat Oct 1 23:03:17 2016 +// Update Count : 11 // @@ -29,6 +29,6 @@ }; - static Spec fromString( const std::string & ); - static std::string toString( Spec ); + static Spec linkageCheck( const std::string * ); + static std::string linkageName( Spec ); static bool isDecoratable( Spec ); Index: src/Parser/ParseNode.cc =================================================================== --- src/Parser/ParseNode.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/ParseNode.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:26:29 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Aug 17 23:14:16 2016 -// Update Count : 126 +// Last Modified On : Sat Oct 1 23:10:43 2016 +// Update Count : 127 // @@ -20,6 +20,6 @@ std::ostream & operator<<( std::ostream & out, const ParseNode * node ) { - node->print( out ); - return out; + node->print( out ); + return out; } Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/ParseNode.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 12 08:00:05 2016 -// Update Count : 603 +// Last Modified On : Mon Oct 3 18:03:08 2016 +// Update Count : 636 // @@ -41,31 +41,27 @@ public: ParseNode() {}; - ParseNode( const std::string * name ) : name( * name ) { assert( false ); delete name; } - ParseNode( const std::string &name ) : name( name ) { assert( false ); } - virtual ~ParseNode() { delete next; }; + virtual ~ParseNode() { delete next; delete name; }; virtual ParseNode * clone() const = 0; ParseNode * get_next() const { return next; } ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; } + ParseNode * get_last() { ParseNode * current; - for ( current = this; current->get_next() != 0; current = current->get_next() ); + for ( current = this; current->get_next() != nullptr; current = current->get_next() ); return current; } ParseNode * set_last( ParseNode * newlast ) { - if ( newlast != 0 ) get_last()->set_next( newlast ); + if ( newlast != nullptr ) get_last()->set_next( newlast ); return this; } - - const std::string &get_name() const { return name; } - void set_name( const std::string &newValue ) { name = newValue; } virtual void print( std::ostream &os, int indent = 0 ) const {} virtual void printList( std::ostream &os, int indent = 0 ) const {} - private: + static int indent_by; ParseNode * next = nullptr; - std::string name; + std::string * name = nullptr; }; // ParseNode @@ -74,6 +70,6 @@ class InitializerNode : public ParseNode { public: - InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = 0 ); - InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0 ); + InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr ); + InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr ); ~InitializerNode(); virtual InitializerNode * clone() const { assert( false ); return nullptr; } @@ -106,5 +102,4 @@ public: ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {} - ExpressionNode( Expression * expr, const std::string * name ) : ParseNode( name ), expr( expr ) {} ExpressionNode( const ExpressionNode &other ); virtual ~ExpressionNode() {} @@ -183,5 +178,5 @@ Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ); Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ); -Expression * build_tuple( ExpressionNode * expr_node = 0 ); +Expression * build_tuple( ExpressionNode * expr_node = nullptr ); Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ); Expression * build_range( ExpressionNode * low, ExpressionNode * high ); @@ -203,6 +198,6 @@ enum Signedness { Signed, Unsigned, NoSignedness }; enum Length { Short, Long, LongLong, NoLength }; - enum Aggregate { Struct, Union, Trait }; - enum TypeClass { Otype, Dtype, Ftype }; + enum Aggregate { Struct, Union, Trait, NoAggregate }; + enum TypeClass { Otype, Dtype, Ftype, NoTypeClass }; enum BuiltinType { Valist }; @@ -219,5 +214,5 @@ static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false ); static DeclarationNode * newQualifier( Qualifier ); - static DeclarationNode * newForall( DeclarationNode *); + static DeclarationNode * newForall( DeclarationNode * ); static DeclarationNode * newStorageClass( StorageClass ); static DeclarationNode * newBasicType( BasicType ); @@ -226,13 +221,13 @@ static DeclarationNode * newLength( Length lnth ); static DeclarationNode * newBuiltinType( BuiltinType ); - static DeclarationNode * newFromTypedef( std::string *); + static DeclarationNode * newFromTypedef( std::string * ); static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants ); static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant ); - static DeclarationNode * newName( std::string *); + static DeclarationNode * newName( std::string * ); static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params ); - static DeclarationNode * newTypeParam( TypeClass, std::string *); - static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts ); - static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params ); + static DeclarationNode * newTypeParam( TypeClass, std::string * ); + static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts ); + static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params ); static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams ); static DeclarationNode * newPointer( DeclarationNode * qualifiers ); @@ -249,12 +244,12 @@ DeclarationNode * clone() const; - DeclarationNode * addQualifiers( DeclarationNode *); + DeclarationNode * addQualifiers( DeclarationNode * ); void checkQualifiers( const TypeData *, const TypeData * ); - void checkStorageClasses( DeclarationNode *q ); - DeclarationNode * copyStorageClasses( DeclarationNode *); - DeclarationNode * addType( DeclarationNode *); + void checkStorageClasses( DeclarationNode * ); + DeclarationNode * copyStorageClasses( DeclarationNode * ); + DeclarationNode * addType( DeclarationNode * ); DeclarationNode * addTypedef(); - DeclarationNode * addAssertions( DeclarationNode *); - DeclarationNode * addName( std::string *); + DeclarationNode * addAssertions( DeclarationNode * ); + DeclarationNode * addName( std::string * ); DeclarationNode * addBitfield( ExpressionNode * size ); DeclarationNode * addVarArgs(); @@ -270,7 +265,4 @@ DeclarationNode * cloneType( std::string * newName ); - DeclarationNode * cloneType( DeclarationNode * existing ); - DeclarationNode * cloneType( int ) { return cloneType( ( std::string *)0 ); } - DeclarationNode * cloneBaseType( std::string * newName ); DeclarationNode * cloneBaseType( DeclarationNode * newdecl ); @@ -286,5 +278,4 @@ bool get_hasEllipsis() const; - const std::string &get_name() const { return name; } LinkageSpec::Spec get_linkage() const { return linkage; } DeclarationNode * extractAggregate() const; @@ -295,10 +286,7 @@ DeclarationNode * set_extension( bool exten ) { extension = exten; return this; } public: - // StorageClass buildStorageClass() const; - // bool buildFuncSpecifier( StorageClass key ) const; - struct Variable_t { +// const std::string * name; DeclarationNode::TypeClass tyClass; - std::string name; DeclarationNode * assertions; }; @@ -306,5 +294,5 @@ struct Attr_t { - std::string name; +// const std::string * name; ExpressionNode * expr; DeclarationNode * type; @@ -315,5 +303,4 @@ TypeData * type; - std::string name; StorageClass storageClass; bool isInline, isNoreturn; @@ -331,5 +318,4 @@ Type * buildType( TypeData * type ); -//Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers ); static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) { @@ -393,5 +379,5 @@ Statement * build_finally( StatementNode * stmt ); Statement * build_compound( StatementNode * first ); -Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0 ); +Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr ); //############################################################################## Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/TypeData.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 12 21:11:22 2016 -// Update Count : 377 +// Last Modified On : Sat Sep 24 11:14:26 2016 +// Update Count : 415 // @@ -24,6 +24,7 @@ #include "SynTree/Statement.h" #include "SynTree/Initializer.h" - -TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) { +using namespace std; + +TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) { switch ( kind ) { case Unknown: @@ -37,5 +38,5 @@ case Array: // array = new Array_t; - array.dimension = 0; + array.dimension = nullptr; array.isVarLen = false; array.isStatic = false; @@ -43,8 +44,8 @@ case Function: // function = new Function_t; - function.params = 0; - function.idList = 0; - function.oldDeclList = 0; - function.body = 0; + function.params = nullptr; + function.idList = nullptr; + function.oldDeclList = nullptr; + function.body = nullptr; function.hasBody = false; function.newStyle = false; @@ -52,28 +53,26 @@ case Aggregate: // aggregate = new Aggregate_t; - aggregate.params = 0; - aggregate.actuals = 0; - aggregate.fields = 0; + aggregate.name = nullptr; + aggregate.params = nullptr; + aggregate.actuals = nullptr; + aggregate.fields = nullptr; break; case AggregateInst: // aggInst = new AggInst_t; - aggInst.aggregate = 0; - aggInst.params = 0; + aggInst.aggregate = nullptr; + aggInst.params = nullptr; break; case Enum: // enumeration = new Enumeration_t; - enumeration.constants = 0; + enumeration.name = nullptr; + enumeration.constants = nullptr; break; case Symbolic: case SymbolicInst: // symbolic = new Symbolic_t; - symbolic.params = 0; - symbolic.actuals = 0; - symbolic.assertions = 0; - break; - case Variable: - // variable = new Variable_t; - // variable.tyClass = DeclarationNode::Type; - // variable.assertions = 0; + symbolic.name = nullptr; + symbolic.params = nullptr; + symbolic.actuals = nullptr; + symbolic.assertions = nullptr; break; case Tuple: @@ -84,9 +83,4 @@ // typeexpr = new Typeof_t; typeexpr = nullptr; - break; - case Attr: - // attr = new Attr_t; - // attr.expr = nullptr; - // attr.type = nullptr; break; case Builtin: @@ -121,4 +115,5 @@ break; case Aggregate: + delete aggregate.name; delete aggregate.params; delete aggregate.actuals; @@ -132,4 +127,5 @@ break; case Enum: + delete enumeration.name; delete enumeration.constants; // delete enumeration; @@ -137,4 +133,5 @@ case Symbolic: case SymbolicInst: + delete symbolic.name; delete symbolic.params; delete symbolic.actuals; @@ -142,8 +139,4 @@ // delete symbolic; break; - case Variable: - // delete variable.assertions; - // delete variable; - break; case Tuple: // delete tuple->members; @@ -153,9 +146,4 @@ // delete typeexpr->expr; delete typeexpr; - break; - case Attr: - // delete attr.expr; - // delete attr.type; - // delete attr; break; case Builtin: @@ -197,8 +185,8 @@ break; case Aggregate: + newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr; newtype->aggregate.params = maybeClone( aggregate.params ); newtype->aggregate.actuals = maybeClone( aggregate.actuals ); newtype->aggregate.fields = maybeClone( aggregate.fields ); - newtype->aggregate.name = aggregate.name; newtype->aggregate.kind = aggregate.kind; newtype->aggregate.body = aggregate.body; @@ -209,20 +197,14 @@ break; case Enum: - newtype->enumeration.name = enumeration.name; + newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr; newtype->enumeration.constants = maybeClone( enumeration.constants ); break; case Symbolic: case SymbolicInst: + newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr; newtype->symbolic.params = maybeClone( symbolic.params ); newtype->symbolic.actuals = maybeClone( symbolic.actuals ); newtype->symbolic.assertions = maybeClone( symbolic.assertions ); newtype->symbolic.isTypedef = symbolic.isTypedef; - newtype->symbolic.name = symbolic.name; - break; - case Variable: - assert( false ); - // newtype->variable.assertions = maybeClone( variable.assertions ); - // newtype->variable.name = variable.name; - // newtype->variable.tyClass = variable.tyClass; break; case Tuple: @@ -231,9 +213,4 @@ case Typeof: newtype->typeexpr = maybeClone( typeexpr ); - break; - case Attr: - assert( false ); - // newtype->attr.expr = maybeClone( attr.expr ); - // newtype->attr.type = maybeClone( attr.type ); break; case Builtin: @@ -245,8 +222,5 @@ } // TypeData::clone -void TypeData::print( std::ostream &os, int indent ) const { - using std::endl; - using std::string; - +void TypeData::print( ostream &os, int indent ) const { for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) { if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' '; @@ -326,5 +300,5 @@ break; case Aggregate: - os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << aggregate.name << endl; + os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl; if ( aggregate.params ) { os << string( indent + 2, ' ' ) << "with type parameters " << endl; @@ -363,5 +337,5 @@ break; case SymbolicInst: - os << "instance of type " << symbolic.name; + os << "instance of type " << *symbolic.name; if ( symbolic.actuals ) { os << " with parameters" << endl; @@ -389,12 +363,4 @@ } // if break; - case Variable: - // os << DeclarationNode::typeClassName[ variable.tyClass ] << " variable "; - // if ( variable.assertions ) { - // os << endl << string( indent + 2, ' ' ) << "with assertions" << endl; - // variable.assertions->printList( os, indent + 4 ); - // os << string( indent + 2, ' ' ); - // } // if - break; case Tuple: os << "tuple "; @@ -409,13 +375,4 @@ typeexpr->print( os, indent + 2 ); } // if - break; - case Attr: - // os << "attribute type decl " << attr.name << " applied to "; - // if ( attr.expr ) { - // attr.expr->print( os, indent + 2 ); - // } // if - // if ( attr.type ) { - // attr.type->print( os, indent + 2 ); - // } // if break; case Builtin: @@ -437,24 +394,24 @@ // add dtor: void ^?{}(T *) FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false ); - dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) ); - td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, 0, false, false ) ); + dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) ); // add copy ctor: void ?{}(T *, T) FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false ); - copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) ); - copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) ); - td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, 0, false, false ) ); + copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) ); // add default ctor: void ?{}(T *) FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false ); - ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) ); - td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, 0, false, false ) ); + ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) ); // add assignment operator: T * ?=?(T *, T) FunctionType * assignType = new FunctionType( Type::Qualifiers(), false ); - assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) ); - assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) ); - assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) ); - td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) ); + assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) ); } // if } // for @@ -488,18 +445,14 @@ case TypeData::Builtin: return new VarArgsType( buildQualifiers( td ) ); - case TypeData::Attr: - assert( false ); - return buildAttr( td ); case TypeData::Symbolic: case TypeData::Enum: case TypeData::Aggregate: - case TypeData::Variable: assert( false ); } // switch - return 0; + return nullptr; } // typebuild TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) { - TypeData * ret = 0; + TypeData * ret = nullptr; switch ( td->kind ) { @@ -551,8 +504,8 @@ case DeclarationNode::Bool: if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); } // if if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); } // if @@ -567,5 +520,5 @@ if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); } // if @@ -597,8 +550,8 @@ FloatingPoint: ; if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); } // if if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); } // if if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) { @@ -657,13 +610,13 @@ switch ( td->aggregate.kind ) { case DeclarationNode::Struct: - at = new StructDecl( td->aggregate.name ); + at = new StructDecl( *td->aggregate.name ); buildForall( td->aggregate.params, at->get_parameters() ); break; case DeclarationNode::Union: - at = new UnionDecl( td->aggregate.name ); + at = new UnionDecl( *td->aggregate.name ); buildForall( td->aggregate.params, at->get_parameters() ); break; case DeclarationNode::Trait: - at = new TraitDecl( td->aggregate.name ); + at = new TraitDecl( *td->aggregate.name ); buildList( td->aggregate.params, at->get_parameters() ); break; @@ -683,16 +636,17 @@ ReferenceToType * ret; if ( td->aggInst.aggregate->kind == TypeData::Enum ) { - ret = new EnumInstType( buildQualifiers( td ), td->aggInst.aggregate->enumeration.name ); + ret = new EnumInstType( buildQualifiers( td ), *td->aggInst.aggregate->enumeration.name ); } else { assert( td->aggInst.aggregate->kind == TypeData::Aggregate ); switch ( td->aggInst.aggregate->aggregate.kind ) { case DeclarationNode::Struct: - ret = new StructInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); + assert( td->aggInst.aggregate->aggregate.name ); + ret = new StructInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name ); break; case DeclarationNode::Union: - ret = new UnionInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); + ret = new UnionInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name ); break; case DeclarationNode::Trait: - ret = new TraitInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); + ret = new TraitInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name ); break; default: @@ -705,5 +659,5 @@ } // buildAggInst -NamedTypeDecl * buildSymbolic( const TypeData * td, const std::string & name, DeclarationNode::StorageClass sc ) { +NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) { assert( td->kind == TypeData::Symbolic ); NamedTypeDecl * ret; @@ -719,24 +673,13 @@ } // buildSymbolic -TypeDecl * buildVariable( const TypeData * td ) { - assert( false ); - return nullptr; - // assert( td->kind == TypeData::Variable ); - // static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; - - // TypeDecl * ret = new TypeDecl( td->variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable.tyClass ] ); - // buildList( td->variable.assertions, ret->get_assertions() ); - // return ret; -} // buildSymbolic - EnumDecl * buildEnum( const TypeData * td ) { assert( td->kind == TypeData::Enum ); - EnumDecl * ret = new EnumDecl( td->enumeration.name ); + EnumDecl * ret = new EnumDecl( *td->enumeration.name ); buildList( td->enumeration.constants, ret->get_members() ); - std::list< Declaration * >::iterator members = ret->get_members().begin(); + list< Declaration * >::iterator members = ret->get_members().begin(); for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) { if ( cur->has_enumeratorValue() ) { ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members); - member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), std::list< Expression * >() ) ); + member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) ); } // if } // for @@ -746,5 +689,5 @@ TypeInstType * buildSymbolicInst( const TypeData * td ) { assert( td->kind == TypeData::SymbolicInst ); - TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic.name, false ); + TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false ); buildList( td->symbolic.actuals, ret->get_parameters() ); buildForall( td->forall, ret->get_forall() ); @@ -767,20 +710,5 @@ } // buildTypeof -AttrType * buildAttr( const TypeData * td ) { - assert( false ); - return nullptr; - // assert( td->kind == TypeData::Attr ); - // // assert( td->attr ); - // AttrType * ret; - // if ( td->attr.expr ) { - // ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.expr->build() ); - // } else { - // assert( td->attr.type ); - // ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.type->buildType() ); - // } // if - // return ret; -} // buildAttr - -Declaration * buildDecl( const TypeData * td, std::string name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) { +Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) { if ( td->kind == TypeData::Function ) { FunctionDecl * decl; @@ -792,13 +720,13 @@ decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn ); } else { - // std::list< Label > ls; - decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( std::list< Label >() ), isInline, isNoreturn ); + // list< Label > ls; + decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( list< Label >() ), isInline, isNoreturn ); } // if } else { - decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), 0, isInline, isNoreturn ); - } // if - for ( DeclarationNode * cur = td->function.idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) { - if ( cur->get_name() != "" ) { - decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() ); + decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), nullptr, isInline, isNoreturn ); + } // if + for ( DeclarationNode * cur = td->function.idList; cur != nullptr; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) { + if ( cur->name ) { + decl->get_oldIdents().insert( decl->get_oldIdents().end(), *cur->name ); } // if } // for @@ -811,11 +739,8 @@ } else if ( td->kind == TypeData::Symbolic ) { return buildSymbolic( td, name, sc ); - } else if ( td->kind == TypeData::Variable ) { - assert( false ); - return buildVariable( td ); } else { - return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, std::list< Attribute * >(), isInline, isNoreturn ); + return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, list< Attribute * >(), isInline, isNoreturn ); } // if - return 0; + return nullptr; } // buildDecl @@ -833,8 +758,8 @@ break; default: - ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, 0, false, false, LinkageSpec::Cforall ) ) ); + ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall ) ) ); } // switch } else { - ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) ); + ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); } // if return ft; Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/TypeData.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 12 17:15:49 2016 -// Update Count : 129 +// Last Modified On : Mon Oct 3 12:34:08 2016 +// Update Count : 142 // @@ -23,12 +23,12 @@ struct TypeData { - enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst, - Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr }; + enum Kind { Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic, + SymbolicInst, Tuple, Typeof, Builtin, Unknown }; struct Aggregate_t { DeclarationNode::Aggregate kind; - std::string name; + const std::string * name; DeclarationNode * params; - ExpressionNode * actuals; // holds actual parameters later applied to AggInst + ExpressionNode * actuals; // holds actual parameters later applied to AggInst DeclarationNode * fields; bool body; @@ -47,5 +47,5 @@ struct Enumeration_t { - std::string name; + const std::string * name; DeclarationNode * constants; }; @@ -61,5 +61,5 @@ struct Symbolic_t { - std::string name; + const std::string * name; bool isTypedef; // false => TYPEGENname, true => TYPEDEFname DeclarationNode * params; @@ -88,5 +88,4 @@ DeclarationNode * tuple; ExpressionNode * typeexpr; - // Attr_t attr; // DeclarationNode::BuiltinType builtin; @@ -111,6 +110,5 @@ TupleType * buildTuple( const TypeData * ); TypeofType * buildTypeof( const TypeData * ); -AttrType * buildAttr( const TypeData * ); -Declaration * buildDecl( const TypeData *, std::string, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = 0 ); +Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = nullptr ); FunctionType * buildFunction( const TypeData * ); Index: src/Parser/parser.cc =================================================================== --- src/Parser/parser.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/parser.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -82,4 +82,5 @@ #include "TypeData.h" #include "LinkageSpec.h" +using namespace std; extern DeclarationNode * parseTree; @@ -87,7 +88,7 @@ extern TypedefTable typedefTable; -std::stack< LinkageSpec::Spec > linkageStack; - -void appendStr( std::string *to, std::string *from ) { +stack< LinkageSpec::Spec > linkageStack; + +void appendStr( string *to, string *from ) { // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string. to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) ); @@ -96,5 +97,5 @@ /* Line 268 of yacc.c */ -#line 99 "Parser/parser.cc" +#line 100 "Parser/parser.cc" /* Enabling traces. */ @@ -347,5 +348,5 @@ /* Line 293 of yacc.c */ -#line 115 "parser.yy" +#line 116 "parser.yy" Token tok; @@ -367,5 +368,5 @@ /* Line 293 of yacc.c */ -#line 370 "Parser/parser.cc" +#line 371 "Parser/parser.cc" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 @@ -379,5 +380,5 @@ /* Line 343 of yacc.c */ -#line 382 "Parser/parser.cc" +#line 383 "Parser/parser.cc" #ifdef short @@ -598,14 +599,14 @@ #define YYFINAL 250 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 10863 +#define YYLAST 10888 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 133 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 241 +#define YYNNTS 242 /* YYNRULES -- Number of rules. */ -#define YYNRULES 751 +#define YYNRULES 754 /* YYNRULES -- Number of states. */ -#define YYNSTATES 1555 +#define YYNSTATES 1558 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ @@ -666,77 +667,77 @@ 17, 19, 21, 23, 25, 27, 29, 31, 33, 36, 38, 40, 44, 48, 50, 57, 62, 66, 74, 78, - 86, 89, 92, 100, 105, 107, 111, 112, 114, 116, - 120, 122, 126, 134, 138, 146, 148, 150, 152, 155, - 158, 161, 164, 167, 170, 175, 178, 183, 190, 192, - 197, 202, 204, 206, 208, 210, 212, 214, 216, 221, - 226, 228, 232, 236, 240, 242, 246, 250, 252, 256, - 260, 262, 266, 270, 274, 278, 280, 284, 288, 290, - 294, 296, 300, 302, 306, 308, 312, 314, 318, 320, - 326, 331, 337, 339, 341, 345, 348, 349, 351, 353, - 355, 357, 359, 361, 363, 365, 367, 369, 371, 373, - 375, 378, 384, 391, 399, 401, 405, 407, 411, 412, - 414, 416, 418, 420, 422, 424, 426, 428, 430, 437, - 442, 445, 453, 455, 459, 461, 464, 466, 469, 471, - 474, 477, 483, 491, 497, 507, 513, 523, 525, 529, - 531, 533, 537, 541, 544, 546, 549, 552, 553, 555, - 558, 562, 563, 565, 568, 572, 576, 581, 582, 584, - 586, 589, 595, 603, 610, 617, 622, 626, 631, 634, - 638, 641, 645, 649, 653, 657, 663, 667, 671, 676, - 678, 684, 691, 697, 704, 714, 725, 735, 746, 749, - 751, 754, 757, 760, 762, 769, 778, 789, 802, 817, - 818, 820, 821, 823, 825, 829, 834, 842, 843, 845, - 849, 851, 855, 857, 859, 861, 865, 867, 869, 871, - 875, 876, 878, 882, 887, 889, 893, 895, 897, 901, - 905, 909, 913, 917, 920, 924, 931, 935, 939, 944, - 946, 949, 952, 956, 962, 971, 979, 987, 993, 1003, - 1006, 1009, 1015, 1019, 1025, 1030, 1034, 1039, 1044, 1052, - 1056, 1060, 1064, 1068, 1073, 1080, 1082, 1084, 1086, 1088, - 1090, 1092, 1094, 1096, 1097, 1099, 1101, 1104, 1106, 1108, - 1110, 1112, 1114, 1116, 1118, 1119, 1125, 1127, 1130, 1134, - 1136, 1139, 1141, 1143, 1145, 1147, 1149, 1151, 1153, 1155, - 1157, 1159, 1161, 1163, 1165, 1167, 1169, 1171, 1173, 1175, - 1177, 1179, 1181, 1183, 1186, 1189, 1193, 1197, 1199, 1203, - 1205, 1208, 1211, 1214, 1219, 1224, 1229, 1234, 1236, 1239, - 1242, 1246, 1248, 1251, 1254, 1256, 1259, 1262, 1266, 1268, - 1271, 1274, 1276, 1278, 1283, 1286, 1287, 1294, 1302, 1305, - 1308, 1311, 1312, 1315, 1318, 1322, 1325, 1329, 1331, 1334, - 1338, 1341, 1344, 1349, 1350, 1352, 1355, 1358, 1360, 1361, - 1363, 1366, 1369, 1375, 1378, 1379, 1387, 1390, 1395, 1396, - 1399, 1400, 1402, 1404, 1406, 1412, 1418, 1424, 1426, 1432, - 1438, 1448, 1450, 1456, 1457, 1459, 1461, 1467, 1469, 1471, - 1477, 1483, 1485, 1489, 1493, 1498, 1500, 1502, 1504, 1506, - 1509, 1511, 1515, 1519, 1521, 1524, 1526, 1530, 1532, 1534, - 1536, 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1555, - 1557, 1559, 1561, 1564, 1565, 1568, 1571, 1573, 1578, 1579, - 1581, 1584, 1588, 1593, 1596, 1599, 1601, 1604, 1607, 1613, - 1619, 1627, 1634, 1636, 1639, 1642, 1646, 1648, 1651, 1654, - 1659, 1662, 1667, 1668, 1673, 1676, 1678, 1680, 1682, 1683, - 1686, 1692, 1698, 1712, 1714, 1716, 1720, 1724, 1727, 1731, - 1735, 1738, 1743, 1745, 1752, 1762, 1763, 1775, 1777, 1781, - 1785, 1789, 1791, 1793, 1799, 1802, 1808, 1809, 1811, 1813, - 1817, 1818, 1820, 1822, 1824, 1826, 1827, 1834, 1837, 1839, - 1842, 1847, 1850, 1854, 1858, 1862, 1867, 1873, 1879, 1885, - 1892, 1894, 1896, 1898, 1902, 1903, 1909, 1910, 1912, 1914, - 1917, 1924, 1926, 1930, 1931, 1933, 1938, 1940, 1942, 1944, - 1946, 1949, 1951, 1954, 1957, 1959, 1963, 1966, 1970, 1974, - 1977, 1982, 1987, 1991, 2000, 2004, 2007, 2009, 2012, 2019, - 2028, 2032, 2035, 2039, 2043, 2048, 2053, 2057, 2059, 2061, - 2063, 2068, 2075, 2079, 2082, 2086, 2090, 2095, 2100, 2104, - 2107, 2109, 2112, 2115, 2117, 2121, 2124, 2128, 2132, 2135, - 2140, 2145, 2149, 2156, 2165, 2169, 2172, 2174, 2177, 2180, - 2183, 2187, 2191, 2194, 2199, 2204, 2208, 2215, 2224, 2228, - 2231, 2233, 2236, 2239, 2241, 2243, 2246, 2250, 2254, 2257, - 2262, 2269, 2278, 2280, 2283, 2286, 2288, 2291, 2294, 2298, - 2302, 2304, 2309, 2314, 2318, 2324, 2333, 2337, 2340, 2344, - 2346, 2352, 2358, 2365, 2372, 2374, 2377, 2380, 2382, 2385, - 2388, 2392, 2396, 2398, 2403, 2408, 2412, 2418, 2427, 2431, - 2433, 2436, 2438, 2441, 2448, 2454, 2461, 2469, 2477, 2479, - 2482, 2485, 2487, 2490, 2493, 2497, 2501, 2503, 2508, 2513, - 2517, 2526, 2530, 2532, 2534, 2537, 2539, 2541, 2544, 2548, - 2551, 2555, 2558, 2562, 2566, 2569, 2574, 2578, 2581, 2585, - 2588, 2593, 2597, 2600, 2607, 2614, 2621, 2629, 2631, 2634, - 2636, 2638, 2640, 2643, 2647, 2650, 2654, 2657, 2661, 2665, - 2670, 2673, 2677, 2682, 2685, 2691, 2697, 2704, 2711, 2712, - 2714, 2715 + 82, 90, 93, 96, 104, 109, 111, 115, 116, 118, + 120, 124, 126, 130, 138, 142, 150, 152, 154, 156, + 158, 160, 163, 166, 169, 172, 175, 178, 183, 186, + 191, 198, 200, 205, 210, 212, 214, 216, 218, 220, + 222, 224, 229, 234, 236, 240, 244, 248, 250, 254, + 258, 260, 264, 268, 270, 274, 278, 282, 286, 288, + 292, 296, 298, 302, 304, 308, 310, 314, 316, 320, + 322, 326, 328, 334, 339, 345, 347, 349, 353, 356, + 357, 359, 361, 363, 365, 367, 369, 371, 373, 375, + 377, 379, 381, 383, 386, 392, 399, 407, 409, 413, + 415, 419, 420, 422, 424, 426, 428, 430, 432, 434, + 436, 438, 445, 450, 453, 461, 463, 467, 469, 472, + 474, 477, 479, 482, 485, 491, 499, 505, 515, 521, + 531, 533, 537, 539, 541, 545, 549, 552, 554, 557, + 560, 561, 563, 566, 570, 571, 573, 576, 580, 584, + 589, 590, 592, 594, 597, 603, 611, 618, 625, 630, + 634, 639, 642, 646, 649, 653, 657, 661, 665, 671, + 675, 679, 684, 686, 692, 699, 705, 712, 722, 733, + 743, 754, 757, 759, 762, 765, 768, 770, 777, 786, + 797, 810, 825, 826, 828, 829, 831, 833, 837, 842, + 850, 851, 853, 857, 859, 863, 865, 867, 869, 873, + 875, 877, 879, 883, 884, 886, 890, 895, 897, 901, + 903, 905, 909, 913, 917, 921, 925, 928, 932, 939, + 943, 947, 952, 954, 957, 960, 964, 970, 979, 987, + 995, 1001, 1011, 1014, 1017, 1023, 1027, 1033, 1038, 1042, + 1047, 1052, 1060, 1064, 1068, 1072, 1076, 1081, 1088, 1090, + 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1105, 1107, 1109, + 1112, 1114, 1116, 1118, 1120, 1122, 1124, 1126, 1127, 1133, + 1135, 1138, 1142, 1144, 1147, 1149, 1151, 1153, 1155, 1157, + 1159, 1161, 1163, 1165, 1167, 1169, 1171, 1173, 1175, 1177, + 1179, 1181, 1183, 1185, 1187, 1189, 1191, 1194, 1197, 1201, + 1205, 1207, 1211, 1213, 1216, 1219, 1222, 1227, 1232, 1237, + 1242, 1244, 1247, 1250, 1254, 1256, 1259, 1262, 1264, 1267, + 1270, 1274, 1276, 1279, 1282, 1284, 1286, 1291, 1294, 1295, + 1302, 1310, 1313, 1316, 1319, 1320, 1323, 1326, 1330, 1333, + 1337, 1339, 1342, 1346, 1349, 1352, 1357, 1358, 1360, 1363, + 1366, 1368, 1369, 1371, 1374, 1377, 1383, 1386, 1387, 1395, + 1398, 1403, 1404, 1407, 1408, 1410, 1412, 1414, 1420, 1426, + 1432, 1434, 1440, 1446, 1456, 1458, 1464, 1465, 1467, 1469, + 1475, 1477, 1479, 1485, 1491, 1493, 1497, 1501, 1506, 1508, + 1510, 1512, 1514, 1517, 1519, 1523, 1527, 1529, 1532, 1534, + 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1554, 1556, + 1558, 1560, 1563, 1565, 1567, 1569, 1572, 1573, 1576, 1579, + 1581, 1586, 1587, 1589, 1592, 1596, 1601, 1604, 1607, 1609, + 1612, 1615, 1621, 1627, 1635, 1642, 1644, 1647, 1650, 1654, + 1656, 1659, 1662, 1667, 1670, 1675, 1676, 1681, 1684, 1686, + 1688, 1690, 1691, 1694, 1700, 1706, 1720, 1722, 1724, 1728, + 1732, 1735, 1739, 1743, 1746, 1751, 1753, 1760, 1770, 1771, + 1783, 1785, 1789, 1793, 1797, 1799, 1801, 1807, 1810, 1816, + 1817, 1819, 1821, 1825, 1826, 1828, 1830, 1832, 1834, 1835, + 1842, 1845, 1847, 1850, 1855, 1858, 1862, 1866, 1870, 1875, + 1881, 1887, 1893, 1900, 1902, 1904, 1906, 1910, 1911, 1917, + 1918, 1920, 1922, 1925, 1932, 1934, 1938, 1939, 1941, 1946, + 1948, 1950, 1952, 1954, 1957, 1959, 1962, 1965, 1967, 1971, + 1974, 1978, 1982, 1985, 1990, 1995, 1999, 2008, 2012, 2015, + 2017, 2020, 2027, 2036, 2040, 2043, 2047, 2051, 2056, 2061, + 2065, 2067, 2069, 2071, 2076, 2083, 2087, 2090, 2094, 2098, + 2103, 2108, 2112, 2115, 2117, 2120, 2123, 2125, 2129, 2132, + 2136, 2140, 2143, 2148, 2153, 2157, 2164, 2173, 2177, 2180, + 2182, 2185, 2188, 2191, 2195, 2199, 2202, 2207, 2212, 2216, + 2223, 2232, 2236, 2239, 2241, 2244, 2247, 2249, 2251, 2254, + 2258, 2262, 2265, 2270, 2277, 2286, 2288, 2291, 2294, 2296, + 2299, 2302, 2306, 2310, 2312, 2317, 2322, 2326, 2332, 2341, + 2345, 2348, 2352, 2354, 2360, 2366, 2373, 2380, 2382, 2385, + 2388, 2390, 2393, 2396, 2400, 2404, 2406, 2411, 2416, 2420, + 2426, 2435, 2439, 2441, 2444, 2446, 2449, 2456, 2462, 2469, + 2477, 2485, 2487, 2490, 2493, 2495, 2498, 2501, 2505, 2509, + 2511, 2516, 2521, 2525, 2534, 2538, 2540, 2542, 2545, 2547, + 2549, 2552, 2556, 2559, 2563, 2566, 2570, 2574, 2577, 2582, + 2586, 2589, 2593, 2596, 2601, 2605, 2608, 2615, 2622, 2629, + 2637, 2639, 2642, 2644, 2646, 2648, 2651, 2655, 2658, 2662, + 2665, 2669, 2673, 2678, 2681, 2685, 2690, 2693, 2699, 2705, + 2712, 2719, 2720, 2722, 2723 }; @@ -744,276 +745,277 @@ static const yytype_int16 yyrhs[] = { - 302, 0, -1, -1, -1, 79, -1, 80, -1, 81, + 303, 0, -1, -1, -1, 79, -1, 80, -1, 81, -1, 72, -1, 76, -1, 140, -1, 72, -1, 76, -1, 72, -1, 140, -1, 83, -1, 84, -1, 142, -1, 82, -1, 142, 82, -1, 72, -1, 140, -1, - 109, 170, 110, -1, 109, 174, 110, -1, 143, -1, - 144, 111, 134, 165, 135, 112, -1, 144, 109, 145, + 109, 171, 110, -1, 109, 175, 110, -1, 143, -1, + 144, 111, 134, 166, 135, 112, -1, 144, 109, 145, 110, -1, 144, 113, 139, -1, 144, 113, 111, 134, - 147, 135, 112, -1, 144, 85, 139, -1, 144, 85, - 111, 134, 147, 135, 112, -1, 144, 86, -1, 144, - 87, -1, 109, 275, 110, 114, 279, 372, 115, -1, - 144, 114, 145, 115, -1, 146, -1, 145, 116, 146, - -1, -1, 165, -1, 148, -1, 147, 116, 148, -1, - 139, -1, 139, 113, 148, -1, 139, 113, 111, 134, - 147, 135, 112, -1, 139, 85, 148, -1, 139, 85, - 111, 134, 147, 135, 112, -1, 144, -1, 136, -1, - 141, -1, 40, 152, -1, 150, 152, -1, 151, 152, - -1, 86, 149, -1, 87, 149, -1, 37, 149, -1, - 37, 109, 275, 110, -1, 66, 149, -1, 66, 109, - 275, 110, -1, 38, 109, 275, 116, 139, 110, -1, - 76, -1, 76, 109, 146, 110, -1, 76, 109, 276, - 110, -1, 117, -1, 118, -1, 119, -1, 120, -1, - 121, -1, 122, -1, 149, -1, 109, 275, 110, 152, - -1, 109, 275, 110, 168, -1, 152, -1, 153, 117, - 152, -1, 153, 123, 152, -1, 153, 124, 152, -1, - 153, -1, 154, 119, 153, -1, 154, 120, 153, -1, - 154, -1, 155, 88, 154, -1, 155, 89, 154, -1, - 155, -1, 156, 125, 155, -1, 156, 126, 155, -1, - 156, 90, 155, -1, 156, 91, 155, -1, 156, -1, - 157, 92, 156, -1, 157, 93, 156, -1, 157, -1, - 158, 118, 157, -1, 158, -1, 159, 127, 158, -1, - 159, -1, 160, 128, 159, -1, 160, -1, 161, 94, - 160, -1, 161, -1, 162, 95, 161, -1, 162, -1, - 162, 129, 170, 130, 163, -1, 162, 129, 130, 163, - -1, 162, 129, 170, 130, 168, -1, 163, -1, 163, - -1, 149, 167, 165, -1, 168, 373, -1, -1, 165, - -1, 131, -1, 107, -1, 97, -1, 98, -1, 99, - -1, 100, -1, 101, -1, 102, -1, 103, -1, 104, - -1, 105, -1, 106, -1, 111, 112, -1, 111, 134, - 165, 135, 112, -1, 111, 134, 116, 169, 135, 112, - -1, 111, 134, 165, 116, 169, 135, 112, -1, 166, - -1, 169, 116, 166, -1, 165, -1, 170, 116, 165, - -1, -1, 170, -1, 173, -1, 174, -1, 178, -1, - 179, -1, 191, -1, 193, -1, 194, -1, 199, -1, - 127, 144, 114, 145, 115, 132, -1, 72, 130, 312, - 172, -1, 114, 115, -1, 114, 134, 134, 210, 175, - 135, 115, -1, 176, -1, 175, 134, 176, -1, 213, - -1, 40, 213, -1, 308, -1, 172, 135, -1, 172, - -1, 177, 172, -1, 171, 132, -1, 41, 109, 170, - 110, 172, -1, 41, 109, 170, 110, 172, 42, 172, - -1, 43, 109, 170, 110, 184, -1, 43, 109, 170, - 110, 114, 134, 206, 185, 115, -1, 53, 109, 170, - 110, 184, -1, 53, 109, 170, 110, 114, 134, 206, - 187, 115, -1, 164, -1, 164, 96, 164, -1, 310, - -1, 180, -1, 181, 116, 180, -1, 44, 181, 130, - -1, 45, 130, -1, 182, -1, 183, 182, -1, 183, - 172, -1, -1, 186, -1, 183, 177, -1, 186, 183, - 177, -1, -1, 188, -1, 183, 190, -1, 183, 177, - 189, -1, 188, 183, 190, -1, 188, 183, 177, 189, - -1, -1, 190, -1, 56, -1, 56, 132, -1, 47, - 109, 170, 110, 172, -1, 46, 172, 47, 109, 170, - 110, 132, -1, 48, 109, 134, 192, 110, 172, -1, - 171, 135, 132, 171, 132, 171, -1, 213, 171, 132, - 171, -1, 51, 72, 132, -1, 51, 117, 170, 132, - -1, 50, 132, -1, 50, 72, 132, -1, 49, 132, - -1, 49, 72, 132, -1, 52, 171, 132, -1, 61, - 166, 132, -1, 62, 166, 132, -1, 62, 166, 63, - 165, 132, -1, 57, 174, 195, -1, 57, 174, 197, - -1, 57, 174, 195, 197, -1, 196, -1, 58, 109, - 96, 110, 174, -1, 196, 58, 109, 96, 110, 174, - -1, 59, 109, 96, 110, 174, -1, 196, 59, 109, - 96, 110, 174, -1, 58, 109, 134, 134, 198, 135, - 110, 174, 135, -1, 196, 58, 109, 134, 134, 198, - 135, 110, 174, 135, -1, 59, 109, 134, 134, 198, - 135, 110, 174, 135, -1, 196, 59, 109, 134, 134, - 198, 135, 110, 174, 135, -1, 60, 174, -1, 226, - -1, 226, 309, -1, 226, 357, -1, 366, 139, -1, - 366, -1, 64, 200, 109, 141, 110, 132, -1, 64, - 200, 109, 141, 130, 201, 110, 132, -1, 64, 200, - 109, 141, 130, 201, 130, 201, 110, 132, -1, 64, - 200, 109, 141, 130, 201, 130, 201, 130, 204, 110, - 132, -1, 64, 200, 51, 109, 141, 130, 130, 201, - 130, 204, 130, 205, 110, 132, -1, -1, 11, -1, - -1, 202, -1, 203, -1, 202, 116, 203, -1, 141, - 109, 164, 110, -1, 111, 164, 112, 141, 109, 164, - 110, -1, -1, 141, -1, 204, 116, 141, -1, 139, - -1, 205, 116, 139, -1, 135, -1, 207, -1, 213, - -1, 207, 134, 213, -1, 135, -1, 209, -1, 223, - -1, 209, 134, 223, -1, -1, 211, -1, 29, 212, - 132, -1, 211, 29, 212, 132, -1, 274, -1, 212, - 116, 274, -1, 214, -1, 223, -1, 215, 135, 132, - -1, 220, 135, 132, -1, 217, 135, 132, -1, 293, - 135, 132, -1, 296, 135, 132, -1, 216, 277, -1, - 232, 216, 277, -1, 215, 135, 116, 134, 272, 277, - -1, 367, 272, 311, -1, 370, 272, 311, -1, 228, - 370, 272, 311, -1, 218, -1, 228, 218, -1, 232, - 218, -1, 232, 228, 218, -1, 217, 135, 116, 134, - 272, -1, 111, 112, 272, 109, 134, 260, 135, 110, - -1, 370, 272, 109, 134, 260, 135, 110, -1, 219, - 272, 109, 134, 260, 135, 110, -1, 111, 134, 262, - 135, 112, -1, 111, 134, 262, 135, 116, 134, 263, - 135, 112, -1, 3, 216, -1, 3, 218, -1, 220, - 135, 116, 134, 139, -1, 3, 226, 309, -1, 221, - 135, 116, 134, 309, -1, 228, 3, 226, 309, -1, - 226, 3, 309, -1, 226, 3, 228, 309, -1, 3, - 139, 131, 165, -1, 222, 135, 116, 134, 139, 131, - 165, -1, 224, 135, 132, -1, 221, 135, 132, -1, - 222, 135, 132, -1, 240, 135, 132, -1, 225, 309, - 311, 277, -1, 224, 116, 312, 309, 311, 277, -1, - 236, -1, 240, -1, 242, -1, 283, -1, 237, -1, - 241, -1, 243, -1, 284, -1, -1, 228, -1, 229, - -1, 228, 229, -1, 230, -1, 314, -1, 10, -1, - 12, -1, 11, -1, 14, -1, 67, -1, -1, 13, - 109, 231, 286, 110, -1, 233, -1, 228, 233, -1, - 232, 228, 233, -1, 234, -1, 233, 234, -1, 5, - -1, 7, -1, 4, -1, 6, -1, 8, -1, 9, - -1, 69, -1, 71, -1, 16, -1, 21, -1, 20, - -1, 18, -1, 19, -1, 17, -1, 22, -1, 23, - -1, 15, -1, 25, -1, 26, -1, 27, -1, 24, - -1, 237, -1, 232, 237, -1, 236, 234, -1, 236, - 234, 228, -1, 236, 234, 237, -1, 238, -1, 227, - 239, 227, -1, 235, -1, 228, 235, -1, 238, 229, - -1, 238, 235, -1, 28, 109, 276, 110, -1, 28, - 109, 170, 110, -1, 78, 109, 276, 110, -1, 78, - 109, 170, 110, -1, 241, -1, 232, 241, -1, 240, - 234, -1, 240, 234, 228, -1, 244, -1, 228, 244, - -1, 241, 229, -1, 243, -1, 232, 243, -1, 242, - 234, -1, 242, 234, 228, -1, 74, -1, 228, 74, - -1, 243, 229, -1, 245, -1, 256, -1, 247, 114, - 248, 115, -1, 247, 274, -1, -1, 247, 274, 246, - 114, 248, 115, -1, 247, 109, 292, 110, 114, 248, - 115, -1, 247, 285, -1, 31, 312, -1, 32, 312, - -1, -1, 248, 249, -1, 250, 132, -1, 40, 250, - 132, -1, 251, 132, -1, 40, 251, 132, -1, 366, - -1, 366, 274, -1, 250, 116, 274, -1, 250, 116, - -1, 226, 252, -1, 251, 116, 312, 252, -1, -1, - 254, -1, 318, 253, -1, 331, 253, -1, 357, -1, - -1, 254, -1, 130, 164, -1, 30, 312, -1, 255, - 114, 258, 372, 115, -1, 255, 274, -1, -1, 255, - 274, 257, 114, 258, 372, 115, -1, 274, 259, -1, - 258, 116, 274, 259, -1, -1, 131, 164, -1, -1, - 261, -1, 263, -1, 262, -1, 262, 135, 116, 134, - 263, -1, 263, 135, 116, 134, 96, -1, 262, 135, - 116, 134, 96, -1, 267, -1, 263, 135, 116, 134, - 267, -1, 262, 135, 116, 134, 267, -1, 262, 135, - 116, 134, 263, 135, 116, 134, 267, -1, 268, -1, - 263, 135, 116, 134, 268, -1, -1, 265, -1, 266, - -1, 266, 135, 116, 134, 96, -1, 270, -1, 269, - -1, 266, 135, 116, 134, 270, -1, 266, 135, 116, - 134, 269, -1, 269, -1, 362, 272, 373, -1, 370, - 272, 373, -1, 228, 370, 272, 373, -1, 218, -1, - 270, -1, 362, -1, 370, -1, 228, 370, -1, 371, - -1, 225, 336, 373, -1, 225, 340, 373, -1, 225, - -1, 225, 351, -1, 139, -1, 271, 116, 139, -1, - 137, -1, 74, -1, 75, -1, 138, -1, 74, -1, - 75, -1, 139, -1, 74, -1, 75, -1, 366, -1, - 226, -1, 226, 357, -1, 366, -1, 371, -1, 226, - -1, 226, 345, -1, -1, 131, 278, -1, 107, 278, - -1, 165, -1, 114, 279, 372, 115, -1, -1, 278, - -1, 280, 278, -1, 279, 116, 278, -1, 279, 116, - 280, 278, -1, 281, 130, -1, 274, 130, -1, 282, - -1, 281, 282, -1, 113, 274, -1, 111, 134, 165, - 135, 112, -1, 111, 134, 310, 135, 112, -1, 111, - 134, 164, 96, 164, 135, 112, -1, 113, 111, 134, - 147, 135, 112, -1, 284, -1, 232, 284, -1, 283, - 234, -1, 283, 234, 228, -1, 285, -1, 228, 285, - -1, 284, 229, -1, 75, 109, 292, 110, -1, 287, - 373, -1, 286, 116, 287, 373, -1, -1, 289, 274, - 288, 290, -1, 226, 336, -1, 33, -1, 35, -1, - 34, -1, -1, 290, 291, -1, 128, 274, 109, 292, - 110, -1, 128, 114, 134, 298, 115, -1, 128, 109, - 134, 286, 135, 110, 114, 134, 298, 115, 109, 292, - 110, -1, 276, -1, 165, -1, 292, 116, 276, -1, - 292, 116, 165, -1, 33, 294, -1, 233, 33, 294, - -1, 293, 116, 294, -1, 295, 290, -1, 295, 290, - 131, 276, -1, 274, -1, 273, 109, 134, 286, 135, - 110, -1, 36, 274, 109, 134, 286, 135, 110, 114, - 115, -1, -1, 36, 274, 109, 134, 286, 135, 110, - 114, 297, 298, 115, -1, 299, -1, 298, 134, 299, - -1, 300, 135, 132, -1, 301, 135, 132, -1, 216, - -1, 218, -1, 300, 135, 116, 134, 272, -1, 226, - 309, -1, 301, 135, 116, 134, 309, -1, -1, 303, - -1, 305, -1, 303, 134, 305, -1, -1, 303, -1, - 213, -1, 307, -1, 199, -1, -1, 5, 82, 306, - 114, 304, 115, -1, 40, 305, -1, 308, -1, 323, - 174, -1, 327, 134, 208, 174, -1, 217, 174, -1, - 225, 323, 174, -1, 228, 323, 174, -1, 232, 323, - 174, -1, 232, 228, 323, 174, -1, 225, 327, 134, - 208, 174, -1, 228, 327, 134, 208, 174, -1, 232, - 327, 134, 208, 174, -1, 232, 228, 327, 134, 208, - 174, -1, 318, -1, 331, -1, 323, -1, 164, 122, - 164, -1, -1, 64, 109, 142, 110, 312, -1, -1, - 313, -1, 314, -1, 313, 314, -1, 39, 109, 109, - 315, 110, 110, -1, 316, -1, 315, 116, 316, -1, - -1, 317, -1, 317, 109, 171, 110, -1, 272, -1, - 234, -1, 235, -1, 229, -1, 319, 312, -1, 320, - -1, 321, 312, -1, 322, 312, -1, 137, -1, 109, - 319, 110, -1, 150, 318, -1, 150, 228, 318, -1, - 109, 320, 110, -1, 319, 349, -1, 109, 320, 110, - 349, -1, 109, 321, 110, 350, -1, 109, 321, 110, - -1, 109, 320, 110, 109, 134, 264, 135, 110, -1, - 109, 322, 110, -1, 324, 312, -1, 325, -1, 326, - 312, -1, 319, 109, 134, 264, 135, 110, -1, 109, - 325, 110, 109, 134, 264, 135, 110, -1, 109, 324, - 110, -1, 150, 323, -1, 150, 228, 323, -1, 109, - 325, 110, -1, 109, 325, 110, 349, -1, 109, 326, - 110, 350, -1, 109, 326, 110, -1, 328, -1, 329, - -1, 330, -1, 319, 109, 271, 110, -1, 109, 329, - 110, 109, 271, 110, -1, 109, 328, 110, -1, 150, - 327, -1, 150, 228, 327, -1, 109, 329, 110, -1, - 109, 329, 110, 349, -1, 109, 330, 110, 350, -1, - 109, 330, 110, -1, 332, 312, -1, 333, -1, 334, - 312, -1, 335, 312, -1, 341, -1, 109, 332, 110, - -1, 150, 331, -1, 150, 228, 331, -1, 109, 333, - 110, -1, 332, 349, -1, 109, 333, 110, 349, -1, - 109, 334, 110, 350, -1, 109, 334, 110, -1, 332, - 109, 134, 264, 135, 110, -1, 109, 333, 110, 109, - 134, 264, 135, 110, -1, 109, 335, 110, -1, 319, - 312, -1, 337, -1, 338, 312, -1, 339, 312, -1, - 150, 336, -1, 150, 228, 336, -1, 109, 337, 110, - -1, 319, 355, -1, 109, 337, 110, 349, -1, 109, - 338, 110, 350, -1, 109, 338, 110, -1, 319, 109, - 134, 264, 135, 110, -1, 109, 337, 110, 109, 134, - 264, 135, 110, -1, 109, 339, 110, -1, 341, 312, - -1, 342, -1, 343, 312, -1, 344, 312, -1, 74, - -1, 75, -1, 150, 340, -1, 150, 228, 340, -1, - 109, 342, 110, -1, 341, 355, -1, 109, 342, 110, - 355, -1, 341, 109, 134, 264, 135, 110, -1, 109, - 342, 110, 109, 134, 264, 135, 110, -1, 346, -1, - 347, 312, -1, 348, 312, -1, 150, -1, 150, 228, - -1, 150, 345, -1, 150, 228, 345, -1, 109, 346, - 110, -1, 349, -1, 109, 346, 110, 349, -1, 109, - 347, 110, 350, -1, 109, 347, 110, -1, 109, 134, - 264, 135, 110, -1, 109, 346, 110, 109, 134, 264, - 135, 110, -1, 109, 348, 110, -1, 111, 112, -1, - 111, 112, 350, -1, 350, -1, 111, 134, 165, 135, - 112, -1, 111, 134, 117, 135, 112, -1, 350, 111, - 134, 165, 135, 112, -1, 350, 111, 134, 117, 135, - 112, -1, 352, -1, 353, 312, -1, 354, 312, -1, - 150, -1, 150, 228, -1, 150, 351, -1, 150, 228, - 351, -1, 109, 352, 110, -1, 355, -1, 109, 352, - 110, 355, -1, 109, 353, 110, 350, -1, 109, 353, - 110, -1, 109, 134, 264, 135, 110, -1, 109, 352, - 110, 109, 134, 264, 135, 110, -1, 109, 354, 110, - -1, 356, -1, 356, 350, -1, 350, -1, 111, 112, - -1, 111, 134, 228, 117, 135, 112, -1, 111, 134, - 228, 135, 112, -1, 111, 134, 228, 165, 135, 112, - -1, 111, 134, 7, 227, 165, 135, 112, -1, 111, - 134, 228, 7, 165, 135, 112, -1, 358, -1, 359, - 312, -1, 360, 312, -1, 150, -1, 150, 228, -1, - 150, 357, -1, 150, 228, 357, -1, 109, 358, 110, - -1, 349, -1, 109, 358, 110, 349, -1, 109, 359, - 110, 350, -1, 109, 359, 110, -1, 109, 358, 110, - 109, 134, 264, 135, 110, -1, 109, 360, 110, -1, - 362, -1, 370, -1, 228, 370, -1, 363, -1, 364, - -1, 150, 226, -1, 228, 150, 226, -1, 150, 371, - -1, 228, 150, 371, -1, 150, 361, -1, 228, 150, - 361, -1, 111, 112, 226, -1, 365, 226, -1, 111, - 112, 350, 226, -1, 365, 350, 226, -1, 350, 226, - -1, 111, 112, 363, -1, 365, 363, -1, 111, 112, - 350, 363, -1, 365, 350, 363, -1, 350, 363, -1, - 111, 134, 228, 117, 135, 112, -1, 111, 134, 228, - 165, 135, 112, -1, 111, 134, 232, 165, 135, 112, - -1, 111, 134, 232, 228, 165, 135, 112, -1, 370, - -1, 228, 370, -1, 367, -1, 368, -1, 369, -1, - 150, 226, -1, 228, 150, 226, -1, 150, 371, -1, - 228, 150, 371, -1, 150, 366, -1, 228, 150, 366, - -1, 111, 112, 226, -1, 111, 112, 350, 226, -1, - 350, 226, -1, 111, 112, 368, -1, 111, 112, 350, - 368, -1, 350, 368, -1, 111, 134, 263, 135, 112, - -1, 111, 112, 109, 260, 110, -1, 370, 109, 134, - 260, 135, 110, -1, 219, 109, 134, 260, 135, 110, - -1, -1, 116, -1, -1, 131, 165, -1 + 147, 135, 112, -1, 144, 113, 79, -1, 144, 85, + 139, -1, 144, 85, 111, 134, 147, 135, 112, -1, + 144, 86, -1, 144, 87, -1, 109, 276, 110, 114, + 280, 373, 115, -1, 144, 114, 145, 115, -1, 146, + -1, 145, 116, 146, -1, -1, 166, -1, 148, -1, + 147, 116, 148, -1, 149, -1, 149, 113, 148, -1, + 149, 113, 111, 134, 147, 135, 112, -1, 149, 85, + 148, -1, 149, 85, 111, 134, 147, 135, 112, -1, + 139, -1, 79, -1, 144, -1, 136, -1, 141, -1, + 40, 153, -1, 151, 153, -1, 152, 153, -1, 86, + 150, -1, 87, 150, -1, 37, 150, -1, 37, 109, + 276, 110, -1, 66, 150, -1, 66, 109, 276, 110, + -1, 38, 109, 276, 116, 139, 110, -1, 76, -1, + 76, 109, 146, 110, -1, 76, 109, 277, 110, -1, + 117, -1, 118, -1, 119, -1, 120, -1, 121, -1, + 122, -1, 150, -1, 109, 276, 110, 153, -1, 109, + 276, 110, 169, -1, 153, -1, 154, 117, 153, -1, + 154, 123, 153, -1, 154, 124, 153, -1, 154, -1, + 155, 119, 154, -1, 155, 120, 154, -1, 155, -1, + 156, 88, 155, -1, 156, 89, 155, -1, 156, -1, + 157, 125, 156, -1, 157, 126, 156, -1, 157, 90, + 156, -1, 157, 91, 156, -1, 157, -1, 158, 92, + 157, -1, 158, 93, 157, -1, 158, -1, 159, 118, + 158, -1, 159, -1, 160, 127, 159, -1, 160, -1, + 161, 128, 160, -1, 161, -1, 162, 94, 161, -1, + 162, -1, 163, 95, 162, -1, 163, -1, 163, 129, + 171, 130, 164, -1, 163, 129, 130, 164, -1, 163, + 129, 171, 130, 169, -1, 164, -1, 164, -1, 150, + 168, 166, -1, 169, 374, -1, -1, 166, -1, 131, + -1, 107, -1, 97, -1, 98, -1, 99, -1, 100, + -1, 101, -1, 102, -1, 103, -1, 104, -1, 105, + -1, 106, -1, 111, 112, -1, 111, 134, 166, 135, + 112, -1, 111, 134, 116, 170, 135, 112, -1, 111, + 134, 166, 116, 170, 135, 112, -1, 167, -1, 170, + 116, 167, -1, 166, -1, 171, 116, 166, -1, -1, + 171, -1, 174, -1, 175, -1, 179, -1, 180, -1, + 192, -1, 194, -1, 195, -1, 200, -1, 127, 144, + 114, 145, 115, 132, -1, 72, 130, 313, 173, -1, + 114, 115, -1, 114, 134, 134, 211, 176, 135, 115, + -1, 177, -1, 176, 134, 177, -1, 214, -1, 40, + 214, -1, 309, -1, 173, 135, -1, 173, -1, 178, + 173, -1, 172, 132, -1, 41, 109, 171, 110, 173, + -1, 41, 109, 171, 110, 173, 42, 173, -1, 43, + 109, 171, 110, 185, -1, 43, 109, 171, 110, 114, + 134, 207, 186, 115, -1, 53, 109, 171, 110, 185, + -1, 53, 109, 171, 110, 114, 134, 207, 188, 115, + -1, 165, -1, 165, 96, 165, -1, 311, -1, 181, + -1, 182, 116, 181, -1, 44, 182, 130, -1, 45, + 130, -1, 183, -1, 184, 183, -1, 184, 173, -1, + -1, 187, -1, 184, 178, -1, 187, 184, 178, -1, + -1, 189, -1, 184, 191, -1, 184, 178, 190, -1, + 189, 184, 191, -1, 189, 184, 178, 190, -1, -1, + 191, -1, 56, -1, 56, 132, -1, 47, 109, 171, + 110, 173, -1, 46, 173, 47, 109, 171, 110, 132, + -1, 48, 109, 134, 193, 110, 173, -1, 172, 135, + 132, 172, 132, 172, -1, 214, 172, 132, 172, -1, + 51, 72, 132, -1, 51, 117, 171, 132, -1, 50, + 132, -1, 50, 72, 132, -1, 49, 132, -1, 49, + 72, 132, -1, 52, 172, 132, -1, 61, 167, 132, + -1, 62, 167, 132, -1, 62, 167, 63, 166, 132, + -1, 57, 175, 196, -1, 57, 175, 198, -1, 57, + 175, 196, 198, -1, 197, -1, 58, 109, 96, 110, + 175, -1, 197, 58, 109, 96, 110, 175, -1, 59, + 109, 96, 110, 175, -1, 197, 59, 109, 96, 110, + 175, -1, 58, 109, 134, 134, 199, 135, 110, 175, + 135, -1, 197, 58, 109, 134, 134, 199, 135, 110, + 175, 135, -1, 59, 109, 134, 134, 199, 135, 110, + 175, 135, -1, 197, 59, 109, 134, 134, 199, 135, + 110, 175, 135, -1, 60, 175, -1, 227, -1, 227, + 310, -1, 227, 358, -1, 367, 139, -1, 367, -1, + 64, 201, 109, 141, 110, 132, -1, 64, 201, 109, + 141, 130, 202, 110, 132, -1, 64, 201, 109, 141, + 130, 202, 130, 202, 110, 132, -1, 64, 201, 109, + 141, 130, 202, 130, 202, 130, 205, 110, 132, -1, + 64, 201, 51, 109, 141, 130, 130, 202, 130, 205, + 130, 206, 110, 132, -1, -1, 11, -1, -1, 203, + -1, 204, -1, 203, 116, 204, -1, 141, 109, 165, + 110, -1, 111, 165, 112, 141, 109, 165, 110, -1, + -1, 141, -1, 205, 116, 141, -1, 139, -1, 206, + 116, 139, -1, 135, -1, 208, -1, 214, -1, 208, + 134, 214, -1, 135, -1, 210, -1, 224, -1, 210, + 134, 224, -1, -1, 212, -1, 29, 213, 132, -1, + 212, 29, 213, 132, -1, 275, -1, 213, 116, 275, + -1, 215, -1, 224, -1, 216, 135, 132, -1, 221, + 135, 132, -1, 218, 135, 132, -1, 294, 135, 132, + -1, 297, 135, 132, -1, 217, 278, -1, 233, 217, + 278, -1, 216, 135, 116, 134, 273, 278, -1, 368, + 273, 312, -1, 371, 273, 312, -1, 229, 371, 273, + 312, -1, 219, -1, 229, 219, -1, 233, 219, -1, + 233, 229, 219, -1, 218, 135, 116, 134, 273, -1, + 111, 112, 273, 109, 134, 261, 135, 110, -1, 371, + 273, 109, 134, 261, 135, 110, -1, 220, 273, 109, + 134, 261, 135, 110, -1, 111, 134, 263, 135, 112, + -1, 111, 134, 263, 135, 116, 134, 264, 135, 112, + -1, 3, 217, -1, 3, 219, -1, 221, 135, 116, + 134, 139, -1, 3, 227, 310, -1, 222, 135, 116, + 134, 310, -1, 229, 3, 227, 310, -1, 227, 3, + 310, -1, 227, 3, 229, 310, -1, 3, 139, 131, + 166, -1, 223, 135, 116, 134, 139, 131, 166, -1, + 225, 135, 132, -1, 222, 135, 132, -1, 223, 135, + 132, -1, 241, 135, 132, -1, 226, 310, 312, 278, + -1, 225, 116, 313, 310, 312, 278, -1, 237, -1, + 241, -1, 243, -1, 284, -1, 238, -1, 242, -1, + 244, -1, 285, -1, -1, 229, -1, 230, -1, 229, + 230, -1, 231, -1, 315, -1, 10, -1, 12, -1, + 11, -1, 14, -1, 67, -1, -1, 13, 109, 232, + 287, 110, -1, 234, -1, 229, 234, -1, 233, 229, + 234, -1, 235, -1, 234, 235, -1, 5, -1, 7, + -1, 4, -1, 6, -1, 8, -1, 9, -1, 69, + -1, 71, -1, 16, -1, 21, -1, 20, -1, 18, + -1, 19, -1, 17, -1, 22, -1, 23, -1, 15, + -1, 25, -1, 26, -1, 27, -1, 24, -1, 238, + -1, 233, 238, -1, 237, 235, -1, 237, 235, 229, + -1, 237, 235, 238, -1, 239, -1, 228, 240, 228, + -1, 236, -1, 229, 236, -1, 239, 230, -1, 239, + 236, -1, 28, 109, 277, 110, -1, 28, 109, 171, + 110, -1, 78, 109, 277, 110, -1, 78, 109, 171, + 110, -1, 242, -1, 233, 242, -1, 241, 235, -1, + 241, 235, 229, -1, 245, -1, 229, 245, -1, 242, + 230, -1, 244, -1, 233, 244, -1, 243, 235, -1, + 243, 235, 229, -1, 74, -1, 229, 74, -1, 244, + 230, -1, 246, -1, 257, -1, 248, 114, 249, 115, + -1, 248, 275, -1, -1, 248, 275, 247, 114, 249, + 115, -1, 248, 109, 293, 110, 114, 249, 115, -1, + 248, 286, -1, 31, 313, -1, 32, 313, -1, -1, + 249, 250, -1, 251, 132, -1, 40, 251, 132, -1, + 252, 132, -1, 40, 252, 132, -1, 367, -1, 367, + 275, -1, 251, 116, 275, -1, 251, 116, -1, 227, + 253, -1, 252, 116, 313, 253, -1, -1, 255, -1, + 319, 254, -1, 332, 254, -1, 358, -1, -1, 255, + -1, 130, 165, -1, 30, 313, -1, 256, 114, 259, + 373, 115, -1, 256, 275, -1, -1, 256, 275, 258, + 114, 259, 373, 115, -1, 275, 260, -1, 259, 116, + 275, 260, -1, -1, 131, 165, -1, -1, 262, -1, + 264, -1, 263, -1, 263, 135, 116, 134, 264, -1, + 264, 135, 116, 134, 96, -1, 263, 135, 116, 134, + 96, -1, 268, -1, 264, 135, 116, 134, 268, -1, + 263, 135, 116, 134, 268, -1, 263, 135, 116, 134, + 264, 135, 116, 134, 268, -1, 269, -1, 264, 135, + 116, 134, 269, -1, -1, 266, -1, 267, -1, 267, + 135, 116, 134, 96, -1, 271, -1, 270, -1, 267, + 135, 116, 134, 271, -1, 267, 135, 116, 134, 270, + -1, 270, -1, 363, 273, 374, -1, 371, 273, 374, + -1, 229, 371, 273, 374, -1, 219, -1, 271, -1, + 363, -1, 371, -1, 229, 371, -1, 372, -1, 226, + 337, 374, -1, 226, 341, 374, -1, 226, -1, 226, + 352, -1, 139, -1, 272, 116, 139, -1, 137, -1, + 74, -1, 75, -1, 138, -1, 74, -1, 75, -1, + 139, -1, 74, -1, 75, -1, 367, -1, 227, -1, + 227, 358, -1, 367, -1, 372, -1, 227, -1, 227, + 346, -1, -1, 131, 279, -1, 107, 279, -1, 166, + -1, 114, 280, 373, 115, -1, -1, 279, -1, 281, + 279, -1, 280, 116, 279, -1, 280, 116, 281, 279, + -1, 282, 130, -1, 275, 130, -1, 283, -1, 282, + 283, -1, 113, 275, -1, 111, 134, 166, 135, 112, + -1, 111, 134, 311, 135, 112, -1, 111, 134, 165, + 96, 165, 135, 112, -1, 113, 111, 134, 147, 135, + 112, -1, 285, -1, 233, 285, -1, 284, 235, -1, + 284, 235, 229, -1, 286, -1, 229, 286, -1, 285, + 230, -1, 75, 109, 293, 110, -1, 288, 374, -1, + 287, 116, 288, 374, -1, -1, 290, 275, 289, 291, + -1, 227, 337, -1, 33, -1, 35, -1, 34, -1, + -1, 291, 292, -1, 128, 275, 109, 293, 110, -1, + 128, 114, 134, 299, 115, -1, 128, 109, 134, 287, + 135, 110, 114, 134, 299, 115, 109, 293, 110, -1, + 277, -1, 166, -1, 293, 116, 277, -1, 293, 116, + 166, -1, 33, 295, -1, 234, 33, 295, -1, 294, + 116, 295, -1, 296, 291, -1, 296, 291, 131, 277, + -1, 275, -1, 274, 109, 134, 287, 135, 110, -1, + 36, 275, 109, 134, 287, 135, 110, 114, 115, -1, + -1, 36, 275, 109, 134, 287, 135, 110, 114, 298, + 299, 115, -1, 300, -1, 299, 134, 300, -1, 301, + 135, 132, -1, 302, 135, 132, -1, 217, -1, 219, + -1, 301, 135, 116, 134, 273, -1, 227, 310, -1, + 302, 135, 116, 134, 310, -1, -1, 304, -1, 306, + -1, 304, 134, 306, -1, -1, 304, -1, 214, -1, + 308, -1, 200, -1, -1, 5, 82, 307, 114, 305, + 115, -1, 40, 306, -1, 309, -1, 324, 175, -1, + 328, 134, 209, 175, -1, 218, 175, -1, 226, 324, + 175, -1, 229, 324, 175, -1, 233, 324, 175, -1, + 233, 229, 324, 175, -1, 226, 328, 134, 209, 175, + -1, 229, 328, 134, 209, 175, -1, 233, 328, 134, + 209, 175, -1, 233, 229, 328, 134, 209, 175, -1, + 319, -1, 332, -1, 324, -1, 165, 122, 165, -1, + -1, 64, 109, 142, 110, 313, -1, -1, 314, -1, + 315, -1, 314, 315, -1, 39, 109, 109, 316, 110, + 110, -1, 317, -1, 316, 116, 317, -1, -1, 318, + -1, 318, 109, 172, 110, -1, 273, -1, 235, -1, + 236, -1, 230, -1, 320, 313, -1, 321, -1, 322, + 313, -1, 323, 313, -1, 137, -1, 109, 320, 110, + -1, 151, 319, -1, 151, 229, 319, -1, 109, 321, + 110, -1, 320, 350, -1, 109, 321, 110, 350, -1, + 109, 322, 110, 351, -1, 109, 322, 110, -1, 109, + 321, 110, 109, 134, 265, 135, 110, -1, 109, 323, + 110, -1, 325, 313, -1, 326, -1, 327, 313, -1, + 320, 109, 134, 265, 135, 110, -1, 109, 326, 110, + 109, 134, 265, 135, 110, -1, 109, 325, 110, -1, + 151, 324, -1, 151, 229, 324, -1, 109, 326, 110, + -1, 109, 326, 110, 350, -1, 109, 327, 110, 351, + -1, 109, 327, 110, -1, 329, -1, 330, -1, 331, + -1, 320, 109, 272, 110, -1, 109, 330, 110, 109, + 272, 110, -1, 109, 329, 110, -1, 151, 328, -1, + 151, 229, 328, -1, 109, 330, 110, -1, 109, 330, + 110, 350, -1, 109, 331, 110, 351, -1, 109, 331, + 110, -1, 333, 313, -1, 334, -1, 335, 313, -1, + 336, 313, -1, 342, -1, 109, 333, 110, -1, 151, + 332, -1, 151, 229, 332, -1, 109, 334, 110, -1, + 333, 350, -1, 109, 334, 110, 350, -1, 109, 335, + 110, 351, -1, 109, 335, 110, -1, 333, 109, 134, + 265, 135, 110, -1, 109, 334, 110, 109, 134, 265, + 135, 110, -1, 109, 336, 110, -1, 320, 313, -1, + 338, -1, 339, 313, -1, 340, 313, -1, 151, 337, + -1, 151, 229, 337, -1, 109, 338, 110, -1, 320, + 356, -1, 109, 338, 110, 350, -1, 109, 339, 110, + 351, -1, 109, 339, 110, -1, 320, 109, 134, 265, + 135, 110, -1, 109, 338, 110, 109, 134, 265, 135, + 110, -1, 109, 340, 110, -1, 342, 313, -1, 343, + -1, 344, 313, -1, 345, 313, -1, 74, -1, 75, + -1, 151, 341, -1, 151, 229, 341, -1, 109, 343, + 110, -1, 342, 356, -1, 109, 343, 110, 356, -1, + 342, 109, 134, 265, 135, 110, -1, 109, 343, 110, + 109, 134, 265, 135, 110, -1, 347, -1, 348, 313, + -1, 349, 313, -1, 151, -1, 151, 229, -1, 151, + 346, -1, 151, 229, 346, -1, 109, 347, 110, -1, + 350, -1, 109, 347, 110, 350, -1, 109, 348, 110, + 351, -1, 109, 348, 110, -1, 109, 134, 265, 135, + 110, -1, 109, 347, 110, 109, 134, 265, 135, 110, + -1, 109, 349, 110, -1, 111, 112, -1, 111, 112, + 351, -1, 351, -1, 111, 134, 166, 135, 112, -1, + 111, 134, 117, 135, 112, -1, 351, 111, 134, 166, + 135, 112, -1, 351, 111, 134, 117, 135, 112, -1, + 353, -1, 354, 313, -1, 355, 313, -1, 151, -1, + 151, 229, -1, 151, 352, -1, 151, 229, 352, -1, + 109, 353, 110, -1, 356, -1, 109, 353, 110, 356, + -1, 109, 354, 110, 351, -1, 109, 354, 110, -1, + 109, 134, 265, 135, 110, -1, 109, 353, 110, 109, + 134, 265, 135, 110, -1, 109, 355, 110, -1, 357, + -1, 357, 351, -1, 351, -1, 111, 112, -1, 111, + 134, 229, 117, 135, 112, -1, 111, 134, 229, 135, + 112, -1, 111, 134, 229, 166, 135, 112, -1, 111, + 134, 7, 228, 166, 135, 112, -1, 111, 134, 229, + 7, 166, 135, 112, -1, 359, -1, 360, 313, -1, + 361, 313, -1, 151, -1, 151, 229, -1, 151, 358, + -1, 151, 229, 358, -1, 109, 359, 110, -1, 350, + -1, 109, 359, 110, 350, -1, 109, 360, 110, 351, + -1, 109, 360, 110, -1, 109, 359, 110, 109, 134, + 265, 135, 110, -1, 109, 361, 110, -1, 363, -1, + 371, -1, 229, 371, -1, 364, -1, 365, -1, 151, + 227, -1, 229, 151, 227, -1, 151, 372, -1, 229, + 151, 372, -1, 151, 362, -1, 229, 151, 362, -1, + 111, 112, 227, -1, 366, 227, -1, 111, 112, 351, + 227, -1, 366, 351, 227, -1, 351, 227, -1, 111, + 112, 364, -1, 366, 364, -1, 111, 112, 351, 364, + -1, 366, 351, 364, -1, 351, 364, -1, 111, 134, + 229, 117, 135, 112, -1, 111, 134, 229, 166, 135, + 112, -1, 111, 134, 233, 166, 135, 112, -1, 111, + 134, 233, 229, 166, 135, 112, -1, 371, -1, 229, + 371, -1, 368, -1, 369, -1, 370, -1, 151, 227, + -1, 229, 151, 227, -1, 151, 372, -1, 229, 151, + 372, -1, 151, 367, -1, 229, 151, 367, -1, 111, + 112, 227, -1, 111, 112, 351, 227, -1, 351, 227, + -1, 111, 112, 369, -1, 111, 112, 351, 369, -1, + 351, 369, -1, 111, 134, 264, 135, 112, -1, 111, + 112, 109, 261, 110, -1, 371, 109, 134, 261, 135, + 110, -1, 220, 109, 134, 261, 135, 110, -1, -1, + 116, -1, -1, 131, 166, -1 }; @@ -1021,80 +1023,80 @@ static const yytype_uint16 yyrline[] = { - 0, 300, 300, 304, 311, 312, 313, 317, 318, 319, - 323, 324, 328, 329, 333, 334, 338, 342, 343, 354, - 356, 358, 360, 365, 366, 372, 376, 378, 380, 382, - 384, 386, 388, 390, 399, 400, 406, 407, 411, 412, - 416, 420, 422, 424, 426, 431, 434, 436, 438, 443, - 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, - 476, 483, 484, 490, 491, 492, 493, 497, 498, 500, - 505, 506, 508, 510, 515, 516, 518, 523, 524, 526, - 531, 532, 534, 536, 538, 543, 544, 546, 551, 552, - 557, 558, 563, 564, 569, 570, 575, 576, 581, 582, - 585, 587, 592, 597, 598, 600, 606, 607, 611, 612, - 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, - 628, 630, 632, 634, 639, 640, 645, 646, 652, 653, - 659, 660, 661, 662, 663, 664, 665, 666, 667, 677, - 684, 686, 696, 697, 702, 704, 710, 712, 716, 717, - 722, 727, 730, 732, 734, 744, 746, 757, 758, 760, - 764, 766, 770, 771, 776, 777, 781, 786, 787, 791, - 793, 799, 800, 804, 806, 808, 810, 816, 817, 821, - 823, 828, 830, 832, 837, 839, 844, 846, 850, 853, - 857, 860, 864, 866, 868, 870, 875, 877, 879, 884, - 886, 888, 890, 892, 897, 899, 901, 903, 908, 920, - 921, 926, 928, 933, 937, 939, 941, 943, 945, 951, - 952, 958, 959, 963, 964, 969, 971, 977, 978, 980, - 985, 990, 1000, 1002, 1006, 1007, 1012, 1014, 1018, 1019, - 1023, 1025, 1029, 1030, 1034, 1035, 1039, 1040, 1055, 1056, - 1057, 1058, 1059, 1063, 1068, 1075, 1085, 1090, 1095, 1103, - 1108, 1113, 1118, 1123, 1131, 1153, 1158, 1165, 1167, 1174, - 1179, 1184, 1195, 1200, 1205, 1210, 1215, 1224, 1229, 1237, - 1238, 1239, 1240, 1246, 1251, 1259, 1260, 1261, 1262, 1266, - 1267, 1268, 1269, 1274, 1275, 1284, 1285, 1290, 1291, 1296, - 1298, 1300, 1302, 1304, 1307, 1306, 1318, 1319, 1321, 1331, - 1332, 1337, 1339, 1341, 1343, 1345, 1348, 1350, 1353, 1358, - 1360, 1362, 1364, 1366, 1368, 1370, 1372, 1374, 1376, 1378, - 1380, 1382, 1388, 1389, 1391, 1393, 1395, 1400, 1401, 1407, - 1408, 1410, 1412, 1417, 1419, 1421, 1423, 1428, 1429, 1431, - 1433, 1438, 1439, 1441, 1446, 1447, 1449, 1451, 1456, 1458, - 1460, 1465, 1466, 1470, 1472, 1478, 1477, 1481, 1483, 1488, - 1490, 1496, 1497, 1502, 1503, 1505, 1506, 1515, 1516, 1518, - 1520, 1525, 1527, 1533, 1534, 1536, 1539, 1542, 1547, 1548, - 1553, 1558, 1562, 1564, 1570, 1569, 1576, 1578, 1584, 1585, - 1593, 1594, 1598, 1599, 1600, 1602, 1604, 1611, 1612, 1614, - 1616, 1621, 1622, 1628, 1629, 1633, 1634, 1639, 1640, 1641, - 1643, 1651, 1652, 1654, 1657, 1659, 1663, 1664, 1665, 1667, - 1669, 1673, 1678, 1686, 1687, 1696, 1698, 1703, 1704, 1705, - 1709, 1710, 1711, 1715, 1716, 1717, 1721, 1722, 1723, 1728, - 1729, 1730, 1731, 1737, 1738, 1740, 1745, 1746, 1751, 1752, - 1753, 1754, 1755, 1770, 1771, 1776, 1777, 1783, 1785, 1788, - 1790, 1792, 1815, 1816, 1818, 1820, 1825, 1826, 1828, 1833, - 1838, 1839, 1845, 1844, 1848, 1852, 1854, 1856, 1862, 1863, - 1868, 1873, 1875, 1880, 1882, 1883, 1885, 1890, 1892, 1894, - 1899, 1901, 1906, 1911, 1919, 1925, 1924, 1938, 1939, 1944, - 1945, 1949, 1954, 1959, 1967, 1972, 1983, 1984, 1989, 1990, - 1996, 1997, 2001, 2002, 2003, 2006, 2005, 2016, 2025, 2031, - 2037, 2046, 2052, 2058, 2064, 2070, 2078, 2084, 2092, 2098, - 2107, 2108, 2109, 2113, 2117, 2119, 2124, 2125, 2129, 2130, - 2135, 2141, 2142, 2145, 2147, 2148, 2152, 2153, 2154, 2155, - 2189, 2191, 2192, 2194, 2199, 2204, 2209, 2211, 2213, 2218, - 2220, 2222, 2224, 2229, 2231, 2240, 2242, 2243, 2248, 2250, - 2252, 2257, 2259, 2261, 2266, 2268, 2270, 2279, 2280, 2281, - 2285, 2287, 2289, 2294, 2296, 2298, 2303, 2305, 2307, 2322, - 2324, 2325, 2327, 2332, 2333, 2338, 2340, 2342, 2347, 2349, - 2351, 2353, 2358, 2360, 2362, 2372, 2374, 2375, 2377, 2382, - 2384, 2386, 2391, 2393, 2395, 2397, 2402, 2404, 2406, 2437, - 2439, 2440, 2442, 2447, 2452, 2460, 2462, 2464, 2469, 2471, - 2476, 2478, 2492, 2493, 2495, 2500, 2502, 2504, 2506, 2508, - 2513, 2514, 2516, 2518, 2523, 2525, 2527, 2533, 2535, 2537, - 2541, 2543, 2545, 2547, 2561, 2562, 2564, 2569, 2571, 2573, - 2575, 2577, 2582, 2583, 2585, 2587, 2592, 2594, 2596, 2602, - 2603, 2605, 2614, 2617, 2619, 2622, 2624, 2626, 2639, 2640, - 2642, 2647, 2649, 2651, 2653, 2655, 2660, 2661, 2663, 2665, - 2670, 2672, 2680, 2681, 2682, 2687, 2688, 2692, 2694, 2696, - 2698, 2700, 2702, 2709, 2711, 2713, 2715, 2717, 2719, 2721, - 2723, 2725, 2727, 2732, 2734, 2736, 2741, 2767, 2768, 2770, - 2774, 2775, 2779, 2781, 2783, 2785, 2787, 2789, 2796, 2798, - 2800, 2802, 2804, 2806, 2811, 2816, 2818, 2820, 2838, 2840, - 2845, 2846 + 0, 302, 302, 306, 313, 314, 315, 319, 320, 321, + 325, 326, 330, 331, 335, 336, 340, 344, 345, 356, + 358, 360, 362, 367, 368, 374, 378, 380, 382, 384, + 386, 388, 390, 392, 394, 403, 404, 410, 411, 415, + 416, 420, 424, 426, 428, 430, 435, 436, 440, 443, + 445, 447, 452, 465, 467, 469, 471, 473, 475, 477, + 479, 481, 483, 485, 492, 493, 499, 500, 501, 502, + 506, 507, 509, 514, 515, 517, 519, 524, 525, 527, + 532, 533, 535, 540, 541, 543, 545, 547, 552, 553, + 555, 560, 561, 566, 567, 572, 573, 578, 579, 584, + 585, 590, 591, 594, 596, 601, 606, 607, 609, 615, + 616, 620, 621, 622, 623, 624, 625, 626, 627, 628, + 629, 630, 631, 637, 639, 641, 643, 648, 649, 654, + 655, 661, 662, 668, 669, 670, 671, 672, 673, 674, + 675, 676, 686, 693, 695, 705, 706, 711, 713, 719, + 721, 725, 726, 731, 736, 739, 741, 743, 753, 755, + 766, 767, 769, 773, 775, 779, 780, 785, 786, 790, + 795, 796, 800, 802, 808, 809, 813, 815, 817, 819, + 825, 826, 830, 832, 837, 839, 841, 846, 848, 853, + 855, 859, 862, 866, 869, 873, 875, 877, 879, 884, + 886, 888, 893, 895, 897, 899, 901, 906, 908, 910, + 912, 917, 929, 930, 935, 937, 942, 946, 948, 950, + 952, 954, 960, 961, 967, 968, 972, 973, 978, 980, + 986, 987, 989, 994, 999, 1009, 1011, 1015, 1016, 1021, + 1023, 1027, 1028, 1032, 1034, 1038, 1039, 1043, 1044, 1048, + 1049, 1064, 1065, 1066, 1067, 1068, 1072, 1077, 1084, 1094, + 1099, 1104, 1112, 1117, 1122, 1127, 1132, 1140, 1162, 1167, + 1174, 1176, 1183, 1188, 1193, 1204, 1209, 1214, 1219, 1224, + 1233, 1238, 1246, 1247, 1248, 1249, 1255, 1260, 1268, 1269, + 1270, 1271, 1275, 1276, 1277, 1278, 1283, 1284, 1293, 1294, + 1299, 1300, 1305, 1307, 1309, 1311, 1313, 1316, 1315, 1327, + 1328, 1330, 1340, 1341, 1346, 1348, 1350, 1352, 1354, 1357, + 1359, 1362, 1367, 1369, 1371, 1373, 1375, 1377, 1379, 1381, + 1383, 1385, 1387, 1389, 1391, 1397, 1398, 1400, 1402, 1404, + 1409, 1410, 1416, 1417, 1419, 1421, 1426, 1428, 1430, 1432, + 1437, 1438, 1440, 1442, 1447, 1448, 1450, 1455, 1456, 1458, + 1460, 1465, 1467, 1469, 1474, 1475, 1479, 1481, 1487, 1486, + 1490, 1492, 1497, 1499, 1505, 1506, 1511, 1512, 1514, 1515, + 1524, 1525, 1527, 1529, 1534, 1536, 1542, 1543, 1545, 1548, + 1551, 1556, 1557, 1562, 1567, 1571, 1573, 1579, 1578, 1585, + 1587, 1593, 1594, 1602, 1603, 1607, 1608, 1609, 1611, 1613, + 1620, 1621, 1623, 1625, 1630, 1631, 1637, 1638, 1642, 1643, + 1648, 1649, 1650, 1652, 1660, 1661, 1663, 1666, 1668, 1672, + 1673, 1674, 1676, 1678, 1682, 1687, 1695, 1696, 1705, 1707, + 1712, 1713, 1714, 1718, 1719, 1720, 1724, 1725, 1726, 1730, + 1731, 1732, 1737, 1738, 1739, 1740, 1746, 1747, 1749, 1754, + 1755, 1760, 1761, 1762, 1763, 1764, 1779, 1780, 1785, 1786, + 1792, 1794, 1797, 1799, 1801, 1824, 1825, 1827, 1829, 1834, + 1835, 1837, 1842, 1847, 1848, 1854, 1853, 1857, 1861, 1863, + 1865, 1871, 1872, 1877, 1882, 1884, 1889, 1891, 1892, 1894, + 1899, 1901, 1903, 1908, 1910, 1915, 1920, 1928, 1934, 1933, + 1947, 1948, 1953, 1954, 1958, 1963, 1968, 1976, 1981, 1992, + 1993, 1998, 1999, 2005, 2006, 2010, 2011, 2012, 2015, 2014, + 2025, 2034, 2040, 2046, 2055, 2061, 2067, 2073, 2079, 2087, + 2093, 2101, 2107, 2116, 2117, 2118, 2122, 2126, 2128, 2133, + 2134, 2138, 2139, 2144, 2150, 2151, 2154, 2156, 2157, 2161, + 2162, 2163, 2164, 2198, 2200, 2201, 2203, 2208, 2213, 2218, + 2220, 2222, 2227, 2229, 2231, 2233, 2238, 2240, 2249, 2251, + 2252, 2257, 2259, 2261, 2266, 2268, 2270, 2275, 2277, 2279, + 2288, 2289, 2290, 2294, 2296, 2298, 2303, 2305, 2307, 2312, + 2314, 2316, 2331, 2333, 2334, 2336, 2341, 2342, 2347, 2349, + 2351, 2356, 2358, 2360, 2362, 2367, 2369, 2371, 2381, 2383, + 2384, 2386, 2391, 2393, 2395, 2400, 2402, 2404, 2406, 2411, + 2413, 2415, 2446, 2448, 2449, 2451, 2456, 2461, 2469, 2471, + 2473, 2478, 2480, 2485, 2487, 2501, 2502, 2504, 2509, 2511, + 2513, 2515, 2517, 2522, 2523, 2525, 2527, 2532, 2534, 2536, + 2542, 2544, 2546, 2550, 2552, 2554, 2556, 2570, 2571, 2573, + 2578, 2580, 2582, 2584, 2586, 2591, 2592, 2594, 2596, 2601, + 2603, 2605, 2611, 2612, 2614, 2623, 2626, 2628, 2631, 2633, + 2635, 2648, 2649, 2651, 2656, 2658, 2660, 2662, 2664, 2669, + 2670, 2672, 2674, 2679, 2681, 2689, 2690, 2691, 2696, 2697, + 2701, 2703, 2705, 2707, 2709, 2711, 2718, 2720, 2722, 2724, + 2726, 2728, 2730, 2732, 2734, 2736, 2741, 2743, 2745, 2750, + 2776, 2777, 2779, 2783, 2784, 2788, 2790, 2792, 2794, 2796, + 2798, 2805, 2807, 2809, 2811, 2813, 2815, 2820, 2825, 2827, + 2829, 2847, 2849, 2854, 2855 }; #endif @@ -1128,28 +1130,28 @@ "string_literal", "string_literal_list", "primary_expression", "postfix_expression", "argument_expression_list", "argument_expression", - "field_list", "field", "unary_expression", "ptrref_operator", - "unary_operator", "cast_expression", "multiplicative_expression", - "additive_expression", "shift_expression", "relational_expression", - "equality_expression", "AND_expression", "exclusive_OR_expression", - "inclusive_OR_expression", "logical_AND_expression", - "logical_OR_expression", "conditional_expression", "constant_expression", - "assignment_expression", "assignment_expression_opt", - "assignment_operator", "tuple", "tuple_expression_list", - "comma_expression", "comma_expression_opt", "statement", - "labeled_statement", "compound_statement", "block_item_list", - "block_item", "statement_list", "expression_statement", - "selection_statement", "case_value", "case_value_list", "case_label", - "case_label_list", "case_clause", "switch_clause_list_opt", - "switch_clause_list", "choose_clause_list_opt", "choose_clause_list", - "fall_through_opt", "fall_through", "iteration_statement", - "for_control_expression", "jump_statement", "exception_statement", - "handler_list", "handler_clause", "finally_clause", - "exception_declaration", "asm_statement", "asm_volatile_opt", - "asm_operands_opt", "asm_operands_list", "asm_operand", - "asm_clobbers_list_opt", "label_list", "declaration_list_opt", - "declaration_list", "old_declaration_list_opt", "old_declaration_list", - "local_label_declaration_opt", "local_label_declaration_list", - "local_label_list", "declaration", "new_declaration", - "new_variable_declaration", "new_variable_specifier", + "field_list", "field", "field_name", "unary_expression", + "ptrref_operator", "unary_operator", "cast_expression", + "multiplicative_expression", "additive_expression", "shift_expression", + "relational_expression", "equality_expression", "AND_expression", + "exclusive_OR_expression", "inclusive_OR_expression", + "logical_AND_expression", "logical_OR_expression", + "conditional_expression", "constant_expression", "assignment_expression", + "assignment_expression_opt", "assignment_operator", "tuple", + "tuple_expression_list", "comma_expression", "comma_expression_opt", + "statement", "labeled_statement", "compound_statement", + "block_item_list", "block_item", "statement_list", + "expression_statement", "selection_statement", "case_value", + "case_value_list", "case_label", "case_label_list", "case_clause", + "switch_clause_list_opt", "switch_clause_list", "choose_clause_list_opt", + "choose_clause_list", "fall_through_opt", "fall_through", + "iteration_statement", "for_control_expression", "jump_statement", + "exception_statement", "handler_list", "handler_clause", + "finally_clause", "exception_declaration", "asm_statement", + "asm_volatile_opt", "asm_operands_opt", "asm_operands_list", + "asm_operand", "asm_clobbers_list_opt", "label_list", + "declaration_list_opt", "declaration_list", "old_declaration_list_opt", + "old_declaration_list", "local_label_declaration_opt", + "local_label_declaration_list", "local_label_list", "declaration", + "new_declaration", "new_variable_declaration", "new_variable_specifier", "new_function_declaration", "new_function_specifier", "new_function_return", "new_typedef_declaration", "typedef_declaration", @@ -1241,77 +1243,77 @@ 138, 138, 139, 139, 140, 140, 141, 142, 142, 143, 143, 143, 143, 144, 144, 144, 144, 144, 144, 144, - 144, 144, 144, 144, 145, 145, 146, 146, 147, 147, - 148, 148, 148, 148, 148, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 150, 150, 151, 151, 151, 151, 152, 152, 152, - 153, 153, 153, 153, 154, 154, 154, 155, 155, 155, - 156, 156, 156, 156, 156, 157, 157, 157, 158, 158, - 159, 159, 160, 160, 161, 161, 162, 162, 163, 163, - 163, 163, 164, 165, 165, 165, 166, 166, 167, 167, - 167, 167, 167, 167, 167, 167, 167, 167, 167, 167, - 168, 168, 168, 168, 169, 169, 170, 170, 171, 171, - 172, 172, 172, 172, 172, 172, 172, 172, 172, 173, - 174, 174, 175, 175, 176, 176, 176, 176, 177, 177, - 178, 179, 179, 179, 179, 179, 179, 180, 180, 180, - 181, 181, 182, 182, 183, 183, 184, 185, 185, 186, - 186, 187, 187, 188, 188, 188, 188, 189, 189, 190, - 190, 191, 191, 191, 192, 192, 193, 193, 193, 193, - 193, 193, 193, 193, 193, 193, 194, 194, 194, 195, - 195, 195, 195, 195, 196, 196, 196, 196, 197, 198, - 198, 198, 198, 198, 199, 199, 199, 199, 199, 200, - 200, 201, 201, 202, 202, 203, 203, 204, 204, 204, - 205, 205, 206, 206, 207, 207, 208, 208, 209, 209, - 210, 210, 211, 211, 212, 212, 213, 213, 214, 214, - 214, 214, 214, 215, 215, 215, 216, 216, 216, 217, - 217, 217, 217, 217, 218, 218, 218, 219, 219, 220, - 220, 220, 221, 221, 221, 221, 221, 222, 222, 223, - 223, 223, 223, 224, 224, 225, 225, 225, 225, 226, - 226, 226, 226, 227, 227, 228, 228, 229, 229, 230, - 230, 230, 230, 230, 231, 230, 232, 232, 232, 233, - 233, 234, 234, 234, 234, 234, 234, 234, 234, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 236, 236, 236, 236, 236, 237, 237, 238, - 238, 238, 238, 239, 239, 239, 239, 240, 240, 240, - 240, 241, 241, 241, 242, 242, 242, 242, 243, 243, - 243, 244, 244, 245, 245, 246, 245, 245, 245, 247, - 247, 248, 248, 249, 249, 249, 249, 250, 250, 250, - 250, 251, 251, 252, 252, 252, 252, 252, 253, 253, - 254, 255, 256, 256, 257, 256, 258, 258, 259, 259, - 260, 260, 261, 261, 261, 261, 261, 262, 262, 262, - 262, 263, 263, 264, 264, 265, 265, 266, 266, 266, - 266, 267, 267, 267, 267, 267, 268, 268, 268, 268, - 268, 269, 269, 270, 270, 271, 271, 272, 272, 272, + 144, 144, 144, 144, 144, 145, 145, 146, 146, 147, + 147, 148, 148, 148, 148, 148, 149, 149, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 151, 151, 152, 152, 152, 152, + 153, 153, 153, 154, 154, 154, 154, 155, 155, 155, + 156, 156, 156, 157, 157, 157, 157, 157, 158, 158, + 158, 159, 159, 160, 160, 161, 161, 162, 162, 163, + 163, 164, 164, 164, 164, 165, 166, 166, 166, 167, + 167, 168, 168, 168, 168, 168, 168, 168, 168, 168, + 168, 168, 168, 169, 169, 169, 169, 170, 170, 171, + 171, 172, 172, 173, 173, 173, 173, 173, 173, 173, + 173, 173, 174, 175, 175, 176, 176, 177, 177, 177, + 177, 178, 178, 179, 180, 180, 180, 180, 180, 180, + 181, 181, 181, 182, 182, 183, 183, 184, 184, 185, + 186, 186, 187, 187, 188, 188, 189, 189, 189, 189, + 190, 190, 191, 191, 192, 192, 192, 193, 193, 194, + 194, 194, 194, 194, 194, 194, 194, 194, 194, 195, + 195, 195, 196, 196, 196, 196, 196, 197, 197, 197, + 197, 198, 199, 199, 199, 199, 199, 200, 200, 200, + 200, 200, 201, 201, 202, 202, 203, 203, 204, 204, + 205, 205, 205, 206, 206, 207, 207, 208, 208, 209, + 209, 210, 210, 211, 211, 212, 212, 213, 213, 214, + 214, 215, 215, 215, 215, 215, 216, 216, 216, 217, + 217, 217, 218, 218, 218, 218, 218, 219, 219, 219, + 220, 220, 221, 221, 221, 222, 222, 222, 222, 222, + 223, 223, 224, 224, 224, 224, 225, 225, 226, 226, + 226, 226, 227, 227, 227, 227, 228, 228, 229, 229, + 230, 230, 231, 231, 231, 231, 231, 232, 231, 233, + 233, 233, 234, 234, 235, 235, 235, 235, 235, 235, + 235, 235, 236, 236, 236, 236, 236, 236, 236, 236, + 236, 236, 236, 236, 236, 237, 237, 237, 237, 237, + 238, 238, 239, 239, 239, 239, 240, 240, 240, 240, + 241, 241, 241, 241, 242, 242, 242, 243, 243, 243, + 243, 244, 244, 244, 245, 245, 246, 246, 247, 246, + 246, 246, 248, 248, 249, 249, 250, 250, 250, 250, + 251, 251, 251, 251, 252, 252, 253, 253, 253, 253, + 253, 254, 254, 255, 256, 257, 257, 258, 257, 259, + 259, 260, 260, 261, 261, 262, 262, 262, 262, 262, + 263, 263, 263, 263, 264, 264, 265, 265, 266, 266, + 267, 267, 267, 267, 268, 268, 268, 268, 268, 269, + 269, 269, 269, 269, 270, 270, 271, 271, 272, 272, 273, 273, 273, 274, 274, 274, 275, 275, 275, 276, - 276, 276, 276, 277, 277, 277, 278, 278, 279, 279, - 279, 279, 279, 280, 280, 281, 281, 282, 282, 282, - 282, 282, 283, 283, 283, 283, 284, 284, 284, 285, - 286, 286, 288, 287, 287, 289, 289, 289, 290, 290, - 291, 291, 291, 292, 292, 292, 292, 293, 293, 293, - 294, 294, 295, 295, 296, 297, 296, 298, 298, 299, - 299, 300, 300, 300, 301, 301, 302, 302, 303, 303, - 304, 304, 305, 305, 305, 306, 305, 305, 307, 307, - 307, 308, 308, 308, 308, 308, 308, 308, 308, 308, - 309, 309, 309, 310, 311, 311, 312, 312, 313, 313, - 314, 315, 315, 316, 316, 316, 317, 317, 317, 317, - 318, 318, 318, 318, 319, 319, 320, 320, 320, 321, - 321, 321, 321, 322, 322, 323, 323, 323, 324, 324, + 276, 276, 277, 277, 277, 277, 278, 278, 278, 279, + 279, 280, 280, 280, 280, 280, 281, 281, 282, 282, + 283, 283, 283, 283, 283, 284, 284, 284, 284, 285, + 285, 285, 286, 287, 287, 289, 288, 288, 290, 290, + 290, 291, 291, 292, 292, 292, 293, 293, 293, 293, + 294, 294, 294, 295, 295, 296, 296, 297, 298, 297, + 299, 299, 300, 300, 301, 301, 301, 302, 302, 303, + 303, 304, 304, 305, 305, 306, 306, 306, 307, 306, + 306, 308, 308, 308, 309, 309, 309, 309, 309, 309, + 309, 309, 309, 310, 310, 310, 311, 312, 312, 313, + 313, 314, 314, 315, 316, 316, 317, 317, 317, 318, + 318, 318, 318, 319, 319, 319, 319, 320, 320, 321, + 321, 321, 322, 322, 322, 322, 323, 323, 324, 324, 324, 325, 325, 325, 326, 326, 326, 327, 327, 327, 328, 328, 328, 329, 329, 329, 330, 330, 330, 331, - 331, 331, 331, 332, 332, 333, 333, 333, 334, 334, - 334, 334, 335, 335, 335, 336, 336, 336, 336, 337, - 337, 337, 338, 338, 338, 338, 339, 339, 339, 340, - 340, 340, 340, 341, 341, 342, 342, 342, 343, 343, - 344, 344, 345, 345, 345, 346, 346, 346, 346, 346, - 347, 347, 347, 347, 348, 348, 348, 349, 349, 349, - 350, 350, 350, 350, 351, 351, 351, 352, 352, 352, - 352, 352, 353, 353, 353, 353, 354, 354, 354, 355, - 355, 355, 356, 356, 356, 356, 356, 356, 357, 357, - 357, 358, 358, 358, 358, 358, 359, 359, 359, 359, - 360, 360, 361, 361, 361, 362, 362, 363, 363, 363, - 363, 363, 363, 364, 364, 364, 364, 364, 364, 364, - 364, 364, 364, 365, 365, 365, 365, 366, 366, 366, - 367, 367, 368, 368, 368, 368, 368, 368, 369, 369, - 369, 369, 369, 369, 370, 371, 371, 371, 372, 372, - 373, 373 + 331, 331, 332, 332, 332, 332, 333, 333, 334, 334, + 334, 335, 335, 335, 335, 336, 336, 336, 337, 337, + 337, 337, 338, 338, 338, 339, 339, 339, 339, 340, + 340, 340, 341, 341, 341, 341, 342, 342, 343, 343, + 343, 344, 344, 345, 345, 346, 346, 346, 347, 347, + 347, 347, 347, 348, 348, 348, 348, 349, 349, 349, + 350, 350, 350, 351, 351, 351, 351, 352, 352, 352, + 353, 353, 353, 353, 353, 354, 354, 354, 354, 355, + 355, 355, 356, 356, 356, 357, 357, 357, 357, 357, + 357, 358, 358, 358, 359, 359, 359, 359, 359, 360, + 360, 360, 360, 361, 361, 362, 362, 362, 363, 363, + 364, 364, 364, 364, 364, 364, 365, 365, 365, 365, + 365, 365, 365, 365, 365, 365, 366, 366, 366, 366, + 367, 367, 367, 368, 368, 369, 369, 369, 369, 369, + 369, 370, 370, 370, 370, 370, 370, 371, 372, 372, + 372, 373, 373, 374, 374 }; @@ -1321,78 +1323,78 @@ 0, 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, - 1, 3, 3, 1, 6, 4, 3, 7, 3, 7, - 2, 2, 7, 4, 1, 3, 0, 1, 1, 3, - 1, 3, 7, 3, 7, 1, 1, 1, 2, 2, - 2, 2, 2, 2, 4, 2, 4, 6, 1, 4, - 4, 1, 1, 1, 1, 1, 1, 1, 4, 4, - 1, 3, 3, 3, 1, 3, 3, 1, 3, 3, - 1, 3, 3, 3, 3, 1, 3, 3, 1, 3, - 1, 3, 1, 3, 1, 3, 1, 3, 1, 5, - 4, 5, 1, 1, 3, 2, 0, 1, 1, 1, + 1, 3, 3, 1, 6, 4, 3, 7, 3, 3, + 7, 2, 2, 7, 4, 1, 3, 0, 1, 1, + 3, 1, 3, 7, 3, 7, 1, 1, 1, 1, + 1, 2, 2, 2, 2, 2, 2, 4, 2, 4, + 6, 1, 4, 4, 1, 1, 1, 1, 1, 1, + 1, 4, 4, 1, 3, 3, 3, 1, 3, 3, + 1, 3, 3, 1, 3, 3, 3, 3, 1, 3, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, + 3, 1, 5, 4, 5, 1, 1, 3, 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 2, 5, 6, 7, 1, 3, 1, 3, 0, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 6, 4, - 2, 7, 1, 3, 1, 2, 1, 2, 1, 2, - 2, 5, 7, 5, 9, 5, 9, 1, 3, 1, - 1, 3, 3, 2, 1, 2, 2, 0, 1, 2, - 3, 0, 1, 2, 3, 3, 4, 0, 1, 1, - 2, 5, 7, 6, 6, 4, 3, 4, 2, 3, - 2, 3, 3, 3, 3, 5, 3, 3, 4, 1, - 5, 6, 5, 6, 9, 10, 9, 10, 2, 1, - 2, 2, 2, 1, 6, 8, 10, 12, 14, 0, - 1, 0, 1, 1, 3, 4, 7, 0, 1, 3, - 1, 3, 1, 1, 1, 3, 1, 1, 1, 3, - 0, 1, 3, 4, 1, 3, 1, 1, 3, 3, - 3, 3, 3, 2, 3, 6, 3, 3, 4, 1, - 2, 2, 3, 5, 8, 7, 7, 5, 9, 2, - 2, 5, 3, 5, 4, 3, 4, 4, 7, 3, - 3, 3, 3, 4, 6, 1, 1, 1, 1, 1, - 1, 1, 1, 0, 1, 1, 2, 1, 1, 1, - 1, 1, 1, 1, 0, 5, 1, 2, 3, 1, - 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 5, 6, 7, 1, 3, 1, + 3, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 6, 4, 2, 7, 1, 3, 1, 2, 1, + 2, 1, 2, 2, 5, 7, 5, 9, 5, 9, + 1, 3, 1, 1, 3, 3, 2, 1, 2, 2, + 0, 1, 2, 3, 0, 1, 2, 3, 3, 4, + 0, 1, 1, 2, 5, 7, 6, 6, 4, 3, + 4, 2, 3, 2, 3, 3, 3, 3, 5, 3, + 3, 4, 1, 5, 6, 5, 6, 9, 10, 9, + 10, 2, 1, 2, 2, 2, 1, 6, 8, 10, + 12, 14, 0, 1, 0, 1, 1, 3, 4, 7, + 0, 1, 3, 1, 3, 1, 1, 1, 3, 1, + 1, 1, 3, 0, 1, 3, 4, 1, 3, 1, + 1, 3, 3, 3, 3, 3, 2, 3, 6, 3, + 3, 4, 1, 2, 2, 3, 5, 8, 7, 7, + 5, 9, 2, 2, 5, 3, 5, 4, 3, 4, + 4, 7, 3, 3, 3, 3, 4, 6, 1, 1, + 1, 1, 1, 1, 1, 1, 0, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 0, 5, 1, + 2, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 2, 2, 3, 3, 1, 3, 1, - 2, 2, 2, 4, 4, 4, 4, 1, 2, 2, - 3, 1, 2, 2, 1, 2, 2, 3, 1, 2, - 2, 1, 1, 4, 2, 0, 6, 7, 2, 2, - 2, 0, 2, 2, 3, 2, 3, 1, 2, 3, - 2, 2, 4, 0, 1, 2, 2, 1, 0, 1, - 2, 2, 5, 2, 0, 7, 2, 4, 0, 2, - 0, 1, 1, 1, 5, 5, 5, 1, 5, 5, - 9, 1, 5, 0, 1, 1, 5, 1, 1, 5, - 5, 1, 3, 3, 4, 1, 1, 1, 1, 2, - 1, 3, 3, 1, 2, 1, 3, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, - 1, 1, 2, 0, 2, 2, 1, 4, 0, 1, - 2, 3, 4, 2, 2, 1, 2, 2, 5, 5, - 7, 6, 1, 2, 2, 3, 1, 2, 2, 4, - 2, 4, 0, 4, 2, 1, 1, 1, 0, 2, - 5, 5, 13, 1, 1, 3, 3, 2, 3, 3, - 2, 4, 1, 6, 9, 0, 11, 1, 3, 3, - 3, 1, 1, 5, 2, 5, 0, 1, 1, 3, - 0, 1, 1, 1, 1, 0, 6, 2, 1, 2, - 4, 2, 3, 3, 3, 4, 5, 5, 5, 6, - 1, 1, 1, 3, 0, 5, 0, 1, 1, 2, - 6, 1, 3, 0, 1, 4, 1, 1, 1, 1, - 2, 1, 2, 2, 1, 3, 2, 3, 3, 2, - 4, 4, 3, 8, 3, 2, 1, 2, 6, 8, - 3, 2, 3, 3, 4, 4, 3, 1, 1, 1, - 4, 6, 3, 2, 3, 3, 4, 4, 3, 2, - 1, 2, 2, 1, 3, 2, 3, 3, 2, 4, - 4, 3, 6, 8, 3, 2, 1, 2, 2, 2, - 3, 3, 2, 4, 4, 3, 6, 8, 3, 2, - 1, 2, 2, 1, 1, 2, 3, 3, 2, 4, - 6, 8, 1, 2, 2, 1, 2, 2, 3, 3, - 1, 4, 4, 3, 5, 8, 3, 2, 3, 1, - 5, 5, 6, 6, 1, 2, 2, 1, 2, 2, - 3, 3, 1, 4, 4, 3, 5, 8, 3, 1, - 2, 1, 2, 6, 5, 6, 7, 7, 1, 2, - 2, 1, 2, 2, 3, 3, 1, 4, 4, 3, - 8, 3, 1, 1, 2, 1, 1, 2, 3, 2, - 3, 2, 3, 3, 2, 4, 3, 2, 3, 2, - 4, 3, 2, 6, 6, 6, 7, 1, 2, 1, - 1, 1, 2, 3, 2, 3, 2, 3, 3, 4, - 2, 3, 4, 2, 5, 5, 6, 6, 0, 1, - 0, 2 + 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, + 1, 3, 1, 2, 2, 2, 4, 4, 4, 4, + 1, 2, 2, 3, 1, 2, 2, 1, 2, 2, + 3, 1, 2, 2, 1, 1, 4, 2, 0, 6, + 7, 2, 2, 2, 0, 2, 2, 3, 2, 3, + 1, 2, 3, 2, 2, 4, 0, 1, 2, 2, + 1, 0, 1, 2, 2, 5, 2, 0, 7, 2, + 4, 0, 2, 0, 1, 1, 1, 5, 5, 5, + 1, 5, 5, 9, 1, 5, 0, 1, 1, 5, + 1, 1, 5, 5, 1, 3, 3, 4, 1, 1, + 1, 1, 2, 1, 3, 3, 1, 2, 1, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 2, 0, 2, 2, 1, + 4, 0, 1, 2, 3, 4, 2, 2, 1, 2, + 2, 5, 5, 7, 6, 1, 2, 2, 3, 1, + 2, 2, 4, 2, 4, 0, 4, 2, 1, 1, + 1, 0, 2, 5, 5, 13, 1, 1, 3, 3, + 2, 3, 3, 2, 4, 1, 6, 9, 0, 11, + 1, 3, 3, 3, 1, 1, 5, 2, 5, 0, + 1, 1, 3, 0, 1, 1, 1, 1, 0, 6, + 2, 1, 2, 4, 2, 3, 3, 3, 4, 5, + 5, 5, 6, 1, 1, 1, 3, 0, 5, 0, + 1, 1, 2, 6, 1, 3, 0, 1, 4, 1, + 1, 1, 1, 2, 1, 2, 2, 1, 3, 2, + 3, 3, 2, 4, 4, 3, 8, 3, 2, 1, + 2, 6, 8, 3, 2, 3, 3, 4, 4, 3, + 1, 1, 1, 4, 6, 3, 2, 3, 3, 4, + 4, 3, 2, 1, 2, 2, 1, 3, 2, 3, + 3, 2, 4, 4, 3, 6, 8, 3, 2, 1, + 2, 2, 2, 3, 3, 2, 4, 4, 3, 6, + 8, 3, 2, 1, 2, 2, 1, 1, 2, 3, + 3, 2, 4, 6, 8, 1, 2, 2, 1, 2, + 2, 3, 3, 1, 4, 4, 3, 5, 8, 3, + 2, 3, 1, 5, 5, 6, 6, 1, 2, 2, + 1, 2, 2, 3, 3, 1, 4, 4, 3, 5, + 8, 3, 1, 2, 1, 2, 6, 5, 6, 7, + 7, 1, 2, 2, 1, 2, 2, 3, 3, 1, + 4, 4, 3, 8, 3, 1, 1, 2, 1, 1, + 2, 3, 2, 3, 2, 3, 3, 2, 4, 3, + 2, 3, 2, 4, 3, 2, 6, 6, 6, 7, + 1, 2, 1, 1, 1, 2, 3, 2, 3, 2, + 3, 3, 4, 2, 3, 4, 2, 5, 5, 6, + 6, 0, 1, 0, 2 }; @@ -1402,160 +1404,160 @@ static const yytype_uint16 yydefact[] = { - 293, 293, 313, 311, 314, 312, 315, 316, 299, 301, - 300, 0, 302, 327, 319, 324, 322, 323, 321, 320, - 325, 326, 331, 328, 329, 330, 546, 546, 546, 0, - 0, 0, 293, 219, 303, 317, 318, 7, 358, 0, - 8, 14, 15, 0, 2, 61, 62, 564, 9, 293, - 524, 522, 246, 3, 453, 3, 259, 0, 3, 3, - 3, 247, 3, 0, 0, 0, 294, 295, 297, 293, - 306, 309, 339, 285, 332, 337, 286, 347, 287, 354, - 351, 361, 0, 0, 362, 288, 472, 476, 3, 3, - 0, 2, 518, 523, 528, 298, 0, 0, 546, 576, - 546, 2, 587, 588, 589, 293, 0, 730, 731, 0, - 12, 0, 13, 293, 269, 270, 0, 294, 289, 290, - 291, 292, 525, 304, 391, 547, 548, 369, 370, 12, - 444, 445, 11, 440, 443, 0, 502, 497, 488, 444, - 445, 0, 0, 527, 220, 0, 293, 0, 0, 0, - 0, 0, 0, 0, 0, 293, 293, 2, 0, 732, - 294, 581, 593, 736, 729, 727, 734, 0, 0, 0, - 253, 2, 0, 531, 438, 439, 437, 0, 0, 0, - 0, 546, 0, 633, 634, 0, 0, 544, 540, 546, - 561, 546, 546, 542, 2, 541, 546, 600, 546, 546, - 603, 0, 0, 0, 293, 293, 311, 359, 2, 293, - 260, 296, 307, 340, 352, 477, 0, 2, 0, 453, - 261, 294, 333, 348, 355, 473, 0, 2, 0, 310, - 334, 341, 342, 0, 349, 353, 356, 360, 445, 293, - 371, 364, 368, 0, 393, 474, 478, 0, 0, 0, - 1, 293, 2, 529, 575, 577, 293, 2, 740, 294, - 743, 544, 544, 0, 294, 0, 0, 272, 546, 542, - 2, 293, 0, 0, 293, 549, 2, 500, 2, 553, - 0, 0, 0, 0, 0, 0, 19, 58, 4, 5, - 6, 17, 0, 0, 293, 2, 63, 64, 65, 66, - 46, 20, 47, 16, 23, 45, 67, 293, 0, 70, - 74, 77, 80, 85, 88, 90, 92, 94, 96, 98, - 103, 494, 750, 451, 493, 0, 449, 450, 0, 565, - 580, 583, 586, 592, 595, 598, 358, 0, 2, 738, - 0, 293, 741, 2, 61, 293, 3, 425, 0, 433, - 294, 293, 306, 332, 286, 347, 354, 3, 3, 407, - 411, 421, 426, 472, 293, 427, 705, 706, 293, 428, - 430, 293, 2, 582, 594, 728, 2, 2, 248, 2, - 458, 0, 456, 455, 454, 140, 2, 2, 250, 2, - 2, 249, 2, 280, 2, 281, 0, 279, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 566, 605, 0, - 453, 2, 560, 569, 659, 562, 563, 532, 293, 2, - 599, 608, 601, 602, 0, 275, 293, 293, 338, 294, - 0, 294, 0, 293, 733, 737, 735, 533, 293, 544, - 254, 262, 308, 0, 2, 534, 293, 498, 335, 336, - 282, 350, 357, 0, 293, 0, 748, 398, 0, 475, - 499, 251, 252, 519, 293, 435, 0, 293, 236, 0, - 2, 238, 0, 294, 0, 256, 2, 257, 277, 0, - 0, 2, 293, 544, 293, 485, 487, 486, 0, 0, - 750, 0, 293, 0, 293, 489, 293, 559, 557, 558, - 556, 0, 551, 554, 0, 0, 293, 53, 293, 67, - 48, 293, 55, 293, 293, 51, 52, 2, 126, 0, - 0, 447, 0, 446, 727, 120, 293, 18, 0, 30, - 31, 36, 2, 0, 36, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 109, 108, 0, 49, 50, + 296, 296, 316, 314, 317, 315, 318, 319, 302, 304, + 303, 0, 305, 330, 322, 327, 325, 326, 324, 323, + 328, 329, 334, 331, 332, 333, 549, 549, 549, 0, + 0, 0, 296, 222, 306, 320, 321, 7, 361, 0, + 8, 14, 15, 0, 2, 64, 65, 567, 9, 296, + 527, 525, 249, 3, 456, 3, 262, 0, 3, 3, + 3, 250, 3, 0, 0, 0, 297, 298, 300, 296, + 309, 312, 342, 288, 335, 340, 289, 350, 290, 357, + 354, 364, 0, 0, 365, 291, 475, 479, 3, 3, + 0, 2, 521, 526, 531, 301, 0, 0, 549, 579, + 549, 2, 590, 591, 592, 296, 0, 733, 734, 0, + 12, 0, 13, 296, 272, 273, 0, 297, 292, 293, + 294, 295, 528, 307, 394, 550, 551, 372, 373, 12, + 447, 448, 11, 443, 446, 0, 505, 500, 491, 447, + 448, 0, 0, 530, 223, 0, 296, 0, 0, 0, + 0, 0, 0, 0, 0, 296, 296, 2, 0, 735, + 297, 584, 596, 739, 732, 730, 737, 0, 0, 0, + 256, 2, 0, 534, 441, 442, 440, 0, 0, 0, + 0, 549, 0, 636, 637, 0, 0, 547, 543, 549, + 564, 549, 549, 545, 2, 544, 549, 603, 549, 549, + 606, 0, 0, 0, 296, 296, 314, 362, 2, 296, + 263, 299, 310, 343, 355, 480, 0, 2, 0, 456, + 264, 297, 336, 351, 358, 476, 0, 2, 0, 313, + 337, 344, 345, 0, 352, 356, 359, 363, 448, 296, + 374, 367, 371, 0, 396, 477, 481, 0, 0, 0, + 1, 296, 2, 532, 578, 580, 296, 2, 743, 297, + 746, 547, 547, 0, 297, 0, 0, 275, 549, 545, + 2, 296, 0, 0, 296, 552, 2, 503, 2, 556, + 0, 0, 0, 0, 0, 0, 19, 61, 4, 5, + 6, 17, 0, 0, 296, 2, 66, 67, 68, 69, + 49, 20, 50, 16, 23, 48, 70, 296, 0, 73, + 77, 80, 83, 88, 91, 93, 95, 97, 99, 101, + 106, 497, 753, 454, 496, 0, 452, 453, 0, 568, + 583, 586, 589, 595, 598, 601, 361, 0, 2, 741, + 0, 296, 744, 2, 64, 296, 3, 428, 0, 436, + 297, 296, 309, 335, 289, 350, 357, 3, 3, 410, + 414, 424, 429, 475, 296, 430, 708, 709, 296, 431, + 433, 296, 2, 585, 597, 731, 2, 2, 251, 2, + 461, 0, 459, 458, 457, 143, 2, 2, 253, 2, + 2, 252, 2, 283, 2, 284, 0, 282, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 569, 608, 0, + 456, 2, 563, 572, 662, 565, 566, 535, 296, 2, + 602, 611, 604, 605, 0, 278, 296, 296, 341, 297, + 0, 297, 0, 296, 736, 740, 738, 536, 296, 547, + 257, 265, 311, 0, 2, 537, 296, 501, 338, 339, + 285, 353, 360, 0, 296, 0, 751, 401, 0, 478, + 502, 254, 255, 522, 296, 438, 0, 296, 239, 0, + 2, 241, 0, 297, 0, 259, 2, 260, 280, 0, + 0, 2, 296, 547, 296, 488, 490, 489, 0, 0, + 753, 0, 296, 0, 296, 492, 296, 562, 560, 561, + 559, 0, 554, 557, 0, 0, 296, 56, 296, 70, + 51, 296, 58, 296, 296, 54, 55, 2, 129, 0, + 0, 450, 0, 449, 730, 123, 296, 18, 0, 31, + 32, 37, 2, 0, 37, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 112, 111, 0, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 105, 2, 645, 452, 642, 546, 546, 650, 479, 293, - 2, 584, 585, 0, 596, 597, 0, 2, 739, 742, - 120, 293, 0, 2, 707, 294, 711, 702, 703, 709, - 0, 2, 2, 667, 546, 750, 616, 546, 546, 750, - 546, 630, 546, 546, 681, 434, 664, 546, 546, 672, - 679, 293, 429, 294, 0, 0, 293, 717, 294, 722, - 750, 714, 293, 719, 750, 293, 293, 293, 0, 120, - 0, 19, 2, 0, 20, 0, 459, 748, 0, 0, - 465, 240, 0, 293, 0, 0, 0, 544, 568, 572, - 574, 604, 607, 611, 614, 567, 606, 0, 283, 657, - 0, 293, 276, 0, 0, 0, 0, 274, 2, 0, - 258, 535, 293, 0, 0, 293, 2, 363, 383, 372, - 0, 0, 377, 371, 749, 0, 0, 396, 0, 294, - 3, 414, 3, 418, 417, 590, 0, 530, 293, 61, - 3, 293, 433, 294, 3, 427, 428, 2, 0, 0, - 0, 484, 305, 293, 480, 482, 3, 2, 2, 0, - 501, 3, 0, 553, 128, 0, 0, 221, 0, 0, - 0, 0, 37, 0, 0, 120, 293, 21, 0, 22, - 0, 691, 696, 448, 688, 546, 546, 0, 106, 3, - 2, 28, 0, 34, 0, 2, 26, 0, 104, 71, - 72, 73, 75, 76, 78, 79, 83, 84, 81, 82, - 86, 87, 89, 91, 93, 95, 97, 0, 0, 751, - 293, 0, 0, 0, 646, 647, 643, 644, 496, 495, - 293, 0, 293, 713, 293, 718, 294, 293, 661, 293, - 293, 704, 660, 2, 293, 0, 0, 0, 0, 0, - 0, 0, 0, 682, 0, 668, 619, 635, 669, 2, - 615, 622, 431, 617, 618, 432, 2, 629, 638, 631, - 632, 665, 666, 680, 708, 712, 710, 750, 267, 2, - 744, 2, 422, 716, 721, 423, 0, 401, 3, 3, - 3, 3, 453, 3, 0, 2, 467, 464, 749, 0, - 460, 2, 463, 466, 0, 293, 241, 263, 3, 271, - 273, 0, 453, 2, 570, 571, 2, 609, 610, 0, - 658, 536, 3, 344, 343, 346, 345, 293, 537, 0, - 538, 371, 0, 0, 293, 293, 0, 0, 691, 381, - 384, 388, 546, 388, 387, 380, 373, 546, 375, 378, - 293, 398, 392, 102, 399, 748, 0, 0, 436, 239, - 0, 0, 3, 2, 667, 429, 0, 526, 0, 750, - 488, 0, 293, 293, 293, 0, 550, 552, 129, 0, - 0, 214, 0, 0, 0, 222, 223, 54, 0, 56, - 59, 60, 0, 2, 127, 0, 0, 0, 692, 693, - 689, 690, 458, 68, 69, 107, 124, 3, 106, 0, - 0, 25, 36, 3, 0, 33, 100, 0, 3, 649, - 653, 656, 648, 3, 591, 3, 715, 720, 2, 61, - 293, 3, 3, 294, 0, 3, 621, 625, 628, 637, - 671, 675, 678, 293, 3, 620, 636, 670, 293, 293, - 424, 293, 293, 745, 0, 0, 0, 0, 255, 0, - 102, 0, 3, 3, 0, 461, 0, 457, 0, 0, - 244, 293, 0, 0, 128, 0, 0, 0, 0, 0, - 128, 0, 0, 106, 106, 19, 2, 0, 0, 3, - 130, 131, 2, 142, 132, 133, 134, 135, 136, 137, - 144, 146, 0, 0, 0, 284, 293, 293, 546, 0, - 539, 293, 374, 376, 0, 390, 692, 385, 389, 386, - 379, 383, 366, 397, 0, 578, 2, 663, 662, 0, - 668, 2, 481, 483, 503, 3, 511, 512, 0, 2, - 507, 3, 3, 0, 0, 555, 221, 0, 0, 0, - 221, 0, 0, 120, 695, 699, 701, 694, 748, 106, - 0, 3, 660, 40, 3, 38, 35, 0, 3, 99, - 101, 0, 2, 651, 652, 0, 0, 293, 0, 0, - 0, 3, 637, 0, 2, 623, 624, 2, 639, 2, - 673, 674, 0, 0, 61, 0, 3, 3, 3, 3, - 409, 408, 412, 2, 2, 747, 746, 121, 0, 0, - 0, 0, 3, 462, 3, 0, 242, 145, 3, 294, - 293, 0, 0, 0, 0, 2, 0, 190, 0, 188, - 0, 0, 0, 0, 0, 0, 0, 546, 120, 0, - 150, 147, 293, 0, 0, 266, 278, 3, 3, 545, - 612, 367, 382, 395, 293, 265, 293, 0, 514, 491, - 293, 0, 0, 490, 505, 0, 0, 0, 215, 0, - 224, 57, 2, 697, 698, 0, 125, 122, 0, 0, - 0, 0, 0, 24, 0, 654, 293, 579, 264, 723, - 724, 725, 0, 676, 293, 293, 293, 3, 3, 0, - 684, 0, 0, 0, 0, 293, 293, 3, 543, 121, - 469, 0, 0, 245, 294, 0, 0, 0, 0, 293, - 191, 189, 186, 0, 192, 0, 0, 0, 0, 196, - 199, 197, 193, 0, 194, 128, 36, 143, 141, 243, - 0, 0, 416, 420, 419, 0, 508, 2, 509, 2, - 510, 504, 293, 227, 0, 225, 0, 227, 293, 32, - 123, 2, 43, 2, 41, 39, 29, 27, 3, 726, - 3, 3, 3, 0, 0, 683, 685, 626, 640, 268, - 2, 406, 3, 405, 0, 471, 468, 128, 0, 0, - 128, 3, 0, 128, 187, 0, 2, 2, 208, 198, - 0, 0, 0, 139, 0, 573, 613, 2, 0, 0, - 2, 228, 0, 0, 216, 0, 3, 0, 0, 0, - 0, 0, 0, 686, 687, 293, 0, 470, 151, 0, - 0, 2, 164, 128, 153, 0, 181, 0, 128, 0, - 2, 155, 0, 2, 0, 2, 2, 2, 195, 33, - 293, 513, 515, 506, 0, 0, 0, 0, 0, 3, - 3, 655, 627, 641, 677, 410, 128, 157, 160, 0, - 159, 163, 3, 166, 165, 0, 128, 183, 128, 3, - 0, 293, 0, 293, 0, 2, 0, 2, 138, 2, - 229, 230, 0, 226, 217, 700, 0, 0, 152, 0, - 0, 162, 232, 167, 2, 234, 182, 0, 185, 171, - 200, 3, 209, 213, 202, 3, 0, 293, 0, 293, - 0, 0, 0, 44, 42, 158, 161, 128, 0, 168, - 293, 128, 128, 0, 172, 0, 0, 691, 210, 211, - 212, 0, 201, 3, 203, 3, 293, 218, 231, 148, - 169, 154, 128, 235, 184, 179, 177, 173, 156, 128, - 0, 692, 0, 0, 0, 0, 149, 170, 180, 174, - 178, 177, 175, 3, 3, 0, 0, 492, 176, 204, - 206, 3, 3, 205, 207 + 108, 2, 648, 455, 645, 549, 549, 653, 482, 296, + 2, 587, 588, 0, 599, 600, 0, 2, 742, 745, + 123, 296, 0, 2, 710, 297, 714, 705, 706, 712, + 0, 2, 2, 670, 549, 753, 619, 549, 549, 753, + 549, 633, 549, 549, 684, 437, 667, 549, 549, 675, + 682, 296, 432, 297, 0, 0, 296, 720, 297, 725, + 753, 717, 296, 722, 753, 296, 296, 296, 0, 123, + 0, 19, 2, 0, 20, 0, 462, 751, 0, 0, + 468, 243, 0, 296, 0, 0, 0, 547, 571, 575, + 577, 607, 610, 614, 617, 570, 609, 0, 286, 660, + 0, 296, 279, 0, 0, 0, 0, 277, 2, 0, + 261, 538, 296, 0, 0, 296, 2, 366, 386, 375, + 0, 0, 380, 374, 752, 0, 0, 399, 0, 297, + 3, 417, 3, 421, 420, 593, 0, 533, 296, 64, + 3, 296, 436, 297, 3, 430, 431, 2, 0, 0, + 0, 487, 308, 296, 483, 485, 3, 2, 2, 0, + 504, 3, 0, 556, 131, 0, 0, 224, 0, 0, + 0, 0, 38, 0, 0, 123, 296, 21, 0, 22, + 0, 694, 699, 451, 691, 549, 549, 0, 109, 3, + 2, 29, 0, 35, 0, 28, 2, 26, 0, 107, + 74, 75, 76, 78, 79, 81, 82, 86, 87, 84, + 85, 89, 90, 92, 94, 96, 98, 100, 0, 0, + 754, 296, 0, 0, 0, 649, 650, 646, 647, 499, + 498, 296, 0, 296, 716, 296, 721, 297, 296, 664, + 296, 296, 707, 663, 2, 296, 0, 0, 0, 0, + 0, 0, 0, 0, 685, 0, 671, 622, 638, 672, + 2, 618, 625, 434, 620, 621, 435, 2, 632, 641, + 634, 635, 668, 669, 683, 711, 715, 713, 753, 270, + 2, 747, 2, 425, 719, 724, 426, 0, 404, 3, + 3, 3, 3, 456, 3, 0, 2, 470, 467, 752, + 0, 463, 2, 466, 469, 0, 296, 244, 266, 3, + 274, 276, 0, 456, 2, 573, 574, 2, 612, 613, + 0, 661, 539, 3, 347, 346, 349, 348, 296, 540, + 0, 541, 374, 0, 0, 296, 296, 0, 0, 694, + 384, 387, 391, 549, 391, 390, 383, 376, 549, 378, + 381, 296, 401, 395, 105, 402, 751, 0, 0, 439, + 242, 0, 0, 3, 2, 670, 432, 0, 529, 0, + 753, 491, 0, 296, 296, 296, 0, 553, 555, 132, + 0, 0, 217, 0, 0, 0, 225, 226, 57, 0, + 59, 62, 63, 0, 2, 130, 0, 0, 0, 695, + 696, 692, 693, 461, 71, 72, 110, 127, 3, 109, + 0, 0, 25, 37, 3, 0, 34, 103, 0, 3, + 652, 656, 659, 651, 3, 594, 3, 718, 723, 2, + 64, 296, 3, 3, 297, 0, 3, 624, 628, 631, + 640, 674, 678, 681, 296, 3, 623, 639, 673, 296, + 296, 427, 296, 296, 748, 0, 0, 0, 0, 258, + 0, 105, 0, 3, 3, 0, 464, 0, 460, 0, + 0, 247, 296, 0, 0, 131, 0, 0, 0, 0, + 0, 131, 0, 0, 109, 109, 19, 2, 0, 0, + 3, 133, 134, 2, 145, 135, 136, 137, 138, 139, + 140, 147, 149, 0, 0, 0, 287, 296, 296, 549, + 0, 542, 296, 377, 379, 0, 393, 695, 388, 392, + 389, 382, 386, 369, 400, 0, 581, 2, 666, 665, + 0, 671, 2, 484, 486, 506, 3, 514, 515, 0, + 2, 510, 3, 3, 0, 0, 558, 224, 0, 0, + 0, 224, 0, 0, 123, 698, 702, 704, 697, 751, + 109, 0, 3, 663, 47, 46, 3, 39, 41, 36, + 0, 3, 102, 104, 0, 2, 654, 655, 0, 0, + 296, 0, 0, 0, 3, 640, 0, 2, 626, 627, + 2, 642, 2, 676, 677, 0, 0, 64, 0, 3, + 3, 3, 3, 412, 411, 415, 2, 2, 750, 749, + 124, 0, 0, 0, 0, 3, 465, 3, 0, 245, + 148, 3, 297, 296, 0, 0, 0, 0, 2, 0, + 193, 0, 191, 0, 0, 0, 0, 0, 0, 0, + 549, 123, 0, 153, 150, 296, 0, 0, 269, 281, + 3, 3, 548, 615, 370, 385, 398, 296, 268, 296, + 0, 517, 494, 296, 0, 0, 493, 508, 0, 0, + 0, 218, 0, 227, 60, 2, 700, 701, 0, 128, + 125, 0, 0, 0, 0, 0, 24, 0, 657, 296, + 582, 267, 726, 727, 728, 0, 679, 296, 296, 296, + 3, 3, 0, 687, 0, 0, 0, 0, 296, 296, + 3, 546, 124, 472, 0, 0, 248, 297, 0, 0, + 0, 0, 296, 194, 192, 189, 0, 195, 0, 0, + 0, 0, 199, 202, 200, 196, 0, 197, 131, 37, + 146, 144, 246, 0, 0, 419, 423, 422, 0, 511, + 2, 512, 2, 513, 507, 296, 230, 0, 228, 0, + 230, 296, 33, 126, 40, 30, 2, 44, 2, 42, + 27, 3, 729, 3, 3, 3, 0, 0, 686, 688, + 629, 643, 271, 2, 409, 3, 408, 0, 474, 471, + 131, 0, 0, 131, 3, 0, 131, 190, 0, 2, + 2, 211, 201, 0, 0, 0, 142, 0, 576, 616, + 2, 0, 0, 2, 231, 0, 0, 219, 0, 3, + 0, 0, 0, 0, 0, 0, 689, 690, 296, 0, + 473, 154, 0, 0, 2, 167, 131, 156, 0, 184, + 0, 131, 0, 2, 158, 0, 2, 0, 2, 2, + 2, 198, 34, 296, 516, 518, 509, 0, 0, 0, + 0, 0, 3, 3, 658, 630, 644, 680, 413, 131, + 160, 163, 0, 162, 166, 3, 169, 168, 0, 131, + 186, 131, 3, 0, 296, 0, 296, 0, 2, 0, + 2, 141, 2, 232, 233, 0, 229, 220, 703, 0, + 0, 155, 0, 0, 165, 235, 170, 2, 237, 185, + 0, 188, 174, 203, 3, 212, 216, 205, 3, 0, + 296, 0, 296, 0, 0, 0, 45, 43, 161, 164, + 131, 0, 171, 296, 131, 131, 0, 175, 0, 0, + 694, 213, 214, 215, 0, 204, 3, 206, 3, 296, + 221, 234, 151, 172, 157, 131, 238, 187, 182, 180, + 176, 159, 131, 0, 695, 0, 0, 0, 0, 152, + 173, 183, 177, 181, 180, 178, 3, 3, 0, 0, + 495, 179, 207, 209, 3, 3, 208, 210 }; @@ -1563,192 +1565,192 @@ static const yytype_int16 yydefgoto[] = { - -1, 814, 468, 300, 47, 133, 134, 301, 302, 303, - 304, 305, 762, 763, 1134, 1135, 306, 381, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 1031, 518, 976, 547, 322, 977, 948, 1058, 1519, - 1060, 1061, 1062, 1063, 1520, 1064, 1065, 1438, 1439, 1402, - 1403, 1404, 1498, 1499, 1503, 1504, 1539, 1540, 1066, 1362, - 1067, 1068, 1299, 1300, 1301, 1481, 1069, 145, 954, 955, - 956, 1382, 1462, 1473, 1474, 469, 470, 875, 876, 1039, - 51, 52, 53, 54, 55, 347, 158, 58, 59, 60, - 61, 62, 349, 64, 65, 264, 67, 68, 274, 351, - 352, 71, 72, 73, 118, 75, 204, 354, 119, 78, - 120, 80, 81, 455, 82, 454, 689, 690, 691, 909, - 1087, 910, 83, 84, 458, 456, 697, 856, 857, 858, - 859, 700, 701, 702, 359, 360, 361, 362, 466, 340, - 135, 136, 522, 324, 170, 646, 647, 648, 649, 650, - 85, 121, 87, 489, 490, 940, 491, 277, 495, 325, - 88, 137, 138, 89, 1322, 1109, 1110, 1111, 1112, 90, - 91, 718, 92, 273, 93, 94, 187, 1033, 680, 412, - 125, 95, 501, 502, 503, 188, 268, 190, 191, 192, - 269, 98, 99, 100, 101, 102, 103, 104, 195, 196, - 197, 198, 199, 826, 606, 607, 608, 609, 200, 611, - 612, 613, 573, 574, 575, 576, 752, 105, 615, 616, - 617, 618, 619, 620, 969, 754, 755, 756, 596, 365, - 366, 367, 368, 326, 164, 107, 108, 109, 370, 695, - 570 + -1, 815, 468, 300, 47, 133, 134, 301, 302, 303, + 304, 305, 762, 763, 1136, 1137, 1138, 306, 381, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 1032, 518, 977, 547, 322, 978, 949, 1059, + 1522, 1061, 1062, 1063, 1064, 1523, 1065, 1066, 1441, 1442, + 1405, 1406, 1407, 1501, 1502, 1506, 1507, 1542, 1543, 1067, + 1365, 1068, 1069, 1302, 1303, 1304, 1484, 1070, 145, 955, + 956, 957, 1385, 1465, 1476, 1477, 469, 470, 876, 877, + 1040, 51, 52, 53, 54, 55, 347, 158, 58, 59, + 60, 61, 62, 349, 64, 65, 264, 67, 68, 274, + 351, 352, 71, 72, 73, 118, 75, 204, 354, 119, + 78, 120, 80, 81, 455, 82, 454, 689, 690, 691, + 910, 1088, 911, 83, 84, 458, 456, 697, 857, 858, + 859, 860, 700, 701, 702, 359, 360, 361, 362, 466, + 340, 135, 136, 522, 324, 170, 646, 647, 648, 649, + 650, 85, 121, 87, 489, 490, 941, 491, 277, 495, + 325, 88, 137, 138, 89, 1325, 1110, 1111, 1112, 1113, + 90, 91, 718, 92, 273, 93, 94, 187, 1034, 680, + 412, 125, 95, 501, 502, 503, 188, 268, 190, 191, + 192, 269, 98, 99, 100, 101, 102, 103, 104, 195, + 196, 197, 198, 199, 827, 606, 607, 608, 609, 200, + 611, 612, 613, 573, 574, 575, 576, 752, 105, 615, + 616, 617, 618, 619, 620, 970, 754, 755, 756, 596, + 365, 366, 367, 368, 326, 164, 107, 108, 109, 370, + 695, 570 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -1323 +#define YYPACT_NINF -1338 static const yytype_int16 yypact[] = { - 7329, 8828, -1323, 37, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, 109, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, 85, 85, 85, 873, - 733, 178, 7561, 370, -1323, -1323, -1323, -1323, -1323, 191, - -1323, -1323, -1323, 614, 225, -1323, -1323, -1323, -1323, 4615, - -1323, -1323, -1323, -1323, 229, 285, -1323, 934, -1323, -1323, - -1323, -1323, 435, 1196, 579, 110, 7677, -1323, -1323, 4858, - 1038, -1323, -1323, 580, 596, 6761, 1021, 875, 580, 1103, - -1323, -1323, 1317, 308, -1323, 580, 1224, -1323, 495, -1323, - 616, 623, -1323, -1323, -1323, -1323, 547, 285, 85, -1323, - 85, -1323, -1323, -1323, -1323, 9174, 934, -1323, -1323, 934, - -1323, 551, -1323, 9403, -1323, -1323, 1899, 9436, -1323, 844, - 844, 844, -1323, -1323, -1323, 85, -1323, -1323, -1323, 584, - 608, 632, -1323, -1323, -1323, 646, -1323, -1323, -1323, -1323, - -1323, 664, 687, -1323, -1323, -28, 8797, 2908, 117, 701, - 717, 726, 771, 786, 799, 8715, 6849, 731, 757, -1323, - 5600, -1323, -1323, -1323, -1323, 804, -1323, 223, 5225, 5225, - -1323, 802, 365, -1323, -1323, -1323, -1323, 816, 443, 480, - 534, 85, 827, -1323, -1323, 1196, 4341, 868, -1323, 50, - -1323, 85, 85, 285, -1323, -1323, 61, -1323, 85, 85, - -1323, 4647, 857, 864, 844, 6523, -1323, -1323, 869, 4615, - -1323, -1323, 580, -1323, -1323, -1323, 285, -1323, 934, 229, - -1323, 7868, -1323, 844, 844, 844, 285, -1323, 873, -1323, - 5676, -1323, -1323, 852, 844, -1323, 844, -1323, 191, 8797, - -1323, 884, -1323, 733, 890, 844, -1323, 873, 888, 892, - -1323, 7561, 631, -1323, -1323, -1323, 9256, -1323, -1323, 9621, - -1323, 868, 151, 10214, 9436, 1899, 4647, -1323, 88, -1323, - -1323, 9403, 934, 891, 7708, -1323, -1323, 347, -1323, 10561, - 922, 956, 10347, 945, 10366, 10423, -1323, 954, -1323, -1323, - -1323, -1323, 10442, 10442, 8571, 952, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, 988, -1323, 966, 1946, 8910, 10366, -1323, - 756, 338, 485, 411, 635, 955, 947, 957, 984, 237, - -1323, -1323, 962, 647, -1323, 302, -1323, -1323, 2908, -1323, - -1323, 235, 985, -1323, 312, 985, 989, 191, -1323, -1323, - 990, 9174, -1323, 999, 1006, 9023, -1323, -1323, 1335, 2030, - 8286, 6523, 580, -1323, 580, 844, 844, -1323, -1323, -1323, - -1323, -1323, -1323, 844, 9174, 934, -1323, -1323, 9474, 1575, - -1323, 8017, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 1008, - 5958, 10366, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, 1899, -1323, 973, 991, - 992, 1012, 978, 1017, 1018, 1020, 4341, -1323, -1323, 1029, - 229, 1031, -1323, -1323, 1033, -1323, -1323, -1323, 9256, -1323, - -1323, -1323, -1323, -1323, 4647, -1323, 8797, 8797, -1323, 844, - 1899, 6642, 934, 8359, -1323, -1323, -1323, -1323, 9256, 151, - -1323, -1323, 580, 285, -1323, -1323, 9256, -1323, 5770, -1323, - -1323, 844, 844, 337, 8204, 1032, 1036, 1023, 1042, 844, - -1323, -1323, -1323, -1323, 9660, -1323, 367, 6404, -1323, 285, - 1044, -1323, 1899, 10643, 10271, -1323, -1323, -1323, -1323, 1015, - 4647, -1323, 8432, 868, 7445, -1323, -1323, -1323, 843, 436, - 962, 733, 7708, 1341, 9403, -1323, 7708, -1323, -1323, -1323, - -1323, 508, -1323, 1051, 956, 248, 8571, -1323, 9512, -1323, - -1323, 8571, -1323, 8684, 8571, -1323, -1323, 1049, -1323, 606, - 1057, 682, 1059, -1323, -1323, 3527, 6492, -1323, 362, -1323, - -1323, 10214, -1323, 368, 10214, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, -1323, 10214, -1323, -1323, - 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, - 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 3593, 10214, - -1323, 647, 1677, -1323, -1323, 85, 85, -1323, -1323, 8797, - -1323, -1323, 1033, 631, -1323, 1033, 10290, -1323, -1323, -1323, - 5046, 6492, 1060, 1063, -1323, 9436, -1323, -1323, 804, -1323, - 1067, 750, 1068, 2627, 125, 962, -1323, 85, 85, 962, - 132, -1323, 85, 85, 1033, -1323, -1323, 85, 85, -1323, - 985, 9545, 934, 10788, 532, 656, 9545, -1323, 9621, -1323, - 962, -1323, 9174, -1323, 238, 7983, 7983, 7983, 934, -1323, - 5791, 1047, 1008, 493, 1058, 1061, -1323, 1076, 5225, 528, - -1323, 1165, 934, 7983, 631, 1899, 631, 868, 430, 985, - -1323, -1323, 536, 985, -1323, -1323, -1323, 956, -1323, 985, - 285, 9660, -1323, 619, 1086, 633, 1088, -1323, 1087, 285, - -1323, -1323, 9256, 285, 1089, 9512, 1092, -1323, 1065, -1323, - 538, 552, 733, -1323, 733, 1085, 10366, -1323, 733, 10788, - -1323, -1323, 1096, -1323, -1323, -1323, 631, -1323, 10716, 1006, - -1323, 7983, 703, 8286, -1323, -1323, 804, 1095, 1098, 843, - 5016, -1323, -1323, 7708, -1323, -1323, 1091, -1323, -1323, 1102, - -1323, 1091, 1104, 10561, 10214, 1090, 1093, 94, 1109, 1107, - 1111, 1114, -1323, 1118, 1129, 9365, 6611, -1323, 10214, -1323, - 682, 1717, -1323, -1323, -1323, 85, 85, 10157, 10214, 1125, - -1323, -1323, 653, -1323, 10214, -1323, -1323, 736, -1323, -1323, - -1323, -1323, 756, 756, 338, 338, 485, 485, 485, 485, - 411, 411, 635, 955, 947, 957, 984, 10366, 260, -1323, - 9660, 1132, 1136, 1137, 1677, -1323, -1323, -1323, -1323, -1323, - 9660, 708, 7983, -1323, 9174, -1323, 6968, 9136, -1323, 8017, - 6849, -1323, -1323, 750, 9660, 1022, 1140, 1141, 1142, 1143, - 1146, 1149, 1154, -1323, 3715, 2627, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, 1033, -1323, -1323, -1323, 962, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, 1155, -1323, 1157, 1159, - -1323, -1323, 229, 1125, 5791, -1323, -1323, -1323, 5958, 1158, - -1323, -1323, -1323, -1323, 733, 6174, 1248, -1323, -1323, -1323, - -1323, 1151, 229, -1323, -1323, 1033, -1323, -1323, 1033, 84, - 1033, -1323, -1323, -1323, -1323, -1323, -1323, 9327, -1323, 285, - -1323, -1323, 559, 562, 9474, 7087, 2137, 10366, 3114, -1323, - -1323, 1156, 51, 1156, -1323, 733, -1323, 85, -1323, -1323, - 8941, 1023, -1323, -1323, -1323, 1036, 1175, 1171, -1323, -1323, - 1178, 1181, -1323, 703, 1901, -1323, 672, -1323, 5016, 962, - -1323, 1184, 7708, 9583, 8797, 1185, -1323, -1323, 1180, 1187, - 1170, -1323, 10366, 1197, 326, 1194, -1323, 1202, 631, 1202, - -1323, -1323, 1202, 1199, -1323, 1208, 1210, 1211, 1717, -1323, - -1323, -1323, 5958, -1323, -1323, -1323, -1323, 1209, 10214, 1212, - 631, -1323, 10214, -1323, 631, -1323, -1323, 10214, -1323, 558, - 985, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 1008, 1006, - 9023, -1323, -1323, 7206, 1218, -1323, 674, 985, -1323, 813, - 861, 985, -1323, 844, 4029, -1323, -1323, -1323, 9660, 9660, - -1323, 8359, 8359, -1323, 1215, 1216, 1225, 1230, -1323, 1232, - 685, 82, 1125, -1323, 631, -1323, 5225, -1323, 10214, 564, - -1323, 6373, 1236, 1240, 10100, 1242, 1243, 70, 79, 96, - 10214, 1244, 285, 10214, 10214, 1227, 1249, 522, 1222, -1323, - -1323, -1323, 1250, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, 733, 1254, 10214, -1323, 9660, 9660, 85, 1257, - -1323, 9054, -1323, -1323, 752, -1323, 3114, -1323, -1323, -1323, - -1323, 1065, -1323, -1323, 1255, -1323, -1323, -1323, -1323, 1258, - 1901, -1323, -1323, 1245, -1323, 1091, -1323, -1323, 1899, 1260, - -1323, -1323, -1323, 713, 1264, -1323, 94, 1269, 10366, 1252, - 94, 94, 1262, 3527, 879, 985, -1323, -1323, 1076, 10214, - 1273, 1209, 358, 204, 1270, -1323, -1323, 1275, 1270, -1323, - -1323, 1278, -1323, -1323, 1033, 1280, 1284, 6730, 1285, 1290, - 1291, -1323, -1323, 1286, -1323, -1323, 1033, -1323, -1323, -1323, - -1323, 1033, 10214, 10214, 1006, 1294, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 10366, 10366, - 1300, 1302, 1270, -1323, -1323, 733, -1323, -1323, -1323, 5213, - 9583, 10214, 10214, 1374, 10214, -1323, 1295, -1323, 1296, -1323, - 1297, 10214, 1301, 10214, 1105, 1304, 12, 85, 9289, 1625, - -1323, -1323, 6174, 1322, 573, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, 9920, -1323, 8432, 1330, -1323, -1323, - 9583, 576, 602, -1323, 1331, 1315, 956, 1337, -1323, 329, - -1323, -1323, -1323, -1323, 1033, 1339, -1323, -1323, 1320, 486, - 509, 631, 1340, -1323, 1344, -1323, 9660, -1323, -1323, -1323, - -1323, -1323, 1347, -1323, 9660, 9660, 9660, -1323, -1323, 1348, - -1323, 1351, 1354, 1355, 716, 8056, 8171, -1323, -1323, 529, - -1323, 1357, 1362, -1323, 8505, 721, 730, 1358, 761, 3837, - -1323, -1323, -1323, 605, -1323, 766, 1366, 1367, 285, 1419, - 834, -1323, -1323, 10214, -1323, 10100, 10214, -1323, -1323, -1323, - 1370, 1375, -1323, -1323, -1323, 1372, -1323, -1323, -1323, -1323, - -1323, -1323, 9583, 956, 1379, -1323, 1352, 956, 9660, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, 1378, 1382, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, 1387, -1323, 1386, -1323, -1323, 10100, 289, 10214, - 10100, -1323, 1389, 10214, -1323, 318, 1405, 1406, -1323, -1323, - 1399, 1400, 1380, -1323, 821, -1323, -1323, -1323, 934, 1899, - 1396, -1323, 402, 10366, -1323, 785, -1323, 631, 631, 1407, - 1408, 1413, 1415, -1323, -1323, 8359, 1414, -1323, 1490, 10366, - 1385, -1323, -1323, 10012, -1323, 800, -1323, 1402, 10100, 1403, - -1323, -1323, 1426, -1323, 1427, -1323, 1445, 1446, -1323, 1411, - 9583, -1323, -1323, -1323, 956, 631, 1434, 1417, 1435, 1270, - 1270, -1323, -1323, -1323, -1323, -1323, 10100, 107, -1323, 433, - -1323, -1323, 7793, -1323, -1323, 1418, 10214, -1323, 10214, 7793, - 285, 9512, 285, 9512, 1436, -1323, 1442, -1323, -1323, 1440, - -1323, -1323, 825, -1323, -1323, -1323, 1444, 1449, -1323, 10366, - 10366, -1323, -1323, 909, 211, -1323, -1323, 1425, -1323, 909, - -1323, -1323, 2166, 631, -1323, -1323, 285, 9512, 285, 9512, - 1453, 1431, 631, -1323, -1323, -1323, -1323, 10012, 1443, 909, - 6091, 10214, 9924, 1452, 909, 1454, 2166, 3344, -1323, -1323, - -1323, 1458, -1323, -1323, -1323, -1323, 8797, -1323, -1323, -1323, - 9791, -1323, 10012, -1323, -1323, 1438, 9703, -1323, -1323, 9924, - 285, 3344, 285, 1464, 1466, 853, -1323, 9791, -1323, -1323, - -1323, 9703, -1323, -1323, -1323, 285, 285, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323 + 4794, 8872, -1338, 118, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -32, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, 75, 75, 75, 889, + 761, 17, 6057, 231, -1338, -1338, -1338, -1338, -1338, 166, + -1338, -1338, -1338, 566, 192, -1338, -1338, -1338, -1338, 4939, + -1338, -1338, -1338, -1338, 195, 234, -1338, 1148, -1338, -1338, + -1338, -1338, 170, 2042, 352, 44, 7574, -1338, -1338, 9333, + 1157, -1338, -1338, 1542, 364, 3919, 608, 982, 1542, 1041, + -1338, -1338, 474, 402, -1338, 1542, 1242, -1338, 273, -1338, + 455, 478, -1338, -1338, -1338, -1338, 354, 234, 75, -1338, + 75, -1338, -1338, -1338, -1338, 9218, 1148, -1338, -1338, 1148, + -1338, 387, -1338, 9518, -1338, -1338, 2342, 9556, -1338, 992, + 992, 992, -1338, -1338, -1338, 75, -1338, -1338, -1338, 374, + 386, 471, -1338, -1338, -1338, 480, -1338, -1338, -1338, -1338, + -1338, 525, 539, -1338, -1338, 53, 8841, 1022, 54, 558, + 563, 587, 592, 605, 615, 8759, 7097, 644, 585, -1338, + 9371, -1338, -1338, -1338, -1338, 619, -1338, 349, 4637, 4637, + -1338, 657, 446, -1338, -1338, -1338, -1338, 651, 453, 454, + 476, 75, 659, -1338, -1338, 2042, 2592, 742, -1338, 57, + -1338, 75, 75, 234, -1338, -1338, 101, -1338, 75, 75, + -1338, 3079, 687, 706, 992, 6771, -1338, -1338, 707, 4939, + -1338, -1338, 1542, -1338, -1338, -1338, 234, -1338, 1148, 195, + -1338, 7912, -1338, 992, 992, 992, 234, -1338, 889, -1338, + 4555, -1338, -1338, 691, 992, -1338, 992, -1338, 166, 8841, + -1338, 713, -1338, 761, 725, 992, -1338, 889, 756, 768, + -1338, 6057, 675, -1338, -1338, -1338, 9300, -1338, -1338, 2361, + -1338, 742, 105, 10239, 9556, 2342, 3079, -1338, 194, -1338, + -1338, 9518, 1148, 743, 7605, -1338, -1338, 126, -1338, 10586, + 755, 847, 10372, 832, 10391, 10448, -1338, 839, -1338, -1338, + -1338, -1338, 10467, 10467, 8615, 824, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, 901, -1338, 679, 3121, 8954, 10391, -1338, + 507, 418, 680, 295, 694, 894, 852, 888, 930, 66, + -1338, -1338, 938, 665, -1338, 380, -1338, -1338, 1022, -1338, + -1338, 12, 949, -1338, 338, 949, 961, 166, -1338, -1338, + 968, 9218, -1338, 983, 984, 9067, -1338, -1338, 776, 1555, + 8330, 6771, 1542, -1338, 1542, 992, 992, -1338, -1338, -1338, + -1338, -1338, -1338, 992, 9218, 1148, -1338, -1338, 9594, 1098, + -1338, 8061, -1338, -1338, -1338, -1338, -1338, -1338, -1338, 995, + 5881, 10391, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, 2342, -1338, 489, 993, + 994, 1000, 732, 1004, 1007, 1008, 2592, -1338, -1338, 969, + 195, 1030, -1338, -1338, 1024, -1338, -1338, -1338, 9300, -1338, + -1338, -1338, -1338, -1338, 3079, -1338, 8841, 8841, -1338, 992, + 2342, 6890, 1148, 8403, -1338, -1338, -1338, -1338, 9300, 105, + -1338, -1338, 1542, 234, -1338, -1338, 9300, -1338, 6655, -1338, + -1338, 992, 992, 465, 8248, 1029, 1028, 1015, 1033, 992, + -1338, -1338, -1338, -1338, 9742, -1338, 591, 6518, -1338, 234, + 1044, -1338, 2342, 10668, 10296, -1338, -1338, -1338, -1338, 929, + 3079, -1338, 8476, 742, 5771, -1338, -1338, -1338, 1039, 645, + 938, 761, 7605, 809, 9518, -1338, 7605, -1338, -1338, -1338, + -1338, 688, -1338, 1046, 847, 251, 8615, -1338, 9627, -1338, + -1338, 8615, -1338, 8728, 8615, -1338, -1338, 1048, -1338, 751, + 1043, 711, 1057, -1338, -1338, 9447, 6740, -1338, 107, -1338, + -1338, 10239, -1338, 318, 10239, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, 10239, -1338, -1338, + 10391, 10391, 10391, 10391, 10391, 10391, 10391, 10391, 10391, 10391, + 10391, 10391, 10391, 10391, 10391, 10391, 10391, 10391, 4422, 10239, + -1338, 665, 1831, -1338, -1338, 75, 75, -1338, -1338, 8841, + -1338, -1338, 1024, 675, -1338, 1024, 10315, -1338, -1338, -1338, + 5500, 6740, 1056, 1064, -1338, 9556, -1338, -1338, 619, -1338, + 1065, 1323, 1067, 2196, 209, 938, -1338, 75, 75, 938, + 243, -1338, 75, 75, 1024, -1338, -1338, 75, 75, -1338, + 949, 9665, 1148, 10813, 217, 306, 9665, -1338, 2361, -1338, + 938, -1338, 9218, -1338, 212, 8027, 8027, 8027, 1148, -1338, + 6120, 1053, 995, 535, 1061, 1066, -1338, 1071, 4637, 421, + -1338, 1166, 1148, 8027, 675, 2342, 675, 742, 394, 949, + -1338, -1338, 788, 949, -1338, -1338, -1338, 847, -1338, 949, + 234, 9742, -1338, 764, 1087, 806, 1088, -1338, 1089, 234, + -1338, -1338, 9300, 234, 1090, 9627, 1096, -1338, 1729, -1338, + 527, 550, 761, -1338, 761, 1102, 10391, -1338, 761, 10813, + -1338, -1338, 1092, -1338, -1338, -1338, 675, -1338, 10741, 984, + -1338, 8027, 857, 8330, -1338, -1338, 619, 1103, 1112, 1039, + 3523, -1338, -1338, 7605, -1338, -1338, 1097, -1338, -1338, 1121, + -1338, 1097, 1124, 10586, 10239, 1105, 1104, 94, 1128, 1123, + 1132, 1133, -1338, 1136, 1138, 9485, 6859, -1338, 10239, -1338, + 711, 1914, -1338, -1338, -1338, 75, 75, 6186, 10239, 1134, + -1338, -1338, 822, -1338, 10239, -1338, -1338, -1338, 715, -1338, + -1338, -1338, -1338, 507, 507, 418, 418, 680, 680, 680, + 680, 295, 295, 694, 894, 852, 888, 930, 10391, 250, + -1338, 9742, 1151, 1153, 1158, 1831, -1338, -1338, -1338, -1338, + -1338, 9742, 827, 8027, -1338, 9218, -1338, 7216, 9180, -1338, + 8061, 7097, -1338, -1338, 1323, 9742, 936, 1159, 1162, 1164, + 1167, 1170, 1175, 1178, -1338, 3437, 2196, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, 1024, -1338, -1338, -1338, 938, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, 1179, -1338, 1180, + 1181, -1338, -1338, 195, 1134, 6120, -1338, -1338, -1338, 5881, + 1143, -1338, -1338, -1338, -1338, 761, 6348, 1247, -1338, -1338, + -1338, -1338, 1165, 195, -1338, -1338, 1024, -1338, -1338, 1024, + 230, 1024, -1338, -1338, -1338, -1338, -1338, -1338, 9409, -1338, + 234, -1338, -1338, 554, 555, 9594, 7335, 2114, 10391, 2586, + -1338, -1338, 1163, 40, 1163, -1338, 761, -1338, 75, -1338, + -1338, 8985, 1015, -1338, -1338, -1338, 1028, 1185, 1186, -1338, + -1338, 1189, 1191, -1338, 857, 1994, -1338, 444, -1338, 3523, + 938, -1338, 1195, 7605, 9703, 8841, 1196, -1338, -1338, 1192, + 1200, 1182, -1338, 10391, 1205, 298, 1203, -1338, 1206, 675, + 1206, -1338, -1338, 1206, 1209, -1338, 1214, 1216, 1217, 1914, + -1338, -1338, -1338, 5881, -1338, -1338, -1338, -1338, 1215, 10239, + 1220, 831, -1338, 10239, -1338, 831, -1338, -1338, 10239, -1338, + 972, 949, -1338, -1338, -1338, -1338, -1338, -1338, -1338, 995, + 984, 9067, -1338, -1338, 7454, 1229, -1338, 975, 949, -1338, + 979, 991, 949, -1338, 992, 3705, -1338, -1338, -1338, 9742, + 9742, -1338, 8403, 8403, -1338, 1226, 1232, 1235, 1240, -1338, + 1244, 564, 43, 1134, -1338, 831, -1338, 4637, -1338, 10239, + 582, -1338, 6621, 1243, 1245, 10182, 1248, 1251, 46, 70, + 103, 10239, 1252, 234, 10239, 10239, 1238, 1257, 333, 1239, + -1338, -1338, -1338, 1258, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, 761, 1268, 10239, -1338, 9742, 9742, 75, + 1269, -1338, 9098, -1338, -1338, 767, -1338, 2586, -1338, -1338, + -1338, -1338, 1729, -1338, -1338, 1270, -1338, -1338, -1338, -1338, + 1273, 1994, -1338, -1338, 1256, -1338, 1097, -1338, -1338, 2342, + 1271, -1338, -1338, -1338, 836, 1276, -1338, 94, 1279, 10391, + 1265, 94, 94, 1293, 9447, 1023, 949, -1338, -1338, 1071, + 10239, 1292, 1215, 513, -1338, -1338, 1296, -1338, -5, -1338, + 1297, 1296, -1338, -1338, 1304, -1338, -1338, 1024, 1306, 1309, + 6978, 1310, 1312, 1313, -1338, -1338, 1316, -1338, -1338, 1024, + -1338, -1338, -1338, -1338, 1024, 10239, 10239, 984, 1315, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, 10391, 10391, 1317, 1318, 1296, -1338, -1338, 761, -1338, + -1338, -1338, 7839, 9703, 10239, 10239, 1381, 10239, -1338, 1299, + -1338, 1303, -1338, 1305, 10239, 1311, 10239, 1014, 1314, 39, + 75, 5221, 1493, -1338, -1338, 6348, 1321, 584, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, 10002, -1338, 8476, + 1328, -1338, -1338, 9703, 589, 606, -1338, 1327, 1325, 847, + 1334, -1338, 331, -1338, -1338, -1338, -1338, 1024, 1332, -1338, + -1338, 1336, 831, 1339, 320, 457, -1338, 1341, -1338, 9742, + -1338, -1338, -1338, -1338, -1338, 1345, -1338, 9742, 9742, 9742, + -1338, -1338, 1351, -1338, 1355, 1358, 1360, 623, 8100, 8215, + -1338, -1338, 463, -1338, 1361, 1370, -1338, 8549, 841, 866, + 1374, 868, 6487, -1338, -1338, -1338, 616, -1338, 881, 1375, + 1379, 234, 1429, 861, -1338, -1338, 10239, -1338, 10182, 10239, + -1338, -1338, -1338, 1383, 1384, -1338, -1338, -1338, 1382, -1338, + -1338, -1338, -1338, -1338, -1338, 9703, 847, 1386, -1338, 1366, + 847, 9742, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, 1389, 1390, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, 1395, -1338, 1394, -1338, -1338, + 10182, 334, 10239, 10182, -1338, 1398, 10239, -1338, 339, 1415, + 1417, -1338, -1338, 1405, 1406, 1393, -1338, 840, -1338, -1338, + -1338, 1148, 2342, 1403, -1338, 329, 10391, -1338, 897, -1338, + 831, 831, 1411, 1412, 1416, 1421, -1338, -1338, 8403, 1423, + -1338, 1485, 10391, 1407, -1338, -1338, 10094, -1338, 898, -1338, + 1410, 10182, 1422, -1338, -1338, 1434, -1338, 1443, -1338, 1459, + 1461, -1338, 1428, 9703, -1338, -1338, -1338, 847, 675, 1452, + 1431, 1455, 1296, 1296, -1338, -1338, -1338, -1338, -1338, 10182, + 81, -1338, 447, -1338, -1338, 7690, -1338, -1338, 1435, 10239, + -1338, 10239, 7690, 234, 9627, 234, 9627, 1465, -1338, 1466, + -1338, -1338, 1456, -1338, -1338, 909, -1338, -1338, -1338, 1470, + 1471, -1338, 10391, 10391, -1338, -1338, 880, 254, -1338, -1338, + 1453, -1338, 880, -1338, -1338, 2645, 675, -1338, -1338, 234, + 9627, 234, 9627, 1480, 1458, 675, -1338, -1338, -1338, -1338, + 10094, 1476, 880, 7766, 10239, 10006, 1478, 880, 1486, 2645, + 2922, -1338, -1338, -1338, 1487, -1338, -1338, -1338, -1338, 8841, + -1338, -1338, -1338, 9873, -1338, 10094, -1338, -1338, 1467, 9785, + -1338, -1338, 10006, 234, 2922, 234, 1495, 1498, 927, -1338, + 9873, -1338, -1338, -1338, 9785, -1338, -1338, -1338, 234, 234, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338 }; @@ -1756,29 +1758,29 @@ static const yytype_int16 yypgoto[] = { - -1323, 4572, 3263, -1323, 197, -1323, 601, 950, -251, 910, - -1323, 521, -520, -467, -853, -64, 3183, 0, -1323, -150, - 423, 446, 477, 450, 1016, 1025, 1019, 1026, 1028, -1323, - -622, -408, 5012, -745, -1323, -735, 604, 472, -656, 413, - -1323, 1279, -1323, 374, -1058, -1323, -1323, 126, -1323, -823, - -1106, 222, -1323, -1323, -1323, -1323, 58, -1209, -1323, -1323, - -1323, -1323, -1323, -1323, 301, -1149, 35, -1323, -933, -1323, - 482, 274, -1323, 159, -1323, -303, -1323, -1323, -1323, 535, - -827, -1323, -1323, 15, -1007, 71, 28, -1323, -1323, -1323, - -21, -1323, 357, 1253, -198, 1636, 4113, -1323, -1323, 80, - 54, 422, 1473, -1323, 1886, -1323, -1323, 192, 2183, -1323, - 2495, 898, -1323, -1323, -1323, -638, -1323, 924, 925, 524, - 699, 83, -1323, -1323, -1323, 915, 695, -339, -1323, -106, - 34, 1281, -1323, -1323, -847, -986, 1046, 1127, 1039, 5, - -1323, 1536, 481, -165, -210, -124, 651, 758, -1323, 979, - -1323, 2789, 1548, -413, 904, -1323, -1323, 689, -1323, -235, - -1323, 158, -1323, -1323, -1323, -1257, 401, -1323, -1323, -1323, - 1148, -1323, 21, -1323, -1323, -858, -105, -1322, -129, 2267, - -1323, 2391, -1323, 906, -1323, -184, 59, -180, -173, -170, - 7, -40, -35, -33, 60, -6, 25, 93, -168, -164, - -158, -147, -144, -292, -471, -462, -452, -551, -302, -537, - -1323, -1323, -511, 1069, 1072, 1074, 2608, 4844, -578, -514, - -502, -495, -500, -1323, -508, -724, -717, -708, -590, -305, - -195, -1323, -1323, 246, 19, 36, -1323, 3865, 104, -623, - -397 + -1338, 4260, 2887, -1338, 1463, -1338, 1198, 661, -268, 942, + -1338, 552, -528, -471, -934, -784, -1338, 4910, 0, -1338, + -100, 434, 472, 506, 438, 1049, 1050, 1051, 1062, 1055, + -1338, 1094, -577, 5180, -896, -1338, -712, 636, -68, -593, + -654, -1338, 1469, -1338, 408, -1065, -1338, -1338, 159, -1338, + -1118, -880, 265, -1338, -1338, -1338, -1338, 92, -1253, -1338, + -1338, -1338, -1338, -1338, -1338, 341, -1303, 36, -1338, -904, + -1338, 518, 311, -1338, 196, -1338, -309, -1338, -1338, -1338, + 571, -749, -1338, -1338, 16, -930, 172, 1119, -1338, -1338, + -1338, -149, -1338, 71, 966, -196, 1532, 4034, -1338, -1338, + 83, 174, 287, 2700, -1338, 1836, -1338, -1338, 55, 2097, + -1338, 2401, 2181, -1338, -1338, -1338, -656, -1338, 962, 964, + 560, 736, -249, -1338, -1338, -1338, 955, 734, -456, -1338, + -116, -94, 869, -1338, -1338, -963, -979, -2, 913, 1074, + 29, -1338, 719, 357, -283, -191, -146, 681, 789, -1338, + 1010, -1338, 2818, 1589, -439, 940, -1338, -1338, 720, -1338, + -237, -1338, 109, -1338, -1338, -1338, -1275, 435, -1338, -1338, + -1338, 1183, -1338, 32, -1338, -1338, -845, -111, -1337, -112, + 3150, -1338, 3946, -1338, 941, -1338, -138, 1137, -181, -176, + -174, 7, -40, -33, -28, 1352, 38, 50, 77, -134, + -173, -171, -166, -165, -261, -504, -490, -476, -565, -319, + -523, -1338, -1338, -525, 1107, 1111, 1115, -135, 4740, -582, + -583, -534, -519, -480, -1338, -505, -725, -715, -709, -592, + -312, -258, -1338, -1338, 326, 26, -81, -1338, 3689, -15, + -601, -356 }; @@ -1786,680 +1788,681 @@ positive, shift that token. If negative, reduce the rule which number is the opposite. If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -522 +#define YYTABLE_NINF -525 static const yytype_int16 yytable[] = { - 49, 113, 407, 149, 453, 399, 428, 97, 150, 440, - 151, 267, 400, 753, 767, 401, 114, 1071, 408, 106, - 106, 402, 974, 280, 869, 828, 965, 403, 57, 57, - 505, 845, 49, 966, 1188, 50, 1172, 152, 404, 97, - 597, 405, 967, 147, 383, 384, 741, 610, 1070, 49, - 357, 106, 827, 143, 70, 920, 161, 605, 410, 96, - 57, 795, 177, 186, 819, 1380, 209, 50, 153, 49, - 193, 56, 115, 216, 923, 1303, 226, 1440, 949, 726, - 69, 281, 407, 731, 219, 399, 70, 820, 106, 31, - 31, 96, 400, 724, 57, 401, 425, 57, 408, 821, - 31, 402, 148, 56, 831, 113, 822, 403, 96, 162, - 838, 261, 69, 113, 262, 670, 266, 271, 404, 122, - 212, 405, 189, 194, 31, 96, 217, 31, 96, 227, - 816, 1138, 475, 477, 510, 679, 154, 210, 202, 817, - 220, 260, 1196, 683, 1304, 149, 307, 147, 1440, 818, - 150, 1198, 151, 166, 161, 113, 345, 548, 549, 252, - 209, 411, 411, 1459, 31, 986, 527, 373, 1200, 629, - 419, 31, 411, 633, 1170, 1171, 291, 715, 1178, 152, - 914, 1182, 965, 1235, 348, 186, 186, 1239, 203, 966, - 358, 342, 76, 161, 1078, 548, 721, 481, 967, 411, - 668, 266, 1197, 1469, 1179, 952, 96, 162, 832, 49, - 153, 1199, 835, 1201, 1187, 409, 161, 166, 123, 96, - 374, 209, 665, 439, 76, 149, 252, 329, 443, 1179, - 150, 548, 151, 852, 829, 471, 602, 855, 666, 307, - 1172, 836, 1030, 602, 398, 189, 162, 1017, 816, 57, - 327, 49, 1140, 735, 176, -233, -233, 817, 97, 271, - 476, 674, 676, 1081, 271, 266, 266, 818, 96, 162, - 106, 113, 463, 161, 1016, 442, 1004, 483, 154, 57, - 96, 444, 1188, 992, 500, 923, 50, 142, 924, 1249, - 1172, 657, 441, 1527, 307, 163, 665, 860, 861, 820, - 146, 610, 1094, 176, 1485, 70, 176, 307, 1205, 1206, - 96, 821, 666, 436, 878, 831, 597, 1250, 822, 672, - 1542, 597, 56, 572, 479, 677, -233, 357, 147, 730, - 923, 69, 567, 1399, 1400, 373, 168, 155, 1513, 377, - 1515, 113, 816, 327, 580, 345, 411, 476, 743, 603, - 621, 817, 176, 177, 1071, 378, 828, 63, 736, 163, - 169, 818, 1399, 1400, 626, 1139, 568, 1497, 626, 569, - 630, 113, 932, 1502, 634, 436, 748, 589, 737, 899, - 110, 144, 139, 140, 1246, 1070, 447, 96, 374, 63, - 987, 41, 42, 1522, 1202, 805, 266, 471, 1529, 171, - 769, 770, 771, 1401, 212, 460, 186, 342, 604, 1172, - 845, 166, 578, 373, 799, 176, 1030, 471, 579, 820, - 357, 583, 243, 411, 266, 471, 307, 307, 1170, 1171, - 266, 821, 1410, 626, 110, 1188, 1119, 854, 822, 1326, - 110, 715, 1188, 76, 1526, 41, 42, 684, 76, 599, - 1020, 41, 42, 579, 113, 435, 1120, 553, 554, 1327, - 1127, 348, 1363, 995, 1537, 189, 374, 358, -121, 176, - -121, 1541, 266, 760, -121, 493, 176, 705, 494, 765, - 266, 387, 626, 706, 49, 357, 953, 373, 720, -121, - -121, 97, 229, 1188, 113, 230, 923, 388, 234, 1085, - 236, 557, 558, 106, 911, 1245, 307, 245, 113, 1158, - 1160, 307, 57, 307, 307, 1136, 714, 435, 1424, 50, - 913, 751, 1017, 610, 870, 113, 345, 212, 882, 1105, - 327, 327, 1425, 1015, 1429, 1430, 559, 560, 70, 883, - 523, 411, 1102, 96, 1117, 176, 722, 604, 1435, 1470, - 880, 181, 723, 163, 348, 56, 923, 923, 110, 390, - 358, 342, 176, 1471, 69, 110, 176, 139, 140, 41, - 42, 572, 572, 555, 556, 391, 41, 42, 1127, 307, - 1444, 110, 201, 914, 2, 206, 4, 5, 6, 7, - 626, 345, 41, 42, 286, 621, 392, 1331, 327, -289, - 715, 603, 111, 603, 865, 41, 42, 973, 63, 997, - 76, 247, 393, 472, 805, 1475, 250, 327, 732, 348, - 1333, 626, 1475, -517, 733, 358, 626, 847, 621, 176, - 76, 514, 626, 1361, 229, 626, 626, 626, 76, 871, - -468, 643, -468, 862, 848, 886, 1015, 411, 849, 35, - 394, 36, 1028, 626, 915, 266, 252, 877, 872, -468, - 815, 471, 604, 348, 348, 348, 395, 1142, 917, 411, - 916, 807, 1075, 1523, 1444, 915, 76, 442, 917, 1444, - 1185, 348, 263, 327, 918, 113, 37, 929, 908, 1185, - 40, 1082, 1317, -10, 1083, 597, 1186, 41, 42, 1444, - 692, 498, 805, 110, 357, 1309, 1444, 1409, 1318, 1113, - 1237, 626, 934, 621, 41, 42, 747, -441, 1319, 720, - 720, 748, 748, 43, 407, 846, 399, 561, 562, 893, - 599, 45, 46, 400, 1320, 748, 401, 1364, 500, 348, - 408, -442, 402, 895, 1035, 113, 345, 912, 403, 748, - 751, 751, 523, 212, 523, 276, 571, 523, 411, 404, - 523, 923, 405, 981, 45, 46, 519, 212, 850, 982, - 1277, 1278, 851, 278, 229, 472, 234, 923, 815, 604, - 714, 342, 965, 1154, 850, 411, 1374, 176, 1101, 966, - 1477, 750, 1478, 411, 572, 472, 279, -103, 967, 45, - 46, -103, 626, 472, 626, 110, 1000, 139, 140, 626, - 345, 330, 933, 603, 602, 1162, 41, 42, 994, 176, - 45, 46, 37, 1233, 706, 603, 40, 331, 1349, 579, - 348, 1357, 1350, 41, 42, 176, 332, 748, 348, 712, - 1358, 63, 715, 371, 358, 1524, 748, 923, 923, 176, - 548, 985, 982, 465, 8, 9, 10, 11, 12, 813, - 212, 602, 329, 411, 229, 953, 372, 45, 46, 953, - 953, 1360, 815, 550, 76, 307, 1365, 748, -290, 551, - 552, 333, 748, 31, 604, 8, 9, 10, 11, 12, - 807, 510, 1370, 1371, 106, 1427, 334, 626, 673, 675, - 76, 1424, 665, 57, 113, 345, 908, 911, 908, 335, - 1445, 34, 1183, 376, 31, 37, 748, 385, 666, 40, - 113, 715, 1157, 913, 602, 389, 41, 42, 805, 70, - 176, 692, 409, 934, 934, 1491, 1419, 982, 720, 714, - 342, 1492, 34, 113, 307, 129, 56, 130, 131, 132, - 48, 112, 719, 1399, 1400, 69, 41, 42, 1106, 397, - 45, 46, 106, 1547, 214, 1084, 426, 912, 751, 579, - 1159, 57, 602, 427, 1509, 1426, 772, 773, 519, 112, - 112, 432, 48, 519, 450, 1324, 519, 738, 1242, 739, - 411, 1437, 740, 48, 1088, 744, 1088, 604, -365, 48, - 345, 774, 775, 1228, -394, 484, 37, 48, 174, 175, - 40, 780, 781, 48, 1107, 214, 48, 41, 42, 48, - 461, 626, 626, 1127, 462, 2, 206, 4, 5, 6, - 7, 504, 112, 112, 776, 777, 778, 779, 291, 472, - 788, 307, 2, 206, 4, 5, 6, 7, 327, 348, - 348, 528, 529, 530, 508, 1169, 48, 442, 214, 48, - 106, 1495, 1437, 513, 525, 472, 48, 76, 111, 57, - 527, 228, 1381, 563, 564, 531, 1381, 532, 566, 533, - 534, 113, 252, 329, 411, 565, 908, 419, 661, 411, - 35, 908, 36, 569, 176, 70, 338, 48, -438, 587, - 934, 658, 659, 712, 846, 48, -291, 35, 266, 36, - 48, 590, 56, 8, 9, 10, 11, 12, -3, 214, - 639, 1190, 660, 626, 481, 329, 411, 662, 663, 761, - 664, 829, 329, 602, 766, 48, 48, 37, 667, 183, - 184, 40, 31, 669, 257, 912, 693, 345, 41, 42, - 912, 48, 694, -3, 696, 498, 698, 214, -237, 48, - 734, 745, 214, 1296, 1297, 1298, 692, 749, 48, 757, - 34, 48, 808, 1460, 906, 809, 411, -12, 112, 812, - 823, 714, 45, 46, 465, 1332, 1334, 1335, -13, 271, - 113, 867, 868, 112, 874, 907, 894, 112, 896, 897, - 922, 48, 112, 901, 904, 219, -415, 723, 113, 106, - -521, 944, 307, 937, 946, 48, 48, 57, 57, 957, - 950, 959, 48, 958, 960, 951, 626, -292, 961, 48, - 113, 106, 63, 76, 8, 9, 10, 11, 12, 962, - 57, 978, 989, 212, 342, 1106, 990, 991, 214, 106, - 1006, 1007, 1008, 1009, 116, 879, 1010, 881, 57, 1011, - 210, 220, 712, 31, 1012, 1023, 70, -403, 37, -402, - 183, 184, 40, 1037, 1422, 626, 626, 1072, 48, 41, - 42, 1535, 1074, 56, 271, 1095, 907, 1096, 1059, 307, - 1097, 34, 69, 1098, 1104, 1114, 748, 1115, 48, 48, - 1116, 1107, 159, 348, 348, 185, 1118, 928, 106, 1352, - 1121, 1123, 57, 45, 46, 48, 972, 57, 1124, 48, - 1125, 1126, 113, 407, 1132, 1129, 399, 692, 1152, 214, - 644, 1173, 1174, 400, 173, 1175, 401, 1106, 442, 408, - 1176, 106, 402, 70, 1177, 1191, 48, 665, 403, 1192, - 57, 1194, 1195, 1203, 1210, 441, 48, 1207, 258, 404, - 56, 1208, 405, 666, 1215, -3, 159, 1220, 1225, 1190, - 1223, 214, 1241, 493, 48, 1229, 253, 1508, 1234, 266, - 48, 1236, 48, 1421, 1238, 1247, 1251, 1253, 1255, 110, - 1257, 139, 238, 1107, 1258, 626, 1263, 1259, 472, 323, - 41, 42, 1260, 1261, 76, 176, 1270, 37, 339, 174, - 175, 40, 1279, 110, 1280, 139, 140, 112, 41, 42, - 113, 1287, 48, 348, 41, 42, 239, 1290, 1291, 1292, - 48, 240, 1330, 1294, 48, 1106, 1302, 1308, 48, 106, - 1315, 112, 113, 112, 372, 1323, 1321, 1325, 57, 113, - 727, 113, 1336, 113, 1329, 728, 1337, 1193, 430, 1339, - 1345, 106, 434, 1346, 1347, 1348, 149, 1359, 106, 1355, - 57, 150, 417, 151, 1356, 1366, 1367, 57, 112, 1298, - 1375, 76, 1507, 112, 1384, 1376, 1377, 113, 1383, 113, - 1393, 1107, 323, 214, 1394, 437, 70, -404, 1397, 1408, - 113, 1412, 1414, 70, 712, 445, 1507, 1507, 1416, 1417, - 703, 1423, 1418, 56, 161, 1441, 307, 1431, 1432, 106, - 56, 214, 1190, 1433, 434, 1434, 214, 488, 57, 1190, - 1350, 1507, 1436, 112, 1446, 1448, 1450, 1452, 373, 213, - 48, 1454, 1456, 1458, 1463, 1465, 1486, 521, 232, 1464, - 1476, 48, 1488, 48, 70, 1490, 1493, 1501, 1521, 1122, - 159, 1494, 1516, 1517, 1530, 479, 141, 1528, 1532, 63, - 1538, 56, 48, 520, 1545, 176, 1546, 889, 1209, 782, - 1190, 1133, 1131, 712, 784, 1133, 1307, 1411, 48, 783, - 213, 704, 785, 112, 588, 786, 1496, 214, 594, 1548, - 1369, 1385, 48, 1240, 112, 48, 112, 1214, 1479, 902, - 903, 214, 1089, 925, 215, 1222, 1093, 627, 241, 244, - 327, 631, 801, 1128, 339, 1059, 1036, 939, 873, 1103, - 242, 1316, 717, 213, 76, 1133, 66, 117, 48, 947, - 791, 76, 112, 792, 112, 793, 472, 37, 112, 174, - 175, 40, 0, 0, 0, 0, 112, 0, 41, 42, - 0, 0, 0, 1285, 1286, 215, 1288, 0, 66, 48, - 48, 0, 0, 1293, 0, 1295, 0, 0, 0, 323, - 323, 0, 0, 48, 376, 160, 0, 8, 9, 10, - 11, 12, 76, 0, 213, 0, 0, 1483, 0, 1483, - 0, 0, 0, 0, 214, 221, 0, 688, 215, 0, - 528, 529, 530, 0, 0, 0, 31, 703, 1373, 0, - 116, 0, 681, 0, 0, 0, 0, 8, 9, 10, - 11, 12, 213, 1483, 531, 1483, 532, 213, 533, 1306, - 0, 259, 0, 0, 34, 488, 0, 323, 707, 488, - 0, 0, 499, 0, 0, 0, 31, 0, 0, 521, - 0, 521, 0, 48, 521, 0, 323, 521, 0, 215, - 1398, 0, 0, 1406, 0, 48, 0, 0, 339, 457, - 0, 0, 0, 328, 34, 520, 571, 0, 411, 0, - 520, 259, 350, 520, 45, 46, 0, 0, 704, 472, - 0, 0, 0, 0, 0, 0, 472, 215, 0, 0, - 0, 0, 215, 0, 0, 0, 1443, 0, 644, 0, - 0, 1447, 406, 213, 112, 0, 750, 0, 411, 0, - 0, 1405, 323, 0, 45, 46, 703, 424, 0, 0, - 429, 431, 0, 803, 0, 160, 703, 48, 0, 1468, - 1133, 1133, 1133, 0, 0, 0, 48, 472, 48, 0, - 703, 0, 0, 0, 0, 112, 448, 0, 0, 0, - 451, 0, 452, 0, 844, 0, 0, 0, 0, 594, - 0, 459, 0, 0, 0, 853, 74, 66, 48, 0, - 0, 0, 473, 0, 0, 0, 0, 0, 215, 0, - 0, 214, 480, 0, 213, 0, 0, 0, 112, 0, - 431, 8, 9, 10, 11, 12, 645, 704, 74, 0, - 0, 213, 644, 0, 0, 0, 0, 704, 0, 0, - 112, 0, 0, 1536, 112, 0, 0, 0, 688, 1536, - 31, 704, 0, 0, 0, 0, 213, 0, 0, 891, - 1536, 0, 892, 0, 1536, 222, 0, 0, 898, 0, - 0, 0, 900, 0, 0, 0, 0, 0, 34, 0, - 0, 37, 0, 183, 184, 40, 488, 259, 0, 215, - 0, 595, 41, 42, 112, 0, 0, 623, 1133, 1133, - 0, 0, 0, 0, 0, 0, 0, 0, 339, 0, - 628, 0, 0, 0, 628, 0, 0, 259, 265, 0, - 933, 0, 602, 0, 0, 0, 45, 46, 45, 46, - 0, 215, 112, 0, 0, 0, 1461, 725, 0, 729, - 0, 0, 0, 0, 0, 0, 48, 0, 0, 0, - 0, 48, 353, 535, 536, 537, 538, 539, 540, 541, - 542, 543, 544, 545, 473, 0, 0, 996, 48, 0, - 0, 0, 803, 0, 703, 703, 0, 0, 213, 350, - 0, 988, 0, 0, 473, 0, 0, 546, 0, 0, - 0, 993, 473, 0, 1510, 0, 0, 214, 0, 0, - 0, 0, 0, 1518, 0, 1005, 213, 0, 0, 0, - 699, 213, 37, 431, 183, 184, 40, 0, 0, 0, - 0, 0, 0, 41, 42, 0, 449, 0, 713, 0, - 66, 0, 703, 703, 0, 0, 0, 0, 431, 0, - 0, 0, 431, 0, 0, 112, 0, 74, 0, 601, - 0, 602, 74, 215, 0, 704, 704, 45, 46, 0, - 803, 0, 0, 0, 0, 0, 0, 339, 48, 0, - 0, 259, 350, 0, 0, 0, 0, 0, 0, 0, - 0, 215, 213, 688, 0, 0, 215, 0, 1080, 866, - 0, 0, 214, 77, 0, 0, 213, 0, 0, 0, - 0, 0, 0, 0, 0, 488, 1108, 323, 0, 112, - 112, 112, 0, 704, 704, 0, 499, 0, 794, 37, - 0, 183, 184, 40, 0, 77, 0, 0, 0, 0, - 41, 42, 0, 0, 0, 0, 628, 806, 919, 0, - 921, 0, 0, 0, 457, 0, 0, 222, 37, 825, - 183, 184, 40, 0, 0, 0, 906, 215, 411, 41, - 42, 0, 223, 844, 45, 46, 0, 595, 0, 0, - 0, 215, 595, 0, 0, 0, 0, 0, 628, 0, - 1313, 350, 350, 350, 0, 1506, 0, 411, 0, 213, - 0, 0, 0, 45, 46, 0, 0, 0, 0, 350, - 0, 0, 0, 124, 127, 128, 0, 0, 0, 1167, - 1168, 0, 703, 0, 74, 0, 0, 699, 0, 0, - 703, 703, 703, 0, 0, 0, 0, 0, 473, 353, - 0, 0, 0, 0, 74, 0, 0, 0, 48, 48, - 0, 1204, 74, 0, 688, 0, 0, 112, 112, 355, - 0, 0, 0, 0, 473, 0, 0, 350, 0, 0, - 353, 1314, 0, 0, 215, 0, 938, 1217, 1218, 431, - 0, 0, 0, 0, 0, 254, 0, 255, 353, 0, - 74, 0, 0, 0, 703, 112, 803, 0, 0, 0, - 0, 259, 713, 704, 0, 0, 0, 968, 0, 0, - 0, 704, 704, 704, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 645, 0, 0, 0, 0, 0, - 1040, 0, 353, 0, 0, 0, 0, 126, 126, 126, - 0, 0, 0, 0, 0, 0, 699, 0, 0, 0, - 0, 0, 48, 112, 77, 0, 699, 0, 350, 77, - 628, 0, 112, 1003, 0, 628, 806, 0, 396, 0, - 699, 1090, 0, 0, 0, 704, 48, 48, 415, 416, - 1014, 339, 0, 420, 0, 422, 423, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 213, 353, 0, 0, - 0, 48, 0, 1108, 0, 0, 0, 0, 0, 126, - 0, 126, 0, 0, 0, 79, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 645, 0, - 0, 66, 0, 0, 0, 0, 275, 0, 0, 0, - 0, 353, 353, 353, 0, 0, 0, 79, 0, 0, - 0, 0, 0, 628, 223, 0, 0, 1338, 0, 353, - 259, 713, 0, 0, 1086, 1340, 1341, 1342, 0, 0, - 0, 215, 0, 0, 0, 0, 0, 353, 0, 0, - 0, 0, 0, 0, 224, 0, 0, 0, 74, 0, - 1100, 0, 126, 0, 0, 1108, 0, 1368, 431, 117, - 126, 0, 126, 126, 0, 0, 0, 126, 0, 126, - 126, 0, 0, 0, 74, 0, 0, 353, 0, 0, - 0, 77, 0, 0, 0, 0, 0, 0, 1040, 1386, + 49, 113, 453, 149, 399, 267, 768, 97, 428, 400, + 150, 401, 402, 505, 403, 151, 753, 114, 821, 404, + 405, 829, 383, 384, 260, 966, 106, 106, 440, 846, + 610, 1072, 49, 597, 166, 967, 50, 921, 828, 97, + 357, 968, 741, 147, 1175, 975, 870, 796, 407, 49, + 1383, 1141, 408, 726, 413, 76, 161, 731, 106, 1173, + 1174, 421, 358, 186, 143, 1443, 209, 822, 50, 49, + 193, 63, 202, 216, 342, 410, 226, 123, 820, 31, + 1254, 152, 823, 69, 399, 219, 177, 76, 605, 400, + 425, 401, 402, 153, 403, 106, 31, 817, 166, 404, + 405, 1185, 1306, 63, 280, 113, 629, 471, 1255, 670, + 633, 818, 1191, 113, 31, 69, 266, 271, 1199, 925, + 154, 580, 203, 411, 832, 819, 142, 1071, 407, 679, + 839, 327, 408, 413, 724, 261, 1443, 683, 262, 1181, + 31, 950, 1201, 674, 676, 149, 307, 147, 1462, 475, + 477, 411, 150, 1488, 161, 113, 345, 151, 1208, 1209, + 209, 567, 281, 252, 329, 1182, 252, 373, 411, 409, + 715, 1307, 56, 115, 70, 1203, 291, 1472, 1200, 110, + 861, 862, 966, 915, 510, 186, 186, 1516, 577, 1518, + 41, 42, 967, 161, 436, 568, 581, 879, 968, 584, + 122, 266, 1202, 1182, 56, 953, 70, 548, 549, 49, + 419, 730, 411, 1238, 476, 817, 161, 1242, 760, 668, + 1204, 209, 1060, 152, 327, 149, 519, 721, 443, 818, + 743, 821, 150, 31, 1249, 153, 735, 151, 210, 307, + 212, 220, 144, 819, 1018, 548, 1082, 439, 31, 833, + 1175, 49, 1530, 836, 493, 933, 436, 494, 97, 271, + 589, 1017, 154, 413, 271, 266, 266, 421, 665, 471, + 993, 113, 666, 161, 853, 146, 1143, 106, 856, 1545, + 822, 548, 31, 463, 610, 657, 181, 50, 1447, 471, + 342, 1005, 166, 1190, 307, 823, 800, 471, -236, -236, + 1175, 483, 168, 481, 155, 411, 76, 307, 500, 597, + 817, 76, 527, 672, 597, 1173, 1174, 357, 830, 677, + 602, 476, 63, 572, 818, 1095, 169, 472, 147, 849, + 599, 1086, 806, 850, 69, 373, 832, 447, 819, 358, + 1079, 113, 665, 569, 413, 345, 666, 996, 171, 603, + 621, 821, 837, 829, 602, 201, 460, 229, 673, 675, + 230, 736, 1191, 234, 626, 236, 748, -292, 626, -236, + 1072, 113, 245, 900, 855, 163, 1118, 177, 1402, 1403, + 988, 737, 1447, 1402, 1403, 557, 558, 1447, 714, 247, + 110, 1196, 110, 441, 630, 442, 266, 765, 634, 1134, + 822, 41, 42, 41, 42, 286, 186, 1447, 1120, 846, + 357, 327, 327, 373, 1447, 823, 41, 42, 851, 1175, + 559, 560, 852, 56, 266, 70, 307, 307, 1121, 766, + 266, 1336, 358, 626, 715, 1438, 577, 577, 519, 163, + 1529, 1329, 514, 519, 342, 1427, 519, 583, 1404, 411, + 770, 771, 772, 1413, 113, 250, 1432, 1433, 1205, 1428, + 1540, 1330, 703, 252, 1128, 377, 1071, 1544, 1334, 954, + 1337, 1339, 266, 76, 110, 357, 139, 140, -520, 327, + 266, 378, 626, -10, 49, 41, 42, 373, 720, 472, + 578, 97, 1021, 76, 113, -444, 579, 358, 327, 229, + 789, 76, 871, 884, 1106, 411, 307, 610, 113, 472, + 106, 307, 1139, 307, 307, 1191, 243, 472, 263, 1018, + 50, 751, 1191, 885, 212, 113, 345, 888, 1248, 110, + 1161, 1163, 872, 471, 643, 435, 1134, 553, 554, 76, + 41, 42, 1240, 1366, 881, 883, 110, 998, 139, 238, + 912, 873, 806, 712, 914, 63, 851, 41, 42, 930, + 1102, 1060, 387, 1473, 327, 1016, 498, 69, 1338, 390, + 392, 572, 572, 1191, -471, 684, -471, 1474, 388, 307, + -445, 579, 1128, 239, 1103, 391, 393, 915, 240, 276, + 626, 345, 394, -471, 715, 621, 1500, 435, 252, 329, + 411, 603, 1505, 603, 1280, 1281, 847, 110, 395, 139, + 140, 599, 2, 206, 4, 5, 6, 7, 41, 42, + 523, 626, 1525, -124, 550, -124, 626, 1532, 621, -124, + 551, 552, 626, 163, 278, 626, 626, 626, 37, 229, + 806, 234, 40, 916, -124, -124, 866, 212, 279, 41, + 42, 848, 714, 626, 1376, 266, 56, 974, 70, 917, + 577, 48, 112, 1089, 342, 1089, 918, 863, 330, 703, + 916, 918, 1029, 331, 808, 43, -106, 35, 1016, 36, + -106, 878, 919, 45, 46, 113, 1083, 1084, 909, 597, + 112, 112, 1076, 48, 372, 357, 1478, 332, 1188, 1364, + 1188, 705, 333, 1478, 48, 1320, 1401, 706, 1114, 1409, + 48, 626, 935, 621, 1189, 334, 1312, 358, 48, 720, + 720, 1321, 1322, 1036, 48, 335, 399, 48, 376, 229, + 48, 400, 748, 401, 402, 1352, 403, 76, 1323, 1353, + -3, 404, 405, 112, 112, 113, 345, 110, 1367, 141, + 751, 751, 1446, 472, 1526, 722, 371, 1450, 41, 42, + 389, 723, 500, 76, 528, 529, 530, 48, 555, 556, + 48, 407, 385, 1412, 571, 408, 411, 48, 413, 472, + 692, 1377, 45, 46, 966, 1471, 561, 562, 531, 703, + 532, 397, 533, 534, 967, 572, 426, 442, 732, 703, + 968, 241, 244, 626, 733, 626, 409, 1001, 48, 1429, + 626, 345, 714, 703, 603, 427, 48, 712, 1165, 432, + 750, 48, 411, 450, 342, 1440, 603, -368, 45, 46, + 986, 983, 523, 110, 523, 139, 140, 523, 715, -397, + 523, 419, 661, 411, 41, 42, 48, 48, 37, 954, + 174, 175, 40, 954, 954, 1146, 1480, 484, 1481, 41, + 42, 747, 48, 738, 504, 739, 806, 748, 740, 1539, + 48, 744, 1158, 212, 894, 1539, 307, 329, 411, 48, + 748, 110, 48, 139, 140, 372, 1539, 212, 461, 112, + 1539, 1186, 41, 42, 808, 1498, 1440, 887, 626, 411, + 462, 548, 106, 110, 112, 113, 345, 909, 112, 909, + 1134, 1527, 48, 112, 41, 42, 896, 715, 727, 1373, + 1374, 113, 748, 728, 1402, 1403, 48, 48, 1172, 291, + 327, 76, 982, 48, 935, 935, 525, 995, 983, 720, + 48, 508, 510, 706, 113, 307, 1236, 63, 513, 665, + 413, 1360, 579, 666, 912, 1422, 983, 748, 914, 69, + 1107, 129, 457, 130, 131, 132, 934, 116, 602, 751, + 106, 1327, 41, 42, 45, 46, 1361, 712, 1363, 564, + 1512, 212, 748, 527, 748, -293, 847, 773, 774, 48, + 1246, 1368, 8, 9, 10, 11, 12, 748, 1231, 781, + 782, 345, 8, 9, 10, 11, 12, 1430, 1448, 48, + 48, 692, 563, 1427, 748, 159, 565, 703, 703, 1494, + 498, 31, 626, 626, 566, 1495, 48, 775, 776, 1128, + 48, 31, 8, 9, 10, 11, 12, 1550, 481, 329, + 411, 644, 307, 579, -294, 830, 329, 602, 56, 34, + 70, 8, 9, 10, 11, 12, 714, 48, 1384, 34, + 338, 31, 1384, 777, 778, 779, 780, 48, 106, 569, + -441, 258, 1299, 1300, 1301, 703, 703, 587, 667, 159, + 31, 1145, 113, 411, 1157, 48, 411, 909, 1160, 34, + 602, 48, 909, 48, 37, 590, -3, 76, 40, 645, + 1162, 935, 602, 658, 659, 41, 42, 639, 34, 266, + 660, 37, 323, 472, 662, 40, 1108, 663, 664, 57, + 57, 339, 41, 42, 626, 1193, 1288, 1289, 112, 1291, + 342, 43, 1245, 48, 411, 257, 1296, 96, 1298, 45, + 46, 48, 669, 693, 694, 48, 696, 698, 719, 48, + 345, 57, 112, 749, 112, 734, 45, 46, -240, 1463, + 745, 2, 206, 4, 5, 6, 7, 757, 809, 96, + 37, 430, 174, 175, 40, 434, 810, 813, 442, 824, + 148, 41, 42, -12, 1355, 57, 96, 869, 57, 112, + 228, -13, 271, 113, 112, 875, 868, 895, 897, 111, + 189, 898, -418, 96, 902, 323, 96, 376, 905, 219, + 725, 113, 729, 723, 56, 307, 70, 923, -524, 106, + 37, 712, 174, 175, 40, 1316, 35, 938, 36, 626, + 945, 41, 42, 113, 947, 951, 952, 434, 958, 959, + 488, 106, 960, 961, 112, -295, 962, 692, 963, 1107, + 979, 48, 8, 9, 10, 11, 12, 703, 1038, 106, + 521, 990, 48, 991, 48, 703, 703, 703, 992, 1007, + 76, 1425, 1008, 159, 1009, 348, 1073, 1010, 626, 626, + 1011, 31, 1538, 48, 96, 1012, 63, 271, 1013, 1024, + -406, -405, 307, 908, 1408, 1096, 1075, 96, 69, 48, + 712, 1098, 1097, 1099, 112, 1105, 1115, 588, 748, 34, + 1116, 594, 1117, 48, 1119, 112, 48, 112, 106, 1122, + 973, 1124, 398, 189, 1125, 113, 1126, 1127, 399, 703, + 627, 1130, 1133, 400, 631, 401, 402, 339, 403, 1155, + 57, 1107, 1176, 404, 405, 1178, 96, 76, 1177, 48, + 1179, 106, 1194, 112, 1195, 112, 1180, 1197, 96, 112, + 1198, 1206, 867, 472, 210, 220, 212, 112, 1210, 1211, + 57, 1213, 407, -3, 1511, 1193, 408, 704, 1218, 1223, + 48, 48, 266, 1228, 493, 1226, 1232, 56, 96, 70, + 1237, 1239, 323, 323, 48, 37, 665, 1241, 626, 40, + 666, 162, 479, 1244, 1250, 1108, 41, 42, 692, 1256, + 1424, 920, 1252, 922, 1258, 194, 1260, 457, 217, 1261, + 688, 227, 1262, 113, 1263, 1264, 1266, 1273, 1290, 1282, + 1283, 1293, 814, 116, 602, 1294, 1311, 1295, 1318, 1107, + 45, 46, 1324, 1297, 1328, 113, 1305, 1332, 1333, 106, + 465, 1335, 113, 1340, 113, 1326, 113, 1342, 488, 441, + 323, 442, 488, 1348, 56, 96, 70, 1349, 1350, 149, + 1351, 106, 521, 1358, 521, 48, 150, 521, 106, 323, + 521, 151, 1359, 1362, 1369, 1510, 604, 48, 1370, 1301, + 113, 339, 113, 1378, 1379, 1386, 1380, 1108, 1387, 162, + 76, 1396, 1397, 113, 327, -407, 1400, 76, 1411, 1510, + 1510, 1415, 374, 1417, 1419, 1420, 472, 161, 1426, 307, + 176, 1434, 1435, 472, 173, 1421, 1436, 1439, 1193, 106, + 644, 1437, 66, 117, 1510, 1193, 112, 1444, 162, 1353, + 893, 373, 1449, 189, 1453, 323, 2, 206, 4, 5, + 6, 7, 348, 1455, 1451, 1457, 804, 1459, 76, 48, + 1461, 162, 1466, 1467, 66, 1468, 253, 1479, 48, 176, + 48, 1493, 176, 444, 472, 1489, 1491, 112, 528, 529, + 530, 160, 1496, 1497, 704, 1504, 1193, 845, 645, 1519, + 1520, 1524, 594, 1531, 1041, 1108, 1533, 1535, 854, 1541, + 48, 221, 531, 57, 532, 1548, 533, 1309, 1549, 890, + 1212, 35, 783, 36, 784, 1132, 785, 56, 176, 70, + 112, 96, 787, 1310, 56, 604, 70, 37, 786, 183, + 184, 40, 1499, 1414, 644, 1091, 1551, 259, 41, 42, + 1243, 1388, 112, 1372, 1217, 348, 112, 903, 1482, 904, + 1090, 688, 1225, 926, 1129, 215, 1094, 802, 1037, 874, + 989, 1104, 417, 940, 601, 111, 602, 717, 1319, 0, + 994, 242, 45, 46, 948, 56, 0, 70, 792, 328, + 374, 176, 793, 0, 1006, 437, 794, 259, 350, 488, + 0, 0, 645, 0, 0, 445, 112, 0, 0, 0, + 0, 0, 0, 0, 704, 0, 215, 0, 0, 0, + 348, 339, 0, 0, 704, 0, 0, 0, 406, 0, + 0, 0, 0, 0, 0, 0, 761, 0, 704, 0, + 0, 767, 0, 424, 112, 176, 429, 431, 816, 0, + 604, 160, 176, 0, 0, 0, 0, 0, 48, 215, + 0, 0, 0, 48, 348, 348, 348, 0, 374, 0, + 0, 0, 448, 520, 0, 0, 451, 0, 452, 0, + 48, 997, 348, 0, 0, 0, 804, 459, 0, 0, + 1486, 465, 1486, 66, 0, 0, 0, 0, 473, 0, + 924, 0, 1041, 0, 0, 0, 0, 0, 480, 0, + 0, 37, 0, 183, 184, 40, 431, 0, 0, 0, + 215, 176, 41, 42, 0, 0, 1486, 0, 1486, 0, + 0, 0, 0, 0, 0, 913, 0, 0, 176, 0, + 348, 0, 176, 0, 0, 0, 74, 0, 907, 0, + 411, 8, 9, 10, 11, 12, 45, 46, 215, 112, + 0, 0, 880, 215, 882, 0, 816, 604, 0, 908, + 0, 0, 0, 0, 804, 0, 0, 0, 74, 0, + 31, 339, 48, 259, 0, 0, 0, 595, 0, 0, + 0, 0, 987, 623, 0, 0, 0, 688, 1170, 1171, + 0, 0, 0, 0, 0, 176, 628, 0, 34, 0, + 628, 0, 0, 259, 929, 222, 0, 1286, 0, 488, + 1109, 323, 681, 112, 0, 112, 112, 0, 0, 0, + 0, 0, 348, 0, 8, 9, 10, 11, 12, 0, + 348, 0, 704, 704, 0, 0, 0, 0, 707, 215, + 571, 0, 411, 0, 0, 0, 1220, 1221, 45, 46, + 473, 816, 0, 31, 0, 0, 0, 0, 0, 1031, + 0, 0, 0, 604, 0, 350, 0, 845, 0, 0, + 473, 0, 0, 0, 0, 520, 0, 0, 473, 0, + 520, 34, 0, 520, 0, 0, 0, 0, 0, 0, + 704, 704, 353, 0, 0, 57, 699, 0, 0, 431, + 0, 0, 924, 0, 8, 9, 10, 11, 12, 0, + 0, 0, 0, 0, 713, 0, 66, 0, 0, 0, + 215, 0, 0, 750, 431, 411, 0, 0, 431, 0, + 0, 45, 46, 31, 0, 0, 0, 0, 0, 0, + 0, 0, 48, 48, 1085, 0, 913, 924, 688, 0, + 0, 112, 112, 176, 0, 0, 0, 259, 350, 0, + 0, 34, 215, 57, 0, 0, 449, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 604, 0, 0, 0, + 0, 0, 1142, 0, 0, 176, 0, 74, 0, 112, + 804, 0, 74, 0, 0, 0, 0, 77, 0, 0, + 0, 176, 0, 934, 795, 602, 0, 0, 0, 0, + 0, 45, 46, 0, 37, 176, 183, 184, 40, 0, + 0, 0, 628, 807, 0, 41, 42, 0, 1341, 77, + 0, 0, 0, 1031, 0, 826, 1343, 1344, 1345, 892, + 1317, 348, 348, 0, 0, 0, 48, 112, 899, 0, + 0, 185, 901, 595, 0, 0, 112, 1123, 595, 45, + 46, 57, 0, 0, 628, 0, 223, 350, 350, 350, + 48, 48, 704, 0, 0, 0, 0, 339, 0, 1135, + 704, 704, 704, 1135, 215, 350, 37, 222, 183, 184, + 40, 0, 0, 0, 0, 48, 176, 41, 42, 1109, + 1389, 0, 0, 699, 0, 0, 8, 9, 10, 11, + 12, 0, 215, 924, 473, 0, 0, 215, 0, 0, + 0, 0, 0, 907, 913, 411, 0, 0, 0, 913, + 0, 45, 46, 1135, 0, 31, 0, 0, 0, 0, + 473, 0, 0, 350, 704, 0, 0, 214, 0, 0, + 0, 0, 939, 355, 74, 431, 0, 0, 0, 0, + 0, 0, 0, 34, 0, 0, 0, 0, 37, 353, + 183, 184, 40, 0, 74, 924, 924, 259, 713, 41, + 42, 0, 74, 969, 0, 0, 0, 0, 215, 0, + 0, 1109, 0, 0, 0, 0, 0, 0, 214, 0, + 353, 0, 215, 0, 0, 601, 0, 602, 0, 0, + 0, 57, 57, 45, 46, 0, 0, 0, 353, 0, + 74, 0, 0, 699, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 699, 57, 350, 0, 628, 0, 0, + 1004, 214, 628, 807, 0, 0, 0, 699, 77, 0, + 0, 0, 57, 77, 0, 0, 0, 1015, 0, 0, + 0, 176, 353, 0, 0, 0, 0, 0, 0, 1081, + 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 1109, + 0, 26, 27, 28, 0, 0, 215, 348, 348, 0, + 31, 79, 214, 0, 0, 0, 57, 0, 66, 0, + 0, 57, 0, 0, 37, 0, 183, 184, 40, 0, + 1485, 0, 1485, 0, 0, 41, 42, 353, 34, 0, + 628, 0, 0, 79, 0, 207, 39, 259, 713, 0, + 214, 1087, 0, 0, 57, 214, 0, 0, 223, 0, + 1135, 265, 1135, 1135, 0, 0, 1485, 0, 1485, 45, + 46, 0, 0, 0, 0, 0, 0, 1101, 0, 0, + 224, 353, 353, 353, 0, 431, 117, 0, 45, 46, + 924, 0, 0, 0, 0, 323, 0, 0, 0, 353, + 0, 0, 0, 0, 0, 0, 924, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 353, 0, 0, + 0, 0, 0, 0, 0, 77, 0, 348, 74, 0, + 0, 0, 1207, 0, 0, 0, 0, 0, 0, 0, + 355, 214, 0, 595, 0, 77, 0, 0, 0, 0, + 0, 0, 57, 77, 74, 0, 429, 353, 0, 0, + 0, 699, 699, 0, 350, 350, 0, 356, 0, 0, + 0, 355, 0, 0, 57, 0, 924, 924, 0, 0, + 0, 57, 0, 0, 1192, 0, 0, 0, 0, 355, + 0, 77, 353, 0, 0, 0, 0, 0, 1135, 1135, + 0, 0, 0, 215, 0, 0, 8, 9, 10, 11, + 12, 0, 8, 9, 10, 11, 12, 0, 0, 699, + 699, 0, 214, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 57, 355, 0, 31, 1464, 353, 0, 0, + 0, 31, 0, 0, 0, 0, 0, 353, 0, 353, + 0, 0, 0, 0, 222, 0, 479, 353, 0, 0, + 0, 353, 79, 34, 214, 0, 628, 79, 37, 34, + 183, 184, 40, 0, 37, 0, 183, 184, 40, 41, + 42, 0, 0, 0, 176, 41, 42, 0, 0, 0, + 0, 0, 713, 0, 1513, 0, 0, 0, 355, 0, + 0, 0, 0, 1521, 0, 907, 0, 411, 0, 0, + 0, 185, 0, 45, 46, 0, 0, 0, 0, 45, + 46, 0, 74, 0, 0, 0, 0, 37, 0, 183, + 184, 40, 0, 0, 0, 1287, 0, 0, 41, 42, + 0, 0, 355, 355, 355, 0, 0, 0, 0, 0, + 0, 0, 353, 259, 0, 0, 0, 66, 0, 0, + 355, 0, 224, 0, 1509, 0, 411, 0, 0, 699, + 0, 713, 45, 46, 0, 117, 213, 0, 355, 0, + 1371, 0, 0, 0, 0, 232, 214, 0, 0, 77, + 0, 215, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 699, 0, 0, 0, 0, 0, 0, 0, 699, + 699, 699, 0, 0, 214, 77, 0, 0, 355, 214, + 350, 350, 0, 0, 0, 0, 0, 213, 86, 79, + 0, 0, 0, 0, 1192, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 356, 0, 0, 0, 0, 79, + 0, 0, 0, 355, 176, 0, 0, 79, 0, 0, + 86, 0, 0, 0, 0, 353, 353, 117, 353, 353, + 213, 0, 0, 699, 0, 356, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 215, 0, 74, 0, + 214, 0, 0, 356, 0, 79, 0, 225, 355, 0, + 0, 0, 0, 0, 214, 0, 0, 0, 355, 0, + 355, 0, 0, 0, 0, 223, 0, 0, 355, 0, + 0, 0, 355, 353, 353, 0, 0, 0, 0, 0, + 0, 213, 1483, 0, 1487, 0, 0, 356, 0, 0, + 350, 0, 8, 9, 10, 11, 12, 0, 0, 0, + 167, 0, 172, 0, 0, 178, 179, 180, 0, 182, + 0, 0, 0, 0, 0, 117, 0, 0, 1515, 213, + 1517, 31, 0, 233, 213, 0, 0, 0, 0, 0, + 0, 0, 0, 77, 363, 248, 249, 1192, 0, 499, + 0, 0, 0, 0, 1192, 0, 353, 0, 214, 34, + 0, 0, 356, 0, 37, 0, 183, 184, 40, 0, + 0, 0, 1546, 355, 1547, 41, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1554, 1555, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 222, + 0, 1509, 0, 411, 0, 1192, 356, 356, 356, 45, + 46, 0, 1534, 0, 0, 0, 0, 0, 0, 0, + 213, 74, 0, 0, 356, 0, 0, 0, 0, 0, + 0, 0, 0, 353, 0, 353, 0, 0, 0, 86, + 0, 0, 356, 0, 86, 0, 0, 0, 0, 0, + 0, 0, 0, 79, 0, 0, 0, 0, 0, 8, + 9, 10, 11, 12, 0, 353, 0, 0, 0, 0, + 0, 0, 0, 353, 353, 353, 0, 0, 0, 79, + 0, 0, 356, 0, 353, 353, 355, 355, 31, 355, + 355, 0, 0, 0, 0, 0, 0, 0, 74, 0, + 0, 213, 0, 0, 0, 0, 0, 0, 0, 77, + 0, 0, 0, 0, 0, 0, 34, 356, 213, 0, + 0, 37, 0, 183, 184, 40, 0, 0, 0, 0, + 0, 0, 41, 42, 0, 0, 0, 353, 0, 225, + 0, 0, 0, 213, 355, 355, 124, 127, 128, 0, + 0, 0, 0, 0, 0, 214, 0, 0, 265, 0, + 0, 0, 356, 0, 0, 0, 45, 46, 0, 0, + 0, 0, 356, 0, 356, 0, 0, 0, 0, 224, + 0, 0, 356, 0, 0, 0, 356, 0, 535, 536, + 537, 538, 539, 540, 541, 542, 543, 544, 545, 0, + 0, 592, 0, 600, 353, 0, 86, 0, 0, 0, + 0, 0, 0, 0, 624, 625, 0, 355, 254, 0, + 255, 363, 546, 0, 0, 0, 86, 0, 0, 0, + 0, 0, 0, 0, 86, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 79, 0, 0, + 0, 74, 363, 0, 0, 0, 0, 0, 74, 0, + 223, 0, 0, 0, 0, 213, 0, 0, 0, 0, + 363, 0, 86, 0, 0, 0, 0, 356, 0, 0, + 0, 0, 77, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 213, 355, 0, 355, 0, 213, 0, + 0, 396, 0, 0, 0, 0, 0, 0, 0, 74, + 0, 415, 416, 0, 363, 0, 420, 0, 422, 423, 0, 0, 0, 0, 0, 0, 355, 0, 0, 0, - 0, 77, 0, 0, 0, 0, 0, 0, 0, 77, - 0, 0, 353, 0, 0, 0, 595, 8, 9, 10, - 11, 12, 0, 0, 0, 0, 0, 355, 0, 429, - 0, 356, 0, 0, 699, 699, 0, 350, 350, 126, - 0, 0, 213, 0, 0, 355, 31, 77, 0, 0, - 0, 0, 0, 1108, 0, 0, 353, 1189, 0, 0, - 0, 0, 0, 0, 0, 0, 353, 0, 353, 0, - 0, 0, 0, 222, 34, 0, 353, 0, 0, 37, - 353, 183, 184, 40, 1482, 0, 1482, 0, 0, 355, - 41, 42, 699, 699, 0, 0, 0, 0, 0, 0, - 0, 1283, 0, 0, 0, 0, 0, 0, 0, 1480, - 0, 1484, 0, 0, 0, 0, 601, 215, 602, 0, - 1482, 0, 1482, 0, 45, 46, 79, 0, 0, 0, - 0, 79, 0, 0, 0, 0, 0, 213, 0, 628, - 0, 74, 0, 0, 0, 1512, 0, 1514, 0, 323, - 0, 0, 0, 0, 355, 0, 0, 0, 0, 0, - 0, 0, 0, 713, 0, 0, 0, 0, 0, 86, - 0, 353, 0, 0, 0, 0, 0, 413, 0, 0, - 0, 0, 0, 0, 421, 0, 0, 0, 0, 1543, - 0, 1544, 0, 0, 0, 0, 0, 0, 355, 355, - 355, 86, 0, 0, 1551, 1552, 1284, 0, 0, 0, - 0, 0, 215, 0, 0, 0, 355, 0, 0, 0, - 0, 0, 796, 797, 259, 0, 224, 0, 66, 0, - 0, 0, 0, 0, 355, 0, 0, 0, 225, 0, - 699, 0, 713, 0, 0, 77, 117, 0, 0, 0, - 0, 830, 0, 0, 833, 834, 413, 837, 0, 839, - 840, 0, 0, 0, 841, 842, 0, 0, 0, 0, - 0, 77, 699, 0, 355, 0, 0, 0, 0, 0, - 699, 699, 699, 0, 353, 353, 0, 353, 353, 0, - 0, 350, 350, 79, 0, 0, 0, 0, 8, 9, - 10, 11, 12, 0, 0, 1189, 0, 74, 356, 355, - 0, 577, 0, 79, 0, 0, 0, 0, 0, 581, - 0, 79, 584, 0, 0, 363, 0, 31, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 117, 356, - 0, 0, 353, 353, 699, 0, 126, 126, 0, 0, - 0, 0, 0, 355, 0, 34, 0, 356, 0, 79, - 37, 0, 0, 355, 40, 355, 0, 0, 0, 0, - 223, 41, 42, 355, 0, 126, 0, 355, 126, 126, - 0, 126, 0, 126, 126, 0, 413, 0, 126, 126, - 421, 0, 0, 0, 0, 0, 0, 43, 0, 0, - 0, 356, 970, 971, 0, 45, 46, 0, 0, 0, - 0, 350, 0, 353, 0, 0, 0, 0, 0, 0, - 86, 0, 0, 0, 0, 86, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 117, 0, 77, 0, + 0, 0, 0, 0, 355, 355, 355, 0, 0, 0, + 0, 0, 0, 214, 0, 355, 355, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 213, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 363, + 0, 0, 0, 213, 0, 0, 0, 0, 0, 0, + 356, 356, 0, 356, 356, 0, 0, 0, 355, 0, + 0, 0, 0, 499, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 79, 1014, 0, 0, 8, 9, 10, + 11, 12, 0, 363, 363, 363, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 214, 0, + 0, 363, 0, 0, 282, 283, 31, 284, 356, 356, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 363, + 0, 0, 0, 0, 0, 355, 0, 0, 0, 0, + 86, 0, 0, 285, 34, 0, 0, 213, 0, 286, + 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, + 41, 42, 0, 292, 293, 0, 86, 0, 0, 363, + 0, 0, 0, 8, 9, 10, 11, 12, 0, 0, + 0, 0, 77, 0, 0, 0, 294, 0, 379, 77, + 0, 356, 0, 0, 344, 46, 296, 297, 298, 299, + 0, 0, 31, 0, 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 222, 0, 1189, 0, - 0, 0, 0, 0, 0, 1189, 356, 413, 355, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 74, 0, + 0, 0, 0, 0, 0, 0, 0, 927, 0, 928, + 34, 0, 0, 0, 224, 37, 931, 932, 0, 40, + 77, 937, 0, 0, 0, 0, 41, 42, 0, 363, + 0, 0, 0, 942, 0, 0, 79, 0, 946, 363, + 0, 363, 0, 0, 0, 0, 225, 0, 356, 363, + 356, 0, 719, 363, 0, 0, 0, 0, 0, 0, + 45, 46, 0, 0, 0, 0, 980, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 353, 0, 353, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 8, 9, 10, 11, 12, 0, - 356, 356, 356, 0, 0, 0, 1189, 0, 0, 0, - 225, 0, 353, 1531, 0, 0, 126, 126, 356, 0, - 353, 353, 353, 31, 0, 0, 0, 0, 0, 0, - 0, 353, 353, 0, 0, 0, 356, 0, 0, 0, - 0, 0, 0, 0, 0, 74, 0, 79, 0, 577, - 577, 34, 0, 0, 1091, 0, 37, 0, 183, 184, + 356, 0, 0, 0, 0, 0, 0, 0, 356, 356, + 356, 0, 0, 0, 0, 0, 0, 0, 0, 356, + 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 79, 86, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 213, 0, 0, 0, 0, 0, + 0, 0, 1166, 0, 0, 8, 9, 10, 11, 12, + 0, 0, 0, 0, 363, 797, 798, 0, 0, 0, + 0, 0, 356, 0, 0, 0, 0, 0, 165, 0, + 0, 0, 282, 283, 31, 284, 1025, 1026, 1027, 1028, + 0, 1030, 0, 0, 831, 218, 0, 834, 835, 0, + 838, 0, 840, 841, 0, 0, 1074, 842, 843, 0, + 0, 285, 34, 0, 0, 0, 0, 286, 0, 0, + 1080, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 0, 0, 0, 0, 356, + 0, 0, 165, 0, 0, 0, 272, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 379, 0, 0, 0, + 1100, 0, 1167, 46, 296, 297, 298, 299, 0, 0, + 0, 0, 0, 0, 0, 165, 0, 363, 363, 0, + 363, 363, 0, 0, 0, 369, 79, 0, 0, 375, + 0, 0, 0, 79, 0, 0, 0, 0, 0, 0, + 86, 0, 0, 0, 0, 1131, 0, 0, 0, 0, + 0, 1140, 0, 0, 0, 0, 1144, 0, 0, 0, + 0, 1148, 0, 1149, 0, 0, 0, 1151, 0, 1152, + 1153, 0, 213, 1156, 0, 363, 363, 0, 165, 0, + 0, 0, 1168, 0, 79, 971, 972, 0, 0, 0, + 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1183, 1184, 0, 0, 0, 0, 0, 0, 165, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 1214, 0, 0, + 1216, 0, 0, 375, 0, 0, 0, 0, 31, 0, + 165, 0, 0, 0, 0, 0, 0, 0, 363, 0, + 0, 0, 126, 126, 126, 0, 0, 0, 0, 0, + 0, 0, 0, 524, 0, 0, 34, 213, 0, 0, + 0, 0, 0, 1230, 0, 0, 165, 0, 0, 1234, + 1235, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 225, 0, 0, 0, 0, 0, 0, 0, 1251, + 0, 0, 0, 1253, 0, 0, 0, 0, 1257, 0, + 0, 0, 0, 86, 598, 0, 0, 0, 0, 622, + 0, 1265, 0, 0, 126, 363, 126, 363, 0, 0, + 0, 0, 0, 0, 1272, 0, 1274, 1275, 1276, 1277, + 0, 0, 0, 0, 0, 0, 0, 0, 1092, 0, + 0, 275, 1284, 0, 1285, 0, 0, 363, 172, 0, + 0, 0, 0, 0, 0, 363, 363, 363, 0, 0, + 0, 0, 0, 0, 0, 0, 363, 363, 0, 0, + 211, 0, 0, 0, 0, 0, 0, 1313, 1314, 231, + 86, 235, 0, 237, 0, 165, 165, 0, 0, 0, + 246, 0, 369, 0, 0, 0, 0, 126, 0, 0, + 0, 0, 0, 0, 0, 126, 0, 126, 126, 0, + 0, 0, 126, 524, 126, 126, 0, 0, 0, 363, + 0, 211, 0, 235, 237, 246, 0, 1346, 1347, 0, + 0, 0, 0, 0, 0, 0, 0, 1357, 0, 0, + 0, 716, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 165, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 211, 524, 0, 524, 0, 0, + 524, 0, 165, 524, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 126, 369, 363, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1392, 1222, + 1393, 1394, 1395, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1399, 0, 0, 0, 0, 0, 0, 0, + 0, 1410, 0, 0, 0, 211, 0, 235, 237, 246, + 0, 0, 0, 86, 0, 0, 0, 0, 165, 0, + 86, 0, 0, 0, 0, 0, 1431, 0, 0, 0, + 369, 0, 0, 0, 812, 0, 0, 0, 0, 0, + 0, 0, 0, 211, 0, 0, 0, 0, 211, 0, + 0, 0, 0, 0, 156, 0, 0, 0, 0, 0, + 598, 0, 0, 497, 0, 598, 0, 0, 0, 1469, + 1470, 86, 0, 0, 369, 369, 369, 0, 0, 0, + 0, 0, 1475, 0, 0, 0, 0, 0, 0, 1475, + 0, 0, 369, 0, 0, 0, 0, 0, 0, 0, + 0, 251, 0, 0, 0, 0, 0, 0, 0, 0, + 1308, 256, 211, 0, 0, 0, 0, 0, 0, 0, + 0, 1508, 0, 0, 524, 1514, 0, 0, 0, 0, + 0, 0, 0, 0, 211, 0, 0, 0, 0, 235, + 237, 0, 0, 0, 0, 0, 0, 246, 0, 0, + 369, 0, 936, 1536, 0, 1537, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 386, 0, 1552, 1553, 716, 0, 0, 0, 0, + 211, 1556, 1557, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 418, 0, 0, 0, 211, 282, + 283, 0, 284, 211, 0, 211, 0, 0, 433, 0, + 0, 0, 0, 0, 0, 0, 0, 438, 0, 0, + 0, 0, 211, 0, 0, 211, 211, 446, 285, 0, + 0, 0, 369, 211, 286, 0, 622, 0, 287, 0, + 369, 288, 289, 290, 291, 41, 42, 211, 292, 293, + 0, 0, 464, 0, 211, 0, 0, 474, 0, 0, + 0, 126, 126, 0, 0, 0, 0, 0, 0, 0, + 482, 294, 0, 379, 0, 0, 492, 0, 496, 45, + 46, 296, 297, 298, 299, 0, 0, 0, 0, 0, + 126, 0, 788, 126, 126, 526, 126, 0, 126, 126, + 0, 0, 0, 126, 126, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -296, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 31, 716, 0, 0, 586, 0, + 0, 0, 0, 591, 0, 0, 0, 0, 0, 0, + 524, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 211, + 0, 0, 636, -296, 165, 0, 637, 638, 0, 640, + 0, 0, 0, 0, 0, 0, 651, 652, 0, 653, + 654, 0, 655, 0, 656, 0, 0, 211, 0, 0, + 0, 0, 211, 0, 0, 0, 0, 0, 0, 0, + 0, 586, 0, 0, 282, 283, 0, 284, 0, 671, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 598, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 126, 126, 285, 682, 0, 0, 0, 0, 286, + 0, 369, 369, 287, 0, 0, 288, 289, 290, 291, + 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, + 708, 0, 0, 211, 0, 0, 711, 0, 0, 0, + 0, 464, 0, 0, 0, 0, 294, 211, 379, 0, + 0, 380, 0, 0, 45, 46, 296, 297, 298, 299, + 0, 0, 0, 0, 0, 0, 0, 497, 0, 0, + 0, 524, 0, 0, 0, 0, 0, 746, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 764, 0, -519, 0, 0, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 0, 26, 27, 28, 29, 0, 211, + 30, 791, 0, 31, 32, 0, 0, 0, 0, 716, + 801, 211, 0, 0, 0, 0, 0, 803, 0, 0, + 0, 0, 0, 811, 0, 0, 0, 0, 33, 126, + 211, 34, 825, 35, 126, 36, 37, 0, 38, 39, 40, 0, 0, 0, 0, 0, 0, 41, 42, 0, - 0, 355, 355, 79, 355, 355, 356, 86, 0, 0, - 0, 0, 0, 0, 353, 0, 0, 0, 0, 0, - 0, 0, 363, 906, 77, 411, 0, 86, 0, 0, - 0, 45, 46, 0, 0, 86, 0, 0, 0, 0, - 0, 356, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 363, 0, 0, 0, 0, 0, 355, - 355, 0, 0, 0, 0, 0, 884, 0, 0, 0, - 887, 363, 0, 86, 0, 0, 0, 0, 0, 0, - 0, 353, 0, 0, 0, 356, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 356, 0, 356, 0, 0, - 0, 0, 224, 126, 0, 356, 0, 0, 126, 356, - 0, 0, 0, 0, 0, 363, 167, 0, 172, 0, - 0, 178, 179, 180, 0, 182, 0, 0, 74, 0, - 355, 0, 0, 0, 0, 74, 0, 0, 0, 233, - 0, 0, 0, 0, 0, 1219, 0, 0, 0, 0, - 0, 248, 249, 0, 8, 9, 10, 11, 12, 0, + 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 341, 364, 0, 0, 0, + 0, 0, 865, 43, 0, 44, 0, 0, 0, 0, + 0, 45, 46, 0, 0, 0, 0, 0, 716, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 414, + 0, 0, 0, 0, 0, 0, 414, 0, 811, 0, + 0, 0, 0, 0, 0, 0, 906, 0, 0, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 369, 369, 26, + 27, 28, 0, 211, 0, 0, 218, 251, 31, 0, + 0, 0, 0, 0, 0, 0, 0, 943, 944, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 79, 0, 0, 223, 0, 0, 0, 0, 0, 0, - 363, 0, 0, 31, 0, 0, 74, 0, 0, 0, - 0, 0, 0, 0, 0, 77, 0, 0, 0, 0, - 356, 0, 577, 0, 0, 0, 0, 355, 0, 355, - 0, 34, 0, 0, 0, 0, 37, 0, 183, 184, - 40, 0, 0, 0, 363, 363, 363, 41, 42, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 355, - 0, 0, 363, 0, 0, 0, 0, 355, 355, 355, - 0, 0, 0, 1506, 0, 411, 0, 0, 355, 355, - 363, 45, 46, 0, 0, 507, 0, 509, 512, 126, - 0, 86, 77, 0, 1305, 515, 516, 0, 0, 0, + 0, 0, 0, 211, 0, 0, 34, 0, 414, 0, + 0, 37, 0, 38, 39, 40, 0, 0, 0, 0, + 981, 0, 41, 42, 0, 126, 985, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 211, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 43, 211, + 157, 0, 0, 0, 0, 0, 45, 46, 0, 0, + 0, 0, 0, 414, 0, 0, 0, 0, 0, 0, + 0, 414, 582, 0, 414, 585, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 364, 0, 369, 0, 614, + 1019, 0, 0, 0, 0, 0, 0, 1020, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 632, 0, + 1022, 341, 1023, 0, 0, 0, 0, 0, 0, 0, + 0, 211, 0, 0, 0, 0, 1035, 0, 0, 0, + 0, 0, 1039, 0, 0, 211, 0, 0, 414, 0, + 0, 0, 414, 524, 1077, 524, 0, 1078, 0, 0, + 0, 0, 0, 0, 0, 0, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 509, 509, 0, 0, 0, 0, 0, 86, 0, 0, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 355, 0, 356, 356, 0, 356, 356, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 509, 0, - 0, 0, 0, 0, 0, 363, 79, 8, 9, 10, + 0, 0, 0, 364, 0, 0, 0, 0, 0, 524, + 0, 524, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 507, 0, 509, 512, 0, 0, 0, 0, + 0, 0, 515, 516, 0, 0, 0, 0, 165, 0, + 0, 0, 0, 0, 0, 0, 0, 509, 509, 414, + 0, 0, 364, 0, 591, 0, 211, 0, 0, 0, + 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, -296, + 0, 26, 27, 28, 0, 509, 0, 0, 0, 1150, + 31, 414, 0, 0, 0, 341, 364, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, + 0, 509, 0, 37, 0, 336, 337, 40, 0, -296, + 0, 0, 0, 0, 41, 42, 0, 0, 0, 0, + 0, 414, 414, 0, 0, 0, 0, 526, 0, 0, + 0, 211, 0, 1215, 0, 0, 321, 0, 0, 0, + 805, 364, 338, 0, 0, 0, 346, 0, 45, 46, + 0, 614, 0, 614, 614, 0, 0, 0, 382, 382, + 614, 0, 0, 0, 0, 0, 0, 1227, 0, 0, + 844, 364, 1229, 0, 0, 0, 364, 0, 0, 0, + 1233, 0, 0, 0, 0, 364, 364, 364, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 364, 0, 0, 0, 0, 414, 886, + 0, 0, 414, 889, 0, 1259, 0, 0, 0, 891, + 0, 0, 0, 0, 0, 0, 0, 1267, 0, 321, + 1268, 0, 1269, 0, 0, 0, 0, 0, 414, 0, + 0, 0, 0, 0, 0, 0, 1278, 1279, 0, 0, + 0, 0, 0, 478, 0, 0, 0, 0, 0, 0, + 0, 364, 614, 0, 0, 0, 0, 0, 1292, 0, + 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, + 509, 509, 509, 509, 509, 509, 509, 509, 0, 0, + 0, 0, 0, 0, 0, 341, 364, 0, 0, 0, + 414, 414, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1331, 0, 0, 0, 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, -296, 0, + 26, 27, 28, 0, 0, 414, 0, 0, 0, 31, + 0, 0, 0, 364, 0, 0, 0, 0, 0, 0, + 805, 364, 0, 0, 614, 0, 614, 0, 0, 0, + 382, 0, 0, 0, 0, 0, 614, 34, 211, 0, + 0, 0, 37, 0, 336, 337, 40, 0, -296, 0, + 1381, 0, 1382, 41, 42, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1390, 0, 1391, 0, + 0, 0, 0, 0, 0, 0, 509, 0, 0, 635, + 0, 338, 0, 1398, 0, 0, 0, 45, 46, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1416, + 1418, 0, 0, 0, 0, 0, 0, 0, 805, 0, + 1423, 0, 0, 1233, 0, 341, 364, 414, 0, 414, + 0, 0, 0, 414, 710, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1445, 0, 0, 509, 0, 0, + 0, 0, 0, 1452, 614, 614, 1454, 0, 1456, 1458, + 1460, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 742, 0, 0, 0, 0, 509, 0, + 0, 0, 0, 0, 0, 0, 759, 0, 0, 414, + 0, 742, 0, 0, 742, 0, 0, 0, 1490, 0, + 1492, 0, 1233, 0, 0, 0, 0, 769, 0, 0, + 414, 1147, 0, 0, 0, 0, 0, 1503, 0, 0, + 0, 364, 0, 0, 0, 0, 0, 414, 1159, 790, + 614, 614, 1164, 0, 0, 0, 0, 0, 0, 799, + 0, 0, 364, 364, 0, 0, 346, 0, 0, 0, + 0, 759, 0, 0, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 29, 0, 0, 30, 0, 0, + 31, 32, 0, 0, 0, 0, 0, 0, 509, 0, + 864, 0, 0, 0, 0, 414, 0, 414, 382, 0, + 0, 0, 414, 0, 0, 33, 0, 0, 34, 0, + 35, 614, 36, 37, 0, 38, 39, 40, 0, 0, + 0, 0, 0, 0, 41, 42, 0, 0, 0, 0, + 0, 0, 0, 509, 805, 414, 1247, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 43, 0, 44, 0, 0, 0, -523, 0, 45, 46, + 364, 0, 0, 0, 0, 0, 0, 0, 509, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 509, 0, 0, 0, 0, 0, 0, 282, 283, + 0, 284, 0, 0, 0, 0, 759, 0, 965, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 976, 0, + 0, 0, 0, 0, 984, 0, 0, 285, 0, 0, + 0, 341, 509, 641, 0, 139, 140, 287, 0, 0, + 288, 289, 290, 291, 41, 42, 0, 292, 293, 364, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1002, 1003, 0, + 294, 346, 642, 0, 643, 380, 0, 0, 45, 46, + 296, 297, 298, 299, 0, 346, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 364, 364, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 509, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1033, 0, 0, 0, 382, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, -293, 0, 26, 27, 28, - 0, 0, 0, 0, 509, 0, 31, 0, 0, 0, - 0, 356, 356, 0, 0, 0, 0, 0, 355, 363, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 363, - 0, 363, 0, 0, 34, 0, 225, 1143, 126, 363, - 0, 38, 39, 363, 0, -293, 0, 592, 0, 600, - 0, 0, 0, 0, 1155, 0, 0, 0, 0, 0, - 624, 625, 0, 0, 0, 77, 0, 0, 0, 0, - 282, 283, 77, 284, 0, 0, 635, 0, 338, 0, - 0, 0, 356, 0, 45, 46, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 285, - 0, 0, 0, 0, 86, 286, 0, 0, 0, 287, - 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, - 293, 0, 0, 77, 0, 224, 0, 0, 0, 0, - 0, 0, 413, 0, 363, 0, 0, 0, 0, 0, - 0, 0, 294, 0, 379, 0, 0, 79, 0, 0, - 45, 46, 296, 297, 298, 299, 0, 0, 0, 356, - 0, 356, 1013, 787, 0, 8, 9, 10, 11, 12, - 0, 0, 1243, 509, 509, 509, 509, 509, 509, 509, - 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, - 509, 356, 282, 283, 31, 284, 0, 0, 0, 356, - 356, 356, 0, 0, 0, 0, 0, 0, 0, 0, - 356, 356, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 285, 34, 0, 79, 0, 0, 286, 0, 0, - 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, - 0, 292, 293, 0, 0, 0, 0, 363, 363, 0, - 363, 363, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 356, 294, 0, 379, 0, 0, 0, - 86, 0, 344, 46, 296, 297, 298, 299, 0, 0, + 21, 22, 23, 24, 25, 0, 346, 26, 27, 28, + 29, 509, 509, 30, 0, 0, 31, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 33, 0, 0, 34, 321, 35, 0, 36, 37, + 0, 38, 39, 40, 0, 0, 0, 0, 364, 0, + 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 382, 0, 0, 0, 282, 283, 976, + 284, 0, 0, 742, 0, 0, 43, 0, 44, 0, + 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, + 0, 0, 0, 0, 1154, 0, 285, 0, 0, 0, + 0, 0, 286, 0, 0, 1169, 287, 0, 0, 288, + 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 382, 0, 1187, + 0, 0, 0, 282, 283, 414, 284, 0, 0, 294, + 0, 379, 0, 0, 976, 976, 758, 45, 46, 296, + 297, 298, 299, 0, 0, 0, 0, 0, 0, 414, + 414, 0, 285, 0, 0, 1219, 0, 0, 286, 0, + 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, + 42, 0, 292, 293, 414, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 294, 509, 379, 0, 0, + 973, 0, 0, 45, 46, 296, 297, 298, 299, 0, + 976, 0, 509, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 864, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1270, 1271, 0, 0, 0, + 0, 1, 2, 206, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 29, 509, 509, 30, 282, 283, 31, 1042, 1043, + 0, 1044, 0, 0, 1045, 1046, 1047, 1048, 1049, 1050, + 1051, 1052, 0, 0, 0, 1053, 0, 0, 0, 1054, + 1055, 0, 33, 0, 285, 34, 0, 35, 0, 36, + 1056, 0, 38, 39, 287, 0, 0, 288, 289, 290, + 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 294, 0, 1057, + 0, 0, 171, 0, 0, 45, 46, 296, 297, 298, + 299, 0, 0, 0, 0, 1058, 0, 0, 0, 0, + -131, 0, 0, 0, 0, 0, 1375, 0, 0, 742, 1, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 363, 363, 26, 27, 28, - 29, 0, 0, 30, 282, 283, 31, 284, 0, 509, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 285, 34, 0, 35, 0, 36, 286, - 0, 38, 39, 287, 165, 0, 288, 289, 290, 291, + 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, + 29, 0, 0, 30, 282, 283, 31, 284, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 0, 285, 34, 0, 35, 31, 36, 286, + 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, - 0, 218, 0, 0, 0, 0, 363, 79, 0, 0, - 509, 0, 0, 0, 79, 0, 294, 0, 1056, 0, - 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, - 0, 0, 0, 926, 0, 927, 0, 0, 0, -128, - 509, 0, 930, 931, 0, 0, 0, 936, 165, 225, - 0, 0, 272, 0, 0, 0, 0, 0, 0, 941, - 0, 0, 0, 0, 945, 79, 0, 0, 0, 0, - 0, 86, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 165, 0, 363, 0, 363, 0, 0, 0, 0, - 0, 369, 979, 0, 0, 375, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1163, 0, 0, 8, - 9, 10, 11, 12, 0, 363, 0, 0, 0, 0, - 0, 0, 0, 363, 363, 363, 0, 0, 0, 0, - 0, 0, 0, 0, 363, 363, 282, 283, 31, 284, - 0, 0, 0, 0, 165, 0, 0, 0, 86, 0, - 0, 0, 0, 0, 0, 0, 218, 0, 0, 0, - 509, 0, 0, 0, 0, 285, 34, 0, 0, 0, - 0, 286, 0, 0, 165, 287, 0, 0, 288, 289, - 290, 291, 41, 42, 0, 292, 293, 363, 0, 0, - 0, 1024, 1025, 1026, 1027, 0, 1029, 0, 0, 375, - 0, 0, 0, 0, 0, 509, 165, 0, 294, 0, - 379, 1073, 0, 0, 0, 0, 1164, 46, 296, 297, - 298, 299, 0, 0, 0, 1079, 0, 0, 0, 524, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 509, 0, 165, 0, 0, 0, 0, 0, 0, 211, - 0, 0, 0, 509, 363, 0, 0, 0, 231, 0, - 235, 0, 237, 0, 0, 1099, 0, 0, 0, 246, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 598, 0, 0, 0, 0, 622, 0, 0, 0, 0, - 0, 0, 0, 0, 509, 0, 0, 0, 0, 0, - 211, 86, 235, 237, 246, 0, 0, 0, 86, 0, - 1130, 0, 0, 0, 0, 0, 1137, 0, 0, 0, - 0, 1141, 0, 0, 0, 0, 1145, 0, 1146, 0, - 0, 0, 1148, 0, 1149, 1150, 0, 0, 1153, 0, - 0, 0, 0, 211, 0, 0, 0, 1165, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 86, - 0, 165, 165, 0, 0, 1180, 1181, 0, 369, 0, - 0, 509, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 524, - 0, 0, 1211, 0, 0, 1213, 0, 0, 0, 0, - 0, 0, 0, 0, 211, 0, 235, 237, 246, 0, - 0, 0, 0, 0, 0, 0, 0, 716, 0, 0, - 0, 8, 9, 10, 11, 12, 0, 0, 0, 165, - 0, 509, 509, 0, 0, 0, 0, 0, 1227, 0, - 0, 524, 211, 524, 1231, 1232, 524, 211, 165, 524, - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 369, 497, 0, 1248, 0, 0, 1252, 0, 0, - 0, 1254, 0, 0, 0, 0, 0, 0, 34, 0, - 0, 0, 0, 37, 1262, 183, 184, 40, 0, 0, - 0, 0, 0, 0, 41, 42, 0, 1269, 0, 1271, - 1272, 1273, 1274, 0, 0, 0, 0, 0, 0, 0, - 0, 211, 0, 0, 165, 1281, 0, 1282, 0, 0, - 185, 172, 0, 0, 0, 0, 369, 0, 45, 46, - 811, 0, 0, 211, 0, 0, 0, 0, 235, 237, - 0, 0, 0, 0, 0, 0, 246, 0, 0, 0, - 1310, 1311, 0, 0, 0, 0, 598, 0, 0, 0, - 0, 598, 0, 0, 0, 0, 0, 0, 0, 0, - 369, 369, 369, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 369, 211, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1343, 1344, 0, 0, 0, 0, 0, 211, 0, 0, - 1354, 0, 211, 0, 211, 0, 0, 0, 0, 0, - 524, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 211, 0, 0, 211, 211, 509, 0, 0, 0, - 0, 0, 211, 0, 0, 0, 369, 0, 935, 0, - 0, 0, 509, 0, 0, 0, 211, 0, 0, 0, - 0, 0, 0, 211, 0, 0, 0, 0, 0, 0, - 0, 1389, 0, 1390, 1391, 1392, 0, 0, 0, 0, - 0, 716, 0, 0, 0, 1396, 156, 0, 0, 0, - 0, 0, 0, 0, 1407, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 0, 0, 26, 27, 28, 0, 1428, - 0, 0, 509, 509, 31, 0, 0, 8, 9, 10, - 11, 12, 0, 251, 0, 0, 0, 369, 0, 0, - 0, 622, 0, 256, 0, 369, 0, 0, 0, 0, - 0, 0, 34, 0, 0, 0, 31, 37, 0, 38, - 39, 40, 1466, 1467, 0, 0, 0, 0, 41, 42, - 0, 0, 0, 0, 0, 1472, 0, 0, 211, 0, - 0, 0, 1472, 0, 34, 0, 0, 0, 0, 37, - 0, 183, 184, 40, 43, 0, 157, 0, 0, 156, - 41, 42, 45, 46, 0, 0, 211, 0, 0, 0, - 0, 211, 0, 386, 1505, 0, 0, 0, 1511, 0, - 0, 0, 0, 0, 0, 0, 265, 0, 0, 0, - 0, 0, 0, 0, 45, 46, 418, 0, 0, 0, - 716, 0, 0, 0, 0, 0, 1533, 0, 1534, 0, - 433, 0, 0, 0, 0, 524, 0, 0, 0, 438, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 446, - 0, 0, 0, 0, 0, 0, 1549, 1550, 0, 165, - 0, 0, 211, 0, 1553, 1554, 0, 0, 0, 0, - 0, 0, 0, 0, 464, 0, 211, 0, 0, 474, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 482, 0, 0, 0, 497, 0, 492, 0, - 496, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 598, 0, 526, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 369, 369, 26, 27, - 28, 0, 0, 0, 0, 0, 0, 31, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 211, 0, 0, - 586, 0, 0, 0, 0, 591, 0, 0, 0, 211, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, - 37, 0, 38, 39, 40, 0, 0, 0, 211, 0, - 0, 41, 42, 0, 636, 0, 524, 0, 637, 638, - 0, 640, 0, 0, 0, 0, 0, 0, 651, 652, - 0, 653, 654, 0, 655, 0, 656, 43, 0, 44, - 0, 0, 0, 0, 0, 45, 46, 0, 0, 0, - 0, 0, 0, 586, 0, 0, 0, 0, 0, 0, - 0, 671, 0, 0, 0, 0, 0, 0, 0, 341, - 364, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 716, 0, 0, 0, 682, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 8, 9, 10, 11, - 12, 0, 0, 414, 0, 0, 0, 0, 0, 0, - 414, 0, 708, 0, 0, 0, 0, 0, 711, 0, - 0, 211, 0, 464, 218, 31, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, -293, 0, 26, 27, 28, 0, - 0, 211, 0, 34, 0, 31, 0, 0, 37, 746, - 0, 716, 40, 0, 0, 0, 0, 0, 0, 41, - 42, 0, 0, 0, 764, 0, 0, 0, 0, 0, - 0, 0, 414, 34, 0, 0, 211, 0, 37, 0, - 336, 337, 40, 0, -293, 719, 0, 211, 0, 41, - 42, 0, 0, 45, 46, 0, 0, 0, 0, 0, - 369, 369, 0, 790, 0, 0, 0, 0, 0, 218, - 0, 0, 800, 0, 0, 635, 0, 338, 321, 802, - 0, 0, 0, 45, 46, 810, 0, 414, 346, 0, - 0, 0, 0, 0, 824, 414, 582, 0, 414, 585, - 382, 382, 0, 0, 0, 0, 0, 0, 0, 364, - 0, 0, 0, 614, 0, 0, 0, 0, 0, 211, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 632, 211, 864, 341, 205, 2, 206, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 414, 26, 27, 28, 414, 0, 0, 0, - 810, 321, 31, 0, 0, 0, 0, 0, 905, 0, - 369, 0, 282, 283, 0, 284, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 478, 0, 364, 0, 0, - 34, 0, 35, 0, 36, 0, 0, 207, 39, 251, - 0, 285, 0, 0, 0, 0, 0, 286, 0, 942, - 943, 287, 211, 0, 288, 289, 290, 291, 41, 42, - 0, 292, 293, 0, 0, 0, 524, 0, 524, 0, - 0, 0, 0, 414, 208, 0, 364, 0, 0, 0, - 45, 46, 980, 0, 294, 0, 379, 984, 0, 380, - 0, 0, 45, 46, 296, 297, 298, 299, 0, 0, - 0, 0, 524, 0, 524, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 414, 0, 0, 0, 341, - 364, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 165, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 382, 0, 0, 0, 0, 211, 0, 0, - 0, 1018, 0, 0, 0, 0, 0, 0, 1019, 0, - 0, 0, 0, 0, 0, 414, 414, 0, 0, 0, - 0, 1021, 0, 1022, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 804, 364, 0, 1034, 0, 0, - 0, 0, 0, 1038, 0, 614, 0, 614, 614, 0, - 0, 0, 0, 0, 614, 1076, 0, 0, 1077, 0, - 0, 0, 0, 0, 843, 364, 0, 0, 0, 0, - 364, 0, 0, 0, 0, 0, 0, 0, 0, 364, - 364, 364, 0, 0, 0, 0, 710, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 364, 0, 0, - 0, 0, 414, 885, 0, 0, 414, 888, 0, 0, - 0, 0, 0, 890, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 742, 0, 0, 0, 0, - 0, 0, 414, 0, 0, 591, 0, 0, 759, 0, - 0, 0, 0, 742, 0, 0, 742, 0, 0, 0, - 0, 0, 0, 0, 0, 364, 614, 0, 0, 768, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1147, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 789, 0, 0, 0, 0, 0, 0, 0, 341, - 364, 798, 0, 0, 414, 414, 0, 0, 346, 0, - 0, 0, 0, 759, 0, 0, 0, 0, 0, 0, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 526, 0, - 26, 27, 28, 0, 1212, 0, 0, 0, 414, 31, - 0, 0, 0, 0, 211, 0, 364, 0, 0, 0, - 0, 0, 863, 804, 364, 0, 0, 614, 0, 614, - 382, 0, 0, 0, 0, 0, 0, 34, 1224, 614, - 0, 0, 37, 1226, 207, 39, 40, 0, 0, 0, - 0, 1230, 0, 41, 42, 0, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, -293, 0, 0, 0, 0, 43, - 0, 270, 0, 0, 1256, 31, 0, 45, 46, 0, - 0, 0, 0, 0, 0, 0, 1264, 0, 0, 1265, - 0, 1266, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 804, 0, 34, 0, 1275, 1276, 0, 341, 364, - 414, 0, 414, 0, -293, 0, 414, 0, 759, 0, - 964, 0, 0, 0, 0, 0, 0, 1289, 0, 0, - 975, 0, 0, 0, 0, 0, 983, 614, 614, 0, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, -294, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, - 0, 0, 414, 0, 1328, 0, 0, 0, 1001, 1002, - 0, 0, 346, 0, 0, 0, 0, 0, 282, 283, - 0, 284, 0, 414, 1144, 0, 346, 34, 0, 0, - 0, 0, 0, 0, 364, 0, 0, 0, -294, 0, - 414, 1156, 0, 614, 614, 1161, 0, 285, 0, 0, - 0, 0, 0, 286, 0, 364, 364, 287, 0, 0, - 288, 289, 290, 291, 41, 42, 1032, 292, 293, 0, - 382, 0, 0, 0, 0, 0, 0, 0, 0, 1378, - 0, 1379, 0, 0, 0, 0, 0, 0, 0, 0, - 294, 0, 379, 1387, 0, 1388, 0, 758, 45, 46, - 296, 297, 298, 299, 0, 0, 0, 346, 0, 0, - 0, 0, 1395, 0, 0, 0, 0, 0, 414, 0, - 414, 0, 0, 0, 0, 414, 0, 0, 1413, 1415, - 0, 0, 0, 0, 614, 0, 0, 0, 0, 1420, - 0, 0, 1230, 0, 0, 0, 321, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 804, 414, 1244, - 0, 0, 0, 1442, 0, 0, 0, 0, 0, 0, - 0, 0, 1449, 0, 382, 1451, 0, 1453, 1455, 1457, - 975, 364, 0, 0, 742, 282, 283, 0, 284, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1151, 0, 0, 0, 0, - 0, 0, 0, 0, 285, 0, 1166, 1487, 0, 1489, - 641, 1230, 139, 140, 287, 0, 0, 288, 289, 290, - 291, 41, 42, 0, 292, 293, 1500, 0, 382, 0, - 1184, 0, 341, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 975, 975, 294, 0, 642, - 364, 643, 380, 0, 0, 45, 46, 296, 297, 298, - 299, 0, 0, 0, 0, 0, 1216, 0, 0, 0, + 110, 0, 38, 39, 0, 0, 294, 0, 1057, 0, + 0, 41, 42, 0, 45, 46, 296, 297, 298, 299, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -131, 0, 0, 0, 0, 1, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 364, - 364, 26, 27, 28, 29, 0, 0, 30, 0, 0, - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 975, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 34, 863, - 35, 0, 36, 0, 0, 38, 39, 0, 0, 0, - 0, 0, 0, 0, 1267, 1268, 0, 1, 2, 206, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 44, 0, 26, 27, 28, 29, 45, 46, - 30, 282, 283, 31, 1041, 1042, 0, 1043, 0, 0, - 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 0, 0, - 0, 1052, 0, 0, 0, 1053, 1054, 0, 33, 364, - 285, 34, 0, 35, 0, 36, 1055, 0, 38, 39, - 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, - 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 29, 0, 0, 30, 282, 283, + 31, 284, 0, 0, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -297, 0, 0, 0, 285, 34, 0, + 35, 0, 36, 286, 31, 38, 39, 287, 0, 321, + 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 294, 0, 1056, 0, 0, 171, 0, - 0, 45, 46, 296, 297, 298, 299, 0, 0, 0, - 0, 1057, 0, 0, 0, 0, -128, 0, 0, 0, - 0, 0, 0, 0, 0, 1372, 0, 0, 742, 0, - 0, 0, 0, 0, 0, 0, 414, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 414, 414, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 414, 1, 2, 206, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 0, 26, 27, 28, 29, 0, 0, 30, - 282, 283, 31, 284, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 0, 26, 27, 28, 0, 0, 285, - 34, 0, 35, 31, 36, 286, 0, 38, 39, 287, - 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, - 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 34, 0, 0, 0, 0, 110, 0, 38, 39, - 0, 0, 294, 0, 44, 0, 0, 41, 42, 0, - 45, 46, 296, 297, 298, 299, 2, 206, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 0, 0, 26, 27, 28, 0, 0, 0, 321, 282, - 283, 31, 284, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 0, 26, 27, 28, 0, 0, 285, 34, - 0, 35, 31, 36, 286, 0, 38, 39, 287, 0, - 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 34, 0, 0, 0, 0, 0, 0, 38, 39, 0, - 0, 294, 0, 343, 0, 0, 0, 0, 758, 344, - 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 0, 0, 0, 0, 282, 283, - 31, 284, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 0, 0, 26, 27, 28, 0, 0, 285, 34, 0, - 35, 31, 36, 286, 0, 38, 39, 287, 0, 0, - 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, - 0, 0, 0, 0, 0, 0, 207, 39, 0, 0, - 294, 0, 963, 0, 0, 0, 0, 758, 344, 46, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, + 294, 0, 44, -297, 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, @@ -2468,22 +2471,22 @@ 284, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 0, 0, 0, 0, 0, 285, 34, 0, 35, + 0, 26, 27, 28, 0, 0, 285, 34, 0, 35, 31, 36, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, - 0, 963, 0, 0, 0, 0, 758, 45, 46, 296, + 0, 0, 0, 0, 0, 38, 39, 0, 0, 294, + 0, 343, 0, 0, 0, 0, 758, 344, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, 282, 283, 31, 284, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 285, 34, 0, 35, 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, + 26, 27, 28, 0, 0, 285, 34, 0, 35, 31, 36, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 294, 0, - 343, 0, 0, 0, 0, 0, 344, 46, 296, 297, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, + 0, 0, 0, 0, 207, 39, 0, 0, 294, 0, + 964, 0, 0, 0, 0, 758, 344, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, @@ -2493,9 +2496,9 @@ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 285, 34, 0, 35, 0, 36, - 286, 0, 207, 39, 287, 0, 0, 288, 289, 290, + 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 294, 0, 998, - 0, 0, 0, 0, 0, 999, 46, 296, 297, 298, + 0, 0, 0, 0, 0, 0, 0, 294, 0, 964, + 0, 0, 0, 0, 758, 45, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, @@ -2508,5 +2511,5 @@ 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 294, 0, 963, 0, + 0, 0, 0, 0, 0, 0, 294, 0, 343, 0, 0, 0, 0, 0, 344, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, @@ -2520,338 +2523,354 @@ 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 294, 0, 379, 0, 0, - 0, 0, 0, 45, 46, 296, 297, 298, 299, -516, - 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, + 0, 0, 0, 0, 0, 294, 0, 999, 0, 0, + 0, 0, 0, 1000, 46, 296, 297, 298, 299, 2, + 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, + 0, 0, 282, 283, 31, 284, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 285, 34, 0, 35, 0, 36, 286, 0, 38, + 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 964, 0, 0, 0, + 0, 0, 344, 46, 296, 297, 298, 299, 2, 206, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 0, 26, 27, 28, 0, 0, 0, + 0, 282, 283, 31, 284, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 285, 34, 0, 35, 0, 36, 286, 0, 207, 39, + 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, + 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 294, 0, 379, 0, 0, 0, 0, + 0, 45, 46, 296, 297, 298, 299, 205, 2, 206, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 0, 26, 27, 28, 0, 0, 0, + 0, 0, 0, 31, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 0, 26, 27, 28, 485, 486, + 487, 34, 0, 35, 31, 36, 37, 0, 207, 39, + 40, 0, 0, 0, 0, 0, 0, 41, 42, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 38, + 39, 0, 0, 43, 0, 208, 0, 0, 0, 0, + 0, 45, 46, 1, 2, 206, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, -296, 0, + 26, 27, 28, 29, 0, 0, 30, 0, 0, 31, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, + 0, 36, 0, 0, 38, 39, 0, 0, -296, 1, + 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 29, + 0, 44, 30, 0, 0, 31, 0, 45, 46, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 34, 0, 35, 0, 36, 0, 0, + 38, 39, 205, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, - 27, 28, 29, 0, 0, 30, 0, 0, 31, 32, + 27, 28, 0, 0, 0, 0, 0, 44, 31, 0, + 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 34, 0, 35, 0, + 36, 0, 0, 207, 39, 0, 2, 206, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 0, + 208, 31, 0, 0, 0, 0, 45, 46, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, + 0, 35, 0, 36, 37, 0, 207, 39, 40, 0, + 0, 0, 0, 0, 0, 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 33, 0, 0, 34, 0, 35, 0, - 36, 37, 0, 38, 39, 40, 0, 0, 0, 0, - 0, 0, 41, 42, 0, 0, 0, 0, 0, 0, + 0, 43, 0, 208, 0, 0, 0, 0, 0, 45, + 46, 2, 206, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, + 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, + 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 34, 0, 35, 0, 36, 0, + 31, 38, 39, 0, 2, 206, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 34, 0, + 26, 27, 28, 0, 0, 38, 39, -403, 678, 31, + 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 43, 0, - 44, 0, 0, 0, 0, 0, 45, 46, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, + 635, 36, 338, 0, 38, 39, 0, 0, 45, 46, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1354, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 678, 0, 0, 0, 0, 0, 45, 46, 2, + 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 0, 0, 26, 27, 28, 29, 0, - 0, 30, 0, 0, 31, 32, 0, 0, 0, 0, + 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, + 0, 0, 0, 0, 31, 0, 0, 0, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 34, 0, 35, 0, 36, 31, 685, 38, + 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, - 0, 0, 34, 0, 35, 0, 36, 37, 0, 38, - 39, 40, 0, 0, 0, 0, 0, 0, 41, 42, + 0, 1356, 0, 0, 0, 34, 0, 0, 0, 0, + 0, 0, 38, 39, 0, 0, 678, 0, 0, 0, + 0, 0, 45, 46, 2, 206, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 686, + 26, 27, 28, 687, 0, 45, 46, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 43, 0, 44, 0, 0, 0, - -520, 0, 45, 46, 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 29, 0, 0, 30, 0, 0, - 31, 32, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 33, 0, 0, 34, 0, - 35, 0, 36, 37, 0, 38, 39, 40, 0, 0, - 0, 0, 0, 0, 41, 42, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 43, 0, 44, 0, 0, 0, 0, 0, 45, 46, - 205, 2, 206, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, - 0, 0, 0, 0, 0, 0, 31, 0, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, - 28, 485, 486, 487, 34, 0, 35, 31, 36, 37, - 0, 207, 39, 40, 0, 0, 0, 0, 0, 0, - 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, - 0, 0, 38, 39, 0, 0, 43, 0, 208, 0, - 0, 0, 0, 0, 45, 46, 1, 2, 206, 4, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, + 0, 36, 0, 0, 207, 39, 0, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, -293, 0, 26, 27, 28, 29, 0, 0, 30, - 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, + 0, 270, 31, 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, 0, 0, 38, 39, 0, - 0, -293, 2, 206, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, - 28, 0, 0, 0, 44, 0, 0, 31, 0, 0, + 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, + 0, 0, 0, 0, 678, 31, 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, - 37, 0, 207, 39, 40, 0, 0, 0, 0, 0, - 0, 41, 42, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 43, 0, 208, - 0, 0, 0, 0, 0, 45, 46, 2, 206, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, - 0, 0, 31, 0, 0, 0, 0, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, - 34, 0, 35, 0, 36, 0, 31, 38, 39, 0, - 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 34, 0, 26, 27, 28, 0, - 0, 38, 39, -400, 678, 31, 0, 0, 0, 0, - 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 34, 0, 35, 635, 36, 338, 0, - 38, 39, 0, 0, 45, 46, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1351, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 678, 0, 0, - 0, 0, 0, 45, 46, 2, 206, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 0, 0, 0, 0, 0, 0, - 31, 0, 0, 0, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 0, 26, 27, 28, 0, 34, 0, - 35, 0, 36, 31, 685, 38, 39, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1353, 0, 0, - 0, 34, 0, 0, 0, 0, 0, 0, 38, 39, - 0, 0, 678, 0, 0, 0, 0, 0, 45, 46, - 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 686, 26, 27, 28, 687, - 0, 45, 46, 0, 0, 31, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, 0, 0, - 207, 39, 0, 2, 206, 4, 5, 6, 7, 8, + 38, 39, 0, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, - 27, 28, 0, 0, 0, 0, 0, 270, 31, 0, + 27, 28, 0, 0, 0, 0, 0, 593, 31, 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, 0, - 36, 0, 0, 38, 39, 0, 2, 206, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 0, 0, 26, 27, 28, 0, 0, 0, 0, 0, - 678, 31, 0, 0, 0, 0, 45, 46, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, - 0, 35, 0, 36, 0, 0, 38, 39, 0, 2, - 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 36, 0, 0, 207, 39, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, - 0, 0, 0, 593, 31, 0, 0, 0, 0, 45, - 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 282, 283, 31, 284, 0, 0, 0, 0, + 208, 0, 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 34, 0, 35, 0, 36, 0, 0, 207, - 39, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 0, 285, 34, 0, 0, 0, 0, 286, 0, 38, + 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 517, 0, 0, 171, + 0, 0, 45, 46, 296, 297, 298, 299, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 0, 0, 0, 282, 283, 31, 284, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, + 27, 28, 0, 0, 285, 34, 0, 0, 31, 0, + 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, + 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, + 0, 37, 0, 336, 337, 40, 0, 294, -37, 295, + 0, 0, 41, 42, 0, 45, 46, 296, 297, 298, + 299, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 0, 0, 0, 0, 282, 283, - 31, 284, 0, 0, 0, 0, 208, 0, 0, 0, - 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 285, 34, 0, - 0, 0, 0, 286, 0, 38, 39, 287, 0, 0, + 338, 26, 27, 28, 0, 0, 45, 46, 282, 283, + 31, 284, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 285, 34, 0, + 0, 31, 0, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 294, 0, 517, 0, 0, 171, 0, 0, 45, 46, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, + 0, 0, 0, 0, 110, 0, 38, 39, 0, 0, + 294, 0, 295, 0, 0, 41, 42, 0, 45, 46, 296, 297, 298, 299, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 0, 26, 27, 28, 0, 0, 0, - 0, 282, 283, 31, 284, 8, 9, 10, 11, 12, + 24, 25, 0, 44, 26, 27, 28, 0, 0, 45, + 46, 282, 283, 31, 284, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, - 285, 34, 0, 0, 31, 0, 286, 0, 38, 39, + 285, 34, 0, 0, 31, 685, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 34, 0, 0, 0, 0, 37, 0, 336, - 337, 40, 0, 294, -36, 295, 0, 0, 41, 42, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 38, + 39, 0, 0, 294, 0, 157, 0, 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 0, 338, 26, 27, 28, - 0, 0, 45, 46, 282, 283, 31, 284, 8, 9, + 21, 22, 23, 24, 25, 0, 686, 26, 27, 28, + 1093, 0, 45, 46, 282, 283, 31, 284, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, - 28, 0, 0, 285, 34, 0, 0, 31, 0, 286, + 28, 0, 0, 285, 34, 0, 0, 31, 685, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, - 110, 0, 38, 39, 0, 0, 294, 0, 295, 0, - 0, 41, 42, 0, 45, 46, 296, 297, 298, 299, + 0, 0, 38, 39, 0, 0, 294, 0, 593, 0, + 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 0, 44, - 26, 27, 28, 0, 0, 45, 46, 282, 283, 31, - 284, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 686, + 26, 27, 28, 1224, 0, 45, 46, 282, 283, 31, + 284, 0, 0, 0, 0, 0, 0, 0, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 285, 34, 26, 27, + 28, 0, 286, 0, 38, 39, 287, 31, 0, 288, + 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 34, 0, 0, 0, 294, + 0, 379, 38, 39, 0, 0, 0, 45, 46, 296, + 297, 298, 299, 467, 2, 206, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 257, + 26, 27, 28, 0, 0, 45, 46, 0, 0, 31, + 0, 0, 0, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 0, 34, 0, 35, + 0, 36, 31, 0, 38, 39, 0, 0, 0, 0, + 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 0, 0, 285, 34, 0, 0, - 31, 685, 286, 0, 38, 39, 287, 0, 0, 288, - 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, - 0, 0, 0, 0, 0, 38, 39, 0, 0, 294, - 0, 157, 0, 0, 0, 0, 0, 45, 46, 296, - 297, 298, 299, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 686, 26, 27, 28, 1092, 0, 45, 46, - 282, 283, 31, 284, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 0, 26, 27, 28, 0, 0, 285, - 34, 0, 0, 31, 685, 286, 0, 38, 39, 287, - 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, - 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 34, 0, 0, 0, 0, 0, 0, 38, 39, - 0, 0, 294, 0, 593, 0, 0, 0, 0, 0, - 45, 46, 296, 297, 298, 299, 8, 9, 10, 11, + 34, 26, 27, 28, 0, 37, 0, 38, 39, 40, + 31, 0, 0, 0, -3, 0, 41, 42, 0, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 0, 34, 26, + 27, 28, 43, 37, 44, 207, 39, 40, 31, 0, + 45, 46, 0, 0, 41, 42, 0, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, -296, 34, 26, 27, 28, + 43, 37, 270, 336, 337, 40, 31, 0, 45, 46, + 0, 0, 41, 42, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -296, 34, 26, 27, 28, 635, 0, + 338, 38, 39, 0, 31, -296, 45, 46, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 34, 0, 0, 0, 635, 31, 338, 38, + 39, 0, 0, -296, 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 686, 26, 27, 28, 1221, - 0, 45, 46, 282, 283, 31, 284, 0, 0, 0, - 0, 0, 0, 0, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 285, 34, 26, 27, 28, 0, 286, 0, - 38, 39, 287, 31, 0, 288, 289, 290, 291, 41, - 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 34, 0, 0, 0, 294, 0, 379, 38, 39, - 0, 0, 0, 45, 46, 296, 297, 298, 299, 467, - 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 257, 26, 27, 28, 0, - 0, 45, 46, 0, 0, 31, 0, 0, 0, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, -293, 0, 26, - 27, 28, 0, 34, 0, 35, 0, 36, 31, 0, - 38, 39, 0, 0, 0, 0, 0, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 0, 34, 26, 27, 28, - 0, 37, 0, 336, 337, 40, 31, -293, 0, 0, - -3, 0, 41, 42, 0, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, -293, 34, 26, 27, 28, 0, 37, - 338, 336, 337, 40, 31, 0, 45, 46, 0, 0, - 41, 42, 0, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 34, 26, 27, 28, 635, 0, 338, 38, - 39, 0, 31, -293, 45, 46, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, - 34, 0, 0, 0, 0, 31, 338, 38, 39, 0, + 22, 23, 24, 25, 0, 34, 26, 27, 28, 0, + 0, 0, 38, 39, 0, 31, 338, 0, 0, 0, 0, 0, 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 34, 26, 27, 28, 0, 0, 0, - 207, 39, 0, 31, 157, 0, 0, 0, 0, 0, - 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 0, 34, 26, 27, 28, 0, 0, 270, 38, 39, - 0, 31, 0, 45, 46, 8, 9, 10, 11, 12, + 24, 25, 0, 34, 26, 27, 28, 0, 0, 157, + 207, 39, 0, 31, 0, 45, 46, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, + 0, 34, 0, 0, 0, 0, 31, 270, 38, 39, + 0, 0, 0, 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 0, 0, 26, 27, 28, 0, 34, - 0, 0, 0, 0, 31, 338, 38, 39, 0, 0, + 23, 24, 25, 0, 34, 26, 27, 28, 0, 0, + 0, 38, 39, 0, 31, 338, 0, 0, 0, 0, 0, 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 34, 26, 27, 28, 0, 0, 0, 38, - 39, 0, 31, 686, 0, 0, 0, 0, 0, 45, - 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 34, 26, 27, 28, 0, 0, 593, 38, 39, 0, - 31, 0, 45, 46, 2, 206, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 34, 0, - 26, 27, 28, 0, 44, 207, 39, 0, 0, 31, - 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 34, 26, 27, 28, 0, 0, 686, 38, + 39, 0, 31, 0, 45, 46, 2, 206, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 34, 0, 26, 27, 28, 0, 593, 38, 39, 0, + 0, 31, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, - 0, 36, 0, 0, 38, 39, 0, 0, 45, 46, - 282, 283, 0, 284, 1042, 0, 1043, 0, 0, 1044, - 1045, 1046, 1047, 1048, 1049, 1050, 1051, 0, 0, 1525, - 1052, 0, 0, 0, 1053, 1054, 0, 33, 0, 285, - -413, 0, 0, 0, 0, 1055, 0, 0, 0, 287, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, + 0, 35, 0, 36, 44, 0, 38, 39, 0, 0, + 45, 46, 282, 283, 0, 284, 1043, 0, 1044, 0, + 0, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 0, + 0, 1528, 1053, 0, 0, 0, 1054, 1055, 0, 33, + 0, 285, -416, 0, 0, 0, 0, 1056, 0, 0, + 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 379, 0, 0, 171, + 0, 0, 45, 46, 296, 297, 298, 299, 0, 0, + 282, 283, 1058, 284, 1043, 0, 1044, -131, 0, 1045, + 1046, 1047, 1048, 1049, 1050, 1051, 1052, 0, 0, 0, + 1053, 0, 0, 0, 1054, 1055, 0, 33, 0, 285, + 0, 0, 0, 0, 0, 1056, 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, 0, 379, 0, 0, 171, 0, 0, - 45, 46, 296, 297, 298, 299, 0, 0, 282, 283, - 1057, 284, 1042, 0, 1043, -128, 0, 1044, 1045, 1046, - 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 1052, 0, - 0, 0, 1053, 1054, 0, 33, 0, 285, 0, 0, - 0, 0, 0, 1055, 0, 0, 0, 287, 0, 0, - 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, + 45, 46, 296, 297, 298, 299, 0, 0, 0, 0, + 1058, 0, 0, 0, 0, -131, 2, 206, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 0, + 0, 31, 0, 282, 283, 0, 284, 1043, 0, 1044, + 1402, 1403, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, + 0, 0, 1528, 1053, 0, 0, 0, 1054, 1055, 34, + 33, 35, 285, 36, 0, 0, 38, 39, 1056, 0, + 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, + 42, 0, 292, 293, 0, 0, 0, 0, 1315, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 294, 0, 379, 0, 0, 171, 0, 0, 45, 46, - 296, 297, 298, 299, 0, 0, 0, 0, 1057, 0, - 0, 0, 0, -128, 2, 206, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, - 26, 27, 28, 0, 0, 0, 0, 0, 0, 31, - 0, 282, 283, 0, 284, 1042, 0, 1043, 1399, 1400, - 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 0, 0, - 1525, 1052, 0, 0, 0, 1053, 1054, 34, 33, 35, - 285, 36, 0, 0, 38, 39, 1055, 0, 0, 0, + 0, 0, 0, 0, 0, 294, 0, 379, 0, 0, + 171, 0, 0, 45, 46, 296, 297, 298, 299, 0, + 0, 282, 283, 1058, 284, 1043, 0, 1044, 1402, 1403, + 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 0, 0, + 0, 1053, 0, 0, 0, 1054, 1055, 0, 33, 0, + 285, 0, 0, 0, 0, 0, 1056, 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, - 292, 293, 0, 0, 0, 0, 1312, 0, 0, 0, + 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, 0, 379, 0, 0, 171, 0, 0, 45, 46, 296, 297, 298, 299, 0, 0, 282, - 283, 1057, 284, 1042, 0, 1043, 1399, 1400, 1044, 1045, - 1046, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 1052, - 0, 0, 0, 1053, 1054, 0, 33, 0, 285, 0, - 0, 0, 0, 0, 1055, 0, 0, 0, 287, 0, + 283, 1058, 284, 1043, 0, 1044, 0, 0, 1045, 1046, + 1047, 1048, 1049, 1050, 1051, 1052, 0, 0, 0, 1053, + 0, 0, 0, 1054, 1055, 0, 33, 0, 285, 0, + 0, 0, 0, 0, 1056, 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, + 0, 0, 0, 0, 0, 0, 282, 283, 0, 284, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 379, 0, 0, 171, 0, 0, 45, + 46, 296, 297, 298, 299, 285, 0, 0, 0, 1058, + 0, 286, 0, 0, 0, 287, 0, 0, 288, 289, + 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, + 0, 0, 0, 282, 283, 0, 284, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 294, 0, + 379, 0, 282, 283, 0, 284, 45, 46, 296, 297, + 298, 299, 285, 0, 0, 0, 0, 0, 286, 0, + 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, + 42, 285, 292, 293, 0, 0, 0, 286, 0, 0, + 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 294, 0, 379, 0, 282, + 283, 0, 284, 709, 46, 296, 297, 298, 299, 0, + 0, 0, 0, 0, 294, 0, 379, 0, 282, 283, + 0, 284, 344, 46, 296, 297, 298, 299, 285, 0, + 0, 0, 0, 0, 286, 0, 0, 0, 287, 0, + 0, 288, 289, 290, 291, 41, 42, 285, 292, 293, + 0, 0, 0, 286, 0, 0, 0, 287, 0, 0, + 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, + 0, 506, 0, 0, 0, 282, 283, 0, 284, 45, + 46, 296, 297, 298, 299, 0, 0, 0, 0, 0, + 294, 0, 0, 0, 282, 283, 0, 284, 45, 46, + 296, 297, 298, 299, 285, 0, 0, 0, 0, 0, + 286, 0, 0, 0, 287, 0, 0, 288, 289, 290, + 291, 41, 42, 285, 292, 293, 0, 0, 0, 286, + 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, + 41, 42, 0, 292, 293, 0, 0, 511, 0, 0, + 0, 0, 0, 0, 0, 45, 46, 296, 297, 298, + 299, 0, 0, 0, 0, 0, 514, 0, 0, 0, + 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, + 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 294, 0, 379, 0, 0, 171, 0, 0, 45, - 46, 296, 297, 298, 299, 0, 0, 282, 283, 1057, - 284, 1042, 0, 1043, 0, 0, 1044, 1045, 1046, 1047, - 1048, 1049, 1050, 1051, 0, 0, 0, 1052, 0, 0, - 0, 1053, 1054, 0, 33, 0, 285, 0, 0, 0, - 0, 0, 1055, 0, 0, 0, 287, 0, 0, 288, - 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, - 0, 0, 0, 0, 282, 283, 0, 284, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, - 0, 379, 0, 0, 171, 0, 0, 45, 46, 296, - 297, 298, 299, 285, 0, 0, 0, 1057, 0, 286, - 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, - 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, - 0, 282, 283, 0, 284, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 294, 0, 379, 0, - 0, 972, 0, 0, 45, 46, 296, 297, 298, 299, - 285, 0, 0, 0, 0, 0, 286, 0, 0, 0, - 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, - 292, 293, 0, 0, 0, 0, 0, 0, 282, 283, - 0, 284, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 294, 0, 379, 0, 282, 283, 0, - 284, 45, 46, 296, 297, 298, 299, 285, 0, 0, - 0, 0, 0, 286, 0, 0, 0, 287, 0, 0, - 288, 289, 290, 291, 41, 42, 285, 292, 293, 0, - 0, 0, 286, 0, 0, 0, 287, 0, 0, 288, - 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, - 294, 0, 379, 0, 282, 283, 0, 284, 709, 46, - 296, 297, 298, 299, 0, 0, 0, 0, 0, 294, - 0, 379, 0, 282, 283, 0, 284, 344, 46, 296, - 297, 298, 299, 285, 0, 0, 0, 0, 0, 286, - 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, - 41, 42, 285, 292, 293, 0, 0, 0, 286, 0, - 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, - 42, 0, 292, 293, 0, 0, 506, 0, 0, 0, - 282, 283, 0, 284, 45, 46, 296, 297, 298, 299, - 0, 0, 0, 0, 0, 294, 0, 0, 0, 282, - 283, 0, 284, 45, 46, 296, 297, 298, 299, 285, - 0, 0, 0, 0, 0, 286, 0, 0, 0, 287, - 0, 0, 288, 289, 290, 291, 41, 42, 285, 292, - 293, 0, 0, 0, 286, 0, 0, 0, 287, 0, - 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, - 0, 0, 511, 0, 0, 0, 0, 0, 0, 0, - 45, 46, 296, 297, 298, 299, 0, 0, 0, 0, - 0, 514, 0, 0, 0, 0, 0, 0, 0, 45, - 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, + 0, 0, 0, 34, 0, 35, 0, 36, 37, 0, + 174, 175, 40, 0, 0, 0, 0, 0, 0, 41, + 42, 205, 2, 206, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 0, 0, 0, 0, 0, 31, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, + 0, 0, 207, 39, 467, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 26, 27, 28, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, - 35, 0, 36, 37, 0, 174, 175, 40, 0, 0, - 0, 0, 0, 0, 41, 42, 205, 2, 206, 4, + 35, 0, 36, 0, 0, 38, 39, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, @@ -2860,24 +2879,9 @@ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 34, 0, 35, 0, 36, 0, 0, 207, 39, 467, - 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, - 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 34, 0, 35, 0, 36, 0, 0, - 38, 39, 2, 206, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, - 28, 0, 0, 0, 0, 0, 0, 31, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, - 0, 0, 207, 39 + 34, 0, 35, 0, 36, 0, 0, 207, 39 }; #define yypact_value_is_default(yystate) \ - ((yystate) == (-1323)) + ((yystate) == (-1338)) #define yytable_value_is_error(yytable_value) \ @@ -2886,677 +2890,678 @@ static const yytype_int16 yycheck[] = { - 0, 1, 186, 43, 239, 185, 204, 0, 43, 219, - 43, 116, 185, 521, 534, 185, 1, 875, 186, 0, - 1, 185, 757, 51, 647, 603, 750, 185, 0, 1, - 281, 621, 32, 750, 1041, 0, 1022, 43, 185, 32, - 345, 185, 750, 43, 168, 169, 513, 349, 875, 49, - 156, 32, 603, 32, 0, 693, 49, 349, 187, 0, - 32, 572, 57, 63, 601, 1322, 66, 32, 43, 69, - 63, 0, 1, 66, 696, 63, 69, 1399, 734, 492, - 0, 109, 266, 496, 69, 265, 32, 601, 69, 39, - 39, 32, 265, 490, 66, 265, 201, 69, 266, 601, - 39, 265, 43, 32, 604, 105, 601, 265, 49, 49, - 610, 106, 32, 113, 109, 418, 116, 117, 265, 82, - 66, 265, 63, 63, 39, 66, 66, 39, 69, 69, - 601, 984, 261, 262, 284, 438, 43, 66, 28, 601, - 69, 105, 72, 446, 132, 185, 146, 147, 1470, 601, - 185, 72, 185, 49, 147, 155, 156, 307, 308, 109, - 160, 111, 111, 1420, 39, 787, 82, 160, 72, 364, - 109, 39, 111, 368, 1021, 1022, 82, 482, 96, 185, - 688, 1034, 906, 1116, 156, 185, 186, 1120, 78, 906, - 156, 155, 0, 186, 110, 345, 488, 109, 906, 111, - 410, 201, 132, 96, 122, 111, 147, 147, 605, 209, - 185, 132, 609, 117, 1041, 64, 209, 113, 109, 160, - 160, 221, 406, 218, 32, 265, 109, 110, 221, 122, - 265, 381, 265, 630, 109, 256, 111, 634, 406, 239, - 1226, 109, 864, 111, 185, 186, 186, 825, 719, 221, - 146, 251, 987, 504, 57, 44, 45, 719, 251, 259, - 109, 426, 427, 901, 264, 265, 266, 719, 209, 209, - 251, 271, 251, 266, 825, 221, 813, 272, 185, 251, - 221, 221, 1289, 794, 279, 907, 251, 109, 696, 85, - 1276, 396, 221, 1502, 294, 49, 480, 636, 637, 813, - 109, 603, 925, 106, 1453, 251, 109, 307, 1053, 1054, - 251, 813, 480, 209, 653, 815, 621, 113, 813, 424, - 1529, 626, 251, 323, 265, 430, 115, 433, 328, 494, - 952, 251, 95, 44, 45, 328, 107, 112, 1487, 116, - 1489, 341, 813, 239, 109, 345, 111, 109, 513, 349, - 350, 813, 155, 348, 1212, 132, 934, 0, 110, 113, - 131, 813, 44, 45, 364, 987, 129, 1473, 368, 131, - 365, 371, 711, 1479, 369, 271, 116, 341, 130, 682, - 72, 11, 74, 75, 1129, 1212, 228, 328, 328, 32, - 130, 83, 84, 1499, 1050, 590, 396, 418, 1504, 114, - 550, 551, 552, 114, 350, 247, 406, 371, 349, 1395, - 1000, 307, 110, 406, 579, 218, 1038, 438, 116, 933, - 526, 109, 114, 111, 424, 446, 426, 427, 1275, 1276, - 430, 933, 114, 433, 72, 1442, 110, 632, 933, 110, - 72, 746, 1449, 251, 1502, 83, 84, 110, 256, 345, - 847, 83, 84, 116, 454, 209, 130, 119, 120, 130, - 968, 433, 1289, 802, 1522, 406, 406, 433, 110, 272, - 112, 1529, 472, 111, 116, 128, 279, 110, 131, 111, - 480, 116, 482, 116, 484, 591, 737, 480, 488, 131, - 132, 484, 70, 1500, 494, 73, 1118, 132, 76, 907, - 78, 90, 91, 484, 688, 1128, 506, 85, 508, 1009, - 1010, 511, 484, 513, 514, 982, 482, 271, 116, 484, - 688, 521, 1100, 825, 648, 525, 526, 473, 657, 942, - 426, 427, 130, 825, 1387, 1388, 125, 126, 484, 109, - 294, 111, 939, 484, 952, 348, 110, 488, 1395, 116, - 655, 116, 116, 307, 526, 484, 1178, 1179, 72, 116, - 526, 525, 365, 130, 484, 72, 369, 74, 75, 83, - 84, 571, 572, 88, 89, 132, 83, 84, 1086, 579, - 1403, 72, 3, 1091, 4, 5, 6, 7, 8, 9, - 590, 591, 83, 84, 72, 595, 116, 111, 494, 3, - 905, 601, 1, 603, 111, 83, 84, 757, 251, 804, - 418, 116, 132, 256, 809, 1442, 0, 513, 110, 591, - 111, 621, 1449, 0, 116, 591, 626, 622, 628, 432, - 438, 109, 632, 1289, 212, 635, 636, 637, 446, 111, - 111, 113, 113, 638, 112, 109, 938, 111, 116, 69, - 116, 71, 862, 653, 116, 655, 109, 652, 130, 130, - 601, 682, 603, 635, 636, 637, 132, 109, 116, 111, - 132, 591, 882, 1500, 1497, 116, 484, 623, 116, 1502, - 116, 653, 131, 579, 132, 685, 72, 708, 688, 116, - 76, 132, 116, 109, 132, 1000, 132, 83, 84, 1522, - 454, 279, 897, 72, 810, 132, 1529, 1363, 132, 944, - 1118, 711, 712, 713, 83, 84, 110, 109, 116, 719, - 720, 116, 116, 109, 908, 621, 906, 92, 93, 110, - 626, 117, 118, 906, 132, 116, 906, 132, 733, 711, - 908, 109, 906, 110, 868, 745, 746, 688, 906, 116, - 750, 751, 506, 699, 508, 109, 109, 511, 111, 906, - 514, 1383, 906, 110, 117, 118, 294, 713, 112, 116, - 1178, 1179, 116, 109, 352, 418, 354, 1399, 719, 720, - 746, 745, 1506, 109, 112, 111, 1306, 590, 116, 1506, - 1446, 109, 1448, 111, 794, 438, 109, 112, 1506, 117, - 118, 116, 802, 446, 804, 72, 806, 74, 75, 809, - 810, 110, 109, 813, 111, 1013, 83, 84, 110, 622, - 117, 118, 72, 110, 116, 825, 76, 110, 112, 116, - 802, 110, 116, 83, 84, 638, 110, 116, 810, 482, - 110, 484, 1147, 112, 810, 1501, 116, 1469, 1470, 652, - 1000, 115, 116, 252, 10, 11, 12, 13, 14, 109, - 806, 111, 110, 111, 442, 1116, 109, 117, 118, 1120, - 1121, 110, 813, 117, 682, 875, 110, 116, 3, 123, - 124, 110, 116, 39, 825, 10, 11, 12, 13, 14, - 810, 1041, 58, 59, 875, 110, 110, 897, 426, 427, - 708, 116, 1086, 875, 904, 905, 906, 1091, 908, 110, - 110, 67, 1036, 109, 39, 72, 116, 115, 1086, 76, - 920, 1226, 109, 1091, 111, 109, 83, 84, 1123, 875, - 733, 685, 64, 933, 934, 110, 115, 116, 938, 905, - 904, 116, 67, 943, 944, 72, 875, 74, 75, 76, - 0, 1, 109, 44, 45, 875, 83, 84, 943, 132, - 117, 118, 943, 110, 66, 906, 109, 908, 968, 116, - 109, 943, 111, 109, 1482, 1383, 553, 554, 506, 29, - 30, 112, 32, 511, 132, 1236, 514, 506, 109, 508, - 111, 1399, 511, 43, 911, 514, 913, 938, 114, 49, - 1000, 555, 556, 1108, 114, 114, 72, 57, 74, 75, - 76, 561, 562, 63, 943, 117, 66, 83, 84, 69, - 132, 1021, 1022, 1531, 132, 4, 5, 6, 7, 8, - 9, 109, 82, 83, 557, 558, 559, 560, 82, 682, - 568, 1041, 4, 5, 6, 7, 8, 9, 944, 1021, - 1022, 85, 86, 87, 109, 1021, 106, 1003, 160, 109, - 1041, 1469, 1470, 109, 112, 708, 116, 875, 467, 1041, - 82, 33, 1323, 118, 127, 109, 1327, 111, 94, 113, - 114, 1081, 109, 110, 111, 128, 1086, 109, 110, 111, - 69, 1091, 71, 131, 897, 1041, 111, 147, 109, 109, - 1100, 110, 110, 746, 1000, 155, 3, 69, 1108, 71, - 160, 112, 1041, 10, 11, 12, 13, 14, 112, 221, - 112, 1041, 110, 1123, 109, 110, 111, 110, 110, 528, - 110, 109, 110, 111, 533, 185, 186, 72, 109, 74, - 75, 76, 39, 112, 111, 1086, 114, 1147, 83, 84, - 1091, 201, 116, 132, 131, 733, 114, 259, 114, 209, - 109, 112, 264, 58, 59, 60, 920, 110, 218, 110, - 67, 221, 112, 1424, 109, 112, 111, 130, 228, 112, - 112, 1147, 117, 118, 583, 1249, 1250, 1251, 130, 1189, - 1190, 130, 116, 243, 29, 130, 110, 247, 110, 112, - 115, 251, 252, 114, 112, 1190, 110, 116, 1208, 1190, - 115, 109, 1212, 115, 110, 265, 266, 1189, 1190, 110, - 130, 110, 272, 116, 110, 132, 1226, 3, 110, 279, - 1230, 1212, 875, 1041, 10, 11, 12, 13, 14, 110, - 1212, 116, 110, 1189, 1208, 1230, 110, 110, 350, 1230, - 110, 110, 110, 110, 1, 654, 110, 656, 1230, 110, - 1189, 1190, 905, 39, 110, 110, 1212, 110, 72, 110, - 74, 75, 76, 115, 1379, 1275, 1276, 29, 328, 83, - 84, 1516, 131, 1212, 1284, 110, 130, 116, 875, 1289, - 112, 67, 1212, 112, 110, 110, 116, 110, 348, 349, - 130, 1230, 49, 1275, 1276, 109, 109, 706, 1289, 1275, - 116, 112, 1284, 117, 118, 365, 114, 1289, 110, 369, - 110, 110, 1322, 1507, 112, 116, 1506, 1081, 110, 431, - 380, 116, 116, 1506, 55, 110, 1506, 1322, 1284, 1507, - 110, 1322, 1506, 1289, 112, 109, 396, 1531, 1506, 109, - 1322, 109, 109, 109, 132, 1284, 406, 130, 105, 1506, - 1289, 112, 1506, 1531, 110, 115, 113, 110, 110, 1289, - 115, 473, 110, 128, 424, 115, 97, 1482, 114, 1379, - 430, 112, 432, 1378, 132, 112, 116, 112, 110, 72, - 110, 74, 75, 1322, 110, 1395, 110, 112, 1041, 146, - 83, 84, 112, 112, 1212, 1208, 112, 72, 155, 74, - 75, 76, 112, 72, 112, 74, 75, 467, 83, 84, - 1420, 47, 472, 1395, 83, 84, 109, 132, 132, 132, - 480, 114, 112, 132, 484, 1420, 132, 115, 488, 1420, - 110, 491, 1442, 493, 109, 130, 115, 110, 1420, 1449, - 109, 1451, 112, 1453, 115, 114, 112, 1044, 205, 112, - 112, 1442, 209, 112, 110, 110, 1506, 109, 1449, 112, - 1442, 1506, 193, 1506, 112, 109, 109, 1449, 528, 60, - 110, 1289, 1482, 533, 132, 110, 114, 1487, 109, 1489, - 112, 1420, 239, 595, 112, 216, 1442, 110, 112, 110, - 1500, 96, 96, 1449, 1147, 226, 1506, 1507, 109, 109, - 464, 115, 132, 1442, 1507, 130, 1516, 110, 110, 1500, - 1449, 623, 1442, 110, 271, 110, 628, 274, 1500, 1449, - 116, 1531, 42, 583, 132, 132, 110, 110, 1531, 66, - 590, 96, 96, 132, 110, 110, 110, 294, 75, 132, - 132, 601, 110, 603, 1500, 115, 112, 132, 115, 958, - 307, 112, 109, 132, 110, 1506, 30, 115, 110, 1212, - 132, 1500, 622, 294, 110, 1378, 110, 667, 1057, 563, - 1500, 980, 978, 1226, 565, 984, 1212, 1365, 638, 564, - 117, 464, 566, 643, 341, 567, 1470, 699, 345, 1541, - 1299, 1327, 652, 1121, 654, 655, 656, 1072, 1449, 685, - 685, 713, 913, 698, 66, 1091, 921, 364, 82, 83, - 1516, 368, 583, 972, 371, 1212, 868, 723, 649, 940, - 82, 1230, 484, 160, 1442, 1034, 0, 1, 688, 733, - 571, 1449, 692, 571, 694, 571, 1289, 72, 698, 74, - 75, 76, -1, -1, -1, -1, 706, -1, 83, 84, - -1, -1, -1, 1191, 1192, 117, 1194, -1, 32, 719, - 720, -1, -1, 1201, -1, 1203, -1, -1, -1, 426, - 427, -1, -1, 733, 109, 49, -1, 10, 11, 12, - 13, 14, 1500, -1, 221, -1, -1, 1451, -1, 1453, - -1, -1, -1, -1, 806, 69, -1, 454, 160, -1, - 85, 86, 87, -1, -1, -1, 39, 671, 1305, -1, - 467, -1, 443, -1, -1, -1, -1, 10, 11, 12, - 13, 14, 259, 1487, 109, 1489, 111, 264, 113, 114, - -1, 105, -1, -1, 67, 492, -1, 494, 469, 496, - -1, -1, 279, -1, -1, -1, 39, -1, -1, 506, - -1, 508, -1, 813, 511, -1, 513, 514, -1, 221, - 1357, -1, -1, 1360, -1, 825, -1, -1, 525, 243, - -1, -1, -1, 147, 67, 506, 109, -1, 111, -1, - 511, 155, 156, 514, 117, 118, -1, -1, 671, 1442, - -1, -1, -1, -1, -1, -1, 1449, 259, -1, -1, - -1, -1, 264, -1, -1, -1, 1403, -1, 868, -1, - -1, 1408, 186, 350, 874, -1, 109, -1, 111, -1, - -1, 1359, 579, -1, 117, 118, 790, 201, -1, -1, - 204, 205, -1, 590, -1, 209, 800, 897, -1, 1436, - 1249, 1250, 1251, -1, -1, -1, 906, 1500, 908, -1, - 814, -1, -1, -1, -1, 915, 230, -1, -1, -1, - 234, -1, 236, -1, 621, -1, -1, -1, -1, 626, - -1, 245, -1, -1, -1, 632, 0, 251, 938, -1, - -1, -1, 256, -1, -1, -1, -1, -1, 350, -1, - -1, 1003, 266, -1, 431, -1, -1, -1, 958, -1, - 274, 10, 11, 12, 13, 14, 380, 790, 32, -1, - -1, 448, 972, -1, -1, -1, -1, 800, -1, -1, - 980, -1, -1, 1520, 984, -1, -1, -1, 685, 1526, - 39, 814, -1, -1, -1, -1, 473, -1, -1, 670, - 1537, -1, 671, -1, 1541, 69, -1, -1, 679, -1, - -1, -1, 683, -1, -1, -1, -1, -1, 67, -1, - -1, 72, -1, 74, 75, 76, 723, 341, -1, 431, - -1, 345, 83, 84, 1034, -1, -1, 351, 1387, 1388, - -1, -1, -1, -1, -1, -1, -1, -1, 745, -1, - 364, -1, -1, -1, 368, -1, -1, 371, 109, -1, - 109, -1, 111, -1, -1, -1, 117, 118, 117, 118, - -1, 473, 1072, -1, -1, -1, 1425, 491, -1, 493, - -1, -1, -1, -1, -1, -1, 1086, -1, -1, -1, - -1, 1091, 156, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 418, -1, -1, 804, 1108, -1, - -1, -1, 809, -1, 1018, 1019, -1, -1, 595, 433, - -1, 790, -1, -1, 438, -1, -1, 131, -1, -1, - -1, 800, 446, -1, 1483, -1, -1, 1189, -1, -1, - -1, -1, -1, 1492, -1, 814, 623, -1, -1, -1, - 464, 628, 72, 467, 74, 75, 76, -1, -1, -1, - -1, -1, -1, 83, 84, -1, 230, -1, 482, -1, - 484, -1, 1076, 1077, -1, -1, -1, -1, 492, -1, - -1, -1, 496, -1, -1, 1185, -1, 251, -1, 109, - -1, 111, 256, 595, -1, 1018, 1019, 117, 118, -1, - 897, -1, -1, -1, -1, -1, -1, 904, 1208, -1, - -1, 525, 526, -1, -1, -1, -1, -1, -1, -1, - -1, 623, 699, 920, -1, -1, 628, -1, 899, 643, - -1, -1, 1284, 0, -1, -1, 713, -1, -1, -1, - -1, -1, -1, -1, -1, 942, 943, 944, -1, 1249, - 1250, 1251, -1, 1076, 1077, -1, 733, -1, 572, 72, - -1, 74, 75, 76, -1, 32, -1, -1, -1, -1, - 83, 84, -1, -1, -1, -1, 590, 591, 692, -1, - 694, -1, -1, -1, 698, -1, -1, 351, 72, 603, - 74, 75, 76, -1, -1, -1, 109, 699, 111, 83, - 84, -1, 69, 1000, 117, 118, -1, 621, -1, -1, - -1, 713, 626, -1, -1, -1, -1, -1, 632, -1, - 1224, 635, 636, 637, -1, 109, -1, 111, -1, 806, - -1, -1, -1, 117, 118, -1, -1, -1, -1, 653, - -1, -1, -1, 26, 27, 28, -1, -1, -1, 1018, - 1019, -1, 1256, -1, 418, -1, -1, 671, -1, -1, - 1264, 1265, 1266, -1, -1, -1, -1, -1, 682, 433, - -1, -1, -1, -1, 438, -1, -1, -1, 1378, 1379, - -1, 1052, 446, -1, 1081, -1, -1, 1387, 1388, 156, - -1, -1, -1, -1, 708, -1, -1, 711, -1, -1, - 464, 1224, -1, -1, 806, -1, 720, 1076, 1077, 723, - -1, -1, -1, -1, -1, 98, -1, 100, 482, -1, - 484, -1, -1, -1, 1328, 1425, 1123, -1, -1, -1, - -1, 745, 746, 1256, -1, -1, -1, 751, -1, -1, - -1, 1264, 1265, 1266, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 868, -1, -1, -1, -1, -1, - 874, -1, 526, -1, -1, -1, -1, 26, 27, 28, - -1, -1, -1, -1, -1, -1, 790, -1, -1, -1, - -1, -1, 1482, 1483, 251, -1, 800, -1, 802, 256, - 804, -1, 1492, 807, -1, 809, 810, -1, 181, -1, - 814, 915, -1, -1, -1, 1328, 1506, 1507, 191, 192, - 824, 1208, -1, 196, -1, 198, 199, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1003, 591, -1, -1, - -1, 1531, -1, 1230, -1, -1, -1, -1, -1, 98, - -1, 100, -1, -1, -1, 0, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 972, -1, - -1, 875, -1, -1, -1, -1, 125, -1, -1, -1, - -1, 635, 636, 637, -1, -1, -1, 32, -1, -1, - -1, -1, -1, 897, 351, -1, -1, 1256, -1, 653, - 904, 905, -1, -1, 908, 1264, 1265, 1266, -1, -1, - -1, 1003, -1, -1, -1, -1, -1, 671, -1, -1, - -1, -1, -1, -1, 69, -1, -1, -1, 682, -1, - 934, -1, 181, -1, -1, 1322, -1, 1298, 942, 943, - 189, -1, 191, 192, -1, -1, -1, 196, -1, 198, - 199, -1, -1, -1, 708, -1, -1, 711, -1, -1, - -1, 418, -1, -1, -1, -1, -1, -1, 1072, 1328, - -1, -1, -1, -1, -1, -1, 433, -1, -1, -1, - -1, 438, -1, -1, -1, -1, -1, -1, -1, 446, - -1, -1, 746, -1, -1, -1, 1000, 10, 11, 12, - 13, 14, -1, -1, -1, -1, -1, 464, -1, 1013, - -1, 156, -1, -1, 1018, 1019, -1, 1021, 1022, 268, - -1, -1, 1189, -1, -1, 482, 39, 484, -1, -1, - -1, -1, -1, 1420, -1, -1, 790, 1041, -1, -1, - -1, -1, -1, -1, -1, -1, 800, -1, 802, -1, - -1, -1, -1, 807, 67, -1, 810, -1, -1, 72, - 814, 74, 75, 76, 1451, -1, 1453, -1, -1, 526, - 83, 84, 1076, 1077, -1, -1, -1, -1, -1, -1, - -1, 1185, -1, -1, -1, -1, -1, -1, -1, 1450, - -1, 1452, -1, -1, -1, -1, 109, 1189, 111, -1, - 1487, -1, 1489, -1, 117, 118, 251, -1, -1, -1, - -1, 256, -1, -1, -1, -1, -1, 1284, -1, 1123, - -1, 875, -1, -1, -1, 1486, -1, 1488, -1, 1516, - -1, -1, -1, -1, 591, -1, -1, -1, -1, -1, - -1, -1, -1, 1147, -1, -1, -1, -1, -1, 0, - -1, 905, -1, -1, -1, -1, -1, 189, -1, -1, - -1, -1, -1, -1, 196, -1, -1, -1, -1, 1530, - -1, 1532, -1, -1, -1, -1, -1, -1, 635, 636, - 637, 32, -1, -1, 1545, 1546, 1190, -1, -1, -1, - -1, -1, 1284, -1, -1, -1, 653, -1, -1, -1, - -1, -1, 575, 576, 1208, -1, 351, -1, 1212, -1, - -1, -1, -1, -1, 671, -1, -1, -1, 69, -1, - 1224, -1, 1226, -1, -1, 682, 1230, -1, -1, -1, - -1, 604, -1, -1, 607, 608, 268, 610, -1, 612, - 613, -1, -1, -1, 617, 618, -1, -1, -1, -1, - -1, 708, 1256, -1, 711, -1, -1, -1, -1, -1, - 1264, 1265, 1266, -1, 1018, 1019, -1, 1021, 1022, -1, - -1, 1275, 1276, 418, -1, -1, -1, -1, 10, 11, - 12, 13, 14, -1, -1, 1289, -1, 1041, 433, 746, - -1, 323, -1, 438, -1, -1, -1, -1, -1, 331, - -1, 446, 334, -1, -1, 156, -1, 39, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 1322, 464, - -1, -1, 1076, 1077, 1328, -1, 575, 576, -1, -1, - -1, -1, -1, 790, -1, 67, -1, 482, -1, 484, - 72, -1, -1, 800, 76, 802, -1, -1, -1, -1, - 807, 83, 84, 810, -1, 604, -1, 814, 607, 608, - -1, 610, -1, 612, 613, -1, 398, -1, 617, 618, - 402, -1, -1, -1, -1, -1, -1, 109, -1, -1, - -1, 526, 755, 756, -1, 117, 118, -1, -1, -1, - -1, 1395, -1, 1147, -1, -1, -1, -1, -1, -1, - 251, -1, -1, -1, -1, 256, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1420, -1, 875, -1, + 0, 1, 239, 43, 185, 116, 534, 0, 204, 185, + 43, 185, 185, 281, 185, 43, 521, 1, 601, 185, + 185, 603, 168, 169, 105, 750, 0, 1, 219, 621, + 349, 876, 32, 345, 49, 750, 0, 693, 603, 32, + 156, 750, 513, 43, 1023, 757, 647, 572, 186, 49, + 1325, 985, 186, 492, 189, 0, 49, 496, 32, 1022, + 1023, 196, 156, 63, 32, 1402, 66, 601, 32, 69, + 63, 0, 28, 66, 155, 187, 69, 109, 601, 39, + 85, 43, 601, 0, 265, 69, 57, 32, 349, 265, + 201, 265, 265, 43, 265, 69, 39, 601, 113, 265, + 265, 1035, 63, 32, 51, 105, 364, 256, 113, 418, + 368, 601, 1042, 113, 39, 32, 116, 117, 72, 696, + 43, 109, 78, 111, 604, 601, 109, 876, 266, 438, + 610, 146, 266, 268, 490, 106, 1473, 446, 109, 96, + 39, 734, 72, 426, 427, 185, 146, 147, 1423, 261, + 262, 111, 185, 1456, 147, 155, 156, 185, 1054, 1055, + 160, 95, 109, 109, 110, 122, 109, 160, 111, 64, + 482, 132, 0, 1, 0, 72, 82, 96, 132, 72, + 636, 637, 907, 688, 284, 185, 186, 1490, 323, 1492, + 83, 84, 907, 186, 209, 129, 331, 653, 907, 334, + 82, 201, 132, 122, 32, 111, 32, 307, 308, 209, + 109, 494, 111, 1117, 109, 719, 209, 1121, 111, 410, + 117, 221, 876, 185, 239, 265, 294, 488, 221, 719, + 513, 814, 265, 39, 1130, 185, 504, 265, 66, 239, + 66, 69, 11, 719, 826, 345, 902, 218, 39, 605, + 1229, 251, 1505, 609, 128, 711, 271, 131, 251, 259, + 341, 826, 185, 398, 264, 265, 266, 402, 406, 418, + 795, 271, 406, 266, 630, 109, 988, 251, 634, 1532, + 814, 381, 39, 251, 603, 396, 116, 251, 1406, 438, + 371, 814, 307, 1042, 294, 814, 579, 446, 44, 45, + 1279, 272, 107, 109, 112, 111, 251, 307, 279, 621, + 814, 256, 82, 424, 626, 1278, 1279, 433, 109, 430, + 111, 109, 251, 323, 814, 926, 131, 256, 328, 112, + 345, 908, 590, 116, 251, 328, 816, 228, 814, 433, + 110, 341, 480, 131, 479, 345, 480, 803, 114, 349, + 350, 934, 109, 935, 111, 3, 247, 70, 426, 427, + 73, 110, 1292, 76, 364, 78, 116, 3, 368, 115, + 1215, 371, 85, 682, 632, 49, 953, 348, 44, 45, + 130, 130, 1500, 44, 45, 90, 91, 1505, 482, 116, + 72, 1045, 72, 221, 365, 221, 396, 79, 369, 79, + 934, 83, 84, 83, 84, 72, 406, 1525, 110, 1001, + 526, 426, 427, 406, 1532, 934, 83, 84, 112, 1398, + 125, 126, 116, 251, 424, 251, 426, 427, 130, 111, + 430, 111, 526, 433, 746, 1398, 571, 572, 506, 113, + 1505, 110, 109, 511, 525, 116, 514, 109, 114, 111, + 550, 551, 552, 114, 454, 0, 1390, 1391, 1051, 130, + 1525, 130, 464, 109, 969, 116, 1215, 1532, 1252, 737, + 1254, 1255, 472, 418, 72, 591, 74, 75, 0, 494, + 480, 132, 482, 109, 484, 83, 84, 480, 488, 418, + 110, 484, 848, 438, 494, 109, 116, 591, 513, 212, + 568, 446, 648, 109, 943, 111, 506, 826, 508, 438, + 484, 511, 983, 513, 514, 1445, 114, 446, 131, 1101, + 484, 521, 1452, 658, 350, 525, 526, 662, 1129, 72, + 1010, 1011, 111, 682, 113, 209, 79, 119, 120, 484, + 83, 84, 1119, 1292, 655, 657, 72, 805, 74, 75, + 688, 130, 810, 482, 688, 484, 112, 83, 84, 708, + 116, 1215, 116, 116, 579, 826, 279, 484, 111, 116, + 116, 571, 572, 1503, 111, 110, 113, 130, 132, 579, + 109, 116, 1087, 109, 940, 132, 132, 1092, 114, 109, + 590, 591, 116, 130, 906, 595, 1476, 271, 109, 110, + 111, 601, 1482, 603, 1181, 1182, 621, 72, 132, 74, + 75, 626, 4, 5, 6, 7, 8, 9, 83, 84, + 294, 621, 1502, 110, 117, 112, 626, 1507, 628, 116, + 123, 124, 632, 307, 109, 635, 636, 637, 72, 352, + 898, 354, 76, 116, 131, 132, 111, 473, 109, 83, + 84, 622, 746, 653, 1308, 655, 484, 757, 484, 132, + 795, 0, 1, 912, 745, 914, 116, 638, 110, 671, + 116, 116, 863, 110, 591, 109, 112, 69, 939, 71, + 116, 652, 132, 117, 118, 685, 132, 132, 688, 1001, + 29, 30, 883, 32, 109, 811, 1445, 110, 116, 1292, + 116, 110, 110, 1452, 43, 116, 1360, 116, 945, 1363, + 49, 711, 712, 713, 132, 110, 132, 811, 57, 719, + 720, 132, 116, 869, 63, 110, 907, 66, 109, 442, + 69, 907, 116, 907, 907, 112, 907, 682, 132, 116, + 132, 907, 907, 82, 83, 745, 746, 72, 132, 30, + 750, 751, 1406, 682, 1503, 110, 112, 1411, 83, 84, + 109, 116, 733, 708, 85, 86, 87, 106, 88, 89, + 109, 909, 115, 1366, 109, 909, 111, 116, 913, 708, + 454, 1309, 117, 118, 1509, 1439, 92, 93, 109, 791, + 111, 132, 113, 114, 1509, 795, 109, 623, 110, 801, + 1509, 82, 83, 803, 116, 805, 64, 807, 147, 1386, + 810, 811, 906, 815, 814, 109, 155, 746, 1014, 112, + 109, 160, 111, 132, 905, 1402, 826, 114, 117, 118, + 115, 116, 506, 72, 508, 74, 75, 511, 1150, 114, + 514, 109, 110, 111, 83, 84, 185, 186, 72, 1117, + 74, 75, 76, 1121, 1122, 990, 1449, 114, 1451, 83, + 84, 110, 201, 506, 109, 508, 1124, 116, 511, 1523, + 209, 514, 1007, 699, 110, 1529, 876, 110, 111, 218, + 116, 72, 221, 74, 75, 109, 1540, 713, 132, 228, + 1544, 1037, 83, 84, 811, 1472, 1473, 109, 898, 111, + 132, 1001, 876, 72, 243, 905, 906, 907, 247, 909, + 79, 1504, 251, 252, 83, 84, 110, 1229, 109, 58, + 59, 921, 116, 114, 44, 45, 265, 266, 1022, 82, + 945, 876, 110, 272, 934, 935, 112, 110, 116, 939, + 279, 109, 1042, 116, 944, 945, 110, 876, 109, 1087, + 1085, 110, 116, 1087, 1092, 115, 116, 116, 1092, 876, + 944, 72, 243, 74, 75, 76, 109, 1, 111, 969, + 944, 1239, 83, 84, 117, 118, 110, 906, 110, 127, + 1485, 807, 116, 82, 116, 3, 1001, 553, 554, 328, + 1125, 110, 10, 11, 12, 13, 14, 116, 1109, 561, + 562, 1001, 10, 11, 12, 13, 14, 110, 110, 348, + 349, 685, 118, 116, 116, 49, 128, 1019, 1020, 110, + 733, 39, 1022, 1023, 94, 116, 365, 555, 556, 1534, + 369, 39, 10, 11, 12, 13, 14, 110, 109, 110, + 111, 380, 1042, 116, 3, 109, 110, 111, 876, 67, + 876, 10, 11, 12, 13, 14, 1150, 396, 1326, 67, + 111, 39, 1330, 557, 558, 559, 560, 406, 1042, 131, + 109, 105, 58, 59, 60, 1077, 1078, 109, 109, 113, + 39, 109, 1082, 111, 109, 424, 111, 1087, 109, 67, + 111, 430, 1092, 432, 72, 112, 112, 1042, 76, 380, + 109, 1101, 111, 110, 110, 83, 84, 112, 67, 1109, + 110, 72, 146, 1042, 110, 76, 944, 110, 110, 0, + 1, 155, 83, 84, 1124, 1042, 1194, 1195, 467, 1197, + 1211, 109, 109, 472, 111, 111, 1204, 0, 1206, 117, + 118, 480, 112, 114, 116, 484, 131, 114, 109, 488, + 1150, 32, 491, 110, 493, 109, 117, 118, 114, 1427, + 112, 4, 5, 6, 7, 8, 9, 110, 112, 32, + 72, 205, 74, 75, 76, 209, 112, 112, 1004, 112, + 43, 83, 84, 130, 1278, 66, 49, 116, 69, 528, + 33, 130, 1192, 1193, 533, 29, 130, 110, 110, 1, + 63, 112, 110, 66, 114, 239, 69, 109, 112, 1193, + 491, 1211, 493, 116, 1042, 1215, 1042, 115, 115, 1193, + 72, 1150, 74, 75, 76, 1227, 69, 115, 71, 1229, + 109, 83, 84, 1233, 110, 130, 132, 271, 110, 116, + 274, 1215, 110, 110, 583, 3, 110, 921, 110, 1233, + 116, 590, 10, 11, 12, 13, 14, 1259, 115, 1233, + 294, 110, 601, 110, 603, 1267, 1268, 1269, 110, 110, + 1215, 1382, 110, 307, 110, 156, 29, 110, 1278, 1279, + 110, 39, 1519, 622, 147, 110, 1215, 1287, 110, 110, + 110, 110, 1292, 130, 1362, 110, 131, 160, 1215, 638, + 1229, 112, 116, 112, 643, 110, 110, 341, 116, 67, + 110, 345, 130, 652, 109, 654, 655, 656, 1292, 116, + 114, 112, 185, 186, 110, 1325, 110, 110, 1509, 1331, + 364, 116, 112, 1509, 368, 1509, 1509, 371, 1509, 110, + 221, 1325, 116, 1509, 1509, 110, 209, 1292, 116, 688, + 110, 1325, 109, 692, 109, 694, 112, 109, 221, 698, + 109, 109, 643, 1292, 1192, 1193, 1192, 706, 130, 112, + 251, 132, 1510, 115, 1485, 1292, 1510, 464, 110, 110, + 719, 720, 1382, 110, 128, 115, 115, 1215, 251, 1215, + 114, 112, 426, 427, 733, 72, 1534, 132, 1398, 76, + 1534, 49, 265, 110, 112, 1233, 83, 84, 1082, 112, + 1381, 692, 116, 694, 110, 63, 110, 698, 66, 110, + 454, 69, 112, 1423, 112, 112, 110, 112, 47, 112, + 112, 132, 109, 467, 111, 132, 115, 132, 110, 1423, + 117, 118, 115, 132, 110, 1445, 132, 115, 112, 1423, + 252, 112, 1452, 112, 1454, 130, 1456, 112, 492, 1287, + 494, 1287, 496, 112, 1292, 328, 1292, 112, 110, 1509, + 110, 1445, 506, 112, 508, 814, 1509, 511, 1452, 513, + 514, 1509, 112, 109, 109, 1485, 349, 826, 109, 60, + 1490, 525, 1492, 110, 110, 109, 114, 1325, 132, 147, + 1445, 112, 112, 1503, 1519, 110, 112, 1452, 110, 1509, + 1510, 96, 160, 96, 109, 109, 1445, 1510, 115, 1519, + 57, 110, 110, 1452, 55, 132, 110, 42, 1445, 1503, + 869, 110, 0, 1, 1534, 1452, 875, 130, 186, 116, + 671, 1534, 132, 406, 110, 579, 4, 5, 6, 7, + 8, 9, 433, 110, 132, 96, 590, 96, 1503, 898, + 132, 209, 110, 132, 32, 110, 97, 132, 907, 106, + 909, 115, 109, 221, 1503, 110, 110, 916, 85, 86, + 87, 49, 112, 112, 671, 132, 1503, 621, 869, 109, + 132, 115, 626, 115, 875, 1423, 110, 110, 632, 132, + 939, 69, 109, 484, 111, 110, 113, 114, 110, 667, + 1058, 69, 563, 71, 564, 979, 565, 1445, 155, 1445, + 959, 484, 567, 1215, 1452, 488, 1452, 72, 566, 74, + 75, 76, 1473, 1368, 973, 916, 1544, 105, 83, 84, + 1122, 1330, 981, 1302, 1073, 526, 985, 685, 1452, 685, + 914, 685, 1092, 698, 973, 66, 922, 583, 869, 649, + 791, 941, 193, 723, 109, 467, 111, 484, 1233, -1, + 801, 82, 117, 118, 733, 1503, -1, 1503, 571, 147, + 328, 218, 571, -1, 815, 216, 571, 155, 156, 723, + -1, -1, 973, -1, -1, 226, 1035, -1, -1, -1, + -1, -1, -1, -1, 791, -1, 117, -1, -1, -1, + 591, 745, -1, -1, 801, -1, -1, -1, 186, -1, + -1, -1, -1, -1, -1, -1, 528, -1, 815, -1, + -1, 533, -1, 201, 1073, 272, 204, 205, 601, -1, + 603, 209, 279, -1, -1, -1, -1, -1, 1087, 160, + -1, -1, -1, 1092, 635, 636, 637, -1, 406, -1, + -1, -1, 230, 294, -1, -1, 234, -1, 236, -1, + 1109, 805, 653, -1, -1, -1, 810, 245, -1, -1, + 1454, 583, 1456, 251, -1, -1, -1, -1, 256, -1, + 696, -1, 1073, -1, -1, -1, -1, -1, 266, -1, + -1, 72, -1, 74, 75, 76, 274, -1, -1, -1, + 221, 348, 83, 84, -1, -1, 1490, -1, 1492, -1, + -1, -1, -1, -1, -1, 688, -1, -1, 365, -1, + 711, -1, 369, -1, -1, -1, 0, -1, 109, -1, + 111, 10, 11, 12, 13, 14, 117, 118, 259, 1188, + -1, -1, 654, 264, 656, -1, 719, 720, -1, 130, + -1, -1, -1, -1, 898, -1, -1, -1, 32, -1, + 39, 905, 1211, 341, -1, -1, -1, 345, -1, -1, + -1, -1, 788, 351, -1, -1, -1, 921, 1019, 1020, + -1, -1, -1, -1, -1, 432, 364, -1, 67, -1, + 368, -1, -1, 371, 706, 69, -1, 1188, -1, 943, + 944, 945, 443, 1252, -1, 1254, 1255, -1, -1, -1, + -1, -1, 803, -1, 10, 11, 12, 13, 14, -1, + 811, -1, 1019, 1020, -1, -1, -1, -1, 469, 350, + 109, -1, 111, -1, -1, -1, 1077, 1078, 117, 118, + 418, 814, -1, 39, -1, -1, -1, -1, -1, 865, + -1, -1, -1, 826, -1, 433, -1, 1001, -1, -1, + 438, -1, -1, -1, -1, 506, -1, -1, 446, -1, + 511, 67, -1, 514, -1, -1, -1, -1, -1, -1, + 1077, 1078, 156, -1, -1, 876, 464, -1, -1, 467, + -1, -1, 908, -1, 10, 11, 12, 13, 14, -1, + -1, -1, -1, -1, 482, -1, 484, -1, -1, -1, + 431, -1, -1, 109, 492, 111, -1, -1, 496, -1, + -1, 117, 118, 39, -1, -1, -1, -1, -1, -1, + -1, -1, 1381, 1382, 907, -1, 909, 953, 1082, -1, + -1, 1390, 1391, 590, -1, -1, -1, 525, 526, -1, + -1, 67, 473, 944, -1, -1, 230, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 939, -1, -1, -1, + -1, -1, 988, -1, -1, 622, -1, 251, -1, 1428, + 1124, -1, 256, -1, -1, -1, -1, 0, -1, -1, + -1, 638, -1, 109, 572, 111, -1, -1, -1, -1, + -1, 117, 118, -1, 72, 652, 74, 75, 76, -1, + -1, -1, 590, 591, -1, 83, 84, -1, 1259, 32, + -1, -1, -1, 1039, -1, 603, 1267, 1268, 1269, 670, + 1227, 1022, 1023, -1, -1, -1, 1485, 1486, 679, -1, + -1, 109, 683, 621, -1, -1, 1495, 959, 626, 117, + 118, 1042, -1, -1, 632, -1, 69, 635, 636, 637, + 1509, 1510, 1259, -1, -1, -1, -1, 1211, -1, 981, + 1267, 1268, 1269, 985, 595, 653, 72, 351, 74, 75, + 76, -1, -1, -1, -1, 1534, 733, 83, 84, 1233, + 1331, -1, -1, 671, -1, -1, 10, 11, 12, 13, + 14, -1, 623, 1119, 682, -1, -1, 628, -1, -1, + -1, -1, -1, 109, 1087, 111, -1, -1, -1, 1092, + -1, 117, 118, 1035, -1, 39, -1, -1, -1, -1, + 708, -1, -1, 711, 1331, -1, -1, 66, -1, -1, + -1, -1, 720, 156, 418, 723, -1, -1, -1, -1, + -1, -1, -1, 67, -1, -1, -1, -1, 72, 433, + 74, 75, 76, -1, 438, 1181, 1182, 745, 746, 83, + 84, -1, 446, 751, -1, -1, -1, -1, 699, -1, + -1, 1325, -1, -1, -1, -1, -1, -1, 117, -1, + 464, -1, 713, -1, -1, 109, -1, 111, -1, -1, + -1, 1192, 1193, 117, 118, -1, -1, -1, 482, -1, + 484, -1, -1, 791, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 801, 1215, 803, -1, 805, -1, -1, + 808, 160, 810, 811, -1, -1, -1, 815, 251, -1, + -1, -1, 1233, 256, -1, -1, -1, 825, -1, -1, + -1, 898, 526, -1, -1, -1, -1, -1, -1, 900, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 1423, + -1, 30, 31, 32, -1, -1, 807, 1278, 1279, -1, + 39, 0, 221, -1, -1, -1, 1287, -1, 876, -1, + -1, 1292, -1, -1, 72, -1, 74, 75, 76, -1, + 1454, -1, 1456, -1, -1, 83, 84, 591, 67, -1, + 898, -1, -1, 32, -1, 74, 75, 905, 906, -1, + 259, 909, -1, -1, 1325, 264, -1, -1, 351, -1, + 1252, 109, 1254, 1255, -1, -1, 1490, -1, 1492, 117, + 118, -1, -1, -1, -1, -1, -1, 935, -1, -1, + 69, 635, 636, 637, -1, 943, 944, -1, 117, 118, + 1386, -1, -1, -1, -1, 1519, -1, -1, -1, 653, + -1, -1, -1, -1, -1, -1, 1402, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 671, -1, -1, + -1, -1, -1, -1, -1, 418, -1, 1398, 682, -1, + -1, -1, 1053, -1, -1, -1, -1, -1, -1, -1, + 433, 350, -1, 1001, -1, 438, -1, -1, -1, -1, + -1, -1, 1423, 446, 708, -1, 1014, 711, -1, -1, + -1, 1019, 1020, -1, 1022, 1023, -1, 156, -1, -1, + -1, 464, -1, -1, 1445, -1, 1472, 1473, -1, -1, + -1, 1452, -1, -1, 1042, -1, -1, -1, -1, 482, + -1, 484, 746, -1, -1, -1, -1, -1, 1390, 1391, + -1, -1, -1, 1004, -1, -1, 10, 11, 12, 13, + 14, -1, 10, 11, 12, 13, 14, -1, -1, 1077, + 1078, -1, 431, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1503, 526, -1, 39, 1428, 791, -1, -1, + -1, 39, -1, -1, -1, -1, -1, 801, -1, 803, + -1, -1, -1, -1, 808, -1, 1509, 811, -1, -1, + -1, 815, 251, 67, 473, -1, 1124, 256, 72, 67, + 74, 75, 76, -1, 72, -1, 74, 75, 76, 83, + 84, -1, -1, -1, 1211, 83, 84, -1, -1, -1, + -1, -1, 1150, -1, 1486, -1, -1, -1, 591, -1, + -1, -1, -1, 1495, -1, 109, -1, 111, -1, -1, + -1, 109, -1, 117, 118, -1, -1, -1, -1, 117, + 118, -1, 876, -1, -1, -1, -1, 72, -1, 74, + 75, 76, -1, -1, -1, 1193, -1, -1, 83, 84, + -1, -1, 635, 636, 637, -1, -1, -1, -1, -1, + -1, -1, 906, 1211, -1, -1, -1, 1215, -1, -1, + 653, -1, 351, -1, 109, -1, 111, -1, -1, 1227, + -1, 1229, 117, 118, -1, 1233, 66, -1, 671, -1, + 1301, -1, -1, -1, -1, 75, 595, -1, -1, 682, + -1, 1192, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1259, -1, -1, -1, -1, -1, -1, -1, 1267, + 1268, 1269, -1, -1, 623, 708, -1, -1, 711, 628, + 1278, 1279, -1, -1, -1, -1, -1, 117, 0, 418, + -1, -1, -1, -1, 1292, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 433, -1, -1, -1, -1, 438, + -1, -1, -1, 746, 1381, -1, -1, 446, -1, -1, + 32, -1, -1, -1, -1, 1019, 1020, 1325, 1022, 1023, + 160, -1, -1, 1331, -1, 464, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1287, -1, 1042, -1, + 699, -1, -1, 482, -1, 484, -1, 69, 791, -1, + -1, -1, -1, -1, 713, -1, -1, -1, 801, -1, + 803, -1, -1, -1, -1, 808, -1, -1, 811, -1, + -1, -1, 815, 1077, 1078, -1, -1, -1, -1, -1, + -1, 221, 1453, -1, 1455, -1, -1, 526, -1, -1, + 1398, -1, 10, 11, 12, 13, 14, -1, -1, -1, + 53, -1, 55, -1, -1, 58, 59, 60, -1, 62, + -1, -1, -1, -1, -1, 1423, -1, -1, 1489, 259, + 1491, 39, -1, 76, 264, -1, -1, -1, -1, -1, + -1, -1, -1, 876, 156, 88, 89, 1445, -1, 279, + -1, -1, -1, -1, 1452, -1, 1150, -1, 807, 67, + -1, -1, 591, -1, 72, -1, 74, 75, 76, -1, + -1, -1, 1533, 906, 1535, 83, 84, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1548, 1549, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1193, + -1, 109, -1, 111, -1, 1503, 635, 636, 637, 117, + 118, -1, 1510, -1, -1, -1, -1, -1, -1, -1, + 350, 1215, -1, -1, 653, -1, -1, -1, -1, -1, + -1, -1, -1, 1227, -1, 1229, -1, -1, -1, 251, + -1, -1, 671, -1, 256, -1, -1, -1, -1, -1, + -1, -1, -1, 682, -1, -1, -1, -1, -1, 10, + 11, 12, 13, 14, -1, 1259, -1, -1, -1, -1, + -1, -1, -1, 1267, 1268, 1269, -1, -1, -1, 708, + -1, -1, 711, -1, 1278, 1279, 1019, 1020, 39, 1022, + 1023, -1, -1, -1, -1, -1, -1, -1, 1292, -1, + -1, 431, -1, -1, -1, -1, -1, -1, -1, 1042, + -1, -1, -1, -1, -1, -1, 67, 746, 448, -1, + -1, 72, -1, 74, 75, 76, -1, -1, -1, -1, + -1, -1, 83, 84, -1, -1, -1, 1331, -1, 351, + -1, -1, -1, 473, 1077, 1078, 26, 27, 28, -1, + -1, -1, -1, -1, -1, 1004, -1, -1, 109, -1, + -1, -1, 791, -1, -1, -1, 117, 118, -1, -1, + -1, -1, 801, -1, 803, -1, -1, -1, -1, 808, + -1, -1, 811, -1, -1, -1, 815, -1, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, -1, + -1, 344, -1, 346, 1398, -1, 418, -1, -1, -1, + -1, -1, -1, -1, 357, 358, -1, 1150, 98, -1, + 100, 433, 131, -1, -1, -1, 438, -1, -1, -1, + -1, -1, -1, -1, 446, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 876, -1, -1, + -1, 1445, 464, -1, -1, -1, -1, -1, 1452, -1, + 1193, -1, -1, -1, -1, 595, -1, -1, -1, -1, + 482, -1, 484, -1, -1, -1, -1, 906, -1, -1, + -1, -1, 1215, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 623, 1227, -1, 1229, -1, 628, -1, + -1, 181, -1, -1, -1, -1, -1, -1, -1, 1503, + -1, 191, 192, -1, 526, -1, 196, -1, 198, 199, + -1, -1, -1, -1, -1, -1, 1259, -1, -1, -1, + -1, -1, -1, -1, 1267, 1268, 1269, -1, -1, -1, + -1, -1, -1, 1192, -1, 1278, 1279, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1292, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 699, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 591, + -1, -1, -1, 713, -1, -1, -1, -1, -1, -1, + 1019, 1020, -1, 1022, 1023, -1, -1, -1, 1331, -1, + -1, -1, -1, 733, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1042, 7, -1, -1, 10, 11, 12, + 13, 14, -1, 635, 636, 637, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1287, -1, + -1, 653, -1, -1, 37, 38, 39, 40, 1077, 1078, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 671, + -1, -1, -1, -1, -1, 1398, -1, -1, -1, -1, + 682, -1, -1, 66, 67, -1, -1, 807, -1, 72, + -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, + 83, 84, -1, 86, 87, -1, 708, -1, -1, 711, + -1, -1, -1, 10, 11, 12, 13, 14, -1, -1, + -1, -1, 1445, -1, -1, -1, 109, -1, 111, 1452, + -1, 1150, -1, -1, 117, 118, 119, 120, 121, 122, + -1, -1, 39, -1, 746, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1190, -1, 1442, -1, - -1, -1, -1, -1, -1, 1449, 591, 479, 905, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 1212, -1, + -1, -1, -1, -1, -1, -1, -1, 700, -1, 702, + 67, -1, -1, -1, 1193, 72, 709, 710, -1, 76, + 1503, 714, -1, -1, -1, -1, 83, 84, -1, 791, + -1, -1, -1, 726, -1, -1, 1215, -1, 731, 801, + -1, 803, -1, -1, -1, -1, 808, -1, 1227, 811, + 1229, -1, 109, 815, -1, -1, -1, -1, -1, -1, + 117, 118, -1, -1, -1, -1, 759, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1224, -1, 1226, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 10, 11, 12, 13, 14, -1, - 635, 636, 637, -1, -1, -1, 1500, -1, -1, -1, - 351, -1, 1256, 1507, -1, -1, 755, 756, 653, -1, - 1264, 1265, 1266, 39, -1, -1, -1, -1, -1, -1, - -1, 1275, 1276, -1, -1, -1, 671, -1, -1, -1, - -1, -1, -1, -1, -1, 1289, -1, 682, -1, 571, - 572, 67, -1, -1, 917, -1, 72, -1, 74, 75, + 1259, -1, -1, -1, -1, -1, -1, -1, 1267, 1268, + 1269, -1, -1, -1, -1, -1, -1, -1, -1, 1278, + 1279, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1292, 876, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1004, -1, -1, -1, -1, -1, + -1, -1, 7, -1, -1, 10, 11, 12, 13, 14, + -1, -1, -1, -1, 906, 575, 576, -1, -1, -1, + -1, -1, 1331, -1, -1, -1, -1, -1, 49, -1, + -1, -1, 37, 38, 39, 40, 859, 860, 861, 862, + -1, 864, -1, -1, 604, 66, -1, 607, 608, -1, + 610, -1, 612, 613, -1, -1, 879, 617, 618, -1, + -1, 66, 67, -1, -1, -1, -1, 72, -1, -1, + 893, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, -1, 1398, + -1, -1, 113, -1, -1, -1, 117, -1, -1, -1, + -1, -1, -1, -1, 109, -1, 111, -1, -1, -1, + 933, -1, 117, 118, 119, 120, 121, 122, -1, -1, + -1, -1, -1, -1, -1, 146, -1, 1019, 1020, -1, + 1022, 1023, -1, -1, -1, 156, 1445, -1, -1, 160, + -1, -1, -1, 1452, -1, -1, -1, -1, -1, -1, + 1042, -1, -1, -1, -1, 978, -1, -1, -1, -1, + -1, 984, -1, -1, -1, -1, 989, -1, -1, -1, + -1, 994, -1, 996, -1, -1, -1, 1000, -1, 1002, + 1003, -1, 1192, 1006, -1, 1077, 1078, -1, 209, -1, + -1, -1, 1015, -1, 1503, 755, 756, -1, -1, -1, + 221, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1033, 1034, -1, -1, -1, -1, -1, -1, 239, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 1060, -1, -1, + 1063, -1, -1, 264, -1, -1, -1, -1, 39, -1, + 271, -1, -1, -1, -1, -1, -1, -1, 1150, -1, + -1, -1, 26, 27, 28, -1, -1, -1, -1, -1, + -1, -1, -1, 294, -1, -1, 67, 1287, -1, -1, + -1, -1, -1, 1106, -1, -1, 307, -1, -1, 1112, + 1113, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1193, -1, -1, -1, -1, -1, -1, -1, 1132, + -1, -1, -1, 1136, -1, -1, -1, -1, 1141, -1, + -1, -1, -1, 1215, 345, -1, -1, -1, -1, 350, + -1, 1154, -1, -1, 98, 1227, 100, 1229, -1, -1, + -1, -1, -1, -1, 1167, -1, 1169, 1170, 1171, 1172, + -1, -1, -1, -1, -1, -1, -1, -1, 918, -1, + -1, 125, 1185, -1, 1187, -1, -1, 1259, 1191, -1, + -1, -1, -1, -1, -1, 1267, 1268, 1269, -1, -1, + -1, -1, -1, -1, -1, -1, 1278, 1279, -1, -1, + 66, -1, -1, -1, -1, -1, -1, 1220, 1221, 75, + 1292, 77, -1, 79, -1, 426, 427, -1, -1, -1, + 86, -1, 433, -1, -1, -1, -1, 181, -1, -1, + -1, -1, -1, -1, -1, 189, -1, 191, 192, -1, + -1, -1, 196, 454, 198, 199, -1, -1, -1, 1331, + -1, 117, -1, 119, 120, 121, -1, 1270, 1271, -1, + -1, -1, -1, -1, -1, -1, -1, 1280, -1, -1, + -1, 482, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 494, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 160, 506, -1, 508, -1, -1, + 511, -1, 513, 514, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 268, 526, 1398, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1341, 1079, + 1343, 1344, 1345, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1355, -1, -1, -1, -1, -1, -1, -1, + -1, 1364, -1, -1, -1, 221, -1, 223, 224, 225, + -1, -1, -1, 1445, -1, -1, -1, -1, 579, -1, + 1452, -1, -1, -1, -1, -1, 1389, -1, -1, -1, + 591, -1, -1, -1, 595, -1, -1, -1, -1, -1, + -1, -1, -1, 259, -1, -1, -1, -1, 264, -1, + -1, -1, -1, -1, 44, -1, -1, -1, -1, -1, + 621, -1, -1, 279, -1, 626, -1, -1, -1, 1432, + 1433, 1503, -1, -1, 635, 636, 637, -1, -1, -1, + -1, -1, 1445, -1, -1, -1, -1, -1, -1, 1452, + -1, -1, 653, -1, -1, -1, -1, -1, -1, -1, + -1, 91, -1, -1, -1, -1, -1, -1, -1, -1, + 1210, 101, 328, -1, -1, -1, -1, -1, -1, -1, + -1, 1484, -1, -1, 685, 1488, -1, -1, -1, -1, + -1, -1, -1, -1, 350, -1, -1, -1, -1, 355, + 356, -1, -1, -1, -1, -1, -1, 363, -1, -1, + 711, -1, 713, 1516, -1, 1518, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 157, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 171, -1, 1546, 1547, 746, -1, -1, -1, -1, + 406, 1554, 1555, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 194, -1, -1, -1, 424, 37, + 38, -1, 40, 429, -1, 431, -1, -1, 208, -1, + -1, -1, -1, -1, -1, -1, -1, 217, -1, -1, + -1, -1, 448, -1, -1, 451, 452, 227, 66, -1, + -1, -1, 803, 459, 72, -1, 807, -1, 76, -1, + 811, 79, 80, 81, 82, 83, 84, 473, 86, 87, + -1, -1, 252, -1, 480, -1, -1, 257, -1, -1, + -1, 575, 576, -1, -1, -1, -1, -1, -1, -1, + 270, 109, -1, 111, -1, -1, 276, -1, 278, 117, + 118, 119, 120, 121, 122, -1, -1, -1, -1, -1, + 604, -1, 130, 607, 608, 295, 610, -1, 612, 613, + -1, -1, -1, 617, 618, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 39, 906, -1, -1, 338, -1, + -1, -1, -1, 343, -1, -1, -1, -1, -1, -1, + 921, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 67, -1, -1, -1, -1, -1, -1, 595, + -1, -1, 372, 78, 945, -1, 376, 377, -1, 379, + -1, -1, -1, -1, -1, -1, 386, 387, -1, 389, + 390, -1, 392, -1, 394, -1, -1, 623, -1, -1, + -1, -1, 628, -1, -1, -1, -1, -1, -1, -1, + -1, 411, -1, -1, 37, 38, -1, 40, -1, 419, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1001, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 755, 756, 66, 444, -1, -1, -1, -1, 72, + -1, 1022, 1023, 76, -1, -1, 79, 80, 81, 82, + 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, + 470, -1, -1, 699, -1, -1, 476, -1, -1, -1, + -1, 481, -1, -1, -1, -1, 109, 713, 111, -1, + -1, 114, -1, -1, 117, 118, 119, 120, 121, 122, + -1, -1, -1, -1, -1, -1, -1, 733, -1, -1, + -1, 1082, -1, -1, -1, -1, -1, 517, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 532, -1, 0, -1, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, -1, 30, 31, 32, 33, -1, 795, + 36, 571, -1, 39, 40, -1, -1, -1, -1, 1150, + 580, 807, -1, -1, -1, -1, -1, 587, -1, -1, + -1, -1, -1, 593, -1, -1, -1, -1, 64, 913, + 826, 67, 602, 69, 918, 71, 72, -1, 74, 75, 76, -1, -1, -1, -1, -1, -1, 83, 84, -1, - -1, 1018, 1019, 708, 1021, 1022, 711, 418, -1, -1, - -1, -1, -1, -1, 1328, -1, -1, -1, -1, -1, - -1, -1, 433, 109, 1041, 111, -1, 438, -1, -1, - -1, 117, 118, -1, -1, 446, -1, -1, -1, -1, - -1, 746, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 464, -1, -1, -1, -1, -1, 1076, - 1077, -1, -1, -1, -1, -1, 658, -1, -1, -1, - 662, 482, -1, 484, -1, -1, -1, -1, -1, -1, - -1, 1395, -1, -1, -1, 790, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 800, -1, 802, -1, -1, - -1, -1, 807, 912, -1, 810, -1, -1, 917, 814, - -1, -1, -1, -1, -1, 526, 53, -1, 55, -1, - -1, 58, 59, 60, -1, 62, -1, -1, 1442, -1, - 1147, -1, -1, -1, -1, 1449, -1, -1, -1, 76, - -1, -1, -1, -1, -1, 1078, -1, -1, -1, -1, - -1, 88, 89, -1, 10, 11, 12, 13, 14, -1, + -1, 1192, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 155, 156, -1, -1, -1, + -1, -1, 642, 109, -1, 111, -1, -1, -1, -1, + -1, 117, 118, -1, -1, -1, -1, -1, 1229, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 189, + -1, -1, -1, -1, -1, -1, 196, -1, 678, -1, + -1, -1, -1, -1, -1, -1, 686, -1, -1, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 1278, 1279, 30, + 31, 32, -1, 939, -1, -1, 1287, 717, 39, -1, + -1, -1, -1, -1, -1, -1, -1, 727, 728, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 875, -1, -1, 1190, -1, -1, -1, -1, -1, -1, - 591, -1, -1, 39, -1, -1, 1500, -1, -1, -1, - -1, -1, -1, -1, -1, 1212, -1, -1, -1, -1, - 905, -1, 794, -1, -1, -1, -1, 1224, -1, 1226, - -1, 67, -1, -1, -1, -1, 72, -1, 74, 75, - 76, -1, -1, -1, 635, 636, 637, 83, 84, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1256, - -1, -1, 653, -1, -1, -1, -1, 1264, 1265, 1266, - -1, -1, -1, 109, -1, 111, -1, -1, 1275, 1276, - 671, 117, 118, -1, -1, 282, -1, 284, 285, 1078, - -1, 682, 1289, -1, 1207, 292, 293, -1, -1, -1, + -1, -1, -1, 969, -1, -1, 67, -1, 268, -1, + -1, 72, -1, 74, 75, 76, -1, -1, -1, -1, + 760, -1, 83, 84, -1, 1079, 766, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1004, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 109, 1015, + 111, -1, -1, -1, -1, -1, 117, 118, -1, -1, + -1, -1, -1, 323, -1, -1, -1, -1, -1, -1, + -1, 331, 332, -1, 334, 335, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 345, -1, 1398, -1, 349, + 830, -1, -1, -1, -1, -1, -1, 837, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 368, -1, + 850, 371, 852, -1, -1, -1, -1, -1, -1, -1, + -1, 1087, -1, -1, -1, -1, 866, -1, -1, -1, + -1, -1, 872, -1, -1, 1101, -1, -1, 398, -1, + -1, -1, 402, 1454, 884, 1456, -1, 887, -1, -1, + -1, -1, -1, -1, -1, -1, 1210, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 307, 308, -1, -1, -1, -1, -1, 708, -1, -1, - 711, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1328, -1, 1018, 1019, -1, 1021, 1022, -1, -1, - 912, -1, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, -1, -1, -1, 746, 1041, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, -1, 30, 31, 32, - -1, -1, -1, -1, 381, -1, 39, -1, -1, -1, - -1, 1076, 1077, -1, -1, -1, -1, -1, 1395, 790, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 800, - -1, 802, -1, -1, 67, -1, 807, 989, 1207, 810, - -1, 74, 75, 814, -1, 78, -1, 344, -1, 346, - -1, -1, -1, -1, 1006, -1, -1, -1, -1, -1, - 357, 358, -1, -1, -1, 1442, -1, -1, -1, -1, - 37, 38, 1449, 40, -1, -1, 109, -1, 111, -1, - -1, -1, 1147, -1, 117, 118, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 66, - -1, -1, -1, -1, 875, 72, -1, -1, -1, 76, - -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, - 87, -1, -1, 1500, -1, 1190, -1, -1, -1, -1, - -1, -1, 1084, -1, 905, -1, -1, -1, -1, -1, - -1, -1, 109, -1, 111, -1, -1, 1212, -1, -1, - 117, 118, 119, 120, 121, 122, -1, -1, -1, 1224, - -1, 1226, 7, 130, -1, 10, 11, 12, 13, 14, - -1, -1, 1124, 550, 551, 552, 553, 554, 555, 556, - 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, - 567, 1256, 37, 38, 39, 40, -1, -1, -1, 1264, - 1265, 1266, -1, -1, -1, -1, -1, -1, -1, -1, - 1275, 1276, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 66, 67, -1, 1289, -1, -1, 72, -1, -1, - -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, - -1, 86, 87, -1, -1, -1, -1, 1018, 1019, -1, - 1021, 1022, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1328, 109, -1, 111, -1, -1, -1, - 1041, -1, 117, 118, 119, 120, 121, 122, -1, -1, + -1, -1, -1, 433, -1, -1, -1, -1, -1, 1490, + -1, 1492, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 282, -1, 284, 285, -1, -1, -1, -1, + -1, -1, 292, 293, -1, -1, -1, -1, 1519, -1, + -1, -1, -1, -1, -1, -1, -1, 307, 308, 479, + -1, -1, 482, -1, 964, -1, 1192, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + -1, 30, 31, 32, -1, 345, -1, -1, -1, 999, + 39, 521, -1, -1, -1, 525, 526, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, + -1, 381, -1, 72, -1, 74, 75, 76, -1, 78, + -1, -1, -1, -1, 83, 84, -1, -1, -1, -1, + -1, 571, 572, -1, -1, -1, -1, 1057, -1, -1, + -1, 1287, -1, 1063, -1, -1, 146, -1, -1, -1, + 590, 591, 111, -1, -1, -1, 156, -1, 117, 118, + -1, 601, -1, 603, 604, -1, -1, -1, 168, 169, + 610, -1, -1, -1, -1, -1, -1, 1097, -1, -1, + 620, 621, 1102, -1, -1, -1, 626, -1, -1, -1, + 1110, -1, -1, -1, -1, 635, 636, 637, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 653, -1, -1, -1, -1, 658, 659, + -1, -1, 662, 663, -1, 1145, -1, -1, -1, 669, + -1, -1, -1, -1, -1, -1, -1, 1157, -1, 239, + 1160, -1, 1162, -1, -1, -1, -1, -1, 688, -1, + -1, -1, -1, -1, -1, -1, 1176, 1177, -1, -1, + -1, -1, -1, 263, -1, -1, -1, -1, -1, -1, + -1, 711, 712, -1, -1, -1, -1, -1, 1198, -1, + 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, + 560, 561, 562, 563, 564, 565, 566, 567, -1, -1, + -1, -1, -1, -1, -1, 745, 746, -1, -1, -1, + 750, 751, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1245, -1, -1, -1, -1, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, -1, + 30, 31, 32, -1, -1, 795, -1, -1, -1, 39, + -1, -1, -1, 803, -1, -1, -1, -1, -1, -1, + 810, 811, -1, -1, 814, -1, 816, -1, -1, -1, + 380, -1, -1, -1, -1, -1, 826, 67, 1534, -1, + -1, -1, 72, -1, 74, 75, 76, -1, 78, -1, + 1320, -1, 1322, 83, 84, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1336, -1, 1338, -1, + -1, -1, -1, -1, -1, -1, 696, -1, -1, 109, + -1, 111, -1, 1353, -1, -1, -1, 117, 118, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1369, + 1370, -1, -1, -1, -1, -1, -1, -1, 898, -1, + 1380, -1, -1, 1383, -1, 905, 906, 907, -1, 909, + -1, -1, -1, 913, 474, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1404, -1, -1, 757, -1, -1, + -1, -1, -1, 1413, 934, 935, 1416, -1, 1418, 1419, + 1420, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 513, -1, -1, -1, -1, 788, -1, + -1, -1, -1, -1, -1, -1, 526, -1, -1, 969, + -1, 531, -1, -1, 534, -1, -1, -1, 1458, -1, + 1460, -1, 1462, -1, -1, -1, -1, 547, -1, -1, + 990, 991, -1, -1, -1, -1, -1, 1477, -1, -1, + -1, 1001, -1, -1, -1, -1, -1, 1007, 1008, 569, + 1010, 1011, 1012, -1, -1, -1, -1, -1, -1, 579, + -1, -1, 1022, 1023, -1, -1, 586, -1, -1, -1, + -1, 591, -1, -1, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, 33, -1, -1, 36, -1, -1, + 39, 40, -1, -1, -1, -1, -1, -1, 908, -1, + 640, -1, -1, -1, -1, 1085, -1, 1087, 648, -1, + -1, -1, 1092, -1, -1, 64, -1, -1, 67, -1, + 69, 1101, 71, 72, -1, 74, 75, 76, -1, -1, + -1, -1, -1, -1, 83, 84, -1, -1, -1, -1, + -1, -1, -1, 953, 1124, 1125, 1126, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 109, -1, 111, -1, -1, -1, 115, -1, 117, 118, + 1150, -1, -1, -1, -1, -1, -1, -1, 988, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1001, -1, -1, -1, -1, -1, -1, 37, 38, + -1, 40, -1, -1, -1, -1, 746, -1, 748, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 758, -1, + -1, -1, -1, -1, 764, -1, -1, 66, -1, -1, + -1, 1211, 1042, 72, -1, 74, 75, 76, -1, -1, + 79, 80, 81, 82, 83, 84, -1, 86, 87, 1229, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 807, 808, -1, + 109, 811, 111, -1, 113, 114, -1, -1, 117, 118, + 119, 120, 121, 122, -1, 825, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1278, 1279, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1119, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 865, -1, -1, -1, 869, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 1076, 1077, 30, 31, 32, - 33, -1, -1, 36, 37, 38, 39, 40, -1, 696, + 23, 24, 25, 26, 27, -1, 906, 30, 31, 32, + 33, 1181, 1182, 36, -1, -1, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1395, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 66, 67, -1, 69, -1, 71, 72, - -1, 74, 75, 76, 49, -1, 79, 80, 81, 82, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 64, -1, -1, 67, 945, 69, -1, 71, 72, + -1, 74, 75, 76, -1, -1, -1, -1, 1398, -1, + 83, 84, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 973, -1, -1, -1, 37, 38, 979, + 40, -1, -1, 983, -1, -1, 109, -1, 111, -1, + -1, -1, -1, -1, 117, 118, -1, -1, -1, -1, + -1, -1, -1, -1, 1004, -1, 66, -1, -1, -1, + -1, -1, 72, -1, -1, 1015, 76, -1, -1, 79, + 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1037, -1, 1039, + -1, -1, -1, 37, 38, 1485, 40, -1, -1, 109, + -1, 111, -1, -1, 1054, 1055, 116, 117, 118, 119, + 120, 121, 122, -1, -1, -1, -1, -1, -1, 1509, + 1510, -1, 66, -1, -1, 1075, -1, -1, 72, -1, + -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, + 84, -1, 86, 87, 1534, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 109, 1386, 111, -1, -1, + 114, -1, -1, 117, 118, 119, 120, 121, 122, -1, + 1130, -1, 1402, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1150, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1165, 1166, -1, -1, -1, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, 33, 1472, 1473, 36, 37, 38, 39, 40, 41, + -1, 43, -1, -1, 46, 47, 48, 49, 50, 51, + 52, 53, -1, -1, -1, 57, -1, -1, -1, 61, + 62, -1, 64, -1, 66, 67, -1, 69, -1, 71, + 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, + 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, + -1, -1, 114, -1, -1, 117, 118, 119, 120, 121, + 122, -1, -1, -1, -1, 127, -1, -1, -1, -1, + 132, -1, -1, -1, -1, -1, 1306, -1, -1, 1309, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, + 33, -1, -1, 36, 37, 38, 39, 40, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, -1, 66, 67, -1, 69, 39, 71, 72, + -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, - -1, 66, -1, -1, -1, -1, 1147, 1442, -1, -1, - 757, -1, -1, -1, 1449, -1, 109, -1, 111, -1, - -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, - -1, -1, -1, 700, -1, 702, -1, -1, -1, 132, - 787, -1, 709, 710, -1, -1, -1, 714, 113, 1190, - -1, -1, 117, -1, -1, -1, -1, -1, -1, 726, - -1, -1, -1, -1, 731, 1500, -1, -1, -1, -1, - -1, 1212, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 146, -1, 1224, -1, 1226, -1, -1, -1, -1, - -1, 156, 759, -1, -1, 160, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 7, -1, -1, 10, - 11, 12, 13, 14, -1, 1256, -1, -1, -1, -1, - -1, -1, -1, 1264, 1265, 1266, -1, -1, -1, -1, - -1, -1, -1, -1, 1275, 1276, 37, 38, 39, 40, - -1, -1, -1, -1, 209, -1, -1, -1, 1289, -1, - -1, -1, -1, -1, -1, -1, 221, -1, -1, -1, - 907, -1, -1, -1, -1, 66, 67, -1, -1, -1, - -1, 72, -1, -1, 239, 76, -1, -1, 79, 80, - 81, 82, 83, 84, -1, 86, 87, 1328, -1, -1, - -1, 858, 859, 860, 861, -1, 863, -1, -1, 264, - -1, -1, -1, -1, -1, 952, 271, -1, 109, -1, - 111, 878, -1, -1, -1, -1, 117, 118, 119, 120, - 121, 122, -1, -1, -1, 892, -1, -1, -1, 294, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 987, -1, 307, -1, -1, -1, -1, -1, -1, 66, - -1, -1, -1, 1000, 1395, -1, -1, -1, 75, -1, - 77, -1, 79, -1, -1, 932, -1, -1, -1, 86, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 345, -1, -1, -1, -1, 350, -1, -1, -1, -1, - -1, -1, -1, -1, 1041, -1, -1, -1, -1, -1, - 117, 1442, 119, 120, 121, -1, -1, -1, 1449, -1, - 977, -1, -1, -1, -1, -1, 983, -1, -1, -1, - -1, 988, -1, -1, -1, -1, 993, -1, 995, -1, - -1, -1, 999, -1, 1001, 1002, -1, -1, 1005, -1, - -1, -1, -1, 160, -1, -1, -1, 1014, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1500, - -1, 426, 427, -1, -1, 1032, 1033, -1, 433, -1, - -1, 1118, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 454, - -1, -1, 1059, -1, -1, 1062, -1, -1, -1, -1, - -1, -1, -1, -1, 221, -1, 223, 224, 225, -1, - -1, -1, -1, -1, -1, -1, -1, 482, -1, -1, - -1, 10, 11, 12, 13, 14, -1, -1, -1, 494, - -1, 1178, 1179, -1, -1, -1, -1, -1, 1105, -1, - -1, 506, 259, 508, 1111, 1112, 511, 264, 513, 514, - 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 526, 279, -1, 1131, -1, -1, 1134, -1, -1, - -1, 1138, -1, -1, -1, -1, -1, -1, 67, -1, - -1, -1, -1, 72, 1151, 74, 75, 76, -1, -1, - -1, -1, -1, -1, 83, 84, -1, 1164, -1, 1166, - 1167, 1168, 1169, -1, -1, -1, -1, -1, -1, -1, - -1, 328, -1, -1, 579, 1182, -1, 1184, -1, -1, - 109, 1188, -1, -1, -1, -1, 591, -1, 117, 118, - 595, -1, -1, 350, -1, -1, -1, -1, 355, 356, - -1, -1, -1, -1, -1, -1, 363, -1, -1, -1, - 1217, 1218, -1, -1, -1, -1, 621, -1, -1, -1, - -1, 626, -1, -1, -1, -1, -1, -1, -1, -1, - 635, 636, 637, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 653, 406, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1267, 1268, -1, -1, -1, -1, -1, 424, -1, -1, - 1277, -1, 429, -1, 431, -1, -1, -1, -1, -1, - 685, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 448, -1, -1, 451, 452, 1383, -1, -1, -1, - -1, -1, 459, -1, -1, -1, 711, -1, 713, -1, - -1, -1, 1399, -1, -1, -1, 473, -1, -1, -1, - -1, -1, -1, 480, -1, -1, -1, -1, -1, -1, - -1, 1338, -1, 1340, 1341, 1342, -1, -1, -1, -1, - -1, 746, -1, -1, -1, 1352, 44, -1, -1, -1, - -1, -1, -1, -1, 1361, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, -1, -1, 30, 31, 32, -1, 1386, - -1, -1, 1469, 1470, 39, -1, -1, 10, 11, 12, - 13, 14, -1, 91, -1, -1, -1, 802, -1, -1, - -1, 806, -1, 101, -1, 810, -1, -1, -1, -1, - -1, -1, 67, -1, -1, -1, 39, 72, -1, 74, - 75, 76, 1429, 1430, -1, -1, -1, -1, 83, 84, - -1, -1, -1, -1, -1, 1442, -1, -1, 595, -1, - -1, -1, 1449, -1, 67, -1, -1, -1, -1, 72, - -1, 74, 75, 76, 109, -1, 111, -1, -1, 157, - 83, 84, 117, 118, -1, -1, 623, -1, -1, -1, - -1, 628, -1, 171, 1481, -1, -1, -1, 1485, -1, - -1, -1, -1, -1, -1, -1, 109, -1, -1, -1, - -1, -1, -1, -1, 117, 118, 194, -1, -1, -1, - 905, -1, -1, -1, -1, -1, 1513, -1, 1515, -1, - 208, -1, -1, -1, -1, 920, -1, -1, -1, 217, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 227, - -1, -1, -1, -1, -1, -1, 1543, 1544, -1, 944, - -1, -1, 699, -1, 1551, 1552, -1, -1, -1, -1, - -1, -1, -1, -1, 252, -1, 713, -1, -1, 257, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 270, -1, -1, -1, 733, -1, 276, -1, - 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1000, -1, 295, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 1021, 1022, 30, 31, - 32, -1, -1, -1, -1, -1, -1, 39, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 794, -1, -1, - 338, -1, -1, -1, -1, 343, -1, -1, -1, 806, -1, -1, -1, -1, -1, 67, -1, -1, -1, -1, - 72, -1, 74, 75, 76, -1, -1, -1, 825, -1, - -1, 83, 84, -1, 372, -1, 1081, -1, 376, 377, - -1, 379, -1, -1, -1, -1, -1, -1, 386, 387, - -1, 389, 390, -1, 392, -1, 394, 109, -1, 111, - -1, -1, -1, -1, -1, 117, 118, -1, -1, -1, - -1, -1, -1, 411, -1, -1, -1, -1, -1, -1, - -1, 419, -1, -1, -1, -1, -1, -1, -1, 155, - 156, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1147, -1, -1, -1, 444, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, - 14, -1, -1, 189, -1, -1, -1, -1, -1, -1, - 196, -1, 470, -1, -1, -1, -1, -1, 476, -1, - -1, 938, -1, 481, 1189, 39, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, -1, 30, 31, 32, -1, - -1, 968, -1, 67, -1, 39, -1, -1, 72, 517, - -1, 1226, 76, -1, -1, -1, -1, -1, -1, 83, - 84, -1, -1, -1, 532, -1, -1, -1, -1, -1, - -1, -1, 268, 67, -1, -1, 1003, -1, 72, -1, - 74, 75, 76, -1, 78, 109, -1, 1014, -1, 83, - 84, -1, -1, 117, 118, -1, -1, -1, -1, -1, - 1275, 1276, -1, 571, -1, -1, -1, -1, -1, 1284, - -1, -1, 580, -1, -1, 109, -1, 111, 146, 587, - -1, -1, -1, 117, 118, 593, -1, 323, 156, -1, - -1, -1, -1, -1, 602, 331, 332, -1, 334, 335, - 168, 169, -1, -1, -1, -1, -1, -1, -1, 345, - -1, -1, -1, 349, -1, -1, -1, -1, -1, 1086, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 368, 1100, 642, 371, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, 398, 30, 31, 32, 402, -1, -1, -1, - 678, 239, 39, -1, -1, -1, -1, -1, 686, -1, - 1395, -1, 37, 38, -1, 40, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 263, -1, 433, -1, -1, - 67, -1, 69, -1, 71, -1, -1, 74, 75, 717, - -1, 66, -1, -1, -1, -1, -1, 72, -1, 727, - 728, 76, 1189, -1, 79, 80, 81, 82, 83, 84, - -1, 86, 87, -1, -1, -1, 1451, -1, 1453, -1, - -1, -1, -1, 479, 111, -1, 482, -1, -1, -1, - 117, 118, 760, -1, 109, -1, 111, 765, -1, 114, - -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, - -1, -1, 1487, -1, 1489, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 521, -1, -1, -1, 525, - 526, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1516, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 380, -1, -1, -1, -1, 1284, -1, -1, - -1, 829, -1, -1, -1, -1, -1, -1, 836, -1, - -1, -1, -1, -1, -1, 571, 572, -1, -1, -1, - -1, 849, -1, 851, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 590, 591, -1, 865, -1, -1, - -1, -1, -1, 871, -1, 601, -1, 603, 604, -1, - -1, -1, -1, -1, 610, 883, -1, -1, 886, -1, - -1, -1, -1, -1, 620, 621, -1, -1, -1, -1, - 626, -1, -1, -1, -1, -1, -1, -1, -1, 635, - 636, 637, -1, -1, -1, -1, 474, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 653, -1, -1, - -1, -1, 658, 659, -1, -1, 662, 663, -1, -1, - -1, -1, -1, 669, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 513, -1, -1, -1, -1, - -1, -1, 688, -1, -1, 963, -1, -1, 526, -1, - -1, -1, -1, 531, -1, -1, 534, -1, -1, -1, - -1, -1, -1, -1, -1, 711, 712, -1, -1, 547, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 998, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 569, -1, -1, -1, -1, -1, -1, -1, 745, - 746, 579, -1, -1, 750, 751, -1, -1, 586, -1, - -1, -1, -1, 591, -1, -1, -1, -1, -1, -1, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 1056, -1, - 30, 31, 32, -1, 1062, -1, -1, -1, 794, 39, - -1, -1, -1, -1, 1531, -1, 802, -1, -1, -1, - -1, -1, 640, 809, 810, -1, -1, 813, -1, 815, - 648, -1, -1, -1, -1, -1, -1, 67, 1096, 825, - -1, -1, 72, 1101, 74, 75, 76, -1, -1, -1, - -1, 1109, -1, 83, 84, -1, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, -1, -1, -1, -1, 109, - -1, 111, -1, -1, 1142, 39, -1, 117, 118, -1, - -1, -1, -1, -1, -1, -1, 1154, -1, -1, 1157, - -1, 1159, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 897, -1, 67, -1, 1173, 1174, -1, 904, 905, - 906, -1, 908, -1, 78, -1, 912, -1, 746, -1, - 748, -1, -1, -1, -1, -1, -1, 1195, -1, -1, - 758, -1, -1, -1, -1, -1, 764, 933, 934, -1, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 39, - -1, -1, 968, -1, 1242, -1, -1, -1, 806, 807, - -1, -1, 810, -1, -1, -1, -1, -1, 37, 38, - -1, 40, -1, 989, 990, -1, 824, 67, -1, -1, - -1, -1, -1, -1, 1000, -1, -1, -1, 78, -1, - 1006, 1007, -1, 1009, 1010, 1011, -1, 66, -1, -1, - -1, -1, -1, 72, -1, 1021, 1022, 76, -1, -1, - 79, 80, 81, 82, 83, 84, 864, 86, 87, -1, - 868, -1, -1, -1, -1, -1, -1, -1, -1, 1317, - -1, 1319, -1, -1, -1, -1, -1, -1, -1, -1, - 109, -1, 111, 1331, -1, 1333, -1, 116, 117, 118, - 119, 120, 121, 122, -1, -1, -1, 905, -1, -1, - -1, -1, 1350, -1, -1, -1, -1, -1, 1084, -1, - 1086, -1, -1, -1, -1, 1091, -1, -1, 1366, 1367, - -1, -1, -1, -1, 1100, -1, -1, -1, -1, 1377, - -1, -1, 1380, -1, -1, -1, 944, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1123, 1124, 1125, - -1, -1, -1, 1401, -1, -1, -1, -1, -1, -1, - -1, -1, 1410, -1, 972, 1413, -1, 1415, 1416, 1417, - 978, 1147, -1, -1, 982, 37, 38, -1, 40, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1003, -1, -1, -1, -1, - -1, -1, -1, -1, 66, -1, 1014, 1455, -1, 1457, - 72, 1459, 74, 75, 76, -1, -1, 79, 80, 81, - 82, 83, 84, -1, 86, 87, 1474, -1, 1036, -1, - 1038, -1, 1208, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1053, 1054, 109, -1, 111, - 1226, 113, 114, -1, -1, 117, 118, 119, 120, 121, - 122, -1, -1, -1, -1, -1, 1074, -1, -1, -1, + 72, -1, 74, 75, -1, -1, 109, -1, 111, -1, + -1, 83, 84, -1, 117, 118, 119, 120, 121, 122, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 132, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 1275, - 1276, 30, 31, 32, 33, -1, -1, 36, -1, -1, - 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1129, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 67, 1147, - 69, -1, 71, -1, -1, 74, 75, -1, -1, -1, - -1, -1, -1, -1, 1162, 1163, -1, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 111, -1, 30, 31, 32, 33, 117, 118, - 36, 37, 38, 39, 40, 41, -1, 43, -1, -1, - 46, 47, 48, 49, 50, 51, 52, 53, -1, -1, - -1, 57, -1, -1, -1, 61, 62, -1, 64, 1395, - 66, 67, -1, 69, -1, 71, 72, -1, 74, 75, - 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, - 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, 33, -1, -1, 36, 37, 38, + 39, 40, -1, -1, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, -1, -1, -1, 66, 67, -1, + 69, -1, 71, 72, 39, 74, 75, 76, -1, 1519, + 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 109, -1, 111, -1, -1, 114, -1, - -1, 117, 118, 119, 120, 121, 122, -1, -1, -1, - -1, 127, -1, -1, -1, -1, 132, -1, -1, -1, - -1, -1, -1, -1, -1, 1303, -1, -1, 1306, -1, - -1, -1, -1, -1, -1, -1, 1482, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1506, 1507, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1531, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, -1, 30, 31, 32, 33, -1, -1, 36, - 37, 38, 39, 40, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, -1, 30, 31, 32, -1, -1, 66, - 67, -1, 69, 39, 71, 72, -1, 74, 75, 76, - -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, - 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 67, -1, -1, -1, -1, 72, -1, 74, 75, - -1, -1, 109, -1, 111, -1, -1, 83, 84, -1, - 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - -1, -1, 30, 31, 32, -1, -1, -1, 1516, 37, - 38, 39, 40, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, -1, 30, 31, 32, -1, -1, 66, 67, - -1, 69, 39, 71, 72, -1, 74, 75, 76, -1, - -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 67, -1, -1, -1, -1, -1, -1, 74, 75, -1, - -1, 109, -1, 111, -1, -1, -1, -1, 116, 117, - 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, -1, -1, -1, -1, 37, 38, - 39, 40, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - -1, -1, 30, 31, 32, -1, -1, 66, 67, -1, - 69, 39, 71, 72, -1, 74, 75, 76, -1, -1, - 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, - -1, -1, -1, -1, -1, -1, 74, 75, -1, -1, - 109, -1, 111, -1, -1, -1, -1, 116, 117, 118, + -1, -1, 67, -1, -1, -1, -1, -1, -1, -1, + 109, -1, 111, 78, -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, @@ -3565,9 +3570,9 @@ 40, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, -1, -1, -1, -1, -1, 66, 67, -1, 69, + -1, 30, 31, 32, -1, -1, 66, 67, -1, 69, 39, 71, 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, + -1, -1, -1, -1, -1, 74, 75, -1, -1, 109, -1, 111, -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, 9, 10, @@ -3575,12 +3580,12 @@ 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, 38, 39, 40, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 66, 67, -1, 69, -1, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, + 30, 31, 32, -1, -1, 66, 67, -1, 69, 39, 71, 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, - 111, -1, -1, -1, -1, -1, 117, 118, 119, 120, + -1, -1, -1, -1, -1, -1, -1, 67, -1, -1, + -1, -1, -1, -1, 74, 75, -1, -1, 109, -1, + 111, -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, @@ -3594,5 +3599,5 @@ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, - -1, -1, -1, -1, -1, 117, 118, 119, 120, 121, + -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, @@ -3618,109 +3623,56 @@ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, - -1, -1, -1, 117, 118, 119, 120, 121, 122, 0, - -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, - 31, 32, 33, -1, -1, 36, -1, -1, 39, 40, + -1, -1, -1, 117, 118, 119, 120, 121, 122, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, + -1, -1, 37, 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 64, -1, -1, 67, -1, 69, -1, - 71, 72, -1, 74, 75, 76, -1, -1, -1, -1, - -1, -1, 83, 84, -1, -1, -1, -1, -1, -1, + -1, 66, 67, -1, 69, -1, 71, 72, -1, 74, + 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, - 111, -1, -1, -1, -1, -1, 117, 118, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, -1, -1, 30, 31, 32, 33, -1, - -1, 36, -1, -1, 39, 40, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 64, - -1, -1, 67, -1, 69, -1, 71, 72, -1, 74, - 75, 76, -1, -1, -1, -1, -1, -1, 83, 84, + -1, -1, -1, -1, 109, -1, 111, -1, -1, -1, + -1, -1, 117, 118, 119, 120, 121, 122, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, -1, 30, 31, 32, -1, -1, -1, + -1, 37, 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 109, -1, 111, -1, -1, -1, - 115, -1, 117, 118, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, 33, -1, -1, 36, -1, -1, - 39, 40, -1, -1, -1, -1, -1, -1, -1, -1, + 66, 67, -1, 69, -1, 71, 72, -1, 74, 75, + 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, + 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 64, -1, -1, 67, -1, - 69, -1, 71, 72, -1, 74, 75, 76, -1, -1, - -1, -1, -1, -1, 83, 84, -1, -1, -1, -1, + -1, -1, -1, 109, -1, 111, -1, -1, -1, -1, + -1, 117, 118, 119, 120, 121, 122, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, -1, 30, 31, 32, -1, -1, -1, + -1, -1, -1, 39, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, 30, 31, 32, 33, 34, + 35, 67, -1, 69, 39, 71, 72, -1, 74, 75, + 76, -1, -1, -1, -1, -1, -1, 83, 84, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 67, -1, -1, -1, -1, -1, -1, 74, + 75, -1, -1, 109, -1, 111, -1, -1, -1, -1, + -1, 117, 118, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, -1, + 30, 31, 32, 33, -1, -1, 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 109, -1, 111, -1, -1, -1, -1, -1, 117, 118, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, - -1, -1, -1, -1, -1, -1, 39, -1, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, - 32, 33, 34, 35, 67, -1, 69, 39, 71, 72, - -1, 74, 75, 76, -1, -1, -1, -1, -1, -1, - 83, 84, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 67, -1, -1, -1, -1, - -1, -1, 74, 75, -1, -1, 109, -1, 111, -1, - -1, -1, -1, -1, 117, 118, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, -1, 30, 31, 32, 33, -1, -1, 36, - -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 67, -1, 69, -1, 71, -1, -1, 74, 75, -1, - -1, 78, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, - 32, -1, -1, -1, 111, -1, -1, 39, -1, -1, - 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 67, -1, 69, -1, 71, - 72, -1, 74, 75, 76, -1, -1, -1, -1, -1, - -1, 83, 84, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, - -1, -1, -1, -1, -1, 117, 118, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, - -1, -1, 39, -1, -1, -1, -1, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, - 67, -1, 69, -1, 71, -1, 39, 74, 75, -1, + -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, + -1, 71, -1, -1, 74, 75, -1, -1, 78, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 67, -1, 30, 31, 32, -1, - -1, 74, 75, 110, 111, 39, -1, -1, -1, -1, - 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 67, -1, 69, 109, 71, 111, -1, - 74, 75, -1, -1, 117, 118, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 96, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 111, -1, -1, - -1, -1, -1, 117, 118, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, -1, -1, -1, -1, -1, -1, - 39, -1, -1, -1, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, -1, 30, 31, 32, -1, 67, -1, - 69, -1, 71, 39, 40, 74, 75, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 96, -1, -1, - -1, 67, -1, -1, -1, -1, -1, -1, 74, 75, - -1, -1, 111, -1, -1, -1, -1, -1, 117, 118, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, 111, 30, 31, 32, 115, - -1, 117, 118, -1, -1, 39, -1, -1, -1, -1, + 24, 25, 26, 27, -1, -1, 30, 31, 32, 33, + -1, 111, 36, -1, -1, 39, -1, 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, -1, 71, -1, -1, - 74, 75, -1, 4, 5, 6, 7, 8, 9, 10, + 74, 75, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, @@ -3736,219 +3688,288 @@ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, - -1, 69, -1, 71, -1, -1, 74, 75, -1, 4, + -1, 69, -1, 71, 72, -1, 74, 75, 76, -1, + -1, -1, -1, -1, -1, 83, 84, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, -1, -1, -1, 117, + 118, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, + -1, -1, -1, -1, -1, -1, 39, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, 67, -1, 69, -1, 71, -1, + 39, 74, 75, -1, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 67, -1, + 30, 31, 32, -1, -1, 74, 75, 110, 111, 39, + -1, -1, -1, -1, 117, 118, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, + 109, 71, 111, -1, 74, 75, -1, -1, 117, 118, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 96, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 111, -1, -1, -1, -1, -1, 117, 118, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, - -1, -1, -1, 111, 39, -1, -1, -1, -1, 117, - 118, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 39, -1, -1, -1, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, 67, -1, 69, -1, 71, 39, 40, 74, + 75, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, -1, 69, -1, 71, -1, -1, 74, - 75, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, -1, -1, -1, -1, 37, 38, - 39, 40, -1, -1, -1, -1, 111, -1, -1, -1, - -1, -1, 117, 118, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 66, 67, -1, - -1, -1, -1, 72, -1, 74, 75, 76, -1, -1, - 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + -1, 96, -1, -1, -1, 67, -1, -1, -1, -1, + -1, -1, 74, 75, -1, -1, 111, -1, -1, -1, + -1, -1, 117, 118, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, -1, 111, + 30, 31, 32, 115, -1, 117, 118, -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 109, -1, 111, -1, -1, 114, -1, -1, 117, 118, + -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, + -1, 71, -1, -1, 74, 75, -1, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, + -1, 111, 39, -1, -1, -1, -1, 117, 118, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 67, -1, 69, -1, 71, -1, -1, 74, 75, -1, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, + -1, -1, -1, -1, 111, 39, -1, -1, -1, -1, + 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 67, -1, 69, -1, 71, -1, -1, + 74, 75, -1, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, + 31, 32, -1, -1, -1, -1, -1, 111, 39, -1, + -1, -1, -1, 117, 118, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 67, -1, 69, -1, + 71, -1, -1, 74, 75, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, + -1, -1, 37, 38, 39, 40, -1, -1, -1, -1, + 111, -1, -1, -1, -1, -1, 117, 118, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 66, 67, -1, -1, -1, -1, 72, -1, 74, + 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 109, -1, 111, -1, -1, 114, + -1, -1, 117, 118, 119, 120, 121, 122, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, -1, -1, -1, 37, 38, 39, 40, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, + 31, 32, -1, -1, 66, 67, -1, -1, 39, -1, + 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, + 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 67, -1, -1, -1, + -1, 72, -1, 74, 75, 76, -1, 109, 110, 111, + -1, -1, 83, 84, -1, 117, 118, 119, 120, 121, + 122, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + 111, 30, 31, 32, -1, -1, 117, 118, 37, 38, + 39, 40, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, 66, 67, -1, + -1, 39, -1, 72, -1, 74, 75, 76, -1, -1, + 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, + -1, -1, -1, -1, 72, -1, 74, 75, -1, -1, + 109, -1, 111, -1, -1, 83, 84, -1, 117, 118, 119, 120, 121, 122, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, -1, 30, 31, 32, -1, -1, -1, - -1, 37, 38, 39, 40, 10, 11, 12, 13, 14, + 26, 27, -1, 111, 30, 31, 32, -1, -1, 117, + 118, 37, 38, 39, 40, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, - 66, 67, -1, -1, 39, -1, 72, -1, 74, 75, + 66, 67, -1, -1, 39, 40, 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, -1, -1, -1, -1, 72, -1, 74, - 75, 76, -1, 109, 110, 111, -1, -1, 83, 84, + -1, -1, 67, -1, -1, -1, -1, -1, -1, 74, + 75, -1, -1, 109, -1, 111, -1, -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, 111, 30, 31, 32, - -1, -1, 117, 118, 37, 38, 39, 40, 10, 11, + 115, -1, 117, 118, 37, 38, 39, 40, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, - 32, -1, -1, 66, 67, -1, -1, 39, -1, 72, + 32, -1, -1, 66, 67, -1, -1, 39, 40, 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, -1, -1, -1, - 72, -1, 74, 75, -1, -1, 109, -1, 111, -1, - -1, 83, 84, -1, 117, 118, 119, 120, 121, 122, + -1, -1, 74, 75, -1, -1, 109, -1, 111, -1, + -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, 111, - 30, 31, 32, -1, -1, 117, 118, 37, 38, 39, - 40, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 30, 31, 32, 115, -1, 117, 118, 37, 38, 39, + 40, -1, -1, -1, -1, -1, -1, -1, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 66, 67, 30, 31, + 32, -1, 72, -1, 74, 75, 76, 39, -1, 79, + 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 67, -1, -1, -1, 109, + -1, 111, 74, 75, -1, -1, -1, 117, 118, 119, + 120, 121, 122, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, -1, 111, + 30, 31, 32, -1, -1, 117, 118, -1, -1, 39, + -1, -1, -1, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, -1, 67, -1, 69, + -1, 71, 39, -1, 74, 75, -1, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, -1, -1, 66, 67, -1, -1, - 39, 40, 72, -1, 74, 75, 76, -1, -1, 79, - 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, - -1, -1, -1, -1, -1, 74, 75, -1, -1, 109, - -1, 111, -1, -1, -1, -1, -1, 117, 118, 119, - 120, 121, 122, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, 111, 30, 31, 32, 115, -1, 117, 118, - 37, 38, 39, 40, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, -1, 30, 31, 32, -1, -1, 66, - 67, -1, -1, 39, 40, 72, -1, 74, 75, 76, - -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, - 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 67, -1, -1, -1, -1, -1, -1, 74, 75, - -1, -1, 109, -1, 111, -1, -1, -1, -1, -1, - 117, 118, 119, 120, 121, 122, 10, 11, 12, 13, + 67, 30, 31, 32, -1, 72, -1, 74, 75, 76, + 39, -1, -1, -1, 114, -1, 83, 84, -1, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, -1, 67, 30, + 31, 32, 109, 72, 111, 74, 75, 76, 39, -1, + 117, 118, -1, -1, 83, 84, -1, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 67, 30, 31, 32, + 109, 72, 111, 74, 75, 76, 39, -1, 117, 118, + -1, -1, 83, 84, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 67, 30, 31, 32, 109, -1, + 111, 74, 75, -1, 39, 78, 117, 118, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, 67, -1, -1, -1, 109, 39, 111, 74, + 75, -1, -1, 78, 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, 111, 30, 31, 32, 115, - -1, 117, 118, 37, 38, 39, 40, -1, -1, -1, - -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 66, 67, 30, 31, 32, -1, 72, -1, - 74, 75, 76, 39, -1, 79, 80, 81, 82, 83, - 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 67, -1, -1, -1, 109, -1, 111, 74, 75, - -1, -1, -1, 117, 118, 119, 120, 121, 122, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, 111, 30, 31, 32, -1, - -1, 117, 118, -1, -1, 39, -1, -1, -1, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, -1, 30, - 31, 32, -1, 67, -1, 69, -1, 71, 39, -1, - 74, 75, -1, -1, -1, -1, -1, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, -1, 67, 30, 31, 32, - -1, 72, -1, 74, 75, 76, 39, 78, -1, -1, - 114, -1, 83, 84, -1, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 67, 30, 31, 32, -1, 72, - 111, 74, 75, 76, 39, -1, 117, 118, -1, -1, - 83, 84, -1, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, 67, 30, 31, 32, 109, -1, 111, 74, - 75, -1, 39, 78, 117, 118, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, - 67, -1, -1, -1, -1, 39, 111, 74, 75, -1, + 24, 25, 26, 27, -1, 67, 30, 31, 32, -1, + -1, -1, 74, 75, -1, 39, 111, -1, -1, -1, -1, -1, 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, 67, 30, 31, 32, -1, -1, -1, - 74, 75, -1, 39, 111, -1, -1, -1, -1, -1, - 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - -1, 67, 30, 31, 32, -1, -1, 111, 74, 75, - -1, 39, -1, 117, 118, 10, 11, 12, 13, 14, + 26, 27, -1, 67, 30, 31, 32, -1, -1, 111, + 74, 75, -1, 39, -1, 117, 118, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, + -1, 67, -1, -1, -1, -1, 39, 111, 74, 75, + -1, -1, -1, 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, -1, -1, 30, 31, 32, -1, 67, - -1, -1, -1, -1, 39, 111, 74, 75, -1, -1, + 25, 26, 27, -1, 67, 30, 31, 32, -1, -1, + -1, 74, 75, -1, 39, 111, -1, -1, -1, -1, -1, 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, 67, 30, 31, 32, -1, -1, -1, 74, - 75, -1, 39, 111, -1, -1, -1, -1, -1, 117, - 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - 67, 30, 31, 32, -1, -1, 111, 74, 75, -1, - 39, -1, 117, 118, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 67, -1, - 30, 31, 32, -1, 111, 74, 75, -1, -1, 39, - 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, + 27, -1, 67, 30, 31, 32, -1, -1, 111, 74, + 75, -1, 39, -1, 117, 118, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 67, -1, 30, 31, 32, -1, 111, 74, 75, -1, + -1, 39, 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, - -1, 71, -1, -1, 74, 75, -1, -1, 117, 118, - 37, 38, -1, 40, 41, -1, 43, -1, -1, 46, - 47, 48, 49, 50, 51, 52, 53, -1, -1, 56, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, + -1, 69, -1, 71, 111, -1, 74, 75, -1, -1, + 117, 118, 37, 38, -1, 40, 41, -1, 43, -1, + -1, 46, 47, 48, 49, 50, 51, 52, 53, -1, + -1, 56, 57, -1, -1, -1, 61, 62, -1, 64, + -1, 66, 110, -1, -1, -1, -1, 72, -1, -1, + -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 109, -1, 111, -1, -1, 114, + -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, + 37, 38, 127, 40, 41, -1, 43, 132, -1, 46, + 47, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, -1, -1, -1, 61, 62, -1, 64, -1, 66, - 110, -1, -1, -1, -1, 72, -1, -1, -1, 76, + -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, 114, -1, -1, - 117, 118, 119, 120, 121, 122, -1, -1, 37, 38, - 127, 40, 41, -1, 43, 132, -1, 46, 47, 48, - 49, 50, 51, 52, 53, -1, -1, -1, 57, -1, - -1, -1, 61, 62, -1, 64, -1, 66, -1, -1, - -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, - 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + 117, 118, 119, 120, 121, 122, -1, -1, -1, -1, + 127, -1, -1, -1, -1, 132, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, -1, + -1, 39, -1, 37, 38, -1, 40, 41, -1, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + -1, -1, 56, 57, -1, -1, -1, 61, 62, 67, + 64, 69, 66, 71, -1, -1, 74, 75, 72, -1, + -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, + 84, -1, 86, 87, -1, -1, -1, -1, 96, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 109, -1, 111, -1, -1, 114, -1, -1, 117, 118, - 119, 120, 121, 122, -1, -1, -1, -1, 127, -1, - -1, -1, -1, 132, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, - 30, 31, 32, -1, -1, -1, -1, -1, -1, 39, - -1, 37, 38, -1, 40, 41, -1, 43, 44, 45, + -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, + 114, -1, -1, 117, 118, 119, 120, 121, 122, -1, + -1, 37, 38, 127, 40, 41, -1, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, -1, -1, - 56, 57, -1, -1, -1, 61, 62, 67, 64, 69, - 66, 71, -1, -1, 74, 75, 72, -1, -1, -1, + -1, 57, -1, -1, -1, 61, 62, -1, 64, -1, + 66, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, - 86, 87, -1, -1, -1, -1, 96, -1, -1, -1, + 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, 114, -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, 37, - 38, 127, 40, 41, -1, 43, 44, 45, 46, 47, + 38, 127, 40, 41, -1, 43, -1, -1, 46, 47, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, -1, -1, -1, 61, 62, -1, 64, -1, 66, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, 114, -1, -1, 117, + 118, 119, 120, 121, 122, 66, -1, -1, -1, 127, + -1, 72, -1, -1, -1, 76, -1, -1, 79, 80, + 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, + -1, -1, -1, 37, 38, -1, 40, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, + 111, -1, 37, 38, -1, 40, 117, 118, 119, 120, + 121, 122, 66, -1, -1, -1, -1, -1, 72, -1, + -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, + 84, 66, 86, 87, -1, -1, -1, 72, -1, -1, + -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, 109, -1, 111, -1, 37, + 38, -1, 40, 117, 118, 119, 120, 121, 122, -1, + -1, -1, -1, -1, 109, -1, 111, -1, 37, 38, + -1, 40, 117, 118, 119, 120, 121, 122, 66, -1, + -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, + -1, 79, 80, 81, 82, 83, 84, 66, 86, 87, + -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, + 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + -1, 109, -1, -1, -1, 37, 38, -1, 40, 117, + 118, 119, 120, 121, 122, -1, -1, -1, -1, -1, + 109, -1, -1, -1, 37, 38, -1, 40, 117, 118, + 119, 120, 121, 122, 66, -1, -1, -1, -1, -1, + 72, -1, -1, -1, 76, -1, -1, 79, 80, 81, + 82, 83, 84, 66, 86, 87, -1, -1, -1, 72, + -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, + 83, 84, -1, 86, 87, -1, -1, 109, -1, -1, + -1, -1, -1, -1, -1, 117, 118, 119, 120, 121, + 122, -1, -1, -1, -1, -1, 109, -1, -1, -1, + -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 109, -1, 111, -1, -1, 114, -1, -1, 117, - 118, 119, 120, 121, 122, -1, -1, 37, 38, 127, - 40, 41, -1, 43, -1, -1, 46, 47, 48, 49, - 50, 51, 52, 53, -1, -1, -1, 57, -1, -1, - -1, 61, 62, -1, 64, -1, 66, -1, -1, -1, - -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, - 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, - -1, -1, -1, -1, 37, 38, -1, 40, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, - -1, 111, -1, -1, 114, -1, -1, 117, 118, 119, - 120, 121, 122, 66, -1, -1, -1, 127, -1, 72, - -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, - 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, - -1, 37, 38, -1, 40, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 109, -1, 111, -1, - -1, 114, -1, -1, 117, 118, 119, 120, 121, 122, - 66, -1, -1, -1, -1, -1, 72, -1, -1, -1, - 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, - 86, 87, -1, -1, -1, -1, -1, -1, 37, 38, - -1, 40, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 109, -1, 111, -1, 37, 38, -1, - 40, 117, 118, 119, 120, 121, 122, 66, -1, -1, - -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, - 79, 80, 81, 82, 83, 84, 66, 86, 87, -1, - -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, - 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, - 109, -1, 111, -1, 37, 38, -1, 40, 117, 118, - 119, 120, 121, 122, -1, -1, -1, -1, -1, 109, - -1, 111, -1, 37, 38, -1, 40, 117, 118, 119, - 120, 121, 122, 66, -1, -1, -1, -1, -1, 72, - -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, - 83, 84, 66, 86, 87, -1, -1, -1, 72, -1, - -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, - 84, -1, 86, 87, -1, -1, 109, -1, -1, -1, - 37, 38, -1, 40, 117, 118, 119, 120, 121, 122, - -1, -1, -1, -1, -1, 109, -1, -1, -1, 37, - 38, -1, 40, 117, 118, 119, 120, 121, 122, 66, - -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, - -1, -1, 79, 80, 81, 82, 83, 84, 66, 86, - 87, -1, -1, -1, 72, -1, -1, -1, 76, -1, - -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, - -1, -1, 109, -1, -1, -1, -1, -1, -1, -1, - 117, 118, 119, 120, 121, 122, -1, -1, -1, -1, - -1, 109, -1, -1, -1, -1, -1, -1, -1, 117, - 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, + -1, -1, -1, 67, -1, 69, -1, 71, 72, -1, + 74, 75, 76, -1, -1, -1, -1, -1, -1, 83, + 84, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, -1, -1, -1, -1, -1, 39, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 67, -1, 69, -1, 71, + -1, -1, 74, 75, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 30, 31, 32, -1, -1, -1, -1, -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, - 69, -1, 71, 72, -1, 74, 75, 76, -1, -1, - -1, -1, -1, -1, 83, 84, 3, 4, 5, 6, + 69, -1, 71, -1, -1, 74, 75, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, @@ -3957,20 +3978,5 @@ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 67, -1, 69, -1, 71, -1, -1, 74, 75, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, - -1, -1, -1, -1, -1, 39, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 67, -1, 69, -1, 71, -1, -1, - 74, 75, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, - 32, -1, -1, -1, -1, -1, -1, 39, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 67, -1, 69, -1, 71, - -1, -1, 74, 75 + 67, -1, 69, -1, 71, -1, -1, 74, 75 }; @@ -3983,156 +3989,156 @@ 22, 23, 24, 25, 26, 27, 30, 31, 32, 33, 36, 39, 40, 64, 67, 69, 71, 72, 74, 75, - 76, 83, 84, 109, 111, 117, 118, 137, 140, 150, - 199, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 232, - 233, 234, 235, 236, 237, 238, 240, 241, 242, 243, - 244, 245, 247, 255, 256, 283, 284, 285, 293, 296, - 302, 303, 305, 307, 308, 314, 319, 323, 324, 325, - 326, 327, 328, 329, 330, 350, 367, 368, 369, 370, - 72, 139, 140, 150, 216, 218, 226, 228, 237, 241, - 243, 284, 82, 109, 312, 313, 314, 312, 312, 72, - 74, 75, 76, 138, 139, 273, 274, 294, 295, 74, - 75, 274, 109, 305, 11, 200, 109, 150, 319, 324, - 325, 326, 328, 329, 330, 112, 134, 111, 219, 226, - 228, 323, 327, 366, 367, 370, 371, 135, 107, 131, - 277, 114, 135, 174, 74, 75, 137, 272, 135, 135, - 135, 116, 135, 74, 75, 109, 150, 309, 318, 319, - 320, 321, 322, 323, 327, 331, 332, 333, 334, 335, - 341, 3, 28, 78, 239, 3, 5, 74, 111, 150, - 218, 229, 233, 235, 244, 285, 323, 327, 370, 216, - 218, 228, 237, 241, 243, 284, 323, 327, 33, 234, - 234, 229, 235, 135, 234, 229, 234, 229, 75, 109, - 114, 274, 285, 114, 274, 234, 229, 116, 135, 135, - 0, 134, 109, 174, 312, 312, 134, 111, 226, 228, - 368, 272, 272, 131, 228, 109, 150, 309, 319, 323, - 111, 150, 370, 306, 231, 314, 109, 290, 109, 109, + 76, 83, 84, 109, 111, 117, 118, 137, 140, 151, + 200, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 233, + 234, 235, 236, 237, 238, 239, 241, 242, 243, 244, + 245, 246, 248, 256, 257, 284, 285, 286, 294, 297, + 303, 304, 306, 308, 309, 315, 320, 324, 325, 326, + 327, 328, 329, 330, 331, 351, 368, 369, 370, 371, + 72, 139, 140, 151, 217, 219, 227, 229, 238, 242, + 244, 285, 82, 109, 313, 314, 315, 313, 313, 72, + 74, 75, 76, 138, 139, 274, 275, 295, 296, 74, + 75, 275, 109, 306, 11, 201, 109, 151, 320, 325, + 326, 327, 329, 330, 331, 112, 134, 111, 220, 227, + 229, 324, 328, 367, 368, 371, 372, 135, 107, 131, + 278, 114, 135, 175, 74, 75, 137, 273, 135, 135, + 135, 116, 135, 74, 75, 109, 151, 310, 319, 320, + 321, 322, 323, 324, 328, 332, 333, 334, 335, 336, + 342, 3, 28, 78, 240, 3, 5, 74, 111, 151, + 219, 230, 234, 236, 245, 286, 324, 328, 371, 217, + 219, 229, 238, 242, 244, 285, 324, 328, 33, 235, + 235, 230, 236, 135, 235, 230, 235, 230, 75, 109, + 114, 275, 286, 114, 275, 235, 230, 116, 135, 135, + 0, 134, 109, 175, 313, 313, 134, 111, 227, 229, + 369, 273, 273, 131, 229, 109, 151, 310, 320, 324, + 111, 151, 371, 307, 232, 315, 109, 291, 109, 109, 51, 109, 37, 38, 40, 66, 72, 76, 79, 80, 81, 82, 86, 87, 109, 111, 119, 120, 121, 122, - 136, 140, 141, 142, 143, 144, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 165, 168, 226, 276, 292, 366, 371, 228, 110, - 110, 110, 110, 110, 110, 110, 74, 75, 111, 226, - 272, 350, 368, 111, 117, 150, 165, 218, 219, 225, - 228, 232, 233, 237, 240, 241, 243, 262, 263, 267, - 268, 269, 270, 284, 350, 362, 363, 364, 365, 370, - 371, 112, 109, 323, 327, 370, 109, 116, 132, 111, - 114, 150, 165, 278, 278, 115, 134, 116, 132, 109, - 116, 132, 116, 132, 116, 132, 312, 132, 319, 320, - 321, 322, 332, 333, 334, 335, 228, 318, 331, 64, - 311, 111, 312, 349, 350, 312, 312, 174, 134, 109, - 312, 349, 312, 312, 228, 309, 109, 109, 227, 228, - 226, 228, 112, 134, 226, 366, 371, 174, 134, 272, - 277, 218, 233, 323, 327, 174, 134, 294, 228, 237, - 132, 228, 228, 292, 248, 246, 258, 274, 257, 228, - 294, 132, 132, 305, 134, 139, 271, 3, 135, 208, - 209, 223, 225, 228, 134, 311, 109, 311, 165, 319, - 228, 109, 134, 272, 114, 33, 34, 35, 226, 286, - 287, 289, 134, 128, 131, 291, 134, 229, 234, 235, - 272, 315, 316, 317, 109, 141, 109, 149, 109, 149, - 152, 109, 149, 109, 109, 149, 149, 111, 165, 170, - 174, 226, 275, 366, 370, 112, 134, 82, 85, 86, + 136, 140, 141, 142, 143, 144, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 166, 169, 227, 277, 293, 367, 372, 229, 110, + 110, 110, 110, 110, 110, 110, 74, 75, 111, 227, + 273, 351, 369, 111, 117, 151, 166, 219, 220, 226, + 229, 233, 234, 238, 241, 242, 244, 263, 264, 268, + 269, 270, 271, 285, 351, 363, 364, 365, 366, 371, + 372, 112, 109, 324, 328, 371, 109, 116, 132, 111, + 114, 151, 166, 279, 279, 115, 134, 116, 132, 109, + 116, 132, 116, 132, 116, 132, 313, 132, 320, 321, + 322, 323, 333, 334, 335, 336, 229, 319, 332, 64, + 312, 111, 313, 350, 351, 313, 313, 175, 134, 109, + 313, 350, 313, 313, 229, 310, 109, 109, 228, 229, + 227, 229, 112, 134, 227, 367, 372, 175, 134, 273, + 278, 219, 234, 324, 328, 175, 134, 295, 229, 238, + 132, 229, 229, 293, 249, 247, 259, 275, 258, 229, + 295, 132, 132, 306, 134, 139, 272, 3, 135, 209, + 210, 224, 226, 229, 134, 312, 109, 312, 166, 320, + 229, 109, 134, 273, 114, 33, 34, 35, 227, 287, + 288, 290, 134, 128, 131, 292, 134, 230, 235, 236, + 273, 316, 317, 318, 109, 141, 109, 150, 109, 150, + 153, 109, 150, 109, 109, 150, 150, 111, 166, 171, + 175, 227, 276, 367, 371, 112, 134, 82, 85, 86, 87, 109, 111, 113, 114, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 131, 167, 152, 152, + 102, 103, 104, 105, 106, 107, 131, 168, 153, 153, 117, 123, 124, 119, 120, 88, 89, 90, 91, 125, 126, 92, 93, 118, 127, 128, 94, 95, 129, 131, - 373, 109, 150, 345, 346, 347, 348, 349, 110, 116, - 109, 349, 350, 109, 349, 350, 134, 109, 226, 368, - 112, 134, 135, 111, 226, 228, 361, 362, 370, 371, - 135, 109, 111, 150, 319, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 350, 351, 352, 353, 354, 355, - 356, 150, 370, 228, 135, 135, 150, 226, 228, 363, - 272, 226, 350, 363, 272, 109, 134, 134, 134, 112, - 134, 72, 111, 113, 140, 274, 278, 279, 280, 281, - 282, 134, 134, 134, 134, 134, 134, 309, 110, 110, - 110, 110, 110, 110, 110, 318, 331, 109, 277, 112, - 208, 134, 309, 170, 276, 170, 276, 309, 111, 208, - 311, 174, 134, 208, 110, 40, 111, 115, 226, 249, - 250, 251, 366, 114, 116, 372, 131, 259, 114, 228, - 264, 265, 266, 269, 270, 110, 116, 174, 134, 117, - 165, 134, 225, 228, 263, 362, 370, 303, 304, 109, - 150, 336, 110, 116, 373, 274, 286, 109, 114, 274, - 276, 286, 110, 116, 109, 141, 110, 130, 275, 275, - 275, 146, 165, 276, 275, 112, 134, 110, 116, 110, - 109, 150, 349, 357, 358, 359, 360, 110, 116, 165, - 111, 139, 145, 146, 134, 111, 139, 145, 165, 152, - 152, 152, 153, 153, 154, 154, 155, 155, 155, 155, - 156, 156, 157, 158, 159, 160, 161, 130, 170, 165, - 134, 346, 347, 348, 228, 345, 312, 312, 165, 276, - 134, 271, 134, 226, 350, 363, 228, 232, 112, 112, - 134, 370, 112, 109, 134, 319, 337, 338, 339, 342, - 352, 353, 354, 112, 134, 228, 336, 340, 351, 109, - 312, 355, 373, 312, 312, 373, 109, 312, 355, 312, - 312, 312, 312, 350, 226, 361, 371, 272, 112, 116, - 112, 116, 373, 226, 363, 373, 260, 261, 262, 263, - 260, 260, 272, 165, 134, 111, 274, 130, 116, 372, - 278, 111, 130, 282, 29, 210, 211, 272, 260, 139, - 309, 139, 311, 109, 349, 350, 109, 349, 350, 142, - 350, 174, 264, 110, 110, 110, 110, 112, 174, 208, - 174, 114, 250, 251, 112, 134, 109, 130, 150, 252, - 254, 318, 319, 331, 357, 116, 132, 116, 132, 274, - 248, 274, 115, 163, 164, 258, 135, 135, 139, 223, - 135, 135, 260, 109, 150, 370, 135, 115, 228, 287, - 288, 135, 134, 134, 109, 135, 110, 316, 170, 171, - 130, 132, 111, 141, 201, 202, 203, 110, 116, 110, - 110, 110, 110, 111, 165, 358, 359, 360, 228, 357, - 312, 312, 114, 152, 168, 165, 166, 169, 116, 135, - 134, 110, 116, 165, 134, 115, 163, 130, 264, 110, - 110, 110, 345, 264, 110, 260, 226, 363, 111, 117, - 150, 165, 165, 228, 342, 264, 110, 110, 110, 110, - 110, 110, 110, 7, 228, 336, 340, 351, 134, 134, - 373, 134, 134, 110, 135, 135, 135, 135, 277, 135, - 163, 164, 165, 310, 134, 278, 280, 115, 134, 212, - 274, 40, 41, 43, 46, 47, 48, 49, 50, 51, - 52, 53, 57, 61, 62, 72, 111, 127, 171, 172, - 173, 174, 175, 176, 178, 179, 191, 193, 194, 199, - 213, 308, 29, 135, 131, 277, 134, 134, 110, 135, - 174, 248, 132, 132, 319, 164, 228, 253, 254, 253, - 274, 312, 115, 259, 372, 110, 116, 112, 112, 135, - 228, 116, 373, 290, 110, 286, 216, 218, 226, 298, - 299, 300, 301, 292, 110, 110, 130, 164, 109, 110, - 130, 116, 139, 112, 110, 110, 110, 357, 279, 116, - 135, 169, 112, 139, 147, 148, 146, 135, 147, 163, - 168, 135, 109, 349, 350, 135, 135, 134, 135, 135, - 135, 165, 110, 135, 109, 349, 350, 109, 355, 109, - 355, 350, 227, 7, 117, 135, 165, 264, 264, 263, - 267, 267, 268, 116, 116, 110, 110, 112, 96, 122, - 135, 135, 147, 278, 165, 116, 132, 213, 217, 228, - 232, 109, 109, 172, 109, 109, 72, 132, 72, 132, - 72, 117, 171, 109, 174, 166, 166, 130, 112, 144, - 132, 135, 134, 135, 212, 110, 165, 264, 264, 312, - 110, 115, 252, 115, 134, 110, 134, 135, 309, 115, - 134, 135, 135, 110, 114, 201, 112, 164, 132, 201, - 203, 110, 109, 349, 350, 372, 166, 112, 135, 85, - 113, 116, 135, 112, 135, 110, 134, 110, 110, 112, - 112, 112, 135, 110, 134, 134, 134, 165, 165, 135, - 112, 135, 135, 135, 135, 134, 134, 164, 164, 112, - 112, 135, 135, 274, 228, 170, 170, 47, 170, 134, - 132, 132, 132, 170, 132, 170, 58, 59, 60, 195, - 196, 197, 132, 63, 132, 312, 114, 176, 115, 132, - 135, 135, 96, 269, 270, 110, 299, 116, 132, 116, - 132, 115, 297, 130, 141, 110, 110, 130, 134, 115, - 112, 111, 148, 111, 148, 148, 112, 112, 264, 112, - 264, 264, 264, 135, 135, 112, 112, 110, 110, 112, - 116, 96, 263, 96, 135, 112, 112, 110, 110, 109, - 110, 171, 192, 213, 132, 110, 109, 109, 174, 197, - 58, 59, 165, 172, 145, 110, 110, 114, 134, 134, - 298, 141, 204, 109, 132, 204, 264, 134, 134, 135, - 135, 135, 135, 112, 112, 134, 135, 112, 172, 44, - 45, 114, 182, 183, 184, 170, 172, 135, 110, 171, - 114, 184, 96, 134, 96, 134, 109, 109, 132, 115, - 134, 272, 309, 115, 116, 130, 164, 110, 135, 147, - 147, 110, 110, 110, 110, 267, 42, 164, 180, 181, - 310, 130, 134, 172, 182, 110, 132, 172, 132, 134, - 110, 134, 110, 134, 96, 134, 96, 134, 132, 298, - 141, 139, 205, 110, 132, 110, 135, 135, 172, 96, - 116, 130, 135, 206, 207, 213, 132, 171, 171, 206, - 174, 198, 226, 366, 174, 198, 110, 134, 110, 134, - 115, 110, 116, 112, 112, 164, 180, 183, 185, 186, - 134, 132, 183, 187, 188, 135, 109, 150, 309, 357, - 139, 135, 174, 198, 174, 198, 109, 132, 139, 172, - 177, 115, 183, 213, 171, 56, 177, 190, 115, 183, - 110, 228, 110, 135, 135, 292, 172, 177, 132, 189, - 190, 177, 190, 174, 174, 110, 110, 110, 189, 135, - 135, 174, 174, 135, 135 + 374, 109, 151, 346, 347, 348, 349, 350, 110, 116, + 109, 350, 351, 109, 350, 351, 134, 109, 227, 369, + 112, 134, 135, 111, 227, 229, 362, 363, 371, 372, + 135, 109, 111, 151, 320, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 351, 352, 353, 354, 355, 356, + 357, 151, 371, 229, 135, 135, 151, 227, 229, 364, + 273, 227, 351, 364, 273, 109, 134, 134, 134, 112, + 134, 72, 111, 113, 140, 275, 279, 280, 281, 282, + 283, 134, 134, 134, 134, 134, 134, 310, 110, 110, + 110, 110, 110, 110, 110, 319, 332, 109, 278, 112, + 209, 134, 310, 171, 277, 171, 277, 310, 111, 209, + 312, 175, 134, 209, 110, 40, 111, 115, 227, 250, + 251, 252, 367, 114, 116, 373, 131, 260, 114, 229, + 265, 266, 267, 270, 271, 110, 116, 175, 134, 117, + 166, 134, 226, 229, 264, 363, 371, 304, 305, 109, + 151, 337, 110, 116, 374, 275, 287, 109, 114, 275, + 277, 287, 110, 116, 109, 141, 110, 130, 276, 276, + 276, 146, 166, 277, 276, 112, 134, 110, 116, 110, + 109, 151, 350, 358, 359, 360, 361, 110, 116, 166, + 111, 139, 145, 146, 134, 79, 111, 139, 145, 166, + 153, 153, 153, 154, 154, 155, 155, 156, 156, 156, + 156, 157, 157, 158, 159, 160, 161, 162, 130, 171, + 166, 134, 347, 348, 349, 229, 346, 313, 313, 166, + 277, 134, 272, 134, 227, 351, 364, 229, 233, 112, + 112, 134, 371, 112, 109, 134, 320, 338, 339, 340, + 343, 353, 354, 355, 112, 134, 229, 337, 341, 352, + 109, 313, 356, 374, 313, 313, 374, 109, 313, 356, + 313, 313, 313, 313, 351, 227, 362, 372, 273, 112, + 116, 112, 116, 374, 227, 364, 374, 261, 262, 263, + 264, 261, 261, 273, 166, 134, 111, 275, 130, 116, + 373, 279, 111, 130, 283, 29, 211, 212, 273, 261, + 139, 310, 139, 312, 109, 350, 351, 109, 350, 351, + 142, 351, 175, 265, 110, 110, 110, 110, 112, 175, + 209, 175, 114, 251, 252, 112, 134, 109, 130, 151, + 253, 255, 319, 320, 332, 358, 116, 132, 116, 132, + 275, 249, 275, 115, 164, 165, 259, 135, 135, 139, + 224, 135, 135, 261, 109, 151, 371, 135, 115, 229, + 288, 289, 135, 134, 134, 109, 135, 110, 317, 171, + 172, 130, 132, 111, 141, 202, 203, 204, 110, 116, + 110, 110, 110, 110, 111, 166, 359, 360, 361, 229, + 358, 313, 313, 114, 153, 169, 166, 167, 170, 116, + 135, 134, 110, 116, 166, 134, 115, 164, 130, 265, + 110, 110, 110, 346, 265, 110, 261, 227, 364, 111, + 117, 151, 166, 166, 229, 343, 265, 110, 110, 110, + 110, 110, 110, 110, 7, 229, 337, 341, 352, 134, + 134, 374, 134, 134, 110, 135, 135, 135, 135, 278, + 135, 164, 165, 166, 311, 134, 279, 281, 115, 134, + 213, 275, 40, 41, 43, 46, 47, 48, 49, 50, + 51, 52, 53, 57, 61, 62, 72, 111, 127, 172, + 173, 174, 175, 176, 177, 179, 180, 192, 194, 195, + 200, 214, 309, 29, 135, 131, 278, 134, 134, 110, + 135, 175, 249, 132, 132, 320, 165, 229, 254, 255, + 254, 275, 313, 115, 260, 373, 110, 116, 112, 112, + 135, 229, 116, 374, 291, 110, 287, 217, 219, 227, + 299, 300, 301, 302, 293, 110, 110, 130, 165, 109, + 110, 130, 116, 139, 112, 110, 110, 110, 358, 280, + 116, 135, 170, 112, 79, 139, 147, 148, 149, 146, + 135, 147, 164, 169, 135, 109, 350, 351, 135, 135, + 134, 135, 135, 135, 166, 110, 135, 109, 350, 351, + 109, 356, 109, 356, 351, 228, 7, 117, 135, 166, + 265, 265, 264, 268, 268, 269, 116, 116, 110, 110, + 112, 96, 122, 135, 135, 147, 279, 166, 116, 132, + 214, 218, 229, 233, 109, 109, 173, 109, 109, 72, + 132, 72, 132, 72, 117, 172, 109, 175, 167, 167, + 130, 112, 144, 132, 135, 134, 135, 213, 110, 166, + 265, 265, 313, 110, 115, 253, 115, 134, 110, 134, + 135, 310, 115, 134, 135, 135, 110, 114, 202, 112, + 165, 132, 202, 204, 110, 109, 350, 351, 373, 167, + 112, 135, 116, 135, 85, 113, 112, 135, 110, 134, + 110, 110, 112, 112, 112, 135, 110, 134, 134, 134, + 166, 166, 135, 112, 135, 135, 135, 135, 134, 134, + 165, 165, 112, 112, 135, 135, 275, 229, 171, 171, + 47, 171, 134, 132, 132, 132, 171, 132, 171, 58, + 59, 60, 196, 197, 198, 132, 63, 132, 313, 114, + 177, 115, 132, 135, 135, 96, 270, 271, 110, 300, + 116, 132, 116, 132, 115, 298, 130, 141, 110, 110, + 130, 134, 115, 112, 148, 112, 111, 148, 111, 148, + 112, 265, 112, 265, 265, 265, 135, 135, 112, 112, + 110, 110, 112, 116, 96, 264, 96, 135, 112, 112, + 110, 110, 109, 110, 172, 193, 214, 132, 110, 109, + 109, 175, 198, 58, 59, 166, 173, 145, 110, 110, + 114, 134, 134, 299, 141, 205, 109, 132, 205, 265, + 134, 134, 135, 135, 135, 135, 112, 112, 134, 135, + 112, 173, 44, 45, 114, 183, 184, 185, 171, 173, + 135, 110, 172, 114, 185, 96, 134, 96, 134, 109, + 109, 132, 115, 134, 273, 310, 115, 116, 130, 165, + 110, 135, 147, 147, 110, 110, 110, 110, 268, 42, + 165, 181, 182, 311, 130, 134, 173, 183, 110, 132, + 173, 132, 134, 110, 134, 110, 134, 96, 134, 96, + 134, 132, 299, 141, 139, 206, 110, 132, 110, 135, + 135, 173, 96, 116, 130, 135, 207, 208, 214, 132, + 172, 172, 207, 175, 199, 227, 367, 175, 199, 110, + 134, 110, 134, 115, 110, 116, 112, 112, 165, 181, + 184, 186, 187, 134, 132, 184, 188, 189, 135, 109, + 151, 310, 358, 139, 135, 175, 199, 175, 199, 109, + 132, 139, 173, 178, 115, 184, 214, 172, 56, 178, + 191, 115, 184, 110, 229, 110, 135, 135, 293, 173, + 178, 132, 190, 191, 178, 191, 175, 175, 110, 110, + 110, 190, 135, 135, 175, 175, 135, 135 }; @@ -4971,5 +4977,5 @@ /* Line 1806 of yacc.c */ -#line 300 "parser.yy" +#line 302 "parser.yy" { typedefTable.enterScope(); } break; @@ -4978,5 +4984,5 @@ /* Line 1806 of yacc.c */ -#line 304 "parser.yy" +#line 306 "parser.yy" { typedefTable.leaveScope(); } break; @@ -4985,5 +4991,5 @@ /* Line 1806 of yacc.c */ -#line 311 "parser.yy" +#line 313 "parser.yy" { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); } break; @@ -4992,5 +4998,5 @@ /* Line 1806 of yacc.c */ -#line 312 "parser.yy" +#line 314 "parser.yy" { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); } break; @@ -4999,5 +5005,5 @@ /* Line 1806 of yacc.c */ -#line 313 "parser.yy" +#line 315 "parser.yy" { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); } break; @@ -5006,5 +5012,5 @@ /* Line 1806 of yacc.c */ -#line 338 "parser.yy" +#line 340 "parser.yy" { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].str) ); } break; @@ -5013,5 +5019,5 @@ /* Line 1806 of yacc.c */ -#line 342 "parser.yy" +#line 344 "parser.yy" { (yyval.str) = (yyvsp[(1) - (1)].tok); } break; @@ -5020,5 +5026,5 @@ /* Line 1806 of yacc.c */ -#line 344 "parser.yy" +#line 346 "parser.yy" { appendStr( (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].tok) ); // append 2nd juxtaposed string to 1st @@ -5031,19 +5037,19 @@ /* Line 1806 of yacc.c */ -#line 355 "parser.yy" - { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); } - break; - - case 20: - -/* Line 1806 of yacc.c */ #line 357 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); } break; + case 20: + +/* Line 1806 of yacc.c */ +#line 359 "parser.yy" + { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); } + break; + case 21: /* Line 1806 of yacc.c */ -#line 359 "parser.yy" +#line 361 "parser.yy" { (yyval.en) = (yyvsp[(2) - (3)].en); } break; @@ -5052,5 +5058,5 @@ /* Line 1806 of yacc.c */ -#line 361 "parser.yy" +#line 363 "parser.yy" { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); } break; @@ -5059,5 +5065,5 @@ /* Line 1806 of yacc.c */ -#line 371 "parser.yy" +#line 373 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); } break; @@ -5066,5 +5072,5 @@ /* Line 1806 of yacc.c */ -#line 373 "parser.yy" +#line 375 "parser.yy" { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); } break; @@ -5073,5 +5079,5 @@ /* Line 1806 of yacc.c */ -#line 377 "parser.yy" +#line 379 "parser.yy" { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); } break; @@ -5080,5 +5086,5 @@ /* Line 1806 of yacc.c */ -#line 379 "parser.yy" +#line 381 "parser.yy" { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); } break; @@ -5087,128 +5093,135 @@ /* Line 1806 of yacc.c */ -#line 381 "parser.yy" +#line 383 "parser.yy" + { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_constantInteger( *(yyvsp[(3) - (3)].tok) ) ) ); } + break; + + case 29: + +/* Line 1806 of yacc.c */ +#line 385 "parser.yy" { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); } break; - case 29: - -/* Line 1806 of yacc.c */ -#line 383 "parser.yy" + case 30: + +/* Line 1806 of yacc.c */ +#line 387 "parser.yy" { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); } break; - case 30: - -/* Line 1806 of yacc.c */ -#line 385 "parser.yy" + case 31: + +/* Line 1806 of yacc.c */ +#line 389 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); } break; - case 31: - -/* Line 1806 of yacc.c */ -#line 387 "parser.yy" + case 32: + +/* Line 1806 of yacc.c */ +#line 391 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); } break; - case 32: - -/* Line 1806 of yacc.c */ -#line 389 "parser.yy" + case 33: + +/* Line 1806 of yacc.c */ +#line 393 "parser.yy" { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); } break; - case 33: - -/* Line 1806 of yacc.c */ -#line 391 "parser.yy" + case 34: + +/* Line 1806 of yacc.c */ +#line 395 "parser.yy" { Token fn; - fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? + fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? (yyval.en) = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) ) ); } break; - case 35: - -/* Line 1806 of yacc.c */ -#line 401 "parser.yy" + case 36: + +/* Line 1806 of yacc.c */ +#line 405 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); } break; - case 36: - -/* Line 1806 of yacc.c */ -#line 406 "parser.yy" + case 37: + +/* Line 1806 of yacc.c */ +#line 410 "parser.yy" { (yyval.en) = 0; } break; - case 39: - -/* Line 1806 of yacc.c */ -#line 412 "parser.yy" + case 40: + +/* Line 1806 of yacc.c */ +#line 416 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } break; - case 40: - -/* Line 1806 of yacc.c */ -#line 417 "parser.yy" + case 41: + +/* Line 1806 of yacc.c */ +#line 423 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); } break; - case 41: - -/* Line 1806 of yacc.c */ -#line 421 "parser.yy" + case 42: + +/* Line 1806 of yacc.c */ +#line 425 "parser.yy" { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); } break; - case 42: - -/* Line 1806 of yacc.c */ -#line 423 "parser.yy" + case 43: + +/* Line 1806 of yacc.c */ +#line 427 "parser.yy" { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); } break; - case 43: - -/* Line 1806 of yacc.c */ -#line 425 "parser.yy" + case 44: + +/* Line 1806 of yacc.c */ +#line 429 "parser.yy" { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); } break; - case 44: - -/* Line 1806 of yacc.c */ -#line 427 "parser.yy" + case 45: + +/* Line 1806 of yacc.c */ +#line 431 "parser.yy" { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); } break; - case 46: - -/* Line 1806 of yacc.c */ -#line 435 "parser.yy" + case 49: + +/* Line 1806 of yacc.c */ +#line 444 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; - case 47: - -/* Line 1806 of yacc.c */ -#line 437 "parser.yy" + case 50: + +/* Line 1806 of yacc.c */ +#line 446 "parser.yy" { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); } break; - case 48: - -/* Line 1806 of yacc.c */ -#line 439 "parser.yy" + case 51: + +/* Line 1806 of yacc.c */ +#line 448 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); } break; - case 49: - -/* Line 1806 of yacc.c */ -#line 444 "parser.yy" + case 52: + +/* Line 1806 of yacc.c */ +#line 453 "parser.yy" { switch ( (yyvsp[(1) - (2)].op) ) { @@ -5225,460 +5238,460 @@ break; - case 50: - -/* Line 1806 of yacc.c */ -#line 457 "parser.yy" + case 53: + +/* Line 1806 of yacc.c */ +#line 466 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); } break; - case 51: - -/* Line 1806 of yacc.c */ -#line 459 "parser.yy" + case 54: + +/* Line 1806 of yacc.c */ +#line 468 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); } break; - case 52: - -/* Line 1806 of yacc.c */ -#line 461 "parser.yy" + case 55: + +/* Line 1806 of yacc.c */ +#line 470 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); } break; - case 53: - -/* Line 1806 of yacc.c */ -#line 463 "parser.yy" + case 56: + +/* Line 1806 of yacc.c */ +#line 472 "parser.yy" { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); } break; - case 54: - -/* Line 1806 of yacc.c */ -#line 465 "parser.yy" + case 57: + +/* Line 1806 of yacc.c */ +#line 474 "parser.yy" { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); } break; - case 55: - -/* Line 1806 of yacc.c */ -#line 467 "parser.yy" + case 58: + +/* Line 1806 of yacc.c */ +#line 476 "parser.yy" { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); } break; - case 56: - -/* Line 1806 of yacc.c */ -#line 469 "parser.yy" + case 59: + +/* Line 1806 of yacc.c */ +#line 478 "parser.yy" { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); } break; - case 57: - -/* Line 1806 of yacc.c */ -#line 471 "parser.yy" + case 60: + +/* Line 1806 of yacc.c */ +#line 480 "parser.yy" { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); } break; - case 58: - -/* Line 1806 of yacc.c */ -#line 473 "parser.yy" + case 61: + +/* Line 1806 of yacc.c */ +#line 482 "parser.yy" { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); } break; - case 59: - -/* Line 1806 of yacc.c */ -#line 475 "parser.yy" + case 62: + +/* Line 1806 of yacc.c */ +#line 484 "parser.yy" { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); } break; - case 60: - -/* Line 1806 of yacc.c */ -#line 477 "parser.yy" + case 63: + +/* Line 1806 of yacc.c */ +#line 486 "parser.yy" { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); } break; - case 61: - -/* Line 1806 of yacc.c */ -#line 483 "parser.yy" + case 64: + +/* Line 1806 of yacc.c */ +#line 492 "parser.yy" { (yyval.op) = OperKinds::PointTo; } break; - case 62: - -/* Line 1806 of yacc.c */ -#line 484 "parser.yy" + case 65: + +/* Line 1806 of yacc.c */ +#line 493 "parser.yy" { (yyval.op) = OperKinds::AddressOf; } break; - case 63: - -/* Line 1806 of yacc.c */ -#line 490 "parser.yy" + case 66: + +/* Line 1806 of yacc.c */ +#line 499 "parser.yy" { (yyval.op) = OperKinds::UnPlus; } break; - case 64: - -/* Line 1806 of yacc.c */ -#line 491 "parser.yy" + case 67: + +/* Line 1806 of yacc.c */ +#line 500 "parser.yy" { (yyval.op) = OperKinds::UnMinus; } break; - case 65: - -/* Line 1806 of yacc.c */ -#line 492 "parser.yy" + case 68: + +/* Line 1806 of yacc.c */ +#line 501 "parser.yy" { (yyval.op) = OperKinds::Neg; } break; - case 66: - -/* Line 1806 of yacc.c */ -#line 493 "parser.yy" + case 69: + +/* Line 1806 of yacc.c */ +#line 502 "parser.yy" { (yyval.op) = OperKinds::BitNeg; } break; - case 68: - -/* Line 1806 of yacc.c */ -#line 499 "parser.yy" + case 71: + +/* Line 1806 of yacc.c */ +#line 508 "parser.yy" { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); } break; - case 69: - -/* Line 1806 of yacc.c */ -#line 501 "parser.yy" + case 72: + +/* Line 1806 of yacc.c */ +#line 510 "parser.yy" { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); } break; - case 71: - -/* Line 1806 of yacc.c */ -#line 507 "parser.yy" + case 74: + +/* Line 1806 of yacc.c */ +#line 516 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 72: - -/* Line 1806 of yacc.c */ -#line 509 "parser.yy" + case 75: + +/* Line 1806 of yacc.c */ +#line 518 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 73: - -/* Line 1806 of yacc.c */ -#line 511 "parser.yy" + case 76: + +/* Line 1806 of yacc.c */ +#line 520 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 75: - -/* Line 1806 of yacc.c */ -#line 517 "parser.yy" + case 78: + +/* Line 1806 of yacc.c */ +#line 526 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 76: - -/* Line 1806 of yacc.c */ -#line 519 "parser.yy" + case 79: + +/* Line 1806 of yacc.c */ +#line 528 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 78: - -/* Line 1806 of yacc.c */ -#line 525 "parser.yy" + case 81: + +/* Line 1806 of yacc.c */ +#line 534 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 79: - -/* Line 1806 of yacc.c */ -#line 527 "parser.yy" + case 82: + +/* Line 1806 of yacc.c */ +#line 536 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 81: - -/* Line 1806 of yacc.c */ -#line 533 "parser.yy" + case 84: + +/* Line 1806 of yacc.c */ +#line 542 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 82: - -/* Line 1806 of yacc.c */ -#line 535 "parser.yy" + case 85: + +/* Line 1806 of yacc.c */ +#line 544 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 83: - -/* Line 1806 of yacc.c */ -#line 537 "parser.yy" + case 86: + +/* Line 1806 of yacc.c */ +#line 546 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 84: - -/* Line 1806 of yacc.c */ -#line 539 "parser.yy" + case 87: + +/* Line 1806 of yacc.c */ +#line 548 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 86: - -/* Line 1806 of yacc.c */ -#line 545 "parser.yy" + case 89: + +/* Line 1806 of yacc.c */ +#line 554 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 87: - -/* Line 1806 of yacc.c */ -#line 547 "parser.yy" + case 90: + +/* Line 1806 of yacc.c */ +#line 556 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 89: - -/* Line 1806 of yacc.c */ -#line 553 "parser.yy" + case 92: + +/* Line 1806 of yacc.c */ +#line 562 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 91: - -/* Line 1806 of yacc.c */ -#line 559 "parser.yy" + case 94: + +/* Line 1806 of yacc.c */ +#line 568 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 93: - -/* Line 1806 of yacc.c */ -#line 565 "parser.yy" + case 96: + +/* Line 1806 of yacc.c */ +#line 574 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 95: - -/* Line 1806 of yacc.c */ -#line 571 "parser.yy" + case 98: + +/* Line 1806 of yacc.c */ +#line 580 "parser.yy" { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); } break; - case 97: - -/* Line 1806 of yacc.c */ -#line 577 "parser.yy" + case 100: + +/* Line 1806 of yacc.c */ +#line 586 "parser.yy" { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); } break; - case 99: - -/* Line 1806 of yacc.c */ -#line 583 "parser.yy" + case 102: + +/* Line 1806 of yacc.c */ +#line 592 "parser.yy" { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); } break; - case 100: - -/* Line 1806 of yacc.c */ -#line 586 "parser.yy" + case 103: + +/* Line 1806 of yacc.c */ +#line 595 "parser.yy" { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); } break; - case 101: - -/* Line 1806 of yacc.c */ -#line 588 "parser.yy" + case 104: + +/* Line 1806 of yacc.c */ +#line 597 "parser.yy" { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); } break; - case 104: - -/* Line 1806 of yacc.c */ -#line 599 "parser.yy" + case 107: + +/* Line 1806 of yacc.c */ +#line 608 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 105: - -/* Line 1806 of yacc.c */ -#line 601 "parser.yy" + case 108: + +/* Line 1806 of yacc.c */ +#line 610 "parser.yy" { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new ExpressionNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); } break; - case 106: - -/* Line 1806 of yacc.c */ -#line 606 "parser.yy" + case 109: + +/* Line 1806 of yacc.c */ +#line 615 "parser.yy" { (yyval.en) = nullptr; } break; - case 108: - -/* Line 1806 of yacc.c */ -#line 611 "parser.yy" + case 111: + +/* Line 1806 of yacc.c */ +#line 620 "parser.yy" { (yyval.op) = OperKinds::Assign; } break; - case 109: - -/* Line 1806 of yacc.c */ -#line 612 "parser.yy" + case 112: + +/* Line 1806 of yacc.c */ +#line 621 "parser.yy" { (yyval.op) = OperKinds::AtAssn; } break; - case 110: - -/* Line 1806 of yacc.c */ -#line 613 "parser.yy" + case 113: + +/* Line 1806 of yacc.c */ +#line 622 "parser.yy" { (yyval.op) = OperKinds::MulAssn; } break; - case 111: - -/* Line 1806 of yacc.c */ -#line 614 "parser.yy" + case 114: + +/* Line 1806 of yacc.c */ +#line 623 "parser.yy" { (yyval.op) = OperKinds::DivAssn; } break; - case 112: - -/* Line 1806 of yacc.c */ -#line 615 "parser.yy" + case 115: + +/* Line 1806 of yacc.c */ +#line 624 "parser.yy" { (yyval.op) = OperKinds::ModAssn; } break; - case 113: - -/* Line 1806 of yacc.c */ -#line 616 "parser.yy" + case 116: + +/* Line 1806 of yacc.c */ +#line 625 "parser.yy" { (yyval.op) = OperKinds::PlusAssn; } break; - case 114: - -/* Line 1806 of yacc.c */ -#line 617 "parser.yy" + case 117: + +/* Line 1806 of yacc.c */ +#line 626 "parser.yy" { (yyval.op) = OperKinds::MinusAssn; } break; - case 115: - -/* Line 1806 of yacc.c */ -#line 618 "parser.yy" + case 118: + +/* Line 1806 of yacc.c */ +#line 627 "parser.yy" { (yyval.op) = OperKinds::LSAssn; } break; - case 116: - -/* Line 1806 of yacc.c */ -#line 619 "parser.yy" + case 119: + +/* Line 1806 of yacc.c */ +#line 628 "parser.yy" { (yyval.op) = OperKinds::RSAssn; } break; - case 117: - -/* Line 1806 of yacc.c */ -#line 620 "parser.yy" + case 120: + +/* Line 1806 of yacc.c */ +#line 629 "parser.yy" { (yyval.op) = OperKinds::AndAssn; } break; - case 118: - -/* Line 1806 of yacc.c */ -#line 621 "parser.yy" + case 121: + +/* Line 1806 of yacc.c */ +#line 630 "parser.yy" { (yyval.op) = OperKinds::ERAssn; } break; - case 119: - -/* Line 1806 of yacc.c */ -#line 622 "parser.yy" + case 122: + +/* Line 1806 of yacc.c */ +#line 631 "parser.yy" { (yyval.op) = OperKinds::OrAssn; } break; - case 120: - -/* Line 1806 of yacc.c */ -#line 629 "parser.yy" + case 123: + +/* Line 1806 of yacc.c */ +#line 638 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple() ); } break; - case 121: - -/* Line 1806 of yacc.c */ -#line 631 "parser.yy" + case 124: + +/* Line 1806 of yacc.c */ +#line 640 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); } break; - case 122: - -/* Line 1806 of yacc.c */ -#line 633 "parser.yy" + case 125: + +/* Line 1806 of yacc.c */ +#line 642 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); } break; - case 123: - -/* Line 1806 of yacc.c */ -#line 635 "parser.yy" + case 126: + +/* Line 1806 of yacc.c */ +#line 644 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); } break; - case 125: - -/* Line 1806 of yacc.c */ -#line 641 "parser.yy" + case 128: + +/* Line 1806 of yacc.c */ +#line 650 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } break; - case 127: - -/* Line 1806 of yacc.c */ -#line 647 "parser.yy" + case 130: + +/* Line 1806 of yacc.c */ +#line 656 "parser.yy" { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 128: - -/* Line 1806 of yacc.c */ -#line 652 "parser.yy" + case 131: + +/* Line 1806 of yacc.c */ +#line 661 "parser.yy" { (yyval.en) = 0; } break; - case 132: - -/* Line 1806 of yacc.c */ -#line 661 "parser.yy" + case 135: + +/* Line 1806 of yacc.c */ +#line 670 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (1)].sn); } break; - case 138: - -/* Line 1806 of yacc.c */ -#line 668 "parser.yy" + case 141: + +/* Line 1806 of yacc.c */ +#line 677 "parser.yy" { Token fn; - fn.str = new std::string( "^?{}" ); // location undefined + fn.str = new string( "^?{}" ); // location undefined (yyval.sn) = new StatementNode( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_last( (yyvsp[(4) - (6)].en) ) ) ) ) ); } break; - case 139: - -/* Line 1806 of yacc.c */ -#line 678 "parser.yy" + case 142: + +/* Line 1806 of yacc.c */ +#line 687 "parser.yy" { (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) ); @@ -5686,36 +5699,36 @@ break; - case 140: - -/* Line 1806 of yacc.c */ -#line 685 "parser.yy" + case 143: + +/* Line 1806 of yacc.c */ +#line 694 "parser.yy" { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); } break; - case 141: - -/* Line 1806 of yacc.c */ -#line 692 "parser.yy" + case 144: + +/* Line 1806 of yacc.c */ +#line 701 "parser.yy" { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); } break; - case 143: - -/* Line 1806 of yacc.c */ -#line 698 "parser.yy" + case 146: + +/* Line 1806 of yacc.c */ +#line 707 "parser.yy" { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } } break; - case 144: - -/* Line 1806 of yacc.c */ -#line 703 "parser.yy" + case 147: + +/* Line 1806 of yacc.c */ +#line 712 "parser.yy" { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } break; - case 145: - -/* Line 1806 of yacc.c */ -#line 705 "parser.yy" + case 148: + +/* Line 1806 of yacc.c */ +#line 714 "parser.yy" { // mark all fields in list for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) @@ -5725,50 +5738,50 @@ break; - case 146: - -/* Line 1806 of yacc.c */ -#line 711 "parser.yy" + case 149: + +/* Line 1806 of yacc.c */ +#line 720 "parser.yy" { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } break; - case 149: - -/* Line 1806 of yacc.c */ -#line 718 "parser.yy" + case 152: + +/* Line 1806 of yacc.c */ +#line 727 "parser.yy" { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } } break; - case 150: - -/* Line 1806 of yacc.c */ -#line 723 "parser.yy" + case 153: + +/* Line 1806 of yacc.c */ +#line 732 "parser.yy" { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); } break; - case 151: - -/* Line 1806 of yacc.c */ -#line 729 "parser.yy" + case 154: + +/* Line 1806 of yacc.c */ +#line 738 "parser.yy" { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); } break; - case 152: - -/* Line 1806 of yacc.c */ -#line 731 "parser.yy" + case 155: + +/* Line 1806 of yacc.c */ +#line 740 "parser.yy" { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); } break; - case 153: - -/* Line 1806 of yacc.c */ -#line 733 "parser.yy" + case 156: + +/* Line 1806 of yacc.c */ +#line 742 "parser.yy" { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } break; - case 154: - -/* Line 1806 of yacc.c */ -#line 735 "parser.yy" + case 157: + +/* Line 1806 of yacc.c */ +#line 744 "parser.yy" { StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) ); @@ -5782,15 +5795,15 @@ break; - case 155: - -/* Line 1806 of yacc.c */ -#line 745 "parser.yy" + case 158: + +/* Line 1806 of yacc.c */ +#line 754 "parser.yy" { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } break; - case 156: - -/* Line 1806 of yacc.c */ -#line 747 "parser.yy" + case 159: + +/* Line 1806 of yacc.c */ +#line 756 "parser.yy" { StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) ); @@ -5799,323 +5812,323 @@ break; - case 157: - -/* Line 1806 of yacc.c */ -#line 757 "parser.yy" + case 160: + +/* Line 1806 of yacc.c */ +#line 766 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; - case 158: - -/* Line 1806 of yacc.c */ -#line 759 "parser.yy" + case 161: + +/* Line 1806 of yacc.c */ +#line 768 "parser.yy" { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 160: - -/* Line 1806 of yacc.c */ -#line 764 "parser.yy" + case 163: + +/* Line 1806 of yacc.c */ +#line 773 "parser.yy" { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); } break; - case 161: - -/* Line 1806 of yacc.c */ -#line 766 "parser.yy" + case 164: + +/* Line 1806 of yacc.c */ +#line 775 "parser.yy" { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); } break; - case 162: - -/* Line 1806 of yacc.c */ -#line 770 "parser.yy" + case 165: + +/* Line 1806 of yacc.c */ +#line 779 "parser.yy" { (yyval.sn) = (yyvsp[(2) - (3)].sn); } break; - case 163: - -/* Line 1806 of yacc.c */ -#line 771 "parser.yy" + case 166: + +/* Line 1806 of yacc.c */ +#line 780 "parser.yy" { (yyval.sn) = new StatementNode( build_default() ); } break; - case 165: - -/* Line 1806 of yacc.c */ -#line 777 "parser.yy" + case 168: + +/* Line 1806 of yacc.c */ +#line 786 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); } break; - case 166: - -/* Line 1806 of yacc.c */ -#line 781 "parser.yy" + case 169: + +/* Line 1806 of yacc.c */ +#line 790 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); } break; - case 167: - -/* Line 1806 of yacc.c */ -#line 786 "parser.yy" + case 170: + +/* Line 1806 of yacc.c */ +#line 795 "parser.yy" { (yyval.sn) = 0; } break; - case 169: - -/* Line 1806 of yacc.c */ -#line 792 "parser.yy" + case 172: + +/* Line 1806 of yacc.c */ +#line 801 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); } break; - case 170: - -/* Line 1806 of yacc.c */ -#line 794 "parser.yy" + case 173: + +/* Line 1806 of yacc.c */ +#line 803 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); } break; - case 171: - -/* Line 1806 of yacc.c */ -#line 799 "parser.yy" + case 174: + +/* Line 1806 of yacc.c */ +#line 808 "parser.yy" { (yyval.sn) = 0; } break; - case 173: - -/* Line 1806 of yacc.c */ -#line 805 "parser.yy" + case 176: + +/* Line 1806 of yacc.c */ +#line 814 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); } break; - case 174: - -/* Line 1806 of yacc.c */ -#line 807 "parser.yy" + case 177: + +/* Line 1806 of yacc.c */ +#line 816 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); } break; - case 175: - -/* Line 1806 of yacc.c */ -#line 809 "parser.yy" + case 178: + +/* Line 1806 of yacc.c */ +#line 818 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); } break; - case 176: - -/* Line 1806 of yacc.c */ -#line 811 "parser.yy" + case 179: + +/* Line 1806 of yacc.c */ +#line 820 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); } break; - case 177: - -/* Line 1806 of yacc.c */ -#line 816 "parser.yy" + case 180: + +/* Line 1806 of yacc.c */ +#line 825 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); } break; - case 179: - -/* Line 1806 of yacc.c */ -#line 822 "parser.yy" + case 182: + +/* Line 1806 of yacc.c */ +#line 831 "parser.yy" { (yyval.sn) = 0; } break; - case 180: - -/* Line 1806 of yacc.c */ -#line 824 "parser.yy" + case 183: + +/* Line 1806 of yacc.c */ +#line 833 "parser.yy" { (yyval.sn) = 0; } break; - case 181: - -/* Line 1806 of yacc.c */ -#line 829 "parser.yy" + case 184: + +/* Line 1806 of yacc.c */ +#line 838 "parser.yy" { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } break; - case 182: - -/* Line 1806 of yacc.c */ -#line 831 "parser.yy" + case 185: + +/* Line 1806 of yacc.c */ +#line 840 "parser.yy" { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); } break; - case 183: - -/* Line 1806 of yacc.c */ -#line 833 "parser.yy" + case 186: + +/* Line 1806 of yacc.c */ +#line 842 "parser.yy" { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); } break; - case 184: - -/* Line 1806 of yacc.c */ -#line 838 "parser.yy" + case 187: + +/* Line 1806 of yacc.c */ +#line 847 "parser.yy" { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); } break; - case 185: - -/* Line 1806 of yacc.c */ -#line 840 "parser.yy" + case 188: + +/* Line 1806 of yacc.c */ +#line 849 "parser.yy" { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); } break; - case 186: - -/* Line 1806 of yacc.c */ -#line 845 "parser.yy" + case 189: + +/* Line 1806 of yacc.c */ +#line 854 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); } break; - case 187: - -/* Line 1806 of yacc.c */ -#line 849 "parser.yy" + case 190: + +/* Line 1806 of yacc.c */ +#line 858 "parser.yy" { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); } break; - case 188: - -/* Line 1806 of yacc.c */ -#line 852 "parser.yy" + case 191: + +/* Line 1806 of yacc.c */ +#line 861 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); } break; - case 189: - -/* Line 1806 of yacc.c */ -#line 856 "parser.yy" + case 192: + +/* Line 1806 of yacc.c */ +#line 865 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); } break; - case 190: - -/* Line 1806 of yacc.c */ -#line 859 "parser.yy" + case 193: + +/* Line 1806 of yacc.c */ +#line 868 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); } break; - case 191: - -/* Line 1806 of yacc.c */ -#line 863 "parser.yy" + case 194: + +/* Line 1806 of yacc.c */ +#line 872 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); } break; - case 192: - -/* Line 1806 of yacc.c */ -#line 865 "parser.yy" + case 195: + +/* Line 1806 of yacc.c */ +#line 874 "parser.yy" { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); } break; - case 193: - -/* Line 1806 of yacc.c */ -#line 867 "parser.yy" + case 196: + +/* Line 1806 of yacc.c */ +#line 876 "parser.yy" { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); } break; - case 194: - -/* Line 1806 of yacc.c */ -#line 869 "parser.yy" + case 197: + +/* Line 1806 of yacc.c */ +#line 878 "parser.yy" { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); } break; - case 195: - -/* Line 1806 of yacc.c */ -#line 871 "parser.yy" + case 198: + +/* Line 1806 of yacc.c */ +#line 880 "parser.yy" { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); } break; - case 196: - -/* Line 1806 of yacc.c */ -#line 876 "parser.yy" + case 199: + +/* Line 1806 of yacc.c */ +#line 885 "parser.yy" { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); } break; - case 197: - -/* Line 1806 of yacc.c */ -#line 878 "parser.yy" + case 200: + +/* Line 1806 of yacc.c */ +#line 887 "parser.yy" { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); } break; - case 198: - -/* Line 1806 of yacc.c */ -#line 880 "parser.yy" + case 201: + +/* Line 1806 of yacc.c */ +#line 889 "parser.yy" { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); } break; - case 200: - -/* Line 1806 of yacc.c */ -#line 887 "parser.yy" + case 203: + +/* Line 1806 of yacc.c */ +#line 896 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); } break; - case 201: - -/* Line 1806 of yacc.c */ -#line 889 "parser.yy" + case 204: + +/* Line 1806 of yacc.c */ +#line 898 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); } break; - case 202: - -/* Line 1806 of yacc.c */ -#line 891 "parser.yy" + case 205: + +/* Line 1806 of yacc.c */ +#line 900 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); } break; - case 203: - -/* Line 1806 of yacc.c */ -#line 893 "parser.yy" + case 206: + +/* Line 1806 of yacc.c */ +#line 902 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); } break; - case 204: - -/* Line 1806 of yacc.c */ -#line 898 "parser.yy" + case 207: + +/* Line 1806 of yacc.c */ +#line 907 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); } break; - case 205: - -/* Line 1806 of yacc.c */ -#line 900 "parser.yy" + case 208: + +/* Line 1806 of yacc.c */ +#line 909 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); } break; - case 206: - -/* Line 1806 of yacc.c */ -#line 902 "parser.yy" + case 209: + +/* Line 1806 of yacc.c */ +#line 911 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); } break; - case 207: - -/* Line 1806 of yacc.c */ -#line 904 "parser.yy" + case 210: + +/* Line 1806 of yacc.c */ +#line 913 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); } break; - case 208: - -/* Line 1806 of yacc.c */ -#line 909 "parser.yy" + case 211: + +/* Line 1806 of yacc.c */ +#line 918 "parser.yy" { (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) ); @@ -6123,8 +6136,8 @@ break; - case 210: - -/* Line 1806 of yacc.c */ -#line 922 "parser.yy" + case 213: + +/* Line 1806 of yacc.c */ +#line 931 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6133,15 +6146,15 @@ break; - case 211: - -/* Line 1806 of yacc.c */ -#line 927 "parser.yy" + case 214: + +/* Line 1806 of yacc.c */ +#line 936 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 212: - -/* Line 1806 of yacc.c */ -#line 929 "parser.yy" + case 215: + +/* Line 1806 of yacc.c */ +#line 938 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6150,106 +6163,106 @@ break; - case 214: - -/* Line 1806 of yacc.c */ -#line 938 "parser.yy" + case 217: + +/* Line 1806 of yacc.c */ +#line 947 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); } break; - case 215: - -/* Line 1806 of yacc.c */ -#line 940 "parser.yy" + case 218: + +/* Line 1806 of yacc.c */ +#line 949 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); } break; - case 216: - -/* Line 1806 of yacc.c */ -#line 942 "parser.yy" + case 219: + +/* Line 1806 of yacc.c */ +#line 951 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); } break; - case 217: - -/* Line 1806 of yacc.c */ -#line 944 "parser.yy" + case 220: + +/* Line 1806 of yacc.c */ +#line 953 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); } break; - case 218: - -/* Line 1806 of yacc.c */ -#line 946 "parser.yy" + case 221: + +/* Line 1806 of yacc.c */ +#line 955 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ) ); } break; - case 219: - -/* Line 1806 of yacc.c */ -#line 951 "parser.yy" + case 222: + +/* Line 1806 of yacc.c */ +#line 960 "parser.yy" { (yyval.flag) = false; } break; - case 220: - -/* Line 1806 of yacc.c */ -#line 953 "parser.yy" + case 223: + +/* Line 1806 of yacc.c */ +#line 962 "parser.yy" { (yyval.flag) = true; } break; - case 221: - -/* Line 1806 of yacc.c */ -#line 958 "parser.yy" + case 224: + +/* Line 1806 of yacc.c */ +#line 967 "parser.yy" { (yyval.en) = 0; } break; - case 224: - -/* Line 1806 of yacc.c */ -#line 965 "parser.yy" + case 227: + +/* Line 1806 of yacc.c */ +#line 974 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } break; - case 225: - -/* Line 1806 of yacc.c */ -#line 970 "parser.yy" + case 228: + +/* Line 1806 of yacc.c */ +#line 979 "parser.yy" { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); } break; - case 226: - -/* Line 1806 of yacc.c */ -#line 972 "parser.yy" + case 229: + +/* Line 1806 of yacc.c */ +#line 981 "parser.yy" { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); } break; - case 227: - -/* Line 1806 of yacc.c */ -#line 977 "parser.yy" + case 230: + +/* Line 1806 of yacc.c */ +#line 986 "parser.yy" { (yyval.en) = 0; } break; - case 228: - -/* Line 1806 of yacc.c */ -#line 979 "parser.yy" + case 231: + +/* Line 1806 of yacc.c */ +#line 988 "parser.yy" { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); } break; - case 229: - -/* Line 1806 of yacc.c */ -#line 981 "parser.yy" + case 232: + +/* Line 1806 of yacc.c */ +#line 990 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); } break; - case 230: - -/* Line 1806 of yacc.c */ -#line 986 "parser.yy" + case 233: + +/* Line 1806 of yacc.c */ +#line 995 "parser.yy" { (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) ); @@ -6258,8 +6271,8 @@ break; - case 231: - -/* Line 1806 of yacc.c */ -#line 991 "parser.yy" + case 234: + +/* Line 1806 of yacc.c */ +#line 1000 "parser.yy" { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) ); @@ -6268,50 +6281,50 @@ break; - case 232: - -/* Line 1806 of yacc.c */ -#line 1001 "parser.yy" + case 235: + +/* Line 1806 of yacc.c */ +#line 1010 "parser.yy" { (yyval.decl) = 0; } break; - case 235: - -/* Line 1806 of yacc.c */ -#line 1008 "parser.yy" + case 238: + +/* Line 1806 of yacc.c */ +#line 1017 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; - case 236: - -/* Line 1806 of yacc.c */ -#line 1013 "parser.yy" + case 239: + +/* Line 1806 of yacc.c */ +#line 1022 "parser.yy" { (yyval.decl) = 0; } break; - case 239: - -/* Line 1806 of yacc.c */ -#line 1020 "parser.yy" + case 242: + +/* Line 1806 of yacc.c */ +#line 1029 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; - case 244: - -/* Line 1806 of yacc.c */ -#line 1034 "parser.yy" + case 247: + +/* Line 1806 of yacc.c */ +#line 1043 "parser.yy" {} break; - case 245: - -/* Line 1806 of yacc.c */ -#line 1035 "parser.yy" + case 248: + +/* Line 1806 of yacc.c */ +#line 1044 "parser.yy" {} break; - case 253: - -/* Line 1806 of yacc.c */ -#line 1064 "parser.yy" + case 256: + +/* Line 1806 of yacc.c */ +#line 1073 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6320,8 +6333,8 @@ break; - case 254: - -/* Line 1806 of yacc.c */ -#line 1071 "parser.yy" + case 257: + +/* Line 1806 of yacc.c */ +#line 1080 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6330,8 +6343,8 @@ break; - case 255: - -/* Line 1806 of yacc.c */ -#line 1076 "parser.yy" + case 258: + +/* Line 1806 of yacc.c */ +#line 1085 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID ); @@ -6340,8 +6353,8 @@ break; - case 256: - -/* Line 1806 of yacc.c */ -#line 1086 "parser.yy" + case 259: + +/* Line 1806 of yacc.c */ +#line 1095 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); @@ -6350,8 +6363,8 @@ break; - case 257: - -/* Line 1806 of yacc.c */ -#line 1091 "parser.yy" + case 260: + +/* Line 1806 of yacc.c */ +#line 1100 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); @@ -6360,8 +6373,8 @@ break; - case 258: - -/* Line 1806 of yacc.c */ -#line 1096 "parser.yy" + case 261: + +/* Line 1806 of yacc.c */ +#line 1105 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) ); @@ -6370,8 +6383,8 @@ break; - case 259: - -/* Line 1806 of yacc.c */ -#line 1104 "parser.yy" + case 262: + +/* Line 1806 of yacc.c */ +#line 1113 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6380,8 +6393,8 @@ break; - case 260: - -/* Line 1806 of yacc.c */ -#line 1109 "parser.yy" + case 263: + +/* Line 1806 of yacc.c */ +#line 1118 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6390,8 +6403,8 @@ break; - case 261: - -/* Line 1806 of yacc.c */ -#line 1114 "parser.yy" + case 264: + +/* Line 1806 of yacc.c */ +#line 1123 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6400,8 +6413,8 @@ break; - case 262: - -/* Line 1806 of yacc.c */ -#line 1119 "parser.yy" + case 265: + +/* Line 1806 of yacc.c */ +#line 1128 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6410,8 +6423,8 @@ break; - case 263: - -/* Line 1806 of yacc.c */ -#line 1124 "parser.yy" + case 266: + +/* Line 1806 of yacc.c */ +#line 1133 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID ); @@ -6420,8 +6433,8 @@ break; - case 264: - -/* Line 1806 of yacc.c */ -#line 1132 "parser.yy" + case 267: + +/* Line 1806 of yacc.c */ +#line 1141 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true ); @@ -6429,8 +6442,8 @@ break; - case 265: - -/* Line 1806 of yacc.c */ -#line 1155 "parser.yy" + case 268: + +/* Line 1806 of yacc.c */ +#line 1164 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); @@ -6438,8 +6451,8 @@ break; - case 266: - -/* Line 1806 of yacc.c */ -#line 1159 "parser.yy" + case 269: + +/* Line 1806 of yacc.c */ +#line 1168 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); @@ -6447,22 +6460,22 @@ break; - case 267: - -/* Line 1806 of yacc.c */ -#line 1166 "parser.yy" + case 270: + +/* Line 1806 of yacc.c */ +#line 1175 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } break; - case 268: - -/* Line 1806 of yacc.c */ -#line 1170 "parser.yy" + case 271: + +/* Line 1806 of yacc.c */ +#line 1179 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); } break; - case 269: - -/* Line 1806 of yacc.c */ -#line 1175 "parser.yy" + case 272: + +/* Line 1806 of yacc.c */ +#line 1184 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6471,8 +6484,8 @@ break; - case 270: - -/* Line 1806 of yacc.c */ -#line 1180 "parser.yy" + case 273: + +/* Line 1806 of yacc.c */ +#line 1189 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6481,8 +6494,8 @@ break; - case 271: - -/* Line 1806 of yacc.c */ -#line 1185 "parser.yy" + case 274: + +/* Line 1806 of yacc.c */ +#line 1194 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD ); @@ -6491,8 +6504,8 @@ break; - case 272: - -/* Line 1806 of yacc.c */ -#line 1196 "parser.yy" + case 275: + +/* Line 1806 of yacc.c */ +#line 1205 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6501,8 +6514,8 @@ break; - case 273: - -/* Line 1806 of yacc.c */ -#line 1201 "parser.yy" + case 276: + +/* Line 1806 of yacc.c */ +#line 1210 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6511,8 +6524,8 @@ break; - case 274: - -/* Line 1806 of yacc.c */ -#line 1206 "parser.yy" + case 277: + +/* Line 1806 of yacc.c */ +#line 1215 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6521,8 +6534,8 @@ break; - case 275: - -/* Line 1806 of yacc.c */ -#line 1211 "parser.yy" + case 278: + +/* Line 1806 of yacc.c */ +#line 1220 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6531,8 +6544,8 @@ break; - case 276: - -/* Line 1806 of yacc.c */ -#line 1216 "parser.yy" + case 279: + +/* Line 1806 of yacc.c */ +#line 1225 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6541,8 +6554,8 @@ break; - case 277: - -/* Line 1806 of yacc.c */ -#line 1225 "parser.yy" + case 280: + +/* Line 1806 of yacc.c */ +#line 1234 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD ); @@ -6551,8 +6564,8 @@ break; - case 278: - -/* Line 1806 of yacc.c */ -#line 1230 "parser.yy" + case 281: + +/* Line 1806 of yacc.c */ +#line 1239 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD ); @@ -6561,8 +6574,8 @@ break; - case 283: - -/* Line 1806 of yacc.c */ -#line 1247 "parser.yy" + case 286: + +/* Line 1806 of yacc.c */ +#line 1256 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6571,8 +6584,8 @@ break; - case 284: - -/* Line 1806 of yacc.c */ -#line 1252 "parser.yy" + case 287: + +/* Line 1806 of yacc.c */ +#line 1261 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6581,57 +6594,57 @@ break; - case 293: - -/* Line 1806 of yacc.c */ -#line 1274 "parser.yy" + case 296: + +/* Line 1806 of yacc.c */ +#line 1283 "parser.yy" { (yyval.decl) = 0; } break; - case 296: - -/* Line 1806 of yacc.c */ -#line 1286 "parser.yy" + case 299: + +/* Line 1806 of yacc.c */ +#line 1295 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 299: - -/* Line 1806 of yacc.c */ -#line 1297 "parser.yy" + case 302: + +/* Line 1806 of yacc.c */ +#line 1306 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); } break; - case 300: - -/* Line 1806 of yacc.c */ -#line 1299 "parser.yy" + case 303: + +/* Line 1806 of yacc.c */ +#line 1308 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); } break; - case 301: - -/* Line 1806 of yacc.c */ -#line 1301 "parser.yy" + case 304: + +/* Line 1806 of yacc.c */ +#line 1310 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } break; - case 302: - -/* Line 1806 of yacc.c */ -#line 1303 "parser.yy" + case 305: + +/* Line 1806 of yacc.c */ +#line 1312 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } break; - case 303: - -/* Line 1806 of yacc.c */ -#line 1305 "parser.yy" + case 306: + +/* Line 1806 of yacc.c */ +#line 1314 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } break; - case 304: - -/* Line 1806 of yacc.c */ -#line 1307 "parser.yy" + case 307: + +/* Line 1806 of yacc.c */ +#line 1316 "parser.yy" { typedefTable.enterScope(); @@ -6639,8 +6652,8 @@ break; - case 305: - -/* Line 1806 of yacc.c */ -#line 1311 "parser.yy" + case 308: + +/* Line 1806 of yacc.c */ +#line 1320 "parser.yy" { typedefTable.leaveScope(); @@ -6649,417 +6662,417 @@ break; - case 307: - -/* Line 1806 of yacc.c */ -#line 1320 "parser.yy" + case 310: + +/* Line 1806 of yacc.c */ +#line 1329 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 308: - -/* Line 1806 of yacc.c */ -#line 1322 "parser.yy" + case 311: + +/* Line 1806 of yacc.c */ +#line 1331 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 310: - -/* Line 1806 of yacc.c */ -#line 1333 "parser.yy" + case 313: + +/* Line 1806 of yacc.c */ +#line 1342 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 311: - -/* Line 1806 of yacc.c */ -#line 1338 "parser.yy" + case 314: + +/* Line 1806 of yacc.c */ +#line 1347 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } break; - case 312: - -/* Line 1806 of yacc.c */ -#line 1340 "parser.yy" + case 315: + +/* Line 1806 of yacc.c */ +#line 1349 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); } break; - case 313: - -/* Line 1806 of yacc.c */ -#line 1342 "parser.yy" + case 316: + +/* Line 1806 of yacc.c */ +#line 1351 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); } break; - case 314: - -/* Line 1806 of yacc.c */ -#line 1344 "parser.yy" + case 317: + +/* Line 1806 of yacc.c */ +#line 1353 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); } break; - case 315: - -/* Line 1806 of yacc.c */ -#line 1347 "parser.yy" + case 318: + +/* Line 1806 of yacc.c */ +#line 1356 "parser.yy" { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; } break; - case 316: - -/* Line 1806 of yacc.c */ -#line 1349 "parser.yy" + case 319: + +/* Line 1806 of yacc.c */ +#line 1358 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } break; - case 317: - -/* Line 1806 of yacc.c */ -#line 1352 "parser.yy" + case 320: + +/* Line 1806 of yacc.c */ +#line 1361 "parser.yy" { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; } break; - case 318: - -/* Line 1806 of yacc.c */ -#line 1354 "parser.yy" + case 321: + +/* Line 1806 of yacc.c */ +#line 1363 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); } break; - case 319: - -/* Line 1806 of yacc.c */ -#line 1359 "parser.yy" + case 322: + +/* Line 1806 of yacc.c */ +#line 1368 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); } break; - case 320: - -/* Line 1806 of yacc.c */ -#line 1361 "parser.yy" + case 323: + +/* Line 1806 of yacc.c */ +#line 1370 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); } break; - case 321: - -/* Line 1806 of yacc.c */ -#line 1363 "parser.yy" + case 324: + +/* Line 1806 of yacc.c */ +#line 1372 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); } break; - case 322: - -/* Line 1806 of yacc.c */ -#line 1365 "parser.yy" + case 325: + +/* Line 1806 of yacc.c */ +#line 1374 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); } break; - case 323: - -/* Line 1806 of yacc.c */ -#line 1367 "parser.yy" + case 326: + +/* Line 1806 of yacc.c */ +#line 1376 "parser.yy" { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); } break; - case 324: - -/* Line 1806 of yacc.c */ -#line 1369 "parser.yy" + case 327: + +/* Line 1806 of yacc.c */ +#line 1378 "parser.yy" { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); } break; - case 325: - -/* Line 1806 of yacc.c */ -#line 1371 "parser.yy" + case 328: + +/* Line 1806 of yacc.c */ +#line 1380 "parser.yy" { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); } break; - case 326: - -/* Line 1806 of yacc.c */ -#line 1373 "parser.yy" + case 329: + +/* Line 1806 of yacc.c */ +#line 1382 "parser.yy" { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); } break; - case 327: - -/* Line 1806 of yacc.c */ -#line 1375 "parser.yy" + case 330: + +/* Line 1806 of yacc.c */ +#line 1384 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); } break; - case 328: - -/* Line 1806 of yacc.c */ -#line 1377 "parser.yy" + case 331: + +/* Line 1806 of yacc.c */ +#line 1386 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); } break; - case 329: - -/* Line 1806 of yacc.c */ -#line 1379 "parser.yy" + case 332: + +/* Line 1806 of yacc.c */ +#line 1388 "parser.yy" { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); } break; - case 330: - -/* Line 1806 of yacc.c */ -#line 1381 "parser.yy" + case 333: + +/* Line 1806 of yacc.c */ +#line 1390 "parser.yy" { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } break; - case 331: - -/* Line 1806 of yacc.c */ -#line 1383 "parser.yy" + case 334: + +/* Line 1806 of yacc.c */ +#line 1392 "parser.yy" { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); } break; - case 333: - -/* Line 1806 of yacc.c */ -#line 1390 "parser.yy" + case 336: + +/* Line 1806 of yacc.c */ +#line 1399 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 334: - -/* Line 1806 of yacc.c */ -#line 1392 "parser.yy" + case 337: + +/* Line 1806 of yacc.c */ +#line 1401 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 335: - -/* Line 1806 of yacc.c */ -#line 1394 "parser.yy" + case 338: + +/* Line 1806 of yacc.c */ +#line 1403 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 336: - -/* Line 1806 of yacc.c */ -#line 1396 "parser.yy" + case 339: + +/* Line 1806 of yacc.c */ +#line 1405 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); } break; - case 338: - -/* Line 1806 of yacc.c */ -#line 1402 "parser.yy" + case 341: + +/* Line 1806 of yacc.c */ +#line 1411 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 340: - -/* Line 1806 of yacc.c */ -#line 1409 "parser.yy" + case 343: + +/* Line 1806 of yacc.c */ +#line 1418 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 341: - -/* Line 1806 of yacc.c */ -#line 1411 "parser.yy" + case 344: + +/* Line 1806 of yacc.c */ +#line 1420 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 342: - -/* Line 1806 of yacc.c */ -#line 1413 "parser.yy" + case 345: + +/* Line 1806 of yacc.c */ +#line 1422 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); } break; - case 343: - -/* Line 1806 of yacc.c */ -#line 1418 "parser.yy" + case 346: + +/* Line 1806 of yacc.c */ +#line 1427 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (4)].decl); } break; - case 344: - -/* Line 1806 of yacc.c */ -#line 1420 "parser.yy" + case 347: + +/* Line 1806 of yacc.c */ +#line 1429 "parser.yy" { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); } break; - case 345: - -/* Line 1806 of yacc.c */ -#line 1422 "parser.yy" + case 348: + +/* Line 1806 of yacc.c */ +#line 1431 "parser.yy" { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); } break; - case 346: - -/* Line 1806 of yacc.c */ -#line 1424 "parser.yy" + case 349: + +/* Line 1806 of yacc.c */ +#line 1433 "parser.yy" { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } break; - case 348: - -/* Line 1806 of yacc.c */ -#line 1430 "parser.yy" + case 351: + +/* Line 1806 of yacc.c */ +#line 1439 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 349: - -/* Line 1806 of yacc.c */ -#line 1432 "parser.yy" + case 352: + +/* Line 1806 of yacc.c */ +#line 1441 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 350: - -/* Line 1806 of yacc.c */ -#line 1434 "parser.yy" + case 353: + +/* Line 1806 of yacc.c */ +#line 1443 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 352: - -/* Line 1806 of yacc.c */ -#line 1440 "parser.yy" + case 355: + +/* Line 1806 of yacc.c */ +#line 1449 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 353: - -/* Line 1806 of yacc.c */ -#line 1442 "parser.yy" + case 356: + +/* Line 1806 of yacc.c */ +#line 1451 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 355: - -/* Line 1806 of yacc.c */ -#line 1448 "parser.yy" + case 358: + +/* Line 1806 of yacc.c */ +#line 1457 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 356: - -/* Line 1806 of yacc.c */ -#line 1450 "parser.yy" + case 359: + +/* Line 1806 of yacc.c */ +#line 1459 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 357: - -/* Line 1806 of yacc.c */ -#line 1452 "parser.yy" + case 360: + +/* Line 1806 of yacc.c */ +#line 1461 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 358: - -/* Line 1806 of yacc.c */ -#line 1457 "parser.yy" + case 361: + +/* Line 1806 of yacc.c */ +#line 1466 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); } break; - case 359: - -/* Line 1806 of yacc.c */ -#line 1459 "parser.yy" + case 362: + +/* Line 1806 of yacc.c */ +#line 1468 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 360: - -/* Line 1806 of yacc.c */ -#line 1461 "parser.yy" + case 363: + +/* Line 1806 of yacc.c */ +#line 1470 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 363: - -/* Line 1806 of yacc.c */ -#line 1471 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); } - break; - - case 364: - -/* Line 1806 of yacc.c */ -#line 1473 "parser.yy" + case 366: + +/* Line 1806 of yacc.c */ +#line 1480 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), nullptr, nullptr, (yyvsp[(3) - (4)].decl), true ); } + break; + + case 367: + +/* Line 1806 of yacc.c */ +#line 1482 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); - (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), 0, 0, false ); + (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), nullptr, nullptr, false ); } break; - case 365: - -/* Line 1806 of yacc.c */ -#line 1478 "parser.yy" + case 368: + +/* Line 1806 of yacc.c */ +#line 1487 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); } break; - case 366: - -/* Line 1806 of yacc.c */ -#line 1480 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); } - break; - - case 367: - -/* Line 1806 of yacc.c */ -#line 1482 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); } - break; - - case 368: - -/* Line 1806 of yacc.c */ -#line 1484 "parser.yy" + case 369: + +/* Line 1806 of yacc.c */ +#line 1489 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); } + break; + + case 370: + +/* Line 1806 of yacc.c */ +#line 1491 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); } + break; + + case 371: + +/* Line 1806 of yacc.c */ +#line 1493 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl); } break; - case 369: - -/* Line 1806 of yacc.c */ -#line 1489 "parser.yy" + case 372: + +/* Line 1806 of yacc.c */ +#line 1498 "parser.yy" { (yyval.aggKey) = DeclarationNode::Struct; } break; - case 370: - -/* Line 1806 of yacc.c */ -#line 1491 "parser.yy" + case 373: + +/* Line 1806 of yacc.c */ +#line 1500 "parser.yy" { (yyval.aggKey) = DeclarationNode::Union; } break; - case 371: - -/* Line 1806 of yacc.c */ -#line 1496 "parser.yy" + case 374: + +/* Line 1806 of yacc.c */ +#line 1505 "parser.yy" { (yyval.decl) = 0; } break; - case 372: - -/* Line 1806 of yacc.c */ -#line 1498 "parser.yy" + case 375: + +/* Line 1806 of yacc.c */ +#line 1507 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); } break; - case 374: - -/* Line 1806 of yacc.c */ -#line 1504 "parser.yy" + case 377: + +/* Line 1806 of yacc.c */ +#line 1513 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); } break; - case 376: - -/* Line 1806 of yacc.c */ -#line 1507 "parser.yy" + case 379: + +/* Line 1806 of yacc.c */ +#line 1516 "parser.yy" { // mark all fields in list for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) @@ -7069,99 +7082,99 @@ break; - case 378: - -/* Line 1806 of yacc.c */ -#line 1517 "parser.yy" + case 381: + +/* Line 1806 of yacc.c */ +#line 1526 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); } break; - case 379: - -/* Line 1806 of yacc.c */ -#line 1519 "parser.yy" + case 382: + +/* Line 1806 of yacc.c */ +#line 1528 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); } break; - case 380: - -/* Line 1806 of yacc.c */ -#line 1521 "parser.yy" + case 383: + +/* Line 1806 of yacc.c */ +#line 1530 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); } break; - case 381: - -/* Line 1806 of yacc.c */ -#line 1526 "parser.yy" + case 384: + +/* Line 1806 of yacc.c */ +#line 1535 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 382: - -/* Line 1806 of yacc.c */ -#line 1528 "parser.yy" + case 385: + +/* Line 1806 of yacc.c */ +#line 1537 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); } break; - case 383: - -/* Line 1806 of yacc.c */ -#line 1533 "parser.yy" + case 386: + +/* Line 1806 of yacc.c */ +#line 1542 "parser.yy" { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ } break; - case 384: - -/* Line 1806 of yacc.c */ -#line 1535 "parser.yy" + case 387: + +/* Line 1806 of yacc.c */ +#line 1544 "parser.yy" { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); } break; - case 385: - -/* Line 1806 of yacc.c */ -#line 1538 "parser.yy" + case 388: + +/* Line 1806 of yacc.c */ +#line 1547 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } break; - case 386: - -/* Line 1806 of yacc.c */ -#line 1541 "parser.yy" + case 389: + +/* Line 1806 of yacc.c */ +#line 1550 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } break; - case 388: - -/* Line 1806 of yacc.c */ -#line 1547 "parser.yy" + case 391: + +/* Line 1806 of yacc.c */ +#line 1556 "parser.yy" { (yyval.en) = 0; } break; - case 389: - -/* Line 1806 of yacc.c */ -#line 1549 "parser.yy" + case 392: + +/* Line 1806 of yacc.c */ +#line 1558 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; - case 390: - -/* Line 1806 of yacc.c */ -#line 1554 "parser.yy" + case 393: + +/* Line 1806 of yacc.c */ +#line 1563 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; - case 392: - -/* Line 1806 of yacc.c */ -#line 1563 "parser.yy" - { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); } - break; - - case 393: - -/* Line 1806 of yacc.c */ -#line 1565 "parser.yy" + case 395: + +/* Line 1806 of yacc.c */ +#line 1572 "parser.yy" + { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); } + break; + + case 396: + +/* Line 1806 of yacc.c */ +#line 1574 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); @@ -7170,162 +7183,162 @@ break; - case 394: - -/* Line 1806 of yacc.c */ -#line 1570 "parser.yy" + case 397: + +/* Line 1806 of yacc.c */ +#line 1579 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); } break; - case 395: - -/* Line 1806 of yacc.c */ -#line 1572 "parser.yy" + case 398: + +/* Line 1806 of yacc.c */ +#line 1581 "parser.yy" { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); } break; - case 396: - -/* Line 1806 of yacc.c */ -#line 1577 "parser.yy" + case 399: + +/* Line 1806 of yacc.c */ +#line 1586 "parser.yy" { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); } break; - case 397: - -/* Line 1806 of yacc.c */ -#line 1579 "parser.yy" + case 400: + +/* Line 1806 of yacc.c */ +#line 1588 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); } break; - case 398: - -/* Line 1806 of yacc.c */ -#line 1584 "parser.yy" + case 401: + +/* Line 1806 of yacc.c */ +#line 1593 "parser.yy" { (yyval.en) = 0; } break; - case 399: - -/* Line 1806 of yacc.c */ -#line 1586 "parser.yy" + case 402: + +/* Line 1806 of yacc.c */ +#line 1595 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; - case 400: - -/* Line 1806 of yacc.c */ -#line 1593 "parser.yy" + case 403: + +/* Line 1806 of yacc.c */ +#line 1602 "parser.yy" { (yyval.decl) = 0; } break; - case 404: - -/* Line 1806 of yacc.c */ -#line 1601 "parser.yy" + case 407: + +/* Line 1806 of yacc.c */ +#line 1610 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 405: - -/* Line 1806 of yacc.c */ -#line 1603 "parser.yy" + case 408: + +/* Line 1806 of yacc.c */ +#line 1612 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; - case 406: - -/* Line 1806 of yacc.c */ -#line 1605 "parser.yy" + case 409: + +/* Line 1806 of yacc.c */ +#line 1614 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; - case 408: - -/* Line 1806 of yacc.c */ -#line 1613 "parser.yy" + case 411: + +/* Line 1806 of yacc.c */ +#line 1622 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 409: - -/* Line 1806 of yacc.c */ -#line 1615 "parser.yy" + case 412: + +/* Line 1806 of yacc.c */ +#line 1624 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 410: - -/* Line 1806 of yacc.c */ -#line 1617 "parser.yy" + case 413: + +/* Line 1806 of yacc.c */ +#line 1626 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); } break; - case 412: - -/* Line 1806 of yacc.c */ -#line 1623 "parser.yy" + case 415: + +/* Line 1806 of yacc.c */ +#line 1632 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 413: - -/* Line 1806 of yacc.c */ -#line 1628 "parser.yy" + case 416: + +/* Line 1806 of yacc.c */ +#line 1637 "parser.yy" { (yyval.decl) = 0; } break; - case 416: - -/* Line 1806 of yacc.c */ -#line 1635 "parser.yy" + case 419: + +/* Line 1806 of yacc.c */ +#line 1644 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; - case 419: - -/* Line 1806 of yacc.c */ -#line 1642 "parser.yy" + case 422: + +/* Line 1806 of yacc.c */ +#line 1651 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 420: - -/* Line 1806 of yacc.c */ -#line 1644 "parser.yy" + case 423: + +/* Line 1806 of yacc.c */ +#line 1653 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 422: - -/* Line 1806 of yacc.c */ -#line 1653 "parser.yy" + case 425: + +/* Line 1806 of yacc.c */ +#line 1662 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } break; - case 423: - -/* Line 1806 of yacc.c */ -#line 1656 "parser.yy" + case 426: + +/* Line 1806 of yacc.c */ +#line 1665 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } break; - case 424: - -/* Line 1806 of yacc.c */ -#line 1658 "parser.yy" + case 427: + +/* Line 1806 of yacc.c */ +#line 1667 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); } break; - case 429: - -/* Line 1806 of yacc.c */ -#line 1668 "parser.yy" + case 432: + +/* Line 1806 of yacc.c */ +#line 1677 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 431: - -/* Line 1806 of yacc.c */ -#line 1674 "parser.yy" + case 434: + +/* Line 1806 of yacc.c */ +#line 1683 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7334,8 +7347,8 @@ break; - case 432: - -/* Line 1806 of yacc.c */ -#line 1679 "parser.yy" + case 435: + +/* Line 1806 of yacc.c */ +#line 1688 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7344,253 +7357,253 @@ break; - case 434: - -/* Line 1806 of yacc.c */ -#line 1688 "parser.yy" + case 437: + +/* Line 1806 of yacc.c */ +#line 1697 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 435: - -/* Line 1806 of yacc.c */ -#line 1697 "parser.yy" + case 438: + +/* Line 1806 of yacc.c */ +#line 1706 "parser.yy" { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); } break; - case 436: - -/* Line 1806 of yacc.c */ -#line 1699 "parser.yy" + case 439: + +/* Line 1806 of yacc.c */ +#line 1708 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); } break; - case 448: - -/* Line 1806 of yacc.c */ -#line 1724 "parser.yy" + case 451: + +/* Line 1806 of yacc.c */ +#line 1733 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 452: - -/* Line 1806 of yacc.c */ -#line 1732 "parser.yy" + case 455: + +/* Line 1806 of yacc.c */ +#line 1741 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 453: - -/* Line 1806 of yacc.c */ -#line 1737 "parser.yy" + case 456: + +/* Line 1806 of yacc.c */ +#line 1746 "parser.yy" { (yyval.in) = 0; } break; - case 454: - -/* Line 1806 of yacc.c */ -#line 1739 "parser.yy" + case 457: + +/* Line 1806 of yacc.c */ +#line 1748 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in); } break; - case 455: - -/* Line 1806 of yacc.c */ -#line 1741 "parser.yy" + case 458: + +/* Line 1806 of yacc.c */ +#line 1750 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); } break; - case 456: - -/* Line 1806 of yacc.c */ -#line 1745 "parser.yy" + case 459: + +/* Line 1806 of yacc.c */ +#line 1754 "parser.yy" { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); } break; - case 457: - -/* Line 1806 of yacc.c */ -#line 1746 "parser.yy" + case 460: + +/* Line 1806 of yacc.c */ +#line 1755 "parser.yy" { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); } break; - case 458: - -/* Line 1806 of yacc.c */ -#line 1751 "parser.yy" + case 461: + +/* Line 1806 of yacc.c */ +#line 1760 "parser.yy" { (yyval.in) = 0; } break; - case 460: - -/* Line 1806 of yacc.c */ -#line 1753 "parser.yy" + case 463: + +/* Line 1806 of yacc.c */ +#line 1762 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); } break; - case 461: - -/* Line 1806 of yacc.c */ -#line 1754 "parser.yy" + case 464: + +/* Line 1806 of yacc.c */ +#line 1763 "parser.yy" { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); } break; - case 462: - -/* Line 1806 of yacc.c */ -#line 1756 "parser.yy" + case 465: + +/* Line 1806 of yacc.c */ +#line 1765 "parser.yy" { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); } break; - case 464: - -/* Line 1806 of yacc.c */ -#line 1772 "parser.yy" + case 467: + +/* Line 1806 of yacc.c */ +#line 1781 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); } break; - case 466: - -/* Line 1806 of yacc.c */ -#line 1778 "parser.yy" + case 469: + +/* Line 1806 of yacc.c */ +#line 1787 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); } break; - case 467: - -/* Line 1806 of yacc.c */ -#line 1784 "parser.yy" + case 470: + +/* Line 1806 of yacc.c */ +#line 1793 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); } break; - case 468: - -/* Line 1806 of yacc.c */ -#line 1787 "parser.yy" + case 471: + +/* Line 1806 of yacc.c */ +#line 1796 "parser.yy" { (yyval.en) = (yyvsp[(3) - (5)].en); } break; - case 469: - -/* Line 1806 of yacc.c */ -#line 1789 "parser.yy" + case 472: + +/* Line 1806 of yacc.c */ +#line 1798 "parser.yy" { (yyval.en) = (yyvsp[(3) - (5)].en); } break; - case 470: - -/* Line 1806 of yacc.c */ -#line 1791 "parser.yy" + case 473: + +/* Line 1806 of yacc.c */ +#line 1800 "parser.yy" { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); } break; - case 471: - -/* Line 1806 of yacc.c */ -#line 1793 "parser.yy" + case 474: + +/* Line 1806 of yacc.c */ +#line 1802 "parser.yy" { (yyval.en) = (yyvsp[(4) - (6)].en); } break; - case 473: - -/* Line 1806 of yacc.c */ -#line 1817 "parser.yy" + case 476: + +/* Line 1806 of yacc.c */ +#line 1826 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 474: - -/* Line 1806 of yacc.c */ -#line 1819 "parser.yy" + case 477: + +/* Line 1806 of yacc.c */ +#line 1828 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 475: - -/* Line 1806 of yacc.c */ -#line 1821 "parser.yy" + case 478: + +/* Line 1806 of yacc.c */ +#line 1830 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 477: - -/* Line 1806 of yacc.c */ -#line 1827 "parser.yy" + case 480: + +/* Line 1806 of yacc.c */ +#line 1836 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 478: - -/* Line 1806 of yacc.c */ -#line 1829 "parser.yy" + case 481: + +/* Line 1806 of yacc.c */ +#line 1838 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 479: - -/* Line 1806 of yacc.c */ -#line 1834 "parser.yy" + case 482: + +/* Line 1806 of yacc.c */ +#line 1843 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } break; - case 481: - -/* Line 1806 of yacc.c */ -#line 1840 "parser.yy" + case 484: + +/* Line 1806 of yacc.c */ +#line 1849 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); } break; - case 482: - -/* Line 1806 of yacc.c */ -#line 1845 "parser.yy" + case 485: + +/* Line 1806 of yacc.c */ +#line 1854 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); } break; - case 483: - -/* Line 1806 of yacc.c */ -#line 1847 "parser.yy" + case 486: + +/* Line 1806 of yacc.c */ +#line 1856 "parser.yy" { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); } break; - case 485: - -/* Line 1806 of yacc.c */ -#line 1853 "parser.yy" + case 488: + +/* Line 1806 of yacc.c */ +#line 1862 "parser.yy" { (yyval.tclass) = DeclarationNode::Otype; } break; - case 486: - -/* Line 1806 of yacc.c */ -#line 1855 "parser.yy" + case 489: + +/* Line 1806 of yacc.c */ +#line 1864 "parser.yy" { (yyval.tclass) = DeclarationNode::Ftype; } break; - case 487: - -/* Line 1806 of yacc.c */ -#line 1857 "parser.yy" + case 490: + +/* Line 1806 of yacc.c */ +#line 1866 "parser.yy" { (yyval.tclass) = DeclarationNode::Dtype; } break; - case 488: - -/* Line 1806 of yacc.c */ -#line 1862 "parser.yy" + case 491: + +/* Line 1806 of yacc.c */ +#line 1871 "parser.yy" { (yyval.decl) = 0; } break; - case 489: - -/* Line 1806 of yacc.c */ -#line 1864 "parser.yy" + case 492: + +/* Line 1806 of yacc.c */ +#line 1873 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); } break; - case 490: - -/* Line 1806 of yacc.c */ -#line 1869 "parser.yy" + case 493: + +/* Line 1806 of yacc.c */ +#line 1878 "parser.yy" { typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) ); @@ -7599,78 +7612,78 @@ break; - case 491: - -/* Line 1806 of yacc.c */ -#line 1874 "parser.yy" + case 494: + +/* Line 1806 of yacc.c */ +#line 1883 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (5)].decl); } break; - case 492: - -/* Line 1806 of yacc.c */ -#line 1876 "parser.yy" + case 495: + +/* Line 1806 of yacc.c */ +#line 1885 "parser.yy" { (yyval.decl) = 0; } break; - case 493: - -/* Line 1806 of yacc.c */ -#line 1881 "parser.yy" + case 496: + +/* Line 1806 of yacc.c */ +#line 1890 "parser.yy" { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); } break; - case 495: - -/* Line 1806 of yacc.c */ -#line 1884 "parser.yy" + case 498: + +/* Line 1806 of yacc.c */ +#line 1893 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); } break; - case 496: - -/* Line 1806 of yacc.c */ -#line 1886 "parser.yy" + case 499: + +/* Line 1806 of yacc.c */ +#line 1895 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); } break; - case 497: - -/* Line 1806 of yacc.c */ -#line 1891 "parser.yy" + case 500: + +/* Line 1806 of yacc.c */ +#line 1900 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl); } break; - case 498: - -/* Line 1806 of yacc.c */ -#line 1893 "parser.yy" + case 501: + +/* Line 1806 of yacc.c */ +#line 1902 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); } break; - case 499: - -/* Line 1806 of yacc.c */ -#line 1895 "parser.yy" + case 502: + +/* Line 1806 of yacc.c */ +#line 1904 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); } break; - case 500: - -/* Line 1806 of yacc.c */ -#line 1900 "parser.yy" + case 503: + +/* Line 1806 of yacc.c */ +#line 1909 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); } break; - case 501: - -/* Line 1806 of yacc.c */ -#line 1902 "parser.yy" + case 504: + +/* Line 1806 of yacc.c */ +#line 1911 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); } break; - case 502: - -/* Line 1806 of yacc.c */ -#line 1907 "parser.yy" + case 505: + +/* Line 1806 of yacc.c */ +#line 1916 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD ); @@ -7679,8 +7692,8 @@ break; - case 503: - -/* Line 1806 of yacc.c */ -#line 1912 "parser.yy" + case 506: + +/* Line 1806 of yacc.c */ +#line 1921 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG ); @@ -7689,8 +7702,8 @@ break; - case 504: - -/* Line 1806 of yacc.c */ -#line 1920 "parser.yy" + case 507: + +/* Line 1806 of yacc.c */ +#line 1929 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID ); @@ -7699,8 +7712,8 @@ break; - case 505: - -/* Line 1806 of yacc.c */ -#line 1925 "parser.yy" + case 508: + +/* Line 1806 of yacc.c */ +#line 1934 "parser.yy" { typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) ); @@ -7709,8 +7722,8 @@ break; - case 506: - -/* Line 1806 of yacc.c */ -#line 1930 "parser.yy" + case 509: + +/* Line 1806 of yacc.c */ +#line 1939 "parser.yy" { typedefTable.leaveTrait(); @@ -7720,15 +7733,15 @@ break; - case 508: - -/* Line 1806 of yacc.c */ -#line 1940 "parser.yy" + case 511: + +/* Line 1806 of yacc.c */ +#line 1949 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; - case 511: - -/* Line 1806 of yacc.c */ -#line 1950 "parser.yy" + case 514: + +/* Line 1806 of yacc.c */ +#line 1959 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7737,8 +7750,8 @@ break; - case 512: - -/* Line 1806 of yacc.c */ -#line 1955 "parser.yy" + case 515: + +/* Line 1806 of yacc.c */ +#line 1964 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7747,8 +7760,8 @@ break; - case 513: - -/* Line 1806 of yacc.c */ -#line 1960 "parser.yy" + case 516: + +/* Line 1806 of yacc.c */ +#line 1969 "parser.yy" { typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID ); @@ -7757,8 +7770,8 @@ break; - case 514: - -/* Line 1806 of yacc.c */ -#line 1968 "parser.yy" + case 517: + +/* Line 1806 of yacc.c */ +#line 1977 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7767,8 +7780,8 @@ break; - case 515: - -/* Line 1806 of yacc.c */ -#line 1973 "parser.yy" + case 518: + +/* Line 1806 of yacc.c */ +#line 1982 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7777,53 +7790,53 @@ break; - case 516: - -/* Line 1806 of yacc.c */ -#line 1983 "parser.yy" + case 519: + +/* Line 1806 of yacc.c */ +#line 1992 "parser.yy" {} break; - case 517: - -/* Line 1806 of yacc.c */ -#line 1985 "parser.yy" + case 520: + +/* Line 1806 of yacc.c */ +#line 1994 "parser.yy" { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl); } break; - case 519: - -/* Line 1806 of yacc.c */ -#line 1991 "parser.yy" + case 522: + +/* Line 1806 of yacc.c */ +#line 2000 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl) != nullptr ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); } break; - case 520: - -/* Line 1806 of yacc.c */ -#line 1996 "parser.yy" + case 523: + +/* Line 1806 of yacc.c */ +#line 2005 "parser.yy" { (yyval.decl) = 0; } break; - case 524: - -/* Line 1806 of yacc.c */ -#line 2004 "parser.yy" + case 527: + +/* Line 1806 of yacc.c */ +#line 2013 "parser.yy" {} break; - case 525: - -/* Line 1806 of yacc.c */ -#line 2006 "parser.yy" + case 528: + +/* Line 1806 of yacc.c */ +#line 2015 "parser.yy" { linkageStack.push( linkage ); // handle nested extern "C"/"Cforall" - linkage = LinkageSpec::fromString( *(yyvsp[(2) - (2)].tok) ); + linkage = LinkageSpec::linkageCheck( (yyvsp[(2) - (2)].tok) ); } break; - case 526: - -/* Line 1806 of yacc.c */ -#line 2011 "parser.yy" + case 529: + +/* Line 1806 of yacc.c */ +#line 2020 "parser.yy" { linkage = linkageStack.top(); @@ -7833,8 +7846,8 @@ break; - case 527: - -/* Line 1806 of yacc.c */ -#line 2017 "parser.yy" + case 530: + +/* Line 1806 of yacc.c */ +#line 2026 "parser.yy" { // mark all fields in list for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) @@ -7844,8 +7857,8 @@ break; - case 529: - -/* Line 1806 of yacc.c */ -#line 2032 "parser.yy" + case 532: + +/* Line 1806 of yacc.c */ +#line 2041 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7855,8 +7868,8 @@ break; - case 530: - -/* Line 1806 of yacc.c */ -#line 2038 "parser.yy" + case 533: + +/* Line 1806 of yacc.c */ +#line 2047 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7866,8 +7879,8 @@ break; - case 531: - -/* Line 1806 of yacc.c */ -#line 2047 "parser.yy" + case 534: + +/* Line 1806 of yacc.c */ +#line 2056 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7877,8 +7890,8 @@ break; - case 532: - -/* Line 1806 of yacc.c */ -#line 2053 "parser.yy" + case 535: + +/* Line 1806 of yacc.c */ +#line 2062 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7888,8 +7901,8 @@ break; - case 533: - -/* Line 1806 of yacc.c */ -#line 2059 "parser.yy" + case 536: + +/* Line 1806 of yacc.c */ +#line 2068 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7899,8 +7912,8 @@ break; - case 534: - -/* Line 1806 of yacc.c */ -#line 2065 "parser.yy" + case 537: + +/* Line 1806 of yacc.c */ +#line 2074 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7910,8 +7923,8 @@ break; - case 535: - -/* Line 1806 of yacc.c */ -#line 2071 "parser.yy" + case 538: + +/* Line 1806 of yacc.c */ +#line 2080 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7921,8 +7934,8 @@ break; - case 536: - -/* Line 1806 of yacc.c */ -#line 2079 "parser.yy" + case 539: + +/* Line 1806 of yacc.c */ +#line 2088 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7932,8 +7945,8 @@ break; - case 537: - -/* Line 1806 of yacc.c */ -#line 2085 "parser.yy" + case 540: + +/* Line 1806 of yacc.c */ +#line 2094 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7943,8 +7956,8 @@ break; - case 538: - -/* Line 1806 of yacc.c */ -#line 2093 "parser.yy" + case 541: + +/* Line 1806 of yacc.c */ +#line 2102 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7954,8 +7967,8 @@ break; - case 539: - -/* Line 1806 of yacc.c */ -#line 2099 "parser.yy" + case 542: + +/* Line 1806 of yacc.c */ +#line 2108 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7965,99 +7978,99 @@ break; - case 543: - -/* Line 1806 of yacc.c */ -#line 2114 "parser.yy" + case 546: + +/* Line 1806 of yacc.c */ +#line 2123 "parser.yy" { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 545: - -/* Line 1806 of yacc.c */ -#line 2119 "parser.yy" + case 548: + +/* Line 1806 of yacc.c */ +#line 2128 "parser.yy" { delete (yyvsp[(3) - (5)].str); } break; - case 546: - -/* Line 1806 of yacc.c */ -#line 2124 "parser.yy" + case 549: + +/* Line 1806 of yacc.c */ +#line 2133 "parser.yy" { (yyval.decl) = 0; } break; - case 549: - -/* Line 1806 of yacc.c */ -#line 2131 "parser.yy" + case 552: + +/* Line 1806 of yacc.c */ +#line 2140 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 550: - -/* Line 1806 of yacc.c */ -#line 2137 "parser.yy" + case 553: + +/* Line 1806 of yacc.c */ +#line 2146 "parser.yy" { (yyval.decl) = 0; } break; - case 555: - -/* Line 1806 of yacc.c */ -#line 2148 "parser.yy" + case 558: + +/* Line 1806 of yacc.c */ +#line 2157 "parser.yy" { delete (yyvsp[(3) - (4)].en); } break; - case 556: - -/* Line 1806 of yacc.c */ -#line 2152 "parser.yy" + case 559: + +/* Line 1806 of yacc.c */ +#line 2161 "parser.yy" { delete (yyvsp[(1) - (1)].tok); } break; - case 557: - -/* Line 1806 of yacc.c */ -#line 2153 "parser.yy" + case 560: + +/* Line 1806 of yacc.c */ +#line 2162 "parser.yy" { delete (yyvsp[(1) - (1)].decl); } break; - case 558: - -/* Line 1806 of yacc.c */ -#line 2154 "parser.yy" + case 561: + +/* Line 1806 of yacc.c */ +#line 2163 "parser.yy" { delete (yyvsp[(1) - (1)].decl); } break; - case 559: - -/* Line 1806 of yacc.c */ -#line 2155 "parser.yy" + case 562: + +/* Line 1806 of yacc.c */ +#line 2164 "parser.yy" { delete (yyvsp[(1) - (1)].decl); } break; - case 560: - -/* Line 1806 of yacc.c */ -#line 2190 "parser.yy" + case 563: + +/* Line 1806 of yacc.c */ +#line 2199 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 562: - -/* Line 1806 of yacc.c */ -#line 2193 "parser.yy" + case 565: + +/* Line 1806 of yacc.c */ +#line 2202 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 563: - -/* Line 1806 of yacc.c */ -#line 2195 "parser.yy" + case 566: + +/* Line 1806 of yacc.c */ +#line 2204 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 564: - -/* Line 1806 of yacc.c */ -#line 2200 "parser.yy" + case 567: + +/* Line 1806 of yacc.c */ +#line 2209 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8066,25 +8079,4 @@ break; - case 565: - -/* Line 1806 of yacc.c */ -#line 2205 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 566: - -/* Line 1806 of yacc.c */ -#line 2210 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 567: - -/* Line 1806 of yacc.c */ -#line 2212 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - case 568: @@ -8098,89 +8090,89 @@ /* Line 1806 of yacc.c */ #line 2219 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 570: + +/* Line 1806 of yacc.c */ +#line 2221 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 571: + +/* Line 1806 of yacc.c */ +#line 2223 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 572: + +/* Line 1806 of yacc.c */ +#line 2228 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 570: - -/* Line 1806 of yacc.c */ -#line 2221 "parser.yy" + case 573: + +/* Line 1806 of yacc.c */ +#line 2230 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 571: - -/* Line 1806 of yacc.c */ -#line 2223 "parser.yy" + case 574: + +/* Line 1806 of yacc.c */ +#line 2232 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 572: - -/* Line 1806 of yacc.c */ -#line 2225 "parser.yy" + case 575: + +/* Line 1806 of yacc.c */ +#line 2234 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 573: - -/* Line 1806 of yacc.c */ -#line 2230 "parser.yy" + case 576: + +/* Line 1806 of yacc.c */ +#line 2239 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 574: - -/* Line 1806 of yacc.c */ -#line 2232 "parser.yy" + case 577: + +/* Line 1806 of yacc.c */ +#line 2241 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 575: - -/* Line 1806 of yacc.c */ -#line 2241 "parser.yy" + case 578: + +/* Line 1806 of yacc.c */ +#line 2250 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 577: - -/* Line 1806 of yacc.c */ -#line 2244 "parser.yy" + case 580: + +/* Line 1806 of yacc.c */ +#line 2253 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 578: - -/* Line 1806 of yacc.c */ -#line 2249 "parser.yy" + case 581: + +/* Line 1806 of yacc.c */ +#line 2258 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; - case 579: - -/* Line 1806 of yacc.c */ -#line 2251 "parser.yy" + case 582: + +/* Line 1806 of yacc.c */ +#line 2260 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 580: - -/* Line 1806 of yacc.c */ -#line 2253 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 581: - -/* Line 1806 of yacc.c */ -#line 2258 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 582: - -/* Line 1806 of yacc.c */ -#line 2260 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8196,5 +8188,5 @@ /* Line 1806 of yacc.c */ #line 2267 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8203,5 +8195,5 @@ /* Line 1806 of yacc.c */ #line 2269 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8213,37 +8205,37 @@ break; - case 590: - -/* Line 1806 of yacc.c */ -#line 2286 "parser.yy" + case 587: + +/* Line 1806 of yacc.c */ +#line 2276 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 588: + +/* Line 1806 of yacc.c */ +#line 2278 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 589: + +/* Line 1806 of yacc.c */ +#line 2280 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 593: + +/* Line 1806 of yacc.c */ +#line 2295 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); } break; - case 591: - -/* Line 1806 of yacc.c */ -#line 2288 "parser.yy" + case 594: + +/* Line 1806 of yacc.c */ +#line 2297 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); } - break; - - case 592: - -/* Line 1806 of yacc.c */ -#line 2290 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 593: - -/* Line 1806 of yacc.c */ -#line 2295 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 594: - -/* Line 1806 of yacc.c */ -#line 2297 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8259,5 +8251,5 @@ /* Line 1806 of yacc.c */ #line 2304 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8266,5 +8258,5 @@ /* Line 1806 of yacc.c */ #line 2306 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8279,41 +8271,41 @@ /* Line 1806 of yacc.c */ -#line 2323 "parser.yy" +#line 2313 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 600: + +/* Line 1806 of yacc.c */ +#line 2315 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 601: + +/* Line 1806 of yacc.c */ +#line 2317 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 602: + +/* Line 1806 of yacc.c */ +#line 2332 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 601: - -/* Line 1806 of yacc.c */ -#line 2326 "parser.yy" + case 604: + +/* Line 1806 of yacc.c */ +#line 2335 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 602: - -/* Line 1806 of yacc.c */ -#line 2328 "parser.yy" + case 605: + +/* Line 1806 of yacc.c */ +#line 2337 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 604: - -/* Line 1806 of yacc.c */ -#line 2334 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 605: - -/* Line 1806 of yacc.c */ -#line 2339 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 606: - -/* Line 1806 of yacc.c */ -#line 2341 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8329,40 +8321,40 @@ /* Line 1806 of yacc.c */ #line 2348 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 609: + +/* Line 1806 of yacc.c */ +#line 2350 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 610: + +/* Line 1806 of yacc.c */ +#line 2352 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 611: + +/* Line 1806 of yacc.c */ +#line 2357 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 609: - -/* Line 1806 of yacc.c */ -#line 2350 "parser.yy" + case 612: + +/* Line 1806 of yacc.c */ +#line 2359 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 610: - -/* Line 1806 of yacc.c */ -#line 2352 "parser.yy" + case 613: + +/* Line 1806 of yacc.c */ +#line 2361 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 611: - -/* Line 1806 of yacc.c */ -#line 2354 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 612: - -/* Line 1806 of yacc.c */ -#line 2359 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } - break; - - case 613: - -/* Line 1806 of yacc.c */ -#line 2361 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8377,83 +8369,83 @@ /* Line 1806 of yacc.c */ -#line 2373 "parser.yy" +#line 2368 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } + break; + + case 616: + +/* Line 1806 of yacc.c */ +#line 2370 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 617: + +/* Line 1806 of yacc.c */ +#line 2372 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 618: + +/* Line 1806 of yacc.c */ +#line 2382 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 617: - -/* Line 1806 of yacc.c */ -#line 2376 "parser.yy" + case 620: + +/* Line 1806 of yacc.c */ +#line 2385 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 618: - -/* Line 1806 of yacc.c */ -#line 2378 "parser.yy" + case 621: + +/* Line 1806 of yacc.c */ +#line 2387 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 619: - -/* Line 1806 of yacc.c */ -#line 2383 "parser.yy" + case 622: + +/* Line 1806 of yacc.c */ +#line 2392 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 620: - -/* Line 1806 of yacc.c */ -#line 2385 "parser.yy" + case 623: + +/* Line 1806 of yacc.c */ +#line 2394 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 621: - -/* Line 1806 of yacc.c */ -#line 2387 "parser.yy" + case 624: + +/* Line 1806 of yacc.c */ +#line 2396 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 622: - -/* Line 1806 of yacc.c */ -#line 2392 "parser.yy" + case 625: + +/* Line 1806 of yacc.c */ +#line 2401 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 623: - -/* Line 1806 of yacc.c */ -#line 2394 "parser.yy" + case 626: + +/* Line 1806 of yacc.c */ +#line 2403 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 624: - -/* Line 1806 of yacc.c */ -#line 2396 "parser.yy" + case 627: + +/* Line 1806 of yacc.c */ +#line 2405 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 625: - -/* Line 1806 of yacc.c */ -#line 2398 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 626: - -/* Line 1806 of yacc.c */ -#line 2403 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } - break; - - case 627: - -/* Line 1806 of yacc.c */ -#line 2405 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8468,26 +8460,47 @@ /* Line 1806 of yacc.c */ -#line 2438 "parser.yy" +#line 2412 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } + break; + + case 630: + +/* Line 1806 of yacc.c */ +#line 2414 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 631: + +/* Line 1806 of yacc.c */ +#line 2416 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 632: + +/* Line 1806 of yacc.c */ +#line 2447 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 631: - -/* Line 1806 of yacc.c */ -#line 2441 "parser.yy" + case 634: + +/* Line 1806 of yacc.c */ +#line 2450 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 632: - -/* Line 1806 of yacc.c */ -#line 2443 "parser.yy" + case 635: + +/* Line 1806 of yacc.c */ +#line 2452 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 633: - -/* Line 1806 of yacc.c */ -#line 2448 "parser.yy" + case 636: + +/* Line 1806 of yacc.c */ +#line 2457 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8496,8 +8509,8 @@ break; - case 634: - -/* Line 1806 of yacc.c */ -#line 2453 "parser.yy" + case 637: + +/* Line 1806 of yacc.c */ +#line 2462 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8506,135 +8519,114 @@ break; - case 635: - -/* Line 1806 of yacc.c */ -#line 2461 "parser.yy" + case 638: + +/* Line 1806 of yacc.c */ +#line 2470 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 636: - -/* Line 1806 of yacc.c */ -#line 2463 "parser.yy" + case 639: + +/* Line 1806 of yacc.c */ +#line 2472 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 637: - -/* Line 1806 of yacc.c */ -#line 2465 "parser.yy" + case 640: + +/* Line 1806 of yacc.c */ +#line 2474 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 638: - -/* Line 1806 of yacc.c */ -#line 2470 "parser.yy" + case 641: + +/* Line 1806 of yacc.c */ +#line 2479 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 639: - -/* Line 1806 of yacc.c */ -#line 2472 "parser.yy" + case 642: + +/* Line 1806 of yacc.c */ +#line 2481 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 640: - -/* Line 1806 of yacc.c */ -#line 2477 "parser.yy" + case 643: + +/* Line 1806 of yacc.c */ +#line 2486 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; - case 641: - -/* Line 1806 of yacc.c */ -#line 2479 "parser.yy" + case 644: + +/* Line 1806 of yacc.c */ +#line 2488 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 643: - -/* Line 1806 of yacc.c */ -#line 2494 "parser.yy" + case 646: + +/* Line 1806 of yacc.c */ +#line 2503 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 644: - -/* Line 1806 of yacc.c */ -#line 2496 "parser.yy" + case 647: + +/* Line 1806 of yacc.c */ +#line 2505 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 645: - -/* Line 1806 of yacc.c */ -#line 2501 "parser.yy" + case 648: + +/* Line 1806 of yacc.c */ +#line 2510 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; - case 646: - -/* Line 1806 of yacc.c */ -#line 2503 "parser.yy" + case 649: + +/* Line 1806 of yacc.c */ +#line 2512 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; - case 647: - -/* Line 1806 of yacc.c */ -#line 2505 "parser.yy" + case 650: + +/* Line 1806 of yacc.c */ +#line 2514 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 648: - -/* Line 1806 of yacc.c */ -#line 2507 "parser.yy" + case 651: + +/* Line 1806 of yacc.c */ +#line 2516 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 649: - -/* Line 1806 of yacc.c */ -#line 2509 "parser.yy" + case 652: + +/* Line 1806 of yacc.c */ +#line 2518 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 651: - -/* Line 1806 of yacc.c */ -#line 2515 "parser.yy" + case 654: + +/* Line 1806 of yacc.c */ +#line 2524 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 652: - -/* Line 1806 of yacc.c */ -#line 2517 "parser.yy" + case 655: + +/* Line 1806 of yacc.c */ +#line 2526 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 653: - -/* Line 1806 of yacc.c */ -#line 2519 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 654: - -/* Line 1806 of yacc.c */ -#line 2524 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); } - break; - - case 655: - -/* Line 1806 of yacc.c */ -#line 2526 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8649,125 +8641,125 @@ /* Line 1806 of yacc.c */ -#line 2534 "parser.yy" +#line 2533 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); } + break; + + case 658: + +/* Line 1806 of yacc.c */ +#line 2535 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 659: + +/* Line 1806 of yacc.c */ +#line 2537 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 660: + +/* Line 1806 of yacc.c */ +#line 2543 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } break; - case 658: - -/* Line 1806 of yacc.c */ -#line 2536 "parser.yy" + case 661: + +/* Line 1806 of yacc.c */ +#line 2545 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); } break; - case 660: - -/* Line 1806 of yacc.c */ -#line 2542 "parser.yy" + case 663: + +/* Line 1806 of yacc.c */ +#line 2551 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); } break; - case 661: - -/* Line 1806 of yacc.c */ -#line 2544 "parser.yy" + case 664: + +/* Line 1806 of yacc.c */ +#line 2553 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( 0 ); } break; - case 662: - -/* Line 1806 of yacc.c */ -#line 2546 "parser.yy" + case 665: + +/* Line 1806 of yacc.c */ +#line 2555 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); } break; - case 663: - -/* Line 1806 of yacc.c */ -#line 2548 "parser.yy" + case 666: + +/* Line 1806 of yacc.c */ +#line 2557 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); } break; - case 665: - -/* Line 1806 of yacc.c */ -#line 2563 "parser.yy" + case 668: + +/* Line 1806 of yacc.c */ +#line 2572 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 666: - -/* Line 1806 of yacc.c */ -#line 2565 "parser.yy" + case 669: + +/* Line 1806 of yacc.c */ +#line 2574 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 667: - -/* Line 1806 of yacc.c */ -#line 2570 "parser.yy" + case 670: + +/* Line 1806 of yacc.c */ +#line 2579 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; - case 668: - -/* Line 1806 of yacc.c */ -#line 2572 "parser.yy" + case 671: + +/* Line 1806 of yacc.c */ +#line 2581 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; - case 669: - -/* Line 1806 of yacc.c */ -#line 2574 "parser.yy" + case 672: + +/* Line 1806 of yacc.c */ +#line 2583 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 670: - -/* Line 1806 of yacc.c */ -#line 2576 "parser.yy" + case 673: + +/* Line 1806 of yacc.c */ +#line 2585 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 671: - -/* Line 1806 of yacc.c */ -#line 2578 "parser.yy" + case 674: + +/* Line 1806 of yacc.c */ +#line 2587 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 673: - -/* Line 1806 of yacc.c */ -#line 2584 "parser.yy" + case 676: + +/* Line 1806 of yacc.c */ +#line 2593 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 674: - -/* Line 1806 of yacc.c */ -#line 2586 "parser.yy" + case 677: + +/* Line 1806 of yacc.c */ +#line 2595 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 675: - -/* Line 1806 of yacc.c */ -#line 2588 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 676: - -/* Line 1806 of yacc.c */ -#line 2593 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); } - break; - - case 677: - -/* Line 1806 of yacc.c */ -#line 2595 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8779,401 +8771,415 @@ break; + case 679: + +/* Line 1806 of yacc.c */ +#line 2602 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); } + break; + case 680: /* Line 1806 of yacc.c */ #line 2604 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 681: + +/* Line 1806 of yacc.c */ +#line 2606 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 683: + +/* Line 1806 of yacc.c */ +#line 2613 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 682: - -/* Line 1806 of yacc.c */ -#line 2615 "parser.yy" + case 685: + +/* Line 1806 of yacc.c */ +#line 2624 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } break; - case 683: - -/* Line 1806 of yacc.c */ -#line 2618 "parser.yy" + case 686: + +/* Line 1806 of yacc.c */ +#line 2627 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } break; - case 684: - -/* Line 1806 of yacc.c */ -#line 2620 "parser.yy" + case 687: + +/* Line 1806 of yacc.c */ +#line 2629 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); } break; - case 685: - -/* Line 1806 of yacc.c */ -#line 2623 "parser.yy" + case 688: + +/* Line 1806 of yacc.c */ +#line 2632 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } break; - case 686: - -/* Line 1806 of yacc.c */ -#line 2625 "parser.yy" + case 689: + +/* Line 1806 of yacc.c */ +#line 2634 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); } break; - case 687: - -/* Line 1806 of yacc.c */ -#line 2627 "parser.yy" + case 690: + +/* Line 1806 of yacc.c */ +#line 2636 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); } break; - case 689: - -/* Line 1806 of yacc.c */ -#line 2641 "parser.yy" + case 692: + +/* Line 1806 of yacc.c */ +#line 2650 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 690: - -/* Line 1806 of yacc.c */ -#line 2643 "parser.yy" + case 693: + +/* Line 1806 of yacc.c */ +#line 2652 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 691: - -/* Line 1806 of yacc.c */ -#line 2648 "parser.yy" + case 694: + +/* Line 1806 of yacc.c */ +#line 2657 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; - case 692: - -/* Line 1806 of yacc.c */ -#line 2650 "parser.yy" + case 695: + +/* Line 1806 of yacc.c */ +#line 2659 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; - case 693: - -/* Line 1806 of yacc.c */ -#line 2652 "parser.yy" + case 696: + +/* Line 1806 of yacc.c */ +#line 2661 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 694: - -/* Line 1806 of yacc.c */ -#line 2654 "parser.yy" + case 697: + +/* Line 1806 of yacc.c */ +#line 2663 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 695: - -/* Line 1806 of yacc.c */ -#line 2656 "parser.yy" + case 698: + +/* Line 1806 of yacc.c */ +#line 2665 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 697: - -/* Line 1806 of yacc.c */ -#line 2662 "parser.yy" + case 700: + +/* Line 1806 of yacc.c */ +#line 2671 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 698: - -/* Line 1806 of yacc.c */ -#line 2664 "parser.yy" + case 701: + +/* Line 1806 of yacc.c */ +#line 2673 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 699: - -/* Line 1806 of yacc.c */ -#line 2666 "parser.yy" + case 702: + +/* Line 1806 of yacc.c */ +#line 2675 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 700: - -/* Line 1806 of yacc.c */ -#line 2671 "parser.yy" + case 703: + +/* Line 1806 of yacc.c */ +#line 2680 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 701: - -/* Line 1806 of yacc.c */ -#line 2673 "parser.yy" + case 704: + +/* Line 1806 of yacc.c */ +#line 2682 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 704: - -/* Line 1806 of yacc.c */ -#line 2683 "parser.yy" + case 707: + +/* Line 1806 of yacc.c */ +#line 2692 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 707: - -/* Line 1806 of yacc.c */ -#line 2693 "parser.yy" + case 710: + +/* Line 1806 of yacc.c */ +#line 2702 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 708: - -/* Line 1806 of yacc.c */ -#line 2695 "parser.yy" + case 711: + +/* Line 1806 of yacc.c */ +#line 2704 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 709: - -/* Line 1806 of yacc.c */ -#line 2697 "parser.yy" + case 712: + +/* Line 1806 of yacc.c */ +#line 2706 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 710: - -/* Line 1806 of yacc.c */ -#line 2699 "parser.yy" + case 713: + +/* Line 1806 of yacc.c */ +#line 2708 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 711: - -/* Line 1806 of yacc.c */ -#line 2701 "parser.yy" + case 714: + +/* Line 1806 of yacc.c */ +#line 2710 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 712: - -/* Line 1806 of yacc.c */ -#line 2703 "parser.yy" + case 715: + +/* Line 1806 of yacc.c */ +#line 2712 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 713: - -/* Line 1806 of yacc.c */ -#line 2710 "parser.yy" + case 716: + +/* Line 1806 of yacc.c */ +#line 2719 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 714: - -/* Line 1806 of yacc.c */ -#line 2712 "parser.yy" + case 717: + +/* Line 1806 of yacc.c */ +#line 2721 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 715: - -/* Line 1806 of yacc.c */ -#line 2714 "parser.yy" + case 718: + +/* Line 1806 of yacc.c */ +#line 2723 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 716: - -/* Line 1806 of yacc.c */ -#line 2716 "parser.yy" + case 719: + +/* Line 1806 of yacc.c */ +#line 2725 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } break; - case 717: - -/* Line 1806 of yacc.c */ -#line 2718 "parser.yy" + case 720: + +/* Line 1806 of yacc.c */ +#line 2727 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 718: - -/* Line 1806 of yacc.c */ -#line 2720 "parser.yy" + case 721: + +/* Line 1806 of yacc.c */ +#line 2729 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 719: - -/* Line 1806 of yacc.c */ -#line 2722 "parser.yy" + case 722: + +/* Line 1806 of yacc.c */ +#line 2731 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 720: - -/* Line 1806 of yacc.c */ -#line 2724 "parser.yy" + case 723: + +/* Line 1806 of yacc.c */ +#line 2733 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 721: - -/* Line 1806 of yacc.c */ -#line 2726 "parser.yy" + case 724: + +/* Line 1806 of yacc.c */ +#line 2735 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } break; - case 722: - -/* Line 1806 of yacc.c */ -#line 2728 "parser.yy" + case 725: + +/* Line 1806 of yacc.c */ +#line 2737 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 723: - -/* Line 1806 of yacc.c */ -#line 2733 "parser.yy" + case 726: + +/* Line 1806 of yacc.c */ +#line 2742 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } break; - case 724: - -/* Line 1806 of yacc.c */ -#line 2735 "parser.yy" + case 727: + +/* Line 1806 of yacc.c */ +#line 2744 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } break; - case 725: - -/* Line 1806 of yacc.c */ -#line 2740 "parser.yy" + case 728: + +/* Line 1806 of yacc.c */ +#line 2749 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); } break; - case 726: - -/* Line 1806 of yacc.c */ -#line 2742 "parser.yy" + case 729: + +/* Line 1806 of yacc.c */ +#line 2751 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); } break; - case 728: - -/* Line 1806 of yacc.c */ -#line 2769 "parser.yy" + case 731: + +/* Line 1806 of yacc.c */ +#line 2778 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 732: - -/* Line 1806 of yacc.c */ -#line 2780 "parser.yy" + case 735: + +/* Line 1806 of yacc.c */ +#line 2789 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 733: - -/* Line 1806 of yacc.c */ -#line 2782 "parser.yy" + case 736: + +/* Line 1806 of yacc.c */ +#line 2791 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 734: - -/* Line 1806 of yacc.c */ -#line 2784 "parser.yy" + case 737: + +/* Line 1806 of yacc.c */ +#line 2793 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 735: - -/* Line 1806 of yacc.c */ -#line 2786 "parser.yy" + case 738: + +/* Line 1806 of yacc.c */ +#line 2795 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 736: - -/* Line 1806 of yacc.c */ -#line 2788 "parser.yy" + case 739: + +/* Line 1806 of yacc.c */ +#line 2797 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 737: - -/* Line 1806 of yacc.c */ -#line 2790 "parser.yy" + case 740: + +/* Line 1806 of yacc.c */ +#line 2799 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 738: - -/* Line 1806 of yacc.c */ -#line 2797 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 739: - -/* Line 1806 of yacc.c */ -#line 2799 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 740: - -/* Line 1806 of yacc.c */ -#line 2801 "parser.yy" + case 741: + +/* Line 1806 of yacc.c */ +#line 2806 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } + break; + + case 742: + +/* Line 1806 of yacc.c */ +#line 2808 "parser.yy" + { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } + break; + + case 743: + +/* Line 1806 of yacc.c */ +#line 2810 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 741: - -/* Line 1806 of yacc.c */ -#line 2803 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 742: - -/* Line 1806 of yacc.c */ -#line 2805 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 743: - -/* Line 1806 of yacc.c */ -#line 2807 "parser.yy" + case 744: + +/* Line 1806 of yacc.c */ +#line 2812 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } + break; + + case 745: + +/* Line 1806 of yacc.c */ +#line 2814 "parser.yy" + { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } + break; + + case 746: + +/* Line 1806 of yacc.c */ +#line 2816 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 744: - -/* Line 1806 of yacc.c */ -#line 2812 "parser.yy" + case 747: + +/* Line 1806 of yacc.c */ +#line 2821 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } break; - case 745: - -/* Line 1806 of yacc.c */ -#line 2817 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); } - break; - - case 746: - -/* Line 1806 of yacc.c */ -#line 2819 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); } - break; - - case 747: - -/* Line 1806 of yacc.c */ -#line 2821 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); } + case 748: + +/* Line 1806 of yacc.c */ +#line 2826 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), (yyvsp[(4) - (5)].decl), nullptr ); } + break; + + case 749: + +/* Line 1806 of yacc.c */ +#line 2828 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); } break; @@ -9181,12 +9187,19 @@ /* Line 1806 of yacc.c */ -#line 2845 "parser.yy" +#line 2830 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); } + break; + + case 753: + +/* Line 1806 of yacc.c */ +#line 2854 "parser.yy" { (yyval.en) = 0; } break; - case 751: - -/* Line 1806 of yacc.c */ -#line 2847 "parser.yy" + case 754: + +/* Line 1806 of yacc.c */ +#line 2856 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; @@ -9195,5 +9208,5 @@ /* Line 1806 of yacc.c */ -#line 9198 "Parser/parser.cc" +#line 9211 "Parser/parser.cc" default: break; } @@ -9426,5 +9439,5 @@ /* Line 2067 of yacc.c */ -#line 2850 "parser.yy" +#line 2859 "parser.yy" // ----end of grammar---- @@ -9433,9 +9446,9 @@ void yyerror( const char * ) { - std::cout << "Error "; + cout << "Error "; if ( yyfilename ) { - std::cout << "in file " << yyfilename << " "; + cout << "in file " << yyfilename << " "; } // if - std::cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << std::endl; + cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << endl; } Index: src/Parser/parser.h =================================================================== --- src/Parser/parser.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/parser.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -262,5 +262,5 @@ /* Line 2068 of yacc.c */ -#line 115 "parser.yy" +#line 116 "parser.yy" Token tok; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/parser.yy (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 12 17:29:45 2016 -// Update Count : 1969 +// Last Modified On : Wed Oct 5 14:10:46 2016 +// Update Count : 2002 // @@ -54,4 +54,5 @@ #include "TypeData.h" #include "LinkageSpec.h" +using namespace std; extern DeclarationNode * parseTree; @@ -59,7 +60,7 @@ extern TypedefTable typedefTable; -std::stack< LinkageSpec::Spec > linkageStack; - -void appendStr( std::string *to, std::string *from ) { +stack< LinkageSpec::Spec > linkageStack; + +void appendStr( string *to, string *from ) { // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string. to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) ); @@ -195,4 +196,5 @@ %type field_declaration field_declaration_list field_declarator field_declaring_list %type field field_list +%type field_name %type external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr @@ -359,5 +361,5 @@ { $$ = $2; } | '(' compound_statement ')' // GCC, lambda expression - { $$ = new ExpressionNode( build_valexpr( $2 ) ); } + { $$ = new ExpressionNode( build_valexpr( $2 ) ); } ; @@ -378,4 +380,6 @@ | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); } + | postfix_expression '.' INTEGERconstant + { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); } | postfix_expression ARROW no_attr_identifier { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); } @@ -391,5 +395,5 @@ { Token fn; - fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? + fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) ); } @@ -414,16 +418,21 @@ field: // CFA, tuple field selector - no_attr_identifier - { $$ = new ExpressionNode( build_varref( $1 ) ); } + field_name // ambiguity with .0 so space required after field-selection, e.g. // struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1; - | no_attr_identifier '.' field + { $$ = new ExpressionNode( build_varref( $1 ) ); } + | field_name '.' field { $$ = new ExpressionNode( build_fieldSel( $3, build_varref( $1 ) ) ); } - | no_attr_identifier '.' '[' push field_list pop ']' + | field_name '.' '[' push field_list pop ']' { $$ = new ExpressionNode( build_fieldSel( $5, build_varref( $1 ) ) ); } - | no_attr_identifier ARROW field + | field_name ARROW field { $$ = new ExpressionNode( build_pfieldSel( $3, build_varref( $1 ) ) ); } - | no_attr_identifier ARROW '[' push field_list pop ']' + | field_name ARROW '[' push field_list pop ']' { $$ = new ExpressionNode( build_pfieldSel( $5, build_varref( $1 ) ) ); } + ; + +field_name: + no_attr_identifier + | INTEGERconstant ; @@ -668,5 +677,5 @@ { Token fn; - fn.str = new std::string( "^?{}" ); // location undefined + fn.str = new string( "^?{}" ); // location undefined $$ = new StatementNode( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) ) ) ); } @@ -898,5 +907,5 @@ { $$ = new StatementNode( build_catch( $5, $8 ) ); } | handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop - { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $6, $9 ) ) ); } + { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $6, $9 ) ) ); } | CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop { $$ = new StatementNode( build_catch( $5, $8 ) ); } @@ -970,5 +979,5 @@ { $$ = new ExpressionNode( build_asmexpr( 0, $1, $3 ) ); } | '[' constant_expression ']' string_literal '(' constant_expression ')' - { $$ = new ExpressionNode( build_asmexpr( $2, $4, $6 ) ); } + { $$ = new ExpressionNode( build_asmexpr( $2, $4, $6 ) ); } ; @@ -1469,16 +1478,16 @@ aggregate_name: aggregate_key '{' field_declaration_list '}' - { $$ = DeclarationNode::newAggregate( $1, 0, 0, $3, true ); } + { $$ = DeclarationNode::newAggregate( $1, nullptr, nullptr, $3, true ); } | aggregate_key no_attr_identifier_or_type_name { typedefTable.makeTypedef( *$2 ); - $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, false ); + $$ = DeclarationNode::newAggregate( $1, $2, nullptr, nullptr, false ); } | aggregate_key no_attr_identifier_or_type_name { typedefTable.makeTypedef( *$2 ); } '{' field_declaration_list '}' - { $$ = DeclarationNode::newAggregate( $1, $2, 0, $5, true ); } + { $$ = DeclarationNode::newAggregate( $1, $2, nullptr, $5, true ); } | aggregate_key '(' type_name_list ')' '{' field_declaration_list '}' // CFA - { $$ = DeclarationNode::newAggregate( $1, 0, $3, $6, false ); } + { $$ = DeclarationNode::newAggregate( $1, nullptr, $3, $6, false ); } | aggregate_key typegen_name // CFA, S/R conflict { $$ = $2; } @@ -1561,5 +1570,5 @@ enum_name: enum_key '{' enumerator_list comma_opt '}' - { $$ = DeclarationNode::newEnum( 0, $3 ); } + { $$ = DeclarationNode::newEnum( nullptr, $3 ); } | enum_key no_attr_identifier_or_type_name { @@ -2006,5 +2015,5 @@ { linkageStack.push( linkage ); // handle nested extern "C"/"Cforall" - linkage = LinkageSpec::fromString( *$2 ); + linkage = LinkageSpec::linkageCheck( $2 ); } '{' external_definition_list_opt '}' // C++-style linkage specifier @@ -2522,5 +2531,5 @@ abstract_function: '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); } | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } @@ -2591,5 +2600,5 @@ abstract_parameter_function: '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); } | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } @@ -2795,13 +2804,13 @@ // empty (void) function return type. '[' ']' type_specifier - { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } | '[' ']' multi_array_dimension type_specifier - { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } | multi_array_dimension type_specifier { $$ = $2->addNewArray( $1 ); } | '[' ']' new_abstract_ptr - { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } | '[' ']' multi_array_dimension new_abstract_ptr - { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } | multi_array_dimension new_abstract_ptr { $$ = $2->addNewArray( $1 ); } @@ -2815,9 +2824,9 @@ new_abstract_function: // CFA '[' ']' '(' new_parameter_type_list_opt ')' - { $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $4, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, nullptr ); } | new_abstract_tuple '(' push new_parameter_type_list_opt pop ')' - { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); } | new_function_return '(' push new_parameter_type_list_opt pop ')' - { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); } ; @@ -2854,9 +2863,9 @@ void yyerror( const char * ) { - std::cout << "Error "; + cout << "Error "; if ( yyfilename ) { - std::cout << "in file " << yyfilename << " "; + cout << "in file " << yyfilename << " "; } // if - std::cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << std::endl; + cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << endl; } Index: src/SynTree/FunctionDecl.cc =================================================================== --- src/SynTree/FunctionDecl.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/SynTree/FunctionDecl.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 18 23:50:14 2016 -// Update Count : 20 +// Last Modified On : Sat Oct 1 23:06:32 2016 +// Update Count : 21 // @@ -60,5 +60,5 @@ } // if if ( get_linkage() != LinkageSpec::Cforall ) { - os << LinkageSpec::toString( get_linkage() ) << " "; + os << LinkageSpec::linkageName( get_linkage() ) << " "; } // if if ( get_isInline() ) { Index: src/SynTree/ObjectDecl.cc =================================================================== --- src/SynTree/ObjectDecl.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/SynTree/ObjectDecl.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 18 23:50:33 2016 -// Update Count : 31 +// Last Modified On : Sat Oct 1 23:05:56 2016 +// Update Count : 32 // @@ -44,5 +44,5 @@ if ( get_linkage() != LinkageSpec::Cforall ) { - os << LinkageSpec::toString( get_linkage() ) << " "; + os << LinkageSpec::linkageName( get_linkage() ) << " "; } // if Index: src/libcfa/memcheck.awk =================================================================== --- src/libcfa/memcheck.awk (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) +++ src/libcfa/memcheck.awk (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -0,0 +1,26 @@ +#!/usr/bin/nawk -f + +BEGIN { + print "Freed but not allocated:" +} + +/malloc/ { + alloc[ $2 ] = $3; +} + +/free/ { + if ( $2 in alloc ) { + delete alloc[ $2 ]; + } else { + print $2; + } # if +} + +END { + print "Allocated but not freed:" + for ( i in alloc ) { + print i, alloc[ i ]; + total += alloc[ i ] + } # for + print "total", total; +}