Changeset a7c90d4
- Timestamp:
- Mar 7, 2017, 8:33:43 AM (7 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- 64cb860, c3396e0
- Parents:
- 7fe2498
- Location:
- src
- Files:
-
- 34 edited
Legend:
- Unmodified
- Added
- Removed
-
src/CodeGen/CodeGenerator.cc
r7fe2498 ra7c90d4 10 10 // Created On : Mon May 18 07:44:20 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 21:18:47201713 // Update Count : 4 6512 // Last Modified On : Sun Mar 5 17:13:33 2017 13 // Update Count : 475 14 14 // 15 15 … … 895 895 896 896 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 919 900 } // CodeGenerator::handleStorageClass 920 901 -
src/CodeGen/FixNames.cc
r7fe2498 ra7c90d4 10 10 // Created On : Mon May 18 07:44:20 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 21:52:17201713 // Update Count : 612 // Last Modified On : Mon Mar 6 23:32:08 2017 13 // Update Count : 15 14 14 // 15 15 … … 39 39 std::string mangle_main() { 40 40 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 }; 48 44 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 ) 50 46 ); 51 47 … … 56 52 std::string mangle_main_args() { 57 53 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 }; 65 57 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 ) 67 59 ); 68 60 69 61 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 ) 71 63 ); 72 64 73 65 mainDecl->get_functionType()->get_parameters().push_back( 74 new ObjectDecl( "", DeclarationNode:: NoStorageClass, LinkageSpec::Cforall, 0,66 new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, 0, 75 67 new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ), 76 68 nullptr ) -
src/GenPoly/Box.cc
r7fe2498 ra7c90d4 10 10 // Created On : Mon May 18 07:44:20 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 21:57:15201713 // Update Count : 3 1012 // Last Modified On : Mon Mar 6 23:45:59 2017 13 // Update Count : 330 14 14 // 15 15 … … 289 289 TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param ); 290 290 std::string paramName = mangleType( ¶mType ); 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 ) ); 293 293 } 294 294 } … … 298 298 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units 299 299 // 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 ) ); 303 304 layoutDecl->fixUniqueId(); 304 305 return layoutDecl; … … 367 368 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType ); 368 369 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 ); 370 371 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 ); 372 373 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 ); 374 375 layoutFnType->get_parameters().push_back( offsetParam ); 375 376 addOtypeParams( layoutFnType, otypeParams ); … … 428 429 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType ); 429 430 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 ); 431 432 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 ); 433 434 layoutFnType->get_parameters().push_back( alignParam ); 434 435 addOtypeParams( layoutFnType, otypeParams ); … … 536 537 if ( adapters.find( mangleName ) == adapters.end() ) { 537 538 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 ) ) ); 539 540 } // if 540 541 } // for … … 655 656 656 657 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 ); 658 659 stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); 659 660 return newObj; … … 764 765 Type * newType = param->clone(); 765 766 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 ); 767 768 newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right??? 768 769 stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); … … 830 831 makeRetParm( adapter ); 831 832 } // 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 ) ); 833 834 return adapter; 834 835 } … … 911 912 adapterBody->get_kids().push_back( bodyStmt ); 912 913 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 ); 914 915 } 915 916 … … 1272 1273 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) { 1273 1274 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 ) ); 1275 1276 adaptersDone.insert( adaptersDone.begin(), mangleName ); 1276 1277 } … … 1378 1379 std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin(); 1379 1380 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, 1382 1383 new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 ); 1383 1384 for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) { … … 1633 1634 1634 1635 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 ); 1636 1637 stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); 1637 1638 return newObj; … … 1817 1818 memberDecl = origMember->clone(); 1818 1819 } 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 ); 1820 1821 } 1821 1822 inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) ); -
src/GenPoly/Specialize.cc
r7fe2498 ra7c90d4 10 10 // Created On : Mon May 18 07:44:20 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 21:54:45201713 // Update Count : 2812 // Last Modified On : Mon Mar 6 23:13:00 2017 13 // Update Count : 30 14 14 // 15 15 … … 155 155 } // if 156 156 // 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 ) ); 158 158 thunkFunc->fixUniqueId(); 159 159 -
src/InitTweak/FixGlobalInit.cc
r7fe2498 ra7c90d4 10 10 // Created On : Mon May 04 15:14:56 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 21:55:33201713 // Update Count : 912 // Last Modified On : Mon Mar 6 23:14:19 2017 13 // Update Count : 14 14 14 // 15 15 … … 87 87 dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) ); 88 88 } 89 initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::St atic, 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 ) ); 90 90 initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) ); 91 destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::St atic, 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 ) ); 92 92 destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) ); 93 93 } -
src/InitTweak/FixInit.cc
r7fe2498 ra7c90d4 10 10 // Created On : Wed Jan 13 16:29:30 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 21:56:11201713 // Update Count : 3912 // Last Modified On : Tue Mar 7 07:51:40 2017 13 // Update Count : 59 14 14 // 15 15 … … 437 437 result = result->clone(); 438 438 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 ); 440 440 tmp->get_type()->set_isConst( false ); 441 441 … … 483 483 result = result->clone(); 484 484 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 ); 486 486 ret->get_type()->set_isConst( false ); 487 487 impCpCtorExpr->get_returnDecls().push_back( ret ); … … 506 506 result = result->clone(); 507 507 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 ); 509 509 ret->get_type()->set_isConst( false ); 510 510 stmtExpr->get_returnDecls().push_front( ret ); … … 538 538 } else { 539 539 // 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 ) ); 541 541 unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) ); 542 542 } … … 678 678 assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() ); 679 679 if ( Statement * ctor = ctorInit->get_ctor() ) { 680 if ( objDecl->get_storageClass () == DeclarationNode::Static) {680 if ( objDecl->get_storageClasses()[ DeclarationNode::Static ] ) { 681 681 // originally wanted to take advantage of gcc nested functions, but 682 682 // we get memory errors with this approach. To remedy this, the static … … 704 704 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool ); 705 705 SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators ); 706 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::St atic, LinkageSpec::Cforall, 0, boolType, boolInitExpr );706 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", DeclarationNode::StorageClasses( DeclarationNode::StaticClass ), LinkageSpec::Cforall, 0, boolType, boolInitExpr ); 707 707 isUninitializedVar->fixUniqueId(); 708 708 … … 731 731 732 732 // void __objName_dtor_atexitN(...) {...} 733 FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::St atic, 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 ) ); 734 734 dtorCaller->fixUniqueId(); 735 735 dtorCaller->get_statements()->push_back( dtorStmt ); … … 764 764 // create a new object which is never used 765 765 static UniqueName dummyNamer( "_dummy" ); 766 ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::St atic, 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") } ); 767 767 return dummy; 768 768 } … … 821 821 void InsertDtors::visit( ObjectDecl * objDecl ) { 822 822 // 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 ] ) { 824 824 if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) { 825 825 // a decision should have been made by the resolver, so ctor and init are not both non-NULL … … 1118 1118 1119 1119 // 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 ); 1121 1121 addDeclaration( tmp ); 1122 1122 -
src/InitTweak/GenInit.cc
r7fe2498 ra7c90d4 10 10 // Created On : Mon May 18 07:44:20 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : T hu Feb 16 14:57:53201713 // Update Count : 1 6712 // Last Modified On : Tue Mar 7 07:51:38 2017 13 // Update Count : 179 14 14 // 15 15 … … 120 120 void hoist( Type * type ); 121 121 122 DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;122 DeclarationNode::StorageClasses storageClasses; 123 123 bool inFunction = false; 124 124 }; … … 174 174 175 175 DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) { 176 storage class = objectDecl->get_storageClass();176 storageClasses = objectDecl->get_storageClasses(); 177 177 DeclarationWithType * temp = Parent::mutate( objectDecl ); 178 178 hoist( objectDecl->get_type() ); 179 storageclass = DeclarationNode::NoStorageClass;180 179 return temp; 181 180 } … … 185 184 static UniqueName dimensionName( "_array_dim" ); 186 185 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. 189 187 if ( ! inFunction ) return; 190 if ( storage class == DeclarationNode::Static) return;188 if ( storageClasses[ DeclarationNode::StaticClass] ) return; 191 189 192 190 if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) { 193 191 if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist? 194 192 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. 197 194 if ( isConstExpr( arrayType->get_dimension() ) ) return; 198 195 199 ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storage class, 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() ) ); 200 197 arrayDimension->get_type()->set_isConst( true ); 201 198 -
src/InitTweak/InitTweak.cc
r7fe2498 ra7c90d4 260 260 (objDecl->get_init() == NULL || 261 261 ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) 262 && objDecl->get_storageClass() != DeclarationNode::Extern;262 && ! objDecl->get_storageClasses()[ DeclarationNode::Extern ]; 263 263 } 264 264 -
src/Parser/DeclarationNode.cc
r7fe2498 ra7c90d4 10 10 // Created On : Sat May 16 12:34:05 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 21:38:34201713 // Update Count : 86212 // Last Modified On : Tue Mar 7 08:02:09 2017 13 // Update Count : 936 14 14 // 15 15 … … 19 19 #include <algorithm> 20 20 #include <cassert> 21 #include <strings.h> // ffs 21 22 22 23 #include "TypeData.h" … … 32 33 33 34 // 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" };35 const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "NoStorageClassNames" }; 35 36 const char * DeclarationNode::funcSpecifierNames[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" }; 36 const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", " _Atomic", "NoTypeQualifierNames" };37 const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic", "NoTypeQualifierNames" }; 37 38 const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" }; 38 39 const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" }; … … 49 50 DeclarationNode::DeclarationNode() : 50 51 type( nullptr ), 51 storageClass( NoStorageClass ),52 52 bitfieldWidth( nullptr ), 53 53 hasEllipsis( false ), … … 89 89 90 90 newnode->type = maybeClone( type ); 91 newnode->storageClass = storageClass;91 newnode->storageClasses = storageClasses; 92 92 newnode->bitfieldWidth = maybeClone( bitfieldWidth ); 93 newnode->funcSpec = funcSpec;93 newnode->funcSpecs = funcSpecs; 94 94 newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) ); 95 95 newnode->hasEllipsis = hasEllipsis; … … 116 116 } 117 117 118 void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpec funcSpec ) { 118 void 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 128 void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) { 119 129 if ( funcSpec.any() ) { // function specifiers? 120 130 for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) { … … 138 148 } // if 139 149 140 if ( storageClass != NoStorageClass ) os << DeclarationNode::storageClassNames[storageClass] << ' ';141 print_FuncSpec( os, funcSpec );150 print_StorageClass( os, storageClasses ); 151 print_FuncSpec( os, funcSpecs ); 142 152 143 153 if ( type ) { … … 194 204 DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { 195 205 DeclarationNode * newnode = new DeclarationNode; 196 newnode->storageClass = sc;206 newnode->storageClasses[ sc ] = true; 197 207 return newnode; 198 208 } // DeclarationNode::newStorageClass … … 200 210 DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) { 201 211 DeclarationNode * newnode = new DeclarationNode; 202 newnode->funcSpec [ fs ] = true;212 newnode->funcSpecs[ fs ] = true; 203 213 return newnode; 204 214 } // DeclarationNode::newFuncSpecifier … … 443 453 444 454 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) { 445 const TypeData::TypeQualifiers &qsrc = src->typeQualifiers, &qdst = dst->typeQualifiers; // optimization446 447 if ( (qsrc & qdst).any() ) { 455 const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization 456 457 if ( (qsrc & qdst).any() ) { // common qualifier ? 448 458 for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers 449 459 if ( qsrc[i] && qdst[i] ) { … … 451 461 } // if 452 462 } // for 453 } // if463 } // for 454 464 } // DeclarationNode::checkQualifiers 455 465 456 void DeclarationNode::checkStorageClasses( DeclarationNode * q ) { 457 const FuncSpec &src = funcSpec, &dst = q->funcSpec; // optimization 458 if ( (src & dst).any() ) { // common specifier ? 466 void DeclarationNode::checkSpecifiers( DeclarationNode * src ) { 467 if ( (funcSpecs & src->funcSpecs).any() ) { // common specifier ? 459 468 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] ) { 461 470 appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] ); 462 471 } // if … … 464 473 } // if 465 474 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 493 DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) { 494 funcSpecs = funcSpecs | q->funcSpecs; 495 storageClasses = storageClasses | q->storageClasses; 486 496 487 497 for ( Attribute *attr: reverseIterate( q->attributes ) ) { … … 489 499 } // for 490 500 return this; 491 } // DeclarationNode::copyS torageClasses501 } // DeclarationNode::copySpecifiers 492 502 493 503 static void addQualifiersToType( TypeData *&src, TypeData * dst ) { … … 513 523 if ( ! q ) { delete q; return this; } 514 524 515 checkS torageClasses( q );516 copyS torageClasses( q );525 checkSpecifiers( q ); 526 copySpecifiers( q ); 517 527 518 528 if ( ! q->type ) { … … 543 553 } // if 544 554 545 checkQualifiers( q->type,type );555 checkQualifiers( type, q->type ); 546 556 addQualifiersToType( q->type, type ); 547 557 … … 624 634 DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) { 625 635 if ( o ) { 626 checkS torageClasses( o );627 copyS torageClasses( o );636 checkSpecifiers( o ); 637 copySpecifiers( o ); 628 638 if ( o->type ) { 629 639 if ( ! type ) { … … 879 889 DeclarationNode * newnode = new DeclarationNode; 880 890 newnode->type = maybeClone( type ); 881 assert( storageClass == NoStorageClass ); 882 newnode->copyStorageClasses( this ); 891 newnode->copySpecifiers( this ); 883 892 assert( newName ); 884 893 newnode->name = newName; … … 889 898 if ( ! o ) return nullptr; 890 899 891 o->copyS torageClasses( this );900 o->copySpecifiers( this ); 892 901 if ( type ) { 893 902 TypeData * srcType = type; … … 981 990 } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) { 982 991 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 ); 984 993 obj->location = cur->location; 985 994 * out++ = obj; … … 987 996 } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) { 988 997 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 ); 990 999 obj->location = cur->location; 991 1000 * out++ = obj; … … 1034 1043 assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." ); 1035 1044 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 ] ); 1037 1046 buildList( variable.assertions, ret->get_assertions() ); 1038 1047 return ret; … … 1045 1054 // inline _Noreturn int g( int i ); // allowed 1046 1055 // inline _Noreturn int i; // disallowed 1047 if ( type->kind != TypeData::Function && funcSpec .any() ) {1056 if ( type->kind != TypeData::Function && funcSpecs.any() ) { 1048 1057 throw SemanticError( "invalid function specifier for ", this ); 1049 1058 } // 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 ); 1051 1060 } // if 1052 1061 … … 1055 1064 // inlne _Noreturn struct S { ... }; // disallowed 1056 1065 // inlne _Noreturn enum E { ... }; // disallowed 1057 if ( funcSpec .any() ) {1066 if ( funcSpecs.any() ) { 1058 1067 throw SemanticError( "invalid function specifier for ", this ); 1059 1068 } // if 1060 1069 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 ); 1062 1071 } 1063 1072 -
src/Parser/ExpressionNode.cc
r7fe2498 ra7c90d4 10 10 // Created On : Sat May 16 13:17:07 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Sep 16 16:27:44 201613 // Update Count : 50 812 // Last Modified On : Sat Mar 4 06:58:47 2017 13 // Update Count : 509 14 14 // 15 15 … … 173 173 174 174 Expression *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 ) ); 176 176 delete &str; // created by lex 177 177 return ret; … … 275 275 } 276 276 Expression *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() ); 278 278 delete member; 279 279 return ret; -
src/Parser/ParseNode.h
r7fe2498 ra7c90d4 10 10 // Created On : Sat May 16 13:28:16 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 21:34:27201713 // Update Count : 7 0412 // Last Modified On : Tue Mar 7 08:10:53 2017 13 // Update Count : 726 14 14 // 15 15 … … 40 40 //############################################################################## 41 41 42 extern char * yyfilename;42 extern char * yyfilename; 43 43 extern int yylineno; 44 44 … … 123 123 } 124 124 125 Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }125 Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); } 126 126 private: 127 127 bool extension = false; … … 204 204 // These must remain in the same order as the corresponding DeclarationNode names. 205 205 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 }; 207 208 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 }; 210 211 enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType }; 211 212 enum ComplexType { Complex, Imaginary, NoComplexType }; … … 264 265 DeclarationNode * addQualifiers( DeclarationNode * ); 265 266 void checkQualifiers( const TypeData *, const TypeData * ); 266 void checkS torageClasses( DeclarationNode * );267 DeclarationNode * copyS torageClasses( DeclarationNode * );267 void checkSpecifiers( DeclarationNode * ); 268 DeclarationNode * copySpecifiers( DeclarationNode * ); 268 269 DeclarationNode * addType( DeclarationNode * ); 269 270 DeclarationNode * addTypedef(); … … 296 297 297 298 Declaration * build() const; 298 ::Type * buildType() const;299 Type * buildType() const; 299 300 300 301 bool get_hasEllipsis() const; … … 302 303 DeclarationNode * extractAggregate() const; 303 304 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(); } 305 306 306 307 bool get_extension() const { return extension; } … … 324 325 325 326 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 ); 331 335 332 336 ExpressionNode * bitfieldWidth; … … 347 351 348 352 static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) { 349 Type * ret = orig ? orig->buildType() : nullptr;353 Type * ret = orig ? orig->buildType() : nullptr; 350 354 delete orig; 351 355 return ret; … … 362 366 363 367 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(); } 365 369 366 370 virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) { -
src/Parser/TypeData.cc
r7fe2498 ra7c90d4 10 10 // Created On : Sat May 16 15:12:51 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 21:59:10201713 // Update Count : 5 1612 // Last Modified On : Tue Mar 7 08:08:21 2017 13 // Update Count : 538 14 14 // 15 15 … … 393 393 buildList( firstNode, outputList ); 394 394 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); 396 396 if ( td->get_kind() == TypeDecl::Any ) { 397 397 // add assertion parameters to `type' tyvars in reverse order 398 398 // add dtor: void ^?{}(T *) 399 399 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 ) ); 402 402 403 403 // add copy ctor: void ?{}(T *, T) 404 404 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 ) ); 408 408 409 409 // add default ctor: void ?{}(T *) 410 410 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 ) ); 413 413 414 414 // add assignment operator: T * ?=?(T *, T) 415 415 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 ) ); 420 420 } // if 421 421 } // for … … 732 732 } // buildAggInst 733 733 734 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc) {734 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClasses scs ) { 735 735 assert( td->kind == TypeData::Symbolic ); 736 736 NamedTypeDecl * ret; 737 737 assert( td->base ); 738 738 if ( td->symbolic.isTypedef ) { 739 ret = new TypedefDecl( name, sc , typebuild( td->base ) );739 ret = new TypedefDecl( name, scs, typebuild( td->base ) ); 740 740 } else { 741 ret = new TypeDecl( name, sc , typebuild( td->base ), TypeDecl::Any );741 ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any ); 742 742 } // if 743 743 buildList( td->symbolic.params, ret->get_parameters() ); … … 784 784 } // buildTypeof 785 785 786 Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, DeclarationNode::FuncSpecfuncSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {786 Declaration * 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 ) { 787 787 if ( td->kind == TypeData::Function ) { 788 788 if ( td->function.idList ) { // KR function ? … … 792 792 FunctionDecl * decl; 793 793 Statement * stmt = maybeBuild<Statement>( td->function.body ); 794 CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt );795 decl = new FunctionDecl( name, sc , linkage, buildFunction( td ), body, attributes, funcSpec );794 CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt ); 795 decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec ); 796 796 return decl->set_asmName( asmName ); 797 797 } else if ( td->kind == TypeData::Aggregate ) { … … 800 800 return buildEnum( td, attributes ); 801 801 } else if ( td->kind == TypeData::Symbolic ) { 802 return buildSymbolic( td, name, sc );802 return buildSymbolic( td, name, scs ); 803 803 } 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 ); 805 805 } // if 806 806 return nullptr; … … 820 820 break; 821 821 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 ) ) ); 823 823 } // switch 824 824 } 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 ) ); 826 826 } // if 827 827 return ft; … … 846 846 for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = dynamic_cast< DeclarationNode * >( decl->get_next() ) ) { 847 847 // 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() ) ) { 849 849 if ( *decl->name == *param->name ) { 850 850 // type set => parameter name already transformed by a declaration names so there is a duplicate … … 867 867 // rtb( a, b, c ) const char * b; {} => int rtn( int a, const char * b, int c ) {} 868 868 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() ) ) { 870 870 if ( ! param->type ) { // generate type int for empty parameter type 871 871 param->type = new TypeData( TypeData::Basic ); -
src/Parser/TypeData.h
r7fe2498 ra7c90d4 10 10 // Created On : Sat May 16 15:18:36 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Mar 3 20:56:53 201713 // Update Count : 1 6712 // Last Modified On : Tue Mar 7 08:03:53 2017 13 // Update Count : 173 14 14 // 15 15 … … 107 107 ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes ); 108 108 ReferenceToType * buildAggInst( const TypeData * ); 109 NamedTypeDecl * buildSymbolic( const TypeData *, const std::string &name, DeclarationNode::StorageClass sc );110 109 TypeDecl * buildVariable( const TypeData * ); 111 110 EnumDecl * buildEnum( const TypeData *, std::list< Attribute * > ); … … 113 112 TupleType * buildTuple( const TypeData * ); 114 113 TypeofType * buildTypeof( const TypeData * ); 115 Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass , Expression *, DeclarationNode::FuncSpecfuncSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );114 Declaration * 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 * >() ); 116 115 FunctionType * buildFunction( const TypeData * ); 117 116 void buildKRFunction( const TypeData::Function_t & function ); -
src/Parser/lex.cc
r7fe2498 ra7c90d4 382 382 (yy_c_buf_p) = yy_cp; 383 383 384 #define YY_NUM_RULES 18 6385 #define YY_END_OF_BUFFER 18 7384 #define YY_NUM_RULES 187 385 #define YY_END_OF_BUFFER 188 386 386 /* This struct is not used in this scanner, 387 387 but its presence is necessary. */ … … 391 391 flex_int32_t yy_nxt; 392 392 }; 393 static yyconst flex_int16_t yy_accept[9 09] =393 static yyconst flex_int16_t yy_accept[914] = 394 394 { 0, 395 0, 0, 0, 0, 0, 0, 12 1, 121, 124, 124,396 18 7, 185, 7, 9, 8, 144, 123, 106, 149, 152,397 12 0, 131, 132, 147, 145, 135, 146, 138, 148, 111,398 11 2, 113, 136, 137, 154, 156, 155, 157, 185, 106,399 1 29, 185, 130, 150, 106, 108, 106, 106, 106, 106,400 10 6, 106, 106, 106, 106, 106, 106, 106, 106, 106,401 10 6, 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 1 66, 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 1 62, 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, 409 409 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, 419 452 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 447 461 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, 461 478 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 495 496 } ; 496 497 … … 540 541 } ; 541 542 542 static yyconst flex_int16_t yy_base[108 3] =543 static yyconst flex_int16_t yy_base[1088] = 543 544 { 0, 544 0, 84, 23 30, 2327, 94, 0, 177, 178, 179, 180,545 23 41, 2877, 191, 2877, 197, 55, 2877, 2287, 60, 173,546 28 77, 2877, 2877, 56, 188, 2877, 191, 189, 204, 216,547 275, 0, 23 06, 2877, 216, 2305, 152, 344, 155, 220,548 28 77, 159, 2877, 217, 226, 2877, 185, 154, 212, 251,549 237, 270, 235, 257, 241, 2 79, 193, 305, 314, 351,550 238, 228, 227, 2877, 225, 2877, 2300, 406, 412, 2877,551 2 309, 2877, 2277, 235, 2877, 0, 2877, 439, 0, 2877,552 426, 2877, 452, 464, 2877, 511, 2276, 264, 2877, 2877,553 28 77, 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 2 287, 2877, 2877, 2877, 2285, 2282, 218, 312, 2295, 350,558 3 63, 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 4 46, 443, 479, 469, 364, 472, 481, 454, 458, 484,562 503, 493, 352, 506, 486, 453, 507, 509, 2246, 539,563 53 2, 524, 516, 528, 556, 530, 540, 552, 553, 564,564 5 74, 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 22 33, 556, 627, 630, 662, 699, 688, 692, 693, 696,569 2230, 700, 703, 2205, 2202, 2877, 0, 695, 726, 693,570 7 01, 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 21 44, 694, 736, 737, 741, 614, 739, 738, 742, 798,575 807, 792, 802, 797, 746, 816, 748, 791, 824, 819,576 577 8 26, 2174, 827, 830, 831, 440, 834, 838, 836, 843,578 8 47, 849, 841, 850, 861, 853, 862, 851, 863, 865,579 8 72, 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 9 76, 977, 2165, 2164, 2163, 0, 2161, 0, 964, 968,583 2158, 0, 2157, 0, 2156, 0, 2176, 2877, 964, 967,584 2 153, 2147, 0, 2143, 0, 2877, 979, 998, 990, 2877,585 100 4, 1044, 2141, 1020, 1066, 2139, 2877, 2877, 963, 1006,586 1052, 1005, 1091, 968, 1083, 1006, 2877, 2877, 2136, 2134,587 588 2 132, 0, 2129, 0, 2126, 0, 2125, 0, 2877, 931,589 981, 985, 928, 1024, 987, 1068, 958, 1070, 1060, 1010,590 10 05, 1072, 1083, 1022, 1078, 1082, 1088, 1042, 1084, 1081,591 108 9, 1097, 2127, 1090, 2125, 1095, 2122, 1093, 1091, 1109,592 1 101, 1111, 1115, 1116, 2119, 1118, 2118, 1119, 1120, 1121,593 112 3, 1126, 1127, 1128, 2117, 1129, 2115, 1131, 1134, 1135,594 113 2, 1138, 1140, 1143, 1148, 1149, 1150, 1152, 1155, 1151,595 11 61, 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 1 304, 1297, 2097, 2072, 2082, 2079, 0, 2076, 0, 2075,601 0, 20 74, 0, 2072, 0, 2069, 0, 1190, 1210, 2069,602 1191, 1227, 1212, 1230, 1253, 1246, 1254, 1280, 1281, 1282,603 128 4, 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 133 5, 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 14 36, 1403, 1446, 1441, 1431, 1432, 1451, 1452, 1455, 1456,615 14 57, 1486, 1460, 1461, 1462, 1464, 1463, 1467, 1985, 1465,616 1468, 1470, 1 984, 1983, 1981, 1472, 1466, 1974, 1478, 1972,617 1 971, 1480, 1484, 1968, 1964, 1960, 1956, 1953, 1952, 1487,618 1 494, 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 1 530, 1501, 1502, 1533, 1537, 1931, 1532, 1541, 1534, 1539,624 1 544, 599, 1548, 1549, 1579, 1556, 1557, 1560, 1561, 1562,625 15 63, 1564, 1930, 1928, 1567, 1925, 1924, 1566, 1569, 1572,626 19 23, 1574, 1578, 0, 0, 0, 1918, 1915, 1914, 1624,627 0, 19 13, 1911, 1908, 1907, 1906, 1907, 1904, 1903, 1902,628 1 580, 1588, 1576, 1577, 1601, 1583, 1602, 1589, 1604, 1603,629 1 636, 1900, 1609, 1897, 1610, 1614, 1617, 1622, 1618, 1623,630 1 896, 1624, 1895, 1893, 1886, 1626, 1884, 1883, 1877, 1876,631 632 1 875, 1873, 1856, 1847, 1846, 1843, 1836, 1833, 1826, 1824,633 1 628, 1826, 1629, 1630, 1631, 1632, 1635, 1637, 1805, 1639,634 16 67, 1642, 1804, 1643, 1653, 1658, 1651, 1652, 1659, 1662,635 1 800, 1793, 1791, 1790, 1748, 1745, 1744, 1742, 1741, 1737,636 17 35, 1733, 1732, 1734, 1663, 1664, 1666, 1672, 1673, 1674,637 167 5, 1731, 1689, 1676, 1644, 1522, 1680, 1685, 1686, 1687,638 1 500, 1411, 1363, 1362, 1260, 1219, 1218, 1047, 1690, 1688,639 1 046, 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 172 7, 1729, 1728, 1730, 1733, 233, 137, 2877, 1805, 1818,644 1831, 1841, 1851, 1864, 1874, 1887, 1900, 1913, 1921, 1931,645 1 938, 1945, 1952, 1959, 1966, 1973, 1980, 1987, 1994, 2001,646 2005, 2013, 2019, 2026, 2033, 2040, 2047, 2050, 2057, 2063,647 20 76, 2089, 2096, 2103, 2110, 2117, 2120, 2127, 2130, 2137,648 21 40, 2147, 2150, 2157, 2160, 2167, 2170, 2177, 2180, 2187,649 21 95, 2202, 2209, 2216, 2223, 2226, 2233, 2236, 2243, 2246,650 22 53, 2259, 2272, 2279, 2286, 2289, 2296, 2299, 2306, 2309,651 2 316, 2319, 2326, 2329, 2336, 2339, 2346, 2353, 2356, 2363,652 23 66, 2373, 2380, 2387, 2390, 2397, 2400, 2407, 2410, 2417,653 654 24 20, 2427, 2430, 2437, 2443, 2456, 2463, 2470, 2473, 2480,655 24 83, 2490, 2493, 2500, 2503, 2510, 2513, 2520, 2523, 2530,656 25 33, 2540, 2543, 2550, 2557, 2560, 2567, 2570, 2577, 2580,657 25 87, 2590, 2593, 2599, 2606, 2615, 2622, 2629, 2632, 2639,658 26 42, 2645, 2651, 2658, 2661, 2664, 2667, 2670, 2673, 2676,659 267 9, 2686, 2689, 2696, 2699, 2702, 2705, 2708, 2718, 2725,660 27 28, 2731, 2734, 2741, 2748, 2755, 2758, 2765, 2772, 2779,661 27 86, 2793, 2800, 2807, 2814, 2821, 2828, 2835, 2842, 2849,662 28 56, 2863545 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 663 664 } ; 664 665 665 static yyconst flex_int16_t yy_def[108 3] =666 static yyconst flex_int16_t yy_def[1088] = 666 667 { 0, 667 9 08, 1, 909, 909, 908, 5, 910, 910, 911, 911,668 9 08, 908, 908, 908, 908, 908, 908, 912, 908, 908,669 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,670 9 08, 31, 908, 908, 908, 908, 908, 908, 913, 912,671 9 08, 908, 908, 908, 912, 908, 912, 912, 912, 912,672 91 2, 912, 912, 912, 912, 912, 912, 912, 912, 912,673 91 2, 912, 912, 908, 908, 908, 908, 908, 914, 908,674 9 08, 908, 915, 908, 908, 916, 908, 908, 917, 908,675 9 08, 908, 908, 908, 908, 908, 912, 908, 908, 908,676 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,677 678 9 08, 918, 908, 908, 30, 908, 908, 908, 908, 919,679 30, 908, 31, 908, 908, 31, 908, 908, 908, 908,680 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,681 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,682 9 20, 908, 908, 908, 908, 912, 921, 922, 908, 908,683 91 2, 912, 912, 912, 912, 912, 912, 912, 912, 912,684 91 2, 912, 912, 912, 912, 912, 912, 912, 912, 912,685 91 2, 912, 912, 912, 912, 912, 912, 912, 912, 912,686 91 2, 912, 912, 912, 912, 912, 912, 912, 912, 912,687 91 2, 912, 912, 912, 912, 912, 912, 912, 908, 908,688 689 9 08, 914, 914, 914, 908, 914, 908, 915, 908, 923,690 9 24, 916, 908, 908, 908, 908, 925, 926, 927, 917,691 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,692 9 08, 908, 908, 928, 929, 908, 100, 908, 908, 908,693 9 08, 100, 918, 908, 100, 111, 246, 908, 908, 908,694 9 08, 908, 908, 908, 908, 930, 931, 932, 908, 908,695 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,696 9 08, 908, 933, 908, 934, 935, 936, 937, 938, 939,697 9 08, 940, 940, 940, 940, 940, 940, 940, 940, 940,698 94 0, 940, 940, 940, 940, 940, 940, 940, 940, 940,699 700 94 0, 940, 940, 940, 940, 940, 940, 940, 940, 940,701 94 0, 940, 940, 940, 940, 940, 940, 940, 940, 940,702 94 0, 940, 940, 940, 940, 940, 940, 940, 940, 940,703 94 0, 940, 940, 940, 940, 940, 940, 940, 940, 940,704 94 0, 940, 940, 940, 940, 940, 940, 940, 940, 940,705 94 1, 942, 943, 944, 945, 946, 947, 948, 908, 908,706 9 49, 950, 951, 952, 953, 954, 908, 908, 908, 908,707 9 08, 955, 956, 957, 958, 908, 908, 908, 908, 908,708 9 08, 908, 382, 908, 378, 385, 908, 908, 959, 960,709 9 61, 908, 908, 908, 961, 908, 908, 908, 962, 963,710 711 9 64, 965, 966, 967, 968, 969, 970, 971, 908, 972,712 97 2, 972, 972, 972, 972, 972, 972, 972, 972, 972,713 97 2, 972, 972, 972, 972, 972, 972, 972, 972, 972,714 97 2, 972, 972, 972, 972, 972, 972, 972, 972, 972,715 97 2, 972, 972, 972, 972, 972, 972, 972, 972, 972,716 97 2, 972, 972, 972, 972, 972, 972, 972, 972, 972,717 97 2, 972, 972, 972, 972, 972, 972, 972, 972, 972,718 97 2, 972, 972, 972, 972, 972, 972, 972, 972, 973,719 97 4, 975, 976, 977, 978, 979, 980, 981, 908, 982,720 98 3, 984, 985, 986, 986, 987, 988, 989, 990, 908,721 722 500, 908, 908, 991, 908, 991, 908, 908, 908, 908,723 9 08, 908, 908, 908, 992, 993, 994, 995, 996, 997,724 99 8, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1005, 1005,725 100 5, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,726 10 05, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,727 10 05, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,728 10 05, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,729 10 05, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,730 10 05, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005, 1005,731 10 05, 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, 103 4, 1034, 1034, 1034, 1034, 1034, 1034,737 103 4, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034,738 103 4, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034,739 103 4, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034,740 103 4, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034,741 103 4, 1034, 1034, 1034, 1034, 1036, 908, 1037, 1038, 1039,742 104 0, 1041, 1042, 1043, 1044, 1045, 1046, 908, 1047, 1048,743 744 10 49, 1050, 908, 703, 908, 908, 908, 1051, 1052, 1053,745 1054, 1055, 1056, 1057, 1058, 1059, 1059, 1059, 1059, 1059,746 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,747 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,748 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,749 10 59, 1059, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 908,750 106 6, 1051, 1053, 1067, 1068, 1058, 1059, 1059, 1059, 1059,751 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,752 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,753 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1069, 1070,754 755 106 3, 1071, 1064, 1072, 1065, 1073, 1074, 1067, 1075, 1068,756 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,757 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,758 10 76, 1069, 1077, 1070, 1078, 1071, 1079, 1072, 1080, 1073,759 10 81, 1074, 1075, 1059, 1059, 1059, 1059, 1059, 1059, 1059,760 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,761 10 82, 1076, 1077, 1078, 1079, 1053, 1080, 1081, 1059, 1059,762 105 9, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,763 10 59, 1082, 1053, 1059, 1059, 1059, 1059, 1059, 1059, 1059,764 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059,765 766 10 59, 1059, 1059, 1059, 1059, 1059, 1059, 0, 908, 908,767 908, 908, 908, 908, 908, 908, 908, 908, 908, 908,768 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,769 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,770 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,771 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,772 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,773 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,774 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,775 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,776 777 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,778 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,779 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,780 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,781 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,782 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,783 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,784 9 08, 908, 908, 908, 908, 908, 908, 908, 908, 908,785 9 08, 908668 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 786 787 } ; 787 788 788 static yyconst flex_int16_t yy_nxt[296 3] =789 static yyconst flex_int16_t yy_nxt[2969] = 789 790 { 0, 790 791 12, 13, 14, 15, 15, 15, 13, 16, 17, 12, … … 794 795 18, 18, 18, 40, 18, 18, 18, 18, 18, 40, 795 796 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, 804 803 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 1116 1117 } ; 1117 1118 1118 static yyconst flex_int16_t yy_chk[296 3] =1119 static yyconst flex_int16_t yy_chk[2969] = 1119 1120 { 0, 1120 1121 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, … … 1137 1138 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1138 1139 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 1139 8, 9, 10, 37, 37, 20, 39, 9, 10, 9 07,1140 8, 9, 10, 37, 37, 20, 39, 9, 10, 912, 1140 1141 7, 8, 13, 13, 13, 13, 13, 13, 15, 15, 1141 1142 1142 1143 15, 15, 15, 15, 20, 25, 48, 39, 42, 28, 1143 27, 28, 28, 28, 28, 28, 28, 11 0, 116, 25,1144 27, 28, 28, 28, 28, 28, 28, 111, 117, 25, 1144 1145 29, 25, 27, 27, 27, 29, 48, 35, 40, 7, 1145 1146 8, 9, 10, 40, 42, 29, 30, 47, 30, 30, 1146 30, 30, 30, 30, 35, 5 7, 35, 35, 44, 127,1147 44, 12 7, 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, 1148 1149 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, 1420 1419 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 1446 1447 } ; 1447 1448 1448 1449 /* Table of booleans, true if rule could match eol. */ 1449 static yyconst flex_int32_t yy_rule_can_match_eol[18 7] =1450 static yyconst flex_int32_t yy_rule_can_match_eol[188] = 1450 1451 { 0, 1451 1452 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, … … 1455 1456 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1456 1457 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, 1458 1459 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1459 1460 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, }; 1461 1462 1462 1463 static yy_state_type yy_last_accepting_state; … … 1486 1487 * Created On : Sat Sep 22 08:58:10 2001 1487 1488 * Last Modified By : Peter A. Buhr 1488 * Last Modified On : Tue Nov 29 11:32:00 20161489 * Update Count : 50 11489 * Last Modified On : Fri Mar 3 22:18:00 2017 1490 * Update Count : 502 1490 1491 */ 1491 1492 #line 20 "lex.ll" … … 1548 1549 1549 1550 1550 #line 155 1"Parser/lex.cc"1551 #line 1552 "Parser/lex.cc" 1551 1552 1552 1553 #define INITIAL 0 … … 1743 1744 1744 1745 /* line directives */ 1745 #line 174 6"Parser/lex.cc"1746 #line 1747 "Parser/lex.cc" 1746 1747 1747 1748 if ( !(yy_init) ) … … 1797 1798 { 1798 1799 yy_current_state = (int) yy_def[yy_current_state]; 1799 if ( yy_current_state >= 9 09)1800 if ( yy_current_state >= 914 ) 1800 1801 yy_c = yy_meta[(unsigned int) yy_c]; 1801 1802 } … … 1803 1804 ++yy_cp; 1804 1805 } 1805 while ( yy_base[yy_current_state] != 28 77);1806 while ( yy_base[yy_current_state] != 2883 ); 1806 1807 1807 1808 yy_find_action: … … 2209 2210 YY_RULE_SETUP 2210 2211 #line 237 "lex.ll" 2212 { KEYWORD_RETURN(MUTEX); } // CFA 2213 YY_BREAK 2214 case 70: 2215 YY_RULE_SETUP 2216 #line 238 "lex.ll" 2211 2217 { KEYWORD_RETURN(NORETURN); } // C11 2212 2218 YY_BREAK 2213 case 7 0:2214 YY_RULE_SETUP 2215 #line 23 8"lex.ll"2219 case 71: 2220 YY_RULE_SETUP 2221 #line 239 "lex.ll" 2216 2222 { KEYWORD_RETURN(OFFSETOF); } // GCC 2217 2223 YY_BREAK 2218 case 7 1:2219 YY_RULE_SETUP 2220 #line 2 39"lex.ll"2224 case 72: 2225 YY_RULE_SETUP 2226 #line 240 "lex.ll" 2221 2227 { NUMERIC_RETURN(ONE_T); } // CFA 2222 2228 YY_BREAK 2223 case 7 2:2224 YY_RULE_SETUP 2225 #line 24 0"lex.ll"2229 case 73: 2230 YY_RULE_SETUP 2231 #line 241 "lex.ll" 2226 2232 { KEYWORD_RETURN(OTYPE); } // CFA 2227 2233 YY_BREAK 2228 case 7 3:2229 YY_RULE_SETUP 2230 #line 24 1"lex.ll"2234 case 74: 2235 YY_RULE_SETUP 2236 #line 242 "lex.ll" 2231 2237 { KEYWORD_RETURN(REGISTER); } 2232 2238 YY_BREAK 2233 case 7 4:2234 YY_RULE_SETUP 2235 #line 24 2"lex.ll"2239 case 75: 2240 YY_RULE_SETUP 2241 #line 243 "lex.ll" 2236 2242 { KEYWORD_RETURN(RESTRICT); } // C99 2237 YY_BREAK2238 case 75:2239 YY_RULE_SETUP2240 #line 243 "lex.ll"2241 { KEYWORD_RETURN(RESTRICT); } // GCC2242 2243 YY_BREAK 2243 2244 case 76: … … 2249 2250 YY_RULE_SETUP 2250 2251 #line 245 "lex.ll" 2252 { KEYWORD_RETURN(RESTRICT); } // GCC 2253 YY_BREAK 2254 case 78: 2255 YY_RULE_SETUP 2256 #line 246 "lex.ll" 2251 2257 { KEYWORD_RETURN(RETURN); } 2252 2258 YY_BREAK 2253 case 7 8:2254 YY_RULE_SETUP 2255 #line 24 6"lex.ll"2259 case 79: 2260 YY_RULE_SETUP 2261 #line 247 "lex.ll" 2256 2262 { KEYWORD_RETURN(SHORT); } 2257 2263 YY_BREAK 2258 case 79:2259 YY_RULE_SETUP 2260 #line 24 7"lex.ll"2264 case 80: 2265 YY_RULE_SETUP 2266 #line 248 "lex.ll" 2261 2267 { KEYWORD_RETURN(SIGNED); } 2262 YY_BREAK2263 case 80:2264 YY_RULE_SETUP2265 #line 248 "lex.ll"2266 { KEYWORD_RETURN(SIGNED); } // GCC2267 2268 YY_BREAK 2268 2269 case 81: … … 2274 2275 YY_RULE_SETUP 2275 2276 #line 250 "lex.ll" 2277 { KEYWORD_RETURN(SIGNED); } // GCC 2278 YY_BREAK 2279 case 83: 2280 YY_RULE_SETUP 2281 #line 251 "lex.ll" 2276 2282 { KEYWORD_RETURN(SIZEOF); } 2277 2283 YY_BREAK 2278 case 8 3:2279 YY_RULE_SETUP 2280 #line 25 1"lex.ll"2284 case 84: 2285 YY_RULE_SETUP 2286 #line 252 "lex.ll" 2281 2287 { KEYWORD_RETURN(STATIC); } 2282 2288 YY_BREAK 2283 case 8 4:2284 YY_RULE_SETUP 2285 #line 25 2"lex.ll"2289 case 85: 2290 YY_RULE_SETUP 2291 #line 253 "lex.ll" 2286 2292 { KEYWORD_RETURN(STATICASSERT); } // C11 2287 2293 YY_BREAK 2288 case 8 5:2289 YY_RULE_SETUP 2290 #line 25 3"lex.ll"2294 case 86: 2295 YY_RULE_SETUP 2296 #line 254 "lex.ll" 2291 2297 { KEYWORD_RETURN(STRUCT); } 2292 2298 YY_BREAK 2293 case 8 6:2294 YY_RULE_SETUP 2295 #line 25 4"lex.ll"2299 case 87: 2300 YY_RULE_SETUP 2301 #line 255 "lex.ll" 2296 2302 { KEYWORD_RETURN(SWITCH); } 2297 2303 YY_BREAK 2298 case 8 7:2299 YY_RULE_SETUP 2300 #line 25 5"lex.ll"2304 case 88: 2305 YY_RULE_SETUP 2306 #line 256 "lex.ll" 2301 2307 { KEYWORD_RETURN(THREADLOCAL); } // C11 2302 2308 YY_BREAK 2303 case 8 8:2304 YY_RULE_SETUP 2305 #line 25 6"lex.ll"2309 case 89: 2310 YY_RULE_SETUP 2311 #line 257 "lex.ll" 2306 2312 { KEYWORD_RETURN(THROW); } // CFA 2307 2313 YY_BREAK 2308 case 89:2309 YY_RULE_SETUP 2310 #line 25 7"lex.ll"2314 case 90: 2315 YY_RULE_SETUP 2316 #line 258 "lex.ll" 2311 2317 { KEYWORD_RETURN(THROWRESUME); } // CFA 2312 2318 YY_BREAK 2313 case 9 0:2314 YY_RULE_SETUP 2315 #line 25 8"lex.ll"2319 case 91: 2320 YY_RULE_SETUP 2321 #line 259 "lex.ll" 2316 2322 { KEYWORD_RETURN(TRAIT); } // CFA 2317 2323 YY_BREAK 2318 case 9 1:2319 YY_RULE_SETUP 2320 #line 2 59"lex.ll"2324 case 92: 2325 YY_RULE_SETUP 2326 #line 260 "lex.ll" 2321 2327 { KEYWORD_RETURN(TRY); } // CFA 2322 2328 YY_BREAK 2323 case 9 2:2324 YY_RULE_SETUP 2325 #line 26 0"lex.ll"2329 case 93: 2330 YY_RULE_SETUP 2331 #line 261 "lex.ll" 2326 2332 { KEYWORD_RETURN(TTYPE); } // CFA 2327 2333 YY_BREAK 2328 case 9 3:2329 YY_RULE_SETUP 2330 #line 26 1"lex.ll"2334 case 94: 2335 YY_RULE_SETUP 2336 #line 262 "lex.ll" 2331 2337 { KEYWORD_RETURN(TYPEDEF); } 2332 YY_BREAK2333 case 94:2334 YY_RULE_SETUP2335 #line 262 "lex.ll"2336 { KEYWORD_RETURN(TYPEOF); } // GCC2337 2338 YY_BREAK 2338 2339 case 95: … … 2349 2350 YY_RULE_SETUP 2350 2351 #line 265 "lex.ll" 2352 { KEYWORD_RETURN(TYPEOF); } // GCC 2353 YY_BREAK 2354 case 98: 2355 YY_RULE_SETUP 2356 #line 266 "lex.ll" 2351 2357 { KEYWORD_RETURN(UNION); } 2352 2358 YY_BREAK 2353 case 9 8:2354 YY_RULE_SETUP 2355 #line 26 6"lex.ll"2359 case 99: 2360 YY_RULE_SETUP 2361 #line 267 "lex.ll" 2356 2362 { KEYWORD_RETURN(UNSIGNED); } 2357 2363 YY_BREAK 2358 case 99:2359 YY_RULE_SETUP 2360 #line 26 7"lex.ll"2364 case 100: 2365 YY_RULE_SETUP 2366 #line 268 "lex.ll" 2361 2367 { KEYWORD_RETURN(VALIST); } // GCC 2362 2368 YY_BREAK 2363 case 10 0:2364 YY_RULE_SETUP 2365 #line 26 8"lex.ll"2369 case 101: 2370 YY_RULE_SETUP 2371 #line 269 "lex.ll" 2366 2372 { KEYWORD_RETURN(VOID); } 2367 2373 YY_BREAK 2368 case 10 1:2369 YY_RULE_SETUP 2370 #line 2 69"lex.ll"2374 case 102: 2375 YY_RULE_SETUP 2376 #line 270 "lex.ll" 2371 2377 { KEYWORD_RETURN(VOLATILE); } 2372 YY_BREAK2373 case 102:2374 YY_RULE_SETUP2375 #line 270 "lex.ll"2376 { KEYWORD_RETURN(VOLATILE); } // GCC2377 2378 YY_BREAK 2378 2379 case 103: … … 2384 2385 YY_RULE_SETUP 2385 2386 #line 272 "lex.ll" 2387 { KEYWORD_RETURN(VOLATILE); } // GCC 2388 YY_BREAK 2389 case 105: 2390 YY_RULE_SETUP 2391 #line 273 "lex.ll" 2386 2392 { KEYWORD_RETURN(WHILE); } 2387 2393 YY_BREAK 2388 case 10 5:2389 YY_RULE_SETUP 2390 #line 27 3"lex.ll"2394 case 106: 2395 YY_RULE_SETUP 2396 #line 274 "lex.ll" 2391 2397 { NUMERIC_RETURN(ZERO_T); } // CFA 2392 2398 YY_BREAK 2393 2399 /* identifier */ 2394 case 10 6:2395 YY_RULE_SETUP 2396 #line 27 6"lex.ll"2400 case 107: 2401 YY_RULE_SETUP 2402 #line 277 "lex.ll" 2397 2403 { IDENTIFIER_RETURN(); } 2398 2404 YY_BREAK 2399 case 10 7:2400 YY_RULE_SETUP 2401 #line 27 7"lex.ll"2405 case 108: 2406 YY_RULE_SETUP 2407 #line 278 "lex.ll" 2402 2408 { ATTRIBUTE_RETURN(); } 2403 2409 YY_BREAK 2404 case 10 8:2405 YY_RULE_SETUP 2406 #line 27 8"lex.ll"2410 case 109: 2411 YY_RULE_SETUP 2412 #line 279 "lex.ll" 2407 2413 { BEGIN BKQUOTE; } 2408 2414 YY_BREAK 2409 case 1 09:2410 YY_RULE_SETUP 2411 #line 2 79"lex.ll"2415 case 110: 2416 YY_RULE_SETUP 2417 #line 280 "lex.ll" 2412 2418 { IDENTIFIER_RETURN(); } 2413 2419 YY_BREAK 2414 case 11 0:2415 YY_RULE_SETUP 2416 #line 28 0"lex.ll"2420 case 111: 2421 YY_RULE_SETUP 2422 #line 281 "lex.ll" 2417 2423 { BEGIN 0; } 2418 2424 YY_BREAK 2419 2425 /* numeric constants */ 2420 case 11 1:2421 YY_RULE_SETUP 2422 #line 28 3"lex.ll"2426 case 112: 2427 YY_RULE_SETUP 2428 #line 284 "lex.ll" 2423 2429 { NUMERIC_RETURN(ZERO); } // CFA 2424 2430 YY_BREAK 2425 case 11 2:2426 YY_RULE_SETUP 2427 #line 28 4"lex.ll"2431 case 113: 2432 YY_RULE_SETUP 2433 #line 285 "lex.ll" 2428 2434 { NUMERIC_RETURN(ONE); } // CFA 2429 YY_BREAK2430 case 113:2431 YY_RULE_SETUP2432 #line 285 "lex.ll"2433 { NUMERIC_RETURN(INTEGERconstant); }2434 2435 YY_BREAK 2435 2436 case 114: … … 2446 2447 YY_RULE_SETUP 2447 2448 #line 288 "lex.ll" 2449 { NUMERIC_RETURN(INTEGERconstant); } 2450 YY_BREAK 2451 case 117: 2452 YY_RULE_SETUP 2453 #line 289 "lex.ll" 2448 2454 { NUMERIC_RETURN(REALDECIMALconstant); } // must appear before floating_constant 2449 2455 YY_BREAK 2450 case 11 7:2451 YY_RULE_SETUP 2452 #line 2 89"lex.ll"2456 case 118: 2457 YY_RULE_SETUP 2458 #line 290 "lex.ll" 2453 2459 { NUMERIC_RETURN(REALFRACTIONconstant); } // must appear before floating_constant 2454 YY_BREAK2455 case 118:2456 YY_RULE_SETUP2457 #line 290 "lex.ll"2458 { NUMERIC_RETURN(FLOATINGconstant); }2459 2460 YY_BREAK 2460 2461 case 119: … … 2463 2464 { NUMERIC_RETURN(FLOATINGconstant); } 2464 2465 YY_BREAK 2466 case 120: 2467 YY_RULE_SETUP 2468 #line 292 "lex.ll" 2469 { NUMERIC_RETURN(FLOATINGconstant); } 2470 YY_BREAK 2465 2471 /* character constant, allows empty value */ 2466 case 12 0:2467 YY_RULE_SETUP 2468 #line 29 4"lex.ll"2472 case 121: 2473 YY_RULE_SETUP 2474 #line 295 "lex.ll" 2469 2475 { BEGIN QUOTE; rm_underscore(); strtext = new std::string( yytext, yyleng ); } 2470 2476 YY_BREAK 2471 case 12 1:2472 YY_RULE_SETUP 2473 #line 29 5"lex.ll"2477 case 122: 2478 YY_RULE_SETUP 2479 #line 296 "lex.ll" 2474 2480 { strtext->append( yytext, yyleng ); } 2475 2481 YY_BREAK 2476 case 12 2:2477 /* rule 12 2can match eol */2478 YY_RULE_SETUP 2479 #line 29 6"lex.ll"2482 case 123: 2483 /* rule 123 can match eol */ 2484 YY_RULE_SETUP 2485 #line 297 "lex.ll" 2480 2486 { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); } 2481 2487 YY_BREAK 2482 2488 /* ' stop highlighting */ 2483 2489 /* string constant */ 2484 case 12 3:2485 YY_RULE_SETUP 2486 #line 30 0"lex.ll"2490 case 124: 2491 YY_RULE_SETUP 2492 #line 301 "lex.ll" 2487 2493 { BEGIN STRING; rm_underscore(); strtext = new std::string( yytext, yyleng ); } 2488 2494 YY_BREAK 2489 case 12 4:2490 YY_RULE_SETUP 2491 #line 30 1"lex.ll"2495 case 125: 2496 YY_RULE_SETUP 2497 #line 302 "lex.ll" 2492 2498 { strtext->append( yytext, yyleng ); } 2493 2499 YY_BREAK 2494 case 12 5:2495 /* rule 12 5can match eol */2496 YY_RULE_SETUP 2497 #line 30 2"lex.ll"2500 case 126: 2501 /* rule 126 can match eol */ 2502 YY_RULE_SETUP 2503 #line 303 "lex.ll" 2498 2504 { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); } 2499 2505 YY_BREAK 2500 2506 /* " stop highlighting */ 2501 2507 /* common character/string constant */ 2502 case 12 6:2503 YY_RULE_SETUP 2504 #line 30 6"lex.ll"2508 case 127: 2509 YY_RULE_SETUP 2510 #line 307 "lex.ll" 2505 2511 { rm_underscore(); strtext->append( yytext, yyleng ); } 2506 2512 YY_BREAK 2507 case 12 7:2508 /* rule 12 7can match eol */2509 YY_RULE_SETUP 2510 #line 30 7"lex.ll"2513 case 128: 2514 /* rule 128 can match eol */ 2515 YY_RULE_SETUP 2516 #line 308 "lex.ll" 2511 2517 {} // continuation (ALSO HANDLED BY CPP) 2512 2518 YY_BREAK 2513 case 12 8:2514 YY_RULE_SETUP 2515 #line 30 8"lex.ll"2519 case 129: 2520 YY_RULE_SETUP 2521 #line 309 "lex.ll" 2516 2522 { strtext->append( yytext, yyleng ); } // unknown escape character 2517 2523 YY_BREAK 2518 2524 /* punctuation */ 2519 case 129:2520 YY_RULE_SETUP2521 #line 311 "lex.ll"2522 { ASCIIOP_RETURN(); }2523 YY_BREAK2524 2525 case 130: 2525 2526 YY_RULE_SETUP … … 2550 2551 YY_RULE_SETUP 2551 2552 #line 317 "lex.ll" 2553 { ASCIIOP_RETURN(); } 2554 YY_BREAK 2555 case 136: 2556 YY_RULE_SETUP 2557 #line 318 "lex.ll" 2552 2558 { ASCIIOP_RETURN(); } // also operator 2553 YY_BREAK2554 case 136:2555 YY_RULE_SETUP2556 #line 318 "lex.ll"2557 { ASCIIOP_RETURN(); }2558 2559 YY_BREAK 2559 2560 case 137: … … 2565 2566 YY_RULE_SETUP 2566 2567 #line 320 "lex.ll" 2568 { ASCIIOP_RETURN(); } 2569 YY_BREAK 2570 case 139: 2571 YY_RULE_SETUP 2572 #line 321 "lex.ll" 2567 2573 { ASCIIOP_RETURN(); } // also operator 2568 2574 YY_BREAK 2569 case 1 39:2570 YY_RULE_SETUP 2571 #line 32 1"lex.ll"2575 case 140: 2576 YY_RULE_SETUP 2577 #line 322 "lex.ll" 2572 2578 { NAMEDOP_RETURN(ELLIPSIS); } 2573 2579 YY_BREAK 2574 2580 /* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */ 2575 case 14 0:2576 YY_RULE_SETUP 2577 #line 32 4"lex.ll"2581 case 141: 2582 YY_RULE_SETUP 2583 #line 325 "lex.ll" 2578 2584 { RETURN_VAL('['); } 2579 2585 YY_BREAK 2580 case 14 1:2581 YY_RULE_SETUP 2582 #line 32 5"lex.ll"2586 case 142: 2587 YY_RULE_SETUP 2588 #line 326 "lex.ll" 2583 2589 { RETURN_VAL(']'); } 2584 2590 YY_BREAK 2585 case 14 2:2586 YY_RULE_SETUP 2587 #line 32 6"lex.ll"2591 case 143: 2592 YY_RULE_SETUP 2593 #line 327 "lex.ll" 2588 2594 { RETURN_VAL('{'); } 2589 2595 YY_BREAK 2590 case 14 3:2591 YY_RULE_SETUP 2592 #line 32 7"lex.ll"2596 case 144: 2597 YY_RULE_SETUP 2598 #line 328 "lex.ll" 2593 2599 { RETURN_VAL('}'); } 2594 2600 YY_BREAK 2595 2601 /* operators */ 2596 case 144:2597 YY_RULE_SETUP2598 #line 330 "lex.ll"2599 { ASCIIOP_RETURN(); }2600 YY_BREAK2601 2602 case 145: 2602 2603 YY_RULE_SETUP … … 2666 2667 case 158: 2667 2668 YY_RULE_SETUP 2668 #line 345 "lex.ll" 2669 #line 344 "lex.ll" 2670 { ASCIIOP_RETURN(); } 2671 YY_BREAK 2672 case 159: 2673 YY_RULE_SETUP 2674 #line 346 "lex.ll" 2669 2675 { NAMEDOP_RETURN(ICR); } 2670 2676 YY_BREAK 2671 case 1 59:2672 YY_RULE_SETUP 2673 #line 34 6"lex.ll"2677 case 160: 2678 YY_RULE_SETUP 2679 #line 347 "lex.ll" 2674 2680 { NAMEDOP_RETURN(DECR); } 2675 2681 YY_BREAK 2676 case 16 0:2677 YY_RULE_SETUP 2678 #line 34 7"lex.ll"2682 case 161: 2683 YY_RULE_SETUP 2684 #line 348 "lex.ll" 2679 2685 { NAMEDOP_RETURN(EQ); } 2680 2686 YY_BREAK 2681 case 16 1:2682 YY_RULE_SETUP 2683 #line 34 8"lex.ll"2687 case 162: 2688 YY_RULE_SETUP 2689 #line 349 "lex.ll" 2684 2690 { NAMEDOP_RETURN(NE); } 2685 2691 YY_BREAK 2686 case 16 2:2687 YY_RULE_SETUP 2688 #line 3 49"lex.ll"2692 case 163: 2693 YY_RULE_SETUP 2694 #line 350 "lex.ll" 2689 2695 { NAMEDOP_RETURN(LS); } 2690 2696 YY_BREAK 2691 case 16 3:2692 YY_RULE_SETUP 2693 #line 35 0"lex.ll"2697 case 164: 2698 YY_RULE_SETUP 2699 #line 351 "lex.ll" 2694 2700 { NAMEDOP_RETURN(RS); } 2695 2701 YY_BREAK 2696 case 16 4:2697 YY_RULE_SETUP 2698 #line 35 1"lex.ll"2702 case 165: 2703 YY_RULE_SETUP 2704 #line 352 "lex.ll" 2699 2705 { NAMEDOP_RETURN(LE); } 2700 2706 YY_BREAK 2701 case 16 5:2702 YY_RULE_SETUP 2703 #line 35 2"lex.ll"2707 case 166: 2708 YY_RULE_SETUP 2709 #line 353 "lex.ll" 2704 2710 { NAMEDOP_RETURN(GE); } 2705 2711 YY_BREAK 2706 case 16 6:2707 YY_RULE_SETUP 2708 #line 35 3"lex.ll"2712 case 167: 2713 YY_RULE_SETUP 2714 #line 354 "lex.ll" 2709 2715 { NAMEDOP_RETURN(ANDAND); } 2710 2716 YY_BREAK 2711 case 16 7:2712 YY_RULE_SETUP 2713 #line 35 4"lex.ll"2717 case 168: 2718 YY_RULE_SETUP 2719 #line 355 "lex.ll" 2714 2720 { NAMEDOP_RETURN(OROR); } 2715 2721 YY_BREAK 2716 case 16 8:2717 YY_RULE_SETUP 2718 #line 35 5"lex.ll"2722 case 169: 2723 YY_RULE_SETUP 2724 #line 356 "lex.ll" 2719 2725 { NAMEDOP_RETURN(ARROW); } 2720 2726 YY_BREAK 2721 case 1 69:2722 YY_RULE_SETUP 2723 #line 35 6"lex.ll"2727 case 170: 2728 YY_RULE_SETUP 2729 #line 357 "lex.ll" 2724 2730 { NAMEDOP_RETURN(PLUSassign); } 2725 2731 YY_BREAK 2726 case 17 0:2727 YY_RULE_SETUP 2728 #line 35 7"lex.ll"2732 case 171: 2733 YY_RULE_SETUP 2734 #line 358 "lex.ll" 2729 2735 { NAMEDOP_RETURN(MINUSassign); } 2730 2736 YY_BREAK 2731 case 17 1:2732 YY_RULE_SETUP 2733 #line 35 8"lex.ll"2737 case 172: 2738 YY_RULE_SETUP 2739 #line 359 "lex.ll" 2734 2740 { NAMEDOP_RETURN(MULTassign); } 2735 2741 YY_BREAK 2736 case 17 2:2737 YY_RULE_SETUP 2738 #line 3 59"lex.ll"2742 case 173: 2743 YY_RULE_SETUP 2744 #line 360 "lex.ll" 2739 2745 { NAMEDOP_RETURN(DIVassign); } 2740 2746 YY_BREAK 2741 case 17 3:2742 YY_RULE_SETUP 2743 #line 36 0"lex.ll"2747 case 174: 2748 YY_RULE_SETUP 2749 #line 361 "lex.ll" 2744 2750 { NAMEDOP_RETURN(MODassign); } 2745 2751 YY_BREAK 2746 case 17 4:2747 YY_RULE_SETUP 2748 #line 36 1"lex.ll"2752 case 175: 2753 YY_RULE_SETUP 2754 #line 362 "lex.ll" 2749 2755 { NAMEDOP_RETURN(ANDassign); } 2750 2756 YY_BREAK 2751 case 17 5:2752 YY_RULE_SETUP 2753 #line 36 2"lex.ll"2757 case 176: 2758 YY_RULE_SETUP 2759 #line 363 "lex.ll" 2754 2760 { NAMEDOP_RETURN(ORassign); } 2755 2761 YY_BREAK 2756 case 17 6:2757 YY_RULE_SETUP 2758 #line 36 3"lex.ll"2762 case 177: 2763 YY_RULE_SETUP 2764 #line 364 "lex.ll" 2759 2765 { NAMEDOP_RETURN(ERassign); } 2760 2766 YY_BREAK 2761 case 17 7:2762 YY_RULE_SETUP 2763 #line 36 4"lex.ll"2767 case 178: 2768 YY_RULE_SETUP 2769 #line 365 "lex.ll" 2764 2770 { NAMEDOP_RETURN(LSassign); } 2765 2771 YY_BREAK 2766 case 17 8:2767 YY_RULE_SETUP 2768 #line 36 5"lex.ll"2772 case 179: 2773 YY_RULE_SETUP 2774 #line 366 "lex.ll" 2769 2775 { NAMEDOP_RETURN(RSassign); } 2770 2776 YY_BREAK 2771 case 1 79:2772 YY_RULE_SETUP 2773 #line 36 7"lex.ll"2777 case 180: 2778 YY_RULE_SETUP 2779 #line 368 "lex.ll" 2774 2780 { NAMEDOP_RETURN(ATassign); } // CFA 2775 2781 YY_BREAK 2776 2782 /* CFA, operator identifier */ 2777 case 18 0:2778 YY_RULE_SETUP 2779 #line 37 0"lex.ll"2783 case 181: 2784 YY_RULE_SETUP 2785 #line 371 "lex.ll" 2780 2786 { IDENTIFIER_RETURN(); } // unary 2781 YY_BREAK2782 case 181:2783 YY_RULE_SETUP2784 #line 371 "lex.ll"2785 { IDENTIFIER_RETURN(); }2786 2787 YY_BREAK 2787 2788 case 182: … … 2793 2794 YY_RULE_SETUP 2794 2795 #line 373 "lex.ll" 2796 { IDENTIFIER_RETURN(); } 2797 YY_BREAK 2798 case 184: 2799 YY_RULE_SETUP 2800 #line 374 "lex.ll" 2795 2801 { IDENTIFIER_RETURN(); } // binary 2796 2802 YY_BREAK … … 2821 2827 an argument list. 2822 2828 */ 2823 case 18 4:2824 YY_RULE_SETUP 2825 #line 40 0"lex.ll"2829 case 185: 2830 YY_RULE_SETUP 2831 #line 401 "lex.ll" 2826 2832 { 2827 2833 // 1 or 2 character unary operator ? … … 2836 2842 YY_BREAK 2837 2843 /* unknown characters */ 2838 case 18 5:2839 YY_RULE_SETUP 2840 #line 41 2"lex.ll"2844 case 186: 2845 YY_RULE_SETUP 2846 #line 413 "lex.ll" 2841 2847 { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); } 2842 2848 YY_BREAK 2843 case 18 6:2844 YY_RULE_SETUP 2845 #line 41 4"lex.ll"2849 case 187: 2850 YY_RULE_SETUP 2851 #line 415 "lex.ll" 2846 2852 ECHO; 2847 2853 YY_BREAK 2848 #line 28 49"Parser/lex.cc"2854 #line 2855 "Parser/lex.cc" 2849 2855 case YY_STATE_EOF(INITIAL): 2850 2856 case YY_STATE_EOF(COMMENT): … … 3143 3149 { 3144 3150 yy_current_state = (int) yy_def[yy_current_state]; 3145 if ( yy_current_state >= 9 09)3151 if ( yy_current_state >= 914 ) 3146 3152 yy_c = yy_meta[(unsigned int) yy_c]; 3147 3153 } … … 3171 3177 { 3172 3178 yy_current_state = (int) yy_def[yy_current_state]; 3173 if ( yy_current_state >= 9 09)3179 if ( yy_current_state >= 914 ) 3174 3180 yy_c = yy_meta[(unsigned int) yy_c]; 3175 3181 } 3176 3182 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 3177 yy_is_jam = (yy_current_state == 9 08);3183 yy_is_jam = (yy_current_state == 913); 3178 3184 3179 3185 return yy_is_jam ? 0 : yy_current_state; … … 3821 3827 #define YYTABLES_NAME "yytables" 3822 3828 3823 #line 41 4"lex.ll"3829 #line 415 "lex.ll" 3824 3830 3825 3831 -
src/Parser/lex.ll
r7fe2498 ra7c90d4 10 10 * Created On : Sat Sep 22 08:58:10 2001 11 11 * Last Modified By : Peter A. Buhr 12 * Last Modified On : Tue Nov 29 11:32:00 201613 * Update Count : 50 112 * Last Modified On : Fri Mar 3 22:18:00 2017 13 * Update Count : 502 14 14 */ 15 15 … … 235 235 long { KEYWORD_RETURN(LONG); } 236 236 lvalue { KEYWORD_RETURN(LVALUE); } // CFA 237 mutex { KEYWORD_RETURN(MUTEX); } // CFA 237 238 _Noreturn { KEYWORD_RETURN(NORETURN); } // C11 238 239 __builtin_offsetof { KEYWORD_RETURN(OFFSETOF); } // GCC -
src/Parser/parser.cc
r7fe2498 ra7c90d4 144 144 enum yytokentype { 145 145 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 256 257 }; 257 258 #endif 258 259 /* Tokens. */ 259 260 #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 370 372 371 373 … … 377 379 378 380 /* Line 293 of yacc.c */ 379 #line 1 39"parser.yy"381 #line 141 "parser.yy" 380 382 381 383 Token tok; … … 397 399 398 400 /* Line 293 of yacc.c */ 399 #line 40 0"Parser/parser.cc"401 #line 402 "Parser/parser.cc" 400 402 } YYSTYPE; 401 403 # define YYSTYPE_IS_TRIVIAL 1 … … 409 411 410 412 /* Line 343 of yacc.c */ 411 #line 41 2"Parser/parser.cc"413 #line 414 "Parser/parser.cc" 412 414 413 415 #ifdef short … … 626 628 627 629 /* YYFINAL -- State number of the termination state. */ 628 #define YYFINAL 24 0630 #define YYFINAL 241 629 631 /* YYLAST -- Last index in YYTABLE. */ 630 #define YYLAST 118 98632 #define YYLAST 11830 631 633 632 634 /* YYNTOKENS -- Number of terminals. */ 633 #define YYNTOKENS 13 8635 #define YYNTOKENS 139 634 636 /* YYNNTS -- Number of nonterminals. */ 635 637 #define YYNNTS 249 636 638 /* YYNRULES -- Number of rules. */ 637 #define YYNRULES 77 5639 #define YYNRULES 776 638 640 /* YYNRULES -- Number of states. */ 639 #define YYNSTATES 158 2641 #define YYNSTATES 1583 640 642 641 643 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 642 644 #define YYUNDEFTOK 2 643 #define YYMAXUTOK 36 8645 #define YYMAXUTOK 369 644 646 645 647 #define YYTRANSLATE(YYX) \ … … 652 654 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 653 655 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 654 2, 2, 2, 12 6, 2, 2, 2, 129, 123, 2,655 11 4, 115, 122, 124, 121, 125, 118, 128, 2, 2,656 2, 2, 2, 2, 2, 2, 2, 2, 13 5, 137,657 13 0, 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, 658 660 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 659 661 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 660 2, 11 6, 2, 117, 132, 2, 2, 2, 2, 2,662 2, 117, 2, 118, 133, 2, 2, 2, 2, 2, 661 663 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 662 664 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 663 2, 2, 2, 1 19, 133, 120, 127, 2, 2, 2,665 2, 2, 2, 120, 134, 121, 128, 2, 2, 2, 664 666 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 665 667 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, … … 685 687 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 686 688 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 688 690 }; 689 691 … … 724 726 1076, 1083, 1085, 1087, 1089, 1091, 1093, 1095, 1097, 1099, 725 727 1101, 1103, 1105, 1107, 1109, 1111, 1113, 1115, 1116, 1118, 726 1120, 1123, 1125, 1127, 1129, 1131, 1133, 1135, 1137, 113 8,727 114 4, 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, 728 730 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, 1184, 1186, 729 731 1188, 1190, 1192, 1194, 1196, 1198, 1200, 1202, 1204, 1206, 730 120 9, 1212, 1216, 1220, 1222, 1226, 1228, 1231, 1234, 1237,731 12 42, 1247, 1252, 1257, 1259, 1262, 1265, 1269, 1271, 1274,732 127 7, 1279, 1282, 1285, 1289, 1291, 1294, 1297, 1299, 1302,733 130 5, 1309, 1311, 1314, 1317, 1319, 1321, 1323, 1325, 1331,734 133 2, 1340, 1349, 1351, 1355, 1359, 1361, 1363, 1364, 1367,735 13 70, 1374, 1378, 1383, 1385, 1388, 1392, 1395, 1397, 1402,736 140 3, 1405, 1408, 1411, 1413, 1414, 1416, 1419, 1426, 1427,737 14 36, 1438, 1442, 1445, 1450, 1451, 1454, 1455, 1457, 1459,738 1461, 146 7, 1473, 1479, 1481, 1487, 1493, 1503, 1505, 1511,739 151 2, 1514, 1516, 1522, 1524, 1526, 1532, 1538, 1540, 1544,740 154 8, 1553, 1555, 1557, 1559, 1561, 1564, 1566, 1570, 1574,741 157 7, 1581, 1583, 1587, 1589, 1591, 1593, 1595, 1597, 1599,742 1601, 1603, 1605, 1607, 1609, 161 2, 1614, 1616, 1617, 1620,743 162 3, 1625, 1630, 1631, 1633, 1636, 1640, 1645, 1648, 1651,744 1653, 165 6, 1659, 1665, 1671, 1679, 1686, 1688, 1691, 1694,745 169 8, 1700, 1703, 1706, 1711, 1714, 1719, 1720, 1725, 1728,746 1730, 1732, 1734, 1736, 173 7, 1740, 1746, 1752, 1766, 1768,747 1770, 177 4, 1778, 1781, 1785, 1789, 1792, 1797, 1799, 1806,748 18 16, 1817, 1829, 1831, 1835, 1839, 1843, 1845, 1847, 1853,749 185 6, 1862, 1863, 1865, 1867, 1871, 1872, 1874, 1876, 1878,750 188 4, 1885, 1892, 1895, 1897, 1900, 1905, 1908, 1912, 1916,751 19 20, 1925, 1931, 1937, 1943, 1950, 1952, 1954, 1956, 1960,752 196 1, 1967, 1968, 1970, 1972, 1975, 1982, 1984, 1988, 1989,753 1991, 199 6, 1998, 2000, 2002, 2004, 2007, 2009, 2012, 2015,754 2017, 20 21, 2024, 2028, 2033, 2036, 2041, 2046, 2050, 2059,755 206 3, 2066, 2068, 2071, 2078, 2087, 2091, 2094, 2098, 2102,756 210 7, 2112, 2116, 2118, 2120, 2122, 2127, 2136, 2140, 2143,757 214 7, 2151, 2156, 2161, 2165, 2168, 2170, 2173, 2176, 2178,758 218 2, 2185, 2189, 2194, 2197, 2202, 2207, 2211, 2218, 2227,759 22 31, 2234, 2236, 2239, 2242, 2245, 2249, 2254, 2257, 2262,760 226 7, 2271, 2278, 2287, 2291, 2294, 2296, 2299, 2302, 2304,761 2306, 230 9, 2313, 2318, 2321, 2326, 2333, 2342, 2344, 2347,762 23 50, 2352, 2355, 2358, 2362, 2367, 2369, 2374, 2379, 2383,763 238 9, 2398, 2402, 2405, 2409, 2411, 2417, 2423, 2430, 2437,764 2439, 244 2, 2445, 2447, 2450, 2453, 2457, 2462, 2464, 2469,765 247 4, 2478, 2484, 2493, 2497, 2499, 2502, 2504, 2507, 2514,766 25 20, 2527, 2535, 2543, 2545, 2548, 2551, 2553, 2556, 2559,767 256 3, 2568, 2570, 2575, 2580, 2584, 2593, 2597, 2599, 2601,768 260 4, 2606, 2608, 2611, 2615, 2618, 2622, 2625, 2629, 2633,769 263 6, 2641, 2645, 2648, 2652, 2655, 2660, 2664, 2667, 2674,770 26 81, 2688, 2696, 2698, 2701, 2703, 2705, 2707, 2710, 2714,771 271 7, 2721, 2724, 2728, 2732, 2737, 2740, 2744, 2749, 2752,772 275 8, 2765, 2772, 2773, 2775, 2776732 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 773 775 }; 774 776 … … 776 778 static const yytype_int16 yyrhs[] = 777 779 { 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, 1