Changeset b5b0907


Ignore:
Timestamp:
Jun 15, 2015, 12:45:26 PM (7 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, 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:
94b4364
Parents:
ea9b9d3 (diff), a1d5d2a (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 resolver

Conflicts:

src/CodeGen/CodeGenerator.cc

Location:
src
Files:
5 deleted
50 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    rea9b9d3 rb5b0907  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Rob Schluntz
    12 // Last Modified On : Thu Jun 11 13:22:39 2015
    13 // Update Count     : 137
     12// Last Modified On : Mon Jun 15 12:43:21 2015
     13// Update Count     : 138
    1414//
    1515
     
    1919#include <list>
    2020
     21#include "Parser/ParseNode.h"
     22
    2123#include "SynTree/Type.h"
    22 #include "SynTree/Declaration.h"
    23 #include "SynTree/Statement.h"
    2424#include "SynTree/Expression.h"
    2525#include "SynTree/Initializer.h"
     26#include "SynTree/Statement.h"
    2627
    2728#include "utility.h"
     
    628629        void CodeGenerator::handleStorageClass( Declaration *decl ) {
    629630                switch ( decl->get_storageClass() ) {
    630                   case Declaration::NoStorageClass:
    631                         break;
    632                   case Declaration::Extern:
     631                  case DeclarationNode::Extern:
    633632                        output << "extern ";
    634633                        break;
    635                   case Declaration::Static:
     634                  case DeclarationNode::Static:
    636635                        output << "static ";
    637636                        break;
    638                   case Declaration::Auto:
     637                  case DeclarationNode::Auto:
    639638                        // silently drop storage class
    640639                        break;
    641                   case Declaration::Register:
     640                  case DeclarationNode::Register:
    642641                        output << "register ";
    643642                        break;
    644                   case Declaration::Inline:
     643                  case DeclarationNode::Inline:
    645644                        // handled as special via isInline flag (FIX)
    646645                        break;
    647                   case Declaration::Fortran:
     646                  case DeclarationNode::Fortran:
    648647                        // not handled
     648                        output << "fortran ";
     649                        break;
     650                  case DeclarationNode::Noreturn:
     651                        // not handled
     652                        output << "_Noreturn ";
     653                        break;
     654                  case DeclarationNode::Threadlocal:
     655                        // not handled
     656                        output << "_Thread_local ";
     657                        break;
     658                  case DeclarationNode::NoStorageClass:
    649659                        break;
    650660                } // switch
  • src/GenPoly/Box.cc

    rea9b9d3 rb5b0907  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 07:31:41 2015
    13 // Update Count     : 1
     12// Last Modified On : Sat Jun 13 07:13:46 2015
     13// Update Count     : 3
    1414//
    1515
     
    2626#include "ScrubTyVars.h"
    2727
    28 #include "SynTree/Declaration.h"
     28#include "Parser/ParseNode.h"
     29
    2930#include "SynTree/Type.h"
    3031#include "SynTree/Expression.h"
     
    3233#include "SynTree/Statement.h"
    3334#include "SynTree/Mutator.h"
     35
    3436#include "ResolvExpr/TypeEnvironment.h"
     37
    3538#include "SymTab/Mangler.h"
    3639
     
    282285
    283286                ObjectDecl *Pass1::makeTemporary( Type *type ) {
    284                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, type, 0 );
     287                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, 0 );
    285288                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    286289                        return newObj;
     
    362365                                        arg = new AddressExpr( arg );
    363366                                } else {
    364                                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 );
     367                                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 );
    365368                                        newObj->get_type()->get_qualifiers() = Type::Qualifiers();
    366369                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
     
    433436                                makeRetParm( adapter );
    434437                        } // if
    435                         adapter->get_parameters().push_front( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
     438                        adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
    436439                        return adapter;
    437440                }
     
    521524                        adapterBody->get_kids().push_back( bodyStmt );
    522525                        std::string adapterName = makeAdapterName( mangleName );
    523                         return new FunctionDecl( adapterName, Declaration::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false );
     526                        return new FunctionDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false );
    524527                }
    525528
     
    902905                                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
    903906                                        std::string adapterName = makeAdapterName( mangleName );
    904                                         paramList.push_front( new ObjectDecl( adapterName, Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
     907                                        paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
    905908                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
    906909                                }
     
    961964                        std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
    962965                        std::list< DeclarationWithType *> inferredParams;
    963                         ObjectDecl *newObj = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
    964 ///   ObjectDecl *newFunPtr = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
     966                        ObjectDecl *newObj = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
     967///   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
    965968                        for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
    966969                                ObjectDecl *thisParm;
  • src/GenPoly/Specialize.cc

    rea9b9d3 rb5b0907  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 19 07:55:09 2015
    13 // Update Count     : 4
     12// Last Modified On : Sat Jun 13 07:14:42 2015
     13// Update Count     : 5
    1414//
    1515
     
    1919#include "PolyMutator.h"
    2020
    21 #include "SynTree/Declaration.h"
     21#include "Parser/ParseNode.h"
     22
     23#include "SynTree/Expression.h"
    2224#include "SynTree/Statement.h"
    23 #include "SynTree/Expression.h"
    2425#include "SynTree/Type.h"
    2526#include "SynTree/TypeSubstitution.h"
     
    9697                                        newEnv.applyFree( newType );
    9798                                } // if
    98                                 FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( std::list< std::string >() ), false );
     99                                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( std::list< std::string >() ), false );
    99100                                thunkFunc->fixUniqueId();
    100101
  • src/Makefile.am

    rea9b9d3 rb5b0907  
    1111## Created On       : Sun May 31 08:51:46 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Thu Jun  4 21:01:59 2015
    14 ## Update Count     : 15
     13## Last Modified On : Sat Jun 13 08:22:14 2015
     14## Update Count     : 17
    1515###############################################################################
    1616
     
    3838cfa_cpplib_PROGRAMS = cfa-cpp
    3939cfa_cpp_SOURCES = ${SRC}
    40 # need files Common/utility.h and Parser/lex.h
    41 cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${srcdir}/Common -I${srcdir}/Parser
     40# need files Common/utility.h
     41cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${srcdir}/Common
    4242
    4343CXXFLAGS = -g   # remove default -O2 to allow better debugging
  • src/Makefile.in

    rea9b9d3 rb5b0907  
    392392cfa_cpplibdir = ${libdir}
    393393cfa_cpp_SOURCES = ${SRC}
    394 # need files Common/utility.h and Parser/lex.h
    395 cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${srcdir}/Common -I${srcdir}/Parser
     394# need files Common/utility.h
     395cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${srcdir}/Common
    396396all: $(BUILT_SOURCES)
    397397        $(MAKE) $(AM_MAKEFLAGS) all-am
  • src/Parser/DeclarationNode.cc

    rea9b9d3 rb5b0907  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  6 23:29:13 2015
    13 // Update Count     : 23
     12// Last Modified On : Sat Jun 13 08:02:03 2015
     13// Update Count     : 58
    1414//
    1515
     
    2121
    2222#include "TypeData.h"
     23
     24#include "SynTree/Declaration.h"
    2325#include "SynTree/Expression.h"
    2426
    25 
    2627using namespace std;
    2728
    2829// These must remain in the same order as the corresponding DeclarationNode enumerations.
     30const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "" };
    2931const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" };
    3032const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary" };
    31 const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" };
    32 const char *DeclarationNode::tyConName[] = { "struct", "union", "context" };
     33const char *DeclarationNode::modifierName[]  = { "signed", "unsigned", "short", "long" };
     34const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" };
    3335const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" };
    3436
     
    6365}
    6466
    65 const char *storageClassName[] = {
    66         // order must correspond with DeclarationNode::StorageClass
    67         "extern",
    68         "static",
    69         "auto",
    70         "register",
    71         "inline",
    72         "fortran",
    73 };
    74 
    7567void DeclarationNode::print( std::ostream &os, int indent ) const {
    7668        os << string( indent, ' ' );
     
    7971        } else {
    8072                os << name << ": ";
    81         }
     73        } // if
    8274
    8375        if ( linkage != LinkageSpec::Cforall ) {
    8476                os << LinkageSpec::toString( linkage ) << " ";
    85         }
    86 
    87         printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os );
     77        } // if
     78
     79        printEnums( storageClasses.begin(), storageClasses.end(), DeclarationNode::storageName, os );
    8880        if ( type ) {
    8981                type->print( os, indent );
    9082        } else {
    9183                os << "untyped entity ";
    92         }
     84        } // if
    9385
    9486        if ( bitfieldWidth ) {
    9587                os << endl << string( indent + 2, ' ' ) << "with bitfield width ";
    9688                bitfieldWidth->printOneLine( os );
    97         }
     89        } // if
    9890
    9991        if ( initializer != 0 ) {
    10092                os << endl << string( indent + 2, ' ' ) << "with initializer ";
    10193                initializer->printOneLine( os );
    102         }
     94        } // if
    10395
    10496        os << endl;
     
    109101        if ( hasEllipsis ) {
    110102                os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
    111         }
     103        } // if
    112104}
    113105
     
    123115        if ( body ) {
    124116                newnode->type->function->hasBody = true;
    125         }
     117        } // if
    126118
    127119        if ( ret ) {
     
    129121                ret->type = 0;
    130122                delete ret;
    131         }
     123        } // if
    132124
    133125        return newnode;
     
    141133}
    142134
    143 DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) {
     135DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
    144136        DeclarationNode *newnode = new DeclarationNode;
    145137        newnode->storageClasses.push_back( sc );
     
    177169}
    178170
    179 DeclarationNode *DeclarationNode::newAggregate( TyCon kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
     171DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
    180172        DeclarationNode *newnode = new DeclarationNode;
    181173        newnode->type = new TypeData( TypeData::Aggregate );
     
    184176        if ( newnode->type->aggregate->name == "" ) {
    185177                newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
    186         }
     178        } // if
    187179        newnode->type->aggregate->params = formals;
    188180        newnode->type->aggregate->actuals = actuals;
     
    198190        if ( newnode->type->enumeration->name == "" ) {
    199191                newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
    200         }
     192        } // if
    201193        newnode->type->enumeration->constants = constants;
    202194        return newnode;
     
    331323                        } else {
    332324                                dst->forall = src->forall;
    333                         }
     325                        } // if
    334326                        src->forall = 0;
    335                 }
     327                } // if
    336328                if ( dst->base ) {
    337329                        addQualifiersToType( src, dst->base );
     
    341333                } else {
    342334                        dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
    343                 }
    344         }
     335                } // if
     336        } // if
    345337}
    346338         
     
    351343                        if ( ! type ) {
    352344                                type = new TypeData;
    353                         }
     345                        } // if
    354346                        addQualifiersToType( q->type, type );
    355347                        if ( q->type && q->type->forall ) {
     
    357349                                        type->forall->appendList( q->type->forall );
    358350                                } else {
    359                                         type->forall = q->type->forall;
    360                                 }
     351                                        if ( type->kind == TypeData::Aggregate ) {
     352                                                type->aggregate->params = q->type->forall;
     353                                        } else {
     354                                                type->forall = q->type->forall;
     355                                        } // if
     356                                } // if
    361357                                q->type->forall = 0;
    362                         }
    363                 }
    364         }
     358                        } // if
     359                } // if
     360        } // if
    365361        delete q;
    366362        return this;
     
    379375                        } else {
    380376                                dst->forall = src->forall;
    381                         }
     377                        } // if
    382378                        src->forall = 0;
    383                 }
     379                } // if
    384380                if ( dst->base ) {
    385381                        addTypeToType( src, dst->base );
     
    398394                                        dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
    399395                                        dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
    400                                 }
     396                                } // if
    401397                                break;
    402398
     
    409405                                        if ( src->kind == TypeData::Aggregate ) {
    410406                                                dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
    411                                         }
     407                                        } // if
    412408                                        dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers );
    413409                                        src = 0;
     
    419415                                        } else {
    420416                                                dst->forall = src->forall;
    421                                         }
     417                                        } // if
    422418                                        src->forall = 0;
    423419                                        dst->base = src;
    424420                                        src = 0;
    425                                 }
    426                         }
    427                 }
    428         }
     421                                } // switch
     422                        } // switch
     423                } // if
     424        } // if
    429425}
    430426
     
    439435                                        if ( o->type->kind == TypeData::Aggregate ) {
    440436                                                type->aggInst->params = maybeClone( o->type->aggregate->actuals );
    441                                         }
     437                                        } // if
    442438                                        type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers );
    443439                                } else {
    444440                                        type = o->type;
    445                                 }
     441                                } // if
    446442                                o->type = 0;
    447443                        } else {
    448444                                addTypeToType( o->type, type );
    449                         }
    450                 }
     445                        } // if
     446                } // if
    451447                if ( o->bitfieldWidth ) {
    452448                        bitfieldWidth = o->bitfieldWidth;
    453                 }
    454         }
     449                } // if
     450        } // if
    455451        delete o;
    456452        return this;
     
    475471                } else {
    476472                        type->symbolic->assertions = assertions;
    477                 }
     473                } // if
    478474                break;
    479        
    480475          case TypeData::Variable:
    481476                if ( type->variable->assertions ) {
     
    483478                } else {
    484479                        type->variable->assertions = assertions;
    485                 }
     480                } // if
    486481                break;
    487        
    488482          default:
    489483                assert( false );
    490         }
     484        } // switch
    491485       
    492486        return this;
     
    526520}
    527521
    528 static void
    529 setBase( TypeData *&type, TypeData *newType ) {
     522static void setBase( TypeData *&type, TypeData *newType ) {
    530523        if ( type ) {
    531524                TypeData *prevBase = type;
     
    534527                        prevBase = curBase;
    535528                        curBase = curBase->base;
    536                 }
     529                } // while
    537530                prevBase->base = newType;
    538531        } else {
    539532                type = newType;
    540         }
     533        } // if
    541534}
    542535
     
    547540                p->type = 0;
    548541                delete p;
    549         }
     542        } // if
    550543        return this;
    551544}
     
    557550                a->type = 0;
    558551                delete a;
    559         }
     552        } // if
    560553        return this;
    561554}
     
    572565                                if ( type->kind == TypeData::Aggregate ) {
    573566                                        p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
    574                                 }
     567                                } // if
    575568                                p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers );
    576569                                break;
     
    578571                          default:
    579572                                p->type->base = type;
    580                         }
     573                        } // switch
    581574                        type = 0;
    582                 }
     575                } // if
    583576                delete this;
    584577                return p;
    585578        } else {
    586579                return this;
    587         }
     580        } // if
    588581}
    589582
     
    593586        while ( cur->base ) {
    594587                cur = cur->base;
    595         }
     588        } // while
    596589        return cur;
    597590}
     
    609602                                if ( type->kind == TypeData::Aggregate ) {
    610603                                        lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
    611                                 }
     604                                } // if
    612605                                lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers );
    613606                                break;
    614607                          default:
    615608                                lastArray->base = type;
    616                         }
     609                        } // switch
    617610                        type = 0;
    618                 }
     611                } // if
    619612                delete this;
    620613                return a;
    621614        } else {
    622615                return this;
    623         }
     616        } // if
    624617}
    625618
     
    637630                } else {
    638631                        type->function->idList = ids;
    639                 }
     632                } // if
    640633                return type;
    641634        } else {
     
    643636                newtype->function->idList = ids;
    644637                return newtype;
    645         }
     638        } // if
    646639}
    647640       
     
    662655        while ( srcType->base ) {
    663656                srcType = srcType->base;
    664         }
     657        } // while
    665658        newnode->type = maybeClone( srcType );
    666659        if ( newnode->type->kind == TypeData::AggregateInst ) {
     
    673666                        delete newnode->type->aggInst->aggregate->aggregate->members;
    674667                        newnode->type->aggInst->aggregate->aggregate->members = 0;
    675                 }
    676         }
     668                } // if
     669        } // if
    677670        newnode->type->forall = maybeClone( type->forall );
    678671        newnode->storageClasses = storageClasses;
     
    688681                        while ( srcType->base ) {
    689682                                srcType = srcType->base;
    690                         }
     683                        } // while
    691684                        TypeData *newType = srcType->clone();
    692685                        if ( newType->kind == TypeData::AggregateInst ) {
     
    699692                                        delete newType->aggInst->aggregate->aggregate->members;
    700693                                        newType->aggInst->aggregate->aggregate->members = 0;
    701                                 }
    702                         }
     694                                } // if
     695                        } // if
    703696                        newType->forall = maybeClone( type->forall );
    704697                        if ( ! o->type ) {
     
    707700                                addTypeToType( newType, o->type );
    708701                                delete newType;
    709                         }
    710                 }
    711         }
     702                        } // if
     703                } // if
     704        } // if
    712705        return o;
    713706}
     
    731724                                addTypeToType( newType, o->type );
    732725                                delete newType;
    733                         }
    734                 }
    735         }
     726                        } // if
     727                } // if
     728        } // if
    736729        return o;
    737730}
     
    740733        if ( node != 0 ) {
    741734                set_link( node );
    742         }
     735        } // if
    743736        return this;
    744737}
     
    803796                                } else if ( StructDecl *agg = dynamic_cast< StructDecl *>( decl ) ) {
    804797                                        StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
    805                                         *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
     798                                        *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
    806799                                        delete agg;
    807800                                } else if ( UnionDecl *agg = dynamic_cast< UnionDecl *>( decl ) ) {
    808801                                        UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
    809                                         *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
     802                                        *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
    810803                                } // if
    811804                        } // if
     
    882875}
    883876
    884 Declaration::StorageClass DeclarationNode::buildStorageClass() const {
    885         static const Declaration::StorageClass scMap[] = { 
    886                 Declaration::Extern,
    887                 Declaration::Static,
    888                 Declaration::Auto,
    889                 Declaration::Register,
    890                 Declaration::Inline,
    891                 Declaration::Fortran
    892         }; 
    893  
    894         Declaration::StorageClass ret = Declaration::NoStorageClass;
    895         for ( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
    896                 assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) );
    897           if ( *i == Inline ) continue;
    898           if ( ret != Declaration::NoStorageClass ) {
     877DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const {
     878        DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass;
     879        for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
     880          if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers
     881
     882          if ( ret != DeclarationNode::NoStorageClass ) {       // already have a valid storage class ?
    899883                        throw SemanticError( "invalid combination of storage classes in declaration of ", this );
    900                 }
    901                 ret = scMap[ *i ];
    902         }
     884                } // if
     885                ret = *i;
     886        } // for
    903887        return ret;
    904888}
    905889
    906890bool DeclarationNode::buildInline() const {
    907         std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
     891        std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), DeclarationNode::Inline );
    908892  if ( first == storageClasses.end() ) return false;
    909         std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
     893        std::list< DeclarationNode::StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), DeclarationNode::Inline );
    910894  if ( next == storageClasses.end() ) return true;
    911895        throw SemanticError( "duplicate inline specification in declaration of ", this );
  • src/Parser/ParseNode.h

    rea9b9d3 rb5b0907  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jun  7 22:02:00 2015
    13 // Update Count     : 65
     12// Last Modified On : Sat Jun 13 07:24:22 2015
     13// Update Count     : 79
    1414//
    1515
     
    2222
    2323#include "utility.h"
     24#include "Parser/LinkageSpec.h"
    2425#include "SynTree/Type.h"
    25 #include "SynTree/Declaration.h"
     26//#include "SynTree/Declaration.h"
    2627#include "UniqueName.h"
    2728
     
    265266  public:
    266267        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Attribute };
    267         enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran };
     268        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
    268269        enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
    269         enum Modifier { Signed, Unsigned, Short, Long };
    270         enum TyCon { Struct, Union, Context };
     270        enum Modifier  { Signed, Unsigned, Short, Long };
     271        enum Aggregate { Struct, Union, Context };
    271272        enum TypeClass { Type, Dtype, Ftype };
    272273
     274        static const char *storageName[]; 
    273275        static const char *qualifierName[];
    274276        static const char *basicTypeName[];
    275277        static const char *modifierName[];
    276         static const char *tyConName[];
     278        static const char *aggregateName[];
    277279        static const char *typeClassName[];
    278280
     
    285287        static DeclarationNode *newForall( DeclarationNode *);
    286288        static DeclarationNode *newFromTypedef( std::string *);
    287         static DeclarationNode *newAggregate( TyCon kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields );
     289        static DeclarationNode *newAggregate( Aggregate kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields );
    288290        static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
    289291        static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
     
    344346        ~DeclarationNode();
    345347  private:
    346         Declaration::StorageClass buildStorageClass() const;
     348        StorageClass buildStorageClass() const;
    347349        bool buildInline() const;
    348350
  • src/Parser/TypeData.cc

    rea9b9d3 rb5b0907  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  6 12:26:02 2015
    13 // Update Count     : 8
     12// Last Modified On : Sat Jun 13 08:03:20 2015
     13// Update Count     : 15
    1414//
    1515
     
    8989                attr->type = 0;
    9090                break;
    91         }
     91        } // switch
    9292}
    9393
     
    155155                delete attr;
    156156                break;
    157         }
     157        } // switch
    158158}
    159159
     
    225225                newtype->attr->type = maybeClone( attr->type );
    226226                break;
    227         }
     227        } // switch
    228228        return newtype;
    229229}
     
    238238                os << "forall " << endl;
    239239                forall->printList( os, indent+4 );
    240         }
     240        } // if
    241241
    242242        switch ( kind ) {
     
    249249                        os << "to ";
    250250                        base->print( os, indent );
    251                 }
     251                } // if
    252252                break;
    253253          case EnumConstant:
     
    261261                if ( array->isStatic ) {
    262262                        os << "static ";
    263                 }
     263                } // if
    264264                if ( array->dimension ) {
    265265                        os << "array of ";
     
    269269                } else {
    270270                        os << "open array of ";
    271                 }
     271                } // if
    272272                if ( base ) {
    273273                        base->print( os, indent );
    274                 }
     274                } // if
    275275                break;
    276276          case Function:
     
    281281                } else {
    282282                        os << string( indent+2, ' ' ) << "with no parameters " << endl;
    283                 }
     283                } // if
    284284                if ( function->idList ) {
    285285                        os << string( indent+2, ' ' ) << "with old-style identifier list " << endl;
    286286                        function->idList->printList( os, indent+4 );
    287                 }
     287                } // if
    288288                if ( function->oldDeclList ) {
    289289                        os << string( indent+2, ' ' ) << "with old-style declaration list " << endl;
    290290                        function->oldDeclList->printList( os, indent+4 );
    291                 }
     291                } // if
    292292                os << string( indent+2, ' ' ) << "returning ";
    293293                if ( base ) {
     
    295295                } else {
    296296                        os << "nothing ";
    297                 }
     297                } // if
    298298                os << endl;
    299299                if ( function->hasBody ) {
    300300                        os << string( indent+2, ' ' ) << "with body " << endl;
    301                 }
     301                } // if
    302302                if ( function->body ) {
    303303                        function->body->printList( os, indent+2 );
    304                 }
     304                } // if
    305305                break;
    306306          case Aggregate:
    307                 os << DeclarationNode::tyConName[ aggregate->kind ] << ' ' << aggregate->name << endl;
     307                os << DeclarationNode::aggregateName[ aggregate->kind ] << ' ' << aggregate->name << endl;
    308308                if ( aggregate->params ) {
    309309                        os << string( indent+2, ' ' ) << "with type parameters " << endl;
    310310                        aggregate->params->printList( os, indent+4 );
    311                 }
     311                } // if
    312312                if ( aggregate->actuals ) {
    313313                        os << string( indent+2, ' ' ) << "instantiated with actual parameters " << endl;
    314314                        aggregate->actuals->printList( os, indent+4 );
    315                 }
     315                } // if
    316316                if ( aggregate->members ) {
    317317                        os << string( indent+2, ' ' ) << "with members " << endl;
     
    319319///     } else {
    320320///       os << string( indent+2, ' ' ) << "with no members " << endl;
    321                 }
     321                } // if
    322322                break;
    323323          case AggregateInst:
     
    327327                } else {
    328328                        os << "instance of an unspecified aggregate ";
    329                 }
     329                } // if
    330330                if ( aggInst->params ) {
    331331                        os << string( indent+2, ' ' ) << "with parameters " << endl;
    332332                        aggInst->params->printList( os, indent+2 );
    333                 }
     333                } // if
    334334                break;
    335335          case Enum:
     
    338338                        os << "with constants" << endl;
    339339                        enumeration->constants->printList( os, indent+2 );
    340                 }
     340                } // if
    341341                break;
    342342          case SymbolicInst:
     
    345345                        os << " with parameters" << endl;
    346346                        symbolic->actuals->printList( os, indent + 2 );
    347                 }
     347                } // if
    348348                break;
    349349          case Symbolic:
     
    352352                } else {
    353353                        os << "type definition ";
    354                 }
     354                } // if
    355355                if ( symbolic->params ) {
    356356                        os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
    357357                        symbolic->params->printList( os, indent + 2 );
    358                 }
     358                } // if
    359359                if ( symbolic->assertions ) {
    360360                        os << endl << string( indent+2, ' ' ) << "with assertions" << endl;
    361361                        symbolic->assertions->printList( os, indent + 4 );
    362362                        os << string( indent+2, ' ' );
    363                 }
     363                } // if
    364364                if ( base ) {
    365365                        os << "for ";
    366366                        base->print( os, indent + 2 );
    367                 }
     367                } // if
    368368                break;
    369369          case Variable:
     
    373373                        variable->assertions->printList( os, indent + 4 );
    374374                        os << string( indent+2, ' ' );
    375                 }
     375                } // if
    376376                break;
    377377          case Tuple:
     
    380380                        os << "with members " << endl;
    381381                        tuple->members->printList( os, indent + 2 );
    382                 }
     382                } // if
    383383                break;
    384384          case Typeof:
     
    386386                if ( typeexpr->expr ) {
    387387                        typeexpr->expr->print( os, indent + 2 );
    388                 }
     388                } // if
    389389                break;
    390390          case Attr:
     
    392392                if ( attr->expr ) {
    393393                        attr->expr->print( os, indent + 2 );
    394                 }
     394                } // if
    395395                if ( attr->type ) {
    396396                        attr->type->print( os, indent + 2 );
    397                 }
    398                 break;
    399         }
     397                } // if
     398                break;
     399        } // switch
    400400}
    401401
     
    408408                        ret = clone();
    409409                        ret->qualifiers.clear();
    410                 }
     410                } // if
    411411                break;
    412412          case Enum:
     
    414414                        ret = clone();
    415415                        ret->qualifiers.clear();
    416                 }
     416                } // if
    417417                break;
    418418          case AggregateInst:
    419419                if ( aggInst->aggregate ) {
    420420                        ret = aggInst->aggregate->extractAggregate( false );
    421                 }
     421                } // if
    422422                break;
    423423          default:
    424424                if ( base ) {
    425425                        ret = base->extractAggregate( false );
    426                 }
    427         }
     426                } // if
     427        } // switch
    428428        return ret;
    429429}
     
    434434                if ( (*i)->get_kind() == TypeDecl::Any ) {
    435435                        FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
    436                         assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
    437                         assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
    438                         assignType->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
    439                         (*i)->get_assertions().push_front( new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false ) );
    440                 }
    441         }
    442 }
    443 
    444 Declaration *TypeData::buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init ) const {
     436                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
     437                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
     438                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
     439                        (*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false ) );
     440                } // if
     441        } // for
     442}
     443
     444Declaration *TypeData::buildDecl( std::string name, DeclarationNode::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init ) const {
    445445        if ( kind == TypeData::Function ) {
    446446                FunctionDecl *decl;
     
    454454                                // std::list<Label> ls;
    455455                                decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline );
    456                         }
     456                        } // if
    457457                } else {
    458458                        decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline );
    459                 }
     459                } // if
    460460                for ( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_link() ) ) {
    461461                        if ( cur->get_name() != "" ) {
    462462                                decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
    463                         }
    464                 }
     463                        } // if
     464                } // for
    465465                buildList( function->oldDeclList, decl->get_oldDecls() );
    466466                return decl;
     
    478478                } else {
    479479                        return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init );
    480                 }
    481         }
     480                } // if
     481        } // if
    482482        return 0;
    483483}
     
    514514          case Variable:
    515515                assert( false );
    516         }
     516        } // switch
    517517
    518518        return 0;
     
    541541                        q.isAttribute = true;
    542542                        break;
    543                 }
    544         }
     543                } // switch
     544        } // for
    545545        return q;
    546546}
     
    563563                                } else {
    564564                                        return new VoidType( buildQualifiers() );
    565                                 }
     565                                } // if
    566566                        } else {
    567567                                ret = kindMap[ *i ];
    568                         }
     568                        } // if
    569569                } else {
    570570                        switch ( *i ) {
     
    582582                                          default:
    583583                                                throw SemanticError( "invalid type specifier \"float\" in type: ", this );
    584                                         }
    585                                 }
     584                                        } // switch
     585                                } // if
    586586                                break;
    587587                          case DeclarationNode::Double:
     
    595595                                          default:
    596596                                                throw SemanticError( "invalid type specifier \"double\" in type: ", this );
    597                                         }
    598                                 }
     597                                        } // switch
     598                                } // if
    599599                                break;
    600600       
     
    609609                                  default:
    610610                                        throw SemanticError( "invalid type specifier \"_Complex\" in type: ", this );
    611                                 }
     611                                } // switch
    612612                                break;
    613613                          case DeclarationNode::Imaginary:
     
    621621                                  default:
    622622                                        throw SemanticError( "invalid type specifier \"_Imaginary\" in type: ", this );
    623                                 }
     623                                } // switch
    624624                                break;
    625625                          default:
    626626                                throw SemanticError( std::string( "invalid type specifier \"" ) + DeclarationNode::basicTypeName[ *i ] + "\" in type: ", this );
    627                         }
    628                 }
     627                        } // switch
     628                } // if
    629629                if ( *i == DeclarationNode::Double ) {
    630630                        sawDouble = true;
    631                 }
    632         }
     631                } // if
     632        } // for
    633633
    634634        for ( std::list< DeclarationNode::Modifier >::const_iterator i = basic->modifiers.begin(); i != basic->modifiers.end(); ++i ) {
     
    663663                                  default:
    664664                                        throw SemanticError( "invalid type modifier \"long\" in type: ", this );
    665                                 }
    666                         }
     665                                } // switch
     666                        } // if
    667667                        break;
    668668                  case DeclarationNode::Short:
     
    680680                                  default:
    681681                                        throw SemanticError( "invalid type modifier \"short\" in type: ", this );
    682                                 }
    683                         }
     682                                } // switch
     683                        } // if
    684684                        break;
    685685                  case DeclarationNode::Signed:
     
    705705                                  default:
    706706                                        throw SemanticError( "invalid type modifer \"signed\" in type: ", this );
    707                                 }
    708                         }
     707                                } // switch
     708                        } // if
    709709                        break;
    710710                  case DeclarationNode::Unsigned:
     
    733733                                  default:
    734734                                        throw SemanticError( "invalid type modifer \"unsigned\" in type: ", this );
    735                                 }
    736                         }
    737                         break;
    738                 }
     735                                } // switch
     736                        } // if
     737                        break;
     738                } // switch
    739739
    740740                if ( *i == DeclarationNode::Signed ) {
    741741                        sawSigned = true;
    742                 }
    743         }
     742                } // if
     743        } // for
    744744
    745745        BasicType *bt;
     
    748748        } else {
    749749                bt = new BasicType( buildQualifiers(), ret );
    750         }
     750        } // if
    751751        buildForall( forall, bt->get_forall() );
    752752        return bt;
     
    760760        } else {
    761761                pt = new PointerType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
    762         }
     762        } // if
    763763        buildForall( forall, pt->get_forall() );
    764764        return pt;
     
    773773                at = new ArrayType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
    774774                                                        maybeBuild< Expression >( array->dimension ), array->isVarLen, array->isStatic );
    775         }
     775        } // if
    776776        buildForall( forall, at->get_forall() );
    777777        return at;
     
    791791                        break;
    792792                  default:
    793                         ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", Declaration::NoStorageClass, 0, false, LinkageSpec::Cforall ) ) );
    794                 }
     793                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", DeclarationNode::NoStorageClass, 0, false, LinkageSpec::Cforall ) ) );
     794                } // switch
    795795        } else {
    796                 ft->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
    797         }
     796                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
     797        } // if
    798798        return ft;
    799799}
     
    817817          default:
    818818                assert( false );
    819         }
     819        } // switch
    820820        buildList( aggregate->params, at->get_parameters() );
    821821        buildList( aggregate->members, at->get_members() );
     
    857857                  default:
    858858                        assert( false );
    859                 }
    860         }
     859                } // switch
     860        } // if
    861861        buildList( aggInst->params, ret->get_parameters() );
    862862        buildForall( forall, ret->get_forall() );
     
    864864}
    865865
    866 NamedTypeDecl *TypeData::buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const {
     866NamedTypeDecl *TypeData::buildSymbolic( const std::string &name, DeclarationNode::StorageClass sc ) const {
    867867        assert( kind == Symbolic );
    868868        NamedTypeDecl *ret;
     
    871871        } else {
    872872                ret = new TypeDecl( name, sc, maybeBuild< Type >( base ), TypeDecl::Any );
    873         }
     873        } // if
    874874        buildList( symbolic->params, ret->get_parameters() );
    875875        buildList( symbolic->assertions, ret->get_assertions() );
     
    881881        static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
    882882
    883         TypeDecl *ret = new TypeDecl( variable->name, Declaration::NoStorageClass, 0, kindMap[ variable->tyClass ] );
     883        TypeDecl *ret = new TypeDecl( variable->name, DeclarationNode::NoStorageClass, 0, kindMap[ variable->tyClass ] );
    884884        buildList( variable->assertions, ret->get_assertions() );
    885885       
     
    931931                assert( attr->type );
    932932                ret = new AttrType( buildQualifiers(), attr->name, attr->type->buildType() );
    933         }
     933        } // if
    934934
    935935        return ret;
  • src/Parser/TypeData.h

    rea9b9d3 rb5b0907  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat May 16 15:20:00 2015
    13 // Update Count     : 2
     12// Last Modified On : Sat Jun 13 07:26:16 2015
     13// Update Count     : 5
    1414//
    1515
     
    4444
    4545        struct Aggregate_t {
    46                 DeclarationNode::TyCon kind;
     46                DeclarationNode::Aggregate kind;
    4747                std::string name;
    4848                DeclarationNode *params;
     
    120120        TypeData *extractAggregate( bool toplevel = true ) const;
    121121        // helper function for DeclNodeImpl::build
    122         Declaration * buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init = 0 ) const;
     122        Declaration * buildDecl( std::string name, DeclarationNode::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init = 0 ) const;
    123123        // helper functions for build()
    124124        Type::Qualifiers buildQualifiers() const;
     
    128128        AggregateDecl * buildAggregate() const;
    129129        ReferenceToType * buildAggInst() const;
    130         NamedTypeDecl * buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const;
     130        NamedTypeDecl * buildSymbolic( const std::string &name, DeclarationNode::StorageClass sc ) const;
    131131        TypeDecl* buildVariable() const;
    132132        EnumDecl* buildEnum() const;
  • src/Parser/lex.cc

    rea9b9d3 rb5b0907  
    13901390 * Created On       : Sat Sep 22 08:58:10 2001
    13911391 * Last Modified By : Peter A. Buhr
    1392  * Last Modified On : Mon Jun  8 20:24:15 2015
    1393  * Update Count     : 381
     1392 * Last Modified On : Thu Jun 11 21:52:35 2015
     1393 * Update Count     : 382
    13941394 */
    13951395#line 20 "lex.ll"
  • src/Parser/lex.ll

    rea9b9d3 rb5b0907  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Mon Jun  8 20:24:15 2015
    13  * Update Count     : 381
     12 * Last Modified On : Thu Jun 11 21:52:35 2015
     13 * Update Count     : 382
    1414 */
    1515
  • src/Parser/parser.cc

    rea9b9d3 rb5b0907  
    330330        ExpressionNode *en;
    331331        DeclarationNode *decl;
    332         DeclarationNode::TyCon aggKey;
     332        DeclarationNode::Aggregate aggKey;
    333333        DeclarationNode::TypeClass tclass;
    334334        StatementNode *sn;
     
    568568
    569569/* YYFINAL -- State number of the termination state.  */
    570 #define YYFINAL  238
     570#define YYFINAL  240
    571571/* YYLAST -- Last index in YYTABLE.  */
    572 #define YYLAST   12086
     572#define YYLAST   12141
    573573
    574574/* YYNTOKENS -- Number of terminals.  */
     
    577577#define YYNNTS  235
    578578/* YYNRULES -- Number of rules.  */
    579 #define YYNRULES  733
     579#define YYNRULES  735
    580580/* YYNRULES -- Number of states.  */
    581 #define YYNSTATES  1550
     581#define YYNSTATES  1552
    582582
    583583/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
     
    665665    1060,  1061,  1067,  1069,  1072,  1076,  1078,  1081,  1083,  1085,
    666666    1087,  1089,  1091,  1093,  1095,  1097,  1099,  1101,  1103,  1105,
    667     1107,  1109,  1111,  1113,  1115,  1117,  1119,  1121,  1124,  1127,
    668     1131,  1135,  1137,  1141,  1143,  1146,  1149,  1152,  1157,  1162,
    669     1167,  1172,  1174,  1177,  1180,  1184,  1186,  1189,  1192,  1194,
    670     1197,  1200,  1204,  1206,  1209,  1212,  1214,  1216,  1221,  1224,
    671     1230,  1240,  1248,  1259,  1272,  1280,  1294,  1297,  1300,  1302,
    672     1305,  1308,  1312,  1315,  1319,  1321,  1324,  1328,  1331,  1334,
    673     1339,  1340,  1342,  1345,  1348,  1350,  1351,  1353,  1356,  1359,
    674     1365,  1372,  1375,  1378,  1383,  1384,  1387,  1388,  1390,  1392,
    675     1394,  1400,  1406,  1412,  1414,  1420,  1426,  1436,  1438,  1444,
    676     1445,  1447,  1449,  1455,  1457,  1459,  1465,  1471,  1473,  1477,
    677     1481,  1486,  1488,  1490,  1492,  1494,  1497,  1499,  1503,  1507,
    678     1509,  1512,  1514,  1518,  1520,  1522,  1524,  1526,  1528,  1530,
    679     1532,  1534,  1536,  1538,  1540,  1543,  1545,  1547,  1549,  1552,
    680     1553,  1556,  1558,  1563,  1565,  1568,  1572,  1577,  1580,  1583,
    681     1585,  1588,  1591,  1597,  1603,  1611,  1618,  1620,  1623,  1626,
    682     1630,  1635,  1641,  1644,  1647,  1652,  1653,  1658,  1661,  1663,
    683     1665,  1667,  1668,  1671,  1677,  1683,  1697,  1699,  1701,  1705,
    684     1709,  1712,  1716,  1720,  1723,  1728,  1730,  1737,  1747,  1748,
    685     1760,  1762,  1766,  1770,  1774,  1776,  1778,  1784,  1787,  1793,
    686     1794,  1796,  1798,  1802,  1803,  1805,  1807,  1809,  1811,  1812,
    687     1819,  1822,  1824,  1827,  1832,  1835,  1839,  1843,  1847,  1852,
    688     1858,  1864,  1870,  1877,  1879,  1881,  1883,  1887,  1888,  1894,
    689     1895,  1897,  1899,  1902,  1909,  1911,  1915,  1916,  1918,  1923,
    690     1925,  1927,  1929,  1931,  1934,  1936,  1939,  1942,  1944,  1948,
    691     1951,  1955,  1959,  1962,  1967,  1972,  1976,  1985,  1989,  1992,
    692     1994,  1997,  2004,  2013,  2017,  2020,  2024,  2028,  2033,  2038,
    693     2042,  2044,  2046,  2048,  2053,  2060,  2064,  2067,  2071,  2075,
    694     2080,  2085,  2089,  2092,  2094,  2097,  2100,  2102,  2106,  2109,
    695     2113,  2117,  2120,  2125,  2130,  2134,  2141,  2150,  2154,  2157,
    696     2159,  2162,  2165,  2168,  2172,  2176,  2179,  2184,  2189,  2193,
    697     2200,  2209,  2213,  2216,  2218,  2221,  2224,  2226,  2229,  2233,
    698     2237,  2240,  2245,  2252,  2261,  2263,  2266,  2269,  2271,  2274,
    699     2277,  2281,  2285,  2287,  2292,  2297,  2301,  2307,  2316,  2320,
    700     2325,  2331,  2333,  2339,  2345,  2352,  2359,  2361,  2364,  2367,
    701     2369,  2372,  2375,  2379,  2383,  2385,  2390,  2395,  2399,  2405,
    702     2414,  2418,  2420,  2423,  2425,  2430,  2437,  2443,  2450,  2458,
    703     2466,  2468,  2471,  2474,  2476,  2479,  2482,  2486,  2490,  2492,
    704     2497,  2502,  2506,  2515,  2519,  2521,  2523,  2526,  2528,  2530,
    705     2533,  2537,  2540,  2544,  2547,  2551,  2557,  2560,  2567,  2571,
    706     2574,  2580,  2583,  2590,  2594,  2597,  2604,  2611,  2618,  2626,
    707     2628,  2631,  2633,  2635,  2637,  2640,  2644,  2647,  2651,  2654,
    708     2658,  2664,  2671,  2674,  2680,  2687,  2690,  2696,  2704,  2711,
    709     2718,  2719,  2721,  2722
     667    1107,  1109,  1111,  1113,  1115,  1117,  1119,  1121,  1123,  1125,
     668    1128,  1131,  1135,  1139,  1141,  1145,  1147,  1150,  1153,  1156,
     669    1161,  1166,  1171,  1176,  1178,  1181,  1184,  1188,  1190,  1193,
     670    1196,  1198,  1201,  1204,  1208,  1210,  1213,  1216,  1218,  1220,
     671    1225,  1228,  1234,  1244,  1252,  1263,  1276,  1284,  1298,  1301,
     672    1304,  1306,  1309,  1312,  1316,  1319,  1323,  1325,  1328,  1332,
     673    1335,  1338,  1343,  1344,  1346,  1349,  1352,  1354,  1355,  1357,
     674    1360,  1363,  1369,  1376,  1379,  1382,  1387,  1388,  1391,  1392,
     675    1394,  1396,  1398,  1404,  1410,  1416,  1418,  1424,  1430,  1440,
     676    1442,  1448,  1449,  1451,  1453,  1459,  1461,  1463,  1469,  1475,
     677    1477,  1481,  1485,  1490,  1492,  1494,  1496,  1498,  1501,  1503,
     678    1507,  1511,  1513,  1516,  1518,  1522,  1524,  1526,  1528,  1530,
     679    1532,  1534,  1536,  1538,  1540,  1542,  1544,  1547,  1549,  1551,
     680    1553,  1556,  1557,  1560,  1562,  1567,  1569,  1572,  1576,  1581,
     681    1584,  1587,  1589,  1592,  1595,  1601,  1607,  1615,  1622,  1624,
     682    1627,  1630,  1634,  1639,  1645,  1648,  1651,  1656,  1657,  1662,
     683    1665,  1667,  1669,  1671,  1672,  1675,  1681,  1687,  1701,  1703,
     684    1705,  1709,  1713,  1716,  1720,  1724,  1727,  1732,  1734,  1741,
     685    1751,  1752,  1764,  1766,  1770,  1774,  1778,  1780,  1782,  1788,
     686    1791,  1797,  1798,  1800,  1802,  1806,  1807,  1809,  1811,  1813,
     687    1815,  1816,  1823,  1826,  1828,  1831,  1836,  1839,  1843,  1847,
     688    1851,  1856,  1862,  1868,  1874,  1881,  1883,  1885,  1887,  1891,
     689    1892,  1898,  1899,  1901,  1903,  1906,  1913,  1915,  1919,  1920,
     690    1922,  1927,  1929,  1931,  1933,  1935,  1938,  1940,  1943,  1946,
     691    1948,  1952,  1955,  1959,  1963,  1966,  1971,  1976,  1980,  1989,
     692    1993,  1996,  1998,  2001,  2008,  2017,  2021,  2024,  2028,  2032,
     693    2037,  2042,  2046,  2048,  2050,  2052,  2057,  2064,  2068,  2071,
     694    2075,  2079,  2084,  2089,  2093,  2096,  2098,  2101,  2104,  2106,
     695    2110,  2113,  2117,  2121,  2124,  2129,  2134,  2138,  2145,  2154,
     696    2158,  2161,  2163,  2166,  2169,  2172,  2176,  2180,  2183,  2188,
     697    2193,  2197,  2204,  2213,  2217,  2220,  2222,  2225,  2228,  2230,
     698    2233,  2237,  2241,  2244,  2249,  2256,  2265,  2267,  2270,  2273,
     699    2275,  2278,  2281,  2285,  2289,  2291,  2296,  2301,  2305,  2311,
     700    2320,  2324,  2329,  2335,  2337,  2343,  2349,  2356,  2363,  2365,
     701    2368,  2371,  2373,  2376,  2379,  2383,  2387,  2389,  2394,  2399,
     702    2403,  2409,  2418,  2422,  2424,  2427,  2429,  2434,  2441,  2447,
     703    2454,  2462,  2470,  2472,  2475,  2478,  2480,  2483,  2486,  2490,
     704    2494,  2496,  2501,  2506,  2510,  2519,  2523,  2525,  2527,  2530,
     705    2532,  2534,  2537,  2541,  2544,  2548,  2551,  2555,  2561,  2564,
     706    2571,  2575,  2578,  2584,  2587,  2594,  2598,  2601,  2608,  2615,
     707    2622,  2630,  2632,  2635,  2637,  2639,  2641,  2644,  2648,  2651,
     708    2655,  2658,  2662,  2668,  2675,  2678,  2684,  2691,  2694,  2700,
     709    2708,  2715,  2722,  2723,  2725,  2726
    710710};
    711711
     
    822822     221,    -1,   220,   216,   221,    -1,   222,    -1,   221,   222,
    823823      -1,   223,    -1,     5,    -1,     7,    -1,     4,    -1,     6,
    824       -1,     8,    -1,     9,    -1,    16,    -1,    21,    -1,    20,
    825       -1,    18,    -1,    19,    -1,    17,    -1,    22,    -1,    23,
    826       -1,    15,    -1,    24,    -1,    25,    -1,    26,    -1,   226,
    827       -1,   220,   226,    -1,   225,   222,    -1,   225,   222,   216,
    828       -1,   225,   222,   226,    -1,   227,    -1,   215,   228,   215,
    829       -1,   224,    -1,   216,   224,    -1,   227,   217,    -1,   227,
    830      224,    -1,    27,   101,   263,   102,    -1,    27,   101,   160,
    831      102,    -1,    71,   101,   263,   102,    -1,    71,   101,   160,
    832      102,    -1,   230,    -1,   220,   230,    -1,   229,   222,    -1,
    833      229,   222,   216,    -1,   233,    -1,   216,   233,    -1,   230,
    834      217,    -1,   232,    -1,   220,   232,    -1,   231,   222,    -1,
    835      231,   222,   216,    -1,    67,    -1,   216,    67,    -1,   232,
    836      217,    -1,   234,    -1,   244,    -1,   235,   106,   236,   107,
    837       -1,   235,   261,    -1,   235,   261,   106,   236,   107,    -1,
    838      235,   101,   126,   272,   127,   102,   106,   236,   107,    -1,
    839      235,   101,   126,   272,   127,   102,   261,    -1,   235,   101,
    840      126,   272,   127,   102,   261,   106,   236,   107,    -1,   235,
    841      101,   126,   272,   127,   102,   101,   278,   102,   106,   236,
    842      107,    -1,   235,   101,   126,   278,   127,   102,   261,    -1,
    843      235,   101,   126,   272,   127,   102,   101,   278,   102,   261,
    844      106,   236,   107,    -1,    30,   298,    -1,    31,   298,    -1,
    845      237,    -1,   236,   237,    -1,   238,   124,    -1,    38,   238,
    846      124,    -1,   239,   124,    -1,    38,   239,   124,    -1,   352,
    847       -1,   352,   261,    -1,   238,   108,   261,    -1,   238,   108,
    848       -1,   214,   240,    -1,   239,   108,   298,   240,    -1,    -1,
    849      242,    -1,   304,   241,    -1,   317,   241,    -1,   343,    -1,
    850       -1,   242,    -1,   109,   154,    -1,    29,   298,    -1,   243,
    851      106,   245,   358,   107,    -1,   243,   261,   106,   245,   358,
    852      107,    -1,   243,   261,    -1,   261,   246,    -1,   245,   108,
    853      261,   246,    -1,    -1,   123,   154,    -1,    -1,   248,    -1,
    854      250,    -1,   249,    -1,   249,   127,   108,   126,   250,    -1,
    855      250,   127,   108,   126,    89,    -1,   249,   127,   108,   126,
    856       89,    -1,   254,    -1,   250,   127,   108,   126,   254,    -1,
    857      249,   127,   108,   126,   254,    -1,   249,   127,   108,   126,
    858      250,   127,   108,   126,   254,    -1,   255,    -1,   250,   127,
    859      108,   126,   255,    -1,    -1,   252,    -1,   253,    -1,   253,
    860      127,   108,   126,    89,    -1,   257,    -1,   256,    -1,   253,
    861      127,   108,   126,   257,    -1,   253,   127,   108,   126,   256,
    862       -1,   256,    -1,   348,   259,   359,    -1,   356,   259,   359,
    863       -1,   216,   356,   259,   359,    -1,   206,    -1,   257,    -1,
    864      348,    -1,   356,    -1,   216,   356,    -1,   357,    -1,   213,
    865      322,   359,    -1,   213,   326,   359,    -1,   213,    -1,   213,
    866      337,    -1,   131,    -1,   258,   108,   131,    -1,   129,    -1,
    867       67,    -1,    68,    -1,   130,    -1,    67,    -1,    68,    -1,
    868      131,    -1,    67,    -1,    68,    -1,   352,    -1,   214,    -1,
    869      214,   343,    -1,   352,    -1,   357,    -1,   214,    -1,   214,
    870      331,    -1,    -1,   123,   265,    -1,   155,    -1,   106,   266,
    871      358,   107,    -1,   265,    -1,   267,   265,    -1,   266,   108,
    872      265,    -1,   266,   108,   267,   265,    -1,   268,   109,    -1,
    873      261,   109,    -1,   269,    -1,   268,   269,    -1,   105,   261,
    874       -1,   103,   126,   155,   127,   104,    -1,   103,   126,   296,
    875      127,   104,    -1,   103,   126,   154,    89,   154,   127,   104,
    876       -1,   105,   103,   126,   138,   127,   104,    -1,   271,    -1,
    877      220,   271,    -1,   270,   222,    -1,   270,   222,   216,    -1,
    878       68,   101,   278,   102,    -1,   216,    68,   101,   278,   102,
    879       -1,   271,   217,    -1,   273,   359,    -1,   272,   108,   273,
    880      359,    -1,    -1,   275,   261,   274,   276,    -1,   214,   322,
    881       -1,    32,    -1,    34,    -1,    33,    -1,    -1,   276,   277,
    882       -1,   121,   261,   101,   278,   102,    -1,   121,   106,   126,
    883      284,   107,    -1,   121,   101,   126,   272,   127,   102,   106,
    884      126,   284,   107,   101,   278,   102,    -1,   263,    -1,   155,
    885       -1,   278,   108,   263,    -1,   278,   108,   155,    -1,    32,
    886      280,    -1,   221,    32,   280,    -1,   279,   108,   280,    -1,
    887      281,   276,    -1,   281,   276,   123,   263,    -1,   261,    -1,
    888      260,   101,   126,   272,   127,   102,    -1,    35,   261,   101,
    889      126,   272,   127,   102,   106,   107,    -1,    -1,    35,   261,
    890      101,   126,   272,   127,   102,   106,   283,   284,   107,    -1,
    891      285,    -1,   284,   126,   285,    -1,   286,   127,   124,    -1,
    892      287,   127,   124,    -1,   204,    -1,   206,    -1,   286,   127,
    893      108,   126,   259,    -1,   214,   295,    -1,   287,   127,   108,
    894      126,   295,    -1,    -1,   289,    -1,   291,    -1,   289,   126,
    895      291,    -1,    -1,   289,    -1,   201,    -1,   293,    -1,   189,
    896       -1,    -1,     5,    75,   292,   106,   290,   107,    -1,    38,
    897      291,    -1,   294,    -1,   309,   164,    -1,   313,   126,   196,
    898      164,    -1,   205,   164,    -1,   213,   309,   164,    -1,   216,
    899      309,   164,    -1,   220,   309,   164,    -1,   220,   216,   309,
    900      164,    -1,   213,   313,   126,   196,   164,    -1,   216,   313,
    901      126,   196,   164,    -1,   220,   313,   126,   196,   164,    -1,
    902      220,   216,   313,   126,   196,   164,    -1,   304,    -1,   309,
    903       -1,   317,    -1,   154,   115,   154,    -1,    -1,    57,   101,
    904      133,   102,   298,    -1,    -1,   299,    -1,   300,    -1,   299,
    905      300,    -1,    37,   101,   101,   301,   102,   102,    -1,   302,
    906       -1,   301,   108,   302,    -1,    -1,   303,    -1,   303,   101,
    907      161,   102,    -1,   259,    -1,   223,    -1,   224,    -1,   217,
    908       -1,   305,   298,    -1,   306,    -1,   307,   298,    -1,   308,
    909      298,    -1,   129,    -1,   101,   305,   102,    -1,   111,   304,
    910       -1,   111,   216,   304,    -1,   101,   306,   102,    -1,   305,
    911      335,    -1,   101,   306,   102,   335,    -1,   101,   307,   102,
    912      336,    -1,   101,   307,   102,    -1,   101,   306,   102,   101,
    913      126,   251,   127,   102,    -1,   101,   308,   102,    -1,   310,
    914      298,    -1,   311,    -1,   312,   298,    -1,   305,   101,   126,
    915      251,   127,   102,    -1,   101,   311,   102,   101,   126,   251,
    916      127,   102,    -1,   101,   310,   102,    -1,   111,   309,    -1,
    917      111,   216,   309,    -1,   101,   311,   102,    -1,   101,   311,
    918      102,   335,    -1,   101,   312,   102,   336,    -1,   101,   312,
    919      102,    -1,   314,    -1,   315,    -1,   316,    -1,   305,   101,
    920      258,   102,    -1,   101,   315,   102,   101,   258,   102,    -1,
    921      101,   314,   102,    -1,   111,   313,    -1,   111,   216,   313,
    922       -1,   101,   315,   102,    -1,   101,   315,   102,   335,    -1,
    923      101,   316,   102,   336,    -1,   101,   316,   102,    -1,   318,
    924      298,    -1,   319,    -1,   320,   298,    -1,   321,   298,    -1,
    925       67,    -1,   101,   318,   102,    -1,   111,   317,    -1,   111,
    926      216,   317,    -1,   101,   319,   102,    -1,   318,   335,    -1,
    927      101,   319,   102,   335,    -1,   101,   320,   102,   336,    -1,
    928      101,   320,   102,    -1,   318,   101,   126,   251,   127,   102,
    929       -1,   101,   319,   102,   101,   126,   251,   127,   102,    -1,
    930      101,   321,   102,    -1,   305,   298,    -1,   323,    -1,   324,
    931      298,    -1,   325,   298,    -1,   111,   322,    -1,   111,   216,
    932      322,    -1,   101,   323,   102,    -1,   305,   341,    -1,   101,
    933      323,   102,   335,    -1,   101,   324,   102,   336,    -1,   101,
    934      324,   102,    -1,   305,   101,   126,   251,   127,   102,    -1,
    935      101,   323,   102,   101,   126,   251,   127,   102,    -1,   101,
    936      325,   102,    -1,   327,   298,    -1,   328,    -1,   329,   298,
    937       -1,   330,   298,    -1,    67,    -1,   111,   326,    -1,   111,
    938      216,   326,    -1,   101,   328,   102,    -1,   327,   341,    -1,
    939      101,   328,   102,   341,    -1,   327,   101,   126,   251,   127,
    940      102,    -1,   101,   328,   102,   101,   126,   251,   127,   102,
    941       -1,   332,    -1,   333,   298,    -1,   334,   298,    -1,   111,
    942       -1,   111,   216,    -1,   111,   331,    -1,   111,   216,   331,
    943       -1,   101,   332,   102,    -1,   335,    -1,   101,   332,   102,
    944      335,    -1,   101,   333,   102,   336,    -1,   101,   333,   102,
    945       -1,   101,   126,   251,   127,   102,    -1,   101,   332,   102,
    946      101,   126,   251,   127,   102,    -1,   101,   334,   102,    -1,
    947      103,   126,   127,   104,    -1,   103,   126,   127,   104,   336,
    948       -1,   336,    -1,   103,   126,   155,   127,   104,    -1,   103,
    949      126,   111,   127,   104,    -1,   336,   103,   126,   155,   127,
    950      104,    -1,   336,   103,   126,   111,   127,   104,    -1,   338,
    951       -1,   339,   298,    -1,   340,   298,    -1,   111,    -1,   111,
    952      216,    -1,   111,   337,    -1,   111,   216,   337,    -1,   101,
    953      338,   102,    -1,   341,    -1,   101,   338,   102,   341,    -1,
    954      101,   339,   102,   336,    -1,   101,   339,   102,    -1,   101,
    955      126,   251,   127,   102,    -1,   101,   338,   102,   101,   126,
    956      251,   127,   102,    -1,   101,   340,   102,    -1,   342,    -1,
    957      342,   336,    -1,   336,    -1,   103,   126,   127,   104,    -1,
    958      103,   126,   216,   111,   127,   104,    -1,   103,   126,   216,
    959      127,   104,    -1,   103,   126,   216,   155,   127,   104,    -1,
    960      103,   126,     7,   215,   155,   127,   104,    -1,   103,   126,
    961      216,     7,   155,   127,   104,    -1,   344,    -1,   345,   298,
    962       -1,   346,   298,    -1,   111,    -1,   111,   216,    -1,   111,
    963      343,    -1,   111,   216,   343,    -1,   101,   344,   102,    -1,
    964      335,    -1,   101,   344,   102,   335,    -1,   101,   345,   102,
    965      336,    -1,   101,   345,   102,    -1,   101,   344,   102,   101,
    966      126,   251,   127,   102,    -1,   101,   346,   102,    -1,   348,
    967       -1,   356,    -1,   216,   356,    -1,   349,    -1,   350,    -1,
    968      111,   214,    -1,   216,   111,   214,    -1,   111,   357,    -1,
    969      216,   111,   357,    -1,   111,   347,    -1,   216,   111,   347,
    970       -1,   103,   126,   127,   104,   214,    -1,   351,   214,    -1,
    971      103,   126,   127,   104,   336,   214,    -1,   351,   336,   214,
    972       -1,   336,   214,    -1,   103,   126,   127,   104,   349,    -1,
    973      351,   349,    -1,   103,   126,   127,   104,   336,   349,    -1,
    974      351,   336,   349,    -1,   336,   349,    -1,   103,   126,   216,
    975      111,   127,   104,    -1,   103,   126,   216,   155,   127,   104,
    976       -1,   103,   126,   220,   155,   127,   104,    -1,   103,   126,
    977      220,   216,   155,   127,   104,    -1,   356,    -1,   216,   356,
    978       -1,   353,    -1,   354,    -1,   355,    -1,   111,   214,    -1,
    979      216,   111,   214,    -1,   111,   357,    -1,   216,   111,   357,
    980       -1,   111,   352,    -1,   216,   111,   352,    -1,   103,   126,
    981      127,   104,   214,    -1,   103,   126,   127,   104,   336,   214,
    982       -1,   336,   214,    -1,   103,   126,   127,   104,   354,    -1,
    983      103,   126,   127,   104,   336,   354,    -1,   336,   354,    -1,
    984      103,   126,   250,   127,   104,    -1,   103,   126,   127,   104,
    985      101,   247,   102,    -1,   356,   101,   126,   247,   127,   102,
    986       -1,   207,   101,   126,   247,   127,   102,    -1,    -1,   108,
    987       -1,    -1,   123,   155,    -1
     824      -1,     8,    -1,     9,    -1,    62,    -1,    64,    -1,    16,
     825      -1,    21,    -1,    20,    -1,    18,    -1,    19,    -1,    17,
     826      -1,    22,    -1,    23,    -1,    15,    -1,    24,    -1,    25,
     827      -1,    26,    -1,   226,    -1,   220,   226,    -1,   225,   222,
     828      -1,   225,   222,   216,    -1,   225,   222,   226,    -1,   227,
     829      -1,   215,   228,   215,    -1,   224,    -1,   216,   224,    -1,
     830     227,   217,    -1,   227,   224,    -1,    27,   101,   263,   102,
     831      -1,    27,   101,   160,   102,    -1,    71,   101,   263,   102,
     832      -1,    71,   101,   160,   102,    -1,   230,    -1,   220,   230,
     833      -1,   229,   222,    -1,   229,   222,   216,    -1,   233,    -1,
     834     216,   233,    -1,   230,   217,    -1,   232,    -1,   220,   232,
     835      -1,   231,   222,    -1,   231,   222,   216,    -1,    67,    -1,
     836     216,    67,    -1,   232,   217,    -1,   234,    -1,   244,    -1,
     837     235,   106,   236,   107,    -1,   235,   261,    -1,   235,   261,
     838     106,   236,   107,    -1,   235,   101,   126,   272,   127,   102,
     839     106,   236,   107,    -1,   235,   101,   126,   272,   127,   102,
     840     261,    -1,   235,   101,   126,   272,   127,   102,   261,   106,
     841     236,   107,    -1,   235,   101,   126,   272,   127,   102,   101,
     842     278,   102,   106,   236,   107,    -1,   235,   101,   126,   278,
     843     127,   102,   261,    -1,   235,   101,   126,   272,   127,   102,
     844     101,   278,   102,   261,   106,   236,   107,    -1,    30,   298,
     845      -1,    31,   298,    -1,   237,    -1,   236,   237,    -1,   238,
     846     124,    -1,    38,   238,   124,    -1,   239,   124,    -1,    38,
     847     239,   124,    -1,   352,    -1,   352,   261,    -1,   238,   108,
     848     261,    -1,   238,   108,    -1,   214,   240,    -1,   239,   108,
     849     298,   240,    -1,    -1,   242,    -1,   304,   241,    -1,   317,
     850     241,    -1,   343,    -1,    -1,   242,    -1,   109,   154,    -1,
     851      29,   298,    -1,   243,   106,   245,   358,   107,    -1,   243,
     852     261,   106,   245,   358,   107,    -1,   243,   261,    -1,   261,
     853     246,    -1,   245,   108,   261,   246,    -1,    -1,   123,   154,
     854      -1,    -1,   248,    -1,   250,    -1,   249,    -1,   249,   127,
     855     108,   126,   250,    -1,   250,   127,   108,   126,    89,    -1,
     856     249,   127,   108,   126,    89,    -1,   254,    -1,   250,   127,
     857     108,   126,   254,    -1,   249,   127,   108,   126,   254,    -1,
     858     249,   127,   108,   126,   250,   127,   108,   126,   254,    -1,
     859     255,    -1,   250,   127,   108,   126,   255,    -1,    -1,   252,
     860      -1,   253,    -1,   253,   127,   108,   126,    89,    -1,   257,
     861      -1,   256,    -1,   253,   127,   108,   126,   257,    -1,   253,
     862     127,   108,   126,   256,    -1,   256,    -1,   348,   259,   359,
     863      -1,   356,   259,   359,    -1,   216,   356,   259,   359,    -1,
     864     206,    -1,   257,    -1,   348,    -1,   356,    -1,   216,   356,
     865      -1,   357,    -1,   213,   322,   359,    -1,   213,   326,   359,
     866      -1,   213,    -1,   213,   337,    -1,   131,    -1,   258,   108,
     867     131,    -1,   129,    -1,    67,    -1,    68,    -1,   130,    -1,
     868      67,    -1,    68,    -1,   131,    -1,    67,    -1,    68,    -1,
     869     352,    -1,   214,    -1,   214,   343,    -1,   352,    -1,   357,
     870      -1,   214,    -1,   214,   331,    -1,    -1,   123,   265,    -1,
     871     155,    -1,   106,   266,   358,   107,    -1,   265,    -1,   267,
     872     265,    -1,   266,   108,   265,    -1,   266,   108,   267,   265,
     873      -1,   268,   109,    -1,   261,   109,    -1,   269,    -1,   268,
     874     269,    -1,   105,   261,    -1,   103,   126,   155,   127,   104,
     875      -1,   103,   126,   296,   127,   104,    -1,   103,   126,   154,
     876      89,   154,   127,   104,    -1,   105,   103,   126,   138,   127,
     877     104,    -1,   271,    -1,   220,   271,    -1,   270,   222,    -1,
     878     270,   222,   216,    -1,    68,   101,   278,   102,    -1,   216,
     879      68,   101,   278,   102,    -1,   271,   217,    -1,   273,   359,
     880      -1,   272,   108,   273,   359,    -1,    -1,   275,   261,   274,
     881     276,    -1,   214,   322,    -1,    32,    -1,    34,    -1,    33,
     882      -1,    -1,   276,   277,    -1,   121,   261,   101,   278,   102,
     883      -1,   121,   106,   126,   284,   107,    -1,   121,   101,   126,
     884     272,   127,   102,   106,   126,   284,   107,   101,   278,   102,
     885      -1,   263,    -1,   155,    -1,   278,   108,   263,    -1,   278,
     886     108,   155,    -1,    32,   280,    -1,   221,    32,   280,    -1,
     887     279,   108,   280,    -1,   281,   276,    -1,   281,   276,   123,
     888     263,    -1,   261,    -1,   260,   101,   126,   272,   127,   102,
     889      -1,    35,   261,   101,   126,   272,   127,   102,   106,   107,
     890      -1,    -1,    35,   261,   101,   126,   272,   127,   102,   106,
     891     283,   284,   107,    -1,   285,    -1,   284,   126,   285,    -1,
     892     286,   127,   124,    -1,   287,   127,   124,    -1,   204,    -1,
     893     206,    -1,   286,   127,   108,   126,   259,    -1,   214,   295,
     894      -1,   287,   127,   108,   126,   295,    -1,    -1,   289,    -1,
     895     291,    -1,   289,   126,   291,    -1,    -1,   289,    -1,   201,
     896      -1,   293,    -1,   189,    -1,    -1,     5,    75,   292,   106,
     897     290,   107,    -1,    38,   291,    -1,   294,    -1,   309,   164,
     898      -1,   313,   126,   196,   164,    -1,   205,   164,    -1,   213,
     899     309,   164,    -1,   216,   309,   164,    -1,   220,   309,   164,
     900      -1,   220,   216,   309,   164,    -1,   213,   313,   126,   196,
     901     164,    -1,   216,   313,   126,   196,   164,    -1,   220,   313,
     902     126,   196,   164,    -1,   220,   216,   313,   126,   196,   164,
     903      -1,   304,    -1,   309,    -1,   317,    -1,   154,   115,   154,
     904      -1,    -1,    57,   101,   133,   102,   298,    -1,    -1,   299,
     905      -1,   300,    -1,   299,   300,    -1,    37,   101,   101,   301,
     906     102,   102,    -1,   302,    -1,   301,   108,   302,    -1,    -1,
     907     303,    -1,   303,   101,   161,   102,    -1,   259,    -1,   223,
     908      -1,   224,    -1,   217,    -1,   305,   298,    -1,   306,    -1,
     909     307,   298,    -1,   308,   298,    -1,   129,    -1,   101,   305,
     910     102,    -1,   111,   304,    -1,   111,   216,   304,    -1,   101,
     911     306,   102,    -1,   305,   335,    -1,   101,   306,   102,   335,
     912      -1,   101,   307,   102,   336,    -1,   101,   307,   102,    -1,
     913     101,   306,   102,   101,   126,   251,   127,   102,    -1,   101,
     914     308,   102,    -1,   310,   298,    -1,   311,    -1,   312,   298,
     915      -1,   305,   101,   126,   251,   127,   102,    -1,   101,   311,
     916     102,   101,   126,   251,   127,   102,    -1,   101,   310,   102,
     917      -1,   111,   309,    -1,   111,   216,   309,    -1,   101,   311,
     918     102,    -1,   101,   311,   102,   335,    -1,   101,   312,   102,
     919     336,    -1,   101,   312,   102,    -1,   314,    -1,   315,    -1,
     920     316,    -1,   305,   101,   258,   102,    -1,   101,   315,   102,
     921     101,   258,   102,    -1,   101,   314,   102,    -1,   111,   313,
     922      -1,   111,   216,   313,    -1,   101,   315,   102,    -1,   101,
     923     315,   102,   335,    -1,   101,   316,   102,   336,    -1,   101,
     924     316,   102,    -1,   318,   298,    -1,   319,    -1,   320,   298,
     925      -1,   321,   298,    -1,    67,    -1,   101,   318,   102,    -1,
     926     111,   317,    -1,   111,   216,   317,    -1,   101,   319,   102,
     927      -1,   318,   335,    -1,   101,   319,   102,   335,    -1,   101,
     928     320,   102,   336,    -1,   101,   320,   102,    -1,   318,   101,
     929     126,   251,   127,   102,    -1,   101,   319,   102,   101,   126,
     930     251,   127,   102,    -1,   101,   321,   102,    -1,   305,   298,
     931      -1,   323,    -1,   324,   298,    -1,   325,   298,    -1,   111,
     932     322,    -1,   111,   216,   322,    -1,   101,   323,   102,    -1,
     933     305,   341,    -1,   101,   323,   102,   335,    -1,   101,   324,
     934     102,   336,    -1,   101,   324,   102,    -1,   305,   101,   126,
     935     251,   127,   102,    -1,   101,   323,   102,   101,   126,   251,
     936     127,   102,    -1,   101,   325,   102,    -1,   327,   298,    -1,
     937     328,    -1,   329,   298,    -1,   330,   298,    -1,    67,    -1,
     938     111,   326,    -1,   111,   216,   326,    -1,   101,   328,   102,
     939      -1,   327,   341,    -1,   101,   328,   102,   341,    -1,   327,
     940     101,   126,   251,   127,   102,    -1,   101,   328,   102,   101,
     941     126,   251,   127,   102,    -1,   332,    -1,   333,   298,    -1,
     942     334,   298,    -1,   111,    -1,   111,   216,    -1,   111,   331,
     943      -1,   111,   216,   331,    -1,   101,   332,   102,    -1,   335,
     944      -1,   101,   332,   102,   335,    -1,   101,   333,   102,   336,
     945      -1,   101,   333,   102,    -1,   101,   126,   251,   127,   102,
     946      -1,   101,   332,   102,   101,   126,   251,   127,   102,    -1,
     947     101,   334,   102,    -1,   103,   126,   127,   104,    -1,   103,
     948     126,   127,   104,   336,    -1,   336,    -1,   103,   126,   155,
     949     127,   104,    -1,   103,   126,   111,   127,   104,    -1,   336,
     950     103,   126,   155,   127,   104,    -1,   336,   103,   126,   111,
     951     127,   104,    -1,   338,    -1,   339,   298,    -1,   340,   298,
     952      -1,   111,    -1,   111,   216,    -1,   111,   337,    -1,   111,
     953     216,   337,    -1,   101,   338,   102,    -1,   341,    -1,   101,
     954     338,   102,   341,    -1,   101,   339,   102,   336,    -1,   101,
     955     339,   102,    -1,   101,   126,   251,   127,   102,    -1,   101,
     956     338,   102,   101,   126,   251,   127,   102,    -1,   101,   340,
     957     102,    -1,   342,    -1,   342,   336,    -1,   336,    -1,   103,
     958     126,   127,   104,    -1,   103,   126,   216,   111,   127,   104,
     959      -1,   103,   126,   216,   127,   104,    -1,   103,   126,   216,
     960     155,   127,   104,    -1,   103,   126,     7,   215,   155,   127,
     961     104,    -1,   103,   126,   216,     7,   155,   127,   104,    -1,
     962     344,    -1,   345,   298,    -1,   346,   298,    -1,   111,    -1,
     963     111,   216,    -1,   111,   343,    -1,   111,   216,   343,    -1,
     964     101,   344,   102,    -1,   335,    -1,   101,   344,   102,   335,
     965      -1,   101,   345,   102,   336,    -1,   101,   345,   102,    -1,
     966     101,   344,   102,   101,   126,   251,   127,   102,    -1,   101,
     967     346,   102,    -1,   348,    -1,   356,    -1,   216,   356,    -1,
     968     349,    -1,   350,    -1,   111,   214,    -1,   216,   111,   214,
     969      -1,   111,   357,    -1,   216,   111,   357,    -1,   111,   347,
     970      -1,   216,   111,   347,    -1,   103,   126,   127,   104,   214,
     971      -1,   351,   214,    -1,   103,   126,   127,   104,   336,   214,
     972      -1,   351,   336,   214,    -1,   336,   214,    -1,   103,   126,
     973     127,   104,   349,    -1,   351,   349,    -1,   103,   126,   127,
     974     104,   336,   349,    -1,   351,   336,   349,    -1,   336,   349,
     975      -1,   103,   126,   216,   111,   127,   104,    -1,   103,   126,
     976     216,   155,   127,   104,    -1,   103,   126,   220,   155,   127,
     977     104,    -1,   103,   126,   220,   216,   155,   127,   104,    -1,
     978     356,    -1,   216,   356,    -1,   353,    -1,   354,    -1,   355,
     979      -1,   111,   214,    -1,   216,   111,   214,    -1,   111,   357,
     980      -1,   216,   111,   357,    -1,   111,   352,    -1,   216,   111,
     981     352,    -1,   103,   126,   127,   104,   214,    -1,   103,   126,
     982     127,   104,   336,   214,    -1,   336,   214,    -1,   103,   126,
     983     127,   104,   354,    -1,   103,   126,   127,   104,   336,   354,
     984      -1,   336,   354,    -1,   103,   126,   250,   127,   104,    -1,
     985     103,   126,   127,   104,   101,   247,   102,    -1,   356,   101,
     986     126,   247,   127,   102,    -1,   207,   101,   126,   247,   127,
     987     102,    -1,    -1,   108,    -1,    -1,   123,   155,    -1
    988988};
    989989
     
    10211021    1173,  1183,  1184,  1189,  1190,  1195,  1197,  1199,  1201,  1203,
    10221022    1206,  1205,  1217,  1218,  1220,  1230,  1231,  1236,  1240,  1242,
    1023     1244,  1246,  1248,  1251,  1256,  1258,  1260,  1262,  1264,  1266,
    1024     1268,  1270,  1272,  1274,  1276,  1278,  1284,  1285,  1287,  1289,
    1025     1291,  1296,  1297,  1303,  1304,  1306,  1308,  1313,  1315,  1317,
    1026     1319,  1324,  1325,  1327,  1329,  1334,  1335,  1337,  1342,  1343,
    1027     1345,  1347,  1352,  1354,  1356,  1361,  1362,  1366,  1368,  1370,
    1028     1372,  1374,  1376,  1378,  1380,  1383,  1388,  1390,  1395,  1397,
    1029     1402,  1403,  1405,  1406,  1411,  1412,  1414,  1416,  1421,  1423,
    1030     1429,  1430,  1432,  1435,  1438,  1443,  1444,  1449,  1454,  1458,
    1031     1460,  1462,  1467,  1469,  1475,  1476,  1484,  1485,  1489,  1490,
    1032     1491,  1493,  1495,  1503,  1504,  1506,  1508,  1513,  1514,  1520,
    1033     1521,  1525,  1526,  1531,  1532,  1533,  1535,  1544,  1545,  1547,
    1034     1550,  1552,  1556,  1557,  1558,  1560,  1562,  1566,  1571,  1579,
    1035     1580,  1589,  1591,  1596,  1597,  1598,  1602,  1603,  1604,  1608,
    1036     1609,  1610,  1614,  1615,  1616,  1621,  1622,  1623,  1624,  1630,
    1037     1631,  1635,  1636,  1640,  1641,  1642,  1643,  1658,  1659,  1664,
    1038     1665,  1669,  1671,  1675,  1677,  1679,  1703,  1704,  1706,  1708,
    1039     1713,  1715,  1717,  1722,  1723,  1729,  1728,  1732,  1736,  1738,
    1040     1740,  1746,  1747,  1752,  1757,  1759,  1764,  1766,  1767,  1769,
    1041     1774,  1776,  1778,  1783,  1785,  1790,  1795,  1803,  1809,  1808,
    1042     1822,  1823,  1828,  1829,  1833,  1838,  1843,  1851,  1856,  1867,
    1043     1868,  1879,  1880,  1886,  1887,  1891,  1892,  1893,  1896,  1895,
    1044     1906,  1911,  1918,  1924,  1933,  1939,  1945,  1951,  1957,  1965,
    1045     1971,  1979,  1985,  1994,  1995,  1996,  2000,  2004,  2006,  2009,
    1046     2011,  2015,  2016,  2020,  2024,  2025,  2028,  2030,  2031,  2035,
    1047     2036,  2037,  2038,  2073,  2074,  2075,  2076,  2080,  2085,  2090,
    1048     2092,  2094,  2099,  2101,  2103,  2105,  2110,  2112,  2122,  2123,
    1049     2124,  2128,  2130,  2132,  2137,  2139,  2141,  2146,  2148,  2150,
    1050     2159,  2160,  2161,  2165,  2167,  2169,  2174,  2176,  2178,  2183,
    1051     2185,  2187,  2202,  2203,  2204,  2205,  2209,  2214,  2219,  2221,
    1052     2223,  2228,  2230,  2232,  2234,  2239,  2241,  2243,  2253,  2254,
    1053     2255,  2256,  2260,  2262,  2264,  2269,  2271,  2273,  2275,  2280,
    1054     2282,  2284,  2315,  2316,  2317,  2318,  2322,  2330,  2332,  2334,
    1055     2339,  2341,  2346,  2348,  2362,  2363,  2364,  2368,  2370,  2372,
    1056     2374,  2376,  2381,  2382,  2384,  2386,  2391,  2393,  2395,  2401,
    1057     2403,  2405,  2409,  2411,  2413,  2415,  2429,  2430,  2431,  2435,
    1058     2437,  2439,  2441,  2443,  2448,  2449,  2451,  2453,  2458,  2460,
    1059     2462,  2468,  2469,  2471,  2481,  2484,  2486,  2489,  2491,  2493,
    1060     2506,  2507,  2508,  2512,  2514,  2516,  2518,  2520,  2525,  2526,
    1061     2528,  2530,  2535,  2537,  2545,  2546,  2547,  2552,  2553,  2557,
    1062     2559,  2561,  2563,  2565,  2567,  2574,  2576,  2578,  2580,  2582,
    1063     2584,  2586,  2588,  2590,  2592,  2597,  2599,  2601,  2606,  2632,
    1064     2633,  2635,  2639,  2640,  2644,  2646,  2648,  2650,  2652,  2654,
    1065     2661,  2663,  2665,  2667,  2669,  2671,  2676,  2681,  2683,  2685,
    1066     2705,  2707,  2712,  2713
     1023    1244,  1246,  1248,  1250,  1252,  1254,  1259,  1261,  1263,  1265,
     1024    1267,  1269,  1271,  1273,  1275,  1277,  1279,  1281,  1287,  1288,
     1025    1290,  1292,  1294,  1299,  1300,  1306,  1307,  1309,  1311,  1316,
     1026    1318,  1320,  1322,  1327,  1328,  1330,  1332,  1337,  1338,  1340,
     1027    1345,  1346,  1348,  1350,  1355,  1357,  1359,  1364,  1365,  1369,
     1028    1371,  1373,  1375,  1377,  1379,  1381,  1383,  1386,  1391,  1393,
     1029    1398,  1400,  1405,  1406,  1408,  1409,  1414,  1415,  1417,  1419,
     1030    1424,  1426,  1432,  1433,  1435,  1438,  1441,  1446,  1447,  1452,
     1031    1457,  1461,  1463,  1465,  1470,  1472,  1478,  1479,  1487,  1488,
     1032    1492,  1493,  1494,  1496,  1498,  1506,  1507,  1509,  1511,  1516,
     1033    1517,  1523,  1524,  1528,  1529,  1534,  1535,  1536,  1538,  1547,
     1034    1548,  1550,  1553,  1555,  1559,  1560,  1561,  1563,  1565,  1569,
     1035    1574,  1582,  1583,  1592,  1594,  1599,  1600,  1601,  1605,  1606,
     1036    1607,  1611,  1612,  1613,  1617,  1618,  1619,  1624,  1625,  1626,
     1037    1627,  1633,  1634,  1638,  1639,  1643,  1644,  1645,  1646,  1661,
     1038    1662,  1667,  1668,  1672,  1674,  1678,  1680,  1682,  1706,  1707,
     1039    1709,  1711,  1716,  1718,  1720,  1725,  1726,  1732,  1731,  1735,
     1040    1739,  1741,  1743,  1749,  1750,  1755,  1760,  1762,  1767,  1769,
     1041    1770,  1772,  1777,  1779,  1781,  1786,  1788,  1793,  1798,  1806,
     1042    1812,  1811,  1825,  1826,  1831,  1832,  1836,  1841,  1846,  1854,
     1043    1859,  1870,  1871,  1882,  1883,  1889,  1890,  1894,  1895,  1896,
     1044    1899,  1898,  1909,  1914,  1921,  1927,  1936,  1942,  1948,  1954,
     1045    1960,  1968,  1974,  1982,  1988,  1997,  1998,  1999,  2003,  2007,
     1046    2009,  2012,  2014,  2018,  2019,  2023,  2027,  2028,  2031,  2033,
     1047    2034,  2038,  2039,  2040,  2041,  2076,  2077,  2078,  2079,  2083,
     1048    2088,  2093,  2095,  2097,  2102,  2104,  2106,  2108,  2113,  2115,
     1049    2125,  2126,  2127,  2131,  2133,  2135,  2140,  2142,  2144,  2149,
     1050    2151,  2153,  2162,  2163,  2164,  2168,  2170,  2172,  2177,  2179,
     1051    2181,  2186,  2188,  2190,  2205,  2206,  2207,  2208,  2212,  2217,
     1052    2222,  2224,  2226,  2231,  2233,  2235,  2237,  2242,  2244,  2246,
     1053    2256,  2257,  2258,  2259,  2263,  2265,  2267,  2272,  2274,  2276,
     1054    2278,  2283,  2285,  2287,  2318,  2319,  2320,  2321,  2325,  2333,
     1055    2335,  2337,  2342,  2344,  2349,  2351,  2365,  2366,  2367,  2371,
     1056    2373,  2375,  2377,  2379,  2384,  2385,  2387,  2389,  2394,  2396,
     1057    2398,  2404,  2406,  2408,  2412,  2414,  2416,  2418,  2432,  2433,
     1058    2434,  2438,  2440,  2442,  2444,  2446,  2451,  2452,  2454,  2456,
     1059    2461,  2463,  2465,  2471,  2472,  2474,  2484,  2487,  2489,  2492,
     1060    2494,  2496,  2509,  2510,  2511,  2515,  2517,  2519,  2521,  2523,
     1061    2528,  2529,  2531,  2533,  2538,  2540,  2548,  2549,  2550,  2555,
     1062    2556,  2560,  2562,  2564,  2566,  2568,  2570,  2577,  2579,  2581,
     1063    2583,  2585,  2587,  2589,  2591,  2593,  2595,  2600,  2602,  2604,
     1064    2609,  2635,  2636,  2638,  2642,  2643,  2647,  2649,  2651,  2653,
     1065    2655,  2657,  2664,  2666,  2668,  2670,  2672,  2674,  2679,  2684,
     1066    2686,  2688,  2708,  2710,  2715,  2716
    10671067};
    10681068#endif
     
    12341234     215,   216,   216,   217,   217,   218,   218,   218,   218,   218,
    12351235     219,   218,   220,   220,   220,   221,   221,   222,   223,   223,
    1236      223,   223,   223,   223,   224,   224,   224,   224,   224,   224,
    1237      224,   224,   224,   224,   224,   224,   225,   225,   225,   225,
    1238      225,   226,   226,   227,   227,   227,   227,   228,   228,   228,
    1239      228,   229,   229,   229,   229,   230,   230,   230,   231,   231,
    1240      231,   231,   232,   232,   232,   233,   233,   234,   234,   234,
    1241      234,   234,   234,   234,   234,   234,   235,   235,   236,   236,
    1242      237,   237,   237,   237,   238,   238,   238,   238,   239,   239,
    1243      240,   240,   240,   240,   240,   241,   241,   242,   243,   244,
    1244      244,   244,   245,   245,   246,   246,   247,   247,   248,   248,
    1245      248,   248,   248,   249,   249,   249,   249,   250,   250,   251,
    1246      251,   252,   252,   253,   253,   253,   253,   254,   254,   254,
    1247      254,   254,   255,   255,   255,   255,   255,   256,   256,   257,
    1248      257,   258,   258,   259,   259,   259,   260,   260,   260,   261,
    1249      261,   261,   262,   262,   262,   263,   263,   263,   263,   264,
    1250      264,   265,   265,   266,   266,   266,   266,   267,   267,   268,
    1251      268,   269,   269,   269,   269,   269,   270,   270,   270,   270,
    1252      271,   271,   271,   272,   272,   274,   273,   273,   275,   275,
    1253      275,   276,   276,   277,   277,   277,   278,   278,   278,   278,
    1254      279,   279,   279,   280,   280,   281,   281,   282,   283,   282,
    1255      284,   284,   285,   285,   286,   286,   286,   287,   287,   288,
    1256      288,   289,   289,   290,   290,   291,   291,   291,   292,   291,
    1257      291,   293,   293,   293,   294,   294,   294,   294,   294,   294,
    1258      294,   294,   294,   295,   295,   295,   296,   297,   297,   298,
    1259      298,   299,   299,   300,   301,   301,   302,   302,   302,   303,
    1260      303,   303,   303,   304,   304,   304,   304,   305,   305,   306,
    1261      306,   306,   307,   307,   307,   307,   308,   308,   309,   309,
    1262      309,   310,   310,   310,   311,   311,   311,   312,   312,   312,
    1263      313,   313,   313,   314,   314,   314,   315,   315,   315,   316,
    1264      316,   316,   317,   317,   317,   317,   318,   318,   319,   319,
    1265      319,   320,   320,   320,   320,   321,   321,   321,   322,   322,
    1266      322,   322,   323,   323,   323,   324,   324,   324,   324,   325,
    1267      325,   325,   326,   326,   326,   326,   327,   328,   328,   328,
    1268      329,   329,   330,   330,   331,   331,   331,   332,   332,   332,
    1269      332,   332,   333,   333,   333,   333,   334,   334,   334,   335,
    1270      335,   335,   336,   336,   336,   336,   337,   337,   337,   338,
    1271      338,   338,   338,   338,   339,   339,   339,   339,   340,   340,
    1272      340,   341,   341,   341,   342,   342,   342,   342,   342,   342,
    1273      343,   343,   343,   344,   344,   344,   344,   344,   345,   345,
    1274      345,   345,   346,   346,   347,   347,   347,   348,   348,   349,
    1275      349,   349,   349,   349,   349,   350,   350,   350,   350,   350,
    1276      350,   350,   350,   350,   350,   351,   351,   351,   351,   352,
    1277      352,   352,   353,   353,   354,   354,   354,   354,   354,   354,
    1278      355,   355,   355,   355,   355,   355,   356,   357,   357,   357,
    1279      358,   358,   359,   359
     1236     223,   223,   223,   223,   223,   223,   224,   224,   224,   224,
     1237     224,   224,   224,   224,   224,   224,   224,   224,   225,   225,
     1238     225,   225,   225,   226,   226,   227,   227,   227,   227,   228,
     1239     228,   228,   228,   229,   229,   229,   229,   230,   230,   230,
     1240     231,   231,   231,   231,   232,   232,   232,   233,   233,   234,
     1241     234,   234,   234,   234,   234,   234,   234,   234,   235,   235,
     1242     236,   236,   237,   237,   237,   237,   238,   238,   238,   238,
     1243     239,   239,   240,   240,   240,   240,   240,   241,   241,   242,
     1244     243,   244,   244,   244,   245,   245,   246,   246,   247,   247,
     1245     248,   248,   248,   248,   248,   249,   249,   249,   249,   250,
     1246     250,   251,   251,   252,   252,   253,   253,   253,   253,   254,
     1247     254,   254,   254,   254,   255,   255,   255,   255,   255,   256,
     1248     256,   257,   257,   258,   258,   259,   259,   259,   260,   260,
     1249     260,   261,   261,   261,   262,   262,   262,   263,   263,   263,
     1250     263,   264,   264,   265,   265,   266,   266,   266,   266,   267,
     1251     267,   268,   268,   269,   269,   269,   269,   269,   270,   270,
     1252     270,   270,   271,   271,   271,   272,   272,   274,   273,   273,
     1253     275,   275,   275,   276,   276,   277,   277,   277,   278,   278,
     1254     278,   278,   279,   279,   279,   280,   280,   281,   281,   282,
     1255     283,   282,   284,   284,   285,   285,   286,   286,   286,   287,
     1256     287,   288,   288,   289,   289,   290,   290,   291,   291,   291,
     1257     292,   291,   291,   293,   293,   293,   294,   294,   294,   294,
     1258     294,   294,   294,   294,   294,   295,   295,   295,   296,   297,
     1259     297,   298,   298,   299,   299,   300,   301,   301,   302,   302,
     1260     302,   303,   303,   303,   303,   304,   304,   304,   304,   305,
     1261     305,   306,   306,   306,   307,   307,   307,   307,   308,   308,
     1262     309,   309,   309,   310,   310,   310,   311,   311,   311,   312,
     1263     312,   312,   313,   313,   313,   314,   314,   314,   315,   315,
     1264     315,   316,   316,   316,   317,   317,   317,   317,   318,   318,
     1265     319,   319,   319,   320,   320,   320,   320,   321,   321,   321,
     1266     322,   322,   322,   322,   323,   323,   323,   324,   324,   324,
     1267     324,   325,   325,   325,   326,   326,   326,   326,   327,   328,
     1268     328,   328,   329,   329,   330,   330,   331,   331,   331,   332,
     1269     332,   332,   332,   332,   333,   333,   333,   333,   334,   334,
     1270     334,   335,   335,   335,   336,   336,   336,   336,   337,   337,
     1271     337,   338,   338,   338,   338,   338,   339,   339,   339,   339,
     1272     340,   340,   340,   341,   341,   341,   342,   342,   342,   342,
     1273     342,   342,   343,   343,   343,   344,   344,   344,   344,   344,
     1274     345,   345,   345,   345,   346,   346,   347,   347,   347,   348,
     1275     348,   349,   349,   349,   349,   349,   349,   350,   350,   350,
     1276     350,   350,   350,   350,   350,   350,   350,   351,   351,   351,
     1277     351,   352,   352,   352,   353,   353,   354,   354,   354,   354,
     1278     354,   354,   355,   355,   355,   355,   355,   355,   356,   357,
     1279     357,   357,   358,   358,   359,   359
    12801280};
    12811281
     
    13141314       0,     5,     1,     2,     3,     1,     2,     1,     1,     1,
    13151315       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
    1316        1,     1,     1,     1,     1,     1,     1,     2,     2,     3,
    1317        3,     1,     3,     1,     2,     2,     2,     4,     4,     4,
    1318        4,     1,     2,     2,     3,     1,     2,     2,     1,     2,
    1319        2,     3,     1,     2,     2,     1,     1,     4,     2,     5,
    1320        9,     7,    10,    12,     7,    13,     2,     2,     1,     2,
    1321        2,     3,     2,     3,     1,     2,     3,     2,     2,     4,
    1322        0,     1,     2,     2,     1,     0,     1,     2,     2,     5,
    1323        6,     2,     2,     4,     0,     2,     0,     1,     1,     1,
    1324        5,     5,     5,     1,     5,     5,     9,     1,     5,     0,
    1325        1,     1,     5,     1,     1,     5,     5,     1,     3,     3,
    1326        4,     1,     1,     1,     1,     2,     1,     3,     3,     1,
    1327        2,     1,     3,     1,     1,     1,     1,     1,     1,     1,
    1328        1,     1,     1,     1,     2,     1,     1,     1,     2,     0,
    1329        2,     1,     4,     1,     2,     3,     4,     2,     2,     1,
    1330        2,     2,     5,     5,     7,     6,     1,     2,     2,     3,
    1331        4,     5,     2,     2,     4,     0,     4,     2,     1,     1,
    1332        1,     0,     2,     5,     5,    13,     1,     1,     3,     3,
    1333        2,     3,     3,     2,     4,     1,     6,     9,     0,    11,
    1334        1,     3,     3,     3,     1,     1,     5,     2,     5,     0,
    1335        1,     1,     3,     0,     1,     1,     1,     1,     0,     6,
    1336        2,     1,     2,     4,     2,     3,     3,     3,     4,     5,
    1337        5,     5,     6,     1,     1,     1,     3,     0,     5,     0,
    1338        1,     1,     2,     6,     1,     3,     0,     1,     4,     1,
    1339        1,     1,     1,     2,     1,     2,     2,     1,     3,     2,
    1340        3,     3,     2,     4,     4,     3,     8,     3,     2,     1,
    1341        2,     6,     8,     3,     2,     3,     3,     4,     4,     3,
    1342        1,     1,     1,     4,     6,     3,     2,     3,     3,     4,
    1343        4,     3,     2,     1,     2,     2,     1,     3,     2,     3,
    1344        3,     2,     4,     4,     3,     6,     8,     3,     2,     1,
    1345        2,     2,     2,     3,     3,     2,     4,     4,     3,     6,
    1346        8,     3,     2,     1,     2,     2,     1,     2,     3,     3,
    1347        2,     4,     6,     8,     1,     2,     2,     1,     2,     2,
    1348        3,     3,     1,     4,     4,     3,     5,     8,     3,     4,
    1349        5,     1,     5,     5,     6,     6,     1,     2,     2,     1,
     1316       1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
     1317       2,     3,     3,     1,     3,     1,     2,     2,     2,     4,
     1318       4,     4,     4,     1,     2,     2,     3,     1,     2,     2,
     1319       1,     2,     2,     3,     1,     2,     2,     1,     1,     4,
     1320       2,     5,     9,     7,    10,    12,     7,    13,     2,     2,
     1321       1,     2,     2,     3,     2,     3,     1,     2,     3,     2,
     1322       2,     4,     0,     1,     2,     2,     1,     0,     1,     2,
     1323       2,     5,     6,     2,     2,     4,     0,     2,     0,     1,
     1324       1,     1,     5,     5,     5,     1,     5,     5,     9,     1,
     1325       5,     0,     1,     1,     5,     1,     1,     5,     5,     1,
     1326       3,     3,     4,     1,     1,     1,     1,     2,     1,     3,
     1327       3,     1,     2,     1,     3,     1,     1,     1,     1,     1,
     1328       1,     1,     1,     1,     1,     1,     2,     1,     1,     1,
     1329       2,     0,     2,     1,     4,     1,     2,     3,     4,     2,
     1330       2,     1,     2,     2,     5,     5,     7,     6,     1,     2,
     1331       2,     3,     4,     5,     2,     2,     4,     0,     4,     2,
     1332       1,     1,     1,     0,     2,     5,     5,    13,     1,     1,
     1333       3,     3,     2,     3,     3,     2,     4,     1,     6,     9,
     1334       0,    11,     1,     3,     3,     3,     1,     1,     5,     2,
     1335       5,     0,     1,     1,     3,     0,     1,     1,     1,     1,
     1336       0,     6,     2,     1,     2,     4,     2,     3,     3,     3,
     1337       4,     5,     5,     5,     6,     1,     1,     1,     3,     0,
     1338       5,     0,     1,     1,     2,     6,     1,     3,     0,     1,
     1339       4,     1,     1,     1,     1,     2,     1,     2,     2,     1,
     1340       3,     2,     3,     3,     2,     4,     4,     3,     8,     3,
     1341       2,     1,     2,     6,     8,     3,     2,     3,     3,     4,
     1342       4,     3,     1,     1,     1,     4,     6,     3,     2,     3,
     1343       3,     4,     4,     3,     2,     1,     2,     2,     1,     3,
     1344       2,     3,     3,     2,     4,     4,     3,     6,     8,     3,
     1345       2,     1,     2,     2,     2,     3,     3,     2,     4,     4,
     1346       3,     6,     8,     3,     2,     1,     2,     2,     1,     2,
     1347       3,     3,     2,     4,     6,     8,     1,     2,     2,     1,
    13501348       2,     2,     3,     3,     1,     4,     4,     3,     5,     8,
    1351        3,     1,     2,     1,     4,     6,     5,     6,     7,     7,
    1352        1,     2,     2,     1,     2,     2,     3,     3,     1,     4,
    1353        4,     3,     8,     3,     1,     1,     2,     1,     1,     2,
    1354        3,     2,     3,     2,     3,     5,     2,     6,     3,     2,
    1355        5,     2,     6,     3,     2,     6,     6,     6,     7,     1,
    1356        2,     1,     1,     1,     2,     3,     2,     3,     2,     3,
    1357        5,     6,     2,     5,     6,     2,     5,     7,     6,     6,
    1358        0,     1,     0,     2
     1349       3,     4,     5,     1,     5,     5,     6,     6,     1,     2,
     1350       2,     1,     2,     2,     3,     3,     1,     4,     4,     3,
     1351       5,     8,     3,     1,     2,     1,     4,     6,     5,     6,
     1352       7,     7,     1,     2,     2,     1,     2,     2,     3,     3,
     1353       1,     4,     4,     3,     8,     3,     1,     1,     2,     1,
     1354       1,     2,     3,     2,     3,     2,     3,     5,     2,     6,
     1355       3,     2,     5,     2,     6,     3,     2,     6,     6,     6,
     1356       7,     1,     2,     1,     1,     1,     2,     3,     2,     3,
     1357       2,     3,     5,     6,     2,     5,     6,     2,     5,     7,
     1358       6,     6,     0,     1,     0,     2
    13591359};
    13601360
     
    13651365{
    13661366     279,   279,   300,   298,   301,   299,   302,   303,   285,   287,
    1367      286,     0,   288,   312,   304,   309,   307,   308,   306,   305,
    1368      310,   311,   313,   314,   315,   529,   529,   529,     0,     0,
    1369        0,   279,   279,   289,     7,   342,     0,     8,    13,    14,
    1370        0,     2,   279,   547,     9,   507,   505,   231,     3,   439,
    1371        3,   244,     0,     3,     3,     3,   232,     3,     0,     0,
    1372        0,   280,   281,   283,   279,   292,   295,   297,   323,   271,
    1373      316,   321,   272,   331,   273,   338,   335,   345,     0,     0,
    1374      346,   274,   456,     3,     3,     0,     2,   501,   506,   511,
    1375      284,     0,     0,   529,   559,   529,     2,   570,   571,   572,
    1376      279,     0,   712,   713,     0,    12,   279,     0,   255,   256,
    1377        0,   280,   275,   276,   277,   278,   508,   290,   378,   530,
    1378      531,   356,   357,    12,   430,   431,    11,   426,   429,     0,
    1379      485,   480,   471,   430,   431,     0,     0,   510,     0,   280,
    1380      279,     0,     0,     0,     0,     0,     0,     0,     0,   279,
    1381        2,     0,   714,   280,   564,   576,   718,   711,   709,   716,
    1382        0,     0,   238,     2,     0,   514,   424,   425,   423,     0,
    1383        0,     0,     0,   529,     0,   586,     0,     0,   527,   523,
    1384      529,   544,   529,   529,   524,     2,   525,   529,   583,   529,
    1385      529,     0,     0,     0,   279,   279,   298,   343,     0,     2,
    1386      279,   245,   282,   293,   324,   336,     0,     2,     0,   439,
    1387      246,   280,   317,   332,   339,   457,     0,     2,     0,   296,
    1388      318,   325,   326,     0,   333,   337,   340,   344,     2,   279,
    1389      348,     0,   381,   458,   462,     0,     0,     0,     1,   279,
    1390        2,   512,   558,   560,   279,     2,   722,   280,   725,   527,
    1391      527,   280,     0,     0,     0,   258,   529,   524,     2,   279,
    1392        0,     0,   279,   532,     2,   483,     2,   536,     0,     0,
    1393        0,     0,    17,    56,     4,     5,     6,    15,     0,     0,
    1394        0,   279,     2,     0,   279,    62,    63,    64,    65,    19,
    1395       18,    20,    23,    47,    66,     0,    69,    73,    76,    79,
    1396       84,    87,    89,    91,    93,    95,    97,   102,   477,   732,
    1397      437,   476,     0,   435,   436,     0,   548,   563,   566,   569,
    1398      575,   578,   581,     2,   279,     0,     3,   411,     0,   419,
    1399      280,   279,   292,   316,   272,   331,   338,     3,     3,   393,
    1400      397,   407,   412,   456,   279,   413,   687,   688,   279,   414,
    1401      416,   279,     2,   565,   577,   710,     2,     2,   233,     2,
    1402        0,     0,   441,   440,   137,     2,     2,   235,     2,     2,
    1403      234,     2,   266,     2,   267,     0,   265,     0,     0,     0,
    1404        0,     0,     0,     0,     0,     0,   549,   588,     0,   439,
    1405        2,   543,   552,   641,   545,   546,   515,   279,     2,   582,
    1406      591,   584,   585,     0,   261,   279,   279,   322,     0,   280,
    1407      279,   279,   715,   719,   717,   516,   279,   527,   239,   247,
    1408      294,     0,     2,   517,   279,   481,   319,   320,   268,   334,
    1409      341,   279,   279,     2,   370,   279,   358,     0,     0,   364,
    1410      709,   279,   730,   384,     0,   459,   482,   236,   237,   502,
    1411      279,   421,     0,   279,   221,     0,     2,   223,     0,   280,
    1412        0,   241,     2,   242,   263,     0,     0,     2,   279,   527,
    1413      279,   468,   470,   469,     0,     0,   732,     0,   279,     0,
    1414      279,   472,   279,   542,   540,   541,   539,     0,   534,   537,
    1415       66,   101,     0,   279,    54,    50,   279,    59,   279,   279,
    1416       48,    49,    61,     2,   124,     0,     0,   433,     0,   432,
    1417      279,    52,    53,    16,     0,    30,    31,    35,     2,     0,
    1418      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
    1419        0,     0,    51,     0,     0,     0,     0,     0,     0,     0,
     1367     286,     0,   288,   314,   306,   311,   309,   310,   308,   307,
     1368     312,   313,   315,   316,   317,   531,   531,   531,     0,     0,
     1369       0,   279,   279,   289,   304,   305,     7,   344,     0,     8,
     1370      13,    14,     0,     2,   279,   549,     9,   509,   507,   231,
     1371       3,   441,     3,   244,     0,     3,     3,     3,   232,     3,
     1372       0,     0,     0,   280,   281,   283,   279,   292,   295,   297,
     1373     325,   271,   318,   323,   272,   333,   273,   340,   337,   347,
     1374       0,     0,   348,   274,   458,     3,     3,     0,     2,   503,
     1375     508,   513,   284,     0,     0,   531,   561,   531,     2,   572,
     1376     573,   574,   279,     0,   714,   715,     0,    12,   279,     0,
     1377     255,   256,     0,   280,   275,   276,   277,   278,   510,   290,
     1378     380,   532,   533,   358,   359,    12,   432,   433,    11,   428,
     1379     431,     0,   487,   482,   473,   432,   433,     0,     0,   512,
     1380       0,   280,   279,     0,     0,     0,     0,     0,     0,     0,
     1381       0,   279,     2,     0,   716,   280,   566,   578,   720,   713,
     1382     711,   718,     0,     0,   238,     2,     0,   516,   426,   427,
     1383     425,     0,     0,     0,     0,   531,     0,   588,     0,     0,
     1384     529,   525,   531,   546,   531,   531,   526,     2,   527,   531,
     1385     585,   531,   531,     0,     0,     0,   279,   279,   298,   345,
     1386       0,     2,   279,   245,   282,   293,   326,   338,     0,     2,
     1387       0,   441,   246,   280,   319,   334,   341,   459,     0,     2,
     1388       0,   296,   320,   327,   328,     0,   335,   339,   342,   346,
     1389       2,   279,   350,     0,   383,   460,   464,     0,     0,     0,
     1390       1,   279,     2,   514,   560,   562,   279,     2,   724,   280,
     1391     727,   529,   529,   280,     0,     0,     0,   258,   531,   526,
     1392       2,   279,     0,     0,   279,   534,     2,   485,     2,   538,
     1393       0,     0,     0,     0,    17,    56,     4,     5,     6,    15,
     1394       0,     0,     0,   279,     2,     0,   279,    62,    63,    64,
     1395      65,    19,    18,    20,    23,    47,    66,     0,    69,    73,
     1396      76,    79,    84,    87,    89,    91,    93,    95,    97,   102,
     1397     479,   734,   439,   478,     0,   437,   438,     0,   550,   565,
     1398     568,   571,   577,   580,   583,     2,   279,     0,     3,   413,
     1399       0,   421,   280,   279,   292,   318,   272,   333,   340,     3,
     1400       3,   395,   399,   409,   414,   458,   279,   415,   689,   690,
     1401     279,   416,   418,   279,     2,   567,   579,   712,     2,     2,
     1402     233,     2,     0,     0,   443,   442,   137,     2,     2,   235,
     1403       2,     2,   234,     2,   266,     2,   267,     0,   265,     0,
     1404       0,     0,     0,     0,     0,     0,     0,     0,   551,   590,
     1405       0,   441,     2,   545,   554,   643,   547,   548,   517,   279,
     1406       2,   584,   593,   586,   587,     0,   261,   279,   279,   324,
     1407       0,   280,   279,   279,   717,   721,   719,   518,   279,   529,
     1408     239,   247,   294,     0,     2,   519,   279,   483,   321,   322,
     1409     268,   336,   343,   279,   279,     2,   372,   279,   360,     0,
     1410       0,   366,   711,   279,   732,   386,     0,   461,   484,   236,
     1411     237,   504,   279,   423,     0,   279,   221,     0,     2,   223,
     1412       0,   280,     0,   241,     2,   242,   263,     0,     0,     2,
     1413     279,   529,   279,   470,   472,   471,     0,     0,   734,     0,
     1414     279,     0,   279,   474,   279,   544,   542,   543,   541,     0,
     1415     536,   539,    66,   101,     0,   279,    54,    50,   279,    59,
     1416     279,   279,    48,    49,    61,     2,   124,     0,     0,   435,
     1417       0,   434,   279,    52,    53,    16,     0,    30,    31,    35,
     1418       2,     0,   114,   115,   116,   117,   118,   119,   120,   121,
     1419     122,   123,     0,     0,    51,     0,     0,     0,     0,     0,
    14201420       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    1421        0,     0,     0,   105,     2,   627,   438,   624,   529,   529,
    1422      632,   460,   279,     2,   567,     2,   568,     0,   579,   580,
    1423      279,     2,   279,     0,   689,   280,   693,   684,   685,   691,
    1424      279,     0,   616,     2,     2,   649,   529,   732,   599,   529,
    1425      529,   732,   529,   613,   529,   529,   663,   420,   646,   529,
    1426      529,   654,   661,   279,   415,   280,     0,     0,   279,   699,
    1427      280,   704,   732,   696,   279,   701,   732,     0,   279,   279,
    1428        0,     3,    17,     2,     0,     0,   443,   730,     0,     0,
    1429      449,   225,     0,   279,     0,     0,     0,   527,   551,   555,
    1430      557,   587,   590,   594,   597,   550,   589,     0,   269,     3,
    1431        0,   279,   262,     0,     0,     0,     0,   260,     0,     2,
    1432        0,     0,   243,   518,   279,     0,   437,     3,     3,     0,
    1433        0,   279,     0,     0,   673,   368,   371,   375,   529,   375,
    1434      678,   374,   670,   529,   529,   347,   359,   367,   360,   529,
    1435      362,   365,   279,   731,     0,     0,   382,   730,   280,     3,
    1436      400,     3,   404,   403,   573,     0,   513,   279,     3,     3,
    1437      279,   419,   280,     3,   413,   414,     2,     0,     0,     0,
    1438      467,   291,   279,   463,   465,     3,     2,     2,     0,   484,
    1439        3,     0,   536,   126,     0,   210,     0,     0,     2,     0,
    1440        0,    36,     0,     0,   279,    21,     0,    22,     0,   673,
    1441      434,     0,   106,     0,     3,     2,    28,     2,     0,    33,
    1442        0,     2,    26,   103,   104,    70,    71,    72,    74,    75,
    1443       77,    78,    82,    83,    80,    81,    85,    86,    88,    90,
    1444       92,    94,    96,     0,     0,   733,   279,     0,     0,     0,
    1445      628,   629,   625,   626,   479,   478,   279,     0,     0,     0,
    1446      280,   279,   279,   643,   686,   342,     0,   720,   279,   723,
    1447      642,     2,   279,     0,     0,     0,     0,     0,     0,     0,
    1448        0,     3,   650,   602,   617,   651,     2,   598,   605,   417,
    1449      600,   601,   418,     2,   612,   620,   614,   615,   647,   648,
    1450      662,   690,   694,   692,   732,   253,     2,   726,     2,   408,
    1451      698,   703,   409,   279,     3,   387,     3,     3,     3,   439,
    1452        0,     3,     3,     2,   451,   448,   731,     0,   444,     2,
    1453      447,   450,     0,   279,   226,   248,     3,   257,   259,     0,
    1454      439,     2,   553,   554,     2,   592,   593,     0,     3,     0,
    1455      519,     3,   328,   327,   330,   329,   461,   279,     0,   520,
    1456        0,   521,     2,   627,     0,     0,   361,   363,     2,     0,
    1457        0,     0,     0,     0,   377,   674,   675,   372,   376,   373,
    1458      671,   672,   366,   370,   349,   384,   379,   385,     0,     0,
    1459        0,   422,   224,     0,     0,     3,     2,   649,   415,     0,
    1460      509,     0,   732,   471,     0,   279,   279,   279,     0,   533,
    1461      535,   127,     0,   206,     0,     0,   211,   212,    55,    60,
    1462      279,     0,    58,    57,     0,     0,   125,   674,     0,    67,
    1463       68,   107,   112,     3,   108,   106,     0,     0,     3,    25,
    1464       35,     3,     0,    99,     0,     3,   631,   635,   638,   630,
    1465        3,   574,   108,     2,   279,     3,     3,   280,     0,     2,
    1466        2,   721,   724,     0,     3,   604,   608,   611,   619,   653,
    1467      657,   660,   279,     0,     3,   603,   618,   652,   279,   279,
    1468      410,   279,   279,   279,     0,     0,     0,     0,   240,   108,
    1469        0,   101,     0,     3,     3,     0,   445,     0,   442,     0,
    1470        0,   229,   279,     0,     0,   126,     0,     0,     0,     0,
    1471        0,   126,     0,     0,     0,     2,     0,     0,     3,   128,
    1472      129,     2,   139,   130,   131,   132,   133,   134,   135,   141,
    1473      143,     0,     0,     0,   270,   279,   279,   529,   639,     0,
    1474        0,     0,   522,   628,     0,     0,   279,   279,   677,   681,
    1475      683,   676,   369,   383,   380,   561,     2,   645,   644,     0,
    1476      650,     2,   464,   466,   486,     3,   494,   495,     0,     2,
    1477      490,     3,     3,     0,     0,   538,     0,     0,   210,     0,
    1478        3,    37,   108,   730,   106,     0,     3,   642,    42,     3,
    1479       40,     3,    34,     0,     3,    98,   100,     0,     2,   633,
    1480      634,     0,   695,   279,   700,   279,     0,     0,     0,     3,
    1481      279,   279,   279,   619,     0,     2,   606,   607,     2,   621,
    1482        2,   655,   656,     0,   664,     0,     3,     0,     3,     3,
    1483        3,     3,   395,   394,   398,     0,   729,     2,     2,   728,
    1484      109,     0,     0,     0,     0,     3,   446,     3,     0,   227,
    1485      142,     3,   280,   279,     0,     0,     0,     0,     2,   187,
    1486        0,   185,     0,     0,     0,     0,     0,     0,   191,     0,
    1487      279,   529,   147,   144,   279,     0,     0,   252,   264,     3,
    1488        3,   528,   640,   595,   279,   279,   279,   351,   354,     0,
    1489        2,   679,   680,   279,   251,   279,     0,   497,   474,   279,
    1490        0,     0,   473,   488,     0,   207,     0,   213,   106,     0,
    1491        0,   113,   110,     0,     0,     0,     0,     0,     0,    24,
    1492        0,   636,   279,   562,   697,   702,   705,   706,   707,     0,
    1493        3,     3,   658,   279,   279,   279,     3,     3,     0,   666,
    1494        0,     0,     0,     0,   727,   279,   279,     3,   526,   109,
    1495      453,     0,     0,   230,   280,     0,     0,     0,     0,   279,
    1496      188,   186,     0,   183,   189,     0,     0,     0,   192,   195,
    1497      193,   190,     0,   126,   140,   138,   228,     0,     0,     0,
    1498      279,   279,   108,   279,   402,   406,   405,     0,   491,     2,
    1499      492,     2,   493,   487,   279,   214,     0,     0,     3,   642,
    1500       32,   111,     2,    45,     2,    43,    41,    29,   109,    27,
    1501        3,   708,     0,     0,     3,     3,     3,     0,     0,   665,
    1502      667,   609,   622,   254,     2,   392,     3,   391,     0,   455,
    1503      452,   126,     0,     0,   126,     3,     0,   126,   184,     0,
    1504        2,   200,   194,     0,   108,   136,   556,   596,     0,   350,
    1505      279,     3,     2,     0,     0,     2,   208,   215,     0,     0,
    1506        0,     0,     0,     0,   250,   249,     0,     0,     0,   668,
    1507      669,   279,     0,   454,   148,     0,     0,     2,   161,   126,
    1508      150,     0,   178,     0,   126,     0,     2,   152,     0,     2,
    1509        2,   279,     0,   352,     0,   279,   496,   498,   489,     0,
    1510        0,   111,    38,     3,     3,   637,   610,   623,   659,   396,
    1511      126,   154,   157,     0,   156,   160,     3,   163,   162,     0,
    1512      126,   180,   126,     3,     0,   279,     0,     2,   279,   279,
    1513      682,     2,   209,   216,     0,     0,     0,   149,     0,     0,
    1514      159,   217,   164,     2,   219,   179,     0,   182,   168,   196,
    1515        3,   201,   205,     0,   279,   353,   279,     0,    39,    46,
    1516       44,   155,   158,   126,     0,   165,   279,   126,   126,     0,
    1517      169,     0,     0,   673,   202,   203,   204,   197,     3,   355,
    1518      279,   145,   166,   151,   126,   220,   181,   176,   174,   170,
    1519      153,   126,     0,   674,     0,     0,   146,   167,   177,   171,
    1520      175,   174,   172,     3,     0,   475,   173,   198,     3,   199
     1421       0,     0,     0,     0,     0,   105,     2,   629,   440,   626,
     1422     531,   531,   634,   462,   279,     2,   569,     2,   570,     0,
     1423     581,   582,   279,     2,   279,     0,   691,   280,   695,   686,
     1424     687,   693,   279,     0,   618,     2,     2,   651,   531,   734,
     1425     601,   531,   531,   734,   531,   615,   531,   531,   665,   422,
     1426     648,   531,   531,   656,   663,   279,   417,   280,     0,     0,
     1427     279,   701,   280,   706,   734,   698,   279,   703,   734,     0,
     1428     279,   279,     0,     3,    17,     2,     0,     0,   445,   732,
     1429       0,     0,   451,   225,     0,   279,     0,     0,     0,   529,
     1430     553,   557,   559,   589,   592,   596,   599,   552,   591,     0,
     1431     269,     3,     0,   279,   262,     0,     0,     0,     0,   260,
     1432       0,     2,     0,     0,   243,   520,   279,     0,   439,     3,
     1433       3,     0,     0,   279,     0,     0,   675,   370,   373,   377,
     1434     531,   377,   680,   376,   672,   531,   531,   349,   361,   369,
     1435     362,   531,   364,   367,   279,   733,     0,     0,   384,   732,
     1436     280,     3,   402,     3,   406,   405,   575,     0,   515,   279,
     1437       3,     3,   279,   421,   280,     3,   415,   416,     2,     0,
     1438       0,     0,   469,   291,   279,   465,   467,     3,     2,     2,
     1439       0,   486,     3,     0,   538,   126,     0,   210,     0,     0,
     1440       2,     0,     0,    36,     0,     0,   279,    21,     0,    22,
     1441       0,   675,   436,     0,   106,     0,     3,     2,    28,     2,
     1442       0,    33,     0,     2,    26,   103,   104,    70,    71,    72,
     1443      74,    75,    77,    78,    82,    83,    80,    81,    85,    86,
     1444      88,    90,    92,    94,    96,     0,     0,   735,   279,     0,
     1445       0,     0,   630,   631,   627,   628,   481,   480,   279,     0,
     1446       0,     0,   280,   279,   279,   645,   688,   344,     0,   722,
     1447     279,   725,   644,     2,   279,     0,     0,     0,     0,     0,
     1448       0,     0,     0,     3,   652,   604,   619,   653,     2,   600,
     1449     607,   419,   602,   603,   420,     2,   614,   622,   616,   617,
     1450     649,   650,   664,   692,   696,   694,   734,   253,     2,   728,
     1451       2,   410,   700,   705,   411,   279,     3,   389,     3,     3,
     1452       3,   441,     0,     3,     3,     2,   453,   450,   733,     0,
     1453     446,     2,   449,   452,     0,   279,   226,   248,     3,   257,
     1454     259,     0,   441,     2,   555,   556,     2,   594,   595,     0,
     1455       3,     0,   521,     3,   330,   329,   332,   331,   463,   279,
     1456       0,   522,     0,   523,     2,   629,     0,     0,   363,   365,
     1457       2,     0,     0,     0,     0,     0,   379,   676,   677,   374,
     1458     378,   375,   673,   674,   368,   372,   351,   386,   381,   387,
     1459       0,     0,     0,   424,   224,     0,     0,     3,     2,   651,
     1460     417,     0,   511,     0,   734,   473,     0,   279,   279,   279,
     1461       0,   535,   537,   127,     0,   206,     0,     0,   211,   212,
     1462      55,    60,   279,     0,    58,    57,     0,     0,   125,   676,
     1463       0,    67,    68,   107,   112,     3,   108,   106,     0,     0,
     1464       3,    25,    35,     3,     0,    99,     0,     3,   633,   637,
     1465     640,   632,     3,   576,   108,     2,   279,     3,     3,   280,
     1466       0,     2,     2,   723,   726,     0,     3,   606,   610,   613,
     1467     621,   655,   659,   662,   279,     0,     3,   605,   620,   654,
     1468     279,   279,   412,   279,   279,   279,     0,     0,     0,     0,
     1469     240,   108,     0,   101,     0,     3,     3,     0,   447,     0,
     1470     444,     0,     0,   229,   279,     0,     0,   126,     0,     0,
     1471       0,     0,     0,   126,     0,     0,     0,     2,     0,     0,
     1472       3,   128,   129,     2,   139,   130,   131,   132,   133,   134,
     1473     135,   141,   143,     0,     0,     0,   270,   279,   279,   531,
     1474     641,     0,     0,     0,   524,   630,     0,     0,   279,   279,
     1475     679,   683,   685,   678,   371,   385,   382,   563,     2,   647,
     1476     646,     0,   652,     2,   466,   468,   488,     3,   496,   497,
     1477       0,     2,   492,     3,     3,     0,     0,   540,     0,     0,
     1478     210,     0,     3,    37,   108,   732,   106,     0,     3,   644,
     1479      42,     3,    40,     3,    34,     0,     3,    98,   100,     0,
     1480       2,   635,   636,     0,   697,   279,   702,   279,     0,     0,
     1481       0,     3,   279,   279,   279,   621,     0,     2,   608,   609,
     1482       2,   623,     2,   657,   658,     0,   666,     0,     3,     0,
     1483       3,     3,     3,     3,   397,   396,   400,     0,   731,     2,
     1484       2,   730,   109,     0,     0,     0,     0,     3,   448,     3,
     1485       0,   227,   142,     3,   280,   279,     0,     0,     0,     0,
     1486       2,   187,     0,   185,     0,     0,     0,     0,     0,     0,
     1487     191,     0,   279,   531,   147,   144,   279,     0,     0,   252,
     1488     264,     3,     3,   530,   642,   597,   279,   279,   279,   353,
     1489     356,     0,     2,   681,   682,   279,   251,   279,     0,   499,
     1490     476,   279,     0,     0,   475,   490,     0,   207,     0,   213,
     1491     106,     0,     0,   113,   110,     0,     0,     0,     0,     0,
     1492       0,    24,     0,   638,   279,   564,   699,   704,   707,   708,
     1493     709,     0,     3,     3,   660,   279,   279,   279,     3,     3,
     1494       0,   668,     0,     0,     0,     0,   729,   279,   279,     3,
     1495     528,   109,   455,     0,     0,   230,   280,     0,     0,     0,
     1496       0,   279,   188,   186,     0,   183,   189,     0,     0,     0,
     1497     192,   195,   193,   190,     0,   126,   140,   138,   228,     0,
     1498       0,     0,   279,   279,   108,   279,   404,   408,   407,     0,
     1499     493,     2,   494,     2,   495,   489,   279,   214,     0,     0,
     1500       3,   644,    32,   111,     2,    45,     2,    43,    41,    29,
     1501     109,    27,     3,   710,     0,     0,     3,     3,     3,     0,
     1502       0,   667,   669,   611,   624,   254,     2,   394,     3,   393,
     1503       0,   457,   454,   126,     0,     0,   126,     3,     0,   126,
     1504     184,     0,     2,   200,   194,     0,   108,   136,   558,   598,
     1505       0,   352,   279,     3,     2,     0,     0,     2,   208,   215,
     1506       0,     0,     0,     0,     0,     0,   250,   249,     0,     0,
     1507       0,   670,   671,   279,     0,   456,   148,     0,     0,     2,
     1508     161,   126,   150,     0,   178,     0,   126,     0,     2,   152,
     1509       0,     2,     2,   279,     0,   354,     0,   279,   498,   500,
     1510     491,     0,     0,   111,    38,     3,     3,   639,   612,   625,
     1511     661,   398,   126,   154,   157,     0,   156,   160,     3,   163,
     1512     162,     0,   126,   180,   126,     3,     0,   279,     0,     2,
     1513     279,   279,   684,     2,   209,   216,     0,     0,     0,   149,
     1514       0,     0,   159,   217,   164,     2,   219,   179,     0,   182,
     1515     168,   196,     3,   201,   205,     0,   279,   355,   279,     0,
     1516      39,    46,    44,   155,   158,   126,     0,   165,   279,   126,
     1517     126,     0,   169,     0,     0,   675,   202,   203,   204,   197,
     1518       3,   357,   279,   145,   166,   151,   126,   220,   181,   176,
     1519     174,   170,   153,   126,     0,   676,     0,     0,   146,   167,
     1520     177,   171,   175,   174,   172,     3,     0,   477,   173,   198,
     1521       3,   199
    15211522};
    15221523
     
    15241525static const yytype_int16 yydefgoto[] =
    15251526{
    1526       -1,   812,   454,   289,    43,   127,   128,   290,   291,   292,
    1527      293,   758,   740,  1129,  1130,   294,   295,   296,   297,   298,
    1528      299,   300,   301,   302,   303,   304,   305,   306,   307,  1032,
    1529      504,   972,   309,   973,   531,   951,  1057,  1521,  1059,  1060,
    1530     1061,  1062,  1522,  1063,  1064,  1452,  1453,  1418,  1419,  1420,
    1531     1504,  1505,  1509,  1510,  1539,  1540,  1065,  1376,  1066,  1067,
    1532     1308,  1309,  1310,  1490,  1068,   955,   956,   957,  1398,  1482,
    1533     1483,   455,   456,   873,   874,  1040,    46,    47,    48,    49,
    1534       50,   327,   151,    53,    54,    55,    56,    57,   329,    59,
    1535       60,   251,    62,    63,   262,   331,   332,    66,    67,    68,
    1536       69,   112,    71,   194,   334,   113,    74,   114,    76,    77,
    1537       78,   435,   436,   437,   438,   675,   917,   676,    79,    80,
    1538      442,   696,   854,   855,   337,   338,   699,   700,   701,   339,
    1539      340,   341,   342,   452,   169,   129,   130,   508,   311,   162,
    1540      626,   627,   628,   629,   630,    81,   115,   475,   476,   943,
    1541      477,   265,   481,   312,    83,   131,   132,    84,  1334,  1109,
    1542     1110,  1111,  1112,    85,    86,   717,    87,   261,    88,    89,
    1543      178,  1034,   662,   391,   119,    90,   487,   488,   489,   179,
    1544      256,   181,   182,   183,   257,    93,    94,    95,    96,    97,
    1545       98,    99,   186,   187,   188,   189,   190,   823,   588,   589,
    1546      590,   591,   592,   593,   594,   595,   556,   557,   558,   559,
    1547      680,   100,   597,   598,   599,   600,   601,   602,   916,   682,
    1548      683,   684,   576,   345,   346,   347,   348,   439,   157,   102,
    1549      103,   349,   350,   694,   553
     1527      -1,   814,   456,   291,    45,   129,   130,   292,   293,   294,
     1528     295,   760,   742,  1131,  1132,   296,   297,   298,   299,   300,
     1529     301,   302,   303,   304,   305,   306,   307,   308,   309,  1034,
     1530     506,   974,   311,   975,   533,   953,  1059,  1523,  1061,  1062,
     1531    1063,  1064,  1524,  1065,  1066,  1454,  1455,  1420,  1421,  1422,
     1532    1506,  1507,  1511,  1512,  1541,  1542,  1067,  1378,  1068,  1069,
     1533    1310,  1311,  1312,  1492,  1070,   957,   958,   959,  1400,  1484,
     1534    1485,   457,   458,   875,   876,  1042,    48,    49,    50,    51,
     1535      52,   329,   153,    55,    56,    57,    58,    59,   331,    61,
     1536      62,   253,    64,    65,   264,   333,   334,    68,    69,    70,
     1537      71,   114,    73,   196,   336,   115,    76,   116,    78,    79,
     1538      80,   437,   438,   439,   440,   677,   919,   678,    81,    82,
     1539     444,   698,   856,   857,   339,   340,   701,   702,   703,   341,
     1540     342,   343,   344,   454,   171,   131,   132,   510,   313,   164,
     1541     628,   629,   630,   631,   632,    83,   117,   477,   478,   945,
     1542     479,   267,   483,   314,    85,   133,   134,    86,  1336,  1111,
     1543    1112,  1113,  1114,    87,    88,   719,    89,   263,    90,    91,
     1544     180,  1036,   664,   393,   121,    92,   489,   490,   491,   181,
     1545     258,   183,   184,   185,   259,    95,    96,    97,    98,    99,
     1546     100,   101,   188,   189,   190,   191,   192,   825,   590,   591,
     1547     592,   593,   594,   595,   596,   597,   558,   559,   560,   561,
     1548     682,   102,   599,   600,   601,   602,   603,   604,   918,   684,
     1549     685,   686,   578,   347,   348,   349,   350,   441,   159,   104,
     1550     105,   351,   352,   696,   555
    15501551};
    15511552
    15521553/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    15531554   STATE-NUM.  */
    1554 #define YYPACT_NINF -1291
     1555#define YYPACT_NINF -1306
    15551556static const yytype_int16 yypact[] =
    15561557{
    1557     3767,  2676, -1291,    62, -1291, -1291, -1291, -1291, -1291, -1291,
    1558    -1291,   146, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291,
    1559    -1291, -1291, -1291, -1291, -1291,   115,   115,   115,   905,   892,
    1560      225,  4876,  1045, -1291, -1291, -1291,   234, -1291, -1291, -1291,
    1561      678, -1291,  2287, -1291, -1291, -1291, -1291, -1291, -1291,    63,
    1562      239, -1291,  1646, -1291, -1291, -1291, -1291,   252,   886,   360,
    1563       99,  7577, -1291, -1291,  9303,  1009, -1291, -1291, -1291,  1359,
    1564      399,  5014,   640,   618,  1359,   728, -1291, -1291,   365,   285,
    1565    -1291,  1359,  1167,   282, -1291,   469,   486, -1291, -1291, -1291,
    1566    -1291,   345,   239,   115, -1291,   115, -1291, -1291, -1291, -1291,
    1567    10104,  1646, -1291, -1291,  1646, -1291, 10163,   377, -1291, -1291,
    1568     1212, 10222, -1291,  1045,  1045,  1045, -1291, -1291, -1291,   115,
    1569    -1291, -1291, -1291,   406,   455,   458, -1291, -1291, -1291,   466,
    1570    -1291, -1291, -1291, -1291, -1291,   475,   515, -1291,   538,  1045,
    1571     8846,  1230,    47,   506,   511,   552,   556,   559,   591,  7019,
    1572    -1291,   604, -1291,  9372, -1291, -1291, -1291, -1291,   614, -1291,
    1573      250,  3635, -1291,   620,   260, -1291, -1291, -1291, -1291,   645,
    1574      270,   290,   311,   115,   629, -1291,   886,  1586,   701, -1291,
    1575      122, -1291,   115,   115,   239, -1291, -1291,   145, -1291,   115,
    1576      115,  2053,   660,   672,  1045, 11990, -1291, -1291,   676, -1291,
    1577     2287, -1291, -1291,  1359, -1291, -1291,   239, -1291,  1646,    63,
    1578    -1291,  7818, -1291,  1045,  1045,  1045,   239, -1291,   905, -1291,
    1579     3082, -1291, -1291,   666,  1045, -1291,  1045, -1291, -1291,  5469,
    1580      699,   892,   721,  1045, -1291,   905,   706,   710, -1291,  4876,
    1581      778, -1291, -1291, -1291,  6212, -1291, -1291,  5247, -1291,   701,
    1582      141, 10222, 11181,  1212,  2053, -1291,   171, -1291, -1291, 10163,
    1583     1646,   744, 11930, -1291, -1291,   401, -1291, 11692, 11409, 11466,
    1584    11409, 11523, -1291,   753, -1291, -1291, -1291, -1291, 11580, 11580,
    1585      778,  8528, -1291, 11409,  8952, -1291, -1291, -1291, -1291, -1291,
    1586    -1291,   782, -1291,   993,  2004, 11409, -1291,   364,   202,   603,
    1587      611,   697,   758,   762,   769,   821,    44, -1291, -1291,   789,
    1588      446, -1291,   353, -1291, -1291,  1230, -1291, -1291,   434,   816,
    1589    -1291,   572,   816, -1291,  8634,   818, -1291, -1291,  1508,  1393,
    1590     8274, 11990,  1359, -1291,  1359,  1045,  1045, -1291, -1291, -1291,
    1591    -1291, -1291, -1291,  1045, 10281,  1646, -1291, -1291, 10340,  1905,
    1592    -1291,  7019, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291,
    1593     5697, 11409, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291,
    1594    -1291, -1291, -1291, -1291, -1291,  1212, -1291,   936,   839,   846,
    1595      864,   951,   873,   893,   897,  1586, -1291, -1291,   902,    63,
    1596    -1291, -1291, -1291,   925, -1291, -1291, -1291,  6212, -1291, -1291,
    1597    -1291, -1291, -1291,  2053, -1291,  8846,  8846, -1291,  1212, 12018,
    1598     8846,  7926, -1291, -1291, -1291, -1291,  6212,   141, -1291, -1291,
    1599     1359,   239, -1291, -1291,  6212, -1291,  3835, -1291, -1291,  1045,
    1600     1045,  5848, 10399, -1291,  1122,  9570, -1291,   315,   316,   892,
    1601    -1291,  5469,   935,   923,   892,  1045, -1291, -1291, -1291, -1291,
    1602    10759, -1291,   387, 11958, -1291,   239,   964, -1291,  1212, 11767,
    1603    11238, -1291, -1291, -1291, -1291,   999,  2053, -1291,  8339,   701,
    1604     7468, -1291, -1291, -1291,   752,   594,   789,   892, 11930,   537,
    1605    10163, -1291, 11930, -1291, -1291, -1291, -1291,   624, -1291,   973,
    1606    -1291, -1291,   152,  8528, -1291, -1291,  8528, -1291,  8740,  8528,
    1607    -1291, -1291, -1291, -1291, -1291,   664,   979,   483,   982, -1291,
    1608     6675, -1291, -1291, -1291,    65, -1291, -1291, 11295, -1291,    91,
    1609    -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291,
    1610    11181, 11181, -1291, 11409, 11409, 11409, 11409, 11409, 11409, 11409,
    1611    11409, 11409, 11409, 11409, 11409, 11409, 11409, 11409, 11409, 11409,
    1612    11409,  3856, 11181, -1291,   446,  1147, -1291, -1291,   115,   115,
    1613    -1291, -1291,  8846, -1291, -1291, -1291,   925,   778, -1291,   925,
    1614     6675, -1291,  9058,   989, -1291, 10458, -1291, -1291,   614, -1291,
    1615     8198,   991, -1291,   306, -1291,  1892,   253,   789, -1291,   115,
    1616      115,   789,   258, -1291,   115,   115,   925, -1291, -1291,   115,
    1617      115, -1291,   816, 10517,  1646, 11898,   307,   330, 10517, -1291,
    1618    10694, -1291,   789, -1291, 10281, -1291,   162,  1003,  7991,  7991,
    1619     1646,  5948,  1007, -1291,   361,  1011, -1291,  1000,  3635,   682,
    1620    -1291,  1096,  1646,  7991,   778,  1212,   778,   701,   705,   816,
    1621    -1291, -1291,   717,   816, -1291, -1291, -1291,  1051, -1291, 11352,
    1622      239, 10759, -1291,   702,  1025,   723,  1027, -1291,   734, -1291,
    1623     1026,   239, -1291, -1291,  6212,   239,  1580,  1024,  1032,   341,
    1624      385,  7131,  1763, 11409,  2122, -1291, -1291,  1035,    43,  1035,
    1625    -1291, -1291, -1291,   115,   115, -1291, -1291,   892, -1291,   115,
    1626    -1291, -1291,  9629,   892,  1028, 11409, -1291,   935, 11898, -1291,
    1627    -1291,  1031, -1291, -1291, -1291,   778, -1291, 11833, 11409, -1291,
    1628     7991,   675,  8274, -1291, -1291,   614,  1034,  1038,   752,  2429,
    1629    -1291, -1291, 11930, -1291, -1291,  1024, -1291, -1291,  1047, -1291,
    1630     1024,  1048, 11692, 11181,  1029,  1076,  1060,  1061, -1291,  1055,
    1631     1064, -1291,  1065,  1067,  6788, -1291, 11181, -1291,   483,  1926,
    1632    -1291,  6058, 11181,  1068,  1063, -1291, -1291, -1291,   756, -1291,
    1633    11181, -1291, -1291, -1291, -1291, -1291, -1291, -1291,   364,   364,
    1634      202,   202,   603,   603,   603,   603,   611,   611,   697,   758,
    1635      762,   769,   821, 11409,   790, -1291, 10759,  1072,  1073,  1080,
    1636     1147, -1291, -1291, -1291, -1291, -1291, 10759, 11352,   760,  1081,
    1637     7243,  9164,  7019, -1291, -1291,  1085,  1089, -1291, 10104, -1291,
    1638    -1291,   306, 10759,  1010,  1090,  1092,  1093,  1098,  1099,  1100,
    1639     1101,  4615,  1892, -1291, -1291, -1291, -1291, -1291, -1291, -1291,
    1640    -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291,
    1641      925, -1291, -1291, -1291,   789, -1291, -1291, -1291, -1291, -1291,
    1642    -1291, -1291, -1291,  9986, -1291, -1291,  1103,  1104, -1291,    63,
    1643     1105,  1063,  5948, -1291, -1291, -1291,  5697,  1107, -1291, -1291,
    1644    -1291, -1291,   892,  6285,  1187, -1291, -1291, -1291, -1291,  1106,
    1645       63, -1291, -1291,   925, -1291, -1291,   925,   175, 11409,  1112,
    1646    -1291, -1291, -1291, -1291, -1291, -1291, -1291,  7019,   512, -1291,
    1647      239, -1291,  1580,  1740,  1132,  1133, -1291, -1291, -1291,  1120,
    1648      880,  1136,  1143,  1144, -1291,  2122, -1291, -1291, -1291, -1291,
    1649    -1291, -1291, -1291,  1122, -1291,   923, -1291, -1291,  1140,  1149,
    1650     1148, -1291, -1291,  1156,  1157, -1291,   675,  2323, -1291,   374,
    1651    -1291,  2429,   789, -1291,  1150, 11930, 10576,  8846,  1160, -1291,
    1652    -1291,  1155,  1163, -1291,  1165,   173,  1161, -1291,  1166,  1166,
    1653     6675, 11181, -1291, -1291,  1166,  1169, -1291,  1926,  5697, -1291,
    1654    -1291, -1291, -1291,  1172,  4760, 11181,  1180,   778,  5948, -1291,
    1655    11295, -1291,   778, -1291, 11181, -1291,   792,   816, -1291, -1291,
    1656    -1291, -1291,  5313, -1291,  8634, -1291, -1291,  7355,  1183, -1291,
    1657    -1291, -1291, -1291,  1191, -1291,   828,   816, -1291,   866,   887,
    1658      816, -1291,  1045,  1190,  4985, -1291, -1291, -1291, 10759, 10759,
    1659    -1291,  8404,  8404,  7991,  1194,  1192,  1193,  1200, -1291, -1291,
    1660     1199,   450,   221,  1063, -1291,   778, -1291,  3635, -1291, 11181,
    1661      501, -1291,  6563,  1207,  1208, 11124,  1209,  1210,   112,   142,
    1662       54, 11181,  1213,   239,  5569, -1291,  1211,  1197, -1291, -1291,
    1663    -1291,  1215, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291,
    1664    -1291,   892,  1223, 11181, -1291, 10759, 10759,   115,   816,  1224,
    1665     1225,  1085, -1291,  1740,   651,   892,  6675, 10635,   924,   816,
    1666    -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291,  1226,
    1667     2323, -1291, -1291,  1206, -1291,  1024, -1291, -1291,  1212,  1228,
    1668    -1291, -1291, -1291,   765,  1232, -1291, 11409,  1216,  1076,  1076,
    1669     1234, -1291,  9688,  1000, 11181,  1240,  1172,   563,   227,  1239,
    1670    -1291,  1234, -1291,  1246,  1239, -1291, -1291,  1251, -1291, -1291,
    1671      925,  1252, -1291, 10281, -1291,  6907,  1254,  1256,  1257, -1291,
    1672    10045,  7991,  7991, -1291,  1253, -1291, -1291,   925, -1291, -1291,
    1673    -1291, -1291,   925, 11181, -1291, 11181, 11409,  1267, -1291, -1291,
    1674    -1291, -1291, -1291, -1291, -1291,  1273, -1291, -1291, -1291, -1291,
    1675    -1291, 11409, 11409,  1275,  1276,  1239, -1291, -1291,   892, -1291,
    1676    -1291, -1291,  7753, 10576, 11181, 11181,  1287, 11181, -1291, -1291,
    1677     1260, -1291,  1263, 11181,  1264,  1266, 11181,   938, -1291,  1268,
    1678     6675,   115, -1291, -1291,  6285,  1229,   542, -1291, -1291, -1291,
    1679    -1291, -1291,   925, -1291,  9440,  8846,  5469,  1285, -1291,  1289,
    1680    -1291, -1291,   925, 10967, -1291,  8339,  1295, -1291, -1291, 10576,
    1681      548,   582, -1291,  1291,  1297, -1291,   219, -1291, 11181,  1298,
    1682     1299, -1291, -1291,  1301,    98,   168,   778,  1303,  1305, -1291,
    1683     1306, -1291, 10759, -1291, -1291, -1291, -1291, -1291, -1291,  1309,
    1684    -1291, -1291, -1291, 10759, 10759, 10759, -1291, -1291,  1311, -1291,
    1685     1315,  1318,  1322,   507, -1291,  8058,  8166, -1291, -1291,   689,
    1686    -1291,  1321,  1325, -1291,  8469,   767,   776,  1329,   779,  6439,
    1687    -1291, -1291,   609, -1291, -1291,   784,  1330,   239,  1371,  1379,
    1688    -1291, -1291,  1332, 11124, -1291, -1291, -1291,  1336,  1337,   808,
    1689     9750,  5469,  9508, 10759, -1291, -1291, -1291,  1328, -1291, -1291,
    1690    -1291, -1291, -1291, -1291, 10576, -1291,  1316,  1368,  1172,    97,
    1691    -1291, -1291, -1291, -1291, -1291, -1291, -1291, -1291,  1342, -1291,
    1692    -1291, -1291,  1343,  1350, -1291, -1291, -1291,  1352,  1355, -1291,
    1693    -1291, -1291, -1291, -1291, -1291, -1291,  1361, -1291,  1362, -1291,
    1694    -1291, 11124,   118, 11181, 11124, -1291,  1365, 11181, -1291,   186,
    1695     1382, -1291, -1291,  1353,  9270, -1291, -1291, -1291,   497, -1291,
    1696     9809, -1291, -1291,  1646,  1212,  1369, -1291, -1291,   825,  1364,
    1697    11181,   778,   778,  1377, -1291, -1291,  1378,  1380,  1384, -1291,
    1698    -1291,  8404,  1381, -1291,  1447, 11409,  1383, -1291, -1291, 11044,
    1699    -1291,   837, -1291,  1366, 11124,  1373, -1291, -1291,  1396, -1291,
    1700     1406,  5469,  1394, -1291,  1397, 10576, -1291, -1291, -1291,  1386,
    1701     1426,  1399, -1291,  1239,  1239, -1291, -1291, -1291, -1291, -1291,
    1702    11124,   240, -1291,   900, -1291, -1291,  4527, -1291, -1291,  1387,
    1703    11181, -1291, 11181,  4527,   239, 10399,  1401, -1291,  9868,  5469,
    1704    -1291,  1405, -1291, -1291, 11181,  1402,  1412, -1291, 11409, 11409,
    1705    -1291, -1291,   990,   130, -1291, -1291,  1404, -1291,   990, -1291,
    1706    -1291,  1855,   778,   239, 10399, -1291,  9927,  1424, -1291, -1291,
    1707    -1291, -1291, -1291, 11044,  1419,   990,  7686, 11181, 10964,  1422,
    1708      990,  1431,  1855,  2409, -1291, -1291, -1291, -1291, -1291, -1291,
    1709     8846, -1291, 10846, -1291, 11044, -1291, -1291,  1410, 10765, -1291,
    1710    -1291, 10964,   239,  2409,  1440,   850, -1291, 10846, -1291, -1291,
    1711    -1291, 10765, -1291, -1291,   239, -1291, -1291, -1291, -1291, -1291
     1558    6112, 10121, -1306,    45, -1306, -1306, -1306, -1306, -1306, -1306,
     1559   -1306,    27, -1306, -1306, -1306, -1306, -1306, -1306, -1306, -1306,
     1560   -1306, -1306, -1306, -1306, -1306,    94,    94,    94,   808,   829,
     1561      69,  7553,   431, -1306, -1306, -1306, -1306, -1306,   134, -1306,
     1562   -1306, -1306,  1527, -1306,  4935, -1306, -1306, -1306, -1306, -1306,
     1563   -1306,    26,   185, -1306,  1590, -1306, -1306, -1306, -1306,   194,
     1564     544,   310,   103,  4656, -1306, -1306,  9491,  1148, -1306, -1306,
     1565   -1306,   779,   321,  3969,   180,  1184,   779,  1266, -1306, -1306,
     1566     614,   276, -1306,   779,  1398,   228, -1306,   350,   396, -1306,
     1567   -1306, -1306, -1306,   244,   185,    94, -1306,    94, -1306, -1306,
     1568   -1306, -1306, 10357,  1590, -1306, -1306,  1590, -1306, 10416,   306,
     1569   -1306, -1306,   946, 10475, -1306,   431,   431,   431, -1306, -1306,
     1570   -1306,    94, -1306, -1306, -1306,   360,   406,   415, -1306, -1306,
     1571   -1306,   427, -1306, -1306, -1306, -1306, -1306,   436,   460, -1306,
     1572     463,   431,  8930,  3037,   712,   484,   502,   510,   513,   524,
     1573     541,  6995, -1306,   566, -1306,  9560, -1306, -1306, -1306, -1306,
     1574     571, -1306,   234,  4195, -1306,   344,   251, -1306, -1306, -1306,
     1575   -1306,   601,   345,   349,   389,    94,   611, -1306,   544,  2525,
     1576     633, -1306,   129, -1306,    94,    94,   185, -1306, -1306,   222,
     1577   -1306,    94,    94,  2900,   637,   644,   431, 11276, -1306, -1306,
     1578     661, -1306,  4935, -1306, -1306,   779, -1306, -1306,   185, -1306,
     1579    1590,    26, -1306,  7796, -1306,   431,   431,   431,   185, -1306,
     1580     808, -1306,  6454, -1306, -1306,   657,   431, -1306,   431, -1306,
     1581   -1306, 10180,   647,   829,   671,   431, -1306,   808,   669,   673,
     1582   -1306,  7553,   752, -1306, -1306, -1306,  9361, -1306, -1306,  5911,
     1583   -1306,   633,   191, 10475,  5789,   946,  2900, -1306,   291, -1306,
     1584   -1306, 10416,  1590,   704,  2725, -1306, -1306,   255, -1306, 11839,
     1585   11556, 11613, 11556, 11670, -1306,   734, -1306, -1306, -1306, -1306,
     1586   11727, 11727,   752,  8612, -1306, 11556,  9036, -1306, -1306, -1306,
     1587   -1306, -1306, -1306,   770, -1306,   468,  1857, 11556, -1306,   446,
     1588     717,   853,   280,   793,   751,   737,   733,   795,   166, -1306,
     1589   -1306,   778,   551, -1306,   298, -1306, -1306,  3037, -1306, -1306,
     1590     401,   802, -1306,   490,   802, -1306,  8718,   811, -1306, -1306,
     1591    1169,   608,  8252, 11276,   779, -1306,   779,   431,   431, -1306,
     1592   -1306, -1306, -1306, -1306, -1306,   431, 10534,  1590, -1306, -1306,
     1593   10593,  1775, -1306,  6995, -1306, -1306, -1306, -1306, -1306, -1306,
     1594   -1306, -1306,  4717, 11556, -1306, -1306, -1306, -1306, -1306, -1306,
     1595   -1306, -1306, -1306, -1306, -1306, -1306, -1306,   946, -1306,   807,
     1596     826,   840,   846,   849,   855,   868,   875,  2525, -1306, -1306,
     1597     820,    26, -1306, -1306, -1306,   881, -1306, -1306, -1306,  9361,
     1598   -1306, -1306, -1306, -1306, -1306,  2900, -1306,  8930,  8930, -1306,
     1599     946, 12073,  8930,  7904, -1306, -1306, -1306, -1306,  9361,   191,
     1600   -1306, -1306,   779,   185, -1306, -1306,  9361, -1306,  6576, -1306,
     1601   -1306,   431,   431,  8506, 10652, -1306,  1231,  3253, -1306,   400,
     1602     418,   829, -1306, 10180,   884,   864,   829,   431, -1306, -1306,
     1603   -1306, -1306, 11012, -1306,   521,  8172, -1306,   185,   891, -1306,
     1604     946, 11914,  5969, -1306, -1306, -1306, -1306,   916,  2900, -1306,
     1605    8317,   633,  7444, -1306, -1306, -1306,  1642,   538,   778,   829,
     1606    2725,   700, 10416, -1306,  2725, -1306, -1306, -1306, -1306,   572,
     1607   -1306,   901, -1306, -1306,   122,  8612, -1306, -1306,  8612, -1306,
     1608    8824,  8612, -1306, -1306, -1306, -1306, -1306,   581,   912,   557,
     1609     918, -1306,  6659, -1306, -1306, -1306,   100, -1306, -1306,  6125,
     1610   -1306,   113, -1306, -1306, -1306, -1306, -1306, -1306, -1306, -1306,
     1611   -1306, -1306,  5789,  5789, -1306, 11556, 11556, 11556, 11556, 11556,
     1612   11556, 11556, 11556, 11556, 11556, 11556, 11556, 11556, 11556, 11556,
     1613   11556, 11556, 11556,  4485,  5789, -1306,   551,   858, -1306, -1306,
     1614      94,    94, -1306, -1306,  8930, -1306, -1306, -1306,   881,   752,
     1615   -1306,   881,  6659, -1306,  9142,   924, -1306, 10711, -1306, -1306,
     1616     571, -1306,  9696,   928, -1306,  1037, -1306,  2282,   292,   778,
     1617   -1306,    94,    94,   778,   300, -1306,    94,    94,   881, -1306,
     1618   -1306,    94,    94, -1306,   802, 10770,  1590, 12045,   172,   352,
     1619   10770, -1306, 10947, -1306,   778, -1306, 10534, -1306,   171,   931,
     1620    7969,  7969,  1590,  4778,   929, -1306,   372,   935, -1306,   956,
     1621    4195,   607, -1306,  1042,  1590,  7969,   752,   946,   752,   633,
     1622     763,   802, -1306, -1306,   797,   802, -1306, -1306, -1306,   997,
     1623   -1306, 11499,   185, 11012, -1306,   589,   976,   605,   984, -1306,
     1624     626, -1306,   986,   185, -1306, -1306,  9361,   185,  1612,   980,
     1625     983,   435,   443,  7107,  1354, 11556,  2791, -1306, -1306,   987,
     1626      87,   987, -1306, -1306, -1306,    94,    94, -1306, -1306,   829,
     1627   -1306,    94, -1306, -1306,  9764,   829,   996, 11556, -1306,   884,
     1628   12045, -1306, -1306,  1003, -1306, -1306, -1306,   752, -1306, 11980,
     1629   11556, -1306,  7969,   585,  8252, -1306, -1306,   571,  1001,  1002,
     1630    1642,  3314, -1306, -1306,  2725, -1306, -1306,   980, -1306, -1306,
     1631    1010, -1306,   980,  1013, 11839,  5789,   992,  1044,  1018,  1019,
     1632   -1306,  1015,  1025, -1306,  1026,  1027,  6771, -1306,  5789, -1306,
     1633     557,   926, -1306,  5040,  5789,  1029,  1022, -1306, -1306, -1306,
     1634     629, -1306,  5789, -1306, -1306, -1306, -1306, -1306, -1306, -1306,
     1635     446,   446,   717,   717,   853,   853,   853,   853,   280,   280,
     1636     793,   751,   737,   733,   795, 11556,   886, -1306, 11012,  1032,
     1637    1034,  1035,   858, -1306, -1306, -1306, -1306, -1306, 11012, 11499,
     1638     653,  1038,  7219,  9248,  6995, -1306, -1306,  1030,  1043, -1306,
     1639   10357, -1306, -1306,  1037, 11012,   923,  1045,  1048,  1049,  1056,
     1640    1057,  1058,  1060,  3551,  2282, -1306, -1306, -1306, -1306, -1306,
     1641   -1306, -1306, -1306, -1306, -1306, -1306, -1306, -1306, -1306, -1306,
     1642   -1306, -1306,   881, -1306, -1306, -1306,   778, -1306, -1306, -1306,
     1643   -1306, -1306, -1306, -1306, -1306, 10239, -1306, -1306,  1061,  1062,
     1644   -1306,    26,  1041,  1022,  4778, -1306, -1306, -1306,  4717,  1039,
     1645   -1306, -1306, -1306, -1306,   829,  6270,  1111, -1306, -1306, -1306,
     1646   -1306,  1047,    26, -1306, -1306,   881, -1306, -1306,   881,   347,
     1647   11556,  1063, -1306, -1306, -1306, -1306, -1306, -1306, -1306,  6995,
     1648     899, -1306,   185, -1306,  1612,  2196,  1070,  1074, -1306, -1306,
     1649   -1306,  1077,   953,  1076,  1086,  1087, -1306,  2791, -1306, -1306,
     1650   -1306, -1306, -1306, -1306, -1306,  1231, -1306,   864, -1306, -1306,
     1651    1083,  1089,  1084, -1306, -1306,  1095,  1107, -1306,   585,  1172,
     1652   -1306,   375, -1306,  3314,   778, -1306,  1091,  2725, 10829,  8930,
     1653    1114, -1306, -1306,  1109,  1116, -1306,  1118,   295,  1112, -1306,
     1654    1117,  1117,  6659,  5789, -1306, -1306,  1117,  1120, -1306,   926,
     1655    4717, -1306, -1306, -1306, -1306,  1119,  5240,  5789,  1121,   752,
     1656    4778, -1306,  6125, -1306,   752, -1306,  5789, -1306,   828,   802,
     1657   -1306, -1306, -1306, -1306,  9389, -1306,  8718, -1306, -1306,  7331,
     1658    1127, -1306, -1306, -1306, -1306,  1131, -1306,   852,   802, -1306,
     1659     870,   879,   802, -1306,   431,  1135,  5490, -1306, -1306, -1306,
     1660   11012, 11012, -1306,  8382,  8382,  7969,  1133,  1132,  1134,  1139,
     1661   -1306, -1306,  1144,   596,    62,  1022, -1306,   752, -1306,  4195,
     1662   -1306,  5789,   458, -1306,  6547,  1149,  1151, 11442,  1152,  1153,
     1663      52,    75,    37,  5789,  1158,   185,  4069, -1306,  1113,  1138,
     1664   -1306, -1306, -1306,  1156, -1306, -1306, -1306, -1306, -1306, -1306,
     1665   -1306, -1306, -1306,   829,  1162,  5789, -1306, 11012, 11012,    94,
     1666     802,  1164,  1163,  1030, -1306,  2196,   819,   829,  6659, 10888,
     1667     887,   802, -1306, -1306, -1306, -1306, -1306, -1306, -1306, -1306,
     1668   -1306,  1179,  1172, -1306, -1306,  1165, -1306,   980, -1306, -1306,
     1669     946,  1167, -1306, -1306, -1306,   662,  1183, -1306, 11556,  1161,
     1670    1044,  1044,  1182, -1306,  9823,   956,  5789,  1189,  1119,   540,
     1671      74,  1186, -1306,  1182, -1306,  1191,  1186, -1306, -1306,  1195,
     1672   -1306, -1306,   881,  1197, -1306, 10534, -1306,  6883,  1198,  1200,
     1673    1205, -1306, 10298,  7969,  7969, -1306,  1208, -1306, -1306,   881,
     1674   -1306, -1306, -1306, -1306,   881,  5789, -1306,  5789, 11556,  1209,
     1675   -1306, -1306, -1306, -1306, -1306, -1306, -1306,  1213, -1306, -1306,
     1676   -1306, -1306, -1306, 11556, 11556,  1212,  1214,  1186, -1306, -1306,
     1677     829, -1306, -1306, -1306,  3779, 10829,  5789,  5789,  1272,  5789,
     1678   -1306, -1306,  1203, -1306,  1204,  5789,  1206,  1207,  5789,  1006,
     1679   -1306,  1215,  6659,    94, -1306, -1306,  6270,  1222,   477, -1306,
     1680   -1306, -1306, -1306, -1306,   881, -1306,  9628,  8930, 10180,  1216,
     1681   -1306,  1229, -1306, -1306,   881, 11248, -1306,  8317,  1217, -1306,
     1682   -1306, 10829,   486,   495, -1306,  1230,  1245, -1306,   308, -1306,
     1683    5789,  1244,  1242, -1306, -1306,  1248,   136,   146,   752,  1251,
     1684    1254, -1306,  1256, -1306, 11012, -1306, -1306, -1306, -1306, -1306,
     1685   -1306,  1257, -1306, -1306, -1306, 11012, 11012, 11012, -1306, -1306,
     1686    1260, -1306,  1264,  1267,  1268,   646, -1306,  8036,  8144, -1306,
     1687   -1306,   715, -1306,  1270,  1273, -1306,  8447,   690,   721,  1275,
     1688     725,  6425, -1306, -1306,   508, -1306, -1306,   730,  1277,   185,
     1689    1316,  1326, -1306, -1306,  1278, 11442, -1306, -1306, -1306,  1279,
     1690    1282,   740,  9885, 10180,  5774, 11012, -1306, -1306, -1306,  1281,
     1691   -1306, -1306, -1306, -1306, -1306, -1306, 10829, -1306,  1261,  1315,
     1692    1119,   357, -1306, -1306, -1306, -1306, -1306, -1306, -1306, -1306,
     1693    1283, -1306, -1306, -1306,  1289,  1293, -1306, -1306, -1306,  1295,
     1694    1296, -1306, -1306, -1306, -1306, -1306, -1306, -1306,  1302, -1306,
     1695    1301, -1306, -1306, 11442,   130,  5789, 11442, -1306,  1304,  5789,
     1696   -1306,   155,  1328, -1306, -1306,  1314,  9458, -1306, -1306, -1306,
     1697     320, -1306,  9944, -1306, -1306,  1590,   946,  1311, -1306, -1306,
     1698     742,  1320,  5789,   752,   752,  1325, -1306, -1306,  1330,  1331,
     1699    1334, -1306, -1306,  8382,  1329, -1306,  1401, 11556,  1333, -1306,
     1700   -1306, 11362, -1306,   745, -1306,  1319, 11442,  1324, -1306, -1306,
     1701    1336, -1306,  1355, 10180,  1343, -1306,  1352, 10829, -1306, -1306,
     1702   -1306,  1332,  1387,  1358, -1306,  1186,  1186, -1306, -1306, -1306,
     1703   -1306, -1306, 11442,   118, -1306,   954, -1306, -1306,  7662, -1306,
     1704   -1306,  1339,  5789, -1306,  5789,  7662,   185, 10652,  1362, -1306,
     1705   10003, 10180, -1306,  1364, -1306, -1306,  5789,  1365,  1370, -1306,
     1706   11556, 11556, -1306, -1306,  1024,   101, -1306, -1306,  1356, -1306,
     1707    1024, -1306, -1306,  1567,   752,   185, 10652, -1306, 10062,  1375,
     1708   -1306, -1306, -1306, -1306, -1306, 11362,  1372,  1024,  7731,  5789,
     1709   11282,  1377,  1024,  1380,  1567,  2919, -1306, -1306, -1306, -1306,
     1710   -1306, -1306,  8930, -1306, 11127, -1306, 11362, -1306, -1306,  1361,
     1711   11046, -1306, -1306, 11282,   185,  2919,  1385,   747, -1306, 11127,
     1712   -1306, -1306, -1306, 11046, -1306, -1306,   185, -1306, -1306, -1306,
     1713   -1306, -1306
    17121714};
    17131715
     
    17151717static const yytype_int16 yypgoto[] =
    17161718{
    1717    -1291,  4245,  3306, -1291,  1116, -1291,    -1,     2,   896, -1291,
    1718    -1291, -1291,  -495,  -897,  -137,  5431, -1291,   913,   541,   551,
    1719      480,   578,  1002,  1004,  1001,  1005,  1006, -1291,    40,  -196,
    1720     5036,   426,  -670,  -935, -1291,   410,  -536,   405, -1291,   215,
    1721    -1291,   338, -1139, -1291, -1291,    76, -1291, -1286,  -974,   178,
    1722    -1291, -1291, -1291, -1291,    21, -1264, -1291, -1291, -1291, -1291,
    1723    -1291, -1291,   251,    72,    70,   452, -1291,   461, -1291,   108,
    1724    -1291,  -221, -1291, -1291, -1291,   510,  -756, -1291, -1291,     0,
    1725     -911,   123,  2941, -1291, -1291, -1291,    -4, -1291,   104,   656,
    1726      -23,  1441,  3190, -1291, -1291,    57,    83,   545,  -242,  1645,
    1727    -1291,  1583, -1291, -1291,   105,  2213, -1291,  2417,   430, -1291,
    1728    -1291,  -424,  -392,  1159,  1162,   665,   908,   386, -1291, -1291,
    1729     1151,   667,  -582, -1291,  -560,   393,  -622, -1291, -1291,  -913,
    1730     -944,  -339,   625,  1039,    -8, -1291,   220,   304,  -284,  -197,
    1731     -141,   644,   727, -1291,   986, -1291,  2799,  -407,   895, -1291,
    1732    -1291,   677, -1291,  -399, -1291,   -84, -1291, -1291, -1291, -1255,
    1733      388, -1291, -1291, -1291,  1154, -1291,    85, -1291, -1291,  -787,
    1734     -102, -1290,   -38,  1983, -1291,  2958, -1291,   894, -1291,  -164,
    1735      127,  -169,  -166,  -161,     4,   -37,   -35,   -34,   791,    51,
    1736       55,    59,  -101,  -155,  -153,  -140,  -138,  -299,  -486,  -465,
    1737     -454,  -533, -1291,  -528, -1291, -1291,  -539,  -526,  -507,  -477,
    1738     1502,  4608,  -529,  -535,  -530,  -514,  -525, -1291,  -360,  -646,
    1739     -641,  -638,  -576,  -285,  -303, -1291, -1291,  1288,    18,   -86,
    1740    -1291,   339,   120,  -577,  -382
     1719   -1306,  4178,  3354, -1306,  1595, -1306,    -1,     2,   839, -1306,
     1720   -1306, -1306,  -497,  -915,  -215,  4919, -1306,   975,   537,   542,
     1721     346,   554,   941,   943,   950,   945,   949, -1306,    17,  -251,
     1722    5020,   377,  -700,  -894, -1306,  -198,  -684,  -459, -1306,    77,
     1723   -1306,   290, -1062, -1306, -1306,    40, -1306, -1305, -1076,   127,
     1724   -1306, -1306, -1306, -1306,   -21, -1283, -1306, -1306, -1306, -1306,
     1725   -1306, -1306,   216,    31,    14,   408, -1306,   414, -1306,    76,
     1726   -1306,  -305, -1306, -1306, -1306,   467,  -851, -1306, -1306,     8,
     1727    -929,    10,  2660, -1306, -1306, -1306,  -110, -1306,   299,   597,
     1728     -29,  1428,  4046, -1306, -1306,    55,    49,    79,  -229,  1809,
     1729   -1306,  1752, -1306, -1306,    66,  2021, -1306,  2437,  1677, -1306,
     1730   -1306,  -412,  -376,  1122,  1124,   625,   871,  -270, -1306, -1306,
     1731    1105,   627,  -558, -1306,  -460,  -395,    48, -1306, -1306,  -855,
     1732    -990,   470,   652,   990,   -16, -1306,   727,    -5,  -244,  -195,
     1733    -127,   583,   692, -1306,   930, -1306,  2734,  -373,   841, -1306,
     1734   -1306,   619, -1306,  -405, -1306,    85, -1306, -1306, -1306, -1245,
     1735     327, -1306, -1306, -1306,  1097, -1306,    28, -1306, -1306,  -832,
     1736    -104, -1279,  -133,  2533, -1306,  3317, -1306,   836, -1306,  -122,
     1737    1439,  -163,  -160,  -157,     4,   -41,   -37,   -36,   587,    42,
     1738      51,    90,  -121,  -155,  -152,  -151,  -149,  -294,  -486,  -446,
     1739    -427,  -545, -1306,  -531, -1306, -1306,  -525,  -485,  -484,  -477,
     1740    1927,  4727,  -549,  -504,  -503,  -475,  -461, -1306,  -386,  -662,
     1741    -654,  -649,  -575,  -248,  -333, -1306, -1306,   226,   125,   -50,
     1742   -1306,   339,   169,  -590,  -241
    17411743};
    17421744
     
    17441746   positive, shift that token.  If negative, reduce the rule which
    17451747   number is the opposite.  If YYTABLE_NINF, syntax error.  */
    1746 #define YYTABLE_NINF -505
     1748#define YYTABLE_NINF -507
    17471749static const yytype_int16 yytable[] =
    17481750{
    1749      107,   108,    44,   143,    92,   144,   145,   378,   255,   138,
    1750      379,   658,   418,   386,   248,   380,   791,   692,   101,   101,
    1751      363,   381,   759,   382,   667,   484,   911,   842,   787,   891,
    1752      587,   912,   668,    44,   913,    92,   383,   858,   384,   577,
    1753     1126,   611,    44,   686,    44,   615,   154,   788,   818,   101,
    1754      867,   876,   824,   819,    44,   817,   825,    64,   856,   856,
    1755       44,   828,   184,    44,   209,   206,    44,   835,   216,   820,
    1756       45,   725,   492,   856,   681,   730,   387,   789,  1174,  1395,
    1757       30,   970,   101,    65,   378,  1134,  1070,   379,    64,   404,
    1758      386,   146,   380,   249,   723,   147,   250,   814,   381,   148,
    1759      382,    45,   911,    44,    58,    72,    44,   912,  1172,  1173,
    1760      913,   702,    44,   383,    65,   384,   137,  1069,   815,   105,
    1761      928,   654,   656,    51,   109,  1454,   192,    91,   935,   816,
    1762      105,  1191,   550,  1458,   425,    58,    72,   116,  1185,   143,
    1763      389,   144,   145,    44,   203,   154,   390,   750,   240,   316,
    1764      856,   446,    30,   387,    51,    44,   105,   353,    91,    30,
    1765     1415,  1416,   159,   105,   985,  1203,   551,   142,   755,    91,
    1766      193,   407,  -218,  -218,   990,   720,   650,   105,    44,    44,
    1767     1471,   154,    30,   714,   201,   180,   161,   210,    91,  1454,
    1768     1004,    91,   648,    44,   761,   661,   729,   952,   388,  -109,
    1769      417,  1342,    44,   665,   154,   829,  1400,   105,    30,   832,
    1770       44,   461,   463,    44,   742,   421,   143,  1458,   144,   145,
    1771     -109,   645,  1458,   240,  1417,   390,   159,   146,  1415,  1416,
    1772      849,   147,   814,   105,   852,   148,  1199,  -218,  1458,   451,
    1773      457,    44,   462,    92,  1529,  1458,   398,   117,   390,   135,
    1774      513,   989,   469,   815,   734,    44,    44,   101,   154,   486,
    1775      314,   735,    44,   462,   816,   165,  1201,  1542,    91,    44,
    1776      677,  1344,   467,   637,   390,  1117,   818,  1077,   795,   502,
    1777       91,   819,  1118,  1003,   646,   552,  1190,   577,   828,  1016,
    1778       30,  1174,  1426,  1017,   420,    30,    64,   820,   230,   232,
    1779      686,   652,   645,   377,   180,  1254,   657,   241,   491,    45,
    1780     1181,   851,   702,  1338,  1136,   536,   537,    44,   577,   353,
    1781      414,  1336,    65,   577,   449,   814,   136,    91,  1337,  1478,
    1782       44,    44,  1255,   679,   419,   140,  1182,   612,    91,   104,
    1783      104,   616,  1174,    58,    72,   163,   815,    44,   458,    72,
    1784      105,    44,   133,   134,   826,  1182,   584,   816,   357,   833,
    1785      173,   584,    51,   191,   791,   646,    91,   720,   366,  1528,
    1786      104,    34,  1172,  1173,   358,    37,   787,    44,   369,   414,
    1787      465,   158,    38,    39,   367,  1537,   714,    44,  1191,   353,
    1788      235,   231,  1541,   457,   370,   788,  1169,  1170,   371,   396,
    1789      208,   818,  -275,   104,   159,    44,   819,   811,   825,   584,
    1790       44,   845,   457,   203,   372,   846,   814,   585,   842,   373,
    1791      457,   415,   820,   687,   689,   789,   105,  1070,   133,   134,
    1792      105,   423,   133,   134,   847,   374,    44,   815,   848,   688,
    1793      690,  1175,    91,   900,   579,   158,   240,   702,   816,   687,
    1794      260,   443,   107,  1219,  1220,   561,   586,   702,  1069,   714,
    1795       44,   562,  1020,   856,   863,   906,   228,  1174,    44,   238,
    1796      353,   229,    44,   702,    92,   533,    44,   914,   847,   158,
    1797      534,   535,  1101,  1159,  1161,  1132,  -500,   868,   101,   704,
    1798      484,   205,   355,   689,   809,   705,   506,   739,  1449,   927,
    1799      252,   458,    72,   378,  1443,  1444,   379,   -10,  1503,   907,
    1800      386,   380,   180,   756,  1508,  1205,   739,   381,   762,   382,
    1801      458,    72,   479,  1015,   480,   314,   314,    64,   458,    72,
    1802      314,  1524,   383,   878,   384,   563,  1531,   390,  1105,   158,
    1803       45,   205,   203,  1377,   989,  1191,  1250,   554,  1113,   390,
    1804      208,   314,  1191,    65,  -102,  1091,  -427,   555,  -102,  -428,
    1805     1102,   678,   105,   681,   133,   134,   451,   264,   440,  1270,
    1806     1271,  1017,   711,   387,    58,    72,   266,    34,   104,  1081,
    1807      625,    37,    44,   205,   748,    44,   390,    44,    38,    39,
    1808      355,   856,   856,    51,   749,  1191,   844,    91,   158,   880,
    1809      314,   586,   105,  1431,   133,   134,    44,  1091,   317,  1188,
    1810      219,  1363,   859,   318,   220,  1364,   267,   224,   314,   226,
    1811      440,  -276,    44,   158,   875,  1189,   233,   801,     8,     9,
    1812       10,    11,    12,   877,    44,   879,   663,    44,   726,   268,
    1813     1350,   205,  1015,   727,     2,   196,     4,     5,     6,     7,
    1814     1188,  1354,  1355,  1356,   319,    30,  1329,   110,   320,   691,
    1815      457,   321,  1028,   578,   443,  -109,  1316,  -109,    44,   604,
    1816      706,  -109,  1330,   567,    44,   390,    44,   205,    33,   702,
    1817      702,   205,   314,  1074,   538,   539,  -109,  -109,   420,  1144,
    1818     1331,   505,   579,   322,   540,   541,   721,   724,   152,   728,
    1819     1484,  1391,   722,   932,   931,   352,  1332,  1484,   506,   577,
    1820      813,   506,   586,   491,   506,   356,   105,   746,   133,   134,
    1821       44,    44,  1002,   843,   486,  1036,   731,   364,   579,   542,
    1822      543,  -277,   732,  1378,    44,   491,   702,   702,     8,     9,
    1823       10,    11,    12,    34,   158,   158,   368,    37,   219,   158,
    1824     1525,   645,  1225,   376,    38,    39,   246,  1226,   388,   677,
    1825      205,   405,   152,  1375,    -3,    30,   745,   809,   458,    72,
    1826      158,   440,   746,   406,   440,   711,   936,   410,   584,    40,
    1827      440,   203,   544,   545,  1015,   869,   937,   624,    33,   141,
    1828      428,   870,  -452,   586,  -452,   203,   310,   736,  -452,   910,
    1829      737,   678,  1320,   743,   892,   441,   881,   715,   390,   104,
    1830      746,   458,    72,    44,   646,   653,   655,    34,   884,   158,
    1831      390,    37,   679,   983,    44,   894,  1319,   444,    38,    39,
    1832      447,   746,   440,   155,   448,   440,   896,   158,   440,   205,
    1833     1265,  1425,   562,   105,   864,   813,   586,  1144,   711,   185,
    1834      470,   408,   207,   718,   498,   217,   412,   513,   979,   801,
    1835      714,   713,   991,   719,   980,   890,   911,  1242,   705,  1371,
    1836      546,   912,  1056,   562,   913,   746,   899,   219,  1372,   224,
    1837      901,  1374,   547,   203,   746,   434,  1379,   746,   809,   205,
    1838      548,   101,   746,  1138,  1325,   390,  1186,  1390,   746,   984,
    1839       44,   158,  1031,   505,    44,    44,   505,   922,   549,   505,
    1840     1388,   578,   552,   925,   804,   412,   562,    44,   474,   565,
    1841     1244,  1144,   580,   702,  1486,    44,  1487,  1439,   686,  1155,
    1842       64,   390,   155,  1440,   702,   702,   702,   507,   813,  1459,
    1843      152,   638,   578,    44,   354,   746,  1106,   578,   639,   586,
    1844      714,    34,  1545,   175,   801,    37,    65,   105,   562,   133,
    1845      134,   784,    38,    39,   101,   219,   640,  1158,   155,   584,
    1846      123,  1526,   124,   125,   126,   642,  1128,    58,    72,   739,
    1847      574,  1128,   316,   390,   702,  1287,  1288,   176,  1160,  1163,
    1848      584,   155,  1306,  1307,    44,   643,    51,   177,   686,   644,
    1849      609,   809,   422,   647,   613,   205,  1237,  1468,  1479,  1480,
    1850      715,   857,   857,     2,   196,     4,     5,     6,     7,  1144,
    1851      772,   773,   774,   775,  1135,  1230,   857,   390,   245,   813,
    1852      586,   440,  1415,  1416,  1128,   205,   809,   240,   316,   390,
    1853      205,   218,   678,   693,  1056,  1496,   695,  1200,  1202,  1204,
    1854      678,   938,   398,   641,   390,     8,     9,    10,    11,    12,
    1855      101,   310,   310,   918,   713,   918,   310,   314,   586,  1107,
    1856     -222,   514,   515,   516,   733,   703,   686,   768,   769,  1031,
    1857      420,   747,    30,   715,   751,    44,   625,   666,   434,   770,
    1858      771,   434,  1041,   803,   517,   810,   518,   434,   519,  1193,
    1859      467,   316,   390,   857,   686,    33,   354,   853,   866,   110,
    1860       44,   826,   316,   584,   843,  1082,   -12,  1343,  1345,  1346,
    1861      865,  1535,   776,   777,   872,    65,   277,   893,   205,   895,
    1862      898,  1515,   722,  -401,   474,   926,   310,   713,   474,   604,
    1863      562,  -504,   205,   801,   673,   940,   458,    72,   947,   507,
    1864      949,   954,   507,   953,   310,   507,   491,     8,     9,    10,
    1865       11,    12,   958,   959,   961,    51,   962,   963,   168,   964,
    1866     -278,   975,   974,  1091,   986,   987,   354,     8,     9,    10,
    1867       11,    12,   988,   495,    30,   992,   999,    34,   625,   175,
    1868     1000,    37,  1005,   209,  1006,  1007,   511,   512,    38,    39,
    1869     1008,  1009,  1010,  1011,    30,  -389,  -388,    33,   532,  1029,
    1870      586,   101,   104,  1056,  1038,  1071,  1078,   168,   310,  1451,
    1871      168,   491,   491,   672,  1087,   390,    44,    33,   574,  1073,
    1872      205,   673,   101,   674,  1084,  1085,   807,   512,  1088,  1106,
    1873        8,     9,    10,    11,    12,  1089,  1090,  1094,   554,   711,
    1874      390,  1095,  1104,  1128,  1128,  1128,  1096,   101,   555,   841,
    1875     1097,  1098,  1114,   746,   574,  1115,  1116,    30,  1207,  1119,
    1876      850,    64,   968,  1122,   512,   203,   703,    34,  1058,   175,
    1877     1124,    37,  1501,  1451,  1127,   104,   158,  1150,    38,    39,
    1878       33,  1041,  1437,  1153,  1164,    34,  1176,    65,   809,    37,
    1879     1177,  1178,  1179,  1180,  1227,  1228,    38,    39,  1194,  1195,
    1880     1197,  1198,  1056,   253,  1206,   201,   210,   101,    58,    72,
    1881     1211,  1212,    -3,   254,   168,  1217,  1223,   479,  1234,  1224,
    1882      156,    40,  1297,   578,  1106,  1238,  1315,    51,  1243,   711,
    1883     1245,   141,  1248,   378,  1252,   314,   379,  1256,   434,   386,
    1884     1259,   380,   101,  1261,  1263,  1272,  1193,   381,  1266,   382,
    1885     1267,  1268,  1107,     2,   196,     4,     5,     6,     7,   645,
    1886     1056,  1279,   383,  1056,   384,  1284,   168,   420,   474,  1289,
    1887     1290,   104,    65,   168,  1300,  1436,    44,  1301,  1303,  1514,
    1888     1304,  1321,  1311,  1322,   156,    44,    44,  1327,  1333,  1335,
    1889     1128,  1128,  1339,   458,    72,  1341,  1340,  1347,  1293,  1348,
    1890     1349,   703,   387,  1351,  1171,  1359,   857,   419,  1056,  1360,
    1891     1361,   703,    51,  1056,  1362,  1369,  1307,   205,   313,  1370,
    1892     1373,  1380,   646,  1383,  1392,  1106,  1384,   703,  1386,  1387,
    1893     1396,    61,   111,  1397,   168,  1404,   765,   766,   767,  1056,
    1894     1196,  1400,  1405,   101,  1430,   491,  1409,  1107,    34,  1410,
    1895      582,   168,    37,  -390,  1001,   168,  1413,  1424,  1441,    38,
    1896       39,  1428,    61,   139,   101,   143,  1438,   144,   145,  1445,
    1897     1446,   101,  1447,   153,   715,   512,  1448,  1450,   413,  1364,
    1898     1460,  1516,  1455,    44,   583,  1466,   584,  1462,  1464,  1470,
    1899     1469,  1473,  1056,  1493,   585,   211,  1499,  1056,  1474,   807,
    1900     1472,  1485,  1497,  1193,    44,    44,  1500,   154,   491,   491,
    1901     1193,  1056,  1381,  1056,   101,  1520,  1523,  1056,  1507,  1530,
    1902     1056,   208,   104,  1532,  1538,    44,  1056,   353,   713,    65,
    1903     1056,   247,  1544,   887,   857,   857,    65,   413,   778,   780,
    1904     1251,   779,  1314,   104,   781,  1502,   782,  1427,  1107,  1382,
    1905      458,    72,  1546,  1193,   158,   440,  1518,   458,    72,   509,
    1906     1246,  1488,   156,    34,   715,   166,   167,    37,   104,    51,
    1907     1247,  1216,   315,    70,    38,    39,    51,   919,  1092,    65,
    1908      330,   669,  1093,  1037,   670,   697,     8,     9,    10,    11,
    1909       12,   474,  1108,   310,  1295,  1296,   798,  1298,  1432,   352,
    1910      458,    72,  1123,  1302,    70,   871,  1305,   942,   385,  1058,
    1911     1103,   512,   205,    30,   716,     0,   950,  1328,     0,    51,
    1912      807,     0,   403,   208,     0,   139,   409,     0,   104,   465,
    1913      314,   153,     0,   703,   703,    34,    33,   212,  1142,    37,
    1914      841,    34,     0,   175,     0,    37,    38,    39,     0,   440,
    1915      440,   426,    38,    39,   969,   429,     0,   430,     0,     0,
    1916        0,     0,     0,   104,   445,     0,     0,     0,  1366,  1489,
    1917       61,   902,   392,   390,     0,   459,     0,   176,     0,   400,
    1918        0,   903,     0,   313,   313,   466,   806,   177,   313,     0,
    1919      703,   703,     0,   409,     0,     0,   204,     0,  1517,     0,
    1920        0,    34,     0,   166,   167,    37,   222,     0,  1385,   313,
    1921      168,     0,    38,    39,   205,     0,     0,     0,     0,   440,
    1922        0,     0,   333,     0,     0,     0,   168,     0,     0,     0,
    1923        0,     0,     0,   807,     0,     0,     0,  1543,   168,     0,
    1924        8,     9,    10,    11,    12,     0,   204,     0,   392,  1548,
    1925        0,     0,     0,     0,     0,   575,     0,     0,   313,     0,
    1926      440,     0,   605,     0,   104,     0,  1414,    30,   807,  1422,
    1927        0,   509,     0,  1421,   509,   610,   313,   509,     0,   610,
    1928        0,     0,   330,     0,     0,   104,     0,     0,   204,  1264,
    1929       33,   512,   104,   427,   440,    34,  1142,   440,   440,    37,
    1930        0,     0,   560,     0,     0,     0,    38,    39,     0,     0,
    1931      564,     0,    70,   568,  1457,     0,     0,    70,    34,  1461,
    1932      175,     0,    37,   440,     0,   440,     0,     0,   459,    38,
    1933       39,   902,     0,   390,     0,   104,     0,     0,   168,     0,
    1934      313,   903,   330,     0,     0,  1477,   204,   459,  1326,   158,
    1935        0,     0,     0,     0,   672,   459,   390,     0,     0,     0,
    1936        0,     0,     0,     0,   674,     0,     0,     0,     0,   392,
    1937     1142,   310,   434,   400,     0,     0,     0,   703,     0,     0,
    1938        0,   698,   204,     0,   409,  1108,   204,     0,   703,   703,
    1939      703,     0,     8,     9,    10,    11,    12,   512,     0,   712,
    1940        0,    61,   485,     0,   212,     0,     0,     0,     0,   409,
    1941       34,     0,   175,   409,    37,     0,     0,  1536,     0,    30,
    1942        0,    38,    39,  1536,   333,     0,     8,     9,    10,    11,
    1943       12,     0,  1536,     0,     0,     0,  1536,     0,   703,     0,
    1944        0,   330,    33,     0,     0,   495,  1512,    34,   390,   582,
    1945        0,    37,     0,    30,     0,     0,  1513,   392,    38,    39,
    1946       34,     0,   166,   167,    37,   204,   434,   434,  1142,     0,
    1947       70,    38,    39,     0,     0,     0,    33,     0,     0,     0,
    1948     1108,     0,     0,   583,   333,   584,   790,     0,     0,    70,
    1949        0,     0,     0,   585,     0,     0,   356,    70,   118,   121,
    1950      122,   800,     0,   575,   806,     0,     0,     0,     0,     0,
    1951        0,   247,     0,     0,     0,     0,   822,   748,     0,   390,
    1952        0,     0,     0,   333,     0,     0,     0,   749,     0,     0,
    1953      807,     0,     0,     0,   575,     0,   434,     0,     0,   575,
    1954        0,   333,     0,    70,   204,   610,   560,   560,     0,   330,
    1955      330,     0,     0,     8,     9,    10,    11,    12,     0,     0,
    1956        0,   204,     0,     0,   330,     0,   242,     0,   243,   512,
    1957        0,     0,     0,     0,     0,     0,     0,   434,     0,     0,
    1958       30,  1108,   698,   333,   520,   521,   522,   523,   524,   525,
    1959      526,   527,   528,   529,   204,   459,     0,     0,   806,     0,
    1960        0,     0,   712,    33,     0,   915,     0,     0,    34,     0,
    1961      175,  1491,    37,     0,   434,   434,     0,   530,     0,    38,
    1962       39,     0,     8,     9,    10,    11,    12,     0,     0,     0,
    1963      882,     0,     0,     0,   885,     0,     0,     0,   459,     0,
    1964     1491,   330,   434,   333,   253,     0,   375,     0,     0,    30,
    1965      941,     0,     0,   409,   254,   394,   395,     0,   560,     0,
    1966      399,     0,   401,   402,     0,     0,   310,     0,     0,     0,
    1967      392,     0,    33,     0,     0,   712,     0,    34,     0,   175,
    1968      967,    37,     0,     0,     0,     0,     0,     0,    38,    39,
    1969        0,   333,   333,     0,     0,     0,     0,     0,     0,     0,
    1970        0,     0,     0,    73,     0,     0,   333,     0,     0,     0,
    1971      204,     0,     0,   672,     0,   390,     0,   698,     0,     0,
    1972        0,     0,     0,   674,   333,   313,     0,   698,     0,     0,
    1973        0,     0,   997,   800,    73,     0,     0,    70,     0,   247,
    1974      204,     0,     0,   698,   333,   204,     0,     0,     0,     0,
    1975        0,     0,  1014,     0,     0,     0,     0,     0,     0,     0,
    1976        0,     0,     0,     0,     0,     0,     0,   213,     0,     0,
     1751     109,   145,    46,   140,    94,   146,   147,   660,   257,   110,
     1752      53,   111,   913,   613,    47,   380,   420,   617,   381,   494,
     1753     914,   382,   761,   383,  1071,   915,   384,   385,   670,   386,
     1754     844,   694,   793,    46,  1176,    94,   365,   589,   827,   869,
     1755     486,    53,   826,  1072,    46,    47,    46,   391,   156,    67,
     1756     683,   954,   250,   972,   819,    66,    46,   388,   389,   139,
     1757     669,   688,    46,   860,   186,    46,    74,   208,    46,  1136,
     1758     218,   789,   790,   203,   211,   715,   212,   878,   579,   791,
     1759      67,   820,   821,  1128,   148,   507,    66,   251,   913,   406,
     1760     252,  1397,   380,   149,   652,   381,   914,    74,   382,   816,
     1761     383,   915,   107,   384,   385,    46,   386,   727,    46,   930,
     1762     822,   732,   205,   663,    46,  1193,  1460,   107,   463,   465,
     1763     118,   667,  1187,   752,    30,   103,   103,   830,   119,   167,
     1764     194,    30,   150,   837,   388,   389,   459,   145,  1456,   817,
     1765     107,   146,   147,  -218,  -218,    46,   221,   156,  1205,   163,
     1766     222,  1183,  1256,   226,   937,   228,   103,    46,   818,   355,
     1767     858,   858,   235,   656,   658,   107,    30,   409,  1174,  1175,
     1768     138,   243,  1417,  1418,   195,   858,  1201,  1184,   107,  1257,
     1769      46,    46,   722,   156,     2,   198,     4,     5,     6,     7,
     1770     392,   103,  1473,  1192,   419,    46,   650,  1417,  1418,  1203,
     1771    1460,   107,  1456,   757,    46,  1460,   156,  1480,  -218,   655,
     1772     657,   107,    46,   161,   145,    46,   763,   423,   146,   147,
     1773     148,  1460,   716,   421,   736,   859,   859,  1531,  1460,   149,
     1774     242,   737,   392,  1184,   816,   142,  1419,   725,   731,  1344,
     1775     859,   453,    34,    46,    35,    94,   471,  1176,   390,  1346,
     1776    1544,    53,   858,   488,   552,    47,   744,    46,    46,    30,
     1777     156,  1428,   422,   398,    46,   647,   648,   991,   150,   451,
     1778     158,    46,   464,   639,   817,  1019,   847,   161,   715,  1018,
     1779     848,   504,  1005,   853,   221,   417,  1138,   493,   553,   459,
     1780      67,   165,   464,   818,   554,   425,    66,   507,  1176,    60,
     1781     507,   654,   175,   507,    -3,   427,   659,    74,   459,   820,
     1782     821,   316,    74,   193,   679,   681,   459,   859,   688,    46,
     1783     797,   355,   448,   400,  -275,   392,   579,   816,    30,    30,
     1784      60,   614,    46,    46,   158,   618,   237,    30,   822,   106,
     1785     106,   107,   359,   135,   136,   242,   647,   648,   831,    46,
     1786     240,   715,   834,    46,   830,   786,  1340,   579,   360,   368,
     1787     508,   902,   579,   542,   543,  1071,   103,   817,   315,  1207,
     1788     106,   416,  1193,   851,   722,   369,   481,   854,   482,    46,
     1789     793,   205,   233,   160,  1072,   107,   818,   135,   136,    46,
     1790     827,   355,   469,   828,   392,   586,  -502,  1119,   544,   545,
     1791     563,   835,   210,   586,  1120,   106,   564,    46,  1505,   920,
     1792    1338,   920,    46,   221,  1510,   226,  1060,  1339,   816,   789,
     1793     790,   844,   515,  1176,   916,   716,  1433,   791,   415,   254,
     1794     416,  1526,  1174,  1175,   820,   821,  1533,   107,    46,   135,
     1795     136,     8,     9,    10,    11,    12,   929,   160,  1530,  1079,
     1796    1379,   366,   262,   371,   109,   161,   849,   373,   817,  -109,
     1797     850,   -10,    46,   822,  1539,    74,  1402,  1177,    30,   372,
     1798      46,  1543,   355,   374,    46,   865,    94,   818,    46,   849,
     1799    -109,   160,    53,  1103,    74,  1134,    47,   415,  1445,  1446,
     1800     738,    33,    74,   739,   357,   581,   745,   375,   716,   741,
     1801     665,   221,   565,   870,   392,   486,   882,  -429,   689,   511,
     1802     205,   380,   158,   376,   381,   758,  -430,   382,   741,   383,
     1803     764,    67,   384,   385,   690,   386,   691,    66,   266,  1193,
     1804    1017,  1093,   811,   880,   708,  1252,  1193,   268,    74,   683,
     1805      60,   160,   692,   689,  1115,   460,   516,   517,   518,  1161,
     1806    1163,   691,   210,  1019,   388,   389,   459,   535,  1451,   908,
     1807     991,   269,   536,   537,   270,   858,  1190,   909,   453,   519,
     1808     442,   520,   508,   521,  1107,   508,   316,   316,   508,  1193,
     1809     106,   316,  1191,  1093,    46,  1190,   319,    46,  1198,    46,
     1810     846,   569,   357,   392,  1331,  1272,  1273,   103,   112,   934,
     1811     160,  1318,   316,  1333,   320,  1022,   861,  1486,    46,    36,
     1812    1332,   177,   321,    39,  1486,   322,   748,  1377,   877,  1334,
     1813      40,    41,   442,   706,    46,   160,   323,   803,  1173,   707,
     1814     859,   157,  1380,   315,   315,   879,    46,   881,   315,    46,
     1815     723,   154,  -109,   324,  -109,   178,   724,   187,  -109,  1017,
     1816     209,   316,   556,   219,   392,   179,   422,  1527,   750,   315,
     1817     392,  1146,   557,  -109,  -109,   580,  1030,   354,   751,   316,
     1818      46,   606,   358,    36,   733,   584,    46,    39,    46,   107,
     1819     734,   135,   136,   747,    40,    41,   938,  1076,   586,   748,
     1820     390,   894,   493,   858,   858,  1427,   939,   748,   460,   248,
     1821    -102,   893,   370,  1104,  -102,   154,   933,   896,   315,   585,
     1822     871,   586,   626,   748,   493,   230,   872,   460,   488,   587,
     1823     231,   511,    46,    46,   511,   460,   315,   511,   898,   892,
     1824     157,   981,    74,   316,   564,   378,    46,   982,   407,   312,
     1825     901,  1038,   356,   581,   903,   408,   160,   160,   579,   205,
     1826    1365,   160,   715,   443,  1366,   993,   137,  1060,   859,   859,
     1827    1004,   707,   412,   205,  1244,   107,   157,   135,   136,   713,
     1828     564,    60,   160,   442,   845,    74,   442,   446,  1488,   581,
     1829    1489,   430,   442,     2,   198,     4,     5,     6,     7,   157,
     1830     315,  1017,  1373,   449,   410,   647,   648,   450,   748,   414,
     1831     424,   728,   985,   679,   681,   811,   729,   232,   234,   717,
     1832     472,   106,  1267,   242,   318,    46,  1322,   107,  -454,  1146,
     1833    -454,   160,  1321,  1374,  -454,  1528,    46,  1376,   436,   748,
     1834     538,   539,  1381,   748,   442,   500,   987,   442,   748,   160,
     1835     442,    34,  1390,    35,  1441,   515,   992,  1461,   564,  1547,
     1836    1442,   205,   913,   748,   550,   564,  1387,   549,   414,   803,
     1837     914,   476,  1006,   548,   883,   915,   392,  1246,     8,     9,
     1838      10,    11,    12,   125,  1058,   126,   127,   128,   546,   547,
     1839     509,  1033,   551,   154,   107,    53,   135,   136,   774,   775,
     1840     776,   777,  1368,  1146,   107,    30,   135,   136,   886,   716,
     1841     392,   554,    46,   160,   356,   567,    46,    46,   242,   318,
     1842     392,  1392,  1188,   580,  1416,   582,   806,  1424,    33,    46,
     1843    1227,   649,   704,   576,    67,  1228,   811,    46,   640,  1140,
     1844      66,   392,  1289,  1290,   540,   541,     8,     9,    10,    11,
     1845      12,    74,   641,   611,   580,    46,   688,   615,   642,   580,
     1846     400,   643,   392,  1157,   803,   392,  1108,   644,  1109,   556,
     1847     445,   392,  1459,    30,    36,   460,  1083,  1463,    39,   557,
     1848     645,  1160,   713,   586,   356,    40,    41,   646,  1130,  1084,
     1849    1162,   741,   586,  1130,   247,  1165,    33,   697,  1232,   716,
     1850     392,  1146,   695,  1479,   748,   986,    46,  -222,  1297,  1298,
     1851     103,  1300,   735,  1137,   312,   312,  1239,  1304,   460,   312,
     1852    1307,    36,   717,   177,   749,    39,   688,   469,   318,   392,
     1853     753,  1470,    40,    41,   828,   318,   586,   750,   805,   392,
     1854     668,   436,   812,   442,   436,   855,  1130,   751,   -12,   811,
     1855     436,  1345,  1347,  1348,   867,   713,  1058,   255,   422,  1202,
     1856    1204,  1206,   112,   940,    53,   318,   392,   256,  1033,  1498,
     1857    1308,  1309,  1481,  1482,   868,  1538,  1417,  1418,  1171,  1172,
     1858     874,  1538,   279,   103,   811,   770,   771,   476,   895,   312,
     1859    1538,   476,   772,   773,  1538,   717,   897,    46,   724,   627,
     1860     900,   564,   509,    67,   688,   509,   675,   312,   509,  1195,
     1861     778,   779,    36,   928,   705,  -403,    39,  1517,  -506,   942,
     1862      74,   949,    46,    40,    41,   951,   955,  1537,   316,   956,
     1863     960,   961,   688,   704,   963,  1221,  1222,   964,   965,   966,
     1864     977,  1001,  1209,   976,   988,   493,   989,   990,   813,  1073,
     1865     586,   606,   994,   803,  1002,  1031,  1040,  1007,   587,  1093,
     1866    1008,  1009,     2,   198,     4,     5,     6,     7,  1010,  1011,
     1867    1012,   312,  1013,  -391,  -390,   845,  1453,  1080,   693,   103,
     1868    1075,   576,  1086,   445,    60,   315,  1087,  1423,  1090,   809,
     1869     220,  1089,     8,     9,    10,    11,    12,  -276,  1091,  1092,
     1870    1096,  1097,  1098,  1106,     8,     9,    10,    11,    12,  1099,
     1871     493,   493,   843,   211,   203,   212,   726,   576,   730,    30,
     1872      34,  1100,    35,   852,   106,  1058,  1116,   748,  1117,  1118,
     1873    1121,    30,  1213,   970,  1124,  1129,    53,  1126,    46,  1503,
     1874    1453,  1152,    33,  1155,    36,  1178,   168,   169,    39,  1166,
     1875    1179,  1181,  1180,   205,    33,    40,    41,   497,  1182,  1108,
     1876    1196,  1109,  1197,  1199,  1200,  1130,  1130,  1130,   704,  1208,
     1877     513,   514,  1214,    -3,  1219,    67,  1225,  1226,   704,  -277,
     1878     354,    66,   534,   938,  1240,   586,     8,     9,    10,    11,
     1879      12,  1236,    74,   939,   704,  1247,   481,   106,   160,  1245,
     1880    1250,   436,  1439,  1254,  1258,  1261,    36,  1263,   177,  1265,
     1881      39,   514,  1268,    30,  1269,   705,   421,    40,    41,  1270,
     1882    1274,    53,  1352,  1281,  1058,  1286,  1291,  1299,  1292,  1329,
     1883     103,   476,  1323,  1356,  1357,  1358,    33,  1302,  1303,  1317,
     1884    1305,  1306,   674,  1324,   392,   580,   811,  1335,   514,  1313,
     1885     675,   103,   676,   460,  1108,   422,  1109,  1337,  1341,  1342,
     1886      67,   380,  1343,   866,   381,  1349,  1195,   382,  1350,   383,
     1887    1351,  1353,   384,   385,  1361,   386,   103,    74,  1362,  1363,
     1888    1364,  1309,  1058,  1393,  1371,  1058,  1375,  1372,  1382,  1438,
     1889    1385,  1388,  1386,   106,  1389,  1398,  1383,  1394,    46,  1516,
     1890    1399,  1406,  1402,   388,   389,  1407,   316,    46,    46,  1411,
     1891    1412,  -278,  1130,  1130,  -392,  1415,  1426,  1003,     8,     9,
     1892      10,    11,    12,   647,   648,  1432,   924,  1430,  1440,    36,
     1893    1058,   177,   927,    39,  1443,  1058,   103,  1447,    63,   113,
     1894      40,    41,  1448,  1449,   493,    30,  1450,  1366,  1466,    93,
     1895     705,  1452,  1457,  1462,  1468,  1108,   713,  1109,  1464,  1471,
     1896     705,  1058,   809,   315,  1472,   674,  1474,   392,    33,    63,
     1897     141,   103,  1475,  1487,  1495,   676,   705,  1476,    53,  1501,
     1898      93,  1499,   155,   145,  1502,    53,  1522,   146,   147,  1525,
     1899    1509,   144,  1534,    93,  1532,  1540,   717,  1546,   889,   780,
     1900     704,   704,   781,  1518,   213,    46,   783,   493,   493,   182,
     1901     782,   784,    93,  1253,  1058,    93,  1316,    67,  1429,  1058,
     1902     767,   768,   769,  1195,    67,    60,    46,    46,    53,   156,
     1903    1195,  1504,  1548,  1058,    74,  1058,  1384,  1520,  1248,  1058,
     1904     249,    74,  1058,   210,   106,  1249,   713,    46,  1058,   355,
     1905    1218,  1490,  1058,  1491,   476,  1110,   312,   704,   704,   514,
     1906    1094,   699,   921,  1125,  1095,   106,   671,    67,   672,   800,
     1907    1039,   873,   103,  1195,  1105,   944,   160,   442,  1330,   718,
     1908     952,   317,  1519,   809,    74,     0,   717,     0,     0,   332,
     1909     106,     0,    93,   103,     0,     0,     0,     0,     0,     0,
     1910     103,  1144,    36,   843,    93,   627,    39,     0,     0,     0,
     1911     460,  1043,     0,    40,    41,     0,     0,   387,     0,     0,
     1912       0,  1545,     0,     0,     0,     0,     0,   379,   182,     0,
     1913       0,   405,     0,  1550,   141,   411,     0,     0,    42,     0,
     1914     155,     0,    36,   103,   177,   210,    39,     0,   143,     0,
     1915     106,    93,     0,    40,    41,     0,     0,     0,     0,   170,
     1916     428,     0,    93,     0,   431,    36,   432,   168,   169,    39,
     1917       0,   442,   442,   447,     0,     0,    40,    41,  1514,    63,
     1918     392,     0,   705,   705,   461,   106,     0,    36,  1515,     0,
     1919      93,    39,     0,     0,   468,   514,   809,     0,    40,    41,
     1920       0,   316,   411,  1494,   467,     0,     0,   627,   170,     0,
     1921       0,   170,     0,     0,     0,  1327,     0,    36,     0,     0,
     1922       0,    39,     0,   904,     0,   392,     0,     0,    40,    41,
     1923       0,   809,  1494,   905,     0,     0,     0,     0,   971,   705,
     1924     705,   442,     0,     0,   704,     0,     0,     0,     0,     0,
     1925     207,     0,  1266,   720,     0,   704,   704,   704,   315,  1144,
     1926       0,     0,    72,   721,   577,     0,    93,   460,     0,     0,
     1927       0,   607,     0,     0,   460,     0,     0,     0,     0,     0,
     1928     588,     0,   442,     0,   612,     0,   106,     0,   612,     0,
     1929       0,   332,     0,    72,     0,     0,     0,     0,     0,     0,
     1930     207,     0,     0,     0,     0,   704,     0,   106,     0,     0,
     1931    1043,     0,     0,     0,   106,   170,   442,   460,     0,   442,
     1932     442,     0,     0,  1229,  1230,     0,     0,     0,   214,     0,
     1933       0,     0,     0,  1144,   312,   436,   182,   461,     0,     0,
     1934       0,     0,   207,     0,     0,   442,     0,   442,  1110,     0,
     1935      36,   332,   168,   169,    39,     0,   461,   106,     0,     0,
     1936       0,    40,    41,     0,   461,     0,     0,   170,     0,     0,
     1937       0,   160,     0,     0,   170,   514,     0,     0,     0,     0,
     1938       0,     0,   206,     0,     0,   680,   358,     0,     0,     0,
     1939     700,     0,   224,   411,     0,     0,     0,  1328,     0,     0,
     1940     207,     0,     0,     0,     0,     0,     0,     0,   714,     0,
     1941      63,     0,     0,   335,     0,     0,     0,     0,   411,     0,
     1942       0,    93,   411,     0,     0,   588,   705,  1295,     0,   436,
     1943     436,  1144,   206,     0,     0,   170,   207,   705,   705,   705,
     1944     207,     0,     0,  1110,     0,     0,     0,     0,     0,     0,
     1945     332,     0,   170,     0,     0,     0,   170,   522,   523,   524,
     1946     525,   526,   527,   528,   529,   530,   531,     0,     0,     0,
     1947       0,     0,     0,     0,   206,     0,     0,     0,     0,     0,
     1948       0,   514,     0,     0,   429,     0,     0,   705,     0,     0,
     1949     532,     0,     0,   809,     0,   792,     0,     0,     0,   436,
     1950       0,     0,     0,    72,     0,     0,     0,     0,    72,     0,
     1951     802,     0,   577,     0,     0,     0,     0,     0,     0,   207,
     1952     249,     0,     0,     0,     0,   824,     0,     0,     0,   497,
     1953       0,    75,   206,     0,   815,     0,   588,     0,     0,     0,
     1954     436,     0,     0,   577,  1110,     0,     0,     0,   577,     0,
     1955       0,     0,     0,     0,   612,     0,     0,     0,   332,   332,
     1956       0,     0,    75,     0,     0,     0,     0,     0,   206,     0,
     1957       0,     0,   206,   332,  1493,     0,     0,   436,   436,     0,
     1958       0,     0,     0,     0,     0,     0,     0,     0,   487,     0,
     1959       0,   700,     0,     0,     0,   214,     0,   215,   207,     0,
     1960       0,     0,     0,  1493,   461,   436,     0,     0,     0,     0,
     1961       0,   714,     0,     0,   917,   335,     0,   588,     0,   394,
     1962       0,     0,     0,   912,     0,   680,   402,  1434,     0,   312,
    19771963       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    1978       70,     0,   560,   333,   247,     0,     0,     8,     9,    10,
     1964       0,     0,     0,     0,     0,     0,     0,   461,   207,     0,
     1965     332,   206,     0,   514,     0,     0,     0,     0,     0,   943,
     1966       0,    72,   411,     0,     0,     0,     0,     0,     0,   815,
     1967     588,     0,     0,     0,     0,   335,     0,     0,     0,     0,
     1968      72,     0,   337,     0,   714,     0,     0,   808,    72,   969,
     1969       0,     0,     0,     0,     0,   394,     0,     0,     0,     0,
     1970       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     1971       0,   170,     0,     0,   335,     0,     8,     9,    10,    11,
     1972      12,     0,     0,     0,     0,     0,   700,   170,     0,     0,
     1973     206,     0,   335,     0,    72,     0,   700,     0,     0,   170,
     1974       0,   999,   802,    30,     0,     0,     0,   206,   249,   562,
     1975       0,     0,   700,     0,     0,     0,     0,   566,     0,     0,
     1976     570,  1016,   815,     0,   207,     0,    33,     0,     0,     0,
     1977       0,    36,    75,   588,   335,    39,     0,    75,     0,     0,
     1978     206,     0,    40,    41,     0,     0,     0,     0,     0,     0,
     1979       0,     0,     0,   249,   207,     0,     0,     0,     0,   207,
     1980       0,     0,     8,     9,    10,    11,    12,   904,     0,   392,
     1981       0,     0,     0,    63,     0,     0,   394,   905,     0,     0,
     1982     402,     0,     0,     0,     0,     0,     0,     0,     0,    30,
     1983       0,     0,     0,     0,   335,     0,     0,   802,     0,   170,
     1984       0,     0,     0,  1085,     0,     0,     0,     0,     0,     0,
     1985       0,     0,    33,   815,   588,     0,     0,    36,     0,   584,
     1986       0,    39,     0,     0,   215,     0,   680,     0,    40,    41,
     1987       0,     0,     0,     0,   680,     0,     0,  1102,     0,     0,
     1988       0,     0,   335,   335,   337,   411,   113,   207,     0,     0,
     1989       0,     0,   588,   585,     0,   586,   206,   335,     0,     0,
     1990     332,   207,     0,   587,   394,     0,     0,     0,     0,     0,
     1991       0,     0,     0,     0,   249,   335,     0,     0,     0,     0,
     1992       0,     0,     0,     0,     0,     0,   206,     0,    72,     0,
     1993      75,   206,   612,     0,   577,   335,     0,     0,     0,     0,
     1994       0,     0,     0,     0,   337,     0,     0,    77,     0,    75,
     1995       0,     0,   141,     0,     0,     0,     0,    75,   700,   700,
     1996       0,   332,   332,   332,     0,     0,     0,     0,     0,     0,
     1997       0,    72,     0,     0,   335,     0,     0,     0,    77,     0,
     1998       0,     0,  1194,   337,     0,     0,     0,     0,     0,   207,
     1999       0,     0,     0,   562,   562,     0,     0,     0,     0,     0,
     2000       0,   337,     0,    75,     0,   808,     0,     0,   335,     0,
     2001       0,     0,     0,   216,     0,   700,   700,     0,     0,   206,
     2002       0,     0,     0,     0,     0,     0,   802,   249,     0,     0,
     2003       0,     0,     0,   206,   588,     0,     0,     0,     0,     0,
     2004       0,     0,     0,   337,     0,     8,     9,    10,    11,    12,
     2005     335,     0,     0,   487,     0,     0,     0,     0,     0,     0,
     2006     335,     0,   249,     0,     0,   214,   335,     0,   120,   123,
     2007     124,     0,    30,     0,     0,     0,   335,   884,     0,     0,
     2008       0,   887,     0,   612,     0,   714,     0,     0,     0,     0,
     2009     612,   332,   332,     0,     0,    33,     0,     0,   338,   808,
     2010      36,     0,   177,   337,    39,   562,     0,     0,     0,     0,
     2011       0,    40,    41,     0,     0,     0,     0,   394,     0,     0,
     2012       0,   206,     0,     0,     0,     0,     0,     0,     0,     0,
     2013       0,     0,     0,  1296,     0,     0,   178,    72,   244,     0,
     2014     245,     0,     0,     0,     0,     0,   179,     0,     0,     0,
     2015     332,   337,   337,     0,    63,     0,     0,     0,     0,     0,
     2016       0,   335,     0,     0,   612,     0,   337,     0,     0,     0,
     2017      54,    54,     0,   700,     0,   714,     0,     0,     0,   113,
     2018       0,     0,     0,     0,   337,     0,   207,     0,    77,     0,
     2019       0,     0,     0,    77,     0,     0,     0,    75,     0,     0,
     2020       0,    54,   700,     0,   337,     0,     0,     0,     0,     0,
     2021       0,     0,     0,   700,   700,   700,     0,     0,   377,     0,
     2022       0,     0,     0,     0,   335,   332,   332,   396,   397,   562,
     2023       0,     0,   401,    54,   403,   404,    54,     0,     0,  1194,
     2024      75,     0,     0,   337,    84,     8,     9,    10,    11,    12,
     2025      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     2026      23,    24,   612,   700,    25,    26,    27,   473,   474,   475,
     2027       0,     0,    30,     0,   113,    84,     0,   337,     0,     0,
     2028     216,     0,   335,   335,     0,   335,   335,   335,     0,     0,
     2029       0,     0,     0,     0,     0,    33,     0,     0,     0,     0,
     2030     338,     0,    37,    38,     0,     0,    72,     0,     0,     0,
     2031     217,     8,     9,    10,    11,    12,     0,     0,   206,   337,
     2032       0,   330,     0,     0,   249,     0,     0,     0,     0,   337,
     2033       0,   808,     0,     0,   215,   337,     0,     0,    30,   335,
     2034     335,   562,   562,     0,     0,   337,    77,     0,     0,   394,
     2035     335,   332,     0,     0,     0,     0,     0,     0,     0,     0,
     2036     338,    33,     0,     0,     0,    77,    36,     0,   177,     0,
     2037      39,     0,     0,    77,     0,   113,     0,    40,    41,     0,
     2038       0,   207,     0,    54,     0,     0,     0,     0,     0,     0,
     2039       0,     0,     0,     0,     0,   345,  1194,     0,     0,   338,
     2040       0,     0,   674,  1194,   392,     0,    75,     0,     0,   335,
     2041       0,    54,   676,     0,     0,   335,   335,   338,     0,    77,
     2042       8,     9,    10,    11,    12,  1141,     0,     0,     0,     0,
     2043     337,     0,     0,     0,     0,     0,     0,     0,     0,     8,
     2044       9,    10,    11,    12,  1158,     0,  1194,    30,     0,     0,
     2045       0,     0,     0,  1535,     0,     0,     0,   214,     0,   338,
     2046       0,     0,     0,   467,     0,     0,    30,     0,     0,     0,
     2047      33,     0,     0,     0,   335,    36,     0,   177,    72,    39,
     2048       0,     0,     0,   207,     0,    84,    40,    41,     0,    33,
     2049      84,   808,     0,   337,    36,     0,   177,   335,    39,   335,
     2050     170,     0,     0,     0,     0,    40,    41,     0,     0,     0,
     2051       0,   255,     0,   206,     0,     0,     0,     0,     0,   338,
     2052       0,   256,   562,   330,     0,     0,   335,  1233,     0,     0,
     2053    1514,     0,   392,     0,     0,     0,     0,   335,   335,   335,
     2054    1515,     0,     0,     0,     0,     0,     0,     0,     0,   335,
     2055     335,   337,   337,     0,   337,   337,   337,     8,     9,    10,
     2056      11,    12,     0,    72,     0,     0,     0,   338,   338,     0,
     2057       0,     0,     0,     0,     0,    75,     0,   217,     0,     0,
     2058       0,     0,   338,   330,    30,     0,     0,   335,     0,     0,
     2059       0,     0,     0,     0,     0,     0,     0,   345,     0,     0,
     2060     338,     0,     0,   794,   795,     0,     0,    33,   337,   337,
     2061       0,     0,    36,    77,     0,   206,    39,     0,     0,   337,
     2062     338,     0,     0,    40,    41,     0,     0,     0,     0,     0,
     2063       0,   829,     0,     0,   832,   833,     0,   836,     0,   838,
     2064     839,     0,    54,    84,   840,   841,     0,     0,    42,     0,
     2065       0,     0,     0,     0,     0,     0,    77,   345,   143,   338,
     2066       0,     0,    84,     0,     0,     0,     0,     0,     0,     0,
     2067      84,     0,     0,     0,     0,   335,     0,     0,   337,     0,
     2068       0,     0,   330,     0,   337,   337,     0,     0,     0,     0,
     2069       0,     0,     0,   338,     0,     0,   345,     0,     0,     0,
     2070       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2071       0,     0,     0,     0,   345,     0,    84,     0,     0,     0,
     2072      72,     0,     0,     0,     0,     0,   215,    72,   922,   923,
     2073       0,     0,     0,     0,   925,   338,     0,     0,     0,     0,
     2074       0,     0,   330,   337,     0,   338,     0,    75,     0,     0,
     2075     216,   338,     0,     0,     0,     0,   345,     0,     0,     0,
     2076       0,   338,     0,     0,     0,     0,   337,     0,   337,     0,
     2077      72,     0,     0,     8,     9,    10,    11,    12,    13,    14,
     2078      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2079     330,   330,    25,    26,    27,   337,     0,     0,     0,     0,
     2080      30,   434,     0,     0,     0,   330,   337,   337,   337,     0,
     2081       0,     0,     0,     0,     0,     0,   345,     0,   337,   337,
     2082       0,     0,    77,    33,     0,     0,     0,     0,     0,     0,
     2083      37,    38,    75,     0,     8,     9,    10,    11,    12,     0,
     2084       0,     0,     0,     0,     0,     0,   338,     0,     0,     0,
     2085       0,     0,   122,   122,   122,     0,   337,     0,     0,     0,
     2086       0,    30,     0,     0,   345,   345,   435,     0,     0,     0,
     2087     687,     0,     0,     0,   108,     0,     0,     0,     0,   345,
     2088       0,     0,   330,     0,    33,     0,     0,     0,     0,    36,
     2089       0,     0,     0,    39,     0,     0,     0,   345,     0,     0,
     2090      40,    41,     0,     0,     0,     0,     0,     0,     0,   338,
     2091      84,     0,     0,     0,   162,     0,   166,   345,     0,   172,
     2092     173,   174,   122,   176,   122,   720,     0,     0,     0,     0,
     2093       0,     0,     0,     0,     0,   721,     0,     0,   225,     0,
     2094       0,     0,     0,     0,   337,     0,     0,     0,   265,   238,
     2095     239,     0,     0,    84,     0,     0,   345,     0,     0,     0,
     2096       0,     0,     0,     0,     0,     0,     0,   338,   338,     0,
     2097     338,   338,   338,     0,   330,     0,     0,     0,     0,     0,
     2098       0,     0,     0,     0,     0,     0,     0,     0,     0,    75,
     2099     345,    77,     0,     0,     0,     0,    75,     0,     0,     0,
     2100       0,     0,   122,     0,     0,     0,     0,     0,     0,   122,
     2101       0,   122,   122,     0,     0,   327,   122,     0,   122,   122,
     2102       0,     0,     0,     0,   338,   338,     0,     0,     0,     0,
     2103       0,     0,   345,     0,     0,   338,     0,     0,     0,    75,
     2104       0,     0,   345,     0,     0,    54,     0,   217,   345,     0,
     2105       0,     0,     0,     0,     0,     0,     0,     0,   345,     0,
     2106       0,     0,     0,     0,     0,     0,     0,     0,  1014,   330,
     2107       0,     8,     9,    10,    11,    12,     0,     0,     0,     0,
     2108       0,     0,     0,     0,     0,   122,     0,     0,     0,     0,
     2109       0,     0,     0,     0,   338,     0,     0,   271,    30,   272,
     2110     338,   338,     0,     0,     0,     0,     0,     0,     0,     0,
     2111       0,     0,     0,     0,     0,     0,     0,     0,    54,    84,
     2112     273,    33,  1223,     0,     0,     0,   274,     0,     0,     0,
     2113     275,     0,   330,   276,   277,   278,   279,    40,    41,     0,
     2114     280,   281,   216,   345,     0,     0,     0,     0,   282,     0,
     2115       0,     0,     0,     0,     0,     0,     0,     0,     0,   338,
     2116       0,     0,   283,    77,   361,     0,     0,     0,     0,     0,
     2117       0,   285,   890,   287,   288,   289,   290,     0,     0,     0,
     2118       0,     0,   338,     0,   338,     0,     0,     0,     0,     0,
     2119     575,     0,   583,   330,   330,   330,     0,     0,     0,     0,
     2120       0,     0,     0,   608,   609,     0,   345,     0,     0,     0,
     2121       0,   338,     0,     0,    54,     0,     0,   619,     0,     0,
     2122       0,     0,   338,   338,   338,     0,     0,     0,     0,     0,
     2123       0,     0,     0,     0,   338,   338,     0,     0,     0,     0,
     2124       0,     0,     0,     0,     0,     0,     0,     0,    77,     0,
     2125       0,     0,     0,     0,     0,     0,  1315,     0,   330,     0,
     2126       0,     0,     0,     0,   345,   345,     0,   345,   345,   345,
     2127       0,     0,   338,     0,     0,     0,     0,   662,     0,     0,
     2128       0,     0,     0,     0,     0,     0,     0,     0,    84,     0,
     2129       0,     0,   197,     2,   198,     4,     5,     6,     7,     8,
     2130       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2131      19,    20,    21,    22,    23,    24,     0,     0,    25,    26,
     2132      27,   345,   345,   330,   330,     0,    30,     0,     0,     0,
     2133       0,     0,   345,     0,     0,     0,     0,     0,     0,     0,
     2134       0,     0,     0,     0,     0,     0,     0,     0,     0,    33,
     2135       0,    34,     0,    35,     0,     0,   199,   200,     0,     0,
     2136     338,     0,     0,     0,    54,    54,     0,     0,     0,     0,
     2137       0,     0,     0,     0,     0,     0,   755,     0,     0,     0,
     2138       0,     0,   330,     0,     0,     0,    54,   122,   122,     0,
     2139       0,   345,   201,     0,     0,     0,     0,   345,   345,     0,
     2140     261,     0,     0,     0,     0,    77,     0,     0,     0,     0,
     2141       0,    54,    77,     0,     0,   122,     0,     0,   122,   122,
     2142       0,   122,     0,   122,   122,     0,     0,     0,   122,   122,
     2143       0,     0,     0,     0,     0,     0,   801,     0,     0,   217,
     2144       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2145       0,     0,     0,     0,     0,    77,   345,   330,   330,     0,
     2146      84,     0,     0,     0,     0,     0,    54,     0,     0,     0,
     2147       0,    54,     0,     0,     0,     0,     0,     0,     0,   345,
     2148       0,   345,     0,     0,     0,     0,     0,   862,     0,     8,
     2149       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2150      19,    20,    21,    22,    23,    24,    54,   122,   345,     0,
     2151       0,     0,   122,   122,     0,   891,    30,     0,   122,   345,
     2152     345,   345,     0,     0,     0,     0,     0,     0,     0,     0,
     2153       0,   345,   345,   906,   907,     0,     0,   911,     0,    33,
     2154       0,     0,     0,     0,     0,    84,     0,     0,     0,     0,
     2155       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2156       0,     0,     0,     0,     0,   931,     0,   932,     0,   345,
     2157       0,     0,     0,     0,   935,   936,     0,     0,     0,   941,
     2158       0,     0,     0,   330,     0,     0,     0,     0,     0,     0,
     2159       0,   946,     0,     0,     0,     0,   950,     0,     0,     0,
     2160       0,     0,     0,     0,     0,     0,     0,    54,     0,     0,
     2161     967,     0,     0,     0,     0,   271,     0,   272,     0,   204,
     2162     978,     0,     0,     0,     0,     0,     0,     0,    54,   223,
     2163       0,   227,     0,   229,     0,    54,     0,     0,   273,     0,
     2164     236,     0,     0,     0,   274,     0,     0,     0,   275,     0,
     2165       0,   276,   277,   278,   279,    40,    41,   345,   280,   281,
     2166       0,     0,     0,     0,     0,     0,   282,     0,  1000,   204,
     2167       0,   227,   229,   236,     0,     0,     0,     0,    54,     0,
     2168     283,     0,   361,     0,     0,     0,     0,  1015,     0,   285,
     2169     363,   287,   288,   289,   290,     0,     0,   204,     0,     0,
     2170       0,     0,    84,  1210,     0,     0,     0,     0,     0,    84,
     2171       0,   204,     0,     0,     0,     0,     0,     0,     0,     0,
     2172    1026,     0,  1027,  1028,  1029,     0,     0,  1032,   862,     0,
     2173       0,   151,     0,     0,     0,     0,     0,     0,     0,     0,
     2174       0,   271,  1074,   272,     0,     0,     0,     0,     0,     0,
     2175       0,     0,    84,     0,   575,     0,     0,  1081,     0,     0,
     2176       0,     0,     0,  1082,   273,     0,     0,     0,     0,   204,
     2177     274,   227,   229,   236,   275,     0,   241,   276,   277,   278,
     2178     279,    40,    41,     0,   280,   281,   246,     0,     0,     0,
     2179       0,     0,   282,     0,     0,     0,     0,     0,     0,     0,
     2180       0,  1101,     0,     0,     0,   204,   283,     0,   361,   204,
     2181       0,   362,     0,     0,     0,   285,   363,   287,   288,   289,
     2182     290,     0,     0,     0,     0,   485,   755,     0,     0,     0,
     2183       0,     0,     0,     0,     0,     0,     0,     0,     0,  1127,
     2184     353,     0,     0,     0,   862,     0,     0,  1135,     0,     0,
     2185       0,  1139,     0,   367,     0,     0,  1143,     0,     0,     0,
     2186    1148,  1149,  1150,     0,     0,     0,     0,     0,     0,     0,
     2187    1156,     0,     0,   204,     0,   399,     0,     0,     0,     0,
     2188    1169,     0,     0,     0,     0,     0,     0,     0,   204,   413,
     2189       0,     0,     0,   227,   229,     0,     0,   418,     0,  1185,
     2190    1186,   236,     0,     0,     0,     0,   122,   426,     0,     0,
     2191       0,     0,     0,     0,     0,     0,     0,     0,   433,     0,
     2192       0,     0,     0,     0,  1215,     0,     0,  1217,     0,     0,
     2193     452,     0,     0,     0,     0,   462,     0,     0,     0,     0,
     2194       0,     0,     0,   204,     0,     0,     0,     0,   470,     0,
     2195       0,     0,  1231,     0,   480,     0,   484,     0,     0,     0,
     2196       0,   204,     0,     0,     0,     0,     0,   204,     0,     0,
     2197       0,  1238,   512,     0,     0,     0,     0,  1242,  1243,     0,
     2198       0,     0,     0,     0,   204,     0,  1251,   204,   204,     0,
     2199       0,     0,  1255,     0,     0,  1259,     0,  1260,     0,     0,
     2200    1262,     0,     0,   204,     0,     0,     0,     0,     0,     0,
     2201       0,   862,     0,   572,     0,  1271,     0,   204,     0,     0,
     2202       0,     0,     0,     0,   204,     0,     0,     0,     0,     0,
     2203       0,   271,  1280,   272,  1282,  1283,  1284,  1285,     0,     0,
     2204     122,     0,   620,     0,     0,     0,   621,   622,     0,   623,
     2205       0,  1293,     0,  1294,   273,   633,   634,   166,   635,   636,
     2206     274,   637,     0,   638,   275,     0,     0,   276,   277,   278,
     2207     279,    40,    41,     0,   280,   281,  1314,     0,     0,     0,
     2208     651,     0,   282,     0,     0,  1319,  1320,     0,   653,     0,
     2209       0,     0,     0,     0,     0,     0,   283,     0,   361,     0,
     2210       0,     0,     0,     0,   785,   285,   363,   287,   288,   289,
     2211     290,     0,   666,     0,     0,     0,     0,     0,     0,     0,
     2212       0,     0,     0,   673,     0,     0,     0,     0,     0,     0,
     2213       0,     0,     0,   204,     0,     0,  1354,  1355,     0,     0,
     2214       0,     0,  1359,  1360,     0,     0,   709,     0,     0,     0,
     2215       0,     0,   712,  1370,     0,     0,     0,   452,     0,     0,
     2216       0,     0,     0,   204,     0,     0,     0,     0,   204,   197,
     2217       2,   198,     4,     5,     6,     7,     8,     9,    10,    11,
     2218      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
     2219      22,    23,    24,   746,     0,    25,    26,    27,     0,     0,
     2220       0,     0,     0,    30,  1401,     0,     0,     0,   762,     0,
     2221       0,     0,     0,     0,     0,     0,  1405,     0,     0,     0,
     2222    1408,  1409,  1410,     0,     0,     0,    33,     0,    34,     0,
     2223      35,    36,  1414,   199,   200,    39,     0,     0,     0,     0,
     2224       0,  1425,    40,    41,   788,     0,     0,     0,     0,     0,
     2225       0,     0,     0,   798,     0,   799,   204,  1436,     0,     0,
     2226       0,   804,     0,   271,     0,   272,     0,    42,     0,   201,
     2227     204,     0,     0,     0,   823,     0,     0,   202,     0,     0,
     2228       0,     0,     0,     0,     0,     0,   273,     0,     0,     0,
     2229     485,     0,   624,     0,   135,   136,   275,     0,     0,   276,
     2230     277,   278,   279,    40,    41,     0,   280,   281,     0,  1477,
     2231    1478,     0,     0,   864,   282,     0,     0,     0,     0,     0,
     2232       0,     0,  1483,     0,   271,     0,   272,     0,   283,  1483,
     2233     625,     0,   626,   362,     0,     0,     0,   285,   363,   287,
     2234     288,   289,   290,     0,     0,     0,     0,   273,   204,   899,
     2235       0,     0,     0,   274,     0,     0,  1513,   275,   204,     0,
     2236     276,   277,   278,   279,    40,    41,     0,   280,   281,     0,
     2237       0,     0,     0,     0,     0,   282,     0,     0,     0,     0,
     2238     204,     0,     0,     0,  1536,     0,     0,     0,   346,   283,
     2239       0,   361,     0,     0,     0,     0,   754,     0,   285,   363,
     2240     287,   288,   289,   290,     0,     0,   241,     0,     0,  1549,
     2241       0,     0,     0,     0,  1551,     0,   947,   948,     0,   395,
     2242       0,     0,     0,     0,     0,     0,   395,     0,   962,     0,
     2243       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2244       0,     0,     0,     0,     0,   979,     0,   980,     0,     0,
     2245       0,   984,     0,     0,     0,     8,     9,    10,    11,    12,
     2246      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     2247      23,    24,     0,   204,    25,    26,    27,     0,     0,     0,
     2248       0,     0,    30,     0,     0,     0,     0,     0,     0,     0,
     2249       0,     0,     0,     0,     0,   395,     0,     0,     0,   204,
     2250       0,     0,     0,     0,     0,    33,     0,     0,     0,     0,
     2251      36,     0,    37,    38,    39,     0,  1020,     0,     0,     0,
     2252       0,    40,    41,  1021,     0,   204,     0,     0,     0,     0,
     2253       0,     0,     0,     0,     0,     0,  1023,     0,  1024,     0,
     2254       0,     0,     0,     0,     0,     0,    42,     0,   152,   395,
     2255       0,     0,     0,  1037,     0,   204,    44,   395,   568,  1041,
     2256     395,   571,     0,   346,     0,     0,     0,     0,   598,     0,
     2257       0,  1077,   204,     0,  1078,     0,     0,     0,     0,     0,
     2258       0,     0,     0,     0,     0,     0,   271,   616,   272,     0,
     2259     346,     0,   788,     0,     0,     0,     0,     0,  1088,     0,
     2260       0,     0,     0,     0,     0,     0,     0,     0,     0,   273,
     2261       0,     0,     0,     0,     0,   274,   395,     0,     0,   275,
     2262     395,     0,   276,   277,   278,   279,    40,    41,     0,   280,
     2263     281,     0,     0,     0,     0,     0,     0,   282,     0,     0,
     2264       0,   204,     0,     0,     0,     0,     0,     0,     0,     0,
     2265     346,   283,     0,   361,     0,     0,   970,     0,   204,     0,
     2266     285,   363,   287,   288,   289,   290,     0,     0,     0,     0,
     2267       0,     0,   310,   395,     0,     0,     0,     0,     0,     0,
     2268       0,   328,     0,  1147,     0,     0,     0,     0,     0,  1153,
     2269    1154,     0,     0,   364,     0,     0,     0,     0,     0,   492,
     2270     496,   492,   499,     0,   395,     0,     0,   346,     0,   502,
     2271     503,     0,     0,     0,   492,   492,     0,     0,     0,     0,
     2272       0,     0,     0,     0,     0,     0,   492,     0,     0,     0,
     2273       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2274       0,     0,     0,     0,     0,  1212,   395,     0,     0,   346,
     2275     204,  1216,     0,     0,     0,   492,     0,     0,     0,     0,
     2276       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     2277      18,    19,    20,    21,    22,    23,    24,  -279,     0,    25,
     2278      26,    27,     0,     0,   466,     0,  1235,    30,     0,     0,
     2279       0,  1237,   492,   395,   395,     0,     0,     0,     0,  1241,
     2280       0,     0,     0,     0,     0,     0,     0,     0,     0,   346,
     2281      33,   346,     0,     0,     0,     0,     0,    37,    38,   810,
     2282       0,  -279,   598,     0,   598,   598,     0,     0,  1264,     0,
     2283       0,   598,     0,     0,     0,     0,     0,     0,     0,     0,
     2284       0,   842,   346,     0,     0,  1275,     0,   346,  1276,     0,
     2285    1277,  1025,   204,   567,     0,     0,     0,   346,   346,     0,
     2286       0,   108,     0,     0,     0,     0,     0,  1287,  1288,     0,
     2287       0,     0,   346,     0,     0,     0,     0,   395,   885,     0,
     2288       0,   395,   888,   328,     0,     0,     0,     0,  1301,     0,
     2289       0,     0,   364,     0,     0,     0,     0,     0,     0,     0,
     2290       0,     0,     0,     0,     0,   395,     0,     0,     0,     0,
     2291     346,   395,     0,   395,     0,     0,     0,   395,     0,     0,
     2292    1325,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2293       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2294       0,     0,   310,     0,     0,     0,     0,     0,     0,   346,
     2295     598,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2296       0,     0,     0,   310,   492,   492,   492,   492,   492,   492,
     2297     492,   492,   492,   492,   492,   492,   492,   492,   492,   492,
     2298     492,   492,     0,   346,     0,     0,     0,   395,   395,     0,
     2299       0,     0,   711,     0,     0,     0,     0,     0,     0,     0,
     2300       0,     0,     0,   492,     0,     0,     0,  1167,     0,     0,
     2301       8,     9,    10,    11,    12,     0,     0,     0,     0,  1395,
     2302       0,  1396,     0,     0,     0,     0,     0,     0,     0,   395,
     2303     743,     0,  1403,     0,  1404,     0,   271,    30,   272,     0,
     2304       0,   346,   756,     0,     0,     0,     0,     0,     0,   743,
     2305     598,     0,   598,     0,  1413,     0,     0,     0,     0,   273,
     2306      33,   598,   765,   766,     0,   274,     0,     0,     0,   275,
     2307    1431,     0,   276,   277,   278,   279,    40,    41,     0,   280,
     2308     281,     0,  1437,     0,   787,  1241,     0,   282,     0,     0,
     2309       0,   204,   810,     0,   796,     0,     0,     0,     0,     0,
     2310       0,   283,   756,   361,   492,     0,     0,  1458,     0,     0,
     2311     285,  1168,   287,   288,   289,   290,  1465,     0,     0,  1467,
     2312    1469,     0,     0,     0,     0,     0,   492,     0,     0,     0,
     2313       0,     0,     0,     0,     0,     0,   346,     0,     0,   492,
     2314       0,   395,   395,     0,     0,     0,     0,     0,     0,   395,
     2315       0,     0,     0,   863,   395,     0,     0,  1496,     0,     0,
     2316     364,  1241,   395,     0,     0,     0,     0,     0,     0,     0,
     2317       0,     0,     0,  1508,     0,   598,   598,     0,     0,     0,
     2318       0,   328,   492,     0,     0,     0,     0,     0,     0,     0,
     2319       0,     0,     0,     0,     0,     0,     0,     0,     0,   346,
     2320       0,     0,     0,   328,     0,     0,   395,     0,     0,     0,
     2321       0,     0,     0,   810,   492,     0,     0,     0,     0,     0,
     2322       0,     0,     0,     0,     0,   395,  1142,     0,     0,     0,
     2323       0,  1145,     0,   346,     0,     0,     0,     0,     0,     0,
     2324       0,     0,     0,     0,   395,  1159,     0,   598,   598,  1164,
     2325       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2326     346,   346,   346,     0,     0,     0,     0,     0,     0,     0,
     2327       0,     0,     0,     0,     0,     0,   756,     0,   968,     0,
     2328       0,     0,     0,     0,   973,     0,     0,     0,     0,     0,
     2329       0,     0,   983,     0,     8,     9,    10,    11,    12,    13,
     2330      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
     2331      24,  -279,     0,    25,    26,    27,     0,  1224,     0,   492,
     2332       0,    30,   395,     0,     0,   346,   810,   395,  1234,   328,
     2333       0,     0,   997,   998,   328,   271,     0,   272,     0,   598,
     2334       0,     0,     0,     0,    33,     0,     0,     0,     0,     0,
     2335       0,    37,    38,   328,     0,  -279,     0,     0,   273,     0,
     2336       0,   810,     0,     0,   274,     0,     0,     0,   275,     0,
     2337       0,   276,   277,   278,   279,    40,    41,     0,   280,   281,
     2338       0,     0,     0,     0,   346,  1025,   282,   567,     0,  1145,
     2339     346,   346,     0,     0,  1035,   610,     0,     0,   364,     0,
     2340     283,     0,   361,     0,     0,     0,     0,     0,     0,   285,
     2341     363,   287,   288,   289,   290,   492,     0,     0,     0,     0,
     2342       0,     0,     0,     0,     0,   492,     0,     0,     0,   328,
     2343       0,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     2344      17,    18,    19,    20,    21,    22,    23,    24,     0,   346,
     2345      25,    26,    27,     0,     0,     0,     0,     0,    30,     0,
     2346       0,     0,     0,  1145,     0,     0,     0,     0,     0,     0,
     2347       0,     0,     0,   492,   346,     0,     0,     0,     0,   310,
     2348       0,    33,     0,     0,     0,     0,     0,     0,   199,   200,
     2349       0,     0,  1122,  1123,     0,     0,     0,     0,     0,     0,
     2350     364,     0,     0,     0,     0,     0,     0,   973,     0,     0,
     2351    1133,     0,   743,     0,     0,   271,     0,   272,     0,     0,
     2352       0,     0,     0,     0,   346,   346,     0,     0,     0,  1151,
     2353       0,     0,   261,     0,     0,     0,     0,     0,   273,     0,
     2354       0,     0,     0,     0,   274,     0,  1170,   492,   275,     0,
     2355       0,   276,   277,   278,   279,    40,    41,     0,   280,   281,
     2356       0,  1145,     0,     0,     0,     0,   282,     0,     0,   364,
     2357       0,  1189,     0,     0,     0,     0,     0,     0,     0,     0,
     2358     283,     0,   361,     0,     0,     0,  1211,     0,     0,   285,
     2359     710,   287,   288,   289,   290,     0,     0,   492,     0,     0,
     2360       0,     0,     0,     0,     0,  1220,     0,     0,     0,     0,
     2361       0,     0,   492,   492,     0,     0,     0,     0,   756,     0,
     2362       0,     0,  -501,   810,     0,     1,     2,     3,     4,     5,
     2363       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     2364      16,    17,    18,    19,    20,    21,    22,    23,    24,     0,
     2365     346,    25,    26,    27,    28,     0,   973,    29,     0,    30,
     2366      31,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2367       0,   271,     0,   272,     0,     0,     0,   863,     0,    32,
     2368       0,     0,    33,     0,    34,     0,    35,    36,     0,    37,
     2369      38,    39,     0,     0,   273,  1278,     0,  1279,    40,    41,
     2370     624,     0,     0,     0,   275,     0,     0,   276,   277,   278,
     2371     279,    40,    41,     0,   280,   281,     0,     0,     0,     0,
     2372       0,     0,   282,    42,     0,    43,     0,     0,     0,     0,
     2373     395,     0,     0,    44,     0,     0,   283,     0,   759,     0,
     2374       0,     0,   756,     0,     0,   285,   363,   287,   288,   289,
     2375     290,   395,   395,     0,     0,     0,     0,   310,     0,     0,
     2376       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2377       0,     0,   395,     0,     0,     0,     0,     0,     0,     0,
     2378     973,     0,     0,     1,     2,   198,     4,     5,     6,     7,
     2379       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     2380      18,    19,    20,    21,    22,    23,    24,     0,     0,    25,
     2381      26,    27,    28,     0,     0,    29,   271,    30,  1044,  1045,
     2382       0,  1046,     0,     0,  1047,  1048,  1049,  1050,  1051,  1052,
     2383    1053,  1054,     0,  1055,     0,     0,  1056,    32,     0,   273,
     2384      33,     0,    34,     0,    35,   624,   492,    37,    38,   275,
     2385       0,     0,   276,   277,   278,   279,    40,    41,     0,   280,
     2386     281,     0,     0,     0,     0,     0,     0,   282,     0,     0,
     2387       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2388       0,   283,     0,  1057,     0,     0,   165,     0,     0,     0,
     2389     285,   286,   287,   288,   289,   290,     0,     0,     0,     0,
     2390       0,     0,     0,     0,  -126,     0,     0,     0,     0,   492,
     2391     492,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2392       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2393       0,     0,  1444,     0,     0,     0,     0,     0,     1,     2,
     2394     198,     4,     5,     6,     7,     8,     9,    10,    11,    12,
     2395      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     2396      23,    24,     0,     0,    25,    26,    27,    28,     0,     0,
     2397      29,   271,    30,   272,     8,     9,    10,    11,    12,    13,
     2398      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
     2399      24,  -279,     0,     0,   273,    33,     0,    34,     0,    35,
     2400     274,    30,    37,    38,   275,     0,  1500,   276,   277,   278,
     2401     279,    40,    41,     0,   280,   281,     0,     0,     0,     0,
     2402       0,     0,   282,     0,    33,     0,     0,     0,     0,     0,
     2403       0,     0,     0,     0,     0,  -279,   283,     0,  1057,     0,
     2404       0,     0,     0,     0,     0,   285,   286,   287,   288,   289,
     2405     290,     0,   310,     0,     0,     0,     0,     0,     0,  -126,
     2406       1,     2,   198,     4,     5,     6,     7,     8,     9,    10,
    19792407      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    1980       21,    22,    23,    24,    61,     0,    25,    26,    27,     0,
    1981        0,     0,     0,     0,    30,     0,     0,   333,     0,     0,
    1982        0,     0,     0,     8,     9,    10,    11,    12,   800,     0,
    1983      806,     0,     0,   204,  1083,     0,     0,    33,     0,     0,
    1984        0,     0,    34,     0,    35,    36,    37,   204,     0,     0,
    1985       30,     0,   335,    38,    39,     0,     0,     0,     0,   333,
    1986        0,     0,     0,     0,     0,     0,     0,   485,  1100,   333,
    1987        0,     0,     0,    33,   212,   333,   409,   111,    40,     0,
    1988      150,     0,     0,     0,     0,   333,     0,     0,    42,     0,
    1989        0,   330,     0,     0,   560,   560,     0,     0,     0,     0,
    1990        0,     0,   392,     0,     0,   247,     0,    75,     0,     8,
    1991        9,    10,    11,    12,   936,     0,   584,     0,     0,     0,
    1992        0,     0,     0,   610,   937,   575,     0,     0,     0,     8,
    1993        9,    10,    11,    12,     0,   204,    30,     0,    75,     0,
    1994        0,     0,    73,   139,     0,     0,    70,    73,     0,   698,
    1995      698,     0,   330,   330,   330,     0,    30,     0,     0,    33,
    1996        0,     0,     0,     0,    34,     0,   175,     0,    37,     0,
    1997      333,   214,     0,  1192,     0,    38,    39,     0,  1139,    33,
    1998        0,     0,     0,     0,    34,     0,     0,     0,    37,     0,
    1999      806,     0,     0,     0,     0,    38,    39,  1156,     0,   168,
    2000     1512,     0,   390,   313,     0,     0,   698,   698,     0,     0,
    2001     1513,     0,     0,     0,     0,     0,     0,   800,   247,     0,
    2002      718,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2003      719,   792,   793,   333,   213,     0,     0,     0,     0,     0,
     2408      21,    22,    23,    24,     0,     0,    25,    26,    27,    28,
     2409       0,     0,    29,   271,    30,   272,     8,     9,    10,    11,
     2410      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
     2411      22,    23,    24,  -280,     0,     0,   273,    33,     0,    34,
     2412       0,    35,   274,    30,    37,    38,   275,     0,     0,   276,
     2413     277,   278,   279,    40,    41,     0,   280,   281,     0,     0,
     2414       0,     0,     0,     0,   282,     0,    33,     0,     0,     0,
     2415       0,     0,     0,     0,     0,     0,     0,  -280,   283,     0,
     2416      43,     0,     0,     0,     0,     0,     0,   285,   286,   287,
     2417     288,   289,   290,     2,   198,     4,     5,     6,     7,     8,
     2418       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2419      19,    20,    21,    22,    23,    24,     0,     0,    25,    26,
     2420      27,     0,     0,     0,     0,   271,    30,   272,     0,     0,
    20042421       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2005        0,     0,     0,   247,   335,     0,   336,     0,     0,   827,
    2006        0,     0,   830,   831,     0,   834,     0,   836,   837,     0,
    2007        0,     0,   838,   839,   610,   560,   712,     0,     0,     0,
    2008     1231,   610,   330,   330,     0,     0,     0,     0,     0,     0,
    2009        0,   333,   333,     0,   333,   333,   333,     0,     0,     0,
    2010       73,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2011        0,     0,     0,     0,   335,    70,     0,     0,     0,    73,
    2012        0,     0,     0,     0,  1294,     0,     0,    73,     0,     0,
    2013        0,     0,   204,     0,     0,     0,     0,     0,     0,     0,
    2014        0,   330,     0,     0,     0,    61,    75,     0,   333,   333,
    2015        0,    75,     0,   335,     0,   610,   920,   921,     0,   333,
    2016        0,     0,   923,     0,   698,     0,   712,     0,     0,     0,
    2017      111,   335,     0,    73,     0,     0,     8,     9,    10,    11,
     2422       0,     0,     0,     0,     0,     0,     0,     0,   273,    33,
     2423       0,    34,     0,    35,   274,     0,    37,    38,   275,     0,
     2424       0,   276,   277,   278,   279,    40,    41,     0,   280,   281,
     2425       0,     0,     0,     0,     0,     0,   282,     0,     0,     0,
     2426       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2427     283,     0,   325,    -3,     0,     0,     0,   754,     0,   285,
     2428     326,   287,   288,   289,   290,     2,   198,     4,     5,     6,
     2429       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     2430      17,    18,    19,    20,    21,    22,    23,    24,     0,     0,
     2431      25,    26,    27,     0,     0,     0,     0,   271,    30,   272,
     2432       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2433       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2434     273,    33,     0,    34,     0,    35,   274,     0,    37,    38,
     2435     275,     0,     0,   276,   277,   278,   279,    40,    41,     0,
     2436     280,   281,     0,     0,     0,     0,     0,     0,   282,     0,
     2437