Changeset a7c90d4


Ignore:
Timestamp:
Mar 7, 2017, 8:33:43 AM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
64cb860, c3396e0
Parents:
7fe2498
Message:

change StorageClass? to bitset, support _Thread_local as separate storage-class

Location:
src
Files:
34 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    r7fe2498 ra7c90d4  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar  3 21:18:47 2017
    13 // Update Count     : 465
     12// Last Modified On : Sun Mar  5 17:13:33 2017
     13// Update Count     : 475
    1414//
    1515
     
    895895
    896896        void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
    897                 switch ( decl->get_storageClass() ) {
    898                         //output << DeclarationNode::storageClassNames[decl->get_storageClass()] << ' ';
    899                   case DeclarationNode::Extern:
    900                         output << "extern ";
    901                         break;
    902                   case DeclarationNode::Static:
    903                         output << "static ";
    904                         break;
    905                   case DeclarationNode::Auto:
    906                         // silently drop storage class
    907                         break;
    908                   case DeclarationNode::Register:
    909                         output << "register ";
    910                         break;
    911                   case DeclarationNode::Threadlocal:
    912                         output << "_Thread_local ";
    913                         break;
    914                   case DeclarationNode::NoStorageClass:
    915                         break;
    916                   default:
    917                         assert( false );
    918                 } // switch
     897                if ( decl->get_storageClasses().any() ) {
     898                        DeclarationNode::print_StorageClass( output, decl->get_storageClasses() );
     899                } // if
    919900        } // CodeGenerator::handleStorageClass
    920901
  • src/CodeGen/FixNames.cc

    r7fe2498 ra7c90d4  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar  3 21:52:17 2017
    13 // Update Count     : 6
     12// Last Modified On : Mon Mar  6 23:32:08 2017
     13// Update Count     : 15
    1414//
    1515
     
    3939        std::string mangle_main() {
    4040                FunctionType* main_type;
    41                 std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl(
    42                         "main",
    43                         DeclarationNode::NoStorageClass,
    44                         LinkageSpec::Cforall,
    45                         main_type = new FunctionType( Type::Qualifiers(), true ),
    46                         nullptr
    47                 ) };
     41                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall,
     42                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), true ), nullptr )
     43                                };
    4844                main_type->get_returnVals().push_back(
    49                         new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
     45                        new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
    5046                );
    5147
     
    5652        std::string mangle_main_args() {
    5753                FunctionType* main_type;
    58                 std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl(
    59                         "main",
    60                         DeclarationNode::NoStorageClass,
    61                         LinkageSpec::Cforall,
    62                         main_type = new FunctionType( Type::Qualifiers(), false ),
    63                         nullptr
    64                 ) };
     54                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", DeclarationNode::StorageClasses(), LinkageSpec::Cforall,
     55                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), false ), nullptr )
     56                                };
    6557                main_type->get_returnVals().push_back(
    66                         new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
     58                        new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
    6759                );
    6860
    6961                mainDecl->get_functionType()->get_parameters().push_back(
    70                         new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
     62                        new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
    7163                );
    7264
    7365                mainDecl->get_functionType()->get_parameters().push_back(
    74                         new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0,
     66                        new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0,
    7567                        new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),
    7668                        nullptr )
  • src/GenPoly/Box.cc

    r7fe2498 ra7c90d4  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar  3 21:57:15 2017
    13 // Update Count     : 310
     12// Last Modified On : Mon Mar  6 23:45:59 2017
     13// Update Count     : 330
    1414//
    1515
     
    289289                        TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
    290290                        std::string paramName = mangleType( &paramType );
    291                         layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
    292                         layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
     291                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
     292                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
    293293                }
    294294        }
     
    298298                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
    299299                // because each unit generates copies of the default routines for each aggregate.
    300                 FunctionDecl *layoutDecl = new FunctionDecl(
    301                         layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
    302                         std::list< Attribute * >(), DeclarationNode::FuncSpec( DeclarationNode::InlineSpec ) );
     300                FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
     301                                                                                                         functionNesting > 0 ? DeclarationNode::StorageClasses() : DeclarationNode::StorageClasses( DeclarationNode::StaticClass ),
     302                                                                                                         LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
     303                                                                                                         std::list< Attribute * >(), DeclarationNode::FuncSpecifiers( DeclarationNode::InlineSpec ) );
    303304                layoutDecl->fixUniqueId();
    304305                return layoutDecl;
     
    367368                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
    368369
    369                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
     370                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
    370371                layoutFnType->get_parameters().push_back( sizeParam );
    371                 ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
     372                ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
    372373                layoutFnType->get_parameters().push_back( alignParam );
    373                 ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
     374                ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
    374375                layoutFnType->get_parameters().push_back( offsetParam );
    375376                addOtypeParams( layoutFnType, otypeParams );
     
    428429                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
    429430
    430                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
     431                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
    431432                layoutFnType->get_parameters().push_back( sizeParam );
    432                 ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
     433                ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
    433434                layoutFnType->get_parameters().push_back( alignParam );
    434435                addOtypeParams( layoutFnType, otypeParams );
     
    536537                                        if ( adapters.find( mangleName ) == adapters.end() ) {
    537538                                                std::string adapterName = makeAdapterName( mangleName );
    538                                                 adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
     539                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
    539540                                        } // if
    540541                                } // for
     
    655656
    656657                ObjectDecl *Pass1::makeTemporary( Type *type ) {
    657                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, 0 );
     658                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, 0 );
    658659                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    659660                        return newObj;
     
    764765                                        Type * newType = param->clone();
    765766                                        if ( env ) env->apply( newType );
    766                                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, newType, 0 );
     767                                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
    767768                                        newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
    768769                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
     
    830831                                makeRetParm( adapter );
    831832                        } // if
    832                         adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
     833                        adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
    833834                        return adapter;
    834835                }
     
    911912                        adapterBody->get_kids().push_back( bodyStmt );
    912913                        std::string adapterName = makeAdapterName( mangleName );
    913                         return new FunctionDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, adapterType, adapterBody );
     914                        return new FunctionDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, adapterType, adapterBody );
    914915                }
    915916
     
    12721273                                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
    12731274                                        std::string adapterName = makeAdapterName( mangleName );
    1274                                         paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
     1275                                        paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
    12751276                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
    12761277                                }
     
    13781379                        std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
    13791380                        std::list< DeclarationWithType *> inferredParams;
    1380                         ObjectDecl newObj( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
    1381                         ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0,
     1381                        ObjectDecl newObj( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
     1382                        ObjectDecl newPtr( "", DeclarationNode::StorageClasses(), LinkageSpec::C, 0,
    13821383                                           new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
    13831384                        for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
     
    16331634
    16341635                ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
    1635                         ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, init );
     1636                        ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::StorageClasses(), LinkageSpec::C, 0, type, init );
    16361637                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    16371638                        return newObj;
     
    18171818                                                        memberDecl = origMember->clone();
    18181819                                                } else {
    1819                                                         memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
     1820                                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
    18201821                                                }
    18211822                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
  • src/GenPoly/Specialize.cc

    r7fe2498 ra7c90d4  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar  3 21:54:45 2017
    13 // Update Count     : 28
     12// Last Modified On : Mon Mar  6 23:13:00 2017
     13// Update Count     : 30
    1414//
    1515
     
    155155                } // if
    156156                // create new thunk with same signature as formal type (C linkage, empty body)
    157                 FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
     157                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
    158158                thunkFunc->fixUniqueId();
    159159
  • src/InitTweak/FixGlobalInit.cc

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

    r7fe2498 ra7c90d4  
    1010// Created On       : Wed Jan 13 16:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar  3 21:56:11 2017
    13 // Update Count     : 39
     12// Last Modified On : Tue Mar  7 07:51:40 2017
     13// Update Count     : 59
    1414//
    1515
     
    437437                        result = result->clone();
    438438                        env->apply( result );
    439                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
     439                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
    440440                        tmp->get_type()->set_isConst( false );
    441441
     
    483483                                result = result->clone();
    484484                                env->apply( result );
    485                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
     485                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
    486486                                ret->get_type()->set_isConst( false );
    487487                                impCpCtorExpr->get_returnDecls().push_back( ret );
     
    506506                                result = result->clone();
    507507                                env->apply( result );
    508                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
     508                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, 0, result, 0 );
    509509                                ret->get_type()->set_isConst( false );
    510510                                stmtExpr->get_returnDecls().push_front( ret );
     
    538538                        } else {
    539539                                // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
    540                                 unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
     540                                unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
    541541                                unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
    542542                        }
     
    678678                                assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
    679679                                if ( Statement * ctor = ctorInit->get_ctor() ) {
    680                                         if ( objDecl->get_storageClass() == DeclarationNode::Static ) {
     680                                        if ( objDecl->get_storageClasses()[ DeclarationNode::Static ] ) {
    681681                                                // originally wanted to take advantage of gcc nested functions, but
    682682                                                // we get memory errors with this approach. To remedy this, the static
     
    704704                                                BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
    705705                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
    706                                                 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::Static, LinkageSpec::Cforall, 0, boolType, boolInitExpr );
     706                                                ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
    707707                                                isUninitializedVar->fixUniqueId();
    708708
     
    731731
    732732                                                        // void __objName_dtor_atexitN(...) {...}
    733                                                         FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
     733                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
    734734                                                        dtorCaller->fixUniqueId();
    735735                                                        dtorCaller->get_statements()->push_back( dtorStmt );
     
    764764                                                        // create a new object which is never used
    765765                                                        static UniqueName dummyNamer( "_dummy" );
    766                                                         ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::Static, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
     766                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
    767767                                                        return dummy;
    768768                                                }
     
    821821                void InsertDtors::visit( ObjectDecl * objDecl ) {
    822822                        // remember non-static destructed objects so that their destructors can be inserted later
    823                         if ( objDecl->get_storageClass() != DeclarationNode::Static ) {
     823                        if ( ! objDecl->get_storageClasses()[ DeclarationNode::Static ] ) {
    824824                                if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
    825825                                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
     
    11181118
    11191119                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
    1120                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
     1120                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
    11211121                        addDeclaration( tmp );
    11221122
  • src/InitTweak/GenInit.cc

    r7fe2498 ra7c90d4  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 14:57:53 2017
    13 // Update Count     : 167
     12// Last Modified On : Tue Mar  7 07:51:38 2017
     13// Update Count     : 179
    1414//
    1515
     
    120120                void hoist( Type * type );
    121121
    122                 DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
     122                DeclarationNode::StorageClasses storageClasses;
    123123                bool inFunction = false;
    124124        };
     
    174174
    175175        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
    176                 storageclass = objectDecl->get_storageClass();
     176                storageClasses = objectDecl->get_storageClasses();
    177177                DeclarationWithType * temp = Parent::mutate( objectDecl );
    178178                hoist( objectDecl->get_type() );
    179                 storageclass = DeclarationNode::NoStorageClass;
    180179                return temp;
    181180        }
     
    185184                static UniqueName dimensionName( "_array_dim" );
    186185
    187                 // C doesn't allow variable sized arrays at global scope or for static variables,
    188                 // so don't hoist dimension.
     186                // C doesn't allow variable sized arrays at global scope or for static variables, so don't hoist dimension.
    189187                if ( ! inFunction ) return;
    190                 if ( storageclass == DeclarationNode::Static ) return;
     188                if ( storageClasses[ DeclarationNode::StaticClass] ) return;
    191189
    192190                if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
    193191                        if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
    194192
    195                         // don't need to hoist dimension if it's a constexpr - only need to if there's potential
    196                         // for side effects.
     193                        // don't need to hoist dimension if it's a constexpr - only need to if there's potential for side effects.
    197194                        if ( isConstExpr( arrayType->get_dimension() ) ) return;
    198195
    199                         ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageclass, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
     196                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
    200197                        arrayDimension->get_type()->set_isConst( true );
    201198
  • src/InitTweak/InitTweak.cc

    r7fe2498 ra7c90d4  
    260260                        (objDecl->get_init() == NULL ||
    261261                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
    262                         && objDecl->get_storageClass() != DeclarationNode::Extern;
     262                        && ! objDecl->get_storageClasses()[ DeclarationNode::Extern ];
    263263        }
    264264
  • src/Parser/DeclarationNode.cc

    r7fe2498 ra7c90d4  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar  3 21:38:34 2017
    13 // Update Count     : 862
     12// Last Modified On : Tue Mar  7 08:02:09 2017
     13// Update Count     : 936
    1414//
    1515
     
    1919#include <algorithm>
    2020#include <cassert>
     21#include <strings.h>                                                                    // ffs
    2122
    2223#include "TypeData.h"
     
    3233
    3334// These must remain in the same order as the corresponding DeclarationNode enumerations.
    34 const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "inline", "fortran", "_Noreturn", "NoStorageClassNames" };
     35const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "NoStorageClassNames" };
    3536const char * DeclarationNode::funcSpecifierNames[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" };
    36 const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoTypeQualifierNames" };
     37const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic", "NoTypeQualifierNames" };
    3738const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
    3839const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
     
    4950DeclarationNode::DeclarationNode() :
    5051                type( nullptr ),
    51                 storageClass( NoStorageClass ),
    5252                bitfieldWidth( nullptr ),
    5353                hasEllipsis( false ),
     
    8989
    9090        newnode->type = maybeClone( type );
    91         newnode->storageClass = storageClass;
     91        newnode->storageClasses = storageClasses;
    9292        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
    93         newnode->funcSpec = funcSpec;
     93        newnode->funcSpecs = funcSpecs;
    9494        newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
    9595        newnode->hasEllipsis = hasEllipsis;
     
    116116}
    117117
    118 void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpec funcSpec ) {
     118void DeclarationNode::print_StorageClass( std::ostream & output, StorageClasses storageClasses ) {
     119        if ( storageClasses.any() ) {                                                           // function specifiers?
     120                for ( unsigned int i = 0; i < DeclarationNode::NoStorageClass; i += 1 ) {
     121                        if ( storageClasses[i] ) {
     122                                output << DeclarationNode::storageClassNames[i] << ' ';
     123                        } // if
     124                } // for
     125        } // if
     126} // print_StorageClass
     127
     128void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) {
    119129        if ( funcSpec.any() ) {                                                         // function specifiers?
    120130                for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) {
     
    138148        } // if
    139149
    140         if ( storageClass != NoStorageClass ) os << DeclarationNode::storageClassNames[storageClass] << ' ';
    141         print_FuncSpec( os, funcSpec );
     150        print_StorageClass( os, storageClasses );
     151        print_FuncSpec( os, funcSpecs );
    142152
    143153        if ( type ) {
     
    194204DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
    195205        DeclarationNode * newnode = new DeclarationNode;
    196         newnode->storageClass = sc;
     206        newnode->storageClasses[ sc ] = true;
    197207        return newnode;
    198208} // DeclarationNode::newStorageClass
     
    200210DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) {
    201211        DeclarationNode * newnode = new DeclarationNode;
    202         newnode->funcSpec[ fs ] = true;
     212        newnode->funcSpecs[ fs ] = true;
    203213        return newnode;
    204214} // DeclarationNode::newFuncSpecifier
     
    443453
    444454void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
    445         const TypeData::TypeQualifiers &qsrc = src->typeQualifiers, &qdst = dst->typeQualifiers; // optimization
    446 
    447         if ( (qsrc & qdst).any() ) {                                             // common qualifier ?
     455        const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization
     456
     457        if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
    448458                for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers
    449459                        if ( qsrc[i] && qdst[i] ) {
     
    451461                        } // if
    452462                } // for
    453         } // if
     463        } // for
    454464} // DeclarationNode::checkQualifiers
    455465
    456 void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {
    457         const FuncSpec &src = funcSpec, &dst = q->funcSpec; // optimization
    458         if ( (src & dst).any() ) {                                                      // common specifier ?
     466void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
     467        if ( (funcSpecs & src->funcSpecs).any() ) {                     // common specifier ?
    459468                for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find common specifier
    460                         if ( src[i] && dst[i] ) {
     469                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
    461470                                appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] );
    462471                        } // if
     
    464473        } // if
    465474
    466         if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
    467                 if ( storageClass == q->storageClass ) {                // duplicate qualifier
    468                         appendError( error, string( "duplicate " ) + storageClassNames[ storageClass ] );
    469                 } else {                                                                                // only one storage class
    470                         appendError( error, string( "conflicting " ) + storageClassNames[ storageClass ] + " & " + storageClassNames[ q->storageClass ] );
    471                         q->storageClass = storageClass;                         // FIX ERROR, prevent assertions from triggering
    472                 } // if
    473         } // if
    474 
    475         appendError( error, q->error );
    476 } // DeclarationNode::checkStorageClasses
    477 
    478 DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
    479         funcSpec = funcSpec | q->funcSpec;
    480 
    481         // do not overwrite an existing value with NoStorageClass
    482         if ( q->storageClass != NoStorageClass ) {
    483                 assert( storageClass == NoStorageClass || storageClass == q->storageClass );
    484                 storageClass = q->storageClass;
    485         } // if
     475        if ( storageClasses != 0 && src->storageClasses != 0 ) { // any reason to check ?
     476                if ( (storageClasses & src->storageClasses).any() ) { // duplicates ?
     477                        for ( unsigned int i = 0; i < NoStorageClass; i += 1 ) { // find duplicates
     478                                if ( storageClasses[i] && src->storageClasses[i] ) {
     479                                        appendError( error, string( "duplicate " ) + storageClassNames[i] );
     480                                } // if
     481                        } // for
     482                        // src is the new item being added and has a single bit
     483                } else if ( ! src->storageClasses[ Threadlocal ] ) { // conflict ?
     484                        appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.to_ulong() ) - 1] +
     485                                                 " & " + storageClassNames[ffs( src->storageClasses.to_ulong() ) - 1] );
     486                        src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
     487                } // if
     488        } // if
     489
     490        appendError( error, src->error );
     491} // DeclarationNode::checkSpecifiers
     492
     493DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
     494        funcSpecs = funcSpecs | q->funcSpecs;
     495        storageClasses = storageClasses | q->storageClasses;
    486496
    487497        for ( Attribute *attr: reverseIterate( q->attributes ) ) {
     
    489499        } // for
    490500        return this;
    491 } // DeclarationNode::copyStorageClasses
     501} // DeclarationNode::copySpecifiers
    492502
    493503static void addQualifiersToType( TypeData *&src, TypeData * dst ) {
     
    513523        if ( ! q ) { delete q; return this; }
    514524
    515         checkStorageClasses( q );
    516         copyStorageClasses( q );
     525        checkSpecifiers( q );
     526        copySpecifiers( q );
    517527
    518528        if ( ! q->type ) {
     
    543553        } // if
    544554
    545         checkQualifiers( q->type, type );
     555        checkQualifiers( type, q->type );
    546556        addQualifiersToType( q->type, type );
    547557
     
    624634DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) {
    625635        if ( o ) {
    626                 checkStorageClasses( o );
    627                 copyStorageClasses( o );
     636                checkSpecifiers( o );
     637                copySpecifiers( o );
    628638                if ( o->type ) {
    629639                        if ( ! type ) {
     
    879889        DeclarationNode * newnode = new DeclarationNode;
    880890        newnode->type = maybeClone( type );
    881         assert( storageClass == NoStorageClass );
    882         newnode->copyStorageClasses( this );
     891        newnode->copySpecifiers( this );
    883892        assert( newName );
    884893        newnode->name = newName;
     
    889898        if ( ! o ) return nullptr;
    890899
    891         o->copyStorageClasses( this );
     900        o->copySpecifiers( this );
    892901        if ( type ) {
    893902                TypeData * srcType = type;
     
    981990                                } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
    982991                                        StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
    983                                         auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
     992                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
    984993                                        obj->location = cur->location;
    985994                                        * out++ = obj;
     
    987996                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
    988997                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
    989                                         auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
     998                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
    990999                                        obj->location = cur->location;
    9911000                                        * out++ = obj;
     
    10341043                assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." );
    10351044                assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
    1036                 TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
     1045                TypeDecl * ret = new TypeDecl( *name, DeclarationNode::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
    10371046                buildList( variable.assertions, ret->get_assertions() );
    10381047                return ret;
     
    10451054                //    inline _Noreturn int g( int i );  // allowed
    10461055                //    inline _Noreturn int i;                   // disallowed
    1047                 if ( type->kind != TypeData::Function && funcSpec.any() ) {
     1056                if ( type->kind != TypeData::Function && funcSpecs.any() ) {
    10481057                        throw SemanticError( "invalid function specifier for ", this );
    10491058                } // if
    1050                 return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), funcSpec, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
     1059                return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
    10511060        } // if
    10521061
     
    10551064        //    inlne _Noreturn struct S { ... };         // disallowed
    10561065        //    inlne _Noreturn enum   E { ... };         // disallowed
    1057         if ( funcSpec.any() ) {
     1066        if ( funcSpecs.any() ) {
    10581067                throw SemanticError( "invalid function specifier for ", this );
    10591068        } // if
    10601069        assertf( name, "ObjectDecl must a have name\n" );
    1061         return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
     1070        return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
    10621071}
    10631072
  • src/Parser/ExpressionNode.cc

    r7fe2498 ra7c90d4  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep 16 16:27:44 2016
    13 // Update Count     : 508
     12// Last Modified On : Sat Mar  4 06:58:47 2017
     13// Update Count     : 509
    1414//
    1515
     
    173173
    174174Expression *build_constantZeroOne( const std::string & str ) {
    175         Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type*)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) );
     175        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) );
    176176        delete &str;                                                                            // created by lex
    177177        return ret;
     
    275275}
    276276Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ) {
    277         Expression* ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
     277        Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
    278278        delete member;
    279279        return ret;
  • src/Parser/ParseNode.h

    r7fe2498 ra7c90d4  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar  3 21:34:27 2017
    13 // Update Count     : 704
     12// Last Modified On : Tue Mar  7 08:10:53 2017
     13// Update Count     : 726
    1414//
    1515
     
    4040//##############################################################################
    4141
    42 extern char* yyfilename;
     42extern char * yyfilename;
    4343extern int yylineno;
    4444
     
    123123        }
    124124
    125         Expression * build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
     125        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
    126126  private:
    127127        bool extension = false;
     
    204204        // These must remain in the same order as the corresponding DeclarationNode names.
    205205
    206         enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass };
     206        enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass,
     207                                                ExternClass = 1 << Extern, StaticClass = 1 << Static, AutoClass = 1 << Auto, RegisterClass = 1 << Register, ThreadlocalClass = 1 << Threadlocal };
    207208        enum FuncSpecifier { Inline, Noreturn, Fortran, NoFuncSpecifier,
    208                                         InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran };
    209         enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoTypeQualifier };
     209                                                 InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran };
     210        enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Mutex, Atomic, NoTypeQualifier };
    210211        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
    211212        enum ComplexType { Complex, Imaginary, NoComplexType };
     
    264265        DeclarationNode * addQualifiers( DeclarationNode * );
    265266        void checkQualifiers( const TypeData *, const TypeData * );
    266         void checkStorageClasses( DeclarationNode * );
    267         DeclarationNode * copyStorageClasses( DeclarationNode * );
     267        void checkSpecifiers( DeclarationNode * );
     268        DeclarationNode * copySpecifiers( DeclarationNode * );
    268269        DeclarationNode * addType( DeclarationNode * );
    269270        DeclarationNode * addTypedef();
     
    296297
    297298        Declaration * build() const;
    298         ::Type * buildType() const;
     299        Type * buildType() const;
    299300
    300301        bool get_hasEllipsis() const;
     
    302303        DeclarationNode * extractAggregate() const;
    303304        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
    304         ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
     305        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
    305306
    306307        bool get_extension() const { return extension; }
     
    324325
    325326        TypeData * type;
    326         StorageClass storageClass;
    327 
    328         typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpec;
    329         FuncSpec funcSpec;
    330         static void print_FuncSpec( std::ostream & output, FuncSpec funcSpec );
     327
     328        typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses;
     329        StorageClasses storageClasses;
     330        static void print_StorageClass( std::ostream & output, StorageClasses storageClasses );
     331
     332        typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpecifiers;
     333        FuncSpecifiers funcSpecs;
     334        static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs );
    331335
    332336        ExpressionNode * bitfieldWidth;
     
    347351
    348352static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
    349         Type* ret = orig ? orig->buildType() : nullptr;
     353        Type * ret = orig ? orig->buildType() : nullptr;
    350354        delete orig;
    351355        return ret;
     
    362366
    363367        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
    364         Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
     368        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
    365369
    366370        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
  • src/Parser/TypeData.cc

    r7fe2498 ra7c90d4  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar  3 21:59:10 2017
    13 // Update Count     : 516
     12// Last Modified On : Tue Mar  7 08:08:21 2017
     13// Update Count     : 538
    1414//
    1515
     
    393393        buildList( firstNode, outputList );
    394394        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
    395                 TypeDecl * td = static_cast<TypeDecl*>(*i);
     395                TypeDecl * td = static_cast<TypeDecl *>(*i);
    396396                if ( td->get_kind() == TypeDecl::Any ) {
    397397                        // add assertion parameters to `type' tyvars in reverse order
    398398                        // add dtor:  void ^?{}(T *)
    399399                        FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
    400                         dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    401                         td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr ) );
     400                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     401                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
    402402
    403403                        // add copy ctor:  void ?{}(T *, T)
    404404                        FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
    405                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    406                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    407                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr ) );
     405                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     406                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     407                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
    408408
    409409                        // add default ctor:  void ?{}(T *)
    410410                        FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
    411                         ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    412                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr ) );
     411                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     412                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
    413413
    414414                        // add assignment operator:  T * ?=?(T *, T)
    415415                        FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
    416                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    417                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    418                         assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    419                         td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr ) );
     416                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
     417                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     418                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
     419                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
    420420                } // if
    421421        } // for
     
    732732} // buildAggInst
    733733
    734 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) {
     734NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClasses scs ) {
    735735        assert( td->kind == TypeData::Symbolic );
    736736        NamedTypeDecl * ret;
    737737        assert( td->base );
    738738        if ( td->symbolic.isTypedef ) {
    739                 ret = new TypedefDecl( name, sc, typebuild( td->base ) );
     739                ret = new TypedefDecl( name, scs, typebuild( td->base ) );
    740740        } else {
    741                 ret = new TypeDecl( name, sc, typebuild( td->base ), TypeDecl::Any );
     741                ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any );
    742742        } // if
    743743        buildList( td->symbolic.params, ret->get_parameters() );
     
    784784} // buildTypeof
    785785
    786 Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, DeclarationNode::FuncSpec funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
     786Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClasses scs, Expression * bitfieldWidth, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
    787787        if ( td->kind == TypeData::Function ) {
    788788                if ( td->function.idList ) {                                    // KR function ?
     
    792792                FunctionDecl * decl;
    793793                Statement * stmt = maybeBuild<Statement>( td->function.body );
    794                 CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt );
    795                 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, attributes, funcSpec );
     794                CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt );
     795                decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec );
    796796                return decl->set_asmName( asmName );
    797797        } else if ( td->kind == TypeData::Aggregate ) {
     
    800800                return buildEnum( td, attributes );
    801801        } else if ( td->kind == TypeData::Symbolic ) {
    802                 return buildSymbolic( td, name, sc );
     802                return buildSymbolic( td, name, scs );
    803803        } else {
    804                 return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
     804                return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
    805805        } // if
    806806        return nullptr;
     
    820820                        break;
    821821                  default:
    822                         ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, nullptr, DeclarationNode::FuncSpecifier(), LinkageSpec::Cforall, nullptr ) ) );
     822                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", DeclarationNode::StorageClasses(), nullptr, DeclarationNode::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
    823823                } // switch
    824824        } else {
    825                 ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
     825                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
    826826        } // if
    827827        return ft;
     
    846846        for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = dynamic_cast< DeclarationNode * >( decl->get_next() ) ) {
    847847                // scan ALL parameter names for each declaration name to check for duplicates
    848                 for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) {
     848                for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) {
    849849                        if ( *decl->name == *param->name ) {
    850850                                // type set => parameter name already transformed by a declaration names so there is a duplicate
     
    867867        //    rtb( a, b, c ) const char * b; {} => int rtn( int a, const char * b, int c ) {}
    868868
    869         for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) {
     869        for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) {
    870870                if ( ! param->type ) {                                                  // generate type int for empty parameter type
    871871                        param->type = new TypeData( TypeData::Basic );
  • src/Parser/TypeData.h

    r7fe2498 ra7c90d4  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar  3 20:56:53 2017
    13 // Update Count     : 167
     12// Last Modified On : Tue Mar  7 08:03:53 2017
     13// Update Count     : 173
    1414//
    1515
     
    107107ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes );
    108108ReferenceToType * buildAggInst( const TypeData * );
    109 NamedTypeDecl * buildSymbolic( const TypeData *, const std::string &name, DeclarationNode::StorageClass sc );
    110109TypeDecl * buildVariable( const TypeData * );
    111110EnumDecl * buildEnum( const TypeData *, std::list< Attribute * > );
     
    113112TupleType * buildTuple( const TypeData * );
    114113TypeofType * buildTypeof( const TypeData * );
    115 Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, DeclarationNode::FuncSpec funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
     114Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClasses, Expression *, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
    116115FunctionType * buildFunction( const TypeData * );
    117116void buildKRFunction( const TypeData::Function_t & function );
  • src/Parser/lex.cc

    r7fe2498 ra7c90d4  
    382382        (yy_c_buf_p) = yy_cp;
    383383
    384 #define YY_NUM_RULES 186
    385 #define YY_END_OF_BUFFER 187
     384#define YY_NUM_RULES 187
     385#define YY_END_OF_BUFFER 188
    386386/* This struct is not used in this scanner,
    387387   but its presence is necessary. */
     
    391391        flex_int32_t yy_nxt;
    392392        };
    393 static yyconst flex_int16_t yy_accept[909] =
     393static yyconst flex_int16_t yy_accept[914] =
    394394    {   0,
    395         0,    0,    0,    0,    0,    0,  121,  121,  124,  124,
    396       187,  185,    7,    9,    8,  144,  123,  106,  149,  152,
    397       120,  131,  132,  147,  145,  135,  146,  138,  148,  111,
    398       112,  113,  136,  137,  154,  156,  155,  157,  185,  106,
    399       129,  185,  130,  150,  106,  108,  106,  106,  106,  106,
    400       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    401       106,  106,  106,  133,  153,  134,  151,    7,  185,    4,
    402         4,  186,  109,  186,  110,  121,  122,  128,  124,  125,
    403         7,    9,    0,    8,  161,  180,  106,    0,  173,  143,
    404       166,  174,  171,  158,  169,  159,  170,  168,    0,  117,
    405 
    406         3,    0,  172,  116,  114,    0,    0,  114,  114,    0,
    407         0,  114,  113,  113,  113,    0,  113,  141,  142,  140,
    408       162,  164,  160,  165,  163,    0,    0,    0,    0,    0,
     395        0,    0,    0,    0,    0,    0,  122,  122,  125,  125,
     396      188,  186,    7,    9,    8,  145,  124,  107,  150,  153,
     397      121,  132,  133,  148,  146,  136,  147,  139,  149,  112,
     398      113,  114,  137,  138,  155,  157,  156,  158,  186,  107,
     399      130,  186,  131,  151,  107,  109,  107,  107,  107,  107,
     400      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     401      107,  107,  107,  107,  134,  154,  135,  152,    7,  186,
     402        4,    4,  187,  110,  187,  111,  122,  123,  129,  125,
     403      126,    7,    9,    0,    8,  162,  181,  107,    0,  174,
     404      144,  167,  175,  172,  159,  170,  160,  171,  169,    0,
     405
     406      118,    3,    0,  173,  117,  115,    0,    0,  115,  115,
     407        0,    0,  115,  114,  114,  114,    0,  114,  142,  143,
     408      141,  163,  165,  161,  166,  164,    0,    0,    0,    0,
    409409        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    410       107,  179,    0,  123,  120,  106,    0,    0,  176,    0,
    411       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    412       106,  106,  106,  106,  106,  106,  106,   38,  106,  106,
    413       106,  106,  106,  106,  106,  106,  106,  106,   57,  106,
    414       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    415       106,  106,  106,  106,  106,  106,  106,  106,  175,  167,
    416 
    417         7,    0,    0,    0,    2,    0,    5,  109,    0,    0,
    418         0,  121,    0,  127,  126,  126,    0,    0,    0,  124,
     410        0,  108,  180,    0,  124,  121,  107,    0,    0,  177,
     411        0,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     412      107,  107,  107,  107,  107,  107,  107,  107,   38,  107,
     413      107,  107,  107,  107,  107,  107,  107,  107,  107,   57,
     414      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     415      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     416
     417      176,  168,    7,    0,    0,    0,    2,    0,    5,  110,
     418        0,    0,    0,  122,    0,  128,  127,  127,    0,    0,
     419        0,  125,    0,    0,    0,    0,    0,    0,    0,    0,
     420        0,    0,    0,    0,    0,    0,    0,  140,  118,  119,
     421        0,  119,  119,    0,    0,    6,  119,  115,    0,    0,
     422        0,  119,    0,  115,  115,  115,  115,    0,  116,    0,
     423        0,  114,  114,  114,  114,    0,  178,  179,    0,  184,
     424      182,    0,    0,    0,  108,    0,    0,    0,    0,    0,
     425        0,    0,    0,  107,   17,  107,  107,  107,  107,  107,
     426      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     427
     428      107,  107,  107,   14,  107,  107,  107,  107,  107,  107,
     429      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     430      107,  107,   51,  107,  107,  107,   64,  107,  107,  107,
     431      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     432      107,  107,  107,   92,  107,  107,  107,  107,  107,  107,
     433      107,  107,  107,    0,    0,    0,    0,    0,    0,    0,
     434        0,  127,    0,    0,    0,    0,    0,  127,    0,    0,
     435      185,    0,    0,    0,    0,    0,    0,    0,  119,    0,
     436      119,    0,  119,    0,  119,    0,    0,  119,    0,  115,
     437      115,    0,    0,  116,  116,    0,  116,    0,  116,  114,
     438
     439      114,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     440        0,  183,  107,  107,  107,  107,  107,  107,  107,  107,
     441      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     442      107,  107,  107,  107,  107,   21,  107,   24,  107,   27,
     443      107,  107,  107,  107,  107,  107,  107,   41,  107,   43,
     444      107,  107,  107,  107,  107,  107,  107,   56,  107,   67,
     445      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     446      107,  107,  107,  107,  107,  107,  107,  107,  107,  101,
     447      107,  107,  107,    0,    0,    0,    0,    0,    0,    0,
     448        0,    0,    0,    0,    0,    0,    0,  127,    0,    0,
     449
     450        0,    0,    0,  119,    0,    0,    0,    0,    0,    0,
     451        0,  116,  116,    0,  120,    0,  116,  116,    0,    0,
    419452        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    420         0,    0,    0,    0,    0,  139,  117,  118,    0,  118,
    421       118,    0,    0,    6,  118,  114,    0,    0,    0,  118,
    422         0,  114,  114,  114,  114,    0,  115,    0,    0,  113,
    423       113,  113,  113,    0,  177,  178,    0,  183,  181,    0,
    424         0,    0,  107,    0,    0,    0,    0,    0,    0,    0,
    425         0,  106,   17,  106,  106,  106,  106,  106,  106,  106,
    426       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    427 
    428       106,   14,  106,  106,  106,  106,  106,  106,  106,  106,
    429       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    430        51,  106,  106,  106,   64,  106,  106,  106,  106,  106,
    431       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    432        91,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    433         0,    0,    0,    0,    0,    0,    0,    0,  126,    0,
    434         0,    0,    0,    0,  126,    0,    0,  184,    0,    0,
    435         0,    0,    0,    0,    0,  118,    0,  118,    0,  118,
    436         0,  118,    0,    0,  118,    0,  114,  114,    0,    0,
    437       115,  115,    0,  115,    0,  115,  113,  113,    0,    0,
    438 
    439         0,    0,    0,    0,    0,    0,    0,    0,  182,  106,
    440       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    441       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    442       106,  106,   21,  106,   24,  106,   27,  106,  106,  106,
    443       106,  106,  106,  106,   41,  106,   43,  106,  106,  106,
    444       106,  106,  106,  106,   56,  106,   67,  106,  106,  106,
    445       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    446       106,  106,  106,  106,  106,  100,  106,  106,  106,    0,
     453        0,  107,  107,   22,  107,  107,  107,  107,  107,  107,
     454      107,   15,  107,  107,  107,  107,  107,  107,  107,  107,
     455      107,  107,  107,  107,  107,  107,   23,   25,  107,   32,
     456      107,  107,  107,  107,   40,  107,  107,  107,  107,   49,
     457      107,  107,   54,  107,  107,   69,   72,   73,  107,  107,
     458      107,   79,  107,  107,  107,  107,  107,   89,   91,   93,
     459      107,  107,   98,  107,  107,  105,  107,    0,    0,    0,
     460
    447461        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    448         0,    0,    0,  126,    0,    0,    0,    0,    0,  118,
    449 
    450         0,    0,    0,    0,    0,    0,    0,  115,  115,    0,
    451       119,    0,  115,  115,    0,    0,    0,    0,    0,    0,
    452         0,    0,    0,    0,    0,    0,    0,  106,  106,   22,
    453       106,  106,  106,  106,  106,  106,  106,   15,  106,  106,
    454       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    455       106,  106,   23,   25,  106,   32,  106,  106,  106,  106,
    456        40,  106,  106,  106,  106,   49,  106,  106,   54,  106,
    457       106,   71,   72,  106,  106,  106,   78,  106,  106,  106,
    458       106,  106,   88,   90,   92,  106,  106,   97,  106,  106,
    459       104,  106,    0,    0,    0,    0,    0,    0,    0,    0,
    460 
     462        0,    0,    0,    0,    0,    0,  120,    0,    0,  116,
     463      120,  120,  120,  120,    0,  116,    0,    0,    0,    0,
     464        0,    0,    0,    0,    0,    0,  107,    0,  107,  107,
     465      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
     466      107,  107,  107,  107,   59,  107,  107,  107,  107,  107,
     467      107,  107,  107,   28,  107,  107,  107,   39,   42,   45,
     468      107,  107,   52,  107,   61,   68,  107,  107,   78,   80,
     469       83,   84,   86,   87,  107,  107,   95,  107,  107,  106,
     470        0,    1,    0,    0,    0,    0,    0,    0,  110,    0,
     471
     472        0,    0,  127,    0,    0,    0,    0,  120,    0,  120,
     473      120,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     474      107,  107,   18,  107,  107,  107,  107,  107,  107,  107,
     475       16,  107,  107,  107,   33,  107,  107,  107,  107,  107,
     476      107,  107,  107,  107,  107,  107,  107,   36,   37,  107,
     477       48,   53,  107,  107,  107,   94,  107,  107,    0,    0,
    461478        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    462         0,  119,    0,    0,  115,  119,  119,  119,  119,    0,
    463       115,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    464         0,  106,    0,  106,  106,  106,  106,  106,  106,  106,
    465       106,  106,  106,  106,  106,  106,  106,  106,  106,   59,
    466       106,  106,  106,  106,  106,  106,  106,  106,   28,  106,
    467       106,  106,   39,   42,   45,  106,  106,   52,  106,   61,
    468        68,  106,  106,   77,   79,   82,   83,   85,   86,  106,
    469       106,   94,  106,  106,  105,    0,    1,    0,    0,    0,
    470         0,    0,    0,  109,    0,    0,    0,  126,    0,    0,
    471 
    472         0,    0,  119,    0,  119,  119,    0,    0,    0,    0,
    473         0,    0,    0,    0,    0,  106,  106,   18,  106,  106,
    474       106,  106,  106,  106,  106,   16,  106,  106,  106,   33,
    475       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    476       106,  106,   36,   37,  106,   48,   53,  106,  106,  106,
    477        93,  106,  106,    0,    0,    0,    0,    0,    0,    0,
    478         0,    0,    0,    0,    0,    0,   10,   11,   29,   55,
    479       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
    480       106,   60,   62,   65,  106,  106,   80,   95,  106,  106,
    481        35,  106,   47,   73,   74,  106,   98,  101,    0,    0,
    482 
    483         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    484       106,   69,  106,  106,   12,  106,  106,   30,   34,  106,
    485       106,  106,   66,  106,  106,  106,  106,  106,  106,  106,
    486         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    487         0,    0,    0,   58,  106,  106,  106,  106,  106,  106,
    488       106,   50,   63,   75,   81,   96,  102,  106,  106,  106,
    489         0,    0,    0,    0,    0,    0,    0,    0,  106,  106,
    490        13,   19,  106,  106,   31,  106,  106,  106,   26,   46,
    491        89,    0,    0,  106,  106,  106,  106,  106,  106,   76,
    492       103,  106,   87,   20,  106,  106,   44,   84,  106,  106,
    493 
    494       106,  106,  106,  106,  106,   99,   70,    0
     479        0,   10,   11,   29,   55,  107,  107,  107,  107,  107,
     480      107,  107,  107,  107,  107,  107,   60,   62,   65,  107,
     481      107,   81,   96,  107,  107,   35,  107,   47,   74,   75,
     482
     483      107,   99,  102,    0,    0,    0,    0,    0,    0,    0,
     484        0,    0,    0,    0,    0,  107,   70,  107,  107,   12,
     485      107,  107,   30,   34,  107,  107,  107,   66,  107,  107,
     486      107,  107,  107,  107,  107,    0,    0,    0,    0,    0,
     487        0,    0,    0,    0,    0,    0,    0,    0,   58,  107,
     488      107,  107,  107,  107,  107,  107,   50,   63,   76,   82,
     489       97,  103,  107,  107,  107,    0,    0,    0,    0,    0,
     490        0,    0,    0,  107,  107,   13,   19,  107,  107,   31,
     491      107,  107,  107,   26,   46,   90,    0,    0,  107,  107,
     492      107,  107,  107,  107,   77,  104,  107,   88,   20,  107,
     493
     494      107,   44,   85,  107,  107,  107,  107,  107,  107,  107,
     495      100,   71,    0
    495496    } ;
    496497
     
    540541    } ;
    541542
    542 static yyconst flex_int16_t yy_base[1083] =
     543static yyconst flex_int16_t yy_base[1088] =
    543544    {   0,
    544         0,   84, 2330, 2327,   94,    0,  177,  178,  179,  180,
    545      2341, 2877,  191, 2877,  197,   55, 2877, 2287,   60,  173,
    546      2877, 2877, 2877,   56,  188, 2877,  191,  189,  204,  216,
    547       275,    0, 2306, 2877,  216, 2305,  152,  344,  155,  220,
    548      2877,  159, 2877,  217,  226, 2877,  185,  154,  212,  251,
    549       237,  270,  235,  257,  241,  279,  193,  305,  314,  351,
    550       238,  228,  227, 2877,  225, 2877, 2300,  406,  412, 2877,
    551      2309, 2877, 2277,  235, 2877,    0, 2877,  439,    0, 2877,
    552       426, 2877,  452,  464, 2877,  511, 2276,  264, 2877, 2877,
    553      2877, 2877, 2877, 2293, 2877, 2290, 2877, 2877, 2300,  572,
    554 
    555      2877, 2317, 2877,  451,  457,  524,  547,  298,  253,  197,
    556       312,  279,    0,  342,  325,  198,  322, 2877, 2877, 2877,
    557      2287, 2877, 2877, 2877, 2285, 2282,  218,  312, 2295,  350,
    558       363,  368,  369,  391,  411,  417, 2276,  452, 2225,  453,
    559      2254, 2877,  274, 2877, 2877,  438, 2248, 2245, 2877, 2218,
    560       435,  282,  353,  277,  391,  419,  442,  320,  583,  451,
    561       446,  443,  479,  469,  364,  472,  481,  454,  458,  484,
    562       503,  493,  352,  506,  486,  453,  507,  509, 2246,  539,
    563       532,  524,  516,  528,  556,  530,  540,  552,  553,  564,
    564       574,  538,  576,  613,  573,  597,  602,  571, 2877, 2877,
    565 
    566       668,  674, 2294,  680, 2877,  686, 2877, 2241,  603, 2235,
    567      2234,    0,  683, 2877, 2877,  692, 2233, 2231, 2211,    0,
    568      2233,  556,  627,  630,  662,  699,  688,  692,  693,  696,
    569      2230,  700,  703, 2205, 2202, 2877,    0,  695,  726,  693,
    570       701, 2201, 2253, 2877,  747,  742,  700,  753,  760,  793,
    571       815,  746, 2877, 2210, 2183,    0,  802, 2227,  801,  754,
    572      2877, 2203, 2178,  839, 2877, 2877, 2210, 2877, 2877,  709,
    573       723, 2187, 2185,  755, 2181, 2180, 2178,    0, 2175,    0,
    574      2144,  694,  736,  737,  741,  614,  739,  738,  742,  798,
    575       807,  792,  802,  797,  746,  816,  748,  791,  824,  819,
    576 
    577       826, 2174,  827,  830,  831,  440,  834,  838,  836,  843,
    578       847,  849,  841,  850,  861,  853,  862,  851,  863,  865,
    579       872,  864,  873,  874, 2173,  749,  875,  876,  878,  880,
    580       881,  882,  884,  885,  886,  888,  889,  892,  898,  896,
    581      2171,  899,  906,  944,  901,  907,  913,  917,  908,  911,
    582       976,  977, 2165, 2164, 2163,    0, 2161,    0,  964,  968,
    583      2158,    0, 2157,    0, 2156,    0, 2176, 2877,  964,  967,
    584      2153, 2147,    0, 2143,    0, 2877,  979,  998,  990, 2877,
    585      1004, 1044, 2141, 1020, 1066, 2139, 2877, 2877,  963, 1006,
    586      1052, 1005, 1091,  968, 1083, 1006, 2877, 2877, 2136, 2134,
    587 
    588      2132,    0, 2129,    0, 2126,    0, 2125,    0, 2877,  931,
    589       981,  985,  928, 1024,  987, 1068,  958, 1070, 1060, 1010,
    590      1005, 1072, 1083, 1022, 1078, 1082, 1088, 1042, 1084, 1081,
    591      1089, 1097, 2127, 1090, 2125, 1095, 2122, 1093, 1091, 1109,
    592      1101, 1111, 1115, 1116, 2119, 1118, 2118, 1119, 1120, 1121,
    593      1123, 1126, 1127, 1128, 2117, 1129, 2115, 1131, 1134, 1135,
    594      1132, 1138, 1140, 1143, 1148, 1149, 1150, 1152, 1155, 1151,
    595      1161, 1164, 1166, 1168, 1169, 2112, 1170, 1172, 1175, 1221,
    596      2106,    0, 2105,    0, 2104,    0, 2102,    0, 1216, 2099,
    597         0, 2096,    0, 2095, 2094, 2092,    0, 2089,    0, 1223,
    598 
    599      2086, 1229, 1245, 1231, 1270, 1236, 1186, 1185, 2877, 1286,
    600      1304, 1297, 2097, 2072, 2082, 2079,    0, 2076,    0, 2075,
    601         0, 2074,    0, 2072,    0, 2069,    0, 1190, 1210, 2069,
    602      1191, 1227, 1212, 1230, 1253, 1246, 1254, 1280, 1281, 1282,
    603      1284, 1228, 1287, 1286, 1288, 1285,  234, 1293, 1289, 1304,
    604      1300, 1305, 2068, 1322, 1306, 2067, 1308, 1313, 1318, 1320,
    605      2065, 1323, 1324, 1326, 1327, 2062, 1330, 1331, 2061, 1334,
    606      1335, 2060, 2058, 1337, 1339, 1340, 2055, 1004, 1346, 1347,
    607      1348, 1349, 1364, 2054, 2053, 1351, 1353, 2051, 1350, 1355,
    608      2018, 1362, 2066, 2012,    0, 2009,    0, 2006,    0, 2005,
    609 
    610         0, 2004,    0, 2002,    0, 1999,    0, 1996,    0, 1401,
    611      1407, 1435, 1418, 1995, 2877, 1424, 1411, 1421, 1427, 1994,
    612      2877, 1992,    0, 1989,    0, 1988,    0, 1987,    0,    0,
    613         0, 1988,    0, 1412, 1422, 1419, 1387, 1369, 1416, 1433,
    614      1436, 1403, 1446, 1441, 1431, 1432, 1451, 1452, 1455, 1456,
    615      1457, 1486, 1460, 1461, 1462, 1464, 1463, 1467, 1985, 1465,
    616      1468, 1470, 1984, 1983, 1981, 1472, 1466, 1974, 1478, 1972,
    617      1971, 1480, 1484, 1968, 1964, 1960, 1956, 1953, 1952, 1487,
    618      1494, 1951, 1497, 1483, 1949, 1996, 2877, 1942,    0, 1941,
    619         0,    0,    0, 1942,    0,    0,    0, 2877,    0,    0,
    620 
    621         0,    0, 1537, 1936, 2877, 2877, 1543, 1935,    0, 1934,
    622         0,    0,    0,    0, 1932, 1499, 1519, 1932, 1500, 1524,
    623      1530, 1501, 1502, 1533, 1537, 1931, 1532, 1541, 1534, 1539,
    624      1544,  599, 1548, 1549, 1579, 1556, 1557, 1560, 1561, 1562,
    625      1563, 1564, 1930, 1928, 1567, 1925, 1924, 1566, 1569, 1572,
    626      1923, 1574, 1578,    0,    0,    0, 1918, 1915, 1914, 1624,
    627         0, 1913, 1911, 1908, 1907, 1906, 1907, 1904, 1903, 1902,
    628      1580, 1588, 1576, 1577, 1601, 1583, 1602, 1589, 1604, 1603,
    629      1636, 1900, 1609, 1897, 1610, 1614, 1617, 1622, 1618, 1623,
    630      1896, 1624, 1895, 1893, 1886, 1626, 1884, 1883, 1877, 1876,
    631 
    632      1875, 1873, 1856, 1847, 1846, 1843, 1836, 1833, 1826, 1824,
    633      1628, 1826, 1629, 1630, 1631, 1632, 1635, 1637, 1805, 1639,
    634      1667, 1642, 1804, 1643, 1653, 1658, 1651, 1652, 1659, 1662,
    635      1800, 1793, 1791, 1790, 1748, 1745, 1744, 1742, 1741, 1737,
    636      1735, 1733, 1732, 1734, 1663, 1664, 1666, 1672, 1673, 1674,
    637      1675, 1731, 1689, 1676, 1644, 1522, 1680, 1685, 1686, 1687,
    638      1500, 1411, 1363, 1362, 1260, 1219, 1218, 1047, 1690, 1688,
    639      1046, 1700, 1695, 1701,  924, 1704, 1708, 1709,  839,  794,
    640       759,  702,  636, 1682, 1710, 1713, 1714, 1715, 1717,  638,
    641       536, 1719,  488,  441, 1721, 1722,  408,  281, 1723, 1726,
    642 
    643      1727, 1729, 1728, 1730, 1733,  233,  137, 2877, 1805, 1818,
    644      1831, 1841, 1851, 1864, 1874, 1887, 1900, 1913, 1921, 1931,
    645      1938, 1945, 1952, 1959, 1966, 1973, 1980, 1987, 1994, 2001,
    646      2005, 2013, 2019, 2026, 2033, 2040, 2047, 2050, 2057, 2063,
    647      2076, 2089, 2096, 2103, 2110, 2117, 2120, 2127, 2130, 2137,
    648      2140, 2147, 2150, 2157, 2160, 2167, 2170, 2177, 2180, 2187,
    649      2195, 2202, 2209, 2216, 2223, 2226, 2233, 2236, 2243, 2246,
    650      2253, 2259, 2272, 2279, 2286, 2289, 2296, 2299, 2306, 2309,
    651      2316, 2319, 2326, 2329, 2336, 2339, 2346, 2353, 2356, 2363,
    652      2366, 2373, 2380, 2387, 2390, 2397, 2400, 2407, 2410, 2417,
    653 
    654      2420, 2427, 2430, 2437, 2443, 2456, 2463, 2470, 2473, 2480,
    655      2483, 2490, 2493, 2500, 2503, 2510, 2513, 2520, 2523, 2530,
    656      2533, 2540, 2543, 2550, 2557, 2560, 2567, 2570, 2577, 2580,
    657      2587, 2590, 2593, 2599, 2606, 2615, 2622, 2629, 2632, 2639,
    658      2642, 2645, 2651, 2658, 2661, 2664, 2667, 2670, 2673, 2676,
    659      2679, 2686, 2689, 2696, 2699, 2702, 2705, 2708, 2718, 2725,
    660      2728, 2731, 2734, 2741, 2748, 2755, 2758, 2765, 2772, 2779,
    661      2786, 2793, 2800, 2807, 2814, 2821, 2828, 2835, 2842, 2849,
    662      2856, 2863
     545        0,   84, 2340, 2339,   94,    0,  177,  178,  179,  180,
     546     2355, 2883,  191, 2883,  197,   55, 2883, 2300,   60,  173,
     547     2883, 2883, 2883,   56,  188, 2883,  191,  189,  204,  216,
     548      275,    0, 2317, 2883,  216, 2315,  152,  344,  155,  220,
     549     2883,  159, 2883,  217,  226, 2883,  185,  154,  212,  251,
     550      237,  270,  235,  257,  241,  204,  279,  193,  305,  314,
     551      351,  238,  228,  268, 2883,  257, 2883, 2312,  406,  412,
     552     2883, 2323, 2883, 2290,  235, 2883,    0, 2883,  439,    0,
     553     2883,  426, 2883,  452,  464, 2883,  511, 2287,  258, 2883,
     554     2883, 2883, 2883, 2883, 2303, 2883, 2302, 2883, 2883, 2314,
     555
     556      572, 2883, 2330, 2883,  451,  457,  524,  547,  298,  285,
     557      197,  312,  305,    0,  342,  325,  198,  322, 2883, 2883,
     558     2883, 2298, 2883, 2883, 2883, 2295, 2294,  218,  312, 2309,
     559      350,  388,  368,  363,  413,  369,  391, 2289,  417, 2236,
     560      418, 2264, 2883,  274, 2883, 2883,  477, 2260, 2259, 2883,
     561     2231,  419,  390,  432,  431,  435,  446,  447,  282,  583,
     562      437,  452,  458,  479,  468,  244,  472,  481,  484,  488,
     563      485,  503,  487,  442,  364,  505,  332,  504,  516, 2257,
     564      534,  535,  524,  532,  528,  530,  555,  551,  525,  574,
     565      548,  564,  568,  540,  572,  609,  597,  586,  600,  602,
     566
     567     2883, 2883,  674,  665, 2304,  680, 2883,  692, 2883, 2253,
     568      609, 2249, 2247,    0,  667, 2883, 2883,  686, 2244, 2241,
     569     2240,    0, 2263,  664,  668,  689,  695,  694,  690,  699,
     570      700,  703, 2259,  706,  707, 2217, 2215, 2883,    0,  700,
     571      727,  682,  717, 2214, 2264, 2883,  744,  739,  725,  763,
     572      781,  803,  825,  699, 2883, 2220, 2195,    0,  811, 2241,
     573      812,  723, 2883, 2216, 2189,  849, 2883, 2883, 2220, 2883,
     574     2883,  725,  742, 2199, 2199,  734, 2194, 2191, 2188,    0,
     575     2187,    0, 2158,  620,  726,  740,  729,  724,  743,  739,
     576      760,  749,  788,  805,  762,  781,  812,  825,  763,  761,
     577
     578      831,  829,  817, 2187,  832,  833,  836,  571,  837,  840,
     579      839,  843,  846,  847,  849,  854,  859,  855,  864,  862,
     580      867,  869,  870,  866,  876,  878, 2184,  443,  880,  879,
     581      608,  881,  883,  882,  884,  886,  893,  889,  887,  890,
     582      897,  899,  901, 2181,  902,  903,  949,  908,  911,  915,
     583      920,  916,  918,  978,  979, 2177, 2176, 2174,    0, 2171,
     584        0,  967,  971, 2170,    0, 2169,    0, 2167,    0, 2186,
     585     2883,  966,  967, 2165, 2162,    0, 2160,    0, 2883,  980,
     586     1001,  991, 2883, 1007, 1047, 2157, 1023, 1069, 2153, 2883,
     587     2883,  964,  966, 1055, 1008, 1094,  969, 1086, 1009, 2883,
     588
     589     2883, 2149, 2147, 2145,    0, 2142,    0, 2140,    0, 2138,
     590        0, 2883,  922,  986,  988, 1008, 1036,  990, 1071, 1007,
     591     1073, 1000, 1012, 1025, 1063, 1075, 1081, 1084, 1085, 1093,
     592     1088, 1030, 1087, 1095, 1096, 2138, 1086, 2135, 1104, 2134,
     593     1099, 1106, 1110, 1107, 1112, 1117, 1113, 2133, 1119, 2131,
     594     1121, 1124, 1125, 1126, 1127, 1129, 1135, 2128, 1133, 2125,
     595     1131, 1136, 1137, 1138, 1139, 1143, 1145, 1151, 1152, 1153,
     596     1155,  764, 1157, 1156, 1158, 1166, 1169, 1167, 1172, 2124,
     597     1170, 1176, 1179, 1238, 2120,    0, 2118,    0, 2115,    0,
     598     2112,    0, 1225, 2111,    0, 2110,    0, 2108, 2105, 2102,
     599
     600        0, 2101,    0, 1229, 2100, 1235, 1251, 1237, 1276, 1242,
     601     1193, 1193, 2883, 1292, 1310, 1303, 2110, 2083, 2092, 2091,
     602        0, 2090,    0, 2088,    0, 2085,    0, 2082,    0, 2081,
     603        0, 1174, 1214, 2083, 1178, 1211, 1258, 1233, 1259, 1213,
     604     1286, 1257, 1269, 1287, 1234, 1288, 1290, 1303, 1293, 1292,
     605      234, 1306, 1294, 1295, 1310, 1317, 2081, 1327, 1324, 2078,
     606     1311, 1314, 1326, 1330, 2075, 1331, 1332, 1334, 1335, 2074,
     607     1336, 1337, 2073, 1338, 1343, 2071, 2068, 2067, 1344, 1345,
     608     1348, 2066, 1228, 1353, 1354, 1355, 1356, 1370, 2064, 2061,
     609     1360, 1357, 2060, 1359, 1362, 2059, 1371, 2107, 2021,    0,
     610
     611     2019,    0, 2018,    0, 2015,    0, 2012,    0, 2011,    0,
     612     2010,    0, 2008,    0, 1408, 1414, 1442, 1425, 2005, 2883,
     613     1431, 1418, 1239, 1432, 2002, 2883, 2001,    0, 2000,    0,
     614     1998,    0, 1995,    0,    0,    0, 1997,    0, 1419, 1422,
     615     1426, 1394, 1374, 1421, 1436, 1438, 1410, 1448, 1441, 1439,
     616     1449, 1453, 1456, 1458, 1459, 1460, 1491, 1466, 1465, 1467,
     617     1468, 1470, 1469, 1996, 1471, 1474, 1479, 1994, 1991, 1990,
     618     1482, 1472, 1989, 1483, 1987, 1980, 1484, 1490, 1978, 1977,
     619     1974, 1970, 1966, 1962, 1489, 1495, 1959, 1501, 1503, 1958,
     620     2007, 2883, 1952,    0, 1949,    0,    0,    0, 1951,    0,
     621
     622        0,    0, 2883,    0,    0,    0,    0, 1549, 1947, 2883,
     623     2883, 1541, 1945,    0, 1942,    0,    0,    0,    0, 1941,
     624     1487, 1507, 1943, 1504, 1525, 1526, 1509, 1533, 1538, 1527,
     625     1941, 1528, 1542, 1547, 1543, 1548, 1578, 1550, 1551, 1580,
     626     1558, 1563, 1565, 1567, 1566, 1568, 1572, 1938, 1937, 1570,
     627     1936, 1934, 1571, 1574, 1582, 1931, 1575, 1585,    0,    0,
     628        0, 1927, 1926, 1924, 1627,    0, 1921, 1920, 1919, 1917,
     629     1914, 1916, 1915, 1913, 1910, 1584, 1590, 1587, 1595, 1605,
     630     1586, 1606, 1608, 1611, 1612, 1641, 1909, 1616, 1908, 1617,
     631     1621, 1624, 1626, 1618, 1622, 1906, 1631, 1903, 1902, 1901,
     632
     633     1632, 1899, 1892, 1887, 1886, 1883, 1882, 1881, 1879, 1862,
     634     1853, 1852, 1849, 1842, 1839, 1635, 1835, 1636, 1638, 1637,
     635     1639, 1643, 1644, 1833, 1642, 1674, 1649, 1832, 1650, 1663,
     636     1664, 1659, 1291, 1658, 1665, 1808, 1807, 1806, 1799, 1797,
     637     1796, 1754, 1751, 1750, 1748, 1747, 1746, 1741, 1742, 1670,
     638     1671, 1673, 1675, 1677, 1679, 1680, 1741, 1739, 1683, 1737,
     639     1693, 1685, 1687, 1690, 1689, 1689, 1650, 1648, 1503, 1422,
     640     1370, 1369, 1186, 1694, 1699, 1053, 1705, 1700, 1706, 1049,
     641     1709, 1713, 1714, 1015,  968,  930,  798,  764, 1707, 1715,
     642     1718, 1719, 1720, 1722,  644,  570, 1724,  539,  493, 1726,
     643
     644     1728,  407,  286, 1731, 1732, 1733, 1735, 1734, 1736, 1738,
     645      233,  137, 2883, 1811, 1824, 1837, 1847, 1857, 1870, 1880,
     646     1893, 1906, 1919, 1927, 1937, 1944, 1951, 1958, 1965, 1972,
     647     1979, 1986, 1993, 2000, 2007, 2011, 2019, 2025, 2032, 2039,
     648     2046, 2053, 2056, 2063, 2069, 2082, 2095, 2102, 2109, 2116,
     649     2123, 2126, 2133, 2136, 2143, 2146, 2153, 2156, 2163, 2166,
     650     2173, 2176, 2183, 2186, 2193, 2201, 2208, 2215, 2222, 2229,
     651     2232, 2239, 2242, 2249, 2252, 2259, 2265, 2278, 2285, 2292,
     652     2295, 2302, 2305, 2312, 2315, 2322, 2325, 2332, 2335, 2342,
     653     2345, 2352, 2359, 2362, 2369, 2372, 2379, 2386, 2393, 2396,
     654
     655     2403, 2406, 2413, 2416, 2423, 2426, 2433, 2436, 2443, 2449,
     656     2462, 2469, 2476, 2479, 2486, 2489, 2496, 2499, 2506, 2509,
     657     2516, 2519, 2526, 2529, 2536, 2539, 2546, 2549, 2556, 2563,
     658     2566, 2573, 2576, 2583, 2586, 2593, 2596, 2599, 2605, 2612,
     659     2621, 2628, 2635, 2638, 2645, 2648, 2651, 2657, 2664, 2667,
     660     2670, 2673, 2676, 2679, 2682, 2685, 2692, 2695, 2702, 2705,
     661     2708, 2711, 2714, 2724, 2731, 2734, 2737, 2740, 2747, 2754,
     662     2761, 2764, 2771, 2778, 2785, 2792, 2799, 2806, 2813, 2820,
     663     2827, 2834, 2841, 2848, 2855, 2862, 2869
    663664    } ;
    664665
    665 static yyconst flex_int16_t yy_def[1083] =
     666static yyconst flex_int16_t yy_def[1088] =
    666667    {   0,
    667       908,    1,  909,  909,  908,    5,  910,  910,  911,  911,
    668       908,  908,  908,  908,  908,  908,  908,  912,  908,  908,
    669       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    670       908,   31,  908,  908,  908,  908,  908,  908,  913,  912,
    671       908,  908,  908,  908,  912,  908,  912,  912,  912,  912,
    672       912,  912,  912,  912,  912,  912,  912,  912,  912,  912,
    673       912,  912,  912,  908,  908,  908,  908,  908,  914,  908,
    674       908,  908,  915,  908,  908,  916,  908,  908,  917,  908,
    675       908,  908,  908,  908,  908,  908,  912,  908,  908,  908,
    676       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    677 
    678       908,  918,  908,  908,   30,  908,  908,  908,  908,  919,
    679        30,  908,   31,  908,  908,   31,  908,  908,  908,  908,
    680       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    681       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    682       920,  908,  908,  908,  908,  912,  921,  922,  908,  908,
    683       912,  912,  912,  912,  912,  912,  912,  912,  912,  912,
    684       912,  912,  912,  912,  912,  912,  912,  912,  912,  912,
    685       912,  912,  912,  912,  912,  912,  912,  912,  912,  912,
    686       912,  912,  912,  912,  912,  912,  912,  912,  912,  912,
    687       912,  912,  912,  912,  912,  912,  912,  912,  908,  908,
    688 
    689       908,  914,  914,  914,  908,  914,  908,  915,  908,  923,
    690       924,  916,  908,  908,  908,  908,  925,  926,  927,  917,
    691       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    692       908,  908,  908,  928,  929,  908,  100,  908,  908,  908,
    693       908,  100,  918,  908,  100,  111,  246,  908,  908,  908,
    694       908,  908,  908,  908,  908,  930,  931,  932,  908,  908,
    695       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    696       908,  908,  933,  908,  934,  935,  936,  937,  938,  939,
    697       908,  940,  940,  940,  940,  940,  940,  940,  940,  940,
    698       940,  940,  940,  940,  940,  940,  940,  940,  940,  940,
    699 
    700       940,  940,  940,  940,  940,  940,  940,  940,  940,  940,
    701       940,  940,  940,  940,  940,  940,  940,  940,  940,  940,
    702       940,  940,  940,  940,  940,  940,  940,  940,  940,  940,
    703       940,  940,  940,  940,  940,  940,  940,  940,  940,  940,
    704       940,  940,  940,  940,  940,  940,  940,  940,  940,  940,
    705       941,  942,  943,  944,  945,  946,  947,  948,  908,  908,
    706       949,  950,  951,  952,  953,  954,  908,  908,  908,  908,
    707       908,  955,  956,  957,  958,  908,  908,  908,  908,  908,
    708       908,  908,  382,  908,  378,  385,  908,  908,  959,  960,
    709       961,  908,  908,  908,  961,  908,  908,  908,  962,  963,
    710 
    711       964,  965,  966,  967,  968,  969,  970,  971,  908,  972,
    712       972,  972,  972,  972,  972,  972,  972,  972,  972,  972,
    713       972,  972,  972,  972,  972,  972,  972,  972,  972,  972,
    714       972,  972,  972,  972,  972,  972,  972,  972,  972,  972,
    715       972,  972,  972,  972,  972,  972,  972,  972,  972,  972,
    716       972,  972,  972,  972,  972,  972,  972,  972,  972,  972,
    717       972,  972,  972,  972,  972,  972,  972,  972,  972,  972,
    718       972,  972,  972,  972,  972,  972,  972,  972,  972,  973,
    719       974,  975,  976,  977,  978,  979,  980,  981,  908,  982,
    720       983,  984,  985,  986,  986,  987,  988,  989,  990,  908,
    721 
    722       500,  908,  908,  991,  908,  991,  908,  908,  908,  908,
    723       908,  908,  908,  908,  992,  993,  994,  995,  996,  997,
    724       998,  999, 1000, 1001, 1002, 1003, 1004, 1005, 1005, 1005,
    725      1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,
    726      1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,
    727      1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,
    728      1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,
    729      1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,
    730      1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,
    731      1005, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013,
    732 
    733      1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022,  908,
    734       908,  908,  908, 1023,  908,  612,  908,  908,  908,  616,
    735       908, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032,
    736      1033, 1034, 1035, 1034, 1034, 1034, 1034, 1034, 1034, 1034,
    737      1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034,
    738      1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034,
    739      1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034,
    740      1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034,
    741      1034, 1034, 1034, 1034, 1034, 1036,  908, 1037, 1038, 1039,
    742      1040, 1041, 1042, 1043, 1044, 1045, 1046,  908, 1047, 1048,
    743 
    744      1049, 1050,  908,  703,  908,  908,  908, 1051, 1052, 1053,
    745      1054, 1055, 1056, 1057, 1058, 1059, 1059, 1059, 1059, 1059,
    746      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    747      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    748      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    749      1059, 1059, 1059, 1060, 1061, 1062, 1063, 1064, 1065,  908,
    750      1066, 1051, 1053, 1067, 1068, 1058, 1059, 1059, 1059, 1059,
    751      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    752      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    753      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1069, 1070,
    754 
    755      1063, 1071, 1064, 1072, 1065, 1073, 1074, 1067, 1075, 1068,
    756      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    757      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    758      1076, 1069, 1077, 1070, 1078, 1071, 1079, 1072, 1080, 1073,
    759      1081, 1074, 1075, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    760      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    761      1082, 1076, 1077, 1078, 1079, 1053, 1080, 1081, 1059, 1059,
    762      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    763      1059, 1082, 1053, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    764      1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,
    765 
    766      1059, 1059, 1059, 1059, 1059, 1059, 1059,    0,  908,  908,
    767       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    768       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    769       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    770       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    771       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    772       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    773       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    774       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    775       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    776 
    777       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    778       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    779       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    780       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    781       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    782       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    783       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    784       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    785       908,  908
     668      913,    1,  914,  914,  913,    5,  915,  915,  916,  916,
     669      913,  913,  913,  913,  913,  913,  913,  917,  913,  913,
     670      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     671      913,   31,  913,  913,  913,  913,  913,  913,  918,  917,
     672      913,  913,  913,  913,  917,  913,  917,  917,  917,  917,
     673      917,  917,  917,  917,  917,  917,  917,  917,  917,  917,
     674      917,  917,  917,  917,  913,  913,  913,  913,  913,  919,
     675      913,  913,  913,  920,  913,  913,  921,  913,  913,  922,
     676      913,  913,  913,  913,  913,  913,  913,  917,  913,  913,
     677      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     678
     679      913,  913,  923,  913,  913,   30,  913,  913,  913,  913,
     680      924,   30,  913,   31,  913,  913,   31,  913,  913,  913,
     681      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     682      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     683      913,  925,  913,  913,  913,  913,  917,  926,  927,  913,
     684      913,  917,  917,  917,  917,  917,  917,  917,  917,  917,
     685      917,  917,  917,  917,  917,  917,  917,  917,  917,  917,
     686      917,  917,  917,  917,  917,  917,  917,  917,  917,  917,
     687      917,  917,  917,  917,  917,  917,  917,  917,  917,  917,
     688      917,  917,  917,  917,  917,  917,  917,  917,  917,  917,
     689
     690      913,  913,  913,  919,  919,  919,  913,  919,  913,  920,
     691      913,  928,  929,  921,  913,  913,  913,  913,  930,  931,
     692      932,  922,  913,  913,  913,  913,  913,  913,  913,  913,
     693      913,  913,  913,  913,  913,  933,  934,  913,  101,  913,
     694      913,  913,  913,  101,  923,  913,  101,  112,  248,  913,
     695      913,  913,  913,  913,  913,  913,  913,  935,  936,  937,
     696      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     697      913,  913,  913,  913,  938,  913,  939,  940,  941,  942,
     698      943,  944,  913,  945,  945,  945,  945,  945,  945,  945,
     699      945,  945,  945,  945,  945,  945,  945,  945,  945,  945,
     700
     701      945,  945,  945,  945,  945,  945,  945,  945,  945,  945,
     702      945,  945,  945,  945,  945,  945,  945,  945,  945,  945,
     703      945,  945,  945,  945,  945,  945,  945,  945,  945,  945,
     704      945,  945,  945,  945,  945,  945,  945,  945,  945,  945,
     705      945,  945,  945,  945,  945,  945,  945,  945,  945,  945,
     706      945,  945,  945,  946,  947,  948,  949,  950,  951,  952,
     707      953,  913,  913,  954,  955,  956,  957,  958,  959,  913,
     708      913,  913,  913,  913,  960,  961,  962,  963,  913,  913,
     709      913,  913,  913,  913,  913,  385,  913,  381,  388,  913,
     710      913,  964,  965,  966,  913,  913,  913,  966,  913,  913,
     711
     712      913,  967,  968,  969,  970,  971,  972,  973,  974,  975,
     713      976,  913,  977,  977,  977,  977,  977,  977,  977,  977,
     714      977,  977,  977,  977,  977,  977,  977,  977,  977,  977,
     715      977,  977,  977,  977,  977,  977,  977,  977,  977,  977,
     716      977,  977,  977,  977,  977,  977,  977,  977,  977,  977,
     717      977,  977,  977,  977,  977,  977,  977,  977,  977,  977,
     718      977,  977,  977,  977,  977,  977,  977,  977,  977,  977,
     719      977,  977,  977,  977,  977,  977,  977,  977,  977,  977,
     720      977,  977,  977,  978,  979,  980,  981,  982,  983,  984,
     721      985,  986,  913,  987,  988,  989,  990,  991,  991,  992,
     722
     723      993,  994,  995,  913,  504,  913,  913,  996,  913,  996,
     724      913,  913,  913,  913,  913,  913,  913,  913,  997,  998,
     725      999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008,
     726     1009, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010,
     727     1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010,
     728     1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010,
     729     1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010,
     730     1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010,
     731     1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010, 1010,
     732     1010, 1010, 1010, 1010, 1010, 1010, 1010, 1011, 1012, 1013,
     733
     734     1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023,
     735     1024, 1025, 1026, 1027,  913,  913,  913,  913, 1028,  913,
     736      617,  913,  913,  913,  621,  913, 1029, 1030, 1031, 1032,
     737     1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1039, 1039,
     738     1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039,
     739     1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039,
     740     1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039,
     741     1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039,
     742     1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039,
     743     1041,  913, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049,
     744
     745     1050, 1051,  913, 1052, 1053, 1054, 1055,  913,  708,  913,
     746      913,  913, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063,
     747     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     748     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     749     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     750     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1065, 1066,
     751     1067, 1068, 1069, 1070,  913, 1071, 1056, 1058, 1072, 1073,
     752     1063, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     753     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     754     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     755
     756     1064, 1064, 1064, 1074, 1075, 1068, 1076, 1069, 1077, 1070,
     757     1078, 1079, 1072, 1080, 1073, 1064, 1064, 1064, 1064, 1064,
     758     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     759     1064, 1064, 1064, 1064, 1064, 1081, 1074, 1082, 1075, 1083,
     760     1076, 1084, 1077, 1085, 1078, 1086, 1079, 1080, 1064, 1064,
     761     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     762     1064, 1064, 1064, 1064, 1064, 1087, 1081, 1082, 1083, 1084,
     763     1058, 1085, 1086, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     764     1064, 1064, 1064, 1064, 1064, 1064, 1087, 1058, 1064, 1064,
     765     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     766
     767     1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064,
     768     1064, 1064,    0,  913,  913,  913,  913,  913,  913,  913,
     769      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     770      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     771      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     772      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     773      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     774      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     775      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     776      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     777
     778      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     779      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     780      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     781      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     782      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     783      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     784      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     785      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     786      913,  913,  913,  913,  913,  913,  913
    786787    } ;
    787788
    788 static yyconst flex_int16_t yy_nxt[2963] =
     789static yyconst flex_int16_t yy_nxt[2969] =
    789790    {   0,
    790791       12,   13,   14,   15,   15,   15,   13,   16,   17,   12,
     
    794795       18,   18,   18,   40,   18,   18,   18,   18,   18,   40,
    795796       18,   41,   42,   43,   44,   45,   46,   47,   48,   49,
    796        50,   51,   52,   53,   18,   54,   18,   55,   18,   18,
    797        56,   18,   57,   58,   59,   60,   61,   62,   18,   18,
    798        63,   64,   65,   66,   67,   68,   85,   93,   86,   86,
    799        68,   89,   90,   69,   72,   72,   72,   72,   72,   72,
    800 
    801        72,   72,   72,   72,   73,   72,   72,   72,   72,   72,
    802        72,   72,   72,   72,   72,   72,   72,   72,   72,   72,
    803        72,   72,   72,   72,   72,   72,   72,   72,   72,   73,
     797       50,   51,   52,   53,   18,   54,   18,   55,   56,   18,
     798       57,   18,   58,   59,   60,   61,   62,   63,   18,   18,
     799       64,   65,   66,   67,   68,   69,   86,   94,   87,   87,
     800       69,   90,   91,   70,   73,   73,   73,   73,   73,   73,
     801
     802       73,   73,   73,   73,   74,   73,   73,   73,   73,   73,
    804803       73,   73,   73,   73,   73,   73,   73,   73,   73,   73,
    805        73,   73,   73,   73,   73,   72,   74,   72,   72,   73,
    806        75,   73,   73,   73,   73,   73,   73,   73,   73,   73,
    807        73,   73,   73,   73,   73,   73,   73,   73,   73,   73,
    808        73,   73,   73,   73,   73,   72,   72,   72,   72,   77,
    809        77,   80,   80,  124,  125,   91,  142,   80,   80,   88,
    810        77,   77,   81,   82,   83,   83,   83,   81,   83,   82,
    811 
    812        84,   84,   84,   83,   92,   94,   88,  143,  147,   99,
    813        96,  100,  100,  100,  100,  100,  100,  256,  908,   95,
    814       101,   86,   97,   98,   86,  102,  162,  119,  144,   78,
    815        78,   78,   78,  145,  148,  103,  104,   88,  105,  105,
    816       105,  105,  106,  106,  120,   88,  121,  122,  149,  267,
    817       150,  268,  258,  264,  185,  107,  199,  652,  160,  108,
    818       161,  151,  152,  153,   88,  109,  110,  154,  155,  163,
    819       156,  111,   88,  157,  158,  146,  164,  107,   88,   88,
    820        88,  159,  165,  112,  210,   88,   88,   88,  198,   88,
    821        88,  109,  197,   88,  110,  104,  254,  113,  113,  113,
    822 
    823       113,  113,  113,   88,  170,  178,  171,  200,  196,   88,
    824       211,  181,  166,  234,  107,  172,  167,  182,  114,  179,
    825       255,  168,   88,  275,  115,  169,  180,  173,  253,   88,
    826       116,   88,  908,   88,   88,  174,  107,  175,  286,  235,
    827       176,  252,  117,  267,  177,  268,  252,  253,  183,  276,
    828       115,  126,  284,  184,  253,  127,  128,   88,  129,  144,
    829       130,  131,  908,  132,  145,  133,   88,  259,  262,  186,
    830       187,  261,   88,  253,  134,  135,  136,  194,  190,  188,
    831       269,  267,  189,  268,  290,  260,  191,  269,  192,  260,
    832       908,  261,  263,  193,  267,  137,  268,  261,  138,  267,
    833 
    834       267,  268,  268,   88,   88,   88,  146,  201,   82,   83,
    835        83,   83,  201,  204,  205,  202,   88,  261,  204,  318,
    836       195,  270,  267,  285,  268,  139,  140,   81,   82,   83,
    837        83,   83,   81,  309,  206,  206,  206,  206,  206,  206,
    838       213,  214,  267,   88,  268,  213,  144,  215,  267,  271,
    839       268,  145,  215,   83,   82,   83,   83,   83,   83,  287,
    840        88,  216,  216,  216,  216,   83,   82,   84,   84,   84,
    841        83,   88,  215,  245,  245,  245,  245,  245,  245,  246,
    842       246,  246,  246,  267,  267,  268,  268,   88,  217,  288,
    843        88,  215,   88,   88,   88,   88,  215,  215,   88,  436,
    844 
    845       215,  215,  282,   88,  304,   88,   88,  908,  215,  283,
    846        88,  215,  247,  215,  218,  215,  289,  219,  221,  302,
    847       303,   88,  222,  223,   88,  321,  307,  224,  225,  312,
    848       226,   88,  227,   88,  310,  908,   88,  313,   88,  308,
    849        88,  228,  229,  230,  104,   88,  106,  106,  106,  106,
    850       106,  106,  305,  306,  311,   88,  320,  314,   88,   88,
    851       315,   88,  231,  107,  249,  232,  249,  317,   88,  250,
    852       250,  250,  250,  250,  250,  319,   88,  328,  316,  248,
    853        88,  327,   88,  323,   88,  107,  322,  367,   88,  368,
    854        88,   88,   88,  233,  237,  237,  237,  237,  237,  237,
    855 
    856       333,  326,  251,  334,   88,   88,  324,  329,   88,  336,
    857       238,  239,  240,  325,  241,  240,   88,  342,  338,  330,
    858       335,  144,  781,   88,  337,   88,   88,  242,   88,  331,
    859       332,  340,  240,  239,  240,   88,  339,  241,  345,  240,
    860       291,  292,  293,  350,  294,  295,  346,  343,  296,   88,
    861       297,   88,  353,  341,   88,  298,  299,  300,  367,  301,
    862       368,  367,  347,  368,  348,   88,   88,  349,  344,  201,
    863        82,   83,   83,   83,  201,  204,  205,  202,  354,  368,
    864       204,  204,  205,  414,  213,  214,  204,  351,  205,  213,
    865        88,  908,  351,  367,  352,  368,  206,  206,  206,  206,
    866 
    867       206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
    868       206,  206,  206,  206,  359,  359,  359,  359,  368,  367,
    869       908,  368,  369,  367,  367,  368,  368,  367,  370,  368,
    870       367,  367,  368,  368,  367,  376,  368,  376,  376,  380,
    871       267,  380,  268,  377,  380,  377,   88,  360,  378,  378,
    872       378,  378,  378,  378,  267,  384,  268,  908,  376,  410,
    873       376,  380,  104,  380,  246,  246,  246,  246,  380,  382,
    874       382,  382,  382,  382,  382,  106,  106,  106,  106,  106,
    875       106,  379,  250,  250,  250,  250,  250,  250,   88,   88,
    876        88,   88,  107,   88,   88,  387,  415,  247,   88,  417,
    877 
    878        88,   88,  383,  397,  399,  428,  411,  412,  259,  413,
    879       416,   88,  457,  425,  107,  385,  385,  385,  385,  385,
    880       385,  387,  390,  106,  106,  106,  106,  106,  106,  397,
    881       400,  238,  249,  240,  249,  241,  240,  250,  250,  250,
    882       250,  250,  250,   88,   88,  392,   88,  393,  386,   88,
    883        88,  394,  429,  240,   88,  240,  259,  395,  241,   88,
    884       240,  113,  113,  113,  113,  113,  113,  422,   88,  396,
    885       418,   88,  423,  393,  419,  424,   88,  394,   88,   88,
    886       420,  421,   88,   88,  426,  427,   88,  434,   88,  430,
    887        88,   88,  435,   88,  264,   88,  432,  433,  431,   88,
    888 
    889       441,   88,   88,   88,  442,   88,  437,  443,  438,  439,
    890       440,  445,  444,   88,   88,   88,   88,   88,  449,  446,
    891       450,  447,  451,  448,   88,   88,   88,   88,   88,  452,
    892        88,  459,   88,   88,   88,  454,   88,   88,   88,  456,
    893        88,   88,  458,  455,   88,  461,  453,  466,   88,  460,
    894        88,   88,  144,   88,  465,  462,  464,  463,   88,   88,
    895        88,  471,  467,   88,  468,   88,  469,  473,  470,   88,
    896       472,  474,  475,  476,  477,  478,   88,  351,  205,  205,
    897        88,  479,  351,   88,  352,  203,  215,  215,  215,  215,
    898       359,  359,  359,  359,  528,  367,   88,  368,  367,  531,
    899 
    900       368,  378,  378,  378,  378,  378,  378,  377,  505,  377,
    901        88,  513,  378,  378,  378,  378,  378,  378,  506,  489,
    902       500,  500,  500,  500,  500,  500,  237,  237,  237,  237,
    903       237,  237,  535,   88,  505,  514,  238,   88,  240,   88,
    904       241,  240,  246,  246,  246,  246,  106,  106,  508,  529,
    905       533,  505,  530,  501,  509,  509,   88,   88,  240,  381,
    906       240,  507,   88,  241,  675,  240,  382,  382,  382,  382,
    907       382,  382,  390,  508,   88,  384,   88,  505,  538,  539,
    908       509,  509,  238,  239,  240,  532,  241,  240,  385,  385,
    909       385,  385,  385,  385,   88,  392,  543,  393,   88,  383,
    910 
    911       548,  394,  908,  908,  240,  239,  240,  395,  510,  241,
    912       510,  240,   88,  511,  511,  511,  511,  511,  511,  396,
    913        88,  386,   88,  393,   88,  537,  392,  394,  393,  534,
    914        88,  536,  394,   88,   88,   88,   88,  540,  515,  545,
    915        88,   88,   88,   88,  550,   88,  512,   88,  544,   88,
    916       396,  541,  542,   88,  393,  546,  553,  549,  394,  554,
    917       551,   88,  547,   88,  552,  556,  555,   88,   88,  559,
    918        88,   88,   88,   88,  557,   88,  558,  561,   88,   88,
    919        88,   88,  560,   88,   88,  562,   88,   88,  565,  569,
    920        88,  563,   88,  567,  564,   88,  573,  566,  570,  568,
    921 
    922        88,   88,   88,   88,   88,  574,  571,   88,  572,  578,
    923       575,  581,  576,   88,  582,  580,   88,  577,   88,  579,
    924        88,   88,   88,  205,   88,  585,  586,   88,  583,  593,
    925       592,  505,  589,  591,  615,  584,  587,  588,  215,  215,
    926       215,  215,   88,   88,  590,  500,  500,  500,  500,  500,
    927       500,  382,  382,  382,  382,  382,  382,  505,  636,  634,
    928       615,  238,   88,  240,   88,  241,  240,  385,  385,  385,
    929       385,  385,  385,  908,  883,  635,  505,  638,  501,   88,
    930        88,  505,   88,  240,  502,  240,  506,  611,  241,  611,
    931       240,  614,  612,  612,  612,  612,  612,  612,   88,  637,
    932 
    933       503,  647,  505,  641,  639,   88,   88,  505,  511,  511,
    934       511,  511,  511,  511,  510,  908,  510,  642,  640,  511,
    935       511,  511,  511,  511,  511,  613,  616,  616,  616,  616,
    936       616,  616,   88,   88,   88,  643,   88,   88,   88,   88,
    937        88,   88,  617,  649,  618,   88,  619,  618,  648,  645,
    938       651,  650,   88,  644,  653,  646,   88,   88,   88,  620,
    939        88,  656,  657,  654,  618,   88,  618,  659,  658,  619,
    940        88,  618,   88,  655,   88,   88,   88,  660,   88,   88,
    941       661,  663,   88,   88,  664,  662,   88,   88,  669,   88,
    942       666,   88,   88,  665,  667,  670,  671,  668,   88,   88,
    943 
    944        88,   88,   88,   88,  673,   88,  677,   88,  676,  674,
    945       680,  672,  681,  679,   88,  682,   88,  908,  908,  683,
    946       684,   88,  678,  500,  500,  500,  500,  500,  500,  612,
    947       612,  612,  612,  612,  612,  611,  685,  611,  721,   88,
    948       612,  612,  612,  612,  612,  612,  616,  616,  616,  616,
    949       616,  616,  720,  705,  705,   88,  610,  703,  703,  703,
    950       703,  703,  703,  705,   88,  706,  908,  706,   88,  716,
    951       706,   88,  725,  617,   88,  618,  705,  619,  618,  620,
    952       719,  718,  717,   88,   88,   88,  705,  706,   88,  706,
    953       704,  722,  723,   88,  706,  618,  724,  618,   88,  729,
    954 
    955       619,  726,  618,   88,   88,  728,  727,   88,   88,   88,
    956       735,  733,   88,   88,   88,   88,   88,   88,   88,   88,
    957        88,  731,   88,  738,   88,  730,  734,  736,  741,  732,
    958        88,  744,   88,  737,  739,   88,   88,  740,   88,   88,
    959       742,  748,  743,  749,  745,  746,   88,  747,  750,   88,
    960       753,   88,   88,   88,   88,  882,  751,  773,  752,  703,
    961       703,  703,  703,  703,  703,  616,  616,  616,  616,  616,
    962       616,   88,  767,  772,   88,  617,   88,  618,  769,  619,
    963       618,  768,   88,  770,   88,   88,   88,  771,  774,   88,
    964       776,   88,  704,   88,  779,  778,   88,  618,  707,  618,
    965 
    966        88,   88,  619,  782,  618,  784,  777,  775,   88,   88,
    967       783,  785,   88,   88,   88,   88,   88,  780,   88,   88,
    968       787,   88,  786,  788,   88,  791,   88,  789,   88,   88,
    969        88,   88,   88,  813,  797,   88,  790,  792,  794,  798,
    970        88,   88,  793,  795,  814,  796,  703,  703,  703,  703,
    971       703,  703,  811,   88,   88,   88,   88,  812,  816,  819,
    972       821,   88,   88,  815,  822,  823,   88,  818,  820,   88,
    973        88,  817,  825,  824,   88,   88,   88,  826,   88,  760,
    974        88,   88,   88,   88,   88,  827,  847,   88,   88,   88,
    975       849,   88,  850,  852,   88,   88,   88,  853,  828,  829,
    976 
    977       846,  830,  845,   88,   88,   88,  848,  844,  855,  851,
    978        88,   88,  857,  856,   88,   88,   88,  854,   88,   88,
    979       858,  871,  859,  870,   88,   88,   88,   88,   88,  875,
    980       860,  877,   88,  872,   88,  878,  869,   88,   88,   88,
    981        88,   88,   88,  873,  876,  885,  879,   88,  881,  874,
    982       880,  884,   88,   88,  892,  886,   88,  887,  888,  889,
    983        88,   88,   88,  890,  891,   88,   88,   88,  894,   88,
    984       896,   88,  897,   88,   88,   88,  895,  893,   88,   88,
    985        88,   88,   88,   88,  901,   88,   88,  908,  908,  900,
    986       868,  902,  908,  898,  899,  907,  867,  908,  905,  865,
    987 
    988       908,  903,  904,  864,  906,   70,   70,   70,   70,   70,
    989        70,   70,   70,   70,   70,   70,   70,   70,   76,   76,
    990        76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
    991        76,   79,   79,   79,   79,   79,   79,   79,   79,   79,
    992        79,   79,   79,   79,   87,  908,  863,   87,  908,   87,
    993        87,   87,   87,   87,  141,  862,   88,   88,  141,  141,
    994       141,  141,  141,  141,  203,  203,  203,  203,  203,  203,
    995       203,  203,  203,  203,  203,  203,  203,  208,   88,  908,
    996       208,  843,  208,  208,  208,  208,  208,  212,  908,  212,
    997       212,  842,  212,  212,  212,  212,  212,  212,  840,  212,
    998 
    999       220,  908,  838,  220,  220,  220,  220,  220,  220,  220,
    1000       220,  908,  220,  243,  243,  243,  243,  243,  243,  243,
    1001       243,  243,  243,  243,  243,  243,  257,  257,  836,  257,
    1002       908,  834,  832,  257,  273,   88,   88,  273,   88,  273,
    1003       273,  273,  273,  273,  277,   88,  277,   88,   88,   88,
    1004       277,  279,   88,  279,   88,   88,   88,  279,  355,   88,
    1005       355,  908,  810,  808,  355,  357,  908,  357,  908,  805,
    1006       803,  357,  361,  801,  361,   88,   88,   88,  361,  363,
    1007        88,  363,   88,   88,   88,  363,  365,  766,  365,  763,
    1008       762,  760,  365,  372,  209,  372,  756,  755,  687,  372,
    1009 
    1010       374,   88,  374,   88,   88,   88,  374,  389,   88,  389,
    1011       391,  391,   88,  391,  391,  391,   88,  391,  257,  257,
    1012        88,  257,  273,   88,   88,  273,   88,  273,  273,  273,
    1013       273,  273,  401,   88,  401,   88,   88,   88,  401,  403,
    1014        88,  403,  714,  713,  711,  403,  405,  709,  405,  707,
    1015       614,  702,  405,  277,  701,  277,  407,  699,  407,  697,
    1016       695,  693,  407,  279,  691,  279,   87,  689,  687,   87,
    1017        88,   87,   87,   87,   87,   87,  203,  203,  203,  203,
    1018       203,  203,  203,  203,  203,  203,  203,  203,  203,  480,
    1019       480,  480,  480,  480,  480,  480,  480,  480,  480,  480,
    1020 
    1021       480,  480,  481,   88,  481,   88,   88,   88,  481,  483,
    1022        88,  483,   88,   88,   88,  483,  485,   88,  485,   88,
    1023        88,   88,  485,  355,  633,  355,  487,  631,  487,  629,
    1024       627,  625,  487,  357,  623,  357,  490,  515,  490,  621,
    1025       621,  610,  490,  361,  609,  361,  492,  607,  492,  495,
    1026       495,  605,  492,  363,  603,  363,  494,  601,  494,  599,
    1027       597,  595,  494,  365,   88,  365,  496,   88,  496,   88,
    1028        88,   88,  496,  372,   88,  372,  498,   88,  498,   88,
    1029       527,  525,  498,  374,  523,  374,  504,  521,  504,  519,
    1030       504,  517,  504,  389,  503,  389,  502,  389,  499,  389,
    1031 
    1032       391,  391,  497,  391,  391,  391,  368,  391,  516,  368,
    1033       516,  495,  493,  491,  516,  518,  488,  518,  486,  484,
    1034       482,  518,  520,   88,  520,   88,   88,  409,  520,  401,
    1035       408,  401,  522,  406,  522,  404,  402,  274,  522,  403,
    1036       269,  403,  524,  268,  524,  398,  398,  256,  524,  405,
    1037       388,  405,  526,  388,  526,  244,  381,  375,  526,  407,
    1038       373,  407,   87,  371,  367,   87,  366,   87,   87,   87,
    1039        87,   87,  480,  480,  480,  480,  480,  480,  480,  480,
    1040       480,  480,  480,  480,  480,  594,  364,  594,  362,  358,
    1041       356,  594,  481,  209,  481,  596,  205,  596,   88,  281,
    1042 
    1043       280,  596,  483,  278,  483,  598,  274,  598,  269,  272,
    1044       269,  598,  485,  267,  485,  600,  266,  600,  265,  244,
    1045       236,  600,  487,   86,  487,  602,   86,  602,   88,  209,
    1046       207,  602,  490,   86,  490,  604,  123,  604,  118,   88,
    1047       908,  604,  492,   71,  492,  494,   71,  494,  908,  908,
    1048       908,  494,  606,  908,  606,  908,  908,  908,  606,  496,
    1049       908,  496,  608,  908,  608,  908,  908,  908,  608,  498,
    1050       908,  498,  504,  908,  504,  908,  504,  908,  504,  391,
    1051       908,  391,  908,  908,  908,  391,  622,  908,  622,  908,
    1052       908,  908,  622,  516,  908,  516,  624,  908,  624,  908,
    1053 
    1054       908,  908,  624,  518,  908,  518,  626,  908,  626,  908,
    1055       908,  908,  626,  520,  908,  520,  628,  908,  628,  908,
    1056       908,  908,  628,  522,  908,  522,  630,  908,  630,  908,
    1057       908,  908,  630,  524,  908,  524,  632,  908,  632,  908,
    1058       908,  908,  632,  526,  908,  526,   87,  908,  908,   87,
    1059       908,   87,   87,   87,   87,   87,  686,  686,  686,  686,
    1060       686,  686,  686,  686,  686,  686,  686,  686,  686,  688,
    1061       908,  688,  908,  908,  908,  688,  594,  908,  594,  690,
    1062       908,  690,  908,  908,  908,  690,  596,  908,  596,  692,
    1063       908,  692,  908,  908,  908,  692,  598,  908,  598,  694,
    1064 
    1065       908,  694,  908,  908,  908,  694,  600,  908,  600,  696,
    1066       908,  696,  908,  908,  908,  696,  602,  908,  602,  698,
    1067       908,  698,  908,  908,  908,  698,  604,  908,  604,  700,
    1068       908,  700,  908,  908,  908,  700,  606,  908,  606,   87,
    1069       908,   87,  908,  908,  908,   87,  608,  908,  608,  504,
    1070       908,  504,  908,  908,  908,  504,  708,  908,  708,  908,
    1071       908,  908,  708,  622,  908,  622,  710,  908,  710,  908,
    1072       908,  908,  710,  624,  908,  624,  712,  908,  712,  908,
    1073       908,  908,  712,  626,  908,  626,  141,  908,  141,  908,
    1074       908,  908,  141,  628,  908,  628,  715,  908,  715,  630,
    1075 
    1076       908,  630,   87,  908,  908,   87,  908,   87,   87,   87,
    1077        87,   87,  632,  908,  632,  686,  686,  686,  686,  686,
    1078       686,  686,  686,  686,  686,  686,  686,  686,  754,  908,
    1079       754,  908,  908,  908,  754,  688,  908,  688,  208,  908,
    1080       208,  908,  908,  908,  208,  690,  908,  690,  757,  908,
    1081       757,  692,  908,  692,  208,  908,  908,  208,  908,  208,
    1082       208,  208,  208,  208,  694,  908,  694,  758,  908,  758,
    1083       696,  908,  696,  698,  908,  698,  759,  908,  759,  700,
    1084       908,  700,   87,  908,   87,  761,  908,  761,  908,  908,
    1085       908,  761,  708,  908,  708,  273,  908,  273,  908,  908,
    1086 
    1087       908,  273,  710,  908,  710,  764,  908,  764,  712,  908,
    1088       712,  141,  908,  141,  765,  908,  765,  908,  908,  908,
    1089       765,   87,  908,  908,   87,  908,   87,   87,   87,   87,
    1090        87,  799,  908,  799,  754,  908,  754,  208,  908,  208,
    1091       800,  908,  800,  908,  908,  908,  800,  802,  908,  802,
    1092       908,  908,  908,  802,  804,  908,  804,  908,  908,  908,
    1093       804,  806,  908,  806,  807,  908,  807,  908,  908,  908,
    1094       807,  809,  908,  809,  908,  908,  908,  809,  831,  908,
    1095       831,  908,  908,  908,  831,  833,  908,  833,  908,  908,
    1096       908,  833,  835,  908,  835,  908,  908,  908,  835,  837,
    1097 
    1098       908,  837,  908,  908,  908,  837,  839,  908,  839,  908,
    1099       908,  908,  839,  841,  908,  841,  908,  908,  908,  841,
    1100       632,  908,  632,  908,  908,  908,  632,  861,  908,  861,
    1101       908,  908,  908,  861,  694,  908,  694,  908,  908,  908,
    1102       694,  698,  908,  698,  908,  908,  908,  698,   87,  908,
    1103        87,  908,  908,  908,   87,  866,  908,  866,  908,  908,
    1104       908,  866,  141,  908,  141,  908,  908,  908,  141,  208,
    1105       908,  208,  908,  908,  908,  208,   11,  908,  908,  908,
    1106       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1107       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1108 
    1109       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1110       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1111       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1112       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1113       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1114       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1115       908,  908
     804       73,   73,   73,   73,   73,   73,   73,   73,   73,   74,
     805       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
     806       74,   74,   74,   74,   74,   73,   75,   73,   73,   74,
     807       76,   74,   74,   74,   74,   74,   74,   74,   74,   74,
     808       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
     809       74,   74,   74,   74,   74,   73,   73,   73,   73,   78,
     810       78,   81,   81,  125,  126,   92,  143,   81,   81,   89,
     811       78,   78,   82,   83,   84,   84,   84,   82,   84,   83,
     812
     813       85,   85,   85,   84,   93,   95,   89,  144,  148,  100,
     814       97,  101,  101,  101,  101,  101,  101,  258,  913,   96,
     815      102,   87,   98,   99,   87,  103,  163,  120,  145,   79,
     816       79,   79,   79,  146,  149,  104,  105,   89,  106,  106,
     817      106,  106,  107,  107,  121,   89,  122,  123,  150,  269,
     818      151,  270,  260,  266,  187,  108,   89,  657,  161,  109,
     819      162,  152,  153,  154,   89,  110,  111,  155,  156,  164,
     820      157,  112,   89,  158,  159,  147,  165,  108,   89,  184,
     821       89,  160,  166,  113,  212,   89,   89,   89,  201,   89,
     822       89,  110,  199,   89,  111,  105,   89,  114,  114,  114,
     823
     824      114,  114,  114,   89,  171,  179,  172,  236,  198,   89,
     825      213,  182,  167,  311,  108,  173,  168,  183,  115,  180,
     826       89,  169,   89,  277,  116,  170,  181,  174,  256,  200,
     827      117,   89,  913,  237,   89,  175,  108,  176,   89,  202,
     828      177,  254,  118,  269,  178,  270,  292,  255,  185,  278,
     829      116,  127,  257,  186,  255,  128,  129,   89,  130,  145,
     830      131,  132,  913,  133,  146,  134,   89,  261,  264,  188,
     831      189,  263,  254,  255,  135,  136,  137,  196,  192,  190,
     832      255,  269,  191,  270,   89,  262,  193,  271,  194,  262,
     833      913,  263,  265,  195,  269,  138,  270,  263,  139,  269,
     834
     835      269,  270,  270,   89,  323,  271,  147,  203,   83,   84,
     836       84,   84,  203,  206,  207,  204,   89,  263,  206,  269,
     837      197,  270,  269,  273,  270,  140,  141,   82,   83,   84,
     838       84,   84,   82,  321,  208,  208,  208,  208,  208,  208,
     839      215,  216,   89,  272,  269,  215,  270,  217,  269,  269,
     840      270,  270,  217,   84,   83,   84,   84,   84,   84,   89,
     841      286,  218,  218,  218,  218,   84,   83,   85,   85,   85,
     842       84,   89,  217,  247,  247,  247,  247,  247,  247,  248,
     843      248,  248,  248,   89,   89,  145,  284,   89,  219,   89,
     844      146,  217,  288,  285,   89,   89,  217,  217,   89,   89,
     845
     846      217,  217,  287,  289,   89,  304,  460,  913,  217,  320,
     847       89,  217,  249,  217,  220,  217,  290,  221,  223,  306,
     848       89,  291,  224,  225,   89,  309,  305,  226,  227,   89,
     849      228,   89,  229,   89,  312,  913,   89,   89,  310,   89,
     850       89,  230,  231,  232,  105,   89,  107,  107,  107,  107,
     851      107,  107,  307,  308,  313,   89,   89,   89,  316,  314,
     852      317,  319,  233,  108,  251,  234,  251,  315,   89,  252,
     853      252,  252,  252,  252,  252,  322,   89,   89,  318,  250,
     854       89,  329,   89,  324,   89,  108,   89,   89,  337,  331,
     855      325,   89,   89,  235,  239,  239,  239,  239,  239,  239,
     856
     857       89,  326,  253,   89,  328,  338,  330,   89,  327,  332,
     858      240,  241,  242,  341,  243,  242,   89,  145,  333,  345,
     859       89,  336,   89,   89,   89,  343,   89,  244,  334,  335,
     860      439,  339,  242,  241,  242,   89,  342,  243,   89,  242,
     861      293,  294,  295,  346,  296,  297,  340,  344,  298,   89,
     862      299,  350,   89,  351,   89,  300,  301,  302,  356,  303,
     863       89,   89,  348,  463,  347,  352,  206,  207,  215,  216,
     864      349,  206,   89,  215,  353,  203,   83,   84,   84,   84,
     865      203,  206,  207,  204,  357,  413,  206,  208,  208,  208,
     866      208,  208,  208,  354,  207,  370,   89,  371,  354,  370,
     867
     868      355,  371,  208,  208,  208,  208,  208,  208,  362,  362,
     869      362,  362,  371,  371,  208,  208,  208,  208,  208,  208,
     870      370,  370,  371,  371,  379,  370,  370,  371,  371,  372,
     871      370,  370,  371,  371,  370,  373,  371,  370,  370,  371,
     872      371,  363,  379,  379,  380,  913,  380,  379,  390,  381,
     873      381,  381,  381,  381,  381,  383,  269,  383,  270,  105,
     874      383,  248,  248,  248,  248,  379,  385,  385,  385,  385,
     875      385,  385,  400,  269,  390,  270,   89,  383,   89,  383,
     876      387,   89,  382,  402,  383,  107,  107,  107,  107,  107,
     877      107,   89,   89,  417,  249,   89,  414,  416,  400,  386,
     878
     879      418,   89,  108,  252,  252,  252,  252,  252,  252,  403,
     880      415,  419,   89,   89,   89,   89,   89,  420,  261,  913,
     881      431,  421,  432,  586,  108,  388,  388,  388,  388,  388,
     882      388,  393,  426,   89,  107,  107,  107,  107,  107,  107,
     883       89,  240,  251,  242,  251,  243,  242,  252,  252,  252,
     884      252,  252,  252,  913,  395,  422,  396,   89,  389,  427,
     885      397,  423,  424,  242,   89,  242,  398,  261,  243,   89,
     886      242,  114,  114,  114,  114,  114,  114,   89,  399,  428,
     887      425,   89,  396,   89,   89,   89,  397,  435,   89,   89,
     888      437,   89,   89,  429,  430,   89,  433,  438,   89,   89,
     889
     890      444,   89,  436,  445,  266,  446,   89,   89,  434,  440,
     891      441,   89,  442,  443,   89,  448,   89,  449,   89,   89,
     892      447,   89,   89,  450,  453,  451,  454,  455,   89,  452,
     893       89,   89,   89,   89,   89,   89,   89,  457,   89,   89,
     894      462,   89,   89,  459,  456,   89,  458,  461,  465,   89,
     895      470,   89,  464,   89,   89,   89,  466,  145,  468,  467,
     896       89,  471,  469,   89,  477,  472,  475,   89,   89,  474,
     897       89,  473,   89,  476,   89,  480,  479,  481,  478,  354,
     898      207,  207,   89,  482,  354,  532,  355,  205,  483,  217,
     899      217,  217,  217,  362,  362,  362,  362,  370,  370,  371,
     900
     901      371,   89,  381,  381,  381,  381,  381,  381,  380,  509,
     902      380,  509,  517,  381,  381,  381,  381,  381,  381,  510,
     903       89,  511,  493,  504,  504,  504,  504,  504,  504,  239,
     904      239,  239,  239,  239,  239,  509,  518,  509,   89,  240,
     905       89,  242,   89,  243,  242,  248,  248,  248,  248,  107,
     906      107,  512,   89,  537,  533,  534,  505,  513,  513,   89,
     907       89,  242,  384,  242,   89,  541,  243,   89,  242,  385,
     908      385,  385,  385,  385,  385,  393,  512,   89,  387,  535,
     909      542,  539,   89,  513,  513,  240,  241,  242,   89,  243,
     910      242,  388,  388,  388,  388,  388,  388,  536,  395,  543,
     911
     912      396,   89,  386,  553,  397,   89,  913,  242,  241,  242,
     913      398,  514,  243,  514,  242,   89,  515,  515,  515,  515,
     914      515,  515,  399,   89,  389,   89,  396,   89,  544,  395,
     915      397,  396,  538,   89,  540,  397,   89,   89,   89,   89,
     916       89,  519,  549,  545,  546,   89,  552,   89,   89,  516,
     917      554,   89,  557,  399,  548,  547,   89,  396,   89,   89,
     918      550,  397,   89,  556,   89,   89,  555,  551,  558,   89,
     919      563,   89,  559,   89,  565,  561,   89,   89,   89,   89,
     920      560,   89,  562,   89,  564,   89,  566,   89,   89,   89,
     921       89,   89,  569,  567,  571,   89,  573,   89,  568,  578,
     922
     923      570,  572,  574,   89,   89,   89,  575,   89,   89,   89,
     924       89,  577,  579,  583,  576,  580,  587,  581,   89,   89,
     925      585,   89,   89,  584,   89,  582,   89,  590,   89,  591,
     926       89,   89,  589,  588,  597,  594,  593,  596,  509,  592,
     927      207,  913,  620,  639,  595,  641,  598,  217,  217,  217,
     928      217,  504,  504,  504,  504,  504,  504,  385,  385,  385,
     929      385,  385,  385,   89,  509,   89,   89,  240,  620,  242,
     930      646,  243,  242,  388,  388,  388,  388,  388,  388,  640,
     931       89,  710,  509,  642,  505,   89,   89,  509,  680,  242,
     932      506,  242,  510,  616,  243,  616,  242,  619,  617,  617,
     933
     934      617,  617,  617,  617,  710,  651,  507,  644,  509,   89,
     935       89,   89,  648,  509,  515,  515,  515,  515,  515,  515,
     936      514,   89,  514,  643,  645,  515,  515,  515,  515,  515,
     937      515,  618,  621,  621,  621,  621,  621,  621,   89,   89,
     938       89,  649,   89,   89,   89,   89,   89,   89,  622,  647,
     939      623,  653,  624,  623,  650,   89,  655,  656,   89,  863,
     940      654,  652,   89,   89,  660,  625,   89,  658,  659,   89,
     941      623,  661,  623,  663,  662,  624,   89,  623,   89,   89,
     942      665,  666,   89,   89,   89,  664,   89,   89,   89,   89,
     943       89,  668,  669,  667,  674,   89,   89,   89,  671,  675,
     944
     945       89,  670,  672,  673,  676,   89,   89,   89,   89,   89,
     946      678,   89,   89,  682,   89,  681,  685,  679,  677,  687,
     947      684,  686,   89,   89,  913,  888,   89,  689,  688,  683,
     948      504,  504,  504,  504,  504,  504,  617,  617,  617,  617,
     949      617,  617,  616,  726,  616,  690,   89,  617,  617,  617,
     950      617,  617,  617,  621,  621,  621,  621,  621,  621,  725,
     951      710,  710,   89,  615,  708,  708,  708,  708,  708,  708,
     952      711,   89,  711,   89,   89,  711,  721,  913,   89,  730,
     953      622,  723,  623,  710,  624,  623,  625,  724,   89,  722,
     954       89,   89,  711,   89,  711,  728,  727,  709,  729,  711,
     955
     956       89,   89,  623,  731,  623,   89,  732,  624,   89,  623,
     957       89,   89,   89,  733,  738,  740,  734,   89,   89,   89,
     958       89,   89,   89,   89,   89,  736,   89,  735,  743,  739,
     959      746,   89,  737,  741,   89,   89,   89,  742,  744,   89,
     960      749,   89,   89,   89,  745,  753,  747,   89,  748,  754,
     961      755,  751,  752,   89,  750,   89,   89,  756,  913,   89,
     962      772,   89,  757,  621,  621,  621,  621,  621,  621,  773,
     963      758,  708,  708,  708,  708,  708,  708,   89,   89,   89,
     964       89,  777,  774,  776,  775,   89,  781,  622,  778,  623,
     965       89,  624,  623,  779,   89,   89,  712,  780,  784,   89,
     966
     967       89,  786,   89,   89,  709,  787,  789,  782,  783,  623,
     968       89,  623,  788,  790,  624,   89,  623,   89,   89,   89,
     969       89,  785,   89,   89,   89,  792,   89,   89,  791,  793,
     970       89,  794,   89,  796,   89,  802,   89,   89,   89,   89,
     971      797,  795,   89,  799,  818,  798,  803,   89,  800,  708,
     972      708,  708,  708,  708,  708,  801,  816,   89,   89,  817,
     973       89,  821,  819,   89,   89,  826,  824,  820,   89,   89,
     974       89,  827,  828,   89,   89,  822,   89,  825,   89,  830,
     975      829,  831,  765,   89,   89,  832,  823,   89,   89,   89,
     976       89,   89,  852,   89,   89,   89,   89,  833,  854,  855,
     977
     978      857,   89,   89,  913,  858,  913,  834,  835,  851,  850,
     979       89,   89,  856,  853,  849,   89,   89,   89,  860,  861,
     980      862,  864,   89,   89,  859,   89,   89,   89,  876,   89,
     981      875,   89,   89,  865,  880,   89,  877,   89,  882,   89,
     982      883,   89,   89,  874,  887,   89,   89,  878,  884,  881,
     983      886,   89,   89,  879,  885,  889,  890,   89,   89,   89,
     984      891,   89,  892,  893,  894,   89,   89,   89,  895,  896,
     985       89,   89,   89,  899,   89,  901,   89,  902,   89,  897,
     986       89,  900,  898,   89,   89,   89,   89,   89,   89,   89,
     987       89,   89,  906,   89,   89,  905,  913,  907,  903,  904,
     988
     989      912,  913,  873,  913,  910,  872,  913,  908,  909,  870,
     990      911,   71,   71,   71,   71,   71,   71,   71,   71,   71,
     991       71,   71,   71,   71,   77,   77,   77,   77,   77,   77,
     992       77,   77,   77,   77,   77,   77,   77,   80,   80,   80,
     993       80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
     994       88,  913,  869,   88,  913,   88,   88,   88,   88,   88,
     995      142,  868,  913,  867,  142,  142,  142,  142,  142,  142,
     996      205,  205,  205,  205,  205,  205,  205,  205,  205,  205,
     997      205,  205,  205,  210,   89,   89,  210,   89,  210,  210,
     998      210,  210,  210,  214,  913,  214,  214,  848,  214,  214,
     999
     1000      214,  214,  214,  214,  913,  214,  222,  847,  845,  222,
     1001      222,  222,  222,  222,  222,  222,  222,  913,  222,  245,
     1002      245,  245,  245,  245,  245,  245,  245,  245,  245,  245,
     1003      245,  245,  259,  259,  843,  259,  913,  841,  913,  259,
     1004      275,  839,  837,  275,   89,  275,  275,  275,  275,  275,
     1005      279,   89,  279,   89,   89,   89,  279,  281,   89,  281,
     1006       89,   89,   89,  281,  358,   89,  358,   89,   89,  913,
     1007      358,  360,  815,  360,  813,  913,  913,  360,  364,  810,
     1008      364,  808,  806,   89,  364,  366,   89,  366,   89,   89,
     1009       89,  366,  368,   89,  368,   89,  771,  768,  368,  375,
     1010
     1011      767,  375,  765,  211,  761,  375,  377,  760,  377,  692,
     1012       89,   89,  377,  392,   89,  392,  394,  394,   89,  394,
     1013      394,  394,   89,  394,  259,  259,   89,  259,  275,   89,
     1014       89,  275,   89,  275,  275,  275,  275,  275,  404,   89,
     1015      404,   89,   89,   89,  404,  406,   89,  406,   89,   89,
     1016      719,  406,  408,  718,  408,  716,  714,  712,  408,  279,
     1017      619,  279,  410,  707,  410,  706,  704,  702,  410,  281,
     1018      700,  281,   88,  698,  696,   88,  694,   88,   88,   88,
     1019       88,   88,  205,  205,  205,  205,  205,  205,  205,  205,
     1020      205,  205,  205,  205,  205,  484,  484,  484,  484,  484,
     1021
     1022      484,  484,  484,  484,  484,  484,  484,  484,  485,  692,
     1023      485,   89,   89,   89,  485,  487,   89,  487,   89,   89,
     1024       89,  487,  489,   89,  489,   89,   89,   89,  489,  358,
     1025       89,  358,  491,   89,  491,   89,  638,  636,  491,  360,
     1026      634,  360,  494,  632,  494,  630,  628,  519,  494,  364,
     1027      626,  364,  496,  626,  496,  615,  614,  612,  496,  366,
     1028      499,  366,  498,  499,  498,  610,  608,  606,  498,  368,
     1029      604,  368,  500,  602,  500,  600,   89,   89,  500,  375,
     1030       89,  375,  502,   89,  502,   89,   89,   89,  502,  377,
     1031       89,  377,  508,  531,  508,  529,  508,  527,  508,  392,
     1032
     1033      525,  392,  523,  392,  521,  392,  394,  394,  507,  394,
     1034      394,  394,  506,  394,  520,  503,  520,  501,  371,  371,
     1035      520,  522,  499,  522,  497,  495,  492,  522,  524,  490,
     1036      524,  488,  486,   89,  524,  404,   89,  404,  526,   89,
     1037      526,  412,  411,  409,  526,  406,  407,  406,  528,  405,
     1038      528,  276,  271,  270,  528,  408,  401,  408,  530,  401,
     1039      530,  258,  391,  391,  530,  410,  246,  410,   88,  384,
     1040      378,   88,  376,   88,   88,   88,   88,   88,  484,  484,
     1041      484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
     1042      484,  599,  374,  599,  370,  369,  367,  599,  485,  365,
     1043
     1044      485,  601,  361,  601,  359,  211,  207,  601,  487,   89,
     1045      487,  603,  283,  603,  282,  280,  276,  603,  489,  271,
     1046      489,  605,  274,  605,  271,  269,  268,  605,  491,  267,
     1047      491,  607,  246,  607,  238,   87,   87,  607,  494,   89,
     1048      494,  609,  211,  609,  209,   87,  124,  609,  496,  119,
     1049      496,  498,   89,  498,  913,   72,   72,  498,  611,  913,
     1050      611,  913,  913,  913,  611,  500,  913,  500,  613,  913,
     1051      613,  913,  913,  913,  613,  502,  913,  502,  508,  913,
     1052      508,  913,  508,  913,  508,  394,  913,  394,  913,  913,
     1053      913,  394,  627,  913,  627,  913,  913,  913,  627,  520,
     1054
     1055      913,  520,  629,  913,  629,  913,  913,  913,  629,  522,
     1056      913,  522,  631,  913,  631,  913,  913,  913,  631,  524,
     1057      913,  524,  633,  913,  633,  913,  913,  913,  633,  526,
     1058      913,  526,  635,  913,  635,  913,  913,  913,  635,  528,
     1059      913,  528,  637,  913,  637,  913,  913,  913,  637,  530,
     1060      913,  530,   88,  913,  913,   88,  913,   88,   88,   88,
     1061       88,   88,  691,  691,  691,  691,  691,  691,  691,  691,
     1062      691,  691,  691,  691,  691,  693,  913,  693,  913,  913,
     1063      913,  693,  599,  913,  599,  695,  913,  695,  913,  913,
     1064      913,  695,  601,  913,  601,  697,  913,  697,  913,  913,
     1065
     1066      913,  697,  603,  913,  603,  699,  913,  699,  913,  913,
     1067      913,  699,  605,  913,  605,  701,  913,  701,  913,  913,
     1068      913,  701,  607,  913,  607,  703,  913,  703,  913,  913,
     1069      913,  703,  609,  913,  609,  705,  913,  705,  913,  913,
     1070      913,  705,  611,  913,  611,   88,  913,   88,  913,  913,
     1071      913,   88,  613,  913,  613,  508,  913,  508,  913,  913,
     1072      913,  508,  713,  913,  713,  913,  913,  913,  713,  627,
     1073      913,  627,  715,  913,  715,  913,  913,  913,  715,  629,
     1074      913,  629,  717,  913,  717,  913,  913,  913,  717,  631,
     1075      913,  631,  142,  913,  142,  913,  913,  913,  142,  633,
     1076
     1077      913,  633,  720,  913,  720,  635,  913,  635,   88,  913,
     1078      913,   88,  913,   88,   88,   88,   88,   88,  637,  913,
     1079      637,  691,  691,  691,  691,  691,  691,  691,  691,  691,
     1080      691,  691,  691,  691,  759,  913,  759,  913,  913,  913,
     1081      759,  693,  913,  693,  210,  913,  210,  913,  913,  913,
     1082      210,  695,  913,  695,  762,  913,  762,  697,  913,  697,
     1083      210,  913,  913,  210,  913,  210,  210,  210,  210,  210,
     1084      699,  913,  699,  763,  913,  763,  701,  913,  701,  703,
     1085      913,  703,  764,  913,  764,  705,  913,  705,   88,  913,
     1086       88,  766,  913,  766,  913,  913,  913,  766,  713,  913,
     1087
     1088      713,  275,  913,  275,  913,  913,  913,  275,  715,  913,
     1089      715,  769,  913,  769,  717,  913,  717,  142,  913,  142,
     1090      770,  913,  770,  913,  913,  913,  770,   88,  913,  913,
     1091       88,  913,   88,   88,   88,   88,   88,  804,  913,  804,
     1092      759,  913,  759,  210,  913,  210,  805,  913,  805,  913,
     1093      913,  913,  805,  807,  913,  807,  913,  913,  913,  807,
     1094      809,  913,  809,  913,  913,  913,  809,  811,  913,  811,
     1095      812,  913,  812,  913,  913,  913,  812,  814,  913,  814,
     1096      913,  913,  913,  814,  836,  913,  836,  913,  913,  913,
     1097      836,  838,  913,  838,  913,  913,  913,  838,  840,  913,
     1098
     1099      840,  913,  913,  913,  840,  842,  913,  842,  913,  913,
     1100      913,  842,  844,  913,  844,  913,  913,  913,  844,  846,
     1101      913,  846,  913,  913,  913,  846,  637,  913,  637,  913,
     1102      913,  913,  637,  866,  913,  866,  913,  913,  913,  866,
     1103      699,  913,  699,  913,  913,  913,  699,  703,  913,  703,
     1104      913,  913,  913,  703,   88,  913,   88,  913,  913,  913,
     1105       88,  871,  913,  871,  913,  913,  913,  871,  142,  913,
     1106      142,  913,  913,  913,  142,  210,  913,  210,  913,  913,
     1107      913,  210,   11,  913,  913,  913,  913,  913,  913,  913,
     1108      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1109
     1110      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1111      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1112      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1113      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1114      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1115      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1116      913,  913,  913,  913,  913,  913,  913,  913
    11161117    } ;
    11171118
    1118 static yyconst flex_int16_t yy_chk[2963] =
     1119static yyconst flex_int16_t yy_chk[2969] =
    11191120    {   0,
    11201121        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     
    11371138        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
    11381139        5,    5,    5,    5,    5,    5,    5,    5,    5,    7,
    1139         8,    9,   10,   37,   37,   20,   39,    9,   10,  907,
     1140        8,    9,   10,   37,   37,   20,   39,    9,   10,  912,
    11401141        7,    8,   13,   13,   13,   13,   13,   13,   15,   15,
    11411142
    11421143       15,   15,   15,   15,   20,   25,   48,   39,   42,   28,
    1143        27,   28,   28,   28,   28,   28,   28,  110,  116,   25,
     1144       27,   28,   28,   28,   28,   28,   28,  111,  117,   25,
    11441145       29,   25,   27,   27,   27,   29,   48,   35,   40,    7,
    11451146        8,    9,   10,   40,   42,   29,   30,   47,   30,   30,
    1146        30,   30,   30,   30,   35,   57,   35,   35,   44,  127,
    1147        44,  127,  110,  116,   57,   30,   65,  547,   47,   30,
     1147       30,   30,   30,   30,   35,   58,   35,   35,   44,  128,
     1148       44,  128,  111,  117,   58,   30,   56,  551,   47,   30,
    11481149       47,   45,   45,   45,   49,   30,   30,   45,   45,   49,
    1149        45,   30,   40,   45,   45,   40,   49,   30,   45,   63,
    1150        62,   45,   49,   30,   74,  906,  547,   53,   63,   51,
    1151        61,   30,   62,   55,   30,   31,  109,   31,   31,   31,
    1152 
    1153        31,   31,   31,   50,   51,   53,   51,   65,   61,   54,
    1154        74,   55,   50,   88,   31,   51,   50,   55,   31,   54,
    1155       109,   50,   52,  143,   31,   50,   54,   52,  112,  154,
    1156        31,   56,  111,  898,  152,   52,   31,   52,  154,   88,
    1157        52,  108,   31,  128,   52,  128,  112,  108,   56,  143,
    1158        31,   38,  152,   56,  112,   38,   38,   58,   38,   60,
    1159        38,   38,  111,   38,   60,   38,   59,  111,  115,   58,
    1160        58,  117,  158,  108,   38,   38,   38,   60,   59,   58,
    1161       131,  130,   58,  130,  158,  114,   59,  132,   59,  117,
    1162       111,  114,  115,   59,  131,   38,  131,  117,   38,  132,
    1163 
    1164       133,  132,  133,   60,  173,  153,   60,   68,   68,   68,
    1165        68,   68,   68,   69,   69,   68,  165,  114,   69,  173,
    1166        60,  134,  134,  153,  134,   38,   38,   81,   81,   81,
    1167        81,   81,   81,  165,   69,   69,   69,   69,   69,   69,
    1168        78,   78,  135,  155,  135,   78,  146,   78,  136,  136,
    1169       136,  146,   78,   83,   83,   83,   83,   83,   83,  155,
    1170       897,   78,   78,   78,   78,   84,   84,   84,   84,   84,
    1171        84,  156,   78,  104,  104,  104,  104,  104,  104,  105,
    1172       105,  105,  105,  138,  140,  138,  140,  151,   78,  156,
    1173       146,   78,  306,  894,  157,  162,   78,   78,  161,  306,
    1174 
    1175        78,   78,  151,  160,  162,  176,  168,  105,   78,  151,
    1176       169,   78,  105,   78,   78,   78,  157,   78,   86,  160,
    1177       161,  164,   86,   86,  166,  176,  164,   86,   86,  168,
    1178        86,  163,   86,  167,  166,  105,  170,  169,  175,  164,
    1179       893,   86,   86,   86,  106,  172,  106,  106,  106,  106,
    1180       106,  106,  163,  163,  167,  171,  175,  170,  174,  177,
    1181       171,  178,   86,  106,  107,   86,  107,  172,  183,  107,
    1182       107,  107,  107,  107,  107,  174,  182,  183,  171,  106,
    1183       184,  182,  186,  178,  181,  106,  177,  222,  891,  222,
    1184       192,  180,  187,   86,  100,  100,  100,  100,  100,  100,
    1185 
    1186       186,  181,  107,  187,  188,  189,  180,  184,  185,  188,
    1187       100,  100,  100,  180,  100,  100,  190,  192,  189,  185,
    1188       187,  194,  732,  198,  188,  195,  191,  100,  193,  185,
    1189       185,  191,  100,  100,  100,  159,  190,  100,  195,  100,
    1190       159,  159,  159,  198,  159,  159,  195,  193,  159,  196,
    1191       159,  732,  209,  191,  197,  159,  159,  159,  223,  159,
    1192       223,  224,  196,  224,  196,  194,  286,  197,  194,  201,
    1193       201,  201,  201,  201,  201,  202,  202,  201,  209,  225,
    1194       202,  204,  204,  286,  213,  213,  204,  206,  206,  213,
    1195       890,  883,  206,  225,  206,  225,  202,  202,  202,  202,
    1196 
    1197       202,  202,  204,  204,  204,  204,  204,  204,  206,  206,
    1198       206,  206,  206,  206,  216,  216,  216,  216,  226,  227,
    1199       247,  227,  228,  228,  229,  228,  229,  230,  230,  230,
    1200       226,  232,  226,  232,  233,  240,  233,  238,  238,  241,
    1201       270,  241,  270,  239,  241,  239,  282,  216,  239,  239,
    1202       239,  239,  239,  239,  271,  247,  271,  882,  240,  282,
    1203       238,  241,  246,  241,  246,  246,  246,  246,  241,  245,
    1204       245,  245,  245,  245,  245,  248,  248,  248,  248,  248,
    1205       248,  239,  249,  249,  249,  249,  249,  249,  283,  284,
    1206       288,  287,  248,  285,  289,  252,  287,  246,  295,  289,
    1207 
    1208       297,  326,  245,  260,  274,  297,  283,  284,  248,  285,
    1209       288,  881,  326,  295,  248,  250,  250,  250,  250,  250,
    1210       250,  252,  257,  259,  259,  259,  259,  259,  259,  260,
    1211       274,  250,  251,  250,  251,  250,  250,  251,  251,  251,
    1212       251,  251,  251,  298,  292,  257,  880,  257,  250,  294,
    1213       290,  257,  298,  250,  293,  250,  259,  257,  250,  291,
    1214       250,  264,  264,  264,  264,  264,  264,  292,  296,  257,
    1215       290,  300,  293,  257,  291,  294,  299,  257,  301,  303,
    1216       291,  291,  304,  305,  296,  296,  307,  304,  309,  299,
    1217       308,  879,  305,  313,  264,  310,  301,  303,  300,  311,
    1218 
    1219       310,  312,  314,  318,  311,  316,  307,  312,  308,  309,
    1220       309,  314,  313,  315,  317,  319,  322,  320,  318,  315,
    1221       319,  316,  320,  317,  321,  323,  324,  327,  328,  321,
    1222       329,  328,  330,  331,  332,  322,  333,  334,  335,  324,
    1223       336,  337,  327,  323,  338,  330,  321,  335,  340,  329,
    1224       339,  342,  344,  345,  334,  331,  333,  332,  343,  346,
    1225       349,  340,  336,  350,  337,  347,  338,  343,  339,  348,
    1226       342,  345,  346,  347,  348,  349,  875,  351,  351,  352,
    1227       413,  350,  351,  410,  351,  352,  359,  359,  359,  359,
    1228       360,  360,  360,  360,  410,  369,  344,  369,  370,  413,
    1229 
    1230       370,  377,  377,  377,  377,  377,  377,  379,  389,  379,
    1231       417,  394,  379,  379,  379,  379,  379,  379,  389,  359,
    1232       378,  378,  378,  378,  378,  378,  381,  381,  381,  381,
    1233       381,  381,  417,  411,  389,  394,  378,  412,  378,  415,
    1234       378,  378,  384,  384,  384,  384,  384,  384,  392,  411,
    1235       415,  390,  412,  378,  392,  396,  578,  421,  378,  381,
    1236       378,  390,  420,  378,  578,  378,  382,  382,  382,  382,
    1237       382,  382,  391,  396,  424,  384,  414,  390,  420,  421,
    1238       392,  396,  382,  382,  382,  414,  382,  382,  385,  385,
    1239       385,  385,  385,  385,  428,  391,  424,  391,  871,  382,
    1240 
    1241       428,  391,  868,  395,  382,  382,  382,  391,  393,  382,
    1242       393,  382,  419,  393,  393,  393,  393,  393,  393,  391,
    1243       416,  385,  418,  391,  422,  419,  395,  391,  395,  416,
    1244       425,  418,  395,  430,  426,  423,  429,  422,  395,  426,
    1245       427,  431,  434,  439,  430,  438,  393,  436,  425,  432,
    1246       395,  423,  423,  441,  395,  427,  434,  429,  395,  436,
    1247       431,  440,  427,  442,  432,  439,  438,  443,  444,  442,
    1248       446,  448,  449,  450,  440,  451,  441,  444,  452,  453,
    1249       454,  456,  443,  458,  461,  446,  459,  460,  450,  454,
    1250       462,  448,  463,  452,  449,  464,  460,  451,  456,  453,
    1251 
    1252       465,  466,  467,  470,  468,  461,  458,  469,  459,  465,
    1253       462,  468,  463,  471,  469,  467,  472,  464,  473,  466,
    1254       474,  475,  477,  480,  478,  472,  473,  479,  470,  480,
    1255       479,  507,  475,  478,  508,  471,  473,  474,  489,  489,
    1256       489,  489,  528,  531,  477,  500,  500,  500,  500,  500,
    1257       500,  502,  502,  502,  502,  502,  502,  507,  531,  528,
    1258       508,  500,  529,  500,  533,  500,  500,  503,  503,  503,
    1259       503,  503,  503,  867,  866,  529,  504,  533,  500,  532,
    1260       542,  506,  534,  500,  502,  500,  504,  505,  500,  505,
    1261       500,  506,  505,  505,  505,  505,  505,  505,  536,  532,
    1262 
    1263       503,  542,  504,  536,  534,  535,  537,  506,  510,  510,
    1264       510,  510,  510,  510,  512,  865,  512,  537,  535,  512,
    1265       512,  512,  512,  512,  512,  505,  511,  511,  511,  511,
    1266       511,  511,  538,  539,  540,  538,  541,  546,  544,  543,
    1267       545,  549,  511,  544,  511,  548,  511,  511,  543,  540,
    1268       546,  545,  551,  539,  548,  541,  550,  552,  555,  511,
    1269       557,  551,  552,  549,  511,  558,  511,  555,  554,  511,
    1270       559,  511,  560,  550,  554,  562,  563,  557,  564,  565,
    1271       558,  560,  567,  568,  562,  559,  570,  571,  568,  574,
    1272       564,  575,  576,  563,  565,  570,  571,  567,  579,  580,
    1273 
    1274       581,  582,  589,  586,  575,  587,  580,  590,  579,  576,
    1275       583,  574,  586,  582,  592,  587,  583,  864,  863,  589,
    1276       590,  638,  581,  610,  610,  610,  610,  610,  610,  611,
    1277       611,  611,  611,  611,  611,  613,  592,  613,  638,  637,
    1278       613,  613,  613,  613,  613,  613,  616,  616,  616,  616,
    1279       616,  616,  637,  617,  617,  642,  610,  612,  612,  612,
    1280       612,  612,  612,  618,  634,  619,  862,  619,  639,  634,
    1281       619,  636,  642,  612,  635,  612,  617,  612,  612,  616,
    1282       636,  635,  634,  645,  646,  640,  618,  619,  641,  619,
    1283       612,  639,  640,  644,  619,  612,  641,  612,  643,  646,
    1284 
    1285       612,  643,  612,  647,  648,  645,  644,  649,  650,  651,
    1286       652,  650,  653,  654,  655,  657,  656,  660,  667,  658,
    1287       661,  648,  662,  655,  666,  647,  651,  653,  658,  649,
    1288       669,  662,  672,  654,  656,  684,  673,  657,  652,  680,
    1289       660,  672,  661,  673,  666,  667,  681,  669,  680,  683,
    1290       684,  716,  719,  722,  723,  861,  681,  723,  683,  703,
    1291       703,  703,  703,  703,  703,  707,  707,  707,  707,  707,
    1292       707,  717,  716,  722,  856,  703,  720,  703,  719,  703,
    1293       703,  717,  721,  720,  727,  724,  729,  721,  724,  725,
    1294       727,  730,  703,  728,  730,  729,  731,  703,  707,  703,
    1295 
    1296       733,  734,  703,  733,  703,  735,  728,  725,  736,  737,
    1297       734,  736,  738,  739,  740,  741,  742,  731,  748,  745,
    1298       738,  749,  737,  739,  750,  742,  752,  740,  773,  774,
    1299       753,  735,  771,  773,  752,  776,  741,  745,  748,  753,
    1300       772,  778,  745,  749,  774,  750,  760,  760,  760,  760,
    1301       760,  760,  771,  775,  777,  780,  779,  772,  776,  779,
    1302       781,  783,  785,  775,  783,  785,  786,  778,  780,  787,
    1303       789,  777,  787,  786,  788,  790,  792,  788,  796,  760,
    1304       811,  813,  814,  815,  816,  789,  815,  817,  781,  818,
    1305       817,  820,  818,  821,  822,  824,  855,  822,  790,  792,
    1306 
    1307       814,  796,  813,  827,  828,  825,  816,  811,  825,  820,
    1308       826,  829,  827,  826,  830,  845,  846,  824,  847,  821,
    1309       828,  847,  829,  846,  848,  849,  850,  851,  854,  850,
    1310       830,  854,  857,  848,  884,  857,  845,  858,  859,  860,
    1311       870,  853,  869,  849,  851,  870,  858,  873,  860,  849,
    1312       859,  869,  872,  874,  884,  872,  876,  873,  874,  876,
    1313       877,  878,  885,  877,  878,  886,  887,  888,  886,  889,
    1314       888,  892,  889,  895,  896,  899,  887,  885,  900,  901,
    1315       903,  902,  904,  852,  899,  905,  844,  843,  842,  896,
    1316       841,  900,  840,  892,  895,  905,  839,  838,  903,  837,
    1317 
    1318       836,  901,  902,  835,  904,  909,  909,  909,  909,  909,
    1319       909,  909,  909,  909,  909,  909,  909,  909,  910,  910,
    1320       910,  910,  910,  910,  910,  910,  910,  910,  910,  910,
    1321       910,  911,  911,  911,  911,  911,  911,  911,  911,  911,
    1322       911,  911,  911,  911,  912,  834,  833,  912,  832,  912,
    1323       912,  912,  912,  912,  913,  831,  823,  819,  913,  913,
    1324       913,  913,  913,  913,  914,  914,  914,  914,  914,  914,
    1325       914,  914,  914,  914,  914,  914,  914,  915,  812,  810,
    1326       915,  809,  915,  915,  915,  915,  915,  916,  808,  916,
    1327       916,  807,  916,  916,  916,  916,  916,  916,  806,  916,
    1328 
    1329       917,  805,  804,  917,  917,  917,  917,  917,  917,  917,
    1330       917,  803,  917,  918,  918,  918,  918,  918,  918,  918,
    1331       918,  918,  918,  918,  918,  918,  919,  919,  802,  919,
    1332       801,  800,  799,  919,  920,  798,  797,  920,  795,  920,
    1333       920,  920,  920,  920,  921,  794,  921,  793,  791,  784,
    1334       921,  922,  782,  922,  770,  769,  768,  922,  923,  767,
    1335       923,  766,  765,  764,  923,  924,  763,  924,  762,  759,
    1336       758,  924,  925,  757,  925,  751,  747,  746,  925,  926,
    1337       744,  926,  743,  726,  718,  926,  927,  715,  927,  710,
    1338       708,  704,  927,  928,  694,  928,  690,  688,  686,  928,
    1339 
    1340       929,  685,  929,  682,  679,  678,  929,  930,  677,  930,
    1341       931,  931,  676,  931,  931,  931,  675,  931,  932,  932,
    1342       674,  932,  933,  671,  670,  933,  668,  933,  933,  933,
    1343       933,  933,  934,  665,  934,  664,  663,  659,  934,  935,
    1344       632,  935,  628,  626,  624,  935,  936,  622,  936,  620,
    1345       614,  608,  936,  937,  606,  937,  938,  604,  938,  602,
    1346       600,  598,  938,  939,  596,  939,  940,  594,  593,  940,
    1347       591,  940,  940,  940,  940,  940,  941,  941,  941,  941,
    1348       941,  941,  941,  941,  941,  941,  941,  941,  941,  942,
    1349       942,  942,  942,  942,  942,  942,  942,  942,  942,  942,
    1350 
    1351       942,  942,  943,  588,  943,  585,  584,  577,  943,  944,
    1352       573,  944,  572,  569,  566,  944,  945,  561,  945,  556,
    1353       553,  530,  945,  946,  526,  946,  947,  524,  947,  522,
    1354       520,  518,  947,  948,  516,  948,  949,  515,  949,  514,
    1355       513,  501,  949,  950,  498,  950,  951,  496,  951,  495,
    1356       494,  492,  951,  952,  490,  952,  953,  487,  953,  485,
    1357       483,  481,  953,  954,  476,  954,  955,  457,  955,  455,
    1358       447,  445,  955,  956,  437,  956,  957,  435,  957,  433,
    1359       407,  405,  957,  958,  403,  958,  959,  401,  959,  400,
    1360       959,  399,  959,  960,  386,  960,  383,  960,  374,  960,
    1361 
    1362       961,  961,  372,  961,  961,  961,  371,  961,  962,  367,
    1363       962,  365,  363,  361,  962,  963,  357,  963,  355,  354,
    1364       353,  963,  964,  341,  964,  325,  302,  281,  964,  965,
    1365       279,  965,  966,  277,  966,  276,  275,  273,  966,  967,
    1366       272,  967,  968,  267,  968,  263,  262,  258,  968,  969,
    1367       255,  969,  970,  254,  970,  243,  242,  235,  970,  971,
    1368       234,  971,  972,  231,  221,  972,  219,  972,  972,  972,
    1369       972,  972,  973,  973,  973,  973,  973,  973,  973,  973,
    1370       973,  973,  973,  973,  973,  974,  218,  974,  217,  211,
    1371       210,  974,  975,  208,  975,  976,  203,  976,  179,  150,
    1372 
    1373       148,  976,  977,  147,  977,  978,  141,  978,  139,  137,
    1374       129,  978,  979,  126,  979,  980,  125,  980,  121,  102,
    1375        99,  980,  981,   96,  981,  982,   94,  982,   87,   73,
    1376        71,  982,  983,   67,  983,  984,   36,  984,   33,   18,
    1377        11,  984,  985,    4,  985,  986,    3,  986,    0,    0,
    1378         0,  986,  987,    0,  987,    0,    0,    0,  987,  988,
    1379         0,  988,  989,    0,  989,    0,    0,    0,  989,  990,
    1380         0,  990,  991,    0,  991,    0,  991,    0,  991,  992,
    1381         0,  992,    0,    0,    0,  992,  993,    0,  993,    0,
    1382         0,    0,  993,  994,    0,  994,  995,    0,  995,    0,
    1383 
    1384         0,    0,  995,  996,    0,  996,  997,    0,  997,    0,
    1385         0,    0,  997,  998,    0,  998,  999,    0,  999,    0,
    1386         0,    0,  999, 1000,    0, 1000, 1001,    0, 1001,    0,
    1387         0,    0, 1001, 1002,    0, 1002, 1003,    0, 1003,    0,
    1388         0,    0, 1003, 1004,    0, 1004, 1005,    0,    0, 1005,
    1389         0, 1005, 1005, 1005, 1005, 1005, 1006, 1006, 1006, 1006,
    1390      1006, 1006, 1006, 1006, 1006, 1006, 1006, 1006, 1006, 1007,
    1391         0, 1007,    0,    0,    0, 1007, 1008,    0, 1008, 1009,
    1392         0, 1009,    0,    0,    0, 1009, 1010,    0, 1010, 1011,
    1393         0, 1011,    0,    0,    0, 1011, 1012,    0, 1012, 1013,
    1394 
    1395         0, 1013,    0,    0,    0, 1013, 1014,    0, 1014, 1015,
    1396         0, 1015,    0,    0,    0, 1015, 1016,    0, 1016, 1017,
    1397         0, 1017,    0,    0,    0, 1017, 1018,    0, 1018, 1019,
    1398         0, 1019,    0,    0,    0, 1019, 1020,    0, 1020, 1021,
    1399         0, 1021,    0,    0,    0, 1021, 1022,    0, 1022, 1023,
    1400         0, 1023,    0,    0,    0, 1023, 1024,    0, 1024,    0,
    1401         0,    0, 1024, 1025,    0, 1025, 1026,    0, 1026,    0,
    1402         0,    0, 1026, 1027,    0, 1027, 1028,    0, 1028,    0,
    1403         0,    0, 1028, 1029,    0, 1029, 1030,    0, 1030,    0,
    1404         0,    0, 1030, 1031,    0, 1031, 1032,    0, 1032, 1033,
    1405 
    1406         0, 1033, 1034,    0,    0, 1034,    0, 1034, 1034, 1034,
    1407      1034, 1034, 1035,    0, 1035, 1036, 1036, 1036, 1036, 1036,
    1408      1036, 1036, 1036, 1036, 1036, 1036, 1036, 1036, 1037,    0,
    1409      1037,    0,    0,    0, 1037, 1038,    0, 1038, 1039,    0,
    1410      1039,    0,    0,    0, 1039, 1040,    0, 1040, 1041,    0,
    1411      1041, 1042,    0, 1042, 1043,    0,    0, 1043,    0, 1043,
    1412      1043, 1043, 1043, 1043, 1044,    0, 1044, 1045,    0, 1045,
    1413      1046,    0, 1046, 1047,    0, 1047, 1048,    0, 1048, 1049,
    1414         0, 1049, 1050,    0, 1050, 1051,    0, 1051,    0,    0,
    1415         0, 1051, 1052,    0, 1052, 1053,    0, 1053,    0,    0,
    1416 
    1417         0, 1053, 1054,    0, 1054, 1055,    0, 1055, 1056,    0,
    1418      1056, 1057,    0, 1057, 1058,    0, 1058,    0,    0,    0,
    1419      1058, 1059,    0,    0, 1059,    0, 1059, 1059, 1059, 1059,
     1150       45,   30,   40,   45,   45,   40,   49,   30,   45,   56,
     1151       63,   45,   49,   30,   75,  911,  551,   53,   66,   51,
     1152       62,   30,   63,   55,   30,   31,  166,   31,   31,   31,
     1153
     1154       31,   31,   31,   50,   51,   53,   51,   89,   62,   54,
     1155       75,   55,   50,  166,   31,   51,   50,   55,   31,   54,
     1156       64,   50,   52,  144,   31,   50,   54,   52,  110,   64,
     1157       31,   57,  112,   89,  159,   52,   31,   52,  903,   66,
     1158       52,  109,   31,  129,   52,  129,  159,  109,   57,  144,
     1159       31,   38,  110,   57,  113,   38,   38,   59,   38,   61,
     1160       38,   38,  112,   38,   61,   38,   60,  112,  116,   59,
     1161       59,  118,  113,  109,   38,   38,   38,   61,   60,   59,
     1162      113,  131,   59,  131,  177,  115,   60,  133,   60,  118,
     1163      112,  115,  116,   60,  134,   38,  134,  118,   38,  133,
     1164
     1165      136,  133,  136,   61,  177,  132,   61,   69,   69,   69,
     1166       69,   69,   69,   70,   70,   69,  175,  115,   70,  132,
     1167       61,  132,  137,  137,  137,   38,   38,   82,   82,   82,
     1168       82,   82,   82,  175,   70,   70,   70,   70,   70,   70,
     1169       79,   79,  153,  135,  135,   79,  135,   79,  139,  141,
     1170      139,  141,   79,   84,   84,   84,   84,   84,   84,  902,
     1171      153,   79,   79,   79,   79,   85,   85,   85,   85,   85,
     1172       85,  152,   79,  105,  105,  105,  105,  105,  105,  106,
     1173      106,  106,  106,  155,  154,  147,  152,  156,   79,  161,
     1174      147,   79,  155,  152,  174,  328,   79,   79,  157,  158,
     1175
     1176       79,   79,  154,  156,  162,  161,  328,  106,   79,  174,
     1177      163,   79,  106,   79,   79,   79,  157,   79,   87,  163,
     1178      165,  158,   87,   87,  167,  165,  162,   87,   87,  147,
     1179       87,  164,   87,  168,  167,  106,  169,  171,  165,  173,
     1180      170,   87,   87,   87,  107,  899,  107,  107,  107,  107,
     1181      107,  107,  164,  164,  168,  172,  178,  176,  171,  169,
     1182      172,  173,   87,  107,  108,   87,  108,  170,  179,  108,
     1183      108,  108,  108,  108,  108,  176,  183,  189,  172,  107,
     1184      185,  183,  186,  178,  184,  107,  181,  182,  189,  185,
     1185      179,  898,  194,   87,  101,  101,  101,  101,  101,  101,
     1186
     1187      191,  181,  108,  188,  182,  189,  184,  187,  181,  186,
     1188      101,  101,  101,  191,  101,  101,  192,  196,  187,  194,
     1189      193,  188,  896,  308,  195,  193,  190,  101,  187,  187,
     1190      308,  190,  101,  101,  101,  160,  192,  101,  198,  101,
     1191      160,  160,  160,  195,  160,  160,  190,  193,  160,  197,
     1192      160,  198,  199,  198,  200,  160,  160,  160,  211,  160,
     1193      331,  196,  197,  331,  196,  199,  204,  204,  215,  215,
     1194      197,  204,  284,  215,  200,  203,  203,  203,  203,  203,
     1195      203,  206,  206,  203,  211,  284,  206,  204,  204,  204,
     1196      204,  204,  204,  208,  208,  224,  895,  224,  208,  225,
     1197
     1198      208,  225,  206,  206,  206,  206,  206,  206,  218,  218,
     1199      218,  218,  227,  228,  208,  208,  208,  208,  208,  208,
     1200      226,  229,  226,  229,  242,  228,  227,  228,  227,  230,
     1201      230,  231,  230,  231,  232,  232,  232,  234,  235,  234,
     1202      235,  218,  240,  240,  241,  249,  241,  242,  254,  241,
     1203      241,  241,  241,  241,  241,  243,  272,  243,  272,  248,
     1204      243,  248,  248,  248,  248,  240,  247,  247,  247,  247,
     1205      247,  247,  262,  273,  254,  273,  288,  243,  285,  243,
     1206      249,  287,  241,  276,  243,  250,  250,  250,  250,  250,
     1207      250,  290,  286,  288,  248,  289,  285,  287,  262,  247,
     1208
     1209      289,  292,  250,  251,  251,  251,  251,  251,  251,  276,
     1210      286,  290,  291,  300,  295,  299,  472,  291,  250,  888,
     1211      299,  292,  300,  472,  250,  252,  252,  252,  252,  252,
     1212      252,  259,  295,  296,  261,  261,  261,  261,  261,  261,
     1213      293,  252,  253,  252,  253,  252,  252,  253,  253,  253,
     1214      253,  253,  253,  887,  259,  293,  259,  294,  252,  296,
     1215      259,  293,  293,  252,  297,  252,  259,  261,  252,  303,
     1216      252,  266,  266,  266,  266,  266,  266,  298,  259,  297,
     1217      294,  302,  259,  301,  305,  306,  259,  303,  307,  309,
     1218      306,  311,  310,  298,  298,  312,  301,  307,  313,  314,
     1219
     1220      312,  315,  305,  313,  266,  314,  316,  318,  302,  309,
     1221      310,  317,  311,  311,  320,  316,  319,  317,  324,  321,
     1222      315,  322,  323,  318,  321,  319,  322,  323,  325,  320,
     1223      326,  330,  329,  332,  334,  333,  335,  324,  336,  339,
     1224      330,  338,  340,  326,  323,  337,  325,  329,  333,  341,
     1225      338,  342,  332,  343,  345,  346,  334,  347,  336,  335,
     1226      348,  339,  337,  349,  346,  340,  343,  350,  352,  342,
     1227      353,  341,  351,  345,  413,  350,  349,  351,  348,  354,
     1228      354,  355,  886,  352,  354,  413,  354,  355,  353,  362,
     1229      362,  362,  362,  363,  363,  363,  363,  372,  373,  372,
     1230
     1231      373,  347,  380,  380,  380,  380,  380,  380,  382,  392,
     1232      382,  393,  397,  382,  382,  382,  382,  382,  382,  392,
     1233      885,  393,  362,  381,  381,  381,  381,  381,  381,  384,
     1234      384,  384,  384,  384,  384,  392,  397,  393,  414,  381,
     1235      415,  381,  418,  381,  381,  387,  387,  387,  387,  387,
     1236      387,  395,  422,  418,  414,  415,  381,  395,  399,  420,
     1237      416,  381,  384,  381,  423,  422,  381,  884,  381,  385,
     1238      385,  385,  385,  385,  385,  394,  399,  424,  387,  416,
     1239      423,  420,  432,  395,  399,  385,  385,  385,  417,  385,
     1240      385,  388,  388,  388,  388,  388,  388,  417,  394,  424,
     1241
     1242      394,  880,  385,  432,  394,  876,  398,  385,  385,  385,
     1243      394,  396,  385,  396,  385,  425,  396,  396,  396,  396,
     1244      396,  396,  394,  419,  388,  421,  394,  426,  425,  398,
     1245      394,  398,  419,  427,  421,  398,  428,  429,  437,  433,
     1246      431,  398,  429,  426,  426,  430,  431,  434,  435,  396,
     1247      433,  441,  437,  398,  428,  427,  439,  398,  442,  444,
     1248      430,  398,  443,  435,  445,  447,  434,  430,  439,  446,
     1249      445,  449,  441,  451,  447,  443,  452,  453,  454,  455,
     1250      442,  456,  444,  461,  446,  459,  449,  457,  462,  463,
     1251      464,  465,  453,  451,  455,  466,  457,  467,  452,  464,
     1252
     1253      454,  456,  459,  468,  469,  470,  461,  471,  474,  473,
     1254      475,  463,  465,  469,  462,  466,  473,  467,  476,  478,
     1255      471,  477,  481,  470,  479,  468,  532,  476,  482,  477,
     1256      535,  483,  475,  474,  483,  479,  478,  482,  511,  477,
     1257      484,  873,  512,  532,  481,  535,  484,  493,  493,  493,
     1258      493,  504,  504,  504,  504,  504,  504,  506,  506,  506,
     1259      506,  506,  506,  536,  511,  540,  533,  504,  512,  504,
     1260      540,  504,  504,  507,  507,  507,  507,  507,  507,  533,
     1261      583,  623,  508,  536,  504,  538,  545,  510,  583,  504,
     1262      506,  504,  508,  509,  504,  509,  504,  510,  509,  509,
     1263
     1264      509,  509,  509,  509,  623,  545,  507,  538,  508,  542,
     1265      537,  539,  542,  510,  514,  514,  514,  514,  514,  514,
     1266      516,  543,  516,  537,  539,  516,  516,  516,  516,  516,
     1267      516,  509,  515,  515,  515,  515,  515,  515,  541,  544,
     1268      546,  543,  547,  833,  550,  549,  553,  554,  515,  541,
     1269      515,  547,  515,  515,  544,  548,  549,  550,  552,  833,
     1270      548,  546,  555,  561,  554,  515,  562,  552,  553,  556,
     1271      515,  555,  515,  558,  556,  515,  559,  515,  563,  558,
     1272      561,  562,  564,  566,  567,  559,  568,  569,  571,  572,
     1273      574,  564,  566,  563,  572,  575,  579,  580,  568,  574,
     1274
     1275      581,  567,  569,  571,  575,  584,  585,  586,  587,  592,
     1276      580,  594,  591,  585,  595,  584,  588,  581,  579,  592,
     1277      587,  591,  588,  597,  872,  871,  643,  595,  594,  586,
     1278      615,  615,  615,  615,  615,  615,  616,  616,  616,  616,
     1279      616,  616,  618,  643,  618,  597,  642,  618,  618,  618,
     1280      618,  618,  618,  621,  621,  621,  621,  621,  621,  642,
     1281      622,  622,  647,  615,  617,  617,  617,  617,  617,  617,
     1282      624,  639,  624,  644,  640,  624,  639,  870,  641,  647,
     1283      617,  640,  617,  622,  617,  617,  621,  641,  645,  639,
     1284      646,  650,  624,  649,  624,  645,  644,  617,  646,  624,
     1285
     1286      648,  651,  617,  648,  617,  652,  649,  617,  653,  617,
     1287      654,  655,  656,  650,  655,  657,  651,  659,  658,  660,
     1288      661,  663,  662,  665,  672,  653,  666,  652,  660,  656,
     1289      663,  667,  654,  658,  671,  674,  677,  659,  661,  721,
     1290      667,  685,  678,  657,  662,  677,  665,  686,  666,  678,
     1291      685,  672,  674,  688,  671,  689,  724,  686,  869,  722,
     1292      721,  727,  688,  712,  712,  712,  712,  712,  712,  722,
     1293      689,  708,  708,  708,  708,  708,  708,  725,  726,  730,
     1294      732,  727,  724,  726,  725,  728,  732,  708,  728,  708,
     1295      729,  708,  708,  729,  733,  735,  712,  730,  735,  734,
     1296
     1297      736,  737,  738,  739,  708,  738,  740,  733,  734,  708,
     1298      741,  708,  739,  741,  708,  742,  708,  743,  745,  744,
     1299      746,  736,  750,  753,  747,  743,  754,  757,  742,  744,
     1300      737,  745,  740,  747,  755,  757,  776,  758,  781,  778,
     1301      750,  746,  777,  753,  778,  750,  758,  779,  754,  765,
     1302      765,  765,  765,  765,  765,  755,  776,  780,  782,  777,
     1303      783,  781,  779,  784,  785,  786,  784,  780,  788,  790,
     1304      794,  788,  790,  791,  795,  782,  792,  785,  793,  792,
     1305      791,  793,  765,  797,  801,  794,  783,  816,  818,  820,
     1306      819,  821,  820,  786,  825,  822,  823,  795,  822,  823,
     1307
     1308      826,  827,  829,  868,  827,  867,  797,  801,  819,  818,
     1309      834,  832,  825,  821,  816,  830,  831,  835,  830,  831,
     1310      832,  834,  850,  851,  829,  852,  826,  853,  852,  854,
     1311      851,  855,  856,  835,  855,  859,  853,  862,  859,  863,
     1312      862,  865,  864,  850,  866,  861,  874,  854,  863,  856,
     1313      865,  875,  878,  854,  864,  874,  875,  877,  879,  889,
     1314      877,  881,  878,  879,  881,  882,  883,  890,  882,  883,
     1315      891,  892,  893,  891,  894,  893,  897,  894,  900,  889,
     1316      901,  892,  890,  904,  905,  906,  908,  907,  909,  860,
     1317      910,  858,  904,  857,  849,  901,  848,  905,  897,  900,
     1318
     1319      910,  847,  846,  845,  908,  844,  843,  906,  907,  842,
     1320      909,  914,  914,  914,  914,  914,  914,  914,  914,  914,
     1321      914,  914,  914,  914,  915,  915,  915,  915,  915,  915,
     1322      915,  915,  915,  915,  915,  915,  915,  916,  916,  916,
     1323      916,  916,  916,  916,  916,  916,  916,  916,  916,  916,
     1324      917,  841,  840,  917,  839,  917,  917,  917,  917,  917,
     1325      918,  838,  837,  836,  918,  918,  918,  918,  918,  918,
     1326      919,  919,  919,  919,  919,  919,  919,  919,  919,  919,
     1327      919,  919,  919,  920,  828,  824,  920,  817,  920,  920,
     1328      920,  920,  920,  921,  815,  921,  921,  814,  921,  921,
     1329
     1330      921,  921,  921,  921,  813,  921,  922,  812,  811,  922,
     1331      922,  922,  922,  922,  922,  922,  922,  810,  922,  923,
     1332      923,  923,  923,  923,  923,  923,  923,  923,  923,  923,
     1333      923,  923,  924,  924,  809,  924,  808,  807,  806,  924,
     1334      925,  805,  804,  925,  803,  925,  925,  925,  925,  925,
     1335      926,  802,  926,  800,  799,  798,  926,  927,  796,  927,
     1336      789,  787,  775,  927,  928,  774,  928,  773,  772,  771,
     1337      928,  929,  770,  929,  769,  768,  767,  929,  930,  764,
     1338      930,  763,  762,  756,  930,  931,  752,  931,  751,  749,
     1339      748,  931,  932,  731,  932,  723,  720,  715,  932,  933,
     1340
     1341      713,  933,  709,  699,  695,  933,  934,  693,  934,  691,
     1342      690,  687,  934,  935,  684,  935,  936,  936,  683,  936,
     1343      936,  936,  682,  936,  937,  937,  681,  937,  938,  680,
     1344      679,  938,  676,  938,  938,  938,  938,  938,  939,  675,
     1345      939,  673,  670,  669,  939,  940,  668,  940,  664,  637,
     1346      633,  940,  941,  631,  941,  629,  627,  625,  941,  942,
     1347      619,  942,  943,  613,  943,  611,  609,  607,  943,  944,
     1348      605,  944,  945,  603,  601,  945,  599,  945,  945,  945,
     1349      945,  945,  946,  946,  946,  946,  946,  946,  946,  946,
     1350      946,  946,  946,  946,  946,  947,  947,  947,  947,  947,
     1351
     1352      947,  947,  947,  947,  947,  947,  947,  947,  948,  598,
     1353      948,  596,  593,  590,  948,  949,  589,  949,  582,  578,
     1354      577,  949,  950,  576,  950,  573,  570,  565,  950,  951,
     1355      560,  951,  952,  557,  952,  534,  530,  528,  952,  953,
     1356      526,  953,  954,  524,  954,  522,  520,  519,  954,  955,
     1357      518,  955,  956,  517,  956,  505,  502,  500,  956,  957,
     1358      499,  957,  958,  498,  958,  496,  494,  491,  958,  959,
     1359      489,  959,  960,  487,  960,  485,  480,  460,  960,  961,
     1360      458,  961,  962,  450,  962,  448,  440,  438,  962,  963,
     1361      436,  963,  964,  410,  964,  408,  964,  406,  964,  965,
     1362
     1363      404,  965,  403,  965,  402,  965,  966,  966,  389,  966,
     1364      966,  966,  386,  966,  967,  377,  967,  375,  374,  370,
     1365      967,  968,  368,  968,  366,  364,  360,  968,  969,  358,
     1366      969,  357,  356,  344,  969,  970,  327,  970,  971,  304,
     1367      971,  283,  281,  279,  971,  972,  278,  972,  973,  277,
     1368      973,  275,  274,  269,  973,  974,  265,  974,  975,  264,
     1369      975,  260,  257,  256,  975,  976,  245,  976,  977,  244,
     1370      237,  977,  236,  977,  977,  977,  977,  977,  978,  978,
     1371      978,  978,  978,  978,  978,  978,  978,  978,  978,  978,
     1372      978,  979,  233,  979,  223,  221,  220,  979,  980,  219,
     1373
     1374      980,  981,  213,  981,  212,  210,  205,  981,  982,  180,
     1375      982,  983,  151,  983,  149,  148,  142,  983,  984,  140,
     1376      984,  985,  138,  985,  130,  127,  126,  985,  986,  122,
     1377      986,  987,  103,  987,  100,   97,   95,  987,  988,   88,
     1378      988,  989,   74,  989,   72,   68,   36,  989,  990,   33,
     1379      990,  991,   18,  991,   11,    4,    3,  991,  992,    0,
     1380      992,    0,    0,    0,  992,  993,    0,  993,  994,    0,
     1381      994,    0,    0,    0,  994,  995,    0,  995,  996,    0,
     1382      996,    0,  996,    0,  996,  997,    0,  997,    0,    0,
     1383        0,  997,  998,    0,  998,    0,    0,    0,  998,  999,
     1384
     1385        0,  999, 1000,    0, 1000,    0,    0,    0, 1000, 1001,
     1386        0, 1001, 1002,    0, 1002,    0,    0,    0, 1002, 1003,
     1387        0, 1003, 1004,    0, 1004,    0,    0,    0, 1004, 1005,
     1388        0, 1005, 1006,    0, 1006,    0,    0,    0, 1006, 1007,
     1389        0, 1007, 1008,    0, 1008,    0,    0,    0, 1008, 1009,
     1390        0, 1009, 1010,    0,    0, 1010,    0, 1010, 1010, 1010,
     1391     1010, 1010, 1011, 1011, 1011, 1011, 1011, 1011, 1011, 1011,
     1392     1011, 1011, 1011, 1011, 1011, 1012,    0, 1012,    0,    0,
     1393        0, 1012, 1013,    0, 1013, 1014,    0, 1014,    0,    0,
     1394        0, 1014, 1015,    0, 1015, 1016,    0, 1016,    0,    0,
     1395
     1396        0, 1016, 1017,    0, 1017, 1018,    0, 1018,    0,    0,
     1397        0, 1018, 1019,    0, 1019, 1020,    0, 1020,    0,    0,
     1398        0, 1020, 1021,    0, 1021, 1022,    0, 1022,    0,    0,
     1399        0, 1022, 1023,    0, 1023, 1024,    0, 1024,    0,    0,
     1400        0, 1024, 1025,    0, 1025, 1026,    0, 1026,    0,    0,
     1401        0, 1026, 1027,    0, 1027, 1028,    0, 1028,    0,    0,
     1402        0, 1028, 1029,    0, 1029,    0,    0,    0, 1029, 1030,
     1403        0, 1030, 1031,    0, 1031,    0,    0,    0, 1031, 1032,
     1404        0, 1032, 1033,    0, 1033,    0,    0,    0, 1033, 1034,
     1405        0, 1034, 1035,    0, 1035,    0,    0,    0, 1035, 1036,
     1406
     1407        0, 1036, 1037,    0, 1037, 1038,    0, 1038, 1039,    0,
     1408        0, 1039,    0, 1039, 1039, 1039, 1039, 1039, 1040,    0,
     1409     1040, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041,
     1410     1041, 1041, 1041, 1041, 1042,    0, 1042,    0,    0,    0,
     1411     1042, 1043,    0, 1043, 1044,    0, 1044,    0,    0,    0,
     1412     1044, 1045,    0, 1045, 1046,    0, 1046, 1047,    0, 1047,
     1413     1048,    0,    0, 1048,    0, 1048, 1048, 1048, 1048, 1048,
     1414     1049,    0, 1049, 1050,    0, 1050, 1051,    0, 1051, 1052,
     1415        0, 1052, 1053,    0, 1053, 1054,    0, 1054, 1055,    0,
     1416     1055, 1056,    0, 1056,    0,    0,    0, 1056, 1057,    0,
     1417
     1418     1057, 1058,    0, 1058,    0,    0,    0, 1058, 1059,    0,
    14201419     1059, 1060,    0, 1060, 1061,    0, 1061, 1062,    0, 1062,
    1421      1063,    0, 1063,    0,    0,    0, 1063, 1064,    0, 1064,
    1422         0,    0,    0, 1064, 1065,    0, 1065,    0,    0,    0,
    1423      1065, 1066,    0, 1066, 1067,    0, 1067,    0,    0,    0,
    1424      1067, 1068,    0, 1068,    0,    0,    0, 1068, 1069,    0,
    1425      1069,    0,    0,    0, 1069, 1070,    0, 1070,    0,    0,
    1426         0, 1070, 1071,    0, 1071,    0,    0,    0, 1071, 1072,
    1427 
    1428         0, 1072,    0,    0,    0, 1072, 1073,    0, 1073,    0,
    1429         0,    0, 1073, 1074,    0, 1074,    0,    0,    0, 1074,
    1430      1075,    0, 1075,    0,    0,    0, 1075, 1076,    0, 1076,
    1431         0,    0,    0, 1076, 1077,    0, 1077,    0,    0,    0,
    1432      1077, 1078,    0, 1078,    0,    0,    0, 1078, 1079,    0,
    1433      1079,    0,    0,    0, 1079, 1080,    0, 1080,    0,    0,
    1434         0, 1080, 1081,    0, 1081,    0,    0,    0, 1081, 1082,
    1435         0, 1082,    0,    0,    0, 1082,  908,  908,  908,  908,
    1436       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1437       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1438 
    1439       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1440       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1441       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1442       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1443       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1444       908,  908,  908,  908,  908,  908,  908,  908,  908,  908,
    1445       908,  908
     1420     1063,    0, 1063,    0,    0,    0, 1063, 1064,    0,    0,
     1421     1064,    0, 1064, 1064, 1064, 1064, 1064, 1065,    0, 1065,
     1422     1066,    0, 1066, 1067,    0, 1067, 1068,    0, 1068,    0,
     1423        0,    0, 1068, 1069,    0, 1069,    0,    0,    0, 1069,
     1424     1070,    0, 1070,    0,    0,    0, 1070, 1071,    0, 1071,
     1425     1072,    0, 1072,    0,    0,    0, 1072, 1073,    0, 1073,
     1426        0,    0,    0, 1073, 1074,    0, 1074,    0,    0,    0,
     1427     1074, 1075,    0, 1075,    0,    0,    0, 1075, 1076,    0,
     1428
     1429     1076,    0,    0,    0, 1076, 1077,    0, 1077,    0,    0,
     1430        0, 1077, 1078,    0, 1078,    0,    0,    0, 1078, 1079,
     1431        0, 1079,    0,    0,    0, 1079, 1080,    0, 1080,    0,
     1432        0,    0, 1080, 1081,    0, 1081,    0,    0,    0, 1081,
     1433     1082,    0, 1082,    0,    0,    0, 1082, 1083,    0, 1083,
     1434        0,    0,    0, 1083, 1084,    0, 1084,    0,    0,    0,
     1435     1084, 1085,    0, 1085,    0,    0,    0, 1085, 1086,    0,
     1436     1086,    0,    0,    0, 1086, 1087,    0, 1087,    0,    0,
     1437        0, 1087,  913,  913,  913,  913,  913,  913,  913,  913,
     1438      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1439
     1440      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1441      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1442      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1443      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1444      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1445      913,  913,  913,  913,  913,  913,  913,  913,  913,  913,
     1446      913,  913,  913,  913,  913,  913,  913,  913
    14461447    } ;
    14471448
    14481449/* Table of booleans, true if rule could match eol. */
    1449 static yyconst flex_int32_t yy_rule_can_match_eol[187] =
     1450static yyconst flex_int32_t yy_rule_can_match_eol[188] =
    14501451    {   0,
    145114521, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     
    14551456    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    14561457    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1457     0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     1458    0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    14581459    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    14591460    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1460     0, 0, 0, 0, 0, 0, 0,     };
     1461    0, 0, 0, 0, 0, 0, 0, 0,     };
    14611462
    14621463static yy_state_type yy_last_accepting_state;
     
    14861487 * Created On       : Sat Sep 22 08:58:10 2001
    14871488 * Last Modified By : Peter A. Buhr
    1488  * Last Modified On : Tue Nov 29 11:32:00 2016
    1489  * Update Count     : 501
     1489 * Last Modified On : Fri Mar  3 22:18:00 2017
     1490 * Update Count     : 502
    14901491 */
    14911492#line 20 "lex.ll"
     
    15481549
    15491550
    1550 #line 1551 "Parser/lex.cc"
     1551#line 1552 "Parser/lex.cc"
    15511552
    15521553#define INITIAL 0
     
    17431744
    17441745                                   /* line directives */
    1745 #line 1746 "Parser/lex.cc"
     1746#line 1747 "Parser/lex.cc"
    17461747
    17471748        if ( !(yy_init) )
     
    17971798                                {
    17981799                                yy_current_state = (int) yy_def[yy_current_state];
    1799                                 if ( yy_current_state >= 909 )
     1800                                if ( yy_current_state >= 914 )
    18001801                                        yy_c = yy_meta[(unsigned int) yy_c];
    18011802                                }
     
    18031804                        ++yy_cp;
    18041805                        }
    1805                 while ( yy_base[yy_current_state] != 2877 );
     1806                while ( yy_base[yy_current_state] != 2883 );
    18061807
    18071808yy_find_action:
     
    22092210YY_RULE_SETUP
    22102211#line 237 "lex.ll"
     2212{ KEYWORD_RETURN(MUTEX); }                              // CFA
     2213        YY_BREAK
     2214case 70:
     2215YY_RULE_SETUP
     2216#line 238 "lex.ll"
    22112217{ KEYWORD_RETURN(NORETURN); }                   // C11
    22122218        YY_BREAK
    2213 case 70:
    2214 YY_RULE_SETUP
    2215 #line 238 "lex.ll"
     2219case 71:
     2220YY_RULE_SETUP
     2221#line 239 "lex.ll"
    22162222{ KEYWORD_RETURN(OFFSETOF); }           // GCC
    22172223        YY_BREAK
    2218 case 71:
    2219 YY_RULE_SETUP
    2220 #line 239 "lex.ll"
     2224case 72:
     2225YY_RULE_SETUP
     2226#line 240 "lex.ll"
    22212227{ NUMERIC_RETURN(ONE_T); }                              // CFA
    22222228        YY_BREAK
    2223 case 72:
    2224 YY_RULE_SETUP
    2225 #line 240 "lex.ll"
     2229case 73:
     2230YY_RULE_SETUP
     2231#line 241 "lex.ll"
    22262232{ KEYWORD_RETURN(OTYPE); }                              // CFA
    22272233        YY_BREAK
    2228 case 73:
    2229 YY_RULE_SETUP
    2230 #line 241 "lex.ll"
     2234case 74:
     2235YY_RULE_SETUP
     2236#line 242 "lex.ll"
    22312237{ KEYWORD_RETURN(REGISTER); }
    22322238        YY_BREAK
    2233 case 74:
    2234 YY_RULE_SETUP
    2235 #line 242 "lex.ll"
     2239case 75:
     2240YY_RULE_SETUP
     2241#line 243 "lex.ll"
    22362242{ KEYWORD_RETURN(RESTRICT); }                   // C99
    2237         YY_BREAK
    2238 case 75:
    2239 YY_RULE_SETUP
    2240 #line 243 "lex.ll"
    2241 { KEYWORD_RETURN(RESTRICT); }                   // GCC
    22422243        YY_BREAK
    22432244case 76:
     
    22492250YY_RULE_SETUP
    22502251#line 245 "lex.ll"
     2252{ KEYWORD_RETURN(RESTRICT); }                   // GCC
     2253        YY_BREAK
     2254case 78:
     2255YY_RULE_SETUP
     2256#line 246 "lex.ll"
    22512257{ KEYWORD_RETURN(RETURN); }
    22522258        YY_BREAK
    2253 case 78:
    2254 YY_RULE_SETUP
    2255 #line 246 "lex.ll"
     2259case 79:
     2260YY_RULE_SETUP
     2261#line 247 "lex.ll"
    22562262{ KEYWORD_RETURN(SHORT); }
    22572263        YY_BREAK
    2258 case 79:
    2259 YY_RULE_SETUP
    2260 #line 247 "lex.ll"
     2264case 80:
     2265YY_RULE_SETUP
     2266#line 248 "lex.ll"
    22612267{ KEYWORD_RETURN(SIGNED); }
    2262         YY_BREAK
    2263 case 80:
    2264 YY_RULE_SETUP
    2265 #line 248 "lex.ll"
    2266 { KEYWORD_RETURN(SIGNED); }                             // GCC
    22672268        YY_BREAK
    22682269case 81:
     
    22742275YY_RULE_SETUP
    22752276#line 250 "lex.ll"
     2277{ KEYWORD_RETURN(SIGNED); }                             // GCC
     2278        YY_BREAK
     2279case 83:
     2280YY_RULE_SETUP
     2281#line 251 "lex.ll"
    22762282{ KEYWORD_RETURN(SIZEOF); }
    22772283        YY_BREAK
    2278 case 83:
    2279 YY_RULE_SETUP
    2280 #line 251 "lex.ll"
     2284case 84:
     2285YY_RULE_SETUP
     2286#line 252 "lex.ll"
    22812287{ KEYWORD_RETURN(STATIC); }
    22822288        YY_BREAK
    2283 case 84:
    2284 YY_RULE_SETUP
    2285 #line 252 "lex.ll"
     2289case 85:
     2290YY_RULE_SETUP
     2291#line 253 "lex.ll"
    22862292{ KEYWORD_RETURN(STATICASSERT); }               // C11
    22872293        YY_BREAK
    2288 case 85:
    2289 YY_RULE_SETUP
    2290 #line 253 "lex.ll"
     2294case 86:
     2295YY_RULE_SETUP
     2296#line 254 "lex.ll"
    22912297{ KEYWORD_RETURN(STRUCT); }
    22922298        YY_BREAK
    2293 case 86:
    2294 YY_RULE_SETUP
    2295 #line 254 "lex.ll"
     2299case 87:
     2300YY_RULE_SETUP
     2301#line 255 "lex.ll"
    22962302{ KEYWORD_RETURN(SWITCH); }
    22972303        YY_BREAK
    2298 case 87:
    2299 YY_RULE_SETUP
    2300 #line 255 "lex.ll"
     2304case 88:
     2305YY_RULE_SETUP
     2306#line 256 "lex.ll"
    23012307{ KEYWORD_RETURN(THREADLOCAL); }                // C11
    23022308        YY_BREAK
    2303 case 88:
    2304 YY_RULE_SETUP
    2305 #line 256 "lex.ll"
     2309case 89:
     2310YY_RULE_SETUP
     2311#line 257 "lex.ll"
    23062312{ KEYWORD_RETURN(THROW); }                              // CFA
    23072313        YY_BREAK
    2308 case 89:
    2309 YY_RULE_SETUP
    2310 #line 257 "lex.ll"
     2314case 90:
     2315YY_RULE_SETUP
     2316#line 258 "lex.ll"
    23112317{ KEYWORD_RETURN(THROWRESUME); }                // CFA
    23122318        YY_BREAK
    2313 case 90:
    2314 YY_RULE_SETUP
    2315 #line 258 "lex.ll"
     2319case 91:
     2320YY_RULE_SETUP
     2321#line 259 "lex.ll"
    23162322{ KEYWORD_RETURN(TRAIT); }                              // CFA
    23172323        YY_BREAK
    2318 case 91:
    2319 YY_RULE_SETUP
    2320 #line 259 "lex.ll"
     2324case 92:
     2325YY_RULE_SETUP
     2326#line 260 "lex.ll"
    23212327{ KEYWORD_RETURN(TRY); }                                // CFA
    23222328        YY_BREAK
    2323 case 92:
    2324 YY_RULE_SETUP
    2325 #line 260 "lex.ll"
     2329case 93:
     2330YY_RULE_SETUP
     2331#line 261 "lex.ll"
    23262332{ KEYWORD_RETURN(TTYPE); }                              // CFA
    23272333        YY_BREAK
    2328 case 93:
    2329 YY_RULE_SETUP
    2330 #line 261 "lex.ll"
     2334case 94:
     2335YY_RULE_SETUP
     2336#line 262 "lex.ll"
    23312337{ KEYWORD_RETURN(TYPEDEF); }
    2332         YY_BREAK
    2333 case 94:
    2334 YY_RULE_SETUP
    2335 #line 262 "lex.ll"
    2336 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    23372338        YY_BREAK
    23382339case 95:
     
    23492350YY_RULE_SETUP
    23502351#line 265 "lex.ll"
     2352{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2353        YY_BREAK
     2354case 98:
     2355YY_RULE_SETUP
     2356#line 266 "lex.ll"
    23512357{ KEYWORD_RETURN(UNION); }
    23522358        YY_BREAK
    2353 case 98:
    2354 YY_RULE_SETUP
    2355 #line 266 "lex.ll"
     2359case 99:
     2360YY_RULE_SETUP
     2361#line 267 "lex.ll"
    23562362{ KEYWORD_RETURN(UNSIGNED); }
    23572363        YY_BREAK
    2358 case 99:
    2359 YY_RULE_SETUP
    2360 #line 267 "lex.ll"
     2364case 100:
     2365YY_RULE_SETUP
     2366#line 268 "lex.ll"
    23612367{ KEYWORD_RETURN(VALIST); }                     // GCC
    23622368        YY_BREAK
    2363 case 100:
    2364 YY_RULE_SETUP
    2365 #line 268 "lex.ll"
     2369case 101:
     2370YY_RULE_SETUP
     2371#line 269 "lex.ll"
    23662372{ KEYWORD_RETURN(VOID); }
    23672373        YY_BREAK
    2368 case 101:
    2369 YY_RULE_SETUP
    2370 #line 269 "lex.ll"
     2374case 102:
     2375YY_RULE_SETUP
     2376#line 270 "lex.ll"
    23712377{ KEYWORD_RETURN(VOLATILE); }
    2372         YY_BREAK
    2373 case 102:
    2374 YY_RULE_SETUP
    2375 #line 270 "lex.ll"
    2376 { KEYWORD_RETURN(VOLATILE); }                   // GCC
    23772378        YY_BREAK
    23782379case 103:
     
    23842385YY_RULE_SETUP
    23852386#line 272 "lex.ll"
     2387{ KEYWORD_RETURN(VOLATILE); }                   // GCC
     2388        YY_BREAK
     2389case 105:
     2390YY_RULE_SETUP
     2391#line 273 "lex.ll"
    23862392{ KEYWORD_RETURN(WHILE); }
    23872393        YY_BREAK
    2388 case 105:
    2389 YY_RULE_SETUP
    2390 #line 273 "lex.ll"
     2394case 106:
     2395YY_RULE_SETUP
     2396#line 274 "lex.ll"
    23912397{ NUMERIC_RETURN(ZERO_T); }                             // CFA
    23922398        YY_BREAK
    23932399/* identifier */
    2394 case 106:
    2395 YY_RULE_SETUP
    2396 #line 276 "lex.ll"
     2400case 107:
     2401YY_RULE_SETUP
     2402#line 277 "lex.ll"
    23972403{ IDENTIFIER_RETURN(); }
    23982404        YY_BREAK
    2399 case 107:
    2400 YY_RULE_SETUP
    2401 #line 277 "lex.ll"
     2405case 108:
     2406YY_RULE_SETUP
     2407#line 278 "lex.ll"
    24022408{ ATTRIBUTE_RETURN(); }
    24032409        YY_BREAK
    2404 case 108:
    2405 YY_RULE_SETUP
    2406 #line 278 "lex.ll"
     2410case 109:
     2411YY_RULE_SETUP
     2412#line 279 "lex.ll"
    24072413{ BEGIN BKQUOTE; }
    24082414        YY_BREAK
    2409 case 109:
    2410 YY_RULE_SETUP
    2411 #line 279 "lex.ll"
     2415case 110:
     2416YY_RULE_SETUP
     2417#line 280 "lex.ll"
    24122418{ IDENTIFIER_RETURN(); }
    24132419        YY_BREAK
    2414 case 110:
    2415 YY_RULE_SETUP
    2416 #line 280 "lex.ll"
     2420case 111:
     2421YY_RULE_SETUP
     2422#line 281 "lex.ll"
    24172423{ BEGIN 0; }
    24182424        YY_BREAK
    24192425/* numeric constants */
    2420 case 111:
    2421 YY_RULE_SETUP
    2422 #line 283 "lex.ll"
     2426case 112:
     2427YY_RULE_SETUP
     2428#line 284 "lex.ll"
    24232429{ NUMERIC_RETURN(ZERO); }                               // CFA
    24242430        YY_BREAK
    2425 case 112:
    2426 YY_RULE_SETUP
    2427 #line 284 "lex.ll"
     2431case 113:
     2432YY_RULE_SETUP
     2433#line 285 "lex.ll"
    24282434{ NUMERIC_RETURN(ONE); }                                // CFA
    2429         YY_BREAK
    2430 case 113:
    2431 YY_RULE_SETUP
    2432 #line 285 "lex.ll"
    2433 { NUMERIC_RETURN(INTEGERconstant); }
    24342435        YY_BREAK
    24352436case 114:
     
    24462447YY_RULE_SETUP
    24472448#line 288 "lex.ll"
     2449{ NUMERIC_RETURN(INTEGERconstant); }
     2450        YY_BREAK
     2451case 117:
     2452YY_RULE_SETUP
     2453#line 289 "lex.ll"
    24482454{ NUMERIC_RETURN(REALDECIMALconstant); } // must appear before floating_constant
    24492455        YY_BREAK
    2450 case 117:
    2451 YY_RULE_SETUP
    2452 #line 289 "lex.ll"
     2456case 118:
     2457YY_RULE_SETUP
     2458#line 290 "lex.ll"
    24532459{ NUMERIC_RETURN(REALFRACTIONconstant); } // must appear before floating_constant
    2454         YY_BREAK
    2455 case 118:
    2456 YY_RULE_SETUP
    2457 #line 290 "lex.ll"
    2458 { NUMERIC_RETURN(FLOATINGconstant); }
    24592460        YY_BREAK
    24602461case 119:
     
    24632464{ NUMERIC_RETURN(FLOATINGconstant); }
    24642465        YY_BREAK
     2466case 120:
     2467YY_RULE_SETUP
     2468#line 292 "lex.ll"
     2469{ NUMERIC_RETURN(FLOATINGconstant); }
     2470        YY_BREAK
    24652471/* character constant, allows empty value */
    2466 case 120:
    2467 YY_RULE_SETUP
    2468 #line 294 "lex.ll"
     2472case 121:
     2473YY_RULE_SETUP
     2474#line 295 "lex.ll"
    24692475{ BEGIN QUOTE; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24702476        YY_BREAK
    2471 case 121:
    2472 YY_RULE_SETUP
    2473 #line 295 "lex.ll"
     2477case 122:
     2478YY_RULE_SETUP
     2479#line 296 "lex.ll"
    24742480{ strtext->append( yytext, yyleng ); }
    24752481        YY_BREAK
    2476 case 122:
    2477 /* rule 122 can match eol */
    2478 YY_RULE_SETUP
    2479 #line 296 "lex.ll"
     2482case 123:
     2483/* rule 123 can match eol */
     2484YY_RULE_SETUP
     2485#line 297 "lex.ll"
    24802486{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
    24812487        YY_BREAK
    24822488/* ' stop highlighting */
    24832489/* string constant */
    2484 case 123:
    2485 YY_RULE_SETUP
    2486 #line 300 "lex.ll"
     2490case 124:
     2491YY_RULE_SETUP
     2492#line 301 "lex.ll"
    24872493{ BEGIN STRING; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24882494        YY_BREAK
    2489 case 124:
    2490 YY_RULE_SETUP
    2491 #line 301 "lex.ll"
     2495case 125:
     2496YY_RULE_SETUP
     2497#line 302 "lex.ll"
    24922498{ strtext->append( yytext, yyleng ); }
    24932499        YY_BREAK
    2494 case 125:
    2495 /* rule 125 can match eol */
    2496 YY_RULE_SETUP
    2497 #line 302 "lex.ll"
     2500case 126:
     2501/* rule 126 can match eol */
     2502YY_RULE_SETUP
     2503#line 303 "lex.ll"
    24982504{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
    24992505        YY_BREAK
    25002506/* " stop highlighting */
    25012507/* common character/string constant */
    2502 case 126:
    2503 YY_RULE_SETUP
    2504 #line 306 "lex.ll"
     2508case 127:
     2509YY_RULE_SETUP
     2510#line 307 "lex.ll"
    25052511{ rm_underscore(); strtext->append( yytext, yyleng ); }
    25062512        YY_BREAK
    2507 case 127:
    2508 /* rule 127 can match eol */
    2509 YY_RULE_SETUP
    2510 #line 307 "lex.ll"
     2513case 128:
     2514/* rule 128 can match eol */
     2515YY_RULE_SETUP
     2516#line 308 "lex.ll"
    25112517{}                                              // continuation (ALSO HANDLED BY CPP)
    25122518        YY_BREAK
    2513 case 128:
    2514 YY_RULE_SETUP
    2515 #line 308 "lex.ll"
     2519case 129:
     2520YY_RULE_SETUP
     2521#line 309 "lex.ll"
    25162522{ strtext->append( yytext, yyleng ); } // unknown escape character
    25172523        YY_BREAK
    25182524/* punctuation */
    2519 case 129:
    2520 YY_RULE_SETUP
    2521 #line 311 "lex.ll"
    2522 { ASCIIOP_RETURN(); }
    2523         YY_BREAK
    25242525case 130:
    25252526YY_RULE_SETUP
     
    25502551YY_RULE_SETUP
    25512552#line 317 "lex.ll"
     2553{ ASCIIOP_RETURN(); }
     2554        YY_BREAK
     2555case 136:
     2556YY_RULE_SETUP
     2557#line 318 "lex.ll"
    25522558{ ASCIIOP_RETURN(); }                                   // also operator
    2553         YY_BREAK
    2554 case 136:
    2555 YY_RULE_SETUP
    2556 #line 318 "lex.ll"
    2557 { ASCIIOP_RETURN(); }
    25582559        YY_BREAK
    25592560case 137:
     
    25652566YY_RULE_SETUP
    25662567#line 320 "lex.ll"
     2568{ ASCIIOP_RETURN(); }
     2569        YY_BREAK
     2570case 139:
     2571YY_RULE_SETUP
     2572#line 321 "lex.ll"
    25672573{ ASCIIOP_RETURN(); }                                   // also operator
    25682574        YY_BREAK
    2569 case 139:
    2570 YY_RULE_SETUP
    2571 #line 321 "lex.ll"
     2575case 140:
     2576YY_RULE_SETUP
     2577#line 322 "lex.ll"
    25722578{ NAMEDOP_RETURN(ELLIPSIS); }
    25732579        YY_BREAK
    25742580/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
    2575 case 140:
    2576 YY_RULE_SETUP
    2577 #line 324 "lex.ll"
     2581case 141:
     2582YY_RULE_SETUP
     2583#line 325 "lex.ll"
    25782584{ RETURN_VAL('['); }
    25792585        YY_BREAK
    2580 case 141:
    2581 YY_RULE_SETUP
    2582 #line 325 "lex.ll"
     2586case 142:
     2587YY_RULE_SETUP
     2588#line 326 "lex.ll"
    25832589{ RETURN_VAL(']'); }
    25842590        YY_BREAK
    2585 case 142:
    2586 YY_RULE_SETUP
    2587 #line 326 "lex.ll"
     2591case 143:
     2592YY_RULE_SETUP
     2593#line 327 "lex.ll"
    25882594{ RETURN_VAL('{'); }
    25892595        YY_BREAK
    2590 case 143:
    2591 YY_RULE_SETUP
    2592 #line 327 "lex.ll"
     2596case 144:
     2597YY_RULE_SETUP
     2598#line 328 "lex.ll"
    25932599{ RETURN_VAL('}'); }
    25942600        YY_BREAK
    25952601/* operators */
    2596 case 144:
    2597 YY_RULE_SETUP
    2598 #line 330 "lex.ll"
    2599 { ASCIIOP_RETURN(); }
    2600         YY_BREAK
    26012602case 145:
    26022603YY_RULE_SETUP
     
    26662667case 158:
    26672668YY_RULE_SETUP
    2668 #line 345 "lex.ll"
     2669#line 344 "lex.ll"
     2670{ ASCIIOP_RETURN(); }
     2671        YY_BREAK
     2672case 159:
     2673YY_RULE_SETUP
     2674#line 346 "lex.ll"
    26692675{ NAMEDOP_RETURN(ICR); }
    26702676        YY_BREAK
    2671 case 159:
    2672 YY_RULE_SETUP
    2673 #line 346 "lex.ll"
     2677case 160:
     2678YY_RULE_SETUP
     2679#line 347 "lex.ll"
    26742680{ NAMEDOP_RETURN(DECR); }
    26752681        YY_BREAK
    2676 case 160:
    2677 YY_RULE_SETUP
    2678 #line 347 "lex.ll"
     2682case 161:
     2683YY_RULE_SETUP
     2684#line 348 "lex.ll"
    26792685{ NAMEDOP_RETURN(EQ); }
    26802686        YY_BREAK
    2681 case 161:
    2682 YY_RULE_SETUP
    2683 #line 348 "lex.ll"
     2687case 162:
     2688YY_RULE_SETUP
     2689#line 349 "lex.ll"
    26842690{ NAMEDOP_RETURN(NE); }
    26852691        YY_BREAK
    2686 case 162:
    2687 YY_RULE_SETUP
    2688 #line 349 "lex.ll"
     2692case 163:
     2693YY_RULE_SETUP
     2694#line 350 "lex.ll"
    26892695{ NAMEDOP_RETURN(LS); }
    26902696        YY_BREAK
    2691 case 163:
    2692 YY_RULE_SETUP
    2693 #line 350 "lex.ll"
     2697case 164:
     2698YY_RULE_SETUP
     2699#line 351 "lex.ll"
    26942700{ NAMEDOP_RETURN(RS); }
    26952701        YY_BREAK
    2696 case 164:
    2697 YY_RULE_SETUP
    2698 #line 351 "lex.ll"
     2702case 165:
     2703YY_RULE_SETUP
     2704#line 352 "lex.ll"
    26992705{ NAMEDOP_RETURN(LE); }
    27002706        YY_BREAK
    2701 case 165:
    2702 YY_RULE_SETUP
    2703 #line 352 "lex.ll"
     2707case 166:
     2708YY_RULE_SETUP
     2709#line 353 "lex.ll"
    27042710{ NAMEDOP_RETURN(GE); }
    27052711        YY_BREAK
    2706 case 166:
    2707 YY_RULE_SETUP
    2708 #line 353 "lex.ll"
     2712case 167:
     2713YY_RULE_SETUP
     2714#line 354 "lex.ll"
    27092715{ NAMEDOP_RETURN(ANDAND); }
    27102716        YY_BREAK
    2711 case 167:
    2712 YY_RULE_SETUP
    2713 #line 354 "lex.ll"
     2717case 168:
     2718YY_RULE_SETUP
     2719#line 355 "lex.ll"
    27142720{ NAMEDOP_RETURN(OROR); }
    27152721        YY_BREAK
    2716 case 168:
    2717 YY_RULE_SETUP
    2718 #line 355 "lex.ll"
     2722case 169:
     2723YY_RULE_SETUP
     2724#line 356 "lex.ll"
    27192725{ NAMEDOP_RETURN(ARROW); }
    27202726        YY_BREAK
    2721 case 169:
    2722 YY_RULE_SETUP
    2723 #line 356 "lex.ll"
     2727case 170:
     2728YY_RULE_SETUP
     2729#line 357 "lex.ll"
    27242730{ NAMEDOP_RETURN(PLUSassign); }
    27252731        YY_BREAK
    2726 case 170:
    2727 YY_RULE_SETUP
    2728 #line 357 "lex.ll"
     2732case 171:
     2733YY_RULE_SETUP
     2734#line 358 "lex.ll"
    27292735{ NAMEDOP_RETURN(MINUSassign); }
    27302736        YY_BREAK
    2731 case 171:
    2732 YY_RULE_SETUP
    2733 #line 358 "lex.ll"
     2737case 172:
     2738YY_RULE_SETUP
     2739#line 359 "lex.ll"
    27342740{ NAMEDOP_RETURN(MULTassign); }
    27352741        YY_BREAK
    2736 case 172:
    2737 YY_RULE_SETUP
    2738 #line 359 "lex.ll"
     2742case 173:
     2743YY_RULE_SETUP
     2744#line 360 "lex.ll"
    27392745{ NAMEDOP_RETURN(DIVassign); }
    27402746        YY_BREAK
    2741 case 173:
    2742 YY_RULE_SETUP
    2743 #line 360 "lex.ll"
     2747case 174:
     2748YY_RULE_SETUP
     2749#line 361 "lex.ll"
    27442750{ NAMEDOP_RETURN(MODassign); }
    27452751        YY_BREAK
    2746 case 174:
    2747 YY_RULE_SETUP
    2748 #line 361 "lex.ll"
     2752case 175:
     2753YY_RULE_SETUP
     2754#line 362 "lex.ll"
    27492755{ NAMEDOP_RETURN(ANDassign); }
    27502756        YY_BREAK
    2751 case 175:
    2752 YY_RULE_SETUP
    2753 #line 362 "lex.ll"
     2757case 176:
     2758YY_RULE_SETUP
     2759#line 363 "lex.ll"
    27542760{ NAMEDOP_RETURN(ORassign); }
    27552761        YY_BREAK
    2756 case 176:
    2757 YY_RULE_SETUP
    2758 #line 363 "lex.ll"
     2762case 177:
     2763YY_RULE_SETUP
     2764#line 364 "lex.ll"
    27592765{ NAMEDOP_RETURN(ERassign); }
    27602766        YY_BREAK
    2761 case 177:
    2762 YY_RULE_SETUP
    2763 #line 364 "lex.ll"
     2767case 178:
     2768YY_RULE_SETUP
     2769#line 365 "lex.ll"
    27642770{ NAMEDOP_RETURN(LSassign); }
    27652771        YY_BREAK
    2766 case 178:
    2767 YY_RULE_SETUP
    2768 #line 365 "lex.ll"
     2772case 179:
     2773YY_RULE_SETUP
     2774#line 366 "lex.ll"
    27692775{ NAMEDOP_RETURN(RSassign); }
    27702776        YY_BREAK
    2771 case 179:
    2772 YY_RULE_SETUP
    2773 #line 367 "lex.ll"
     2777case 180:
     2778YY_RULE_SETUP
     2779#line 368 "lex.ll"
    27742780{ NAMEDOP_RETURN(ATassign); }                   // CFA
    27752781        YY_BREAK
    27762782/* CFA, operator identifier */
    2777 case 180:
    2778 YY_RULE_SETUP
    2779 #line 370 "lex.ll"
     2783case 181:
     2784YY_RULE_SETUP
     2785#line 371 "lex.ll"
    27802786{ IDENTIFIER_RETURN(); }                                // unary
    2781         YY_BREAK
    2782 case 181:
    2783 YY_RULE_SETUP
    2784 #line 371 "lex.ll"
    2785 { IDENTIFIER_RETURN(); }
    27862787        YY_BREAK
    27872788case 182:
     
    27932794YY_RULE_SETUP
    27942795#line 373 "lex.ll"
     2796{ IDENTIFIER_RETURN(); }
     2797        YY_BREAK
     2798case 184:
     2799YY_RULE_SETUP
     2800#line 374 "lex.ll"
    27952801{ IDENTIFIER_RETURN(); }                // binary
    27962802        YY_BREAK
     
    28212827          an argument list.
    28222828        */
    2823 case 184:
    2824 YY_RULE_SETUP
    2825 #line 400 "lex.ll"
     2829case 185:
     2830YY_RULE_SETUP
     2831#line 401 "lex.ll"
    28262832{
    28272833        // 1 or 2 character unary operator ?
     
    28362842        YY_BREAK
    28372843/* unknown characters */
    2838 case 185:
    2839 YY_RULE_SETUP
    2840 #line 412 "lex.ll"
     2844case 186:
     2845YY_RULE_SETUP
     2846#line 413 "lex.ll"
    28412847{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
    28422848        YY_BREAK
    2843 case 186:
    2844 YY_RULE_SETUP
    2845 #line 414 "lex.ll"
     2849case 187:
     2850YY_RULE_SETUP
     2851#line 415 "lex.ll"
    28462852ECHO;
    28472853        YY_BREAK
    2848 #line 2849 "Parser/lex.cc"
     2854#line 2855 "Parser/lex.cc"
    28492855case YY_STATE_EOF(INITIAL):
    28502856case YY_STATE_EOF(COMMENT):
     
    31433149                        {
    31443150                        yy_current_state = (int) yy_def[yy_current_state];
    3145                         if ( yy_current_state >= 909 )
     3151                        if ( yy_current_state >= 914 )
    31463152                                yy_c = yy_meta[(unsigned int) yy_c];
    31473153                        }
     
    31713177                {
    31723178                yy_current_state = (int) yy_def[yy_current_state];
    3173                 if ( yy_current_state >= 909 )
     3179                if ( yy_current_state >= 914 )
    31743180                        yy_c = yy_meta[(unsigned int) yy_c];
    31753181                }
    31763182        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    3177         yy_is_jam = (yy_current_state == 908);
     3183        yy_is_jam = (yy_current_state == 913);
    31783184
    31793185        return yy_is_jam ? 0 : yy_current_state;
     
    38213827#define YYTABLES_NAME "yytables"
    38223828
    3823 #line 414 "lex.ll"
     3829#line 415 "lex.ll"
    38243830
    38253831
  • src/Parser/lex.ll

    r7fe2498 ra7c90d4  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Tue Nov 29 11:32:00 2016
    13  * Update Count     : 501
     12 * Last Modified On : Fri Mar  3 22:18:00 2017
     13 * Update Count     : 502
    1414 */
    1515
     
    235235long                    { KEYWORD_RETURN(LONG); }
    236236lvalue                  { KEYWORD_RETURN(LVALUE); }                             // CFA
     237mutex                   { KEYWORD_RETURN(MUTEX); }                              // CFA
    237238_Noreturn               { KEYWORD_RETURN(NORETURN); }                   // C11
    238239__builtin_offsetof { KEYWORD_RETURN(OFFSETOF); }                // GCC
  • src/Parser/parser.cc

    r7fe2498 ra7c90d4  
    144144   enum yytokentype {
    145145     TYPEDEF = 258,
    146      AUTO = 259,
    147      EXTERN = 260,
    148      REGISTER = 261,
    149      STATIC = 262,
    150      INLINE = 263,
    151      FORTRAN = 264,
    152      CONST = 265,
    153      VOLATILE = 266,
    154      RESTRICT = 267,
    155      FORALL = 268,
    156      LVALUE = 269,
    157      VOID = 270,
    158      CHAR = 271,
    159      SHORT = 272,
    160      INT = 273,
    161      LONG = 274,
    162      FLOAT = 275,
    163      DOUBLE = 276,
    164      SIGNED = 277,
    165      UNSIGNED = 278,
    166      ZERO_T = 279,
    167      ONE_T = 280,
    168      VALIST = 281,
    169      BOOL = 282,
    170      COMPLEX = 283,
    171      IMAGINARY = 284,
    172      TYPEOF = 285,
    173      LABEL = 286,
    174      ENUM = 287,
    175      STRUCT = 288,
    176      UNION = 289,
    177      OTYPE = 290,
    178      FTYPE = 291,
    179      DTYPE = 292,
    180      TTYPE = 293,
    181      TRAIT = 294,
    182      SIZEOF = 295,
    183      OFFSETOF = 296,
    184      ATTRIBUTE = 297,
    185      EXTENSION = 298,
    186      IF = 299,
    187      ELSE = 300,
    188      SWITCH = 301,
    189      CASE = 302,
    190      DEFAULT = 303,
    191      DO = 304,
    192      WHILE = 305,
    193      FOR = 306,
    194      BREAK = 307,
    195      CONTINUE = 308,
    196      GOTO = 309,
    197      RETURN = 310,
    198      CHOOSE = 311,
    199      DISABLE = 312,
    200      ENABLE = 313,
    201      FALLTHRU = 314,
    202      TRY = 315,
    203      CATCH = 316,
    204      CATCHRESUME = 317,
    205      FINALLY = 318,
    206      THROW = 319,
    207      THROWRESUME = 320,
    208      AT = 321,
    209      ASM = 322,
    210      ALIGNAS = 323,
    211      ALIGNOF = 324,
    212      ATOMIC = 325,
    213      GENERIC = 326,
    214      NORETURN = 327,
    215      STATICASSERT = 328,
    216      THREADLOCAL = 329,
    217      IDENTIFIER = 330,
    218      QUOTED_IDENTIFIER = 331,
    219      TYPEDEFname = 332,
    220      TYPEGENname = 333,
    221      ATTR_IDENTIFIER = 334,
    222      ATTR_TYPEDEFname = 335,
    223      ATTR_TYPEGENname = 336,
    224      INTEGERconstant = 337,
    225      CHARACTERconstant = 338,
    226      STRINGliteral = 339,
    227      REALDECIMALconstant = 340,
    228      REALFRACTIONconstant = 341,
    229      FLOATINGconstant = 342,
    230      ZERO = 343,
    231      ONE = 344,
    232      ARROW = 345,
    233      ICR = 346,
    234      DECR = 347,
    235      LS = 348,
    236      RS = 349,
    237      LE = 350,
    238      GE = 351,
    239      EQ = 352,
    240      NE = 353,
    241      ANDAND = 354,
    242      OROR = 355,
    243      ELLIPSIS = 356,
    244      MULTassign = 357,
    245      DIVassign = 358,
    246      MODassign = 359,
    247      PLUSassign = 360,
    248      MINUSassign = 361,
    249      LSassign = 362,
    250      RSassign = 363,
    251      ANDassign = 364,
    252      ERassign = 365,
    253      ORassign = 366,
    254      ATassign = 367,
    255      THEN = 368
     146     EXTERN = 259,
     147     STATIC = 260,
     148     AUTO = 261,
     149     REGISTER = 262,
     150     THREADLOCAL = 263,
     151     INLINE = 264,
     152     FORTRAN = 265,
     153     NORETURN = 266,
     154     CONST = 267,
     155     VOLATILE = 268,
     156     RESTRICT = 269,
     157     ATOMIC = 270,
     158     FORALL = 271,
     159     LVALUE = 272,
     160     MUTEX = 273,
     161     VOID = 274,
     162     CHAR = 275,
     163     SHORT = 276,
     164     INT = 277,
     165     LONG = 278,
     166     FLOAT = 279,
     167     DOUBLE = 280,
     168     SIGNED = 281,
     169     UNSIGNED = 282,
     170     ZERO_T = 283,
     171     ONE_T = 284,
     172     VALIST = 285,
     173     BOOL = 286,
     174     COMPLEX = 287,
     175     IMAGINARY = 288,
     176     TYPEOF = 289,
     177     LABEL = 290,
     178     ENUM = 291,
     179     STRUCT = 292,
     180     UNION = 293,
     181     OTYPE = 294,
     182     FTYPE = 295,
     183     DTYPE = 296,
     184     TTYPE = 297,
     185     TRAIT = 298,
     186     SIZEOF = 299,
     187     OFFSETOF = 300,
     188     ATTRIBUTE = 301,
     189     EXTENSION = 302,
     190     IF = 303,
     191     ELSE = 304,
     192     SWITCH = 305,
     193     CASE = 306,
     194     DEFAULT = 307,
     195     DO = 308,
     196     WHILE = 309,
     197     FOR = 310,
     198     BREAK = 311,
     199     CONTINUE = 312,
     200     GOTO = 313,
     201     RETURN = 314,
     202     CHOOSE = 315,
     203     DISABLE = 316,
     204     ENABLE = 317,
     205     FALLTHRU = 318,
     206     TRY = 319,
     207     CATCH = 320,
     208     CATCHRESUME = 321,
     209     FINALLY = 322,
     210     THROW = 323,
     211     THROWRESUME = 324,
     212     AT = 325,
     213     ASM = 326,
     214     ALIGNAS = 327,
     215     ALIGNOF = 328,
     216     GENERIC = 329,
     217     STATICASSERT = 330,
     218     IDENTIFIER = 331,
     219     QUOTED_IDENTIFIER = 332,
     220     TYPEDEFname = 333,
     221     TYPEGENname = 334,
     222     ATTR_IDENTIFIER = 335,
     223     ATTR_TYPEDEFname = 336,
     224     ATTR_TYPEGENname = 337,
     225     INTEGERconstant = 338,
     226     CHARACTERconstant = 339,
     227     STRINGliteral = 340,
     228     REALDECIMALconstant = 341,
     229     REALFRACTIONconstant = 342,
     230     FLOATINGconstant = 343,
     231     ZERO = 344,
     232     ONE = 345,
     233     ARROW = 346,
     234     ICR = 347,
     235     DECR = 348,
     236     LS = 349,
     237     RS = 350,
     238     LE = 351,
     239     GE = 352,
     240     EQ = 353,
     241     NE = 354,
     242     ANDAND = 355,
     243     OROR = 356,
     244     ELLIPSIS = 357,
     245     MULTassign = 358,
     246     DIVassign = 359,
     247     MODassign = 360,
     248     PLUSassign = 361,
     249     MINUSassign = 362,
     250     LSassign = 363,
     251     RSassign = 364,
     252     ANDassign = 365,
     253     ERassign = 366,
     254     ORassign = 367,
     255     ATassign = 368,
     256     THEN = 369
    256257   };
    257258#endif
    258259/* Tokens.  */
    259260#define TYPEDEF 258
    260 #define AUTO 259
    261 #define EXTERN 260
    262 #define REGISTER 261
    263 #define STATIC 262
    264 #define INLINE 263
    265 #define FORTRAN 264
    266 #define CONST 265
    267 #define VOLATILE 266
    268 #define RESTRICT 267
    269 #define FORALL 268
    270 #define LVALUE 269
    271 #define VOID 270
    272 #define CHAR 271
    273 #define SHORT 272
    274 #define INT 273
    275 #define LONG 274
    276 #define FLOAT 275
    277 #define DOUBLE 276
    278 #define SIGNED 277
    279 #define UNSIGNED 278
    280 #define ZERO_T 279
    281 #define ONE_T 280
    282 #define VALIST 281
    283 #define BOOL 282
    284 #define COMPLEX 283
    285 #define IMAGINARY 284
    286 #define TYPEOF 285
    287 #define LABEL 286
    288 #define ENUM 287
    289 #define STRUCT 288
    290 #define UNION 289
    291 #define OTYPE 290
    292 #define FTYPE 291
    293 #define DTYPE 292
    294 #define TTYPE 293
    295 #define TRAIT 294
    296 #define SIZEOF 295
    297 #define OFFSETOF 296
    298 #define ATTRIBUTE 297
    299 #define EXTENSION 298
    300 #define IF 299
    301 #define ELSE 300
    302 #define SWITCH 301
    303 #define CASE 302
    304 #define DEFAULT 303
    305 #define DO 304
    306 #define WHILE 305
    307 #define FOR 306
    308 #define BREAK 307
    309 #define CONTINUE 308
    310 #define GOTO 309
    311 #define RETURN 310
    312 #define CHOOSE 311
    313 #define DISABLE 312
    314 #define ENABLE 313
    315 #define FALLTHRU 314
    316 #define TRY 315
    317 #define CATCH 316
    318 #define CATCHRESUME 317
    319 #define FINALLY 318
    320 #define THROW 319
    321 #define THROWRESUME 320
    322 #define AT 321
    323 #define ASM 322
    324 #define ALIGNAS 323
    325 #define ALIGNOF 324
    326 #define ATOMIC 325
    327 #define GENERIC 326
    328 #define NORETURN 327
    329 #define STATICASSERT 328
    330 #define THREADLOCAL 329
    331 #define IDENTIFIER 330
    332 #define QUOTED_IDENTIFIER 331
    333 #define TYPEDEFname 332
    334 #define TYPEGENname 333
    335 #define ATTR_IDENTIFIER 334
    336 #define ATTR_TYPEDEFname 335
    337 #define ATTR_TYPEGENname 336
    338 #define INTEGERconstant 337
    339 #define CHARACTERconstant 338
    340 #define STRINGliteral 339
    341 #define REALDECIMALconstant 340
    342 #define REALFRACTIONconstant 341
    343 #define FLOATINGconstant 342
    344 #define ZERO 343
    345 #define ONE 344
    346 #define ARROW 345
    347 #define ICR 346
    348 #define DECR 347
    349 #define LS 348
    350 #define RS 349
    351 #define LE 350
    352 #define GE 351
    353 #define EQ 352
    354 #define NE 353
    355 #define ANDAND 354
    356 #define OROR 355
    357 #define ELLIPSIS 356
    358 #define MULTassign 357
    359 #define DIVassign 358
    360 #define MODassign 359
    361 #define PLUSassign 360
    362 #define MINUSassign 361
    363 #define LSassign 362
    364 #define RSassign 363
    365 #define ANDassign 364
    366 #define ERassign 365
    367 #define ORassign 366
    368 #define ATassign 367
    369 #define THEN 368
     261#define EXTERN 259
     262#define STATIC 260
     263#define AUTO 261
     264#define REGISTER 262
     265#define THREADLOCAL 263
     266#define INLINE 264
     267#define FORTRAN 265
     268#define NORETURN 266
     269#define CONST 267
     270#define VOLATILE 268
     271#define RESTRICT 269
     272#define ATOMIC 270
     273#define FORALL 271
     274#define LVALUE 272
     275#define MUTEX 273
     276#define VOID 274
     277#define CHAR 275
     278#define SHORT 276
     279#define INT 277
     280#define LONG 278
     281#define FLOAT 279
     282#define DOUBLE 280
     283#define SIGNED 281
     284#define UNSIGNED 282
     285#define ZERO_T 283
     286#define ONE_T 284
     287#define VALIST 285
     288#define BOOL 286
     289#define COMPLEX 287
     290#define IMAGINARY 288
     291#define TYPEOF 289
     292#define LABEL 290
     293#define ENUM 291
     294#define STRUCT 292
     295#define UNION 293
     296#define OTYPE 294
     297#define FTYPE 295
     298#define DTYPE 296
     299#define TTYPE 297
     300#define TRAIT 298
     301#define SIZEOF 299
     302#define OFFSETOF 300
     303#define ATTRIBUTE 301
     304#define EXTENSION 302
     305#define IF 303
     306#define ELSE 304
     307#define SWITCH 305
     308#define CASE 306
     309#define DEFAULT 307
     310#define DO 308
     311#define WHILE 309
     312#define FOR 310
     313#define BREAK 311
     314#define CONTINUE 312
     315#define GOTO 313
     316#define RETURN 314
     317#define CHOOSE 315
     318#define DISABLE 316
     319#define ENABLE 317
     320#define FALLTHRU 318
     321#define TRY 319
     322#define CATCH 320
     323#define CATCHRESUME 321
     324#define FINALLY 322
     325#define THROW 323
     326#define THROWRESUME 324
     327#define AT 325
     328#define ASM 326
     329#define ALIGNAS 327
     330#define ALIGNOF 328
     331#define GENERIC 329
     332#define STATICASSERT 330
     333#define IDENTIFIER 331
     334#define QUOTED_IDENTIFIER 332
     335#define TYPEDEFname 333
     336#define TYPEGENname 334
     337#define ATTR_IDENTIFIER 335
     338#define ATTR_TYPEDEFname 336
     339#define ATTR_TYPEGENname 337
     340#define INTEGERconstant 338
     341#define CHARACTERconstant 339
     342#define STRINGliteral 340
     343#define REALDECIMALconstant 341
     344#define REALFRACTIONconstant 342
     345#define FLOATINGconstant 343
     346#define ZERO 344
     347#define ONE 345
     348#define ARROW 346
     349#define ICR 347
     350#define DECR 348
     351#define LS 349
     352#define RS 350
     353#define LE 351
     354#define GE 352
     355#define EQ 353
     356#define NE 354
     357#define ANDAND 355
     358#define OROR 356
     359#define ELLIPSIS 357
     360#define MULTassign 358
     361#define DIVassign 359
     362#define MODassign 360
     363#define PLUSassign 361
     364#define MINUSassign 362
     365#define LSassign 363
     366#define RSassign 364
     367#define ANDassign 365
     368#define ERassign 366
     369#define ORassign 367
     370#define ATassign 368
     371#define THEN 369
    370372
    371373
     
    377379
    378380/* Line 293 of yacc.c  */
    379 #line 139 "parser.yy"
     381#line 141 "parser.yy"
    380382
    381383        Token tok;
     
    397399
    398400/* Line 293 of yacc.c  */
    399 #line 400 "Parser/parser.cc"
     401#line 402 "Parser/parser.cc"
    400402} YYSTYPE;
    401403# define YYSTYPE_IS_TRIVIAL 1
     
    409411
    410412/* Line 343 of yacc.c  */
    411 #line 412 "Parser/parser.cc"
     413#line 414 "Parser/parser.cc"
    412414
    413415#ifdef short
     
    626628
    627629/* YYFINAL -- State number of the termination state.  */
    628 #define YYFINAL  240
     630#define YYFINAL  241
    629631/* YYLAST -- Last index in YYTABLE.  */
    630 #define YYLAST   11898
     632#define YYLAST   11830
    631633
    632634/* YYNTOKENS -- Number of terminals.  */
    633 #define YYNTOKENS  138
     635#define YYNTOKENS  139
    634636/* YYNNTS -- Number of nonterminals.  */
    635637#define YYNNTS  249
    636638/* YYNRULES -- Number of rules.  */
    637 #define YYNRULES  775
     639#define YYNRULES  776
    638640/* YYNRULES -- Number of states.  */
    639 #define YYNSTATES  1582
     641#define YYNSTATES  1583
    640642
    641643/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
    642644#define YYUNDEFTOK  2
    643 #define YYMAXUTOK   368
     645#define YYMAXUTOK   369
    644646
    645647#define YYTRANSLATE(YYX)                                                \
     
    652654       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    653655       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    654        2,     2,     2,   126,     2,     2,     2,   129,   123,     2,
    655      114,   115,   122,   124,   121,   125,   118,   128,     2,     2,
    656        2,     2,     2,     2,     2,     2,     2,     2,   135,   137,
    657      130,   136,   131,   134,     2,     2,     2,     2,     2,     2,
     656       2,     2,     2,   127,     2,     2,     2,   130,   124,     2,
     657     115,   116,   123,   125,   122,   126,   119,   129,     2,     2,
     658       2,     2,     2,     2,     2,     2,     2,     2,   136,   138,
     659     131,   137,   132,   135,     2,     2,     2,     2,     2,     2,
    658660       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    659661       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    660        2,   116,     2,   117,   132,     2,     2,     2,     2,     2,
     662       2,   117,     2,   118,   133,     2,     2,     2,     2,     2,
    661663       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    662664       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    663        2,     2,     2,   119,   133,   120,   127,     2,     2,     2,
     665       2,     2,     2,   120,   134,   121,   128,     2,     2,     2,
    664666       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    665667       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     
    685687      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
    686688      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
    687      105,   106,   107,   108,   109,   110,   111,   112,   113
     689     105,   106,   107,   108,   109,   110,   111,   112,   113,   114
    688690};
    689691
     
    724726    1076,  1083,  1085,  1087,  1089,  1091,  1093,  1095,  1097,  1099,
    725727    1101,  1103,  1105,  1107,  1109,  1111,  1113,  1115,  1116,  1118,
    726     1120,  1123,  1125,  1127,  1129,  1131,  1133,  1135,  1137,  1138,
    727     1144,  1146,  1149,  1153,  1155,  1158,  1160,  1162,  1164,  1166,
     728    1120,  1123,  1125,  1127,  1129,  1131,  1133,  1135,  1137,  1139,
     729    1140,  1146,  1148,  1151,  1155,  1157,  1160,  1162,  1164,  1166,
    728730    1168,  1170,  1172,  1174,  1176,  1178,  1180,  1182,  1184,  1186,
    729731    1188,  1190,  1192,  1194,  1196,  1198,  1200,  1202,  1204,  1206,
    730     1209,  1212,  1216,  1220,  1222,  1226,  1228,  1231,  1234,  1237,
    731     1242,  1247,  1252,  1257,  1259,  1262,  1265,  1269,  1271,  1274,
    732     1277,  1279,  1282,  1285,  1289,  1291,  1294,  1297,  1299,  1302,
    733     1305,  1309,  1311,  1314,  1317,  1319,  1321,  1323,  1325,  1331,
    734     1332,  1340,  1349,  1351,  1355,  1359,  1361,  1363,  1364,  1367,
    735     1370,  1374,  1378,  1383,  1385,  1388,  1392,  1395,  1397,  1402,
    736     1403,  1405,  1408,  1411,  1413,  1414,  1416,  1419,  1426,  1427,
    737     1436,  1438,  1442,  1445,  1450,  1451,  1454,  1455,  1457,  1459,
    738     1461,  1467,  1473,  1479,  1481,  1487,  1493,  1503,  1505,  1511,
    739     1512,  1514,  1516,  1522,  1524,  1526,  1532,  1538,  1540,  1544,
    740     1548,  1553,  1555,  1557,  1559,  1561,  1564,  1566,  1570,  1574,
    741     1577,  1581,  1583,  1587,  1589,  1591,  1593,  1595,  1597,  1599,
    742     1601,  1603,  1605,  1607,  1609,  1612,  1614,  1616,  1617,  1620,
    743     1623,  1625,  1630,  1631,  1633,  1636,  1640,  1645,  1648,  1651,
    744     1653,  1656,  1659,  1665,  1671,  1679,  1686,  1688,  1691,  1694,
    745     1698,  1700,  1703,  1706,  1711,  1714,  1719,  1720,  1725,  1728,
    746     1730,  1732,  1734,  1736,  1737,  1740,  1746,  1752,  1766,  1768,
    747     1770,  1774,  1778,  1781,  1785,  1789,  1792,  1797,  1799,  1806,
    748     1816,  1817,  1829,  1831,  1835,  1839,  1843,  1845,  1847,  1853,
    749     1856,  1862,  1863,  1865,  1867,  1871,  1872,  1874,  1876,  1878,
    750     1884,  1885,  1892,  1895,  1897,  1900,  1905,  1908,  1912,  1916,
    751     1920,  1925,  1931,  1937,  1943,  1950,  1952,  1954,  1956,  1960,
    752     1961,  1967,  1968,  1970,  1972,  1975,  1982,  1984,  1988,  1989,
    753     1991,  1996,  1998,  2000,  2002,  2004,  2007,  2009,  2012,  2015,
    754     2017,  2021,  2024,  2028,  2033,  2036,  2041,  2046,  2050,  2059,
    755     2063,  2066,  2068,  2071,  2078,  2087,  2091,  2094,  2098,  2102,
    756     2107,  2112,  2116,  2118,  2120,  2122,  2127,  2136,  2140,  2143,
    757     2147,  2151,  2156,  2161,  2165,  2168,  2170,  2173,  2176,  2178,
    758     2182,  2185,  2189,  2194,  2197,  2202,  2207,  2211,  2218,  2227,
    759     2231,  2234,  2236,  2239,  2242,  2245,  2249,  2254,  2257,  2262,
    760     2267,  2271,  2278,  2287,  2291,  2294,  2296,  2299,  2302,  2304,
    761     2306,  2309,  2313,  2318,  2321,  2326,  2333,  2342,  2344,  2347,
    762     2350,  2352,  2355,  2358,  2362,  2367,  2369,  2374,  2379,  2383,
    763     2389,  2398,  2402,  2405,  2409,  2411,  2417,  2423,  2430,  2437,
    764     2439,  2442,  2445,  2447,  2450,  2453,  2457,  2462,  2464,  2469,
    765     2474,  2478,  2484,  2493,  2497,  2499,  2502,  2504,  2507,  2514,
    766     2520,  2527,  2535,  2543,  2545,  2548,  2551,  2553,  2556,  2559,
    767     2563,  2568,  2570,  2575,  2580,  2584,  2593,  2597,  2599,  2601,
    768     2604,  2606,  2608,  2611,  2615,  2618,  2622,  2625,  2629,  2633,
    769     2636,  2641,  2645,  2648,  2652,  2655,  2660,  2664,  2667,  2674,
    770     2681,  2688,  2696,  2698,  2701,  2703,  2705,  2707,  2710,  2714,
    771     2717,  2721,  2724,  2728,  2732,  2737,  2740,  2744,  2749,  2752,
    772     2758,  2765,  2772,  2773,  2775,  2776
     732    1208,  1211,  1214,  1218,  1222,  1224,  1228,  1230,  1233,  1236,
     733    1239,  1244,  1249,  1254,  1259,  1261,  1264,  1267,  1271,  1273,
     734    1276,  1279,  1281,  1284,  1287,  1291,  1293,  1296,  1299,  1301,
     735    1304,  1307,  1311,  1313,  1316,  1319,  1321,  1323,  1325,  1327,
     736    1333,  1334,  1342,  1351,  1353,  1357,  1361,  1363,  1365,  1366,
     737    1369,  1372,  1376,  1380,  1385,  1387,  1390,  1394,  1397,  1399,
     738    1404,  1405,  1407,  1410,  1413,  1415,  1416,  1418,  1421,  1428,
     739    1429,  1438,  1440,  1444,  1447,  1452,  1453,  1456,  1457,  1459,
     740    1461,  1463,  1469,  1475,  1481,  1483,  1489,  1495,  1505,  1507,
     741    1513,  1514,  1516,  1518,  1524,  1526,  1528,  1534,  1540,  1542,
     742    1546,  1550,  1555,  1557,  1559,  1561,  1563,  1566,  1568,  1572,
     743    1576,  1579,  1583,  1585,  1589,  1591,  1593,  1595,  1597,  1599,
     744    1601,  1603,  1605,  1607,  1609,  1611,  1614,  1616,  1618,  1619,
     745    1622,  1625,  1627,  1632,  1633,  1635,  1638,  1642,  1647,  1650,
     746    1653,  1655,  1658,  1661,  1667,  1673,  1681,  1688,  1690,  1693,
     747    1696,  1700,  1702,  1705,  1708,  1713,  1716,  1721,  1722,  1727,
     748    1730,  1732,  1734,  1736,  1738,  1739,  1742,  1748,  1754,  1768,
     749    1770,  1772,  1776,  1780,  1783,  1787,  1791,  1794,  1799,  1801,
     750    1808,  1818,  1819,  1831,  1833,  1837,  1841,  1845,  1847,  1849,
     751    1855,  1858,  1864,  1865,  1867,  1869,  1873,  1874,  1876,  1878,
     752    1880,  1886,  1887,  1894,  1897,  1899,  1902,  1907,  1910,  1914,
     753    1918,  1922,  1927,  1933,  1939,  1945,  1952,  1954,  1956,  1958,
     754    1962,  1963,  1969,  1970,  1972,  1974,  1977,  1984,  1986,  1990,
     755    1991,  1993,  1998,  2000,  2002,  2004,  2006,  2009,  2011,  2014,
     756    2017,  2019,  2023,  2026,  2030,  2035,  2038,  2043,  2048,  2052,
     757    2061,  2065,  2068,  2070,  2073,  2080,  2089,  2093,  2096,  2100,
     758    2104,  2109,  2114,  2118,  2120,  2122,  2124,  2129,  2138,  2142,
     759    2145,  2149,  2153,  2158,  2163,  2167,  2170,  2172,  2175,  2178,
     760    2180,  2184,  2187,  2191,  2196,  2199,  2204,  2209,  2213,  2220,
     761    2229,  2233,  2236,  2238,  2241,  2244,  2247,  2251,  2256,  2259,
     762    2264,  2269,  2273,  2280,  2289,  2293,  2296,  2298,  2301,  2304,
     763    2306,  2308,  2311,  2315,  2320,  2323,  2328,  2335,  2344,  2346,
     764    2349,  2352,  2354,  2357,  2360,  2364,  2369,  2371,  2376,  2381,
     765    2385,  2391,  2400,  2404,  2407,  2411,  2413,  2419,  2425,  2432,
     766    2439,  2441,  2444,  2447,  2449,  2452,  2455,  2459,  2464,  2466,
     767    2471,  2476,  2480,  2486,  2495,  2499,  2501,  2504,  2506,  2509,
     768    2516,  2522,  2529,  2537,  2545,  2547,  2550,  2553,  2555,  2558,
     769    2561,  2565,  2570,  2572,  2577,  2582,  2586,  2595,  2599,  2601,
     770    2603,  2606,  2608,  2610,  2613,  2617,  2620,  2624,  2627,  2631,
     771    2635,  2638,  2643,  2647,  2650,  2654,  2657,  2662,  2666,  2669,
     772    2676,  2683,  2690,  2698,  2700,  2703,  2705,  2707,  2709,  2712,
     773    2716,  2719,  2723,  2726,  2730,  2734,  2739,  2742,  2746,  2751,
     774    2754,  2760,  2767,  2774,  2775,  2777,  2778
    773775};
    774776
     
    776778static const yytype_int16 yyrhs[] =
    777779{
    778      315,     0,    -1,    -1,    -1,    82,    -1,    85,    -1,    86,
    779       -1,    87,    -1,    83,    -1,    75,    -1,    79,    -1,   145,
    780       -1,    75,    -1,    79,    -1,    75,    -1,   145,    -1,    88,
    781       -1,    89,    -1,   147,    -1,    84,    -1,   147,    84,    -1,
    782       75,    -1,   145,    -1,   175,    -1,   114,   177,   115,    -1,
    783      114,   181,   115,    -1,   148,    -1,   149,   116,   139,   172,
    784      140,   117,    -1,   149,   114,   150,   115,    -1,   149,   118,
    785      144,    -1,   149,   118,   116,   139,   152,   140,   117,    -1,
    786      149,    86,    -1,   149,    90,   144,    -1,   149,    90,   116,
    787      139,   152,   140,   117,    -1,   149,    91,    -1,   149,    92,
    788       -1,   114,   288,   115,   119,   292,   385,   120,    -1,   149,
    789      119,   150,   120,    -1,   151,    -1,   150,   121,   151,    -1,
    790       -1,   172,    -1,   153,    -1,   152,   121,   153,    -1,   154,
    791       -1,    85,   153,    -1,    85,   116,   139,   152,   140,   117,
    792       -1,   154,   118,   153,    -1,   154,   118,   116,   139,   152,
    793      140,   117,    -1,   154,    90,   153,    -1,   154,    90,   116,
    794      139,   152,   140,   117,    -1,    82,   155,    -1,    87,   155,
    795       -1,   144,   155,    -1,    -1,   155,    86,    -1,   149,    -1,
    796      141,    -1,   146,    -1,    43,   159,    -1,   157,   159,    -1,
    797      158,   159,    -1,    91,   156,    -1,    92,   156,    -1,    40,
    798      156,    -1,    40,   114,   288,   115,    -1,    69,   156,    -1,
    799       69,   114,   288,   115,    -1,    41,   114,   288,   121,   144,
    800      115,    -1,    79,    -1,    79,   114,   151,   115,    -1,    79,
    801      114,   289,   115,    -1,   122,    -1,   123,    -1,   124,    -1,
    802      125,    -1,   126,    -1,   127,    -1,   156,    -1,   114,   288,
    803      115,   159,    -1,   159,    -1,   160,   122,   159,    -1,   160,
    804      128,   159,    -1,   160,   129,   159,    -1,   160,    -1,   161,
    805      124,   160,    -1,   161,   125,   160,    -1,   161,    -1,   162,
    806       93,   161,    -1,   162,    94,   161,    -1,   162,    -1,   163,
    807      130,   162,    -1,   163,   131,   162,    -1,   163,    95,   162,
    808       -1,   163,    96,   162,    -1,   163,    -1,   164,    97,   163,
    809       -1,   164,    98,   163,    -1,   164,    -1,   165,   123,   164,
    810       -1,   165,    -1,   166,   132,   165,    -1,   166,    -1,   167,
    811      133,   166,    -1,   167,    -1,   168,    99,   167,    -1,   168,
    812       -1,   169,   100,   168,    -1,   169,    -1,   169,   134,   177,
    813      135,   170,    -1,   169,   134,   135,   170,    -1,   170,    -1,
    814      170,    -1,   156,   174,   172,    -1,    -1,   172,    -1,   136,
    815       -1,   112,    -1,   102,    -1,   103,    -1,   104,    -1,   105,
    816       -1,   106,    -1,   107,    -1,   108,    -1,   109,    -1,   110,
    817       -1,   111,    -1,   116,   139,   121,   176,   140,   117,    -1,
    818      116,   139,   172,   121,   176,   140,   117,    -1,   173,    -1,
    819      176,   121,   173,    -1,   172,    -1,   177,   121,   172,    -1,
    820       -1,   177,    -1,   180,    -1,   181,    -1,   185,    -1,   186,
    821       -1,   198,    -1,   200,    -1,   201,    -1,   206,    -1,   132,
    822      149,   119,   150,   120,   137,    -1,   285,   135,   325,   179,
    823       -1,   119,   120,    -1,   119,   139,   139,   217,   182,   140,
    824      120,    -1,   183,    -1,   182,   139,   183,    -1,   220,    -1,
    825       43,   220,    -1,   321,    -1,    43,   321,    -1,   179,   140,
    826       -1,   179,    -1,   184,   179,    -1,   178,   137,    -1,    44,
    827      114,   177,   115,   179,    -1,    44,   114,   177,   115,   179,
    828       45,   179,    -1,    46,   114,   177,   115,   191,    -1,    46,
    829      114,   177,   115,   119,   139,   213,   192,   120,    -1,    56,
    830      114,   177,   115,   191,    -1,    56,   114,   177,   115,   119,
    831      139,   213,   194,   120,    -1,   171,    -1,   171,   101,   171,
    832       -1,   323,    -1,   187,    -1,   188,   121,   187,    -1,    47,
    833      188,   135,    -1,    48,   135,    -1,   189,    -1,   190,   189,
    834       -1,   190,   179,    -1,    -1,   193,    -1,   190,   184,    -1,
    835      193,   190,   184,    -1,    -1,   195,    -1,   190,   197,    -1,
    836      190,   184,   196,    -1,   195,   190,   197,    -1,   195,   190,
    837      184,   196,    -1,    -1,   197,    -1,    59,    -1,    59,   137,
    838       -1,    50,   114,   177,   115,   179,    -1,    49,   179,    50,
    839      114,   177,   115,   137,    -1,    51,   114,   139,   199,   115,
    840      179,    -1,   178,   140,   137,   178,   137,   178,    -1,   220,
    841      178,   137,   178,    -1,    54,   285,   137,    -1,    54,   122,
    842      177,   137,    -1,    53,   137,    -1,    53,   285,   137,    -1,
    843       52,   137,    -1,    52,   285,   137,    -1,    55,   178,   137,
    844       -1,    64,   173,   137,    -1,    65,   173,   137,    -1,    65,
    845      173,    66,   172,   137,    -1,    60,   181,   202,    -1,    60,
    846      181,   204,    -1,    60,   181,   202,   204,    -1,   203,    -1,
    847       61,   114,   101,   115,   181,    -1,   203,    61,   114,   101,
    848      115,   181,    -1,    62,   114,   101,   115,   181,    -1,   203,
    849       62,   114,   101,   115,   181,    -1,    61,   114,   139,   139,
    850      205,   140,   115,   181,   140,    -1,   203,    61,   114,   139,
    851      139,   205,   140,   115,   181,   140,    -1,    62,   114,   139,
    852      139,   205,   140,   115,   181,   140,    -1,   203,    62,   114,
    853      139,   139,   205,   140,   115,   181,   140,    -1,    63,   181,
    854       -1,   235,    -1,   235,   322,    -1,   235,   370,    -1,   379,
    855      144,    -1,   379,    -1,    67,   207,   114,   146,   115,   137,
    856       -1,    67,   207,   114,   146,   135,   208,   115,   137,    -1,
    857       67,   207,   114,   146,   135,   208,   135,   208,   115,   137,
    858       -1,    67,   207,   114,   146,   135,   208,   135,   208,   135,
    859      211,   115,   137,    -1,    67,   207,    54,   114,   146,   135,
    860      135,   208,   135,   211,   135,   212,   115,   137,    -1,    -1,
    861       11,    -1,    -1,   209,    -1,   210,    -1,   209,   121,   210,
    862       -1,   146,   114,   171,   115,    -1,   116,   171,   117,   146,
    863      114,   171,   115,    -1,    -1,   146,    -1,   211,   121,   146,
    864       -1,   144,    -1,   212,   121,   144,    -1,   140,    -1,   214,
    865       -1,   220,    -1,   214,   139,   220,    -1,   140,    -1,   216,
    866       -1,   230,    -1,   216,   139,   230,    -1,    -1,   218,    -1,
    867       31,   219,   137,    -1,   218,    31,   219,   137,    -1,   287,
    868       -1,   219,   121,   287,    -1,   221,    -1,   230,    -1,   222,
    869      140,   137,    -1,   227,   140,   137,    -1,   224,   140,   137,
    870       -1,   306,   140,   137,    -1,   309,   140,   137,    -1,   223,
    871      290,    -1,   241,   223,   290,    -1,   222,   140,   121,   139,
    872      285,   290,    -1,   380,   285,   324,    -1,   383,   285,   324,
    873       -1,   237,   383,   285,   324,    -1,   225,    -1,   237,   225,
    874       -1,   241,   225,    -1,   241,   237,   225,    -1,   224,   140,
    875      121,   139,   285,    -1,   383,   285,   114,   139,   273,   140,
    876      115,    -1,   226,   285,   114,   139,   273,   140,   115,    -1,
    877      116,   139,   275,   140,   117,    -1,   116,   139,   275,   140,
    878      121,   139,   276,   140,   117,    -1,     3,   223,    -1,     3,
    879      225,    -1,   227,   140,   121,   139,   144,    -1,     3,   234,
    880      322,    -1,   228,   140,   121,   139,   322,    -1,   237,     3,
    881      234,   322,    -1,   234,     3,   322,    -1,   234,     3,   237,
    882      322,    -1,     3,   144,   136,   172,    -1,   229,   140,   121,
    883      139,   144,   136,   172,    -1,   232,   231,   140,   137,    -1,
    884      228,   140,   137,    -1,   229,   140,   137,    -1,   249,   140,
    885      137,    -1,   322,   324,   290,    -1,   231,   121,   325,   322,
    886      324,   290,    -1,   245,    -1,   249,    -1,   253,    -1,   296,
    887       -1,   245,    -1,   251,    -1,   253,    -1,   296,    -1,   246,
    888       -1,   250,    -1,   254,    -1,   297,    -1,   246,    -1,   252,
    889       -1,   254,    -1,   297,    -1,    -1,   237,    -1,   238,    -1,
    890      237,   238,    -1,   239,    -1,   327,    -1,    10,    -1,    12,
    891       -1,    11,    -1,    14,    -1,    70,    -1,    -1,    13,   114,
    892      240,   299,   115,    -1,   242,    -1,   237,   242,    -1,   241,
    893      237,   242,    -1,   243,    -1,   242,   243,    -1,     5,    -1,
    894        7,    -1,     4,    -1,     6,    -1,    74,    -1,     8,    -1,
    895        9,    -1,    72,    -1,    16,    -1,    21,    -1,    20,    -1,
    896       18,    -1,    19,    -1,    17,    -1,    22,    -1,    23,    -1,
    897       15,    -1,    27,    -1,    28,    -1,    29,    -1,    26,    -1,
    898       24,    -1,    25,    -1,   246,    -1,   241,   246,    -1,   245,
    899      243,    -1,   245,   243,   237,    -1,   245,   243,   246,    -1,
    900      247,    -1,   236,   248,   236,    -1,   244,    -1,   237,   244,
    901       -1,   247,   238,    -1,   247,   244,    -1,    30,   114,   289,
    902      115,    -1,    30,   114,   177,   115,    -1,    81,   114,   289,
    903      115,    -1,    81,   114,   177,   115,    -1,   250,    -1,   241,
    904      250,    -1,   249,   243,    -1,   249,   243,   237,    -1,   255,
    905       -1,   237,   255,    -1,   250,   238,    -1,   252,    -1,   241,
    906      252,    -1,   251,   243,    -1,   251,   243,   237,    -1,   256,
    907       -1,   237,   256,    -1,   252,   238,    -1,   254,    -1,   241,
    908      254,    -1,   253,   243,    -1,   253,   243,   237,    -1,    77,
    909       -1,   237,    77,    -1,   254,   238,    -1,   257,    -1,   268,
    910       -1,   259,    -1,   270,    -1,   260,   325,   119,   261,   120,
    911       -1,    -1,   260,   325,   287,   258,   119,   261,   120,    -1,
    912      260,   325,   114,   305,   115,   119,   261,   120,    -1,   259,
    913       -1,   260,   325,   287,    -1,   260,   325,   298,    -1,    33,
    914       -1,    34,    -1,    -1,   261,   262,    -1,   263,   137,    -1,
    915       43,   263,   137,    -1,   234,   264,   137,    -1,    43,   234,
    916      264,   137,    -1,   379,    -1,   379,   287,    -1,   263,   121,
    917      287,    -1,   263,   121,    -1,   265,    -1,   264,   121,   325,
    918      265,    -1,    -1,   267,    -1,   331,   266,    -1,   344,   266,
    919       -1,   370,    -1,    -1,   267,    -1,   135,   171,    -1,    32,
    920      325,   119,   271,   385,   120,    -1,    -1,    32,   325,   287,
    921      269,   119,   271,   385,   120,    -1,   270,    -1,    32,   325,
    922      287,    -1,   287,   272,    -1,   271,   121,   287,   272,    -1,
    923       -1,   136,   171,    -1,    -1,   274,    -1,   276,    -1,   275,
    924       -1,   275,   140,   121,   139,   276,    -1,   276,   140,   121,
    925      139,   101,    -1,   275,   140,   121,   139,   101,    -1,   280,
    926       -1,   276,   140,   121,   139,   280,    -1,   275,   140,   121,
    927      139,   280,    -1,   275,   140,   121,   139,   276,   140,   121,
    928      139,   280,    -1,   281,    -1,   276,   140,   121,   139,   281,
    929       -1,    -1,   278,    -1,   279,    -1,   279,   140,   121,   139,
    930      101,    -1,   283,    -1,   282,    -1,   279,   140,   121,   139,
    931      283,    -1,   279,   140,   121,   139,   282,    -1,   282,    -1,
    932      375,   285,   386,    -1,   383,   285,   386,    -1,   237,   383,
    933      285,   386,    -1,   225,    -1,   283,    -1,   375,    -1,   383,
    934       -1,   237,   383,    -1,   384,    -1,   233,   349,   386,    -1,
    935      233,   353,   386,    -1,   233,   386,    -1,   233,   364,   386,
    936       -1,   144,    -1,   284,   121,   144,    -1,   142,    -1,    77,
    937       -1,    78,    -1,   143,    -1,    77,    -1,    78,    -1,   144,
    938       -1,    77,    -1,    78,    -1,   379,    -1,   234,    -1,   234,
    939      358,    -1,   288,    -1,   384,    -1,    -1,   136,   291,    -1,
    940      112,   291,    -1,   172,    -1,   119,   292,   385,   120,    -1,
    941       -1,   291,    -1,   293,   291,    -1,   292,   121,   291,    -1,
    942      292,   121,   293,   291,    -1,   294,   135,    -1,   287,   135,
    943       -1,   295,    -1,   294,   295,    -1,   118,   287,    -1,   116,
    944      139,   172,   140,   117,    -1,   116,   139,   323,   140,   117,
    945       -1,   116,   139,   171,   101,   171,   140,   117,    -1,   118,
    946      116,   139,   152,   140,   117,    -1,   297,    -1,   241,   297,
    947       -1,   296,   243,    -1,   296,   243,   237,    -1,   298,    -1,
    948      237,   298,    -1,   297,   238,    -1,    78,   114,   305,   115,
    949       -1,   300,   386,    -1,   299,   121,   300,   386,    -1,    -1,
    950      302,   287,   301,   303,    -1,   234,   349,    -1,    35,    -1,
    951       37,    -1,    36,    -1,    38,    -1,    -1,   303,   304,    -1,
    952      133,   287,   114,   305,   115,    -1,   133,   119,   139,   311,
    953      120,    -1,   133,   114,   139,   299,   140,   115,   119,   139,
    954      311,   120,   114,   305,   115,    -1,   289,    -1,   172,    -1,
    955      305,   121,   289,    -1,   305,   121,   172,    -1,    35,   307,
    956       -1,   242,    35,   307,    -1,   306,   121,   307,    -1,   308,
    957      303,    -1,   308,   303,   136,   289,    -1,   287,    -1,   286,
    958      114,   139,   299,   140,   115,    -1,    39,   287,   114,   139,
    959      299,   140,   115,   119,   120,    -1,    -1,    39,   287,   114,
    960      139,   299,   140,   115,   119,   310,   311,   120,    -1,   312,
    961       -1,   311,   139,   312,    -1,   313,   140,   137,    -1,   314,
    962      140,   137,    -1,   223,    -1,   225,    -1,   313,   140,   121,
    963      139,   285,    -1,   234,   322,    -1,   314,   140,   121,   139,
    964      322,    -1,    -1,   316,    -1,   318,    -1,   316,   139,   318,
    965       -1,    -1,   316,    -1,   220,    -1,   320,    -1,    67,   114,
    966      146,   115,   137,    -1,    -1,     5,    84,   319,   119,   317,
    967      120,    -1,    43,   318,    -1,   321,    -1,   336,   181,    -1,
    968      340,   139,   215,   181,    -1,   224,   181,    -1,   232,   336,
    969      181,    -1,   237,   336,   181,    -1,   241,   3