Changeset d60ccbf


Ignore:
Timestamp:
Aug 12, 2015, 2:27:31 PM (7 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, string, with_gc
Children:
f32c7f4
Parents:
e45215c (diff), e869d663 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into designate

Conflicts:

src/CodeGen/CodeGenerator.h

Files:
4 added
62 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    re45215c rd60ccbf  
    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 : Wed Jul 15 14:47:42 2015
    13 // Update Count     : 177
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jul 27 14:40:06 2015
     13// Update Count     : 218
    1414//
    1515
     
    5252        }
    5353
    54         CodeGenerator::CodeGenerator( std::ostream &os ) : indent(*this), cur_indent( 0 ), insideFunction( false ), output( os ) { }
     54        CodeGenerator::CodeGenerator( std::ostream &os ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ) { }
    5555
    5656        CodeGenerator::CodeGenerator( std::ostream &os, std::string init, int indentation, bool infunp )
    57                         : indent(*this), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
     57                        : indent( *this), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
    5858                //output << std::string( init );
    5959        }
    6060
    6161        CodeGenerator::CodeGenerator( std::ostream &os, char *init, int indentation, bool infunp )
    62                         : indent(*this), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
     62                        : indent( *this ), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
    6363                //output << std::string( init );
    6464        }
     
    9191                // acceptAll( functionDecl->get_oldDecls(), *this );
    9292                if ( functionDecl->get_statements() ) {
    93                         functionDecl->get_statements()->accept(*this );
     93                        functionDecl->get_statements()->accept( *this );
    9494                } // if
    9595        }
     
    121121                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
    122122                                output << indent;
    123                                 (*i)->accept(*this );
     123                                (*i)->accept( *this );
    124124                                output << ";" << endl;
    125125                        }
     
    159159                                if ( obj->get_init() ) {
    160160                                        output << " = ";
    161                                         obj->get_init()->accept(*this );
     161                                        obj->get_init()->accept( *this );
    162162                                } // if
    163163                                output << "," << endl;
     
    478478        void CodeGenerator::visit( TypeExpr *typeExpr ) {}
    479479
     480        void CodeGenerator::visit( AsmExpr *asmExpr ) {
     481                if ( asmExpr->get_inout() ) {
     482                        output << "[ ";
     483                        asmExpr->get_inout()->accept( *this );
     484                        output << " ] ";
     485                } // if
     486                asmExpr->get_constraint()->accept( *this );
     487                output << " ( ";
     488                asmExpr->get_operand()->accept( *this );
     489                output << " )";
     490        }
     491
    480492        //*** Statements
    481493        void CodeGenerator::visit( CompoundStmt *compoundStmt ) {
     
    485497                cur_indent += CodeGenerator::tabsize;
    486498
    487                 for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++) {
     499                for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++ ) {
    488500                        output << indent << printLabels( (*i)->get_labels() );
    489                         (*i)->accept(*this );
     501                        (*i)->accept( *this );
    490502
    491503                        output << endl;
     
    511523        }
    512524
     525        void CodeGenerator::visit( AsmStmt *asmStmt ) {
     526                output << "asm ";
     527                if ( asmStmt->get_voltile() ) output << "volatile ";
     528                if ( ! asmStmt->get_gotolabels().empty()  ) output << "goto ";
     529                output << "( ";
     530                if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *this );
     531                output << " : ";
     532                genCommaList( asmStmt->get_output().begin(), asmStmt->get_output().end() );
     533                output << " : ";
     534                genCommaList( asmStmt->get_input().begin(), asmStmt->get_input().end() );
     535                output << " : ";
     536                genCommaList( asmStmt->get_clobber().begin(), asmStmt->get_clobber().end() );
     537                if ( ! asmStmt->get_gotolabels().empty() ) {
     538                        output << " : ";
     539                        for ( std::list<Label>::iterator begin = asmStmt->get_gotolabels().begin();; ) {
     540                                output << *begin++;
     541                                if ( begin == asmStmt->get_gotolabels().end() ) break;
     542                                output << ", ";
     543                        } // for
     544                } // if
     545                output << " );" ;
     546        }
     547
    513548        void CodeGenerator::visit( IfStmt *ifStmt ) {
    514                 output << "if (";
    515                 ifStmt->get_condition()->accept(*this );
    516                 output << ") ";
    517 
    518                 ifStmt->get_thenPart()->accept(*this );
     549                output << "if ( ";
     550                ifStmt->get_condition()->accept( *this );
     551                output << " ) ";
     552
     553                ifStmt->get_thenPart()->accept( *this );
    519554
    520555                if ( ifStmt->get_elsePart() != 0) {
    521556                        output << " else ";
    522                         ifStmt->get_elsePart()->accept(*this );
     557                        ifStmt->get_elsePart()->accept( *this );
    523558                } // if
    524559        }
    525560
    526561        void CodeGenerator::visit( SwitchStmt *switchStmt ) {
    527                 output << "switch (" ;
    528                 switchStmt->get_condition()->accept(*this );
    529                 output << ") ";
     562                output << "switch ( " ;
     563                switchStmt->get_condition()->accept( *this );
     564                output << " ) ";
    530565               
    531566                output << "{" << std::endl;
     
    545580                } else {
    546581                        output << "case ";
    547                         caseStmt->get_condition()->accept(*this );
     582                        caseStmt->get_condition()->accept( *this );
    548583                } // if
    549584                output << ":\n";
     
    554589                for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
    555590                        output << indent << printLabels( (*i)->get_labels() )  ;
    556                         (*i)->accept(*this );
     591                        (*i)->accept( *this );
    557592                        output << endl;
    558593                }
     
    598633                else {
    599634                        output << "while (" ;
    600                         whileStmt->get_condition()->accept(*this );
     635                        whileStmt->get_condition()->accept( *this );
    601636                        output << ")";
    602637                } // if
     
    610645                if ( whileStmt->get_isDoWhile() ) {
    611646                        output << " while (" ;
    612                         whileStmt->get_condition()->accept(*this );
     647                        whileStmt->get_condition()->accept( *this );
    613648                        output << ");";
    614649                } // if
  • src/CodeGen/CodeGenerator.h

    re45215c rd60ccbf  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Jun 17 11:10:58 2015
    13 // Update Count     : 25
     12// Last Modified On : Wed Aug 12 14:27:14 2015
     13// Update Count     : 27
    1414//
    1515
     
    6565                virtual void visit( TupleExpr *tupleExpr );
    6666                virtual void visit( TypeExpr *typeExpr );
     67                virtual void visit( AsmExpr * );
    6768
    6869                //*** Statements
    6970                virtual void visit( CompoundStmt * );
    7071                virtual void visit( ExprStmt * );
     72                virtual void visit( AsmStmt * );
    7173                virtual void visit( IfStmt * );
    7274                virtual void visit( SwitchStmt * );
  • src/CodeGen/FixNames.h

    re45215c rd60ccbf  
    2020
    2121namespace CodeGen {
     22        /// mangles object and function names
    2223        void fixNames( std::list< Declaration* > translationUnit );
    2324} // namespace CodeGen
  • src/CodeGen/GenType.cc

    re45215c rd60ccbf  
    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 : Wed Jul 08 16:08:24 2015
    13 // Update Count     : 10
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jul  9 16:43:52 2015
     13// Update Count     : 13
    1414//
    1515
     
    9393                        os << "_Atomic ";
    9494                } // if
     95                if ( qualifiers.isAttribute ) {
     96                        os << "__attribute(( )) ";
     97                } // if
    9598                if ( dimension != 0 ) {
    9699                        CodeGenerator cg( os );
    97100                        dimension->accept( cg );
    98101                } else if ( isVarLen ) {
    99                         // no dimension expression on a VLA
    100                         // means it came in with the * token
     102                        // no dimension expression on a VLA means it came in with the * token
    101103                        os << "*";
    102104                } // if
     
    202204                        typeString = "_Atomic " + typeString;
    203205                } // if
     206                if ( type->get_isAttribute() ) {
     207                        typeString = "__attribute(( )) " + typeString;
     208                } // if
    204209        }
    205210} // namespace CodeGen
  • src/CodeGen/Generate.h

    re45215c rd60ccbf  
    2323
    2424namespace CodeGen {
     25        /// Generates code
    2526        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics );
    2627} // namespace CodeGen
  • src/ControlStruct/CaseRangeMutator.h

    re45215c rd60ccbf  
    2222
    2323namespace ControlStruct {
     24        /// expand case ranges and turn fallthru into a null statement
    2425        class CaseRangeMutator : public Mutator {
    2526          public:
  • src/ControlStruct/ChooseMutator.h

    re45215c rd60ccbf  
    2222
    2323namespace ControlStruct {
     24        /// transform choose statements into switch statements
    2425        class ChooseMutator : public Mutator {
    2526          public:
  • src/ControlStruct/LabelFixer.cc

    re45215c rd60ccbf  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Jul 08 12:36:46 2015
    13 // Update Count     : 145
     12// Last Modified On : Tue Jul 28 13:32:43 2015
     13// Update Count     : 156
    1414//
    1515
     
    2727
    2828namespace ControlStruct {
    29         LabelFixer::Entry::Entry( Statement *to, Statement *from ) : definition ( to ) {
    30                 if ( from != 0 ) {
    31                         UsageLoc loc; loc.stmt = from;
    32                         usage.push_back( loc );
    33                 }
    34         }
    35 
    36         LabelFixer::Entry::Entry( Statement *to, Expression *from ) : definition ( to ) {
    37                 if ( from != 0 ) {
    38                         UsageLoc loc; loc.expr = from;
    39                         usage.push_back( loc );
    40                 }
    41         }
    42 
    43 
    4429        bool LabelFixer::Entry::insideLoop() {
    4530                return ( dynamic_cast< ForStmt * > ( definition ) ||
    4631                        dynamic_cast< WhileStmt * > ( definition )  );
    47         }
    48 
    49         void LabelFixer::Entry::UsageLoc::accept( Visitor & visitor ) {
    50                 if ( dynamic_cast< Statement * >( stmt ) ) {
    51                         stmt->accept( visitor );
    52                 } else {
    53                         expr->accept( visitor );
    54                 }
    5532        }
    5633
     
    7754        // prune to at most one label definition for each statement
    7855        void LabelFixer::visit( Statement *stmt ) {
    79                 currentStatement = stmt;
    8056                std::list< Label > &labels = stmt->get_labels();
    8157
     
    8359                        // only remember one label for each statement
    8460                        Label current = setLabelsDef( labels, stmt );
    85                         labels.clear();
    86                         labels.push_front( current );
    8761                } // if
    8862        }
     
    130104                        }       else {
    131105                                // used previously, but undefined until now -> link with this entry
    132                                 Entry * oldEntry = labelTable[ *i ];
    133                                 e->add_uses( *oldEntry );
     106                                delete labelTable[ *i ];
    134107                                labelTable[ *i ] = e;
    135108                        } // if
     
    141114        }
    142115
    143         // Remember all uses of a label.
     116        // A label was used, add it ot the table if it isn't already there
    144117        template< typename UsageNode >
    145118        void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
    146119                assert( use != 0 );
    147120
    148                 if ( labelTable.find( orgValue ) != labelTable.end() ) {
    149                         // the label has been defined or used before
    150                         labelTable[ orgValue ]->add_use( use );
    151                 } else {
    152                         labelTable[ orgValue ] = new Entry( 0, use );
     121                // add label with an unknown origin
     122                if ( labelTable.find( orgValue ) == labelTable.end() ) {
     123                        labelTable[ orgValue ] = new Entry( 0 );
    153124                }
    154125        }
    155126
    156         class LabelGetter : public Visitor {
    157                 public:
    158                 LabelGetter( Label &label ) : label( label ) {}
    159 
    160                 virtual void visit( BranchStmt * branchStmt ) {
    161                         label = branchStmt->get_target();
    162                 }
    163 
    164                 virtual void visit( UntypedExpr * untyped ) {
    165                         NameExpr * name = dynamic_cast< NameExpr * >( untyped->get_function() );
    166                         assert( name );
    167                         assert( name->get_name() == "&&" );
    168                         NameExpr * arg = dynamic_cast< NameExpr * >( untyped->get_args().front() );
    169                         assert( arg );
    170                         label = arg->get_name();
    171                 }               
    172 
    173                 private:
    174                         Label &label;
    175         };
    176 
    177         class LabelSetter : public Visitor {
    178                 public:
    179                 LabelSetter( Label label ) : label( label ) {}
    180 
    181                 virtual void visit( BranchStmt * branchStmt ) {
    182                         branchStmt->set_target( label );
    183                 }
    184 
    185                 virtual void visit( UntypedExpr * untyped ) {
    186                         NameExpr * name = dynamic_cast< NameExpr * >( untyped->get_function() );
    187                         assert( name );
    188                         assert( name->get_name() == "&&" );
    189                         NameExpr * arg = dynamic_cast< NameExpr * >( untyped->get_args().front() );
    190                         assert( arg );
    191                         arg->set_name( label );
    192                 }
    193 
    194         private:
    195                 Label label;
    196         };
    197 
    198         // Ultimately builds a table that maps a label to its defining statement.
    199         // In the process,
     127        // Builds a table that maps a label to its defining statement.
    200128        std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticError ) {
    201                 std::map< Statement *, Entry * > def_us;
    202 
    203                 // combine the entries for all labels that target the same location
    204                 for ( std::map< Label, Entry *>::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
    205                         Entry *e = i->second;
    206 
    207                         if ( def_us.find ( e->get_definition() ) == def_us.end() ) {
    208                                 def_us[ e->get_definition() ] = e;
    209                         } else if ( e->used() ) {
    210                                 def_us[ e->get_definition() ]->add_uses( *e );
     129                std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
     130                for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
     131                        if ( ! i->second->defined() ) {
     132                                throw SemanticError( "Use of undefined label: " + i->first );
    211133                        }
    212                 }
    213 
    214                 // create a unique label for each target location.
    215                 for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); ++i ) {
    216                         Statement *to = (*i).first;
    217                         Entry * entry = (*i).second;
    218                         std::list< Entry::UsageLoc > &from = entry->get_uses();
    219 
    220                         // no label definition found
    221                         if ( to == 0 ) {
    222                                 Label undef;
    223                                 LabelGetter getLabel( undef );
    224                                 from.back().accept( getLabel );
    225                                 // Label undef = getLabel( from.back()->get_target() );
    226                                 throw SemanticError ( "'" + undef + "' label not defined");
    227                         } // if
    228 
    229                         // generate a new label, and attach it to its defining statement as the only label on that statement
    230                         Label finalLabel = generator->newLabel( to->get_labels().back() );
    231                         entry->set_label( finalLabel );
    232 
    233                         to->get_labels().clear();
    234                         to->get_labels().push_back( finalLabel );
    235 
    236                         // redirect each of the source branch statements to the new target label
    237                         for ( std::list< Entry::UsageLoc >::iterator j = from.begin(); j != from.end(); ++j ) {
    238                                 LabelSetter setLabel( finalLabel );
    239                                 (*j).accept( setLabel );
    240                                 // setLabel( *j, finalLabel );
    241 
    242                                 // BranchStmt *jump = *j;
    243                                 // assert( jump != 0 );
    244                                 // jump->set_target( finalLabel );
    245                         } // for
    246                 } // for
    247 
    248                 // create a table where each label maps to its defining statement
    249                 std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
    250                 for ( std::map< Statement *, Entry * >::iterator i = def_us.begin(); i != def_us.end(); ++i ) {
    251                         (*ret)[ (*i).second->get_label() ] = (*i).first;
     134                        (*ret)[ i->first ] = i->second->get_definition();
    252135                }
    253136
  • src/ControlStruct/LabelFixer.h

    re45215c rd60ccbf  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun 29 17:24:39 2015
    13 // Update Count     : 29
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Tue Jul 28 13:09:02 2015
     13// Update Count     : 31
    1414//
    1515
     
    2525
    2626namespace ControlStruct {
     27        /// normalizes label definitions and generates multi-level exit labels
    2728        class LabelFixer : public Visitor {
    2829                typedef Visitor Parent;
     
    6263                class Entry {
    6364                        public:
    64                         union UsageLoc {
    65                                 Statement * stmt;
    66                                 Expression * expr;
    67 
    68                                 void accept( Visitor &visitor );
    69                         };
    70 
    7165                        Entry( Statement *to ) : definition( to ) {}
    72                         Entry( Statement *to, Statement *from );
    73                         Entry( Statement *to, Expression *from );
    74                         bool used() { return ( usage.empty() ); }
    7566                        bool defined() { return ( definition != 0 ); }
    7667                        bool insideLoop();
     
    8273                        void set_definition( Statement *def ) { definition = def; }
    8374
    84                         std::list< UsageLoc > &get_uses() { return usage; }
    85                         void add_use( Statement *use ) {
    86                                 UsageLoc loc;
    87                                 loc.stmt = use;
    88                                 usage.push_back( loc );
    89                         }
    90                         void add_use( Expression *use ) {
    91                                 UsageLoc loc;
    92                                 loc.expr = use;
    93                                 usage.push_back( loc );                                 
    94                         }
    95 
    96                         void add_uses ( Entry &other ) { usage.insert( usage.end(), other.usage.begin(), other.usage.end() ); }
    9775                  private:
    9876                        Label label; 
    9977                        Statement *definition;
    100                         std::list<UsageLoc> usage;
    10178                };
    10279                 
    10380                std::map < Label, Entry *> labelTable;
    10481                LabelGenerator *generator;
    105                 Statement * currentStatement;
    10682        };
    10783} // namespace ControlStruct
  • src/ControlStruct/MLEMutator.cc

    re45215c rd60ccbf  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Rob Schluntz
    12 // Last Modified On : Sat Jun 27 10:56:14 2015
    13 // Update Count     : 174
    14 //
     12// Last Modified On : Mon Jul 20 13:58:35 2015
     13// Update Count     : 176
     14//
     15
     16// NOTE: There are two known subtle differences from the code that uC++
     17// generates for the same input
     18// -CFA puts the break label inside at the end of a switch, uC++ puts it after
     19// -CFA puts the break label after a block, uC++ puts it inside at the end
     20// we don't yet know if these differences are important, but if they are then
     21// the fix would go in this file, since this is where these labels are generated.
    1522
    1623#include <cassert>
  • src/ControlStruct/Mutate.h

    re45215c rd60ccbf  
    2323
    2424namespace ControlStruct {
     25        /// Desugars Cforall control structures
    2526        void mutate( std::list< Declaration* > translationUnit );
    2627} // namespace ControlStruct
  • src/GenPoly/Box.cc

    re45215c rd60ccbf  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Jun 24 16:19:07 2015
    13 // Update Count     : 10
     12// Last Modified On : Tue Aug 11 16:22:35 2015
     13// Update Count     : 89
    1414//
    1515
     
    7777                        Expression *handleIntrinsics( ApplicationExpr *appExpr );
    7878                        ObjectDecl *makeTemporary( Type *type );
    79  
     79
     80                        typedef std::map< std::string, FunctionDecl *> AdapterMap;
    8081                        std::map< std::string, DeclarationWithType *> assignOps;
    81                         typedef std::map< std::string, FunctionDecl *> AdapterMap;
    8282                        std::stack< AdapterMap > adapters;
    8383                        DeclarationWithType *retval;
     
    170170                }
    171171
     172                bool isPolyRet( FunctionType *function, const TyVarMap &otherTyVars ) {
     173                        std::string dummyString;
     174                        return isPolyRet( function, dummyString, otherTyVars );
     175                }
     176
    172177                Pass1::Pass1()
    173178                        : useRetval( false ), tempNamer( "_temp" ) {
     
    204209                }
    205210
    206                 DeclarationWithType *
    207                 Pass1::mutate( FunctionDecl *functionDecl ) {
     211                DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
    208212                        if ( functionDecl->get_statements() ) {
    209213                                TyVarMap oldtyVars = scopeTyVars;
     
    527531                }
    528532
    529                 void Pass1::passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars ) {
     533                void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
     534                        // collect a list of function types passed as parameters or implicit parameters (assertions)
    530535                        std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
    531536                        std::list< FunctionType *> functions;
     
    538543                                findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
    539544                        } // for
     545
     546                        // parameter function types for which an appropriate adapter has been generated.
     547                        // we cannot use the types after applying substitutions, since two different
     548                        // parameter types may be unified to the same type
    540549                        std::set< std::string > adaptersDone;
     550
    541551                        for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
     552                                FunctionType *originalFunction = (*funType)->clone();
    542553                                FunctionType *realFunction = (*funType)->clone();
    543                                 assert( env );
    544                                 env->apply( realFunction );
    545 
    546554                                std::string mangleName = SymTab::Mangler::mangle( realFunction );
     555
     556                                // only attempt to create an adapter or pass one as a parameter if we haven't
     557                                // already done so for this pre-substitution parameter function type.
    547558                                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
    548                                         AdapterMap & adapters = Pass1::adapters.top();
    549                                         AdapterMap::iterator adapter = adapters.find( mangleName );
     559                                        std::string mangleName = SymTab::Mangler::mangle( realFunction );
     560                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
     561                                       
     562                                        // apply substitution to type variables to figure out what the
     563                                        // adapter's type should look like
     564                                        assert( env );
     565                                        env->apply( realFunction );
     566                                        mangleName = SymTab::Mangler::mangle( realFunction );
    550567
    551568                                        if ( needsAdapter( realFunction, exprTyVars, true ) ) {
     
    554571                                                // create a new adapter.
    555572                                                appExpr->get_args().push_front( new NameExpr( makeAdapterName ( mangleName ) ) );
    556                                                 continue;
    557                                         } else if ( adapter == adapters.end() ) {
    558                                                 FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
    559                                                 adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl *>( mangleName, newAdapter ) );
    560                                                 stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
     573                                        } else {
     574                                                if ( isPolyRet( originalFunction, exprTyVars ) ) {
     575                                                        // if the return type involved polymorphic types, then
     576                                                        // the adapter will need to take those polymorphic types
     577                                                        // as pointers. Therefore, there can be two different
     578                                                        // functions with the same mangled name, so we need two adapter map
     579                                                        // stacks and also we need the mangled names to be different.
     580                                                        mangleName += "polyret_";
     581                                                }
     582
     583                                                AdapterMap & adapters = Pass1::adapters.top();
     584                                                AdapterMap::iterator adapter = adapters.find( mangleName );
     585                                                if ( adapter == adapters.end() ) {
     586                                                        // adapter has not been created yet in the current scope, so define it
     587                                                        FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
     588                                                        adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl *>( mangleName, newAdapter ) );
     589                                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
     590                                                } // if
     591                                                assert( adapter != adapters.end() );
     592
     593                                                // add the appropriate adapter as a parameter
     594                                                appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
    561595                                        } // if
    562                                         assert( adapter != adapters.end() );
    563                                         appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
    564                                         // appExpr->get_args().push_front( new NameExpr( makeAdapterName ( mangleName ) ) );
    565                                         adaptersDone.insert( adaptersDone.begin(), mangleName );
    566596                                } // if
    567597                        } // for
     
    881911
    882912                void Pass1::doBeginScope() {
     913                        // actually, maybe this could (should?) push
     914                        // a copy of the current map
    883915                        adapters.push(AdapterMap());
    884916                }
     
    10521084                        if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
    10531085                                if ( isPolyVal( objectDecl->get_type(), scopeTyVars ) ) {
     1086                                        // change initialization of a polymorphic value object
     1087                                        // to allocate storage with alloca
    10541088                                        TypeInstType *typeInst = dynamic_cast< TypeInstType *>( objectDecl->get_type() );
    10551089                                        assert( typeInst );
    10561090                                        UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) );
    10571091                                        alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) );
    1058                                         UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
    1059                                         assign->get_args().push_back( new VariableExpr( objectDecl ) );
    1060                                         assign->get_args().push_back( alloc );
    1061                                         stmtsToAddAfter.push_back( new ExprStmt( noLabels, assign ) );
     1092
     1093                                        delete objectDecl->get_init();
     1094
     1095                                        std::list<Expression*> designators;
     1096                                        objectDecl->set_init( new SingleInit( alloc, designators ) );
    10621097                                }
    10631098                        }
  • src/GenPoly/Box.h

    re45215c rd60ccbf  
    2121
    2222namespace GenPoly {
     23        /// boxes polymorphic function calls
    2324        void box( std::list< Declaration* >& translationUnit );
    2425} // namespace GenPoly
  • src/GenPoly/CopyParams.h

    re45215c rd60ccbf  
    2020
    2121namespace GenPoly {
     22        /// Clones by-value parameters which have been passed by-reference for polymorphism
    2223        void copyParams( std::list< Declaration* > &translationUnit );
    2324} // namespace GenPoly
  • src/GenPoly/Lvalue.h

    re45215c rd60ccbf  
    2222
    2323namespace GenPoly {
     24        /// replaces return type of `lvalue T` with `T*`, along with appropriate address-of and dereference operators
    2425        void convertLvalue( std::list< Declaration* >& translationUnit );
    2526} // namespace GenPoly
  • src/GenPoly/Specialize.h

    re45215c rd60ccbf  
    2222
    2323namespace GenPoly {
     24        /// generates thunks where needed
    2425        void convertSpecializations( std::list< Declaration* >& translationUnit );
    2526} // namespace GenPoly
  • src/InitTweak/RemoveInit.h

    re45215c rd60ccbf  
    2525
    2626namespace InitTweak {
     27        /// Adds assignment statements for polymorphic type initializers
    2728        void tweak( std::list< Declaration * > translationUnit );
    2829
  • src/Parser/DeclarationNode.cc

    re45215c rd60ccbf  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 12:34:05 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Jul 08 16:40:37 2015
    13 // Update Count     : 121
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Jul 14 14:46:32 2015
     13// Update Count     : 126
    1414//
    1515
     
    472472                if ( o->get_link() ) {
    473473                        set_link( o->get_link()->clone() );
    474                 }
    475 
     474                } // if
    476475        } // if
    477476        delete o;
  • src/Parser/ExpressionNode.cc

    re45215c rd60ccbf  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Jun 24 16:20:00 2015
    13 // Update Count     : 158
     12// Last Modified On : Wed Aug 12 13:51:11 2015
     13// Update Count     : 254
    1414//
    1515
     
    3232ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}
    3333
    34 ExpressionNode::ExpressionNode( const string *name_ ) : ParseNode( name_ ), argName( 0 ) {}
     34ExpressionNode::ExpressionNode( const string *name ) : ParseNode( name ), argName( 0 ) {}
    3535
    3636ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ) {
     
    4242}
    4343
    44 ExpressionNode * ExpressionNode::set_asArgName( const std::string *aName ) {
     44ExpressionNode * ExpressionNode::set_argName( const std::string *aName ) {
    4545        argName = new VarRefNode( aName );
    4646        return this;
    4747}
    4848
    49 ExpressionNode * ExpressionNode::set_asArgName( ExpressionNode *aDesignator ) {
     49ExpressionNode * ExpressionNode::set_argName( ExpressionNode *aDesignator ) {
    5050        argName = aDesignator;
    5151        return this;
     
    210210        assert( type == String );
    211211
    212         // "abc" "def" "ghi" => "abcdefghi", so remove new text from quotes and insert before last quote in old string.
     212        // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
    213213        value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) );
    214214       
     
    284284        os << "Variable: " << get_name();
    285285        os << endl;
     286}
     287
     288//##############################################################################
     289
     290DesignatorNode::DesignatorNode( ExpressionNode *expr, bool isArrayIndex ) : isArrayIndex( isArrayIndex ) {
     291        set_argName( expr );
     292        assert( get_argName() );
     293
     294        if ( ! isArrayIndex ) {
     295                if ( VarRefNode * var = dynamic_cast< VarRefNode * >( expr ) ) {
     296
     297                        stringstream ss( var->get_name() );
     298                        double value;
     299                        if ( ss >> value ) {
     300                                // this is a floating point constant. It MUST be
     301                                // ".0" or ".1", otherwise the program is invalid
     302                                if ( ! (var->get_name() == ".0" || var->get_name() == ".1") ) {
     303                                        throw SemanticError( "invalid designator name: " + var->get_name() );
     304                                } // if
     305                                var->set_name( var->get_name().substr(1) );
     306                        } // if
     307                } // if
     308        } // if
     309}
     310
     311DesignatorNode::DesignatorNode( const DesignatorNode &other ) : ExpressionNode( other ), isArrayIndex( other.isArrayIndex ) {
     312}
     313
     314class DesignatorFixer : public Mutator {
     315public:
     316        virtual Expression* mutate( NameExpr *nameExpr ) {
     317                if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
     318                        Constant val( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nameExpr->get_name() );
     319                        delete nameExpr;
     320                        return new ConstantExpr( val );
     321                }
     322                return nameExpr;
     323        }
     324};
     325
     326Expression *DesignatorNode::build() const {
     327        Expression * ret = get_argName()->build();
     328
     329        if ( isArrayIndex ) {
     330                // need to traverse entire structure and change any instances of 0 or 1 to
     331                // ConstantExpr
     332                DesignatorFixer fixer;
     333                ret = ret->acceptMutator( fixer );
     334        } // if
     335
     336        return ret;
     337}
     338
     339void DesignatorNode::printOneLine( std::ostream &os, int indent ) const {
     340        if ( get_argName() ) {
     341                if ( isArrayIndex ) {
     342                        os << "[";
     343                        get_argName()->printOneLine( os, indent );
     344                        os << "]";
     345                } else {
     346                        os << ".";
     347                        get_argName()->printOneLine( os, indent );
     348                }
     349        } // if
     350}
     351
     352void DesignatorNode::print( std::ostream &os, int indent ) const {
     353        if ( get_argName() ) {
     354                if ( isArrayIndex ) {
     355                        os << "[";
     356                        get_argName()->print( os, indent );
     357                        os << "]";
     358                } else {
     359                        os << ".";
     360                        get_argName()->print( os, indent );
     361                }
     362        } // if
    286363}
    287364
     
    330407//##############################################################################
    331408
    332 CompositeExprNode::CompositeExprNode( void ) : ExpressionNode(), function( 0 ), arguments( 0 ) {
     409CompositeExprNode::CompositeExprNode() : ExpressionNode(), function( 0 ), arguments( 0 ) {
    333410}
    334411
     
    541618                {
    542619                        assert( args.size() == 3);
    543                         std::list< Expression* >::const_iterator i = args.begin();
     620                        std::list< Expression * >::const_iterator i = args.begin();
    544621                        Expression *arg1 = notZeroExpr( *i++ );
    545622                        Expression *arg2 = *i++;
     
    552629                {
    553630                        assert( args.size() == 2);
    554                         std::list< Expression* >::const_iterator i = args.begin();
     631                        std::list< Expression * >::const_iterator i = args.begin();
    555632                        Expression *ret = *i++;
    556633                        while ( i != args.end() ) {
     
    617694                set_args( arg );
    618695}
     696
     697//##############################################################################
     698
     699Expression *AsmExprNode::build() const {
     700        return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)constraint->build(), operand->build() );
     701}
     702
     703void AsmExprNode::print( std::ostream &os, int indent ) const {
     704        os << string( indent, ' ' ) << "Assembler Expression:" << endl;
     705        if ( inout ) {
     706                os << string( indent, ' ' ) << "inout: " << std::endl;
     707                inout->print( os, indent + 2 );
     708        } // if
     709        if ( constraint ) {
     710                os << string( indent, ' ' ) << "constraint: " << std::endl;
     711                constraint->print( os, indent + 2 );
     712        } // if
     713        if ( operand ) {
     714                os << string( indent, ' ' ) << "operand: " << std::endl;
     715                operand->print( os, indent + 2 );
     716        } // if
     717}
     718
     719void AsmExprNode::printOneLine( std::ostream &os, int indent ) const {
     720        printDesignation( os );
     721        os << "( ";
     722        if ( inout ) inout->printOneLine( os, indent + 2 );
     723        os << ", ";
     724        if ( constraint ) constraint->printOneLine( os, indent + 2 );
     725        os << ", ";
     726        if ( operand ) operand->printOneLine( os, indent + 2 );
     727        os << ") ";
     728}
     729
     730//##############################################################################
     731
     732void LabelNode::print( std::ostream &os, int indent ) const {}
     733
     734void LabelNode::printOneLine( std::ostream &os, int indent ) const {}
    619735
    620736//##############################################################################
  • src/Parser/ParseNode.cc

    re45215c rd60ccbf  
    1010// Created On       : Sat May 16 13:26:29 2015
    1111// Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Jul 08 14:46:45 2015
    13 // Update Count     : 25
     12// Last Modified On : Wed Aug 12 13:26:00 2015
     13// Update Count     : 36
    1414//
    1515
     
    2020int ParseNode::indent_by = 4;
    2121
    22 ParseNode::ParseNode() : name( 0 ), next( 0 ) {};
    23 ParseNode::ParseNode( const string *name_ ) : name( name_ ), next( 0 ) {}
     22ParseNode::ParseNode() : next( 0 ) {};
     23ParseNode::ParseNode( const string *name ) : name( *name ), next( 0 ) { delete name; }
     24ParseNode::ParseNode( const string &name ) : name( name ), next( 0 ) { }
    2425
    2526ParseNode::~ParseNode() {
  • src/Parser/ParseNode.h

    re45215c rd60ccbf  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 13:28:16 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul  2 17:57:05 2015
    13 // Update Count     : 84
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Wed Aug 12 13:27:11 2015
     13// Update Count     : 172
    1414//
    1515
     
    4040        ParseNode();
    4141        ParseNode( const std::string * );
     42        ParseNode( const std::string & );  // for copy constructing subclasses
    4243        virtual ~ParseNode();
    4344
     
    4950        virtual ParseNode *clone() const { return 0; };
    5051
    51         const std::string &get_name() const { return *name; }
     52        const std::string &get_name() const { return name; }
     53        void set_name( const std::string &newValue ) { name = newValue; }
     54
    5255        virtual void print( std::ostream &, int indent = 0 ) const;
    5356        virtual void printList( std::ostream &, int indent = 0 ) const;
     
    5558        ParseNode &operator,( ParseNode &);
    5659  protected:
    57         const std::string *name;
     60        std::string name;
    5861        ParseNode *next;
    5962        static int indent_by;
     
    6770        ExpressionNode( const std::string * );
    6871        ExpressionNode( const ExpressionNode &other );
    69         virtual ~ExpressionNode() {} // cannot delete asArgName because it might be referenced elsewhere
     72        virtual ~ExpressionNode() { delete argName; } // cannot delete argName because it might be referenced elsewhere
    7073
    7174        virtual ExpressionNode *clone() const = 0;
     
    7477
    7578        ExpressionNode *get_argName() const { return argName; }
    76         ExpressionNode *set_asArgName( const std::string *aName );
    77         ExpressionNode *set_asArgName( ExpressionNode *aDesignator );
     79        ExpressionNode *set_argName( const std::string *aName );
     80        ExpressionNode *set_argName( ExpressionNode *aDesignator );
    7881
    7982        virtual void print( std::ostream &, int indent = 0) const = 0;
     
    105108
    106109        ConstantNode( Type, std::string * );
     110        ~ConstantNode() { delete &value; }
    107111
    108112        virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
     
    135139  private:
    136140        bool isLabel;
     141};
     142
     143class DesignatorNode : public ExpressionNode {
     144  public:
     145        DesignatorNode( ExpressionNode *expr, bool isArrayIndex = false );
     146        DesignatorNode( const DesignatorNode &other );
     147
     148        virtual Expression *build() const ;
     149        virtual DesignatorNode *clone() const { return new DesignatorNode( *this ); }
     150
     151        virtual void print( std::ostream &, int indent = 0 ) const;
     152        virtual void printOneLine( std::ostream &, int indent = 0 ) const;
     153  private:
     154        bool isArrayIndex;
    137155};
    138156
     
    183201};
    184202
    185 
    186203class CompositeExprNode : public ExpressionNode {
    187204  public:
     
    211228};
    212229
     230class AsmExprNode : public ExpressionNode {
     231  public:
     232        AsmExprNode();
     233        AsmExprNode( ExpressionNode *inout, ConstantNode *constraint, ExpressionNode *operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
     234        virtual ~AsmExprNode() { delete inout; delete constraint; delete operand; }
     235
     236        virtual AsmExprNode *clone() const { return new AsmExprNode( *this ); }
     237        virtual Expression *build() const;
     238
     239        virtual void print( std::ostream &, int indent = 0) const;
     240        virtual void printOneLine( std::ostream &, int indent = 0) const;
     241
     242        ExpressionNode *get_inout() const { return inout; };
     243        void set_inout( ExpressionNode *newValue ) { inout = newValue; }
     244
     245        ConstantNode *get_constraint() const { return constraint; };
     246        void set_constraint( ConstantNode *newValue ) { constraint = newValue; }
     247
     248        ExpressionNode *get_operand() const { return operand; };
     249        void set_operand( ExpressionNode *newValue ) { operand = newValue; }
     250  private:
     251        ExpressionNode *inout;
     252        ConstantNode *constraint;
     253        ExpressionNode *operand;
     254};
     255
     256class LabelNode : public ExpressionNode {
     257  public:
     258        virtual Expression *build() const { return NULL; }
     259        virtual LabelNode *clone() const { return new LabelNode( *this ); }
     260
     261        virtual void print( std::ostream &, int indent = 0) const;
     262        virtual void printOneLine( std::ostream &, int indent = 0) const;
     263
     264        const std::list< std::string > &get_labels() const { return labels; };
     265        void append_label( std::string *label ) { labels.push_back( *label ); delete label; }
     266  private:
     267        std::list< std::string > labels;
     268};
     269
    213270class CommaExprNode : public CompositeExprNode {
    214271  public:
     
    265322class DeclarationNode : public ParseNode {
    266323  public:
    267         enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Attribute };
     324        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic };
    268325        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
    269326        enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
     
    279336        static const char *typeClassName[];
    280337
    281         static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param,
    282                                                                                  StatementNode *body, bool newStyle = false );
     338        static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
    283339        static DeclarationNode *newQualifier( Qualifier );
    284340        static DeclarationNode *newStorageClass( StorageClass );
     
    352408        std::string name;
    353409        std::list< StorageClass > storageClasses;
     410        std::list< std::string > attributes;
    354411        ExpressionNode *bitfieldWidth;
    355412        InitializerNode *initializer;
     
    358415
    359416        static UniqueName anonymous;
    360 };
     417}; // DeclarationNode
    361418
    362419class StatementNode : public ParseNode {
     
    370427
    371428        StatementNode();
    372         StatementNode( const std::string * );
    373         StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 );
    374         StatementNode( Type, std::string *target );
     429        StatementNode( const std::string *name );
     430        StatementNode( Type t, ExpressionNode *control = 0, StatementNode *block = 0 );
     431        StatementNode( Type t, std::string *target );
    375432        StatementNode( DeclarationNode *decl );
    376433
    377 
    378434        ~StatementNode();
    379435
    380436        static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
    381437
    382         void set_control( ExpressionNode * );
    383         StatementNode * set_block( StatementNode * );
    384 
    385         ExpressionNode *get_control() const ;
    386         StatementNode *get_block() const;
    387         StatementNode::Type get_type() const;
     438        StatementNode *set_block( StatementNode *b ) {  block = b; return this; }
     439        StatementNode *get_block() const { return block; }
     440
     441        void set_control( ExpressionNode *c ) { control = c; }
     442        ExpressionNode *get_control() const { return control; }
     443
     444        StatementNode::Type get_type() const { return type; }
    388445
    389446        StatementNode *add_label( const std::string * );
    390         std::list<std::string> *get_labels() const;
     447        const std::list<std::string> &get_labels() const { return labels; }
    391448
    392449        void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
     
    400457
    401458        void print( std::ostream &, int indent = 0) const;
    402 
    403459        virtual StatementNode *clone() const;
    404 
    405460        virtual Statement *build() const;
    406461  private:
     
    409464        ExpressionNode *control;
    410465        StatementNode *block;
    411         std::list<std::string> *labels;
     466        std::list<std::string> labels;
    412467        std::string *target;                            // target label for jump statements
    413468        DeclarationNode *decl;
    414 
    415469        bool isCatchRest;
    416 };
     470}; // StatementNode
    417471
    418472class CompoundStmtNode : public StatementNode {
     
    426480
    427481        void print( std::ostream &, int indent = 0 ) const;
    428 
    429482        virtual Statement *build() const;
    430483  private:
     
    432485};
    433486
     487class AsmStmtNode : public StatementNode {
     488  public:
     489        AsmStmtNode( Type, bool voltile, ConstantNode *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ConstantNode *clobber = 0, LabelNode *gotolabels = 0 );
     490        ~AsmStmtNode();
     491
     492        void print( std::ostream &, int indent = 0 ) const;
     493        Statement *build() const;
     494  private:
     495        bool voltile;
     496        ConstantNode *instruction;
     497        ExpressionNode *output, *input;
     498        ConstantNode *clobber;
     499        std::list<std::string> gotolabels;
     500};
     501
    434502class NullStmtNode : public CompoundStmtNode {
    435503  public:
    436504        Statement *build() const;
    437         void print( std::ostream &, int indent = 0) const;
     505        void print( std::ostream &, int indent = 0 ) const;
    438506};
    439507
     
    461529        InitializerNode *kids;
    462530};
    463 
    464 
    465531
    466532template< typename SynTreeType, typename NodeType >
  • src/Parser/StatementNode.cc

    re45215c rd60ccbf  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 14:59:41 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Tue Jul 14 12:20:44 2015
    13 // Update Count     : 21
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Jul 30 14:39:39 2015
     13// Update Count     : 130
    1414//
    1515
     
    3636StatementNode::StatementNode() : ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
    3737
    38 StatementNode::StatementNode( const string *name_ ) : ParseNode( name_ ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
     38StatementNode::StatementNode( const string *name ) : ParseNode( name ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
    3939
    4040StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), isCatchRest ( false ) {
     
    6060}
    6161
    62 StatementNode::StatementNode( Type t, ExpressionNode *ctrl_label, StatementNode *block_ ) :
    63                 type( t ), control( ctrl_label ), block( block_), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {
    64         if ( t == Default )
    65                 control = 0;
     62StatementNode::StatementNode( Type t, ExpressionNode *ctrl_label, StatementNode *block ) : type( t ), control( ctrl_label ), block( block ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {
     63        this->control = ( t == Default ) ? 0 : control;
    6664}
    6765
    68 StatementNode::StatementNode( Type t, string *_target ) :
    69                 type( t ), control( 0 ), block( 0 ), labels( 0 ), target(_target ), decl( 0 ), isCatchRest ( false ) {}
     66StatementNode::StatementNode( Type t, string *target ) : type( t ), control( 0 ), block( 0 ), labels( 0 ), target( target ), decl( 0 ), isCatchRest ( false ) {}
    7067
    7168StatementNode::~StatementNode() {
    7269        delete control;
    7370        delete block;
    74         delete labels;
    7571        delete target;
    7672        delete decl;
     
    10399}
    104100
    105 void StatementNode::set_control( ExpressionNode *c ) {
    106         control = c;
    107 }
    108 
    109 StatementNode * StatementNode::set_block( StatementNode *b ) {
    110         block = b;
    111 
    112         return this;
    113 }
    114 
    115 ExpressionNode *StatementNode::get_control() const {
    116         return control;
    117 }
    118 
    119 StatementNode *StatementNode::get_block() const {
    120         return block;
    121 }
    122 
    123 StatementNode::Type StatementNode::get_type() const {
    124         return type;
    125 }
    126 
    127101StatementNode *StatementNode::add_label( const std::string *l ) {
    128102        if ( l != 0 ) {
    129                 if ( labels == 0 )
    130                         labels = new std::list<std::string>();
    131 
    132                 labels->push_front(*l );
     103                labels.push_front( *l );
    133104                delete l;
    134105        } // if
    135106        return this;
    136107}
    137 
    138 std::list<std::string> *StatementNode::get_labels() const { return labels; }
    139108
    140109StatementNode *StatementNode::add_controlexp( ExpressionNode *e ) {
    141110        if ( control && e )
    142111                control->add_to_list( e ); // xxx - check this
    143 
    144112        return this;
    145113}
     
    170138
    171139void StatementNode::print( std::ostream &os, int indent ) const {
    172         if ( labels != 0 ) {
    173                 if ( ! labels->empty()) {
    174                         std::list<std::string>::const_iterator i;
    175 
    176                         os << string( indent, ' ' );
    177                         for ( i = labels->begin(); i != labels->end(); i++ )
    178                                 os << *i << ":";
    179                         os << endl;
    180                 } // if
     140        if ( ! labels.empty() ) {
     141                std::list<std::string>::const_iterator i;
     142
     143                os << string( indent, ' ' );
     144                for ( i = labels.begin(); i != labels.end(); i++ )
     145                        os << *i << ":";
     146                os << endl;
    181147        } // if
    182148
     
    198164                        if ( decl ) {
    199165                                os << string( indent + ParseNode::indent_by, ' ' ) << "Declaration: " << endl;
    200                                 decl->print( os, indent + 2*ParseNode::indent_by );
     166                                decl->print( os, indent + 2 * ParseNode::indent_by );
    201167                        } else if ( isCatchRest ) {
    202168                                os << string( indent + ParseNode::indent_by, ' ' ) << "Catches the rest " << endl;
     
    206172                } // if
    207173                if ( control ) {
    208                         os << string( indent + ParseNode::indent_by, ' ' ) << "Expression: " << endl;
    209                         control->printList( os, indent + 2*ParseNode::indent_by );
     174                        os << string( indent + ParseNode::indent_by, ' ' ) << "Control: " << endl;
     175                        control->printList( os, indent + 2 * ParseNode::indent_by );
    210176                } // if
    211177                if ( block ) {
    212178                        os << string( indent + ParseNode::indent_by, ' ' ) << "Branches of execution: " << endl;
    213                         block->printList( os, indent + 2*ParseNode::indent_by ); 
     179                        block->printList( os, indent + 2 * ParseNode::indent_by ); 
    214180                } // if
    215181                if ( target ) {
     
    225191        std::list<Label> labs;
    226192
    227         if ( labels != 0 ) {
     193        if ( ! labels.empty() ) {
    228194                std::back_insert_iterator< std::list<Label> > lab_it( labs );
    229                 copy( labels->begin(), labels->end(), lab_it );
     195                copy( labels.begin(), labels.end(), lab_it );
    230196        } // if
    231197
     
    274240                        if ( ctl->get_init() != 0 ) {
    275241                                buildList( ctl->get_init(), init );
    276                         }
     242                        } // if
    277243
    278244                        Expression *cond = 0;
     
    341307                        return new FinallyStmt( labs, block );
    342308                }
     309          case Asm:
     310                assert( false );
    343311          default:
    344312                // shouldn't be here
     
    346314        } // switch
    347315}
     316
    348317
    349318CompoundStmtNode::CompoundStmtNode() : first( 0 ), last( 0 ) {}
     
    378347Statement *CompoundStmtNode::build() const {
    379348        std::list<Label> labs;
    380         std::list<std::string> *labels = get_labels();
    381 
    382         if ( labels != 0 ) {
     349        const std::list<std::string> &labels = get_labels();
     350
     351        if ( ! labels.empty() ) {
    383352                std::back_insert_iterator< std::list<Label> > lab_it( labs );
    384                 copy( labels->begin(), labels->end(), lab_it );
     353                copy( labels.begin(), labels.end(), lab_it );
    385354        } // if
    386355
     
    389358        return cs;
    390359}
     360
     361
     362AsmStmtNode::AsmStmtNode( Type t, bool voltile, ConstantNode *instruction, ExpressionNode *output, ExpressionNode *input, ConstantNode *clobber, LabelNode *gotolabels ) :
     363        StatementNode( t ), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ) {
     364        if ( gotolabels ) {
     365                this->gotolabels = gotolabels->get_labels();
     366                delete gotolabels;
     367        } // if
     368}
     369
     370AsmStmtNode::~AsmStmtNode() {
     371        delete instruction; delete output; delete input; delete clobber;
     372}
     373
     374void AsmStmtNode::print( std::ostream &os, int indent ) const {
     375        StatementNode::print( os, indent );                                     // print statement labels
     376        os << string( indent + ParseNode::indent_by, ' ' ) << "volatile:" << voltile << endl;
     377        if ( instruction ) {
     378                os << string( indent + ParseNode::indent_by, ' ' ) << "Instruction:" << endl;
     379                instruction->printList( os, indent + 2 * ParseNode::indent_by );
     380        } // if
     381        if ( output ) {
     382                os << string( indent + ParseNode::indent_by, ' ' ) << "Output:" << endl;
     383                output->printList( os, indent + 2 * ParseNode::indent_by );
     384        } // if
     385        if ( input ) {
     386                os << string( indent + ParseNode::indent_by, ' ' ) << "Input:" << endl;
     387                input->printList( os, indent + 2 * ParseNode::indent_by );
     388        } // if
     389        if ( clobber ) {
     390                os << string( indent + ParseNode::indent_by, ' ' ) << "Clobber:" << endl;
     391                clobber->printList( os, indent + 2 * ParseNode::indent_by );
     392        } // if
     393        if ( ! gotolabels.empty() ) {
     394                os << string( indent + ParseNode::indent_by, ' ' ) << "Goto Labels:" << endl;
     395                os << string( indent + 2 * ParseNode::indent_by, ' ' );
     396                for ( std::list<std::string>::const_iterator i = gotolabels.begin();; ) {
     397                        os << *i;
     398                        i++;
     399                  if ( i == gotolabels.end() ) break;
     400                        os << ", ";
     401                }
     402                os << endl;
     403        } // if
     404}
     405
     406Statement *AsmStmtNode::build() const {
     407        std::list<Label> labs;
     408
     409        if ( ! get_labels().empty() ) {
     410                std::back_insert_iterator< std::list<Label> > lab_it( labs );
     411                copy( get_labels().begin(), get_labels().end(), lab_it );
     412        } // if
     413
     414        std::list< Expression * > out, in;
     415        std::list< ConstantExpr * > clob;
     416        buildList( output, out );
     417        buildList( input, in );
     418        buildList( clobber, clob );
     419        std::list< Label > gotolabs = gotolabels;
     420        return new AsmStmt( labs, voltile, (ConstantExpr *)maybeBuild< Expression >( instruction ), out, in, clob, gotolabs );
     421}
     422
    391423
    392424void NullStmtNode::print( ostream &os, int indent ) const {
  • src/Parser/TypeData.cc

    re45215c rd60ccbf  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jun 26 07:30:06 2015
    13 // Update Count     : 26
     12// Last Modified On : Tue Jul 14 14:57:23 2015
     13// Update Count     : 32
    1414//
    1515
     
    397397                } // if
    398398                break;
     399          default:
     400                os << "internal error: TypeData::print " << kind  << endl;
     401                assert( false );
    399402        } // switch
    400403}
     
    474477                return buildVariable();
    475478        } else {
    476                 if ( isInline || isNoreturn ) {
    477                         throw SemanticError( "invalid inline or _Noreturn specification in declaration of ", this );
    478                 } else {
    479                         return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init );
    480                 } // if
     479                return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init, isInline, isNoreturn );
    481480        } // if
    482481        return 0;
     
    536535                  case DeclarationNode::Atomic:
    537536                        q.isAtomic = true;
    538                         break;
    539                   case DeclarationNode::Attribute:
    540                         q.isAttribute = true;
    541537                        break;
    542538                } // switch
  • src/Parser/parser.cc

    re45215c rd60ccbf  
    8080#include "lex.h"
    8181#include "ParseNode.h"
     82#include "TypeData.h"
    8283#include "LinkageSpec.h"
    8384
     
    8990
    9091/* Line 268 of yacc.c  */
    91 #line 92 "Parser/parser.cc"
     92#line 93 "Parser/parser.cc"
    9293
    9394/* Enabling traces.  */
     
    324325
    325326/* Line 293 of yacc.c  */
    326 #line 107 "parser.yy"
     327#line 108 "parser.yy"
    327328
    328329        Token tok;
     
    334335        StatementNode *sn;
    335336        ConstantNode *constant;
     337        LabelNode *label;
    336338        InitializerNode *in;
     339        bool flag;
    337340
    338341
    339342
    340343/* Line 293 of yacc.c  */
    341 #line 342 "Parser/parser.cc"
     344#line 345 "Parser/parser.cc"
    342345} YYSTYPE;
    343346# define YYSTYPE_IS_TRIVIAL 1
     
    351354
    352355/* Line 343 of yacc.c  */
    353 #line 354 "Parser/parser.cc"
     356#line 357 "Parser/parser.cc"
    354357
    355358#ifdef short
     
    570573#define YYFINAL  246
    571574/* YYLAST -- Last index in YYTABLE.  */
    572 #define YYLAST   11363
     575#define YYLAST   11329
    573576
    574577/* YYNTOKENS -- Number of terminals.  */
    575578#define YYNTOKENS  125
    576579/* YYNNTS -- Number of nonterminals.  */
    577 #define YYNNTS  236
     580#define YYNNTS  238
    578581/* YYNRULES -- Number of rules.  */
    579 #define YYNRULES  732
     582#define YYNRULES  740
    580583/* YYNRULES -- Number of states.  */
    581 #define YYNSTATES  1505
     584#define YYNSTATES  1530
    582585
    583586/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
     
    636639       0,     0,     3,     4,     5,     7,     9,    11,    13,    15,
    637640      17,    19,    21,    23,    25,    27,    29,    32,    34,    36,
    638       38,    40,    44,    48,    50,    57,    62,    66,    74,    78,
    639       86,    89,    92,   100,   102,   106,   107,   109,   113,   121,
    640      131,   133,   137,   139,   143,   151,   155,   163,   165,   168,
     641      40,    44,    46,    53,    58,    62,    70,    74,    82,    85,
     642      88,    96,    98,   102,   103,   105,   109,   117,   127,   129,
     643     133,   135,   139,   147,   151,   159,   161,   163,   165,   168,
    641644     171,   174,   177,   180,   183,   186,   191,   193,   198,   203,
    642645     206,   211,   214,   216,   218,   220,   222,   224,   229,   234,
     
    655658     650,   654,   657,   661,   665,   670,   672,   678,   685,   695,
    656659     706,   709,   711,   714,   717,   720,   722,   729,   738,   749,
    657      762,   763,   765,   767,   771,   776,   778,   782,   784,   786,
    658      788,   792,   794,   796,   798,   802,   803,   805,   809,   814,
    659      816,   820,   822,   824,   828,   832,   836,   840,   844,   847,
    660      851,   858,   862,   866,   871,   873,   876,   879,   883,   889,
    661      898,   906,   914,   920,   930,   933,   936,   942,   946,   952,
    662      957,   961,   966,   971,   979,   983,   987,   991,   995,  1000,
    663     1007,  1009,  1011,  1013,  1015,  1017,  1019,  1021,  1023,  1024,
    664     1026,  1028,  1031,  1033,  1035,  1037,  1039,  1041,  1043,  1045,
    665     1046,  1052,  1054,  1057,  1061,  1063,  1066,  1068,  1070,  1072,
    666     1074,  1076,  1078,  1080,  1082,  1084,  1086,  1088,  1090,  1092,
    667     1094,  1096,  1098,  1100,  1102,  1104,  1106,  1108,  1110,  1113,
    668     1116,  1120,  1124,  1126,  1130,  1132,  1135,  1138,  1141,  1146,
    669     1151,  1156,  1161,  1163,  1166,  1169,  1173,  1175,  1178,  1181,
    670     1183,  1186,  1189,  1193,  1195,  1198,  1201,  1203,  1205,  1210,
    671     1213,  1219,  1227,  1230,  1233,  1236,  1238,  1241,  1244,  1248,
    672     1251,  1255,  1257,  1260,  1264,  1267,  1270,  1275,  1276,  1278,
    673     1281,  1284,  1286,  1287,  1289,  1292,  1295,  1301,  1308,  1311,
    674     1314,  1319,  1320,  1323,  1324,  1326,  1328,  1330,  1336,  1342,
    675     1348,  1350,  1356,  1362,  1372,  1374,  1380,  1381,  1383,  1385,
    676     1391,  1393,  1395,  1401,  1407,  1409,  1413,  1417,  1422,  1424,
    677     1426,  1428,  1430,  1433,  1435,  1439,  1443,  1445,  1448,  1450,
    678     1454,  1456,  1458,  1460,  1462,  1464,  1466,  1468,  1470,  1472,
    679     1474,  1476,  1479,  1481,  1483,  1485,  1488,  1489,  1492,  1494,
    680     1499,  1501,  1504,  1508,  1513,  1516,  1519,  1521,  1524,  1527,
    681     1533,  1539,  1547,  1554,  1556,  1559,  1562,  1566,  1568,  1571,
    682     1574,  1579,  1582,  1587,  1588,  1593,  1596,  1598,  1600,  1602,
    683     1603,  1606,  1612,  1618,  1632,  1634,  1636,  1640,  1644,  1647,
    684     1651,  1655,  1658,  1663,  1665,  1672,  1682,  1683,  1695,  1697,
    685     1701,  1705,  1709,  1711,  1713,  1719,  1722,  1728,  1729,  1731,
    686     1733,  1737,  1738,  1740,  1742,  1744,  1746,  1747,  1754,  1757,
    687     1759,  1762,  1767,  1770,  1774,  1778,  1782,  1787,  1793,  1799,
    688     1805,  1812,  1814,  1816,  1818,  1822,  1823,  1829,  1830,  1832,
    689     1834,  1837,  1844,  1846,  1850,  1851,  1853,  1858,  1860,  1862,
    690     1864,  1866,  1869,  1871,  1874,  1877,  1879,  1883,  1886,  1890,
    691     1894,  1897,  1902,  1907,  1911,  1920,  1924,  1927,  1929,  1932,
    692     1939,  1948,  1952,  1955,  1959,  1963,  1968,  1973,  1977,  1979,
    693     1981,  1983,  1988,  1995,  1999,  2002,  2006,  2010,  2015,  2020,
    694     2024,  2027,  2029,  2032,  2035,  2037,  2041,  2044,  2048,  2052,
    695     2055,  2060,  2065,  2069,  2076,  2085,  2089,  2092,  2094,  2097,
    696     2100,  2103,  2107,  2111,  2114,  2119,  2124,  2128,  2135,  2144,
    697     2148,  2151,  2153,  2156,  2159,  2161,  2163,  2166,  2170,  2174,
    698     2177,  2182,  2189,  2198,  2200,  2203,  2206,  2208,  2211,  2214,
    699     2218,  2222,  2224,  2229,  2234,  2238,  2244,  2253,  2257,  2260,
    700     2264,  2266,  2272,  2278,  2285,  2292,  2294,  2297,  2300,  2302,
    701     2305,  2308,  2312,  2316,  2318,  2323,  2328,  2332,  2338,  2347,
    702     2351,  2353,  2356,  2358,  2361,  2368,  2374,  2381,  2389,  2397,
    703     2399,  2402,  2405,  2407,  2410,  2413,  2417,  2421,  2423,  2428,
    704     2433,  2437,  2446,  2450,  2452,  2454,  2457,  2459,  2461,  2464,
    705     2468,  2471,  2475,  2478,  2482,  2486,  2489,  2494,  2498,  2501,
    706     2505,  2508,  2513,  2517,  2520,  2527,  2534,  2541,  2549,  2551,
    707     2554,  2556,  2558,  2560,  2563,  2567,  2570,  2574,  2577,  2581,
    708     2585,  2590,  2593,  2597,  2602,  2605,  2611,  2617,  2624,  2631,
    709     2632,  2634,  2635
     660     762,   777,   778,   780,   781,   783,   785,   789,   794,   802,
     661     803,   805,   809,   811,   815,   817,   819,   821,   825,   827,
     662     829,   831,   835,   836,   838,   842,   847,   849,   853,   855,
     663     857,   861,   865,   869,   873,   877,   880,   884,   891,   895,
     664     899,   904,   906,   909,   912,   916,   922,   931,   939,   947,
     665     953,   963,   966,   969,   975,   979,   985,   990,   994,   999,
     666    1004,  1012,  1016,  1020,  1024,  1028,  1033,  1040,  1042,  1044,
     667    1046,  1048,  1050,  1052,  1054,  1056,  1057,  1059,  1061,  1064,
     668    1066,  1068,  1070,  1072,  1074,  1076,  1078,  1079,  1085,  1087,
     669    1090,  1094,  1096,  1099,  1101,  1103,  1105,  1107,  1109,  1111,
     670    1113,  1115,  1117,  1119,  1121,  1123,  1125,  1127,  1129,  1131,
     671    1133,  1135,  1137,  1139,  1141,  1143,  1146,  1149,  1153,  1157,
     672    1159,  1163,  1165,  1168,  1171,  1174,  1179,  1184,  1189,  1194,
     673    1196,  1199,  1202,  1206,  1208,  1211,  1214,  1216,  1219,  1222,
     674    1226,  1228,  1231,  1234,  1236,  1238,  1243,  1246,  1252,  1260,
     675    1263,  1266,  1269,  1271,  1274,  1277,  1281,  1284,  1288,  1290,
     676    1293,  1297,  1300,  1303,  1308,  1309,  1311,  1314,  1317,  1319,
     677    1320,  1322,  1325,  1328,  1334,  1341,  1344,  1347,  1352,  1353,
     678    1356,  1357,  1359,  1361,  1363,  1369,  1375,  1381,  1383,  1389,
     679    1395,  1405,  1407,  1413,  1414,  1416,  1418,  1424,  1426,  1428,
     680    1434,  1440,  1442,  1446,  1450,  1455,  1457,  1459,  1461,  1463,
     681    1466,  1468,  1472,  1476,  1478,  1481,  1483,  1487,  1489,  1491,
     682    1493,  1495,  1497,  1499,  1501,  1503,  1505,  1507,  1509,  1512,
     683    1514,  1516,  1518,  1521,  1522,  1525,  1527,  1532,  1534,  1537,
     684    1541,  1546,  1549,  1552,  1554,  1557,  1559,  1562,  1568,  1574,
     685    1582,  1589,  1591,  1594,  1597,  1601,  1603,  1606,  1609,  1614,
     686    1617,  1622,  1623,  1628,  1631,  1633,  1635,  1637,  1638,  1641,
     687    1647,  1653,  1667,  1669,  1671,  1675,  1679,  1682,  1686,  1690,
     688    1693,  1698,  1700,  1707,  1717,  1718,  1730,  1732,  1736,  1740,
     689    1744,  1746,  1748,  1754,  1757,  1763,  1764,  1766,  1768,  1772,
     690    1773,  1775,  1777,  1779,  1781,  1782,  1789,  1792,  1794,  1797,
     691    1802,  1805,  1809,  1813,  1817,  1822,  1828,  1834,  1840,  1847,
     692    1849,  1851,  1853,  1857,  1858,  1864,  1865,  1867,  1869,  1872,
     693    1879,  1881,  1885,  1886,  1888,  1893,  1895,  1897,  1899,  1901,
     694    1904,  1906,  1909,  1912,  1914,  1918,  1921,  1925,  1929,  1932,
     695    1937,  1942,  1946,  1955,  1959,  1962,  1964,  1967,  1974,  1983,
     696    1987,  1990,  1994,  1998,  2003,  2008,  2012,  2014,  2016,  2018,
     697    2023,  2030,  2034,  2037,  2041,  2045,  2050,  2055,  2059,  2062,
     698    2064,  2067,  2070,  2072,  2076,  2079,  2083,  2087,  2090,  2095,
     699    2100,  2104,  2111,  2120,  2124,  2127,  2129,  2132,  2135,  2138,
     700    2142,  2146,  2149,  2154,  2159,  2163,  2170,  2179,  2183,  2186,
     701    2188,  2191,  2194,  2196,  2198,  2201,  2205,  2209,  2212,  2217,
     702    2224,  2233,  2235,  2238,  2241,  2243,  2246,  2249,  2253,  2257,
     703    2259,  2264,  2269,  2273,  2279,  2288,  2292,  2295,  2299,  2301,
     704    2307,  2313,  2320,  2327,  2329,  2332,  2335,  2337,  2340,  2343,
     705    2347,  2351,  2353,  2358,  2363,  2367,  2373,  2382,  2386,  2388,
     706    2391,  2393,  2396,  2403,  2409,  2416,  2424,  2432,  2434,  2437,
     707    2440,  2442,  2445,  2448,  2452,  2456,  2458,  2463,  2468,  2472,
     708    2481,  2485,  2487,  2489,  2492,  2494,  2496,  2499,  2503,  2506,
     709    2510,  2513,  2517,  2521,  2524,  2529,  2533,  2536,  2540,  2543,
     710    2548,  2552,  2555,  2562,  2569,  2576,  2584,  2586,  2589,  2591,
     711    2593,  2595,  2598,  2602,  2605,  2609,  2612,  2616,  2620,  2625,
     712    2628,  2632,  2637,  2640,  2646,  2652,  2659,  2666,  2667,  2669,
     713    2670
    710714};
    711715
     
    713717static const yytype_int16 yyrhs[] =
    714718{
    715      289,     0,    -1,    -1,    -1,    72,    -1,    73,    -1,    74,
     719     291,     0,    -1,    -1,    -1,    72,    -1,    73,    -1,    74,
    716720      -1,    65,    -1,    69,    -1,   132,    -1,    65,    -1,    69,
    717721      -1,    65,    -1,    76,    -1,    77,    -1,    75,    -1,   133,
    718       75,    -1,    65,    -1,   132,    -1,   128,    -1,   133,    -1,
    719      101,   160,   102,    -1,   101,   164,   102,    -1,   134,    -1,
    720      135,   103,   126,   155,   127,   104,    -1,   135,   101,   136,
    721      102,    -1,   135,   105,   131,    -1,   135,   105,   103,   126,
    722      138,   127,   104,    -1,   135,    78,   131,    -1,   135,    78,
    723      103,   126,   138,   127,   104,    -1,   135,    79,    -1,   135,
    724       80,    -1,   101,   262,   102,   106,   266,   359,   107,    -1,
    725      137,    -1,   136,   108,   137,    -1,    -1,   155,    -1,   131,
    726      109,   155,    -1,   103,   126,   155,   127,   104,   109,   155,
    727       -1,   103,   126,   155,   108,   158,   127,   104,   109,   155,
    728       -1,   139,    -1,   138,   108,   139,    -1,   131,    -1,   131,
    729      105,   139,    -1,   131,   105,   103,   126,   138,   127,   104,
    730       -1,   131,    78,   139,    -1,   131,    78,   103,   126,   138,
    731      127,   104,    -1,   135,    -1,    79,   140,    -1,    80,   140,
     722      75,    -1,    65,    -1,   132,    -1,   101,   160,   102,    -1,
     723     101,   164,   102,    -1,   134,    -1,   135,   103,   126,   155,
     724     127,   104,    -1,   135,   101,   136,   102,    -1,   135,   105,
     725     131,    -1,   135,   105,   103,   126,   138,   127,   104,    -1,
     726     135,    78,   131,    -1,   135,    78,   103,   126,   138,   127,
     727     104,    -1,   135,    79,    -1,   135,    80,    -1,   101,   264,
     728     102,   106,   268,   361,   107,    -1,   137,    -1,   136,   108,
     729     137,    -1,    -1,   155,    -1,   131,   109,   155,    -1,   103,
     730     126,   155,   127,   104,   109,   155,    -1,   103,   126,   155,
     731     108,   158,   127,   104,   109,   155,    -1,   139,    -1,   138,
     732     108,   139,    -1,   131,    -1,   131,   105,   139,    -1,   131,
     733     105,   103,   126,   138,   127,   104,    -1,   131,    78,   139,
     734      -1,   131,    78,   103,   126,   138,   127,   104,    -1,   135,
     735      -1,   128,    -1,   133,    -1,    79,   140,    -1,    80,   140,
    732736      -1,    38,   142,    -1,   141,   142,    -1,   110,   142,    -1,
    733      111,   142,    -1,    36,   140,    -1,    36,   101,   262,   102,
    734       -1,    69,    -1,    69,   101,   263,   102,    -1,    69,   101,
    735      137,   102,    -1,    59,   140,    -1,    59,   101,   262,   102,
     737     111,   142,    -1,    36,   140,    -1,    36,   101,   264,   102,
     738      -1,    69,    -1,    69,   101,   265,   102,    -1,    69,   101,
     739     137,   102,    -1,    59,   140,    -1,    59,   101,   264,   102,
    736740      -1,    87,   131,    -1,   112,    -1,   113,    -1,   114,    -1,
    737      115,    -1,   140,    -1,   101,   262,   102,   142,    -1,   101,
    738      262,   102,   157,    -1,   142,    -1,   143,   111,   142,    -1,
     741     115,    -1,   140,    -1,   101,   264,   102,   142,    -1,   101,
     742     264,   102,   157,    -1,   142,    -1,   143,   111,   142,    -1,
    739743     143,   116,   142,    -1,   143,   117,   142,    -1,   143,    -1,
    740744     144,   113,   143,    -1,   144,   114,   143,    -1,   144,    -1,
     
    748752     160,   109,   153,    -1,   152,   122,   109,   153,    -1,   152,
    749753     122,   160,   109,   157,    -1,   153,    -1,   153,    -1,   140,
    750      123,   155,    -1,   140,   159,   155,    -1,   157,   360,    -1,
     754     123,   155,    -1,   140,   159,   155,    -1,   157,   362,    -1,
    751755      -1,   155,    -1,   103,   104,    -1,   103,   126,   155,   127,
    752756     104,    -1,   103,   126,   108,   158,   127,   104,    -1,   103,
     
    757761     160,    -1,   163,    -1,   164,    -1,   168,    -1,   169,    -1,
    758762     181,    -1,   183,    -1,   184,    -1,   189,    -1,   131,   109,
    759      299,   162,    -1,   106,   107,    -1,   106,   126,   126,   198,
     763     301,   162,    -1,   106,   107,    -1,   106,   126,   126,   200,
    760764     165,   127,   107,    -1,   166,    -1,   165,   126,   166,    -1,
    761      201,    -1,    38,   201,    -1,   295,    -1,   162,   127,    -1,
     765     203,    -1,    38,   203,    -1,   297,    -1,   162,   127,    -1,
    762766     162,    -1,   167,   162,    -1,   161,   124,    -1,    39,   101,
    763767     160,   102,   162,    -1,    39,   101,   160,   102,   162,    40,
    764768     162,    -1,    41,   101,   160,   102,   174,    -1,    41,   101,
    765      160,   102,   106,   126,   194,   175,   107,    -1,    51,   101,
     769     160,   102,   106,   126,   196,   175,   107,    -1,    51,   101,
    766770     160,   102,   174,    -1,    51,   101,   160,   102,   106,   126,
    767      194,   177,   107,    -1,   154,    -1,   154,    89,   154,    -1,
    768      297,    -1,   170,    -1,   171,   108,   170,    -1,    42,   171,
     771     196,   177,   107,    -1,   154,    -1,   154,    89,   154,    -1,
     772     299,    -1,   170,    -1,   171,   108,   170,    -1,    42,   171,
    769773     109,    -1,    43,   109,    -1,   172,    -1,   173,   172,    -1,
    770774     173,   162,    -1,    -1,   176,    -1,   173,   167,    -1,   176,
     
    774778      45,   101,   160,   102,   162,    -1,    44,   162,    45,   101,
    775779     160,   102,   124,    -1,    46,   101,   126,   182,   102,   162,
    776       -1,   161,   127,   124,   161,   124,   161,    -1,   201,   161,
     780      -1,   161,   127,   124,   161,   124,   161,    -1,   203,   161,
    777781     124,   161,    -1,    49,   131,   124,    -1,    49,   111,   160,
    778782     124,    -1,    48,   124,    -1,    48,   131,   124,    -1,    47,
     
    783787     101,    89,   102,   164,    -1,    54,   101,   126,   126,   188,
    784788     127,   102,   164,   127,    -1,   186,    54,   101,   126,   126,
    785      188,   127,   102,   164,   127,    -1,    55,   164,    -1,   214,
    786       -1,   214,   296,    -1,   214,   344,    -1,   353,   131,    -1,
    787      353,    -1,    57,   215,   101,   154,   102,   124,    -1,    57,
    788      215,   101,   154,   109,   190,   102,   124,    -1,    57,   215,
    789      101,   154,   109,   190,   109,   190,   102,   124,    -1,    57,
    790      215,   101,   154,   109,   190,   109,   190,   109,   193,   102,
    791      124,    -1,    -1,   191,    -1,   192,    -1,   191,   108,   192,
    792       -1,    75,   101,   154,   102,    -1,    75,    -1,   193,   108,
    793       75,    -1,   127,    -1,   195,    -1,   201,    -1,   195,   126,
    794      201,    -1,   127,    -1,   197,    -1,   211,    -1,   197,   126,
    795      211,    -1,    -1,   199,    -1,    28,   200,   124,    -1,   199,
    796       28,   200,   124,    -1,   261,    -1,   200,   108,   261,    -1,
    797      202,    -1,   211,    -1,   203,   127,   124,    -1,   208,   127,
    798      124,    -1,   205,   127,   124,    -1,   280,   127,   124,    -1,
    799      283,   127,   124,    -1,   204,   264,    -1,   220,   204,   264,
    800       -1,   203,   127,   108,   126,   259,   264,    -1,   354,   259,
    801      298,    -1,   357,   259,   298,    -1,   216,   357,   259,   298,
    802       -1,   206,    -1,   216,   206,    -1,   220,   206,    -1,   220,
    803      216,   206,    -1,   205,   127,   108,   126,   259,    -1,   103,
    804      104,   259,   101,   126,   247,   127,   102,    -1,   357,   259,
    805      101,   126,   247,   127,   102,    -1,   207,   259,   101,   126,
    806      247,   127,   102,    -1,   103,   126,   249,   127,   104,    -1,
    807      103,   126,   249,   127,   108,   126,   250,   127,   104,    -1,
    808        3,   204,    -1,     3,   206,    -1,   208,   127,   108,   126,
    809      131,    -1,     3,   214,   296,    -1,   209,   127,   108,   126,
    810      296,    -1,   216,     3,   214,   296,    -1,   214,     3,   296,
    811       -1,   214,     3,   216,   296,    -1,     3,   131,   123,   155,
    812       -1,   210,   127,   108,   126,   131,   123,   155,    -1,   212,
    813      127,   124,    -1,   209,   127,   124,    -1,   210,   127,   124,
    814       -1,   229,   127,   124,    -1,   213,   296,   298,   264,    -1,
    815      212,   108,   299,   296,   298,   264,    -1,   225,    -1,   229,
    816       -1,   231,    -1,   270,    -1,   226,    -1,   230,    -1,   232,
    817       -1,   271,    -1,    -1,   216,    -1,   217,    -1,   216,   217,
    818       -1,   218,    -1,   301,    -1,    10,    -1,    12,    -1,    11,
    819       -1,    14,    -1,    60,    -1,    -1,    13,   101,   219,   273,
    820      102,    -1,   221,    -1,   216,   221,    -1,   220,   216,   221,
    821       -1,   222,    -1,   221,   222,    -1,   223,    -1,     5,    -1,
    822        7,    -1,     4,    -1,     6,    -1,     8,    -1,     9,    -1,
    823       62,    -1,    64,    -1,    16,    -1,    21,    -1,    20,    -1,
    824       18,    -1,    19,    -1,    17,    -1,    22,    -1,    23,    -1,
    825       15,    -1,    24,    -1,    25,    -1,    26,    -1,   226,    -1,
    826      220,   226,    -1,   225,   222,    -1,   225,   222,   216,    -1,
    827      225,   222,   226,    -1,   227,    -1,   215,   228,   215,    -1,
    828      224,    -1,   216,   224,    -1,   227,   217,    -1,   227,   224,
    829       -1,    27,   101,   263,   102,    -1,    27,   101,   160,   102,
    830       -1,    71,   101,   263,   102,    -1,    71,   101,   160,   102,
    831       -1,   230,    -1,   220,   230,    -1,   229,   222,    -1,   229,
    832      222,   216,    -1,   233,    -1,   216,   233,    -1,   230,   217,
    833       -1,   232,    -1,   220,   232,    -1,   231,   222,    -1,   231,
    834      222,   216,    -1,    67,    -1,   216,    67,    -1,   232,   217,
    835       -1,   234,    -1,   244,    -1,   235,   106,   236,   107,    -1,
    836      235,   261,    -1,   235,   261,   106,   236,   107,    -1,   235,
    837      101,   279,   102,   106,   236,   107,    -1,   235,   272,    -1,
    838       30,   299,    -1,    31,   299,    -1,   237,    -1,   236,   237,
    839       -1,   238,   124,    -1,    38,   238,   124,    -1,   239,   124,
    840       -1,    38,   239,   124,    -1,   353,    -1,   353,   261,    -1,
    841      238,   108,   261,    -1,   238,   108,    -1,   214,   240,    -1,
    842      239,   108,   299,   240,    -1,    -1,   242,    -1,   305,   241,
    843       -1,   318,   241,    -1,   344,    -1,    -1,   242,    -1,   109,
    844      154,    -1,    29,   299,    -1,   243,   106,   245,   359,   107,
    845       -1,   243,   261,   106,   245,   359,   107,    -1,   243,   261,
    846       -1,   261,   246,    -1,   245,   108,   261,   246,    -1,    -1,
    847      123,   154,    -1,    -1,   248,    -1,   250,    -1,   249,    -1,
    848      249,   127,   108,   126,   250,    -1,   250,   127,   108,   126,
    849       89,    -1,   249,   127,   108,   126,    89,    -1,   254,    -1,
    850      250,   127,   108,   126,   254,    -1,   249,   127,   108,   126,
    851      254,    -1,   249,   127,   108,   126,   250,   127,   108,   126,
    852      254,    -1,   255,    -1,   250,   127,   108,   126,   255,    -1,
    853       -1,   252,    -1,   253,    -1,   253,   127,   108,   126,    89,
    854       -1,   257,    -1,   256,    -1,   253,   127,   108,   126,   257,
    855       -1,   253,   127,   108,   126,   256,    -1,   256,    -1,   349,
    856      259,   360,    -1,   357,   259,   360,    -1,   216,   357,   259,
    857      360,    -1,   206,    -1,   257,    -1,   349,    -1,   357,    -1,
    858      216,   357,    -1,   358,    -1,   213,   323,   360,    -1,   213,
    859      327,   360,    -1,   213,    -1,   213,   338,    -1,   131,    -1,
    860      258,   108,   131,    -1,   129,    -1,    67,    -1,    68,    -1,
    861      130,    -1,    67,    -1,    68,    -1,   131,    -1,    67,    -1,
    862       68,    -1,   353,    -1,   214,    -1,   214,   344,    -1,   353,
    863       -1,   358,    -1,   214,    -1,   214,   332,    -1,    -1,   123,
    864      265,    -1,   155,    -1,   106,   266,   359,   107,    -1,   265,
    865       -1,   267,   265,    -1,   266,   108,   265,    -1,   266,   108,
    866      267,   265,    -1,   268,   109,    -1,   261,   109,    -1,   269,
    867       -1,   268,   269,    -1,   105,   261,    -1,   103,   126,   155,
    868      127,   104,    -1,   103,   126,   297,   127,   104,    -1,   103,
    869      126,   154,    89,   154,   127,   104,    -1,   105,   103,   126,
    870      138,   127,   104,    -1,   271,    -1,   220,   271,    -1,   270,
    871      222,    -1,   270,   222,   216,    -1,   272,    -1,   216,   272,
    872       -1,   271,   217,    -1,    68,   101,   279,   102,    -1,   274,
    873      360,    -1,   273,   108,   274,   360,    -1,    -1,   276,   261,
    874      275,   277,    -1,   214,   323,    -1,    32,    -1,    34,    -1,
    875       33,    -1,    -1,   277,   278,    -1,   121,   261,   101,   279,
    876      102,    -1,   121,   106,   126,   285,   107,    -1,   121,   101,
    877      126,   273,   127,   102,   106,   126,   285,   107,   101,   279,
    878      102,    -1,   263,    -1,   155,    -1,   279,   108,   263,    -1,
    879      279,   108,   155,    -1,    32,   281,    -1,   221,    32,   281,
    880       -1,   280,   108,   281,    -1,   282,   277,    -1,   282,   277,
    881      123,   263,    -1,   261,    -1,   260,   101,   126,   273,   127,
    882      102,    -1,    35,   261,   101,   126,   273,   127,   102,   106,
    883      107,    -1,    -1,    35,   261,   101,   126,   273,   127,   102,
    884      106,   284,   285,   107,    -1,   286,    -1,   285,   126,   286,
    885       -1,   287,   127,   124,    -1,   288,   127,   124,    -1,   204,
    886       -1,   206,    -1,   287,   127,   108,   126,   259,    -1,   214,
    887      296,    -1,   288,   127,   108,   126,   296,    -1,    -1,   290,
    888       -1,   292,    -1,   290,   126,   292,    -1,    -1,   290,    -1,
    889      201,    -1,   294,    -1,   189,    -1,    -1,     5,    75,   293,
    890      106,   291,   107,    -1,    38,   292,    -1,   295,    -1,   310,
    891      164,    -1,   314,   126,   196,   164,    -1,   205,   164,    -1,
    892      213,   310,   164,    -1,   216,   310,   164,    -1,   220,   310,
    893      164,    -1,   220,   216,   310,   164,    -1,   213,   314,   126,
    894      196,   164,    -1,   216,   314,   126,   196,   164,    -1,   220,
    895      314,   126,   196,   164,    -1,   220,   216,   314,   126,   196,
    896      164,    -1,   305,    -1,   310,    -1,   318,    -1,   154,   115,
    897      154,    -1,    -1,    57,   101,   133,   102,   299,    -1,    -1,
    898      300,    -1,   301,    -1,   300,   301,    -1,    37,   101,   101,
    899      302,   102,   102,    -1,   303,    -1,   302,   108,   303,    -1,
    900       -1,   304,    -1,   304,   101,   161,   102,    -1,   259,    -1,
    901      223,    -1,   224,    -1,   217,    -1,   306,   299,    -1,   307,
    902       -1,   308,   299,    -1,   309,   299,    -1,   129,    -1,   101,
    903      306,   102,    -1,   111,   305,    -1,   111,   216,   305,    -1,
    904      101,   307,   102,    -1,   306,   336,    -1,   101,   307,   102,
    905      336,    -1,   101,   308,   102,   337,    -1,   101,   308,   102,
    906       -1,   101,   307,   102,   101,   126,   251,   127,   102,    -1,
    907      101,   309,   102,    -1,   311,   299,    -1,   312,    -1,   313,
    908      299,    -1,   306,   101,   126,   251,   127,   102,    -1,   101,
    909      312,   102,   101,   126,   251,   127,   102,    -1,   101,   311,
    910      102,    -1,   111,   310,    -1,   111,   216,   310,    -1,   101,
    911      312,   102,    -1,   101,   312,   102,   336,    -1,   101,   313,
    912      102,   337,    -1,   101,   313,   102,    -1,   315,    -1,   316,
    913       -1,   317,    -1,   306,   101,   258,   102,    -1,   101,   316,
    914      102,   101,   258,   102,    -1,   101,   315,   102,    -1,   111,
    915      314,    -1,   111,   216,   314,    -1,   101,   316,   102,    -1,
    916      101,   316,   102,   336,    -1,   101,   317,   102,   337,    -1,
    917      101,   317,   102,    -1,   319,   299,    -1,   320,    -1,   321,
    918      299,    -1,   322,   299,    -1,   328,    -1,   101,   319,   102,
    919       -1,   111,   318,    -1,   111,   216,   318,    -1,   101,   320,
    920      102,    -1,   319,   336,    -1,   101,   320,   102,   336,    -1,
    921      101,   321,   102,   337,    -1,   101,   321,   102,    -1,   319,
    922      101,   126,   251,   127,   102,    -1,   101,   320,   102,   101,
    923      126,   251,   127,   102,    -1,   101,   322,   102,    -1,   306,
    924      299,    -1,   324,    -1,   325,   299,    -1,   326,   299,    -1,
    925      111,   323,    -1,   111,   216,   323,    -1,   101,   324,   102,
    926       -1,   306,   342,    -1,   101,   324,   102,   336,    -1,   101,
    927      325,   102,   337,    -1,   101,   325,   102,    -1,   306,   101,
    928      126,   251,   127,   102,    -1,   101,   324,   102,   101,   126,
    929      251,   127,   102,    -1,   101,   326,   102,    -1,   328,   299,
    930       -1,   329,    -1,   330,   299,    -1,   331,   299,    -1,    67,
    931       -1,    68,    -1,   111,   327,    -1,   111,   216,   327,    -1,
    932      101,   329,   102,    -1,   328,   342,    -1,   101,   329,   102,
    933      342,    -1,   328,   101,   126,   251,   127,   102,    -1,   101,
    934      329,   102,   101,   126,   251,   127,   102,    -1,   333,    -1,
    935      334,   299,    -1,   335,   299,    -1,   111,    -1,   111,   216,
    936       -1,   111,   332,    -1,   111,   216,   332,    -1,   101,   333,
    937      102,    -1,   336,    -1,   101,   333,   102,   336,    -1,   101,
    938      334,   102,   337,    -1,   101,   334,   102,    -1,   101,   126,
    939      251,   127,   102,    -1,   101,   333,   102,   101,   126,   251,
    940      127,   102,    -1,   101,   335,   102,    -1,   103,   104,    -1,
    941      103,   104,   337,    -1,   337,    -1,   103,   126,   155,   127,
    942      104,    -1,   103,   126,   111,   127,   104,    -1,   337,   103,
    943      126,   155,   127,   104,    -1,   337,   103,   126,   111,   127,
    944      104,    -1,   339,    -1,   340,   299,    -1,   341,   299,    -1,
    945      111,    -1,   111,   216,    -1,   111,   338,    -1,   111,   216,
    946      338,    -1,   101,   339,   102,    -1,   342,    -1,   101,   339,
    947      102,   342,    -1,   101,   340,   102,   337,    -1,   101,   340,
    948      102,    -1,   101,   126,   251,   127,   102,    -1,   101,   339,
    949      102,   101,   126,   251,   127,   102,    -1,   101,   341,   102,
    950       -1,   343,    -1,   343,   337,    -1,   337,    -1,   103,   104,
    951       -1,   103,   126,   216,   111,   127,   104,    -1,   103,   126,
    952      216,   127,   104,    -1,   103,   126,   216,   155,   127,   104,
    953       -1,   103,   126,     7,   215,   155,   127,   104,    -1,   103,
    954      126,   216,     7,   155,   127,   104,    -1,   345,    -1,   346,
    955      299,    -1,   347,   299,    -1,   111,    -1,   111,   216,    -1,
    956      111,   344,    -1,   111,   216,   344,    -1,   101,   345,   102,
    957       -1,   336,    -1,   101,   345,   102,   336,    -1,   101,   346,
    958      102,   337,    -1,   101,   346,   102,    -1,   101,   345,   102,
    959      101,   126,   251,   127,   102,    -1,   101,   347,   102,    -1,
    960      349,    -1,   357,    -1,   216,   357,    -1,   350,    -1,   351,
    961       -1,   111,   214,    -1,   216,   111,   214,    -1,   111,   358,
    962       -1,   216,   111,   358,    -1,   111,   348,    -1,   216,   111,
    963      348,    -1,   103,   104,   214,    -1,   352,   214,    -1,   103,
    964      104,   337,   214,    -1,   352,   337,   214,    -1,   337,   214,
    965       -1,   103,   104,   350,    -1,   352,   350,    -1,   103,   104,
    966      337,   350,    -1,   352,   337,   350,    -1,   337,   350,    -1,
    967      103,   126,   216,   111,   127,   104,    -1,   103,   126,   216,
    968      155,   127,   104,    -1,   103,   126,   220,   155,   127,   104,
    969       -1,   103,   126,   220,   216,   155,   127,   104,    -1,   357,
    970       -1,   216,   357,    -1,   354,    -1,   355,    -1,   356,    -1,
    971      111,   214,    -1,   216,   111,   214,    -1,   111,   358,    -1,
    972      216,   111,   358,    -1,   111,   353,    -1,   216,   111,   353,
    973       -1,   103,   104,   214,    -1,   103,   104,   337,   214,    -1,
    974      337,   214,    -1,   103,   104,   355,    -1,   103,   104,   337,
    975      355,    -1,   337,   355,    -1,   103,   126,   250,   127,   104,
    976       -1,   103,   104,   101,   247,   102,    -1,   357,   101,   126,
    977      247,   127,   102,    -1,   207,   101,   126,   247,   127,   102,
    978       -1,    -1,   108,    -1,    -1,   123,   155,    -1
     789     188,   127,   102,   164,   127,    -1,    55,   164,    -1,   216,
     790      -1,   216,   298,    -1,   216,   346,    -1,   355,   131,    -1,
     791     355,    -1,    57,   190,   101,   133,   102,   124,    -1,    57,
     792     190,   101,   133,   109,   191,   102,   124,    -1,    57,   190,
     793     101,   133,   109,   191,   109,   191,   102,   124,    -1,    57,
     794     190,   101,   133,   109,   191,   109,   191,   109,   194,   102,
     795     124,    -1,    57,   190,    49,   101,   133,   109,   109,   191,
     796     109,   194,   109,   195,   102,   124,    -1,    -1,    11,    -1,
     797      -1,   192,    -1,   193,    -1,   192,   108,   193,    -1,   133,
     798     101,   154,   102,    -1,   103,   154,   104,   133,   101,   154,
     799     102,    -1,    -1,   133,    -1,   194,   108,   133,    -1,   131,
     800      -1,   195,   108,   131,    -1,   127,    -1,   197,    -1,   203,
     801      -1,   197,   126,   203,    -1,   127,    -1,   199,    -1,   213,
     802      -1,   199,   126,   213,    -1,    -1,   201,    -1,    28,   202,
     803     124,    -1,   201,    28,   202,   124,    -1,   263,    -1,   202,
     804     108,   263,    -1,   204,    -1,   213,    -1,   205,   127,   124,
     805      -1,   210,   127,   124,    -1,   207,   127,   124,    -1,   282,
     806     127,   124,    -1,   285,   127,   124,    -1,   206,   266,    -1,
     807     222,   206,   266,    -1,   205,   127,   108,   126,   261,   266,
     808      -1,   356,   261,   300,    -1,   359,   261,   300,    -1,   218,
     809     359,   261,   300,    -1,   208,    -1,   218,   208,    -1,   222,
     810     208,    -1,   222,   218,   208,    -1,   207,   127,   108,   126,
     811     261,    -1,   103,   104,   261,   101,   126,   249,   127,   102,
     812      -1,   359,   261,   101,   126,   249,   127,   102,    -1,   209,
     813     261,   101,   126,   249,   127,   102,    -1,   103,   126,   251,
     814     127,   104,    -1,   103,   126,   251,   127,   108,   126,   252,
     815     127,   104,    -1,     3,   206,    -1,     3,   208,    -1,   210,
     816     127,   108,   126,   131,    -1,     3,   216,   298,    -1,   211,
     817     127,   108,   126,   298,    -1,   218,     3,   216,   298,    -1,
     818     216,     3,   298,    -1,   216,     3,   218,   298,    -1,     3,
     819     131,   123,   155,    -1,   212,   127,   108,   126,   131,   123,
     820     155,    -1,   214,   127,   124,    -1,   211,   127,   124,    -1,
     821     212,   127,   124,    -1,   231,   127,   124,    -1,   215,   298,
     822     300,   266,    -1,   214,   108,   301,   298,   300,   266,    -1,
     823     227,    -1,   231,    -1,   233,    -1,   272,    -1,   228,    -1,
     824     232,    -1,   234,    -1,   273,    -1,    -1,   218,    -1,   219,
     825      -1,   218,   219,    -1,   220,    -1,   303,    -1,    10,    -1,
     826      12,    -1,    11,    -1,    14,    -1,    60,    -1,    -1,    13,
     827     101,   221,   275,   102,    -1,   223,    -1,   218,   223,    -1,
     828     222,   218,   223,    -1,   224,    -1,   223,   224,    -1,   225,
     829      -1,     5,    -1,     7,    -1,     4,    -1,     6,    -1,     8,
     830      -1,     9,    -1,    62,    -1,    64,    -1,    16,    -1,    21,
     831      -1,    20,    -1,    18,    -1,    19,    -1,    17,    -1,    22,
     832      -1,    23,    -1,    15,    -1,    24,    -1,    25,    -1,    26,
     833      -1,   228,    -1,   222,   228,    -1,   227,   224,    -1,   227,
     834     224,   218,    -1,   227,   224,   228,    -1,   229,    -1,   217,
     835     230,   217,    -1,   226,    -1,   218,   226,    -1,   229,   219,
     836      -1,   229,   226,    -1,    27,   101,   265,   102,    -1,    27,
     837     101,   160,   102,    -1,    71,   101,   265,   102,    -1,    71,
     838     101,   160,   102,    -1,   232,    -1,   222,   232,    -1,   231,
     839     224,    -1,   231,   224,   218,    -1,   235,    -1,   218,   235,
     840      -1,   232,   219,    -1,   234,    -1,   222,   234,    -1,   233,
     841     224,    -1,   233,   224,   218,    -1,    67,    -1,   218,    67,
     842      -1,   234,   219,    -1,   236,    -1,   246,    -1,   237,   106,
     843     238,   107,    -1,   237,   263,    -1,   237,   263,   106,   238,
     844     107,    -1,   237,   101,   281,   102,   106,   238,   107,    -1,
     845     237,   274,    -1,    30,   301,    -1,    31,   301,    -1,   239,
     846      -1,   238,   239,    -1,   240,   124,    -1,    38,   240,   124,
     847      -1,   241,   124,    -1,    38,   241,   124,    -1,   355,    -1,
     848     355,   263,    -1,   240,   108,   263,    -1,   240,   108,    -1,
     849     216,   242,    -1,   241,   108,   301,   242,    -1,    -1,   244,
     850      -1,   307,   243,    -1,   320,   243,    -1,   346,    -1,    -1,
     851     244,    -1,   109,   154,    -1,    29,   301,    -1,   245,   106,
     852     247,   361,   107,    -1,   245,   263,   106,   247,   361,   107,
     853      -1,   245,   263,    -1,   263,   248,    -1,   247,   108,   263,
     854     248,    -1,    -1,   123,   154,    -1,    -1,   250,    -1,   252,
     855      -1,   251,    -1,   251,   127,   108,   126,   252,    -1,   252,
     856     127,   108,   126,    89,    -1,   251,   127,   108,   126,    89,
     857      -1,   256,    -1,   252,   127,   108,   126,   256,    -1,   251,
     858     127,   108,   126,   256,    -1,   251,   127,   108,   126,   252,
     859     127,   108,   126,   256,    -1,   257,    -1,   252,   127,   108,
     860     126,   257,    -1,    -1,   254,    -1,   255,    -1,   255,   127,
     861     108,   126,    89,    -1,   259,    -1,   258,    -1,   255,   127,
     862     108,   126,   259,    -1,   255,   127,   108,   126,   258,    -1,
     863     258,    -1,   351,   261,   362,    -1,   359,   261,   362,    -1,
     864     218,   359,   261,   362,    -1,   208,    -1,   259,    -1,   351,
     865      -1,   359,    -1,   218,   359,    -1,   360,    -1,   215,   325,
     866     362,    -1,   215,   329,   362,    -1,   215,    -1,   215,   340,
     867      -1,   131,    -1,   260,   108,   131,    -1,   129,    -1,    67,
     868      -1,    68,    -1,   130,    -1,    67,    -1,    68,    -1,   131,
     869      -1,    67,    -1,    68,    -1,   355,    -1,   216,    -1,   216,
     870     346,    -1,   355,    -1,   360,    -1,   216,    -1,   216,   334,
     871      -1,    -1,   123,   267,    -1,   155,    -1,   106,   268,   361,
     872     107,    -1,   267,    -1,   269,   267,    -1,   268,   108,   267,
     873      -1,   268,   108,   269,   267,    -1,   270,   109,    -1,   263,
     874     109,    -1,   271,    -1,   270,   271,    -1,    73,    -1,   105,
     875     263,    -1,   103,   126,   155,   127,   104,    -1,   103,   126,
     876     299,   127,   104,    -1,   103,   126,   154,    89,   154,   127,
     877     104,    -1,   105,   103,   126,   138,   127,   104,    -1,   273,
     878      -1,   222,   273,    -1,   272,   224,    -1,   272,   224,   218,
     879      -1,   274,    -1,   218,   274,    -1,   273,   219,    -1,    68,
     880     101,   281,   102,    -1,   276,   362,    -1,   275,   108,   276,
     881     362,    -1,    -1,   278,   263,   277,   279,    -1,   216,   325,
     882      -1,    32,    -1,    34,    -1,    33,    -1,    -1,   279,   280,
     883      -1,   121,   263,   101,   281,   102,    -1,   121,   106,   126,
     884     287,   107,    -1,   121,   101,   126,   275,   127,   102,   106,
     885     126,   287,   107,   101,   281,   102,    -1,   265,    -1,   155,
     886      -1,   281,   108,   265,    -1,   281,   108,   155,    -1,    32,
     887     283,    -1,   223,    32,   283,    -1,   282,   108,   283,    -1,
     888     284,   279,    -1,   284,   279,   123,   265,    -1,   263,    -1,
     889     262,   101,   126,   275,   127,   102,    -1,    35,   263,   101,
     890     126,   275,   127,   102,   106,   107,    -1,    -1,    35,   263,
     891     101,   126,   275,   127,   102,   106,   286,   287,   107,    -1,
     892     288,    -1,   287,   126,   288,    -1,   289,   127,   124,    -1,
     893     290,   127,   124,    -1,   206,    -1,   208,    -1,   289,   127,
     894     108,   126,   261,    -1,   216,   298,    -1,   290,   127,   108,
     895     126,   298,    -1,    -1,   292,    -1,   294,    -1,   292,   126,
     896     294,    -1,    -1,   292,    -1,   203,    -1,   296,    -1,   189,
     897      -1,    -1,     5,    75,   295,   106,   293,   107,    -1,    38,
     898     294,    -1,   297,    -1,   312,   164,    -1,   316,   126,   198,
     899     164,    -1,   207,   164,    -1,   215,   312,   164,    -1,   218,
     900     312,   164,    -1,   222,   312,   164,    -1,   222,   218,   312,
     901     164,    -1,   215,   316,   126,   198,   164,    -1,   218,   316,
     902     126,   198,   164,    -1,   222,   316,   126,   198,   164,    -1,
     903     222,   218,   316,   126,   198,   164,    -1,   307,    -1,   312,
     904      -1,   320,    -1,   154,   115,   154,    -1,    -1,    57,   101,
     905     133,   102,   301,    -1,    -1,   302,    -1,   303,    -1,   302,
     906     303,    -1,    37,   101,   101,   304,   102,   102,    -1,   305,
     907      -1,   304,   108,   305,    -1,    -1,   306,    -1,   306,   101,
     908     161,   102,    -1,   261,    -1,   225,    -1,   226,    -1,   219,
     909      -1,   308,   301,    -1,   309,    -1,   310,   301,    -1,   311,
     910     301,    -1,   129,    -1,   101,   308,   102,    -1,   111,   307,
     911      -1,   111,   218,   307,    -1,   101,   309,   102,    -1,   308,
     912     338,    -1,   101,   309,   102,   338,    -1,   101,   310,   102,
     913     339,    -1,   101,   310,   102,    -1,   101,   309,   102,   101,
     914     126,   253,   127,   102,    -1,   101,   311,   102,    -1,   313,
     915     301,    -1,   314,    -1,   315,   301,    -1,   308,   101,   126,
     916     253,   127,   102,    -1,   101,   314,   102,   101,   126,   253,
     917     127,   102,    -1,   101,   313,   102,    -1,   111,   312,    -1,
     918     111,   218,   312,    -1,   101,   314,   102,    -1,   101,   314,
     919     102,   338,    -1,   101,   315,   102,   339,    -1,   101,   315,
     920     102,    -1,   317,    -1,   318,    -1,   319,    -1,   308,   101,
     921     260,   102,    -1,   101,   318,   102,   101,   260,   102,    -1,
     922     101,   317,   102,    -1,   111,   316,    -1,   111,   218,   316,
     923      -1,   101,   318,   102,    -1,   101,   318,   102,   338,    -1,
     924     101,   319,   102,   339,    -1,   101,   319,   102,    -1,   321,
     925     301,    -1,   322,    -1,   323,   301,    -1,   324,   301,    -1,
     926     330,    -1,   101,   321,   102,    -1,   111,   320,    -1,   111,
     927     218,   320,    -1,   101,   322,   102,    -1,   321,   338,    -1,
     928     101,   322,   102,   338,    -1,   101,   323,   102,   339,    -1,
     929     101,   323,   102,    -1,   321,   101,   126,   253,   127,   102,
     930      -1,   101,   322,   102,   101,   126,   253,   127,   102,    -1,
     931     101,   324,   102,    -1,   308,   301,    -1,   326,    -1,   327,
     932     301,    -1,   328,   301,    -1,   111,   325,    -1,   111,   218,
     933     325,    -1,   101,   326,   102,    -1,   308,   344,    -1,   101,
     934     326,   102,   338,    -1,   101,   327,   102,   339,    -1,   101,
     935     327,   102,    -1,   308,   101,   126,   253,   127,   102,    -1,
     936     101,   326,   102,   101,   126,   253,   127,   102,    -1,   101,
     937     328,   102,    -1,   330,   301,    -1,   331,    -1,   332,   301,
     938      -1,   333,   301,    -1,    67,    -1,    68,    -1,   111,   329,
     939      -1,   111,   218,   329,    -1,   101,   331,   102,    -1,   330,
     940     344,    -1,   101,   331,   102,   344,    -1,   330,   101,   126,
     941     253,   127,   102,    -1,   101,   331,   102,   101,   126,   253,
     942     127,   102,    -1,   335,    -1,   336,   301,    -1,   337,   301,
     943      -1,   111,    -1,   111,   218,    -1,   111,   334,    -1,   111,
     944     218,   334,    -1,   101,   335,   102,    -1,   338,    -1,   101,
     945     335,   102,   338,    -1,   101,   336,   102,   339,    -1,   101,
     946     336,   102,    -1,   101,   126,   253,   127,   102,    -1,   101,
     947     335,   102,   101,   126,   253,   127,   102,    -1,   101,   337,
     948     102,    -1,   103,   104,    -1,   103,   104,   339,    -1,   339,
     949      -1,   103,   126,   155,   127,   104,    -1,   103,   126,   111,
     950     127,   104,    -1,   339,   103,   126,   155,   127,   104,    -1,
     951     339,   103,   126,   111,   127,   104,    -1,   341,    -1,   342,
     952     301,    -1,   343,   301,    -1,   111,    -1,   111,   218,    -1,
     953     111,   340,    -1,   111,   218,   340,    -1,   101,   341,   102,
     954      -1,   344,    -1,   101,   341,   102,   344,    -1,   101,   342,
     955     102,   339,    -1,   101,   342,   102,    -1,   101,   126,   253,
     956     127,   102,    -1,   101,   341,   102,   101,   126,   253,   127,
     957     102,    -1,   101,   343,   102,    -1,   345,    -1,   345,   339,
     958      -1,   339,    -1,   103,   104,    -1,   103,   126,   218,   111,
     959     127,   104,    -1,   103,   126,   218,   127,   104,    -1,   103,
     960     126,   218,   155,   127,   104,    -1,   103,   126,     7,   217,
     961     155,   127,   104,    -1,   103,   126,   218,     7,   155,   127,
     962     104,    -1,   347,    -1,   348,   301,    -1,   349,   301,    -1,
     963     111,    -1,   111,   218,    -1,   111,   346,    -1,   111,   218,
     964     346,    -1,   101,   347,   102,    -1,   338,    -1,   101,   347,
     965     102,   338,    -1,   101,   348,   102,   339,    -1,   101,   348,
     966     102,    -1,   101,   347,   102,   101,   126,   253,   127,   102,
     967      -1,   101,   349,   102,    -1,   351,    -1,   359,    -1,   218,
     968     359,    -1,   352,    -1,   353,    -1,   111,   216,    -1,   218,
     969     111,   216,    -1,   111,   360,    -1,   218,   111,   360,    -1,
     970     111,   350,    -1,   218,   111,   350,    -1,   103,   104,   216,
     971      -1,   354,   216,    -1,   103,   104,   339,   216,    -1,   354,
     972     339,   216,    -1,   339,   216,    -1,   103,   104,   352,    -1,
     973     354,   352,    -1,   103,   104,   339,   352,    -1,   354,   339,
     974     352,    -1,   339,   352,    -1,   103,   126,   218,   111,   127,
     975     104,    -1,   103,   126,   218,   155,   127,   104,    -1,   103,
     976     126,   222,   155,   127,   104,    -1,   103,   126,   222,   218,
     977     155,   127,   104,    -1,   359,    -1,   218,   359,    -1,   356,
     978      -1,   357,    -1,   358,    -1,   111,   216,    -1,   218,   111,
     979     216,    -1,   111,   360,    -1,   218,   111,   360,    -1,   111,
     980     355,    -1,   218,   111,   355,    -1,   103,   104,   216,    -1,
     981     103,   104,   339,   216,    -1,   339,   216,    -1,   103,   104,
     982     357,    -1,   103,   104,   339,   357,    -1,   339,   357,    -1,
     983     103,   126,   252,   127,   104,    -1,   103,   104,   101,   249,
     984     102,    -1,   359,   101,   126,   249,   127,   102,    -1,   209,
     985     101,   126,   249,   127,   102,    -1,    -1,   108,    -1,    -1,
     986     123,   155,    -1
    979987};
    980988
     
    982990static const yytype_uint16 yyrline[] =
    983991{
    984        0,   279,   279,   285,   294,   295,   296,   300,   301,   302,
    985      306,   307,   311,   315,   316,   320,   321,   327,   329,   331,
    986      333,   335,   337,   342,   343,   349,   351,   353,   354,   356,
    987      357,   359,   362,   367,   368,   374,   375,   376,   381,   383,
    988      388,   389,   393,   395,   397,   399,   401,   406,   407,   409,
    989      411,   413,   415,   417,   423,   425,   427,   429,   431,   433,
    990      435,   437,   442,   443,   444,   445,   449,   450,   452,   457,
    991      458,   460,   462,   467,   468,   470,   475,   476,   478,   483,
    992      484,   486,   488,   490,   495,   496,   498,   503,   504,   509,
    993      510,   515,   516,   521,   522,   527,   528,   533,   534,   536,
    994      538,   543,   548,   549,   551,   553,   559,   560,   566,   568,
    995      570,   572,   577,   578,   583,   584,   585,   586,   587,   588,
    996      589,   590,   591,   592,   596,   597,   603,   604,   610,   611,
    997      612,   613,   614,   615,   616,   617,   621,   626,   628,   638,
    998      639,   644,   646,   648,   650,   654,   655,   660,   665,   668,
    999      670,   672,   677,   679,   687,   688,   690,   694,   695,   700,
    1000      701,   706,   707,   711,   716,   717,   721,   723,   729,   730,
    1001      734,   736,   738,   740,   746,   747,   751,   752,   756,   758,
    1002      760,   765,   767,   772,   774,   778,   781,   785,   788,   792,
    1003      794,   796,   801,   803,   805,   814,   816,   818,   823,   825,
    1004      830,   843,   844,   849,   851,   856,   860,   862,   864,   866,
    1005      870,   872,   876,   877,   881,   885,   886,   892,   894,   898,
    1006      899,   904,   906,   910,   911,   915,   917,   921,   922,   926,
    1007      927,   931,   932,   947,   948,   949,   950,   951,   955,   960,
    1008      967,   977,   982,   987,   995,  1000,  1005,  1010,  1015,  1023,
    1009     1045,  1050,  1057,  1059,  1066,  1071,  1076,  1087,  1092,  1097,
    1010     1102,  1107,  1116,  1121,  1129,  1130,  1131,  1132,  1138,  1143,
    1011     1151,  1152,  1153,  1154,  1158,  1159,  1160,  1161,  1166,  1167,
    1012     1176,  1177,  1182,  1183,  1188,  1190,  1192,  1194,  1196,  1199,
    1013     1198,  1210,  1211,  1213,  1223,  1224,  1229,  1233,  1235,  1237,
    1014     1239,  1241,  1243,  1245,  1247,  1252,  1254,  1256,  1258,  1260,
    1015     1262,  1264,  1266,  1268,  1270,  1272,  1274,  1280,  1281,  1283,
    1016     1285,  1287,  1292,  1293,  1299,  1300,  1302,  1304,  1309,  1311,
    1017     1313,  1315,  1320,  1321,  1323,  1325,  1330,  1331,  1333,  1338,
    1018     1339,  1341,  1343,  1348,  1350,  1352,  1357,  1358,  1362,  1364,
    1019     1366,  1368,  1370,  1375,  1377,  1382,  1384,  1389,  1390,  1392,
    1020     1393,  1398,  1399,  1401,  1403,  1408,  1410,  1416,  1417,  1419,
    1021     1422,  1425,  1430,  1431,  1436,  1441,  1445,  1447,  1449,  1454,
    1022     1456,  1462,  1463,  1471,  1472,  1476,  1477,  1478,  1480,  1482,
    1023     1489,  1490,  1492,  1494,  1499,  1500,  1506,  1507,  1511,  1512,
    1024     1517,  1518,  1519,  1521,  1529,  1530,  1532,  1535,  1537,  1541,
    1025     1542,  1543,  1545,  1547,  1551,  1556,  1564,  1565,  1574,  1576,
    1026     1581,  1582,  1583,  1587,  1588,  1589,  1593,  1594,  1595,  1599,
    1027     1600,  1601,  1606,  1607,  1608,  1609,  1615,  1616,  1621,  1622,
    1028     1626,  1627,  1628,  1629,  1644,  1645,  1650,  1651,  1657,  1659,
    1029     1662,  1664,  1666,  1689,  1690,  1692,  1694,  1699,  1700,  1702,
    1030     1707,  1712,  1713,  1719,  1718,  1722,  1726,  1728,  1730,  1736,
    1031     1737,  1742,  1747,  1749,  1754,  1756,  1757,  1759,  1764,  1766,
    1032     1768,  1773,  1775,  1780,  1785,  1793,  1799,  1798,  1812,  1813,
    1033     1818,  1819,  1823,  1828,  1833,  1841,  1846,  1857,  1858,  1869,
    1034     1870,  1876,  1877,  1881,  1882,  1883,  1886,  1885,  1896,  1901,
    1035     1906,  1912,  1921,  1927,  1933,  1939,  1945,  1953,  1959,  1967,
    1036     1973,  1982,  1983,  1984,  1988,  1992,  1994,  1997,  1999,  2003,
    1037     2004,  2008,  2012,  2013,  2016,  2018,  2019,  2023,  2024,  2025,
    1038     2026,  2060,  2061,  2062,  2063,  2067,  2072,  2077,  2079,  2081,
    1039     2086,  2088,  2090,  2092,  2097,  2099,  2109,  2110,  2111,  2115,
    1040     2117,  2119,  2124,  2126,  2128,  2133,  2135,  2137,  2146,  2147,
    1041     2148,  2152,  2154,  2156,  2161,  2163,  2165,  2170,  2172,  2174,
    1042     2189,  2190,  2191,  2192,  2196,  2197,  2202,  2204,  2206,  2211,
    1043     2213,  2215,  2217,  2222,  2224,  2226,  2236,  2237,  2238,  2239,
    1044     2243,  2245,  2247,  2252,  2254,  2256,  2258,  2263,  2265,  2267,
    1045     2298,  2299,  2300,  2301,  2305,  2310,  2318,  2320,  2322,  2327,
    1046     2329,  2334,  2336,  2350,  2351,  2352,  2356,  2358,  2360,  2362,
    1047     2364,  2369,  2370,  2372,  2374,  2379,  2381,  2383,  2389,  2391,
    1048     2393,  2397,  2399,  2401,  2403,  2417,  2418,  2419,  2423,  2425,
    1049     2427,  2429,  2431,  2436,  2437,  2439,  2441,  2446,  2448,  2450,
    1050     2456,  2457,  2459,  2468,  2471,  2473,  2476,  2478,  2480,  2493,
    1051     2494,  2495,  2499,  2501,  2503,  2505,  2507,  2512,  2513,  2515,
    1052     2517,  2522,  2524,  2532,  2533,  2534,  2539,  2540,  2544,  2546,
    1053     2548,  2550,  2552,  2554,  2561,  2563,  2565,  2567,  2569,  2571,
    1054     2573,  2575,  2577,  2579,  2584,  2586,  2588,  2593,  2619,  2620,
    1055     2622,  2626,  2627,  2631,  2633,  2635,  2637,  2639,  2641,  2648,
    1056     2650,  2652,  2654,  2656,  2658,  2663,  2668,  2670,  2672,  2690,
    1057     2692,  2697,  2698
     992       0,   288,   288,   294,   303,   304,   305,   309,   310,   311,
     993     315,   316,   320,   324,   325,   329,   330,   336,   338,   340,
     994     342,   347,   348,   354,   356,   358,   359,   361,   362,   364,
     995     367,   372,   373,   379,   380,   381,   386,   388,   393,   394,
     996     398,   400,   402,   404,   406,   411,   414,   416,   418,   420,
     997     422,   424,   426,   428,   434,   436,   438,   440,   442,   444,
     998     446,   448,   453,   454,   455,   456,   460,   461,   463,   468,
     999     469,   471,   473,   478,   479,   481,   486,   487,   489,   494,
     1000     495,   497,   499,   501,   506,   507,   509,   514,   515,   520,
     1001     521,   526,   527,   532,   533,   538,   539,   544,   545,   547,
     1002     549,   554,   559,   560,   562,   564,   570,   571,   577,   579,
     1003     581,   583,   588,   589,   594,   595,   596,   597,   598,   599,
     1004     600,   601,   602,   603,   607,   608,   614,   615,   621,   622,
     1005     623,   624,   625,   626,   627,   628,   632,   639,   641,   651,
     1006     652,   657,   659,   661,   663,   667,   668,   673,   678,   681,
     1007     683,   685,   690,   692,   700,   701,   703,   707,   708,   713,
     1008     714,   719,   720,   724,   729,   730,   734,   736,   742,   743,
     1009     747,   749,   751,   753,   759,   760,   764,   765,   769,   771,
     1010     773,   778,   780,   785,   787,   791,   794,   798,   801,   805,
     1011     807,   809,   814,   816,   818,   827,   829,   831,   836,   838,
     1012     843,   856,   857,   862,   864,   869,   873,   875,   877,   879,
     1013     881,   887,   888,   894,   895,   899,   900,   905,   907,   913,
     1014     914,   916,   921,   923,   930,   932,   936,   937,   942,   944,
     1015     948,   949,   953,   955,   959,   960,   964,   965,   969,   970,
     1016     985,   986,   987,   988,   989,   993,   998,  1005,  1015,  1020,
     1017    1025,  1033,  1038,  1043,  1048,  1053,  1061,  1083,  1088,  1095,
     1018    1097,  1104,  1109,  1114,  1125,  1130,  1135,  1140,  1145,  1154,
     1019    1159,  1167,  1168,  1169,  1170,  1176,  1181,  1189,  1190,  1191,
     1020    1192,  1196,  1197,  1198,  1199,  1204,  1205,  1214,  1215,  1220,
     1021    1221,  1226,  1228,  1230,  1232,  1234,  1237,  1236,  1248,  1249,
     1022    1251,  1261,  1262,  1267,  1271,  1273,  1275,  1277,  1279,  1281,
     1023    1283,  1285,  1290,  1292,  1294,  1296,  1298,  1300,  1302,  1304,
     1024    1306,  1308,  1310,  1312,  1318,  1319,  1321,  1323,  1325,  1330,
     1025    1331,  1337,  1338,  1340,  1342,  1347,  1349,  1351,  1353,  1358,
     1026    1359,  1361,  1363,  1368,  1369,  1371,  1376,  1377,  1379,  1381,
     1027    1386,  1388,  1390,  1395,  1396,  1400,  1402,  1404,  1406,  1408,
     1028    1413,  1415,  1420,  1422,  1427,  1428,  1430,  1431,  1436,  1437,
     1029    1439,  1441,  1446,  1448,  1454,  1455,  1457,  1460,  1463,  1468,
     1030    1469,  1474,  1479,  1483,  1485,  1487,  1492,  1494,  1500,  1501,
     1031    1509,  1510,  1514,  1515,  1516,  1518,  1520,  1527,  1528,  1530,
     1032    1532,  1537,  1538,  1544,  1545,  1549,  1550,  1555,  1556,  1557,
     1033    1559,  1567,  1568,  1570,  1573,  1575,  1579,  1580,  1581,  1583,
     1034    1585,  1589,  1594,  1602,  1603,  1612,  1614,  1619,  1620,  1621,
     1035    1625,  1626,  1627,  1631,  1632,  1633,  1637,  1638,  1639,  1644,
     1036    1645,  1646,  1647,  1653,  1654,  1659,  1660,  1664,  1665,  1666,
     1037    1667,  1682,  1683,  1688,  1689,  1696,  1698,  1700,  1703,  1705,
     1038    1707,  1730,  1731,  1733,  1735,  1740,  1741,  1743,  1748,  1753,
     1039    1754,  1760,  1759,  1763,  1767,  1769,  1771,  1777,  1778,  1783,
     1040    1788,  1790,  1795,  1797,  1798,  1800,  1805,  1807,  1809,  1814,
     1041    1816,  1821,  1826,  1834,  1840,  1839,  1853,  1854,  1859,  1860,
     1042    1864,  1869,  1874,  1882,  1887,  1898,  1899,  1910,  1911,  1917,
     1043    1918,  1922,  1923,  1924,  1927,  1926,  1937,  1942,  1947,  1953,
     1044    1962,  1968,  1974,  1980,  1986,  1994,  2000,  2008,  2014,  2023,
     1045    2024,  2025,  2029,  2033,  2035,  2040,  2041,  2045,  2046,  2051,
     1046    2057,  2058,  2061,  2063,  2064,  2068,  2069,  2070,  2071,  2105,
     1047    2107,  2108,  2110,  2115,  2120,  2125,  2127,  2129,  2134,  2136,
     1048    2138,  2140,  2145,  2147,  2157,  2159,  2160,  2165,  2167,  2169,
     1049    2174,  2176,  2178,  2183,  2185,  2187,  2196,  2197,  2198,  2202,
     1050    2204,  2206,  2211,  2213,  2215,  2220,  2222,  2224,  2239,  2241,
     1051    2242,  2244,  2249,  2250,  2255,  2257,  2259,  2264,  2266,  2268,
     1052    2270,  2275,  2277,  2279,  2289,  2291,  2292,  2294,  2299,  2301,
     1053    2303,  2308,  2310,  2312,  2314,  2319,  2321,  2323,  2354,  2356,
     1054    2357,  2359,  2364,  2369,  2377,  2379,  2381,  2386,  2388,  2393,
     1055    2395,  2409,  2410,  2412,  2417,  2419,  2421,  2423,  2425,  2430,
     1056    2431,  2433,  2435,  2440,  2442,  2444,  2450,  2452,  2454,  2458,
     1057    2460,  2462,  2464,  2478,  2479,  2481,  2486,  2488,  2490,  2492,
     1058    2494,  2499,  2500,  2502,  2504,  2509,  2511,  2513,  2519,  2520,
     1059    2522,  2531,  2534,  2536,  2539,  2541,  2543,  2556,  2557,  2559,
     1060    2564,  2566,  2568,  2570,  2572,  2577,  2578,  2580,  2582,  2587,
     1061    2589,  2597,  2598,  2599,  2604,  2605,  2609,  2611,  2613,  2615,
     1062    2617,  2619,  2626,  2628,  2630,  2632,  2634,  2636,  2638,  2640,
     1063    2642,  2644,  2649,  2651,  2653,  2658,  2684,  2685,  2687,  2691,
     1064    2692,  2696,  2698,  2700,  2702,  2704,  2706,  2713,  2715,  2717,
     1065    2719,  2721,  2723,  2728,  2733,  2735,  2737,  2755,  2757,  2762,
     1066    2763
    10581067};
    10591068#endif
     
    11031112  "exception_statement", "handler_list", "handler_clause",
    11041113  "finally_clause", "exception_declaration", "asm_statement",
    1105   "asm_operands_opt", "asm_operands_list", "asm_operand",
    1106   "asm_clobbers_list", "declaration_list_opt", "declaration_list",
    1107   "old_declaration_list_opt", "old_declaration_list",
    1108   "label_declaration_opt", "label_declaration_list", "label_list",
    1109   "declaration", "new_declaration", "new_variable_declaration",
    1110   "new_variable_specifier", "new_function_declaration",
    1111   "new_function_specifier", "new_function_return",
    1112   "new_typedef_declaration", "typedef_declaration", "typedef_expression",
    1113   "old_declaration", "declaring_list", "declaration_specifier",
    1114   "type_specifier", "type_qualifier_list_opt", "type_qualifier_list",
    1115   "type_qualifier", "type_qualifier_name", "$@1",
     1114  "asm_volatile_opt", "asm_operands_opt", "asm_operands_list",
     1115  "asm_operand", "asm_clobbers_list_opt", "label_list",
     1116  "declaration_list_opt", "declaration_list", "old_declaration_list_opt",
     1117  "old_declaration_list", "local_label_declaration_opt",
     1118  "local_label_declaration_list", "local_label_list", "declaration",
     1119  "new_declaration", "new_variable_declaration", "new_variable_specifier",
     1120  "new_function_declaration", "new_function_specifier",
     1121  "new_function_return", "new_typedef_declaration", "typedef_declaration",
     1122  "typedef_expression", "old_declaration", "declaring_list",
     1123  "declaration_specifier", "type_specifier", "type_qualifier_list_opt",
     1124  "type_qualifier_list", "type_qualifier", "type_qualifier_name", "$@1",
    11161125  "declaration_qualifier_list", "storage_class_list", "storage_class",
    11171126  "storage_class_name", "basic_type_name", "basic_declaration_specifier",
     
    11971206       0,   125,   126,   127,   128,   128,   128,   129,   129,   129,
    11981207     130,   130,   131,   132,   132,   133,   133,   134,   134,   134,
    1199      134,   134,   134,   135,   135,   135,   135,   135,   135,   135,
    1200      135,   135,   135,   136,   136,   137,   137,   137,   137,   137,
    1201      138,   138,   139,   139,   139,   139,   139,   140,   140,   140,
     1208     134,   135,   135,   135,   135,   135,   135,   135,   135,   135,
     1209     135,   136,   136,   137,   137,   137,   137,   137,   138,   138,
     1210     139,   139,   139,   139,   139,   140,   140,   140,   140,   140,
    12021211     140,   140,   140,   140,   140,   140,   140,   140,   140,   140,
    12031212     140,   140,   141,   141,   141,   141,   142,   142,   142,   143,
     
    12161225     183,   183,   184,   184,   184,   185,   185,   185,   186,   186,
    12171226     187,   188,   188,   188,   188,   188,   189,   189,   189,   189,
    1218      190,   190,   191,   191,   192,   193,   193,   194,   194,   195,
    1219      195,   196,   196,   197,   197,   198,   198,   199,   199,   200,
    1220      200,   201,   201,   202,   202,   202,   202,   202,   203,   203,
    1221      203,   204,   204,   204,   205,   205,   205,   205,   205,   206,
    1222      206,   206,   207,   207,   208,   208,   208,   209,   209,   209,
    1223      209,   209,   210,   210,   211,   211,   211,   211,   212,   212,
    1224      213,   213,   213,   213,   214,   214,   214,   214,   215,   215,
    1225      216,   216,   217,   217,   218,   218,   218,   218,   218,   219,
    1226      218,   220,   220,   220,   221,   221,   222,   223,   223,   223,
    1227      223,   223,   223,   223,   223,   224,   224,   224,   224,   224,
    1228      224,   224,   224,   224,   224,   224,   224,   225,   225,   225,
    1229      225,   225,   226,   226,   227,   227,   227,   227,   228,   228,
    1230      228,   228,   229,   229,   229,   229,   230,   230,   230,   231,
    1231      231,   231,   231,   232,   232,   232,   233,   233,   234,   234,
    1232      234,   234,   234,   235,   235,   236,   236,   237,   237,   237,
    1233      237,   238,   238,   238,   238,   239,   239,   240,   240,   240,
    1234      240,   240,   241,   241,   242,   243,   244,   244,   244,   245,
    1235      245,   246,   246,   247,   247,   248,   248,   248,   248,   248,
    1236      249,   249,   249,   249,   250,   250,   251,   251,   252,   252,
    1237      253,   253,   253,   253,   254,   254,   254,   254,   254,   255,
    1238      255,   255,   255,   255,   256,   256,   257,   257,   258,   258,
    1239      259,   259,   259,   260,   260,   260,   261,   261,   261,   262,
    1240      262,   262,   263,   263,   263,   263,   264,   264,   265,   265,
    1241      266,   266,   266,   266,   267,   267,   268,   268,   269,   269,
    1242      269,   269,   269,   270,   270,   270,   270,   271,   271,   271,
    1243      272,   273,   273,   275,   274,   274,   276,   276,   276,   277,
    1244      277,   278,   278,   278,   279,   279,   279,   279,   280,   280,
    1245      280,   281,   281,   282,   282,   283,   284,   283,   285,   285,
    1246      286,   286,   287,   287,   287,   288,   288,   289,   289,   290,
    1247      290,   291,   291,   292,   292,   292,   293,   292,   292,   294,
    1248      294,   294,   295,   295,   295,   295,   295,   295,   295,   295,
    1249      295,   296,   296,   296,   297,   298,   298,   299,   299,   300,
    1250      300,   301,   302,   302,   303,   303,   303,   304,   304,   304,
    1251      304,   305,   305,   305,   305,   306,   306,   307,   307,   307,
    1252      308,   308,   308,   308,   309,   309,   310,   310,   310,   311,
    1253      311,   311,   312,   312,   312,   313,   313,   313,   314,   314,
    1254      314,   315,   315,   315,   316,   316,   316,   317,   317,   317,
    1255      318,   318,   318,   318,   319,   319,   320,   320,   320,   321,
    1256      321,   321,   321,   322,   322,   322,   323,   323,   323,   323,
    1257      324,   324,   324,   325,   325,   325,   325,   326,   326,   326,
    1258      327,   327,   327,   327,   328,   328,   329,   329,   329,   330,
    1259      330,   331,   331,   332,   332,   332,   333,   333,   333,   333,
    1260      333,   334,   334,   334,   334,   335,   335,   335,   336,   336,
    1261      336,   337,   337,   337,   337,   338,   338,   338,   339,   339,
    1262      339,   339,   339,   340,   340,   340,   340,   341,   341,   341,
    1263      342,   342,   342,   343,   343,   343,   343,   343,   343,   344,
    1264      344,   344,   345,   345,   345,   345,   345,   346,   346,   346,
    1265      346,   347,   347,   348,   348,   348,   349,   349,   350,   350,
    1266      350,   350,   350,   350,   351,   351,   351,   351,   351,   351,
    1267      351,   351,   351,   351,   352,   352,   352,   352,   353,   353,
    1268      353,   354,   354,   355,   355,   355,   355,   355,   355,   356,
    1269      356,   356,   356,   356,   356,   357,   358,   358,   358,   359,
    1270      359,   360,   360
     1227     189,   190,   190,   191,   191,   192,   192,   193,   193,   194,
     1228     194,   194,   195,   195,   196,   196,   197,   197,   198,   198,
     1229     199,   199,   200,   200,   201,   201,   202,   202,   203,   203,
     1230     204,   204,   204,   204,   204,   205,   205,   205,   206,   206,
     1231     206,   207,   207,   207,   207,   207,   208,   208,   208,   209,
     1232     209,   210,   210,   210,   211,   211,   211,   211,   211,   212,
     1233     212,   213,   213,   213,   213,   214,   214,   215,   215,   215,
     1234     215,   216,   216,   216,   216,   217,   217,   218,   218,   219,
     1235     219,   220,   220,   220,   220,   220,   221,   220,   222,   222,
     1236     222,   223,   223,   224,   225,   225,   225,   225,   225,   225,
     1237     225,   225,   226,   226,   226,   226,   226,   226,   226,   226,
     1238     226,   226,   226,   226,   227,   227,   227,   227,   227,   228,
     1239     228,   229,   229,   229,   229,   230,   230,   230,   230,   231,
     1240     231,   231,   231,   232,   232,   232,   233,   233,   233,   233,
     1241     234,   234,   234,   235,   235,   236,   236,   236,   236,   236,
     1242     237,   237,   238,   238,   239,   239,   239,   239,   240,   240,
     1243     240,   240,   241,   241,   242,   242,   242,   242,   242,   243,
     1244     243,   244,   245,   246,   246,   246,   247,   247,   248,   248,
     1245     249,   249,   250,   250,   250,   250,   250,   251,   251,   251,
     1246     251,   252,   252,   253,   253,   254,   254,   255,   255,   255,
     1247     255,   256,   256,   256,   256,   256,   257,   257,   257,   257,
     1248     257,   258,   258,   259,   259,   260,   260,   261,   261,   261,
     1249     262,   262,   262,   263,   263,   263,   264,   264,   264,   265,
     1250     265,   265,   265,   266,   266,   267,   267,   268,   268,   268,
     1251     268,   269,   269,   270,   270,   271,   271,   271,   271,   271,
     1252     271,   272,   272,   272,   272,   273,   273,   273,   274,   275,
     1253     275,   277,   276,   276,   278,   278,   278,   279,   279,   280,
     1254     280,   280,   281,   281,   281,   281,   282,   282,   282,   283,
     1255     283,   284,   284,   285,   286,   285,   287,   287,   288,   288,
     1256     289,   289,   289,   290,   290,   291,   291,   292,   292,   293,
     1257     293,   294,   294,   294,   295,   294,   294,   296,   296,   296,
     1258     297,   297,   297,   297,   297,   297,   297,   297,   297,   298,
     1259     298,   298,   299,   300,   300,   301,   301,   302,   302,   303,
     1260     304,   304,   305,   305,   305,   306,   306,   306,   306,   307,
     1261     307,   307,   307,   308,   308,   309,   309,   309,   310,   310,
     1262     310,   310,   311,   311,   312,   312,   312,   313,   313,   313,
     1263     314,   314,   314,   315,   315,   315,   316,   316,   316,   317,
     1264     317,   317,   318,   318,   318,   319,   319,   319,   320,   320,
     1265     320,   320,   321,   321,   322,   322,   322,   323,   323,   323,
     1266     323,   324,   324,   324,   325,   325,   325,   325,   326,   326,
     1267     326,   327,   327,   327,   327,   328,   328,   328,   329,   329,
     1268     329,   329,   330,   330,   331,   331,   331,   332,   332,   333,
     1269     333,   334,   334,   334,   335,   335,   335,   335,   335,   336,
     1270     336,   336,   336,   337,   337,   337,   338,   338,   338,   339,
     1271     339,   339,   339,   340,   340,   340,   341,   341,   341,   341,
     1272     341,   342,   342,   342,   342,   343,   343,   343,   344,   344,
     1273     344,   345,   345,   345,   345,   345,   345,   346,   346,   346,
     1274     347,   347,   347,   347,   347,   348,   348,   348,   348,   349,
     1275     349,   350,   350,   350,   351,   351,   352,   352,   352,   352,
     1276     352,   352,   353,   353,   353,   353,   353,   353,   353,   353,
     1277     353,   353,   354,   354,   354,   354,   355,   355,   355,   356,
     1278     356,   357,   357,   357,   357,   357,   357,   358,   358,   358,
     1279     358,   358,   358,   359,   360,   360,   360,   361,   361,   362,
     1280     362
    12711281};
    12721282
     
    12751285{
    12761286       0,     2,     0,     0,     1,     1,     1,     1,     1,     1,
    1277        1,     1,     1,     1,     1,     1,     2,     1,     1,     1,
    1278        1,     3,     3,     1,     6,     4,     3,     7,     3,     7,
    1279        2,     2,     7,     1,     3,     0,     1,     3,     7,     9,
    1280        1,     3,     1,     3,     7,     3,     7,     1,     2,     2,
     1287       1,     1,     1,     1,     1,     1,     2,     1,     1,     3,
     1288       3,     1,     6,     4,     3,     7,     3,     7,     2,     2,
     1289       7,     1,     3,     0,     1,     3,     7,     9,     1,     3,
     1290       1,     3,     7,     3,     7,     1,     1,     1,     2,     2,
    12811291       2,     2,     2,     2,     2,     4,     1,     4,     4,     2,
    12821292       4,     2,     1,     1,     1,     1,     1,     4,     4,     1,
     
    12951305       3,     2,     3,     3,     4,     1,     5,     6,     9,    10,
    12961306       2,     1,     2,     2,     2,     1,     6,     8,    10,    12,
    1297        0,     1,     1,     3,     4,     1,     3,     1,     1,     1,
    1298        3,     1,     1,     1,     3,     0,     1,     3,     4,     1,
    1299        3,     1,     1,     3,     3,     3,     3,     3,     2,     3,
    1300        6,     3,     3,     4,     1,     2,     2,     3,     5,     8,
    1301        7,     7,     5,     9,     2,     2,     5,     3,     5,     4,
    1302        3,     4,     4,     7,     3,     3,     3,     3,     4,     6,
    1303        1,     1,     1,     1,     1,     1,     1,     1,     0,     1,
    1304        1,     2,     1,     1,     1,     1,     1,     1,     1,     0,
    1305        5,     1,     2,     3,     1,     2,     1,     1,     1,     1,
     1307      14,     0,     1,     0,     1,     1,     3,     4,     7,     0,
     1308       1,     3,     1,     3,     1,     1,     1,     3,     1,     1,
     1309       1,     3,     0,     1,     3,     4,     1,     3,     1,     1,
     1310       3,     3,     3,     3,     3,     2,     3,     6,     3,     3,
     1311       4,     1,     2,     2,     3,     5,     8,     7,     7,     5,
     1312       9,     2,     2,     5,     3,     5,     4,     3,     4,     4,
     1313       7,     3,     3,     3,     3,     4,     6,     1,     1,     1,
     1314       1,     1,     1,     1,     1,     0,     1,     1,     2,     1,
     1315       1,     1,     1,     1,     1,     1,     0,     5,     1,     2,
     1316       3,     1,     2,     1,     1,     1,     1,     1,     1,     1,
    13061317       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
    1307        1,     1,     1,     1,     1,     1,     1,     1,     2,     2,
    1308        3,     3,     1,     3,     1,     2,     2,     2,     4,     4,
    1309        4,     4,     1,     2,     2,     3,     1,     2,     2,     1,
    1310        2,     2,     3,     1,     2,     2,     1,     1,     4,     2,
    1311        5,     7,     2,     2,     2,     1,     2,     2,     3,     2,
    1312        3,     1,     2,     3,     2,     2,     4,     0,     1,     2,
    1313        2,     1,     0,     1,     2,     2,     5,     6,     2,     2,
    1314        4,     0,     2,     0,     1,     1,     1,     5,     5,     5,
    1315        1,     5,     5,     9,     1,     5,     0,     1,     1,     5,
    1316        1,     1,     5,     5,     1,     3,     3,     4,     1,     1,
    1317        1,     1,     2,     1,     3,     3,     1,     2,     1,     3,
    1318        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
    1319        1,     2,     1,     1,     1,     2,     0,     2,     1,     4,
    1320        1,     2,     3,     4,     2,     2,     1,     2,     2,     5,
    1321        5,     7,     6,     1,     2,     2,     3,     1,     2,     2,
    1322        4,     2,     4,     0,     4,     2,     1,     1,     1,     0,
    1323        2,     5,     5,    13,     1,     1,     3,     3,     2,     3,
    1324        3,     2,     4,     1,     6,     9,     0,    11,     1,     3,
    1325        3,     3,     1,     1,     5,     2,     5,     0,     1,     1,
    1326        3,     0,     1,     1,     1,     1,     0,     6,     2,     1,
    1327        2,     4,     2,     3,     3,     3,     4,     5,     5,     5,
    1328        6,     1,     1,     1,     3,     0,     5,     0,     1,     1,
    1329        2,     6,     1,     3,     0,     1,     4,     1,     1,     1,
    1330        1,     2,     1,     2,     2,     1,     3,     2,     3,     3,
    1331        2,     4,     4,     3,     8,     3,     2,     1,     2,     6,
    1332        8,     3,     2,     3,     3,     4,     4,     3,     1,     1,
    1333        1,     4,     6,     3,     2,     3,     3,     4,     4,     3,
    1334        2,     1,     2,     2,     1,     3,     2,     3,     3,     2,
    1335        4,     4,     3,     6,     8,     3,     2,     1,     2,     2,
    1336        2,     3,     3,     2,     4,     4,     3,     6,     8,     3,
    1337        2,     1,     2,     2,     1,     1,     2,     3,     3,     2,
    1338        4,     6,     8,     1,     2,     2,     1,     2,     2,     3,
    1339        3,     1,     4,     4,     3,     5,     8,     3,     2,     3,
    1340        1,     5,     5,     6,     6,     1,     2,     2,     1,     2,
    1341        2,     3,     3,     1,     4,     4,     3,     5,     8,     3,
    1342        1,     2,     1,     2,     6,     5,     6,     7,     7,     1,
    1343        2,     2,     1,     2,     2,     3,     3,     1,     4,     4,
    1344        3,     8,     3,     1,     1,     2,     1,     1,     2,     3,
    1345        2,     3,     2,     3,     3,     2,     4,     3,     2,     3,
    1346        2,     4,     3,     2,     6,     6,     6,     7,     1,     2,
    1347        1,     1,     1,     2,     3,     2,     3,     2,     3,     3,
    1348        4,     2,     3,     4,     2,     5,     5,     6,     6,     0,
    1349        1,     0,     2
     1318       1,     1,     1,     1,     1,     2,     2,     3,     3,     1,
     1319       3,     1,     2,     2,     2,     4,     4,     4,     4,     1,
     1320       2,     2,     3,     1,     2,     2,     1,     2,     2,     3,
     1321       1,     2,     2,     1,     1,     4,     2,     5,     7,     2,
     1322       2,     2,     1,     2,     2,     3,     2,     3,     1,     2,
     1323       3,     2,     2,     4,     0,     1,     2,     2,     1,     0,
     1324       1,     2,     2,     5,     6,     2,     2,     4,     0,     2,
     1325       0,     1,     1,     1,     5,     5,     5,     1,     5,     5,
     1326       9,     1,     5,     0,     1,     1,     5,     1,     1,     5,
     1327       5,     1,     3,     3,     4,     1,     1,     1,     1,     2,
     1328       1,     3,     3,     1,     2,     1,     3,     1,     1,     1,
     1329       1,     1,     1,     1,     1,     1,     1,     1,     2,     1,
     1330       1,     1,     2,     0,     2,     1,     4,     1,     2,     3,
     1331       4,     2,     2,     1,     2,     1,     2,     5,     5,     7,
     1332       6,     1,     2,     2,     3,     1,     2,     2,     4,     2,
     1333       4,     0,     4,     2,     1,     1,     1,     0,     2,     5,
     1334       5,    13,     1,     1,     3,     3,     2,     3,     3,     2,
     1335       4,     1,     6,     9,     0,    11,     1,     3,     3,     3,
     1336       1,     1,     5,     2,     5,     0,     1,     1,     3,     0,
     1337       1,     1,     1,     1,     0,     6,     2,     1,     2,     4,
     1338       2,     3,     3,     3,     4,     5,     5,     5,     6,     1,
     1339       1,     1,     3,     0,     5,     0,     1,     1,     2,     6,
     1340       1,     3,     0,     1,     4,     1,     1,     1,     1,     2,
     1341       1,     2,     2,     1,     3,     2,     3,     3,     2,     4,
     1342       4,     3,     8,     3,     2,     1,     2,     6,     8,     3,
     1343       2,     3,     3,     4,     4,     3,     1,     1,     1,     4,
     1344       6,     3,     2,     3,     3,     4,     4,     3,     2,     1,
     1345       2,     2,     1,     3,     2,     3,     3,     2,     4,     4,
     1346       3,     6,     8,     3,     2,     1,     2,     2,     2,     3,
     1347       3,     2,     4,     4,     3,     6,     8,     3,     2,     1,
     1348       2,     2,     1,     1,     2,     3,     3,     2,     4,     6,
     1349       8,     1,     2,     2,     1,     2,     2,     3,     3,     1,
     1350       4,     4,     3,     5,     8,     3,     2,     3,     1,     5,
     1351       5,     6,     6,     1,     2,     2,     1,     2,     2,     3,
     1352       3,     1,     4,     4,     3,     5,     8,     3,     1,     2,
     1353       1,     2,     6,     5,     6,     7,     7,     1,     2,     2,
     1354       1,     2,     2,     3,     3,     1,     4,     4,     3,     8,
     1355       3,     1,     1,     2,     1,     1,     2,     3,     2,     3,
     1356       2,     3,     3,     2,     4,     3,     2,     3,     2,     4,
     1357       3,     2,     6,     6,     6,     7,     1,     2,     1,     1,
     1358       1,     2,     3,     2,     3,     2,     3,     3,     4,     2,
     1359       3,     4,     2,     5,     5,     6,     6,     0,     1,     0,
     1360       2
    13501361};
    13511362
     
    13551366static const yytype_uint16 yydefact[] =
    13561367{
    1357      278,   278,   299,   297,   300,   298,   301,   302,   284,   286,
    1358      285,     0,   287,   313,   305,   310,   308,   309,   307,   306,
    1359      311,   312,   314,   315,   316,   527,   527,   527,     0,     0,
    1360        0,   278,   278,   288,   303,   304,     7,   343,     0,     8,
    1361       13,    14,     0,     2,   278,   545,     9,   505,   503,   231,
    1362        3,   436,     3,   244,     0,     3,     3,     3,   232,     3,
    1363        0,     0,     0,   279,   280,   282,   278,   291,   294,   296,
    1364      324,   270,   317,   322,   271,   332,   272,   339,   336,   346,
    1365        0,     0,   347,   273,   453,   457,     3,     3,     0,     2,
    1366      499,   504,   509,   283,     0,     0,   527,   557,   527,     2,
    1367      568,   569,   570,   278,     0,   711,   712,     0,    12,   278,
    1368        0,   254,   255,     0,   279,   274,   275,   276,   277,   506,
    1369      289,   375,   528,   529,   353,   354,    12,   427,   428,    11,
    1370      423,   426,     0,   483,   478,   469,   427,   428,     0,     0,
    1371      508,     0,   279,   278,     0,     0,     0,     0,     0,     0,
    1372        0,     0,   278,   278,     2,     0,   713,   279,   562,   574,
    1373      717,   710,   708,   715,     0,     0,   238,     2,     0,   512,
    1374      421,   422,   420,     0,     0,     0,     0,   527,     0,   614,
    1375      615,     0,     0,   525,   521,   527,   542,   527,   527,   522,
    1376        2,   523,   527,   581,   527,   527,   584,     0,     0,     0,
    1377      278,   278,   297,   344,     2,   278,   245,   281,   292,   325,
    1378      337,   458,     0,     2,     0,   436,   246,   279,   318,   333,
    1379      340,   454,     0,     2,     0,   295,   319,   326,   327,     0,
    1380      334,   338,   341,   345,   428,   278,   278,   349,   352,     0,
    1381      378,   455,   459,     0,     0,     0,     1,   278,     2,   510,
    1382      556,   558,   278,     2,   721,   279,   724,   525,   525,   279,
    1383        0,     0,     0,   257,   527,   522,     2,   278,     0,     0,
    1384      278,   530,     2,   481,     2,   534,     0,     0,     0,     0,
    1385       17,    56,     4,     5,     6,    15,     0,     0,     0,   278,
    1386        2,     0,   278,    62,    63,    64,    65,    19,    18,    20,
    1387       23,    47,    66,     0,    69,    73,    76,    79,    84,    87,
    1388       89,    91,    93,    95,    97,   102,   475,   731,   434,   474,
    1389        0,   432,   433,     0,   546,   561,   564,   567,   573,   576,
    1390      579,   343,     0,     2,   719,     0,   278,   722,     2,   278,
    1391        3,   408,     0,   416,   279,   278,   291,   317,   271,   332,
    1392      339,     3,     3,   390,   394,   404,   409,   453,   278,   410,
    1393      686,   687,   278,   411,   413,   278,     2,   563,   575,   709,
    1394        2,     2,   233,     2,     0,     0,   438,   437,   137,     2,
    1395        2,   235,     2,     2,   234,     2,   265,     2,   266,     0,
    1396      264,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    1397      547,   586,     0,   436,     2,   541,   550,   640,   543,   544,
    1398      513,   278,     2,   580,   589,   582,   583,     0,   260,   278,
    1399      278,   323,     0,   279,     0,   278,   714,   718,   716,   514,
    1400      278,   525,   239,   247,   293,     0,     2,   515,   278,   479,
    1401      320,   321,   267,   335,   342,     0,   278,     2,   367,   278,
    1402      355,     0,     0,   361,   708,   278,   729,   381,     0,   456,
    1403      480,   236,   237,   500,   278,   418,     0,   278,   221,     0,
    1404        2,   223,     0,   279,     0,   241,     2,   242,   262,     0,
    1405        0,     2,   278,   525,   278,   466,   468,   467,     0,     0,
    1406      731,     0,   278,     0,   278,   470,   278,   540,   538,   539,
    1407      537,     0,   532,   535,    66,   101,     0,   278,    54,    50,
    1408      278,    59,   278,   278,    48,    49,    61,     2,   124,     0,
    1409        0,   430,     0,   429,   108,   278,    52,    53,    16,     0,
    1410       30,    31,    35,     2,     0,   114,   115,   116,   117,   118,
    1411      119,   120,   121,   122,   123,     0,     0,    51,     0,     0,
     1368     285,   285,   306,   304,   307,   305,   308,   309,   291,   293,
     1369     292,     0,   294,   320,   312,   317,   315,   316,   314,   313,
     1370     318,   319,   321,   322,   323,   535,   535,   535,     0,     0,
     1371       0,   285,   211,   295,   310,   311,     7,   350,     0,     8,
     1372      13,    14,     0,     2,   285,   553,     9,   513,   511,   238,
     1373       3,   443,     3,   251,     0,     3,     3,     3,   239,     3,
     1374       0,     0,     0,   286,   287,   289,   285,   298,   301,   303,
     1375     331,   277,   324,   329,   278,   339,   279,   346,   343,   353,
     1376       0,     0,   354,   280,   461,   465,     3,     3,     0,     2,
     1377     507,   512,   517,   290,     0,     0,   535,   565,   535,     2,
     1378     576,   577,   578,   285,     0,   719,   720,     0,    12,   285,
     1379       0,   261,   262,     0,   286,   281,   282,   283,   284,   514,
     1380     296,   382,   536,   537,   360,   361,    12,   434,   435,    11,
     1381     430,   433,     0,   491,   486,   477,   434,   435,     0,     0,
     1382     516,   212,     0,   285,     0,     0,     0,     0,     0,     0,
     1383       0,     0,   285,   285,     2,     0,   721,   286,   570,   582,
     1384     725,   718,   716,   723,     0,     0,   245,     2,     0,   520,
     1385     428,   429,   427,     0,     0,     0,     0,   535,     0,   622,
     1386     623,     0,     0,   533,   529,   535,   550,   535,   535,   530,
     1387       2,   531,   535,   589,   535,   535,   592,     0,     0,     0,
     1388     285,   285,   304,   351,     2,   285,   252,   288,   299,   332,
     1389     344,   466,     0,     2,     0,   443,   253,   286,   325,   340,
     1390     347,   462,     0,     2,     0,   302,   326,   333,   334,     0,
     1391     341,   345,   348,   352,   435,   285,   285,   356,   359,     0,
     1392     385,   463,   467,     0,     0,     0,     1,   285,     2,   518,
     1393     564,   566,   285,     2,   729,   286,   732,   533,   533,   286,
     1394       0,     0,     0,   264,   535,   530,     2,   285,     0,     0,
     1395     285,   538,     2,   489,     2,   542,     0,     0,     0,     0,
     1396       0,    17,    56,     4,     5,     6,    15,     0,     0,     0,
     1397     285,     2,     0,   285,    62,    63,    64,    65,    46,    18,
     1398      47,    21,    45,    66,     0,    69,    73,    76,    79,    84,
     1399      87,    89,    91,    93,    95,    97,   102,   483,   739,   441,
     1400     482,     0,   439,   440,     0,   554,   569,   572,   575,   581,
     1401     584,   587,   350,     0,     2,   727,     0,   285,   730,     2,
     1402     285,     3,   415,     0,   423,   286,   285,   298,   324,   278,
     1403     339,   346,     3,     3,   397,   401,   411,   416,   461,   285,
     1404     417,   694,   695,   285,   418,   420,   285,     2,   571,   583,
     1405     717,     2,     2,   240,     2,     0,     0,   445,   444,   137,
     1406       2,     2,   242,     2,     2,   241,     2,   272,     2,   273,
     1407       0,   271,     0,     0,     0,     0,     0,     0,     0,     0,
     1408       0,   555,   594,     0,   443,     2,   549,   558,   648,   551,
     1409     552,   521,   285,     2,   588,   597,   590,   591,     0,   267,
     1410     285,   285,   330,   286,     0,   286,     0,   285,   722,   726,
     1411     724,   522,   285,   533,   246,   254,   300,     0,     2,   523,
     1412     285,   487,   327,   328,   274,   342,   349,     0,   285,     2,
     1413     374,   285,   362,     0,     0,   368,   716,   285,   737,   388,
     1414       0,   464,   488,   243,   244,   508,   285,   425,     0,   285,
     1415     228,     0,     2,   230,     0,   286,     0,   248,     2,   249,
     1416     269,     0,     0,     2,   285,   533,   285,   474,   476,   475,
     1417       0,     0,   739,     0,   285,     0,   285,   478,   285,   548,
     1418     546,   547,   545,     0,   540,   543,     0,     0,   285,    54,
     1419      66,    50,   285,    59,   285,   285,    48,    49,    61,     2,
     1420     124,     0,     0,   437,     0,   436,   108,   285,    52,    53,
     1421      16,     0,    28,    29,    33,     2,     0,   114,   115,   116,
     1422     117,   118,   119,   120,   121,   122,   123,     0,     0,    51,
    14121423       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    1413        0,     0,     0,     0,     0,     0,     0,     0,   105,     2,
    1414      626,   435,   623,   527,   527,   631,   460,   278,     2,   565,
    1415      566,     0,   577,   578,     0,     2,   720,   723,   108,   278,
    1416        2,   278,     0,   688,   279,   692,   683,   684,   690,     0,
    1417        2,     2,   648,   527,   731,   597,   527,   527,   731,   527,
    1418      611,   527,   527,   662,   417,   645,   527,   527,   653,   660,
    1419      278,   412,   279,     0,     0,   278,   698,   279,   703,   731,
    1420      695,   278,   700,   731,   278,   278,   278,     0,   108,     0,
    1421       17,     2,     0,     0,   440,   729,     0,     0,   446,   225,
    1422        0,   278,     0,     0,     0,   525,   549,   553,   555,   585,
    1423      588,   592,   595,   548,   587,     0,   268,   638,     0,   278,
    1424      261,     0,     0,     0,     0,   259,     2,     0,   243,   516,
    1425      278,     0,     0,     0,     0,   278,   278,     0,     0,   672,
    1426      365,   368,   372,   527,   372,   677,   371,   669,   527,   527,
    1427      348,   356,   364,   357,   527,   359,   362,   278,   730,     0,
    1428        0,   379,   729,   279,     3,   397,     3,   401,   400,   571,
    1429        0,   511,   278,     3,     3,   278,   416,   279,     3,   410,
    1430      411,     2,     0,     0,     0,   465,   290,   278,   461,   463,
    1431        3,     2,     2,     0,   482,     3,     0,   534,   126,     0,
    1432      210,     0,     0,     2,     0,     0,    36,     0,     0,   108,
    1433      278,    21,     0,    22,     0,   672,   431,     0,   106,     3,
    1434        2,    28,     2,     0,    33,     0,     2,    26,   103,   104,
    1435       70,    71,    72,    74,    75,    77,    78,    82,    83,    80,
    1436       81,    85,    86,    88,    90,    92,    94,    96,     0,     0,
    1437      732,   278,     0,     0,     0,   627,   628,   624,   625,   477,
    1438      476,   278,     0,     3,   278,   694,   278,   699,   279,   278,
    1439      278,   278,   642,   685,   641,     2,   278,     0,     0,     0,
    1440        0,     0,     0,     0,     0,   663,     0,   649,   600,   616,
    1441      650,     2,   596,   603,   414,   598,   599,   415,     2,   610,
    1442      619,   612,   613,   646,   647,   661,   689,   693,   691,   731,
    1443      252,     2,   725,     2,   405,   697,   702,   406,     0,   384,
    1444        3,     3,     3,     3,   436,     3,     0,     2,   448,   445,
    1445      730,     0,   441,     2,   444,   447,     0,   278,   226,   248,
    1446        3,   256,   258,     0,   436,     2,   551,   552,     2,   590,
    1447      591,     0,   639,   517,     3,   329,   328,   331,   330,   278,
    1448      518,     0,   519,   278,   358,   360,     2,     0,     0,     0,
    1449        0,   374,   673,   674,   369,   373,   370,   670,   671,   363,
    1450      367,   350,   381,   376,   382,     0,     0,     0,   419,   224,
    1451        0,     0,     3,     2,   648,   412,     0,   507,     0,   731,
    1452      469,     0,   278,   278,   278,     0,   531,   533,   127,     0,
    1453      206,     0,     0,   211,   212,    55,    60,   278,     0,    58,
    1454       57,     0,   125,   673,     0,    67,    68,   107,   112,     3,
    1455      106,     0,     0,     0,    25,    35,     3,     0,    99,     0,
    1456        3,   630,   634,   637,   629,     3,   572,     3,   696,   701,
    1457        2,   278,     3,     3,   279,     0,     3,   602,   606,   609,
    1458      618,   652,   656,   659,   278,     3,   601,   617,   651,   278,
    1459      278,   407,   278,   278,   726,     0,     0,     0,     0,   240,
    1460        0,   101,     0,     3,     3,     0,   442,     0,   439,     0,
    1461        0,   229,   278,     0,     0,   126,     0,     0,     0,     0,
    1462        0,   126,     0,     0,     0,     2,     0,     0,     3,   128,
    1463      129,     2,   139,   130,   131,   132,   133,   134,   135,   141,
    1464      143,     0,     0,     0,   269,   278,   278,   527,     0,   520,
    1465      278,   108,   676,   680,   682,   675,   366,   380,   377,   559,
    1466        2,   644,   643,     0,   649,     2,   462,   464,   484,     3,
    1467      492,   493,     0,     2,   488,     3,     3,     0,     0,   536,
    1468        0,     0,   210,     0,     3,    37,   729,   106,     0,     3,
    1469      641,    42,     3,    40,     3,    34,     0,     3,    98,   100,
    1470        0,     2,   632,   633,     0,     0,   278,     0,     0,     0,
    1471        3,   618,     0,     2,   604,   605,     2,   620,     2,   654,
    1472      655,     0,     0,     3,     0,     3,     3,     3,     3,   392,
    1473      391,   395,     2,     2,   728,   727,   109,     0,     0,     0,
    1474        0,     3,   443,     3,     0,   227,   142,     3,   279,   278,
     1424       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     1425     105,     2,   634,   442,   631,   535,   535,   639,   468,   285,
     1426       2,   573,   574,     0,   585,   586,     0,     2,   728,   731,
     1427     108,   285,     2,   285,     0,   696,   286,   700,   691,   692,
     1428     698,     0,     2,     2,   656,   535,   739,   605,   535,   535,
     1429     739,   535,   619,   535,   535,   670,   424,   653,   535,   535,
     1430     661,   668,   285,   419,   286,     0,     0,   285,   706,   286,
     1431     711,   739,   703,   285,   708,   739,   285,   285,   285,     0,
     1432     108,     0,    17,     5,     2,     0,     0,   447,   737,     0,
     1433       0,   453,   232,     0,   285,     0,     0,     0,   533,   557,
     1434     561,   563,   593,   596,   600,   603,   556,   595,     0,   275,
     1435     646,     0,   285,   268,     0,     0,     0,     0,   266,     2,
     1436       0,   250,   524,   285,     0,     0,     0,     0,   285,   285,
     1437       0,     0,   680,   372,   375,   379,   535,   379,   685,   378,
     1438     677,   535,   535,   355,   363,   371,   364,   535,   366,   369,
     1439     285,   738,     0,     0,   386,   737,   286,     3,   404,     3,
     1440     408,   407,   579,     0,   519,   285,     3,     3,   285,   423,
     1441     286,     3,   417,   418,     2,     0,     0,     0,   473,   297,
     1442     285,   469,   471,     3,     2,     2,     0,   490,     3,     0,
     1443     542,   126,     0,     0,   213,     0,     0,     2,     0,     0,
     1444      34,     0,     0,   108,   285,    19,     0,    20,     0,   680,
     1445     438,     0,   106,     3,     2,    26,     2,     0,    31,     0,
     1446       2,    24,   103,   104,    70,    71,    72,    74,    75,    77,
     1447      78,    82,    83,    80,    81,    85,    86,    88,    90,    92,
     1448      94,    96,     0,     0,   740,   285,     0,     0,     0,   635,
     1449     636,   632,   633,   485,   484,   285,     0,     3,   285,   702,
     1450     285,   707,   286,   285,   285,   285,   650,   693,   649,     2,
     1451     285,     0,     0,     0,     0,     0,     0,     0,     0,   671,
     1452       0,   657,   608,   624,   658,     2,   604,   611,   421,   606,
     1453     607,   422,     2,   618,   627,   620,   621,   654,   655,   669,
     1454     697,   701,   699,   739,   259,     2,   733,     2,   412,   705,
     1455     710,   413,     0,   391,     3,     3,     3,     3,   443,     3,
     1456       0,     2,   456,   452,   738,     0,   448,   455,     2,   451,
     1457     454,     0,   285,   233,   255,     3,   263,   265,     0,   443,
     1458       2,   559,   560,     2,   598,   599,     0,   647,   525,     3,
     1459     336,   335,   338,   337,   285,   526,     0,   527,   285,   365,
     1460     367,     2,     0,     0,     0,     0,   101,   381,   681,   682,
     1461     376,   380,   377,   678,   679,   370,   374,   357,   388,   383,
     1462     389,     0,     0,     0,   426,   231,     0,     0,     3,     2,
     1463     656,   419,     0,   515,     0,   739,   477,     0,   285,   285,
     1464     285,     0,   539,   541,   127,     0,     0,   206,     0,     0,
     1465       0,   214,   215,    55,    60,   285,     0,    58,    57,     0,
     1466     125,   681,     0,    67,    68,   107,   112,     3,   106,     0,
     1467       0,     0,    23,    33,     3,     0,    99,     0,     3,   638,
     1468     642,   645,   637,     3,   580,     3,   704,   709,     2,   285,
     1469       3,     3,   286,     0,     3,   610,   614,   617,   626,   660,
     1470     664,   667,   285,     3,   609,   625,   659,   285,   285,   414,
     1471     285,   285,   734,     0,     0,     0,     0,   247,     0,   101,
     1472       0,     3,     3,     0,   449,     0,   446,     0,     0,   236,
     1473     285,     0,     0,   126,     0,     0,     0,     0,     0,   126,
     1474       0,     0,     0,     2,     0,     0,     3,   128,   129,     2,
     1475     139,   130,   131,   132,   133,   134,   135,   141,   143,     0,
     1476       0,     0,   276,   285,   285,   535,     0,   528,   285,   108,
     1477     684,   688,   690,   683,   373,   387,   384,   567,     2,   652,
     1478     651,     0,   657,     2,   470,   472,   492,     3,   500,   501,
     1479       0,     2,   496,     3,     3,     0,     0,   544,   213,     0,
     1480       0,     0,   213,     0,     3,    35,   737,   106,     0,     3,
     1481     649,    40,     3,    38,     3,    32,     0,     3,    98,   100,
     1482       0,     2,   640,   641,     0,     0,   285,     0,     0,     0,
     1483       3,   626,     0,     2,   612,   613,     2,   628,     2,   662,
     1484     663,     0,     0,     3,     0,     3,     3,     3,     3,   399,
     1485     398,   402,     2,     2,   736,   735,   109,     0,     0,     0,
     1486       0,     3,   450,     3,     0,   234,   142,     3,   286,   285,
    14751487       0,     0,     0,     0,     2,   187,     0,   185,     0,     0,
    1476        0,     0,     0,     0,   191,     0,   108,   527,   147,   144,
    1477      278,     0,     0,   251,   263,     3,     3,   526,   593,   351,
    1478        2,   678,   679,   278,   250,   278,     0,   495,   472,   278,
    1479        0,     0,   471,   486,     0,   207,     0,   213,   106,     0,
    1480        0,   113,   110,     0,     0,     0,     0,     0,     0,    24,
    1481        0,   635,   278,   560,   249,   704,   705,   706,     0,   657,
    1482      278,   278,   278,     3,     3,     0,   665,     0,     0,     0,
    1483        0,   278,   278,     3,   524,   109,   450,     0,     0,   230,
    1484      279,     0,     0,     0,     0,   278,   188,   186,     0,   183,
    1485      189,     0,     0,     0,   192,   195,   193,   190,   126,   140,
    1486      138,   228,     0,     0,   278,   399,   403,   402,     0,   489,
    1487        2,   490,     2,   491,   485,   278,   214,     0,     0,     3,
    1488      641,    32,   111,     2,    45,     2,    43,    41,    29,   109,
    1489       27,     3,   707,     3,     3,     3,     0,     0,   664,   666,
    1490      607,   621,   253,     2,   389,     3,   388,     0,   452,   449,
    1491      126,     0,     0,   126,     3,     0,   126,   184,     0,     2,
    1492      200,   194,     0,   136,   554,   594,     3,     2,     0,     0,
    1493        2,   208,   215,     0,     0,     0,     0,     0,     0,     0,
    1494        0,     0,   667,   668,   278,     0,   451,   148,     0,     0,
    1495        2,   161,   126,   150,     0,   178,     0,   126,     0,     2,
    1496      152,     0,     2,     2,     0,   278,   494,   496,   487,     0,
    1497        0,   111,    38,     3,     3,   636,   608,   622,   658,   393,
    1498      126,   154,   157,     0,   156,   160,     3,   163,   162,     0,
    1499      126,   180,   126,     3,     0,   278,     0,     2,   681,     2,
    1500      209,   216,     0,     0,     0,   149,     0,     0,   159,   217,
    1501      164,     2,   219,   179,     0,   182,   168,   196,     3,   201,
    1502      205,     0,   278,     0,    39,    46,    44,   155,   158,   126,
    1503        0,   165,   278,   126,   126,     0,   169,     0,     0,   672,
    1504      202,   203,   204,   197,     3,   278,   145,   166,   151,   126,
    1505      220,   181,   176,   174,   170,   153,   126,     0,   673,     0,
    1506        0,   146,   167,   177,   171,   175,   174,   172,     3,     0,
    1507      473,   173,   198,     3,   199
     1488       0,     0,     0,     0,   191,     0,   108,   535,   147,   144,
     1489     285,     0,     0,   258,   270,     3,     3,   534,   601,   358,
     1490       2,   686,   687,   285,   257,   285,     0,   503,   480,   285,
     1491       0,     0,   479,   494,     0,     0,     0,   207,     0,   216,
     1492     106,     0,     0,   113,   110,     0,     0,     0,     0,     0,
     1493       0,    22,     0,   643,   285,   568,   256,   712,   713,   714,
     1494       0,   665,   285,   285,   285,     3,     3,     0,   673,     0,
     1495       0,     0,     0,   285,   285,     3,   532,   457,   458,     0,
     1496       0,   237,   286,     0,     0,     0,     0,   285,   188,   186,
     1497       0,   183,   189,     0,     0,     0,   192,   195,   193,   190,
     1498     126,   140,   138,   235,     0,     0,   285,   406,   410,   409,
     1499       0,   497,     2,   498,     2,   499,   493,   285,   219,     0,
     1500     217,     0,   219,     3,   649,    30,   111,     2,    43,     2,
     1501      41,    39,    27,   109,    25,     3,   715,     3,     3,     3,
     1502       0,     0,   672,   674,   615,   629,   260,     2,   396,     3,
     1503     395,     0,   460,   457,   126,     0,     0,   126,     3,     0,
     1504     126,   184,     0,     2,   200,   194,     0,   136,   562,   602,
     1505       3,     2,     0,     0,     2,   220,     0,     0,   208,     0,
     1506       0,     0,     0,     0,     0,     0,     0,     0,   675,   676,
     1507     285,     0,   459,   148,     0,     0,     2,   161,   126,   150,
     1508       0,   178,     0,   126,     0,     2,   152,     0,     2,     2,
     1509       0,   285,   502,   504,   495,     0,     0,     0,     0,   111,
     1510      36,     3,     3,   644,   616,   630,   666,   400,   126,   154,
     1511     157,     0,   156,   160,     3,   163,   162,     0,   126,   180,
     1512     126,     3,     0,   285,     0,     2,   689,     2,   221,   222,
     1513       0,   218,   209,     0,     0,     0,   149,     0,     0,   159,
     1514     224,   164,     2,   226,   179,     0,   182,   168,   196,     3,
     1515     201,   205,     0,   285,     0,     0,     0,    37,    44,    42,
     1516     155,   158,   126,     0,   165,   285,   126,   126,     0,   169,
     1517       0,     0,   680,   202,   203,   204,   197,     3,   285,   210,
     1518     223,   145,   166,   151,   126,   227,   181,   176,   174,   170,
     1519     153,   126,     0,   681,     0,     0,   146,   167,   177,   171,
     1520     175,   174,   172,     3,     0,   481,   173,   198,     3,   199
    15081521};
    15091522
     
    15111524static const yytype_int16 yydefgoto[] =
    15121525{
    1513       -1,   826,   468,   297,    45,   130,   131,   298,   299,   300,
    1514      301,   773,   755,  1122,  1123,   302,   303,   304,   305,   306,
    1515      307,   308,   309,   310,   311,   312,   313,   314,   315,  1032,
    1516      518,   978,   317,   979,   546,   958,  1057,  1476,  1059,  1060,
    1517     1061,  1062,  1477,  1063,  1064,  1412,  1413,  1381,  1382,  1383,
    1518     1460,  1461,  1465,  1466,  1494,  1495,  1065,  1345,  1066,  1067,
    1519     1284,  1285,  1286,  1448,  1068,   962,   963,   964,  1363,  1440,
    1520     1441,   469,   470,   887,   888,  1040,    48,    49,    50,    51,
    1521       52,   341,   155,    55,    56,    57,    58,    59,   343,    61,
    1522       62,   259,    64,    65,   270,   345,   346,    68,    69,    70,
    1523       71,   115,    73,   200,   348,   116,    76,   117,    78,    79,
    1524       80,   449,   450,   451,   452,   690,   924,   691,    81,    82,
    1525      456,   711,   868,   869,   351,   352,   714,   715,   716,   353,
    1526      354,   355,   356,   466,   335,   132,   133,   522,   319,   166,
    1527      644,   645,   646,   647,   648,    83,   118,    85,   489,   490,
    1528      950,   491,   273,   495,   320,    86,   134,   135,    87,  1305,
    1529     1103,  1104,  1105,  1106,    88,    89,   732,    90,   269,    91,
    1530       92,   183,  1034,   678,   405,   122,    93,   501,   502,   503,
    1531      184,   264,   186,   187,   188,   265,    96,    97,    98,    99,
    1532      100,   101,   102,   191,   192,   193,   194,   195,   838,   605,
    1533      606,   607,   608,   196,   610,   611,   612,   571,   572,   573,
    1534      574,   695,   103,   614,   615,   616,   617,   618,   619,   923,
    1535      697,   698,   699,   595,   359,   360,   361,   362,   321,   161,
    1536      105,   106,   107,   364,   709,   568
     1526      -1,   830,   470,   298,    45,   130,   131,   299,   300,   301,
     1527     302,   777,   759,  1132,  1133,   303,   304,   305,   306,   307,
     1528     308,   309,   310,   311,   312,   313,   314,   315,   316,  1040,
     1529     520,   986,   318,   987,   548,   964,  1065,  1501,  1067,  1068,
     1530    1069,  1070,  1502,  1071,  1072,  1430,  1431,  1397,  1398,  1399,
     1531    1483,  1484,  1488,  1489,  1519,  1520,  1073,  1359,  1074,  1075,
     1532    1296,  1297,  1298,  1469,  1076,   142,   970,   971,   972,  1376,
     1533    1450,  1461,  1462,   471,   472,   892,   893,  1048,    48,    49,
     1534      50,    51,    52,   342,   155,    55,    56,    57,    58,    59,
     1535     344,    61,    62,   259,    64,    65,   270,   346,   347,    68,
     1536      69,    70,    71,   115,    73,   200,   349,   116,    76,   117,
     1537      78,    79,    80,   451,   452,   453,   454,   693,   930,   694,
     1538      81,    82,   458,   714,   872,   873,   352,   353,   717,   718,
     1539     719,   354,   355,   356,   357,   468,   336,   132,   133,   524,
     1540     320,   166,   647,   648,   649,   650,   651,    83,   118,    85,
     1541     491,   492,   956,   493,   273,   497,   321,    86,   134,   135,
     1542      87,  1317,  1111,  1112,  1113,  1114,    88,    89,   735,    90,
     1543     269,    91,    92,   183,  1042,   681,   406,   122,    93,   503,
     1544     504,   505,   184,   264,   186,   187,   188,   265,    96,    97,
     1545      98,    99,   100,   101,   102,   191,   192,   193,   194,   195,
     1546     842,   607,   608,   609,   610,   196,   612,   613,   614,   573,
     1547     574,   575,   576,   698,   103,   616,   617,   618,   619,   620,
     1548     621,   929,   700,   701,   702,   597,   360,   361,   362,   363,
     1549     322,   161,   105,   106,   107,   365,   712,   570
    15371550};
    15381551
    15391552/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    15401553   STATE-NUM.  */
    1541 #define YYPACT_NINF -1269
     1554#define YYPACT_NINF -1318
    15421555static const yytype_int16 yypact[] =
    15431556{
    1544     5632,  9056, -1269,    25, -1269, -1269, -1269, -1269, -1269, -1269,
    1545    -1269,    17, -1269, -1269, -1269, -1269, -1269, -1269, -1269, -1269,
    1546    -1269, -1269, -1269, -1269, -1269,   113,   113,   113,   803,   791,
    1547       56,  6940,   839, -1269, -1269, -1269, -1269, -1269,    59, -1269,
    1548    -1269, -1269,   628,    90,  8532, -1269, -1269, -1269, -1269, -1269,
    1549    -1269,    88,   155, -1269,   911, -1269, -1269, -1269, -1269,   140,
    1550     1450,   287,    96,  4240, -1269, -1269,  8601,  1048, -1269, -1269,
    1551    -1269,  1246,   329,  6299,  1010,   880,  1246,  1728, -1269, -1269,
    1552      332,   328, -1269,  1246,  1769, -1269,   227, -1269,   369,   379,
    1553    -1269, -1269, -1269, -1269,   256,   155,   113, -1269,   113, -1269,
    1554    -1269, -1269, -1269,  9292,   911, -1269, -1269,   911, -1269,  9351,
    1555      266, -1269, -1269,  1507,  9410, -1269,   839,   839,   839, -1269,
    1556    -1269, -1269,   113, -1269, -1269, -1269,   291,   341,   348, -1269,
    1557    -1269, -1269,   361, -1269, -1269, -1269, -1269, -1269,   391,   401,
    1558    -1269,   469,   839,  8040,  1076,   326,   352,   486,   522,   542,
    1559      576,   588,  8805,  6382,   474,   482, -1269,  8669, -1269, -1269,
    1560    -1269, -1269,   571, -1269,    47,  5492, -1269,   596,   239, -1269,
    1561    -1269, -1269, -1269,   597,   315,   324,   359,   113,   614, -1269,
    1562    -1269,  1450,  2466,   659, -1269,   128, -1269,   113,   113,   155,
    1563    -1269, -1269,   131, -1269,   113,   113, -1269,  3629,   647,   656,
    1564      839, 10211, -1269, -1269,   665,  8532, -1269, -1269,  1246, -1269,
    1565    -1269, -1269,   155, -1269,   911,    88, -1269,  7183, -1269,   839,
    1566      839,   839,   155, -1269,   803, -1269,  6072, -1269, -1269,   652,
    1567      839, -1269,   839, -1269,    59,  8040,  9115,   675, -1269,   791,
    1568      684,   839, -1269,   803,   674,   681, -1269,  6940,   744, -1269,
    1569    -1269, -1269,  8471, -1269, -1269,  5138, -1269,   659,    73,  9410,
    1570    10491,  1507,  3629, -1269,   138, -1269, -1269,  9351,   911,   708,
    1571    11267, -1269, -1269,   713, -1269, 11002, 10719, 10776, 10719, 10833,
    1572    -1269,   737, -1269, -1269, -1269, -1269, 10890, 10890,   744,  4439,
    1573      751, 10719,  8146, -1269, -1269, -1269, -1269, -1269, -1269,   766,
    1574    -1269,   828,  1924, 10719, -1269,   465,   544,   763,   389,   621,
    1575      755,   754,   759,   813,    65, -1269, -1269,   782,   510, -1269,
    1576      307, -1269, -1269,  1076, -1269, -1269,   774,   807, -1269,   784,
    1577      807,   815,    59, -1269, -1269,   821,  9292, -1269,   826,  7828,
    1578    -1269, -1269,   715,  2130,  7574, 10211,  1246, -1269,  1246,   839,
    1579      839, -1269, -1269, -1269, -1269, -1269, -1269,   839,  9469,   911,
    1580    -1269, -1269,  9528,  1378, -1269,  9174, -1269, -1269, -1269, -1269,
    1581    -1269, -1269, -1269,   831,  4897, 10719, -1269, -1269, -1269, -1269,
    1582    -1269, -1269, -1269, -1269, -1269, -1269, -1269, -1269, -1269,  1507,
    1583    -1269,   728,   842,   859,   891,   817,   925,   926,   927,  2466,
    1584    -1269, -1269,   865,    88,   869, -1269, -1269,   928, -1269, -1269,
    1585    -1269,  8471, -1269, -1269, -1269, -1269, -1269,  3629, -1269,  8040,
    1586     8040, -1269,  1507, 11295,   911,  7639, -1269, -1269, -1269, -1269,
    1587     8471,    73, -1269, -1269,  1246,   155, -1269, -1269,  8471, -1269,
    1588     6187, -1269, -1269,   839,   839,   339,  9587,   909,  1932,  2385,
    1589    -1269,   377,   414,   791, -1269,  9115,   924,   912,   791,   839,
    1590    -1269, -1269, -1269, -1269,  9947, -1269,   512,  7494, -1269,   155,
    1591      930, -1269,  1507, 11077, 10548, -1269, -1269, -1269, -1269,   824,
    1592     3629, -1269,  7704,   659,  6831, -1269, -1269, -1269,   746,   592,
    1593      782,   791, 11267,   530,  9351, -1269, 11267, -1269, -1269, -1269,
    1594    -1269,   613, -1269,   932, -1269, -1269,    12,  4439, -1269, -1269,
    1595     4439, -1269,  7934,  4439, -1269, -1269, -1269,   933, -1269,   625,
    1596      936,   545,   939, -1269,  8873,  5389, -1269, -1269, -1269,    67,
    1597    -1269, -1269, 10605, -1269,   249, -1269, -1269, -1269, -1269, -1269,
    1598    -1269, -1269, -1269, -1269, -1269, 10491, 10491, -1269, 10719, 10719,
    1599    10719, 10719, 10719, 10719, 10719, 10719, 10719, 10719, 10719, 10719,
    1600    10719, 10719, 10719, 10719, 10719, 10719,  4719, 10491, -1269,   510,
    1601     1578, -1269, -1269,   113,   113, -1269, -1269,  8040, -1269, -1269,
    1602      928,   744, -1269,   928, 10662, -1269, -1269, -1269,  4020,  5389,
    1603      938,  8252,   941, -1269,  9646, -1269, -1269,   571, -1269,   942,
    1604     1657,   947,  1802,   198,   782, -1269,   113,   113,   782,   245,
    1605    -1269,   113,   113,   928, -1269, -1269,   113,   113, -1269,   807,
    1606     9705,   911, 11208,   419,   426,  9705, -1269,  9882, -1269,   782,
    1607    -1269,  9469, -1269,   144,  7291,  7291,  7291,   911, -1269, 10434,
    1608      934,   831,   353,   949, -1269,   951,  5492,   583, -1269,  1032,
    1609      911,  7291,   744,  1507,   744,   659,   795,   807, -1269, -1269,
    1610      800,   807, -1269, -1269, -1269,   986, -1269,   807,   155,  9947,
    1611    -1269,   635,   960,   638,   961, -1269,   962,   155, -1269, -1269,
    1612     8471,   155,   958,   436,   443,  9764,  6494,  2437, 10719,  2673,
    1613    -1269, -1269,   956,    32,   956, -1269, -1269, -1269,   113,   113,
    1614    -1269, -1269,   791, -1269,   113, -1269, -1269,  2798,   791,   968,
    1615    10719, -1269,   924, 11208, -1269, -1269,   967, -1269, -1269, -1269,
    1616      744, -1269, 11143, 10719, -1269,  7291,   584,  7574, -1269, -1269,
    1617      571,   969,   972,   746,  2082, -1269, -1269, 11267, -1269, -1269,
    1618      965, -1269, -1269,   984, -1269,   965,   989, 11002, 10491,   944,
    1619     1017,   991,   992,   751,   987,   996, -1269,   997,  1000,  2971,
    1620     6158, -1269, 10491, -1269,   545,  1808, -1269,  5683, 10491,   998,
    1621    -1269, -1269,   831,   639, -1269, 10491, -1269, -1269, -1269, -1269,
    1622    -1269, -1269, -1269,   465,   465,   544,   544,   763,   763,   763,
    1623      763,   389,   389,   621,   755,   754,   759,   813, 10719,   616,
    1624    -1269,  9947,  1005,  1006,  1007,  1578, -1269, -1269, -1269, -1269,
    1625    -1269,  9947,   643, 10719,  7291, -1269,  9469, -1269,  6606,  8358,
    1626     9233,  6382, -1269, -1269, -1269,  1657,  9947,   846,  1012,  1013,
    1627     1015,  1019,  1020,  1023,  1024, -1269,  3182,  1802, -1269, -1269,
    1628    -1269, -1269, -1269, -1269, -1269, -1269, -1269, -1269, -1269, -1269,
    1629    -1269, -1269, -1269, -1269, -1269,   928, -1269, -1269, -1269,   782,
    1630    -1269, -1269, -1269, -1269, -1269, -1269, -1269, -1269,  1025, -1269,
    1631     1026,  1029, -1269, -1269,    88,   998, 10434, -1269, -1269, -1269,
    1632     4897,  1028, -1269, -1269, -1269, -1269,   791,  5798,  1104, -1269,
    1633    -1269, -1269, -1269,  1027,    88, -1269, -1269,   928, -1269, -1269,
    1634      928,   142,   928, -1269, -1269, -1269, -1269, -1269, -1269,  8737,
    1635    -1269,   155, -1269,  9115, -1269, -1269,  1034,   761,  1031,  1038,
    1636     1041, -1269,  2673, -1269, -1269, -1269, -1269, -1269, -1269, -1269,
    1637     1932, -1269,   912, -1269, -1269,  1044,  1046,  1047, -1269, -1269,
    1638     1042,  1050, -1269,   584,  1953, -1269,   534, -1269,  2082,   782,
    1639    -1269,  1054, 11267,  9823,  8040,  1055, -1269, -1269,  1051,  1056,
    1640    -1269,  1059,   169,  1057, -1269,  1058,  1058,  5389, 10491, -1269,
    1641    -1269,  1058, -1269,  1808,  4897, -1269, -1269, -1269, -1269,  1060,
    1642    10491,  1062,   744, 10434, -1269, 10605, -1269,   744, -1269, 10491,
    1643    -1269,   840,   807, -1269, -1269, -1269, -1269, -1269, -1269, -1269,
    1644      831,  7828, -1269, -1269,  6718,  1067, -1269,   864,   807, -1269,
    1645      871,   882,   807, -1269,   839,  3327, -1269, -1269, -1269,  9947,
    1646     9947, -1269,  7639,  7639, -1269,  1063,  1064,  1068,  1071, -1269,
    1647     1074,   541,    48,   998, -1269,   744, -1269,  5492, -1269, 10491,
    1648      455, -1269,  6043,  1080,  1081, 10377,  1083,  1084,    55,   173,
    1649       23, 10491,  1085,   155,  4287,  1089,  1086,  1065, -1269, -1269,
    1650    -1269,  1087, -1269, -1269, -1269, -1269, -1269, -1269, -1269, -1269,
    1651    -1269,   791,  1094, 10491, -1269,  9947,  9947,   113,  1095, -1269,
    1652     8997,  8935,   889,   807, -1269, -1269, -1269, -1269, -1269, -1269,
    1653    -1269, -1269, -1269,  1098,  1953, -1269, -1269,  1082, -1269,   965,
    1654    -1269, -1269,  1507,  1097, -1269, -1269, -1269,   650,  1096, -1269,
    1655    10719,  1077,  1017,  1017,  1102, -1269,   951, 10491,  1111,  1060,
    1656      559,    61,  1108, -1269,  1102, -1269,  1113,  1108, -1269, -1269,
    1657     1118, -1269, -1269,   928,  1120,  1121,  6270,  1123,  1124,  1125,
    1658    -1269, -1269,  1122, -1269, -1269,   928, -1269, -1269, -1269, -1269,
    1659      928, 10491, 10491, 10719,  1127, -1269, -1269, -1269, -1269, -1269,
    1660    -1269, -1269, -1269, -1269, -1269, -1269, -1269, 10719, 10719,  1128,
    1661     1133,  1108, -1269, -1269,   791, -1269, -1269, -1269,  7118,  9823,
    1662    10491, 10491,  1180, 10491, -1269, -1269,  1114, -1269,  1117, 10491,
    1663     1135,  1137, 10491,   901, -1269,  1138,  8499,   113, -1269, -1269,
    1664     5798,  1140,   467, -1269, -1269, -1269, -1269, -1269, -1269, -1269,
    1665    -1269, -1269,   928, 10183, -1269,  7704,  1147, -1269, -1269,  9823,
    1666      476,   481, -1269,  1157,  1165, -1269,   201, -1269, 10491,  1166,
    1667     1167, -1269, -1269,  1168,   257,   313,   744,  1169,  1171, -1269,
    1668     1172, -1269,  9947, -1269, -1269, -1269, -1269, -1269,  1174, -1269,
    1669     9947,  9947,  9947, -1269, -1269,  1175, -1269,  1179,  1182,  1183,
    1670      573,  7358,  7466, -1269, -1269,   609, -1269,  1184,  1185, -1269,
    1671     7769,   651,   662,  1141,   664,  5921, -1269, -1269,   508, -1269,
    1672    -1269,   687,  1189,   155,  1237,  1240, -1269, -1269, 10377, -1269,
    1673    -1269, -1269,  1193,  1197,  9947, -1269, -1269, -1269,  1196, -1269,
    1674    -1269, -1269, -1269, -1269, -1269,  9823, -1269,  1190,  1231,  1060,
    1675      253, -1269, -1269, -1269, -1269, -1269, -1269, -1269, -1269,  1204,
    1676    -1269, -1269, -1269, -1269, -1269, -1269,  1211,  1215, -1269, -1269,
    1677    -1269, -1269, -1269, -1269, -1269,  1219, -1269,  1218, -1269, -1269,
    1678    10377,   147, 10491, 10377, -1269,  1225, 10491, -1269,   264,  1239,
    1679    -1269, -1269,  1229, -1269, -1269, -1269, -1269, -1269,   911,  1507,
    1680     1233, -1269, -1269,   704,  1228, 10491,   744,   744,  1248,  1249,
    1681     1250,  1251, -1269, -1269,  7639,  1256, -1269,  1301, 10719,  1259,
    1682    -1269, -1269, 10297, -1269,   716, -1269,  1224, 10377,  1235, -1269,
    1683    -1269,  1268, -1269,  1282,  1270,  9823, -1269, -1269, -1269,  1252,
    1684     1302,  1273, -1269,  1108,  1108, -1269, -1269, -1269, -1269, -1269,
    1685    10377,    54, -1269,   897, -1269, -1269,  7049, -1269, -1269,  1255,
    1686    10491, -1269, 10491,  7049,   155,  9587,  1283, -1269, -1269,  1280,
    1687    -1269, -1269, 10491,  1284,  1285, -1269, 10719, 10719, -1269, -1269,
    1688      966,    99, -1269, -1269,  1266, -1269,   966, -1269, -1269,  2561,
    1689      744,   155,  9587,  1290, -1269, -1269, -1269, -1269, -1269, 10297,
    1690     1286,   966,  3510, 10491, 10217,  1287,   966,  1294,  2561,  3047,
    1691    -1269, -1269, -1269, -1269, -1269,  8040, -1269, 10062, -1269, 10297,
    1692    -1269, -1269,  1274,  9981, -1269, -1269, 10217,   155,  3047,  1297,
    1693      717, -1269, 10062, -1269, -1269, -1269,  9981, -1269, -1269,   155,
    1694    -1269, -1269, -1269, -1269, -1269
     1557    4413,  9104, -1318,    42, -1318, -1318, -1318, -1318, -1318, -1318,
     1558   -1318,   -27, -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318,
     1559   -1318, -1318, -1318, -1318, -1318,    95,    95,    95,   954,   850,
     1560      71,  5300,   201, -1318, -1318, -1318, -1318, -1318,   123, -1318,
     1561   -1318, -1318,   776,   164,  8401, -1318, -1318, -1318, -1318, -1318,
     1562   -1318,   226,   169, -1318,  1184, -1318, -1318, -1318, -1318,   272,
     1563    1531,   387,    89,  3759, -1318, -1318,  8469,  1998, -1318, -1318,
     1564   -1318,   935,   392,  5420,   741,  1183,   935,  1282, -1318, -1318,
     1565     356,   326, -1318,   935,  1429, -1318,   340, -1318,   453,   463,
     1566   -1318, -1318, -1318, -1318,   370,   169,    95, -1318,    95, -1318,
     1567   -1318, -1318, -1318,  9340,  1184, -1318, -1318,  1184, -1318,  9399,
     1568     389, -1318, -1318,  1617,  9458, -1318,  1087,  1087,  1087, -1318,
     1569   -1318, -1318,    95, -1318, -1318, -1318,   386,   435,   438, -1318,
     1570   -1318, -1318,   498, -1318, -1318, -1318, -1318, -1318,   510,   531,
     1571   -1318, -1318,    34,  7909,  1795,    48,   452,   575,   578,   583,
     1572     588,   593,  8673,  6319,   543,   605, -1318,  8537, -1318, -1318,
     1573   -1318, -1318,   652, -1318,   172,  5550, -1318,   473,   232, -1318,
     1574   -1318, -1318, -1318,   661,   301,   325,   403,    95,   646, -1318,
     1575   -1318,  1531,  2279,   739, -1318,    21, -1318,    95,    95,   169,
     1576   -1318, -1318,    35, -1318,    95,    95, -1318,  2781,   700,   710,
     1577    1087, 10200, -1318, -1318,   717,  8401, -1318, -1318,   935, -1318,
     1578   -1318, -1318,   169, -1318,  1184,   226, -1318,  7011, -1318,  1087,
     1579    1087,  1087,   169, -1318,   954, -1318,  3330, -1318, -1318,   704,
     1580    1087, -1318,  1087, -1318,   123,  7909,  9163,   736, -1318,   850,
     1581     769,  1087, -1318,   954,   737,   747, -1318,  5300,   814, -1318,
     1582   -1318, -1318,  2451, -1318, -1318,  3603, -1318,   739,    61,  9458,
     1583   10457,  1617,  2781, -1318,    68, -1318, -1318,  9399,  1184,   778,
     1584   11233, -1318, -1318,   428, -1318, 10968,   787,   870, 10685, 10742,
     1585   10799, -1318,   824, -1318, -1318, -1318, -1318, 10856, 10856,   814,
     1586    7591,   827, 10742,  8015, -1318, -1318, -1318, -1318, -1318, -1318,
     1587     874, -1318,   901,  2137, 10742, -1318,   237,   407,   632,   476,
     1588     638,   859,   855,   869,   890,   101, -1318, -1318,   877,   616,
     1589   -1318,   336, -1318, -1318,  1795, -1318, -1318,   518,   907, -1318,
     1590     633,   907,   892,   123, -1318, -1318,   914,  9340, -1318,   916,
     1591    7697, -1318, -1318,  1197,   771,  5233, 10200,   935, -1318,   935,
     1592    1087,  1087, -1318, -1318, -1318, -1318, -1318, -1318,  1087,  9517,
     1593    1184, -1318, -1318,  9576,  1658, -1318,  9222, -1318, -1318, -1318,
     1594   -1318, -1318, -1318, -1318,   924,  4543, 10742, -1318, -1318, -1318,
     1595   -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318,
     1596    1617, -1318,   676,   942,   945,   946,   690,   947,   948,   958,
     1597    2279, -1318, -1318,   952,   226,   957, -1318, -1318,   959, -1318,
     1598   -1318, -1318,  2451, -1318, -1318, -1318, -1318, -1318,  2781, -1318,
     1599    7909,  7909, -1318,  1087,  1617, 11261,  1184,  7402, -1318, -1318,
     1600   -1318, -1318,  2451,    61, -1318, -1318,   935,   169, -1318, -1318,
     1601    2451, -1318,  5128, -1318, -1318,  1087,  1087,   364,  9635,   960,
     1602    2086,  8865, -1318,   432,   454,   850, -1318,  9163,   955,   944,
     1603     850,  1087, -1318, -1318, -1318, -1318,  9936, -1318,   383,  7322,
     1604   -1318,   169,   962, -1318,  1617, 11043, 10514, -1318, -1318, -1318,
     1605   -1318,   755,  2781, -1318,  7467,   739,  6768, -1318, -1318, -1318,
     1606     885,   414,   877,   850, 11233,   619,  9399, -1318, 11233, -1318,
     1607   -1318, -1318, -1318,   479, -1318,   964,   870,   125,  7591, -1318,
     1608   -1318, -1318,  7591, -1318,  7803,  7591, -1318, -1318, -1318,   969,
     1609   -1318,   544,   972,   640,   974, -1318,  8741,  5983, -1318, -1318,
     1610   -1318,   103, -1318, -1318, 10571, -1318,   112, -1318, -1318, -1318,
     1611   -1318, -1318, -1318, -1318, -1318, -1318, -1318, 10457, 10457, -1318,
     1612   10742, 10742, 10742, 10742, 10742, 10742, 10742, 10742, 10742, 10742,
     1613   10742, 10742, 10742, 10742, 10742, 10742, 10742, 10742, 10343, 10457,
     1614   -1318,   616,   900, -1318, -1318,    95,    95, -1318, -1318,  7909,
     1615   -1318, -1318,   959,   814, -1318,   959, 10628, -1318, -1318, -1318,
     1616    8333,  5983,   973,  8121,   976, -1318,  9694, -1318, -1318,   652,
     1617   -1318,   978,   378,   980,  1782,   139,   877, -1318,    95,    95,
     1618     877,   166, -1318,    95,    95,   959, -1318, -1318,    95,    95,
     1619   -1318,   907,  9753,  1184, 11174,   137,   273,  9753, -1318,  4101,
     1620   -1318,   877, -1318,  9517, -1318,   278,  7119,  7119,  7119,  1184,
     1621   -1318,  3868,   982,   220,   924,   302,   984, -1318,   977,  5550,
     1622     238, -1318,  1061,  1184,  7119,   814,  1617,   814,   739,   705,
     1623     907, -1318, -1318,   765,   907, -1318, -1318, -1318,   870, -1318,
     1624     907,   169,  9936, -1318,   570,  1000,   655,  1005, -1318,  1004,
     1625     169, -1318, -1318,  2451,   169,  1003,   464,   465,  9812,  6431,
     1626    1947, 10742,  2536, -1318, -1318,  1001,    20,  1001, -1318, -1318,
     1627   -1318,    95,    95, -1318, -1318,   850, -1318,    95, -1318, -1318,
     1628    8924,   850,  1006, 10742, -1318,   955, 11174, -1318, -1318,  1017,
     1629   -1318, -1318, -1318,   814, -1318, 11109, 10742, -1318,  7119,   671,
     1630    5233, -1318, -1318,   652,  1013,  1014,   885,  2927, -1318, -1318,
     1631   11233, -1318, -1318,  1015, -1318, -1318,  1021, -1318,  1015,  1023,
     1632   10968, 10457,   243,  1002,    53,  1025,  1026,   827,  1027,  1028,
     1633   -1318,  1030,  1032,  8983,  6095, -1318, 10457, -1318,   640,  1104,
     1634   -1318, 10400, 10457,  1034, -1318, -1318,   924,   678, -1318, 10457,
     1635   -1318, -1318, -1318, -1318, -1318, -1318, -1318,   237,   237,   407,
     1636     407,   632,   632,   632,   632,   476,   476,   638,   859,   855,
     1637     869,   890, 10742,   716, -1318,  9936,  1038,  1041,  1042,   900,
     1638   -1318, -1318, -1318, -1318, -1318,  9936,   679, 10742,  7119, -1318,
     1639    9517, -1318,  6543,  8227,  9281,  6319, -1318, -1318, -1318,   378,
     1640    9936,   820,  1047,  1051,  1052,  1057,  1058,  1059,  1060, -1318,
     1641    3170,  1782, -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318,
     1642   -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318,   959,
     1643   -1318, -1318, -1318,   877, -1318, -1318, -1318, -1318, -1318, -1318,
     1644   -1318, -1318,  1063, -1318,  1064,  1065, -1318, -1318,   226,  1034,
     1645    3868, -1318, -1318, -1318,  4543,  1066, -1318, -1318, -1318, -1318,
     1646   -1318,   850,  5481,  1140, -1318, -1318, -1318, -1318,  1049,   226,
     1647   -1318, -1318,   959, -1318, -1318,   959,   127,   959, -1318, -1318,
     1648   -1318, -1318, -1318, -1318,  8605, -1318,   169, -1318,  9163, -1318,
     1649   -1318,  1070,   856,  1073,  1076,  1077, -1318, -1318,  2536, -1318,
     1650   -1318, -1318, -1318, -1318, -1318, -1318,  2086, -1318,   944, -1318,
     1651   -1318,  1075,  1078,  1082, -1318, -1318,  1080,  1096, -1318,   671,
     1652    1985, -1318,   514, -1318,  2927,   877, -1318,  1100, 11233,  9871,
     1653    7909,  1102, -1318, -1318,  1098,  1110,  1107, -1318, 10742,    12,
     1654     400,  1114, -1318,  1112,  1112,  5983, 10457, -1318, -1318,  1112,
     1655   -1318,  1104,  4543, -1318, -1318, -1318, -1318,  1115, 10457,  1120,
     1656     814,  3868, -1318, 10571, -1318,   814, -1318, 10457, -1318,   825,
     1657     907, -1318, -1318, -1318, -1318, -1318, -1318, -1318,   924,  7697,
     1658   -1318, -1318,  6655,  1125, -1318,   833,   907, -1318,   845,   852,
     1659     907, -1318,  1087,  4145, -1318, -1318, -1318,  9936,  9936, -1318,
     1660    7402,  7402, -1318,  1123,  1124,  1126,  1133, -1318,  1134,   553,
     1661      38,  1034, -1318,   814, -1318,  5550, -1318, 10457,   466, -1318,
     1662    5871,  1136,  1141,  5631,  1149,  1155,    13,    17,    14, 10457,
     1663    1156,   169,  3019,  1137,  1150,  1143, -1318, -1318, -1318,  1161,
     1664   -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318,   850,
     1665    1167, 10457, -1318,  9936,  9936,    95,  1169, -1318,  9045,  8803,
     1666     867,   907, -1318, -1318, -1318, -1318, -1318, -1318, -1318, -1318,
     1667   -1318,  1174,  1985, -1318, -1318,  1158, -1318,  1015, -1318, -1318,
     1668    1617,  1173, -1318, -1318, -1318,   686,  1175, -1318,    53,  1178,
     1669   10742,  1159,    53,    53,  1176, -1318,   977, 10457,  1185,  1115,
     1670     607,   130,  1192, -1318,  1176, -1318,  1198,  1192, -1318, -1318,
     1671    1199, -1318, -1318,   959,  1201,  1203,  6207,  1202,  1205,  1207,
     1672   -1318, -1318,  1210, -1318, -1318,   959, -1318, -1318, -1318, -1318,
     1673     959, 10457, 10457, 10742,  1209, -1318, -1318, -1318, -1318, -1318,
     1674   -1318, -1318, -1318, -1318, -1318, -1318, -1318, 10742, 10742,  1212,
     1675    1219,  1192, -1318, -1318,   850, -1318, -1318, -1318,  4876,  9871,
     1676   10457, 10457,  1262, 10457, -1318, -1318,  1213, -1318,  1214, 10457,
     1677    1216,  1220, 10457,   929, -1318,  1223,  5017,    95, -1318, -1318,
     1678    5481,  1224,   469, -1318, -1318, -1318, -1318, -1318, -1318, -1318,
     1679   -1318, -1318,   959, 10172, -1318,  7467,  1232, -1318, -1318,  9871,
     1680     478,   509, -1318,  1236,  1239,   870,  1248, -1318,   541, -1318,
     1681   10457,  1250,  1245, -1318, -1318,  1251,   128,   133,   814,  1253,
     1682    1254, -1318,  1256, -1318,  9936, -1318, -1318, -1318, -1318, -1318,
     1683    1258, -1318,  9936,  9936,  9936, -1318, -1318,  1260, -1318,  1263,
     1684    1269,  1270,   589,  7186,  7294, -1318, -1318,   351, -1318,  1273,
     1685    1275, -1318,  7532,   721,   742,  1272,   752,  5749, -1318, -1318,
     1686     545, -1318, -1318,   768,  1279,   169,  1330,  1332, -1318, -1318,
     1687    5631, -1318, -1318, -1318,  1285,  1286,  9936, -1318, -1318, -1318,
     1688    1283, -1318, -1318, -1318, -1318, -1318, -1318,  9871,   870,   206,
     1689   -1318,  1268,   870,  1115,   327, -1318, -1318, -1318, -1318, -1318,
     1690   -1318, -1318, -1318,  1284, -1318, -1318, -1318, -1318, -1318, -1318,
     1691    1291,  1294, -1318, -1318, -1318, -1318, -1318, -1318, -1318,  1297,
     1692   -1318,  1296, -1318, -1318,  5631,   124, 10457,  5631, -1318,  1299,
     1693   10457, -1318,   270,  1314, -1318, -1318,  1306, -1318, -1318, -1318,
     1694   -1318, -1318,  1184,  1617,  1301,   874,   879, 10742, -1318,   790,
     1695    1307, 10457,   814,   814,  1308,  1310,  1316,  1317, -1318, -1318,
     1696    7402,  1320, -1318,  1376, 10742,  1313, -1318, -1318, 10286, -1318,
     1697     791, -1318,  1300,  5631,  1305, -1318, -1318,  1323, -1318,  1341,
     1698    1329,  9871, -1318, -1318, -1318,   870,   814,  1334,  1327,  1325,
     1699   -1318,  1192,  1192, -1318, -1318, -1318, -1318, -1318,  5631,   246,
     1700   -1318,   917, -1318, -1318,  6877, -1318, -1318,  1335, 10457, -1318,
     1701   10457,  6877,   169,  9635,  1342, -1318, -1318,  1351,   874, -1318,
     1702     793, -1318, -1318, 10457,  1357,  1359, -1318, 10742, 10742, -1318,
     1703   -1318,   989,    88, -1318, -1318,  1340, -1318,   989, -1318, -1318,
     1704    2035,   814,   169,  9635,  1364,  1345,   814, -1318, -1318, -1318,
     1705   -1318, -1318, 10286,  1369,   989,  6946, 10457, 10206,  1373,   989,
     1706    1380,  2035,  2697, -1318, -1318, -1318, -1318, -1318,  7909, -1318,
     1707   -1318, -1318, 10051, -1318, 10286, -1318, -1318,  1347,  9970, -1318,
     1708   -1318, 10206,   169,  2697,  1383,   794, -1318, 10051, -1318, -1318,
     1709   -1318,  9970, -1318, -1318,   169, -1318, -1318, -1318, -1318, -1318
    16951710};
    16961711
     
    16981713static const yytype_int16 yypgoto[] =
    16991714{
    1700    -1269,  3902,  2604, -1269,   354, -1269,    -1,     2,   742, -1269,
    1701    -1269, -1269,  -489,  -961,  -282,  4749, -1269,   570,   459,   468,
    1702      357,   464,   844,   848,   849,   847,   850, -1269,  -229,  -231,
    1703     4555,   296,  -694,  -919, -1269,   166,  -721,   143, -1269,    86,
    1704    -1269,   216, -1143, -1269, -1269,   -17, -1269, -1146, -1036,    71,
    1705    -1269, -1269, -1269, -1269,   -75, -1160, -1269, -1269, -1269, -1269,
    1706    -1269, -1269,   141,   -26,    21,   316, -1269,   320, -1269,    13,
    1707    -1269,  -294, -1269, -1269, -1269,   364,  -829, -1269, -1269,    11,
    1708     -963,   125,  1704, -1269, -1269, -1269,   -72, -1269,    82,    49,
    1709      -18,  1039,  3754, -1269, -1269,    81,   133,   536,  -256,  1629,
    1710    -1269,  1307, -1269, -1269,   224,  1625, -1269,  1893,  1163, -1269,
    1711    -1269,  -426,  -421,   993,   994,   507,   747,   306, -1269, -1269,
    1712      980,   516,  -433, -1269,  -199,    75,   591, -1269, -1269,  -894,
    1713    -1000,     6,   910,   861,   176, -1269,   721,   158,  -317,  -210,
    1714     -149,   478,   577, -1269,   809, -1269,  2211,   740,  -443,   722,
    1715    -1269, -1269,   511, -1269,  -232, -1269,   -46, -1269, -1269, -1269,
    1716    -1268,   243, -1269, -1269, -1269,   981, -1269,    -7, -1269, -1269,
    1717     -827,   -35, -1227,  -161,  1978, -1269,  3527, -1269,   719, -1269,
    1718     -157,    41,  -172,  -170,  -163,     4,   -41,   -36,   -34,   777,
    1719       24,    33,    45,  -143,  -151,  -150,  -145,  -139,  -288,  -529,
    1720     -505,  -476,  -564,  -323,  -560, -1269, -1269,  -516,   899,   906,
    1721      915,  1643,  4256,  -522,  -566,  -549,  -514,  -546, -1269,  -372,
    1722     -680,  -674,  -672,  -603,  -208,  -186, -1269, -1269,    64,   293,
    1723      -93, -1269,  3162,   208,  -613,  -396
     1715   -1318,  3762,  2543, -1318,  1454, -1318,    -1,     2,   -89, -1318,
     1716   -1318, -1318,  -483,  -942,  -282,  4006, -1318,  1670,   483,   485,
     1717     347,   484,   927,   931,   926,   932,   937, -1318,   792,  -594,
     1718    4587,   375,  -691,  -946, -1318,  -112,  -722,  -695, -1318,   412,
     1719   -1318,   304, -1184, -1318, -1318,    54, -1318, -1317,  -763,   149,
     1720   -1318, -1318, -1318, -1318,    -3, -1151, -1318, -1318, -1318, -1318,
     1721   -1318, -1318,   223,    51,    55, -1318,  -364, -1318,   402,   204,
     1722   -1318,    86, -1318,  -320, -1318, -1318, -1318,   450,  -745, -1318,
     1723   -1318,    10,  -865,   258,   180, -1318, -1318, -1318,  -222, -1318,
     1724     126,    49,  -187,   951,  3574, -1318, -1318,   213,   151,   363,
     1725    -251,  2053, -1318,  1304, -1318, -1318,   344,  1615, -1318,  1898,
     1726    1496, -1318, -1318,  -417,  -439,  1083,  1084,   597,   837,   279,
     1727   -1318, -1318,  1086,   598,   -23, -1318,    37,  -463,   807, -1318,
     1728   -1318,  -923,  -977,   142,   669,   965,   280, -1318,   175,   -35,
     1729    -257,  -199,  -156,   555,   651, -1318,   888, -1318,  1925,  1031,
     1730    -460,   803, -1318, -1318,   594, -1318,  -228, -1318,   140, -1318,
     1731   -1318, -1318, -1268,   320, -1318, -1318, -1318,  1067, -1318,     6,
     1732   -1318, -1318,  -851,   -86, -1303,  -124,  2887, -1318,  2837, -1318,
     1733     812, -1318,  -168,   585,  -176,  -173,  -171,     4,   -41,   -39,
     1734     -36,   834,    47,    56,    79,  -167,  -162,  -161,  -159,  -158,
     1735    -273,  -557,  -498,  -458,  -543,  -318,  -539, -1318, -1318,  -499,
     1736     986,   992,   993,  1485,  4182,  -565,  -577,  -550,  -542,  -536,
     1737   -1318,  -384,  -672,  -658,  -654,  -591,  -211,  -316, -1318, -1318,
     1738     152,   299,   -75, -1318,  2880,   592,  -631,  -200
    17241739};
    17251740
     
    17271742   positive, shift that token.  If negative, reduce the rule which
    17281743   number is the opposite.  If YYTABLE_NINF, syntax error.  */
    1729 #define YYTABLE_NINF -503
     1744#define YYTABLE_NINF -511
    17301745static const yytype_int16 yytable[] =
    17311746{
    1732      110,   146,    46,   445,    95,   432,   147,   918,   148,   392,
    1733      256,   393,   111,   919,   141,   920,   377,   857,   394,   498,
    1734      609,    47,   403,  1161,   140,   400,  1127,   959,   701,   707,
    1735      395,   396,   881,    46,   832,    95,   397,  1360,   839,   401,
    1736      831,    94,   398,   774,    46,   506,    46,   505,   158,   740,
    1737      113,   833,    47,   745,   806,   604,    46,   843,  1069,   337,
    1738     1070,  1119,    46,   850,   189,    46,   149,   212,    46,    30,
    1739      222,   828,    94,   976,  1171,   150,   696,   215,   263,  1177,
    1740      840,    66,    60,   145,   918,    94,   834,   151,   108,   392,
    1741      919,   393,   920,   156,   738,   829,   475,   477,   394,   935,
    1742      119,   185,   672,   674,    94,   400,    46,    94,   160,    46,
    1743      395,   396,    66,    60,   749,    46,   397,   668,   120,   401,
    1744      108,   750,   398,   198,   830,    53,   112,  1429,  1159,  1160,
    1745      402,   596,   108,    67,  1189,   404,   677,  1167,   169,  1234,
    1746      146,  -218,  -218,  1436,   681,   147,    46,   148,   158,   766,
    1747       30,  1414,   254,   565,    46,   371,    53,   139,   156,    46,
    1748      143,   367,   418,  1168,    67,    30,  1235,   199,    30,  1168,
    1749      770,   372,   628,   160,   476,    30,   632,   744,   439,  1185,
    1750      471,   249,   421,    46,    46,    94,   158,   566,   206,  1378,
    1751     1379,   216,   318,   666,   152,   757,   208,   460,    94,    46,
    1752      735,   334,   872,   873,   828,   149,  -218,    46,   844,   158,
    1753     1414,   165,   847,  1176,   150,  1161,    46,   528,   890,    46,
    1754      146,   435,   391,   185,    74,   147,   151,   148,   829,   248,
    1755      173,   404,   412,   864,   404,    30,  1418,   867,   108,   481,
    1756      463,   404,   663,   587,  1077,   476,    94,   465,   177,    46,
    1757      422,    95,   163,  1380,   426,    74,   664,   830,    94,   832,
    1758      810,   167,  1161,    46,    46,  1005,   158,   567,    47,   427,
    1759       46,  1111,   337,  1017,   729,   410,   833,    46,  1112,   609,
    1760      257,   843,    30,   258,   318,   448,   701,   516,    94,   994,
    1761      197,   692,   942,   104,   104,  1129,   828,  1187,   429,   841,
    1762      453,   601,   479,  1307,  1484,   694,  1378,  1379,   437,  1309,
    1763     1308,   834,  1177,  1418,   108,  1018,   426,   163,  1418,   488,
    1764      829,  1483,   108,   663,   104,    46,  1497,   367,    66,    60,
    1765     1191,   427,  -274,  1418,   472,   243,  1492,   664,   521,   471,
    1766     1418,   156,   433,  1496,    46,    46,   848,   380,   601,   830,
    1767      434,   322,   776,   523,   655,  -109,   160,   248,   471,   104,
    1768     1313,    46,  1365,   381,    94,    46,   471,  1159,  1160,   246,
    1769     1389,  1069,    53,  1070,  1161,   520,  -109,   832,   108,  -498,
    1770       67,   997,   670,   596,   603,   586,   911,   675,   593,   260,
    1771      431,    46,   -10,   108,   833,   136,   137,   108,   857,   136,
    1772      234,    46,   817,   367,  1459,  1403,  1404,   626,   172,   576,
    1773     1464,   630,   596,   428,   334,   577,  1315,   596,   108,    46,
    1774      136,   137,   840,   383,    46,  1479,    46,   248,   324,   834,
    1775     1486,   337,   385,   235,   239,   870,   870,   870,   236,   384,
    1776      185,   682,  -424,   322,   483,   866,  1346,   577,   386,  -425,
    1777       46,   500,   870,  1177,   325,   519,   877,   921,   172,   505,
    1778     1177,   172,   272,  1021,  1147,  1149,   110,   387,   318,   318,
    1779      717,    74,   555,   556,    46,   428,    74,   208,   729,   934,
    1780     1409,   505,    46,   388,   367,   702,    46,  1080,    95,   693,
    1781       46,   498,   274,   472,   894,   448,  1125,   882,   448,  1177,
    1782      163,   703,   275,  1230,   448,    47,   172,   557,   558,  1099,
    1783      453,   754,   472,   453,   609,   392,   113,   393,   173,   453,
    1784      472,   679,   704,   860,   394,    94,   870,   861,   771,   603,
    1785      862,   754,   400,   777,   863,   629,   395,   396,   705,   633,
    1786      104,   488,   397,   318,   702,   488,   401,   598,   398,  1016,
    1787     1085,   704,   729,  1096,  1344,   721,   521,   728,   696,   521,
    1788      914,   318,   521,  1174,   726,    66,    60,   915,   172,   988,
    1789      276,   523,  1018,   334,   523,  1174,   548,   523,   365,  1175,
    1790      465,   549,   550,   366,  1300,   671,   673,  1442,   326,  1302,
    1791       46,  1291,   337,   520,  1442,   108,   520,   136,   137,   520,
    1792     1301,  1085,    46,   225,    46,  1303,   208,   226,   471,    53,
    1793      230,   569,   232,   404,   719,   870,   762,    67,   892,   241,
    1794      720,   570,   172,    46,   327,  1388,   318,   322,   322,   172,
    1795      999,   741,  1347,  1480,   817,    74,   742,   815,   862,    46,
    1796      593,   827,  1095,   603,   328,  -102,   764,  1031,   404,  -102,
    1797      939,   891,    46,   893,    74,    46,   765,   551,   552,   701,
    1798     1016,  -109,    74,  -109,  1029,   751,   337,  -109,   752,   856,
    1799      819,   758,   370,   519,   593,   717,   519,  1332,   329,   519,
    1800      865,  1333,  -109,  -109,  1074,   943,   883,   601,   642,    46,
    1801      330,    46,   884,    36,   736,   944,   172,    39,   382,  1444,
    1802      737,  1445,   322,   378,    40,    41,   559,   560,    74,   871,
    1803      871,   871,  -449,   172,  -449,   746,   402,   172,  -449,   938,
    1804      322,   747,  1107,   817,   762,   989,   871,   761,   917,    42,
    1805      693,  1036,   799,   762,   334,    46,    46,   905,   390,   144,
    1806      907,   984,  1481,   762,   225,   996,   762,   985,   419,    46,
    1807      138,   720,  1222,  1340,   903,   434,   448,   420,   577,   762,
    1808     1128,   728,   472,   910,  1341,   663,  1343,   912,   726,   424,
    1809      762,   453,   762,   692,   827,   603,   442,   104,   172,   664,
    1810       36,   455,   170,   171,    39,   322,   488,   694,   918,  1348,
    1811      458,    40,    41,   596,   919,   762,   920,   859,   461,   598,
    1812      871,   237,   240,   211,   472,   462,  1399,   717,   334,   108,
    1813     1031,    36,  1400,   874,   484,    39,   366,   717,  1419,  1500,
    1814      238,   159,    40,    41,   762,   577,   889,    46,   858,   248,
    1815      324,   404,   717,   598,   493,   728,   494,   190,   512,    46,
    1816      213,   528,   726,   223,   553,   554,   208,   733,   509,     8,
    1817        9,    10,    11,    12,   211,   524,   108,   734,   136,   137,
    1818      208,   526,   527,   324,   404,   998,   827,   561,   126,   815,
    1819      127,   128,   129,   547,   562,   578,    30,   404,   603,  1224,
    1820      563,   505,   225,  -275,   230,   581,  1056,   404,  1172,   871,
    1821        8,     9,    10,    11,    12,   817,   895,   211,   404,    33,
    1822      564,   898,   819,   404,    74,   567,   529,   530,   531,   527,
    1823      333,    46,   787,   788,   789,   790,  -421,    30,   412,   659,
    1824      404,   159,   585,   500,    46,   481,   324,   404,   729,   532,
    1825      588,   533,    46,   534,   368,   638,  1263,  1264,   505,   505,
    1826       33,  1131,   172,   404,   656,   527,    74,   841,   324,   601,
    1827       46,   208,  1314,  1316,  1317,  1282,  1283,   211,   815,   159,
    1828      457,   657,   448,   693,  1100,  1143,   665,   404,    66,    60,
    1829      225,   693,  1146,   667,   601,   172,    36,   453,   170,   171,
    1830       39,  1121,   159,  1148,   754,   601,  1121,    40,    41,   603,
    1831     1210,   172,   404,   658,   436,   211,  1151,  1079,   925,   211,
    1832      925,   488,  1102,   318,   172,  1437,  1438,   729,  1378,  1379,
    1833      783,   784,    53,   685,     2,   202,     4,     5,     6,     7,
    1834       67,   785,   786,   791,   792,   717,   717,   660,   661,   662,
    1835     1058,   253,   708,   748,  1121,   710,  -222,   759,   763,    63,
    1836      114,   767,   820,   -12,  1056,   822,   824,  1186,  1188,  1190,
    1837      856,   835,     2,   202,     4,     5,     6,     7,   879,   880,
    1838      886,   285,   906,   908,   913,   688,   909,  1217,   960,  -398,
    1839       63,   142,    34,   737,    35,   933,  -502,  1471,  1101,   947,
    1840      224,   717,   717,   157,   211,   954,     8,     9,    10,    11,
    1841       12,   956,   961,   965,   966,   643,   968,  1158,   969,   970,
    1842      368,   172,   971,   337,    46,   217,   980,   991,   992,   993,
    1843       34,    74,    35,    30,  1007,  1008,  1085,  1009,   780,   781,
    1844      782,  1010,  1011,  1179,   472,  1012,  1013,  1024,  -386,   448,
    1845      815,  -385,  1071,  1082,    -3,  1038,    33,   434,  1081,  1193,
    1846     1083,    36,   255,  1084,   453,    39,  1091,  1411,  1089,   505,
    1847     1073,  1088,    40,    41,  1092,  1090,  1098,  1108,  1109,   762,
    1848     1110,   527,   322,   211,   974,  1113,  1120,    53,  1117,  1141,
    1849     1164,  1162,  1163,  1165,   706,    67,   368,    42,  1166,   457,
    1850      104,  1180,  1181,   323,  1183,  1184,  1192,   144,  1182,  1198,
    1851      215,   255,   344,  1196,    -3,  1197,  1203,  1208,    46,  1056,
    1852     1214,  1225,  1223,   493,  1218,  1457,  1411,   505,   505,   858,
    1853     1228,   728,   739,   211,   743,  1232,  1236,  1239,   726,  1296,
    1854     1241,   399,  1243,  1244,  1249,  1273,   210,  1245,  1246,  1247,
    1855     1100,  1256,  1265,  1121,  1121,  1121,   417,  1266,  1276,   142,
    1856      423,  1277,  1342,  1490,   157,   334,   104,  1290,   717,  1298,
    1857        2,   202,     4,     5,     6,     7,   717,   717,   717,  1279,
    1858      904,  1280,  1287,   172,  1304,   440,    74,  1306,  1102,   443,
    1859     1310,   444,  1312,  1318,  1311,  1319,  1320,   210,  1322,  1328,
    1860      459,    66,    60,  1329,  1330,  1331,    63,  1056,  1338,  1339,
    1861     1349,   473,  1283,   527,  1352,  1354,   392,   726,   393,  1355,
    1862      717,   480,  1357,   206,   216,   394,  1362,    72,    34,   423,
    1863       35,   208,   400,  1365,  1361,  1372,  1100,   395,   396,  1373,
    1864      210,  -387,  1376,   397,  1397,    53,   401,  1387,  1391,   398,
    1865     1393,   663,  1401,    67,   211,   104,  1335,   975,    72,  1056,
    1866     1398,  1410,  1056,  1058,  1101,   664,  1271,  1272,  1420,  1274,
    1867     1405,  1406,  1407,  1408,  1102,  1278,  1179,   472,  1281,  1422,
    1868       46,    46,   211,   878,  1333,  1121,  1121,   211,  1415,  1350,
    1869     1424,  1426,  1428,   218,   718,   255,  1430,  1431,   594,  1443,
    1870      210,  1056,  1432,   527,   622,  1451,  1056,  1453,  1455,  1456,
    1871     1463,  1475,   990,  1478,  1485,   433,  1487,   627,  1493,  1499,
    1872       53,   627,   995,   434,   255,   793,  1100,   901,    67,  1056,
    1873      794,   796,   795,  1231,  1470,   797,  1289,  1006,   210,  1390,
    1874     1458,  1501,   210,   929,    74,  1351,  1474,   146,  1226,   932,
    1875     1101,  1353,   147,  1227,   148,  1202,  1446,  1086,   712,   683,
    1876      684,   926,   812,    36,  1102,   170,   171,    39,  1087,  1472,
    1877      473,    46,  1116,   211,    40,    41,   885,  1037,  1056,   949,
    1878      347,  1097,  1299,  1056,   344,   731,   957,   211,   802,   473,
    1879       46,    46,   104,   158,  1449,   803,  1056,   473,  1056,   370,
    1880        0,     0,  1056,  1377,   804,  1056,  1385,     0,     0,  1450,
    1881       46,  1056,   367,   104,     0,  1056,     0,  1179,   472,    74,
    1882        0,  1449,     0,   713,  1179,   472,   423,   210,  1384,   479,
    1883     1447,     0,   104,     0,     0,    36,  1450,   179,   180,    39,
    1884     1101,   727,     0,    63,   318,  1417,    40,    41,     0,     0,
    1885     1421,   423,     0,   441,  1396,   423,     0,  1473,     0,     0,
    1886        0,    53,     0,  1179,   472,     0,     0,     0,    53,    67,
    1887      172,   181,     0,  1435,    72,     0,    67,     0,   211,    72,
    1888        0,   182,     0,   255,   344,     0,     0,     0,   104,     0,
    1889        0,   527,    36,  1498,   179,   180,    39,     0,     0,   718,
    1890        0,     0,     0,    40,    41,  1503,   210,    53,     8,     9,
    1891       10,    11,    12,     0,     0,    67,     0,     0,   104,     0,
    1892        0,   643,     0,     0,     0,     0,     0,  1041,   261,   805,
    1893     1156,  1157,   509,     0,     0,    30,     0,     0,   262,     0,
    1894     1491,     0,     0,     0,     0,    75,  1491,   627,   818,     0,
    1895      594,     0,     0,     0,     0,  1491,   210,     0,    33,  1491,
    1896       74,   837,     0,     0,     0,     0,     0,    74,     0,     0,
    1897        0,     0,   218,     0,     0,     0,    75,     0,     0,   594,
    1898        0,     0,     0,     0,   594,     0,  1205,  1206,     0,     0,
    1899      627,     0,     0,   344,   344,   344,     0,     0,     0,   569,
    1900        0,   404,     0,   322,     0,     0,    74,     0,   104,   570,
    1901      344,   219,   209,     0,     0,   643,     0,     0,     0,     0,
    1902        0,     0,   228,     0,    54,    54,     0,     0,   713,   104,
    1903        0,   718,   172,     0,     0,     0,   104,     0,    72,   473,
    1904        0,   718,    36,   527,   255,   727,    39,     0,   922,     0,
    1905        0,  -276,   347,    40,    41,    54,   718,    72,     8,     9,
    1906       10,    11,    12,   209,   211,    72,     0,     0,     0,     0,
    1907        0,     0,     0,     0,     0,   104,     0,   210,   825,     0,
    1908      601,   473,     0,     0,   344,    30,     0,    54,   602,     0,
    1909       54,   347,  -277,   948,     0,     0,   423,     0,   349,     8,
    1910        9,    10,    11,    12,     0,   210,   209,     0,    33,   347,
    1911      210,    72,  1041,     0,     0,     0,     0,     0,   255,   727,
    1912        0,     0,     0,     0,   973,     0,    30,     0,     0,     0,
    1913        0,     0,     8,     9,    10,    11,    12,     0,     8,     9,
    1914       10,    11,    12,     0,     0,     0,     0,     0,   406,    33,
    1915        0,     0,   347,  1321,     0,   414,     0,     0,     0,    30,
    1916      713,  1323,  1324,  1325,     0,    30,   209,     0,     0,     0,
    1917      713,     0,     0,   344,     0,   627,     0,   342,  1004,   627,
    1918      818,     0,    33,     0,     0,   713,     0,    36,    33,   179,
    1919      180,    39,    75,     0,     0,  1015,   210,    75,    40,    41,
    1920        0,     0,     0,     0,   209,  1356,     0,     0,   209,     0,
    1921      210,     0,     0,    77,     0,  1269,   347,     0,     0,     0,
    1922        0,     0,     0,   600,   499,   601,     0,   406,     0,   764,
    1923        0,   404,     0,   602,     0,     0,     0,     0,   211,   765,
    1924        0,    54,     0,     0,    77,     0,    63,     0,     0,   718,
    1925      718,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    1926        0,   347,   347,   347,     0,     0,     0,     0,   627,     0,
    1927        0,    54,     0,     0,     0,     0,     0,     0,   347,   220,
    1928        0,   575,     0,     8,     9,    10,    11,    12,     0,   579,
    1929      219,     0,   582,   209,     0,     0,   347,     0,     0,     0,
    1930        0,   210,     0,  1094,     0,   718,   718,    72,     0,     0,
    1931       30,   423,   114,   347,     0,     0,     0,    36,     0,   179,
    1932      180,    39,     0,   121,   124,   125,   344,     0,    40,    41,
    1933      211,     0,     0,    33,   535,   536,   537,   538,   539,   540,
    1934      541,   542,   543,   544,     0,     0,     0,     0,     0,    72,
    1935        0,     0,   347,   687,   406,   404,    75,     0,   414,     0,
    1936      594,   688,     0,   689,     0,     0,   350,   545,     0,     0,
    1937      349,     0,   209,   142,   943,    75,   601,     0,   713,   713,
    1938        0,   344,   344,    75,   944,     0,     0,   347,     0,   209,
    1939        0,     0,     0,     0,   250,     0,   251,     0,     0,     0,
    1940        0,  1178,     0,     0,     0,     0,     0,     0,     0,   349,
    1941        0,     0,     8,     9,    10,    11,    12,     0,     0,     0,
    1942        0,     0,   209,     0,     0,     0,     0,   349,   347,    75,
    1943        0,     0,     0,     0,   713,   713,     0,     0,   347,    30,
    1944      627,   347,   406,  1297,     0,     0,   218,     0,   347,   342,
    1945        0,     0,     0,   347,     0,     0,     0,     0,     0,     0,
    1946       77,     0,    33,     0,     0,    77,     0,    36,     0,     0,
    1947      349,    39,   718,     0,     0,   389,     0,     0,    40,    41,
    1948      718,   718,   718,     0,     0,   408,   409,   210,     0,     0,
    1949      413,     0,   415,   416,     0,   727,     0,     0,     0,     0,
    1950        0,     0,     0,   733,     0,     0,     0,     0,    54,     0,
    1951        0,     0,     0,   734,    72,    36,     0,   179,   180,    39,
    1952        0,     0,     0,     0,   718,     0,    40,    41,     0,     0,
    1953        0,    84,   575,   575,   349,     0,     0,     0,  1270,     0,
    1954        0,     0,     0,   209,     0,     0,     0,     0,     0,   342,
    1955        0,   600,     0,   601,     0,   255,     0,     0,   220,    63,
    1956        0,   602,    84,     0,     0,     0,     0,     0,     0,     0,
    1957        0,   209,   713,     0,   727,     0,   209,     0,   114,   349,
    1958      349,   349,     0,     0,     0,     0,     0,     0,     0,     0,
    1959        0,     0,     0,     0,   347,     0,   349,   221,     0,     0,
    1960        0,   713,     0,     0,     0,     0,     0,     0,     0,   713,
    1961      713,   713,     0,   342,   349,     0,     0,     0,     0,   896,
    1962      344,   344,     0,   899,    77,    75,     0,     0,     0,     0,
    1963        0,   349,     0,     0,  1178,     0,     0,     0,   350,     0,
    1964        0,     0,     0,    77,     0,     0,   347,   347,     0,   347,
    1965      347,    77,     0,   713,     0,     0,   406,     0,   342,   342,
    1966      342,   210,   209,     0,   114,     0,     0,    75,     0,    72,
    1967      349,     0,     0,     0,     0,   342,   209,   350,     0,     0,
    1968        0,     0,     0,     0,   357,     0,     0,     0,     0,     0,
    1969        0,     0,     0,     0,     0,   350,   499,    77,     0,     0,
    1970        0,     0,   347,   347,     0,   349,     0,     0,     0,     0,
    1971        0,     0,     0,     0,     0,     8,     9,    10,    11,    12,
    1972       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    1973       23,    24,     0,   344,    25,    26,    27,     0,   350,     0,
    1974        0,     0,    30,   446,     0,     0,   349,     0,     0,   342,
    1975        0,     0,     0,   210,   114,     0,   349,     0,     0,   349,
    1976        0,     0,     0,   347,   219,    33,   349,   209,   575,     0,
    1977        0,   349,    37,    38,     0,  1178,     0,     0,    84,     0,
    1978        0,     0,  1178,    84,     0,     0,     0,     0,     0,     0,
     1747     110,   146,    46,   147,    95,   393,   148,   447,   394,   378,
     1748     395,   111,   704,   422,   401,   402,   434,   885,   923,   396,
     1749     397,   731,   398,   399,   500,   836,   611,   263,   256,   965,
     1750     473,   861,   924,    46,   743,    95,   925,   140,   748,   844,
     1751     710,  1078,  1129,   630,    46,   832,    46,   634,   158,  1374,
     1752     113,   778,   837,  1137,  1171,    47,    46,    30,    30,   404,
     1753     838,   843,    46,   835,   189,    46,   699,   212,    46,   847,
     1754     222,   606,    30,   810,   120,   854,   215,   338,   108,   108,
     1755     984,  1436,   108,   276,   941,   393,    47,   530,   394,   149,
     1756     395,  1432,   671,   156,   401,   402,   923,   927,   150,   396,
     1757     397,  1181,   398,   399,   833,    30,    46,  1169,  1170,    46,
     1758     924,   419,   680,  1120,   925,    46,   198,   119,   403,   940,
     1759     684,   151,   248,   405,   405,  1199,    60,  1177,   286,   598,
     1760    -225,  -225,    30,   477,   479,   277,   413,  1195,   405,   770,
     1761     146,  1197,   147,  1447,   834,   148,    46,  1077,   158,   248,
     1762     325,    67,   254,  1178,    46,  1432,   968,    60,   156,    46,
     1763     199,   368,   478,   675,   677,  1436,  1394,  1395,   108,   483,
     1764    1436,   405,   139,   875,   875,   875,    30,   108,   521,   832,
     1765      54,    54,    67,    46,    46,  1187,   158,  1436,   507,   567,
     1766     473,   875,   319,   108,  1436,  -225,   160,  1066,   108,    46,
     1767     530,   335,   530,    30,   138,   669,   774,    46,  1246,   158,
     1768     473,    54,   141,    66,   208,   780,    46,   738,   473,    46,
     1769     146,   437,   147,   568,   143,   148,   731,   753,   149,  1085,
     1770    1396,  1327,   666,   667,   754,  1247,  1329,   150,   833,   747,
     1771     845,   864,   603,    54,    66,   865,    54,   467,  1171,    46,
     1772     424,    95,   836,   465,   428,   237,   240,   761,    53,   112,
     1773     151,   160,   589,    46,    46,   875,   158,   852,   152,   603,
     1774      46,   704,   832,   732,   821,   167,  1026,    46,   834,   837,
     1775     372,   530,   695,   697,   319,   450,   611,   838,   518,    53,
     1776    1013,   338,   741,  -455,  1323,   847,   373,  1171,  1025,   104,
     1777     104,   731,    47,  1508,   658,  1186,  1139,  1377,   674,   676,
     1778    1002,   887,  1394,  1395,   666,   667,   428,   870,   530,   490,
     1779    1517,   206,   814,  -455,   216,  -455,    46,  1521,   368,  -455,
     1780     104,   833,   673,   343,   173,  1457,  1509,  1201,   678,   523,
     1781     381,   888,   156,   645,    74,    46,    46,   889,   550,   165,
     1782    1169,  1170,   966,   551,   552,   875,   382,   429,  1192,  1078,
     1783    1522,  1178,    46,   916,   441,   104,    46,   108,   436,   136,
     1784     137,   834,   836,    60,  1119,    74,  1405,   866,   474,   478,
     1785     177,   867,   598,   462,   257,   844,   588,   258,   455,   595,
     1786     197,   108,    46,   136,   137,  -281,   521,    54,    67,   837,
     1787     521,   569,    46,   521,   368,   881,   848,   838,   628,   384,
     1788     851,   598,   632,  1171,   459,   335,   598,   752,   861,   429,
     1789      46,   108,  1187,   136,   234,   385,    46,    54,    46,  -109,
     1790     225,   868,   239,   386,   226,   871,  1381,   230,   578,   232,
     1791    1421,  1422,   525,    36,   579,   160,   241,    39,   243,   387,
     1792    -109,   338,    46,   246,    40,    41,   803,   235,  -109,  -109,
     1793      66,   473,   236,  -506,   169,  1077,   685,  1427,   110,   319,
     1794     319,   248,   579,   755,  -109,   435,    46,   756,   732,   829,
     1795     762,   603,  1157,  1159,    46,   722,   368,   -10,    46,   604,
     1796      95,   723,    46,   886,   433,  1242,   208,   450,  1107,   500,
     1797     450,  1088,  1121,   945,  1007,    53,   450,   249,   821,  1122,
     1798    1135,   388,   260,   758,   393,  1066,   739,   394,   113,   395,
     1799     553,   554,   740,   611,   401,   402,  1236,   389,   396,   397,
     1800     775,   398,   399,   758,   899,   781,  -431,  1026,   474,  -432,
     1801     705,    47,  1360,   490,  1093,   319,   104,   490,   485,   495,
     1802     646,   496,   699,   732,   326,   502,   706,   523,   474,   557,
     1803     558,   523,   707,   319,   523,  1358,   474,  1168,  1024,  1187,
     1804     897,   225,   705,   707,  1184,   335,  1187,  1184,   708,   906,
     1805     379,   749,   467,  1275,  1276,    94,  1312,   750,   919,   920,
     1806    1185,    74,    46,  1303,   559,   560,    74,  1093,   821,   272,
     1807     455,   411,  1313,   455,    46,  1367,    46,   343,   720,   455,
     1808     729,   274,    60,   338,   876,   877,    94,  1314,   866,   580,
     1809    1187,   405,  1103,   173,   431,    46,   208,   145,   319,    94,
     1810     709,   895,   275,  1315,   439,   459,   163,    67,  1404,   819,
     1811     631,    46,   595,  1321,   635,   185,   765,   366,    94,   704,
     1812    1322,    94,   766,   766,   896,    46,   898,  -102,    46,  1393,
     1813     525,  -102,  1401,  1029,   525,   969,    54,   525,   742,  1361,
     1814     746,   860,   910,   874,   874,   874,   595,   327,   766,  1037,
     1815     328,  1024,   869,   731,   108,   329,   136,   137,   338,  1463,
     1816     330,   874,    46,  1346,    46,   331,  1463,  1347,  1482,    66,
     1817    1082,   163,   522,  1435,  1487,   948,   367,   343,  1439,  -109,
     1818     225,  -109,   230,   555,   556,  -109,  1465,   571,  1466,   405,
     1819     744,  1504,   944,   561,   562,   745,  1511,   572,  1044,    94,
     1820    -109,  -109,  1115,  1456,   583,   323,   405,   335,    46,    46,
     1821    1505,   768,    94,   405,    53,     2,   202,     4,     5,     6,
     1822       7,   769,    46,   371,  1234,  1104,    74,   912,  1238,   450,
     1823     666,   667,   383,   766,  1506,   874,   392,   185,   695,   697,
     1824     391,   343,   949,   821,   603,   436,    74,   248,   325,   405,
     1825     992,  1004,   950,  1417,    74,   104,   993,   723,  1232,   490,
     1826      94,   413,   662,   405,   579,  1005,   403,   430,   598,   225,
     1827    1429,   420,    94,    34,   823,    35,   900,  1516,   405,   474,
     1828    1349,   421,   335,  1516,   720,   729,   343,   343,   343,   923,
     1829     882,   426,  1516,  1354,   766,   997,  1516,   323,   444,   766,
     1830      74,    46,    94,   924,   343,  1161,    36,   925,   179,   180,
     1831      39,    36,   457,    46,  1355,    39,   481,    40,    41,   682,
     1832     766,   474,    40,    41,  1357,   874,   483,   325,   405,   430,
     1833     766,   463,   455,  1480,  1429,    -3,   903,   208,   405,  1006,
     1834    1362,   464,   602,   819,   603,   460,   766,    42,   159,   108,
     1835     935,   208,   604,   724,   486,   163,   938,   144,   506,  1182,
     1836     729,  1064,  1418,  1437,   190,  1475,  1525,   213,  1415,   766,
     1837     223,  1476,   579,   863,   791,   792,   793,   794,   343,    94,
     1838       8,     9,    10,    11,    12,   108,    46,   136,   137,   878,
     1839     522,   845,   325,   603,   522,   514,  1141,   522,   405,   605,
     1840      46,   526,   600,   894,  1153,   732,   405,    30,    46,     2,
     1841     202,     4,     5,     6,     7,   286,  1156,   720,   603,   530,
     1842      36,    63,   114,  1158,    39,   603,    46,   720,   325,   405,
     1843      33,    40,    41,   819,  1328,  1330,  1331,   450,  1220,  1108,
     1844     405,   563,   720,   208,   931,   564,   931,   566,   159,   531,
     1845     532,   533,    63,  1294,  1295,   185,   736,  1415,  1416,  1131,
     1846     565,   369,   758,  -428,  1131,   157,   737,    34,   343,    35,
     1847     569,   571,   534,   405,   535,   343,   536,   490,  1110,   319,
     1848     334,   572,   323,   323,   732,   587,   159,   217,    60,   126,
     1849     590,   127,   128,   129,  1227,  1458,  1459,    74,   640,   969,
     1850     502,  1394,  1395,   969,   969,   696,   787,   788,   823,   159,
     1851     789,   790,  1131,    67,   659,   795,   796,   660,   661,   663,
     1852     664,   438,  1064,   668,   255,  1196,  1198,  1200,   860,   646,
     1853     665,   670,   253,   711,   688,   751,  1049,   713,  -229,    74,
     1854     455,    94,    54,   763,   767,   605,   771,   824,  1283,  1284,
     1855     826,  1286,   828,   908,   839,   884,  1494,  1290,   323,   891,
     1856    1293,   -12,   915,   883,   211,   324,   917,     8,     9,    10,
     1857      11,    12,   911,   255,   345,    66,   323,   913,   914,   918,
     1858     691,   238,    46,   939,     8,     9,    10,    11,    12,  -405,
     1859    -510,   953,   960,   740,    30,   962,   967,   973,   974,  1093,
     1860     977,   338,   978,   400,   979,   721,   976,   450,   819,    54,
     1861     999,    30,   988,  1000,  1001,   211,  1319,    33,   418,  1015,
     1862      53,   423,   425,  1016,  1017,   343,   157,   646,   369,  1018,
     1863    1019,  1020,  1021,   436,    33,  1032,  -393,  -392,  1079,   720,
     1864     720,   323,  1081,  1046,  1089,  1090,   474,   442,  1091,  1092,
     1865    1097,   445,  1096,   446,  1099,   600,  -282,   831,   211,   605,
     1866    1098,   104,   461,     8,     9,    10,    11,    12,    63,   215,
     1867    1100,    67,  1106,   475,  1116,   768,   766,   405,    46,  1064,
     1868     343,   343,  1117,   482,   862,   769,  1118,  1109,   982,   600,
     1869      30,   425,  1123,  1127,  1130,   720,   720,  1151,  1174,  1375,
     1870      54,  1172,  1173,  1375,   369,  1175,    74,  1190,  1176,  1108,
     1871     455,  1206,  1191,    33,  1400,  1131,  1131,  1131,   211,    36,
     1872    1193,   170,   171,    39,  1049,   335,  1194,  1202,   104,  1207,
     1873      40,    41,    36,  1189,   170,   171,    39,  1208,    -3,  1213,
     1874    1515,  1218,   729,    40,    41,   922,  1224,   696,  1110,   495,
     1875    1228,  1233,  1235,  1237,  1240,  -283,   211,  1413,   255,  1244,
     1876     211,   596,     8,     9,    10,    11,    12,   624,   367,  1064,
     1877    1248,  1253,  1251,  1255,    72,  1256,  1257,  1285,    53,  1258,
     1878     629,  1259,  1261,  1268,   629,   393,  1277,   255,   394,    30,
     1879     395,   831,   605,  1278,   401,   402,  1448,  1108,  1087,   396,
     1880     397,  1302,   398,   399,  1310,    72,    60,  1288,  1289,   208,
     1881    1291,   721,    33,  1316,  1292,   666,   667,  1299,  1318,   104,
     1882    1320,   729,  1325,  1064,  1324,  1326,  1064,  1332,  1333,  1281,
     1883    1334,    67,  1336,   475,  1342,  1308,  1110,  1343,    54,    54,
     1884     218,  1344,  1345,  1356,    46,    46,   211,  1352,   345,  1353,
     1885    1363,  1131,  1131,   475,  1493,  1295,  1366,  1368,  1369,  1371,
     1886      54,   475,  1378,  1381,    74,  1388,   720,  1064,  1389,  -394,
     1887    1392,  1403,  1064,  1407,   720,   720,   720,  1409,  1414,    54,
     1888    1423,  1419,  1424,   474,   831,  1449,  1428,   716,  1425,  1426,
     1889     425,  1108,  1433,    66,  1438,  1442,   605,  1064,  1347,  1440,
     1890    1444,  1446,  -284,   436,  1453,   730,  1451,    63,    67,     8,
     1891       9,    10,    11,    12,  1472,   425,   206,   216,   720,   425,
     1892     146,  1452,   147,   343,   343,   148,   211,   348,  1474,  1464,
     1893    1110,  1478,    54,  1479,  1486,  1498,    30,    54,    53,  1499,
     1894    1495,  1518,    46,  1203,   721,  1500,  1503,   255,   345,   909,
     1895    1510,  1064,  1512,   926,   721,  1524,  1064,  1109,   104,    33,
     1896     797,   799,  1470,    46,    46,   798,   158,    54,   800,   721,
     1897    1189,  1064,  1243,  1064,   801,   926,   211,  1064,   172,   104,
     1898    1064,  1406,  1481,   696,  1301,    46,  1064,   368,  1526,  1365,
     1899    1064,   696,  1470,   809,  1497,  1239,  1379,  1467,   104,  1212,
     1900     443,   686,   687,  1094,   932,  1045,  1095,  1126,   890,   605,
     1901     435,   629,   822,   955,   596,    53,   715,   319,   816,  1311,
     1902    1105,    72,   323,   734,    74,   841,    72,   806,   172,   210,
     1903     474,   172,   963,   807,   808,     0,     0,   474,     0,     0,
     1904     343,     0,     0,   596,     0,  1109,     0,     0,   596,     0,
     1905       0,     0,     0,     0,   629,    67,   104,   345,   345,   345,
     1906       0,    54,    67,     0,   996,  1471,    36,     0,   179,   180,
     1907      39,   862,     0,     0,     0,   345,   172,    40,    41,     0,
     1908     210,   474,   998,     0,    54,    75,   104,     0,     0,     0,
     1909       0,    54,  1003,   716,     0,  1471,     0,   211,     0,     0,
     1910       0,    74,   181,     0,   475,     0,    67,  1014,     0,   255,
     1911     730,     0,   182,   928,     0,     0,    75,  1189,     0,     0,
     1912     218,     0,  1412,   210,  1189,   211,     0,     0,     0,     0,
     1913     211,     0,     0,     0,     0,    54,     0,     0,   172,  1109,
     1914     407,     0,  1039,     0,     0,     0,   475,   415,     0,   345,
     1915       0,   219,    36,     0,   179,   180,    39,     0,   954,     0,
     1916       0,   425,    53,    40,    41,     0,   721,   721,  1189,    53,
     1917       0,     0,     0,     0,     0,     0,     0,  1364,     0,     0,
     1918     104,     0,     0,   210,   255,   730,    72,     0,   261,     0,
     1919     981,     0,   172,    36,     0,   170,   171,    39,   262,   172,
     1920       0,   348,     0,   104,    40,    41,    72,     0,     0,     0,
     1921     104,     0,     0,    53,    72,     0,     0,   211,     0,   407,
     1922       0,   210,   721,   721,     0,   210,   716,     0,     0,   371,
     1923     926,   211,     0,     0,     0,     0,   716,     0,   350,   345,
     1924     348,   629,     0,     0,  1012,   629,   822,     0,    74,     0,
     1925       0,   716,     0,     0,   104,    74,     0,     0,   348,  1138,
     1926      72,  1023,     8,     9,    10,    11,    12,   172,     0,     0,
     1927       0,     0,     0,     0,   577,     8,     9,    10,    11,    12,
     1928       0,     0,   581,     0,   172,   584,     0,     0,   172,    30,
     1929       0,     0,     0,     0,     0,     0,     0,     0,     0,    74,
     1930       0,   348,    30,     0,  1166,  1167,     0,     0,     0,  1039,
     1931       0,   210,    33,    63,     0,     0,     0,    36,     0,   179,
     1932     180,    39,     0,   211,  1468,    33,     0,     0,    40,    41,
     1933      36,     0,    75,     0,    39,   629,     0,    75,     0,     0,
     1934       0,    40,    41,     0,     0,     0,     0,   407,     0,     0,
     1935     172,   415,     0,   602,  1496,   603,     0,     0,     0,     0,
     1936    1215,  1216,  1309,   604,     0,   348,    42,     0,    77,     0,
     1937       0,  1102,     0,     0,     0,     0,   144,     0,     0,   425,
     1938     114,     0,   926,     0,     0,     0,     0,     0,     0,     0,
     1939       0,   210,     0,   721,  1523,    84,   345,     0,     0,    77,
     1940       0,   721,   721,   721,     0,     0,  1528,     0,     0,     0,
     1941     348,   348,   348,     0,     0,     0,     0,     0,     0,   511,
     1942       0,     0,     0,     0,     0,     0,    84,     0,   348,     0,
     1943     596,   219,   528,   529,   220,     0,   407,     0,     0,   926,
     1944     926,   210,     0,   423,   549,   721,   348,     0,   716,   716,
     1945       0,   345,   345,     0,     0,     0,     0,    72,     0,     0,
     1946       0,   221,     0,   348,     0,     8,     9,    10,    11,    12,
     1947       0,  1188,     2,   202,     4,     5,     6,     7,     0,     0,
     1948     529,     0,    36,     0,   179,   180,    39,     0,     0,     0,
     1949       0,     0,    30,    40,    41,     0,     0,    75,     0,    72,
     1950     224,     0,   348,     0,   716,   716,     0,     0,     0,     0,
     1951     629,     0,   350,   211,   172,    33,   529,    75,   690,     0,
     1952     405,   351,     0,     0,     0,    75,   577,   577,   692,     0,
     1953      34,  1335,    35,     0,     0,     0,     0,     0,   348,  1337,
     1954    1338,  1339,     0,     0,     0,     0,   481,   172,   358,     0,
     1955       0,   350,     0,     0,     0,     0,   949,     0,   603,     0,
     1956     323,     0,   210,   172,     0,     0,   950,   730,     0,   350,
     1957      36,    75,   179,   180,    39,     0,     0,   172,     0,   348,
     1958       0,    40,    41,  1370,     0,     0,   209,     0,     0,   348,
     1959     210,     0,   348,     0,     0,   210,   228,   218,     0,   348,
     1960       0,     0,     0,     0,   348,     0,  1491,     0,   405,     0,
     1961    1282,     0,   350,     0,   901,    77,  1492,     0,   904,     0,
     1962      77,    36,     0,   179,   180,    39,     0,   255,     0,     0,
     1963       0,    63,    40,    41,     0,     0,     0,   209,     0,   926,
     1964       0,     0,    84,     0,   716,     0,   730,    84,     0,     0,
     1965     114,   407,     0,     0,     0,     0,   926,   690,     0,   405,
     1966       0,     0,     0,     0,     0,   691,    72,   692,     0,     0,
     1967       0,     0,     0,     0,   172,   716,   350,     0,     0,     0,
     1968     209,     0,   210,   716,   716,   716,     0,     0,     0,   211,
     1969     784,   785,   786,     0,   345,   345,   210,   537,   538,   539,
     1970     540,   541,   542,   543,   544,   545,   546,     0,  1188,     0,
     1971       0,     0,     0,     0,   220,     0,     0,     0,     0,   926,
     1972     926,   350,   350,   350,     0,     0,     0,   716,     0,     0,
     1973     547,     0,     0,   529,     0,     0,     0,     0,   114,   350,
     1974     209,   221,     0,     0,     0,     0,     0,     0,     0,   348,
     1975       0,     0,     0,     0,     0,     0,     0,   350,     0,     8,
     1976       9,    10,    11,    12,   577,     0,     0,     0,    75,     0,
     1977       0,     0,     0,     0,   350,     0,     0,     0,   209,     0,
     1978      77,     0,   209,   211,     0,     0,    30,     0,   210,     0,
     1979       0,     0,     0,     0,     0,   351,     0,     0,   501,     0,
     1980      77,   348,   348,     0,   348,   348,     0,    84,    77,    33,
     1981      75,   345,     0,   350,    36,     0,   179,   180,    39,     0,
     1982       0,     0,   358,     0,    72,    40,    41,    84,     0,     0,
     1983       0,     0,   114,     0,   351,    84,     0,     0,   172,     0,
     1984       0,     0,     0,     0,     0,     0,     0,     0,     0,   350,
     1985     181,     0,   351,     0,    77,  1188,     0,   348,   348,     0,
     1986     182,   358,  1188,     0,     0,     0,   529,     0,   209,     0,
     1987       0,     0,     0,     0,     0,     0,     0,   407,     0,   358,
     1988       0,    84,     0,     0,     0,     0,     0,     0,     0,     0,
     1989     350,     0,     0,     0,     0,   351,     0,     0,     0,     0,
     1990     350,     0,     0,   350,     0,     0,  1188,     0,   219,     0,
     1991     350,   983,     0,  1513,     0,   350,     0,     0,     0,     0,
     1992     348,     0,   358,     0,   469,     2,   202,     4,     5,     6,
     1993       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     1994      17,    18,    19,    20,    21,    22,    23,    24,   209,     0,
     1995      25,    26,    27,     0,  1142,     0,     0,   529,    30,   351,
     1996       0,     0,     0,   218,     0,   209,     0,     0,     0,     0,
     1997    1154,     0,     0,     0,     0,     0,     0,    75,   210,     0,
     1998       0,    33,     0,    34,    72,    35,   358,     0,    37,    38,
     1999       0,     0,     0,     0,     0,     0,     0,   348,   209,   348,
     2000       0,     0,     0,     0,   351,   351,   351,     0,     0,     0,
    19792001       0,     0,     0,     0,     0,     0,     8,     9,    10,    11,
    1980       12,     0,   350,     0,     0,     0,   218,     0,   447,     0,
    1981        0,     0,   700,     0,     0,     0,   109,     0,     0,     0,
    1982        0,  1178,    36,    30,   179,   180,    39,    72,  1488,     0,
    1983        0,     0,    75,    40,    41,     0,     0,     0,   342,     0,
    1984      347,     0,   347,     0,     0,   342,    33,   350,   350,   350,
    1985        0,    36,     0,   179,   180,    39,     0,     0,   687,     0,
    1986      404,     0,    40,    41,   350,     0,     0,     0,   689,   347,
    1987        0,   807,   808,     0,     0,     0,   221,   347,   347,   347,
    1988      406,     0,   350,     0,     0,     0,     0,   181,   347,   347,
    1989        0,     0,     0,    77,     0,     0,     0,   182,     0,   350,
    1990        0,   842,    72,     0,   845,   846,     0,   849,     0,   851,
    1991      852,    54,   349,     0,   853,   854,     0,     0,     0,     0,
    1992        0,   347,     0,     0,     0,     0,     0,     0,     0,     0,
    1993        0,     0,     0,     0,     0,    77,     0,     0,   350,     0,
    1994        0,     0,    84,     0,     0,     0,    36,     0,   179,   180,
    1995       39,     0,     0,   209,  1132,     0,   357,    40,    41,     0,
    1996        0,    84,     0,     0,   349,   349,     0,   349,   349,    84,
    1997     1144,     0,     0,   350,   164,     0,   168,    54,     0,   174,
    1998      175,   176,  1468,   178,   404,     0,     0,    75,     0,     0,
    1999        0,   342,  1469,     0,     0,   357,   927,   928,   229,     0,
    2000        0,   347,   930,     8,     9,    10,    11,    12,     0,     0,
    2001      244,   245,     0,   357,   350,    84,     0,     0,     0,     0,
    2002      349,   349,     0,     0,   350,     0,     0,   350,     0,     0,
    2003       30,     0,   220,     0,   350,     0,     0,     0,     0,   350,
    2004        0,     0,     0,    72,     0,  1211,   342,   342,     0,     0,
    2005       72,     0,     0,    33,     0,     0,   357,     0,    36,     0,
    2006      179,   180,    39,     0,     0,     0,    54,     0,     0,    40,
    2007       41,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2008        0,   349,     0,     0,     0,     0,     0,     0,     0,    72,
    2009        0,     0,     0,     0,   687,     0,   404,     0,     0,     0,
    2010       77,     0,     0,     0,   689,     0,     0,     0,     0,     0,
     2002      12,     0,   351,     0,     0,     0,     0,    -3,   348,     0,
     2003       0,   358,   358,   358,     0,     0,   348,   348,   348,     0,
     2004     351,     0,     0,    30,     0,  1221,     0,   348,   348,   358,
     2005       0,    77,     0,     0,     0,     0,     0,   351,     0,     0,
     2006     350,    72,     0,   164,     0,   168,    33,   358,   174,   175,
     2007     176,    36,   178,   179,   180,    39,     0,     0,    84,     0,
     2008     348,     0,    40,    41,   358,     0,     0,   229,     0,     0,
     2009       0,     0,     0,    77,     0,     0,   351,     0,     0,   244,
     2010     245,     0,     0,     0,     0,     0,     0,   690,     0,   405,
     2011       0,     0,   350,   350,     0,   350,   350,   692,     0,   209,
     2012      84,     0,     0,   358,     0,     0,     0,     0,     0,     0,
     2013     172,     0,   351,     0,     0,    75,     0,     0,     0,     0,
     2014       0,     0,     0,     0,     0,     0,     0,   209,     0,   529,
     2015       0,     0,   209,     0,   210,     0,     0,     0,     0,   358,
     2016       0,     0,     0,     0,   348,     0,     0,     0,   350,   350,
     2017       0,     0,     0,   351,     0,     0,     0,     8,     9,    10,
     2018      11,    12,     0,   351,     0,     0,   351,     0,     0,     0,
     2019     511,   220,     0,   351,     0,     0,     0,     0,   351,     0,
     2020     358,     0,     0,     0,    30,     0,     0,     0,    72,     0,
     2021     358,     0,     0,   358,     0,    72,     0,     0,   221,     0,
     2022     358,     0,     0,     0,     0,   358,     0,    33,     0,     0,
     2023       0,   350,    36,     0,   179,   180,    39,     0,     0,   209,
     2024       0,     0,     0,    40,    41,     0,     0,     0,   210,     0,
     2025       0,     0,     0,   209,     0,     0,     0,     0,     0,    72,
     2026      77,     8,     9,    10,    11,    12,     0,     0,  1491,     0,
     2027     405,     0,     0,   501,   219,     0,     0,     0,  1492,     0,
     2028       0,     0,     0,     0,     0,     0,     0,    84,    30,     0,
     2029       0,     0,     0,     0,     0,    75,   172,     0,     0,     0,
     2030       0,     0,     0,   529,     0,     0,     0,     0,   350,     0,
     2031     350,    33,     0,     0,     0,     0,    36,     0,   179,   180,
     2032      39,     0,     0,     0,     0,     0,     0,    40,    41,     0,
     2033       0,     0,   123,   123,   123,     0,     0,     0,     0,   350,
     2034       0,     0,     0,   351,     0,   209,     0,   350,   350,   350,
     2035       0,     0,   261,   594,   601,     0,     0,     0,   350,   350,
     2036       0,     0,   262,     0,     0,   625,   626,     0,     0,     0,
     2037     358,     0,    75,     0,     0,     0,     0,     0,     0,     0,
     2038       0,     0,   121,   124,   125,     0,     0,     0,     0,     0,
     2039       0,   350,     0,     0,   162,   351,   351,     0,   351,   351,
     2040       0,     0,     0,   123,     0,   123,     0,     8,     9,    10,
     2041      11,    12,     0,   214,     0,     0,     0,     0,    77,     0,
     2042       0,     0,   358,   358,     0,   358,   358,     0,     0,   271,
     2043       0,     0,     0,     0,    30,     0,     0,     0,     0,     0,
     2044       0,     0,     0,     0,     0,    84,     0,     0,     0,     0,
     2045       0,   351,   351,   250,     0,   251,     0,    33,     0,   162,
     2046       0,     0,    36,     0,   268,     0,    39,     0,     0,     0,
     2047       0,     0,     0,    40,    41,   350,     0,     0,   358,   358,
     2048       0,     0,     0,     0,   123,     0,     0,     0,     0,     0,
     2049       0,     0,   123,   162,   123,   123,     0,     0,   736,   123,
     2050       0,   123,   123,   364,     0,     0,     0,   370,   737,     0,
     2051      &nb