Changeset d107010


Ignore:
Timestamp:
Mar 4, 2017, 10:31:03 PM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
3f80888
Parents:
c3ebf37 (diff), 8191203 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

add signed/unsigned char to I/O

Files:
9 added
2 deleted
46 edited
2 moved

Legend:

Unmodified
Added
Removed
  • Jenkinsfile

    rc3ebf37 rd107010  
    173173
    174174def notify_server() {
    175         sh 'curl --silent -X POST http://plg2:8082/jenkins/notify > /dev/null'
     175        sh 'curl --silent -X POST http://plg2:8082/jenkins/notify > /dev/null || true'
    176176        return
    177177}
     
    320320
    321321                //Then publish the results
    322                 sh 'curl --silent --data @bench.csv http://plg2:8082/jenkins/publish > /dev/null'
     322                sh 'curl --silent --data @bench.csv http://plg2:8082/jenkins/publish > /dev/null || true'
    323323}
    324324
  • configure

    rc3ebf37 rd107010  
    31313131if test "${enable_threading+set}" = set; then :
    31323132  enableval=$enable_threading; case "${enableval}" in
    3133   yes) build_threading-"yes" ;;
     3133  yes) build_threading="yes" ;;
    31343134  no)  build_threading="no" ;;
    31353135  *) as_fn_error $? "bad value ${enableval} for --enable-debug" "$LINENO" 5 ;;
  • configure.ac

    rc3ebf37 rd107010  
    5959AC_ARG_ENABLE(threading, AS_HELP_STRING([--enable-threading], [Build and install libcfa with threading support (Enabled by default)]),
    6060[case "${enableval}" in
    61   yes) build_threading-"yes" ;;
     61  yes) build_threading="yes" ;;
    6262  no)  build_threading="no" ;;
    6363  *) AC_MSG_ERROR([bad value ${enableval} for --enable-debug]) ;;
  • doc/LaTeXmacros/common.tex

    rc3ebf37 rd107010  
    248248        morekeywords={_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto,
    249249                _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
    250                 fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert,
    251                 _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,},
     250                fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,one_t,otype,restrict,_Static_assert,
     251                _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,zero_t},
    252252}%
    253253
     
    263263escapechar=§,                                                                                   % LaTeX escape in CFA code §...§ (section symbol), emacs: C-q M-'
    264264mathescape=true,                                                                                % LaTeX math escape in CFA code $...$
    265 %keepspaces=true,                                                                               % 
     265%keepspaces=true,                                                                               %
    266266showstringspaces=false,                                                                 % do not show spaces with cup
    267267showlines=true,                                                                                 % show blank lines at end of code
  • src/CodeGen/CodeGenerator.cc

    rc3ebf37 rd107010  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:56:29 2017
    13 // Update Count     : 418
     12// Last Modified On : Fri Mar  3 21:18:47 2017
     13// Update Count     : 465
    1414//
    1515
     
    134134
    135135                handleStorageClass( functionDecl );
    136                 if ( functionDecl->get_isInline() ) {
    137                         output << "inline ";
    138                 } // if
    139                 if ( functionDecl->get_isNoreturn() ) {
    140                         output << "_Noreturn ";
    141                 } // if
     136                DeclarationNode::print_FuncSpec( output, functionDecl->get_funcSpec() );
     137
    142138                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty );
    143139
     
    835831        }
    836832
    837 
    838833        void CodeGenerator::visit( ReturnStmt * returnStmt ) {
    839834                output << "return ";
     
    899894        }
    900895
    901         void CodeGenerator::handleStorageClass( Declaration * decl ) {
     896        void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
    902897                switch ( decl->get_storageClass() ) {
     898                        //output << DeclarationNode::storageClassNames[decl->get_storageClass()] << ' ';
    903899                  case DeclarationNode::Extern:
    904900                        output << "extern ";
     
    913909                        output << "register ";
    914910                        break;
    915                   case DeclarationNode::Inline:
    916                         output << "inline ";
    917                         break;
    918                   case DeclarationNode::Fortran:
    919                         output << "fortran ";
    920                         break;
    921                   case DeclarationNode::Noreturn:
    922                         output << "_Noreturn ";
    923                         break;
    924911                  case DeclarationNode::Threadlocal:
    925                         output << "_Thread_local ";
    926                         break;
     912                        output << "_Thread_local ";
     913                        break;
    927914                  case DeclarationNode::NoStorageClass:
    928915                        break;
     916                  default:
     917                        assert( false );
    929918                } // switch
    930         }
     919        } // CodeGenerator::handleStorageClass
    931920
    932921        std::string genName( DeclarationWithType * decl ) {
  • src/CodeGen/CodeGenerator.h

    rc3ebf37 rd107010  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb  9 15:06:21 2017
    13 // Update Count     : 49
     12// Last Modified On : Wed Mar  1 16:20:04 2017
     13// Update Count     : 50
    1414//
    1515
     
    123123
    124124                void printDesignators( std::list< Expression * > & );
    125                 void handleStorageClass( Declaration *decl );
     125                void handleStorageClass( DeclarationWithType *decl );
    126126                void handleAggregate( AggregateDecl *aggDecl );
    127127                void handleTypedef( NamedTypeDecl *namedType );
  • src/CodeGen/FixNames.cc

    rc3ebf37 rd107010  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Mon Apr 11 15:38:10 2016
    13 // Update Count     : 1
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Mar  3 21:52:17 2017
     13// Update Count     : 6
    1414//
    1515
     
    4444                        LinkageSpec::Cforall,
    4545                        main_type = new FunctionType( Type::Qualifiers(), true ),
    46                         nullptr, false, false
     46                        nullptr
    4747                ) };
    4848                main_type->get_returnVals().push_back(
     
    5050                );
    5151
    52                 auto&& name = SymTab::Mangler::mangle( mainDecl.get() );
     52                auto && name = SymTab::Mangler::mangle( mainDecl.get() );
    5353                // std::cerr << name << std::endl;
    5454                return name;
     
    6161                        LinkageSpec::Cforall,
    6262                        main_type = new FunctionType( Type::Qualifiers(), false ),
    63                         nullptr, false, false
     63                        nullptr
    6464                ) };
    6565                main_type->get_returnVals().push_back(
  • src/CodeTools/DeclStats.cc

    rc3ebf37 rd107010  
    6363                        std::map<unsigned, unsigned> p_poly;   ///< Count of decls with each percentage of polymorphic elements
    6464                        VectorMap<unsigned> n_types;           ///< Count of decls with each number of distinct types in the pack
     65                        /// Count of decls with each percentage of new types in lists.
     66                        /// Types used in the parameter list that recur in the return list are not considered to be new.
     67                        std::map<unsigned, unsigned> p_new;
    6568
    6669                        ArgPackStats& operator+= (const ArgPackStats& o) {
     
    7174                                sum(p_poly, o.p_poly);
    7275                                sum(n_types, o.n_types);
     76                                sum(p_new, o.p_new);
    7377                               
    7478                                return *this;
     
    8690                        /// Count of uses of each non-basic type
    8791                        std::unordered_map<std::string, unsigned> compound_type_names;
     92                        /// Count of decls using each basic type
     93                        std::unordered_map<std::string, unsigned> basic_type_decls;
     94                        /// Count of decls using each compound type
     95                        std::unordered_map<std::string, unsigned> compound_type_decls;
    8896                        /// Stats for the parameter list
    8997                        ArgPackStats params;
     
    98106                        ArgPackStats assn_returns;
    99107                       
    100                         Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
     108                        Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), basic_type_decls(), compound_type_decls(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
    101109
    102110                public:
     
    107115                                sum( basic_type_names, o.basic_type_names );
    108116                                sum( compound_type_names, o.compound_type_names );
     117                                sum( basic_type_decls, o.basic_type_decls );
     118                                sum( compound_type_decls, o.compound_type_decls );
    109119                                sum( params, o.params );
    110120                                sum( returns, o.returns );
     
    120130                std::unordered_set<std::string> seen_names;  ///< Stores manglenames already seen to avoid double-counting
    121131                Stats total;
     132                /// Count of expressions with (depth, fanout)
     133                std::map<std::pair<unsigned, unsigned>, unsigned> exprs_by_fanout_at_depth;
    122134
    123135                /// Update arg pack stats based on a declaration list
    124                 void analyze( Stats& stats, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
     136                void analyze( Stats& stats, std::unordered_set<std::string>& seen, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
    125137                        std::unordered_set<std::string> types;
    126                         unsigned n = 0;
    127                         unsigned n_basic = 0;
    128                         unsigned n_poly = 0;
     138                        unsigned n = 0;        ///< number of args/returns
     139                        unsigned n_basic = 0;  ///< number of basic types
     140                        unsigned n_poly = 0;   ///< number of polymorphic types
     141                        unsigned n_new = 0;    ///< number of new types
    129142                        for ( auto decl : decls ) {
    130143                                Type* dt = decl->get_type();
     
    135148                                dt->print( ss );
    136149                                types.insert( ss.str() );
     150                                bool this_new = seen.insert( ss.str() ).second;
     151                                if ( this_new ) { ++n_new; }
    137152
    138153                                if ( dynamic_cast<BasicType*>( dt ) ) {
    139154                                        ++n_basic;
    140155                                        ++stats.basic_type_names[ ss.str() ];
     156                                        if ( this_new ) {
     157                                                ++stats.basic_type_decls[ ss.str() ];
     158                                        }
    141159                                } else if ( GenPoly::hasPolyBase( dt ) ) {
    142160                                        ++n_poly;
    143161                                } else {
    144162                                        ++stats.compound_type_names[ ss.str() ];
     163                                        if ( this_new ) {
     164                                                ++stats.compound_type_decls[ ss.str() ];
     165                                        }
    145166                                }
    146167                        }
     
    151172                                ++pstats.p_basic[ n_basic*100/n ];
    152173                                ++pstats.p_poly[ n_poly*100/n ];
     174                                ++pstats.p_new[ n_new*100/n ];
    153175                        }
    154176                        ++pstats.n_types.at( types.size() );
     
    156178               
    157179                void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) {
    158                         analyze( stats, params, fnTy->get_parameters() );
    159                         analyze( stats, returns, fnTy->get_returnVals() );
     180                        std::unordered_set<std::string> seen;
     181                        analyze( stats, seen, params, fnTy->get_parameters() );
     182                        analyze( stats, seen, returns, fnTy->get_returnVals() );
     183                }
     184
     185                void analyzeExpr( UntypedExpr *expr, unsigned depth ) {
     186                        auto& args = expr->get_args();
     187                        unsigned fanout = args.size();
     188                        ++exprs_by_fanout_at_depth[ std::make_pair(depth, fanout) ];
     189                        for ( Expression* arg : args ) {
     190                                if ( UntypedExpr *uearg = dynamic_cast<UntypedExpr*>(arg) ) {
     191                                        analyzeExpr( uearg, depth+1 );
     192                                }
     193                        }
    160194                }
    161195
     
    166200                        // skip if already seen declaration for this function
    167201                        const std::string& mangleName = decl->get_mangleName().empty() ? decl->get_name() : decl->get_mangleName();
    168                         if ( ! seen_names.insert( mangleName ).second ) return;
     202                        if ( ! seen_names.insert( mangleName ).second ) {
     203                                maybeAccept( decl->get_statements(), *this );
     204                                return;
     205                        }
    169206                       
    170207                        Stats& stats = for_linkage[ decl->get_linkage() ];
     
    194231
    195232                        analyzeFunc( fnTy, stats, stats.params, stats.returns );
     233
     234                        // analyze expressions in decl statements
     235                        maybeAccept( decl->get_statements(), *this );
     236                }
     237
     238                virtual void visit( UntypedExpr *expr ) {
     239                        analyzeExpr( expr, 0 );
    196240                }
    197241
     
    275319                        printAllMap("%_poly_" + name, [&extract](const Stats& stats) { return extract(stats).p_poly; });
    276320                        printAllMap("n_distinct_types_" + name, [&extract](const Stats& stats) { return extract(stats).n_types; });
     321                        printAllMap("%_new_types_in_" + name, [&extract](const Stats& stats) { return extract(stats).p_new; });
     322                }
     323
     324                void printPairMap( const std::string& name,
     325                                   const std::map<std::pair<unsigned, unsigned>, unsigned>& map ) {
     326                        for ( const auto& entry : map ) {
     327                                const auto& key = entry.first;
     328                                std::cout << "\"" << name << "\"," << key.first << "," << key.second << ","
     329                                          << entry.second << std::endl;
     330                        }
    277331                }
    278332               
     
    291345                        printAll("basic_type_names", [](const Stats& stats) { return stats.basic_type_names.size(); });
    292346                        printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; });
     347                        printAllSparseHisto("decls_using_basic_type", [](const Stats& stats) { return stats.basic_type_decls; });
    293348                        printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); });
    294349                        printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; });
     350                        printAllSparseHisto("decls_using_compound_type", [](const Stats& stats) { return stats.compound_type_decls; });
    295351                        printAllPack("params", [](const Stats& stats) { return stats.params; });
    296352                        printAllPack("returns", [](const Stats& stats) { return stats.returns; });
     
    298354                        printAllPack("assn_params", [](const Stats& stats) { return stats.assn_params; });
    299355                        printAllPack("assn_returns", [](const Stats& stats) { return stats.assn_returns; });
     356                        std::cout << std::endl;
     357
     358                        printPairMap("exprs_by_depth+fanout", exprs_by_fanout_at_depth);
    300359                }
    301360        };
  • src/GenPoly/Box.cc

    rc3ebf37 rd107010  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:57:16 2017
    13 // Update Count     : 297
     12// Last Modified On : Fri Mar  3 21:57:15 2017
     13// Update Count     : 310
    1414//
    1515
     
    299299                // because each unit generates copies of the default routines for each aggregate.
    300300                FunctionDecl *layoutDecl = new FunctionDecl(
    301                         layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
     301                        layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
     302                        std::list< Attribute * >(), DeclarationNode::FuncSpec( DeclarationNode::InlineSpec ) );
    302303                layoutDecl->fixUniqueId();
    303304                return layoutDecl;
     
    910911                        adapterBody->get_kids().push_back( bodyStmt );
    911912                        std::string adapterName = makeAdapterName( mangleName );
    912                         return new FunctionDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false, false );
     913                        return new FunctionDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, adapterType, adapterBody );
    913914                }
    914915
  • src/GenPoly/Specialize.cc

    rc3ebf37 rd107010  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Thu Apr 28 15:17:45 2016
    13 // Update Count     : 24
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Mar  3 21:54:45 2017
     13// Update Count     : 28
    1414//
    1515
     
    155155                } // if
    156156                // create new thunk with same signature as formal type (C linkage, empty body)
    157                 FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( noLabels ), false, false );
     157                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
    158158                thunkFunc->fixUniqueId();
    159159
  • src/InitTweak/FixGlobalInit.cc

    rc3ebf37 rd107010  
    1010// Created On       : Mon May 04 15:14:56 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 29 22:33:15 2016
    13 // Update Count     : 4
     12// Last Modified On : Fri Mar  3 21:55:33 2017
     13// Update Count     : 9
    1414//
    1515
     
    8787                        dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
    8888                }
    89                 initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
     89                initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    9090                initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
    91                 destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
     91                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    9292                destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
    9393        }
  • src/InitTweak/FixInit.cc

    rc3ebf37 rd107010  
    1010// Created On       : Wed Jan 13 16:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:58:43 2017
    13 // Update Count     : 35
     12// Last Modified On : Fri Mar  3 21:56:11 2017
     13// Update Count     : 39
    1414//
    1515
     
    731731
    732732                                                        // void __objName_dtor_atexitN(...) {...}
    733                                                         FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
     733                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    734734                                                        dtorCaller->fixUniqueId();
    735735                                                        dtorCaller->get_statements()->push_back( dtorStmt );
  • src/InitTweak/GenInit.cc

    rc3ebf37 rd107010  
    332332                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
    333333                                if ( isManaged( field ) ) {
    334                                         managedTypes.insert( SymTab::Mangler::mangle( aggregateDecl ) );
     334                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
     335                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
    335336                                        break;
    336337                                }
  • src/Parser/DeclarationNode.cc

    rc3ebf37 rd107010  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 13:06:50 2017
    13 // Update Count     : 753
     12// Last Modified On : Fri Mar  3 21:38:34 2017
     13// Update Count     : 862
    1414//
    1515
     
    3232
    3333// These must remain in the same order as the corresponding DeclarationNode enumerations.
    34 const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
    35 const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
    36 const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
    37 const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
    38 const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
    39 const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
    40 const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" };
    41 const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
    42 const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
     34const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "inline", "fortran", "_Noreturn", "NoStorageClassNames" };
     35const char * DeclarationNode::funcSpecifierNames[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" };
     36const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoTypeQualifierNames" };
     37const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
     38const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
     39const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
     40const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
     41const char * DeclarationNode::aggregateNames[] = { "struct", "union", "context", "NoAggregateNames" };
     42const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" };
     43const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "NoBuiltinTypeNames" };
    4344
    4445UniqueName DeclarationNode::anonymous( "__anonymous" );
     
    5051                storageClass( NoStorageClass ),
    5152                bitfieldWidth( nullptr ),
    52                 isInline( false ),
    53                 isNoreturn( false ),
    5453                hasEllipsis( false ),
    5554                linkage( ::linkage ),
     
    9291        newnode->storageClass = storageClass;
    9392        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
    94         newnode->isInline = isInline;
    95         newnode->isNoreturn = isNoreturn;
     93        newnode->funcSpec = funcSpec;
    9694        newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
    9795        newnode->hasEllipsis = hasEllipsis;
     
    118116}
    119117
     118void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpec funcSpec ) {
     119        if ( funcSpec.any() ) {                                                         // function specifiers?
     120                for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) {
     121                        if ( funcSpec[i] ) {
     122                                output << DeclarationNode::funcSpecifierNames[i] << ' ';
     123                        } // if
     124                } // for
     125        } // if
     126} // print_FuncSpec
     127
    120128void DeclarationNode::print( std::ostream &os, int indent ) const {
    121129        os << string( indent, ' ' );
     
    130138        } // if
    131139
    132         if ( storageClass != NoStorageClass ) os << DeclarationNode::storageName[storageClass] << ' ';
    133         if ( isInline ) os << DeclarationNode::storageName[Inline] << ' ';
    134         if ( isNoreturn ) os << DeclarationNode::storageName[Noreturn] << ' ';
     140        if ( storageClass != NoStorageClass ) os << DeclarationNode::storageClassNames[storageClass] << ' ';
     141        print_FuncSpec( os, funcSpec );
     142
    135143        if ( type ) {
    136144                type->print( os, indent );
     
    174182        } // if
    175183
    176         if ( body ) {
    177                 newnode->type->function.hasBody = true;
    178         } // if
    179 
    180184        if ( ret ) {
    181185                newnode->type->base = ret->type;
     
    187191} // DeclarationNode::newFunction
    188192
    189 DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) {
     193
     194DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
     195        DeclarationNode * newnode = new DeclarationNode;
     196        newnode->storageClass = sc;
     197        return newnode;
     198} // DeclarationNode::newStorageClass
     199
     200DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) {
     201        DeclarationNode * newnode = new DeclarationNode;
     202        newnode->funcSpec[ fs ] = true;
     203        return newnode;
     204} // DeclarationNode::newFuncSpecifier
     205
     206DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifier tq ) {
    190207        DeclarationNode * newnode = new DeclarationNode;
    191208        newnode->type = new TypeData();
    192         newnode->type->qualifiers[ q ] = 1;
     209        newnode->type->typeQualifiers[ tq ] = true;
    193210        return newnode;
    194211} // DeclarationNode::newQualifier
     212
     213DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
     214        DeclarationNode * newnode = new DeclarationNode;
     215        newnode->type = new TypeData( TypeData::Basic );
     216        newnode->type->basictype = bt;
     217        return newnode;
     218} // DeclarationNode::newBasicType
     219
     220DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
     221        DeclarationNode * newnode = new DeclarationNode;
     222        newnode->type = new TypeData( TypeData::Basic );
     223        newnode->type->complextype = ct;
     224        return newnode;
     225} // DeclarationNode::newComplexType
     226
     227DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
     228        DeclarationNode * newnode = new DeclarationNode;
     229        newnode->type = new TypeData( TypeData::Basic );
     230        newnode->type->signedness = sn;
     231        return newnode;
     232} // DeclarationNode::newSignedNess
     233
     234DeclarationNode * DeclarationNode::newLength( Length lnth ) {
     235        DeclarationNode * newnode = new DeclarationNode;
     236        newnode->type = new TypeData( TypeData::Basic );
     237        newnode->type->length = lnth;
     238        return newnode;
     239} // DeclarationNode::newLength
    195240
    196241DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {
     
    200245        return newnode;
    201246} // DeclarationNode::newForall
    202 
    203 DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
    204         DeclarationNode * newnode = new DeclarationNode;
    205         newnode->storageClass = sc;
    206         return newnode;
    207 } // DeclarationNode::newStorageClass
    208 
    209 DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
    210         DeclarationNode * newnode = new DeclarationNode;
    211         newnode->type = new TypeData( TypeData::Basic );
    212         newnode->type->basictype = bt;
    213         return newnode;
    214 } // DeclarationNode::newBasicType
    215 
    216 DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
    217         DeclarationNode * newnode = new DeclarationNode;
    218         newnode->type = new TypeData( TypeData::Basic );
    219         newnode->type->complextype = ct;
    220         return newnode;
    221 } // DeclarationNode::newComplexType
    222 
    223 DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
    224         DeclarationNode * newnode = new DeclarationNode;
    225         newnode->type = new TypeData( TypeData::Basic );
    226         newnode->type->signedness = sn;
    227         return newnode;
    228 } // DeclarationNode::newSignedNess
    229 
    230 DeclarationNode * DeclarationNode::newLength( Length lnth ) {
    231         DeclarationNode * newnode = new DeclarationNode;
    232         newnode->type = new TypeData( TypeData::Basic );
    233         newnode->type->length = lnth;
    234         return newnode;
    235 } // DeclarationNode::newLength
    236247
    237248DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
     
    259270} // DeclarationNode::newAggregate
    260271
    261 DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants ) {
     272DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants, bool body ) {
    262273        DeclarationNode * newnode = new DeclarationNode;
    263274        newnode->type = new TypeData( TypeData::Enum );
     
    268279        } // if
    269280        newnode->type->enumeration.constants = constants;
     281        newnode->type->enumeration.body = body;
    270282        return newnode;
    271283} // DeclarationNode::newEnum
     
    431443
    432444void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
    433         TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
    434 
    435         if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
    436                 for ( int i = 0; i < NoQualifier; i += 1 ) {    // find common qualifiers
     445        const TypeData::TypeQualifiers &qsrc = src->typeQualifiers, &qdst = dst->typeQualifiers; // optimization
     446
     447        if ( (qsrc & qdst).any() ) {                                             // common qualifier ?
     448                for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers
    437449                        if ( qsrc[i] && qdst[i] ) {
    438                                 appendError( error, string( "duplicate " ) + DeclarationNode::qualifierName[i] );
     450                                appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] );
    439451                        } // if
    440452                } // for
     
    443455
    444456void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {
     457        const FuncSpec &src = funcSpec, &dst = q->funcSpec; // optimization
     458        if ( (src & dst).any() ) {                                                      // common specifier ?
     459                for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find common specifier
     460                        if ( src[i] && dst[i] ) {
     461                                appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] );
     462                        } // if
     463                } // for
     464        } // if
     465
    445466        if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
    446467                if ( storageClass == q->storageClass ) {                // duplicate qualifier
    447                         appendError( error, string( "duplicate " ) + storageName[ storageClass ] );
     468                        appendError( error, string( "duplicate " ) + storageClassNames[ storageClass ] );
    448469                } else {                                                                                // only one storage class
    449                         appendError( error, string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ] );
     470                        appendError( error, string( "conflicting " ) + storageClassNames[ storageClass ] + " & " + storageClassNames[ q->storageClass ] );
    450471                        q->storageClass = storageClass;                         // FIX ERROR, prevent assertions from triggering
    451472                } // if
    452473        } // if
     474
    453475        appendError( error, q->error );
    454476} // DeclarationNode::checkStorageClasses
    455477
    456478DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
    457         isInline = isInline || q->isInline;
    458         isNoreturn = isNoreturn || q->isNoreturn;
     479        funcSpec = funcSpec | q->funcSpec;
     480
    459481        // do not overwrite an existing value with NoStorageClass
    460482        if ( q->storageClass != NoStorageClass ) {
     
    484506                src = nullptr;
    485507        } else {
    486                 dst->qualifiers |= src->qualifiers;
     508                dst->typeQualifiers |= src->typeQualifiers;
    487509        } // if
    488510} // addQualifiersToType
     
    542564                switch ( dst->kind ) {
    543565                  case TypeData::Unknown:
    544                         src->qualifiers |= dst->qualifiers;
     566                        src->typeQualifiers |= dst->typeQualifiers;
    545567                        dst = src;
    546568                        src = nullptr;
    547569                        break;
    548570                  case TypeData::Basic:
    549                         dst->qualifiers |= src->qualifiers;
     571                        dst->typeQualifiers |= src->typeQualifiers;
    550572                        if ( src->kind != TypeData::Unknown ) {
    551573                                assert( src->kind == TypeData::Basic );
     
    554576                                        dst->basictype = src->basictype;
    555577                                } else if ( src->basictype != DeclarationNode::NoBasicType )
    556                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
     578                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: ", src );
    557579
    558580                                if ( dst->complextype == DeclarationNode::NoComplexType ) {
    559581                                        dst->complextype = src->complextype;
    560582                                } else if ( src->complextype != DeclarationNode::NoComplexType )
    561                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
     583                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: ", src );
    562584
    563585                                if ( dst->signedness == DeclarationNode::NoSignedness ) {
    564586                                        dst->signedness = src->signedness;
    565587                                } else if ( src->signedness != DeclarationNode::NoSignedness )
    566                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
     588                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: ", src );
    567589
    568590                                if ( dst->length == DeclarationNode::NoLength ) {
     
    571593                                        dst->length = DeclarationNode::LongLong;
    572594                                } else if ( src->length != DeclarationNode::NoLength )
    573                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
     595                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: ", src );
    574596                        } // if
    575597                        break;
     
    583605                                        dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
    584606                                } // if
    585                                 dst->base->qualifiers |= src->qualifiers;
     607                                dst->base->typeQualifiers |= src->typeQualifiers;
    586608                                src = nullptr;
    587609                                break;
     
    610632                                        type->aggInst.aggregate = o->type;
    611633                                        if ( o->type->kind == TypeData::Aggregate ) {
     634                                                type->aggInst.hoistType = o->type->aggregate.body;
    612635                                                type->aggInst.params = maybeClone( o->type->aggregate.actuals );
     636                                        } else {
     637                                                type->aggInst.hoistType = o->type->enumeration.body;
    613638                                        } // if
    614                                         type->qualifiers |= o->type->qualifiers;
     639                                        type->typeQualifiers |= o->type->typeQualifiers;
    615640                                } else {
    616641                                        type = o->type;
     
    698723        assert( ! type->function.body );
    699724        type->function.body = body;
    700         type->function.hasBody = true;
    701725        return this;
    702726}
     
    769793                                        p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
    770794                                } // if
    771                                 p->type->base->qualifiers |= type->qualifiers;
     795                                p->type->base->typeQualifiers |= type->typeQualifiers;
    772796                                break;
    773797
     
    806830                                        lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
    807831                                } // if
    808                                 lastArray->base->qualifiers |= type->qualifiers;
     832                                lastArray->base->typeQualifiers |= type->typeQualifiers;
    809833                                break;
    810834                          default:
     
    885909                                newType->aggInst.aggregate->aggregate.fields = nullptr;
    886910                        } // if
     911                        // don't hoist twice
     912                        newType->aggInst.hoistType = false;
    887913                } // if
    888914
     
    945971        SemanticError errors;
    946972        std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
    947        
     973
    948974        for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
    949975                try {
     
    957983                                        auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
    958984                                        obj->location = cur->location;
    959                                         * out++ = obj; 
     985                                        * out++ = obj;
    960986                                        delete agg;
    961987                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
     
    10041030        } // if
    10051031
    1006 //      if ( variable.name ) {
    10071032        if ( variable.tyClass != NoTypeClass ) {
    10081033                static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype };
    10091034                assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." );
    10101035                assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
    1011 //              TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
    10121036                TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
    10131037                buildList( variable.assertions, ret->get_assertions() );
     
    10161040
    10171041        if ( type ) {
    1018                 return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
    1019         } // if
    1020 
    1021         if ( ! isInline && ! isNoreturn ) {
    1022                 assertf( name, "ObjectDecl are assumed to have names\n" );
    1023                 return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
    1024         } // if
    1025 
    1026         throw SemanticError( "invalid function specifier ", this );
     1042                // Function specifiers can only appear on a function definition/declaration.
     1043                //
     1044                //    inline _Noreturn int f();                 // allowed
     1045                //    inline _Noreturn int g( int i );  // allowed
     1046                //    inline _Noreturn int i;                   // disallowed
     1047                if ( type->kind != TypeData::Function && funcSpec.any() ) {
     1048                        throw SemanticError( "invalid function specifier for ", this );
     1049                } // if
     1050                return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), funcSpec, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
     1051        } // if
     1052
     1053        // SUE's cannot have function specifiers, either
     1054        //
     1055        //    inlne _Noreturn struct S { ... };         // disallowed
     1056        //    inlne _Noreturn enum   E { ... };         // disallowed
     1057        if ( funcSpec.any() ) {
     1058                throw SemanticError( "invalid function specifier for ", this );
     1059        } // if
     1060        assertf( name, "ObjectDecl must a have name\n" );
     1061        return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
    10271062}
    10281063
     
    10311066
    10321067        if ( attr.expr ) {
    1033 //              return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
    10341068                return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
    10351069        } else if ( attr.type ) {
    1036 //              return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
    10371070                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
    10381071        } // if
    10391072
    10401073        switch ( type->kind ) {
    1041           case TypeData::Enum: {
    1042                   EnumDecl * typedecl = buildEnum( type, attributes );
    1043                   return new EnumInstType( buildQualifiers( type ), typedecl );
    1044           }
     1074          case TypeData::Enum:
    10451075          case TypeData::Aggregate: {
    1046                   AggregateDecl * typedecl = buildAggregate( type, attributes );
    1047                   ReferenceToType * ret;
    1048                   switch ( type->aggregate.kind ) {
    1049                         case DeclarationNode::Struct:
    1050                           ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
    1051                           break;
    1052                         case DeclarationNode::Union:
    1053                           ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
    1054                           break;
    1055                         case DeclarationNode::Trait:
    1056                           assert( false );
    1057                           //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
    1058                           break;
    1059                         default:
    1060                           assert( false );
    1061                   } // switch
     1076                  ReferenceToType * ret = buildComAggInst( type, attributes );
    10621077                  buildList( type->aggregate.actuals, ret->get_parameters() );
    10631078                  return ret;
  • src/Parser/ParseNode.h

    rc3ebf37 rd107010  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 13:15:55 2017
    13 // Update Count     : 661
     12// Last Modified On : Fri Mar  3 21:34:27 2017
     13// Update Count     : 704
    1414//
    1515
     
    1919#include <string>
    2020#include <list>
     21#include <bitset>
    2122#include <iterator>
    2223#include <memory>
     
    109110        ExpressionNode( const ExpressionNode &other );
    110111        virtual ~ExpressionNode() {}
    111         virtual ExpressionNode * clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
     112        virtual ExpressionNode * clone() const override { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
    112113
    113114        bool get_extension() const { return extension; }
     
    203204        // These must remain in the same order as the corresponding DeclarationNode names.
    204205
    205         // enum StorageClass { Extern, Static, Auto, Register, NoStorageClass };
    206         // enum FunctionSpec { Inline, Fortran, Noreturn, NoFunctionSpec };
    207         // enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Threadlocal, Mutex, NoQualifier };
    208 
    209         enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
    210         enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier };
     206        enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass };
     207        enum FuncSpecifier { Inline, Noreturn, Fortran, NoFuncSpecifier,
     208                                        InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran };
     209        enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoTypeQualifier };
    211210        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
    212211        enum ComplexType { Complex, Imaginary, NoComplexType };
     
    217216        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
    218217
    219         static const char * storageName[];
    220         static const char * qualifierName[];
    221         static const char * basicTypeName[];
    222         static const char * complexTypeName[];
    223         static const char * signednessName[];
    224         static const char * lengthName[];
    225         static const char * aggregateName[];
    226         static const char * typeClassName[];
    227         static const char * builtinTypeName[];
    228 
    229         static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
    230         static DeclarationNode * newQualifier( Qualifier );
    231         static DeclarationNode * newForall( DeclarationNode * );
     218        static const char * storageClassNames[];
     219        static const char * funcSpecifierNames[];
     220        static const char * typeQualifierNames[];
     221        static const char * basicTypeNames[];
     222        static const char * complexTypeNames[];
     223        static const char * signednessNames[];
     224        static const char * lengthNames[];
     225        static const char * aggregateNames[];
     226        static const char * typeClassNames[];
     227        static const char * builtinTypeNames[];
     228
    232229        static DeclarationNode * newStorageClass( StorageClass );
     230        static DeclarationNode * newFuncSpecifier( FuncSpecifier );
     231        static DeclarationNode * newTypeQualifier( TypeQualifier );
    233232        static DeclarationNode * newBasicType( BasicType );
    234233        static DeclarationNode * newComplexType( ComplexType );
    235         static DeclarationNode * newSignedNess( Signedness sn );
    236         static DeclarationNode * newLength( Length lnth );
     234        static DeclarationNode * newSignedNess( Signedness );
     235        static DeclarationNode * newLength( Length );
    237236        static DeclarationNode * newBuiltinType( BuiltinType );
     237        static DeclarationNode * newForall( DeclarationNode * );
    238238        static DeclarationNode * newFromTypedef( std::string * );
     239        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
    239240        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
    240         static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
     241        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
    241242        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
    242243        static DeclarationNode * newName( std::string * );
     
    259260        DeclarationNode();
    260261        ~DeclarationNode();
    261         DeclarationNode * clone() const;
     262        DeclarationNode * clone() const override;
    262263
    263264        DeclarationNode * addQualifiers( DeclarationNode * );
     
    324325        TypeData * type;
    325326        StorageClass storageClass;
     327
     328        typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpec;
     329        FuncSpec funcSpec;
     330        static void print_FuncSpec( std::ostream & output, FuncSpec funcSpec );
     331
    326332        ExpressionNode * bitfieldWidth;
    327         bool isInline, isNoreturn;
    328333        std::unique_ptr<ExpressionNode> enumeratorValue;
    329334        bool hasEllipsis;
  • src/Parser/TypeData.cc

    rc3ebf37 rd107010  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 19 09:49:33 2017
    13 // Update Count     : 467
     12// Last Modified On : Fri Mar  3 21:59:10 2017
     13// Update Count     : 516
    1414//
    1515
     
    4848                function.oldDeclList = nullptr;
    4949                function.body = nullptr;
    50                 function.hasBody = false;
    5150                function.newStyle = false;
    5251                break;
     
    6362                aggInst.aggregate = nullptr;
    6463                aggInst.params = nullptr;
     64                aggInst.hoistType = false;;
    6565                break;
    6666          case Enum:
     
    6868                enumeration.name = nullptr;
    6969                enumeration.constants = nullptr;
     70                enumeration.body = false;
    7071                break;
    7172          case Symbolic:
     
    156157TypeData * TypeData::clone() const {
    157158        TypeData * newtype = new TypeData( kind );
    158         newtype->qualifiers = qualifiers;
     159        newtype->typeQualifiers = typeQualifiers;
    159160        newtype->base = maybeClone( base );
    160161        newtype->forall = maybeClone( forall );
     
    182183                newtype->function.oldDeclList = maybeClone( function.oldDeclList );
    183184                newtype->function.body = maybeClone( function.body );
    184                 newtype->function.hasBody = function.hasBody;
    185185                newtype->function.newStyle = function.newStyle;
    186186                break;
     
    196196                newtype->aggInst.aggregate = maybeClone( aggInst.aggregate );
    197197                newtype->aggInst.params = maybeClone( aggInst.params );
     198                newtype->aggInst.hoistType = aggInst.hoistType;
    198199                break;
    199200          case Enum:
    200201                newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
    201202                newtype->enumeration.constants = maybeClone( enumeration.constants );
     203                newtype->enumeration.body = enumeration.body;
    202204                break;
    203205          case Symbolic:
     
    224226
    225227void TypeData::print( ostream &os, int indent ) const {
    226         for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) {
    227                 if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
     228        for ( int i = 0; i < DeclarationNode::NoTypeQualifier; i += 1 ) {
     229                if ( typeQualifiers[i] ) os << DeclarationNode::typeQualifierNames[ i ] << ' ';
    228230        } // for
    229231
     
    248250                break;
    249251          case Basic:
    250                 if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessName[ signedness ] << " ";
    251                 if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthName[ length ] << " ";
     252                if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
     253                if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
    252254                assert( basictype != DeclarationNode::NoBasicType );
    253                 os << DeclarationNode::basicTypeName[ basictype ] << " ";
    254                 if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeName[ complextype ] << " ";
     255                os << DeclarationNode::basicTypeNames[ basictype ] << " ";
     256                if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeNames[ complextype ] << " ";
    255257                break;
    256258          case Array:
     
    293295                } // if
    294296                os << endl;
    295                 if ( function.hasBody ) {
     297                if ( function.body ) {
    296298                        os << string( indent + 2, ' ' ) << "with body " << endl;
    297                 } // if
    298                 if ( function.body ) {
    299299                        function.body->printList( os, indent + 2 );
    300300                } // if
    301301                break;
    302302          case Aggregate:
    303                 os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl;
     303                os << DeclarationNode::aggregateNames[ aggregate.kind ] << ' ' << *aggregate.name << endl;
    304304                if ( aggregate.params ) {
    305305                        os << string( indent + 2, ' ' ) << "with type parameters " << endl;
     
    335335                        os << "with constants" << endl;
    336336                        enumeration.constants->printList( os, indent + 2 );
     337                } // if
     338                if ( enumeration.body ) {
     339                        os << string( indent + 2, ' ' ) << " with body " << endl;
    337340                } // if
    338341                break;
     
    396399                        FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
    397400                        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 ) );
    398                         td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
     401                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr ) );
    399402
    400403                        // add copy ctor:  void ?{}(T *, T)
     
    402405                        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 ) );
    403406                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    404                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
     407                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr ) );
    405408
    406409                        // add default ctor:  void ?{}(T *)
    407410                        FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
    408411                        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 ) );
    409                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
     412                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr ) );
    410413
    411414                        // add assignment operator:  T * ?=?(T *, T)
     
    414417                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    415418                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    416                         td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
     419                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr ) );
    417420                } // if
    418421        } // for
     
    491494Type::Qualifiers buildQualifiers( const TypeData * td ) {
    492495        Type::Qualifiers q;
    493         q.isConst = td->qualifiers[ DeclarationNode::Const ];
    494         q.isVolatile = td->qualifiers[ DeclarationNode::Volatile ];
    495         q.isRestrict = td->qualifiers[ DeclarationNode::Restrict ];
    496         q.isLvalue = td->qualifiers[ DeclarationNode::Lvalue ];
    497         q.isAtomic = td->qualifiers[ DeclarationNode::Atomic ];;
     496        q.isConst = td->typeQualifiers[ DeclarationNode::Const ];
     497        q.isVolatile = td->typeQualifiers[ DeclarationNode::Volatile ];
     498        q.isRestrict = td->typeQualifiers[ DeclarationNode::Restrict ];
     499        q.isLvalue = td->typeQualifiers[ DeclarationNode::Lvalue ];
     500        q.isAtomic = td->typeQualifiers[ DeclarationNode::Atomic ];;
    498501        return q;
    499502} // buildQualifiers
     
    513516          case DeclarationNode::Bool:
    514517                if ( td->signedness != DeclarationNode::NoSignedness ) {
    515                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
     518                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
    516519                } // if
    517520                if ( td->length != DeclarationNode::NoLength ) {
    518                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
     521                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
    519522                } // if
    520523
     
    529532
    530533                if ( td->length != DeclarationNode::NoLength ) {
    531                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
     534                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
    532535                } // if
    533536
     
    559562          FloatingPoint: ;
    560563                if ( td->signedness != DeclarationNode::NoSignedness ) {
    561                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
     564                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
    562565                } // if
    563566                if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
    564                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
     567                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
    565568                } // if
    566569                if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
     
    643646} // buildAggregate
    644647
     648ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes ) {
     649        switch ( type->kind ) {
     650          case TypeData::Enum: {
     651                  if ( type->enumeration.body ) {
     652                          EnumDecl * typedecl = buildEnum( type, attributes );
     653                          return new EnumInstType( buildQualifiers( type ), typedecl );
     654                  } else {
     655                          return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
     656                  } // if
     657          }
     658          case TypeData::Aggregate: {
     659                  ReferenceToType * ret;
     660                  if ( type->aggregate.body ) {
     661                          AggregateDecl * typedecl = buildAggregate( type, attributes );
     662                          switch ( type->aggregate.kind ) {
     663                                case DeclarationNode::Struct:
     664                                  ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
     665                                  break;
     666                                case DeclarationNode::Union:
     667                                  ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
     668                                  break;
     669                                case DeclarationNode::Trait:
     670                                  assert( false );
     671                                  //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
     672                                  break;
     673                                default:
     674                                  assert( false );
     675                          } // switch
     676                  } else {
     677                          switch ( type->aggregate.kind ) {
     678                                case DeclarationNode::Struct:
     679                                  ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
     680                                  break;
     681                                case DeclarationNode::Union:
     682                                  ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
     683                                  break;
     684                                case DeclarationNode::Trait:
     685                                  ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
     686                                  break;
     687                                default:
     688                                  assert( false );
     689                          } // switch
     690                  } // if
     691                  return ret;
     692          }
     693          default:
     694                assert( false );
     695        } // switch
     696} // buildAggInst
     697
    645698ReferenceToType * buildAggInst( const TypeData * td ) {
    646699        assert( td->kind == TypeData::AggregateInst );
    647700
    648         ReferenceToType * ret;
    649         if ( td->aggInst.aggregate->kind == TypeData::Enum ) {
    650                 ret = new EnumInstType( buildQualifiers( td ), *td->aggInst.aggregate->enumeration.name );
    651         } else {
    652                 assert( td->aggInst.aggregate->kind == TypeData::Aggregate );
    653                 switch ( td->aggInst.aggregate->aggregate.kind ) {
    654                   case DeclarationNode::Struct:
    655                         assert( td->aggInst.aggregate->aggregate.name );
    656                         ret = new StructInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
    657                         break;
    658                   case DeclarationNode::Union:
    659                         ret = new UnionInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
    660                         break;
    661                   case DeclarationNode::Trait:
    662                         ret = new TraitInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
    663                         break;
    664                   default:
    665                         assert( false );
    666                 } // switch
    667         } // if
     701        // ReferenceToType * ret = buildComAggInst( td->aggInst.aggregate, std::list< Attribute * >() );
     702        ReferenceToType * ret = nullptr;
     703        TypeData * type = td->aggInst.aggregate;
     704        switch ( type->kind ) {
     705          case TypeData::Enum: {
     706                  return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
     707          }
     708          case TypeData::Aggregate: {
     709                  switch ( type->aggregate.kind ) {
     710                        case DeclarationNode::Struct:
     711                          ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
     712                          break;
     713                        case DeclarationNode::Union:
     714                          ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
     715                          break;
     716                        case DeclarationNode::Trait:
     717                          ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
     718                          break;
     719                        default:
     720                          assert( false );
     721                  } // switch
     722          }
     723          break;
     724          default:
     725                assert( false );
     726        } // switch
     727
     728        ret->set_hoistType( td->aggInst.hoistType );
    668729        buildList( td->aggInst.params, ret->get_parameters() );
    669730        buildForall( td->forall, ret->get_forall() );
     
    696757                } // if
    697758        } // for
     759        ret->set_body( td->enumeration.body );
    698760        return ret;
    699761} // buildEnum
     
    722784} // buildTypeof
    723785
    724 Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
     786Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, DeclarationNode::FuncSpec funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
    725787        if ( td->kind == TypeData::Function ) {
    726                 if ( td->function.idList ) {
    727                         buildKRFunction( td->function );
     788                if ( td->function.idList ) {                                    // KR function ?
     789                        buildKRFunction( td->function );                        // transform into C11 function
    728790                } // if
    729791
    730792                FunctionDecl * decl;
    731                 if ( td->function.hasBody ) {
    732                         if ( td->function.body ) {
    733                                 Statement * stmt = td->function.body->build();
    734                                 CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt );
    735                                 assert( body );
    736                                 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn, attributes );
    737                         } else {
    738                                 // list< Label > ls;
    739                                 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( list< Label >() ), isInline, isNoreturn, attributes );
    740                         } // if
    741                 } else {
    742                         decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), nullptr, isInline, isNoreturn, attributes );
    743                 } // if
     793                Statement * stmt = maybeBuild<Statement>( td->function.body );
     794                CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt );
     795                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, attributes, funcSpec );
    744796                return decl->set_asmName( asmName );
    745797        } else if ( td->kind == TypeData::Aggregate ) {
     
    750802                return buildSymbolic( td, name, sc );
    751803        } else {
    752                 return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes, isInline, isNoreturn ))->set_asmName( asmName );
     804                return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
    753805        } // if
    754806        return nullptr;
     
    768820                        break;
    769821                  default:
    770                         ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall, nullptr ) ) );
     822                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, nullptr, DeclarationNode::FuncSpecifier(), LinkageSpec::Cforall, nullptr ) ) );
    771823                } // switch
    772824        } else {
     
    816868
    817869        for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) {
    818                 if ( ! param->type ) {                                                  // generate type int for empty parameters
     870                if ( ! param->type ) {                                                  // generate type int for empty parameter type
    819871                        param->type = new TypeData( TypeData::Basic );
    820872                        param->type->basictype = DeclarationNode::Int;
  • src/Parser/TypeData.h

    rc3ebf37 rd107010  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:30:05 2017
    13 // Update Count     : 153
     12// Last Modified On : Fri Mar  3 20:56:53 2017
     13// Update Count     : 167
    1414//
    1515
     
    3838                TypeData * aggregate;
    3939                ExpressionNode * params;
     40                bool hoistType;
    4041        };
    4142
     
    4950                const std::string * name;
    5051                DeclarationNode * constants;
     52                bool body;
    5153        };
    5254
     
    5658                mutable DeclarationNode * oldDeclList;
    5759                StatementNode * body;
    58                 bool hasBody;
    5960                bool newStyle;
    6061        };
     
    7576        DeclarationNode::Length length = DeclarationNode::NoLength;
    7677        DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
    77         typedef std::bitset< DeclarationNode::NoQualifier > Qualifiers;
    78         Qualifiers qualifiers;
     78        typedef std::bitset< DeclarationNode::NoTypeQualifier > TypeQualifiers;
     79        TypeQualifiers typeQualifiers;
    7980        DeclarationNode * forall;
    8081
     
    104105ArrayType * buildArray( const TypeData * );
    105106AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
     107ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes );
    106108ReferenceToType * buildAggInst( const TypeData * );
    107109NamedTypeDecl * buildSymbolic( const TypeData *, const std::string &name, DeclarationNode::StorageClass sc );
     
    111113TupleType * buildTuple( const TypeData * );
    112114TypeofType * buildTypeof( const TypeData * );
    113 Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
     115Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, DeclarationNode::FuncSpec funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
    114116FunctionType * buildFunction( const TypeData * );
    115117void buildKRFunction( const TypeData::Function_t & function );
  • src/Parser/parser.cc

    rc3ebf37 rd107010  
    626626
    627627/* YYFINAL -- State number of the termination state.  */
    628 #define YYFINAL  238
     628#define YYFINAL  240
    629629/* YYLAST -- Last index in YYTABLE.  */
    630 #define YYLAST   11059
     630#define YYLAST   11898
    631631
    632632/* YYNTOKENS -- Number of terminals.  */
    633633#define YYNTOKENS  138
    634634/* YYNNTS -- Number of nonterminals.  */
    635 #define YYNNTS  242
     635#define YYNNTS  249
    636636/* YYNRULES -- Number of rules.  */
    637 #define YYNRULES  756
     637#define YYNRULES  775
    638638/* YYNRULES -- Number of states.  */
    639 #define YYNSTATES  1556
     639#define YYNSTATES  1582
    640640
    641641/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
     
    723723    1028,  1033,  1037,  1042,  1047,  1055,  1060,  1064,  1068,  1072,
    724724    1076,  1083,  1085,  1087,  1089,  1091,  1093,  1095,  1097,  1099,
    725     1100,  1102,  1104,  1107,  1109,  1111,  1113,  1115,  1117,  1119,
    726     1121,  1122,  1128,  1130,  1133,  1137,  1139,  1142,  1144,  1146,
    727     1148,  1150,  1152,  1154,  1156,  1158,  1160,  1162,  1164,  1166,
     725    1101,  1103,  1105,  1107,  1109,  1111,  1113,  1115,  1116,  1118,
     726    1120,  1123,  1125,  1127,  1129,  1131,  1133,  1135,  1137,  1138,
     727    1144,  1146,  1149,  1153,  1155,  1158,  1160,  1162,  1164,  1166,
    728728    1168,  1170,  1172,  1174,  1176,  1178,  1180,  1182,  1184,  1186,
    729     1188,  1190,  1193,  1196,  1200,  1204,  1206,  1210,  1212,  1215,
    730     1218,  1221,  1226,  1231,  1236,  1241,  1243,  1246,  1249,  1253,
    731     1255,  1258,  1261,  1263,  1266,  1269,  1273,  1275,  1278,  1281,
    732     1283,  1285,  1291,  1295,  1296,  1304,  1313,  1317,  1319,  1321,
    733     1322,  1325,  1328,  1332,  1336,  1341,  1343,  1346,  1350,  1353,
    734     1355,  1360,  1361,  1363,  1366,  1369,  1371,  1372,  1374,  1377,
    735     1384,  1388,  1389,  1398,  1401,  1406,  1407,  1410,  1411,  1413,
    736     1415,  1417,  1423,  1429,  1435,  1437,  1443,  1449,  1459,  1461,
    737     1467,  1468,  1470,  1472,  1478,  1480,  1482,  1488,  1494,  1496,
    738     1500,  1504,  1509,  1511,  1513,  1515,  1517,  1520,  1522,  1526,
    739     1530,  1533,  1537,  1539,  1543,  1545,  1547,  1549,  1551,  1553,
    740     1555,  1557,  1559,  1561,  1563,  1565,  1568,  1570,  1572,  1573,
    741     1576,  1579,  1581,  1586,  1587,  1589,  1592,  1596,  1601,  1604,
    742     1607,  1609,  1612,  1615,  1621,  1627,  1635,  1642,  1644,  1647,
    743     1650,  1654,  1656,  1659,  1662,  1667,  1670,  1675,  1676,  1681,
    744     1684,  1686,  1688,  1690,  1692,  1693,  1696,  1702,  1708,  1722,
    745     1724,  1726,  1730,  1734,  1737,  1741,  1745,  1748,  1753,  1755,
    746     1762,  1772,  1773,  1785,  1787,  1791,  1795,  1799,  1801,  1803,
    747     1809,  1812,  1818,  1819,  1821,  1823,  1827,  1828,  1830,  1832,
    748     1834,  1840,  1841,  1848,  1851,  1853,  1856,  1861,  1864,  1868,
    749     1872,  1876,  1881,  1887,  1893,  1899,  1906,  1908,  1910,  1912,
    750     1916,  1917,  1923,  1924,  1926,  1928,  1931,  1938,  1940,  1944,
    751     1945,  1947,  1952,  1954,  1956,  1958,  1960,  1963,  1965,  1968,
    752     1971,  1973,  1977,  1980,  1984,  1989,  1992,  1997,  2002,  2006,
    753     2015,  2019,  2022,  2024,  2027,  2034,  2043,  2047,  2050,  2054,
    754     2058,  2063,  2068,  2072,  2074,  2076,  2078,  2083,  2092,  2096,
    755     2099,  2103,  2107,  2112,  2117,  2121,  2124,  2126,  2129,  2132,
    756     2134,  2138,  2141,  2145,  2150,  2153,  2158,  2163,  2167,  2174,
    757     2183,  2187,  2190,  2192,  2195,  2198,  2201,  2205,  2210,  2213,
    758     2218,  2223,  2227,  2234,  2243,  2247,  2250,  2252,  2255,  2258,
    759     2260,  2262,  2265,  2269,  2274,  2277,  2282,  2289,  2298,  2300,
    760     2303,  2306,  2308,  2311,  2314,  2318,  2323,  2325,  2330,  2335,
    761     2339,  2345,  2354,  2358,  2361,  2365,  2367,  2373,  2379,  2386,
    762     2393,  2395,  2398,  2401,  2403,  2406,  2409,  2413,  2418,  2420,
    763     2425,  2430,  2434,  2440,  2449,  2453,  2455,  2458,  2460,  2463,
    764     2470,  2476,  2483,  2491,  2499,  2501,  2504,  2507,  2509,  2512,
    765     2515,  2519,  2524,  2526,  2531,  2536,  2540,  2549,  2553,  2555,
    766     2557,  2560,  2562,  2564,  2567,  2571,  2574,  2578,  2581,  2585,
    767     2589,  2592,  2597,  2601,  2604,  2608,  2611,  2616,  2620,  2623,
    768     2630,  2637,  2644,  2652,  2654,  2657,  2659,  2661,  2663,  2666,
    769     2670,  2673,  2677,  2680,  2684,  2688,  2693,  2696,  2700,  2705,
    770     2708,  2714,  2721,  2728,  2729,  2731,  2732
     729    1188,  1190,  1192,  1194,  1196,  1198,  1200,  1202,  1204,  1206,
     730    1209,  1212,  1216,  1220,  1222,  1226,  1228,  1231,  1234,  1237,
     731    1242,  1247,  1252,  1257,  1259,  1262,  1265,  1269,  1271,  1274,
     732    1277,  1279,  1282,  1285,  1289,  1291,  1294,  1297,  1299,  1302,
     733    1305,  1309,  1311,  1314,  1317,  1319,  1321,  1323,  1325,  1331,
     734    1332,  1340,  1349,  1351,  1355,  1359,  1361,  1363,  1364,  1367,
     735    1370,  1374,  1378,  1383,  1385,  1388,  1392,  1395,  1397,  1402,
     736    1403,  1405,  1408,  1411,  1413,  1414,  1416,  1419,  1426,  1427,
     737    1436,  1438,  1442,  1445,  1450,  1451,  1454,  1455,  1457,  1459,
     738    1461,  1467,  1473,  1479,  1481,  1487,  1493,  1503,  1505,  1511,
     739    1512,  1514,  1516,  1522,  1524,  1526,  1532,  1538,  1540,  1544,
     740    1548,  1553,  1555,  1557,  1559,  1561,  1564,  1566,  1570,  1574,
     741    1577,  1581,  1583,  1587,  1589,  1591,  1593,  1595,  1597,  1599,
     742    1601,  1603,  1605,  1607,  1609,  1612,  1614,  1616,  1617,  1620,
     743    1623,  1625,  1630,  1631,  1633,  1636,  1640,  1645,  1648,  1651,
     744    1653,  1656,  1659,  1665,  1671,  1679,  1686,  1688,  1691,  1694,
     745    1698,  1700,  1703,  1706,  1711,  1714,  1719,  1720,  1725,  1728,
     746    1730,  1732,  1734,  1736,  1737,  1740,  1746,  1752,  1766,  1768,
     747    1770,  1774,  1778,  1781,  1785,  1789,  1792,  1797,  1799,  1806,
     748    1816,  1817,  1829,  1831,  1835,  1839,  1843,  1845,  1847,  1853,
     749    1856,  1862,  1863,  1865,  1867,  1871,  1872,  1874,  1876,  1878,
     750    1884,  1885,  1892,  1895,  1897,  1900,  1905,  1908,  1912,  1916,
     751    1920,  1925,  1931,  1937,  1943,  1950,  1952,  1954,  1956,  1960,
     752    1961,  1967,  1968,  1970,  1972,  1975,  1982,  1984,  1988,  1989,
     753    1991,  1996,  1998,  2000,  2002,  2004,  2007,  2009,  2012,  2015,
     754    2017,  2021,  2024,  2028,  2033,  2036,  2041,  2046,  2050,  2059,
     755    2063,  2066,  2068,  2071,  2078,  2087,  2091,  2094,  2098,  2102,
     756    2107,  2112,  2116,  2118,  2120,  2122,  2127,  2136,  2140,  2143,
     757    2147,  2151,  2156,  2161,  2165,  2168,  2170,  2173,  2176,  2178,
     758    2182,  2185,  2189,  2194,  2197,  2202,  2207,  2211,  2218,  2227,
     759    2231,  2234,  2236,  2239,  2242,  2245,  2249,  2254,  2257,  2262,
     760    2267,  2271,  2278,  2287,  2291,  2294,  2296,  2299,  2302,  2304,
     761    2306,  2309,  2313,  2318,  2321,  2326,  2333,  2342,  2344,  2347,
     762    2350,  2352,  2355,  2358,  2362,  2367,  2369,  2374,  2379,  2383,
     763    2389,  2398,  2402,  2405,  2409,  2411,  2417,  2423,  2430,  2437,
     764    2439,  2442,  2445,  2447,  2450,  2453,  2457,  2462,  2464,  2469,
     765    2474,  2478,  2484,  2493,  2497,  2499,  2502,  2504,  2507,  2514,
     766    2520,  2527,  2535,  2543,  2545,  2548,  2551,  2553,  2556,  2559,
     767    2563,  2568,  2570,  2575,  2580,  2584,  2593,  2597,  2599,  2601,
     768    2604,  2606,  2608,  2611,  2615,  2618,  2622,  2625,  2629,  2633,
     769    2636,  2641,  2645,  2648,  2652,  2655,  2660,  2664,  2667,  2674,
     770    2681,  2688,  2696,  2698,  2701,  2703,  2705,  2707,  2710,  2714,
     771    2717,  2721,  2724,  2728,  2732,  2737,  2740,  2744,  2749,  2752,
     772    2758,  2765,  2772,  2773,  2775,  2776
    771773};
    772774
     
    774776static const yytype_int16 yyrhs[] =
    775777{
    776      308,     0,    -1,    -1,    -1,    82,    -1,    85,    -1,    86,
     778     315,     0,    -1,    -1,    -1,    82,    -1,    85,    -1,    86,
    777779      -1,    87,    -1,    83,    -1,    75,    -1,    79,    -1,   145,
    778780      -1,    75,    -1,    79,    -1,    75,    -1,   145,    -1,    88,
     
    784786     149,    86,    -1,   149,    90,   144,    -1,   149,    90,   116,
    785787     139,   152,   140,   117,    -1,   149,    91,    -1,   149,    92,
    786       -1,   114,   281,   115,   119,   285,   378,   120,    -1,   149,
     788      -1,   114,   288,   115,   119,   292,   385,   120,    -1,   149,
    787789     119,   150,   120,    -1,   151,    -1,   150,   121,   151,    -1,
    788790      -1,   172,    -1,   153,    -1,   152,   121,   153,    -1,   154,
     
    794796     141,    -1,   146,    -1,    43,   159,    -1,   157,   159,    -1,
    795797     158,   159,    -1,    91,   156,    -1,    92,   156,    -1,    40,
    796      156,    -1,    40,   114,   281,   115,    -1,    69,   156,    -1,
    797       69,   114,   281,   115,    -1,    41,   114,   281,   121,   144,
     798     156,    -1,    40,   114,   288,   115,    -1,    69,   156,    -1,
     799      69,   114,   288,   115,    -1,    41,   114,   288,   121,   144,
    798800     115,    -1,    79,    -1,    79,   114,   151,   115,    -1,    79,
    799      114,   282,   115,    -1,   122,    -1,   123,    -1,   124,    -1,
    800      125,    -1,   126,    -1,   127,    -1,   156,    -1,   114,   281,
     801     114,   289,   115,    -1,   122,    -1,   123,    -1,   124,    -1,
     802     125,    -1,   126,    -1,   127,    -1,   156,    -1,   114,   288,
    801803     115,   159,    -1,   159,    -1,   160,   122,   159,    -1,   160,
    802804     128,   159,    -1,   160,   129,   159,    -1,   160,    -1,   161,
     
    818820      -1,   177,    -1,   180,    -1,   181,    -1,   185,    -1,   186,
    819821      -1,   198,    -1,   200,    -1,   201,    -1,   206,    -1,   132,
    820      149,   119,   150,   120,   137,    -1,   278,   135,   318,   179,
     822     149,   119,   150,   120,   137,    -1,   285,   135,   325,   179,
    821823      -1,   119,   120,    -1,   119,   139,   139,   217,   182,   140,
    822824     120,    -1,   183,    -1,   182,   139,   183,    -1,   220,    -1,
    823       43,   220,    -1,   314,    -1,    43,   314,    -1,   179,   140,
     825      43,   220,    -1,   321,    -1,    43,   321,    -1,   179,   140,
    824826      -1,   179,    -1,   184,   179,    -1,   178,   137,    -1,    44,
    825827     114,   177,   115,   179,    -1,    44,   114,   177,   115,   179,
     
    828830     114,   177,   115,   191,    -1,    56,   114,   177,   115,   119,
    829831     139,   213,   194,   120,    -1,   171,    -1,   171,   101,   171,
    830       -1,   316,    -1,   187,    -1,   188,   121,   187,    -1,    47,
     832      -1,   323,    -1,   187,    -1,   188,   121,   187,    -1,    47,
    831833     188,   135,    -1,    48,   135,    -1,   189,    -1,   190,   189,
    832834      -1,   190,   179,    -1,    -1,   193,    -1,   190,   184,    -1,
     
    837839     114,   177,   115,   137,    -1,    51,   114,   139,   199,   115,
    838840     179,    -1,   178,   140,   137,   178,   137,   178,    -1,   220,
    839      178,   137,   178,    -1,    54,   278,   137,    -1,    54,   122,
    840      177,   137,    -1,    53,   137,    -1,    53,   278,   137,    -1,
    841       52,   137,    -1,    52,   278,   137,    -1,    55,   178,   137,
     841     178,   137,   178,    -1,    54,   285,   137,    -1,    54,   122,
     842     177,   137,    -1,    53,   137,    -1,    53,   285,   137,    -1,
     843      52,   137,    -1,    52,   285,   137,    -1,    55,   178,   137,
    842844      -1,    64,   173,   137,    -1,    65,   173,   137,    -1,    65,
    843845     173,    66,   172,   137,    -1,    60,   181,   202,    -1,    60,
     
    850852     139,   205,   140,   115,   181,   140,    -1,   203,    62,   114,
    851853     139,   139,   205,   140,   115,   181,   140,    -1,    63,   181,
    852       -1,   233,    -1,   233,   315,    -1,   233,   363,    -1,   372,
    853      144,    -1,   372,    -1,    67,   207,   114,   146,   115,   137,
     854      -1,   235,    -1,   235,   322,    -1,   235,   370,    -1,   379,
     855     144,    -1,   379,    -1,    67,   207,   114,   146,   115,   137,
    854856      -1,    67,   207,   114,   146,   135,   208,   115,   137,    -1,
    855857      67,   207,   114,   146,   135,   208,   135,   208,   115,   137,
     
    863865      -1,   220,    -1,   214,   139,   220,    -1,   140,    -1,   216,
    864866      -1,   230,    -1,   216,   139,   230,    -1,    -1,   218,    -1,
    865       31,   219,   137,    -1,   218,    31,   219,   137,    -1,   280,
    866       -1,   219,   121,   280,    -1,   221,    -1,   230,    -1,   222,
     867      31,   219,   137,    -1,   218,    31,   219,   137,    -1,   287,
     868      -1,   219,   121,   287,    -1,   221,    -1,   230,    -1,   222,
    867869     140,   137,    -1,   227,   140,   137,    -1,   224,   140,   137,
    868       -1,   299,   140,   137,    -1,   302,   140,   137,    -1,   223,
    869      283,    -1,   239,   223,   283,    -1,   222,   140,   121,   139,
    870      278,   283,    -1,   373,   278,   317,    -1,   376,   278,   317,
    871       -1,   235,   376,   278,   317,    -1,   225,    -1,   235,   225,
    872       -1,   239,   225,    -1,   239,   235,   225,    -1,   224,   140,
    873      121,   139,   278,    -1,   376,   278,   114,   139,   266,   140,
    874      115,    -1,   226,   278,   114,   139,   266,   140,   115,    -1,
    875      116,   139,   268,   140,   117,    -1,   116,   139,   268,   140,
    876      121,   139,   269,   140,   117,    -1,     3,   223,    -1,     3,
    877      225,    -1,   227,   140,   121,   139,   144,    -1,     3,   233,
    878      315,    -1,   228,   140,   121,   139,   315,    -1,   235,     3,
    879      233,   315,    -1,   233,     3,   315,    -1,   233,     3,   235,
    880      315,    -1,     3,   144,   136,   172,    -1,   229,   140,   121,
     870      -1,   306,   140,   137,    -1,   309,   140,   137,    -1,   223,
     871     290,    -1,   241,   223,   290,    -1,   222,   140,   121,   139,
     872     285,   290,    -1,   380,   285,   324,    -1,   383,   285,   324,
     873      -1,   237,   383,   285,   324,    -1,   225,    -1,   237,   225,
     874      -1,   241,   225,    -1,   241,   237,   225,    -1,   224,   140,
     875     121,   139,   285,    -1,   383,   285,   114,   139,   273,   140,
     876     115,    -1,   226,   285,   114,   139,   273,   140,   115,    -1,
     877     116,   139,   275,   140,   117,    -1,   116,   139,   275,   140,
     878     121,   139,   276,   140,   117,    -1,     3,   223,    -1,     3,
     879     225,    -1,   227,   140,   121,   139,   144,    -1,     3,   234,
     880     322,    -1,   228,   140,   121,   139,   322,    -1,   237,     3,
     881     234,   322,    -1,   234,     3,   322,    -1,   234,     3,   237,
     882     322,    -1,     3,   144,   136,   172,    -1,   229,   140,   121,
    881883     139,   144,   136,   172,    -1,   232,   231,   140,   137,    -1,
    882      228,   140,   137,    -1,   229,   140,   137,    -1,   247,   140,
    883      137,    -1,   315,   317,   283,    -1,   231,   121,   318,   315,
    884      317,   283,    -1,   243,    -1,   247,    -1,   249,    -1,   289,
    885       -1,   244,    -1,   248,    -1,   250,    -1,   290,    -1,    -1,
    886      235,    -1,   236,    -1,   235,   236,    -1,   237,    -1,   320,
    887       -1,    10,    -1,    12,    -1,    11,    -1,    14,    -1,    70,
    888       -1,    -1,    13,   114,   238,   292,   115,    -1,   240,    -1,
    889      235,   240,    -1,   239,   235,   240,    -1,   241,    -1,   240,
    890      241,    -1,     5,    -1,     7,    -1,     4,    -1,     6,    -1,
    891        8,    -1,     9,    -1,    72,    -1,    74,    -1,    16,    -1,
    892       21,    -1,    20,    -1,    18,    -1,    19,    -1,    17,    -1,
    893       22,    -1,    23,    -1,    15,    -1,    27,    -1,    28,    -1,
    894       29,    -1,    26,    -1,    24,    -1,    25,    -1,   244,    -1,
    895      239,   244,    -1,   243,   241,    -1,   243,   241,   235,    -1,
    896      243,   241,   244,    -1,   245,    -1,   234,   246,   234,    -1,
    897      242,    -1,   235,   242,    -1,   245,   236,    -1,   245,   242,
    898       -1,    30,   114,   282,   115,    -1,    30,   114,   177,   115,
    899       -1,    81,   114,   282,   115,    -1,    81,   114,   177,   115,
    900       -1,   248,    -1,   239,   248,    -1,   247,   241,    -1,   247,
    901      241,   235,    -1,   251,    -1,   235,   251,    -1,   248,   236,
    902       -1,   250,    -1,   239,   250,    -1,   249,   241,    -1,   249,
    903      241,   235,    -1,    77,    -1,   235,    77,    -1,   250,   236,
    904       -1,   252,    -1,   262,    -1,   254,   318,   119,   255,   120,
    905       -1,   254,   318,   280,    -1,    -1,   254,   318,   280,   253,
    906      119,   255,   120,    -1,   254,   318,   114,   298,   115,   119,
    907      255,   120,    -1,   254,   318,   291,    -1,    33,    -1,    34,
    908       -1,    -1,   255,   256,    -1,   257,   137,    -1,    43,   257,
    909      137,    -1,   233,   258,   137,    -1,    43,   233,   258,   137,
    910       -1,   372,    -1,   372,   280,    -1,   257,   121,   280,    -1,
    911      257,   121,    -1,   259,    -1,   258,   121,   318,   259,    -1,
    912       -1,   261,    -1,   324,   260,    -1,   337,   260,    -1,   363,
    913       -1,    -1,   261,    -1,   135,   171,    -1,    32,   318,   119,
    914      264,   378,   120,    -1,    32,   318,   280,    -1,    -1,    32,
    915      318,   280,   263,   119,   264,   378,   120,    -1,   280,   265,
    916       -1,   264,   121,   280,   265,    -1,    -1,   136,   171,    -1,
    917       -1,   267,    -1,   269,    -1,   268,    -1,   268,   140,   121,
    918      139,   269,    -1,   269,   140,   121,   139,   101,    -1,   268,
    919      140,   121,   139,   101,    -1,   273,    -1,   269,   140,   121,
    920      139,   273,    -1,   268,   140,   121,   139,   273,    -1,   268,
    921      140,   121,   139,   269,   140,   121,   139,   273,    -1,   274,
    922       -1,   269,   140,   121,   139,   274,    -1,    -1,   271,    -1,
    923      272,    -1,   272,   140,   121,   139,   101,    -1,   276,    -1,
    924      275,    -1,   272,   140,   121,   139,   276,    -1,   272,   140,
    925      121,   139,   275,    -1,   275,    -1,   368,   278,   379,    -1,
    926      376,   278,   379,    -1,   235,   376,   278,   379,    -1,   225,
    927       -1,   276,    -1,   368,    -1,   376,    -1,   235,   376,    -1,
    928      377,    -1,   232,   342,   379,    -1,   232,   346,   379,    -1,
    929      232,   379,    -1,   232,   357,   379,    -1,   144,    -1,   277,
    930      121,   144,    -1,   142,    -1,    77,    -1,    78,    -1,   143,
    931       -1,    77,    -1,    78,    -1,   144,    -1,    77,    -1,    78,
    932       -1,   372,    -1,   233,    -1,   233,   351,    -1,   281,    -1,
    933      377,    -1,    -1,   136,   284,    -1,   112,   284,    -1,   172,
    934       -1,   119,   285,   378,   120,    -1,    -1,   284,    -1,   286,
    935      284,    -1,   285,   121,   284,    -1,   285,   121,   286,   284,
    936       -1,   287,   135,    -1,   280,   135,    -1,   288,    -1,   287,
    937      288,    -1,   118,   280,    -1,   116,   139,   172,   140,   117,
    938       -1,   116,   139,   316,   140,   117,    -1,   116,   139,   171,
    939      101,   171,   140,   117,    -1,   118,   116,   139,   152,   140,
    940      117,    -1,   290,    -1,   239,   290,    -1,   289,   241,    -1,
    941      289,   241,   235,    -1,   291,    -1,   235,   291,    -1,   290,
    942      236,    -1,    78,   114,   298,   115,    -1,   293,   379,    -1,
    943      292,   121,   293,   379,    -1,    -1,   295,   280,   294,   296,
    944       -1,   233,   342,    -1,    35,    -1,    37,    -1,    36,    -1,
    945       38,    -1,    -1,   296,   297,    -1,   133,   280,   114,   298,
    946      115,    -1,   133,   119,   139,   304,   120,    -1,   133,   114,
    947      139,   292,   140,   115,   119,   139,   304,   120,   114,   298,
    948      115,    -1,   282,    -1,   172,    -1,   298,   121,   282,    -1,
    949      298,   121,   172,    -1,    35,   300,    -1,   240,    35,   300,
    950       -1,   299,   121,   300,    -1,   301,   296,    -1,   301,   296,
    951      136,   282,    -1,   280,    -1,   279,   114,   139,   292,   140,
    952      115,    -1,    39,   280,   114,   139,   292,   140,   115,   119,
    953      120,    -1,    -1,    39,   280,   114,   139,   292,   140,   115,
    954      119,   303,   304,   120,    -1,   305,    -1,   304,   139,   305,
    955       -1,   306,   140,   137,    -1,   307,   140,   137,    -1,   223,
    956       -1,   225,    -1,   306,   140,   121,   139,   278,    -1,   233,
    957      315,    -1,   307,   140,   121,   139,   315,    -1,    -1,   309,
    958       -1,   311,    -1,   309,   139,   311,    -1,    -1,   309,    -1,
    959      220,    -1,   313,    -1,    67,   114,   146,   115,   137,    -1,
    960       -1,     5,    84,   312,   119,   310,   120,    -1,    43,   311,
    961       -1,   314,    -1,   329,   181,    -1,   333,   139,   215,   181,
    962       -1,   224,   181,    -1,   232,   329,   181,    -1,   235,   329,
    963      181,    -1,   239,   329,   181,    -1,   239,   235,   329,   181,
    964       -1,   232,   333,   139,   215,   181,    -1,   235,   333,   139,
    965      215,   181,    -1,   239,   333,   139,   215,   181,    -1,   239,
    966      235,   333,   139,   215,   181,    -1,   324,    -1,   337,    -1,
    967      329,    -1,   171,   127,   171,    -1,    -1,    67,   114,   146,
    968      115,   318,    -1,    -1,   319,    -1,   320,    -1,   319,   320,
    969       -1,    42,   114,   114,   321,   115,   115,    -1,   322,    -1,
    970      321,   121,   322,    -1,    -1,   323,    -1,   323,   114,   150,
    971      115,    -1,    75,    -1,    77,    -1,    78,    -1,    10,    -1,
    972      325,   318,    -1,   326,    -1,   327,   318,    -1,   328,   318,
    973       -1,   142,    -1,   114,   325,   115,    -1,   157,   324,    -1,
    974      157,   235,   324,    -1,   114,   326,   115,   318,    -1,   325,
    975      355,    -1,   114,   326,   115,   355,    -1,   114,   327,   115,
    976      356,    -1,   114,   327,   115,    -1,   114,   326,   115,   114,
    977      139,   270,   140,   115,    -1,   114,   328,   115,    -1,   330,
    978      318,    -1,   331,    -1,   332,   318,    -1,   325,   114,   139,
    979      270,   140,   115,    -1,   114,   331,   115,   114,   139,   270,
    980      140,   115,    -1,   114,   330,   115,    -1,   157,   329,    -1,
    981      157,   235,   329,    -1,   114,   331,   115,    -1,   114,   331,
    982      115,   355,    -1,   114,   332,   115,   356,    -1,   114,   332,
    983      115,    -1,   334,    -1,   335,    -1,   336,    -1,   325,   114,
    984      277,   115,    -1,   114,   335,   115,   114,   139,   270,   140,
    985      115,    -1,   114,   334,   115,    -1,   157,   333,    -1,   157,
    986      235,   333,    -1,   114,   335,   115,    -1,   114,   335,   115,
    987      355,    -1,   114,   336,   115,   356,    -1,   114,   336,   115,
    988       -1,   338,   318,    -1,   339,    -1,   340,   318,    -1,   341,
    989      318,    -1,   347,    -1,   114,   338,   115,    -1,   157,   337,
    990       -1,   157,   235,   337,    -1,   114,   339,   115,   318,    -1,
    991      338,   355,    -1,   114,   339,   115,   355,    -1,   114,   340,
    992      115,   356,    -1,   114,   340,   115,    -1,   338,   114,   139,
    993      270,   140,   115,    -1,   114,   339,   115,   114,   139,   270,
    994      140,   115,    -1,   114,   341,   115,    -1,   325,   318,    -1,
    995      343,    -1,   344,   318,    -1,   345,   318,    -1,   157,   342,
    996       -1,   157,   235,   342,    -1,   114,   343,   115,   318,    -1,
    997      325,   361,    -1,   114,   343,   115,   355,    -1,   114,   344,
    998      115,   356,    -1,   114,   344,   115,    -1,   325,   114,   139,
    999      270,   140,   115,    -1,   114,   343,   115,   114,   139,   270,
    1000      140,   115,    -1,   114,   345,   115,    -1,   347,   318,    -1,
    1001      348,    -1,   349,   318,    -1,   350,   318,    -1,    77,    -1,
    1002       78,    -1,   157,   346,    -1,   157,   235,   346,    -1,   114,
    1003      348,   115,   318,    -1,   347,   361,    -1,   114,   348,   115,
    1004      361,    -1,   347,   114,   139,   270,   140,   115,    -1,   114,
    1005      348,   115,   114,   139,   270,   140,   115,    -1,   352,    -1,
    1006      353,   318,    -1,   354,   318,    -1,   157,    -1,   157,   235,
    1007       -1,   157,   351,    -1,   157,   235,   351,    -1,   114,   352,
    1008      115,   318,    -1,   355,    -1,   114,   352,   115,   355,    -1,
    1009      114,   353,   115,   356,    -1,   114,   353,   115,    -1,   114,
    1010      139,   270,   140,   115,    -1,   114,   352,   115,   114,   139,
    1011      270,   140,   115,    -1,   114,   354,   115,    -1,   116,   117,
    1012       -1,   116,   117,   356,    -1,   356,    -1,   116,   139,   172,
    1013      140,   117,    -1,   116,   139,   122,   140,   117,    -1,   356,
    1014      116,   139,   172,   140,   117,    -1,   356,   116,   139,   122,
    1015      140,   117,    -1,   358,    -1,   359,   318,    -1,   360,   318,
    1016       -1,   157,    -1,   157,   235,    -1,   157,   357,    -1,   157,
    1017      235,   357,    -1,   114,   358,   115,   318,    -1,   361,    -1,
    1018      114,   358,   115,   361,    -1,   114,   359,   115,   356,    -1,
    1019      114,   359,   115,    -1,   114,   139,   270,   140,   115,    -1,
    1020      114,   358,   115,   114,   139,   270,   140,   115,    -1,   114,
    1021      360,   115,    -1,   362,    -1,   362,   356,    -1,   356,    -1,
    1022      116,   117,    -1,   116,   139,   235,   122,   140,   117,    -1,
    1023      116,   139,   235,   140,   117,    -1,   116,   139,   235,   172,
    1024      140,   117,    -1,   116,   139,     7,   234,   172,   140,   117,
    1025       -1,   116,   139,   235,     7,   172,   140,   117,    -1,   364,
    1026       -1,   365,   318,    -1,   366,   318,    -1,   157,    -1,   157,
    1027      235,    -1,   157,   363,    -1,   157,   235,   363,    -1,   114,
    1028      364,   115,   318,    -1,   355,    -1,   114,   364,   115,   355,
    1029       -1,   114,   365,   115,   356,    -1,   114,   365,   115,    -1,
    1030      114,   364,   115,   114,   139,   270,   140,   115,    -1,   114,
    1031      366,   115,    -1,   368,    -1,   376,    -1,   235,   376,    -1,
    1032      369,    -1,   370,    -1,   157,   233,    -1,   235,   157,   233,
    1033       -1,   157,   377,    -1,   235,   157,   377,    -1,   157,   367,
    1034       -1,   235,   157,   367,    -1,   116,   117,   233,    -1,   371,
    1035      233,    -1,   116,   117,   356,   233,    -1,   371,   356,   233,
    1036       -1,   356,   233,    -1,   116,   117,   369,    -1,   371,   369,
    1037       -1,   116,   117,   356,   369,    -1,   371,   356,   369,    -1,
    1038      356,   369,    -1,   116,   139,   235,   122,   140,   117,    -1,
    1039      116,   139,   235,   172,   140,   117,    -1,   116,   139,   239,
    1040      172,   140,   117,    -1,   116,   139,   239,   235,   172,   140,
    1041      117,    -1,   376,    -1,   235,   376,    -1,   373,    -1,   374,
    1042       -1,   375,    -1,   157,   233,    -1,   235,   157,   233,    -1,
    1043      157,   377,    -1,   235,   157,   377,    -1,   157,   372,    -1,
    1044      235,   157,   372,    -1,   116,   117,   233,    -1,   116,   117,
    1045      356,   233,    -1,   356,   233,    -1,   116,   117,   374,    -1,
    1046      116,   117,   356,   374,    -1,   356,   374,    -1,   116,   139,
    1047      269,   140,   117,    -1,   376,   114,   139,   266,   140,   115,
    1048       -1,   226,   114,   139,   266,   140,   115,    -1,    -1,   121,
    1049       -1,    -1,   136,   172,    -1
     884     228,   140,   137,    -1,   229,   140,   137,    -1,   249,   140,
     885     137,    -1,   322,   324,   290,    -1,   231,   121,   325,   322,
     886     324,   290,    -1,   245,    -1,   249,    -1,   253,    -1,   296,
     887      -1,   245,    -1,   251,    -1,   253,    -1,   296,    -1,   246,
     888      -1,   250,    -1,   254,    -1,   297,    -1,   246,    -1,   252,
     889      -1,   254,    -1,   297,    -1,    -1,   237,    -1,   238,    -1,
     890     237,   238,    -1,   239,    -1,   327,    -1,    10,    -1,    12,
     891      -1,    11,    -1,    14,    -1,    70,    -1,    -1,    13,   114,
     892     240,   299,   115,    -1,   242,    -1,   237,   242,    -1,   241,
     893     237,   242,    -1,   243,    -1,   242,   243,    -1,     5,    -1,
     894       7,    -1,     4,    -1,     6,    -1,    74,    -1,     8,    -1,
     895       9,    -1,    72,    -1,    16,    -1,    21,    -1,    20,    -1,
     896      18,    -1,    19,    -1,    17,    -1,    22,    -1,    23,    -1,
     897      15,    -1,    27,    -1,    28,    -1,    29,    -1,    26,    -1,
     898      24,    -1,    25,    -1,   246,    -1,   241,   246,    -1,   245,
     899     243,    -1,   245,   243,   237,    -1,   245,   243,   246,    -1,
     900     247,    -1,   236,   248,   236,    -1,   244,    -1,   237,   244,
     901      -1,   247,   238,    -1,   247,   244,    -1,    30,   114,   289,
     902     115,    -1,    30,   114,   177,   115,    -1,    81,   114,   289,
     903     115,    -1,    81,   114,   177,   115,    -1,   250,    -1,   241,
     904     250,    -1,   249,   243,    -1,   249,   243,   237,    -1,   255,
     905      -1,   237,   255,    -1,   250,   238,    -1,   252,    -1,   241,
     906     252,    -1,   251,   243,    -1,   251,   243,   237,    -1,   256,
     907      -1,   237,   256,    -1,   252,   238,    -1,   254,    -1,   241,
     908     254,    -1,   253,   243,    -1,   253,   243,   237,    -1,    77,
     909      -1,   237,    77,    -1,   254,   238,    -1,   257,    -1,   268,
     910      -1,   259,    -1,   270,    -1,   260,   325,   119,   261,   120,
     911      -1,    -1,   260,   325,   287,   258,   119,   261,   120,    -1,
     912     260,   325,   114,   305,   115,   119,   261,   120,    -1,   259,
     913      -1,   260,   325,   287,    -1,   260,   325,   298,    -1,    33,
     914      -1,    34,    -1,    -1,   261,   262,    -1,   263,   137,    -1,
     915      43,   263,   137,    -1,   234,   264,   137,    -1,    43,   234,
     916     264,   137,    -1,   379,    -1,   379,   287,    -1,   263,   121,
     917     287,    -1,   263,   121,    -1,   265,    -1,   264,   121,   325,
     918     265,    -1,    -1,   267,    -1,   331,   266,    -1,   344,   266,
     919      -1,   370,    -1,    -1,   267,    -1,   135,   171,    -1,    32,
     920     325,   119,   271,   385,   120,    -1,    -1,    32,   325,   287,
     921     269,   119,   271,   385,   120,    -1,   270,    -1,    32,   325,
     922     287,    -1,   287,   272,    -1,   271,   121,   287,   272,    -1,
     923      -1,   136,   171,    -1,    -1,   274,    -1,   276,    -1,   275,
     924      -1,   275,   140,   121,   139,   276,    -1,   276,   140,   121,
     925     139,   101,    -1,   275,   140,   121,   139,   101,    -1,   280,
     926      -1,   276,   140,   121,   139,   280,    -1,   275,   140,   121,
     927     139,   280,    -1,   275,   140,   121,   139,   276,   140,   121,
     928     139,   280,    -1,   281,    -1,   276,   140,   121,   139,   281,
     929      -1,    -1,   278,    -1,   279,    -1,   279,   140,   121,   139,
     930     101,    -1,   283,    -1,   282,    -1,   279,   140,   121,   139,
     931     283,    -1,   279,   140,   121,   139,   282,    -1,   282,    -1,
     932     375,   285,   386,    -1,   383,   285,   386,    -1,   237,   383,
     933     285,   386,    -1,   225,    -1,   283,    -1,   375,    -1,   383,
     934      -1,   237,   383,    -1,   384,    -1,   233,   349,   386,    -1,
     935     233,   353,   386,    -1,   233,   386,    -1,   233,   364,   386,
     936      -1,   144,    -1,   284,   121,   144,    -1,   142,    -1,    77,
     937      -1,    78,    -1,   143,    -1,    77,    -1,    78,    -1,   144,
     938      -1,    77,    -1,    78,    -1,   379,    -1,   234,    -1,   234,
     939     358,    -1,   288,    -1,   384,    -1,    -1,   136,   291,    -1,
     940     112,   291,    -1,   172,    -1,   119,   292,   385,   120,    -1,
     941      -1,   291,    -1,   293,   291,    -1,   292,   121,   291,    -1,
     942     292,   121,   293,   291,    -1,   294,   135,    -1,   287,   135,
     943      -1,   295,    -1,   294,   295,    -1,   118,   287,    -1,   116,
     944     139,   172,   140,   117,    -1,   116,   139,   323,   140,   117,
     945      -1,   116,   139,   171,   101,   171,   140,   117,    -1,   118,
     946     116,   139,   152,   140,   117,    -1,   297,    -1,   241,   297,
     947      -1,   296,   243,    -1,   296,   243,   237,    -1,   298,    -1,
     948     237,   298,    -1,   297,   238,    -1,    78,   114,   305,   115,
     949      -1,   300,   386,    -1,   299,   121,   300,   386,    -1,    -1,
     950     302,   287,   301,   303,    -1,   234,   349,    -1,    35,    -1,
     951      37,    -1,    36,    -1,    38,    -1,    -1,   303,   304,    -1,
     952     133,   287,   114,   305,   115,    -1,   133,   119,   139,   311,
     953     120,    -1,   133,   114,   139,   299,   140,   115,   119,   139,
     954     311,   120,   114,   305,   115,    -1,   289,    -1,   172,    -1,
     955     305,   121,   289,    -1,   305,   121,   172,    -1,    35,   307,
     956      -1,   242,    35,   307,    -1,   306,   121,   307,    -1,   308,
     957     303,    -1,   308,   303,   136,   289,    -1,   287,    -1,   286,
     958     114,   139,   299,   140,   115,    -1,    39,   287,   114,   139,
     959     299,   140,   115,   119,   120,    -1,    -1,    39,   287,   114,
     960     139,   299,   140,   115,   119,   310,   311,   120,    -1,   312,
     961      -1,   311,   139,   312,    -1,   313,   140,   137,    -1,   314,
     962     140,   137,    -1,   223,    -1,   225,    -1,   313,   140,   121,
     963     139,   285,    -1,   234,   322,    -1,   314,   140,   121,   139,
     964     322,    -1,    -1,   316,    -1,   318,    -1,   316,   139,   318,
     965      -1,    -1,   316,    -1,   220,    -1,   320,    -1,    67,   114,
     966     146,   115,   137,    -1,    -1,     5,    84,   319,   119,   317,
     967     120,    -1,    43,   318,    -1,   321,    -1,   336,   181,    -1,
     968     340,   139,   215,   181,    -1,   224,   181,    -1,   232,   336,
     969     181,    -1,   237,   336,   181,    -1,   241,   336,   181,    -1,
     970     241,   237,   336,   181,    -1,   232,   340,   139,   215,   181,
     971      -1,   237,   340,   139,   215,   181,    -1,   241,   340,   139,
     972     215,   181,    -1,   241,   237,   340,   139,   215,   181,    -1,
     973     331,    -1,   344,    -1,   336,    -1,   171,   127,   171,    -1,
     974      -1,    67,   114,   146,   115,   325,    -1,    -1,   326,    -1,
     975     327,    -1,   326,   327,    -1,    42,   114,   114,   328,   115,
     976     115,    -1,   329,    -1,   328,   121,   329,    -1,    -1,   330,
     977      -1,   330,   114,   150,   115,    -1,    75,    -1,    77,    -1,
     978      78,    -1,    10,    -1,   332,   325,    -1,   333,    -1,   334,
     979     325,    -1,   335,   325,    -1,   142,    -1,   114,   332,   115,
     980      -1,   157,   331,    -1,   157,   237,   331,    -1,   114,   333,
     981     115,   325,    -1,   332,   362,    -1,   114,   333,   115,   362,
     982      -1,   114,   334,   115,   363,    -1,   114,   334,   115,    -1,
     983     114,   333,   115,   114,   139,   277,   140,   115,    -1,   114,
     984     335,   115,    -1,   337,   325,    -1,   338,    -1,   339,   325,
     985      -1,   332,   114,   139,   277,   140,   115,    -1,   114,   338,
     986     115,   114,   139,   277,   140,   115,    -1,   114,   337,   115,
     987      -1,   157,   336,    -1,   157,   237,   336,    -1,   114,   338,
     988     115,    -1,   114,   338,   115,   362,    -1,   114,   339,   115,
     989     363,    -1,   114,   339,   115,    -1,   341,    -1,   342,    -1,
     990     343,    -1,   332,   114,   284,   115,    -1,   114,   342,   115,
     991     114,   139,   277,   140,   115,    -1,   114,   341,   115,    -1,
     992     157,   340,    -1,   157,   237,   340,    -1,   114,   342,   115,
     993      -1,   114,   342,   115,   362,    -1,   114,   343,   115,   363,
     994      -1,   114,   343,   115,    -1,   345,   325,    -1,   346,    -1,
     995     347,   325,    -1,   348,   325,    -1,   354,    -1,   114,   345,
     996     115,    -1,   157,   344,    -1,   157,   237,   344,    -1,   114,
     997     346,   115,   325,    -1,   345,   362,    -1,   114,   346,   115,
     998     362,    -1,   114,   347,   115,   363,    -1,   114,   347,   115,
     999      -1,   345,   114,   139,   277,   140,   115,    -1,   114,   346,
     1000     115,   114,   139,   277,   140,   115,    -1,   114,   348,   115,
     1001      -1,   332,   325,    -1,   350,    -1,   351,   325,    -1,   352,
     1002     325,    -1,   157,   349,    -1,   157,   237,   349,    -1,   114,
     1003     350,   115,   325,    -1,   332,   368,    -1,   114,   350,   115,
     1004     362,    -1,   114,   351,   115,   363,    -1,   114,   351,   115,
     1005      -1,   332,   114,   139,   277,   140,   115,    -1,   114,   350,
     1006     115,   114,   139,   277,   140,   115,    -1,   114,   352,   115,
     1007      -1,   354,   325,    -1,   355,    -1,   356,   325,    -1,   357,
     1008     325,    -1,    77,    -1,    78,    -1,   157,   353,    -1,   157,
     1009     237,   353,    -1,   114,   355,   115,   325,    -1,   354,   368,
     1010      -1,   114,   355,   115,   368,    -1,   354,   114,   139,   277,
     1011     140,   115,    -1,   114,   355,   115,   114,   139,   277,   140,
     1012     115,    -1,   359,    -1,   360,   325,    -1,   361,   325,    -1,
     1013     157,    -1,   157,   237,    -1,   157,   358,    -1,   157,   237,
     1014     358,    -1,   114,   359,   115,   325,    -1,   362,    -1,   114,
     1015     359,   115,   362,    -1,   114,   360,   115,   363,    -1,   114,
     1016     360,   115,    -1,   114,   139,   277,   140,   115,    -1,   114,
     1017     359,   115,   114,   139,   277,   140,   115,    -1,   114,   361,
     1018     115,    -1,   116,   117,    -1,   116,   117,   363,    -1,   363,
     1019      -1,   116,   139,   172,   140,   117,    -1,   116,   139,   122,
     1020     140,   117,    -1,   363,   116,   139,   172,   140,   117,    -1,
     1021     363,   116,   139,   122,   140,   117,    -1,   365,    -1,   366,
     1022     325,    -1,   367,   325,    -1,   157,    -1,   157,   237,    -1,
     1023     157,   364,    -1,   157,   237,   364,    -1,   114,   365,   115,
     1024     325,    -1,   368,    -1,   114,   365,   115,   368,    -1,   114,
     1025     366,   115,   363,    -1,   114,   366,   115,    -1,   114,   139,
     1026     277,   140,   115,    -1,   114,   365,   115,   114,   139,   277,
     1027     140,   115,    -1,   114,   367,   115,    -1,   369,    -1,   369,
     1028     363,    -1,   363,    -1,   116,   117,    -1,   116,   139,   237,
     1029     122,   140,   117,    -1,   116,   139,   237,   140,   117,    -1,
     1030     116,   139,   237,   172,   140,   117,    -1,   116,   139,     7,
     1031     236,   172,   140,   117,    -1,   116,   139,   237,     7,   172,
     1032     140,   117,    -1,   371,    -1,   372,   325,    -1,   373,   325,
     1033      -1,   157,    -1,   157,   237,    -1,   157,   370,    -1,   157,
     1034     237,   370,    -1,   114,   371,   115,   325,    -1,   362,    -1,
     1035     114,   371,   115,   362,    -1,   114,   372,   115,   363,    -1,
     1036     114,   372,   115,    -1,   114,   371,   115,   114,   139,   277,
     1037     140,   115,    -1,   114,   373,   115,    -1,   375,    -1,   383,
     1038      -1,   237,   383,    -1,   376,    -1,   377,    -1,   157,   235,
     1039      -1,   237,   157,   235,    -1,   157,   384,    -1,   237,   157,
     1040     384,    -1,   157,   374,    -1,   237,   157,   374,    -1,   116,
     1041     117,   235,    -1,   378,   235,    -1,   116,   117,   363,   235,
     1042      -1,   378,   363,   235,    -1,   363,   235,    -1,   116,   117,
     1043     376,    -1,   378,   376,    -1,   116,   117,   363,   376,    -1,
     1044     378,   363,   376,    -1,   363,   376,    -1,   116,   139,   237,
     1045     122,   140,   117,    -1,   116,   139,   237,   172,   140,   117,
     1046      -1,   116,   139,   241,   172,   140,   117,    -1,   116,   139,
     1047     241,   237,   172,   140,   117,    -1,   383,    -1,   237,   383,
     1048      -1,   380,    -1,   381,    -1,   382,    -1,   157,   234,    -1,
     1049     237,   157,   234,    -1,   157,   384,    -1,   237,   157,   384,
     1050      -1,   157,   379,    -1,   237,   157,   379,    -1,   116,   117,
     1051     234,    -1,   116,   117,   363,   234,    -1,   363,   234,    -1,
     1052     116,   117,   381,    -1,   116,   117,   363,   381,    -1,   363,
     1053     381,    -1,   116,   139,   276,   140,   117,    -1,   383,   114,
     1054     139,   273,   140,   115,    -1,   226,   114,   139,   273,   140,
     1055     115,    -1,    -1,   121,    -1,    -1,   136,   172,    -1
    10501056};
    10511057
     
    10741080     892,   897,   899,   904,   906,   910,   913,   917,   920,   924,
    10751081     926,   928,   930,   935,   937,   939,   944,   946,   948,   950,
    1076      952,   957,   959,   961,   963,   968,   980,   981,   986,   988,
    1077      993,   997,   999,  1001,  1003,  1005,  1011,  1012,  1018,  1019,
    1078     1023,  1024,  1029,  1031,  1037,  1038,  1040,  1046,  1051,  1061,
    1079     1063,  1067,  1068,  1073,  1075,  1079,  1080,  1084,  1086,  1090,
    1080     1091,  1095,  1096,  1100,  1101,  1116,  1117,  1118,  1119,  1120,
    1081     1124,  1129,  1136,  1146,  1151,  1156,  1164,  1169,  1174,  1179,
    1082     1184,  1214,  1219,  1226,  1228,  1235,  1240,  1245,  1256,  1261,
    1083     1266,  1271,  1276,  1285,  1290,  1320,  1324,  1325,  1326,  1332,
    1084     1337,  1345,  1346,  1347,  1348,  1352,  1353,  1354,  1355,  1360,
    1085     1361,  1370,  1371,  1376,  1377,  1381,  1383,  1385,  1387,  1389,
    1086     1392,  1391,  1403,  1404,  1406,  1416,  1417,  1422,  1424,  1426,
    1087     1428,  1430,  1433,  1435,  1438,  1443,  1445,  1447,  1449,  1451,
    1088     1453,  1455,  1457,  1459,  1461,  1463,  1465,  1467,  1469,  1471,
    1089     1477,  1478,  1480,  1482,  1484,  1489,  1490,  1496,  1497,  1499,
    1090     1501,  1506,  1508,  1510,  1512,  1517,  1518,  1520,  1522,  1527,
    1091     1528,  1530,  1535,  1536,  1538,  1540,  1545,  1547,  1549,  1554,
    1092     1555,  1559,  1561,  1567,  1566,  1570,  1572,  1577,  1579,  1585,
    1093     1586,  1591,  1592,  1597,  1600,  1608,  1609,  1611,  1613,  1618,
    1094     1619,  1625,  1626,  1628,  1631,  1634,  1639,  1640,  1645,  1650,
    1095     1652,  1658,  1657,  1664,  1666,  1672,  1673,  1681,  1682,  1686,
    1096     1687,  1688,  1690,  1692,  1699,  1700,  1702,  1704,  1709,  1710,
    1097     1716,  1717,  1721,  1722,  1727,  1728,  1729,  1731,  1739,  1740,
    1098     1742,  1745,  1747,  1751,  1752,  1753,  1755,  1757,  1761,  1766,
    1099     1774,  1776,  1785,  1787,  1792,  1793,  1794,  1798,  1799,  1800,
    1100     1804,  1805,  1806,  1810,  1811,  1812,  1817,  1818,  1823,  1824,
    1101     1826,  1831,  1832,  1837,  1838,  1839,  1840,  1841,  1856,  1857,
    1102     1862,  1863,  1869,  1871,  1874,  1876,  1878,  1901,  1902,  1904,
    1103     1906,  1911,  1912,  1914,  1919,  1924,  1925,  1931,  1930,  1934,
    1104     1938,  1940,  1942,  1944,  1950,  1951,  1956,  1961,  1963,  1968,
    1105     1970,  1971,  1973,  1978,  1980,  1982,  1987,  1989,  1994,  1999,
    1106     2007,  2013,  2012,  2026,  2027,  2032,  2033,  2037,  2042,  2047,
    1107     2055,  2060,  2071,  2072,  2077,  2078,  2084,  2085,  2089,  2090,
    1108     2091,  2096,  2095,  2106,  2114,  2120,  2126,  2135,  2141,  2147,
    1109     2153,  2159,  2167,  2173,  2181,  2187,  2196,  2197,  2198,  2202,
    1110     2208,  2209,  2219,  2220,  2224,  2225,  2230,  2235,  2236,  2242,
    1111     2243,  2245,  2250,  2251,  2252,  2253,  2288,  2290,  2291,  2293,
    1112     2298,  2303,  2308,  2310,  2312,  2317,  2319,  2321,  2323,  2328,
    1113     2330,  2339,  2341,  2342,  2347,  2349,  2351,  2356,  2358,  2360,
    1114     2365,  2367,  2369,  2381,  2382,  2383,  2387,  2389,  2391,  2396,
    1115     2398,  2400,  2405,  2407,  2409,  2424,  2426,  2427,  2429,  2434,
    1116     2435,  2440,  2442,  2444,  2449,  2451,  2453,  2455,  2460,  2462,
    1117     2464,  2474,  2476,  2477,  2479,  2484,  2486,  2488,  2493,  2495,
    1118     2497,  2499,  2504,  2506,  2508,  2521,  2523,  2524,  2526,  2531,
    1119     2536,  2544,  2546,  2548,  2553,  2555,  2560,  2562,  2579,  2580,
    1120     2582,  2587,  2589,  2591,  2593,  2595,  2600,  2601,  2603,  2605,
    1121     2610,  2612,  2614,  2620,  2622,  2624,  2628,  2630,  2632,  2634,
    1122     2668,  2669,  2671,  2676,  2678,  2680,  2682,  2684,  2689,  2690,
    1123     2692,  2694,  2699,  2701,  2703,  2709,  2710,  2712,  2721,  2724,
    1124     2726,  2729,  2731,  2733,  2747,  2748,  2750,  2755,  2757,  2759,
    1125     2761,  2763,  2768,  2769,  2771,  2773,  2778,  2780,  2788,  2789,
    1126     2790,  2795,  2796,  2800,  2802,  2804,  2806,  2808,  2810,  2817,
    1127     2819,  2821,  2823,  2825,  2828,  2830,  2832,  2834,  2836,  2841,
    1128     2843,  2845,  2850,  2876,  2877,  2879,  2883,  2884,  2888,  2890,
    1129     2892,  2894,  2896,  2898,  2905,  2907,  2909,  2911,  2913,  2915,
    1130     2920,  2927,  2929,  2947,  2949,  2954,  2955
     1082     952,   957,   959,   961,   963,   968,   976,   977,   982,   984,
     1083     989,   993,   995,   997,   999,  1001,  1007,  1008,  1014,  1015,
     1084    1019,  1020,  1025,  1027,  1033,  1034,  1036,  1042,  1047,  1057,
     1085    1059,  1063,  1064,  1069,  1071,  1075,  1076,  1080,  1082,  1086,
     1086    1087,  1091,  1092,  1096,  1097,  1112,  1113,  1114,  1115,  1116,
     1087    1120,  1125,  1132,  1142,  1147,  1152,  1160,  1165,  1170,  1175,
     1088    1180,  1210,  1215,  1222,  1224,  1231,  1236,  1241,  1252,  1257,
     1089    1262,  1267,  1272,  1281,  1286,  1316,  1320,  1321,  1322,  1328,
     1090    1333,  1341,  1342,  1343,  1344,  1353,  1354,  1355,  1356,  1360,
     1091    1361,  1362,  1363,  1372,  1373,  1374,  1375,  1380,  1381,  1390,
     1092    1391,  1396,  1397,  1401,  1403,  1405,  1407,  1409,  1412,  1411,
     1093    1423,  1424,  1426,  1436,  1437,  1442,  1444,  1446,  1448,  1450,
     1094    1453,  1455,  1457,  1462,  1464,  1466,  1468,  1470,  1472,  1474,
     1095    1476,  1478,  1480,  1482,  1484,  1486,  1488,  1490,  1496,  1497,
     1096    1499,  1501,  1503,  1508,  1509,  1515,  1516,  1518,  1520,  1525,
     1097    1527,  1529,  1531,  1536,  1537,  1539,  1541,  1546,  1547,  1549,
     1098    1554,  1555,  1557,  1559,  1564,  1565,  1567,  1572,  1573,  1575,
     1099    1577,  1582,  1584,  1586,  1591,  1592,  1596,  1597,  1601,  1604,
     1100    1603,  1607,  1609,  1613,  1618,  1623,  1625,  1631,  1632,  1637,
     1101    1638,  1643,  1646,  1654,  1655,  1657,  1659,  1664,  1665,  1671,
     1102    1672,  1674,  1677,  1680,  1685,  1686,  1691,  1696,  1699,  1698,
     1103    1702,  1706,  1714,  1716,  1722,  1723,  1731,  1732,  1736,  1737,
     1104    1738,  1740,  1742,  1749,  1750,  1752,  1754,  1759,  1760,  1766,
     1105    1767,  1771,  1772,  1777,  1778,  1779,  1781,  1789,  1790,  1792,
     1106    1795,  1797,  1801,  1802,  1803,  1805,  1807,  1812,  1817,  1825,
     1107    1827,  1836,  1838,  1843,  1844,  1845,  1849,  1850,  1851,  1855,
     1108    1856,  1857,  1861,  1862,  1863,  1868,  1869,  1874,  1875,  1877,
     1109    1882,  1883,  1888,  1889,  1890,  1891,  1892,  1907,  1908,  1913,
     1110    1914,  1920,  1922,  1925,  1927,  1929,  1952,  1953,  1955,  1957,
     1111    1962,  1963,  1965,  1970,  1975,  1976,  1982,  1981,  1985,  1989,
     1112    1991,  1993,  1995,  2001,  2002,  2007,  2012,  2014,  2019,  2021,
     1113    2022,  2024,  2029,  2031,  2033,  2038,  2040,  2045,  2050,  2058,
     1114    2064,  2063,  2077,  2078,  2083,  2084,  2088,  2093,  2098,  2106,
     1115    2111,  2122,  2123,  2128,  2129,  2135,  2136,  2140,  2141,  2142,
     1116    2147,  2146,  2157,  2165,  2171,  2177,  2186,  2192,  2198,  2204,
     1117    2210,  2218,  2224,  2232,  2238,  2247,  2248,  2249,  2253,  2259,
     1118    2260,  2270,  2271,  2275,  2276,  2281,  2286,  2287,  2293,  2294,
     1119    2296,  2301,  2302,  2303,  2304,  2339,  2341,  2342,  2344,  2349,
     1120    2354,  2359,  2361,  2363,  2368,  2370,  2372,  2374,  2379,  2381,
     1121    2390,  2392,  2393,  2398,  2400,  2402,  2407,  2409,  2411,  2416,
     1122    2418,  2420,  2432,  2433,  2434,  2438,  2440,  2442,  2447,  2449,
     1123    2451,  2456,  2458,  2460,  2475,  2477,  2478,  2480,  2485,  2486,
     1124    2491,  2493,  2495,  2500,  2502,  2504,  2506,  2511,  2513,  2515,
     1125    2525,  2527,  2528,  2530,  2535,  2537,  2539,  2544,  2546,  2548,
     1126    2550,  2555,  2557,  2559,  2572,  2574,  2575,  2577,  2582,  2587,
     1127    2595,  2597,  2599,  2604,  2606,  2611,  2613,  2630,  2631,  2633,
     1128    2638,  2640,  2642,  2644,  2646,  2651,  2652,  2654,  2656,  2661,
     1129    2663,  2665,  2671,  2673,  2675,  2679,  2681,  2683,  2685,  2719,
     1130    2720,  2722,  2727,  2729,  2731,  2733,  2735,  2740,  2741,  2743,
     1131    2745,  2750,  2752,  2754,  2760,  2761,  2763,  2772,  2775,  2777,
     1132    2780,  2782,  2784,  2798,  2799,  2801,  2806,  2808,  2810,  2812,
     1133    2814,  2819,  2820,  2822,  2824,  2829,  2831,  2839,  2840,  2841,
     1134    2846,  2847,  2852,  2854,  2856,  2858,  2860,  2862,  2869,  2871,
     1135    2873,  2875,  2877,  2880,  2882,  2884,  2886,  2888,  2893,  2895,
     1136    2897,  2902,  2928,  2929,  2931,  2935,  2936,  2940,  2942,  2944,
     1137    2946,  2948,  2950,  2957,  2959,  2961,  2963,  2965,  2967,  2972,
     1138    2979,  2981,  2999,  3001,  3006,  3007
    11311139};
    11321140#endif
     
    11891197  "cfa_function_return", "cfa_typedef_declaration", "typedef_declaration",
    11901198  "typedef_expression", "c_declaration", "declaring_list",
    1191   "declaration_specifier", "type_specifier", "type_qualifier_list_opt",
     1199  "declaration_specifier", "declaration_specifier_nobody",
     1200  "type_specifier", "type_specifier_nobody", "type_qualifier_list_opt",
    11921201  "type_qualifier_list", "type_qualifier", "type_qualifier_name", "$@1",
    11931202  "declaration_qualifier_list", "storage_class_list", "storage_class",
    11941203  "basic_type_name", "basic_declaration_specifier", "basic_type_specifier",
    11951204  "direct_type_name", "indirect_type_name", "sue_declaration_specifier",
    1196   "sue_type_specifier", "typedef_declaration_specifier",
    1197   "typedef_type_specifier", "elaborated_type", "aggregate_type", "$@2",
    1198   "aggregate_key", "field_declaration_list", "field_declaration",
     1205  "sue_type_specifier", "sue_declaration_specifier_nobody",
     1206  "sue_type_specifier_nobody", "typedef_declaration_specifier",
     1207  "typedef_type_specifier", "elaborated_type", "elaborated_type_nobody",
     1208  "aggregate_type", "$@2", "aggregate_type_nobody", "aggregate_key",
     1209  "field_declaration_list", "field_declaration",
    11991210  "cfa_field_declaring_list", "field_declaring_list", "field_declarator",
    12001211  "bit_subrange_size_opt", "bit_subrange_size", "enum_type", "$@3",
    1201   "enumerator_list", "enumerator_value_opt", "cfa_parameter_type_list_opt",
    1202   "cfa_parameter_type_list", "cfa_parameter_list",
    1203   "cfa_abstract_parameter_list", "parameter_type_list_opt",
    1204   "parameter_type_list", "parameter_list", "cfa_parameter_declaration",
    1205   "cfa_abstract_parameter_declaration", "parameter_declaration",
    1206   "abstract_parameter_declaration", "identifier_list",
    1207   "identifier_or_type_name", "no_01_identifier_or_type_name",
    1208   "no_attr_identifier_or_type_name", "type_name_no_function", "type_name",
    1209   "initializer_opt", "initializer", "initializer_list", "designation",
    1210   "designator_list", "designator", "typegen_declaration_specifier",
    1211   "typegen_type_specifier", "typegen_name", "type_parameter_list",
    1212   "type_parameter", "$@4", "type_class", "assertion_list_opt", "assertion",
    1213   "type_name_list", "type_declaring_list", "type_declarator",
    1214   "type_declarator_name", "trait_specifier", "$@5",
    1215   "trait_declaration_list", "trait_declaration",
     1212  "enum_type_nobody", "enumerator_list", "enumerator_value_opt",
     1213  "cfa_parameter_type_list_opt", "cfa_parameter_type_list",
     1214  "cfa_parameter_list", "cfa_abstract_parameter_list",
     1215  "parameter_type_list_opt", "parameter_type_list", "parameter_list",
     1216  "cfa_parameter_declaration", "cfa_abstract_parameter_declaration",
     1217  "parameter_declaration", "abstract_parameter_declaration",
     1218  "identifier_list", "identifier_or_type_name",
     1219  "no_01_identifier_or_type_name", "no_attr_identifier_or_type_name",
     1220  "type_name_no_function", "type_name", "initializer_opt", "initializer",
     1221  "initializer_list", "designation", "designator_list", "designator",
     1222  "typegen_declaration_specifier", "typegen_type_specifier",
     1223  "typegen_name", "type_parameter_list", "type_parameter", "$@4",
     1224  "type_class", "assertion_list_opt", "assertion", "type_name_list",
     1225  "type_declaring_list", "type_declarator", "type_declarator_name",
     1226  "trait_specifier", "$@5", "trait_declaration_list", "trait_declaration",
    12161227  "cfa_trait_declaring_list", "trait_declaring_list", "translation_unit",
    12171228  "external_definition_list", "external_definition_list_opt",
     
    13021313     228,   228,   228,   229,   229,   230,   230,   230,   230,   231,
    13031314     231,   232,   232,   232,   232,   233,   233,   233,   233,   234,
    1304      234,   235,   235,   236,   236,   237,   237,   237,   237,   237,
    1305      238,   237,   239,   239,   239,   240,   240,   241,   241,   241,
    1306      241,   241,   241,   241,   241,   242,   242,   242,   242,   242,
    1307      242,   242,   242,   242,   242,   242,   242,   242,   242,   242,
    1308      243,   243,   243,   243,   243,   244,   244,   245,   245,   245,
    1309      245,   246,   246,   246,   246,   247,   247,   247,   247,   248,
    1310      248,   248,   249,   249,   249,   249,   250,   250,   250,   251,
    1311      251,   252,   252,   253,   252,   252,   252,   254,   254,   255,
    1312      255,   256,   256,   256,   256,   257,   257,   257,   257,   258,
    1313      258,   259,   259,   259,   259,   259,   260,   260,   261,   262,
    1314      262,   263,   262,   264,   264,   265,   265,   266,   266,   267,
    1315      267,   267,   267,   267,   268,   268,   268,   268,   269,   269,
    1316      270,   270,   271,   271,   272,   272,   272,   272,   273,   273,
    1317      273,   273,   273,   274,   274,   274,   274,   274,   275,   275,
    1318      276,   276,   277,   277,   278,   278,   278,   279,   279,   279,
    1319      280,   280,   280,   281,   281,   281,   282,   282,   283,   283,
    1320      283,   284,   284,   285,   285,   285,   285,   285,   286,   286,
    1321      287,   287,   288,   288,   288,   288,   288,   289,   289,   289,
    1322      289,   290,   290,   290,   291,   292,   292,   294,   293,   293,
    1323      295,   295,   295,   295,   296,   296,   297,   297,   297,   298,
    1324      298,   298,   298,   299,   299,   299,   300,   300,   301,   301,
    1325      302,   303,   302,   304,   304,   305,   305,   306,   306,   306,
    1326      307,   307,   308,   308,   309,   309,   310,   310,   311,   311,
    1327      311,   312,   311,   311,   313,   313,   313,   314,   314,   314,
    1328      314,   314,   314,   314,   314,   314,   315,   315,   315,   316,
    1329      317,   317,   318,   318,   319,   319,   320,   321,   321,   322,
    1330      322,   322,   323,   323,   323,   323,   324,   324,   324,   324,
    1331      325,   325,   326,   326,   326,   327,   327,   327,   327,   328,
    1332      328,   329,   329,   329,   330,   330,   330,   331,   331,   331,
    1333      332,   332,   332,   333,   333,   333,   334,   334,   334,   335,
    1334      335,   335,   336,   336,   336,   337,   337,   337,   337,   338,
    1335      338,   339,   339,   339,   340,   340,   340,   340,   341,   341,
    1336      341,   342,   342,   342,   342,   343,   343,   343,   344,   344,
    1337      344,   344,   345,   345,   345,   346,   346,   346,   346,   347,
    1338      347,   348,   348,   348,   349,   349,   350,   350,   351,   351,
    1339      351,   352,   352,   352,   352,   352,   353,   353,   353,   353,
    1340      354,   354,   354,   355,   355,   355,   356,   356,   356,   356,
    1341      357,   357,   357,   358,   358,   358,   358,   358,   359,   359,
    1342      359,   359,   360,   360,   360,   361,   361,   361,   362,   362,
    1343      362,   362,   362,   362,   363,   363,   363,   364,   364,   364,
    1344      364,   364,   365,   365,   365,   365,   366,   366,   367,   367,
    1345      367,   368,   368,   369,   369,   369,   369,   369,   369,   370,
    1346      370,   370,   370,   370,   370,   370,   370,   370,   370,   371,
    1347      371,   371,   371,   372,   372,   372,   373,   373,   374,   374,
    1348      374,   374,   374,   374,   375,   375,   375,   375,   375,   375,
    1349      376,   377,   377,   378,   378,   379,   379
     1315     234,   234,   234,   235,   235,   235,   235,   236,   236,   237,
     1316     237,   238,   238,   239,   239,   239,   239,   239,   240,   239,
     1317     241,   241,   241,   242,   242,   243,   243,   243,   243,   243,
     1318     243,   243,   243,   244,   244,   244,   244,   244,   244,   244,
     1319     244,   244,   244,   244,   244,   244,   244,   244,   245,   245,
     1320     245,   245,   245,   246,   246,   247,   247,   247,   247,   248,
     1321     248,   248,   248,   249,   249,   249,   249,   250,   250,   250,
     1322     251,   251,   251,   251,   252,   252,   252,   253,   253,   253,
     1323     253,   254,   254,   254,   255,   255,   256,   256,   257,   258,
     1324     257,   257,   257,   259,   259,   260,   260,   261,   261,   262,
     1325     262,   262,   262,   263,   263,   263,   263,   264,   264,   265,
     1326     265,   265,   265,   265,   266,   266,   267,   268,   269,   268,
     1327     268,   270,   271,   271,   272,   272,   273,   273,   274,   274,
     1328     274,   274,   274,   275,   275,   275,   275,   276,   276,   277,
     1329     277,   278,   278,   279,   279,   279,   279,   280,   280,   280,
     1330     280,   280,   281,   281,   281,   281,   281,   282,   282,   283,
     1331     283,   284,   284,   285,   285,   285,   286,   286,   286,   287,
     1332     287,   287,   288,   288,   288,   289,   289,   290,   290,   290,
     1333     291,   291,   292,   292,   292,   292,   292,   293,   293,   294,
     1334     294,   295,   295,   295,   295,   295,   296,   296,   296,   296,
     1335     297,   297,   297,   298,   299,   299,   301,   300,   300,   302,
     1336     302,   302,   302,   303,   303,   304,   304,   304,   305,   305,
     1337     305,   305,   306,   306,   306,   307,   307,   308,   308,   309,
     1338     310,   309,   311,   311,   312,   312,   313,   313,   313,   314,
     1339     314,   315,   315,   316,   316,   317,   317,   318,   318,   318,
     1340     319,   318,   318,   320,   320,   320,   321,   321,   321,   321,
     1341     321,   321,   321,   321,   321,   322,   322,   322,   323,   324,
     1342     324,   325,   325,   326,   326,   327,   328,   328,   329,   329,
     1343     329,   330,   330,   330,   330,   331,   331,   331,   331,   332,
     1344     332,   333,   333,   333,   334,   334,   334,   334,   335,   335,
     1345     336,   336,   336,   337,   337,   337,   338,   338,   338,   339,
     1346     339,   339,   340,   340,   340,   341,   341,   341,   342,   342,
     1347     342,   343,   343,   343,   344,   344,   344,   344,   345,   345,
     1348     346,   346,   346,   347,   347,   347,   347,   348,   348,   348,
     1349     349,   349,   349,   349,   350,   350,   350,   351,   351,   351,
     1350     351,   352,   352,   352,   353,   353,   353,   353,   354,   354,
     1351     355,   355,   355,   356,   356,   357,   357,   358,   358,   358,
     1352     359,   359,   359,   359,   359,   360,   360,   360,   360,   361,
     1353     361,   361,   362,   362,   362,   363,   363,   363,   363,   364,
     1354     364,   364,   365,   365,   365,   365,   365,   366,   366,   366,
     1355     366,   367,   367,   367,   368,   368,   368,   369,   369,   369,
     1356     369,   369,   369,   370,   370,   370,   371,   371,   371,   371,
     1357     371,   372,   372,   372,   372,   373,   373,   374,   374,   374,
     1358     375,   375,   376,   376,   376,   376,   376,   376,   377,   377,
     1359     377,   377,   377,   377,   377,   377,   377,   377,   378,   378,
     1360     378,   378,   379,   379,   379,   380,   380,   381,   381,   381,
     1361     381,   381,   381,   382,   382,   382,   382,   382,   382,   383,
     1362     384,   384,   385,   385,   386,   386
    13501363};
    13511364
     
    13821395       5,     7,     7,     5,     9,     2,     2,     5,     3,     5,
    13831396       4,     3,     4,     4,     7,     4,     3,     3,     3,     3,
    1384        6,     1,     1,     1,     1,     1,     1,     1,     1,     0,
    1385        1,     1,     2,     1,     1,     1,     1,     1,     1,     1,
    1386        0,     5,     1,     2,     3,     1,     2,     1,     1,     1,
     1397       6,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1398       1,     1,     1,     1,     1,     1,     1,     0,     1,     1,
     1399       2,     1,     1,     1,     1,     1,     1,     1,     0,     5,
     1400       1,     2,     3,     1,     2,     1,     1,     1,     1,     1,
    13871401       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
    1388        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
    1389        1,     2,     2,     3,     3,     1,     3,     1,     2,     2,
    1390        2,     4,     4,     4,     4,     1,     2,     2,     3,     1,
    1391        2,     2,     1,     2,     2,     3,     1,     2,     2,     1,
    1392        1,     5,     3,     0,     7,     8,     3,     1,     1,     0,
    1393        2,     2,     3,     3,     4,     1,     2,     3,     2,     1,
    1394        4,     0,     1,     2,     2,     1,     0,     1,     2,     6,
    1395        3,     0,     8,     2,     4,     0,     2,     0,     1,     1,
    1396        1,     5,     5,     5,     1,     5,     5,     9,     1,     5,
    1397        0,     1,     1,     5,     1,     1,     5,     5,     1,     3,
    1398        3,     4,     1,     1,     1,     1,     2,     1,     3,     3,
    1399        2,     3,     1,     3,     1,     1,     1,     1,     1,     1,
    1400        1,     1,     1,     1,     1,     2,     1,     1,     0,     2,
    1401        2,     1,     4,     0,     1,     2,     3,     4,     2,     2,
    1402        1,     2,     2,     5,     5,     7,     6,     1,     2,     2,
    1403        3,     1,     2,     2,     4,     2,     4,     0,     4,     2,
    1404        1,     1,     1,     1,     0,     2,     5,     5,    13,     1,
    1405        1,     3,     3,     2,     3,     3,     2,     4,     1,     6,
    1406        9,     0,    11,     1,     3,     3,     3,     1,     1,     5,
    1407        2,     5,     0,     1,     1,     3,     0,     1,     1,     1,
    1408        5,     0,     6,     2,     1,     2,     4,     2,     3,     3,
    1409        3,     4,     5,     5,     5,     6,     1,     1,     1,     3,
    1410        0,     5,     0,     1,     1,     2,     6,     1,     3,     0,
    1411        1,     4,     1,     1,     1,     1,     2,     1,     2,     2,
    1412        1,     3,     2,     3,     4,     2,     4,     4,     3,     8,
    1413        3,     2,     1,     2,     6,     8,     3,     2,     3,     3,
    1414        4,     4,     3,     1,     1,     1,     4,     8,     3,     2,
    1415        3,     3,     4,     4,     3,     2,     1,     2,     2,     1,
    1416        3,     2,     3,     4,     2,     4,     4,     3,     6,     8,
    1417        3,     2,     1,     2,     2,     2,     3,     4,     2,     4,
    1418        4,     3,     6,     8,     3,     2,     1,     2,     2,     1,
    1419        1,     2,     3,     4,     2,     4,     6,     8,     1,     2,
    1420        2,     1,     2,     2,     3,     4,     1,     4,     4,     3,
    1421        5,     8,     3,     2,     3,     1,     5,     5,     6,     6,
    1422        1,     2,     2,     1,     2,     2,     3,     4,     1,     4,
    1423        4,     3,     5,     8,     3,     1,     2,     1,     2,     6,
    1424        5,     6,     7,     7,     1,     2,     2,     1,     2,     2,
    1425        3,     4,     1,     4,     4,     3,     8,     3,     1,     1,
    1426        2,     1,     1,     2,     3,     2,     3,     2,     3,     3,
    1427        2,     4,     3,     2,     3,     2,     4,     3,     2,     6,
    1428        6,     6,     7,     1,     2,     1,     1,     1,     2,     3,
    1429        2,     3,     2,     3,     3,     4,     2,     3,     4,     2,
    1430        5,     6,     6,     0,     1,     0,     2
     1402       1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
     1403       2,     3,     3,     1,     3,     1,     2,     2,     2,     4,
     1404       4,     4,     4,     1,     2,     2,     3,     1,     2,     2,
     1405       1,     2,     2,     3,     1,     2,     2,     1,     2,     2,
     1406       3,     1,     2,     2,     1,     1,     1,     1,     5,     0,
     1407       7,     8,     1,     3,     3,     1,     1,     0,     2,     2,
     1408       3,     3,     4,     1,     2,     3,     2,     1,     4,     0,
     1409       1,     2,     2,     1,     0,     1,     2,     6,     0,     8,
     1410       1,     3,     2,     4,     0,     2,     0,     1,     1,     1,
     1411       5,     5,     5,     1,     5,     5,     9,     1,     5,     0,
     1412       1,     1,     5,     1,     1,     5,     5,     1,     3,     3,
     1413       4,     1,     1,     1,     1,     2,     1,     3,     3,     2,
     1414       3,     1,     3,     1,     1,     1,     1,     1,     1,     1,
     1415       1,     1,     1,     1,     2,     1,     1,     0,     2,     2,
     1416       1,     4,     0,     1,     2,     3,     4,     2,     2,     1,
     1417       2,     2,     5,     5,     7,     6,     1,     2,     2,     3,
     1418       1,     2,     2,     4,     2,     4,     0,     4,     2,     1,
     1419       1,     1,     1,     0,     2,     5,     5,    13,     1,     1,
     1420       3,     3,     2,     3,     3,     2,     4,     1,     6,     9,
     1421       0,    11,     1,     3,     3,     3,     1,     1,     5,     2,
     1422       5,     0,     1,     1,     3,     0,     1,     1,     1,     5,
     1423       0,     6,     2,     1,     2,     4,     2,     3,     3,     3,
     1424       4,     5,     5,     5,     6,     1,     1,     1,     3,     0,
     1425       5,     0,     1,     1,     2,     6,     1,     3,     0,     1,
     1426       4,     1,     1,     1,     1,     2,     1,     2,     2,     1,
     1427       3,     2,     3,     4,     2,     4,     4,     3,     8,     3,
     1428       2,     1,     2,     6,     8,     3,     2,     3,     3,     4,
     1429       4,     3,     1,     1,     1,     4,     8,     3,     2,     3,
     1430       3,     4,     4,     3,     2,     1,     2,     2,     1,     3,
     1431       2,     3,     4,     2,     4,     4,     3,     6,     8,     3,
     1432       2,     1,     2,     2,     2,     3,     4,     2,     4,     4,
     1433       3,     6,     8,     3,     2,     1,     2,     2,     1,     1,
     1434       2,     3,     4,     2,     4,     6,     8,     1,     2,     2,
     1435       1,     2,     2,     3,     4,     1,     4,     4,     3,     5,
     1436       8,     3,     2,     3,     1,     5,     5,     6,     6,     1,
     1437       2,     2,     1,     2,     2,     3,     4,     1,     4,     4,
     1438       3,     5,     8,     3,     1,     2,     1,     2,     6,     5,
     1439       6,     7,     7,     1,     2,     2,     1,     2,     2,     3,
     1440       4,     1,     4,     4,     3,     8,     3,     1,     1,     2,
     1441       1,     1,     2,     3,     2,     3,     2,     3,     3,     2,
     1442       4,     3,     2,     3,     2,     4,     3,     2,     6,     6,
     1443       6,     7,     1,     2,     1,     1,     1,     2,     3,     2,
     1444       3,     2,     3,     3,     4,     2,     3,     4,     2,     5,
     1445       6,     6,     0,     1,     0,     2
    14311446};
    14321447
     
    14361451static const yytype_uint16 yydefact[] =
    14371452{
    1438      299,   299,   319,   317,   320,   318,   321,   322,   305,   307,
    1439      306,     0,   308,   333,   325,   330,   328,   329,   327,   326,
    1440      331,   332,   338,   339,   337,   334,   335,   336,   552,   377,
    1441      378,     0,     0,     0,   299,     0,   309,   323,   324,     9,
    1442      366,     0,    10,    16,    17,     0,     2,    72,    73,   570,
    1443       11,   299,   528,   253,     3,   458,     3,   266,     0,     3,
    1444        3,     3,   254,     0,     0,     0,   300,   301,   303,   299,
    1445      312,   315,   347,   291,   340,   345,   292,   355,   293,   362,
    1446      359,   369,   552,   370,   294,   477,   481,     3,     3,     0,
    1447        2,   524,   529,   534,   304,     0,     0,   552,   582,   552,
    1448        2,   593,   594,   595,   299,     0,   736,   737,     0,    14,
    1449        0,    15,   299,   275,   276,     0,   300,   295,   296,   297,
    1450      298,   531,   310,     0,   553,   554,    14,   451,   452,    13,
    1451      447,   450,     0,   508,   503,   494,   451,   452,     0,     0,
    1452      533,     0,   299,     0,     0,     0,     0,     0,     0,     0,
    1453        0,   299,   299,     0,   738,   300,   587,   599,   742,   735,
    1454      733,   740,     0,     0,     0,   260,     2,     0,   537,   445,
    1455      446,   444,     0,     0,     0,     0,   639,   640,     0,     0,
    1456        3,   550,   546,   552,   567,   552,   552,   548,     2,   547,
    1457      552,   606,   552,   552,   609,     0,     0,     0,   299,   299,
    1458      317,   367,     2,   299,   267,   302,   313,   348,   360,   482,
    1459        0,     2,     0,   458,   268,   300,   341,   356,   363,   478,
    1460        0,     2,     0,   316,   342,   349,   350,     0,   357,   361,
    1461      364,   368,     0,   479,   483,     0,     0,     0,     1,   299,
    1462        2,   535,   581,   583,   299,     2,   746,   300,   749,   550,
    1463      550,     0,   300,     0,     0,   278,   552,   548,     2,   299,
    1464        0,     0,   299,     0,   400,   555,     2,   506,     2,   559,
    1465       19,     0,    18,     0,     0,     0,     0,    21,    69,     4,
    1466        8,     5,     6,     7,     0,     0,   299,     2,    74,    75,
    1467       76,    77,    57,    22,    58,    26,    56,    78,   299,     0,
    1468       80,    84,    87,    90,    95,    98,   100,   102,   104,   106,
    1469      108,   112,   500,    23,   454,   456,   499,     0,   453,   457,
    1470        0,   571,   586,   589,   592,   598,   601,   604,     2,   744,
    1471      299,   747,     2,    72,   299,     3,   432,     0,   755,   300,
    1472      299,   312,   340,   292,   355,   362,     3,     3,   414,   418,
    1473      428,   433,   477,   299,   434,   711,   712,   299,   435,   437,
    1474        2,   588,   600,   734,     2,     2,   255,     2,   463,     0,
    1475      461,   460,   459,   146,     2,     2,   257,     2,     2,   256,
     1453     307,   307,   327,   325,   328,   326,   330,   331,   313,   315,
     1454     314,     0,   316,   341,   333,   338,   336,   337,   335,   334,
     1455     339,   340,   346,   347,   345,   342,   343,   344,   571,   395,
     1456     396,     0,     0,     0,   307,     0,   317,   332,   329,     9,
     1457     381,     0,    10,    16,    17,     0,     2,    72,    73,   589,
     1458      11,   307,   547,   253,     3,   477,     3,   266,     0,     3,
     1459       3,     3,   254,     0,     0,     0,   308,   309,   311,   307,
     1460     320,   323,   355,   291,   348,   353,   292,   363,   293,   377,
     1461     367,   384,   392,   571,   385,   420,   294,   496,   500,     3,
     1462       3,     0,     2,   543,   548,   553,   312,     0,     0,   571,
     1463     601,   571,     2,   612,   613,   614,   307,     0,   755,   756,
     1464       0,    14,     0,    15,   307,   275,   276,     0,   308,   299,
     1465     300,   301,   302,   550,   318,     0,   572,   573,    14,   470,
     1466     471,    13,   466,   469,     0,   527,   522,   513,   470,   471,
     1467       0,     0,   552,     0,   307,     0,     0,     0,     0,     0,
     1468       0,     0,     0,   307,   307,     0,   757,   308,   606,   618,
     1469     761,   754,   752,   759,     0,     0,     0,   260,     2,     0,
     1470     556,   464,   465,   463,     0,     0,     0,     0,   658,   659,
     1471       0,     0,     3,   569,   565,   571,   586,   571,   571,   567,
     1472       2,   566,   571,   625,   571,   571,   628,     0,     0,     0,
     1473     307,   307,   325,   382,     2,   307,   267,   310,   321,   356,
     1474     368,   501,     0,     2,     0,   477,   268,   308,   349,   364,
     1475     378,   497,     0,     2,     0,   324,   350,   357,   358,     0,
     1476     365,   369,   379,   383,     0,   498,   502,     0,     0,     0,
     1477       1,   307,     2,   554,   600,   602,   307,     2,   765,   308,
     1478     768,   569,   569,     0,   308,     0,     0,   278,   571,   567,
     1479       2,   307,     0,     0,   307,     0,   421,   574,     2,   525,
     1480       2,   578,    19,     0,    18,     0,     0,     0,     0,    21,
     1481      69,     4,     8,     5,     6,     7,     0,     0,   307,     2,
     1482      74,    75,    76,    77,    57,    22,    58,    26,    56,    78,
     1483     307,     0,    80,    84,    87,    90,    95,    98,   100,   102,
     1484     104,   106,   108,   112,   519,    23,   473,   475,   518,     0,
     1485     472,   476,     0,   590,   605,   608,   611,   617,   620,   623,
     1486       2,   763,   307,   766,   571,     2,    72,   307,     3,   451,
     1487       0,   774,   308,   307,   320,   295,   348,   296,   370,   297,
     1488     377,   374,   386,   571,   387,     3,     3,   433,   437,   447,
     1489     452,   298,   496,   307,   453,   730,   731,   307,   454,   456,
     1490       2,   607,   619,   753,     2,     2,   255,     2,   482,     0,
     1491     480,   479,   478,   146,     2,     2,   257,     2,     2,   256,
    14761492       2,   286,     2,   287,     0,     0,     0,     0,     0,     0,
    1477        0,     0,     0,   572,   611,   552,     0,     0,   458,     2,
    1478      566,   575,   665,   568,   569,   538,   299,     2,   605,   614,
    1479      607,   608,     0,   281,   299,   299,   346,   300,     0,   300,
    1480      299,   739,   743,   741,   539,   299,   550,   261,   269,   314,
    1481        0,     2,   540,   299,   504,   343,   344,   288,   358,   365,
    1482      452,   299,   379,   372,   376,   480,   505,   258,   259,   525,
    1483      299,   442,     0,   299,   243,     0,     2,   245,     0,   300,
    1484        0,   263,     2,   264,   283,     0,     0,     2,   299,   550,
    1485      299,   490,   492,   491,   493,     0,     0,   755,     0,   753,
    1486      405,     0,   299,     0,   299,   495,   299,   565,   562,   563,
    1487      564,     0,   557,   560,     0,    20,   299,    64,   299,    78,
    1488       59,   299,    66,   299,   299,    62,    63,     2,   132,     0,
    1489        0,     0,   733,   299,    31,     0,    34,    35,    40,     2,
    1490        0,    40,   118,   119,   120,   121,   122,   123,   124,   125,
    1491      126,   127,   117,   116,     0,    60,    61,     0,     0,     0,
    1492        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    1493        0,     0,     0,     0,     0,     0,     2,   651,   455,   648,
    1494      552,   552,   656,   484,   299,     2,   590,   591,     2,   602,
    1495      603,     0,   745,   748,   299,   299,     0,   713,   300,   717,
    1496      708,   709,   715,     0,     2,     2,     0,   673,   552,   755,
    1497      622,   552,   552,   755,   552,   636,   552,   552,   687,   755,
    1498      670,   552,   552,   678,   685,   440,   299,   436,   300,     0,
    1499        0,   299,   723,   300,   728,   755,   720,   299,   725,   755,
    1500      299,   299,     0,     0,    21,     2,     0,    22,     0,   464,
    1501      753,     0,     0,   470,   247,     0,   299,     0,     0,     0,
    1502      552,   578,   580,   610,   552,   617,   620,   573,   612,     0,
    1503      285,     0,   289,   663,     0,   299,   282,     0,     0,     0,
    1504        0,   280,     2,     0,   265,   541,   299,     0,     0,   299,
    1505        0,   300,     3,   421,     3,   425,   424,   596,     0,   536,
    1506      299,    72,     3,   299,   755,   300,     3,   434,   435,     2,
    1507        0,     0,     0,   489,   311,   299,   485,   487,   754,     0,
    1508        0,   403,     0,     3,     2,     2,     0,   507,     3,     0,
    1509      559,    40,   530,     0,     2,     0,     0,     0,    41,     0,
    1510        0,   299,    24,     0,    25,     0,   114,     3,     2,    32,
    1511        0,    38,     0,     2,    29,     0,   113,    81,    82,    83,
    1512       85,    86,    88,    89,    93,    94,    91,    92,    96,    97,
    1513       99,   101,   103,   105,   107,     0,     0,   299,     0,     0,
    1514        0,   652,   653,   649,   650,   502,   501,   299,   299,   719,
    1515      299,   724,   300,   299,   667,   710,   666,     2,   299,     0,
    1516        0,     0,     0,     0,     0,     0,     0,   688,     0,   756,
    1517      674,   625,   641,   675,     2,   621,   628,   438,   623,   624,
    1518      439,     2,   635,   644,   637,   638,   441,   671,   672,   686,
    1519      714,   718,   716,   755,   273,     2,   750,     2,   429,   722,
    1520      727,   430,     3,   408,     3,     3,     3,   458,     0,     0,
    1521        2,   472,   469,   754,     0,   465,     2,   468,   471,     0,
    1522      299,   248,   270,     3,   277,   279,     0,     2,   574,   576,
    1523      577,     2,   613,   615,   616,   550,     0,   664,   542,     3,
    1524      352,   351,   354,   353,   299,   543,     0,   544,     0,   299,
    1525      371,   391,   380,     0,   385,   379,     0,     0,   443,   246,
    1526        0,     0,     3,     2,   673,   436,     0,   532,     0,   755,
    1527      494,   405,   399,   111,   406,   753,     0,   299,   299,   299,
    1528        0,   556,   558,     0,    65,   299,     0,    67,    70,    71,
    1529        0,   133,   463,    79,   115,   130,     3,   114,     0,    28,
    1530       40,     3,     0,    37,   110,     0,     3,   552,   659,   662,
    1531      654,     3,     3,   721,   726,     2,    72,   299,     3,     3,
    1532      300,     0,     3,   552,   631,   634,   552,   552,   681,   684,
    1533      299,     3,   626,   642,   676,   299,   299,   431,   299,   299,
    1534        0,     0,     0,     0,   262,   111,     0,     3,     3,     0,
    1535      466,     0,   462,     0,     0,   251,   299,     0,     0,   134,
    1536        0,     0,     0,     0,     0,   134,     0,     0,   114,   114,
    1537      226,    21,   366,   446,    69,     0,    22,   135,     0,     3,
    1538      136,   137,     2,   148,   138,   139,   140,   141,   142,   143,
    1539      150,     0,   152,     0,     0,     0,   299,   299,   458,   552,
    1540        0,   545,   379,   391,     0,     0,     0,   697,     0,   389,
    1541      392,   396,   552,   396,   702,   395,   694,   552,   552,   388,
    1542      381,   386,   299,   584,     2,   669,   668,     0,   674,     2,
    1543      486,   488,   404,     0,   509,     3,   517,   518,     0,     2,
    1544      513,     3,     3,     0,     0,   561,     0,   753,   114,     0,
    1545        3,    54,     0,    54,    54,     3,    42,    44,    39,     0,
    1546        3,   109,     0,     2,   655,   657,   658,     0,     0,   299,
    1547        0,     0,     0,     3,   552,     0,     2,   627,   629,   630,
    1548        2,   643,   645,     2,   677,   679,   680,     0,     0,    72,
    1549        0,     3,     3,     3,     3,   416,   415,   419,   752,     2,
    1550        2,   751,     0,     0,     0,     0,     3,   467,     3,     0,
    1551      249,   151,   153,     0,     0,     0,     0,     2,   197,     0,
    1552      195,     0,     0,     0,     0,     0,     0,     0,     0,   227,
    1553        0,     0,   157,   154,   299,     0,   552,     0,   272,   284,
    1554        3,     3,   290,   551,   618,   299,     0,   382,     0,     0,
    1555        0,     0,   398,   698,   699,   552,   383,   393,   397,   394,
    1556      695,   696,   387,   374,   299,   271,   299,   402,     0,   520,
    1557      497,   299,     0,     0,   496,   511,    68,     0,   131,   128,
    1558        0,    51,     2,    45,    52,    53,     0,     0,     0,     0,
    1559       27,     0,   660,   299,   585,   597,   729,   730,   731,     0,
    1560      682,   299,   299,   299,     3,     3,     0,   690,     0,     0,
    1561        0,     0,   299,   299,     3,   549,   473,   474,     0,   252,
    1562        0,     0,     0,     0,   299,   198,   196,     0,   193,   199,
    1563        0,     0,     0,     0,   203,   206,   204,   200,     0,   201,
    1564        0,     0,    40,   149,   147,   134,   250,     0,     0,   375,
    1565      384,   552,   705,   707,   700,   391,   423,   427,   426,     0,
    1566      514,     2,   515,     2,   516,   510,   299,    36,   129,    55,
    1567        0,    43,    33,     2,    49,     2,    47,    30,     3,   732,
    1568        3,     3,     3,     0,     0,   689,   691,   632,   646,   274,
    1569        2,   413,     3,   412,     0,   476,   134,     0,     0,   134,
    1570        3,     0,   134,     3,   300,   299,   194,     0,     2,     2,
    1571      215,   205,     0,     0,     0,     0,     0,     0,   145,   579,
    1572      619,     2,   701,   703,   704,   390,     2,     0,     0,     2,
    1573        3,     0,     0,     0,     0,     0,     0,   692,   693,   299,
    1574        0,   475,   158,     0,     0,     2,   171,   134,   160,     0,
    1575      188,     0,   134,     0,   300,     2,   162,     0,     2,     0,
    1576        2,     2,     2,   202,     0,     0,   228,    37,   299,   299,
    1577      519,   521,   512,     0,     3,     3,   661,   633,   647,   683,
    1578      417,   134,   164,   167,     0,   166,   170,     3,   173,   172,
    1579        0,   134,   190,   134,     3,     0,   299,     0,   299,     0,
    1580        2,     0,     2,     0,   221,     0,     0,     0,   229,   230,
    1581      144,     3,     2,    46,     0,     0,   159,     0,     0,   169,
    1582      239,   174,     2,   241,   189,     0,   192,   178,   207,     3,
    1583      216,   220,   209,     3,     0,   299,     0,   299,   228,     0,
    1584        0,     0,   228,     0,     0,     0,    50,    48,   165,   168,
    1585      134,     0,   175,   299,   134,   134,     0,   179,     0,     0,
    1586      697,   217,   218,   219,     0,   208,     3,   210,     3,     0,
    1587        0,     0,   222,     0,   231,   706,   299,   155,   176,   161,
    1588      134,   242,   191,   186,   184,   180,   163,   134,     0,   698,
    1589        0,     0,     0,   234,     0,   232,     0,   234,     0,   156,
    1590      177,   187,   181,   185,   184,   182,     3,     3,     0,     0,
    1591      235,     0,     0,   223,     0,   498,   183,   211,   213,     3,
    1592        3,     0,     0,     0,     0,   212,   214,   236,   237,     0,
    1593      233,   224,     0,     0,   225,   238
     1493       0,     0,     0,   591,   630,   571,     0,     0,   477,     2,
     1494     585,   594,   684,   587,   588,   557,   307,     2,   624,   633,
     1495     626,   627,     0,   281,   307,   307,   354,   308,     0,   308,
     1496     307,   758,   762,   760,   558,   307,   569,   261,   269,   322,
     1497       0,     2,   559,   307,   523,   351,   352,   288,   366,   380,
     1498     471,   307,   397,   393,   394,   499,   524,   258,   259,   544,
     1499     307,   461,     0,   307,   243,     0,     2,   245,     0,   308,
     1500     307,     0,   263,     2,   264,   283,     0,     0,     2,   307,
     1501     569,   307,   509,   511,   510,   512,     0,     0,   774,     0,
     1502     772,   424,     0,   307,     0,   307,   514,   307,   584,   581,
     1503     582,   583,     0,   576,   579,     0,    20,   307,    64,   307,
     1504      78,    59,   307,    66,   307,   307,    62,    63,     2,   132,
     1505       0,     0,     0,   752,   307,    31,     0,    34,    35,    40,
     1506       2,     0,    40,   118,   119,   120,   121,   122,   123,   124,
     1507     125,   126,   127,   117,   116,     0,    60,    61,     0,     0,
     1508       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     1509       0,     0,     0,     0,     0,     0,     0,     2,   670,   474,
     1510     667,   571,   571,   675,   503,   307,     2,   609,   610,     2,
     1511     621,   622,     0,   764,   767,     0,   307,   307,     0,   732,
     1512     308,   303,   304,   305,   306,   736,   727,   728,   734,     0,
     1513       2,     2,     0,   692,   571,   774,   641,   571,   571,   774,
     1514     571,   655,   571,   571,   706,   774,   689,   571,   571,   697,
     1515     704,   459,   307,   375,   455,   308,   371,   372,   376,     0,
     1516       0,     0,   307,   742,   308,   747,   774,   739,   307,   744,
     1517     774,   307,   307,     0,     0,    21,     2,     0,    22,     0,
     1518     483,   772,     0,     0,   489,   247,     0,   307,     0,     0,
     1519       0,   571,   597,   599,   629,   571,   636,   639,   592,   631,
     1520       0,   285,     0,   289,   682,     0,   307,   282,     0,     0,
     1521       0,     0,   280,     2,     0,   265,   560,   307,     0,     0,
     1522     307,     0,   308,     3,   440,     3,   444,   443,   615,     0,
     1523     555,   307,   308,    72,     3,   307,   774,   308,     3,   453,
     1524     454,     2,     0,     0,     0,   508,   319,   307,   504,   506,
     1525     773,     0,     0,   422,     0,     3,     2,     2,     0,   526,
     1526       3,     0,   578,    40,   549,     0,     2,     0,     0,     0,
     1527      41,     0,     0,   307,    24,     0,    25,     0,   114,     3,
     1528       2,    32,     0,    38,     0,     2,    29,     0,   113,    81,
     1529      82,    83,    85,    86,    88,    89,    93,    94,    91,    92,
     1530      96,    97,    99,   101,   103,   105,   107,     0,     0,   307,
     1531       0,     0,     0,   671,   672,   668,   669,   521,   520,   307,
     1532     307,   421,   738,   307,   743,   308,   307,   686,   729,   685,
     1533       2,   307,     0,     0,     0,     0,     0,     0,     0,     0,
     1534     707,     0,   775,   693,   644,   660,   694,     2,   640,   647,
     1535     457,   642,   643,   458,     2,   654,   663,   656,   657,   460,
     1536     690,   691,   705,   733,   737,   735,   774,   373,   393,   273,
     1537       2,   769,     2,   448,   741,   746,   449,     3,   427,     3,
     1538       3,     3,   477,     0,     0,     2,   491,   488,   773,     0,
     1539     484,     2,   487,   490,     0,   307,   248,   270,     3,   277,
     1540     279,     0,     2,   593,   595,   596,     2,   632,   634,   635,
     1541     569,     0,   683,   561,     3,   360,   359,   362,   361,   307,
     1542     562,     0,   563,     0,   307,   388,   409,   398,     0,   403,
     1543     397,     0,     0,   462,   246,     0,     0,     3,     2,   692,
     1544     455,     0,   551,     0,   774,   513,   424,   417,   111,   425,
     1545     772,     0,   307,   307,   307,     0,   575,   577,     0,    65,
     1546     307,     0,    67,    70,    71,     0,   133,   482,    79,   115,
     1547     130,     3,   114,     0,    28,    40,     3,     0,    37,   110,
     1548       0,     3,   571,   678,   681,   673,     3,     3,   740,   745,
     1549       2,    72,   307,     3,     3,   308,     0,     3,   571,   650,
     1550     653,   571,   571,   700,   703,   307,     3,   645,   661,   695,
     1551     307,   307,   450,   307,   307,     0,     0,     0,     0,   262,
     1552     111,     0,     3,     3,     0,   485,     0,   481,     0,     0,
     1553     251,   307,     0,     0,   134,     0,     0,     0,     0,     0,
     1554     134,     0,     0,   114,   114,   226,    21,   381,   465,    69,
     1555       0,    22,   135,     0,     3,   136,   137,     2,   148,   138,
     1556     139,   140,   141,   142,   143,   150,     0,   152,     0,     0,
     1557       0,   307,   307,   477,   571,     0,   564,   397,   409,     0,
     1558       0,     0,   716,     0,   407,   410,   414,   571,   414,   721,
     1559     413,   713,   571,   571,   406,   399,   404,   307,   603,     2,
     1560     688,   687,     0,   693,     2,   505,   507,   423,     0,   528,
     1561       3,   536,   537,     0,     2,   532,     3,     3,     0,     0,
     1562     580,     0,   772,   114,     0,     3,    54,     0,    54,    54,
     1563       3,    42,    44,    39,     0,     3,   109,     0,     2,   674,
     1564     676,   677,     0,     0,   307,     0,     0,     0,     3,   571,
     1565       0,     2,   646,   648,   649,     2,   662,   664,     2,   696,
     1566     698,   699,     0,     0,    72,     0,     3,     3,     3,     3,
     1567     435,   434,   438,   771,     2,     2,   770,     0,     0,     0,
     1568       0,     3,   486,     3,     0,   249,   151,   153,     0,     0,
     1569       0,     0,     2,   197,     0,   195,     0,     0,     0,     0,
     1570       0,     0,     0,     0,   227,     0,     0,   157,   154,   307,
     1571       0,   571,     0,   272,   284,     3,     3,   290,   570,   637,
     1572     307,     0,   400,     0,     0,     0,     0,   416,   717,   718,
     1573     571,   401,   411,   415,   412,   714,   715,   405,   390,   307,
     1574     271,   307,   419,     0,   539,   516,   307,     0,     0,   515,
     1575     530,    68,     0,   131,   128,     0,    51,     2,    45,    52,
     1576      53,     0,     0,     0,     0,    27,     0,   679,   307,   604,
     1577     616,   748,   749,   750,     0,   701,   307,   307,   307,     3,
     1578       3,     0,   709,     0,     0,     0,     0,   307,   307,     3,
     1579     568,   492,   493,     0,   252,     0,     0,     0,     0,   307,
     1580     198,   196,     0,   193,   199,     0,     0,     0,     0,   203,
     1581     206,   204,   200,     0,   201,     0,     0,    40,   149,   147,
     1582     134,   250,     0,     0,   391,   402,   571,   724,   726,   719,
     1583     409,   442,   446,   445,     0,   533,     2,   534,     2,   535,
     1584     529,   307,    36,   129,    55,     0,    43,    33,     2,    49,
     1585       2,    47,    30,     3,   751,     3,     3,     3,     0,     0,
     1586     708,   710,   651,   665,   274,     2,   432,     3,   431,     0,
     1587     495,   134,     0,     0,   134,     3,     0,   134,     3,   308,
     1588     307,   194,     0,     2,     2,   215,   205,     0,     0,     0,
     1589       0,     0,     0,   145,   598,   638,     2,   720,   722,   723,
     1590     408,     2,     0,     0,     2,     3,     0,     0,     0,     0,
     1591       0,     0,   711,   712,   307,     0,   494,   158,     0,     0,
     1592       2,   171,   134,   160,     0,   188,     0,   134,     0,   308,
     1593       2,   162,     0,     2,     0,     2,     2,     2,   202,     0,
     1594       0,   228,    37,   307,   307,   538,   540,   531,     0,     3,
     1595       3,   680,   652,   666,   702,   436,   134,   164,   167,     0,
     1596     166,   170,     3,   173,   172,     0,   134,   190,   134,     3,
     1597       0,   307,     0,   307,     0,     2,     0,     2,     0,   221,
     1598       0,     0,     0,   229,   230,   144,     3,     2,    46,     0,
     1599       0,   159,     0,     0,   169,   239,   174,     2,   241,   189,
     1600       0,   192,   178,   207,     3,   216,   308,   220,   209,     3,
     1601       0,   307,     0,   307,   228,     0,     0,     0,   228,     0,
     1602       0,     0,    50,    48,   165,   168,   134,     0,   175,   307,
     1603     134,   134,     0,   179,     0,     0,   716,   217,   218,   219,
     1604       0,   208,     3,   210,     3,     0,     0,     0,   222,     0,
     1605     231,   725,   307,   155,   176,   161,   134,   242,   191,   186,
     1606     184,   180,   163,   134,     0,   717,     0,     0,     0,   234,
     1607       0,   232,     0,   234,     0,   156,   177,   187,   181,   185,
     1608     184,   182,     3,     3,     0,     0,   235,     0,     0,   223,
     1609       0,   517,   183,   211,   213,     3,     3,     0,     0,     0,
     1610       0,   212,   214,   236,   237,     0,   233,   224,     0,     0,
     1611     225,   238
    15941612};
    15951613
     
    15971615static const yytype_int16 yydefgoto[] =
    15981616{
    1599       -1,   778,   454,   292,    49,   130,   131,   293,   294,   272,
    1600      295,   296,   730,   731,  1075,  1076,  1077,  1201,   297,   369,
    1601      299,   300,   301,   302,   303,   304,   305,   306,   307,   308,
    1602      309,   310,   311,   966,   508,   915,   534,   313,   916,   997,
    1603      998,  1497,  1000,  1001,  1002,  1003,  1498,  1004,  1005,  1403,
    1604     1404,  1366,  1367,  1368,  1471,  1472,  1476,  1477,  1522,  1523,
    1605     1006,  1321,  1007,  1008,  1254,  1255,  1256,  1449,  1009,  1150,
    1606     1427,  1428,  1429,  1531,  1549,  1441,  1442,   455,   456,   840,
    1607      841,   974,    52,    53,    54,    55,    56,   336,   153,    59,
    1608       60,    61,    62,   180,   338,    64,    65,   252,    67,    68,
    1609      262,   340,   341,    71,    72,    73,   117,    75,   198,   343,
    1610      118,    78,   119,    80,    81,   670,    82,   669,   872,   873,
    1611     1028,  1029,  1177,  1030,    83,   481,   479,   701,   822,   823,
    1612      346,   347,   672,   673,   674,   348,   349,   675,   351,   452,
    1613     1011,   132,   133,   315,   316,   165,   629,   630,   631,   632,
    1614      633,    84,   120,    86,   476,   477,   890,   478,   267,   485,
    1615      317,    87,   134,   135,    88,  1286,  1059,  1060,  1061,  1062,
    1616       89,    90,   690,    91,   261,    92,    93,   181,   968,   664,
    1617      400,   124,    94,   491,   492,   493,   182,   256,   184,   185,
    1618      186,   257,    97,    98,    99,   100,   101,   102,   103,   189,
    1619      190,   191,   192,   193,   791,   590,   591,   592,   593,   194,
    1620      595,   596,   597,   558,   559,   560,   561,  1034,   104,   599,
    1621      600,   601,   602,   603,   604,  1035,  1036,  1037,  1038,   579,
    1622      354,   355,   356,   357,   318,   159,   106,   107,   108,   359,
    1623      699,   605
     1617      -1,   801,   464,   294,    49,   132,   133,   295,   296,   274,
     1618     297,   298,   752,   753,  1100,  1101,  1102,  1226,   299,   379,
     1619     301,   302,   303,   304,   305,   306,   307,   308,   309,   310,
     1620     311,   312,   313,   991,   519,   940,   545,   315,   941,  1022,
     1621    1023,  1523,  1025,  1026,  1027,  1028,  1524,  1029,  1030,  1428,
     1622    1429,  1391,  1392,  1393,  1497,  1498,  1502,  1503,  1548,  1549,
     1623    1031,  1346,  1032,  1033,  1279,  1280,  1281,  1474,  1034,  1175,
     1624    1452,  1453,  1454,  1557,  1575,  1466,  1467,   465,   466,   865,
     1625     866,   999,    52,    53,    54,    55,    56,   339,   155,    59,
     1626      60,    61,    62,   182,   468,   341,    64,  1475,    65,   254,
     1627      67,    68,   264,   343,   344,    71,    72,   345,   119,    75,
     1628     200,    76,   120,   347,   348,   349,   121,    80,   351,    81,
     1629     691,    82,    83,   690,   897,   898,  1053,  1054,  1202,  1055,
     1630      84,   492,    85,   490,   723,   847,   848,   355,   356,   693,
     1631     694,   695,   357,   358,   696,   360,   462,  1036,   134,   135,
     1632     317,   318,   167,   650,   651,   652,   653,   654,   361,   122,
     1633      88,   487,   488,   915,   489,   269,   496,   319,    89,   136,
     1634     137,    90,  1311,  1084,  1085,  1086,  1087,    91,    92,   712,
     1635      93,   263,    94,    95,   183,   993,   685,   410,   126,    96,
     1636     502,   503,   504,   184,   258,   186,   187,   188,   259,    99,
     1637     100,   101,   102,   103,   104,   105,   191,   192,   193,   194,
     1638     195,   814,   606,   607,   608,   609,   196,   611,   612,   613,
     1639     569,   570,   571,   572,  1059,   106,   615,   616,   617,   618,
     1640     619,   620,  1060,  1061,  1062,  1063,   595,   364,   365,   366,
     1641     367,   320,   161,   108,   109,   110,   369,   721,   621
    16241642};
    16251643
    16261644/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    16271645   STATE-NUM.  */
    1628 #define YYPACT_NINF -1330
     1646#define YYPACT_NINF -1346
    16291647static const yytype_int16 yypact[] =
    16301648{
    1631     6225,  5848, -1330,    41, -1330, -1330, -1330, -1330, -1330, -1330,
    1632    -1330,    44, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330,
    1633    -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330,   160, -1330,
    1634    -1330,  1888,  1143,   152,  7885,   161, -1330, -1330, -1330, -1330,
    1635    -1330,   267, -1330, -1330, -1330,   930,   170, -1330, -1330, -1330,
    1636    -1330,  3147, -1330, -1330, -1330,    75,   301, -1330,  1958, -1330,
    1637    -1330, -1330, -1330,  1627,   423,    40,  8006, -1330, -1330,  3147,
    1638      760, -1330, -1330,   725,   435,  4274,  1756,   809,   725,   987,
    1639    -1330, -1330,   160, -1330,   725,  1086, -1330,   265, -1330,   447,
    1640      450, -1330, -1330, -1330, -1330,   351,   301,   160, -1330,   160,
    1641    -1330, -1330, -1330, -1330,  8356,  1958, -1330, -1330,  1958, -1330,
    1642      337, -1330,  8476, -1330, -1330,  1743,  9451, -1330,  1134,  1134,
    1643     1134, -1330, -1330,   862,   160, -1330,   432,   459,   482, -1330,
    1644    -1330, -1330,   487, -1330, -1330, -1330, -1330, -1330,   511,   519,
    1645    -1330,   413,  9017,  2489,   116,   434,   446,   525,   537,   556,
    1646      561,  9526,  7391,   567, -1330,  3761, -1330, -1330, -1330, -1330,
    1647      570, -1330,   105,  5159,  5159, -1330,   586,   266, -1330, -1330,
    1648    -1330, -1330,   601,   369,   380,   402, -1330, -1330,  1627,  1992,
    1649      603,   654, -1330,    56, -1330,   160,   160,   301, -1330, -1330,
    1650       68, -1330,   160,   160, -1330,  2640,   630,   635,  1134,  6918,
    1651    -1330, -1330, -1330,  3147, -1330, -1330,   725, -1330, -1330, -1330,
    1652      301, -1330,  1958,    75, -1330,  8202, -1330,  1134,  1134,  1134,
    1653      301, -1330,  1888, -1330,  3470, -1330, -1330,   610,  1134, -1330,
    1654     1134, -1330,  1182,  1134, -1330,  1888,   619,   624, -1330,  7885,
    1655      540, -1330, -1330, -1330,  9378, -1330, -1330,  3910, -1330,   654,
    1656       53, 10308,  9451,  1743,  2640, -1330,    69, -1330, -1330,  8476,
    1657     1958,   656, 10981,  1143,   666, -1330, -1330,   383, -1330,   453,
    1658    -1330,   692,   757, 10367,   729, 10308, 10426, -1330,   743, -1330,
    1659    -1330, -1330, -1330, -1330, 10485, 10485,  8781,   170, -1330, -1330,
    1660    -1330, -1330, -1330, -1330, -1330, -1330,  1854,  1766,  9017, 10308,
    1661    -1330,   571,   562,   733,   403,   661,   742,   720,   772,   811,
    1662       80, -1330, -1330, -1330,   587, -1330, -1330,   242, -1330, -1330,
    1663     2489, -1330, -1330,    52,   795, -1330,   295,   795, -1330, -1330,
    1664     8356, -1330,   800,   803,  9135, -1330, -1330,  1159,  2129,  8562,
    1665     6918,   725, -1330,   725,  1134,  1134, -1330, -1330, -1330, -1330,
    1666    -1330, -1330,  1134,  8356,  1958, -1330, -1330,  9526,  1829, -1330,
    1667    -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330,  5097, 10308,
    1668    -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330,
    1669    -1330, -1330, -1330, -1330,   701,   806,   813,   817,   776,   819,
    1670      827,   839,  1992, -1330, -1330,   160,   787,   812,    75,   849,
    1671    -1330, -1330,   851, -1330, -1330, -1330,  9378, -1330, -1330, -1330,
    1672    -1330, -1330,  2640, -1330,  9017,  9017, -1330,  1134,  1743,  7053,
    1673     8637, -1330, -1330, -1330, -1330,  9378,    53, -1330, -1330,   725,
    1674      301, -1330, -1330,  9378, -1330,  4136, -1330, -1330,  1134,  1134,
    1675      267,  9017, -1330,   856, -1330,  1134, -1330, -1330, -1330, -1330,
    1676     9719, -1330,   334, 10721, -1330,   301,   858, -1330,  1743, 10761,
    1677    10544, -1330, -1330, -1330, -1330,   873,  2640, -1330,  8637,   654,
    1678     7764, -1330, -1330, -1330, -1330,  1408,   393,   834,  1143,   864,
    1679      855,   874, 10981,  1547,  8476, -1330, 10981, -1330, -1330, -1330,
    1680    -1330,   596, -1330,   881,   859, -1330,  8781, -1330,  9566, -1330,
    1681    -1330,  8781, -1330,  8899,  8781, -1330, -1330,   170, -1330,   598,
    1682      889,   892, -1330,  7143, -1330,    85, -1330, -1330, 10308, -1330,
    1683      542, 10308, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330,
    1684    -1330, -1330, -1330, -1330, 10308, -1330, -1330, 10308, 10308, 10308,
    1685    10308, 10308, 10308, 10308, 10308, 10308, 10308, 10308, 10308, 10308,
    1686    10308, 10308, 10308, 10308, 10308,  3975,   587,   600, -1330, -1330,
    1687      160,   160, -1330, -1330,  9017, -1330, -1330,   851, -1330, -1330,
    1688      851, 10603, -1330, -1330,  9526,  7143,   893, -1330,  9451, -1330,
    1689    -1330,   570, -1330,   895,   566,   904, 10308,  2075,    76,   834,
    1690    -1330,   160,   160,   834,   202, -1330,   160,   160,   851,   834,
    1691    -1330,   160,   160, -1330,   795, -1330,  9599,  1958, 10912,   173,
    1692      526,  9599, -1330,  3910, -1330,   834, -1330,  8356, -1330,    55,
    1693     6359,  6359,  1958, 10190,   891, -1330,   960,   896,   899, -1330,
    1694      909,  5159,   408, -1330,  1005,  1958,  6359,   540,  1743,   540,
    1695      209,   795, -1330, -1330,   275,   795, -1330, -1330, -1330,  1743,
    1696    -1330,   413, -1330,   795,   301,  9719, -1330,   621,   926,   622,
    1697      928, -1330,   800,   301, -1330, -1330,  9378,   301,   631,  2873,
    1698      927, 10912, -1330, -1330,   935, -1330, -1330, -1330,   540, -1330,
    1699    10837,   803, -1330,  6359,   543,  8562, -1330, -1330,   570,   925,
    1700      934,  1408,  2646, -1330, -1330, 10981, -1330, -1330,  1143,   936,
    1701    10308, -1330,  1143,   938, -1330, -1330,   946, -1330,   938,   947,
    1702      453, 10308, -1330,   950,   170,   949,   952,   953, -1330,   959,
    1703      963,  7143, -1330, 10308, -1330, 10249, 10308,   966, -1330, -1330,
    1704      633, -1330, 10308, -1330, -1330,   683, -1330, -1330, -1330, -1330,
    1705      571,   571,   562,   562,   733,   733,   733,   733,   403,   403,
    1706      661,   742,   720,   772,   811, 10308,   164,  9719,   965,   976,
    1707      977,   600, -1330, -1330, -1330, -1330, -1330,  9719,  9719, -1330,
    1708     8356, -1330,  7515,  9253, -1330, -1330, -1330,   566,  9719,   901,
    1709      979,   980,   986,   990,   996,  1001,  1004, -1330,  5001, -1330,
    1710     2075, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330,
    1711    -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330,   851,
    1712    -1330, -1330, -1330,   834, -1330, -1330, -1330, -1330, -1330, -1330,
    1713    -1330, -1330, -1330, -1330,  1008,  1010, -1330,    75,   966, 10190,
    1714    -1330, -1330, -1330,  5097,   982, -1330, -1330, -1330, -1330,  1143,
    1715     6749,  1096, -1330, -1330, -1330, -1330,   994, -1330, -1330, -1330,
    1716      851, -1330, -1330, -1330,   851,   654,  1019,   851, -1330, -1330,
    1717    -1330, -1330, -1330, -1330,  7391, -1330,   301, -1330,  1023,  9566,
    1718    -1330,  1424, -1330,   421,  1143, -1330,  1035,  1030, -1330, -1330,
    1719     1036,  1040, -1330,   822,  1684, -1330,   552, -1330,  2646,   834,
    1720    -1330,   855, -1330, -1330, -1330,   864,  1046, 10981,  8476,  9017,
    1721     1050, -1330, -1330,   665,  1039,  7391,   540,  1039, -1330, -1330,
    1722     1039, -1330,  5097, -1330, -1330, -1330,  1045, 10308,  1051, -1330,
    1723    10308, -1330,  1051, -1330, -1330, 10308, -1330,   305,   795, -1330,
    1724    -1330, -1330, -1330, -1330, -1330, -1330,   803,  9135, -1330, -1330,
    1725     7639,  1055, -1330,   308,   795, -1330,   311,   328,   795, -1330,
    1726     1134,  6615, -1330, -1330, -1330,  9719,  9719, -1330,  8637,  8637,
    1727     1062,  1058,  1060,  1067, -1330,   655,   304,   966, -1330,  1051,
    1728    -1330,  5159, -1330, 10308,   426, -1330,  7019,  1057,  1073, 10131,
    1729     1074,  1075,   885,  1043,   501, 10308,  1077,   301, 10308, 10308,
    1730     1185,  1065,  1066,   267,   113,   637,  1068,  1072,  1082, -1330,
    1731    -1330, -1330,  1085, -1330, -1330, -1330, -1330, -1330, -1330, -1330,
    1732    -1330,  1076, -1330,  1143,  1095, 10308,  9719,  9719,    75,   160,
    1733     1097, -1330, -1330,  1424,   427,  2325, 10308,  2260,   431, -1330,
    1734    -1330,  1079,    72,  1079, -1330, -1330, -1330,   160,   160,  1143,
    1735    -1330, -1330,  3323, -1330, -1330, -1330, -1330,  1110,  1684, -1330,
    1736    -1330,  1094, -1330,  1108, -1330,   938, -1330, -1330,  1743,  1109,
    1737    -1330, -1330, -1330,   673,  1116, -1330,  1125,   909, 10308,  1126,
    1738     1045, -1330,  1167, -1330, -1330,  1132, -1330,   146, -1330,  1127,
    1739     1132, -1330,  1149, -1330, -1330, -1330,   851,  1152,  1161,  7267,
    1740     1157,  1160,  1163, -1330,   160,  1169, -1330, -1330, -1330,   851,
    1741    -1330, -1330, -1330, -1330, -1330, -1330,   851, 10308, 10308,   803,
    1742     1165, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330,
    1743    -1330, -1330, 10308, 10308,  1168,  1171,  1132, -1330, -1330,  1143,
    1744    -1330, -1330, -1330, 10308, 10308,  1236, 10308, -1330, -1330,  1154,
    1745    -1330,  1158, 10308,  1162,  1166, 10308,  1123,  1172,    38, -1330,
    1746       82,  1907, -1330, -1330,  6749,  1174,   160,   448, -1330, -1330,
    1747    -1330, -1330, -1330, -1330, -1330,  9411,   460, -1330,   762,  1183,
    1748     1187,  1191, -1330,  2260, -1330,   160, -1330, -1330, -1330, -1330,
    1749    -1330, -1330, -1330, -1330,  9947, -1330,  8637, -1330,  1195, -1330,
    1750    -1330,  8476,   462,   471, -1330,  1192, -1330,  1193, -1330, -1330,
    1751     1204,  1240, -1330, -1330,  1240,  1240,  1051,  1210,  1516,  1643,
    1752    -1330,  1212, -1330,  9719, -1330, -1330, -1330, -1330, -1330,  1214,
    1753    -1330,  9719,  9719,  9719, -1330, -1330,  1216, -1330,  1218,  1229,
    1754     1230,   679,  8322,  8442, -1330, -1330, -1330, -1330,  1232, -1330,
    1755      690,   693,  1239,   710,  6884, -1330, -1330,   513, -1330, -1330,
    1756      723,  1241,  1243,   301,  1287,   825, -1330, -1330, 10308, -1330,
    1757     1246,   413, 10308, -1330, -1330, 10131, -1330,  1247,  1251, -1330,
    1758    -1330,   439,   795, -1330, -1330,  1424, -1330, -1330, -1330,  1235,
    1759    -1330, -1330, -1330, -1330, -1330, -1330,  8476, -1330, -1330, -1330,
    1760     1051, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330, -1330,
    1761    -1330, -1330, -1330,  1244,  1253, -1330, -1330, -1330, -1330, -1330,
    1762    -1330, -1330,  1256, -1330,  1257, -1330, 10131,   102, 10308, 10131,
    1763    -1330,  1260, 10308, -1330,  6149,  8476, -1330,   386,  1275,  1280,
    1764    -1330, -1330,  1268,  1269,  1252,   413,   197,   763, -1330, -1330,
    1765    -1330, -1330, -1330, -1330,   851, -1330, -1330,  1958,  1743,  1264,
    1766     1132,  1051,  1051,  1276,  1278,  1279,  1282, -1330, -1330,  8637,
    1767     1274, -1330,  1354, 10308,  1267, -1330, -1330, 10041, -1330,   727,
    1768    -1330,  1266, 10131,  1270,  8712, -1330, -1330,  1290, -1330,  1291,
    1769    -1330,  1307,  1309, -1330,  1277,  1281,   195,  1283,  9719,  8476,
    1770    -1330, -1330, -1330,  1294,  1132,  1132, -1330, -1330, -1330, -1330,
    1771    -1330, 10131,   314, -1330,   327, -1330, -1330,  6528, -1330, -1330,
    1772     1284, 10308, -1330, 10308,  6528,   301,  9566,   301,  9566,  1298,
    1773    -1330,  1299, -1330,  1292, -1330, 10308,  1302,   237,  1305, -1330,
    1774    -1330, -1330,  1310, -1330,  1312,  1314, -1330, 10308, 10308, -1330,
    1775    -1330,   847,    86, -1330, -1330,  1296, -1330,   847, -1330, -1330,
    1776     2447,   540, -1330, -1330,   301,  9566,   301,  9566,   195,  1318,
    1777    10308,  1301,   195,   195,  1326,  1330, -1330, -1330, -1330, -1330,
    1778    10041,  1334,   847,  8127, 10308,  9951,  1336,   847,  1331,  2447,
    1779     2348, -1330, -1330, -1330,  1344, -1330, -1330, -1330, -1330,  1325,
    1780      413,  1347, -1330,   273, -1330, -1330,  9017, -1330,  9813, -1330,
    1781    10041, -1330, -1330,  1328,  9723, -1330, -1330,  9951,   301,  2348,
    1782      301,  1348,  1352,   413,  1355, -1330,  1335,   413,   738, -1330,
    1783     9813, -1330, -1330, -1330,  9723, -1330, -1330, -1330,   301,   301,
    1784    -1330,   485, 10308, -1330,   740, -1330, -1330, -1330, -1330, -1330,
    1785    -1330,   413,   540,  1353,  1337, -1330, -1330, -1330, -1330,   755,
    1786    -1330, -1330,  1339,   540, -1330, -1330
     1649    7080, 10336, -1346,    65, -1346, -1346, -1346, -1346, -1346, -1346,
     1650   -1346,    62, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346,
     1651   -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346,   140, -1346,
     1652   -1346,  1135,  1743,    79,  8505,   107, -1346, -1346, -1346, -1346,
     1653   -1346,   187, -1346, -1346, -1346,  1055,   192, -1346, -1346, -1346,
     1654   -1346, 10182, -1346, -1346, -1346,   118,   227, -1346,  1650, -1346,
     1655   -1346, -1346, -1346,  2245,   362,    74,  8626, -1346, -1346, 10182,
     1656    1874, -1346, -1346,  1963,   424,  3845,  1754,   831,  1963,  1126,
     1657   -1346, -1346, -1346,   140, -1346, -1346,  1963,  1440, -1346,   315,
     1658   -1346,   449,   497, -1346, -1346, -1346, -1346,   340,   227,   140,
     1659   -1346,   140, -1346, -1346, -1346, -1346,  6995,  1650, -1346, -1346,
     1660    1650, -1346,   379, -1346,  9247, -1346, -1346,  2348, 10491, -1346,
     1661     797,   797,   797, -1346, -1346,  1229,   140, -1346,   431,   468,
     1662     505, -1346, -1346, -1346,   517, -1346, -1346, -1346, -1346, -1346,
     1663     536,   569, -1346,   522,  9788,  2012,   153,   486,   556,   589,
     1664     592,   600,   612, 10524,  8132,   576, -1346, 10222, -1346, -1346,
     1665   -1346, -1346,   587, -1346,   216,  3873,  3873, -1346,   616,   454,
     1666   -1346, -1346, -1346, -1346,   636,   467,   478,   540, -1346, -1346,
     1667    2245,  2715,   640,   713, -1346,    42, -1346,   140,   140,   227,
     1668   -1346, -1346,    80, -1346,   140,   140, -1346,  2887,   679,   692,
     1669     797,  7794, -1346, -1346, -1346, 10182, -1346, -1346,  1963, -1346,
     1670   -1346, -1346,   227, -1346,  1650,   118, -1346,  8898, -1346,   797,
     1671     797,   797,   227, -1346,  1135, -1346,  7163, -1346, -1346,   691,
     1672     797, -1346,   797, -1346,   993,   797, -1346,  1135,   700,   717,
     1673   -1346,  8505,   606, -1346, -1346, -1346, 10149, -1346, -1346,  4159,
     1674   -1346,   713,    16,  5182, 10491,  2348,  2887, -1346,    92, -1346,
     1675   -1346,  9247,  1650,   697, 11820,  1743,   800, -1346, -1346,    59,
     1676   -1346,   509, -1346,   765,   838,  5241,   819,  5182,  5622, -1346,
     1677     821, -1346, -1346, -1346, -1346, -1346,  6113,  6113,  9552,   192,
     1678   -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346,  1842,  2541,
     1679    9788,  5182, -1346,   385,   290,   801,   638,   472,   837,   833,
     1680     835,   879,    26, -1346, -1346, -1346,   733, -1346, -1346,   223,
     1681   -1346, -1346,  2012, -1346, -1346,   432,   865, -1346,   659,   865,
     1682   -1346, -1346,  6995, -1346,   140,   874,   876,  9906, -1346, -1346,
     1683     878,  1713,  9333,  7918,  1963,  1963, -1346,  1963,   797,  1963,
     1684     797, -1346, -1346,   140, -1346, -1346, -1346, -1346, -1346, -1346,
     1685   -1346,  1963,   797, 10609,  1650, -1346, -1346, 10642,  1324, -1346,
     1686   -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346,  3398,  5182,
     1687   -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346,
     1688   -1346, -1346, -1346, -1346,   921,   880,   906,   909,   944,   914,
     1689     916,   918,  2715, -1346, -1346,   140,   902,   935,   118,   934,
     1690   -1346, -1346,   949, -1346, -1346, -1346, 10149, -1346, -1346, -1346,
     1691   -1346, -1346,  2887, -1346,  9788,  9788, -1346,   797,  2348,  8042,
     1692    9408, -1346, -1346, -1346, -1346, 10149,    16, -1346, -1346,  1963,
     1693     227, -1346, -1346, 10149, -1346,  7659, -1346, -1346,   797,   797,
     1694     187,  9788, -1346,   954, -1346,   797, -1346, -1346, -1346, -1346,
     1695   10950, -1346,   397, 11485, -1346,   227,   960, -1346,  2348, 11525,
     1696    7794,  6374, -1346, -1346, -1346, -1346,   980,  2887, -1346,  9408,
     1697     713,  7345, -1346, -1346, -1346, -1346,  1499,   420,   951,  1743,
     1698     969,   967,   990, 11820,  1343,  9247, -1346, 11820, -1346, -1346,
     1699   -1346, -1346,   422, -1346,   996,   976, -1346,  9552, -1346, 10682,
     1700   -1346, -1346,  9552, -1346,  9670,  9552, -1346, -1346,   192, -1346,
     1701     452,  1006,  1007, -1346,  7884, -1346,   532, -1346, -1346,  5182,
     1702   -1346,   763,  5182, -1346, -1346, -1346, -1346, -1346, -1346, -1346,
     1703   -1346, -1346, -1346, -1346, -1346,  5182, -1346, -1346,  5182,  5182,
     1704    5182,  5182,  5182,  5182,  5182,  5182,  5182,  5182,  5182,  5182,
     1705    5182,  5182,  5182,  5182,  5182,  5182,  3194,   733,   674, -1346,
     1706   -1346,   140,   140, -1346, -1346,  9788, -1346, -1346,   949, -1346,
     1707   -1346,   949,  6559, -1346, -1346,  1743, 10642,  7884,  1002, -1346,
     1708   10757, -1346,   797,   797,   797, -1346, -1346,   587, -1346,  1011,
     1709     953,  1016,  5182,  2260,   168,   951, -1346,   140,   140,   951,
     1710     211, -1346,   140,   140,   949,   951, -1346,   140,   140, -1346,
     1711     865, -1346, 10797, -1346,  1650, 11676,   797,   797, -1346,  1953,
     1712     266,   729, 10797, -1346,  7263, -1346,   951, -1346, 10609, -1346,
     1713     193,  9018,  9018,  1650,  4710,   989, -1346,   550,  1010,  1012,
     1714   -1346,  1021,  3873,   390, -1346,  1117,  1650,  9018,   606,  2348,
     1715     606,   235,   865, -1346, -1346,   274,   865, -1346, -1346, -1346,
     1716    2348, -1346,   522, -1346,   865,   227, 10950, -1346,   487,  1045,
     1717     620,  1049, -1346,   874,   227, -1346, -1346, 10149,   227,   633,
     1718    6712,  1046, 11676, -1346, -1346,  1051, -1346, -1346, -1346,   606,
     1719   -1346, 11601, 11751,   876, -1346,  9018,   518,  9333, -1346, -1346,
     1720     587,  1047,  1050,  1499,  2494, -1346, -1346, 11820, -1346, -1346,
     1721    1743,  1052,  5182, -1346,  1743,  1053, -1346, -1346,  1057, -1346,
     1722    1053,  1060,   509,  5182, -1346,  1061,   192,  1063,  1072,  1073,
     1723   -1346,  1076,  1077,  7884, -1346,  5182, -1346,  5073,  5182,  1068,
     1724   -1346, -1346,   657, -1346,  5182, -1346, -1346,   828, -1346, -1346,
     1725   -1346, -1346,   385,   385,   290,   290,   801,   801,   801,   801,
     1726     638,   638,   472,   837,   833,   835,   879,  5182,   327, 10950,
     1727    1084,  1085,  1086,   674, -1346, -1346, -1346, -1346, -1346, 10950,
     1728   10950, -1346, -1346, 10609, -1346,  8256, 10024, -1346, -1346, -1346,
     1729     953, 10950,   985,  1089,  1093,  1107,  1110,  1115,  1120,  1124,
     1730   -1346,  4610, -1346,  2260, -1346, -1346, -1346, -1346, -1346, -1346,
     1731   -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346,
     1732   -1346, -1346,   949, -1346, -1346, -1346,   951,   797, -1346, -1346,
     1733   -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346,  1127,
     1734    1130, -1346,   118,  1068,  4710, -1346, -1346, -1346,  3398,  1123,
     1735   -1346, -1346, -1346, -1346,  1743,  7483,  1215, -1346, -1346, -1346,
     1736   -1346,  1116, -1346, -1346, -1346,   949, -1346, -1346, -1346,   949,
     1737     713,  1136,   949, -1346, -1346, -1346, -1346, -1346, -1346,  8132,
     1738   -1346,   227, -1346,  1142, 10682, -1346,  2205, -1346,   542,  1743,
     1739   -1346,  1152,  1157, -1346, -1346,  1156,  1162, -1346,   775,  1004,
     1740   -1346,   751, -1346,  2494,   951, -1346,   967, -1346, -1346, -1346,
     1741     969,  1165, 11820,  9247,  9788,  1168, -1346, -1346,   677,  1169,
     1742    8132,   606,  1169, -1346, -1346,  1169, -1346,  3398, -1346, -1346,
     1743   -1346,  1163,  5182,  1278, -1346,  5182, -1346,  1278, -1346, -1346,
     1744    5182, -1346,   317,   865, -1346, -1346, -1346, -1346, -1346, -1346,
     1745   -1346,   876,  9906, -1346, -1346,  8380,  1174, -1346,   318,   865,
     1746   -1346,   324,   376,   865, -1346,   797,  4908, -1346, -1346, -1346,
     1747   10950, 10950, -1346,  9408,  9408,  1177,  1176,  1184,  1186, -1346,
     1748     793,    61,  1068, -1346,  1278, -1346,  3873, -1346,  5182,   543,
     1749   -1346,  7760,  1195,  1198, 11362,  1199,  1200,  1074,  1128,  1197,
     1750    5182,  1209,   227,  5182,  5182,  1300,  1189,  1193,   187,   182,
     1751     688,  1196,  1212,  1214, -1346, -1346, -1346,  1217, -1346, -1346,
     1752   -1346, -1346, -1346, -1346, -1346, -1346,  1219, -1346,  1743,  1234,
     1753    5182, 10950, 10950,   118,   140,  1237, -1346, -1346,  2205,   575,
     1754    1180,  5182,  2333,   588, -1346, -1346,  1222,    54,  1222, -1346,
     1755   -1346, -1346,   140,   140,  1743, -1346, -1346, 10376, -1346, -1346,
     1756   -1346, -1346,  1255,  1004, -1346, -1346,  1238, -1346,  1254, -1346,
     1757    1053, -1346, -1346,  2348,  1259, -1346, -1346, -1346,   708,  1256,
     1758   -1346,  1266,  1021,  5182,  1265,  1163, -1346,   818, -1346, -1346,
     1759    1264, -1346,    23, -1346,  1270,  1264, -1346,  1275, -1346, -1346,
     1760   -1346,   949,  1276,  1280,  8008,  1287,  1288,  1291, -1346,   140,
     1761    1294, -1346, -1346, -1346,   949, -1346, -1346, -1346, -1346, -1346,
     1762   -1346,   949,  5182,  5182,   876,  1298, -1346, -1346, -1346, -1346,
     1763   -1346, -1346, -1346, -1346, -1346, -1346, -1346,  5182,  5182,  1306,
     1764    1307,  1264, -1346, -1346,  1743, -1346, -1346, -1346,  5182,  5182,
     1765    1361,  5182, -1346, -1346,  1296, -1346,  1297,  5182,  1302,  1303,
     1766    5182,  1094,  1304,    -2, -1346,    55,  1896, -1346, -1346,  7483,
     1767    1273,   140,   608, -1346, -1346, -1346, -1346, -1346, -1346, -1346,
     1768   10451,   618, -1346,   858,  1310,  1313,  1329, -1346,  2333, -1346,
     1769     140, -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346, 11178,
     1770   -1346,  9408, -1346,  1330, -1346, -1346,  9247,   621,   664, -1346,
     1771    1328, -1346,  1336, -1346, -1346,  1347,  1331, -1346, -1346,  1331,
     1772    1331,  1278,  1349,   897,  1631, -1346,  1350, -1346, 10950, -1346,
     1773   -1346, -1346, -1346, -1346,  1355, -1346, 10950, 10950, 10950, -1346,
     1774   -1346,  1357, -1346,  1359,  1345,  1365,   815,  9093,  9213, -1346,
     1775   -1346, -1346, -1346,  1362, -1346,   710,   712,  1344,   754,  7625,
     1776   -1346, -1346,   698, -1346, -1346,   761,  1371,  1376,   227,  1429,
     1777     937, -1346, -1346,  5182, -1346,  1379,   522,  5182, -1346, -1346,
     1778   11362, -1346,  1384,  1385, -1346, -1346,   416,   865, -1346, -1346,
     1779    2205, -1346, -1346, -1346,  1375, -1346, -1346, -1346, -1346, -1346,
     1780   -1346,  9247, -1346, -1346, -1346,  1278, -1346, -1346, -1346, -1346,
     1781   -1346, -1346, -1346, -1346, -1346, -1346, -1346, -1346,  1387,  1390,
     1782   -1346, -1346, -1346, -1346, -1346, -1346, -1346,  1396, -1346,  1397,
     1783   -1346, 11362,    52,  5182, 11362, -1346,  1400,  5182, -1346,  8823,
     1784    9247, -1346,   242,  1401,  1418, -1346, -1346,  1406,  1407,  1388,
     1785     522,   291,   885, -1346, -1346, -1346, -1346, -1346, -1346,   949,
     1786   -1346, -1346,  1650,  2348,  1409,  1264,  1278,  1278,  1416,  1417,
     1787    1421,  1425, -1346, -1346,  9408,  1420, -1346,  1497,  5182,  1412,
     1788   -1346, -1346, 11272, -1346,   794, -1346,  1415, 11362,  1424,  9483,
     1789   -1346, -1346,  1439, -1346,  1442, -1346,  1454,  1461, -1346,  1431,
     1790    1427,   210,  1430, 10950,  9247, -1346, -1346, -1346,  1455,  1264,
     1791    1264, -1346, -1346, -1346, -1346, -1346, 11362,    76, -1346,   476,
     1792   -1346, -1346,  5498, -1346, -1346,  1443,  5182, -1346,  5182,  5498,
     1793     227, 10830,   227, 10830,  1462, -1346,  1467, -1346,  1457, -1346,
     1794    5182,  1480,   308,  1475, -1346, -1346, -1346,  1479, -1346,  1483,
     1795    1485, -1346,  5182,  5182, -1346, -1346,   963,    96, -1346, -1346,
     1796    1471, -1346,   963, -1346, -1346,  1784, 10757,   606, -1346, -1346,
     1797     227, 10830,   227, 10830,   210,  1487,  5182,  1477,   210,   210,
     1798    1500,  1502, -1346, -1346, -1346, -1346, 11272,  1498,   963,  8747,
     1799    5182, 11182,  1503,   963,  1510,  1784,  2509, -1346, -1346, -1346,
     1800    1512, -1346, -1346, -1346, -1346,  1493,   522,  1516, -1346,   358,
     1801   -1346, -1346,  9788, -1346, 11044, -1346, 11272, -1346, -1346,  1501,
     1802   10954, -1346, -1346, 11182,   227,  2509,   227,  1519,  1520,   522,
     1803    1522, -1346,  1509,   522,   809, -1346, 11044, -1346, -1346, -1346,
     1804   10954, -1346, -1346, -1346,   227,   227, -1346,   568,  5182, -1346,
     1805     824, -1346, -1346, -1346, -1346, -1346, -1346,   522,   606,  1533,
     1806    1514, -1346, -1346, -1346, -1346,   843, -1346, -1346,  1518,   606,
     1807   -1346, -1346
    17871808};
    17881809
     
    17901811static const yytype_int16 yypgoto[] =
    17911812{
    1792    -1330,  4602,  1553, -1330,  2208, -1330,     7,     0,   -94, -1330,
    1793    -1330,   478,  -507,  -466,  -839,  -847, -1330,  -174,  5285,   694,
    1794    -1330,    66,   362,   365,   538,   366,   931,   937,   940,   924,
    1795      939, -1330,   320,  -636,  4424,  -882, -1330, -1330,   578,  -177,
    1796     -942,  -361, -1330,   120, -1330,   354, -1077, -1330, -1330,    67,
    1797    -1330, -1071, -1040,   183, -1330, -1330, -1330, -1330,    -9, -1090,
    1798    -1330, -1330, -1330, -1330, -1330, -1330,   262, -1329, -1330, -1330,
    1799     -798, -1330,    54,     4, -1330,   109, -1330,  -306, -1330, -1330,
    1800    -1330,   512,  -805, -1330, -1330,     3, -1131,   270,   704, -1330,
    1801    -1330, -1330,  -145, -1330,   250,  1286,  -188,  2355,  4289, -1330,
    1802    -1330,    18,  1452,   993,  1681, -1330,  2638, -1330, -1330,   112,
    1803     2990, -1330,  3232,  1709, -1330, -1330, -1330,  -833, -1330,   658,
    1804      505,   257,   500,  -445, -1330, -1330,   837,   645,  -484, -1330,
    1805     -489,  -339,  -560, -1330, -1330,  -919,  -900,  -129,  1056, -1330,
    1806      240, -1330,   970,  -170,  -275,  -200,  -136,   629,   717, -1330,
    1807      911, -1330,  3561,  1374,  -401,   857, -1330, -1330,   664, -1330,
    1808     -432, -1330,   316, -1330, -1330, -1330, -1224,   360, -1330, -1330,
    1809    -1330,  1091, -1330,    23, -1330, -1330,  -799,  -109, -1287,  -148,
    1810     5540, -1330,  5415, -1330,   845, -1330,  -100,    90,  -175,  -171,
    1811     -162,     2,   -40,   -34,   -30,   493,    15,    22,    32,   -92,
    1812     -161,  -159,  -157,  -156,  -314,  -467,  -462,  -442,  -512,  -313,
    1813     -534, -1330, -1330,  -503,  1006,  1011,  1014,  1751,  5167,  -538,
    1814     -510,  -504,  -500,  -533, -1330,  -939, -1005,  -999,  -995,  -568,
    1815     -305,  -309, -1330, -1330,   392,   502,   -58, -1330,  3974,   -39,
    1816     -574,  -222
     1813   -1346,  4712,  1583, -1346,  1844, -1346,     7,     0,   257, -1346,
     1814   -1346,   637,  -508,  -460,  -702, -1047, -1346,   -72,  1640,  1181,
     1815   -1346,   368,   492,   531,   498,   557,  1092,  1099,  1100,  1106,
     1816    1091, -1346,  -277,  -697,  5286,  -774, -1346, -1346,   722,   565,
     1817    -972,   603, -1346,   111, -1346,   496, -1130, -1346, -1346,   208,
     1818   -1346, -1322,  -943,   325, -1346, -1346, -1346, -1346,   128, -1151,
     1819   -1346, -1346, -1346, -1346, -1346, -1346,   400, -1046, -1346, -1346,
     1820    -544, -1346,   196,   138, -1346,   243, -1346,  -329, -1346, -1346,
     1821   -1346,   648,  -823, -1346, -1346,     5, -1137,   564,   270, -1346,
     1822   -1346, -1346,  -130, -1346,    18,  -452,    47,  -213,  -191,  2570,
     1823    4418, -1346, -1346,   131,   355,   744,  1341,    39,  2331, -1346,
     1824   -1346, -1346,   276, -1346,   365,   201,  2987,    15,  -227, -1346,
     1825   -1346,  5549,  5788,  -872, -1346,   795,   639,   391,   634,  -919,
     1826   -1346, -1346,  6180,   970,   781,  -314, -1346,   -52,  -391,   770,
     1827   -1346, -1346,  -927,  -863,   -63,   -19, -1346,  1233, -1346,  1364,
     1828     -99,  -296,  -180,  -136,   762,   840, -1346,  1048,   405,  3462,
     1829    1523,  -417,   986, -1346, -1346,   792, -1346,  -436, -1346,   -73,
     1830   -1346, -1346, -1346, -1262,   494, -1346, -1346, -1346,  1230, -1346,
     1831       6, -1346, -1346,  -803,  -107, -1345,  -150,  6282, -1346,  3941,
     1832   -1346,   982, -1346,   -18,   212,  -176,  -173,  -169,     2,   -42,
     1833     -40,   -32,   586,    10,    22,    49,    50,  -166,  -163,  -160,
     1834    -158,  -318,  -540,  -528,  -480,  -587,  -304,  -556, -1346, -1346,
     1835    -509,  1145,  1154,  1155,  1813,  5019,  -577,  -507,  -497,  -488,
     1836    -468, -1346,  -925, -1029, -1004, -1003,  -581,  -252,  -244, -1346,
     1837   -1346,   169,    77,   -45, -1346,  3860,   -39,  -632,   147
    18171838};
    18181839
     
    18201841   positive, shift that token.  If negative, reduce the rule which
    18211842   number is the opposite.  If YYTABLE_NINF, syntax error.  */
    1822 #define YYTABLE_NINF -528
     1843#define YYTABLE_NINF -547
    18231844static const yytype_int16 yytable[] =
    18241845{
    1825       50,   111,    96,   385,   113,   145,   255,   386,   110,   668,
    1826      416,   146,   161,   427,   735,   147,   387,   388,    69,   389,
    1827     1169,   390,   391,   350,   589,   594,  1170,   371,   372,   580,
    1828     1171,   111,   111,   398,    50,  1010,    96,   717,   811,  1115,
    1829     1116,  1012,  1042,  1144,   614,    50,   248,   271,   618,   793,
    1830      783,    50,    69,   156,   762,   796,   834,   140,    50,  1117,
    1831      148,   803,  1349,    50,   894,   187,    50,   149,   210,    50,
    1832      196,   220,   213,   161,   784,   792,  1405,   150,   385,   393,
    1833      785,   703,   386,  1080,   786,   708,   413,   394,  1174,  1453,
    1834       95,   387,   388,   331,   389,   859,   390,   391,    33,   457,
    1835      654,   461,   463,   319,  1258,    50,  1147,  1148,    50,   509,
    1836       33,    33,    76,  1323,    33,    50,   511,   780,    33,   663,
    1837      397,   197,   781,   111,    95,   121,  1486,   667,  1488,   686,
    1838     1126,   824,   824,  -240,  -240,   144,  1260,   826,   145,   658,
    1839      660,    95,   782,    50,   146,   156,    76,   824,   147,  1363,
    1840     1364,  1405,   843,   183,   393,    50,    95,   361,   122,    95,
    1841      109,   693,   394,   687,   423,  1432,   565,   462,   399,   462,
    1842      240,  1131,   399,    43,    44,  1259,   168,  1132,    50,    50,
    1843      554,   156,   407,   467,   399,   399,  1198,   163,   399,  1165,
    1844      794,   586,   585,   148,   824,    50,  1261,   926,   652,   882,
    1845      149,   728,    33,    50,   903,   156,  -240,   931,   932,   707,
    1846      150,   164,    50,   145,   555,    50,   241,   430,   942,   146,
    1847      423,  1365,   111,   147,   780,  1203,   365,   503,   719,   781,
    1848      240,   321,   111,    95,  1274,   111,  1208,   657,   659,    50,
    1849      111,    96,   366,   941,    33,    95,   796,   451,   -10,   782,
    1850       63,    33,   954,    50,    50,   696,   156,    69,   930,   161,
    1851       50,   457,   449,   111,  1209,   771,   139,   784,   384,   183,
    1852       57,   114,   573,   785,   594,   141,  1323,   786,   953,   270,
    1853      457,   825,   825,  1323,    63,   723,  1117,   151,   457,   766,
    1854      814,   350,   647,    95,   815,   582,  1409,   825,   172,   925,
    1855      648,   580,  1320,   656,    57,    95,   580,   405,   820,   661,
    1856      780,  1425,  1385,  1115,  1116,   781,   801,    33,   585,   509,
    1857       50,  1053,   361,   847,   509,   399,   713,   509,   715,    95,
    1858      424,   716,  1386,  1117,   720,   782,   204,    50,    50,   214,
    1859      432,   500,  1323,   465,   825,   249,   793,    33,   250,  1010,
    1860       33,    76,  1461,    33,    50,  1012,    76,   563,    50,  1291,
    1861      866,  1294,  1296,   564,   535,   536,   647,   797,   627,   811,
    1862       33,   800,  1462,   784,   648,   319,   319,   806,   756,   785,
    1863     1373,   142,   686,   786,   350,  1505,   235,   375,  1516,   851,
    1864     1172,   399,    50,   818,   361,  1112,  1113,   821,  1504,  1409,
    1865      535,  1470,   319,   376,  1409,  1122,   510,  1475,  1517,   568,
    1866       95,   399,    50,  1102,  1105,  1437,   687,  1525,    50,  1083,
    1867      166,   399,  1096,  1520,   399,  1100,   195,   585,   588,  1409,
    1868     1524,  1123,  1500,  1363,  1364,   535,  1409,  1507,  -295,  1322,
    1869     1400,  1123,  1103,   158,   585,   319,   350,   238,  1438,   677,
    1870     -523,  1350,   426,   111,  1078,   678,  1160,  1161,    50,  1117,
    1871      110,   934,  1439,   487,   319,   240,    50,  1063,   361,  1445,
    1872       50,  1446,    96,   251,  1169,    50,   952,   594,   111,   999,
    1873     1170,    33,   183,   111,  1171,   428,  1234,  1235,    69,    63,
    1874      378,   350,   350,  1197,   458,   835,  1055,   270,   544,   545,
    1875      469,   380,   105,   105,   158,  1375,   379,   350,   694,    57,
    1876      954,  1482,  1394,  1395,   695,   111,   483,   381,    76,   484,
    1877      111,   457,   729,   382,   836,   319,   626,   734,   488,   845,
    1878      489,   490,  1502,   546,   547,   879,   105,    76,   434,   383,
    1879      855,  1174,  1039,   837,   157,    76,   -12,  1129,  1039,   322,
    1880      665,   446,  1175,  1341,   350,   399,   188,   856,  1040,   211,
    1881       95,   323,   221,  1130,  1167,   588,   686,   812,  1176,  1129,
    1882     1274,   105,   582,  -448,   952,   679,    39,   172,   169,   170,
    1883       42,  1175,    76,  1281,    50,  1266,  1178,    50,  1178,    43,
    1884       44,   957,  1283,   773,   615,   422,  -449,  1270,   619,  1282,
    1885      687,   266,  1443,   737,   738,   739,  1541,    50,  1284,  1443,
    1886        8,     9,    10,    11,    12,   109,   510,   109,  1135,  1114,
    1887     1542,   510,    50,  1142,   510,   268,   111,   964,    43,    44,
    1888       43,    44,   580,   269,   723,    50,   157,   111,    50,   111,
    1889      324,    39,    33,   816,   844,    42,   846,   817,   362,    50,
    1890     1326,   422,   325,  1298,    43,    44,   458,   883,   733,   585,
    1891     1489,  1300,  1301,  1302,  1493,    47,    48,  1050,  1501,   816,
    1892       36,   326,   157,  1049,   779,   458,   327,   588,   111,   586,
    1893      777,   360,   585,   458,   364,   878,   540,   541,    47,    48,
    1894      158,    50,    50,   537,    51,   112,   157,   970,   111,   538,
    1895      539,   556,   111,   399,    58,    58,   373,  1018,   431,    47,
    1896       48,   709,   277,   722,   556,   377,   399,   710,   684,   723,
    1897       63,   397,    47,    48,   395,    43,    44,  1402,    51,     2,
    1898      200,     4,     5,     6,     7,   350,   860,   862,    58,   143,
    1899       57,   105,   723,   723,   414,    51,   868,   437,   919,   415,
    1900      686,   504,   564,   367,   920,  1337,   447,   179,   548,   549,
    1901      203,   448,  1107,    51,     2,   200,     4,     5,     6,     7,
    1902       58,  1031,  -112,    58,   858,   470,  -112,    50,    76,  1033,
    1903     1065,   779,   588,   865,   687,  -401,   920,   867,  1194,  1459,
    1904       50,   913,    76,   999,   564,   222,  1309,    37,   112,    38,
    1905     1310,  1468,  1402,   923,   920,  1316,   112,   494,  1317,   254,
    1906      259,   723,  -296,   362,   723,   240,   321,   399,  1162,     8,
    1907        9,    10,    11,    12,  1491,  1319,   542,   543,  1431,   350,
    1908      350,   723,    37,   627,    38,  1127,   298,   143,  1327,   111,
    1909      996,   495,  1410,   498,   723,   112,   334,   813,   723,   203,
    1910      385,    33,   551,  1535,   386,  1544,   337,   503,    69,   564,
    1911      319,  1541,   827,   387,   388,   550,   389,   779,   390,   391,
    1912     1552,    50,   179,   179,   111,   842,  1553,   321,   399,    36,
    1913      588,   687,   773,  1387,   920,   362,  1332,  1333,    50,   254,
    1914      407,   643,   399,  1312,  1363,  1364,  1543,    51,   812,  1204,
    1915     1205,  1056,   740,   741,  1338,   552,   111,   742,   743,   203,
    1916      553,   328,   627,  1066,   748,   749,   458,   574,   111,    58,
    1917       -3,   640,   111,  1031,   650,  1074,   651,   393,   641,  1074,
    1918      458,  1033,   642,    51,   644,   394,   883,   109,   585,   136,
    1919      137,   259,   645,    58,    47,    48,   259,   254,   254,  1189,
    1920       43,    44,    76,   112,   646,  1362,  1240,  1241,  1370,  1243,
    1921       39,  1032,   169,   170,    42,  1247,   653,   245,  1250,   111,
    1922      586,   684,   105,    43,    44,  -373,  1074,  -244,   588,   996,
    1923      298,   263,    50,    50,    50,   698,  1021,   467,   321,   399,
    1924     -297,   700,   298,   702,    69,   711,   712,     8,     9,    10,
    1925       11,    12,   138,   535,   724,    39,  1408,   725,   557,    42,
    1926      774,  1412,   776,   111,   143,   794,   321,   585,    43,    44,
    1927      893,   787,  1138,    50,   112,    50,   -14,    50,   334,    33,
    1928      833,   -15,   587,   606,   832,   109,   839,   136,   137,   111,
    1929     1436,   861,   500,   863,    45,  -527,   875,   611,    43,    44,
    1930     -422,   611,    47,    48,   887,  1277,   892,    36,    50,   695,
    1931      899,   874,   901,   223,  1518,   904,   224,   907,   908,   228,
    1932      906,   230,   111,   647,   909,   924,   830,   233,   910,  1074,
    1933      927,   648,   744,   745,   746,   747,   179,   917,    76,  -298,
    1934       63,   928,   929,   264,   943,   944,     8,     9,    10,    11,
    1935       12,   945,   972,   350,   350,   946,   254,  1146,   298,   298,
    1936       57,   947,   254,  1032,   611,  1168,   948,  1032,    39,   949,
    1937      169,   170,    42,  -410,   337,  -409,   109,  1013,    33,   111,
    1938     1015,    43,    44,  1071,  1019,   298,  1072,  1519,  1073,    43,
    1939       44,  1369,  1022,  1519,     8,     9,    10,    11,    12,   965,
    1940     1043,  1044,   254,  1045,   996,   684,    36,  1046,   912,  1519,
    1941      254,  1054,   611,  1519,    51,  1064,  1068,  1336,  1057,   692,
    1942     1094,  1133,    69,    50,    58,  1031,    33,  1118,   112,  1119,
    1943     1140,  1120,  1121,  1033,  1251,  1252,  1253,  1134,  1136,  1137,
    1944      298,  1145,   112,   723,  1056,   298,  1149,   298,   298,   223,
    1945       -9,  -445,   443,   -11,    36,    -3,   111,   334,   111,   111,
    1946     1158,  1156,  1164,  1074,  1026,  1074,  1074,   337,   109,  1152,
    1947      136,   137,  1139,  1141,  1143,  1185,    63,   483,  1187,  1190,
    1948      350,    43,    44,   480,    39,  1195,   169,   170,    42,  1391,
    1949     1196,  1384,   109,  1199,  1210,  1081,    57,    43,    44,  1071,
    1950      557,   557,  1072,  1206,  1073,    43,    44,   109,   298,   136,
    1951      440,   874,  1325,  1032,  1212,   996,    76,  1214,   611,   334,
    1952       43,    44,   606,   360,  1216,    50,  1215,  1217,   587,   337,
    1953     1218,   587,  1227,  1202,  1220,  1236,  1242,   115,  1237,  1056,
    1954      111,  1245,  1426,   965,  1264,  1246,   441,  1074,  1271,  1248,
    1955      611,   442,  1272,  1249,   385,   611,  1273,   606,   386,  1257,
    1956     1279,   611,  1285,  1287,   611,   611,   996,   387,   388,   996,
    1957      389,  1288,   390,   391,   337,   337,  1289,  1292,   213,  1297,
    1958      611,  1299,   254,  1305,   223,  1306,   228,   154,   628,   684,
    1959      337,  1481,   105,   254,  1307,  1308,   893,    50,    50,  1315,
    1960     1253,   111,   111,  1318,  1346,  1328,    76,  1329,  1074,  1074,
    1961     1335,  1357,  1339,   112,  1426,  1032,  1340,   996,  1426,  1426,
    1962     1358,  -411,   996,  1330,  1361,  1372,  1377,   611,   884,   606,
    1963      393,  1379,  1381,  1382,  1392,   692,   692,   337,   394,  1383,
    1964      246,  1396,  1056,  1397,  1398,  1310,  1514,  1399,   154,  1401,
    1965      105,   996,  1406,  1411,    63,  1415,  1417,  1413,  1419,   647,
    1966     1421,  1433,  1423,  1454,  1456,   334,  1460,   648,  1424,  1530,
    1967     1430,  1444,   223,  1530,    57,  1325,  1463,  1458,   314,  1466,
    1968     1465,  1467,  1325,  1474,   874,  1490,   684,   329,  1492,   145,
    1969      209,  1495,   893,   893,  1496,   146,  1508,  1547,   697,   147,
    1970       50,   111,    70,   706,  1499,   557,  1506,   319,  1483,  1510,
    1971     1513,  1057,  1515,  1528,   611,  1521,   937,  1529,  1550,  1532,
    1972      996,   587,  1533,  1151,  1551,   996,  1554,   753,   105,    50,
    1973       50,   750,   156,    39,   587,   418,    70,    42,   751,   421,
    1974      209,  1325,   752,   754,   458,  1070,    43,    44,   996,    39,
    1975      996,   176,   177,    42,   996,  1469,   676,   996,  1263,    50,
    1976     1376,   361,    43,    44,    57,  1536,  1331,  1494,   206,    76,
    1977      996,  1534,   691,  1447,   996,  1157,    76,  1024,  1166,   209,
    1978       47,    48,  1345,  1179,   298,  1448,  1052,  1452,  1025,   895,
    1979      399,  1067,   111,   838,    58,   421,    47,    48,   475,  1548,
    1980      971,  1280,   889,   111,  1051,   902,  1057,   874,   334,  1026,
    1981     1555,   689,   758,   112,     0,  1027,     0,   759,   337,   465,
    1982      760,     0,   314,     0,  1485,     0,  1487,   884,   884,     0,
    1983        0,     0,   692,     0,   154,    76,     0,  1390,     0,   209,
    1984        0,   109,   112,   298,   204,   214,   831,     0,  1071,   334,
    1985        0,  1072,    58,  1073,    43,    44,   444,   162,     0,   167,
    1986        0,     0,   173,   174,   175,     0,   572,     0,     0,     0,
    1987      577,   209,   109,     0,   136,   137,   209,     0,  1526,   227,
    1988     1527,   334,  1293,     0,     0,    43,    44,     0,     0,   612,
    1989      236,   237,     0,   616,   428,     0,     0,     0,  1539,  1540,
    1990        0,     0,   611,   611,     0,     0,   105,   458,     0,  1057,
    1991        0,   704,   337,   337,   458,     0,   705,   429,   891,     0,
    1992      298,     0,   480,     0,     0,     0,     0,    57,     0,     0,
    1993       58,     0,     0,   893,    57,     0,     0,     0,     0,     0,
    1994        0,    70,     0,   105,     8,     9,    10,    11,    12,     0,
    1995      314,   314,    39,     0,   176,   177,    42,     0,     0,     0,
    1996        0,   676,     0,   209,     0,    43,    44,  1027,   109,  1027,
    1997        0,  1027,     0,   458,     0,  1071,    33,   314,  1072,     0,
    1998     1073,    43,    44,   396,     0,     0,   112,     0,     0,   115,
    1999        0,   178,   884,    57,     0,   893,   105,   207,     0,    47,
    2000       48,     0,   254,     0,    36,     0,   226,   893,   893,  1295,
    2001        2,   200,     4,     5,     6,     7,     0,     0,   475,     0,
    2002      314,     0,   475,     0,     0,   208,     0,     0,     0,     0,
    2003      893,     0,   314,   334,   314,     0,     0,   314,   105,   314,
    2004      314,   206,     0,   209,     0,     0,     0,   207,   883,     0,
    2005      585,     0,     0,   628,     0,     0,    47,    48,  1451,   975,
    2006     1451,     0,     0,   676,     0,     0,     0,     0,    39,     0,
    2007      176,   177,    42,   676,   676,   208,     0,   105,    37,     0,
    2008       38,    43,    44,   209,   676,     0,   207,     0,     0,     0,
    2009        0,     0,     0,     0,  1041,     0,     0,  1451,   298,  1451,
    2010      314,     0,   893,     0,     0,     0,     0,   253,    58,   112,
    2011      769,     0,     0,     0,   208,    47,    48,  1027,   522,   523,
    2012      524,   525,   526,   527,   528,   529,   530,   531,   532,     0,
    2013      611,     0,   628,     0,     0,   112,   576,     0,   583,     0,
    2014        0,   105,   810,    -3,     0,    58,   207,   577,     0,   609,
    2015      610,     0,   533,   819,    39,     0,   169,   170,    42,   105,
    2016        0,   206,     0,     0,     0,     0,   105,    43,    44,     0,
    2017        0,     0,    70,     0,   208,     0,   611,   611,   207,     0,
    2018        0,     0,     0,   207,   401,     0,   337,   337,   298,     0,
    2019      514,   409,     0,   364,   515,   516,   517,     0,    58,     0,
    2020        0,     0,   209,     0,     0,   871,   208,     0,     0,     0,
    2021        0,   208,     0,   126,     0,   127,   128,   129,   518,  1027,
    2022      519,     0,   520,   521,     0,   105,    43,    44,     0,     0,
    2023      112,   475,   209,   975,     0,     0,     0,   209,     0,     0,
    2024       58,     0,     0,   514,     0,     0,     0,   515,   516,   517,
    2025        0,     0,     8,     9,    10,    11,    12,   401,     0,  1182,
    2026        0,   676,   676,     0,     0,     0,     0,     0,   259,   112,
    2027      207,   518,     0,   519,     0,   520,  1262,     0,    58,    58,
    2028        0,     0,     0,    39,    33,   169,   170,    42,     0,     0,
    2029        0,     0,   254,     0,     0,   209,    43,    44,   208,     0,
    2030        0,     0,     0,   611,     0,     0,   933,     0,     0,   209,
    2031      429,     0,    36,   337,     0,   562,     0,    39,   259,   176,
    2032      177,    42,   676,   676,   566,     0,     0,   569,    58,     0,
    2033       43,    44,     0,   112,     0,     8,     9,    10,    11,    12,
    2034        0,     0,     0,    58,     0,     0,     0,     0,     0,  1239,
    2035      207,   112,     0,     0,     0,     0,   178,     0,   112,     0,
    2036      112,    58,   112,     0,    47,    48,   207,    33,    58,     0,
    2037        0,     0,     0,   206,     0,     0,     0,     0,   208,     0,
    2038        0,     0,     0,     0,     0,   401,     0,   206,     0,   409,
    2039      207,     0,     0,     0,  1480,    36,   209,     0,     0,   112,
    2040       39,   112,   176,   177,    42,  1023,     0,     0,     0,     0,
    2041        0,     0,     0,    43,    44,     0,     0,   112,   208,     0,
    2042        0,     0,     0,  1480,  1480,     0,     0,    58,     0,     0,
    2043        0,     0,     0,   475,  1058,   314,     0,     0,     0,   584,
    2044      298,   585,     0,     0,     0,     0,     0,    47,    48,     0,
    2045        0,     0,     0,  1480,    39,     0,   176,   177,    42,     0,
    2046        0,     0,     0,     0,     0,     0,   401,    43,    44,     0,
    2047        0,     0,     0,   810,   206,   876,     0,   877,     0,     0,
    2048        0,     0,     0,     0,   880,   881,     0,     0,     0,   886,
    2049     1278,     0,     0,   584,     0,   585,     0,     0,     0,     0,
    2050        0,    47,    48,     0,     0,     0,   896,     0,     0,   207,
    2051        0,   900,     0,     0,     0,   586,   171,     0,     0,   676,
    2052        8,     9,    10,    11,    12,     0,     0,   676,   676,   676,
    2053      583,     0,     0,     0,     0,     0,     0,   208,     0,   207,
    2054        0,     0,    70,     0,   207,     0,     0,     0,     0,     0,
    2055        0,     0,    33,     0,     0,     0,     0,   562,   562,     0,
    2056        0,     0,     0,   171,   209,     0,   171,   208,     0,     0,
    2057        0,     0,   208,     0,     0,     0,     0,     0,   871,     0,
    2058       36,     0,     0,     0,     0,    39,     0,   176,   177,    42,
    2059        0,     0,     0,     0,     0,     0,     0,     0,    43,    44,
    2060        0,     0,   207,     0,     0,    66,   116,     0,     8,     9,
    2061       10,    11,    12,     0,     0,     0,   207,     0,     0,     0,
    2062        0,     0,     0,     0,  1025,   960,   399,   961,   962,   963,
    2063      208,     0,    47,    48,     0,     0,     0,     0,     0,    66,
    2064       33,   849,   429,     0,   208,   853,  1014,     0,     0,     0,
    2065       39,     0,   176,   177,    42,     0,   155,     0,     0,     0,
    2066        0,     0,  1020,    43,    44,     0,     0,     0,    36,     0,
    2067      171,     0,     0,    39,   215,   176,   177,    42,    70,     0,
    2068        0,     0,     0,     0,     0,  1047,    43,    44,     0,  1025,
    2069        0,   399,     0,     0,   676,     0,     0,    47,    48,     0,
    2070        0,   871,     0,   207,     0,     0,     0,     0,     0,   247,
    2071        0,     0,  1479,     0,   399,     0,     0,     0,   171,  1069,
    2072       47,    48,     0,     0,  1079,     0,     0,  1058,     0,  1082,
    2073        0,   208,     0,     0,  1087,  1088,     0,     0,     0,  1090,
    2074        0,  1091,  1092,     0,     0,  1095,     0,     0,   320,     8,
    2075        9,    10,    11,    12,  1110,     0,   247,   339,     0,     0,
    2076        0,     0,   562,     0,     0,     0,     0,     0,     0,     0,
    2077     1124,  1125,    39,     0,   176,   177,    42,     0,     0,     0,
    2078        0,    33,     0,     0,   392,    43,    44,     0,     0,     0,
    2079        0,     0,     0,     0,     0,   171,     0,     0,     0,     0,
    2080      412,     0,  1153,   417,   419,  1155,     0,     0,   155,    36,
    2081        0,  1479,   171,   399,    39,     0,   171,     0,    42,    47,
    2082       48,     0,  1058,     0,     0,     0,     0,    43,    44,   435,
    2083        0,     0,     0,   438,     0,   439,     0,     0,   445,     0,
    2084        0,     0,     0,     0,    66,     0,     0,     0,     0,   459,
    2085        0,     0,     0,    45,     0,     0,    70,     0,  1188,   466,
    2086        0,    47,    48,     0,  1192,  1193,     0,   419,     0,     0,
    2087        0,   207,     0,  1200,     0,     0,     0,     0,  1207,     0,
    2088        0,     0,     0,  1211,     0,     0,     0,     0,    74,     0,
    2089        0,     0,     0,     0,     0,     0,  1219,     0,     0,   208,
    2090        8,     9,    10,    11,    12,     0,     8,     9,    10,    11,
    2091       12,     0,  1226,     0,  1228,  1229,  1230,  1231,     0,     0,
    2092        0,     0,    74,     0,     0,  1058,     0,     0,  1085,  1238,
    2093        0,  1124,    33,     0,     0,   247,     0,     0,    33,   578,
    2094        0,     0,     0,     0,  1098,   608,    70,     0,   209,     0,
    2095        0,     0,  1450,     0,  1450,     0,     0,   216,   613,     0,
    2096       36,     0,   613,  1267,  1268,    39,    36,   176,   177,    42,
    2097        0,    39,     0,     0,     0,    42,     0,     0,    43,    44,
    2098        0,     0,     0,     0,    43,    44,     0,     0,     0,     0,
    2099        0,  1450,     0,  1450,     0,     0,     0,     0,   209,     0,
    2100        0,     0,     0,     0,   253,     0,     0,     0,     0,     0,
    2101      691,   459,    47,    48,     0,     0,     0,     0,    47,    48,
    2102        0,     0,     0,     0,     0,   339,   206,  1303,  1304,     0,
    2103      459,     0,   314,   401,     0,     0,     0,  1314,   459,     0,
    2104      342,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2105        0,     0,     0,     0,     0,   671,     0,     0,   419,     0,
    2106        0,     0,     0,     0,     0,   171,     0,     0,     0,     0,
    2107        0,     0,     0,   685,     0,    66,   429,     0,     0,     0,
    2108      171,     0,     0,     0,     0,     0,     0,   419,     0,     0,
    2109        0,   419,     0,   171,     0,     0,     0,     0,     0,     0,
    2110        0,  1353,     0,  1354,  1355,  1356,     0,     0,     0,    70,
    2111        0,     0,   436,     0,     0,  1360,    70,     0,   339,     0,
    2112        0,     0,     0,  1371,     0,     0,   167,    74,     0,     0,
    2113        0,     0,    74,     8,     9,    10,    11,    12,    13,    14,
    2114       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2115       25,    26,    27,  1393,     0,    28,    29,    30,     0,     0,
    2116        0,     0,   761,     0,     0,    33,   869,     0,     0,   401,
    2117        0,     0,     0,     0,     0,    70,     0,     0,     0,   613,
    2118      772,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2119        0,     0,   790,    36,     0,     0,     0,  1434,  1435,     0,
    2120       40,    41,     0,     0,     0,     0,     0,     0,     0,     0,
    2121     1440,   578,     0,     0,     0,     0,   578,  1440,     0,     0,
    2122        0,     0,   613,     0,     0,   339,   339,     0,   216,     0,
    2123        0,     0,     0,     0,  1464,     0,     0,     0,     0,   714,
    2124       77,   339,     0,   870,     0,    47,    48,     0,     0,     0,
    2125        0,     0,  1478,     0,     0,   207,  1484,     0,     0,     0,
    2126      671,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2127        0,   459,  1343,     0,    77,     0,     0,     0,     0,     0,
    2128        0,     0,     0,   208,     0,   459,     0,     0,   339,  1511,
    2129        0,  1512,     0,     0,    74,     0,     0,   888,   171,     0,
    2130      419,     0,     0,     0,     0,   207,     0,     0,   342,   217,
    2131        0,     0,     0,    74,     0,     0,     0,     0,     0,     0,
    2132        0,    74,     0,     0,     0,     0,   685,     0,     0,  1537,
    2133     1538,     0,     0,   208,     0,     0,     0,     0,   342,     0,
    2134        0,     0,  1545,  1546,     0,     0,     0,     0,     0,     0,
    2135        0,     0,     0,     0,     0,     0,   342,     0,    74,     0,
    2136        0,     0,   671,     0,     0,     0,     0,     0,     0,     0,
    2137        0,     0,   671,   671,     0,   613,     0,     0,   940,     0,
    2138        0,     0,     0,   671,     0,     0,     0,     0,     0,     0,
    2139        0,     0,   344,   951,     0,     0,     0,     0,     0,     0,
    2140        0,   342,     0,     0,     0,     0,     0,     8,     9,    10,
    2141       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    2142       21,    22,    23,    24,    25,    26,    27,     0,     0,    28,
    2143       29,    30,     0,     0,     0,     0,     0,   171,     0,    33,
    2144      171,   171,   171,     0,     0,    66,     0,     0,     0,     0,
    2145        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2146        0,     0,     0,   342,     0,     0,     0,    36,     0,   772,
    2147        0,     0,    39,     0,    40,    41,    42,     0,     0,    77,
    2148        0,     0,    79,     0,    77,    43,    44,     0,     0,  1048,
    2149        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2150        0,     0,   419,   116,     0,     0,     0,     0,   342,   342,
    2151      685,    45,     0,    46,     0,     0,    79,     0,     0,    47,
    2152       48,     0,     0,     0,   342,     0,     0,     0,     0,     0,
    2153        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2154        0,     0,   578,   342,     0,     0,     0,     0,     0,     0,
    2155        0,   218,     0,     0,    74,   417,     0,     0,     0,     0,
    2156      671,   671,     0,   339,   339,     0,     0,     0,    74,     0,
    2157        0,   342,     0,     0,     0,     0,     0,     0,     0,     0,
    2158      217,    66,     0,     8,     9,    10,    11,    12,    13,    14,
    2159       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2160       25,    26,    27,     0,     0,    28,    29,    30,     0,   342,
    2161        0,     0,   171,     0,     0,    33,   869,     0,     0,     0,
    2162        0,   671,   671,     0,     0,     0,     0,     0,     0,     0,
    2163        0,     0,  1173,     0,   345,     0,     0,     0,     0,     0,
    2164        0,     0,     0,    36,     0,   342,    77,     0,     0,     0,
    2165       40,    41,     0,     0,     0,   342,   342,     0,     0,     0,
    2166      344,   216,     0,     0,     0,    77,   342,     0,     0,     0,
    2167        0,     0,     0,    77,     0,     0,     0,     0,     0,     0,
    2168        0,     0,     0,     0,     0,     0,     0,     0,     0,   714,
    2169      344,     0,     0,  1183,   685,    47,    48,     0,     0,     0,
    2170        0,     0,     0,     0,     0,     0,     0,     0,   344,     0,
    2171       77,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2172        0,    79,     0,   171,     0,     0,    79,     0,    74,     0,
     1846      50,   113,    98,   147,   395,   148,   115,   396,   112,   426,
     1847     257,   397,   163,   149,   398,   689,   815,   399,    63,   859,
     1848     400,  1194,   401,   605,   757,   919,   816,   706,  1067,   381,
     1849     382,   113,   113,   408,    50,   437,    98,   610,  1169,    73,
     1850     142,   834,  1035,  1430,   806,    50,  1195,  1196,   117,  1374,
     1851    1228,    50,    63,   158,   739,   150,  1140,  1141,    50,   784,
     1852     803,   250,  1037,    50,  1283,   189,    50,   151,   212,    50,
     1853    1434,   222,   804,    73,   215,   163,   725,   107,   107,   395,
     1854     730,   210,   396,   407,    33,   596,   397,   675,   708,   398,
     1855     423,   359,   399,   807,   152,   400,    33,   401,   156,  1388,
     1856    1389,   472,   474,   808,   198,   321,   684,    50,   333,  1285,
     1857      50,   107,   809,  1233,   688,   623,   467,    50,  1430,   635,
     1858     805,  1142,    33,   639,   589,   113,   565,  1199,   679,   681,
     1859     473,    69,  1348,   210,    33,  1284,   819,  1203,   147,  1203,
     1860     148,  1234,   826,  -240,  -240,    50,   107,   158,   149,   123,
     1861     633,   444,  1457,   248,   637,   199,   242,    50,   409,   371,
     1862     566,   156,  1147,   403,   456,    69,   433,   170,   715,  1286,
     1863     409,  1390,   210,   803,  1434,  1190,   124,  1462,  1156,  1434,
     1864      50,    50,    33,   158,  1316,   804,  1319,  1321,  1148,   522,
     1865     150,   316,   494,   141,   417,   495,   409,    50,  1157,   729,
     1866     331,    78,   151,  1148,  1434,    50,   478,   158,   409,   243,
     1867      33,  1434,    97,   147,    50,   148,  -240,    50,   741,   440,
     1868     160,   143,   433,   149,   113,   928,   978,   709,   673,   152,
     1869     165,   404,   210,   805,   113,    78,   979,   113,   403,  1172,
     1870    1173,    50,   113,    98,   966,  1105,    97,   459,   428,   461,
     1871     850,   850,   431,    33,   166,    50,    50,   146,   158,    63,
     1872     803,   163,    50,    97,   210,   113,   850,   242,   323,   210,
     1873      58,    58,   804,  1299,   955,   185,    77,    33,    97,   788,
     1874      73,    97,   817,   160,   601,    73,   467,   584,  1078,  1388,
     1875    1389,   706,  1151,   807,   272,  1348,   514,  1345,   598,   610,
     1876     415,   144,  1348,   808,    58,   467,   404,   473,   431,   153,
     1877      77,   486,   809,   467,   850,   677,    33,   -10,   107,  1223,
     1878     805,   682,    50,   434,   371,   824,  1450,   601,   851,   602,
     1879    1140,  1141,   816,   442,   819,   316,    58,   375,   574,    58,
     1880      50,    50,   794,   868,   575,   219,   168,   156,  1142,   872,
     1881    1531,   409,   708,   376,  1197,    70,  1035,    97,   891,    33,
     1882      33,  1400,  1348,   623,    50,   197,    33,   359,    50,    97,
     1883     596,  1530,    69,   792,   432,  1398,  1037,   470,   648,   583,
     1884     596,   834,  1551,   839,   668,   321,   321,   840,   876,    70,
     1885     409,   907,   394,   185,   845,  1142,  1546,  1479,   623,   521,
     1886     273,   807,    50,  1550,   371,    86,  1410,   623,   735,   833,
     1887     737,   808,   321,   738,   551,   552,   742,    97,    33,   589,
     1888     809,   208,    50,  1487,   340,   844,  1411,  -299,    50,    97,
     1889     432,  1108,  1121,   409,   409,  1512,   237,  1514,  1125,    86,
     1890     601,   697,    78,  1488,   210,   918,  1347,    78,   745,   240,
     1891    1259,  1260,   669,    97,   242,    73,   321,  1425,    33,   668,
     1892    1222,   359,   950,   113,  1470,   623,  1471,   476,    50,   160,
     1893     112,   316,   316,  1542,    73,   321,  1194,    50,   706,   371,
     1894     623,    50,    73,    98,   210,  1103,    50,    58,  1088,   113,
     1895    1128,   709,   601,  1543,   113,   977,   979,  -542,   316,    63,
     1896     949,  1195,  1196,  1127,  1130,  1080,   861,   548,   647,   610,
     1897     117,    58,   698,   549,   550,   253,   860,    77,   699,   498,
     1898      73,  1142,    77,  1496,   359,   862,   113,   669,  1528,  1501,
     1899    1366,   113,   409,   751,    97,   716,   321,   731,   756,   708,
     1900     486,   717,   316,   732,   486,   -12,   576,   470,   409,   959,
     1901    1508,   686,   870,   604,   316,  1526,   316,   467,   107,   316,
     1902    1533,   316,   316,   880,    57,   116,   470,   744,   623,   559,
     1903     560,   904,   439,   745,   470,   385,   700,   990,   359,   359,
     1904     958,  1199,  -467,   835,   499,   113,   500,   501,   388,   849,
     1905     849,   386,  1139,   598,   359,   977,    70,  1463,    57,   390,
     1906      50,   324,   885,    50,   389,   849,   272,   111,   745,  1468,
     1907    1299,  1464,    69,  1375,   185,   391,  1468,    78,   521,  -468,
     1908      43,    44,   316,   521,    50,   111,   521,   138,   139,   113,
     1909     206,   268,   908,   216,   601,   718,    78,   159,    43,    44,
     1910      47,    48,   359,    50,    78,   511,    86,   113,   750,   190,
     1911     270,    86,   213,   849,   602,   223,    50,   697,   113,    50,
     1912     113,   392,   706,  1064,  1154,   869,   855,   871,   546,   547,
     1913      50,   325,   989,  1106,  1419,  1420,  1527,   393,   709,  1065,
     1914    1155,   111,    78,   271,     8,     9,    10,    11,    12,  1567,
     1915     370,  1427,    77,    97,    43,    44,  1064,   208,   604,   113,
     1916     340,   374,   592,  1568,   326,   546,   903,   327,   626,  1200,
     1917     596,    77,  1192,    50,    50,   328,    33,   210,   796,    77,
     1918     113,   990,   995,   708,   113,  1201,    73,   329,   592,  1154,
     1919    1043,   159,   592,   555,   556,   887,   383,   896,   623,  1200,
     1920      73,   745,  1306,   372,    36,  1291,   219,   546,   893,   833,
     1921     387,    58,   820,  1485,   575,  1295,   823,    77,  1307,   706,
     1922     697,   405,   829,   279,   486,  1494,  1427,   159,   557,   558,
     1923     697,   697,   944,   579,   918,   409,    43,    44,   945,  1362,
     1924     407,   438,   697,   843,  1132,  1308,   883,   846,   567,  1517,
     1925     409,   159,  1090,   424,   340,   890,    47,    48,   945,   892,
     1926      50,  1309,   515,   441,   377,    57,   425,     8,     9,    10,
     1927      11,    12,   802,    50,   225,   604,   481,   226,   470,   745,
     1928     230,    86,   232,  1219,   208,  1341,   359,  1342,   447,   575,
     1929     235,   745,   470,   745,  -300,  1351,    70,   457,   111,    33,
     1930      86,     8,     9,    10,    11,    12,   841,   567,    86,   409,
     1931     842,    43,    44,   520,   458,    47,    48,   340,   648,   899,
     1932    1152,  1569,   709,  1187,   113,  1021,  1337,    36,   841,  1344,
     1933     918,   918,  1074,    33,   395,   745,  1352,   396,  1056,   755,
     1934     505,   397,   745,    63,   398,   321,    86,   399,    78,   908,
     1935     400,   601,   401,   111,   553,   554,    50,    47,    48,   113,
     1936    1096,    36,    78,  1097,    73,  1098,    43,    44,   372,  1435,
     1937    -112,   340,   340,    50,  -112,   745,   759,   760,   761,  -418,
     1938     359,   359,   506,   835,  1561,   802,   604,   340,  1081,   881,
     1939     575,   113,  1334,   509,  1227,   514,  1335,   648,  1091,  1570,
     1940    1515,  1048,   107,   113,  1519,  1567,  1058,   113,   948,   945,
     1941    1099,   592,   225,    39,  1099,   171,   172,    42,  1578,   709,
     1942     561,   697,   697,    77,  1579,   562,    43,    44,   563,   486,
     1943    1083,   316,   111,   323,   409,   340,  1214,    77,   564,  1096,
     1944     439,   330,  1097,   982,  1098,    43,    44,   592,   372,   678,
     1945     680,   586,   370,    -3,   113,   661,    69,   592,  1357,  1358,
     1946     107,  1099,  1046,   592,  1021,  1412,   945,    50,    50,    50,
     1947    1388,  1389,   802,  1318,     8,     9,    10,    11,    12,    63,
     1948     796,   662,   697,   697,   663,   604,  1229,  1230,    39,   665,
     1949    1056,   666,    42,   667,   403,   242,   323,   409,   113,   671,
     1950      73,    43,    44,   762,   763,    57,    33,   208,    50,   672,
     1951      50,   674,    50,   766,   767,   768,   769,   439,   417,   664,
     1952     409,  1075,   208,   899,   113,   247,    78,   800,   111,   601,
     1953     138,   450,   520,  -389,    36,    47,    48,   520,   107,  -244,
     1954     520,    43,    44,    50,   764,   765,  1544,   602,   225,   226,
     1955     720,   627,    86,   232,   478,   323,   409,   113,  1058,   817,
     1956     323,   601,   404,   722,  1099,   235,    86,   451,  1057,   724,
     1957     733,   918,   452,   734,   896,   938,   770,   771,   908,   797,
     1958     601,   746,   747,  1171,   -14,   604,    47,    48,   799,  -301,
     1959      39,   778,    69,   810,    42,    58,     8,     9,    10,    11,
     1960      12,    77,   858,    43,    44,   -15,  1302,   857,   864,    39,
     1961     208,   171,   172,    42,   113,  1276,  1277,  1278,   592,   340,
     1962     886,   626,    43,    44,   888,   900,  -441,  -546,    33,    45,
     1963     912,   924,   917,   918,   717,   926,   929,    47,    48,  1021,
     1964     668,    51,   114,   225,   931,   918,   918,   932,   933,   942,
     1965    1303,   934,   935,    58,   359,   359,    36,    63,    50,   952,
     1966     953,   954,    78,    39,   968,   171,   172,    42,   969,   918,
     1967     128,  1163,   129,   130,   131,    51,    43,    44,    73,   697,
     1968      70,  1081,   970,    43,    44,   971,   145,   697,   697,   697,
     1969     972,   113,    51,   113,   113,   973,   899,   896,  1099,   974,
     1970    1099,  1099,  -429,   997,   181,  -428,  1038,   205,   669,   623,
     1971      51,  1044,  1040,   340,   340,    39,   107,   178,   179,    42,
     1972    1057,  1047,  1193,  1083,  1057,  1165,  1416,  1068,    43,    44,
     1973      86,    58,    39,  1070,   171,   172,    42,    77,  1069,  1071,
     1974    1079,   918,  1056,  1089,  1093,    43,    44,   114,   937,  1119,
     1975    1021,   174,  1143,   107,  1050,   114,   409,  1144,   256,   261,
     1976      50,  1146,    47,    48,   111,  1145,   138,   139,    73,  1158,
     1977      69,  1174,  1159,  1161,  1162,   113,  1081,    43,    44,  1167,
     1978     439,   359,  1099,  1170,    -9,   300,   145,   592,  -464,   395,
     1979     546,   -11,   396,   745,   114,   337,   397,    -3,   205,   398,
     1980     251,  1021,   399,   252,  1021,   400,   107,   401,   265,  1183,
     1981    1058,  1177,  1189,   111,  1181,   215,    70,  1051,  1083,   899,
     1982    1096,   181,   181,  1097,   210,  1098,    43,    44,  1507,   511,
     1983    1210,   494,    50,    50,  1212,  1220,   113,   113,   256,  1215,
     1984      78,  1221,  1224,  1099,  1099,  1231,    51,  1235,   107,  1355,
     1985    1237,  1239,  1021,  1289,   697,  1240,   140,  1021,   205,    39,
     1986    1350,   171,   172,    42,  1241,  1242,    86,   209,  1243,  1245,
     1987    1057,  1267,    43,    44,   210,  1252,   228,  1314,   111,  1081,
     1988     138,   139,    51,  1261,  1262,  1296,  1021,   107,  1297,    57,
     1989     261,    43,    44,  1270,  1271,   261,   256,   256,   374,  1273,
     1990    1274,  1282,   114,  -302,  1298,  1304,   884,   436,  1310,    58,
     1991       8,     9,    10,    11,    12,    77,  1312,   726,  1343,   209,
     1992    1332,  1083,   727,   147,  1313,   148,  1317,  1322,  1024,   300,
     1993      78,    73,  1324,   149,  1330,    50,  1331,   113,    73,  1340,
     1994    1333,   300,    33,   321,  1509,  1353,    58,  1082,   403,   266,
     1995    1354,   107,  1278,  1360,  1371,   480,  1021,   568,   209,  1364,
     1996    1365,  1021,  1402,   145,  1382,    50,    50,  1383,   158,   107,
     1997      36,  -430,  1057,   114,  1386,  1397,   107,   668,   337,  1404,
     1998    1406,  1407,   603,   622,  1021,  1408,  1021,   340,   340,  1417,
     1999    1021,  1421,  1422,  1021,    70,    50,  1423,   371,    73,    58,
     2000    1424,  1335,  1426,  1361,   632,    77,  1021,  1431,   632,   951,
     2001    1021,  1473,  1436,  1478,  1440,  1444,   404,  1442,   209,   956,
     2002     957,  1438,  1446,  1350,  1449,    57,  1448,  1455,   113,   316,
     2003    1350,   967,  1458,   174,    39,  1574,   107,  1480,    42,   113,
     2004    1469,    58,  1482,   181,    86,   669,  1581,    43,    44,   211,
     2005     209,  1511,  1484,  1513,  1486,   209,  1489,   636,   453,  1491,
     2006    1492,   640,  1493,   256,  1516,   300,   300,  1160,  1500,   256,
     2007    1477,   632,  1477,   713,  1518,  1521,  1522,  1409,  1525,    58,
     2008      58,    47,    48,  1532,    70,  1534,   219,  1536,  1539,   491,
     2009    1350,  1541,   300,    78,  1554,  1555,  1558,   164,  1547,   169,
     2010      78,   211,   175,   176,   177,  1552,  1559,  1553,  1576,   256,
     2011    1477,  1577,  1477,   772,   340,  1580,   776,  1176,   256,   229,
     2012     632,   773,    51,   774,  1095,  1565,  1566,   714,  1451,    58,
     2013     775,  1495,   238,   239,    86,  1288,   114,  1401,  1562,  1356,
     2014     211,  1560,  1472,   209,    58,  1520,  1182,  1191,   300,  1049,
     2015     114,  1370,  1204,   300,   920,   300,   300,  1077,   996,  1092,
     2016      78,   863,    58,   914,   208,   337,   111,  1076,    77,    58,
     2017    1305,   711,   780,  1096,   927,    77,  1097,   476,  1098,    43,
     2018      44,   781,   782,  1265,  1266,    39,  1268,   171,   172,    42,
     2019       0,     0,  1272,     0,     0,  1275,     0,     0,    43,    44,
     2020     211,  1451,   649,    57,     0,  1451,  1451,  1320,   568,   568,
     2021    1137,  1138,     0,     0,   439,     0,   300,   454,     2,   202,
     2022       4,     5,     6,     7,     0,   406,     0,   632,   337,    58,
     2023     209,   622,   211,  1540,     0,    77,     0,   211,     0,     0,
     2024    1082,   603,  1024,     0,   603,     0,   209,    70,    39,     0,
     2025     178,   179,    42,     0,    70,     0,  1556,     0,     0,     0,
     2026    1556,    43,    44,   632,     0,     0,   592,     0,   592,     0,
     2027     209,  1185,  1186,   632,     0,   622,     0,     0,   111,   632,
     2028     138,   139,   632,   632,  1573,     0,    37,   600,    38,   601,
     2029       0,    43,    44,    57,     0,    47,    48,    86,   632,     0,
     2030     256,     0,     0,     0,    86,     0,   592,     0,   592,   602,
     2031       0,   256,     0,   719,    70,     0,     0,   836,   728,    39,
     2032       0,   178,   179,    42,     0,   211,     0,     0,     0,     0,
     2033       0,   114,    43,    44,     0,  1082,   852,     0,     2,   202,
     2034       4,     5,     6,     7,     0,     0,   632,   909,   622,   867,
     2035       0,    -3,     0,  1363,   714,   714,     0,     0,  1505,     0,
     2036     409,     0,   173,     0,    86,     0,    47,    48,  1394,   224,
     2037       0,     0,     0,   206,   216,   508,     0,   510,   513,   588,
     2038       0,   599,     0,     0,   337,     0,   516,   517,   525,     0,
     2039       0,   209,   526,   527,   528,     0,     0,     0,   630,   631,
     2040     510,   510,     0,     0,  1387,     0,    37,  1395,    38,   791,
     2041       0,   173,   211,     0,   173,     0,   529,     0,   530,     0,
     2042     531,   532,     0,   438,   568,     0,   209,     2,   202,     4,
     2043       5,     6,     7,     0,   632,   209,   962,   510,  1082,     0,
     2044       0,   603,   525,     0,     0,     0,   526,   527,   528,     0,
     2045       0,     0,   211,   838,   603,  1433,    57,     0,   411,     0,
     2046    1437,     0,     0,    57,     0,   419,     0,     0,  1323,     0,
     2047     529,   856,   530,     0,   531,  1287,  1325,  1326,  1327,   510,
     2048       0,     0,     8,     9,    10,    11,    12,     0,   111,  1461,
     2049     138,   450,     0,   209,     0,    37,     0,    38,     0,     0,
     2050       0,    43,    44,   209,     0,     0,   300,     0,   209,     0,
     2051       0,     0,     0,     0,    33,     0,     0,     0,   173,     0,
     2052       0,     0,     0,    57,     0,     0,     0,     0,     0,     0,
     2053     337,   411,     0,     0,     0,   114,     0,  1052,     0,     0,
     2054       0,     0,    36,     0,   916,     0,     0,    39,   491,   909,
     2055     909,    42,     0,     0,   714,     0,     0,     0,     0,     0,
     2056      43,    44,     0,     0,   114,   300,   173,     0,     0,     0,
     2057       0,   337,     0,   211,     0,     0,     0,     0,     0,     0,
     2058       0,     0,     0,     0,     0,     0,    45,  1545,     0,   573,
     2059       0,     0,     0,  1545,    47,    48,   209,     0,   577,     0,
     2060       0,   580,     0,   337,     0,     0,     0,     0,   211,  1545,
     2061       0,     0,   454,  1545,     0,     0,     0,   211,     0,     0,
     2062       0,     0,     0,     0,   632,   632,     0,     0,     0,     0,
     2063       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2064       0,     0,   300,  1456,   173,     0,     0,     0,   510,   510,
     2065     510,   510,   510,   510,   510,   510,   510,   510,   510,   510,
     2066     510,   510,   510,   510,   510,   510,     0,   411,   173,     0,
     2067       0,   419,   173,     0,     0,   211,     0,     0,     0,     0,
     2068       0,     0,   649,     0,     0,   211,     0,     0,  1000,  1052,
     2069     211,  1052,     0,  1052,     0,     0,     0,     0,     0,     0,
     2070    1164,  1166,  1168,     0,     0,     0,     0,     0,   114,     0,
     2071       0,     0,     0,     0,   909,     0,     0,     0,     0,     0,
     2072       0,     0,     0,  1066,   256,     0,     0,     0,     0,     0,
     2073       8,     9,    10,    11,    12,     0,   901,     0,   902,     0,
     2074      39,     0,   178,   179,    42,     0,   905,   906,     0,   411,
     2075       0,   911,     0,    43,    44,   337,     0,     0,     0,     0,
     2076       0,   649,    33,     0,     0,     0,   209,     0,   921,     0,
     2077       0,     0,     0,   925,     0,     0,     0,     0,   211,  1050,
     2078      39,   409,   178,   179,    42,     0,     0,    47,    48,     0,
     2079      36,    74,   599,    43,    44,    39,     0,   178,   179,    42,
     2080    1051,     0,     0,     8,     9,    10,    11,    12,    43,    44,
     2081       0,     0,     0,     0,     0,     0,     0,     0,     0,   180,
     2082     300,     0,   510,     0,     0,    74,     0,    47,    48,     0,
     2083       0,   114,     0,     0,   600,    33,   601,     0,     0,  1052,
     2084     573,   573,    47,    48,     0,     0,     0,   510,     0,     0,
     2085       0,     0,   632,     0,     0,     0,     0,   114,     0,     0,
     2086     218,     0,  1000,    36,     0,     0,     0,     0,    39,     0,
     2087     178,   179,    42,     0,     0,     0,     0,   510,     0,     0,
     2088       0,    43,    44,    39,     0,   178,   179,    42,  1207,     0,
     2089     985,     0,   986,   987,   988,     0,    43,    44,   632,   632,
     2090       0,     0,     0,     0,     0,     0,     0,  1050,     0,   409,
     2091     300,  1039,     0,     0,     0,    47,    48,     0,     0,     0,
     2092       0,     0,   255,     0,     0,     0,     0,  1045,   173,     0,
     2093      47,    48,     0,     0,   874,     0,     0,     0,   878,     0,
     2094       0,  1052,     0,     0,     0,   346,     0,   173,   211,     0,
     2095    1072,     0,   114,     0,     0,     0,     0,     0,     0,     0,
     2096     173,     0,     0,     0,     8,     9,    10,    11,    12,     0,
     2097       0,     0,     0,     0,     0,     0,     0,     0,  1264,     8,
     2098       9,    10,    11,    12,  1094,     0,     0,     0,     0,  1104,
     2099     261,   114,     0,     0,  1107,     0,    33,     0,     0,  1112,
     2100    1113,     0,     0,     0,  1115,     0,  1116,  1117,     0,     0,
     2101    1120,    33,     0,     0,   256,     0,     0,   446,     0,  1135,
     2102       0,     0,     0,     0,    36,   632,     0,     0,     0,    39,
     2103      66,   118,    74,    42,     0,  1149,  1150,    74,     0,    36,
     2104     261,     0,    43,    44,    39,     0,   178,   179,    42,     0,
     2105     510,     0,     0,     0,     0,   114,   573,    43,    44,     0,
     2106       0,     0,   510,     0,    66,  1415,     0,  1178,   713,     0,
     2107    1180,     0,     0,   114,     0,     0,    47,    48,     0,     0,
     2108     114,   157,   114,  1505,   114,   409,     0,     0,     0,     0,
     2109       0,    47,    48,     0,     0,     0,     0,     0,     0,   217,
     2110       0,   510,     0,   533,   534,   535,   536,   537,   538,   539,
     2111     540,   541,   542,   543,     0,     0,  1506,   261,     0,     0,
     2112       0,     0,   114,  1213,   114,     0,     0,     0,   591,  1217,
     2113    1218,     0,     0,     0,   218,     0,   249,   544,  1225,     0,
     2114     114,     0,     0,  1232,     0,     0,  1506,  1506,  1236,     0,
     2115     209,   510,     0,     0,   591,     0,     0,     0,   591,     0,
     2116       0,  1244,     0,   300,     0,     0,     0,     0,     0,   173,
     2117       0,     0,     0,     0,     0,   322,  1506,  1251,     0,  1253,
     2118    1254,  1255,  1256,   249,   342,     8,     9,    10,    11,    12,
     2119       0,     0,     0,     0,  1263,     0,  1149,     0,     0,     0,
     2120     209,     0,     0,     0,     0,     0,     0,    74,     0,     0,
     2121       0,   402,     0,     0,     0,     0,     0,    33,     0,     0,
     2122       0,   346,     0,     0,     0,  1110,    74,   422,  1292,  1293,
     2123     427,   429,     0,     0,    74,   157,     0,     0,     0,     0,
     2124       0,  1123,     0,     0,     0,    36,     0,   510,   510,     0,
     2125      39,   346,   178,   179,    42,     0,   445,     0,     0,     0,
     2126     448,   218,   449,    43,    44,   455,     0,     0,     0,     0,
     2127     346,    66,    74,     0,     0,     0,   469,   209,     0,     0,
     2128       0,     0,     0,     0,     0,     0,   477,     0,     0,   180,
     2129       0,     0,  1328,  1329,   429,     0,     0,    47,    48,     0,
     2130       0,     0,  1339,     0,     0,     0,     0,     0,   173,     0,
     2131       0,   173,   173,   173,     0,   346,     0,     0,     0,     0,
     2132       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2133     411,     0,   211,     0,     0,     0,     0,     0,     0,     0,
     2134       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2135       0,     0,     0,     0,     0,     0,     0,     8,     9,    10,
     2136      11,    12,   249,     0,     0,     0,  1378,   590,  1379,  1380,
     2137    1381,     0,     0,   625,     0,     0,     0,   591,   346,     0,
     2138    1385,     0,   211,     0,     0,     0,     0,     0,  1396,    33,
     2139       0,   169,     0,   634,     0,     0,     0,   634,     0,     0,
     2140       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2141       0,     0,     0,   591,     0,     0,     0,    36,  1418,     0,
     2142       0,     0,    39,   591,   178,   179,    42,     0,     0,   591,
     2143       0,     0,   346,   346,     0,    43,    44,     0,     0,     0,
     2144       0,     0,     0,     0,     0,     0,   469,    79,   346,     0,
     2145       0,     0,     0,     0,     0,     0,     0,     0,     0,   211,
     2146     342,   255,  1459,  1460,     0,   469,   411,   346,     0,    47,
     2147      48,     0,     0,   469,     0,  1465,     0,     0,    74,     0,
     2148       0,    79,  1465,   173,     0,     0,     0,     0,   510,     0,
     2149     692,     0,    74,   429,     0,     0,   346,     0,     0,  1490,
     2150     702,     0,     0,     0,     0,     0,     0,     0,     0,   707,
     2151       0,    66,     0,     0,     0,     0,   220,  1504,     0,     0,
     2152       0,     0,  1510,   429,     0,     0,     0,   429,     0,     0,
     2153       0,     0,     0,     0,   346,     0,     0,     0,     0,     0,
     2154       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2155     510,     0,     0,     0,   342,  1537,     0,  1538,     0,     0,
     2156       0,     0,   510,   510,     0,     0,     0,     0,     0,  1368,
     2157     346,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2158     346,   346,     0,     0,   591,     0,   510,   218,     0,     0,
     2159       0,     0,   346,     0,   173,  1563,  1564,     0,   783,     0,
     2160       0,   350,     0,     0,     0,     0,     0,     0,  1571,  1572,
     2161       0,     0,     0,     0,     0,     0,   634,   795,     0,     0,
     2162       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2163       0,     0,     0,   813,     0,     0,     0,     0,     0,     0,
     2164       0,     0,     0,     0,     0,   173,     0,     0,   173,     0,
     2165       0,     0,   590,     0,     0,     0,    74,   837,   510,     0,
     2166       0,     0,   590,     0,     0,     0,     0,     0,   634,     0,
     2167       0,   342,   342,     0,     0,     0,   173,     0,     0,     0,
     2168     346,     0,     0,     0,     0,     0,     0,   342,    79,     0,
     2169       0,     0,     0,    79,   275,   276,   173,   277,     0,     0,
     2170       0,   173,     0,     0,     0,     0,   692,     0,     0,     0,
     2171       0,     0,     0,     0,     0,     0,     0,   469,     0,     0,
     2172       0,   346,     0,   278,     0,     0,     0,     0,     0,   279,
     2173     173,   469,     0,   280,     0,   342,   281,   282,   272,   283,
     2174     284,   285,    43,    44,   913,   286,   287,   429,     0,     0,
     2175       0,     0,     0,   591,     0,     0,     0,     0,     0,     0,
     2176       0,     0,     0,     0,     0,     0,     0,     0,   288,     0,
     2177     377,   346,   346,   707,   346,   346,    47,    48,   290,   291,
     2178     292,   293,     0,     0,   593,     0,     0,     0,     0,   777,
     2179     220,     0,    74,     0,     0,     0,     0,     0,     0,     0,
     2180     173,     0,     0,     0,     0,   173,     0,     0,     0,   692,
     2181     593,     0,     0,     0,   593,     0,     0,     0,     0,   692,
     2182     692,     0,     0,   634,     0,     0,   965,     0,   173,     0,
     2183     173,   692,   346,   346,   173,     0,     0,   173,     0,     0,
     2184       0,   976,     0,     0,     0,     0,     0,     0,     0,     0,
     2185     173,     0,     0,     0,   173,     0,     0,     0,     0,     0,
     2186       0,     0,     0,    79,     0,     0,     0,     0,     0,     0,
     2187       0,     0,     0,     0,     0,     0,     0,   350,     0,     0,
     2188       0,     0,    79,     0,     0,     0,     0,     0,     0,     0,
     2189      79,     0,     0,     0,     0,    66,     0,     0,   275,   276,
     2190       0,   277,     0,     0,     0,   346,     0,   350,     0,     0,
     2191       0,     0,     0,     0,     0,     0,     0,   220,     0,   795,
     2192       0,     0,    87,     0,     0,     0,   350,   278,    79,     0,
     2193       0,     0,     0,   645,     0,   138,   139,   280,     0,  1073,
     2194     281,   282,   272,   283,   284,   285,    43,    44,     0,   286,
     2195     287,     0,   429,   118,     0,     0,    87,     0,     0,     0,
     2196     707,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2197      74,   350,   288,     0,   646,     0,   647,   378,     0,     0,
     2198      47,    48,   290,   291,   292,   293,     0,     0,     0,     0,
     2199       0,   221,   590,     0,     0,     0,     0,     0,     0,     0,
     2200     346,     0,   346,     0,     0,   427,     0,     0,     0,     0,
     2201     692,   692,     0,   342,   342,     0,     0,     0,     0,     0,
     2202       0,     0,     0,     0,     0,     0,     0,     0,     0,   346,
     2203    &nb