Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/CodeGen/CodeGenerator.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jan 25 21:22:00 2016 -// Update Count : 242 +// Last Modified On : Wed Mar 2 17:32:16 2016 +// Update Count : 243 // @@ -21,8 +21,9 @@ #include "Parser/ParseNode.h" -#include "SynTree/Type.h" +#include "SynTree/Declaration.h" #include "SynTree/Expression.h" #include "SynTree/Initializer.h" #include "SynTree/Statement.h" +#include "SynTree/Type.h" #include "Common/utility.h" @@ -170,5 +171,5 @@ } - void CodeGenerator::visit( ContextDecl *aggregateDecl ) {} + void CodeGenerator::visit( TraitDecl *aggregateDecl ) {} void CodeGenerator::visit( TypedefDecl *typeDecl ) { @@ -454,5 +455,5 @@ void CodeGenerator::visit( UntypedOffsetofExpr *offsetofExpr ) { - assert( false ); + assert( false && "UntypedOffsetofExpr should not reach code generation" ); } @@ -463,4 +464,8 @@ output << ", " << mangleName( offsetofExpr->get_member() ); output << ")"; + } + + void CodeGenerator::visit( OffsetPackExpr *offsetPackExpr ) { + assert( false && "OffsetPackExpr should not reach code generation" ); } Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/CodeGen/CodeGenerator.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Wed Aug 12 14:27:14 2015 -// Update Count : 27 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Mar 2 17:32:24 2016 +// Update Count : 28 // @@ -19,6 +19,8 @@ #include +#include "SynTree/Declaration.h" #include "SynTree/SynTree.h" #include "SynTree/Visitor.h" + #include "SymTab/Indexer.h" @@ -38,5 +40,5 @@ virtual void visit( UnionDecl *aggregateDecl ); virtual void visit( EnumDecl *aggregateDecl ); - virtual void visit( ContextDecl *aggregateDecl ); + virtual void visit( TraitDecl *aggregateDecl ); virtual void visit( TypedefDecl *typeDecl ); virtual void visit( TypeDecl *typeDecl ); @@ -63,4 +65,5 @@ virtual void visit( UntypedOffsetofExpr *offsetofExpr ); virtual void visit( OffsetofExpr *offsetofExpr ); + virtual void visit( OffsetPackExpr *offsetPackExpr ); virtual void visit( LogicalExpr *logicalExpr ); virtual void visit( ConditionalExpr *conditionalExpr ); Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/CodeGen/GenType.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -19,7 +19,9 @@ #include "GenType.h" #include "CodeGenerator.h" + +#include "SynTree/Declaration.h" +#include "SynTree/Expression.h" +#include "SynTree/Type.h" #include "SynTree/Visitor.h" -#include "SynTree/Type.h" -#include "SynTree/Expression.h" namespace CodeGen { @@ -39,4 +41,5 @@ virtual void visit( EnumInstType *enumInst ); virtual void visit( TypeInstType *typeInst ); + virtual void visit( VarArgsType *varArgsType ); private: @@ -191,4 +194,9 @@ } + void GenType::visit( VarArgsType *varArgsType ) { + typeString = "__builtin_va_list " + typeString; + handleQualifiers( varArgsType ); + } + void GenType::handleQualifiers( Type *type ) { if ( type->get_isConst() ) { Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/Box.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -14,15 +14,21 @@ // +#include +#include +#include +#include #include #include #include -#include -#include +#include +#include #include #include "Box.h" -#include "InstantiateGeneric.h" +#include "DeclMutator.h" #include "PolyMutator.h" #include "FindFunction.h" +#include "ScopedMap.h" +#include "ScopedSet.h" #include "ScrubTyVars.h" @@ -30,9 +36,11 @@ #include "SynTree/Constant.h" -#include "SynTree/Type.h" +#include "SynTree/Declaration.h" #include "SynTree/Expression.h" #include "SynTree/Initializer.h" +#include "SynTree/Mutator.h" #include "SynTree/Statement.h" -#include "SynTree/Mutator.h" +#include "SynTree/Type.h" +#include "SynTree/TypeSubstitution.h" #include "ResolvExpr/TypeEnvironment.h" @@ -40,4 +48,5 @@ #include "ResolvExpr/typeops.h" +#include "SymTab/Indexer.h" #include "SymTab/Mangler.h" @@ -54,4 +63,102 @@ FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ); + /// Abstracts type equality for a list of parameter types + struct TypeList { + TypeList() : params() {} + TypeList( const std::list< Type* > &_params ) : params() { cloneAll(_params, params); } + TypeList( std::list< Type* > &&_params ) : params( _params ) {} + + TypeList( const TypeList &that ) : params() { cloneAll(that.params, params); } + TypeList( TypeList &&that ) : params( std::move( that.params ) ) {} + + /// Extracts types from a list of TypeExpr* + TypeList( const std::list< TypeExpr* >& _params ) : params() { + for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) { + params.push_back( (*param)->get_type()->clone() ); + } + } + + TypeList& operator= ( const TypeList &that ) { + deleteAll( params ); + + params.clear(); + cloneAll( that.params, params ); + + return *this; + } + + TypeList& operator= ( TypeList &&that ) { + deleteAll( params ); + + params = std::move( that.params ); + + return *this; + } + + ~TypeList() { deleteAll( params ); } + + bool operator== ( const TypeList& that ) const { + if ( params.size() != that.params.size() ) return false; + + SymTab::Indexer dummy; + for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) { + if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false; + } + return true; + } + + std::list< Type* > params; ///< Instantiation parameters + }; + + /// Maps a key and a TypeList to the some value, accounting for scope + template< typename Key, typename Value > + class InstantiationMap { + /// Wraps value for a specific (Key, TypeList) combination + typedef std::pair< TypeList, Value* > Instantiation; + /// List of TypeLists paired with their appropriate values + typedef std::vector< Instantiation > ValueList; + /// Underlying map type; maps keys to a linear list of corresponding TypeLists and values + typedef ScopedMap< Key*, ValueList > InnerMap; + + InnerMap instantiations; ///< instantiations + + public: + /// Starts a new scope + void beginScope() { instantiations.beginScope(); } + + /// Ends a scope + void endScope() { instantiations.endScope(); } + + /// Gets the value for the (key, typeList) pair, returns NULL on none such. + Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const { + TypeList typeList( params ); + + // scan scopes for matches to the key + for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) { + for ( typename ValueList::const_reverse_iterator inst = insts->second.rbegin(); inst != insts->second.rend(); ++inst ) { + if ( inst->first == typeList ) return inst->second; + } + } + // no matching instantiations found + return 0; + } + + /// Adds a value for a (key, typeList) pair to the current scope + void insert( Key *key, const std::list< TypeExpr* > ¶ms, Value *value ) { + instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) ); + } + }; + + /// Adds layout-generation functions to polymorphic types + class LayoutFunctionBuilder : public DeclMutator { + unsigned int functionNesting; // current level of nested functions + public: + LayoutFunctionBuilder() : functionNesting( 0 ) {} + + virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ); + virtual Declaration *mutate( StructDecl *structDecl ); + virtual Declaration *mutate( UnionDecl *unionDecl ); + }; + /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call class Pass1 : public PolyMutator { @@ -72,6 +179,4 @@ virtual void doEndScope(); private: - /// Makes a new temporary array holding the offsets of the fields of `type`, and returns a new variable expression referencing it - Expression *makeOffsetArray( StructInstType *type ); /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ); @@ -100,8 +205,8 @@ ObjectDecl *makeTemporary( Type *type ); - typedef std::map< std::string, DeclarationWithType *> AdapterMap; - std::map< std::string, DeclarationWithType *> assignOps; - ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps; - std::stack< AdapterMap > adapters; + ScopedMap< std::string, DeclarationWithType *> assignOps; ///< Currently known type variable assignment operators + ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps; ///< Currently known assignment operators + ScopedMap< std::string, DeclarationWithType* > adapters; ///< Set of adapter functions in the current scope + DeclarationWithType *retval; bool useRetval; @@ -109,5 +214,6 @@ }; - /// Moves polymorphic returns in function types to pointer-type parameters, adds type size and assertion parameters to parameter lists as well + /// * Moves polymorphic returns in function types to pointer-type parameters + /// * adds type size and assertion parameters to parameter lists class Pass2 : public PolyMutator { public: @@ -120,4 +226,5 @@ virtual Type *mutate( PointerType *pointerType ); virtual Type *mutate( FunctionType *funcType ); + private: void addAdapters( FunctionType *functionType ); @@ -126,8 +233,38 @@ }; - /// Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference; - /// also fixes offsetof expressions. - class MemberExprFixer : public PolyMutator { - public: + /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately + class GenericInstantiator : public DeclMutator { + /// Map of (generic type, parameter list) pairs to concrete type instantiations + InstantiationMap< AggregateDecl, AggregateDecl > instantiations; + /// Namer for concrete types + UniqueName typeNamer; + + public: + GenericInstantiator() : DeclMutator(), instantiations(), typeNamer("_conc_") {} + + virtual Type* mutate( StructInstType *inst ); + virtual Type* mutate( UnionInstType *inst ); + + // virtual Expression* mutate( MemberExpr *memberExpr ); + + virtual void doBeginScope(); + virtual void doEndScope(); + private: + /// Wrap instantiation lookup for structs + StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)instantiations.lookup( inst->get_baseStruct(), typeSubs ); } + /// Wrap instantiation lookup for unions + UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)instantiations.lookup( inst->get_baseUnion(), typeSubs ); } + /// Wrap instantiation insertion for structs + void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { instantiations.insert( inst->get_baseStruct(), typeSubs, decl ); } + /// Wrap instantiation insertion for unions + void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { instantiations.insert( inst->get_baseUnion(), typeSubs, decl ); } + }; + + /// Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions. + /// * Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference + /// * Calculates polymorphic offsetof expressions from offset array + /// * Inserts dynamic calculation of polymorphic type layouts where needed + class PolyGenericCalculator : public PolyMutator { + public: template< typename DeclClass > DeclClass *handleDecl( DeclClass *decl, Type *type ); @@ -140,5 +277,27 @@ virtual Type *mutate( FunctionType *funcType ); virtual Expression *mutate( MemberExpr *memberExpr ); + virtual Expression *mutate( SizeofExpr *sizeofExpr ); + virtual Expression *mutate( AlignofExpr *alignofExpr ); virtual Expression *mutate( OffsetofExpr *offsetofExpr ); + virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ); + + virtual void doBeginScope(); + virtual void doEndScope(); + + private: + /// Makes a new variable in the current scope with the given name, type & optional initializer + ObjectDecl *makeVar( const std::string &name, Type *type, Initializer *init = 0 ); + /// returns true if the type has a dynamic layout; such a layout will be stored in appropriately-named local variables when the function returns + bool findGeneric( Type *ty ); + /// adds type parameters to the layout call; will generate the appropriate parameters if needed + void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams ); + + /// Enters a new scope for type-variables, adding the type variables from ty + void beginTypeScope( Type *ty ); + /// Exits the type-variable scope + void endTypeScope(); + + ScopedSet< std::string > knownLayouts; ///< Set of generic type layouts known in the current scope, indexed by sizeofName + ScopedSet< std::string > knownOffsets; ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName }; @@ -159,13 +318,4 @@ } // anonymous namespace - void printAllNotBuiltin( const std::list< Declaration *>& translationUnit, std::ostream &os ) { - for ( std::list< Declaration *>::const_iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) { - if ( ! LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) { - (*i)->print( os ); - os << std::endl; - } // if - } // for - } - /// version of mutateAll with special handling for translation unit so you can check the end of the prelude when debugging template< typename MutatorType > @@ -195,15 +345,218 @@ void box( std::list< Declaration *>& translationUnit ) { + LayoutFunctionBuilder layoutBuilder; Pass1 pass1; Pass2 pass2; - MemberExprFixer memberFixer; + GenericInstantiator instantiator; + PolyGenericCalculator polyCalculator; Pass3 pass3; + + layoutBuilder.mutateDeclarationList( translationUnit ); mutateTranslationUnit/*All*/( translationUnit, pass1 ); mutateTranslationUnit/*All*/( translationUnit, pass2 ); - instantiateGeneric( translationUnit ); - mutateTranslationUnit/*All*/( translationUnit, memberFixer ); + instantiator.mutateDeclarationList( translationUnit ); + mutateTranslationUnit/*All*/( translationUnit, polyCalculator ); mutateTranslationUnit/*All*/( translationUnit, pass3 ); } + ////////////////////////////////// LayoutFunctionBuilder //////////////////////////////////////////// + + DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) { + functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) ); + mutateAll( functionDecl->get_oldDecls(), *this ); + ++functionNesting; + functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); + --functionNesting; + return functionDecl; + } + + /// Get a list of type declarations that will affect a layout function + std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) { + std::list< TypeDecl * > otypeDecls; + + for ( std::list< TypeDecl* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) { + if ( (*decl)->get_kind() == TypeDecl::Any ) { + otypeDecls.push_back( *decl ); + } + } + + return otypeDecls; + } + + /// Adds parameters for otype layout to a function type + void addOtypeParams( FunctionType *layoutFnType, std::list< TypeDecl* > &otypeParams ) { + BasicType sizeAlignType( Type::Qualifiers(), BasicType::LongUnsignedInt ); + + for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) { + TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param ); + std::string paramName = mangleType( ¶mType ); + layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); + layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) ); + } + } + + /// Builds a layout function declaration + FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, unsigned int functionNesting, FunctionType *layoutFnType ) { + // Routines at global scope marked "static" to prevent multiple definitions is separate translation units + // because each unit generates copies of the default routines for each aggregate. + FunctionDecl *layoutDecl = new FunctionDecl( + layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false ); + layoutDecl->fixUniqueId(); + return layoutDecl; + } + + /// Makes a unary operation + Expression *makeOp( const std::string &name, Expression *arg ) { + UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) ); + expr->get_args().push_back( arg ); + return expr; + } + + /// Makes a binary operation + Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) { + UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) ); + expr->get_args().push_back( lhs ); + expr->get_args().push_back( rhs ); + return expr; + } + + /// Returns the dereference of a local pointer variable + Expression *derefVar( ObjectDecl *var ) { + return makeOp( "*?", new VariableExpr( var ) ); + } + + /// makes an if-statement with a single-expression if-block and no then block + Statement *makeCond( Expression *cond, Expression *ifPart ) { + return new IfStmt( noLabels, cond, new ExprStmt( noLabels, ifPart ), 0 ); + } + + /// makes a statement that assigns rhs to lhs if lhs < rhs + Statement *makeAssignMax( Expression *lhs, Expression *rhs ) { + return makeCond( makeOp( "?clone(), rhs->clone() ) ); + } + + /// makes a statement that aligns lhs to rhs (rhs should be an integer power of two) + Statement *makeAlignTo( Expression *lhs, Expression *rhs ) { + // check that the lhs is zeroed out to the level of rhs + Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "1" ) ) ) ); + // if not aligned, increment to alignment + Expression *ifExpr = makeOp( "?+=?", lhs->clone(), makeOp( "?-?", rhs->clone(), ifCond->clone() ) ); + return makeCond( ifCond, ifExpr ); + } + + /// adds an expression to a compound statement + void addExpr( CompoundStmt *stmts, Expression *expr ) { + stmts->get_kids().push_back( new ExprStmt( noLabels, expr ) ); + } + + /// adds a statement to a compound statement + void addStmt( CompoundStmt *stmts, Statement *stmt ) { + stmts->get_kids().push_back( stmt ); + } + + Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) { + // do not generate layout function for "empty" tag structs + if ( structDecl->get_members().empty() ) return structDecl; + + // get parameters that can change layout, exiting early if none + std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() ); + if ( otypeParams.empty() ) return structDecl; + + // build layout function signature + FunctionType *layoutFnType = new FunctionType( Type::Qualifiers(), false ); + BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ); + PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType ); + + ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 ); + layoutFnType->get_parameters().push_back( sizeParam ); + ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); + layoutFnType->get_parameters().push_back( alignParam ); + ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); + layoutFnType->get_parameters().push_back( offsetParam ); + addOtypeParams( layoutFnType, otypeParams ); + + // build function decl + FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, functionNesting, layoutFnType ); + + // calculate struct layout in function body + + // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size + addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) ); + addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) ); + unsigned long n_members = 0; + bool firstMember = true; + for ( std::list< Declaration* >::const_iterator member = structDecl->get_members().begin(); member != structDecl->get_members().end(); ++member ) { + DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ); + assert( dwt ); + Type *memberType = dwt->get_type(); + + if ( firstMember ) { + firstMember = false; + } else { + // make sure all members after the first (automatically aligned at 0) are properly padded for alignment + addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) ); + } + + // place current size in the current offset index + addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from( n_members ) ) ), + derefVar( sizeParam ) ) ); + ++n_members; + + // add member size to current size + addExpr( layoutDecl->get_statements(), makeOp( "?+=?", derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) ); + + // take max of member alignment and global alignment + addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) ); + } + // make sure the type is end-padded to a multiple of its alignment + addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) ); + + addDeclarationAfter( layoutDecl ); + return structDecl; + } + + Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) { + // do not generate layout function for "empty" tag unions + if ( unionDecl->get_members().empty() ) return unionDecl; + + // get parameters that can change layout, exiting early if none + std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() ); + if ( otypeParams.empty() ) return unionDecl; + + // build layout function signature + FunctionType *layoutFnType = new FunctionType( Type::Qualifiers(), false ); + BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ); + PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType ); + + ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 ); + layoutFnType->get_parameters().push_back( sizeParam ); + ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 ); + layoutFnType->get_parameters().push_back( alignParam ); + addOtypeParams( layoutFnType, otypeParams ); + + // build function decl + FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, functionNesting, layoutFnType ); + + // calculate union layout in function body + addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) ); + addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) ); + for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) { + DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ); + assert( dwt ); + Type *memberType = dwt->get_type(); + + // take max member size and global size + addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) ); + + // take max of member alignment and global alignment + addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) ); + } + // make sure the type is end-padded to a multiple of its alignment + addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) ); + + addDeclarationAfter( layoutDecl ); + return unionDecl; + } + ////////////////////////////////////////// Pass1 //////////////////////////////////////////////////// @@ -245,7 +598,5 @@ } - Pass1::Pass1() : useRetval( false ), tempNamer( "_temp" ) { - adapters.push(AdapterMap()); - } + Pass1::Pass1() : useRetval( false ), tempNamer( "_temp" ) {} /// Returns T if the given declaration is (*?=?)(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise @@ -309,5 +660,5 @@ DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) { - // if this is a polymorphic assignment function, put it in the map for this scope + // if this is a assignment function, put it in the map for this scope if ( Type *assignedType = isAssignment( functionDecl ) ) { if ( ! dynamic_cast< TypeInstType* >( assignedType ) ) { @@ -318,6 +669,6 @@ if ( functionDecl->get_statements() ) { // empty routine body ? doBeginScope(); - TyVarMap oldtyVars = scopeTyVars; - std::map< std::string, DeclarationWithType *> oldassignOps = assignOps; + scopeTyVars.beginScope(); + assignOps.beginScope(); DeclarationWithType *oldRetval = retval; bool oldUseRetval = useRetval; @@ -350,5 +701,4 @@ } // for - AdapterMap & adapters = Pass1::adapters.top(); for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) { std::string mangleName = mangleAdapterName( *funType, scopeTyVars ); @@ -361,11 +711,6 @@ functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) ); - scopeTyVars = oldtyVars; - assignOps = oldassignOps; - // std::cerr << "end FunctionDecl: "; - // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) { - // std::cerr << i->first << " "; - // } - // std::cerr << "\n"; + scopeTyVars.endScope(); + assignOps.endScope(); retval = oldRetval; useRetval = oldUseRetval; @@ -400,36 +745,9 @@ } - Expression *Pass1::makeOffsetArray( StructInstType *ty ) { - std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members(); - - // make a new temporary array - Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ); - std::stringstream lenGen; - lenGen << baseMembers.size(); - ConstantExpr *lenExpr = new ConstantExpr( Constant( offsetType->clone(), lenGen.str() ) ); - ObjectDecl *arrayTemp = makeTemporary( new ArrayType( Type::Qualifiers(), offsetType, lenExpr, false, false ) ); - - // build initializer list for temporary - std::list< Initializer* > inits; - for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) { - DeclarationWithType *memberDecl; - if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) { - memberDecl = origMember->clone(); - } else { - memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 ); - } - inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) ); - } - arrayTemp->set_init( new ListInit( inits ) ); - - // return variable pointing to temporary - return new VariableExpr( arrayTemp ); - } - void Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) { - Type *polyBase = hasPolyBase( parmType, exprTyVars ); - if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) { - std::string sizeName = sizeofName( polyBase ); - if ( seenTypes.count( sizeName ) ) return; + Type *polyType = isPolyType( parmType, exprTyVars ); + if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) { + std::string typeName = mangleType( polyType ); + if ( seenTypes.count( typeName ) ) return; arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) ); @@ -437,8 +755,11 @@ arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) ); arg++; - if ( dynamic_cast< StructInstType* >( polyBase ) ) { + if ( dynamic_cast< StructInstType* >( polyType ) ) { if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) { - arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) ); - arg++; + // zero-length arrays are forbidden by C, so don't pass offset for empty struct + if ( ! argBaseStructType->get_baseStruct()->get_members().empty() ) { + arg = appExpr->get_args().insert( arg, new OffsetPackExpr( argBaseStructType->clone() ) ); + arg++; + } } else { throw SemanticError( "Cannot pass non-struct type for generic struct" ); @@ -446,5 +767,5 @@ } - seenTypes.insert( sizeName ); + seenTypes.insert( typeName ); } } @@ -588,6 +909,10 @@ return; } else if ( arg->get_results().front()->get_isLvalue() ) { - // VariableExpr and MemberExpr are lvalues - arg = new AddressExpr( arg ); + // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue) + if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) { + commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) ); + } else { + arg = new AddressExpr( arg ); + } } else { // use type computed in unification to declare boxed variables @@ -684,6 +1009,4 @@ } // for } - - FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) { @@ -772,10 +1095,11 @@ mangleName += makePolyMonoSuffix( originalFunction, exprTyVars ); - AdapterMap & adapters = Pass1::adapters.top(); - AdapterMap::iterator adapter = adapters.find( mangleName ); + typedef ScopedMap< std::string, DeclarationWithType* >::iterator AdapterIter; + AdapterIter adapter = adapters.find( mangleName ); if ( adapter == adapters.end() ) { // adapter has not been created yet in the current scope, so define it FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars ); - adapter = adapters.insert( adapters.begin(), std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) ); + std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) ); + adapter = answer.first; stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) ); } // if @@ -801,5 +1125,5 @@ addAssign->get_args().push_back( appExpr->get_args().front() ); } // if - addAssign->get_args().push_back( new NameExpr( sizeofName( polyType ) ) ); + addAssign->get_args().push_back( new NameExpr( sizeofName( mangleType( polyType ) ) ) ); addAssign->get_results().front() = appExpr->get_results().front()->clone(); if ( appExpr->get_env() ) { @@ -828,5 +1152,5 @@ UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().back() ); - multiply->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) ); + multiply->get_args().push_back( new SizeofExpr( baseType1->clone() ) ); ret->get_args().push_back( appExpr->get_args().front() ); ret->get_args().push_back( multiply ); @@ -834,5 +1158,5 @@ UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().front() ); - multiply->get_args().push_back( new NameExpr( sizeofName( baseType2 ) ) ); + multiply->get_args().push_back( new SizeofExpr( baseType2->clone() ) ); ret->get_args().push_back( multiply ); ret->get_args().push_back( appExpr->get_args().back() ); @@ -897,5 +1221,5 @@ UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) ); divide->get_args().push_back( appExpr ); - divide->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) ); + divide->get_args().push_back( new SizeofExpr( baseType1->clone() ) ); divide->get_results().push_front( appExpr->get_results().front()->clone() ); if ( appExpr->get_env() ) { @@ -907,10 +1231,10 @@ UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().back() ); - multiply->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) ); + multiply->get_args().push_back( new SizeofExpr( baseType1->clone() ) ); appExpr->get_args().back() = multiply; } else if ( baseType2 ) { UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().front() ); - multiply->get_args().push_back( new NameExpr( sizeofName( baseType2 ) ) ); + multiply->get_args().push_back( new SizeofExpr( baseType2->clone() ) ); appExpr->get_args().front() = multiply; } // if @@ -922,5 +1246,5 @@ UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) ); multiply->get_args().push_back( appExpr->get_args().back() ); - multiply->get_args().push_back( new NameExpr( sizeofName( baseType ) ) ); + multiply->get_args().push_back( new SizeofExpr( baseType->clone() ) ); appExpr->get_args().back() = multiply; } // if @@ -959,5 +1283,5 @@ std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin(); - TyVarMap exprTyVars; + TyVarMap exprTyVars( (TypeDecl::Kind)-1 ); makeTyVarMap( function, exprTyVars ); ReferenceToType *polyRetType = isPolyRet( function ); @@ -982,5 +1306,4 @@ boxParams( appExpr, function, arg, exprTyVars ); - passAdapters( appExpr, function, exprTyVars ); @@ -1062,5 +1385,5 @@ if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() ) ) { // find assignment operator for type variable - std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() ); + ScopedMap< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() ); if ( assignIter == assignOps.end() ) { throw SemanticError( "Attempt to return dtype or ftype object in ", returnStmt->get_expr() ); @@ -1084,19 +1407,17 @@ std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin(); for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) { - if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; // skip types with no assign op (ftype/dtype) - - std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions(); - assert( ! asserts.empty() && "Type param needs assignment operator assertion" ); - DeclarationWithType *actualDecl = asserts.front(); - TypeInstType *actualType = isTypeInstAssignment( actualDecl ); - assert( actualType && "First assertion of type with assertions should be assignment operator" ); + // Add appropriate mapping to assignment expression environment TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt ); assert( formalTypeExpr && "type parameters must be type expressions" ); Type *formalType = formalTypeExpr->get_type(); - assignExpr->get_env()->add( actualType->get_name(), formalType ); - + assignExpr->get_env()->add( (*forallIt)->get_name(), formalType ); + + // skip types with no assign op (ftype/dtype) + if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; + + // find assignment operator for formal type DeclarationWithType *assertAssign = 0; if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) { - std::map< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() ); + ScopedMap< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() ); if ( assertAssignIt == assignOps.end() ) { throw SemanticError( "No assignment operation found for ", formalTypeInstType ); @@ -1109,6 +1430,9 @@ } } - - + + // add inferred parameter for field assignment operator to assignment expression + std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions(); + assert( ! asserts.empty() && "Type param needs assignment operator assertion" ); + DeclarationWithType *actualDecl = asserts.front(); assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ] = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) ); @@ -1136,31 +1460,30 @@ Type * Pass1::mutate( PointerType *pointerType ) { - TyVarMap oldtyVars = scopeTyVars; + scopeTyVars.beginScope(); makeTyVarMap( pointerType, scopeTyVars ); Type *ret = Mutator::mutate( pointerType ); - scopeTyVars = oldtyVars; + scopeTyVars.endScope(); return ret; } Type * Pass1::mutate( FunctionType *functionType ) { - TyVarMap oldtyVars = scopeTyVars; + scopeTyVars.beginScope(); makeTyVarMap( functionType, scopeTyVars ); Type *ret = Mutator::mutate( functionType ); - scopeTyVars = oldtyVars; + scopeTyVars.endScope(); return ret; } void Pass1::doBeginScope() { - // push a copy of the current map - adapters.push(adapters.top()); + adapters.beginScope(); scopedAssignOps.beginScope(); } void Pass1::doEndScope() { - adapters.pop(); + adapters.endScope(); scopedAssignOps.endScope(); } @@ -1217,15 +1540,15 @@ Type * Pass2::mutate( PointerType *pointerType ) { - TyVarMap oldtyVars = scopeTyVars; + scopeTyVars.beginScope(); makeTyVarMap( pointerType, scopeTyVars ); Type *ret = Mutator::mutate( pointerType ); - scopeTyVars = oldtyVars; + scopeTyVars.endScope(); return ret; } Type *Pass2::mutate( FunctionType *funcType ) { - TyVarMap oldtyVars = scopeTyVars; + scopeTyVars.beginScope(); makeTyVarMap( funcType, scopeTyVars ); @@ -1244,5 +1567,4 @@ ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 ); -// ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ); for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) { ObjectDecl *sizeParm, *alignParm; @@ -1250,12 +1572,13 @@ if ( (*tyParm)->get_kind() == TypeDecl::Any ) { TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm ); + std::string parmName = mangleType( &parmType ); sizeParm = newObj.clone(); - sizeParm->set_name( sizeofName( &parmType ) ); + sizeParm->set_name( sizeofName( parmName ) ); last = funcType->get_parameters().insert( last, sizeParm ); ++last; alignParm = newObj.clone(); - alignParm->set_name( alignofName( &parmType ) ); + alignParm->set_name( alignofName( parmName ) ); last = funcType->get_parameters().insert( last, alignParm ); ++last; @@ -1272,28 +1595,31 @@ std::set< std::string > seenTypes; // sizeofName for generic types we've seen for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) { - Type *polyBase = hasPolyBase( (*fnParm)->get_type(), scopeTyVars ); - if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) { - std::string sizeName = sizeofName( polyBase ); - if ( seenTypes.count( sizeName ) ) continue; + Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars ); + if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) { + std::string typeName = mangleType( polyType ); + if ( seenTypes.count( typeName ) ) continue; ObjectDecl *sizeParm, *alignParm, *offsetParm; sizeParm = newObj.clone(); - sizeParm->set_name( sizeName ); + sizeParm->set_name( sizeofName( typeName ) ); last = funcType->get_parameters().insert( last, sizeParm ); ++last; alignParm = newObj.clone(); - alignParm->set_name( alignofName( polyBase ) ); + alignParm->set_name( alignofName( typeName ) ); last = funcType->get_parameters().insert( last, alignParm ); ++last; - if ( dynamic_cast< StructInstType* >( polyBase ) ) { - offsetParm = newPtr.clone(); - offsetParm->set_name( offsetofName( polyBase ) ); - last = funcType->get_parameters().insert( last, offsetParm ); - ++last; + if ( StructInstType *polyBaseStruct = dynamic_cast< StructInstType* >( polyType ) ) { + // NOTE zero-length arrays are illegal in C, so empty structs have no offset array + if ( ! polyBaseStruct->get_baseStruct()->get_members().empty() ) { + offsetParm = newPtr.clone(); + offsetParm->set_name( offsetofName( typeName ) ); + last = funcType->get_parameters().insert( last, offsetParm ); + ++last; + } } - seenTypes.insert( sizeName ); + seenTypes.insert( typeName ); } } @@ -1305,66 +1631,274 @@ mutateAll( funcType->get_parameters(), *this ); - scopeTyVars = oldtyVars; + scopeTyVars.endScope(); return funcType; } -////////////////////////////////////////// MemberExprFixer //////////////////////////////////////////////////// +//////////////////////////////////////// GenericInstantiator ////////////////////////////////////////////////// + + /// Makes substitutions of params into baseParams; returns true if all parameters substituted for a concrete type + bool makeSubstitutions( const std::list< TypeDecl* >& baseParams, const std::list< Expression* >& params, std::list< TypeExpr* >& out ) { + bool allConcrete = true; // will finish the substitution list even if they're not all concrete + + // substitute concrete types for given parameters, and incomplete types for placeholders + std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin(); + std::list< Expression* >::const_iterator param = params.begin(); + for ( ; baseParam != baseParams.end() && param != params.end(); ++baseParam, ++param ) { + // switch ( (*baseParam)->get_kind() ) { + // case TypeDecl::Any: { // any type is a valid substitution here; complete types can be used to instantiate generics + TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); + assert(paramType && "Aggregate parameters should be type expressions"); + out.push_back( paramType->clone() ); + // check that the substituted type isn't a type variable itself + if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) { + allConcrete = false; + } + // break; + // } + // case TypeDecl::Dtype: // dtype can be consistently replaced with void [only pointers, which become void*] + // out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) ); + // break; + // case TypeDecl::Ftype: // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype] + // out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) ); + // break; + // } + } + + // if any parameters left over, not done + if ( baseParam != baseParams.end() ) return false; + // // if not enough parameters given, substitute remaining incomplete types for placeholders + // for ( ; baseParam != baseParams.end(); ++baseParam ) { + // switch ( (*baseParam)->get_kind() ) { + // case TypeDecl::Any: // no more substitutions here, fail early + // return false; + // case TypeDecl::Dtype: // dtype can be consistently replaced with void [only pointers, which become void*] + // out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) ); + // break; + // case TypeDecl::Ftype: // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype] + // out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) ); + // break; + // } + // } + + return allConcrete; + } + + /// Substitutes types of members of in according to baseParams => typeSubs, appending the result to out + void substituteMembers( const std::list< Declaration* >& in, const std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs, + std::list< Declaration* >& out ) { + // substitute types into new members + TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() ); + for ( std::list< Declaration* >::const_iterator member = in.begin(); member != in.end(); ++member ) { + Declaration *newMember = (*member)->clone(); + subs.apply(newMember); + out.push_back( newMember ); + } + } + + Type* GenericInstantiator::mutate( StructInstType *inst ) { + // mutate subtypes + Type *mutated = Mutator::mutate( inst ); + inst = dynamic_cast< StructInstType* >( mutated ); + if ( ! inst ) return mutated; + + // exit early if no need for further mutation + if ( inst->get_parameters().empty() ) return inst; + assert( inst->get_baseParameters() && "Base struct has parameters" ); + + // check if type can be concretely instantiated; put substitutions into typeSubs + std::list< TypeExpr* > typeSubs; + if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) { + deleteAll( typeSubs ); + return inst; + } + + // make concrete instantiation of generic type + StructDecl *concDecl = lookup( inst, typeSubs ); + if ( ! concDecl ) { + // set concDecl to new type, insert type declaration into statements to add + concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) ); + substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() ); + DeclMutator::addDeclaration( concDecl ); + insert( inst, typeSubs, concDecl ); + } + StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() ); + newInst->set_baseStruct( concDecl ); + + deleteAll( typeSubs ); + delete inst; + return newInst; + } + + Type* GenericInstantiator::mutate( UnionInstType *inst ) { + // mutate subtypes + Type *mutated = Mutator::mutate( inst ); + inst = dynamic_cast< UnionInstType* >( mutated ); + if ( ! inst ) return mutated; + + // exit early if no need for further mutation + if ( inst->get_parameters().empty() ) return inst; + assert( inst->get_baseParameters() && "Base union has parameters" ); + + // check if type can be concretely instantiated; put substitutions into typeSubs + std::list< TypeExpr* > typeSubs; + if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) { + deleteAll( typeSubs ); + return inst; + } + + // make concrete instantiation of generic type + UnionDecl *concDecl = lookup( inst, typeSubs ); + if ( ! concDecl ) { + // set concDecl to new type, insert type declaration into statements to add + concDecl = new UnionDecl( typeNamer.newName( inst->get_name() ) ); + substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() ); + DeclMutator::addDeclaration( concDecl ); + insert( inst, typeSubs, concDecl ); + } + UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() ); + newInst->set_baseUnion( concDecl ); + + deleteAll( typeSubs ); + delete inst; + return newInst; + } + + // /// Gets the base struct or union declaration for a member expression; NULL if not applicable + // AggregateDecl* getMemberBaseDecl( MemberExpr *memberExpr ) { + // // get variable for member aggregate + // VariableExpr *varExpr = dynamic_cast< VariableExpr* >( memberExpr->get_aggregate() ); + // if ( ! varExpr ) return NULL; + // + // // get object for variable + // ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( varExpr->get_var() ); + // if ( ! objectDecl ) return NULL; + // + // // get base declaration from object type + // Type *objectType = objectDecl->get_type(); + // StructInstType *structType = dynamic_cast< StructInstType* >( objectType ); + // if ( structType ) return structType->get_baseStruct(); + // UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType ); + // if ( unionType ) return unionType->get_baseUnion(); + // + // return NULL; + // } + // + // /// Finds the declaration with the given name, returning decls.end() if none such + // std::list< Declaration* >::const_iterator findDeclNamed( const std::list< Declaration* > &decls, const std::string &name ) { + // for( std::list< Declaration* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) { + // if ( (*decl)->get_name() == name ) return decl; + // } + // return decls.end(); + // } + // + // Expression* Instantiate::mutate( MemberExpr *memberExpr ) { + // // mutate, exiting early if no longer MemberExpr + // Expression *expr = Mutator::mutate( memberExpr ); + // memberExpr = dynamic_cast< MemberExpr* >( expr ); + // if ( ! memberExpr ) return expr; + // + // // get declaration of member and base declaration of member, exiting early if not found + // AggregateDecl *memberBase = getMemberBaseDecl( memberExpr ); + // if ( ! memberBase ) return memberExpr; + // DeclarationWithType *memberDecl = memberExpr->get_member(); + // std::list< Declaration* >::const_iterator baseIt = findDeclNamed( memberBase->get_members(), memberDecl->get_name() ); + // if ( baseIt == memberBase->get_members().end() ) return memberExpr; + // DeclarationWithType *baseDecl = dynamic_cast< DeclarationWithType* >( *baseIt ); + // if ( ! baseDecl ) return memberExpr; + // + // // check if stated type of the member is not the type of the member's declaration; if so, need a cast + // // this *SHOULD* be safe, I don't think anything but the void-replacements I put in for dtypes would make it past the typechecker + // SymTab::Indexer dummy; + // if ( ResolvExpr::typesCompatible( memberDecl->get_type(), baseDecl->get_type(), dummy ) ) return memberExpr; + // else return new CastExpr( memberExpr, memberDecl->get_type() ); + // } + + void GenericInstantiator::doBeginScope() { + DeclMutator::doBeginScope(); + instantiations.beginScope(); + } + + void GenericInstantiator::doEndScope() { + DeclMutator::doEndScope(); + instantiations.endScope(); + } + +////////////////////////////////////////// PolyGenericCalculator //////////////////////////////////////////////////// + + void PolyGenericCalculator::beginTypeScope( Type *ty ) { + scopeTyVars.beginScope(); + makeTyVarMap( ty, scopeTyVars ); + } + + void PolyGenericCalculator::endTypeScope() { + scopeTyVars.endScope(); + } template< typename DeclClass > - DeclClass * MemberExprFixer::handleDecl( DeclClass *decl, Type *type ) { - TyVarMap oldtyVars = scopeTyVars; - makeTyVarMap( type, scopeTyVars ); + DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) { + beginTypeScope( type ); + knownLayouts.beginScope(); + knownOffsets.beginScope(); DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) ); - scopeTyVars = oldtyVars; + knownOffsets.endScope(); + knownLayouts.endScope(); + endTypeScope(); return ret; } - ObjectDecl * MemberExprFixer::mutate( ObjectDecl *objectDecl ) { + ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) { return handleDecl( objectDecl, objectDecl->get_type() ); } - DeclarationWithType * MemberExprFixer::mutate( FunctionDecl *functionDecl ) { + DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) { return handleDecl( functionDecl, functionDecl->get_functionType() ); } - TypedefDecl * MemberExprFixer::mutate( TypedefDecl *typedefDecl ) { + TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) { return handleDecl( typedefDecl, typedefDecl->get_base() ); } - TypeDecl * MemberExprFixer::mutate( TypeDecl *typeDecl ) { + TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) { scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind(); return Mutator::mutate( typeDecl ); } - Type * MemberExprFixer::mutate( PointerType *pointerType ) { - TyVarMap oldtyVars = scopeTyVars; - makeTyVarMap( pointerType, scopeTyVars ); + Type * PolyGenericCalculator::mutate( PointerType *pointerType ) { + beginTypeScope( pointerType ); Type *ret = Mutator::mutate( pointerType ); - scopeTyVars = oldtyVars; + endTypeScope(); return ret; } - Type * MemberExprFixer::mutate( FunctionType *functionType ) { - TyVarMap oldtyVars = scopeTyVars; - makeTyVarMap( functionType, scopeTyVars ); - - Type *ret = Mutator::mutate( functionType ); - - scopeTyVars = oldtyVars; + Type * PolyGenericCalculator::mutate( FunctionType *funcType ) { + beginTypeScope( funcType ); + + // make sure that any type information passed into the function is accounted for + for ( std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); fnParm != funcType->get_parameters().end(); ++fnParm ) { + // condition here duplicates that in Pass2::mutate( FunctionType* ) + Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars ); + if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) { + knownLayouts.insert( mangleType( polyType ) ); + } + } + + Type *ret = Mutator::mutate( funcType ); + + endTypeScope(); return ret; } - Statement *MemberExprFixer::mutate( DeclStmt *declStmt ) { + Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) { if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) { - if ( isPolyType( objectDecl->get_type(), scopeTyVars ) ) { + if ( findGeneric( objectDecl->get_type() ) ) { // change initialization of a polymorphic value object // to allocate storage with alloca Type *declType = objectDecl->get_type(); UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) ); - alloc->get_args().push_back( new NameExpr( sizeofName( declType ) ) ); + alloc->get_args().push_back( new NameExpr( sizeofName( mangleType( declType ) ) ) ); delete objectDecl->get_init(); @@ -1398,5 +1932,5 @@ ConstantExpr *fieldIndex = new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), offset_namer.str() ) ); UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) ); - fieldOffset->get_args().push_back( new NameExpr( offsetofName( objectType ) ) ); + fieldOffset->get_args().push_back( new NameExpr( offsetofName( mangleType( objectType ) ) ) ); fieldOffset->get_args().push_back( fieldIndex ); return fieldOffset; @@ -1413,5 +1947,5 @@ } - Expression *MemberExprFixer::mutate( MemberExpr *memberExpr ) { + Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) { // mutate, exiting early if no longer MemberExpr Expression *expr = Mutator::mutate( memberExpr ); @@ -1430,4 +1964,5 @@ Type *objectType = hasPolyBase( objectDecl->get_type(), scopeTyVars, &tyDepth ); if ( ! objectType ) return memberExpr; + findGeneric( objectType ); // ensure layout for this type is available Expression *newMemberExpr = 0; @@ -1461,5 +1996,144 @@ } - Expression *MemberExprFixer::mutate( OffsetofExpr *offsetofExpr ) { + ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) { + ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, init ); + stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); + return newObj; + } + + void PolyGenericCalculator::addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams ) { + for ( std::list< Type* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) { + if ( findGeneric( *param ) ) { + // push size/align vars for a generic parameter back + std::string paramName = mangleType( *param ); + layoutCall->get_args().push_back( new NameExpr( sizeofName( paramName ) ) ); + layoutCall->get_args().push_back( new NameExpr( alignofName( paramName ) ) ); + } else { + layoutCall->get_args().push_back( new SizeofExpr( (*param)->clone() ) ); + layoutCall->get_args().push_back( new AlignofExpr( (*param)->clone() ) ); + } + } + } + + /// returns true if any of the otype parameters have a dynamic layout and puts all otype parameters in the output list + bool findGenericParams( std::list< TypeDecl* > &baseParams, std::list< Expression* > &typeParams, std::list< Type* > &out ) { + bool hasDynamicLayout = false; + + std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin(); + std::list< Expression* >::const_iterator typeParam = typeParams.begin(); + for ( ; baseParam != baseParams.end() && typeParam != typeParams.end(); ++baseParam, ++typeParam ) { + // skip non-otype parameters + if ( (*baseParam)->get_kind() != TypeDecl::Any ) continue; + TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( *typeParam ); + assert( typeExpr && "all otype parameters should be type expressions" ); + + Type *type = typeExpr->get_type(); + out.push_back( type ); + if ( isPolyType( type ) ) hasDynamicLayout = true; + } + assert( baseParam == baseParams.end() && typeParam == typeParams.end() ); + + return hasDynamicLayout; + } + + bool PolyGenericCalculator::findGeneric( Type *ty ) { + if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) { + // duplicate logic from isPolyType() + if ( env ) { + if ( Type *newType = env->lookup( typeInst->get_name() ) ) { + return findGeneric( newType ); + } // if + } // if + if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) { + // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set + return true; + } + return false; + } else if ( StructInstType *structTy = dynamic_cast< StructInstType* >( ty ) ) { + // check if this type already has a layout generated for it + std::string typeName = mangleType( ty ); + if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true; + + // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized + std::list< Type* > otypeParams; + if ( ! findGenericParams( *structTy->get_baseParameters(), structTy->get_parameters(), otypeParams ) ) return false; + + // insert local variables for layout and generate call to layout function + knownLayouts.insert( typeName ); // done early so as not to interfere with the later addition of parameters to the layout call + Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ); + + int n_members = structTy->get_baseStruct()->get_members().size(); + if ( n_members == 0 ) { + // all empty structs have the same layout - size 1, align 1 + makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) ); + makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) ); + // NOTE zero-length arrays are forbidden in C, so empty structs have no offsetof array + } else { + ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType ); + ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() ); + ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from( n_members ) ), false, false ) ); + + // generate call to layout function + UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( layoutofName( structTy->get_baseStruct() ) ) ); + layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) ); + layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) ); + layoutCall->get_args().push_back( new VariableExpr( offsetVar ) ); + addOtypeParamsToLayoutCall( layoutCall, otypeParams ); + + stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) ); + } + + return true; + } else if ( UnionInstType *unionTy = dynamic_cast< UnionInstType* >( ty ) ) { + // check if this type already has a layout generated for it + std::string typeName = mangleType( ty ); + if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true; + + // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized + std::list< Type* > otypeParams; + if ( ! findGenericParams( *unionTy->get_baseParameters(), unionTy->get_parameters(), otypeParams ) ) return false; + + // insert local variables for layout and generate call to layout function + knownLayouts.insert( typeName ); // done early so as not to interfere with the later addition of parameters to the layout call + Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ); + + ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType ); + ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() ); + + // generate call to layout function + UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( layoutofName( unionTy->get_baseUnion() ) ) ); + layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) ); + layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) ); + addOtypeParamsToLayoutCall( layoutCall, otypeParams ); + + stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) ); + + return true; + } + + return false; + } + + Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) { + Type *ty = sizeofExpr->get_type(); + if ( findGeneric( ty ) ) { + Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) ); + delete sizeofExpr; + return ret; + } + return sizeofExpr; + } + + Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) { + Type *ty = alignofExpr->get_type(); + if ( findGeneric( ty ) ) { + Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) ); + delete alignofExpr; + return ret; + } + return alignofExpr; + } + + Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) { // mutate, exiting early if no longer OffsetofExpr Expression *expr = Mutator::mutate( offsetofExpr ); @@ -1468,7 +2142,7 @@ // only mutate expressions for polymorphic structs/unions - Type *ty = isPolyType( offsetofExpr->get_type(), scopeTyVars ); - if ( ! ty ) return offsetofExpr; - + Type *ty = offsetofExpr->get_type(); + if ( ! findGeneric( ty ) ) return offsetofExpr; + if ( StructInstType *structType = dynamic_cast< StructInstType* >( ty ) ) { // replace offsetof expression by index into offset array @@ -1486,9 +2160,60 @@ } + Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) { + StructInstType *ty = offsetPackExpr->get_type(); + + Expression *ret = 0; + if ( findGeneric( ty ) ) { + // pull offset back from generated type information + ret = new NameExpr( offsetofName( mangleType( ty ) ) ); + } else { + std::string offsetName = offsetofName( mangleType( ty ) ); + if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) { + // use the already-generated offsets for this type + ret = new NameExpr( offsetName ); + } else { + knownOffsets.insert( offsetName ); + + std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members(); + Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ); + + // build initializer list for offset array + std::list< Initializer* > inits; + for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) { + DeclarationWithType *memberDecl; + if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) { + memberDecl = origMember->clone(); + } else { + memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 ); + } + inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) ); + } + + // build the offset array and replace the pack with a reference to it + ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from( baseMembers.size() ) ), false, false ), + new ListInit( inits ) ); + ret = new VariableExpr( offsetArray ); + } + } + + delete offsetPackExpr; + return ret; + } + + void PolyGenericCalculator::doBeginScope() { + knownLayouts.beginScope(); + knownOffsets.beginScope(); + } + + void PolyGenericCalculator::doEndScope() { + knownLayouts.endScope(); + knownOffsets.endScope(); + } + ////////////////////////////////////////// Pass3 //////////////////////////////////////////////////// template< typename DeclClass > DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) { - TyVarMap oldtyVars = scopeTyVars; + scopeTyVars.beginScope(); makeTyVarMap( type, scopeTyVars ); @@ -1496,5 +2221,5 @@ ScrubTyVars::scrub( decl, scopeTyVars ); - scopeTyVars = oldtyVars; + scopeTyVars.endScope(); return ret; } @@ -1526,20 +2251,20 @@ Type * Pass3::mutate( PointerType *pointerType ) { - TyVarMap oldtyVars = scopeTyVars; + scopeTyVars.beginScope(); makeTyVarMap( pointerType, scopeTyVars ); Type *ret = Mutator::mutate( pointerType ); - scopeTyVars = oldtyVars; + scopeTyVars.endScope(); return ret; } Type * Pass3::mutate( FunctionType *functionType ) { - TyVarMap oldtyVars = scopeTyVars; + scopeTyVars.beginScope(); makeTyVarMap( functionType, scopeTyVars ); Type *ret = Mutator::mutate( functionType ); - scopeTyVars = oldtyVars; + scopeTyVars.endScope(); return ret; } Index: src/GenPoly/DeclMutator.cc =================================================================== --- src/GenPoly/DeclMutator.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/DeclMutator.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -24,10 +24,15 @@ } - DeclMutator::DeclMutator() : Mutator(), declsToAdd(1) {} + DeclMutator::DeclMutator() : Mutator(), declsToAdd(1), declsToAddAfter(1) {} DeclMutator::~DeclMutator() {} void DeclMutator::mutateDeclarationList( std::list< Declaration* > &decls ) { - for ( std::list< Declaration* >::iterator decl = decls.begin(); decl != decls.end(); ++decl ) { + for ( std::list< Declaration* >::iterator decl = decls.begin(); ; ++decl ) { + // splice in new declarations after previous decl + decls.splice( decl, declsToAddAfter.back() ); + + if ( decl == decls.end() ) break; + // run mutator on declaration *decl = maybeMutate( *decl, *this ); @@ -39,6 +44,7 @@ void DeclMutator::doBeginScope() { - // add new decl list for inside of scope + // add new decl lists for inside of scope declsToAdd.resize( declsToAdd.size()+1 ); + declsToAddAfter.resize( declsToAddAfter.size()+1 ); } @@ -49,4 +55,9 @@ newBack->splice( newBack->end(), *back ); declsToAdd.pop_back(); + + back = declsToAddAfter.rbegin(); + newBack = back + 1; + newBack->splice( newBack->end(), *back ); + declsToAddAfter.pop_back(); } @@ -61,5 +72,8 @@ stmt = maybeMutate( stmt, *this ); // return if no declarations to add - if ( declsToAdd.back().empty() ) return stmt; + if ( declsToAdd.back().empty() && declsToAddAfter.back().empty() ) { + doEndScope(); + return stmt; + } // otherwise add declarations to new compound statement @@ -71,8 +85,15 @@ declsToAdd.back().clear(); + // add mutated statement + compound->get_kids().push_back( stmt ); + + // add declarations after to new compound statement + for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) { + DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); + compound->get_kids().push_back( declStmt ); + } + declsToAddAfter.back().clear(); + doEndScope(); - - // add mutated statement and return - compound->get_kids().push_back( stmt ); return compound; } @@ -80,6 +101,16 @@ void DeclMutator::mutateStatementList( std::list< Statement* > &stmts ) { doBeginScope(); + - for ( std::list< Statement* >::iterator stmt = stmts.begin(); stmt != stmts.end(); ++stmt ) { + for ( std::list< Statement* >::iterator stmt = stmts.begin(); ; ++stmt ) { + // add any new declarations after the previous statement + for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) { + DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); + stmts.insert( stmt, declStmt ); + } + declsToAddAfter.back().clear(); + + if ( stmt == stmts.end() ) break; + // run mutator on statement *stmt = maybeMutate( *stmt, *this ); @@ -92,5 +123,5 @@ declsToAdd.back().clear(); } - + doEndScope(); } @@ -98,4 +129,8 @@ void DeclMutator::addDeclaration( Declaration *decl ) { declsToAdd.back().push_back( decl ); + } + + void DeclMutator::addDeclarationAfter( Declaration *decl ) { + declsToAddAfter.back().push_back( decl ); } Index: src/GenPoly/DeclMutator.h =================================================================== --- src/GenPoly/DeclMutator.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/DeclMutator.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -55,7 +55,11 @@ /// Add a declaration to the list to be added before the current position void addDeclaration( Declaration* decl ); + /// Add a declaration to the list to be added after the current position + void addDeclarationAfter( Declaration* decl ); private: /// A stack of declarations to add before the current declaration or statement std::vector< std::list< Declaration* > > declsToAdd; + /// A stack of declarations to add after the current declaration or statement + std::vector< std::list< Declaration* > > declsToAddAfter; }; } // namespace Index: src/GenPoly/ErasableScopedMap.h =================================================================== --- src/GenPoly/ErasableScopedMap.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) +++ src/GenPoly/ErasableScopedMap.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -0,0 +1,286 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ScopedMap.h -- +// +// Author : Aaron B. Moss +// Created On : Wed Dec 2 11:37:00 2015 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed Dec 2 11:37:00 2015 +// Update Count : 1 +// + +#ifndef _ERASABLESCOPEDMAP_H +#define _ERASABLESCOPEDMAP_H + +#include +#include +#include +#include +#include + +namespace GenPoly { + /// A map where the items are placed into nested scopes; + /// inserted items are placed into the innermost scope, lookup looks from the innermost scope outward; + /// erasing a key means that find() will no longer report any instance of the key in a scope further + /// out, but the erasure itself is scoped. Key erasure works by inserting a sentinal value into the + /// value field, and thus only works for Value types where a meaningful sentinal can be chosen. + template + class ErasableScopedMap { + typedef std::map< Key, Value > Scope; + typedef std::vector< Scope > ScopeList; + + ScopeList scopes; ///< scoped list of maps + Value erased; ///< sentinal value for erased keys + public: + typedef typename Scope::key_type key_type; + typedef typename Scope::mapped_type mapped_type; + typedef typename Scope::value_type value_type; + typedef typename ScopeList::size_type size_type; + typedef typename ScopeList::difference_type difference_type; + typedef typename Scope::reference reference; + typedef typename Scope::const_reference const_reference; + typedef typename Scope::pointer pointer; + typedef typename Scope::const_pointer const_pointer; + + class iterator : public std::iterator< std::bidirectional_iterator_tag, + value_type > { + friend class ErasableScopedMap; + friend class const_iterator; + typedef typename std::map< Key, Value >::iterator wrapped_iterator; + typedef typename std::vector< std::map< Key, Value > > scope_list; + typedef typename scope_list::size_type size_type; + + /// Checks if this iterator points to a valid item + bool is_valid() const { + return it != map->scopes[i].end() && it->second != map->erased; + } + + /// Increments on invalid + iterator& next_valid() { + if ( ! is_valid() ) { ++(*this); } + return *this; + } + + /// Decrements on invalid + iterator& prev_valid() { + if ( ! is_valid() ) { --(*this); } + return *this; + } + + iterator(ErasableScopedMap< Key, Value > const &_map, const wrapped_iterator &_it, size_type _i) + : map(&_map), it(_it), i(_i) {} + + public: + iterator(const iterator &that) : map(that.map), it(that.it), i(that.i) {} + iterator& operator= (const iterator &that) { + map = that.map; i = that.i; it = that.it; + return *this; + } + + reference operator* () { return *it; } + pointer operator-> () { return it.operator->(); } + + iterator& operator++ () { + if ( it == map->scopes[i].end() ) { + if ( i == 0 ) return *this; + --i; + it = map->scopes[i].begin(); + } else { + ++it; + } + return next_valid(); + } + iterator& operator++ (int) { iterator tmp = *this; ++(*this); return tmp; } + + iterator& operator-- () { + // may fail if this is the begin iterator; allowed by STL spec + if ( it == map->scopes[i].begin() ) { + ++i; + it = map->scopes[i].end(); + } + --it; + return prev_valid(); + } + iterator& operator-- (int) { iterator tmp = *this; --(*this); return tmp; } + + bool operator== (const iterator &that) { + return map == that.map && i == that.i && it == that.it; + } + bool operator!= (const iterator &that) { return !( *this == that ); } + + private: + ErasableScopedMap< Key, Value > const *map; + wrapped_iterator it; + size_type i; + }; + + class const_iterator : public std::iterator< std::bidirectional_iterator_tag, + value_type > { + friend class ErasableScopedMap; + typedef typename std::map< Key, Value >::iterator wrapped_iterator; + typedef typename std::map< Key, Value >::const_iterator wrapped_const_iterator; + typedef typename std::vector< std::map< Key, Value > > scope_list; + typedef typename scope_list::size_type size_type; + + /// Checks if this iterator points to a valid item + bool is_valid() const { + return it != map->scopes[i].end() && it->second != map->erased; + } + + /// Increments on invalid + const_iterator& next_valid() { + if ( ! is_valid() ) { ++(*this); } + return *this; + } + + /// Decrements on invalid + const_iterator& prev_valid() { + if ( ! is_valid() ) { --(*this); } + return *this; + } + + const_iterator(ErasableScopedMap< Key, Value > const &_map, const wrapped_const_iterator &_it, size_type _i) + : map(&_map), it(_it), i(_i) {} + public: + const_iterator(const iterator &that) : map(that.map), it(that.it), i(that.i) {} + const_iterator(const const_iterator &that) : map(that.map), it(that.it), i(that.i) {} + const_iterator& operator= (const iterator &that) { + map = that.map; i = that.i; it = that.it; + return *this; + } + const_iterator& operator= (const const_iterator &that) { + map = that.map; i = that.i; it = that.it; + return *this; + } + + const_reference operator* () { return *it; } + const_pointer operator-> () { return it.operator->(); } + + const_iterator& operator++ () { + if ( it == map->scopes[i].end() ) { + if ( i == 0 ) return *this; + --i; + it = map->scopes[i].begin(); + } else { + ++it; + } + return next_valid(); + } + const_iterator& operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; } + + const_iterator& operator-- () { + // may fail if this is the begin iterator; allowed by STL spec + if ( it == map->scopes[i].begin() ) { + ++i; + it = map->scopes[i].end(); + } + --it; + return prev_valid(); + } + const_iterator& operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; } + + bool operator== (const const_iterator &that) { + return map == that.map && i == that.i && it == that.it; + } + bool operator!= (const const_iterator &that) { return !( *this == that ); } + + private: + ErasableScopedMap< Key, Value > const *map; + wrapped_const_iterator it; + size_type i; + }; + + /// Starts a new scope + void beginScope() { + Scope scope; + scopes.push_back(scope); + } + + /// Ends a scope; invalidates any iterators pointing to elements of that scope + void endScope() { + scopes.pop_back(); + assert( ! scopes.empty() ); + } + + /// Default constructor initializes with one scope + ErasableScopedMap( const Value &erased_ ) : erased( erased_ ) { beginScope(); } + + iterator begin() { return iterator(*this, scopes.back().begin(), scopes.size()-1).next_valid(); } + const_iterator begin() const { return const_iterator(*this, scopes.back().begin(), scopes.size()-1).next_valid(); } + const_iterator cbegin() const { return const_iterator(*this, scopes.back().begin(), scopes.size()-1).next_valid(); } + iterator end() { return iterator(*this, scopes[0].end(), 0); } + const_iterator end() const { return const_iterator(*this, scopes[0].end(), 0); } + const_iterator cend() const { return const_iterator(*this, scopes[0].end(), 0); } + + /// Gets the index of the current scope (counted from 1) + size_type currentScope() const { return scopes.size(); } + + /// Finds the given key in the outermost scope it occurs; returns end() for none such + iterator find( const Key &key ) { + for ( size_type i = scopes.size() - 1; ; --i ) { + typename Scope::iterator val = scopes[i].find( key ); + if ( val != scopes[i].end() ) { + return val->second == erased ? end() : iterator( *this, val, i ); + } + if ( i == 0 ) break; + } + return end(); + } + const_iterator find( const Key &key ) const { + return const_iterator( const_cast< ErasableScopedMap< Key, Value >* >(this)->find( key ) ); + } + + /// Finds the given key in the outermost scope inside the given scope where it occurs + iterator findNext( const_iterator &it, const Key &key ) { + if ( it.i == 0 ) return end(); + for ( size_type i = it.i - 1; ; --i ) { + typename Scope::iterator val = scopes[i].find( key ); + if ( val != scopes[i].end() ) { + return val->second == erased ? end() : iterator( *this, val, i ); + } + if ( i == 0 ) break; + } + return end(); + } + const_iterator findNext( const_iterator &it, const Key &key ) const { + return const_iterator( const_cast< ErasableScopedMap< Key, Value >* >(this)->findNext( it, key ) ); + } + + /// Inserts the given key-value pair into the outermost scope + std::pair< iterator, bool > insert( const value_type &value ) { + std::pair< typename Scope::iterator, bool > res = scopes.back().insert( value ); + return std::make_pair( iterator(*this, res.first, scopes.size()-1), res.second ); + } + std::pair< iterator, bool > insert( const Key &key, const Value &value ) { return insert( std::make_pair( key, value ) ); } + + /// Marks the given element as erased from this scope inward; returns 1 for erased an element, 0 otherwise + size_type erase( const Key &key ) { + typename Scope::iterator val = scopes.back().find( key ); + if ( val != scopes.back().end() ) { + val->second = erased; + return 1; + } else { + scopes.back().insert( val, std::make_pair( key, erased ) ); + return 0; + } + } + + Value& operator[] ( const Key &key ) { + iterator slot = find( key ); + if ( slot != end() ) return slot->second; + return insert( key, Value() ).first->second; + } + }; +} // namespace GenPoly + +#endif // _ERASABLESCOPEDMAP_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/GenPoly/FindFunction.cc =================================================================== --- src/GenPoly/FindFunction.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/FindFunction.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -55,5 +55,5 @@ TyVarMap::iterator var = tyVars.find( (*i)->get_name() ); if ( var != tyVars.end() ) { - tyVars.erase( var ); + tyVars.erase( var->first ); } // if } // for @@ -61,5 +61,5 @@ Type * FindFunction::mutate( FunctionType *functionType ) { - TyVarMap oldTyVars = tyVars; + tyVars.beginScope(); handleForall( functionType->get_forall() ); mutateAll( functionType->get_returnVals(), *this ); @@ -72,13 +72,13 @@ } // if } // if - tyVars = oldTyVars; + tyVars.endScope(); return ret; } Type * FindFunction::mutate( PointerType *pointerType ) { - TyVarMap oldTyVars = tyVars; + tyVars.beginScope(); handleForall( pointerType->get_forall() ); Type *ret = Mutator::mutate( pointerType ); - tyVars = oldTyVars; + tyVars.endScope(); return ret; } Index: src/GenPoly/GenPoly.cc =================================================================== --- src/GenPoly/GenPoly.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/GenPoly.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -16,5 +16,4 @@ #include "GenPoly.h" -#include "SymTab/Mangler.h" #include "SynTree/Expression.h" #include "SynTree/Type.h" @@ -38,5 +37,5 @@ ReferenceToType *isPolyRet( FunctionType *function ) { if ( ! function->get_returnVals().empty() ) { - TyVarMap forallTypes; + TyVarMap forallTypes( (TypeDecl::Kind)-1 ); makeTyVarMap( function, forallTypes ); return (ReferenceToType*)isPolyType( function->get_returnVals().front()->get_type(), forallTypes ); @@ -218,16 +217,4 @@ } - std::string sizeofName( Type *ty ) { - return std::string( "_sizeof_" ) + SymTab::Mangler::mangleType( ty ); - } - - std::string alignofName( Type *ty ) { - return std::string( "_alignof_" ) + SymTab::Mangler::mangleType( ty ); - } - - std::string offsetofName( Type* ty ) { - return std::string( "_offsetof_" ) + SymTab::Mangler::mangleType( ty ); - } - } // namespace GenPoly Index: src/GenPoly/GenPoly.h =================================================================== --- src/GenPoly/GenPoly.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/GenPoly.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -17,8 +17,11 @@ #define GENPOLY_H -#include #include #include #include + +#include "ErasableScopedMap.h" + +#include "SymTab/Mangler.h" #include "SynTree/Declaration.h" @@ -27,5 +30,5 @@ namespace GenPoly { - typedef std::map< std::string, TypeDecl::Kind > TyVarMap; + typedef ErasableScopedMap< std::string, TypeDecl::Kind > TyVarMap; /// A function needs an adapter if it returns a polymorphic value or if any of its @@ -69,12 +72,19 @@ void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ); - /// Gets the name of the sizeof parameter for the type - std::string sizeofName( Type *ty ); + /// Gets the mangled name of this type; alias for SymTab::Mangler::mangleType(). + inline std::string mangleType( Type *ty ) { return SymTab::Mangler::mangleType( ty ); } + + /// Gets the name of the sizeof parameter for the type, given its mangled name + inline std::string sizeofName( const std::string &name ) { return std::string( "_sizeof_" ) + name; } - /// Gets the name of the alignof parameter for the type - std::string alignofName( Type *ty ); + /// Gets the name of the alignof parameter for the type, given its mangled name + inline std::string alignofName( const std::string &name ) { return std::string( "_alignof_" ) + name; } - /// Gets the name of the offsetof parameter for the type - std::string offsetofName( Type *ty ); + /// Gets the name of the offsetof parameter for the type, given its mangled name + inline std::string offsetofName( const std::string &name ) { return std::string( "_offsetof_" ) + name; } + + /// Gets the name of the layout function for a given aggregate type, given its declaration + inline std::string layoutofName( AggregateDecl *decl ) { return std::string( "_layoutof_" ) + decl->get_name(); } + } // namespace GenPoly Index: src/GenPoly/InstantiateGeneric.cc =================================================================== --- src/GenPoly/InstantiateGeneric.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,360 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// InstantiateGeneric.cc -- -// -// Author : Aaron B. Moss -// Created On : Wed Nov 11 14:55:01 2015 -// Last Modified By : Aaron B. Moss -// Last Modified On : Wed Nov 11 14:55:01 2015 -// Update Count : 1 -// - -#include -#include -#include -#include -#include - -#include "InstantiateGeneric.h" -#include "DeclMutator.h" - -#include "ResolvExpr/typeops.h" -#include "SymTab/Indexer.h" -#include "SynTree/Declaration.h" -#include "SynTree/Mutator.h" -#include "SynTree/Statement.h" -#include "SynTree/Type.h" -#include "SynTree/TypeSubstitution.h" - -#include "Common/UniqueName.h" -#include "Common/utility.h" - -namespace GenPoly { - - /// Key for a unique concrete type; generic base type paired with type parameter list - struct ConcreteType { - ConcreteType() : base(NULL), params() {} - - ConcreteType(AggregateDecl *_base, const std::list< Type* >& _params) : base(_base), params() { cloneAll(_params, params); } - - ConcreteType(const ConcreteType& that) : base(that.base), params() { cloneAll(that.params, params); } - - /// Extracts types from a list of TypeExpr* - ConcreteType(AggregateDecl *_base, const std::list< TypeExpr* >& _params) : base(_base), params() { - for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) { - params.push_back( (*param)->get_type()->clone() ); - } - } - - ConcreteType& operator= (const ConcreteType& that) { - deleteAll( params ); - params.clear(); - - base = that.base; - cloneAll( that.params, params ); - - return *this; - } - - ~ConcreteType() { deleteAll( params ); } - - bool operator== (const ConcreteType& that) const { - if ( base != that.base ) return false; - - SymTab::Indexer dummy; - if ( params.size() != that.params.size() ) return false; - for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) { - if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false; - } - return true; - } - - AggregateDecl *base; ///< Base generic type - std::list< Type* > params; ///< Instantiation parameters - }; - - /// Maps a concrete type to the instantiated struct type, accounting for scope - class InstantiationMap { - /// Instantiation of a generic type, with key information to find it - struct Instantiation { - ConcreteType key; ///< Instantiation parameters for this type - AggregateDecl *decl; ///< Declaration of the instantiated generic type - - Instantiation() : key(), decl(0) {} - Instantiation(const ConcreteType &_key, AggregateDecl *_decl) : key(_key), decl(_decl) {} - }; - /// Map of generic types to instantiations of them - typedef std::map< AggregateDecl*, std::vector< Instantiation > > Scope; - - std::vector< Scope > scopes; ///< list of scopes, from outermost to innermost - - public: - /// Starts a new scope - void beginScope() { - Scope scope; - scopes.push_back(scope); - } - - /// Ends a scope - void endScope() { - scopes.pop_back(); - } - - /// Default constructor initializes with one scope - InstantiationMap() { beginScope(); } - - private: - /// Gets the declaration for the concrete instantiation of this type, assuming it has already been instantiated in the current scope. - /// Returns NULL on none such. - AggregateDecl* lookup( AggregateDecl *generic, const std::list< TypeExpr* >& params ) { - ConcreteType key(generic, params); - // scan scopes from innermost out - for ( std::vector< Scope >::const_reverse_iterator scope = scopes.rbegin(); scope != scopes.rend(); ++scope ) { - // skip scope if no instantiations of this generic type - Scope::const_iterator insts = scope->find( generic ); - if ( insts == scope->end() ) continue; - // look through instantiations for matches to concrete type - for ( std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) { - if ( inst->key == key ) return inst->decl; - } - } - // no matching instantiation found - return NULL; - } - public: - StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)lookup( inst->get_baseStruct(), typeSubs ); } - UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)lookup( inst->get_baseUnion(), typeSubs ); } - - private: - /// Adds a declaration for a concrete type to the current scope - void insert( AggregateDecl *generic, const std::list< TypeExpr* > ¶ms, AggregateDecl *decl ) { - ConcreteType key(generic, params); - scopes.back()[generic].push_back( Instantiation( key, decl ) ); - } - public: - void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { insert( inst->get_baseStruct(), typeSubs, decl ); } - void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { insert( inst->get_baseUnion(), typeSubs, decl ); } - }; - - /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately - class Instantiate : public DeclMutator { - /// Map of (generic type, parameter list) pairs to concrete type instantiations - InstantiationMap instantiations; - /// Namer for concrete types - UniqueName typeNamer; - - public: - Instantiate() : DeclMutator(), instantiations(), typeNamer("_conc_") {} - - virtual Type* mutate( StructInstType *inst ); - virtual Type* mutate( UnionInstType *inst ); - -// virtual Expression* mutate( MemberExpr *memberExpr ); - - virtual void doBeginScope(); - virtual void doEndScope(); - }; - - void instantiateGeneric( std::list< Declaration* >& translationUnit ) { - Instantiate instantiator; - instantiator.mutateDeclarationList( translationUnit ); - } - - /// Makes substitutions of params into baseParams; returns true if all parameters substituted for a concrete type - bool makeSubstitutions( const std::list< TypeDecl* >& baseParams, const std::list< Expression* >& params, std::list< TypeExpr* >& out ) { - bool allConcrete = true; // will finish the substitution list even if they're not all concrete - - // substitute concrete types for given parameters, and incomplete types for placeholders - std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin(); - std::list< Expression* >::const_iterator param = params.begin(); - for ( ; baseParam != baseParams.end() && param != params.end(); ++baseParam, ++param ) { -// switch ( (*baseParam)->get_kind() ) { -// case TypeDecl::Any: { // any type is a valid substitution here; complete types can be used to instantiate generics - TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); - assert(paramType && "Aggregate parameters should be type expressions"); - out.push_back( paramType->clone() ); - // check that the substituted type isn't a type variable itself - if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) { - allConcrete = false; - } -// break; -// } -// case TypeDecl::Dtype: // dtype can be consistently replaced with void [only pointers, which become void*] -// out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) ); -// break; -// case TypeDecl::Ftype: // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype] -// out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) ); -// break; -// } - } - - // if any parameters left over, not done - if ( baseParam != baseParams.end() ) return false; -// // if not enough parameters given, substitute remaining incomplete types for placeholders -// for ( ; baseParam != baseParams.end(); ++baseParam ) { -// switch ( (*baseParam)->get_kind() ) { -// case TypeDecl::Any: // no more substitutions here, fail early -// return false; -// case TypeDecl::Dtype: // dtype can be consistently replaced with void [only pointers, which become void*] -// out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) ); -// break; -// case TypeDecl::Ftype: // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype] -// out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) ); -// break; -// } -// } - - return allConcrete; - } - - /// Substitutes types of members of in according to baseParams => typeSubs, appending the result to out - void substituteMembers( const std::list< Declaration* >& in, const std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs, - std::list< Declaration* >& out ) { - // substitute types into new members - TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() ); - for ( std::list< Declaration* >::const_iterator member = in.begin(); member != in.end(); ++member ) { - Declaration *newMember = (*member)->clone(); - subs.apply(newMember); - out.push_back( newMember ); - } - } - - Type* Instantiate::mutate( StructInstType *inst ) { - // mutate subtypes - Type *mutated = Mutator::mutate( inst ); - inst = dynamic_cast< StructInstType* >( mutated ); - if ( ! inst ) return mutated; - - // exit early if no need for further mutation - if ( inst->get_parameters().empty() ) return inst; - assert( inst->get_baseParameters() && "Base struct has parameters" ); - - // check if type can be concretely instantiated; put substitutions into typeSubs - std::list< TypeExpr* > typeSubs; - if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) { - deleteAll( typeSubs ); - return inst; - } - - // make concrete instantiation of generic type - StructDecl *concDecl = instantiations.lookup( inst, typeSubs ); - if ( ! concDecl ) { - // set concDecl to new type, insert type declaration into statements to add - concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) ); - substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() ); - DeclMutator::addDeclaration( concDecl ); - instantiations.insert( inst, typeSubs, concDecl ); - } - StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() ); - newInst->set_baseStruct( concDecl ); - - deleteAll( typeSubs ); - delete inst; - return newInst; - } - - Type* Instantiate::mutate( UnionInstType *inst ) { - // mutate subtypes - Type *mutated = Mutator::mutate( inst ); - inst = dynamic_cast< UnionInstType* >( mutated ); - if ( ! inst ) return mutated; - - // exit early if no need for further mutation - if ( inst->get_parameters().empty() ) return inst; - assert( inst->get_baseParameters() && "Base union has parameters" ); - - // check if type can be concretely instantiated; put substitutions into typeSubs - std::list< TypeExpr* > typeSubs; - if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) { - deleteAll( typeSubs ); - return inst; - } - - // make concrete instantiation of generic type - UnionDecl *concDecl = instantiations.lookup( inst, typeSubs ); - if ( ! concDecl ) { - // set concDecl to new type, insert type declaration into statements to add - concDecl = new UnionDecl( typeNamer.newName( inst->get_name() ) ); - substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() ); - DeclMutator::addDeclaration( concDecl ); - instantiations.insert( inst, typeSubs, concDecl ); - } - UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() ); - newInst->set_baseUnion( concDecl ); - - deleteAll( typeSubs ); - delete inst; - return newInst; - } - -// /// Gets the base struct or union declaration for a member expression; NULL if not applicable -// AggregateDecl* getMemberBaseDecl( MemberExpr *memberExpr ) { -// // get variable for member aggregate -// VariableExpr *varExpr = dynamic_cast< VariableExpr* >( memberExpr->get_aggregate() ); -// if ( ! varExpr ) return NULL; -// -// // get object for variable -// ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( varExpr->get_var() ); -// if ( ! objectDecl ) return NULL; -// -// // get base declaration from object type -// Type *objectType = objectDecl->get_type(); -// StructInstType *structType = dynamic_cast< StructInstType* >( objectType ); -// if ( structType ) return structType->get_baseStruct(); -// UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType ); -// if ( unionType ) return unionType->get_baseUnion(); -// -// return NULL; -// } -// -// /// Finds the declaration with the given name, returning decls.end() if none such -// std::list< Declaration* >::const_iterator findDeclNamed( const std::list< Declaration* > &decls, const std::string &name ) { -// for( std::list< Declaration* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) { -// if ( (*decl)->get_name() == name ) return decl; -// } -// return decls.end(); -// } -// -// Expression* Instantiate::mutate( MemberExpr *memberExpr ) { -// // mutate, exiting early if no longer MemberExpr -// Expression *expr = Mutator::mutate( memberExpr ); -// memberExpr = dynamic_cast< MemberExpr* >( expr ); -// if ( ! memberExpr ) return expr; -// -// // get declaration of member and base declaration of member, exiting early if not found -// AggregateDecl *memberBase = getMemberBaseDecl( memberExpr ); -// if ( ! memberBase ) return memberExpr; -// DeclarationWithType *memberDecl = memberExpr->get_member(); -// std::list< Declaration* >::const_iterator baseIt = findDeclNamed( memberBase->get_members(), memberDecl->get_name() ); -// if ( baseIt == memberBase->get_members().end() ) return memberExpr; -// DeclarationWithType *baseDecl = dynamic_cast< DeclarationWithType* >( *baseIt ); -// if ( ! baseDecl ) return memberExpr; -// -// // check if stated type of the member is not the type of the member's declaration; if so, need a cast -// // this *SHOULD* be safe, I don't think anything but the void-replacements I put in for dtypes would make it past the typechecker -// SymTab::Indexer dummy; -// if ( ResolvExpr::typesCompatible( memberDecl->get_type(), baseDecl->get_type(), dummy ) ) return memberExpr; -// else return new CastExpr( memberExpr, memberDecl->get_type() ); -// } - - void Instantiate::doBeginScope() { - DeclMutator::doBeginScope(); - instantiations.beginScope(); - } - - void Instantiate::doEndScope() { - DeclMutator::doEndScope(); - instantiations.endScope(); - } - -} // namespace GenPoly - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/InstantiateGeneric.h =================================================================== --- src/GenPoly/InstantiateGeneric.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,33 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// InstantiateGeneric.h -- -// -// Author : Aaron B. Moss -// Created On : Wed Nov 11 14:55:01 2015 -// Last Modified By : Aaron B. Moss -// Last Modified On : Wed Nov 11 14:55:01 2015 -// Update Count : 1 -// - -#ifndef _INSTANTIATEGENERIC_H -#define _INSTANTIATEGENERIC_H - -#include -#include "SynTree/SynTree.h" - -namespace GenPoly { - /// Replaces generic structs used outside polymorphic contexts with their concrete instantiations - void instantiateGeneric( std::list< Declaration* >& translationUnit ); -} // namespace GenPoly - -#endif // _INSTANTIATEGENERIC_H - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/Lvalue.cc =================================================================== --- src/GenPoly/Lvalue.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/Lvalue.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -17,4 +17,6 @@ #include "Lvalue.h" + +#include "GenPoly.h" #include "SynTree/Declaration.h" @@ -63,10 +65,8 @@ namespace { - bool isLvalueRet( FunctionType *function ) { - if ( ! function->get_returnVals().empty() ) { - return function->get_returnVals().front()->get_type()->get_isLvalue(); - } else { - return false; - } // if + Type* isLvalueRet( FunctionType *function ) { + if ( function->get_returnVals().empty() ) return 0; + Type *ty = function->get_returnVals().front()->get_type(); + return ty->get_isLvalue() ? ty : 0; } @@ -107,10 +107,16 @@ assert( function ); - std::string typeName; - if ( isLvalueRet( function ) && ! isIntrinsicApp( appExpr ) ) { + Type *funType = isLvalueRet( function ); + if ( funType && ! isIntrinsicApp( appExpr ) ) { + Expression *expr = appExpr; + Type *appType = appExpr->get_results().front(); + if ( isPolyType( funType ) && ! isPolyType( appType ) ) { + // make sure cast for polymorphic type is inside dereference + expr = new CastExpr( appExpr, new PointerType( Type::Qualifiers(), appType->clone() ) ); + } UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); - deref->get_results().push_back( appExpr->get_results().front() ); - appExpr->get_results().front() = new PointerType( Type::Qualifiers(), deref->get_results().front()->clone() ); - deref->get_args().push_back( appExpr ); + deref->get_results().push_back( appType->clone() ); + appExpr->get_results().front() = new PointerType( Type::Qualifiers(), appType ); + deref->get_args().push_back( expr ); return deref; } else { Index: src/GenPoly/PolyMutator.cc =================================================================== --- src/GenPoly/PolyMutator.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/PolyMutator.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -27,6 +27,5 @@ } - PolyMutator::PolyMutator() : env( 0 ) { - } + PolyMutator::PolyMutator() : scopeTyVars( (TypeDecl::Kind)-1 ), env( 0 ) {} void PolyMutator::mutateStatementList( std::list< Statement* > &statements ) { Index: src/GenPoly/ScopedMap.h =================================================================== --- src/GenPoly/ScopedMap.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/ScopedMap.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -17,4 +17,5 @@ #define _SCOPEDMAP_H +#include #include #include @@ -50,4 +51,21 @@ typedef typename scope_list::size_type size_type; + /// Checks if this iterator points to a valid item + bool is_valid() const { + return it != (*scopes)[i].end(); + } + + /// Increments on invalid + iterator& next_valid() { + if ( ! is_valid() ) { ++(*this); } + return *this; + } + + /// Decrements on invalid + iterator& prev_valid() { + if ( ! is_valid() ) { --(*this); } + return *this; + } + iterator(scope_list const &_scopes, const wrapped_iterator &_it, size_type _i) : scopes(&_scopes), it(_it), i(_i) {} @@ -67,8 +85,8 @@ --i; it = (*scopes)[i].begin(); - return *this; - } - ++it; - return *this; + } else { + ++it; + } + return next_valid(); } iterator& operator++ (int) { iterator tmp = *this; ++(*this); return tmp; } @@ -81,5 +99,5 @@ } --it; - return *this; + return prev_valid(); } iterator& operator-- (int) { iterator tmp = *this; --(*this); return tmp; } @@ -104,4 +122,21 @@ typedef typename scope_list::size_type size_type; + /// Checks if this iterator points to a valid item + bool is_valid() const { + return it != (*scopes)[i].end(); + } + + /// Increments on invalid + const_iterator& next_valid() { + if ( ! is_valid() ) { ++(*this); } + return *this; + } + + /// Decrements on invalid + const_iterator& prev_valid() { + if ( ! is_valid() ) { --(*this); } + return *this; + } + const_iterator(scope_list const &_scopes, const wrapped_const_iterator &_it, size_type _i) : scopes(&_scopes), it(_it), i(_i) {} @@ -126,8 +161,8 @@ --i; it = (*scopes)[i].begin(); - return *this; - } - ++it; - return *this; + } else { + ++it; + } + return next_valid(); } const_iterator& operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; } @@ -140,5 +175,5 @@ } --it; - return *this; + return prev_valid(); } const_iterator& operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; } @@ -164,4 +199,5 @@ void endScope() { scopes.pop_back(); + assert( ! scopes.empty() ); } @@ -169,7 +205,7 @@ ScopedMap() { beginScope(); } - iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1); } - const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1); } - const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1); } + iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); } + const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); } + const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); } iterator end() { return iterator(scopes, scopes[0].end(), 0); } const_iterator end() const { return const_iterator(scopes, scopes[0].end(), 0); } @@ -188,5 +224,7 @@ return end(); } - const_iterator find( const Key &key ) const { return const_iterator( find( key ) ); } + const_iterator find( const Key &key ) const { + return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->find( key ) ); + } /// Finds the given key in the outermost scope inside the given scope where it occurs @@ -200,5 +238,7 @@ return end(); } - const_iterator findNext( const_iterator &it, const Key &key ) const { return const_iterator( findNext( it, key ) ); } + const_iterator findNext( const_iterator &it, const Key &key ) const { + return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findNext( it, key ) ); + } /// Inserts the given key-value pair into the outermost scope @@ -208,5 +248,10 @@ } std::pair< iterator, bool > insert( const Key &key, const Value &value ) { return insert( std::make_pair( key, value ) ); } - + + Value& operator[] ( const Key &key ) { + iterator slot = find( key ); + if ( slot != end() ) return slot->second; + return insert( key, Value() ).first->second; + } }; } // namespace GenPoly Index: src/GenPoly/ScopedSet.h =================================================================== --- src/GenPoly/ScopedSet.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) +++ src/GenPoly/ScopedSet.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -0,0 +1,255 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ScopedSet.h -- +// +// Author : Aaron B. Moss +// Created On : Thu Dec 3 11:51:00 2015 +// Last Modified By : Aaron B. Moss +// Last Modified On : Thu Dec 3 11:51:00 2015 +// Update Count : 1 +// + +#ifndef _SCOPEDSET_H +#define _SCOPEDSET_H + +#include +#include +#include + +namespace GenPoly { + /// A set where the items are placed into nested scopes; + /// inserted items are placed into the innermost scope, lookup looks from the innermost scope outward + template + class ScopedSet { + typedef std::set< Value > Scope; + typedef std::vector< Scope > ScopeList; + + ScopeList scopes; ///< scoped list of sets + public: + typedef typename Scope::key_type key_type; + typedef typename Scope::value_type value_type; + typedef typename ScopeList::size_type size_type; + typedef typename ScopeList::difference_type difference_type; + typedef typename Scope::reference reference; + typedef typename Scope::const_reference const_reference; + typedef typename Scope::pointer pointer; + typedef typename Scope::const_pointer const_pointer; + + class iterator : public std::iterator< std::bidirectional_iterator_tag, + value_type > { + friend class ScopedSet; + friend class const_iterator; + typedef typename std::set< Value >::iterator wrapped_iterator; + typedef typename std::vector< std::set< Value > > scope_list; + typedef typename scope_list::size_type size_type; + + /// Checks if this iterator points to a valid item + bool is_valid() const { + return it != (*scopes)[i].end(); + } + + /// Increments on invalid + iterator& next_valid() { + if ( ! is_valid() ) { ++(*this); } + return *this; + } + + /// Decrements on invalid + iterator& prev_valid() { + if ( ! is_valid() ) { --(*this); } + return *this; + } + + iterator(scope_list const &_scopes, const wrapped_iterator &_it, size_type _i) + : scopes(&_scopes), it(_it), i(_i) {} + public: + iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {} + iterator& operator= (const iterator &that) { + scopes = that.scopes; i = that.i; it = that.it; + return *this; + } + + reference operator* () { return *it; } + pointer operator-> () { return it.operator->(); } + + iterator& operator++ () { + if ( it == (*scopes)[i].end() ) { + if ( i == 0 ) return *this; + --i; + it = (*scopes)[i].begin(); + } else { + ++it; + } + return next_valid(); + } + iterator& operator++ (int) { iterator tmp = *this; ++(*this); return tmp; } + + iterator& operator-- () { + // may fail if this is the begin iterator; allowed by STL spec + if ( it == (*scopes)[i].begin() ) { + ++i; + it = (*scopes)[i].end(); + } + --it; + return prev_valid(); + } + iterator& operator-- (int) { iterator tmp = *this; --(*this); return tmp; } + + bool operator== (const iterator &that) { + return scopes == that.scopes && i == that.i && it == that.it; + } + bool operator!= (const iterator &that) { return !( *this == that ); } + + private: + scope_list const *scopes; + wrapped_iterator it; + size_type i; + }; + + class const_iterator : public std::iterator< std::bidirectional_iterator_tag, + value_type > { + friend class ScopedSet; + typedef typename std::set< Value >::iterator wrapped_iterator; + typedef typename std::set< Value >::const_iterator wrapped_const_iterator; + typedef typename std::vector< std::set< Value > > scope_list; + typedef typename scope_list::size_type size_type; + + /// Checks if this iterator points to a valid item + bool is_valid() const { + return it != (*scopes)[i].end(); + } + + /// Increments on invalid + const_iterator& next_valid() { + if ( ! is_valid() ) { ++(*this); } + return *this; + } + + /// Decrements on invalid + const_iterator& prev_valid() { + if ( ! is_valid() ) { --(*this); } + return *this; + } + + const_iterator(scope_list const &_scopes, const wrapped_const_iterator &_it, size_type _i) + : scopes(&_scopes), it(_it), i(_i) {} + public: + const_iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {} + const_iterator(const const_iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {} + const_iterator& operator= (const iterator &that) { + scopes = that.scopes; i = that.i; it = that.it; + return *this; + } + const_iterator& operator= (const const_iterator &that) { + scopes = that.scopes; i = that.i; it = that.it; + return *this; + } + + const_reference operator* () { return *it; } + const_pointer operator-> () { return it.operator->(); } + + const_iterator& operator++ () { + if ( it == (*scopes)[i].end() ) { + if ( i == 0 ) return *this; + --i; + it = (*scopes)[i].begin(); + } else { + ++it; + } + return next_valid(); + } + const_iterator& operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; } + + const_iterator& operator-- () { + // may fail if this is the begin iterator; allowed by STL spec + if ( it == (*scopes)[i].begin() ) { + ++i; + it = (*scopes)[i].end(); + } + --it; + return prev_valid(); + } + const_iterator& operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; } + + bool operator== (const const_iterator &that) { + return scopes == that.scopes && i == that.i && it == that.it; + } + bool operator!= (const const_iterator &that) { return !( *this == that ); } + + private: + scope_list const *scopes; + wrapped_const_iterator it; + size_type i; + }; + + /// Starts a new scope + void beginScope() { + Scope scope; + scopes.push_back(scope); + } + + /// Ends a scope; invalidates any iterators pointing to elements of that scope + void endScope() { + scopes.pop_back(); + } + + /// Default constructor initializes with one scope + ScopedSet() { beginScope(); } + + iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); } + const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); } + const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); } + iterator end() { return iterator(scopes, scopes[0].end(), 0); } + const_iterator end() const { return const_iterator(scopes, scopes[0].end(), 0); } + const_iterator cend() const { return const_iterator(scopes, scopes[0].end(), 0); } + + /// Gets the index of the current scope (counted from 1) + size_type currentScope() const { return scopes.size(); } + + /// Finds the given key in the outermost scope it occurs; returns end() for none such + iterator find( const Value &key ) { + for ( size_type i = scopes.size() - 1; ; --i ) { + typename Scope::iterator val = scopes[i].find( key ); + if ( val != scopes[i].end() ) return iterator( scopes, val, i ); + if ( i == 0 ) break; + } + return end(); + } + const_iterator find( const Value &key ) const { + return const_iterator( const_cast< ScopedSet< Value >* >(this)->find( key ) ); + } + + /// Finds the given key in the outermost scope inside the given scope where it occurs + iterator findNext( const_iterator &it, const Value &key ) { + if ( it.i == 0 ) return end(); + for ( size_type i = it.i - 1; ; --i ) { + typename Scope::iterator val = scopes[i].find( key ); + if ( val != scopes[i].end() ) return iterator( scopes, val, i ); + if ( i == 0 ) break; + } + return end(); + } + const_iterator findNext( const_iterator &it, const Value &key ) const { + return const_iterator( const_cast< ScopedSet< Value >* >(this)->findNext( it, key ) ); + } + + /// Inserts the given value into the outermost scope + std::pair< iterator, bool > insert( const value_type &value ) { + std::pair< typename Scope::iterator, bool > res = scopes.back().insert( value ); + return std::make_pair( iterator(scopes, res.first, scopes.size()-1), res.second ); + } + + }; +} // namespace GenPoly + +#endif // _SCOPEDSET_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/GenPoly/ScrubTyVars.cc =================================================================== --- src/GenPoly/ScrubTyVars.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/ScrubTyVars.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -64,5 +64,5 @@ // sizeof( T ) => _sizeof_T parameter, which is the size of T if ( Type *polyType = isPolyType( szeof->get_type() ) ) { - Expression *expr = new NameExpr( sizeofName( polyType ) ); + Expression *expr = new NameExpr( sizeofName( mangleType( polyType ) ) ); return expr; } else { @@ -74,5 +74,5 @@ // alignof( T ) => _alignof_T parameter, which is the alignment of T if ( Type *polyType = isPolyType( algnof->get_type() ) ) { - Expression *expr = new NameExpr( alignofName( polyType ) ); + Expression *expr = new NameExpr( alignofName( mangleType( polyType ) ) ); return expr; } else { Index: src/GenPoly/module.mk =================================================================== --- src/GenPoly/module.mk (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/GenPoly/module.mk (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -23,4 +23,3 @@ GenPoly/CopyParams.cc \ GenPoly/FindFunction.cc \ - GenPoly/InstantiateGeneric.cc \ GenPoly/DeclMutator.cc Index: src/InitTweak/InitModel.h =================================================================== --- src/InitTweak/InitModel.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/InitTweak/InitModel.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -75,4 +75,5 @@ void visit( UntypedOffsetofExpr * ) { throw 0; } void visit( OffsetofExpr * ) { throw 0; } + void visit( OffsetPackExpr * ) { throw 0; } void visit( AttrExpr * ) { throw 0; } void visit( LogicalExpr * ) { throw 0; } Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Makefile.am (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -11,6 +11,6 @@ ## Created On : Sun May 31 08:51:46 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Thu Jan 28 16:50:26 2016 -## Update Count : 55 +## Last Modified On : Fri Feb 26 17:19:16 2016 +## Update Count : 57 ############################################################################### @@ -46,5 +46,5 @@ driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -CXXFLAGS = -g # remove default -O2 to allow better debugging +CXXFLAGS = -g -std=c++11 # remove default -O2 to allow better debugging MAINTAINERCLEANFILES += ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}} Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Makefile.in (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -122,5 +122,4 @@ GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT) \ GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \ - GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \ GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \ InitTweak/driver_cfa_cpp-RemoveInit.$(OBJEXT) \ @@ -154,5 +153,4 @@ ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) \ ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \ - SymTab/driver_cfa_cpp-IdTable.$(OBJEXT) \ SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \ SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \ @@ -171,4 +169,5 @@ SynTree/driver_cfa_cpp-TypeofType.$(OBJEXT) \ SynTree/driver_cfa_cpp-AttrType.$(OBJEXT) \ + SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT) \ SynTree/driver_cfa_cpp-Constant.$(OBJEXT) \ SynTree/driver_cfa_cpp-Expression.$(OBJEXT) \ @@ -191,5 +190,4 @@ SynTree/driver_cfa_cpp-Visitor.$(OBJEXT) \ SynTree/driver_cfa_cpp-Mutator.$(OBJEXT) \ - SynTree/driver_cfa_cpp-CodeGenVisitor.$(OBJEXT) \ SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \ Tuples/driver_cfa_cpp-Mutate.$(OBJEXT) \ @@ -247,5 +245,5 @@ CXX = @CXX@ CXXDEPMODE = @CXXDEPMODE@ -CXXFLAGS = -g # remove default -O2 to allow better debugging +CXXFLAGS = -g -std=c++11 # remove default -O2 to allow better debugging CYGPATH_W = @CYGPATH_W@ DEFS = @DEFS@ @@ -347,11 +345,10 @@ GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \ GenPoly/CopyParams.cc GenPoly/FindFunction.cc \ - GenPoly/InstantiateGeneric.cc GenPoly/DeclMutator.cc \ - InitTweak/RemoveInit.cc Parser/parser.yy Parser/lex.ll \ - Parser/TypedefTable.cc Parser/ParseNode.cc \ - Parser/DeclarationNode.cc Parser/ExpressionNode.cc \ - Parser/StatementNode.cc Parser/InitializerNode.cc \ - Parser/TypeData.cc Parser/LinkageSpec.cc \ - Parser/parseutility.cc Parser/Parser.cc \ + GenPoly/DeclMutator.cc InitTweak/RemoveInit.cc \ + Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \ + Parser/ParseNode.cc Parser/DeclarationNode.cc \ + Parser/ExpressionNode.cc Parser/StatementNode.cc \ + Parser/InitializerNode.cc Parser/TypeData.cc \ + Parser/LinkageSpec.cc Parser/parseutility.cc Parser/Parser.cc \ ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \ ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \ @@ -362,12 +359,12 @@ ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \ ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \ - ResolvExpr/TypeEnvironment.cc SymTab/IdTable.cc \ - SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \ - SymTab/FixFunction.cc SymTab/ImplementationType.cc \ - SymTab/TypeEquality.cc SynTree/Type.cc SynTree/VoidType.cc \ - SynTree/BasicType.cc SynTree/PointerType.cc \ - SynTree/ArrayType.cc SynTree/FunctionType.cc \ - SynTree/ReferenceToType.cc SynTree/TupleType.cc \ - SynTree/TypeofType.cc SynTree/AttrType.cc SynTree/Constant.cc \ + ResolvExpr/TypeEnvironment.cc SymTab/Indexer.cc \ + SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \ + SymTab/ImplementationType.cc SymTab/TypeEquality.cc \ + SynTree/Type.cc SynTree/VoidType.cc SynTree/BasicType.cc \ + SynTree/PointerType.cc SynTree/ArrayType.cc \ + SynTree/FunctionType.cc SynTree/ReferenceToType.cc \ + SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \ + SynTree/VarArgsType.cc SynTree/Constant.cc \ SynTree/Expression.cc SynTree/TupleExpr.cc \ SynTree/CommaExpr.cc SynTree/TypeExpr.cc \ @@ -379,8 +376,8 @@ SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \ SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \ - SynTree/CodeGenVisitor.cc SynTree/TypeSubstitution.cc \ - Tuples/Mutate.cc Tuples/AssignExpand.cc \ - Tuples/FunctionFixer.cc Tuples/TupleAssignment.cc \ - Tuples/FunctionChecker.cc Tuples/NameMatcher.cc + SynTree/TypeSubstitution.cc Tuples/Mutate.cc \ + Tuples/AssignExpand.cc Tuples/FunctionFixer.cc \ + Tuples/TupleAssignment.cc Tuples/FunctionChecker.cc \ + Tuples/NameMatcher.cc MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \ ${cfa_cpplib_PROGRAMS}} @@ -410,7 +407,7 @@ esac; \ done; \ - echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/Makefile'; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \ $(am__cd) $(top_srcdir) && \ - $(AUTOMAKE) --gnu src/Makefile + $(AUTOMAKE) --foreign src/Makefile .PRECIOUS: Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @@ -555,6 +552,4 @@ GenPoly/$(DEPDIR)/$(am__dirstamp) GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT): \ - GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp) -GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT): \ GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp) GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \ @@ -663,6 +658,4 @@ @$(MKDIR_P) SymTab/$(DEPDIR) @: > SymTab/$(DEPDIR)/$(am__dirstamp) -SymTab/driver_cfa_cpp-IdTable.$(OBJEXT): SymTab/$(am__dirstamp) \ - SymTab/$(DEPDIR)/$(am__dirstamp) SymTab/driver_cfa_cpp-Indexer.$(OBJEXT): SymTab/$(am__dirstamp) \ SymTab/$(DEPDIR)/$(am__dirstamp) @@ -702,4 +695,6 @@ SynTree/$(DEPDIR)/$(am__dirstamp) SynTree/driver_cfa_cpp-AttrType.$(OBJEXT): SynTree/$(am__dirstamp) \ + SynTree/$(DEPDIR)/$(am__dirstamp) +SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \ SynTree/$(DEPDIR)/$(am__dirstamp) SynTree/driver_cfa_cpp-Constant.$(OBJEXT): SynTree/$(am__dirstamp) \ @@ -743,6 +738,4 @@ SynTree/driver_cfa_cpp-Mutator.$(OBJEXT): SynTree/$(am__dirstamp) \ SynTree/$(DEPDIR)/$(am__dirstamp) -SynTree/driver_cfa_cpp-CodeGenVisitor.$(OBJEXT): \ - SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp) SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT): \ SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp) @@ -795,5 +788,4 @@ -rm -f GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) -rm -f GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) - -rm -f GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) -rm -f GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT) -rm -f GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT) @@ -831,5 +823,4 @@ -rm -f ResolvExpr/driver_cfa_cpp-Unify.$(OBJEXT) -rm -f SymTab/driver_cfa_cpp-FixFunction.$(OBJEXT) - -rm -f SymTab/driver_cfa_cpp-IdTable.$(OBJEXT) -rm -f SymTab/driver_cfa_cpp-ImplementationType.$(OBJEXT) -rm -f SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) @@ -843,5 +834,4 @@ -rm -f SynTree/driver_cfa_cpp-AttrType.$(OBJEXT) -rm -f SynTree/driver_cfa_cpp-BasicType.$(OBJEXT) - -rm -f SynTree/driver_cfa_cpp-CodeGenVisitor.$(OBJEXT) -rm -f SynTree/driver_cfa_cpp-CommaExpr.$(OBJEXT) -rm -f SynTree/driver_cfa_cpp-CompoundStmt.$(OBJEXT) @@ -867,4 +857,5 @@ -rm -f SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) -rm -f SynTree/driver_cfa_cpp-TypeofType.$(OBJEXT) + -rm -f SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT) -rm -f SynTree/driver_cfa_cpp-Visitor.$(OBJEXT) -rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT) @@ -902,5 +893,4 @@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@ @@ -938,5 +928,4 @@ @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Unify.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-FixFunction.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Po@am__quote@ @@ -950,5 +939,4 @@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AttrType.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-BasicType.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-CodeGenVisitor.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-CommaExpr.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-CompoundStmt.Po@am__quote@ @@ -974,4 +962,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TypeSubstitution.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TypeofType.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Visitor.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@ @@ -1363,18 +1352,4 @@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-FindFunction.obj `if test -f 'GenPoly/FindFunction.cc'; then $(CYGPATH_W) 'GenPoly/FindFunction.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/FindFunction.cc'; fi` -GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc -@am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc -@am__fastdepCXX_TRUE@ $(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='GenPoly/InstantiateGeneric.cc' object='GenPoly/driver_cfa_cpp-InstantiateGeneric.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc - -GenPoly/driver_cfa_cpp-InstantiateGeneric.obj: GenPoly/InstantiateGeneric.cc -@am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.obj `if test -f 'GenPoly/InstantiateGeneric.cc'; then $(CYGPATH_W) 'GenPoly/InstantiateGeneric.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/InstantiateGeneric.cc'; fi` -@am__fastdepCXX_TRUE@ $(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='GenPoly/InstantiateGeneric.cc' object='GenPoly/driver_cfa_cpp-InstantiateGeneric.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.obj `if test -f 'GenPoly/InstantiateGeneric.cc'; then $(CYGPATH_W) 'GenPoly/InstantiateGeneric.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/InstantiateGeneric.cc'; fi` - GenPoly/driver_cfa_cpp-DeclMutator.o: GenPoly/DeclMutator.cc @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc @@ -1811,18 +1786,4 @@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-TypeEnvironment.obj `if test -f 'ResolvExpr/TypeEnvironment.cc'; then $(CYGPATH_W) 'ResolvExpr/TypeEnvironment.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/TypeEnvironment.cc'; fi` -SymTab/driver_cfa_cpp-IdTable.o: SymTab/IdTable.cc -@am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-IdTable.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Tpo -c -o SymTab/driver_cfa_cpp-IdTable.o `test -f 'SymTab/IdTable.cc' || echo '$(srcdir)/'`SymTab/IdTable.cc -@am__fastdepCXX_TRUE@ $(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='SymTab/IdTable.cc' object='SymTab/driver_cfa_cpp-IdTable.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-IdTable.o `test -f 'SymTab/IdTable.cc' || echo '$(srcdir)/'`SymTab/IdTable.cc - -SymTab/driver_cfa_cpp-IdTable.obj: SymTab/IdTable.cc -@am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-IdTable.obj -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Tpo -c -o SymTab/driver_cfa_cpp-IdTable.obj `if test -f 'SymTab/IdTable.cc'; then $(CYGPATH_W) 'SymTab/IdTable.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/IdTable.cc'; fi` -@am__fastdepCXX_TRUE@ $(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='SymTab/IdTable.cc' object='SymTab/driver_cfa_cpp-IdTable.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-IdTable.obj `if test -f 'SymTab/IdTable.cc'; then $(CYGPATH_W) 'SymTab/IdTable.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/IdTable.cc'; fi` - SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.cc @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-Indexer.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Tpo -c -o SymTab/driver_cfa_cpp-Indexer.o `test -f 'SymTab/Indexer.cc' || echo '$(srcdir)/'`SymTab/Indexer.cc @@ -2049,4 +2010,18 @@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AttrType.obj `if test -f 'SynTree/AttrType.cc'; then $(CYGPATH_W) 'SynTree/AttrType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AttrType.cc'; fi` +SynTree/driver_cfa_cpp-VarArgsType.o: SynTree/VarArgsType.cc +@am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarArgsType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Tpo -c -o SynTree/driver_cfa_cpp-VarArgsType.o `test -f 'SynTree/VarArgsType.cc' || echo '$(srcdir)/'`SynTree/VarArgsType.cc +@am__fastdepCXX_TRUE@ $(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='SynTree/VarArgsType.cc' object='SynTree/driver_cfa_cpp-VarArgsType.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarArgsType.o `test -f 'SynTree/VarArgsType.cc' || echo '$(srcdir)/'`SynTree/VarArgsType.cc + +SynTree/driver_cfa_cpp-VarArgsType.obj: SynTree/VarArgsType.cc +@am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarArgsType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Tpo -c -o SynTree/driver_cfa_cpp-VarArgsType.obj `if test -f 'SynTree/VarArgsType.cc'; then $(CYGPATH_W) 'SynTree/VarArgsType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarArgsType.cc'; fi` +@am__fastdepCXX_TRUE@ $(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='SynTree/VarArgsType.cc' object='SynTree/driver_cfa_cpp-VarArgsType.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarArgsType.obj `if test -f 'SynTree/VarArgsType.cc'; then $(CYGPATH_W) 'SynTree/VarArgsType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarArgsType.cc'; fi` + SynTree/driver_cfa_cpp-Constant.o: SynTree/Constant.cc @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-Constant.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-Constant.Tpo -c -o SynTree/driver_cfa_cpp-Constant.o `test -f 'SynTree/Constant.cc' || echo '$(srcdir)/'`SynTree/Constant.cc @@ -2328,18 +2303,4 @@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Mutator.obj `if test -f 'SynTree/Mutator.cc'; then $(CYGPATH_W) 'SynTree/Mutator.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Mutator.cc'; fi` - -SynTree/driver_cfa_cpp-CodeGenVisitor.o: SynTree/CodeGenVisitor.cc -@am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-CodeGenVisitor.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-CodeGenVisitor.Tpo -c -o SynTree/driver_cfa_cpp-CodeGenVisitor.o `test -f 'SynTree/CodeGenVisitor.cc' || echo '$(srcdir)/'`SynTree/CodeGenVisitor.cc -@am__fastdepCXX_TRUE@ $(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-CodeGenVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-CodeGenVisitor.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='SynTree/CodeGenVisitor.cc' object='SynTree/driver_cfa_cpp-CodeGenVisitor.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-CodeGenVisitor.o `test -f 'SynTree/CodeGenVisitor.cc' || echo '$(srcdir)/'`SynTree/CodeGenVisitor.cc - -SynTree/driver_cfa_cpp-CodeGenVisitor.obj: SynTree/CodeGenVisitor.cc -@am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-CodeGenVisitor.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-CodeGenVisitor.Tpo -c -o SynTree/driver_cfa_cpp-CodeGenVisitor.obj `if test -f 'SynTree/CodeGenVisitor.cc'; then $(CYGPATH_W) 'SynTree/CodeGenVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/CodeGenVisitor.cc'; fi` -@am__fastdepCXX_TRUE@ $(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-CodeGenVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-CodeGenVisitor.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='SynTree/CodeGenVisitor.cc' object='SynTree/driver_cfa_cpp-CodeGenVisitor.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-CodeGenVisitor.obj `if test -f 'SynTree/CodeGenVisitor.cc'; then $(CYGPATH_W) 'SynTree/CodeGenVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/CodeGenVisitor.cc'; fi` SynTree/driver_cfa_cpp-TypeSubstitution.o: SynTree/TypeSubstitution.cc Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/DeclarationNode.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 14 14:46:32 2015 -// Update Count : 126 +// Last Modified On : Wed Apr 13 16:53:17 2016 +// Update Count : 161 // @@ -34,12 +34,13 @@ const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "" }; const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" }; -const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary" }; +const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary", }; const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" }; const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" }; const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" }; +const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" }; UniqueName DeclarationNode::anonymous( "__anonymous" ); -extern LinkageSpec::Type linkage; /* defined in cfa.y */ +extern LinkageSpec::Type linkage; // defined in parser.yy DeclarationNode *DeclarationNode::clone() const { @@ -54,5 +55,5 @@ newnode->linkage = linkage; return newnode; -} +} // DeclarationNode::clone DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) { @@ -116,4 +117,5 @@ newnode->type->function->newStyle = newStyle; newnode->type->function->body = body; + typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID ); if ( body ) { @@ -128,5 +130,5 @@ return newnode; -} +} // DeclarationNode::newFunction DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) { @@ -135,5 +137,5 @@ newnode->type->qualifiers.push_back( q ); return newnode; -} +} // DeclarationNode::newQualifier DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { @@ -141,5 +143,5 @@ newnode->storageClasses.push_back( sc ); return newnode; -} +} // DeclarationNode::newStorageClass DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) { @@ -148,5 +150,12 @@ newnode->type->basic->typeSpec.push_back( bt ); return newnode; -} +} // DeclarationNode::newBasicType + +DeclarationNode *DeclarationNode::newBuiltinType( BuiltinType bt ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Builtin ); + newnode->type->builtin->type = bt; + return newnode; +} // DeclarationNode::newBuiltinType DeclarationNode *DeclarationNode::newModifier( Modifier mod ) { @@ -155,5 +164,5 @@ newnode->type->basic->modifiers.push_back( mod ); return newnode; -} +} // DeclarationNode::newModifier DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) { @@ -162,5 +171,5 @@ newnode->type->forall = forall; return newnode; -} +} // DeclarationNode::newForall DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) { @@ -171,5 +180,5 @@ newnode->type->symbolic->params = 0; return newnode; -} +} // DeclarationNode::newFromTypedef DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields ) { @@ -179,17 +188,10 @@ newnode->type->aggregate->name = assign_strptr( name ); if ( newnode->type->aggregate->name == "" ) { // anonymous aggregate ? - newnode->type->aggregate->name = DeclarationNode::anonymous.newName(); - } else { - // SKULLDUGGERY: generate a typedef for the aggregate name so that the aggregate does not have to be qualified - // by "struct" - typedefTable.addToEnclosingScope( newnode->type->aggregate->name, TypedefTable::TD ); - DeclarationNode *typedf = new DeclarationNode; - typedf->name = newnode->type->aggregate->name; - newnode->appendList( typedf->addType( newnode->clone() )->addTypedef() ); + newnode->type->aggregate->name = anonymous.newName(); } // if newnode->type->aggregate->actuals = actuals; newnode->type->aggregate->fields = fields; return newnode; -} +} // DeclarationNode::newAggregate DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) { @@ -200,22 +202,16 @@ if ( newnode->type->enumeration->name == "" ) { // anonymous enumeration ? newnode->type->enumeration->name = DeclarationNode::anonymous.newName(); - } else { - // SKULLDUGGERY: generate a typedef for the enumeration name so that the enumeration does not have to be - // qualified by "enum" - typedefTable.addToEnclosingScope( newnode->type->enumeration->name, TypedefTable::TD ); - DeclarationNode *typedf = new DeclarationNode; - typedf->name = newnode->type->enumeration->name; - newnode->appendList( typedf->addType( newnode->clone() )->addTypedef() ); } // if newnode->type->enumeration->constants = constants; return newnode; -} +} // DeclarationNode::newEnum DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) { DeclarationNode *newnode = new DeclarationNode; newnode->name = assign_strptr( name ); - // do something with the constant - return newnode; -} + newnode->enumeratorValue = constant; + typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID ); + return newnode; +} // DeclarationNode::newEnumConstant DeclarationNode *DeclarationNode::newName( std::string *name ) { @@ -223,5 +219,5 @@ newnode->name = assign_strptr( name ); return newnode; -} +} // DeclarationNode::newName DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) { @@ -232,5 +228,5 @@ newnode->type->symbolic->actuals = params; return newnode; -} +} // DeclarationNode::newFromTypeGen DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) { @@ -241,25 +237,25 @@ newnode->type->variable->name = newnode->name; return newnode; -} - -DeclarationNode *DeclarationNode::newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) { +} // DeclarationNode::newTypeParam + +DeclarationNode *DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) { DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Aggregate ); - newnode->type->aggregate->kind = Context; + newnode->type->aggregate->kind = Trait; newnode->type->aggregate->params = params; newnode->type->aggregate->fields = asserts; newnode->type->aggregate->name = assign_strptr( name ); return newnode; -} - -DeclarationNode *DeclarationNode::newContextUse( std::string *name, ExpressionNode *params ) { +} // DeclarationNode::newTrait + +DeclarationNode *DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) { DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::AggregateInst ); newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate ); - newnode->type->aggInst->aggregate->aggregate->kind = Context; + newnode->type->aggInst->aggregate->aggregate->kind = Trait; newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name ); newnode->type->aggInst->params = params; return newnode; -} +} // DeclarationNode::newTraitUse DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) { @@ -271,5 +267,5 @@ newnode->type->symbolic->name = newnode->name; return newnode; -} +} // DeclarationNode::newTypeDecl DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) { @@ -277,5 +273,5 @@ newnode->type = new TypeData( TypeData::Pointer ); return newnode->addQualifiers( qualifiers ); -} +} // DeclarationNode::newPointer DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) { @@ -290,5 +286,5 @@ } // if return newnode->addQualifiers( qualifiers ); -} +} // DeclarationNode::newArray DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) { @@ -794,5 +790,5 @@ errors.append( e ); } // try - cur = dynamic_cast< DeclarationNode *>( cur->get_link() ); + cur = dynamic_cast( cur->get_link() ); } // while if ( ! errors.isEmpty() ) { @@ -881,6 +877,6 @@ ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name ); break; - case DeclarationNode::Context: - ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name ); + case DeclarationNode::Trait: + ret = new TraitInstType( type->buildQualifiers(), type->aggregate->name ); break; default: Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/ExpressionNode.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Feb 1 13:32:30 2016 -// Update Count : 271 +// Last Modified On : Fri Apr 8 15:43:05 2016 +// Update Count : 296 // @@ -22,6 +22,8 @@ #include "ParseNode.h" +#include "TypeData.h" #include "SynTree/Constant.h" #include "SynTree/Expression.h" +#include "SynTree/Declaration.h" #include "Common/UnimplementedError.h" #include "parseutility.h" @@ -487,8 +489,7 @@ args.front() = new AddressExpr( args.front() ); break; - default: - /* do nothing */ + default: // do nothing ; - } + } // switch switch ( op->get_type() ) { @@ -873,4 +874,54 @@ } + +CompoundLiteralNode::CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids ) : type( type ), kids( kids ) {} +CompoundLiteralNode::CompoundLiteralNode( const CompoundLiteralNode &other ) : ExpressionNode( other ), type( other.type ), kids( other.kids ) {} + +CompoundLiteralNode::~CompoundLiteralNode() { + delete kids; + delete type; +} + +CompoundLiteralNode *CompoundLiteralNode::clone() const { + return new CompoundLiteralNode( *this ); +} + +void CompoundLiteralNode::print( std::ostream &os, int indent ) const { + os << string( indent,' ' ) << "CompoundLiteralNode:" << endl; + + os << string( indent + 2, ' ' ) << "type:" << endl; + if ( type != 0 ) + type->print( os, indent + 4 ); + + os << string( indent + 2, ' ' ) << "initialization:" << endl; + if ( kids != 0 ) + kids->printList( os, indent + 4 ); +} + +void CompoundLiteralNode::printOneLine( std::ostream &os, int indent ) const { + os << "( "; + if ( type ) type->print( os ); + os << ", "; + if ( kids ) kids->printOneLine( os ); + os << ") "; +} + +Expression *CompoundLiteralNode::build() const { + Declaration * newDecl = type->build(); // compound literal type + if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type + return new CompoundLiteralExpr( newDeclWithType->get_type(), kids->build() ); + // these types do not have associated type information + } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl ) ) { + return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), kids->build() ); + } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl ) ) { + return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), kids->build() ); + } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl ) ) { + return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), kids->build() ); + } else { + assert( false ); + } // if +} + + ExpressionNode *flattenCommas( ExpressionNode *list ) { if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) { Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/ParseNode.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// ParseNode.h -- +// ParseNode.h -- // // Author : Rodolfo G. Esteves // Created On : Sat May 16 13:28:16 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon Feb 1 13:32:32 2016 -// Update Count : 184 +// Last Modified By : Rob Schluntz +// Last Modified On : Mon Apr 11 11:50:52 2016 +// Update Count : 205 // @@ -108,5 +108,5 @@ ConstantNode( Type, std::string * ); - ConstantNode( const ConstantNode &other ) : value( *new std::string( other.value ) ) {}; + ConstantNode( const ConstantNode &other ) : type( other.type ), btype( other.btype), value( *new std::string( other.value ) ) {}; ~ConstantNode() { delete &value; } @@ -177,8 +177,8 @@ enum Type { TupleC, Comma, TupleFieldSel, // n-adic // triadic - Cond, NCond, + Cond, NCond, // diadic - SizeOf, AlignOf, OffsetOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, - BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, + SizeOf, AlignOf, OffsetOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, + BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn, Index, FieldSel, PFieldSel, Range, @@ -309,5 +309,5 @@ ValofExprNode( const ValofExprNode &other ); ~ValofExprNode(); - + virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); } @@ -329,8 +329,9 @@ enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary }; enum Modifier { Signed, Unsigned, Short, Long }; - enum Aggregate { Struct, Union, Context }; + enum Aggregate { Struct, Union, Trait }; enum TypeClass { Type, Dtype, Ftype }; - - static const char *storageName[]; + enum BuiltinType { Valist }; + + static const char *storageName[]; static const char *qualifierName[]; static const char *basicTypeName[]; @@ -338,4 +339,5 @@ static const char *aggregateName[]; static const char *typeClassName[]; + static const char *builtinTypeName[]; static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false ); @@ -352,6 +354,6 @@ static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params ); static DeclarationNode *newTypeParam( TypeClass, std::string *); - static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ); - static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params ); + static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ); + static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params ); static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams ); static DeclarationNode *newPointer( DeclarationNode *qualifiers ); @@ -363,4 +365,5 @@ static DeclarationNode *newAttr( std::string *, ExpressionNode *expr ); static DeclarationNode *newAttr( std::string *, DeclarationNode *type ); + static DeclarationNode *newBuiltinType( BuiltinType ); DeclarationNode *addQualifiers( DeclarationNode *); @@ -401,4 +404,5 @@ LinkageSpec::Type get_linkage() const { return linkage; } DeclarationNode *extractAggregate() const; + ExpressionNode *get_enumeratorValue() const { return enumeratorValue; } DeclarationNode(); @@ -413,4 +417,5 @@ std::list< std::string > attributes; ExpressionNode *bitfieldWidth; + ExpressionNode *enumeratorValue; InitializerNode *initializer; bool hasEllipsis; @@ -422,5 +427,5 @@ class StatementNode : public ParseNode { public: - enum Type { Exp, If, Switch, Case, Default, Choose, Fallthru, + enum Type { Exp, If, Switch, Case, Default, Choose, Fallthru, While, Do, For, Goto, Continue, Break, Return, Throw, @@ -530,4 +535,27 @@ bool aggregate; ExpressionNode *designator; // may be list + InitializerNode *kids; +}; + +class CompoundLiteralNode : public ExpressionNode { + public: + CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids ); + CompoundLiteralNode( const CompoundLiteralNode &type ); + ~CompoundLiteralNode(); + + virtual CompoundLiteralNode *clone() const; + + DeclarationNode *get_type() const { return type; } + CompoundLiteralNode *set_type( DeclarationNode *t ) { type = t; return this; } + + InitializerNode *get_initializer() const { return kids; } + CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; } + + void print( std::ostream &, int indent = 0 ) const; + void printOneLine( std::ostream &, int indent = 0 ) const; + + virtual Expression *build() const; + private: + DeclarationNode *type; InitializerNode *kids; }; Index: src/Parser/Parser.cc =================================================================== --- src/Parser/Parser.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/Parser.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,12 +10,12 @@ // Created On : Sat May 16 14:54:28 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 31 23:45:19 2015 -// Update Count : 4 +// Last Modified On : Mon Mar 21 18:04:47 2016 +// Update Count : 5 // #include "Parser.h" -#include "TypedefTable.h" #include "lex.h" #include "parser.h" +#include "TypedefTable.h" // global variables in cfa.y Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/TypeData.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 14 14:57:23 2015 -// Update Count : 32 +// Last Modified On : Wed Mar 2 17:26:45 2016 +// Update Count : 49 // @@ -23,4 +23,5 @@ #include "SynTree/Expression.h" #include "SynTree/Statement.h" +#include "SynTree/Initializer.h" TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) { @@ -84,4 +85,7 @@ typeexpr->expr = 0; break; + case Builtin: + builtin = new Builtin_t; + break; case Attr: attr = new Attr_t; @@ -149,4 +153,7 @@ delete typeexpr->expr; delete typeexpr; + break; + case Builtin: + delete builtin; break; case Attr: @@ -221,4 +228,7 @@ newtype->typeexpr->expr = maybeClone( typeexpr->expr ); break; + case Builtin: + newtype->builtin->type = builtin->type; + break; case Attr: newtype->attr->expr = maybeClone( attr->expr ); @@ -396,4 +406,7 @@ attr->type->print( os, indent + 2 ); } // if + break; + case Builtin: + os << "gcc builtin type"; break; default: @@ -506,4 +519,6 @@ case Typeof: return buildTypeof(); + case Builtin: + return new VarArgsType( buildQualifiers() ); case Attr: return buildAttr(); @@ -805,6 +820,6 @@ buildForall( aggregate->params, at->get_parameters() ); break; - case DeclarationNode::Context: - at = new ContextDecl( aggregate->name ); + case DeclarationNode::Trait: + at = new TraitDecl( aggregate->name ); buildList( aggregate->params, at->get_parameters() ); break; @@ -845,6 +860,6 @@ ret = new UnionInstType( buildQualifiers(), aggInst->aggregate->aggregate->name ); break; - case DeclarationNode::Context: - ret = new ContextInstType( buildQualifiers(), aggInst->aggregate->aggregate->name ); + case DeclarationNode::Trait: + ret = new TraitInstType( buildQualifiers(), aggInst->aggregate->aggregate->name ); break; default: @@ -883,4 +898,11 @@ EnumDecl *ret = new EnumDecl( enumeration->name ); buildList( enumeration->constants, ret->get_members() ); + std::list< Declaration * >::iterator members = ret->get_members().begin(); + for ( const DeclarationNode *cur = enumeration->constants; cur != NULL; cur = dynamic_cast( cur->get_link() ), ++members ) { + if ( cur->get_enumeratorValue() != NULL ) { + ObjectDecl *member = dynamic_cast(*members); + member->set_init( new SingleInit( maybeBuild< Expression >( cur->get_enumeratorValue() ) ) ); + } // if + } // for return ret; } Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/TypeData.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Jan 14 23:31:15 2016 -// Update Count : 17 +// Last Modified On : Fri Feb 26 14:21:38 2016 +// Update Count : 19 // @@ -24,5 +24,5 @@ struct TypeData { enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst, - Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Attr } kind; + Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr } kind; TypeData( Kind k = Unknown ); @@ -98,4 +98,8 @@ }; + struct Builtin_t { + DeclarationNode::BuiltinType type; + }; + struct Attr_t { std::string name; @@ -116,4 +120,5 @@ Typeof_t * typeexpr; Attr_t * attr; + Builtin_t * builtin; }; Index: src/Parser/TypedefTable.cc =================================================================== --- src/Parser/TypedefTable.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/TypedefTable.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,12 +10,12 @@ // Created On : Sat May 16 15:20:13 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jun 26 07:30:16 2015 -// Update Count : 19 +// Last Modified On : Wed Apr 13 16:57:30 2016 +// Update Count : 24 // #include #include +#include #include "TypedefTable.h" -#include using namespace std; @@ -29,39 +29,34 @@ TypedefTable::TypedefTable() : currentScope( 0 ) {} +bool TypedefTable::exists( const string &identifier ) { + return table.count( identifier ) > 0; +} + +int TypedefTable::isKind( const string &identifier ) const { + tableType::const_iterator id_pos = table.find( identifier ); + // Name lookup defaults to identifier, and then the identifier's kind is set by the parser. + if ( id_pos == table.end() ) return IDENTIFIER; + return id_pos->second.begin()->kind; +} + void TypedefTable::changeKind( const string &identifier, kind_t kind ) { tableType::iterator id_pos = table.find( identifier ); - if ( id_pos == table.end() ) { - return; - } else { - (*((*id_pos ).second.begin())).kind = kind; - return; + if ( id_pos == table.end() ) return; + id_pos->second.begin()->kind = kind; +} + +// SKULLDUGGERY: Generate a typedef for the aggregate name so the aggregate does not have to be qualified by +// "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed +// if the name is explicitly used. +void TypedefTable::makeTypedef( const string &name ) { + if ( ! typedefTable.exists( name ) ) { + typedefTable.addToEnclosingScope( name, TypedefTable::TD ); } // if } -bool TypedefTable::isKind( const string &identifier, kind_t kind ) const { - tableType::const_iterator id_pos = table.find( identifier ); - if ( id_pos == table.end() ) { - return true; - } else { - return (*((*id_pos ).second.begin())).kind == kind; - } // if -} - -bool TypedefTable::isIdentifier( const string &identifier ) const { - return isKind( identifier, ID ); -} - -bool TypedefTable::isTypedef( const string &identifier ) const { - return isKind( identifier, TD ); -} - -bool TypedefTable::isTypegen( const string &identifier ) const { - return isKind( identifier, TG ); -} - void TypedefTable::addToScope( const std::string &identifier, kind_t kind, int scope ) { - if ( currentContext != "" && scope == contextScope ) { + if ( currentTrait != "" && scope == contextScope ) { DeferredEntry entry = { identifier, kind }; - contexts[currentContext].push_back( entry ); + contexts[currentTrait].push_back( entry ); } else { debugPrint( "Adding " << identifier << " as kind " << kind << " scope " << scope << " from scope " << currentScope << endl ); @@ -112,5 +107,5 @@ } -void TypedefTable::openContext( const std::string &contextName ) { +void TypedefTable::openTrait( const std::string &contextName ) { map< string, deferListType >::iterator i = contexts.find( contextName ); if ( i != contexts.end() ) { @@ -150,11 +145,11 @@ } -void TypedefTable::enterContext( const std::string &contextName ) { - currentContext = contextName; +void TypedefTable::enterTrait( const std::string &contextName ) { + currentTrait = contextName; contextScope = currentScope; } -void TypedefTable::leaveContext() { - currentContext = ""; +void TypedefTable::leaveTrait() { + currentTrait = ""; } Index: src/Parser/TypedefTable.h =================================================================== --- src/Parser/TypedefTable.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/TypedefTable.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:24:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Jun 25 22:52:15 2015 -// Update Count : 11 +// Last Modified On : Wed Apr 13 16:59:56 2016 +// Update Count : 27 // @@ -22,7 +22,10 @@ #include +#include "lex.h" +#include "parser.h" + class TypedefTable { public: - enum kind_t { ID, TD, TG }; + enum kind_t { ID = IDENTIFIER, TD = TYPEDEFname, TG = TYPEGENname }; private: struct Entry { @@ -40,5 +43,5 @@ int currentScope; - std::string currentContext; + std::string currentTrait; int contextScope; @@ -49,15 +52,14 @@ std::stack< std::string > nextIdentifiers; - bool isKind( const std::string &identifier, kind_t kind ) const; void addToScope( const std::string &identifier, kind_t kind, int scope ); public: TypedefTable(); - bool isIdentifier( const std::string &identifier ) const; - bool isTypedef( const std::string &identifier ) const; - bool isTypegen( const std::string &identifier ) const; + bool exists( const std::string &identifier ); + int isKind( const std::string &identifier ) const; + void changeKind( const std::string &identifier, kind_t kind ); - void changeKind( const std::string &identifier, kind_t kind ); - + void makeTypedef( const std::string &name ); + // "addToCurrentScope" adds the identifier/type pair to the current scope. This does less than you think it does, // since each declaration is within its own scope. Mostly useful for type parameters. @@ -79,10 +81,10 @@ // dump the definitions from a pre-defined context into the current scope - void openContext( const std::string &contextName ); + void openTrait( const std::string &contextName ); void enterScope(); void leaveScope(); - void enterContext( const std::string &contextName ); - void leaveContext(); + void enterTrait( const std::string &contextName ); + void leaveTrait(); void print() const; Index: src/Parser/lex.cc =================================================================== --- src/Parser/lex.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/lex.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -382,6 +382,6 @@ (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 179 -#define YY_END_OF_BUFFER 180 +#define YY_NUM_RULES 180 +#define YY_END_OF_BUFFER 181 /* This struct is not used in this scanner, but its presence is necessary. */ @@ -391,102 +391,103 @@ flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[876] = +static yyconst flex_int16_t yy_accept[888] = { 0, - 0, 0, 0, 0, 0, 0, 114, 114, 117, 117, - 180, 178, 7, 9, 8, 137, 116, 101, 142, 145, - 113, 124, 125, 140, 138, 128, 139, 131, 141, 106, - 107, 108, 129, 130, 147, 149, 148, 150, 178, 101, - 122, 178, 123, 143, 101, 103, 101, 101, 101, 101, - 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 126, 146, 127, 144, 7, 178, 4, 4, 179, - 104, 179, 105, 114, 115, 121, 117, 118, 7, 9, - 0, 8, 154, 173, 101, 0, 166, 136, 159, 167, - 164, 151, 162, 152, 163, 161, 0, 111, 3, 0, - - 165, 111, 109, 0, 0, 109, 109, 0, 0, 109, - 108, 108, 108, 0, 108, 134, 135, 133, 155, 157, - 153, 158, 156, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 102, 172, - 0, 116, 113, 101, 0, 0, 169, 0, 101, 101, - 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 101, 101, 101, 101, 39, 101, 101, 101, 101, - 101, 101, 101, 101, 101, 101, 57, 101, 101, 101, - 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 101, 168, 160, 7, 0, 0, 0, 2, 0, - - 5, 104, 0, 0, 0, 114, 0, 120, 119, 119, - 0, 0, 0, 117, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 132, - 111, 111, 0, 111, 111, 111, 0, 6, 111, 109, - 0, 0, 0, 111, 0, 109, 109, 109, 109, 0, - 110, 0, 0, 108, 108, 108, 108, 0, 170, 171, - 0, 176, 174, 0, 0, 0, 102, 0, 0, 0, - 0, 0, 0, 0, 0, 101, 17, 101, 101, 101, - 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 101, 101, 101, 101, 14, 101, 101, 101, 101, - - 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 101, 101, 101, 51, 101, 101, 101, 64, 101, - 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 88, 101, 101, 101, 101, 101, 101, 101, 0, - 0, 0, 0, 0, 0, 0, 0, 119, 0, 0, - 0, 0, 0, 119, 0, 0, 177, 0, 0, 0, - 0, 0, 0, 0, 111, 0, 111, 0, 111, 0, - 0, 111, 111, 109, 109, 0, 0, 110, 110, 0, - 110, 0, 110, 108, 108, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 175, 101, 101, 101, 101, - - 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 101, 101, 101, 101, 101, 101, 101, 101, 21, - 101, 24, 101, 27, 101, 101, 101, 101, 101, 101, - 101, 42, 101, 44, 101, 101, 101, 101, 101, 101, - 101, 56, 101, 67, 101, 101, 101, 101, 101, 101, - 101, 101, 101, 101, 101, 89, 101, 101, 96, 101, - 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 119, 0, 0, 0, 0, - 0, 111, 111, 0, 0, 0, 0, 0, 110, 110, - 0, 112, 0, 110, 110, 0, 0, 0, 0, 0, - - 0, 0, 0, 0, 0, 0, 0, 0, 101, 101, - 22, 101, 101, 101, 101, 101, 101, 101, 15, 101, - 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 101, 101, 23, 25, 101, 32, 101, 101, 101, - 101, 101, 41, 101, 101, 101, 101, 49, 101, 101, - 54, 101, 101, 101, 101, 101, 76, 101, 101, 101, - 101, 101, 86, 101, 101, 94, 101, 101, 100, 0, + 0, 0, 0, 0, 0, 0, 115, 115, 118, 118, + 181, 179, 7, 9, 8, 138, 117, 102, 143, 146, + 114, 125, 126, 141, 139, 129, 140, 132, 142, 107, + 108, 109, 130, 131, 148, 150, 149, 151, 179, 102, + 123, 179, 124, 144, 102, 104, 102, 102, 102, 102, + 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 127, 147, 128, 145, 7, 179, 4, 4, + 180, 105, 180, 106, 115, 116, 122, 118, 119, 7, + 9, 0, 8, 155, 174, 102, 0, 167, 137, 160, + 168, 165, 152, 163, 153, 164, 162, 0, 112, 3, + + 0, 166, 112, 110, 0, 0, 110, 110, 0, 0, + 110, 109, 109, 109, 0, 109, 135, 136, 134, 156, + 158, 154, 159, 157, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, + 173, 0, 117, 114, 102, 0, 0, 170, 0, 102, + 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 102, 102, 38, 102, 102, 102, + 102, 102, 102, 102, 102, 102, 102, 56, 102, 102, + 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 169, 161, 7, 0, 0, 0, + + 2, 0, 5, 105, 0, 0, 0, 115, 0, 121, + 120, 120, 0, 0, 0, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 112, 0, - 0, 110, 112, 112, 112, 112, 112, 110, 0, 0, - - 0, 0, 0, 0, 0, 0, 0, 0, 101, 0, - 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, - 101, 101, 101, 101, 101, 101, 59, 101, 101, 101, - 101, 101, 101, 101, 101, 28, 101, 101, 101, 101, - 40, 43, 46, 101, 101, 52, 101, 61, 68, 101, - 101, 75, 77, 80, 81, 83, 84, 101, 101, 91, - 101, 101, 0, 1, 0, 0, 0, 0, 0, 0, - 104, 0, 0, 0, 119, 0, 0, 0, 0, 112, - 112, 112, 112, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 101, 101, 18, 101, 101, 101, 101, 101, - - 101, 101, 16, 101, 101, 101, 33, 101, 101, 101, - 101, 101, 101, 101, 101, 101, 101, 101, 35, 101, - 37, 38, 101, 48, 53, 101, 101, 101, 90, 101, - 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 10, 11, 29, 55, 101, 101, - 101, 101, 101, 101, 101, 101, 101, 101, 101, 60, - 62, 65, 101, 101, 78, 92, 101, 101, 36, 47, - 71, 72, 101, 95, 97, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 101, 69, 101, - 101, 12, 101, 101, 30, 34, 101, 101, 101, 66, - - 101, 101, 101, 101, 101, 101, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 58, - 101, 101, 101, 101, 101, 101, 101, 50, 63, 73, - 79, 93, 98, 101, 101, 0, 0, 0, 0, 0, - 0, 0, 0, 101, 101, 13, 19, 101, 31, 101, - 101, 101, 26, 87, 0, 0, 101, 101, 101, 101, - 101, 74, 99, 101, 85, 20, 101, 45, 82, 101, - 101, 101, 101, 70, 0 + 0, 133, 112, 112, 0, 112, 112, 0, 0, 6, + 0, 110, 0, 0, 0, 112, 0, 110, 110, 110, + 110, 0, 111, 0, 0, 109, 109, 109, 109, 0, + 171, 172, 0, 177, 175, 0, 0, 0, 103, 0, + 0, 0, 0, 0, 0, 0, 0, 102, 17, 102, + 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 102, 102, 102, 14, 102, 102, + + 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 102, 102, 50, 102, 102, 102, + 63, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 102, 89, 102, 102, 102, 102, + 102, 102, 102, 0, 0, 0, 0, 0, 0, 0, + 0, 120, 0, 0, 0, 0, 0, 120, 0, 0, + 178, 0, 0, 0, 0, 0, 0, 0, 112, 0, + 112, 0, 112, 0, 0, 112, 0, 110, 110, 0, + 0, 111, 111, 0, 111, 0, 111, 109, 109, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 176, + + 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 21, 102, 24, 102, 27, 102, 102, + 102, 102, 102, 102, 102, 41, 102, 43, 102, 102, + 102, 102, 102, 102, 102, 55, 102, 66, 102, 102, + 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 97, 102, 102, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 120, 0, 0, 0, 0, 0, 112, 0, 0, + 0, 0, 0, 0, 111, 111, 0, 113, 0, 111, + + 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 102, 102, 22, 102, 102, 102, + 102, 102, 102, 102, 15, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 102, 102, 102, 102, 102, 23, + 25, 102, 32, 102, 102, 102, 102, 40, 102, 102, + 102, 102, 48, 102, 102, 53, 102, 102, 70, 102, + 102, 102, 76, 102, 102, 102, 102, 102, 86, 88, + 102, 102, 94, 102, 102, 101, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 113, 0, 0, 111, 113, + + 113, 113, 113, 0, 111, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 102, 0, 102, 102, 102, + 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 58, 102, 102, 102, 102, 102, 102, + 102, 102, 28, 102, 102, 102, 39, 42, 45, 102, + 102, 51, 102, 60, 67, 102, 102, 75, 77, 80, + 81, 83, 84, 102, 102, 91, 102, 102, 0, 1, + 0, 0, 0, 0, 0, 0, 105, 0, 0, 0, + 120, 0, 0, 0, 0, 113, 0, 113, 113, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 102, 102, + + 18, 102, 102, 102, 102, 102, 102, 102, 16, 102, + 102, 102, 33, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 102, 36, 37, 102, 47, 52, + 102, 102, 102, 90, 102, 102, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, + 11, 29, 54, 102, 102, 102, 102, 102, 102, 102, + 102, 102, 102, 102, 59, 61, 64, 102, 102, 78, + 92, 102, 102, 35, 46, 71, 72, 102, 95, 98, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 102, 68, 102, 102, 12, 102, 102, 30, + + 34, 102, 102, 102, 65, 102, 102, 102, 102, 102, + 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 57, 102, 102, 102, 102, 102, + 102, 102, 49, 62, 73, 79, 93, 99, 102, 102, + 0, 0, 0, 0, 0, 0, 0, 0, 102, 102, + 13, 19, 102, 102, 31, 102, 102, 102, 26, 87, + 0, 0, 102, 102, 102, 102, 102, 102, 74, 100, + 102, 85, 20, 102, 102, 44, 82, 102, 102, 102, + 102, 102, 102, 102, 96, 69, 0 } ; @@ -499,12 +500,12 @@ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 26, 26, 26, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 39, - 41, 11, 42, 11, 11, 43, 11, 44, 11, 45, - 11, 46, 47, 48, 49, 11, 11, 50, 11, 11, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - - 61, 62, 63, 64, 65, 11, 66, 67, 68, 69, - 70, 71, 11, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82, 83, 84, 1, 1, 1, 1, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 11, 43, 11, 11, 44, 11, 45, 11, 46, + 11, 47, 48, 49, 50, 11, 11, 51, 11, 11, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + + 62, 63, 64, 65, 66, 11, 67, 68, 69, 70, + 71, 72, 11, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -523,5 +524,5 @@ } ; -static yyconst flex_int32_t yy_meta[85] = +static yyconst flex_int32_t yy_meta[86] = { 0, 1, 1, 2, 1, 1, 1, 1, 1, 3, 1, @@ -529,250 +530,254 @@ 6, 1, 7, 7, 7, 7, 7, 7, 1, 1, 1, 8, 1, 1, 1, 9, 9, 9, 9, 9, - 4, 4, 10, 4, 11, 4, 4, 4, 10, 4, - 1, 12, 1, 1, 13, 1, 9, 9, 9, 9, - 9, 9, 4, 4, 4, 4, 10, 4, 4, 4, - 11, 4, 4, 4, 10, 4, 4, 4, 4, 4, - 1, 1, 1, 1 + 9, 4, 4, 10, 4, 11, 4, 4, 4, 10, + 4, 1, 12, 1, 1, 13, 1, 9, 9, 9, + 9, 9, 9, 4, 4, 4, 4, 10, 4, 4, + 4, 11, 4, 4, 4, 10, 4, 4, 4, 4, + 4, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[1050] = +static yyconst flex_int16_t yy_base[1062] = { 0, - 0, 83, 2238, 2237, 93, 0, 175, 176, 177, 178, - 2252, 2782, 189, 2782, 195, 54, 2782, 2197, 59, 171, - 2782, 2782, 2782, 55, 186, 2782, 189, 187, 202, 214, - 272, 0, 2213, 2782, 214, 2213, 150, 340, 153, 222, - 2782, 157, 2782, 215, 224, 2782, 207, 181, 221, 249, - 235, 289, 155, 255, 218, 206, 266, 256, 323, 259, - 192, 2782, 223, 2782, 2210, 377, 342, 2782, 2220, 2782, - 2187, 234, 2782, 0, 2782, 421, 0, 2782, 393, 2782, - 399, 405, 2782, 492, 2184, 241, 2782, 2782, 2782, 2782, - 2782, 2201, 2782, 2200, 2782, 2782, 2211, 552, 2782, 2226, - - 2782, 413, 393, 437, 493, 377, 318, 195, 430, 382, - 0, 384, 321, 196, 427, 2782, 2782, 2782, 2194, 2782, - 2782, 2782, 2193, 2192, 252, 302, 2206, 342, 435, 422, - 381, 455, 400, 494, 2185, 440, 2133, 469, 2163, 2782, - 276, 2782, 2782, 520, 2159, 2157, 2782, 2128, 414, 463, - 470, 325, 254, 479, 432, 274, 480, 423, 483, 498, - 492, 503, 499, 509, 341, 455, 484, 377, 510, 512, - 517, 518, 529, 530, 531, 537, 2154, 541, 536, 544, - 557, 546, 566, 569, 538, 552, 548, 554, 588, 571, - 570, 580, 2782, 2782, 645, 651, 2202, 657, 2782, 663, - - 2782, 2152, 593, 2147, 2144, 0, 631, 2782, 2782, 669, - 2141, 2140, 2139, 0, 2160, 629, 635, 639, 678, 677, - 666, 670, 671, 674, 2138, 681, 682, 2115, 2114, 2782, - 0, 597, 702, 678, 676, 2111, 2160, 2782, 693, 0, - 710, 723, 743, 762, 788, 707, 2782, 2119, 2094, 0, - 776, 2138, 768, 723, 2782, 2113, 2086, 809, 2782, 2782, - 2118, 2782, 2782, 705, 710, 2098, 2097, 724, 2091, 2088, - 2087, 0, 2086, 0, 2056, 709, 682, 707, 712, 710, - 724, 647, 750, 671, 786, 751, 748, 731, 778, 787, - 789, 788, 792, 790, 758, 2084, 796, 806, 800, 813, - - 798, 810, 802, 816, 822, 819, 815, 826, 830, 829, - 831, 832, 833, 837, 839, 841, 846, 843, 2081, 848, - 850, 849, 851, 852, 854, 853, 857, 855, 858, 863, - 868, 2080, 867, 912, 871, 878, 872, 879, 882, 937, - 939, 2076, 2074, 2071, 0, 2070, 0, 927, 931, 2069, - 0, 2067, 0, 2064, 0, 2084, 2782, 913, 926, 2064, - 2060, 0, 2057, 0, 2782, 942, 960, 953, 2782, 966, - 981, 1005, 2053, 2782, 2782, 955, 968, 995, 968, 1028, - 892, 1014, 970, 2782, 2782, 2049, 2047, 2045, 0, 2042, - 0, 2040, 0, 2038, 0, 2782, 909, 944, 982, 943, - - 1006, 911, 1012, 923, 1013, 1019, 1009, 1016, 1023, 1024, - 1020, 972, 1030, 1028, 989, 1026, 1034, 1027, 1039, 2038, - 1044, 2035, 1048, 2034, 1049, 1051, 1052, 1053, 1056, 1057, - 1055, 2033, 1059, 2031, 946, 1063, 1066, 1067, 1068, 1071, - 1069, 2028, 1075, 2025, 1077, 1080, 1079, 1082, 1084, 1086, - 1087, 1090, 1097, 1107, 1088, 1108, 1093, 1098, 2024, 1096, - 1111, 1164, 2020, 0, 2018, 0, 2015, 0, 2012, 0, - 1151, 2011, 0, 2010, 0, 2008, 2005, 2002, 0, 2001, - 0, 1156, 2000, 1162, 1148, 1182, 1149, 1126, 1147, 2782, - 1201, 1215, 1241, 2010, 1983, 1992, 1991, 0, 1990, 0, - - 1988, 0, 1985, 0, 1982, 0, 1981, 0, 1161, 1149, - 1983, 1179, 1140, 1180, 1117, 1182, 1192, 1199, 1181, 1163, - 1196, 1200, 1201, 1220, 1198, 1221, 1224, 604, 1226, 1227, - 1231, 1233, 1234, 1981, 1244, 1236, 1978, 1240, 1241, 1246, - 1247, 1243, 1975, 1250, 1251, 1253, 1254, 1974, 1255, 1267, - 1973, 1264, 1271, 1256, 1263, 1257, 1971, 1275, 1277, 1279, - 1260, 1281, 1290, 1285, 1288, 1968, 1289, 1291, 1967, 2015, - 1961, 0, 1958, 0, 1957, 0, 1956, 0, 1954, 0, - 1921, 0, 1919, 0, 1918, 0, 1336, 1342, 1369, 1353, - 1915, 2782, 1359, 1307, 1359, 1309, 1912, 2782, 1911, 0, - - 1910, 0, 1908, 0, 1905, 0, 0, 0, 1905, 0, - 1347, 1295, 1292, 1323, 1337, 1338, 1296, 1349, 1351, 1355, - 1353, 1348, 1363, 1364, 1371, 1373, 1380, 1375, 1403, 1381, - 1385, 1389, 1094, 1387, 1390, 1904, 1391, 1393, 1397, 1401, - 1903, 1901, 1898, 1394, 1400, 1897, 1404, 1896, 1894, 1402, - 1408, 1891, 1890, 1889, 1887, 1884, 1880, 1417, 1412, 1876, - 1420, 1418, 1921, 2782, 1853, 0, 1852, 0, 0, 0, - 1854, 0, 0, 0, 2782, 0, 0, 0, 0, 1463, - 1849, 2782, 2782, 1469, 1846, 0, 1845, 0, 0, 0, - 0, 1844, 1407, 1446, 1845, 1406, 1423, 1300, 1431, 1449, - - 1455, 1447, 1842, 1457, 1448, 1459, 1464, 1460, 1490, 1474, - 1470, 1494, 1480, 1475, 1484, 1485, 1486, 1482, 1841, 1487, - 1840, 1838, 1489, 1835, 1834, 1491, 1493, 1497, 1833, 1498, - 1500, 0, 0, 0, 1828, 1825, 1824, 1548, 0, 1823, - 1821, 1818, 1817, 1816, 1817, 1814, 1813, 1812, 1505, 1510, - 1502, 1501, 1504, 1508, 1513, 1517, 1526, 1528, 1559, 1810, - 1533, 1807, 1534, 1535, 1544, 1545, 1538, 1539, 1806, 1805, - 1803, 1800, 1540, 1799, 1798, 1793, 1786, 1784, 1783, 1780, - 1779, 1778, 1776, 1759, 1750, 1749, 1746, 1546, 1742, 1549, - 1550, 1552, 1554, 1557, 1558, 1739, 1556, 1589, 1566, 1732, - - 1565, 1572, 1577, 1579, 1567, 1578, 1727, 1726, 1705, 1704, - 1703, 1696, 1694, 1693, 1650, 1649, 1647, 1645, 1644, 1646, - 1571, 1584, 1582, 1581, 1586, 1593, 1595, 1645, 1644, 1597, - 1642, 1641, 1598, 1599, 1602, 1636, 1635, 1633, 1422, 1421, - 1205, 1201, 946, 1605, 1610, 910, 1603, 1607, 768, 1613, - 1618, 1619, 723, 605, 503, 370, 1609, 1620, 1623, 1624, - 1625, 338, 337, 1627, 290, 251, 1630, 200, 196, 1631, - 1632, 1637, 1633, 136, 2782, 1707, 1720, 1733, 1743, 1753, - 1766, 1776, 1789, 1802, 1815, 1823, 1833, 1840, 1847, 1854, - 1861, 1868, 1875, 1882, 1889, 1896, 1909, 1916, 1920, 1928, - - 1931, 1938, 1945, 1952, 1955, 1962, 1968, 1981, 1994, 2001, - 2008, 2015, 2022, 2025, 2032, 2035, 2042, 2045, 2052, 2055, - 2062, 2065, 2072, 2075, 2082, 2085, 2092, 2100, 2107, 2114, - 2121, 2128, 2131, 2138, 2141, 2148, 2151, 2158, 2164, 2177, - 2184, 2191, 2194, 2201, 2204, 2211, 2214, 2221, 2224, 2231, - 2234, 2241, 2244, 2251, 2258, 2261, 2268, 2271, 2278, 2285, - 2292, 2295, 2302, 2305, 2312, 2315, 2322, 2325, 2332, 2335, - 2342, 2348, 2361, 2368, 2375, 2378, 2385, 2388, 2395, 2398, - 2405, 2408, 2415, 2418, 2425, 2428, 2435, 2438, 2445, 2448, - 2455, 2462, 2465, 2472, 2475, 2482, 2485, 2492, 2495, 2498, - - 2504, 2511, 2520, 2527, 2534, 2537, 2544, 2547, 2550, 2556, - 2563, 2566, 2569, 2572, 2575, 2578, 2581, 2584, 2591, 2594, - 2601, 2604, 2607, 2610, 2613, 2623, 2630, 2633, 2636, 2639, - 2646, 2653, 2660, 2663, 2670, 2677, 2684, 2691, 2698, 2705, - 2712, 2719, 2726, 2733, 2740, 2747, 2754, 2761, 2768 + 0, 84, 2272, 2269, 94, 0, 177, 178, 179, 180, + 2285, 2822, 191, 2822, 197, 55, 2822, 2231, 60, 173, + 2822, 2822, 2822, 56, 188, 2822, 191, 189, 204, 216, + 275, 0, 2249, 2822, 216, 2247, 152, 344, 155, 220, + 2822, 159, 2822, 217, 226, 2822, 185, 154, 212, 251, + 237, 270, 235, 257, 241, 205, 193, 305, 314, 333, + 238, 228, 2822, 225, 2822, 2242, 402, 390, 2822, 2253, + 2822, 2221, 235, 2822, 0, 2822, 426, 0, 2822, 417, + 2822, 439, 451, 2822, 498, 2219, 264, 2822, 2822, 2822, + 2822, 2822, 2235, 2822, 2232, 2822, 2822, 2244, 559, 2822, + + 2261, 2822, 438, 444, 511, 534, 289, 253, 197, 380, + 305, 0, 319, 280, 198, 322, 2822, 2822, 2822, 2230, + 2822, 2822, 2822, 2227, 2224, 218, 255, 2239, 298, 350, + 368, 312, 440, 398, 405, 2220, 441, 2168, 446, 2196, + 2822, 335, 2822, 2822, 468, 2190, 2189, 2822, 2162, 439, + 282, 433, 372, 281, 437, 434, 428, 570, 444, 466, + 464, 469, 475, 321, 492, 438, 471, 445, 474, 512, + 489, 503, 496, 521, 276, 515, 516, 2189, 526, 510, + 519, 525, 543, 522, 560, 553, 523, 561, 551, 544, + 599, 582, 593, 584, 2822, 2822, 660, 651, 2236, 666, + + 2822, 678, 2822, 2183, 607, 2179, 2178, 0, 693, 2822, + 2822, 684, 2176, 2156, 2154, 0, 2177, 578, 608, 617, + 654, 679, 650, 683, 684, 687, 2172, 690, 691, 2147, + 2146, 2822, 0, 683, 710, 686, 700, 2145, 2196, 2822, + 714, 0, 427, 746, 764, 786, 808, 621, 2822, 2152, + 2125, 0, 794, 2171, 795, 709, 2822, 2147, 2121, 832, + 2822, 2822, 2152, 2822, 2822, 711, 714, 2129, 2129, 717, + 2125, 2123, 2120, 0, 2117, 0, 2088, 694, 679, 712, + 709, 711, 698, 566, 726, 743, 771, 741, 790, 784, + 800, 795, 742, 744, 814, 816, 818, 2118, 819, 745, + + 820, 821, 822, 823, 824, 746, 825, 748, 659, 831, + 826, 833, 838, 839, 848, 850, 851, 844, 834, 857, + 2116, 858, 859, 860, 862, 861, 864, 865, 867, 868, + 866, 871, 876, 872, 878, 2113, 880, 689, 881, 882, + 892, 896, 893, 953, 954, 2109, 2108, 2106, 0, 2103, + 0, 941, 945, 2102, 0, 2101, 0, 2099, 0, 2118, + 2822, 940, 941, 2094, 2088, 0, 2086, 0, 2822, 953, + 975, 964, 2822, 981, 997, 1021, 2084, 2822, 2822, 939, + 940, 1006, 982, 1041, 310, 1039, 1004, 2822, 2822, 2081, + 2079, 2077, 0, 2074, 0, 2071, 0, 2070, 0, 2822, + + 886, 941, 960, 962, 977, 976, 980, 982, 1017, 1010, + 1002, 998, 1022, 1031, 1028, 1033, 1034, 1037, 1040, 1043, + 1038, 1041, 1053, 2072, 1055, 2070, 1045, 2067, 1056, 1061, + 1063, 1065, 1066, 1067, 1070, 2064, 1071, 2063, 1073, 1074, + 1075, 1078, 1080, 1081, 1085, 2062, 1087, 2060, 1084, 1089, + 1091, 1097, 1099, 1092, 1102, 1103, 1105, 1106, 1108, 905, + 1109, 1116, 1110, 1122, 2057, 1120, 1123, 1179, 2051, 0, + 2050, 0, 2049, 0, 2047, 0, 1166, 2044, 0, 2041, + 0, 2040, 2039, 2037, 0, 2034, 0, 1173, 2031, 1179, + 1137, 1195, 1181, 1178, 1176, 2822, 1219, 1231, 1253, 2042, + + 2017, 2027, 2024, 0, 2021, 0, 2020, 0, 2019, 0, + 2017, 0, 2014, 0, 1141, 1172, 2014, 1180, 1155, 1196, + 1157, 1216, 1207, 1231, 1125, 1210, 1232, 1214, 1187, 1236, + 1235, 1237, 1238, 1272, 1249, 1252, 1250, 1253, 1254, 2013, + 1261, 1256, 2012, 1260, 1263, 1264, 1257, 2010, 1271, 1268, + 1269, 1273, 2007, 1275, 1282, 2006, 1283, 1284, 2005, 1276, + 1286, 1289, 2003, 1294, 1291, 1296, 1295, 1297, 1310, 2000, + 1305, 1308, 1999, 1307, 1300, 1998, 2046, 1960, 0, 1958, + 0, 1957, 0, 1954, 0, 1951, 0, 1950, 0, 1949, + 0, 1947, 0, 1355, 1361, 1389, 1372, 1944, 2822, 1378, + + 1325, 1365, 1379, 1941, 2822, 1940, 0, 1939, 0, 1937, + 0, 1934, 0, 0, 0, 1936, 0, 1366, 1312, 1311, + 1341, 1323, 1368, 1369, 1374, 1356, 1383, 1372, 1388, 1390, + 1393, 1395, 1396, 1398, 1400, 1431, 1406, 1407, 1411, 1408, + 1413, 1414, 1935, 1409, 1416, 1419, 1933, 1930, 1929, 1422, + 1424, 1928, 1429, 1926, 1923, 1425, 1430, 1919, 1915, 1911, + 1895, 1894, 1893, 1436, 1433, 1891, 1439, 1440, 1938, 2822, + 1884, 0, 1883, 0, 0, 0, 1884, 0, 0, 0, + 2822, 0, 0, 0, 0, 1486, 1878, 2822, 2822, 1492, + 1877, 0, 1876, 0, 0, 0, 0, 1874, 1447, 1444, + + 1874, 1449, 1471, 1479, 1450, 1480, 1482, 1469, 1873, 1486, + 1490, 1488, 1502, 1452, 1510, 1504, 1491, 1519, 1506, 1498, + 1508, 1512, 1513, 1514, 1515, 1872, 1870, 1517, 1867, 1866, + 1518, 1520, 1523, 1865, 1521, 1525, 0, 0, 0, 1860, + 1857, 1856, 1575, 0, 1855, 1853, 1850, 1849, 1848, 1849, + 1846, 1845, 1844, 1531, 1536, 1527, 1528, 1552, 1533, 1537, + 1539, 1555, 1557, 1569, 1842, 1560, 1839, 1561, 1559, 1568, + 1572, 1567, 1573, 1838, 1837, 1835, 1828, 1574, 1826, 1825, + 1819, 1818, 1817, 1815, 1798, 1789, 1788, 1785, 1778, 1775, + 1768, 1766, 1576, 1768, 1577, 1581, 1580, 1579, 1584, 1585, + + 1747, 1586, 1615, 1590, 1746, 1591, 1592, 1602, 1600, 1594, + 1606, 1742, 1735, 1733, 1732, 1690, 1689, 1686, 1685, 1683, + 1682, 1678, 1677, 1674, 1676, 1607, 1611, 1614, 1612, 1608, + 1616, 1620, 1675, 1623, 1624, 1530, 1453, 1630, 1625, 1629, + 1438, 1354, 1319, 1318, 1267, 1212, 1210, 1208, 1631, 1636, + 1178, 1639, 1635, 1643, 1177, 1644, 1646, 1650, 1126, 964, + 937, 903, 1651, 1652, 1654, 1655, 1656, 1658, 788, 752, + 1660, 607, 487, 1662, 1663, 394, 357, 1664, 1666, 1668, + 1670, 1669, 1672, 1674, 233, 137, 2822, 1747, 1760, 1773, + 1783, 1793, 1806, 1816, 1829, 1842, 1855, 1863, 1873, 1880, + + 1887, 1894, 1901, 1908, 1915, 1922, 1929, 1936, 1949, 1956, + 1960, 1968, 1971, 1978, 1985, 1992, 1995, 2002, 2008, 2021, + 2034, 2041, 2048, 2055, 2062, 2065, 2072, 2075, 2082, 2085, + 2092, 2095, 2102, 2105, 2112, 2115, 2122, 2125, 2132, 2140, + 2147, 2154, 2161, 2168, 2171, 2178, 2181, 2188, 2191, 2198, + 2204, 2217, 2224, 2231, 2234, 2241, 2244, 2251, 2254, 2261, + 2264, 2271, 2274, 2281, 2284, 2291, 2298, 2301, 2308, 2311, + 2318, 2325, 2332, 2335, 2342, 2345, 2352, 2355, 2362, 2365, + 2372, 2375, 2382, 2388, 2401, 2408, 2415, 2418, 2425, 2428, + 2435, 2438, 2445, 2448, 2455, 2458, 2465, 2468, 2475, 2478, + + 2485, 2488, 2495, 2502, 2505, 2512, 2515, 2522, 2525, 2532, + 2535, 2538, 2544, 2551, 2560, 2567, 2574, 2577, 2584, 2587, + 2590, 2596, 2603, 2606, 2609, 2612, 2615, 2618, 2621, 2624, + 2631, 2634, 2641, 2644, 2647, 2650, 2653, 2663, 2670, 2673, + 2676, 2679, 2686, 2693, 2700, 2703, 2710, 2717, 2724, 2731, + 2738, 2745, 2752, 2759, 2766, 2773, 2780, 2787, 2794, 2801, + 2808 } ; -static yyconst flex_int16_t yy_def[1050] = +static yyconst flex_int16_t yy_def[1062] = { 0, - 875, 1, 876, 876, 875, 5, 877, 877, 878, 878, - 875, 875, 875, 875, 875, 875, 875, 879, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 31, 875, 875, 875, 875, 875, 875, 880, 879, - 875, 875, 875, 875, 879, 875, 879, 879, 879, 879, - 879, 879, 879, 879, 879, 879, 879, 879, 879, 879, - 879, 875, 875, 875, 875, 875, 881, 875, 875, 875, - 882, 875, 875, 883, 875, 875, 884, 875, 875, 875, - 875, 875, 875, 875, 879, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 885, - - 875, 98, 30, 875, 875, 875, 875, 886, 30, 875, - 31, 875, 875, 31, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 887, 875, - 875, 875, 875, 879, 888, 889, 875, 875, 879, 879, - 879, 879, 879, 879, 879, 879, 879, 879, 879, 879, - 879, 879, 879, 879, 879, 879, 879, 879, 879, 879, - 879, 879, 879, 879, 879, 879, 879, 879, 879, 879, - 879, 879, 879, 879, 879, 879, 879, 879, 879, 879, - 879, 879, 875, 875, 875, 881, 881, 881, 875, 881, - - 875, 882, 875, 890, 891, 883, 875, 875, 875, 875, - 892, 893, 894, 884, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 895, 896, 875, - 98, 875, 875, 875, 875, 98, 897, 875, 875, 103, - 103, 875, 875, 875, 875, 875, 875, 875, 875, 898, - 899, 900, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 887, 875, 901, 902, - 903, 904, 905, 906, 875, 907, 907, 907, 907, 907, - 907, 907, 907, 907, 907, 907, 907, 907, 907, 907, - 907, 907, 907, 907, 907, 907, 907, 907, 907, 907, - - 907, 907, 907, 907, 907, 907, 907, 907, 907, 907, - 907, 907, 907, 907, 907, 907, 907, 907, 907, 907, - 907, 907, 907, 907, 907, 907, 907, 907, 907, 907, - 907, 907, 907, 907, 907, 907, 907, 907, 907, 908, - 909, 910, 911, 912, 913, 914, 915, 875, 875, 916, - 917, 918, 919, 920, 921, 875, 875, 875, 875, 875, - 922, 923, 924, 925, 875, 875, 875, 875, 875, 875, - 875, 367, 372, 875, 875, 926, 927, 928, 875, 875, - 875, 928, 875, 875, 875, 929, 930, 931, 932, 933, - 934, 935, 936, 937, 938, 875, 939, 939, 939, 939, - - 939, 939, 939, 939, 939, 939, 939, 939, 939, 939, - 939, 939, 939, 939, 939, 939, 939, 939, 939, 939, - 939, 939, 939, 939, 939, 939, 939, 939, 939, 939, - 939, 939, 939, 939, 939, 939, 939, 939, 939, 939, - 939, 939, 939, 939, 939, 939, 939, 939, 939, 939, - 939, 939, 939, 939, 939, 939, 939, 939, 939, 939, - 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, - 875, 949, 950, 951, 952, 953, 953, 954, 955, 956, - 957, 875, 482, 875, 958, 875, 958, 875, 875, 875, - 875, 875, 875, 875, 875, 959, 960, 961, 962, 963, - - 964, 965, 966, 967, 968, 969, 970, 971, 972, 972, - 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, - 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, - 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, - 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, - 972, 972, 972, 972, 972, 972, 972, 972, 972, 972, - 972, 972, 972, 972, 972, 972, 972, 972, 972, 973, - 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, - 984, 985, 986, 987, 988, 989, 875, 875, 875, 875, - 990, 875, 589, 875, 875, 875, 593, 875, 991, 992, - - 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, - 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, - 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, - 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, - 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, - 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, 1001, - 1001, 1001, 1003, 875, 1004, 1005, 1006, 1007, 1008, 1009, - 1010, 1011, 1012, 1013, 875, 1014, 1015, 1016, 1017, 875, - 680, 875, 875, 875, 1018, 1019, 1020, 1021, 1022, 1023, - 1024, 1025, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - - 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - 1026, 1027, 1028, 1029, 1030, 1031, 1032, 875, 1033, 1018, - 1020, 1034, 1035, 1025, 1026, 1026, 1026, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 1026, 1036, 1037, 1030, 1038, 1031, - 1039, 1032, 1040, 1041, 1034, 1042, 1035, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - - 1026, 1026, 1026, 1026, 1026, 1026, 1043, 1036, 1044, 1037, - 1045, 1038, 1046, 1039, 1047, 1040, 1048, 1041, 1042, 1026, - 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 1026, 1049, 1043, 1044, 1045, 1046, - 1020, 1047, 1048, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 1049, 1020, 1026, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, - 1026, 1026, 1026, 1026, 0, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875 + 887, 1, 888, 888, 887, 5, 889, 889, 890, 890, + 887, 887, 887, 887, 887, 887, 887, 891, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 31, 887, 887, 887, 887, 887, 887, 892, 891, + 887, 887, 887, 887, 891, 887, 891, 891, 891, 891, + 891, 891, 891, 891, 891, 891, 891, 891, 891, 891, + 891, 891, 887, 887, 887, 887, 887, 893, 887, 887, + 887, 894, 887, 887, 895, 887, 887, 896, 887, 887, + 887, 887, 887, 887, 887, 891, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + + 897, 887, 99, 30, 887, 887, 887, 887, 898, 30, + 887, 31, 887, 887, 31, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 899, + 887, 887, 887, 887, 891, 900, 901, 887, 887, 891, + 891, 891, 891, 891, 891, 891, 891, 891, 891, 891, + 891, 891, 891, 891, 891, 891, 891, 891, 891, 891, + 891, 891, 891, 891, 891, 891, 891, 891, 891, 891, + 891, 891, 891, 891, 891, 891, 891, 891, 891, 891, + 891, 891, 891, 891, 887, 887, 887, 893, 893, 893, + + 887, 893, 887, 894, 887, 902, 903, 895, 887, 887, + 887, 887, 904, 905, 906, 896, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 907, + 908, 887, 99, 887, 887, 887, 887, 99, 909, 887, + 887, 104, 104, 887, 887, 887, 887, 887, 887, 887, + 887, 910, 911, 912, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 899, 887, + 913, 914, 915, 916, 917, 918, 887, 919, 919, 919, + 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, + 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, + + 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, + 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, + 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, + 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, + 919, 919, 919, 920, 921, 922, 923, 924, 925, 926, + 927, 887, 887, 928, 929, 930, 931, 932, 933, 887, + 887, 887, 887, 887, 934, 935, 936, 937, 887, 887, + 887, 887, 887, 887, 887, 371, 376, 887, 887, 938, + 939, 940, 887, 887, 887, 940, 887, 887, 887, 941, + 942, 943, 944, 945, 946, 947, 948, 949, 950, 887, + + 951, 951, 951, 951, 951, 951, 951, 951, 951, 951, + 951, 951, 951, 951, 951, 951, 951, 951, 951, 951, + 951, 951, 951, 951, 951, 951, 951, 951, 951, 951, + 951, 951, 951, 951, 951, 951, 951, 951, 951, 951, + 951, 951, 951, 951, 951, 951, 951, 951, 951, 951, + 951, 951, 951, 951, 951, 951, 951, 951, 951, 951, + 951, 951, 951, 951, 951, 951, 951, 952, 953, 954, + 955, 956, 957, 958, 959, 960, 887, 961, 962, 963, + 964, 965, 965, 966, 967, 968, 969, 887, 488, 887, + 970, 887, 970, 887, 887, 887, 887, 887, 887, 887, + + 887, 971, 972, 973, 974, 975, 976, 977, 978, 979, + 980, 981, 982, 983, 984, 984, 984, 984, 984, 984, + 984, 984, 984, 984, 984, 984, 984, 984, 984, 984, + 984, 984, 984, 984, 984, 984, 984, 984, 984, 984, + 984, 984, 984, 984, 984, 984, 984, 984, 984, 984, + 984, 984, 984, 984, 984, 984, 984, 984, 984, 984, + 984, 984, 984, 984, 984, 984, 984, 984, 984, 984, + 984, 984, 984, 984, 984, 984, 985, 986, 987, 988, + 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, + 999, 1000, 1001, 887, 887, 887, 887, 1002, 887, 596, + + 887, 887, 887, 600, 887, 1003, 1004, 1005, 1006, 1007, + 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1013, 1013, 1013, + 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, + 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, + 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, + 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, + 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1015, 887, + 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, + 887, 1026, 1027, 1028, 1029, 887, 686, 887, 887, 887, + 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1038, + + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 1039, 1040, 1041, 1042, + 1043, 1044, 887, 1045, 1030, 1032, 1046, 1047, 1037, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1048, 1049, 1042, 1050, 1043, 1051, 1044, 1052, 1053, 1046, + 1054, 1047, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1038, 1055, 1048, 1056, 1049, 1057, 1050, 1058, 1051, 1059, + 1052, 1060, 1053, 1054, 1038, 1038, 1038, 1038, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1061, 1055, 1056, 1057, 1058, 1032, 1059, 1060, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1061, 1032, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1038, 0, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887 } ; -static yyconst flex_int16_t yy_nxt[2867] = +static yyconst flex_int16_t yy_nxt[2908] = { 0, 12, 13, 14, 15, 15, 15, 13, 16, 17, 12, @@ -780,318 +785,323 @@ 28, 29, 30, 31, 32, 32, 32, 32, 33, 34, 35, 36, 37, 38, 39, 18, 18, 18, 18, 18, - 18, 18, 40, 18, 18, 18, 18, 18, 40, 18, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 18, 54, 18, 55, 18, 18, 18, - 18, 56, 57, 58, 59, 60, 61, 18, 18, 18, - 62, 63, 64, 65, 66, 83, 91, 84, 84, 66, - 87, 88, 67, 70, 70, 70, 70, 70, 70, 70, - - 70, 70, 70, 71, 70, 70, 70, 70, 70, 70, - 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, - 70, 70, 70, 70, 70, 70, 70, 70, 71, 71, + 18, 18, 18, 40, 18, 18, 18, 18, 18, 40, + 18, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 18, 54, 18, 55, 18, 18, + 56, 18, 57, 58, 59, 60, 61, 62, 18, 18, + 18, 63, 64, 65, 66, 67, 84, 92, 85, 85, + 67, 88, 89, 68, 71, 71, 71, 71, 71, 71, + + 71, 71, 71, 71, 72, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 70, 72, 70, 70, 71, 73, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 70, 70, 70, 70, 75, 75, 78, - 78, 122, 123, 89, 140, 78, 78, 86, 75, 75, - 79, 80, 81, 81, 81, 79, 81, 80, 82, 82, - - 82, 81, 90, 92, 141, 145, 86, 97, 94, 98, - 98, 98, 98, 98, 98, 250, 875, 93, 99, 84, - 95, 96, 84, 100, 176, 117, 76, 76, 76, 76, - 142, 146, 86, 101, 102, 143, 103, 103, 103, 103, - 104, 104, 118, 86, 119, 120, 147, 86, 148, 252, - 258, 86, 160, 105, 193, 192, 106, 86, 86, 149, - 150, 151, 107, 108, 152, 153, 181, 154, 109, 86, - 155, 156, 86, 86, 105, 86, 144, 161, 157, 158, - 110, 159, 204, 261, 162, 262, 86, 179, 107, 228, - 163, 108, 102, 180, 111, 111, 111, 111, 111, 111, - - 86, 168, 86, 169, 194, 86, 86, 86, 205, 164, - 86, 105, 170, 165, 112, 229, 177, 86, 166, 186, - 113, 281, 167, 178, 269, 86, 114, 187, 191, 182, - 183, 142, 105, 261, 188, 262, 143, 284, 115, 184, - 86, 86, 185, 198, 199, 171, 113, 124, 198, 189, - 270, 125, 126, 172, 127, 173, 128, 129, 174, 130, - 248, 131, 175, 256, 200, 200, 200, 200, 200, 200, - 132, 133, 134, 261, 86, 262, 86, 144, 195, 80, - 81, 81, 81, 195, 249, 280, 196, 257, 86, 86, - 135, 190, 86, 136, 79, 80, 81, 81, 81, 79, - - 81, 80, 81, 81, 81, 81, 81, 80, 82, 82, - 82, 81, 261, 305, 262, 240, 240, 240, 240, 246, - 137, 138, 207, 208, 875, 247, 254, 207, 86, 209, - 247, 261, 255, 262, 209, 98, 98, 98, 98, 98, - 98, 263, 875, 210, 210, 210, 210, 241, 246, 308, - 875, 247, 263, 261, 209, 262, 247, 102, 255, 104, - 104, 104, 104, 104, 104, 86, 261, 239, 262, 211, - 875, 261, 209, 262, 86, 255, 105, 209, 209, 875, - 276, 209, 209, 86, 253, 264, 261, 277, 262, 209, - 296, 242, 209, 254, 209, 212, 209, 105, 213, 215, - - 261, 255, 262, 216, 217, 283, 86, 875, 218, 219, - 243, 220, 243, 221, 86, 244, 244, 244, 244, 244, - 244, 86, 222, 223, 224, 261, 265, 262, 142, 306, - 86, 86, 278, 143, 86, 86, 285, 286, 287, 279, - 288, 289, 225, 86, 290, 226, 291, 245, 282, 86, - 86, 292, 293, 294, 86, 295, 297, 875, 298, 301, - 86, 86, 307, 86, 299, 300, 309, 303, 86, 86, - 304, 86, 302, 227, 231, 231, 231, 231, 231, 231, - 86, 86, 86, 312, 310, 311, 313, 86, 86, 86, - 232, 233, 86, 234, 235, 86, 142, 86, 314, 86, - - 321, 315, 330, 86, 320, 86, 236, 318, 86, 316, - 317, 232, 233, 232, 319, 325, 234, 86, 235, 322, - 86, 86, 86, 331, 333, 328, 332, 629, 326, 323, - 324, 86, 207, 208, 337, 335, 338, 207, 365, 86, - 329, 342, 334, 336, 339, 327, 195, 80, 81, 81, - 81, 195, 198, 199, 196, 86, 86, 198, 198, 199, - 356, 365, 357, 198, 340, 199, 356, 343, 357, 340, - 356, 341, 357, 200, 200, 200, 200, 200, 200, 200, - 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, - 200, 348, 348, 348, 348, 357, 357, 356, 86, 357, - - 358, 356, 356, 357, 357, 356, 359, 357, 356, 356, - 357, 357, 356, 356, 357, 357, 369, 365, 403, 366, - 369, 366, 86, 349, 367, 367, 367, 367, 367, 367, - 875, 232, 233, 86, 234, 235, 261, 369, 262, 369, - 365, 261, 405, 262, 369, 104, 104, 104, 104, 104, - 104, 398, 232, 233, 232, 374, 368, 234, 86, 235, - 86, 86, 105, 86, 371, 244, 244, 244, 244, 244, - 244, 384, 386, 397, 86, 86, 399, 253, 401, 400, - 402, 374, 86, 105, 372, 372, 372, 372, 372, 372, - 104, 104, 104, 104, 104, 104, 377, 384, 387, 86, - - 232, 86, 86, 234, 235, 243, 404, 243, 411, 86, - 244, 244, 244, 244, 244, 244, 373, 410, 379, 86, - 380, 232, 253, 232, 381, 409, 234, 419, 235, 86, - 382, 111, 111, 111, 111, 111, 111, 86, 86, 86, - 86, 86, 383, 86, 412, 415, 380, 86, 416, 86, - 381, 86, 406, 86, 413, 414, 417, 86, 407, 408, - 422, 86, 421, 258, 86, 420, 86, 86, 418, 424, - 86, 423, 428, 86, 426, 427, 430, 86, 429, 425, - 86, 86, 86, 86, 86, 431, 432, 433, 86, 437, - 86, 435, 86, 438, 86, 439, 434, 86, 436, 86, - - 86, 86, 86, 86, 86, 86, 86, 443, 86, 86, - 444, 441, 440, 446, 86, 442, 445, 451, 86, 86, - 142, 450, 86, 86, 447, 449, 448, 456, 452, 86, - 86, 459, 453, 86, 494, 460, 454, 455, 340, 199, - 457, 199, 458, 340, 356, 341, 357, 197, 461, 209, - 209, 209, 209, 348, 348, 348, 348, 356, 495, 357, - 86, 86, 86, 86, 367, 367, 367, 367, 367, 367, - 366, 509, 366, 514, 86, 367, 367, 367, 367, 367, - 367, 471, 482, 482, 482, 482, 482, 482, 231, 231, - 231, 231, 231, 231, 86, 86, 516, 86, 232, 486, - - 875, 234, 235, 240, 240, 240, 240, 104, 104, 487, - 489, 510, 486, 512, 483, 377, 490, 545, 490, 232, - 370, 232, 488, 86, 234, 486, 235, 372, 372, 372, - 372, 372, 372, 86, 875, 371, 489, 379, 486, 380, - 86, 525, 490, 381, 490, 491, 529, 491, 511, 382, - 492, 492, 492, 492, 492, 492, 379, 86, 380, 373, - 86, 383, 381, 86, 86, 380, 513, 86, 496, 381, - 86, 86, 515, 517, 86, 86, 519, 86, 86, 86, - 383, 86, 493, 518, 380, 86, 526, 521, 381, 520, - 86, 522, 523, 524, 527, 86, 531, 532, 530, 86, - - 86, 528, 86, 86, 86, 533, 86, 86, 86, 534, - 86, 535, 538, 541, 86, 543, 539, 86, 86, 86, - 86, 536, 86, 542, 537, 544, 86, 540, 86, 551, - 86, 86, 547, 86, 549, 86, 546, 86, 86, 86, - 548, 86, 550, 552, 86, 86, 558, 86, 86, 86, - 555, 553, 554, 556, 560, 561, 559, 557, 86, 86, - 567, 566, 86, 716, 563, 562, 199, 564, 86, 568, - 486, 569, 570, 209, 209, 209, 209, 565, 482, 482, - 482, 482, 482, 482, 372, 372, 372, 372, 372, 372, - 616, 86, 486, 486, 232, 592, 486, 234, 235, 588, - - 86, 588, 487, 591, 589, 589, 589, 589, 589, 589, - 483, 614, 86, 612, 86, 232, 484, 232, 486, 486, - 234, 592, 235, 492, 492, 492, 492, 492, 492, 611, - 86, 86, 86, 86, 621, 620, 590, 593, 593, 593, - 593, 593, 593, 86, 615, 613, 617, 86, 618, 86, - 86, 86, 86, 594, 626, 875, 595, 596, 491, 856, - 491, 619, 622, 492, 492, 492, 492, 492, 492, 597, - 623, 86, 86, 624, 594, 86, 594, 86, 86, 595, - 625, 596, 86, 627, 86, 86, 630, 86, 628, 635, - 634, 86, 86, 633, 86, 86, 636, 86, 86, 632, - - 631, 86, 86, 641, 86, 86, 86, 86, 86, 638, - 642, 86, 639, 640, 86, 86, 644, 637, 86, 643, - 645, 646, 86, 647, 648, 652, 86, 651, 86, 650, - 86, 649, 86, 656, 653, 658, 86, 655, 654, 86, - 86, 86, 86, 86, 657, 659, 86, 86, 682, 660, - 682, 86, 696, 695, 700, 662, 749, 661, 482, 482, - 482, 482, 482, 482, 589, 589, 589, 589, 589, 589, - 588, 682, 588, 682, 86, 589, 589, 589, 589, 589, - 589, 593, 593, 593, 593, 593, 593, 697, 86, 86, - 587, 680, 680, 680, 680, 680, 680, 683, 86, 86, - - 86, 683, 86, 693, 86, 698, 86, 594, 701, 703, - 595, 596, 699, 597, 86, 86, 694, 704, 683, 702, - 683, 705, 86, 681, 86, 683, 86, 712, 594, 706, - 594, 86, 86, 595, 710, 596, 86, 707, 86, 708, - 86, 86, 86, 711, 86, 86, 709, 713, 86, 715, - 718, 86, 86, 86, 86, 86, 714, 86, 86, 86, - 717, 722, 726, 86, 719, 723, 727, 720, 86, 86, - 721, 86, 725, 729, 86, 875, 875, 728, 724, 745, - 730, 748, 86, 747, 731, 680, 680, 680, 680, 680, - 680, 593, 593, 593, 593, 593, 593, 86, 86, 86, - - 86, 594, 750, 751, 595, 596, 86, 746, 86, 752, - 86, 86, 755, 759, 754, 86, 753, 681, 757, 756, - 762, 86, 594, 684, 594, 86, 86, 595, 760, 596, - 761, 86, 758, 86, 763, 86, 86, 86, 86, 764, - 86, 86, 86, 765, 86, 86, 766, 769, 86, 86, - 767, 86, 86, 86, 768, 86, 86, 774, 790, 86, - 775, 86, 771, 770, 86, 792, 772, 791, 86, 773, - 680, 680, 680, 680, 680, 680, 788, 86, 789, 86, - 796, 794, 793, 798, 86, 86, 86, 799, 800, 86, - 86, 86, 797, 801, 795, 86, 86, 86, 802, 803, - - 86, 86, 738, 86, 804, 86, 823, 86, 86, 86, - 86, 825, 826, 805, 806, 828, 86, 86, 86, 822, - 829, 821, 86, 86, 820, 827, 831, 824, 86, 86, - 86, 832, 86, 86, 834, 86, 846, 86, 830, 833, - 86, 847, 845, 844, 86, 835, 86, 849, 86, 86, - 86, 851, 852, 86, 86, 848, 86, 859, 86, 853, - 86, 86, 854, 850, 86, 857, 858, 861, 860, 86, - 86, 86, 862, 863, 86, 86, 86, 866, 86, 868, - 864, 86, 86, 86, 86, 867, 865, 875, 86, 875, - 855, 871, 86, 86, 874, 86, 86, 86, 875, 875, - - 869, 843, 870, 875, 842, 872, 873, 68, 68, 68, - 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, - 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, - 74, 74, 74, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 77, 77, 85, 875, 840, 85, - 875, 85, 85, 85, 85, 85, 139, 839, 875, 838, - 139, 139, 139, 139, 139, 139, 197, 197, 197, 197, - 197, 197, 197, 197, 197, 197, 197, 197, 197, 202, - 875, 837, 202, 86, 202, 202, 202, 202, 202, 206, - 86, 206, 206, 86, 206, 206, 206, 206, 206, 206, - - 875, 206, 214, 819, 875, 214, 214, 214, 214, 214, - 214, 214, 214, 818, 214, 237, 237, 237, 237, 237, - 237, 237, 237, 237, 237, 237, 237, 237, 251, 251, - 816, 251, 875, 814, 875, 251, 267, 812, 875, 267, - 810, 267, 267, 267, 267, 267, 271, 808, 271, 86, - 86, 86, 271, 273, 86, 273, 86, 86, 86, 273, - 344, 86, 344, 86, 86, 86, 344, 346, 86, 346, - 875, 787, 785, 346, 350, 875, 350, 875, 782, 780, - 350, 352, 778, 352, 86, 86, 86, 352, 354, 86, - 354, 86, 86, 86, 354, 361, 86, 361, 744, 741, - - 740, 361, 363, 738, 363, 203, 734, 733, 363, 237, - 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - 237, 237, 376, 664, 376, 378, 378, 86, 378, 378, - 378, 86, 378, 251, 251, 86, 251, 388, 86, 388, - 86, 86, 86, 388, 390, 86, 390, 86, 86, 86, - 390, 392, 86, 392, 86, 86, 86, 392, 271, 691, - 271, 394, 690, 394, 688, 686, 684, 394, 273, 591, - 273, 85, 679, 678, 85, 676, 85, 85, 85, 85, - 85, 197, 197, 197, 197, 197, 197, 197, 197, 197, - 197, 197, 197, 197, 462, 462, 462, 462, 462, 462, - - 462, 462, 462, 462, 462, 462, 462, 463, 674, 463, - 672, 670, 668, 463, 465, 666, 465, 664, 86, 86, - 465, 467, 86, 467, 86, 86, 86, 467, 344, 86, - 344, 469, 86, 469, 86, 610, 608, 469, 346, 606, - 346, 472, 604, 472, 602, 600, 496, 472, 350, 598, - 350, 474, 598, 474, 587, 586, 584, 474, 352, 477, - 352, 476, 477, 476, 582, 580, 578, 476, 354, 576, - 354, 478, 574, 478, 572, 86, 86, 478, 361, 86, - 361, 480, 86, 480, 86, 86, 86, 480, 363, 86, - 363, 485, 508, 485, 506, 485, 504, 485, 376, 502, - - 376, 500, 376, 498, 376, 378, 378, 484, 378, 378, - 378, 481, 378, 497, 479, 497, 357, 357, 477, 497, - 499, 475, 499, 473, 470, 468, 499, 501, 466, 501, - 464, 86, 86, 501, 388, 86, 388, 503, 396, 503, - 395, 393, 391, 503, 390, 389, 390, 505, 268, 505, - 263, 262, 385, 505, 392, 385, 392, 507, 250, 507, - 375, 375, 238, 507, 394, 370, 394, 85, 364, 362, - 85, 360, 85, 85, 85, 85, 85, 462, 462, 462, - 462, 462, 462, 462, 462, 462, 462, 462, 462, 462, - 571, 356, 571, 355, 353, 351, 571, 463, 347, 463, - - 573, 345, 573, 203, 199, 86, 573, 465, 275, 465, - 575, 274, 575, 272, 268, 263, 575, 467, 266, 467, - 577, 263, 577, 261, 260, 259, 577, 469, 238, 469, - 579, 230, 579, 84, 84, 86, 579, 472, 203, 472, - 581, 201, 581, 84, 121, 116, 581, 474, 86, 474, - 476, 875, 476, 69, 69, 875, 476, 583, 875, 583, - 875, 875, 875, 583, 478, 875, 478, 585, 875, 585, - 875, 875, 875, 585, 480, 875, 480, 485, 875, 485, - 875, 485, 875, 485, 378, 875, 378, 875, 875, 875, - 378, 599, 875, 599, 875, 875, 875, 599, 497, 875, - - 497, 601, 875, 601, 875, 875, 875, 601, 499, 875, - 499, 603, 875, 603, 875, 875, 875, 603, 501, 875, - 501, 605, 875, 605, 875, 875, 875, 605, 503, 875, - 503, 607, 875, 607, 875, 875, 875, 607, 505, 875, - 505, 609, 875, 609, 875, 875, 875, 609, 507, 875, - 507, 85, 875, 875, 85, 875, 85, 85, 85, 85, - 85, 663, 663, 663, 663, 663, 663, 663, 663, 663, - 663, 663, 663, 663, 665, 875, 665, 875, 875, 875, - 665, 571, 875, 571, 667, 875, 667, 875, 875, 875, - 667, 573, 875, 573, 669, 875, 669, 875, 875, 875, - - 669, 575, 875, 575, 671, 875, 671, 875, 875, 875, - 671, 577, 875, 577, 673, 875, 673, 875, 875, 875, - 673, 579, 875, 579, 675, 875, 675, 875, 875, 875, - 675, 581, 875, 581, 677, 875, 677, 875, 875, 875, - 677, 583, 875, 583, 85, 875, 85, 875, 875, 875, - 85, 585, 875, 585, 485, 875, 485, 875, 875, 875, - 485, 685, 875, 685, 875, 875, 875, 685, 599, 875, - 599, 687, 875, 687, 875, 875, 875, 687, 601, 875, - 601, 689, 875, 689, 875, 875, 875, 689, 603, 875, - 603, 139, 875, 139, 875, 875, 875, 139, 605, 875, - - 605, 692, 875, 692, 607, 875, 607, 85, 875, 875, - 85, 875, 85, 85, 85, 85, 85, 609, 875, 609, - 663, 663, 663, 663, 663, 663, 663, 663, 663, 663, - 663, 663, 663, 732, 875, 732, 875, 875, 875, 732, - 665, 875, 665, 202, 875, 202, 875, 875, 875, 202, - 667, 875, 667, 735, 875, 735, 669, 875, 669, 202, - 875, 875, 202, 875, 202, 202, 202, 202, 202, 671, - 875, 671, 736, 875, 736, 673, 875, 673, 675, 875, - 675, 737, 875, 737, 677, 875, 677, 85, 875, 85, - 739, 875, 739, 875, 875, 875, 739, 685, 875, 685, - - 267, 875, 267, 875, 875, 875, 267, 687, 875, 687, - 742, 875, 742, 689, 875, 689, 139, 875, 139, 743, - 875, 743, 875, 875, 875, 743, 85, 875, 875, 85, - 875, 85, 85, 85, 85, 85, 776, 875, 776, 732, - 875, 732, 202, 875, 202, 777, 875, 777, 875, 875, - 875, 777, 779, 875, 779, 875, 875, 875, 779, 781, - 875, 781, 875, 875, 875, 781, 783, 875, 783, 784, - 875, 784, 875, 875, 875, 784, 786, 875, 786, 875, - 875, 875, 786, 807, 875, 807, 875, 875, 875, 807, - 809, 875, 809, 875, 875, 875, 809, 811, 875, 811, - - 875, 875, 875, 811, 813, 875, 813, 875, 875, 875, - 813, 815, 875, 815, 875, 875, 875, 815, 817, 875, - 817, 875, 875, 875, 817, 609, 875, 609, 875, 875, - 875, 609, 836, 875, 836, 875, 875, 875, 836, 671, - 875, 671, 875, 875, 875, 671, 675, 875, 675, 875, - 875, 875, 675, 85, 875, 85, 875, 875, 875, 85, - 841, 875, 841, 875, 875, 875, 841, 139, 875, 139, - 875, 875, 875, 139, 202, 875, 202, 875, 875, 875, - 202, 11, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875 + 71, 71, 71, 71, 71, 71, 71, 71, 71, 72, + 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, + 72, 72, 72, 72, 72, 71, 73, 71, 71, 72, + 74, 72, 72, 72, 72, 72, 72, 72, 72, 72, + 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, + 72, 72, 72, 72, 72, 71, 71, 71, 71, 76, + 76, 79, 79, 123, 124, 90, 141, 79, 79, 87, + 76, 76, 80, 81, 82, 82, 82, 80, 82, 81, + + 83, 83, 83, 82, 91, 93, 87, 142, 146, 98, + 95, 99, 99, 99, 99, 99, 99, 252, 887, 94, + 100, 85, 96, 97, 85, 101, 161, 118, 143, 77, + 77, 77, 77, 144, 147, 102, 103, 87, 104, 104, + 104, 104, 105, 105, 119, 87, 120, 121, 148, 263, + 149, 264, 254, 260, 183, 106, 195, 87, 159, 107, + 160, 150, 151, 152, 87, 108, 109, 153, 154, 162, + 155, 110, 87, 156, 157, 145, 163, 106, 87, 182, + 87, 158, 164, 111, 206, 87, 263, 87, 264, 87, + 87, 108, 194, 87, 109, 103, 250, 112, 112, 112, + + 112, 112, 112, 87, 169, 177, 170, 196, 193, 87, + 207, 180, 165, 230, 106, 171, 166, 181, 113, 178, + 251, 167, 87, 258, 114, 168, 179, 172, 87, 263, + 115, 264, 248, 87, 87, 173, 106, 174, 249, 231, + 175, 143, 116, 263, 176, 264, 144, 259, 317, 283, + 114, 125, 280, 500, 249, 126, 127, 87, 128, 191, + 129, 130, 256, 131, 249, 132, 87, 265, 257, 184, + 185, 257, 248, 87, 133, 134, 135, 501, 188, 186, + 249, 263, 187, 264, 271, 87, 189, 265, 145, 256, + 305, 200, 201, 190, 257, 136, 200, 257, 137, 263, + + 887, 264, 192, 197, 81, 82, 82, 82, 197, 87, + 272, 198, 202, 202, 202, 202, 202, 202, 80, 81, + 82, 82, 82, 80, 87, 138, 139, 209, 210, 263, + 887, 264, 209, 282, 211, 255, 263, 267, 264, 211, + 82, 81, 82, 82, 82, 82, 87, 887, 212, 212, + 212, 212, 82, 81, 83, 83, 83, 82, 887, 211, + 99, 99, 99, 99, 99, 99, 242, 242, 242, 242, + 266, 263, 263, 264, 264, 213, 143, 263, 211, 264, + 87, 144, 375, 211, 211, 87, 87, 211, 211, 87, + 87, 87, 286, 241, 887, 211, 87, 87, 211, 243, + + 211, 214, 211, 281, 215, 217, 278, 284, 285, 218, + 219, 307, 298, 279, 220, 221, 87, 222, 87, 223, + 87, 87, 887, 87, 309, 300, 87, 87, 224, 225, + 226, 103, 303, 105, 105, 105, 105, 105, 105, 87, + 299, 87, 301, 302, 87, 304, 308, 310, 87, 227, + 106, 245, 228, 245, 306, 87, 246, 246, 246, 246, + 246, 246, 87, 313, 87, 315, 244, 87, 87, 311, + 314, 87, 106, 87, 87, 87, 323, 87, 87, 322, + 229, 233, 233, 233, 233, 233, 233, 312, 333, 247, + 319, 316, 328, 320, 318, 87, 87, 234, 235, 236, + + 321, 237, 236, 87, 324, 87, 325, 143, 335, 360, + 331, 361, 87, 87, 238, 337, 326, 327, 87, 236, + 235, 236, 87, 329, 237, 332, 236, 287, 288, 289, + 336, 290, 291, 334, 87, 292, 87, 293, 407, 360, + 330, 361, 294, 295, 296, 87, 297, 339, 360, 343, + 361, 87, 200, 201, 338, 340, 346, 200, 341, 87, + 342, 197, 81, 82, 82, 82, 197, 200, 201, 198, + 378, 361, 200, 202, 202, 202, 202, 202, 202, 344, + 201, 360, 347, 361, 344, 360, 345, 361, 202, 202, + 202, 202, 202, 202, 209, 210, 378, 143, 361, 209, + + 202, 202, 202, 202, 202, 202, 352, 352, 352, 352, + 360, 87, 361, 362, 360, 360, 361, 361, 360, 363, + 361, 360, 360, 361, 361, 369, 369, 370, 369, 370, + 435, 87, 371, 371, 371, 371, 371, 371, 373, 353, + 373, 87, 263, 373, 264, 263, 87, 264, 369, 402, + 87, 369, 234, 235, 236, 406, 237, 236, 388, 401, + 373, 87, 373, 87, 87, 372, 390, 373, 105, 105, + 105, 105, 105, 105, 236, 235, 236, 404, 87, 237, + 405, 236, 403, 408, 388, 106, 246, 246, 246, 246, + 246, 246, 391, 87, 87, 87, 87, 87, 87, 419, + + 87, 255, 425, 432, 87, 420, 434, 106, 376, 376, + 376, 376, 376, 376, 381, 409, 413, 105, 105, 105, + 105, 105, 105, 87, 234, 245, 236, 245, 237, 236, + 246, 246, 246, 246, 246, 246, 87, 383, 410, 384, + 87, 377, 87, 385, 411, 412, 236, 87, 236, 386, + 255, 237, 87, 236, 112, 112, 112, 112, 112, 112, + 414, 387, 415, 417, 418, 384, 87, 416, 87, 385, + 87, 87, 87, 87, 87, 87, 87, 87, 87, 421, + 427, 426, 433, 87, 437, 87, 87, 260, 423, 424, + 87, 87, 436, 429, 428, 422, 87, 430, 431, 439, + + 87, 438, 87, 87, 446, 441, 440, 442, 443, 87, + 87, 87, 87, 87, 87, 445, 87, 87, 87, 87, + 87, 448, 447, 87, 87, 444, 449, 451, 87, 456, + 87, 450, 87, 87, 87, 452, 455, 454, 87, 453, + 457, 462, 460, 461, 87, 87, 458, 464, 87, 515, + 459, 463, 465, 466, 344, 201, 201, 87, 887, 344, + 467, 345, 199, 211, 211, 211, 211, 352, 352, 352, + 352, 360, 360, 361, 361, 371, 371, 371, 371, 371, + 371, 370, 569, 370, 492, 492, 371, 371, 371, 371, + 371, 371, 887, 87, 493, 494, 477, 488, 488, 488, + + 488, 488, 488, 233, 233, 233, 233, 233, 233, 516, + 492, 492, 87, 234, 87, 236, 87, 237, 236, 242, + 242, 242, 242, 105, 105, 495, 381, 517, 87, 87, + 489, 496, 87, 518, 87, 236, 374, 236, 519, 520, + 237, 521, 236, 376, 376, 376, 376, 376, 376, 383, + 87, 384, 375, 496, 87, 385, 522, 496, 497, 887, + 497, 386, 87, 498, 498, 498, 498, 498, 498, 87, + 525, 495, 526, 387, 87, 524, 377, 384, 523, 496, + 87, 385, 383, 87, 384, 87, 87, 527, 385, 87, + 87, 532, 87, 87, 502, 87, 499, 87, 535, 528, + + 529, 537, 530, 531, 533, 87, 387, 87, 87, 541, + 384, 534, 538, 87, 385, 87, 536, 87, 87, 87, + 539, 540, 87, 87, 546, 87, 87, 87, 544, 542, + 87, 548, 87, 87, 547, 543, 87, 87, 549, 87, + 545, 87, 552, 87, 87, 550, 556, 554, 551, 87, + 559, 87, 553, 555, 87, 87, 557, 87, 87, 558, + 87, 87, 87, 564, 560, 567, 563, 568, 87, 561, + 566, 562, 87, 565, 87, 87, 571, 87, 87, 573, + 627, 201, 492, 570, 576, 574, 572, 577, 211, 211, + 211, 211, 493, 87, 575, 488, 488, 488, 488, 488, + + 488, 376, 376, 376, 376, 376, 376, 87, 492, 87, + 618, 234, 595, 236, 595, 237, 236, 596, 596, 596, + 596, 596, 596, 492, 87, 599, 492, 621, 489, 87, + 87, 623, 87, 236, 490, 236, 598, 619, 237, 87, + 236, 498, 498, 498, 498, 498, 498, 620, 87, 492, + 597, 599, 492, 600, 600, 600, 600, 600, 600, 87, + 631, 622, 87, 887, 625, 887, 87, 862, 87, 601, + 497, 602, 497, 603, 602, 498, 498, 498, 498, 498, + 498, 624, 628, 87, 87, 630, 604, 87, 87, 87, + 87, 602, 633, 602, 626, 636, 603, 632, 602, 629, + + 634, 87, 87, 635, 87, 87, 87, 642, 87, 87, + 637, 641, 87, 87, 640, 87, 87, 643, 647, 639, + 87, 87, 887, 87, 87, 87, 638, 87, 87, 644, + 645, 646, 648, 650, 87, 87, 87, 649, 87, 653, + 651, 87, 652, 87, 654, 655, 87, 87, 87, 87, + 656, 657, 87, 660, 659, 661, 664, 87, 658, 87, + 87, 663, 87, 87, 87, 668, 665, 688, 688, 662, + 666, 701, 702, 887, 887, 87, 667, 488, 488, 488, + 488, 488, 488, 596, 596, 596, 596, 596, 596, 595, + 688, 595, 704, 87, 596, 596, 596, 596, 596, 596, + + 600, 600, 600, 600, 600, 600, 703, 688, 87, 887, + 594, 686, 686, 686, 686, 686, 686, 689, 87, 689, + 87, 87, 689, 699, 87, 708, 87, 601, 706, 602, + 688, 603, 602, 604, 707, 87, 700, 710, 709, 689, + 87, 689, 87, 705, 687, 87, 689, 87, 87, 602, + 87, 602, 87, 716, 603, 718, 602, 712, 87, 87, + 87, 87, 711, 87, 714, 87, 87, 713, 87, 717, + 715, 87, 721, 719, 87, 724, 87, 87, 722, 720, + 727, 87, 87, 87, 725, 87, 731, 723, 87, 732, + 726, 87, 87, 861, 728, 734, 87, 733, 730, 87, + + 735, 87, 87, 729, 87, 87, 751, 736, 686, 686, + 686, 686, 686, 686, 600, 600, 600, 600, 600, 600, + 750, 87, 755, 87, 601, 763, 602, 752, 603, 602, + 753, 87, 87, 764, 87, 756, 754, 757, 87, 758, + 87, 687, 87, 87, 759, 767, 602, 690, 602, 761, + 87, 603, 766, 602, 87, 760, 87, 762, 87, 765, + 87, 768, 87, 769, 87, 87, 87, 87, 770, 87, + 87, 87, 87, 87, 771, 87, 774, 87, 772, 87, + 87, 779, 87, 87, 795, 87, 780, 773, 87, 87, + 776, 87, 775, 803, 777, 796, 778, 686, 686, 686, + + 686, 686, 686, 793, 87, 794, 799, 87, 798, 87, + 801, 87, 87, 87, 797, 804, 805, 800, 806, 87, + 87, 87, 802, 807, 87, 87, 87, 808, 87, 87, + 743, 87, 87, 87, 809, 828, 87, 87, 87, 830, + 831, 833, 87, 87, 87, 834, 87, 836, 810, 811, + 826, 827, 87, 829, 87, 825, 832, 837, 87, 87, + 87, 838, 839, 87, 87, 835, 87, 87, 87, 851, + 850, 855, 87, 852, 840, 87, 87, 87, 853, 857, + 849, 87, 87, 87, 854, 858, 859, 87, 87, 856, + 860, 87, 863, 864, 865, 87, 87, 866, 87, 868, + + 867, 869, 87, 87, 87, 870, 87, 87, 87, 873, + 87, 875, 87, 876, 87, 87, 87, 874, 87, 872, + 87, 87, 87, 871, 87, 880, 87, 87, 87, 887, + 879, 881, 887, 848, 877, 878, 886, 887, 847, 884, + 887, 845, 882, 883, 887, 844, 885, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, + 75, 75, 75, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 78, 78, 86, 887, 843, 86, + 887, 86, 86, 86, 86, 86, 140, 842, 87, 87, + + 140, 140, 140, 140, 140, 140, 199, 199, 199, 199, + 199, 199, 199, 199, 199, 199, 199, 199, 199, 204, + 87, 887, 204, 824, 204, 204, 204, 204, 204, 208, + 887, 208, 208, 823, 208, 208, 208, 208, 208, 208, + 821, 208, 216, 887, 819, 216, 216, 216, 216, 216, + 216, 216, 216, 887, 216, 239, 239, 239, 239, 239, + 239, 239, 239, 239, 239, 239, 239, 239, 253, 253, + 817, 253, 887, 815, 813, 253, 269, 87, 87, 269, + 87, 269, 269, 269, 269, 269, 273, 87, 273, 87, + 87, 87, 273, 275, 87, 275, 87, 87, 87, 275, + + 348, 87, 348, 887, 792, 790, 348, 350, 887, 350, + 887, 787, 785, 350, 354, 783, 354, 87, 87, 87, + 354, 356, 87, 356, 87, 87, 87, 356, 358, 749, + 358, 746, 745, 743, 358, 365, 205, 365, 739, 738, + 670, 365, 367, 87, 367, 87, 87, 87, 367, 239, + 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, + 239, 239, 380, 87, 380, 382, 382, 87, 382, 382, + 382, 87, 382, 253, 253, 87, 253, 392, 87, 392, + 87, 87, 87, 392, 394, 87, 394, 87, 87, 697, + 394, 396, 696, 396, 694, 692, 690, 396, 273, 598, + + 273, 398, 685, 398, 684, 682, 680, 398, 275, 678, + 275, 86, 676, 674, 86, 672, 86, 86, 86, 86, + 86, 199, 199, 199, 199, 199, 199, 199, 199, 199, + 199, 199, 199, 199, 468, 468, 468, 468, 468, 468, + 468, 468, 468, 468, 468, 468, 468, 469, 670, 469, + 87, 87, 87, 469, 471, 87, 471, 87, 87, 87, + 471, 473, 87, 473, 87, 87, 87, 473, 348, 617, + 348, 475, 615, 475, 613, 611, 609, 475, 350, 607, + 350, 478, 502, 478, 605, 605, 594, 478, 354, 593, + 354, 480, 591, 480, 483, 483, 589, 480, 356, 587, + + 356, 482, 585, 482, 583, 581, 579, 482, 358, 87, + 358, 484, 87, 484, 87, 87, 87, 484, 365, 87, + 365, 486, 87, 486, 87, 514, 512, 486, 367, 510, + 367, 491, 508, 491, 506, 491, 504, 491, 380, 490, + 380, 487, 380, 485, 380, 382, 382, 361, 382, 382, + 382, 361, 382, 503, 483, 503, 481, 479, 476, 503, + 505, 474, 505, 472, 470, 87, 505, 507, 87, 507, + 87, 400, 399, 507, 392, 397, 392, 509, 395, 509, + 393, 270, 265, 509, 394, 264, 394, 511, 389, 511, + 389, 252, 379, 511, 396, 379, 396, 513, 240, 513, + + 374, 368, 366, 513, 398, 364, 398, 86, 360, 359, + 86, 357, 86, 86, 86, 86, 86, 468, 468, 468, + 468, 468, 468, 468, 468, 468, 468, 468, 468, 468, + 578, 355, 578, 351, 349, 205, 578, 469, 201, 469, + 580, 87, 580, 277, 276, 274, 580, 471, 270, 471, + 582, 265, 582, 268, 265, 263, 582, 473, 262, 473, + 584, 261, 584, 240, 232, 85, 584, 475, 85, 475, + 586, 87, 586, 205, 203, 85, 586, 478, 122, 478, + 588, 117, 588, 87, 887, 70, 588, 480, 70, 480, + 482, 887, 482, 887, 887, 887, 482, 590, 887, 590, + + 887, 887, 887, 590, 484, 887, 484, 592, 887, 592, + 887, 887, 887, 592, 486, 887, 486, 491, 887, 491, + 887, 491, 887, 491, 382, 887, 382, 887, 887, 887, + 382, 606, 887, 606, 887, 887, 887, 606, 503, 887, + 503, 608, 887, 608, 887, 887, 887, 608, 505, 887, + 505, 610, 887, 610, 887, 887, 887, 610, 507, 887, + 507, 612, 887, 612, 887, 887, 887, 612, 509, 887, + 509, 614, 887, 614, 887, 887, 887, 614, 511, 887, + 511, 616, 887, 616, 887, 887, 887, 616, 513, 887, + 513, 86, 887, 887, 86, 887, 86, 86, 86, 86, + + 86, 669, 669, 669, 669, 669, 669, 669, 669, 669, + 669, 669, 669, 669, 671, 887, 671, 887, 887, 887, + 671, 578, 887, 578, 673, 887, 673, 887, 887, 887, + 673, 580, 887, 580, 675, 887, 675, 887, 887, 887, + 675, 582, 887, 582, 677, 887, 677, 887, 887, 887, + 677, 584, 887, 584, 679, 887, 679, 887, 887, 887, + 679, 586, 887, 586, 681, 887, 681, 887, 887, 887, + 681, 588, 887, 588, 683, 887, 683, 887, 887, 887, + 683, 590, 887, 590, 86, 887, 86, 887, 887, 887, + 86, 592, 887, 592, 491, 887, 491, 887, 887, 887, + + 491, 691, 887, 691, 887, 887, 887, 691, 606, 887, + 606, 693, 887, 693, 887, 887, 887, 693, 608, 887, + 608, 695, 887, 695, 887, 887, 887, 695, 610, 887, + 610, 140, 887, 140, 887, 887, 887, 140, 612, 887, + 612, 698, 887, 698, 614, 887, 614, 86, 887, 887, + 86, 887, 86, 86, 86, 86, 86, 616, 887, 616, + 669, 669, 669, 669, 669, 669, 669, 669, 669, 669, + 669, 669, 669, 737, 887, 737, 887, 887, 887, 737, + 671, 887, 671, 204, 887, 204, 887, 887, 887, 204, + 673, 887, 673, 740, 887, 740, 675, 887, 675, 204, + + 887, 887, 204, 887, 204, 204, 204, 204, 204, 677, + 887, 677, 741, 887, 741, 679, 887, 679, 681, 887, + 681, 742, 887, 742, 683, 887, 683, 86, 887, 86, + 744, 887, 744, 887, 887, 887, 744, 691, 887, 691, + 269, 887, 269, 887, 887, 887, 269, 693, 887, 693, + 747, 887, 747, 695, 887, 695, 140, 887, 140, 748, + 887, 748, 887, 887, 887, 748, 86, 887, 887, 86, + 887, 86, 86, 86, 86, 86, 781, 887, 781, 737, + 887, 737, 204, 887, 204, 782, 887, 782, 887, 887, + 887, 782, 784, 887, 784, 887, 887, 887, 784, 786, + + 887, 786, 887, 887, 887, 786, 788, 887, 788, 789, + 887, 789, 887, 887, 887, 789, 791, 887, 791, 887, + 887, 887, 791, 812, 887, 812, 887, 887, 887, 812, + 814, 887, 814, 887, 887, 887, 814, 816, 887, 816, + 887, 887, 887, 816, 818, 887, 818, 887, 887, 887, + 818, 820, 887, 820, 887, 887, 887, 820, 822, 887, + 822, 887, 887, 887, 822, 616, 887, 616, 887, 887, + 887, 616, 841, 887, 841, 887, 887, 887, 841, 677, + 887, 677, 887, 887, 887, 677, 681, 887, 681, 887, + 887, 887, 681, 86, 887, 86, 887, 887, 887, 86, + + 846, 887, 846, 887, 887, 887, 846, 140, 887, 140, + 887, 887, 887, 140, 204, 887, 204, 887, 887, 887, + 204, 11, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + + 887, 887, 887, 887, 887, 887, 887 } ; -static yyconst flex_int16_t yy_chk[2867] = +static yyconst flex_int16_t yy_chk[2908] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -1103,6 +1113,6 @@ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 2, 16, 24, 16, 24, 2, - 19, 19, 2, 5, 5, 5, 5, 5, 5, 5, + 1, 1, 1, 1, 1, 2, 16, 24, 16, 24, + 2, 19, 19, 2, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, @@ -1113,305 +1123,310 @@ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 5, 5, 5, 5, 5, 5, 5, 7, 8, 9, - 10, 37, 37, 20, 39, 9, 10, 874, 7, 8, - 13, 13, 13, 13, 13, 13, 15, 15, 15, 15, - - 15, 15, 20, 25, 39, 42, 53, 28, 27, 28, - 28, 28, 28, 28, 28, 108, 114, 25, 29, 25, - 27, 27, 27, 29, 53, 35, 7, 8, 9, 10, - 40, 42, 48, 29, 30, 40, 30, 30, 30, 30, - 30, 30, 35, 61, 35, 35, 44, 869, 44, 108, - 114, 868, 48, 30, 63, 61, 30, 56, 47, 45, - 45, 45, 30, 30, 45, 45, 56, 45, 30, 55, - 45, 45, 49, 40, 30, 45, 40, 49, 45, 47, - 30, 47, 72, 125, 49, 125, 51, 55, 30, 86, - 49, 30, 31, 55, 31, 31, 31, 31, 31, 31, - - 50, 51, 866, 51, 63, 153, 54, 58, 72, 50, - 60, 31, 51, 50, 31, 86, 54, 57, 50, 58, - 31, 153, 50, 54, 141, 156, 31, 58, 60, 57, - 57, 59, 31, 126, 58, 126, 59, 156, 31, 57, - 52, 865, 57, 67, 67, 52, 31, 38, 67, 59, - 141, 38, 38, 52, 38, 52, 38, 38, 52, 38, - 107, 38, 52, 113, 67, 67, 67, 67, 67, 67, - 38, 38, 38, 128, 59, 128, 152, 59, 66, 66, - 66, 66, 66, 66, 107, 152, 66, 113, 863, 862, - 38, 59, 165, 38, 79, 79, 79, 79, 79, 79, - - 81, 81, 81, 81, 81, 81, 82, 82, 82, 82, - 82, 82, 131, 165, 131, 103, 103, 103, 103, 106, - 38, 38, 76, 76, 856, 106, 112, 76, 168, 76, - 110, 133, 112, 133, 76, 102, 102, 102, 102, 102, - 102, 130, 103, 76, 76, 76, 76, 103, 110, 168, - 109, 106, 129, 130, 76, 130, 110, 104, 112, 104, - 104, 104, 104, 104, 104, 149, 129, 102, 129, 76, - 103, 136, 76, 136, 158, 115, 104, 76, 76, 109, - 149, 76, 76, 155, 109, 132, 132, 149, 132, 76, - 158, 104, 76, 115, 76, 76, 76, 104, 76, 84, - - 138, 115, 138, 84, 84, 155, 166, 109, 84, 84, - 105, 84, 105, 84, 150, 105, 105, 105, 105, 105, - 105, 151, 84, 84, 84, 134, 134, 134, 144, 166, - 154, 157, 150, 144, 159, 167, 157, 157, 157, 151, - 157, 157, 84, 161, 157, 84, 157, 105, 154, 160, - 163, 157, 157, 157, 162, 157, 159, 855, 160, 162, - 164, 169, 167, 170, 161, 161, 169, 163, 171, 172, - 164, 144, 162, 84, 98, 98, 98, 98, 98, 98, - 173, 174, 175, 171, 169, 170, 172, 179, 176, 185, - 98, 98, 178, 98, 98, 180, 189, 182, 173, 187, - - 180, 174, 185, 186, 179, 188, 98, 178, 181, 175, - 176, 98, 98, 98, 178, 182, 98, 183, 98, 181, - 184, 191, 190, 186, 188, 184, 187, 528, 183, 181, - 181, 192, 207, 207, 191, 190, 191, 207, 232, 189, - 184, 203, 189, 190, 192, 183, 195, 195, 195, 195, - 195, 195, 196, 196, 195, 528, 854, 196, 198, 198, - 216, 232, 216, 198, 200, 200, 217, 203, 217, 200, - 218, 200, 218, 196, 196, 196, 196, 196, 196, 198, - 198, 198, 198, 198, 198, 200, 200, 200, 200, 200, - 200, 210, 210, 210, 210, 219, 220, 221, 282, 221, - - 222, 222, 223, 222, 223, 224, 224, 224, 220, 219, - 220, 219, 226, 227, 226, 227, 234, 235, 282, 233, - 234, 233, 284, 210, 233, 233, 233, 233, 233, 233, - 241, 239, 239, 277, 239, 239, 264, 234, 264, 234, - 235, 265, 284, 265, 234, 242, 242, 242, 242, 242, - 242, 277, 239, 239, 239, 246, 233, 239, 278, 239, - 276, 280, 242, 279, 241, 243, 243, 243, 243, 243, - 243, 254, 268, 276, 853, 281, 278, 242, 280, 279, - 281, 246, 288, 242, 244, 244, 244, 244, 244, 244, - 253, 253, 253, 253, 253, 253, 251, 254, 268, 287, - - 244, 283, 286, 244, 244, 245, 283, 245, 288, 295, - 245, 245, 245, 245, 245, 245, 244, 287, 251, 849, - 251, 244, 253, 244, 251, 286, 244, 295, 244, 289, - 251, 258, 258, 258, 258, 258, 258, 285, 290, 292, - 291, 294, 251, 293, 289, 291, 251, 297, 292, 301, - 251, 299, 285, 303, 290, 290, 293, 298, 285, 285, - 299, 302, 298, 258, 300, 297, 307, 304, 294, 301, - 306, 300, 304, 305, 303, 303, 306, 308, 305, 302, - 310, 309, 311, 312, 313, 307, 308, 309, 314, 313, - 315, 311, 316, 314, 318, 315, 310, 317, 312, 320, - - 322, 321, 323, 324, 326, 325, 328, 318, 327, 329, - 320, 316, 315, 322, 330, 317, 321, 327, 333, 331, - 334, 326, 335, 337, 323, 325, 324, 333, 328, 336, - 338, 337, 329, 339, 381, 338, 330, 331, 340, 340, - 335, 341, 336, 340, 358, 340, 358, 341, 339, 348, - 348, 348, 348, 349, 349, 349, 349, 359, 381, 359, - 397, 846, 402, 334, 366, 366, 366, 366, 366, 366, - 368, 397, 368, 402, 404, 368, 368, 368, 368, 368, - 368, 348, 367, 367, 367, 367, 367, 367, 370, 370, - 370, 370, 370, 370, 400, 398, 404, 435, 367, 376, - - 843, 367, 367, 371, 371, 371, 371, 371, 371, 376, - 379, 398, 377, 400, 367, 378, 379, 435, 383, 367, - 370, 367, 377, 412, 367, 376, 367, 372, 372, 372, - 372, 372, 372, 399, 382, 371, 383, 378, 377, 378, - 415, 412, 379, 378, 383, 380, 415, 380, 399, 378, - 380, 380, 380, 380, 380, 380, 382, 401, 382, 372, - 407, 378, 382, 403, 405, 378, 401, 408, 382, 378, - 406, 411, 403, 405, 409, 410, 407, 416, 418, 414, - 382, 413, 380, 406, 382, 417, 413, 409, 382, 408, - 419, 410, 410, 411, 414, 421, 417, 418, 416, 423, - - 425, 414, 426, 427, 428, 419, 431, 429, 430, 421, - 433, 423, 427, 429, 436, 431, 427, 437, 438, 439, - 441, 425, 440, 430, 426, 433, 443, 428, 445, 441, - 447, 446, 437, 448, 439, 449, 436, 450, 451, 455, - 438, 452, 440, 443, 457, 633, 450, 460, 453, 458, - 447, 445, 446, 448, 452, 453, 451, 449, 454, 456, - 458, 457, 461, 633, 455, 454, 462, 456, 515, 460, - 488, 461, 462, 471, 471, 471, 471, 456, 482, 482, - 482, 482, 482, 482, 484, 484, 484, 484, 484, 484, - 515, 513, 485, 487, 482, 489, 488, 482, 482, 486, - - 510, 486, 485, 487, 486, 486, 486, 486, 486, 486, - 482, 513, 509, 510, 520, 482, 484, 482, 485, 487, - 482, 489, 482, 491, 491, 491, 491, 491, 491, 509, - 512, 514, 519, 516, 520, 519, 486, 492, 492, 492, - 492, 492, 492, 517, 514, 512, 516, 521, 517, 525, - 518, 522, 523, 492, 525, 842, 492, 492, 493, 841, - 493, 518, 521, 493, 493, 493, 493, 493, 493, 492, - 522, 524, 526, 523, 492, 527, 492, 529, 530, 492, - 524, 492, 531, 526, 532, 533, 529, 536, 527, 535, - 533, 538, 539, 532, 542, 535, 536, 540, 541, 531, - - 530, 544, 545, 542, 546, 547, 549, 554, 556, 539, - 544, 561, 540, 541, 555, 552, 546, 538, 550, 545, - 547, 549, 553, 550, 552, 556, 558, 555, 559, 554, - 560, 553, 562, 561, 558, 563, 564, 560, 559, 565, - 567, 563, 568, 613, 562, 564, 612, 617, 594, 565, - 596, 698, 613, 612, 617, 568, 698, 567, 587, 587, - 587, 587, 587, 587, 588, 588, 588, 588, 588, 588, - 590, 594, 590, 596, 614, 590, 590, 590, 590, 590, - 590, 593, 593, 593, 593, 593, 593, 614, 615, 616, - 587, 589, 589, 589, 589, 589, 589, 595, 611, 622, - - 618, 595, 619, 611, 621, 615, 620, 589, 618, 620, - 589, 589, 616, 593, 623, 624, 611, 621, 595, 619, - 595, 622, 625, 589, 626, 595, 628, 629, 589, 623, - 589, 627, 630, 589, 627, 589, 631, 624, 634, 625, - 632, 635, 637, 628, 638, 644, 626, 630, 639, 632, - 635, 645, 640, 650, 629, 647, 631, 696, 693, 651, - 634, 640, 650, 659, 637, 644, 651, 638, 658, 662, - 639, 661, 647, 659, 697, 840, 839, 658, 645, 693, - 661, 697, 699, 696, 662, 680, 680, 680, 680, 680, - 680, 684, 684, 684, 684, 684, 684, 694, 702, 705, - - 700, 680, 699, 700, 680, 680, 701, 694, 704, 701, - 706, 708, 705, 709, 704, 707, 702, 680, 707, 706, - 712, 711, 680, 684, 680, 710, 714, 680, 710, 680, - 711, 713, 708, 718, 713, 715, 716, 717, 720, 714, - 723, 709, 726, 715, 727, 712, 716, 720, 728, 730, - 717, 731, 752, 751, 718, 753, 749, 730, 751, 754, - 731, 750, 726, 723, 755, 753, 727, 752, 756, 728, - 738, 738, 738, 738, 738, 738, 749, 757, 750, 758, - 757, 755, 754, 759, 761, 763, 764, 761, 763, 767, - 768, 773, 758, 764, 756, 765, 766, 788, 765, 766, - - 790, 791, 738, 792, 767, 793, 792, 797, 794, 795, - 759, 794, 795, 768, 773, 798, 801, 799, 805, 791, - 799, 790, 821, 802, 788, 797, 802, 793, 803, 806, - 804, 803, 824, 823, 805, 822, 823, 825, 801, 804, - 798, 824, 822, 821, 826, 806, 827, 826, 830, 833, - 834, 830, 833, 835, 847, 825, 844, 847, 848, 834, - 857, 845, 835, 827, 850, 844, 845, 850, 848, 851, - 852, 858, 851, 852, 859, 860, 861, 859, 864, 861, - 857, 867, 870, 871, 873, 860, 858, 838, 872, 837, - 836, 870, 832, 831, 873, 829, 828, 820, 819, 818, - - 864, 817, 867, 816, 815, 871, 872, 876, 876, 876, - 876, 876, 876, 876, 876, 876, 876, 876, 876, 876, - 877, 877, 877, 877, 877, 877, 877, 877, 877, 877, - 877, 877, 877, 878, 878, 878, 878, 878, 878, 878, - 878, 878, 878, 878, 878, 878, 879, 814, 813, 879, - 812, 879, 879, 879, 879, 879, 880, 811, 810, 809, - 880, 880, 880, 880, 880, 880, 881, 881, 881, 881, - 881, 881, 881, 881, 881, 881, 881, 881, 881, 882, - 808, 807, 882, 800, 882, 882, 882, 882, 882, 883, - 796, 883, 883, 789, 883, 883, 883, 883, 883, 883, - - 787, 883, 884, 786, 785, 884, 884, 884, 884, 884, - 884, 884, 884, 784, 884, 885, 885, 885, 885, 885, - 885, 885, 885, 885, 885, 885, 885, 885, 886, 886, - 783, 886, 782, 781, 780, 886, 887, 779, 778, 887, - 777, 887, 887, 887, 887, 887, 888, 776, 888, 775, - 774, 772, 888, 889, 771, 889, 770, 769, 762, 889, - 890, 760, 890, 748, 747, 746, 890, 891, 745, 891, - 744, 743, 742, 891, 892, 741, 892, 740, 737, 736, - 892, 893, 735, 893, 729, 725, 724, 893, 894, 722, - 894, 721, 719, 703, 894, 895, 695, 895, 692, 687, - - 685, 895, 896, 681, 896, 671, 667, 665, 896, 897, - 897, 897, 897, 897, 897, 897, 897, 897, 897, 897, - 897, 897, 898, 663, 898, 899, 899, 660, 899, 899, - 899, 657, 899, 900, 900, 656, 900, 901, 655, 901, - 654, 653, 652, 901, 902, 649, 902, 648, 646, 643, - 902, 903, 642, 903, 641, 636, 609, 903, 904, 605, - 904, 905, 603, 905, 601, 599, 597, 905, 906, 591, - 906, 907, 585, 583, 907, 581, 907, 907, 907, 907, - 907, 908, 908, 908, 908, 908, 908, 908, 908, 908, - 908, 908, 908, 908, 909, 909, 909, 909, 909, 909, - - 909, 909, 909, 909, 909, 909, 909, 910, 579, 910, - 577, 575, 573, 910, 911, 571, 911, 570, 569, 566, - 911, 912, 557, 912, 551, 548, 543, 912, 913, 537, - 913, 914, 534, 914, 511, 507, 505, 914, 915, 503, - 915, 916, 501, 916, 499, 497, 496, 916, 917, 495, - 917, 918, 494, 918, 483, 480, 478, 918, 919, 477, - 919, 920, 476, 920, 474, 472, 469, 920, 921, 467, - 921, 922, 465, 922, 463, 459, 444, 922, 923, 442, - 923, 924, 434, 924, 432, 424, 422, 924, 925, 420, - 925, 926, 394, 926, 392, 926, 390, 926, 927, 388, - - 927, 387, 927, 386, 927, 928, 928, 373, 928, 928, - 928, 363, 928, 929, 361, 929, 360, 356, 354, 929, - 930, 352, 930, 350, 346, 344, 930, 931, 343, 931, - 342, 332, 319, 931, 932, 296, 932, 933, 275, 933, - 273, 271, 270, 933, 934, 269, 934, 935, 267, 935, - 266, 261, 257, 935, 936, 256, 936, 937, 252, 937, - 249, 248, 237, 937, 938, 236, 938, 939, 229, 228, - 939, 225, 939, 939, 939, 939, 939, 940, 940, 940, - 940, 940, 940, 940, 940, 940, 940, 940, 940, 940, - 941, 215, 941, 213, 212, 211, 941, 942, 205, 942, - - 943, 204, 943, 202, 197, 177, 943, 944, 148, 944, - 945, 146, 945, 145, 139, 137, 945, 946, 135, 946, - 947, 127, 947, 124, 123, 119, 947, 948, 100, 948, - 949, 97, 949, 94, 92, 85, 949, 950, 71, 950, - 951, 69, 951, 65, 36, 33, 951, 952, 18, 952, - 953, 11, 953, 4, 3, 0, 953, 954, 0, 954, - 0, 0, 0, 954, 955, 0, 955, 956, 0, 956, - 0, 0, 0, 956, 957, 0, 957, 958, 0, 958, - 0, 958, 0, 958, 959, 0, 959, 0, 0, 0, - 959, 960, 0, 960, 0, 0, 0, 960, 961, 0, - - 961, 962, 0, 962, 0, 0, 0, 962, 963, 0, - 963, 964, 0, 964, 0, 0, 0, 964, 965, 0, - 965, 966, 0, 966, 0, 0, 0, 966, 967, 0, - 967, 968, 0, 968, 0, 0, 0, 968, 969, 0, - 969, 970, 0, 970, 0, 0, 0, 970, 971, 0, - 971, 972, 0, 0, 972, 0, 972, 972, 972, 972, - 972, 973, 973, 973, 973, 973, 973, 973, 973, 973, - 973, 973, 973, 973, 974, 0, 974, 0, 0, 0, - 974, 975, 0, 975, 976, 0, 976, 0, 0, 0, - 976, 977, 0, 977, 978, 0, 978, 0, 0, 0, - - 978, 979, 0, 979, 980, 0, 980, 0, 0, 0, - 980, 981, 0, 981, 982, 0, 982, 0, 0, 0, - 982, 983, 0, 983, 984, 0, 984, 0, 0, 0, - 984, 985, 0, 985, 986, 0, 986, 0, 0, 0, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, + 8, 9, 10, 37, 37, 20, 39, 9, 10, 886, + 7, 8, 13, 13, 13, 13, 13, 13, 15, 15, + + 15, 15, 15, 15, 20, 25, 48, 39, 42, 28, + 27, 28, 28, 28, 28, 28, 28, 109, 115, 25, + 29, 25, 27, 27, 27, 29, 48, 35, 40, 7, + 8, 9, 10, 40, 42, 29, 30, 47, 30, 30, + 30, 30, 30, 30, 35, 57, 35, 35, 44, 126, + 44, 126, 109, 115, 57, 30, 64, 56, 47, 30, + 47, 45, 45, 45, 49, 30, 30, 45, 45, 49, + 45, 30, 40, 45, 45, 40, 49, 30, 45, 56, + 62, 45, 49, 30, 73, 885, 127, 53, 127, 51, + 61, 30, 62, 55, 30, 31, 108, 31, 31, 31, + + 31, 31, 31, 50, 51, 53, 51, 64, 61, 54, + 73, 55, 50, 87, 31, 51, 50, 55, 31, 54, + 108, 50, 52, 114, 31, 50, 54, 52, 175, 129, + 31, 129, 107, 154, 151, 52, 31, 52, 107, 87, + 52, 60, 31, 132, 52, 132, 60, 114, 175, 154, + 31, 38, 151, 385, 111, 38, 38, 58, 38, 60, + 38, 38, 113, 38, 107, 38, 59, 130, 113, 58, + 58, 116, 111, 164, 38, 38, 38, 385, 59, 58, + 111, 130, 58, 130, 142, 60, 59, 131, 60, 116, + 164, 68, 68, 59, 113, 38, 68, 116, 38, 131, + + 110, 131, 60, 67, 67, 67, 67, 67, 67, 877, + 142, 67, 68, 68, 68, 68, 68, 68, 80, 80, + 80, 80, 80, 80, 153, 38, 38, 77, 77, 134, + 110, 134, 77, 153, 77, 110, 135, 135, 135, 77, + 82, 82, 82, 82, 82, 82, 876, 243, 77, 77, + 77, 77, 83, 83, 83, 83, 83, 83, 110, 77, + 103, 103, 103, 103, 103, 103, 104, 104, 104, 104, + 133, 133, 137, 133, 137, 77, 145, 139, 77, 139, + 157, 145, 243, 77, 77, 152, 156, 77, 77, 155, + 166, 150, 157, 103, 104, 77, 159, 168, 77, 104, + + 77, 77, 77, 152, 77, 85, 150, 155, 156, 85, + 85, 166, 159, 150, 85, 85, 161, 85, 160, 85, + 145, 162, 104, 167, 168, 161, 169, 163, 85, 85, + 85, 105, 163, 105, 105, 105, 105, 105, 105, 873, + 160, 171, 162, 162, 165, 163, 167, 169, 173, 85, + 105, 106, 85, 106, 165, 172, 106, 106, 106, 106, + 106, 106, 180, 171, 170, 173, 105, 176, 177, 170, + 172, 181, 105, 174, 184, 187, 181, 182, 179, 180, + 85, 99, 99, 99, 99, 99, 99, 170, 187, 106, + 177, 174, 184, 179, 176, 183, 190, 99, 99, 99, + + 179, 99, 99, 189, 182, 186, 183, 191, 189, 218, + 186, 218, 185, 188, 99, 190, 183, 183, 284, 99, + 99, 99, 158, 185, 99, 186, 99, 158, 158, 158, + 189, 158, 158, 188, 192, 158, 194, 158, 284, 219, + 185, 219, 158, 158, 158, 193, 158, 192, 220, 194, + 220, 191, 198, 198, 191, 192, 205, 198, 193, 872, + 193, 197, 197, 197, 197, 197, 197, 200, 200, 197, + 248, 221, 200, 198, 198, 198, 198, 198, 198, 202, + 202, 223, 205, 223, 202, 221, 202, 221, 200, 200, + 200, 200, 200, 200, 209, 209, 248, 338, 222, 209, + + 202, 202, 202, 202, 202, 202, 212, 212, 212, 212, + 222, 309, 222, 224, 224, 225, 224, 225, 226, 226, + 226, 228, 229, 228, 229, 234, 234, 235, 236, 235, + 309, 279, 235, 235, 235, 235, 235, 235, 237, 212, + 237, 338, 266, 237, 266, 267, 278, 267, 234, 279, + 283, 236, 241, 241, 241, 283, 241, 241, 256, 278, + 237, 281, 237, 282, 280, 235, 270, 237, 244, 244, + 244, 244, 244, 244, 241, 241, 241, 281, 285, 241, + 282, 241, 280, 285, 256, 244, 245, 245, 245, 245, + 245, 245, 270, 288, 293, 286, 294, 300, 306, 293, + + 308, 244, 300, 306, 870, 294, 308, 244, 246, 246, + 246, 246, 246, 246, 253, 286, 288, 255, 255, 255, + 255, 255, 255, 287, 246, 247, 246, 247, 246, 246, + 247, 247, 247, 247, 247, 247, 290, 253, 287, 253, + 869, 246, 289, 253, 287, 287, 246, 292, 246, 253, + 255, 246, 291, 246, 260, 260, 260, 260, 260, 260, + 289, 253, 290, 292, 292, 253, 295, 291, 296, 253, + 297, 299, 301, 302, 303, 304, 305, 307, 311, 295, + 302, 301, 307, 310, 311, 312, 319, 260, 297, 299, + 313, 314, 310, 304, 303, 296, 318, 305, 305, 313, + + 315, 312, 316, 317, 319, 315, 314, 316, 317, 320, + 322, 323, 324, 326, 325, 318, 327, 328, 331, 329, + 330, 322, 320, 332, 334, 317, 323, 325, 333, 330, + 335, 324, 337, 339, 340, 326, 329, 328, 401, 327, + 331, 337, 334, 335, 341, 343, 332, 340, 342, 401, + 333, 339, 341, 342, 344, 344, 345, 460, 862, 344, + 343, 344, 345, 352, 352, 352, 352, 353, 353, 353, + 353, 362, 363, 362, 363, 370, 370, 370, 370, 370, + 370, 372, 460, 372, 380, 381, 372, 372, 372, 372, + 372, 372, 861, 402, 380, 381, 352, 371, 371, 371, + + 371, 371, 371, 374, 374, 374, 374, 374, 374, 402, + 380, 381, 403, 371, 404, 371, 860, 371, 371, 375, + 375, 375, 375, 375, 375, 383, 382, 403, 406, 405, + 371, 383, 407, 404, 408, 371, 374, 371, 405, 406, + 371, 407, 371, 376, 376, 376, 376, 376, 376, 382, + 412, 382, 375, 387, 411, 382, 408, 383, 384, 386, + 384, 382, 410, 384, 384, 384, 384, 384, 384, 409, + 411, 387, 412, 382, 413, 410, 376, 382, 409, 387, + 415, 382, 386, 414, 386, 416, 417, 413, 386, 418, + 421, 417, 419, 422, 386, 420, 384, 427, 419, 414, + + 414, 421, 415, 416, 418, 423, 386, 425, 429, 427, + 386, 418, 422, 430, 386, 431, 420, 432, 433, 434, + 423, 425, 435, 437, 433, 439, 440, 441, 431, 429, + 442, 435, 443, 444, 434, 430, 449, 445, 437, 447, + 432, 450, 441, 451, 454, 439, 445, 443, 440, 452, + 450, 453, 442, 444, 455, 456, 447, 457, 458, 449, + 459, 461, 463, 455, 451, 458, 454, 459, 462, 452, + 457, 453, 466, 456, 464, 467, 462, 525, 859, 463, + 525, 468, 491, 461, 467, 464, 462, 468, 477, 477, + 477, 477, 491, 515, 466, 488, 488, 488, 488, 488, + + 488, 490, 490, 490, 490, 490, 490, 519, 491, 521, + 515, 488, 492, 488, 492, 488, 488, 492, 492, 492, + 492, 492, 492, 494, 516, 495, 493, 519, 488, 855, + 851, 521, 518, 488, 490, 488, 493, 516, 488, 529, + 488, 497, 497, 497, 497, 497, 497, 518, 520, 494, + 492, 495, 493, 498, 498, 498, 498, 498, 498, 523, + 529, 520, 526, 848, 523, 847, 528, 846, 522, 498, + 499, 498, 499, 498, 498, 499, 499, 499, 499, 499, + 499, 522, 526, 524, 527, 528, 498, 531, 530, 532, + 533, 498, 531, 498, 524, 534, 498, 530, 498, 527, + + 532, 535, 537, 533, 536, 538, 539, 541, 542, 547, + 535, 539, 544, 541, 538, 545, 546, 542, 547, 537, + 550, 551, 845, 549, 534, 552, 536, 554, 560, 544, + 545, 546, 549, 551, 555, 557, 558, 550, 561, 555, + 552, 562, 554, 565, 557, 558, 564, 567, 566, 568, + 560, 561, 575, 565, 564, 566, 569, 571, 562, 574, + 572, 568, 569, 620, 619, 575, 571, 601, 601, 567, + 572, 619, 620, 844, 843, 622, 574, 594, 594, 594, + 594, 594, 594, 595, 595, 595, 595, 595, 595, 597, + 601, 597, 622, 621, 597, 597, 597, 597, 597, 597, + + 600, 600, 600, 600, 600, 600, 621, 602, 626, 842, + 594, 596, 596, 596, 596, 596, 596, 603, 618, 603, + 623, 624, 603, 618, 628, 626, 625, 596, 624, 596, + 602, 596, 596, 600, 625, 627, 618, 628, 627, 603, + 629, 603, 630, 623, 596, 631, 603, 632, 633, 596, + 634, 596, 635, 634, 596, 636, 596, 630, 637, 638, + 640, 644, 629, 639, 632, 641, 642, 631, 645, 635, + 633, 646, 639, 637, 650, 642, 651, 656, 640, 638, + 646, 653, 657, 636, 644, 665, 656, 641, 664, 657, + 645, 667, 668, 841, 650, 665, 700, 664, 653, 699, + + 667, 702, 705, 651, 714, 837, 700, 668, 686, 686, + 686, 686, 686, 686, 690, 690, 690, 690, 690, 690, + 699, 708, 705, 703, 686, 714, 686, 702, 686, 686, + 703, 704, 706, 715, 707, 706, 704, 707, 710, 708, + 712, 686, 711, 717, 710, 718, 686, 690, 686, 712, + 720, 686, 717, 686, 713, 711, 716, 713, 719, 716, + 721, 719, 715, 720, 722, 723, 724, 725, 721, 728, + 731, 718, 732, 735, 722, 733, 725, 736, 723, 756, + 757, 735, 836, 754, 756, 759, 736, 724, 755, 760, + 731, 761, 728, 764, 732, 757, 733, 743, 743, 743, + + 743, 743, 743, 754, 758, 755, 760, 762, 759, 763, + 762, 769, 766, 768, 758, 766, 768, 761, 769, 772, + 770, 764, 763, 770, 771, 773, 778, 771, 793, 795, + 743, 798, 797, 796, 772, 797, 799, 800, 802, 799, + 800, 803, 804, 806, 807, 804, 810, 807, 773, 778, + 795, 796, 809, 798, 808, 793, 802, 808, 811, 826, + 830, 809, 810, 827, 829, 806, 828, 803, 831, 828, + 827, 831, 832, 829, 811, 834, 835, 839, 830, 835, + 826, 840, 838, 849, 830, 838, 839, 853, 850, 832, + 840, 852, 849, 850, 852, 854, 856, 853, 857, 856, + + 854, 857, 858, 863, 864, 858, 865, 866, 867, 865, + 868, 867, 871, 868, 874, 875, 878, 866, 879, 864, + 880, 882, 881, 863, 883, 878, 884, 833, 825, 824, + 875, 879, 823, 822, 871, 874, 884, 821, 820, 882, + 819, 818, 880, 881, 817, 816, 883, 888, 888, 888, + 888, 888, 888, 888, 888, 888, 888, 888, 888, 888, + 889, 889, 889, 889, 889, 889, 889, 889, 889, 889, + 889, 889, 889, 890, 890, 890, 890, 890, 890, 890, + 890, 890, 890, 890, 890, 890, 891, 815, 814, 891, + 813, 891, 891, 891, 891, 891, 892, 812, 805, 801, + + 892, 892, 892, 892, 892, 892, 893, 893, 893, 893, + 893, 893, 893, 893, 893, 893, 893, 893, 893, 894, + 794, 792, 894, 791, 894, 894, 894, 894, 894, 895, + 790, 895, 895, 789, 895, 895, 895, 895, 895, 895, + 788, 895, 896, 787, 786, 896, 896, 896, 896, 896, + 896, 896, 896, 785, 896, 897, 897, 897, 897, 897, + 897, 897, 897, 897, 897, 897, 897, 897, 898, 898, + 784, 898, 783, 782, 781, 898, 899, 780, 779, 899, + 777, 899, 899, 899, 899, 899, 900, 776, 900, 775, + 774, 767, 900, 901, 765, 901, 753, 752, 751, 901, + + 902, 750, 902, 749, 748, 747, 902, 903, 746, 903, + 745, 742, 741, 903, 904, 740, 904, 734, 730, 729, + 904, 905, 727, 905, 726, 709, 701, 905, 906, 698, + 906, 693, 691, 687, 906, 907, 677, 907, 673, 671, + 669, 907, 908, 666, 908, 663, 662, 661, 908, 909, + 909, 909, 909, 909, 909, 909, 909, 909, 909, 909, + 909, 909, 910, 660, 910, 911, 911, 659, 911, 911, + 911, 658, 911, 912, 912, 655, 912, 913, 654, 913, + 652, 649, 648, 913, 914, 647, 914, 643, 616, 612, + 914, 915, 610, 915, 608, 606, 604, 915, 916, 598, + + 916, 917, 592, 917, 590, 588, 586, 917, 918, 584, + 918, 919, 582, 580, 919, 578, 919, 919, 919, 919, + 919, 920, 920, 920, 920, 920, 920, 920, 920, 920, + 920, 920, 920, 920, 921, 921, 921, 921, 921, 921, + 921, 921, 921, 921, 921, 921, 921, 922, 577, 922, + 576, 573, 570, 922, 923, 563, 923, 559, 556, 553, + 923, 924, 548, 924, 543, 540, 517, 924, 925, 513, + 925, 926, 511, 926, 509, 507, 505, 926, 927, 503, + 927, 928, 502, 928, 501, 500, 489, 928, 929, 486, + 929, 930, 484, 930, 483, 482, 480, 930, 931, 478, + + 931, 932, 475, 932, 473, 471, 469, 932, 933, 465, + 933, 934, 448, 934, 446, 438, 436, 934, 935, 428, + 935, 936, 426, 936, 424, 398, 396, 936, 937, 394, + 937, 938, 392, 938, 391, 938, 390, 938, 939, 377, + 939, 367, 939, 365, 939, 940, 940, 364, 940, 940, + 940, 360, 940, 941, 358, 941, 356, 354, 350, 941, + 942, 348, 942, 347, 346, 336, 942, 943, 321, 943, + 298, 277, 275, 943, 944, 273, 944, 945, 272, 945, + 271, 269, 268, 945, 946, 263, 946, 947, 259, 947, + 258, 254, 251, 947, 948, 250, 948, 949, 239, 949, + + 238, 231, 230, 949, 950, 227, 950, 951, 217, 215, + 951, 214, 951, 951, 951, 951, 951, 952, 952, 952, + 952, 952, 952, 952, 952, 952, 952, 952, 952, 952, + 953, 213, 953, 207, 206, 204, 953, 954, 199, 954, + 955, 178, 955, 149, 147, 146, 955, 956, 140, 956, + 957, 138, 957, 136, 128, 125, 957, 958, 124, 958, + 959, 120, 959, 101, 98, 95, 959, 960, 93, 960, + 961, 86, 961, 72, 70, 66, 961, 962, 36, 962, + 963, 33, 963, 18, 11, 4, 963, 964, 3, 964, + 965, 0, 965, 0, 0, 0, 965, 966, 0, 966, + + 0, 0, 0, 966, 967, 0, 967, 968, 0, 968, + 0, 0, 0, 968, 969, 0, 969, 970, 0, 970, + 0, 970, 0, 970, 971, 0, 971, 0, 0, 0, + 971, 972, 0, 972, 0, 0, 0, 972, 973, 0, + 973, 974, 0, 974, 0, 0, 0, 974, 975, 0, + 975, 976, 0, 976, 0, 0, 0, 976, 977, 0, + 977, 978, 0, 978, 0, 0, 0, 978, 979, 0, + 979, 980, 0, 980, 0, 0, 0, 980, 981, 0, + 981, 982, 0, 982, 0, 0, 0, 982, 983, 0, + 983, 984, 0, 0, 984, 0, 984, 984, 984, 984, + + 984, 985, 985, 985, 985, 985, 985, 985, 985, 985, + 985, 985, 985, 985, 986, 0, 986, 0, 0, 0, 986, 987, 0, 987, 988, 0, 988, 0, 0, 0, 988, 989, 0, 989, 990, 0, 990, 0, 0, 0, - 990, 991, 0, 991, 0, 0, 0, 991, 992, 0, - 992, 993, 0, 993, 0, 0, 0, 993, 994, 0, - 994, 995, 0, 995, 0, 0, 0, 995, 996, 0, - 996, 997, 0, 997, 0, 0, 0, 997, 998, 0, - - 998, 999, 0, 999, 1000, 0, 1000, 1001, 0, 0, - 1001, 0, 1001, 1001, 1001, 1001, 1001, 1002, 0, 1002, - 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, - 1003, 1003, 1003, 1004, 0, 1004, 0, 0, 0, 1004, - 1005, 0, 1005, 1006, 0, 1006, 0, 0, 0, 1006, - 1007, 0, 1007, 1008, 0, 1008, 1009, 0, 1009, 1010, - 0, 0, 1010, 0, 1010, 1010, 1010, 1010, 1010, 1011, - 0, 1011, 1012, 0, 1012, 1013, 0, 1013, 1014, 0, - 1014, 1015, 0, 1015, 1016, 0, 1016, 1017, 0, 1017, - 1018, 0, 1018, 0, 0, 0, 1018, 1019, 0, 1019, - - 1020, 0, 1020, 0, 0, 0, 1020, 1021, 0, 1021, - 1022, 0, 1022, 1023, 0, 1023, 1024, 0, 1024, 1025, - 0, 1025, 0, 0, 0, 1025, 1026, 0, 0, 1026, - 0, 1026, 1026, 1026, 1026, 1026, 1027, 0, 1027, 1028, - 0, 1028, 1029, 0, 1029, 1030, 0, 1030, 0, 0, - 0, 1030, 1031, 0, 1031, 0, 0, 0, 1031, 1032, - 0, 1032, 0, 0, 0, 1032, 1033, 0, 1033, 1034, - 0, 1034, 0, 0, 0, 1034, 1035, 0, 1035, 0, - 0, 0, 1035, 1036, 0, 1036, 0, 0, 0, 1036, - 1037, 0, 1037, 0, 0, 0, 1037, 1038, 0, 1038, - - 0, 0, 0, 1038, 1039, 0, 1039, 0, 0, 0, - 1039, 1040, 0, 1040, 0, 0, 0, 1040, 1041, 0, - 1041, 0, 0, 0, 1041, 1042, 0, 1042, 0, 0, + 990, 991, 0, 991, 992, 0, 992, 0, 0, 0, + 992, 993, 0, 993, 994, 0, 994, 0, 0, 0, + 994, 995, 0, 995, 996, 0, 996, 0, 0, 0, + 996, 997, 0, 997, 998, 0, 998, 0, 0, 0, + 998, 999, 0, 999, 1000, 0, 1000, 0, 0, 0, + 1000, 1001, 0, 1001, 1002, 0, 1002, 0, 0, 0, + + 1002, 1003, 0, 1003, 0, 0, 0, 1003, 1004, 0, + 1004, 1005, 0, 1005, 0, 0, 0, 1005, 1006, 0, + 1006, 1007, 0, 1007, 0, 0, 0, 1007, 1008, 0, + 1008, 1009, 0, 1009, 0, 0, 0, 1009, 1010, 0, + 1010, 1011, 0, 1011, 1012, 0, 1012, 1013, 0, 0, + 1013, 0, 1013, 1013, 1013, 1013, 1013, 1014, 0, 1014, + 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, + 1015, 1015, 1015, 1016, 0, 1016, 0, 0, 0, 1016, + 1017, 0, 1017, 1018, 0, 1018, 0, 0, 0, 1018, + 1019, 0, 1019, 1020, 0, 1020, 1021, 0, 1021, 1022, + + 0, 0, 1022, 0, 1022, 1022, 1022, 1022, 1022, 1023, + 0, 1023, 1024, 0, 1024, 1025, 0, 1025, 1026, 0, + 1026, 1027, 0, 1027, 1028, 0, 1028, 1029, 0, 1029, + 1030, 0, 1030, 0, 0, 0, 1030, 1031, 0, 1031, + 1032, 0, 1032, 0, 0, 0, 1032, 1033, 0, 1033, + 1034, 0, 1034, 1035, 0, 1035, 1036, 0, 1036, 1037, + 0, 1037, 0, 0, 0, 1037, 1038, 0, 0, 1038, + 0, 1038, 1038, 1038, 1038, 1038, 1039, 0, 1039, 1040, + 0, 1040, 1041, 0, 1041, 1042, 0, 1042, 0, 0, 0, 1042, 1043, 0, 1043, 0, 0, 0, 1043, 1044, - 0, 1044, 0, 0, 0, 1044, 1045, 0, 1045, 0, - 0, 0, 1045, 1046, 0, 1046, 0, 0, 0, 1046, - 1047, 0, 1047, 0, 0, 0, 1047, 1048, 0, 1048, - 0, 0, 0, 1048, 1049, 0, 1049, 0, 0, 0, - 1049, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875, 875, 875, 875, 875, - 875, 875, 875, 875, 875, 875 + + 0, 1044, 0, 0, 0, 1044, 1045, 0, 1045, 1046, + 0, 1046, 0, 0, 0, 1046, 1047, 0, 1047, 0, + 0, 0, 1047, 1048, 0, 1048, 0, 0, 0, 1048, + 1049, 0, 1049, 0, 0, 0, 1049, 1050, 0, 1050, + 0, 0, 0, 1050, 1051, 0, 1051, 0, 0, 0, + 1051, 1052, 0, 1052, 0, 0, 0, 1052, 1053, 0, + 1053, 0, 0, 0, 1053, 1054, 0, 1054, 0, 0, + 0, 1054, 1055, 0, 1055, 0, 0, 0, 1055, 1056, + 0, 1056, 0, 0, 0, 1056, 1057, 0, 1057, 0, + 0, 0, 1057, 1058, 0, 1058, 0, 0, 0, 1058, + + 1059, 0, 1059, 0, 0, 0, 1059, 1060, 0, 1060, + 0, 0, 0, 1060, 1061, 0, 1061, 0, 0, 0, + 1061, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + 887, 887, 887, 887, 887, 887, 887, 887, 887, 887, + + 887, 887, 887, 887, 887, 887, 887 } ; /* Table of booleans, true if rule could match eol. */ -static yyconst flex_int32_t yy_rule_can_match_eol[180] = +static yyconst flex_int32_t yy_rule_can_match_eol[181] = { 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -1420,9 +1435,9 @@ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, - 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - }; + 0, }; static yy_state_type yy_last_accepting_state; @@ -1452,6 +1467,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Tue Feb 2 15:06:54 2016 - * Update Count : 426 + * Last Modified On : Mon Mar 21 23:33:46 2016 + * Update Count : 450 */ #line 20 "lex.ll" @@ -1465,6 +1480,7 @@ #include "lex.h" +#include "parser.h" // YACC generated definitions based on C++ grammar #include "ParseNode.h" -#include "parser.h" // YACC generated definitions based on C++ grammar +#include "TypedefTable.h" char *yyfilename; @@ -1482,5 +1498,5 @@ #define NUMERIC_RETURN(x) rm_underscore(); RETURN_VAL( x ) // numeric constant #define KEYWORD_RETURN(x) RETURN_CHAR( x ) // keyword -#define IDENTIFIER_RETURN() RETURN_VAL( (typedefTable.isIdentifier( yytext ) ? IDENTIFIER : typedefTable.isTypedef( yytext ) ? TYPEDEFname : TYPEGENname ) ) +#define IDENTIFIER_RETURN() RETURN_VAL( typedefTable.isKind( yytext ) ) #define ATTRIBUTE_RETURN() RETURN_VAL( ATTR_IDENTIFIER ) @@ -1502,5 +1518,6 @@ // attribute identifier, GCC: $ in identifier // numeric constants, CFA: '_' in constant -// GCC: D (double), LD (long double) and iI (imaginary) suffixes +// GCC: D (double), DL (long double) and iI (imaginary) suffixes +//floating_suffix "_"?([fFdD]|[lL]|[D][L])|([iI][lLfFdD])|([lLfFdD][iI])) // character escape sequence, GCC: \e => esc character // ' stop highlighting @@ -1511,5 +1528,5 @@ -#line 1514 "Parser/lex.cc" +#line 1531 "Parser/lex.cc" #define INITIAL 0 @@ -1703,8 +1720,8 @@ register int yy_act; -#line 137 "lex.ll" +#line 139 "lex.ll" /* line directives */ -#line 1709 "Parser/lex.cc" +#line 1726 "Parser/lex.cc" if ( !(yy_init) ) @@ -1760,5 +1777,5 @@ { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 876 ) + if ( yy_current_state >= 888 ) yy_c = yy_meta[(unsigned int) yy_c]; } @@ -1766,5 +1783,5 @@ ++yy_cp; } - while ( yy_base[yy_current_state] != 2782 ); + while ( yy_base[yy_current_state] != 2822 ); yy_find_action: @@ -1803,5 +1820,5 @@ /* rule 1 can match eol */ YY_RULE_SETUP -#line 139 "lex.ll" +#line 141 "lex.ll" { /* " stop highlighting */ @@ -1830,5 +1847,5 @@ /* rule 2 can match eol */ YY_RULE_SETUP -#line 162 "lex.ll" +#line 164 "lex.ll" ; YY_BREAK @@ -1836,5 +1853,5 @@ case 3: YY_RULE_SETUP -#line 165 "lex.ll" +#line 167 "lex.ll" { BEGIN COMMENT; } YY_BREAK @@ -1842,10 +1859,10 @@ /* rule 4 can match eol */ YY_RULE_SETUP -#line 166 "lex.ll" +#line 168 "lex.ll" ; YY_BREAK case 5: YY_RULE_SETUP -#line 167 "lex.ll" +#line 169 "lex.ll" { BEGIN 0; } YY_BREAK @@ -1854,5 +1871,5 @@ /* rule 6 can match eol */ YY_RULE_SETUP -#line 170 "lex.ll" +#line 172 "lex.ll" ; YY_BREAK @@ -1860,10 +1877,10 @@ case 7: YY_RULE_SETUP -#line 173 "lex.ll" +#line 175 "lex.ll" { WHITE_RETURN(' '); } YY_BREAK case 8: YY_RULE_SETUP -#line 174 "lex.ll" +#line 176 "lex.ll" { WHITE_RETURN(' '); } YY_BREAK @@ -1871,5 +1888,5 @@ /* rule 9 can match eol */ YY_RULE_SETUP -#line 175 "lex.ll" +#line 177 "lex.ll" { NEWLINE_RETURN(); } YY_BREAK @@ -1877,849 +1894,854 @@ case 10: YY_RULE_SETUP -#line 178 "lex.ll" +#line 180 "lex.ll" { KEYWORD_RETURN(ALIGNAS); } // C11 YY_BREAK case 11: YY_RULE_SETUP -#line 179 "lex.ll" +#line 181 "lex.ll" { KEYWORD_RETURN(ALIGNOF); } // C11 YY_BREAK case 12: YY_RULE_SETUP -#line 180 "lex.ll" +#line 182 "lex.ll" { KEYWORD_RETURN(ALIGNOF); } // GCC YY_BREAK case 13: YY_RULE_SETUP -#line 181 "lex.ll" +#line 183 "lex.ll" { KEYWORD_RETURN(ALIGNOF); } // GCC YY_BREAK case 14: YY_RULE_SETUP -#line 182 "lex.ll" +#line 184 "lex.ll" { KEYWORD_RETURN(ASM); } YY_BREAK case 15: YY_RULE_SETUP -#line 183 "lex.ll" +#line 185 "lex.ll" { KEYWORD_RETURN(ASM); } // GCC YY_BREAK case 16: YY_RULE_SETUP -#line 184 "lex.ll" +#line 186 "lex.ll" { KEYWORD_RETURN(ASM); } // GCC YY_BREAK case 17: YY_RULE_SETUP -#line 185 "lex.ll" +#line 187 "lex.ll" { KEYWORD_RETURN(AT); } // CFA YY_BREAK case 18: YY_RULE_SETUP -#line 186 "lex.ll" +#line 188 "lex.ll" { KEYWORD_RETURN(ATOMIC); } // C11 YY_BREAK case 19: YY_RULE_SETUP -#line 187 "lex.ll" +#line 189 "lex.ll" { KEYWORD_RETURN(ATTRIBUTE); } // GCC YY_BREAK case 20: YY_RULE_SETUP -#line 188 "lex.ll" +#line 190 "lex.ll" { KEYWORD_RETURN(ATTRIBUTE); } // GCC YY_BREAK case 21: YY_RULE_SETUP -#line 189 "lex.ll" +#line 191 "lex.ll" { KEYWORD_RETURN(AUTO); } YY_BREAK case 22: YY_RULE_SETUP -#line 190 "lex.ll" +#line 192 "lex.ll" { KEYWORD_RETURN(BOOL); } // C99 YY_BREAK case 23: YY_RULE_SETUP -#line 191 "lex.ll" +#line 193 "lex.ll" { KEYWORD_RETURN(BREAK); } YY_BREAK case 24: YY_RULE_SETUP -#line 192 "lex.ll" +#line 194 "lex.ll" { KEYWORD_RETURN(CASE); } YY_BREAK case 25: YY_RULE_SETUP -#line 193 "lex.ll" +#line 195 "lex.ll" { KEYWORD_RETURN(CATCH); } // CFA YY_BREAK case 26: YY_RULE_SETUP -#line 194 "lex.ll" +#line 196 "lex.ll" { KEYWORD_RETURN(CATCHRESUME); } // CFA YY_BREAK case 27: YY_RULE_SETUP -#line 195 "lex.ll" +#line 197 "lex.ll" { KEYWORD_RETURN(CHAR); } YY_BREAK case 28: YY_RULE_SETUP -#line 196 "lex.ll" +#line 198 "lex.ll" { KEYWORD_RETURN(CHOOSE); } // CFA YY_BREAK case 29: YY_RULE_SETUP -#line 197 "lex.ll" +#line 199 "lex.ll" { KEYWORD_RETURN(COMPLEX); } // C99 YY_BREAK case 30: YY_RULE_SETUP -#line 198 "lex.ll" +#line 200 "lex.ll" { KEYWORD_RETURN(COMPLEX); } // GCC YY_BREAK case 31: YY_RULE_SETUP -#line 199 "lex.ll" +#line 201 "lex.ll" { KEYWORD_RETURN(COMPLEX); } // GCC YY_BREAK case 32: YY_RULE_SETUP -#line 200 "lex.ll" +#line 202 "lex.ll" { KEYWORD_RETURN(CONST); } YY_BREAK case 33: YY_RULE_SETUP -#line 201 "lex.ll" +#line 203 "lex.ll" { KEYWORD_RETURN(CONST); } // GCC YY_BREAK case 34: YY_RULE_SETUP -#line 202 "lex.ll" +#line 204 "lex.ll" { KEYWORD_RETURN(CONST); } // GCC YY_BREAK case 35: YY_RULE_SETUP -#line 203 "lex.ll" -{ KEYWORD_RETURN(CONTEXT); } // CFA +#line 205 "lex.ll" +{ KEYWORD_RETURN(CONTINUE); } YY_BREAK case 36: YY_RULE_SETUP -#line 204 "lex.ll" -{ KEYWORD_RETURN(CONTINUE); } +#line 206 "lex.ll" +{ KEYWORD_RETURN(DEFAULT); } YY_BREAK case 37: YY_RULE_SETUP -#line 205 "lex.ll" -{ KEYWORD_RETURN(DEFAULT); } +#line 207 "lex.ll" +{ KEYWORD_RETURN(DISABLE); } // CFA YY_BREAK case 38: YY_RULE_SETUP -#line 206 "lex.ll" -{ KEYWORD_RETURN(DISABLE); } // CFA +#line 208 "lex.ll" +{ KEYWORD_RETURN(DO); } YY_BREAK case 39: YY_RULE_SETUP -#line 207 "lex.ll" -{ KEYWORD_RETURN(DO); } +#line 209 "lex.ll" +{ KEYWORD_RETURN(DOUBLE); } YY_BREAK case 40: YY_RULE_SETUP -#line 208 "lex.ll" -{ KEYWORD_RETURN(DOUBLE); } +#line 210 "lex.ll" +{ KEYWORD_RETURN(DTYPE); } // CFA YY_BREAK case 41: YY_RULE_SETUP -#line 209 "lex.ll" -{ KEYWORD_RETURN(DTYPE); } // CFA +#line 211 "lex.ll" +{ KEYWORD_RETURN(ELSE); } YY_BREAK case 42: YY_RULE_SETUP -#line 210 "lex.ll" -{ KEYWORD_RETURN(ELSE); } +#line 212 "lex.ll" +{ KEYWORD_RETURN(ENABLE); } // CFA YY_BREAK case 43: YY_RULE_SETUP -#line 211 "lex.ll" -{ KEYWORD_RETURN(ENABLE); } // CFA +#line 213 "lex.ll" +{ KEYWORD_RETURN(ENUM); } YY_BREAK case 44: YY_RULE_SETUP -#line 212 "lex.ll" -{ KEYWORD_RETURN(ENUM); } +#line 214 "lex.ll" +{ KEYWORD_RETURN(EXTENSION); } // GCC YY_BREAK case 45: YY_RULE_SETUP -#line 213 "lex.ll" -{ KEYWORD_RETURN(EXTENSION); } // GCC +#line 215 "lex.ll" +{ KEYWORD_RETURN(EXTERN); } YY_BREAK case 46: YY_RULE_SETUP -#line 214 "lex.ll" -{ KEYWORD_RETURN(EXTERN); } +#line 216 "lex.ll" +{ KEYWORD_RETURN(FALLTHRU); } // CFA YY_BREAK case 47: YY_RULE_SETUP -#line 215 "lex.ll" -{ KEYWORD_RETURN(FALLTHRU); } // CFA +#line 217 "lex.ll" +{ KEYWORD_RETURN(FINALLY); } // CFA YY_BREAK case 48: YY_RULE_SETUP -#line 216 "lex.ll" -{ KEYWORD_RETURN(FINALLY); } // CFA +#line 218 "lex.ll" +{ KEYWORD_RETURN(FLOAT); } YY_BREAK case 49: YY_RULE_SETUP -#line 217 "lex.ll" -{ KEYWORD_RETURN(FLOAT); } +#line 219 "lex.ll" +{ KEYWORD_RETURN(FLOAT); } // GCC YY_BREAK case 50: YY_RULE_SETUP -#line 218 "lex.ll" -{ KEYWORD_RETURN(FLOAT); } // GCC +#line 220 "lex.ll" +{ KEYWORD_RETURN(FOR); } YY_BREAK case 51: YY_RULE_SETUP -#line 219 "lex.ll" -{ KEYWORD_RETURN(FOR); } +#line 221 "lex.ll" +{ KEYWORD_RETURN(FORALL); } // CFA YY_BREAK case 52: YY_RULE_SETUP -#line 220 "lex.ll" -{ KEYWORD_RETURN(FORALL); } // CFA +#line 222 "lex.ll" +{ KEYWORD_RETURN(FORTRAN); } YY_BREAK case 53: YY_RULE_SETUP -#line 221 "lex.ll" -{ KEYWORD_RETURN(FORTRAN); } +#line 223 "lex.ll" +{ KEYWORD_RETURN(FTYPE); } // CFA YY_BREAK case 54: YY_RULE_SETUP -#line 222 "lex.ll" -{ KEYWORD_RETURN(FTYPE); } // CFA +#line 224 "lex.ll" +{ KEYWORD_RETURN(GENERIC); } // C11 YY_BREAK case 55: YY_RULE_SETUP -#line 223 "lex.ll" -{ KEYWORD_RETURN(GENERIC); } // C11 +#line 225 "lex.ll" +{ KEYWORD_RETURN(GOTO); } YY_BREAK case 56: YY_RULE_SETUP -#line 224 "lex.ll" -{ KEYWORD_RETURN(GOTO); } +#line 226 "lex.ll" +{ KEYWORD_RETURN(IF); } YY_BREAK case 57: YY_RULE_SETUP -#line 225 "lex.ll" -{ KEYWORD_RETURN(IF); } +#line 227 "lex.ll" +{ KEYWORD_RETURN(IMAGINARY); } // C99 YY_BREAK case 58: -YY_RULE_SETUP -#line 226 "lex.ll" -{ KEYWORD_RETURN(IMAGINARY); } // C99 - YY_BREAK -case 59: -YY_RULE_SETUP -#line 227 "lex.ll" -{ KEYWORD_RETURN(IMAGINARY); } // GCC - YY_BREAK -case 60: YY_RULE_SETUP #line 228 "lex.ll" { KEYWORD_RETURN(IMAGINARY); } // GCC YY_BREAK +case 59: +YY_RULE_SETUP +#line 229 "lex.ll" +{ KEYWORD_RETURN(IMAGINARY); } // GCC + YY_BREAK +case 60: +YY_RULE_SETUP +#line 230 "lex.ll" +{ KEYWORD_RETURN(INLINE); } // C99 + YY_BREAK case 61: -YY_RULE_SETUP -#line 229 "lex.ll" -{ KEYWORD_RETURN(INLINE); } // C99 - YY_BREAK -case 62: -YY_RULE_SETUP -#line 230 "lex.ll" -{ KEYWORD_RETURN(INLINE); } // GCC - YY_BREAK -case 63: YY_RULE_SETUP #line 231 "lex.ll" { KEYWORD_RETURN(INLINE); } // GCC YY_BREAK +case 62: +YY_RULE_SETUP +#line 232 "lex.ll" +{ KEYWORD_RETURN(INLINE); } // GCC + YY_BREAK +case 63: +YY_RULE_SETUP +#line 233 "lex.ll" +{ KEYWORD_RETURN(INT); } + YY_BREAK case 64: YY_RULE_SETUP -#line 232 "lex.ll" -{ KEYWORD_RETURN(INT); } +#line 234 "lex.ll" +{ KEYWORD_RETURN(INT); } // GCC YY_BREAK case 65: YY_RULE_SETUP -#line 233 "lex.ll" -{ KEYWORD_RETURN(INT); } // GCC +#line 235 "lex.ll" +{ KEYWORD_RETURN(LABEL); } // GCC YY_BREAK case 66: YY_RULE_SETUP -#line 234 "lex.ll" -{ KEYWORD_RETURN(LABEL); } // GCC +#line 236 "lex.ll" +{ KEYWORD_RETURN(LONG); } YY_BREAK case 67: YY_RULE_SETUP -#line 235 "lex.ll" -{ KEYWORD_RETURN(LONG); } +#line 237 "lex.ll" +{ KEYWORD_RETURN(LVALUE); } // CFA YY_BREAK case 68: YY_RULE_SETUP -#line 236 "lex.ll" -{ KEYWORD_RETURN(LVALUE); } // CFA +#line 238 "lex.ll" +{ KEYWORD_RETURN(NORETURN); } // C11 YY_BREAK case 69: YY_RULE_SETUP -#line 237 "lex.ll" -{ KEYWORD_RETURN(NORETURN); } // C11 +#line 239 "lex.ll" +{ KEYWORD_RETURN(OFFSETOF); } // GCC YY_BREAK case 70: YY_RULE_SETUP -#line 238 "lex.ll" -{ KEYWORD_RETURN(OFFSETOF); } // GCC +#line 240 "lex.ll" +{ KEYWORD_RETURN(OTYPE); } // CFA YY_BREAK case 71: YY_RULE_SETUP -#line 239 "lex.ll" +#line 241 "lex.ll" { KEYWORD_RETURN(REGISTER); } YY_BREAK case 72: YY_RULE_SETUP -#line 240 "lex.ll" +#line 242 "lex.ll" { KEYWORD_RETURN(RESTRICT); } // C99 YY_BREAK case 73: YY_RULE_SETUP -#line 241 "lex.ll" +#line 243 "lex.ll" { KEYWORD_RETURN(RESTRICT); } // GCC YY_BREAK case 74: YY_RULE_SETUP -#line 242 "lex.ll" +#line 244 "lex.ll" { KEYWORD_RETURN(RESTRICT); } // GCC YY_BREAK case 75: YY_RULE_SETUP -#line 243 "lex.ll" +#line 245 "lex.ll" { KEYWORD_RETURN(RETURN); } YY_BREAK case 76: YY_RULE_SETUP -#line 244 "lex.ll" +#line 246 "lex.ll" { KEYWORD_RETURN(SHORT); } YY_BREAK case 77: YY_RULE_SETUP -#line 245 "lex.ll" +#line 247 "lex.ll" { KEYWORD_RETURN(SIGNED); } YY_BREAK case 78: YY_RULE_SETUP -#line 246 "lex.ll" +#line 248 "lex.ll" { KEYWORD_RETURN(SIGNED); } // GCC YY_BREAK case 79: YY_RULE_SETUP -#line 247 "lex.ll" +#line 249 "lex.ll" { KEYWORD_RETURN(SIGNED); } // GCC YY_BREAK case 80: YY_RULE_SETUP -#line 248 "lex.ll" +#line 250 "lex.ll" { KEYWORD_RETURN(SIZEOF); } YY_BREAK case 81: YY_RULE_SETUP -#line 249 "lex.ll" +#line 251 "lex.ll" { KEYWORD_RETURN(STATIC); } YY_BREAK case 82: YY_RULE_SETUP -#line 250 "lex.ll" +#line 252 "lex.ll" { KEYWORD_RETURN(STATICASSERT); } // C11 YY_BREAK case 83: YY_RULE_SETUP -#line 251 "lex.ll" +#line 253 "lex.ll" { KEYWORD_RETURN(STRUCT); } YY_BREAK case 84: YY_RULE_SETUP -#line 252 "lex.ll" +#line 254 "lex.ll" { KEYWORD_RETURN(SWITCH); } YY_BREAK case 85: YY_RULE_SETUP -#line 253 "lex.ll" +#line 255 "lex.ll" { KEYWORD_RETURN(THREADLOCAL); } // C11 YY_BREAK case 86: YY_RULE_SETUP -#line 254 "lex.ll" +#line 256 "lex.ll" { KEYWORD_RETURN(THROW); } // CFA YY_BREAK case 87: YY_RULE_SETUP -#line 255 "lex.ll" +#line 257 "lex.ll" { KEYWORD_RETURN(THROWRESUME); } // CFA YY_BREAK case 88: YY_RULE_SETUP -#line 256 "lex.ll" +#line 258 "lex.ll" +{ KEYWORD_RETURN(TRAIT); } // CFA + YY_BREAK +case 89: +YY_RULE_SETUP +#line 259 "lex.ll" { KEYWORD_RETURN(TRY); } // CFA YY_BREAK -case 89: -YY_RULE_SETUP -#line 257 "lex.ll" -{ KEYWORD_RETURN(TYPE); } // CFA - YY_BREAK case 90: YY_RULE_SETUP -#line 258 "lex.ll" +#line 260 "lex.ll" { KEYWORD_RETURN(TYPEDEF); } YY_BREAK case 91: -YY_RULE_SETUP -#line 259 "lex.ll" -{ KEYWORD_RETURN(TYPEOF); } // GCC - YY_BREAK -case 92: -YY_RULE_SETUP -#line 260 "lex.ll" -{ KEYWORD_RETURN(TYPEOF); } // GCC - YY_BREAK -case 93: YY_RULE_SETUP #line 261 "lex.ll" { KEYWORD_RETURN(TYPEOF); } // GCC YY_BREAK +case 92: +YY_RULE_SETUP +#line 262 "lex.ll" +{ KEYWORD_RETURN(TYPEOF); } // GCC + YY_BREAK +case 93: +YY_RULE_SETUP +#line 263 "lex.ll" +{ KEYWORD_RETURN(TYPEOF); } // GCC + YY_BREAK case 94: YY_RULE_SETUP -#line 262 "lex.ll" +#line 264 "lex.ll" { KEYWORD_RETURN(UNION); } YY_BREAK case 95: YY_RULE_SETUP -#line 263 "lex.ll" +#line 265 "lex.ll" { KEYWORD_RETURN(UNSIGNED); } YY_BREAK case 96: YY_RULE_SETUP -#line 264 "lex.ll" +#line 266 "lex.ll" +{ KEYWORD_RETURN(VALIST); } // GCC + YY_BREAK +case 97: +YY_RULE_SETUP +#line 267 "lex.ll" { KEYWORD_RETURN(VOID); } YY_BREAK -case 97: -YY_RULE_SETUP -#line 265 "lex.ll" +case 98: +YY_RULE_SETUP +#line 268 "lex.ll" { KEYWORD_RETURN(VOLATILE); } YY_BREAK -case 98: -YY_RULE_SETUP -#line 266 "lex.ll" +case 99: +YY_RULE_SETUP +#line 269 "lex.ll" { KEYWORD_RETURN(VOLATILE); } // GCC YY_BREAK -case 99: -YY_RULE_SETUP -#line 267 "lex.ll" +case 100: +YY_RULE_SETUP +#line 270 "lex.ll" { KEYWORD_RETURN(VOLATILE); } // GCC YY_BREAK -case 100: -YY_RULE_SETUP -#line 268 "lex.ll" +case 101: +YY_RULE_SETUP +#line 271 "lex.ll" { KEYWORD_RETURN(WHILE); } YY_BREAK /* identifier */ -case 101: -YY_RULE_SETUP -#line 271 "lex.ll" -{ IDENTIFIER_RETURN(); } - YY_BREAK case 102: -YY_RULE_SETUP -#line 272 "lex.ll" -{ ATTRIBUTE_RETURN(); } - YY_BREAK -case 103: -YY_RULE_SETUP -#line 273 "lex.ll" -{ BEGIN BKQUOTE; } - YY_BREAK -case 104: YY_RULE_SETUP #line 274 "lex.ll" { IDENTIFIER_RETURN(); } YY_BREAK +case 103: +YY_RULE_SETUP +#line 275 "lex.ll" +{ ATTRIBUTE_RETURN(); } + YY_BREAK +case 104: +YY_RULE_SETUP +#line 276 "lex.ll" +{ BEGIN BKQUOTE; } + YY_BREAK case 105: YY_RULE_SETUP -#line 275 "lex.ll" +#line 277 "lex.ll" +{ IDENTIFIER_RETURN(); } + YY_BREAK +case 106: +YY_RULE_SETUP +#line 278 "lex.ll" { BEGIN 0; } YY_BREAK /* numeric constants */ -case 106: -YY_RULE_SETUP -#line 278 "lex.ll" +case 107: +YY_RULE_SETUP +#line 281 "lex.ll" { NUMERIC_RETURN(ZERO); } // CFA YY_BREAK -case 107: -YY_RULE_SETUP -#line 279 "lex.ll" +case 108: +YY_RULE_SETUP +#line 282 "lex.ll" { NUMERIC_RETURN(ONE); } // CFA YY_BREAK -case 108: -YY_RULE_SETUP -#line 280 "lex.ll" +case 109: +YY_RULE_SETUP +#line 283 "lex.ll" { NUMERIC_RETURN(INTEGERconstant); } YY_BREAK -case 109: -YY_RULE_SETUP -#line 281 "lex.ll" +case 110: +YY_RULE_SETUP +#line 284 "lex.ll" { NUMERIC_RETURN(INTEGERconstant); } YY_BREAK -case 110: -YY_RULE_SETUP -#line 282 "lex.ll" +case 111: +YY_RULE_SETUP +#line 285 "lex.ll" { NUMERIC_RETURN(INTEGERconstant); } YY_BREAK -case 111: -YY_RULE_SETUP -#line 283 "lex.ll" +case 112: +YY_RULE_SETUP +#line 286 "lex.ll" { NUMERIC_RETURN(FLOATINGconstant); } YY_BREAK -case 112: -YY_RULE_SETUP -#line 284 "lex.ll" +case 113: +YY_RULE_SETUP +#line 287 "lex.ll" { NUMERIC_RETURN(FLOATINGconstant); } YY_BREAK /* character constant, allows empty value */ -case 113: -YY_RULE_SETUP -#line 287 "lex.ll" +case 114: +YY_RULE_SETUP +#line 290 "lex.ll" { BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); } YY_BREAK -case 114: -YY_RULE_SETUP -#line 288 "lex.ll" +case 115: +YY_RULE_SETUP +#line 291 "lex.ll" { *strtext += std::string( yytext ); } YY_BREAK -case 115: -/* rule 115 can match eol */ -YY_RULE_SETUP -#line 289 "lex.ll" +case 116: +/* rule 116 can match eol */ +YY_RULE_SETUP +#line 292 "lex.ll" { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); } YY_BREAK /* ' stop highlighting */ /* string constant */ -case 116: -YY_RULE_SETUP -#line 293 "lex.ll" +case 117: +YY_RULE_SETUP +#line 296 "lex.ll" { BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); } YY_BREAK -case 117: -YY_RULE_SETUP -#line 294 "lex.ll" +case 118: +YY_RULE_SETUP +#line 297 "lex.ll" { *strtext += std::string( yytext ); } YY_BREAK -case 118: -/* rule 118 can match eol */ -YY_RULE_SETUP -#line 295 "lex.ll" +case 119: +/* rule 119 can match eol */ +YY_RULE_SETUP +#line 298 "lex.ll" { BEGIN 0; *strtext += std::string( yytext ); RETURN_STR(STRINGliteral); } YY_BREAK /* " stop highlighting */ /* common character/string constant */ -case 119: -YY_RULE_SETUP -#line 299 "lex.ll" +case 120: +YY_RULE_SETUP +#line 302 "lex.ll" { rm_underscore(); *strtext += std::string( yytext ); } YY_BREAK -case 120: -/* rule 120 can match eol */ -YY_RULE_SETUP -#line 300 "lex.ll" +case 121: +/* rule 121 can match eol */ +YY_RULE_SETUP +#line 303 "lex.ll" {} // continuation (ALSO HANDLED BY CPP) YY_BREAK -case 121: -YY_RULE_SETUP -#line 301 "lex.ll" +case 122: +YY_RULE_SETUP +#line 304 "lex.ll" { *strtext += std::string( yytext ); } // unknown escape character YY_BREAK /* punctuation */ -case 122: -YY_RULE_SETUP -#line 304 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK case 123: -YY_RULE_SETUP -#line 305 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 124: -YY_RULE_SETUP -#line 306 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 125: YY_RULE_SETUP #line 307 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 126: +case 124: YY_RULE_SETUP #line 308 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 127: +case 125: YY_RULE_SETUP #line 309 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 128: +case 126: YY_RULE_SETUP #line 310 "lex.ll" -{ ASCIIOP_RETURN(); } // also operator - YY_BREAK -case 129: +{ ASCIIOP_RETURN(); } + YY_BREAK +case 127: YY_RULE_SETUP #line 311 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 130: +case 128: YY_RULE_SETUP #line 312 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 131: +case 129: YY_RULE_SETUP #line 313 "lex.ll" { ASCIIOP_RETURN(); } // also operator YY_BREAK +case 130: +YY_RULE_SETUP +#line 314 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 131: +YY_RULE_SETUP +#line 315 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK case 132: YY_RULE_SETUP -#line 314 "lex.ll" +#line 316 "lex.ll" +{ ASCIIOP_RETURN(); } // also operator + YY_BREAK +case 133: +YY_RULE_SETUP +#line 317 "lex.ll" { NAMEDOP_RETURN(ELLIPSIS); } YY_BREAK /* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */ -case 133: -YY_RULE_SETUP -#line 317 "lex.ll" +case 134: +YY_RULE_SETUP +#line 320 "lex.ll" { RETURN_VAL('['); } YY_BREAK -case 134: -YY_RULE_SETUP -#line 318 "lex.ll" +case 135: +YY_RULE_SETUP +#line 321 "lex.ll" { RETURN_VAL(']'); } YY_BREAK -case 135: -YY_RULE_SETUP -#line 319 "lex.ll" +case 136: +YY_RULE_SETUP +#line 322 "lex.ll" { RETURN_VAL('{'); } YY_BREAK -case 136: -YY_RULE_SETUP -#line 320 "lex.ll" +case 137: +YY_RULE_SETUP +#line 323 "lex.ll" { RETURN_VAL('}'); } YY_BREAK /* operators */ -case 137: -YY_RULE_SETUP -#line 323 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK case 138: -YY_RULE_SETUP -#line 324 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 139: -YY_RULE_SETUP -#line 325 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 140: YY_RULE_SETUP #line 326 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 141: +case 139: YY_RULE_SETUP #line 327 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 142: +case 140: YY_RULE_SETUP #line 328 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 143: +case 141: YY_RULE_SETUP #line 329 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 144: +case 142: YY_RULE_SETUP #line 330 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 145: +case 143: YY_RULE_SETUP #line 331 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 146: +case 144: YY_RULE_SETUP #line 332 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 147: +case 145: YY_RULE_SETUP #line 333 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 148: +case 146: YY_RULE_SETUP #line 334 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 149: +case 147: YY_RULE_SETUP #line 335 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 150: +case 148: YY_RULE_SETUP #line 336 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK +case 149: +YY_RULE_SETUP +#line 337 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 150: +YY_RULE_SETUP +#line 338 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK case 151: YY_RULE_SETUP -#line 338 "lex.ll" +#line 339 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 152: +YY_RULE_SETUP +#line 341 "lex.ll" { NAMEDOP_RETURN(ICR); } YY_BREAK -case 152: -YY_RULE_SETUP -#line 339 "lex.ll" +case 153: +YY_RULE_SETUP +#line 342 "lex.ll" { NAMEDOP_RETURN(DECR); } YY_BREAK -case 153: -YY_RULE_SETUP -#line 340 "lex.ll" +case 154: +YY_RULE_SETUP +#line 343 "lex.ll" { NAMEDOP_RETURN(EQ); } YY_BREAK -case 154: -YY_RULE_SETUP -#line 341 "lex.ll" +case 155: +YY_RULE_SETUP +#line 344 "lex.ll" { NAMEDOP_RETURN(NE); } YY_BREAK -case 155: -YY_RULE_SETUP -#line 342 "lex.ll" +case 156: +YY_RULE_SETUP +#line 345 "lex.ll" { NAMEDOP_RETURN(LS); } YY_BREAK -case 156: -YY_RULE_SETUP -#line 343 "lex.ll" +case 157: +YY_RULE_SETUP +#line 346 "lex.ll" { NAMEDOP_RETURN(RS); } YY_BREAK -case 157: -YY_RULE_SETUP -#line 344 "lex.ll" +case 158: +YY_RULE_SETUP +#line 347 "lex.ll" { NAMEDOP_RETURN(LE); } YY_BREAK -case 158: -YY_RULE_SETUP -#line 345 "lex.ll" +case 159: +YY_RULE_SETUP +#line 348 "lex.ll" { NAMEDOP_RETURN(GE); } YY_BREAK -case 159: -YY_RULE_SETUP -#line 346 "lex.ll" +case 160: +YY_RULE_SETUP +#line 349 "lex.ll" { NAMEDOP_RETURN(ANDAND); } YY_BREAK -case 160: -YY_RULE_SETUP -#line 347 "lex.ll" +case 161: +YY_RULE_SETUP +#line 350 "lex.ll" { NAMEDOP_RETURN(OROR); } YY_BREAK -case 161: -YY_RULE_SETUP -#line 348 "lex.ll" +case 162: +YY_RULE_SETUP +#line 351 "lex.ll" { NAMEDOP_RETURN(ARROW); } YY_BREAK -case 162: -YY_RULE_SETUP -#line 349 "lex.ll" +case 163: +YY_RULE_SETUP +#line 352 "lex.ll" { NAMEDOP_RETURN(PLUSassign); } YY_BREAK -case 163: -YY_RULE_SETUP -#line 350 "lex.ll" +case 164: +YY_RULE_SETUP +#line 353 "lex.ll" { NAMEDOP_RETURN(MINUSassign); } YY_BREAK -case 164: -YY_RULE_SETUP -#line 351 "lex.ll" +case 165: +YY_RULE_SETUP +#line 354 "lex.ll" { NAMEDOP_RETURN(MULTassign); } YY_BREAK -case 165: -YY_RULE_SETUP -#line 352 "lex.ll" +case 166: +YY_RULE_SETUP +#line 355 "lex.ll" { NAMEDOP_RETURN(DIVassign); } YY_BREAK -case 166: -YY_RULE_SETUP -#line 353 "lex.ll" +case 167: +YY_RULE_SETUP +#line 356 "lex.ll" { NAMEDOP_RETURN(MODassign); } YY_BREAK -case 167: -YY_RULE_SETUP -#line 354 "lex.ll" +case 168: +YY_RULE_SETUP +#line 357 "lex.ll" { NAMEDOP_RETURN(ANDassign); } YY_BREAK -case 168: -YY_RULE_SETUP -#line 355 "lex.ll" +case 169: +YY_RULE_SETUP +#line 358 "lex.ll" { NAMEDOP_RETURN(ORassign); } YY_BREAK -case 169: -YY_RULE_SETUP -#line 356 "lex.ll" +case 170: +YY_RULE_SETUP +#line 359 "lex.ll" { NAMEDOP_RETURN(ERassign); } YY_BREAK -case 170: -YY_RULE_SETUP -#line 357 "lex.ll" +case 171: +YY_RULE_SETUP +#line 360 "lex.ll" { NAMEDOP_RETURN(LSassign); } YY_BREAK -case 171: -YY_RULE_SETUP -#line 358 "lex.ll" +case 172: +YY_RULE_SETUP +#line 361 "lex.ll" { NAMEDOP_RETURN(RSassign); } YY_BREAK -case 172: -YY_RULE_SETUP -#line 360 "lex.ll" +case 173: +YY_RULE_SETUP +#line 363 "lex.ll" { NAMEDOP_RETURN(ATassign); } YY_BREAK /* CFA, operator identifier */ -case 173: -YY_RULE_SETUP -#line 363 "lex.ll" +case 174: +YY_RULE_SETUP +#line 366 "lex.ll" { IDENTIFIER_RETURN(); } // unary YY_BREAK -case 174: -YY_RULE_SETUP -#line 364 "lex.ll" +case 175: +YY_RULE_SETUP +#line 367 "lex.ll" { IDENTIFIER_RETURN(); } YY_BREAK -case 175: -YY_RULE_SETUP -#line 365 "lex.ll" +case 176: +YY_RULE_SETUP +#line 368 "lex.ll" { IDENTIFIER_RETURN(); } YY_BREAK -case 176: -YY_RULE_SETUP -#line 366 "lex.ll" +case 177: +YY_RULE_SETUP +#line 369 "lex.ll" { IDENTIFIER_RETURN(); } // binary YY_BREAK @@ -2750,7 +2772,7 @@ an argument list. */ -case 177: -YY_RULE_SETUP -#line 393 "lex.ll" +case 178: +YY_RULE_SETUP +#line 396 "lex.ll" { // 1 or 2 character unary operator ? @@ -2765,15 +2787,15 @@ YY_BREAK /* unknown characters */ -case 178: -YY_RULE_SETUP -#line 405 "lex.ll" +case 179: +YY_RULE_SETUP +#line 408 "lex.ll" { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); } YY_BREAK -case 179: -YY_RULE_SETUP -#line 407 "lex.ll" +case 180: +YY_RULE_SETUP +#line 410 "lex.ll" ECHO; YY_BREAK -#line 2778 "Parser/lex.cc" +#line 2800 "Parser/lex.cc" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(COMMENT): @@ -3072,5 +3094,5 @@ { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 876 ) + if ( yy_current_state >= 888 ) yy_c = yy_meta[(unsigned int) yy_c]; } @@ -3100,9 +3122,9 @@ { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 876 ) + if ( yy_current_state >= 888 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 875); + yy_is_jam = (yy_current_state == 887); return yy_is_jam ? 0 : yy_current_state; @@ -3750,5 +3772,5 @@ #define YYTABLES_NAME "yytables" -#line 407 "lex.ll" +#line 410 "lex.ll" Index: src/Parser/lex.h =================================================================== --- src/Parser/lex.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/lex.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sat Sep 22 08:58:10 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jun 8 20:28:48 2015 -// Update Count : 341 +// Last Modified On : Mon Mar 21 18:18:06 2016 +// Update Count : 346 // @@ -20,6 +20,8 @@ void yyerror( const char * ); +#include +#include "ParseNode.h" // External declarations for information sharing between lexer and scanner -#include "TypedefTable.h" +class TypedefTable; extern TypedefTable typedefTable; Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/lex.ll (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Tue Feb 2 15:06:54 2016 - * Update Count : 426 + * Last Modified On : Mon Mar 21 23:33:46 2016 + * Update Count : 450 */ @@ -27,6 +27,7 @@ #include "lex.h" +#include "parser.h" // YACC generated definitions based on C++ grammar #include "ParseNode.h" -#include "parser.h" // YACC generated definitions based on C++ grammar +#include "TypedefTable.h" char *yyfilename; @@ -44,5 +45,5 @@ #define NUMERIC_RETURN(x) rm_underscore(); RETURN_VAL( x ) // numeric constant #define KEYWORD_RETURN(x) RETURN_CHAR( x ) // keyword -#define IDENTIFIER_RETURN() RETURN_VAL( (typedefTable.isIdentifier( yytext ) ? IDENTIFIER : typedefTable.isTypedef( yytext ) ? TYPEDEFname : TYPEGENname ) ) +#define IDENTIFIER_RETURN() RETURN_VAL( typedefTable.isKind( yytext ) ) #define ATTRIBUTE_RETURN() RETURN_VAL( ATTR_IDENTIFIER ) @@ -95,6 +96,7 @@ fractional_constant ({decimal_digits}?"."{decimal_digits})|({decimal_digits}".") exponent "_"?[eE]"_"?[+-]?{decimal_digits} - // GCC: D (double), LD (long double) and iI (imaginary) suffixes -floating_suffix "_"?([fFdD]?|([lL]?)|([iI][lLfFdD]?)|([lLfFdD][iI])) + // GCC: D (double), DL (long double) and iI (imaginary) suffixes +floating_suffix "_"?([fFdDlL][iI]?|"DL"|[iI][lLfFdD]?) + //floating_suffix "_"?([fFdD]|[lL]|[D][L])|([iI][lLfFdD])|([lLfFdD][iI])) floating_constant (({fractional_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix}? @@ -137,5 +139,5 @@ %% /* line directives */ -^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["][^\n]*"\n" { +^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["].*"\n" { /* " stop highlighting */ char *end_num; @@ -201,5 +203,4 @@ __const { KEYWORD_RETURN(CONST); } // GCC __const__ { KEYWORD_RETURN(CONST); } // GCC -context { KEYWORD_RETURN(CONTEXT); } // CFA continue { KEYWORD_RETURN(CONTINUE); } default { KEYWORD_RETURN(DEFAULT); } @@ -237,4 +238,5 @@ _Noreturn { KEYWORD_RETURN(NORETURN); } // C11 __builtin_offsetof { KEYWORD_RETURN(OFFSETOF); } // GCC +otype { KEYWORD_RETURN(OTYPE); } // CFA register { KEYWORD_RETURN(REGISTER); } restrict { KEYWORD_RETURN(RESTRICT); } // C99 @@ -254,6 +256,6 @@ throw { KEYWORD_RETURN(THROW); } // CFA throwResume { KEYWORD_RETURN(THROWRESUME); } // CFA +trait { KEYWORD_RETURN(TRAIT); } // CFA try { KEYWORD_RETURN(TRY); } // CFA -type { KEYWORD_RETURN(TYPE); } // CFA typedef { KEYWORD_RETURN(TYPEDEF); } typeof { KEYWORD_RETURN(TYPEOF); } // GCC @@ -262,4 +264,5 @@ union { KEYWORD_RETURN(UNION); } unsigned { KEYWORD_RETURN(UNSIGNED); } +__builtin_va_list { KEYWORD_RETURN(VALIST); } // GCC void { KEYWORD_RETURN(VOID); } volatile { KEYWORD_RETURN(VOLATILE); } Index: src/Parser/parser.cc =================================================================== --- src/Parser/parser.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/parser.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -77,7 +77,8 @@ #include #include +#include "lex.h" +#include "parser.h" +#include "ParseNode.h" #include "TypedefTable.h" -#include "lex.h" -#include "ParseNode.h" #include "TypeData.h" #include "LinkageSpec.h" @@ -90,5 +91,5 @@ /* Line 268 of yacc.c */ -#line 93 "Parser/parser.cc" +#line 94 "Parser/parser.cc" /* Enabling traces. */ @@ -138,88 +139,89 @@ SIGNED = 277, UNSIGNED = 278, - BOOL = 279, - COMPLEX = 280, - IMAGINARY = 281, - TYPEOF = 282, - LABEL = 283, - ENUM = 284, - STRUCT = 285, - UNION = 286, - TYPE = 287, - FTYPE = 288, - DTYPE = 289, - CONTEXT = 290, - SIZEOF = 291, - OFFSETOF = 292, - ATTRIBUTE = 293, - EXTENSION = 294, - IF = 295, - ELSE = 296, - SWITCH = 297, - CASE = 298, - DEFAULT = 299, - DO = 300, - WHILE = 301, - FOR = 302, - BREAK = 303, - CONTINUE = 304, - GOTO = 305, - RETURN = 306, - CHOOSE = 307, - DISABLE = 308, - ENABLE = 309, - FALLTHRU = 310, - TRY = 311, - CATCH = 312, - CATCHRESUME = 313, - FINALLY = 314, - THROW = 315, - THROWRESUME = 316, - AT = 317, - ASM = 318, - ALIGNAS = 319, - ALIGNOF = 320, - ATOMIC = 321, - GENERIC = 322, - NORETURN = 323, - STATICASSERT = 324, - THREADLOCAL = 325, - IDENTIFIER = 326, - QUOTED_IDENTIFIER = 327, - TYPEDEFname = 328, - TYPEGENname = 329, - ATTR_IDENTIFIER = 330, - ATTR_TYPEDEFname = 331, - ATTR_TYPEGENname = 332, - INTEGERconstant = 333, - FLOATINGconstant = 334, - CHARACTERconstant = 335, - STRINGliteral = 336, - ZERO = 337, - ONE = 338, - ARROW = 339, - ICR = 340, - DECR = 341, - LS = 342, - RS = 343, - LE = 344, - GE = 345, - EQ = 346, - NE = 347, - ANDAND = 348, - OROR = 349, - ELLIPSIS = 350, - MULTassign = 351, - DIVassign = 352, - MODassign = 353, - PLUSassign = 354, - MINUSassign = 355, - LSassign = 356, - RSassign = 357, - ANDassign = 358, - ERassign = 359, - ORassign = 360, - ATassign = 361, - THEN = 362 + VALIST = 279, + BOOL = 280, + COMPLEX = 281, + IMAGINARY = 282, + TYPEOF = 283, + LABEL = 284, + ENUM = 285, + STRUCT = 286, + UNION = 287, + OTYPE = 288, + FTYPE = 289, + DTYPE = 290, + TRAIT = 291, + SIZEOF = 292, + OFFSETOF = 293, + ATTRIBUTE = 294, + EXTENSION = 295, + IF = 296, + ELSE = 297, + SWITCH = 298, + CASE = 299, + DEFAULT = 300, + DO = 301, + WHILE = 302, + FOR = 303, + BREAK = 304, + CONTINUE = 305, + GOTO = 306, + RETURN = 307, + CHOOSE = 308, + DISABLE = 309, + ENABLE = 310, + FALLTHRU = 311, + TRY = 312, + CATCH = 313, + CATCHRESUME = 314, + FINALLY = 315, + THROW = 316, + THROWRESUME = 317, + AT = 318, + ASM = 319, + ALIGNAS = 320, + ALIGNOF = 321, + ATOMIC = 322, + GENERIC = 323, + NORETURN = 324, + STATICASSERT = 325, + THREADLOCAL = 326, + IDENTIFIER = 327, + QUOTED_IDENTIFIER = 328, + TYPEDEFname = 329, + TYPEGENname = 330, + ATTR_IDENTIFIER = 331, + ATTR_TYPEDEFname = 332, + ATTR_TYPEGENname = 333, + INTEGERconstant = 334, + FLOATINGconstant = 335, + CHARACTERconstant = 336, + STRINGliteral = 337, + ZERO = 338, + ONE = 339, + ARROW = 340, + ICR = 341, + DECR = 342, + LS = 343, + RS = 344, + LE = 345, + GE = 346, + EQ = 347, + NE = 348, + ANDAND = 349, + OROR = 350, + ELLIPSIS = 351, + MULTassign = 352, + DIVassign = 353, + MODassign = 354, + PLUSassign = 355, + MINUSassign = 356, + LSassign = 357, + RSassign = 358, + ANDassign = 359, + ERassign = 360, + ORassign = 361, + ATassign = 362, + THEN = 363 }; #endif @@ -246,88 +248,89 @@ #define SIGNED 277 #define UNSIGNED 278 -#define BOOL 279 -#define COMPLEX 280 -#define IMAGINARY 281 -#define TYPEOF 282 -#define LABEL 283 -#define ENUM 284 -#define STRUCT 285 -#define UNION 286 -#define TYPE 287 -#define FTYPE 288 -#define DTYPE 289 -#define CONTEXT 290 -#define SIZEOF 291 -#define OFFSETOF 292 -#define ATTRIBUTE 293 -#define EXTENSION 294 -#define IF 295 -#define ELSE 296 -#define SWITCH 297 -#define CASE 298 -#define DEFAULT 299 -#define DO 300 -#define WHILE 301 -#define FOR 302 -#define BREAK 303 -#define CONTINUE 304 -#define GOTO 305 -#define RETURN 306 -#define CHOOSE 307 -#define DISABLE 308 -#define ENABLE 309 -#define FALLTHRU 310 -#define TRY 311 -#define CATCH 312 -#define CATCHRESUME 313 -#define FINALLY 314 -#define THROW 315 -#define THROWRESUME 316 -#define AT 317 -#define ASM 318 -#define ALIGNAS 319 -#define ALIGNOF 320 -#define ATOMIC 321 -#define GENERIC 322 -#define NORETURN 323 -#define STATICASSERT 324 -#define THREADLOCAL 325 -#define IDENTIFIER 326 -#define QUOTED_IDENTIFIER 327 -#define TYPEDEFname 328 -#define TYPEGENname 329 -#define ATTR_IDENTIFIER 330 -#define ATTR_TYPEDEFname 331 -#define ATTR_TYPEGENname 332 -#define INTEGERconstant 333 -#define FLOATINGconstant 334 -#define CHARACTERconstant 335 -#define STRINGliteral 336 -#define ZERO 337 -#define ONE 338 -#define ARROW 339 -#define ICR 340 -#define DECR 341 -#define LS 342 -#define RS 343 -#define LE 344 -#define GE 345 -#define EQ 346 -#define NE 347 -#define ANDAND 348 -#define OROR 349 -#define ELLIPSIS 350 -#define MULTassign 351 -#define DIVassign 352 -#define MODassign 353 -#define PLUSassign 354 -#define MINUSassign 355 -#define LSassign 356 -#define RSassign 357 -#define ANDassign 358 -#define ERassign 359 -#define ORassign 360 -#define ATassign 361 -#define THEN 362 +#define VALIST 279 +#define BOOL 280 +#define COMPLEX 281 +#define IMAGINARY 282 +#define TYPEOF 283 +#define LABEL 284 +#define ENUM 285 +#define STRUCT 286 +#define UNION 287 +#define OTYPE 288 +#define FTYPE 289 +#define DTYPE 290 +#define TRAIT 291 +#define SIZEOF 292 +#define OFFSETOF 293 +#define ATTRIBUTE 294 +#define EXTENSION 295 +#define IF 296 +#define ELSE 297 +#define SWITCH 298 +#define CASE 299 +#define DEFAULT 300 +#define DO 301 +#define WHILE 302 +#define FOR 303 +#define BREAK 304 +#define CONTINUE 305 +#define GOTO 306 +#define RETURN 307 +#define CHOOSE 308 +#define DISABLE 309 +#define ENABLE 310 +#define FALLTHRU 311 +#define TRY 312 +#define CATCH 313 +#define CATCHRESUME 314 +#define FINALLY 315 +#define THROW 316 +#define THROWRESUME 317 +#define AT 318 +#define ASM 319 +#define ALIGNAS 320 +#define ALIGNOF 321 +#define ATOMIC 322 +#define GENERIC 323 +#define NORETURN 324 +#define STATICASSERT 325 +#define THREADLOCAL 326 +#define IDENTIFIER 327 +#define QUOTED_IDENTIFIER 328 +#define TYPEDEFname 329 +#define TYPEGENname 330 +#define ATTR_IDENTIFIER 331 +#define ATTR_TYPEDEFname 332 +#define ATTR_TYPEGENname 333 +#define INTEGERconstant 334 +#define FLOATINGconstant 335 +#define CHARACTERconstant 336 +#define STRINGliteral 337 +#define ZERO 338 +#define ONE 339 +#define ARROW 340 +#define ICR 341 +#define DECR 342 +#define LS 343 +#define RS 344 +#define LE 345 +#define GE 346 +#define EQ 347 +#define NE 348 +#define ANDAND 349 +#define OROR 350 +#define ELLIPSIS 351 +#define MULTassign 352 +#define DIVassign 353 +#define MODassign 354 +#define PLUSassign 355 +#define MINUSassign 356 +#define LSassign 357 +#define RSassign 358 +#define ANDassign 359 +#define ERassign 360 +#define ORassign 361 +#define ATassign 362 +#define THEN 363 @@ -339,5 +342,5 @@ /* Line 293 of yacc.c */ -#line 110 "parser.yy" +#line 112 "parser.yy" Token tok; @@ -356,5 +359,5 @@ /* Line 293 of yacc.c */ -#line 359 "Parser/parser.cc" +#line 362 "Parser/parser.cc" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 @@ -368,5 +371,5 @@ /* Line 343 of yacc.c */ -#line 371 "Parser/parser.cc" +#line 374 "Parser/parser.cc" #ifdef short @@ -585,20 +588,20 @@ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 248 +#define YYFINAL 249 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 11042 +#define YYLAST 11449 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 132 +#define YYNTOKENS 133 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 238 +#define YYNNTS 240 /* YYNRULES -- Number of rules. */ -#define YYNRULES 751 +#define YYNRULES 754 /* YYNRULES -- Number of states. */ -#define YYNSTATES 1578 +#define YYNSTATES 1581 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 362 +#define YYMAXUTOK 363 #define YYTRANSLATE(YYX) \ @@ -611,14 +614,14 @@ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 117, 2, 2, 2, 124, 119, 2, - 108, 109, 118, 120, 115, 121, 112, 123, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 116, 131, - 125, 130, 126, 129, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 118, 2, 2, 2, 125, 120, 2, + 109, 110, 119, 121, 116, 122, 113, 124, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 117, 132, + 126, 131, 127, 130, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 110, 2, 111, 127, 2, 2, 2, 2, 2, + 2, 111, 2, 112, 128, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 113, 128, 114, 122, 2, 2, 2, + 2, 2, 2, 114, 129, 115, 123, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -644,5 +647,5 @@ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107 + 105, 106, 107, 108 }; @@ -685,47 +688,47 @@ 1156, 1158, 1161, 1163, 1165, 1167, 1169, 1171, 1173, 1175, 1177, 1179, 1181, 1183, 1185, 1187, 1189, 1191, 1193, 1195, - 1197, 1199, 1201, 1203, 1205, 1208, 1211, 1215, 1219, 1221, - 1225, 1227, 1230, 1233, 1236, 1241, 1246, 1251, 1256, 1258, - 1261, 1264, 1268, 1270, 1273, 1276, 1278, 1281, 1284, 1288, - 1290, 1293, 1296, 1298, 1300, 1305, 1308, 1314, 1322, 1325, - 1328, 1331, 1333, 1336, 1339, 1343, 1346, 1350, 1352, 1355, - 1359, 1362, 1365, 1370, 1371, 1373, 1376, 1379, 1381, 1382, - 1384, 1387, 1390, 1396, 1403, 1406, 1409, 1414, 1415, 1418, - 1419, 1421, 1423, 1425, 1431, 1437, 1443, 1445, 1451, 1457, - 1467, 1469, 1475, 1476, 1478, 1480, 1486, 1488, 1490, 1496, - 1502, 1504, 1508, 1512, 1517, 1519, 1521, 1523, 1525, 1528, - 1530, 1534, 1538, 1540, 1543, 1545, 1549, 1551, 1553, 1555, - 1557, 1559, 1561, 1563, 1565, 1567, 1569, 1571, 1574, 1576, - 1578, 1580, 1583, 1584, 1587, 1590, 1592, 1597, 1598, 1600, - 1603, 1607, 1612, 1615, 1618, 1620, 1623, 1625, 1628, 1634, - 1640, 1648, 1655, 1657, 1660, 1663, 1667, 1669, 1672, 1675, - 1680, 1683, 1688, 1689, 1694, 1697, 1699, 1701, 1703, 1704, - 1707, 1713, 1719, 1733, 1735, 1737, 1741, 1745, 1748, 1752, - 1756, 1759, 1764, 1766, 1773, 1783, 1784, 1796, 1798, 1802, - 1806, 1810, 1812, 1814, 1820, 1823, 1829, 1830, 1832, 1834, - 1838, 1839, 1841, 1843, 1845, 1847, 1848, 1855, 1858, 1860, - 1863, 1868, 1871, 1875, 1879, 1883, 1888, 1894, 1900, 1906, - 1913, 1915, 1917, 1919, 1923, 1924, 1930, 1931, 1933, 1935, - 1938, 1945, 1947, 1951, 1952, 1954, 1959, 1961, 1963, 1965, - 1967, 1970, 1972, 1975, 1978, 1980, 1984, 1987, 1991, 1995, - 1998, 2003, 2008, 2012, 2021, 2025, 2028, 2030, 2033, 2040, - 2049, 2053, 2056, 2060, 2064, 2069, 2074, 2078, 2080, 2082, - 2084, 2089, 2096, 2100, 2103, 2107, 2111, 2116, 2121, 2125, - 2128, 2130, 2133, 2136, 2138, 2142, 2145, 2149, 2153, 2156, - 2161, 2166, 2170, 2177, 2186, 2190, 2193, 2195, 2198, 2201, - 2204, 2208, 2212, 2215, 2220, 2225, 2229, 2236, 2245, 2249, - 2252, 2254, 2257, 2260, 2262, 2264, 2267, 2271, 2275, 2278, - 2283, 2290, 2299, 2301, 2304, 2307, 2309, 2312, 2315, 2319, - 2323, 2325, 2330, 2335, 2339, 2345, 2354, 2358, 2361, 2365, - 2367, 2373, 2379, 2386, 2393, 2395, 2398, 2401, 2403, 2406, - 2409, 2413, 2417, 2419, 2424, 2429, 2433, 2439, 2448, 2452, - 2454, 2457, 2459, 2462, 2469, 2475, 2482, 2490, 2498, 2500, - 2503, 2506, 2508, 2511, 2514, 2518, 2522, 2524, 2529, 2534, - 2538, 2547, 2551, 2553, 2555, 2558, 2560, 2562, 2565, 2569, - 2572, 2576, 2579, 2583, 2587, 2590, 2595, 2599, 2602, 2606, - 2609, 2614, 2618, 2621, 2628, 2635, 2642, 2650, 2652, 2655, - 2657, 2659, 2661, 2664, 2668, 2671, 2675, 2678, 2682, 2686, - 2691, 2694, 2698, 2703, 2706, 2712, 2718, 2725, 2732, 2733, - 2735, 2736 + 1197, 1199, 1201, 1203, 1205, 1207, 1210, 1213, 1217, 1221, + 1223, 1227, 1229, 1232, 1235, 1238, 1243, 1248, 1253, 1258, + 1260, 1263, 1266, 1270, 1272, 1275, 1278, 1280, 1283, 1286, + 1290, 1292, 1295, 1298, 1300, 1302, 1307, 1310, 1311, 1318, + 1326, 1329, 1332, 1335, 1337, 1340, 1343, 1347, 1350, 1354, + 1356, 1359, 1363, 1366, 1369, 1374, 1375, 1377, 1380, 1383, + 1385, 1386, 1388, 1391, 1394, 1400, 1403, 1404, 1412, 1415, + 1420, 1421, 1424, 1425, 1427, 1429, 1431, 1437, 1443, 1449, + 1451, 1457, 1463, 1473, 1475, 1481, 1482, 1484, 1486, 1492, + 1494, 1496, 1502, 1508, 1510, 1514, 1518, 1523, 1525, 1527, + 1529, 1531, 1534, 1536, 1540, 1544, 1546, 1549, 1551, 1555, + 1557, 1559, 1561, 1563, 1565, 1567, 1569, 1571, 1573, 1575, + 1577, 1580, 1582, 1584, 1586, 1589, 1590, 1593, 1596, 1598, + 1603, 1604, 1606, 1609, 1613, 1618, 1621, 1624, 1626, 1629, + 1631, 1634, 1640, 1646, 1654, 1661, 1663, 1666, 1669, 1673, + 1675, 1678, 1681, 1686, 1689, 1694, 1695, 1700, 1703, 1705, + 1707, 1709, 1710, 1713, 1719, 1725, 1739, 1741, 1743, 1747, + 1751, 1754, 1758, 1762, 1765, 1770, 1772, 1779, 1789, 1790, + 1802, 1804, 1808, 1812, 1816, 1818, 1820, 1826, 1829, 1835, + 1836, 1838, 1840, 1844, 1845, 1847, 1849, 1851, 1853, 1854, + 1861, 1864, 1866, 1869, 1874, 1877, 1881, 1885, 1889, 1894, + 1900, 1906, 1912, 1919, 1921, 1923, 1925, 1929, 1930, 1936, + 1937, 1939, 1941, 1944, 1951, 1953, 1957, 1958, 1960, 1965, + 1967, 1969, 1971, 1973, 1976, 1978, 1981, 1984, 1986, 1990, + 1993, 1997, 2001, 2004, 2009, 2014, 2018, 2027, 2031, 2034, + 2036, 2039, 2046, 2055, 2059, 2062, 2066, 2070, 2075, 2080, + 2084, 2086, 2088, 2090, 2095, 2102, 2106, 2109, 2113, 2117, + 2122, 2127, 2131, 2134, 2136, 2139, 2142, 2144, 2148, 2151, + 2155, 2159, 2162, 2167, 2172, 2176, 2183, 2192, 2196, 2199, + 2201, 2204, 2207, 2210, 2214, 2218, 2221, 2226, 2231, 2235, + 2242, 2251, 2255, 2258, 2260, 2263, 2266, 2268, 2270, 2273, + 2277, 2281, 2284, 2289, 2296, 2305, 2307, 2310, 2313, 2315, + 2318, 2321, 2325, 2329, 2331, 2336, 2341, 2345, 2351, 2360, + 2364, 2367, 2371, 2373, 2379, 2385, 2392, 2399, 2401, 2404, + 2407, 2409, 2412, 2415, 2419, 2423, 2425, 2430, 2435, 2439, + 2445, 2454, 2458, 2460, 2463, 2465, 2468, 2475, 2481, 2488, + 2496, 2504, 2506, 2509, 2512, 2514, 2517, 2520, 2524, 2528, + 2530, 2535, 2540, 2544, 2553, 2557, 2559, 2561, 2564, 2566, + 2568, 2571, 2575, 2578, 2582, 2585, 2589, 2593, 2596, 2601, + 2605, 2608, 2612, 2615, 2620, 2624, 2627, 2634, 2641, 2648, + 2656, 2658, 2661, 2663, 2665, 2667, 2670, 2674, 2677, 2681, + 2684, 2688, 2692, 2697, 2700, 2704, 2709, 2712, 2718, 2724, + 2731, 2738, 2739, 2741, 2742 }; @@ -733,278 +736,279 @@ static const yytype_int16 yyrhs[] = { - 298, 0, -1, -1, -1, 78, -1, 79, -1, 80, - -1, 71, -1, 75, -1, 139, -1, 71, -1, 75, - -1, 71, -1, 139, -1, 82, -1, 83, -1, 81, - -1, 140, 81, -1, 71, -1, 139, -1, 108, 167, - 109, -1, 108, 171, 109, -1, 141, -1, 142, 110, - 133, 162, 134, 111, -1, 142, 108, 143, 109, -1, - 142, 112, 138, -1, 142, 112, 110, 133, 145, 134, - 111, -1, 142, 84, 138, -1, 142, 84, 110, 133, - 145, 134, 111, -1, 142, 85, -1, 142, 86, -1, - 108, 271, 109, 113, 275, 368, 114, -1, 142, 113, - 143, 114, -1, 144, -1, 143, 115, 144, -1, -1, - 162, -1, 138, 116, 162, -1, 110, 133, 162, 134, - 111, 116, 162, -1, 110, 133, 162, 115, 165, 134, - 111, 116, 162, -1, 146, -1, 145, 115, 146, -1, - 138, -1, 138, 112, 146, -1, 138, 112, 110, 133, - 145, 134, 111, -1, 138, 84, 146, -1, 138, 84, - 110, 133, 145, 134, 111, -1, 142, -1, 135, -1, - 140, -1, 85, 147, -1, 86, 147, -1, 39, 149, - -1, 148, 149, -1, 117, 149, -1, 118, 149, -1, - 36, 147, -1, 36, 108, 271, 109, -1, 37, 108, - 271, 115, 138, 109, -1, 75, -1, 75, 108, 272, - 109, -1, 75, 108, 144, 109, -1, 65, 147, -1, - 65, 108, 271, 109, -1, 93, 138, -1, 119, -1, - 120, -1, 121, -1, 122, -1, 147, -1, 108, 271, - 109, 149, -1, 108, 271, 109, 164, -1, 149, -1, - 150, 118, 149, -1, 150, 123, 149, -1, 150, 124, - 149, -1, 150, -1, 151, 120, 150, -1, 151, 121, - 150, -1, 151, -1, 152, 87, 151, -1, 152, 88, - 151, -1, 152, -1, 153, 125, 152, -1, 153, 126, - 152, -1, 153, 89, 152, -1, 153, 90, 152, -1, - 153, -1, 154, 91, 153, -1, 154, 92, 153, -1, - 154, -1, 155, 119, 154, -1, 155, -1, 156, 127, - 155, -1, 156, -1, 157, 128, 156, -1, 157, -1, - 158, 93, 157, -1, 158, -1, 159, 94, 158, -1, - 159, -1, 159, 129, 167, 116, 160, -1, 159, 129, - 116, 160, -1, 159, 129, 167, 116, 164, -1, 160, - -1, 160, -1, 147, 130, 162, -1, 147, 166, 162, - -1, 164, 369, -1, -1, 162, -1, 110, 111, -1, - 110, 133, 162, 134, 111, -1, 110, 133, 115, 165, - 134, 111, -1, 110, 133, 162, 115, 165, 134, 111, - -1, 163, -1, 165, 115, 163, -1, 96, -1, 97, - -1, 98, -1, 99, -1, 100, -1, 101, -1, 102, - -1, 103, -1, 104, -1, 105, -1, 162, -1, 167, - 115, 162, -1, -1, 167, -1, 170, -1, 171, -1, - 175, -1, 176, -1, 188, -1, 190, -1, 191, -1, - 196, -1, 127, 142, 113, 143, 114, 131, -1, 138, - 116, 308, 169, -1, 113, 114, -1, 113, 133, 133, - 207, 172, 134, 114, -1, 173, -1, 172, 133, 173, - -1, 210, -1, 39, 210, -1, 304, -1, 169, 134, - -1, 169, -1, 174, 169, -1, 168, 131, -1, 40, - 108, 167, 109, 169, -1, 40, 108, 167, 109, 169, - 41, 169, -1, 42, 108, 167, 109, 181, -1, 42, - 108, 167, 109, 113, 133, 203, 182, 114, -1, 52, - 108, 167, 109, 181, -1, 52, 108, 167, 109, 113, - 133, 203, 184, 114, -1, 161, -1, 161, 95, 161, - -1, 306, -1, 177, -1, 178, 115, 177, -1, 43, - 178, 116, -1, 44, 116, -1, 179, -1, 180, 179, - -1, 180, 169, -1, -1, 183, -1, 180, 174, -1, - 183, 180, 174, -1, -1, 185, -1, 180, 187, -1, - 180, 174, 186, -1, 185, 180, 187, -1, 185, 180, - 174, 186, -1, -1, 187, -1, 55, -1, 55, 131, - -1, 46, 108, 167, 109, 169, -1, 45, 169, 46, - 108, 167, 109, 131, -1, 47, 108, 133, 189, 109, - 169, -1, 168, 134, 131, 168, 131, 168, -1, 210, - 168, 131, 168, -1, 50, 138, 131, -1, 50, 118, - 167, 131, -1, 49, 131, -1, 49, 138, 131, -1, - 48, 131, -1, 48, 138, 131, -1, 51, 168, 131, - -1, 60, 163, 131, -1, 61, 163, 131, -1, 61, - 163, 62, 162, 131, -1, 56, 171, 192, -1, 56, - 171, 194, -1, 56, 171, 192, 194, -1, 193, -1, - 57, 108, 95, 109, 171, -1, 193, 57, 108, 95, - 109, 171, -1, 58, 108, 95, 109, 171, -1, 193, - 58, 108, 95, 109, 171, -1, 57, 108, 133, 133, - 195, 134, 109, 171, 134, -1, 193, 57, 108, 133, - 133, 195, 134, 109, 171, 134, -1, 58, 108, 133, - 133, 195, 134, 109, 171, 134, -1, 193, 58, 108, - 133, 133, 195, 134, 109, 171, 134, -1, 59, 171, - -1, 223, -1, 223, 305, -1, 223, 353, -1, 362, - 138, -1, 362, -1, 63, 197, 108, 140, 109, 131, - -1, 63, 197, 108, 140, 116, 198, 109, 131, -1, - 63, 197, 108, 140, 116, 198, 116, 198, 109, 131, - -1, 63, 197, 108, 140, 116, 198, 116, 198, 116, - 201, 109, 131, -1, 63, 197, 50, 108, 140, 116, - 116, 198, 116, 201, 116, 202, 109, 131, -1, -1, - 11, -1, -1, 199, -1, 200, -1, 199, 115, 200, - -1, 140, 108, 161, 109, -1, 110, 161, 111, 140, - 108, 161, 109, -1, -1, 140, -1, 201, 115, 140, - -1, 138, -1, 202, 115, 138, -1, 134, -1, 204, - -1, 210, -1, 204, 133, 210, -1, 134, -1, 206, - -1, 220, -1, 206, 133, 220, -1, -1, 208, -1, - 28, 209, 131, -1, 208, 28, 209, 131, -1, 270, - -1, 209, 115, 270, -1, 211, -1, 220, -1, 212, - 134, 131, -1, 217, 134, 131, -1, 214, 134, 131, - -1, 289, 134, 131, -1, 292, 134, 131, -1, 213, - 273, -1, 229, 213, 273, -1, 212, 134, 115, 133, - 268, 273, -1, 363, 268, 307, -1, 366, 268, 307, - -1, 225, 366, 268, 307, -1, 215, -1, 225, 215, - -1, 229, 215, -1, 229, 225, 215, -1, 214, 134, - 115, 133, 268, -1, 110, 111, 268, 108, 133, 256, - 134, 109, -1, 366, 268, 108, 133, 256, 134, 109, - -1, 216, 268, 108, 133, 256, 134, 109, -1, 110, - 133, 258, 134, 111, -1, 110, 133, 258, 134, 115, - 133, 259, 134, 111, -1, 3, 213, -1, 3, 215, - -1, 217, 134, 115, 133, 138, -1, 3, 223, 305, - -1, 218, 134, 115, 133, 305, -1, 225, 3, 223, - 305, -1, 223, 3, 305, -1, 223, 3, 225, 305, - -1, 3, 138, 130, 162, -1, 219, 134, 115, 133, - 138, 130, 162, -1, 221, 134, 131, -1, 218, 134, - 131, -1, 219, 134, 131, -1, 238, 134, 131, -1, - 222, 305, 307, 273, -1, 221, 115, 308, 305, 307, - 273, -1, 234, -1, 238, -1, 240, -1, 279, -1, - 235, -1, 239, -1, 241, -1, 280, -1, -1, 225, - -1, 226, -1, 225, 226, -1, 227, -1, 310, -1, - 10, -1, 12, -1, 11, -1, 14, -1, 66, -1, - -1, 13, 108, 228, 282, 109, -1, 230, -1, 225, - 230, -1, 229, 225, 230, -1, 231, -1, 230, 231, - -1, 232, -1, 5, -1, 7, -1, 4, -1, 6, - -1, 8, -1, 9, -1, 68, -1, 70, -1, 16, + 301, 0, -1, -1, -1, 79, -1, 80, -1, 81, + -1, 72, -1, 76, -1, 140, -1, 72, -1, 76, + -1, 72, -1, 140, -1, 83, -1, 84, -1, 82, + -1, 141, 82, -1, 72, -1, 140, -1, 109, 168, + 110, -1, 109, 172, 110, -1, 142, -1, 143, 111, + 134, 163, 135, 112, -1, 143, 109, 144, 110, -1, + 143, 113, 139, -1, 143, 113, 111, 134, 146, 135, + 112, -1, 143, 85, 139, -1, 143, 85, 111, 134, + 146, 135, 112, -1, 143, 86, -1, 143, 87, -1, + 109, 274, 110, 114, 278, 371, 115, -1, 143, 114, + 144, 115, -1, 145, -1, 144, 116, 145, -1, -1, + 163, -1, 139, 117, 163, -1, 111, 134, 163, 135, + 112, 117, 163, -1, 111, 134, 163, 116, 166, 135, + 112, 117, 163, -1, 147, -1, 146, 116, 147, -1, + 139, -1, 139, 113, 147, -1, 139, 113, 111, 134, + 146, 135, 112, -1, 139, 85, 147, -1, 139, 85, + 111, 134, 146, 135, 112, -1, 143, -1, 136, -1, + 141, -1, 86, 148, -1, 87, 148, -1, 40, 150, + -1, 149, 150, -1, 118, 150, -1, 119, 150, -1, + 37, 148, -1, 37, 109, 274, 110, -1, 38, 109, + 274, 116, 139, 110, -1, 76, -1, 76, 109, 275, + 110, -1, 76, 109, 145, 110, -1, 66, 148, -1, + 66, 109, 274, 110, -1, 94, 139, -1, 120, -1, + 121, -1, 122, -1, 123, -1, 148, -1, 109, 274, + 110, 150, -1, 109, 274, 110, 165, -1, 150, -1, + 151, 119, 150, -1, 151, 124, 150, -1, 151, 125, + 150, -1, 151, -1, 152, 121, 151, -1, 152, 122, + 151, -1, 152, -1, 153, 88, 152, -1, 153, 89, + 152, -1, 153, -1, 154, 126, 153, -1, 154, 127, + 153, -1, 154, 90, 153, -1, 154, 91, 153, -1, + 154, -1, 155, 92, 154, -1, 155, 93, 154, -1, + 155, -1, 156, 120, 155, -1, 156, -1, 157, 128, + 156, -1, 157, -1, 158, 129, 157, -1, 158, -1, + 159, 94, 158, -1, 159, -1, 160, 95, 159, -1, + 160, -1, 160, 130, 168, 117, 161, -1, 160, 130, + 117, 161, -1, 160, 130, 168, 117, 165, -1, 161, + -1, 161, -1, 148, 131, 163, -1, 148, 167, 163, + -1, 165, 372, -1, -1, 163, -1, 111, 112, -1, + 111, 134, 163, 135, 112, -1, 111, 134, 116, 166, + 135, 112, -1, 111, 134, 163, 116, 166, 135, 112, + -1, 164, -1, 166, 116, 164, -1, 97, -1, 98, + -1, 99, -1, 100, -1, 101, -1, 102, -1, 103, + -1, 104, -1, 105, -1, 106, -1, 163, -1, 168, + 116, 163, -1, -1, 168, -1, 171, -1, 172, -1, + 176, -1, 177, -1, 189, -1, 191, -1, 192, -1, + 197, -1, 128, 143, 114, 144, 115, 132, -1, 139, + 117, 311, 170, -1, 114, 115, -1, 114, 134, 134, + 208, 173, 135, 115, -1, 174, -1, 173, 134, 174, + -1, 211, -1, 40, 211, -1, 307, -1, 170, 135, + -1, 170, -1, 175, 170, -1, 169, 132, -1, 41, + 109, 168, 110, 170, -1, 41, 109, 168, 110, 170, + 42, 170, -1, 43, 109, 168, 110, 182, -1, 43, + 109, 168, 110, 114, 134, 204, 183, 115, -1, 53, + 109, 168, 110, 182, -1, 53, 109, 168, 110, 114, + 134, 204, 185, 115, -1, 162, -1, 162, 96, 162, + -1, 309, -1, 178, -1, 179, 116, 178, -1, 44, + 179, 117, -1, 45, 117, -1, 180, -1, 181, 180, + -1, 181, 170, -1, -1, 184, -1, 181, 175, -1, + 184, 181, 175, -1, -1, 186, -1, 181, 188, -1, + 181, 175, 187, -1, 186, 181, 188, -1, 186, 181, + 175, 187, -1, -1, 188, -1, 56, -1, 56, 132, + -1, 47, 109, 168, 110, 170, -1, 46, 170, 47, + 109, 168, 110, 132, -1, 48, 109, 134, 190, 110, + 170, -1, 169, 135, 132, 169, 132, 169, -1, 211, + 169, 132, 169, -1, 51, 139, 132, -1, 51, 119, + 168, 132, -1, 50, 132, -1, 50, 139, 132, -1, + 49, 132, -1, 49, 139, 132, -1, 52, 169, 132, + -1, 61, 164, 132, -1, 62, 164, 132, -1, 62, + 164, 63, 163, 132, -1, 57, 172, 193, -1, 57, + 172, 195, -1, 57, 172, 193, 195, -1, 194, -1, + 58, 109, 96, 110, 172, -1, 194, 58, 109, 96, + 110, 172, -1, 59, 109, 96, 110, 172, -1, 194, + 59, 109, 96, 110, 172, -1, 58, 109, 134, 134, + 196, 135, 110, 172, 135, -1, 194, 58, 109, 134, + 134, 196, 135, 110, 172, 135, -1, 59, 109, 134, + 134, 196, 135, 110, 172, 135, -1, 194, 59, 109, + 134, 134, 196, 135, 110, 172, 135, -1, 60, 172, + -1, 224, -1, 224, 308, -1, 224, 356, -1, 365, + 139, -1, 365, -1, 64, 198, 109, 141, 110, 132, + -1, 64, 198, 109, 141, 117, 199, 110, 132, -1, + 64, 198, 109, 141, 117, 199, 117, 199, 110, 132, + -1, 64, 198, 109, 141, 117, 199, 117, 199, 117, + 202, 110, 132, -1, 64, 198, 51, 109, 141, 117, + 117, 199, 117, 202, 117, 203, 110, 132, -1, -1, + 11, -1, -1, 200, -1, 201, -1, 200, 116, 201, + -1, 141, 109, 162, 110, -1, 111, 162, 112, 141, + 109, 162, 110, -1, -1, 141, -1, 202, 116, 141, + -1, 139, -1, 203, 116, 139, -1, 135, -1, 205, + -1, 211, -1, 205, 134, 211, -1, 135, -1, 207, + -1, 221, -1, 207, 134, 221, -1, -1, 209, -1, + 29, 210, 132, -1, 209, 29, 210, 132, -1, 273, + -1, 210, 116, 273, -1, 212, -1, 221, -1, 213, + 135, 132, -1, 218, 135, 132, -1, 215, 135, 132, + -1, 292, 135, 132, -1, 295, 135, 132, -1, 214, + 276, -1, 230, 214, 276, -1, 213, 135, 116, 134, + 271, 276, -1, 366, 271, 310, -1, 369, 271, 310, + -1, 226, 369, 271, 310, -1, 216, -1, 226, 216, + -1, 230, 216, -1, 230, 226, 216, -1, 215, 135, + 116, 134, 271, -1, 111, 112, 271, 109, 134, 259, + 135, 110, -1, 369, 271, 109, 134, 259, 135, 110, + -1, 217, 271, 109, 134, 259, 135, 110, -1, 111, + 134, 261, 135, 112, -1, 111, 134, 261, 135, 116, + 134, 262, 135, 112, -1, 3, 214, -1, 3, 216, + -1, 218, 135, 116, 134, 139, -1, 3, 224, 308, + -1, 219, 135, 116, 134, 308, -1, 226, 3, 224, + 308, -1, 224, 3, 308, -1, 224, 3, 226, 308, + -1, 3, 139, 131, 163, -1, 220, 135, 116, 134, + 139, 131, 163, -1, 222, 135, 132, -1, 219, 135, + 132, -1, 220, 135, 132, -1, 239, 135, 132, -1, + 223, 308, 310, 276, -1, 222, 116, 311, 308, 310, + 276, -1, 235, -1, 239, -1, 241, -1, 282, -1, + 236, -1, 240, -1, 242, -1, 283, -1, -1, 226, + -1, 227, -1, 226, 227, -1, 228, -1, 313, -1, + 10, -1, 12, -1, 11, -1, 14, -1, 67, -1, + -1, 13, 109, 229, 285, 110, -1, 231, -1, 226, + 231, -1, 230, 226, 231, -1, 232, -1, 231, 232, + -1, 233, -1, 5, -1, 7, -1, 4, -1, 6, + -1, 8, -1, 9, -1, 69, -1, 71, -1, 16, -1, 21, -1, 20, -1, 18, -1, 19, -1, 17, - -1, 22, -1, 23, -1, 15, -1, 24, -1, 25, - -1, 26, -1, 235, -1, 229, 235, -1, 234, 231, - -1, 234, 231, 225, -1, 234, 231, 235, -1, 236, - -1, 224, 237, 224, -1, 233, -1, 225, 233, -1, - 236, 226, -1, 236, 233, -1, 27, 108, 272, 109, - -1, 27, 108, 167, 109, -1, 77, 108, 272, 109, - -1, 77, 108, 167, 109, -1, 239, -1, 229, 239, - -1, 238, 231, -1, 238, 231, 225, -1, 242, -1, - 225, 242, -1, 239, 226, -1, 241, -1, 229, 241, - -1, 240, 231, -1, 240, 231, 225, -1, 73, -1, - 225, 73, -1, 241, 226, -1, 243, -1, 253, -1, - 244, 113, 245, 114, -1, 244, 270, -1, 244, 270, - 113, 245, 114, -1, 244, 108, 288, 109, 113, 245, - 114, -1, 244, 281, -1, 30, 308, -1, 31, 308, - -1, 246, -1, 245, 246, -1, 247, 131, -1, 39, - 247, 131, -1, 248, 131, -1, 39, 248, 131, -1, - 362, -1, 362, 270, -1, 247, 115, 270, -1, 247, - 115, -1, 223, 249, -1, 248, 115, 308, 249, -1, - -1, 251, -1, 314, 250, -1, 327, 250, -1, 353, - -1, -1, 251, -1, 116, 161, -1, 29, 308, -1, - 252, 113, 254, 368, 114, -1, 252, 270, 113, 254, - 368, 114, -1, 252, 270, -1, 270, 255, -1, 254, - 115, 270, 255, -1, -1, 130, 161, -1, -1, 257, - -1, 259, -1, 258, -1, 258, 134, 115, 133, 259, - -1, 259, 134, 115, 133, 95, -1, 258, 134, 115, - 133, 95, -1, 263, -1, 259, 134, 115, 133, 263, - -1, 258, 134, 115, 133, 263, -1, 258, 134, 115, - 133, 259, 134, 115, 133, 263, -1, 264, -1, 259, - 134, 115, 133, 264, -1, -1, 261, -1, 262, -1, - 262, 134, 115, 133, 95, -1, 266, -1, 265, -1, - 262, 134, 115, 133, 266, -1, 262, 134, 115, 133, - 265, -1, 265, -1, 358, 268, 369, -1, 366, 268, - 369, -1, 225, 366, 268, 369, -1, 215, -1, 266, - -1, 358, -1, 366, -1, 225, 366, -1, 367, -1, - 222, 332, 369, -1, 222, 336, 369, -1, 222, -1, - 222, 347, -1, 138, -1, 267, 115, 138, -1, 136, - -1, 73, -1, 74, -1, 137, -1, 73, -1, 74, - -1, 138, -1, 73, -1, 74, -1, 362, -1, 223, - -1, 223, 353, -1, 362, -1, 367, -1, 223, -1, - 223, 341, -1, -1, 130, 274, -1, 106, 274, -1, - 162, -1, 113, 275, 368, 114, -1, -1, 274, -1, - 276, 274, -1, 275, 115, 274, -1, 275, 115, 276, - 274, -1, 277, 116, -1, 270, 116, -1, 278, -1, - 277, 278, -1, 79, -1, 112, 270, -1, 110, 133, - 162, 134, 111, -1, 110, 133, 306, 134, 111, -1, - 110, 133, 161, 95, 161, 134, 111, -1, 112, 110, - 133, 145, 134, 111, -1, 280, -1, 229, 280, -1, - 279, 231, -1, 279, 231, 225, -1, 281, -1, 225, - 281, -1, 280, 226, -1, 74, 108, 288, 109, -1, - 283, 369, -1, 282, 115, 283, 369, -1, -1, 285, - 270, 284, 286, -1, 223, 332, -1, 32, -1, 34, - -1, 33, -1, -1, 286, 287, -1, 128, 270, 108, - 288, 109, -1, 128, 113, 133, 294, 114, -1, 128, - 108, 133, 282, 134, 109, 113, 133, 294, 114, 108, - 288, 109, -1, 272, -1, 162, -1, 288, 115, 272, - -1, 288, 115, 162, -1, 32, 290, -1, 230, 32, - 290, -1, 289, 115, 290, -1, 291, 286, -1, 291, - 286, 130, 272, -1, 270, -1, 269, 108, 133, 282, - 134, 109, -1, 35, 270, 108, 133, 282, 134, 109, - 113, 114, -1, -1, 35, 270, 108, 133, 282, 134, - 109, 113, 293, 294, 114, -1, 295, -1, 294, 133, - 295, -1, 296, 134, 131, -1, 297, 134, 131, -1, - 213, -1, 215, -1, 296, 134, 115, 133, 268, -1, - 223, 305, -1, 297, 134, 115, 133, 305, -1, -1, - 299, -1, 301, -1, 299, 133, 301, -1, -1, 299, - -1, 210, -1, 303, -1, 196, -1, -1, 5, 81, - 302, 113, 300, 114, -1, 39, 301, -1, 304, -1, - 319, 171, -1, 323, 133, 205, 171, -1, 214, 171, - -1, 222, 319, 171, -1, 225, 319, 171, -1, 229, - 319, 171, -1, 229, 225, 319, 171, -1, 222, 323, - 133, 205, 171, -1, 225, 323, 133, 205, 171, -1, - 229, 323, 133, 205, 171, -1, 229, 225, 323, 133, - 205, 171, -1, 314, -1, 319, -1, 327, -1, 161, - 122, 161, -1, -1, 63, 108, 140, 109, 308, -1, - -1, 309, -1, 310, -1, 309, 310, -1, 38, 108, - 108, 311, 109, 109, -1, 312, -1, 311, 115, 312, - -1, -1, 313, -1, 313, 108, 168, 109, -1, 268, - -1, 232, -1, 233, -1, 226, -1, 315, 308, -1, - 316, -1, 317, 308, -1, 318, 308, -1, 136, -1, - 108, 315, 109, -1, 118, 314, -1, 118, 225, 314, - -1, 108, 316, 109, -1, 315, 345, -1, 108, 316, - 109, 345, -1, 108, 317, 109, 346, -1, 108, 317, - 109, -1, 108, 316, 109, 108, 133, 260, 134, 109, - -1, 108, 318, 109, -1, 320, 308, -1, 321, -1, - 322, 308, -1, 315, 108, 133, 260, 134, 109, -1, - 108, 321, 109, 108, 133, 260, 134, 109, -1, 108, - 320, 109, -1, 118, 319, -1, 118, 225, 319, -1, - 108, 321, 109, -1, 108, 321, 109, 345, -1, 108, - 322, 109, 346, -1, 108, 322, 109, -1, 324, -1, - 325, -1, 326, -1, 315, 108, 267, 109, -1, 108, - 325, 109, 108, 267, 109, -1, 108, 324, 109, -1, - 118, 323, -1, 118, 225, 323, -1, 108, 325, 109, - -1, 108, 325, 109, 345, -1, 108, 326, 109, 346, - -1, 108, 326, 109, -1, 328, 308, -1, 329, -1, - 330, 308, -1, 331, 308, -1, 337, -1, 108, 328, - 109, -1, 118, 327, -1, 118, 225, 327, -1, 108, - 329, 109, -1, 328, 345, -1, 108, 329, 109, 345, - -1, 108, 330, 109, 346, -1, 108, 330, 109, -1, - 328, 108, 133, 260, 134, 109, -1, 108, 329, 109, - 108, 133, 260, 134, 109, -1, 108, 331, 109, -1, - 315, 308, -1, 333, -1, 334, 308, -1, 335, 308, - -1, 118, 332, -1, 118, 225, 332, -1, 108, 333, - 109, -1, 315, 351, -1, 108, 333, 109, 345, -1, - 108, 334, 109, 346, -1, 108, 334, 109, -1, 315, - 108, 133, 260, 134, 109, -1, 108, 333, 109, 108, - 133, 260, 134, 109, -1, 108, 335, 109, -1, 337, - 308, -1, 338, -1, 339, 308, -1, 340, 308, -1, - 73, -1, 74, -1, 118, 336, -1, 118, 225, 336, - -1, 108, 338, 109, -1, 337, 351, -1, 108, 338, - 109, 351, -1, 337, 108, 133, 260, 134, 109, -1, - 108, 338, 109, 108, 133, 260, 134, 109, -1, 342, - -1, 343, 308, -1, 344, 308, -1, 118, -1, 118, - 225, -1, 118, 341, -1, 118, 225, 341, -1, 108, - 342, 109, -1, 345, -1, 108, 342, 109, 345, -1, - 108, 343, 109, 346, -1, 108, 343, 109, -1, 108, - 133, 260, 134, 109, -1, 108, 342, 109, 108, 133, - 260, 134, 109, -1, 108, 344, 109, -1, 110, 111, - -1, 110, 111, 346, -1, 346, -1, 110, 133, 162, - 134, 111, -1, 110, 133, 118, 134, 111, -1, 346, - 110, 133, 162, 134, 111, -1, 346, 110, 133, 118, - 134, 111, -1, 348, -1, 349, 308, -1, 350, 308, - -1, 118, -1, 118, 225, -1, 118, 347, -1, 118, - 225, 347, -1, 108, 348, 109, -1, 351, -1, 108, - 348, 109, 351, -1, 108, 349, 109, 346, -1, 108, - 349, 109, -1, 108, 133, 260, 134, 109, -1, 108, - 348, 109, 108, 133, 260, 134, 109, -1, 108, 350, - 109, -1, 352, -1, 352, 346, -1, 346, -1, 110, - 111, -1, 110, 133, 225, 118, 134, 111, -1, 110, - 133, 225, 134, 111, -1, 110, 133, 225, 162, 134, - 111, -1, 110, 133, 7, 224, 162, 134, 111, -1, - 110, 133, 225, 7, 162, 134, 111, -1, 354, -1, - 355, 308, -1, 356, 308, -1, 118, -1, 118, 225, - -1, 118, 353, -1, 118, 225, 353, -1, 108, 354, - 109, -1, 345, -1, 108, 354, 109, 345, -1, 108, - 355, 109, 346, -1, 108, 355, 109, -1, 108, 354, - 109, 108, 133, 260, 134, 109, -1, 108, 356, 109, - -1, 358, -1, 366, -1, 225, 366, -1, 359, -1, - 360, -1, 118, 223, -1, 225, 118, 223, -1, 118, - 367, -1, 225, 118, 367, -1, 118, 357, -1, 225, - 118, 357, -1, 110, 111, 223, -1, 361, 223, -1, - 110, 111, 346, 223, -1, 361, 346, 223, -1, 346, - 223, -1, 110, 111, 359, -1, 361, 359, -1, 110, - 111, 346, 359, -1, 361, 346, 359, -1, 346, 359, - -1, 110, 133, 225, 118, 134, 111, -1, 110, 133, - 225, 162, 134, 111, -1, 110, 133, 229, 162, 134, - 111, -1, 110, 133, 229, 225, 162, 134, 111, -1, - 366, -1, 225, 366, -1, 363, -1, 364, -1, 365, - -1, 118, 223, -1, 225, 118, 223, -1, 118, 367, - -1, 225, 118, 367, -1, 118, 362, -1, 225, 118, - 362, -1, 110, 111, 223, -1, 110, 111, 346, 223, - -1, 346, 223, -1, 110, 111, 364, -1, 110, 111, - 346, 364, -1, 346, 364, -1, 110, 133, 259, 134, - 111, -1, 110, 111, 108, 256, 109, -1, 366, 108, - 133, 256, 134, 109, -1, 216, 108, 133, 256, 134, - 109, -1, -1, 115, -1, -1, 130, 162, -1 + -1, 22, -1, 23, -1, 15, -1, 25, -1, 26, + -1, 27, -1, 24, -1, 236, -1, 230, 236, -1, + 235, 232, -1, 235, 232, 226, -1, 235, 232, 236, + -1, 237, -1, 225, 238, 225, -1, 234, -1, 226, + 234, -1, 237, 227, -1, 237, 234, -1, 28, 109, + 275, 110, -1, 28, 109, 168, 110, -1, 78, 109, + 275, 110, -1, 78, 109, 168, 110, -1, 240, -1, + 230, 240, -1, 239, 232, -1, 239, 232, 226, -1, + 243, -1, 226, 243, -1, 240, 227, -1, 242, -1, + 230, 242, -1, 241, 232, -1, 241, 232, 226, -1, + 74, -1, 226, 74, -1, 242, 227, -1, 244, -1, + 255, -1, 246, 114, 247, 115, -1, 246, 273, -1, + -1, 246, 273, 245, 114, 247, 115, -1, 246, 109, + 291, 110, 114, 247, 115, -1, 246, 284, -1, 31, + 311, -1, 32, 311, -1, 248, -1, 247, 248, -1, + 249, 132, -1, 40, 249, 132, -1, 250, 132, -1, + 40, 250, 132, -1, 365, -1, 365, 273, -1, 249, + 116, 273, -1, 249, 116, -1, 224, 251, -1, 250, + 116, 311, 251, -1, -1, 253, -1, 317, 252, -1, + 330, 252, -1, 356, -1, -1, 253, -1, 117, 162, + -1, 30, 311, -1, 254, 114, 257, 371, 115, -1, + 254, 273, -1, -1, 254, 273, 256, 114, 257, 371, + 115, -1, 273, 258, -1, 257, 116, 273, 258, -1, + -1, 131, 162, -1, -1, 260, -1, 262, -1, 261, + -1, 261, 135, 116, 134, 262, -1, 262, 135, 116, + 134, 96, -1, 261, 135, 116, 134, 96, -1, 266, + -1, 262, 135, 116, 134, 266, -1, 261, 135, 116, + 134, 266, -1, 261, 135, 116, 134, 262, 135, 116, + 134, 266, -1, 267, -1, 262, 135, 116, 134, 267, + -1, -1, 264, -1, 265, -1, 265, 135, 116, 134, + 96, -1, 269, -1, 268, -1, 265, 135, 116, 134, + 269, -1, 265, 135, 116, 134, 268, -1, 268, -1, + 361, 271, 372, -1, 369, 271, 372, -1, 226, 369, + 271, 372, -1, 216, -1, 269, -1, 361, -1, 369, + -1, 226, 369, -1, 370, -1, 223, 335, 372, -1, + 223, 339, 372, -1, 223, -1, 223, 350, -1, 139, + -1, 270, 116, 139, -1, 137, -1, 74, -1, 75, + -1, 138, -1, 74, -1, 75, -1, 139, -1, 74, + -1, 75, -1, 365, -1, 224, -1, 224, 356, -1, + 365, -1, 370, -1, 224, -1, 224, 344, -1, -1, + 131, 277, -1, 107, 277, -1, 163, -1, 114, 278, + 371, 115, -1, -1, 277, -1, 279, 277, -1, 278, + 116, 277, -1, 278, 116, 279, 277, -1, 280, 117, + -1, 273, 117, -1, 281, -1, 280, 281, -1, 80, + -1, 113, 273, -1, 111, 134, 163, 135, 112, -1, + 111, 134, 309, 135, 112, -1, 111, 134, 162, 96, + 162, 135, 112, -1, 113, 111, 134, 146, 135, 112, + -1, 283, -1, 230, 283, -1, 282, 232, -1, 282, + 232, 226, -1, 284, -1, 226, 284, -1, 283, 227, + -1, 75, 109, 291, 110, -1, 286, 372, -1, 285, + 116, 286, 372, -1, -1, 288, 273, 287, 289, -1, + 224, 335, -1, 33, -1, 35, -1, 34, -1, -1, + 289, 290, -1, 129, 273, 109, 291, 110, -1, 129, + 114, 134, 297, 115, -1, 129, 109, 134, 285, 135, + 110, 114, 134, 297, 115, 109, 291, 110, -1, 275, + -1, 163, -1, 291, 116, 275, -1, 291, 116, 163, + -1, 33, 293, -1, 231, 33, 293, -1, 292, 116, + 293, -1, 294, 289, -1, 294, 289, 131, 275, -1, + 273, -1, 272, 109, 134, 285, 135, 110, -1, 36, + 273, 109, 134, 285, 135, 110, 114, 115, -1, -1, + 36, 273, 109, 134, 285, 135, 110, 114, 296, 297, + 115, -1, 298, -1, 297, 134, 298, -1, 299, 135, + 132, -1, 300, 135, 132, -1, 214, -1, 216, -1, + 299, 135, 116, 134, 271, -1, 224, 308, -1, 300, + 135, 116, 134, 308, -1, -1, 302, -1, 304, -1, + 302, 134, 304, -1, -1, 302, -1, 211, -1, 306, + -1, 197, -1, -1, 5, 82, 305, 114, 303, 115, + -1, 40, 304, -1, 307, -1, 322, 172, -1, 326, + 134, 206, 172, -1, 215, 172, -1, 223, 322, 172, + -1, 226, 322, 172, -1, 230, 322, 172, -1, 230, + 226, 322, 172, -1, 223, 326, 134, 206, 172, -1, + 226, 326, 134, 206, 172, -1, 230, 326, 134, 206, + 172, -1, 230, 226, 326, 134, 206, 172, -1, 317, + -1, 322, -1, 330, -1, 162, 123, 162, -1, -1, + 64, 109, 141, 110, 311, -1, -1, 312, -1, 313, + -1, 312, 313, -1, 39, 109, 109, 314, 110, 110, + -1, 315, -1, 314, 116, 315, -1, -1, 316, -1, + 316, 109, 169, 110, -1, 271, -1, 233, -1, 234, + -1, 227, -1, 318, 311, -1, 319, -1, 320, 311, + -1, 321, 311, -1, 137, -1, 109, 318, 110, -1, + 119, 317, -1, 119, 226, 317, -1, 109, 319, 110, + -1, 318, 348, -1, 109, 319, 110, 348, -1, 109, + 320, 110, 349, -1, 109, 320, 110, -1, 109, 319, + 110, 109, 134, 263, 135, 110, -1, 109, 321, 110, + -1, 323, 311, -1, 324, -1, 325, 311, -1, 318, + 109, 134, 263, 135, 110, -1, 109, 324, 110, 109, + 134, 263, 135, 110, -1, 109, 323, 110, -1, 119, + 322, -1, 119, 226, 322, -1, 109, 324, 110, -1, + 109, 324, 110, 348, -1, 109, 325, 110, 349, -1, + 109, 325, 110, -1, 327, -1, 328, -1, 329, -1, + 318, 109, 270, 110, -1, 109, 328, 110, 109, 270, + 110, -1, 109, 327, 110, -1, 119, 326, -1, 119, + 226, 326, -1, 109, 328, 110, -1, 109, 328, 110, + 348, -1, 109, 329, 110, 349, -1, 109, 329, 110, + -1, 331, 311, -1, 332, -1, 333, 311, -1, 334, + 311, -1, 340, -1, 109, 331, 110, -1, 119, 330, + -1, 119, 226, 330, -1, 109, 332, 110, -1, 331, + 348, -1, 109, 332, 110, 348, -1, 109, 333, 110, + 349, -1, 109, 333, 110, -1, 331, 109, 134, 263, + 135, 110, -1, 109, 332, 110, 109, 134, 263, 135, + 110, -1, 109, 334, 110, -1, 318, 311, -1, 336, + -1, 337, 311, -1, 338, 311, -1, 119, 335, -1, + 119, 226, 335, -1, 109, 336, 110, -1, 318, 354, + -1, 109, 336, 110, 348, -1, 109, 337, 110, 349, + -1, 109, 337, 110, -1, 318, 109, 134, 263, 135, + 110, -1, 109, 336, 110, 109, 134, 263, 135, 110, + -1, 109, 338, 110, -1, 340, 311, -1, 341, -1, + 342, 311, -1, 343, 311, -1, 74, -1, 75, -1, + 119, 339, -1, 119, 226, 339, -1, 109, 341, 110, + -1, 340, 354, -1, 109, 341, 110, 354, -1, 340, + 109, 134, 263, 135, 110, -1, 109, 341, 110, 109, + 134, 263, 135, 110, -1, 345, -1, 346, 311, -1, + 347, 311, -1, 119, -1, 119, 226, -1, 119, 344, + -1, 119, 226, 344, -1, 109, 345, 110, -1, 348, + -1, 109, 345, 110, 348, -1, 109, 346, 110, 349, + -1, 109, 346, 110, -1, 109, 134, 263, 135, 110, + -1, 109, 345, 110, 109, 134, 263, 135, 110, -1, + 109, 347, 110, -1, 111, 112, -1, 111, 112, 349, + -1, 349, -1, 111, 134, 163, 135, 112, -1, 111, + 134, 119, 135, 112, -1, 349, 111, 134, 163, 135, + 112, -1, 349, 111, 134, 119, 135, 112, -1, 351, + -1, 352, 311, -1, 353, 311, -1, 119, -1, 119, + 226, -1, 119, 350, -1, 119, 226, 350, -1, 109, + 351, 110, -1, 354, -1, 109, 351, 110, 354, -1, + 109, 352, 110, 349, -1, 109, 352, 110, -1, 109, + 134, 263, 135, 110, -1, 109, 351, 110, 109, 134, + 263, 135, 110, -1, 109, 353, 110, -1, 355, -1, + 355, 349, -1, 349, -1, 111, 112, -1, 111, 134, + 226, 119, 135, 112, -1, 111, 134, 226, 135, 112, + -1, 111, 134, 226, 163, 135, 112, -1, 111, 134, + 7, 225, 163, 135, 112, -1, 111, 134, 226, 7, + 163, 135, 112, -1, 357, -1, 358, 311, -1, 359, + 311, -1, 119, -1, 119, 226, -1, 119, 356, -1, + 119, 226, 356, -1, 109, 357, 110, -1, 348, -1, + 109, 357, 110, 348, -1, 109, 358, 110, 349, -1, + 109, 358, 110, -1, 109, 357, 110, 109, 134, 263, + 135, 110, -1, 109, 359, 110, -1, 361, -1, 369, + -1, 226, 369, -1, 362, -1, 363, -1, 119, 224, + -1, 226, 119, 224, -1, 119, 370, -1, 226, 119, + 370, -1, 119, 360, -1, 226, 119, 360, -1, 111, + 112, 224, -1, 364, 224, -1, 111, 112, 349, 224, + -1, 364, 349, 224, -1, 349, 224, -1, 111, 112, + 362, -1, 364, 362, -1, 111, 112, 349, 362, -1, + 364, 349, 362, -1, 349, 362, -1, 111, 134, 226, + 119, 135, 112, -1, 111, 134, 226, 163, 135, 112, + -1, 111, 134, 230, 163, 135, 112, -1, 111, 134, + 230, 226, 163, 135, 112, -1, 369, -1, 226, 369, + -1, 366, -1, 367, -1, 368, -1, 119, 224, -1, + 226, 119, 224, -1, 119, 370, -1, 226, 119, 370, + -1, 119, 365, -1, 226, 119, 365, -1, 111, 112, + 224, -1, 111, 112, 349, 224, -1, 349, 224, -1, + 111, 112, 367, -1, 111, 112, 349, 367, -1, 349, + 367, -1, 111, 134, 262, 135, 112, -1, 111, 112, + 109, 259, 110, -1, 369, 109, 134, 259, 135, 110, + -1, 217, 109, 134, 259, 135, 110, -1, -1, 116, + -1, -1, 131, 163, -1 }; @@ -1012,80 +1016,80 @@ static const yytype_uint16 yyrline[] = { - 0, 290, 290, 296, 305, 306, 307, 311, 312, 313, - 317, 318, 322, 323, 327, 328, 332, 333, 339, 341, - 343, 345, 350, 351, 357, 361, 363, 364, 366, 367, - 369, 371, 373, 381, 382, 388, 389, 390, 395, 397, - 402, 403, 407, 411, 413, 415, 417, 422, 425, 427, - 429, 431, 433, 435, 437, 439, 445, 447, 449, 451, - 453, 455, 457, 459, 461, 466, 467, 468, 469, 473, - 474, 476, 481, 482, 484, 486, 491, 492, 494, 499, - 500, 502, 507, 508, 510, 512, 514, 519, 520, 522, - 527, 528, 533, 534, 539, 540, 545, 546, 551, 552, - 557, 558, 560, 562, 567, 572, 573, 575, 577, 583, - 584, 590, 592, 594, 596, 601, 602, 607, 608, 609, - 610, 611, 612, 613, 614, 615, 616, 620, 621, 627, - 628, 634, 635, 636, 637, 638, 639, 640, 641, 642, - 651, 658, 660, 670, 671, 676, 678, 680, 682, 686, - 687, 692, 697, 700, 702, 704, 709, 711, 719, 720, - 722, 726, 727, 732, 733, 738, 739, 743, 748, 749, - 753, 755, 761, 762, 766, 768, 770, 772, 778, 779, - 783, 784, 788, 790, 792, 797, 799, 804, 806, 810, - 813, 817, 820, 824, 826, 830, 832, 839, 841, 843, - 852, 854, 856, 858, 860, 865, 867, 869, 871, 876, - 889, 890, 895, 897, 902, 906, 908, 910, 912, 914, - 920, 921, 927, 928, 932, 933, 938, 940, 946, 947, - 949, 954, 956, 963, 965, 969, 970, 975, 977, 981, - 982, 986, 988, 992, 993, 997, 998, 1002, 1003, 1018, - 1019, 1020, 1021, 1022, 1026, 1031, 1038, 1048, 1053, 1058, - 1066, 1071, 1076, 1081, 1086, 1094, 1116, 1121, 1128, 1130, - 1137, 1142, 1147, 1158, 1163, 1168, 1173, 1178, 1187, 1192, - 1200, 1201, 1202, 1203, 1209, 1214, 1222, 1223, 1224, 1225, - 1229, 1230, 1231, 1232, 1237, 1238, 1247, 1248, 1253, 1254, - 1259, 1261, 1263, 1265, 1267, 1270, 1269, 1281, 1282, 1284, - 1294, 1295, 1300, 1304, 1306, 1308, 1310, 1312, 1314, 1316, - 1318, 1323, 1325, 1327, 1329, 1331, 1333, 1335, 1337, 1339, - 1341, 1343, 1345, 1351, 1352, 1354, 1356, 1358, 1363, 1364, - 1370, 1371, 1373, 1375, 1380, 1382, 1384, 1386, 1391, 1392, - 1394, 1396, 1401, 1402, 1404, 1409, 1410, 1412, 1414, 1419, - 1421, 1423, 1428, 1429, 1433, 1435, 1437, 1439, 1441, 1446, - 1448, 1453, 1455, 1460, 1461, 1463, 1464, 1469, 1470, 1472, - 1474, 1479, 1481, 1487, 1488, 1490, 1493, 1496, 1501, 1502, - 1507, 1512, 1516, 1518, 1520, 1525, 1527, 1533, 1534, 1542, - 1543, 1547, 1548, 1549, 1551, 1553, 1560, 1561, 1563, 1565, - 1570, 1571, 1577, 1578, 1582, 1583, 1588, 1589, 1590, 1592, - 1600, 1601, 1603, 1606, 1608, 1612, 1613, 1614, 1616, 1618, - 1622, 1627, 1635, 1636, 1645, 1647, 1652, 1653, 1654, 1658, - 1659, 1660, 1664, 1665, 1666, 1670, 1671, 1672, 1677, 1678, - 1679, 1680, 1686, 1687, 1689, 1694, 1695, 1700, 1701, 1702, - 1703, 1704, 1719, 1720, 1725, 1726, 1734, 1736, 1738, 1741, - 1743, 1745, 1768, 1769, 1771, 1773, 1778, 1779, 1781, 1786, - 1791, 1792, 1798, 1797, 1801, 1805, 1807, 1809, 1815, 1816, - 1821, 1826, 1828, 1833, 1835, 1836, 1838, 1843, 1845, 1847, - 1852, 1854, 1859, 1864, 1872, 1878, 1877, 1891, 1892, 1897, - 1898, 1902, 1907, 1912, 1920, 1925, 1936, 1937, 1948, 1949, - 1955, 1956, 1960, 1961, 1962, 1965, 1964, 1975, 1980, 1985, - 1991, 2000, 2006, 2012, 2018, 2024, 2032, 2038, 2046, 2052, - 2061, 2062, 2063, 2067, 2071, 2073, 2078, 2079, 2083, 2084, - 2089, 2095, 2096, 2099, 2101, 2102, 2106, 2107, 2108, 2109, - 2143, 2145, 2146, 2148, 2153, 2158, 2163, 2165, 2167, 2172, - 2174, 2176, 2178, 2183, 2185, 2195, 2197, 2198, 2203, 2205, - 2207, 2212, 2214, 2216, 2221, 2223, 2225, 2234, 2235, 2236, - 2240, 2242, 2244, 2249, 2251, 2253, 2258, 2260, 2262, 2277, - 2279, 2280, 2282, 2287, 2288, 2293, 2295, 2297, 2302, 2304, - 2306, 2308, 2313, 2315, 2317, 2327, 2329, 2330, 2332, 2337, - 2339, 2341, 2346, 2348, 2350, 2352, 2357, 2359, 2361, 2392, - 2394, 2395, 2397, 2402, 2407, 2415, 2417, 2419, 2424, 2426, - 2431, 2433, 2447, 2448, 2450, 2455, 2457, 2459, 2461, 2463, - 2468, 2469, 2471, 2473, 2478, 2480, 2482, 2488, 2490, 2492, - 2496, 2498, 2500, 2502, 2516, 2517, 2519, 2524, 2526, 2528, - 2530, 2532, 2537, 2538, 2540, 2542, 2547, 2549, 2551, 2557, - 2558, 2560, 2569, 2572, 2574, 2577, 2579, 2581, 2594, 2595, - 2597, 2602, 2604, 2606, 2608, 2610, 2615, 2616, 2618, 2620, - 2625, 2627, 2635, 2636, 2637, 2642, 2643, 2647, 2649, 2651, - 2653, 2655, 2657, 2664, 2666, 2668, 2670, 2672, 2674, 2676, - 2678, 2680, 2682, 2687, 2689, 2691, 2696, 2722, 2723, 2725, - 2729, 2730, 2734, 2736, 2738, 2740, 2742, 2744, 2751, 2753, - 2755, 2757, 2759, 2761, 2766, 2771, 2773, 2775, 2793, 2795, - 2800, 2801 + 0, 292, 292, 298, 307, 308, 309, 313, 314, 315, + 319, 320, 324, 325, 329, 330, 334, 335, 341, 343, + 345, 347, 352, 353, 359, 363, 365, 366, 368, 369, + 371, 373, 375, 383, 384, 390, 391, 392, 397, 399, + 404, 405, 409, 413, 415, 417, 419, 424, 427, 429, + 431, 433, 435, 437, 439, 441, 447, 449, 451, 453, + 455, 457, 459, 461, 463, 468, 469, 470, 471, 475, + 476, 478, 483, 484, 486, 488, 493, 494, 496, 501, + 502, 504, 509, 510, 512, 514, 516, 521, 522, 524, + 529, 530, 535, 536, 541, 542, 547, 548, 553, 554, + 559, 560, 562, 564, 569, 574, 575, 577, 579, 585, + 586, 592, 594, 596, 598, 603, 604, 609, 610, 611, + 612, 613, 614, 615, 616, 617, 618, 622, 623, 629, + 630, 636, 637, 638, 639, 640, 641, 642, 643, 644, + 653, 660, 662, 672, 673, 678, 680, 682, 684, 688, + 689, 694, 699, 702, 704, 706, 711, 713, 721, 722, + 724, 728, 729, 734, 735, 740, 741, 745, 750, 751, + 755, 757, 763, 764, 768, 770, 772, 774, 780, 781, + 785, 786, 790, 792, 794, 799, 801, 806, 808, 812, + 815, 819, 822, 826, 828, 832, 834, 841, 843, 845, + 854, 856, 858, 860, 862, 867, 869, 871, 873, 878, + 891, 892, 897, 899, 904, 908, 910, 912, 914, 916, + 922, 923, 929, 930, 934, 935, 940, 942, 948, 949, + 951, 956, 958, 965, 967, 971, 972, 977, 979, 983, + 984, 988, 990, 994, 995, 999, 1000, 1004, 1005, 1020, + 1021, 1022, 1023, 1024, 1028, 1033, 1040, 1050, 1055, 1060, + 1068, 1073, 1078, 1083, 1088, 1096, 1118, 1123, 1130, 1132, + 1139, 1144, 1149, 1160, 1165, 1170, 1175, 1180, 1189, 1194, + 1202, 1203, 1204, 1205, 1211, 1216, 1224, 1225, 1226, 1227, + 1231, 1232, 1233, 1234, 1239, 1240, 1249, 1250, 1255, 1256, + 1261, 1263, 1265, 1267, 1269, 1272, 1271, 1283, 1284, 1286, + 1296, 1297, 1302, 1306, 1308, 1310, 1312, 1314, 1316, 1318, + 1320, 1325, 1327, 1329, 1331, 1333, 1335, 1337, 1339, 1341, + 1343, 1345, 1347, 1349, 1355, 1356, 1358, 1360, 1362, 1367, + 1368, 1374, 1375, 1377, 1379, 1384, 1386, 1388, 1390, 1395, + 1396, 1398, 1400, 1405, 1406, 1408, 1413, 1414, 1416, 1418, + 1423, 1425, 1427, 1432, 1433, 1437, 1439, 1445, 1444, 1448, + 1450, 1455, 1457, 1462, 1464, 1469, 1470, 1472, 1473, 1478, + 1479, 1481, 1483, 1488, 1490, 1496, 1497, 1499, 1502, 1505, + 1510, 1511, 1516, 1521, 1525, 1527, 1533, 1532, 1539, 1541, + 1547, 1548, 1556, 1557, 1561, 1562, 1563, 1565, 1567, 1574, + 1575, 1577, 1579, 1584, 1585, 1591, 1592, 1596, 1597, 1602, + 1603, 1604, 1606, 1614, 1615, 1617, 1620, 1622, 1626, 1627, + 1628, 1630, 1632, 1636, 1641, 1649, 1650, 1659, 1661, 1666, + 1667, 1668, 1672, 1673, 1674, 1678, 1679, 1680, 1684, 1685, + 1686, 1691, 1692, 1693, 1694, 1700, 1701, 1703, 1708, 1709, + 1714, 1715, 1716, 1717, 1718, 1733, 1734, 1739, 1740, 1748, + 1750, 1752, 1755, 1757, 1759, 1782, 1783, 1785, 1787, 1792, + 1793, 1795, 1800, 1805, 1806, 1812, 1811, 1815, 1819, 1821, + 1823, 1829, 1830, 1835, 1840, 1842, 1847, 1849, 1850, 1852, + 1857, 1859, 1861, 1866, 1868, 1873, 1878, 1886, 1892, 1891, + 1905, 1906, 1911, 1912, 1916, 1921, 1926, 1934, 1939, 1950, + 1951, 1962, 1963, 1969, 1970, 1974, 1975, 1976, 1979, 1978, + 1989, 1994, 1999, 2005, 2014, 2020, 2026, 2032, 2038, 2046, + 2052, 2060, 2066, 2075, 2076, 2077, 2081, 2085, 2087, 2092, + 2093, 2097, 2098, 2103, 2109, 2110, 2113, 2115, 2116, 2120, + 2121, 2122, 2123, 2157, 2159, 2160, 2162, 2167, 2172, 2177, + 2179, 2181, 2186, 2188, 2190, 2192, 2197, 2199, 2209, 2211, + 2212, 2217, 2219, 2221, 2226, 2228, 2230, 2235, 2237, 2239, + 2248, 2249, 2250, 2254, 2256, 2258, 2263, 2265, 2267, 2272, + 2274, 2276, 2291, 2293, 2294, 2296, 2301, 2302, 2307, 2309, + 2311, 2316, 2318, 2320, 2322, 2327, 2329, 2331, 2341, 2343, + 2344, 2346, 2351, 2353, 2355, 2360, 2362, 2364, 2366, 2371, + 2373, 2375, 2406, 2408, 2409, 2411, 2416, 2421, 2429, 2431, + 2433, 2438, 2440, 2445, 2447, 2461, 2462, 2464, 2469, 2471, + 2473, 2475, 2477, 2482, 2483, 2485, 2487, 2492, 2494, 2496, + 2502, 2504, 2506, 2510, 2512, 2514, 2516, 2530, 2531, 2533, + 2538, 2540, 2542, 2544, 2546, 2551, 2552, 2554, 2556, 2561, + 2563, 2565, 2571, 2572, 2574, 2583, 2586, 2588, 2591, 2593, + 2595, 2608, 2609, 2611, 2616, 2618, 2620, 2622, 2624, 2629, + 2630, 2632, 2634, 2639, 2641, 2649, 2650, 2651, 2656, 2657, + 2661, 2663, 2665, 2667, 2669, 2671, 2678, 2680, 2682, 2684, + 2686, 2688, 2690, 2692, 2694, 2696, 2701, 2703, 2705, 2710, + 2736, 2737, 2739, 2743, 2744, 2748, 2750, 2752, 2754, 2756, + 2758, 2765, 2767, 2769, 2771, 2773, 2775, 2780, 2785, 2787, + 2789, 2807, 2809, 2814, 2815 }; #endif @@ -1099,13 +1103,13 @@ "STATIC", "INLINE", "FORTRAN", "CONST", "VOLATILE", "RESTRICT", "FORALL", "LVALUE", "VOID", "CHAR", "SHORT", "INT", "LONG", "FLOAT", "DOUBLE", - "SIGNED", "UNSIGNED", "BOOL", "COMPLEX", "IMAGINARY", "TYPEOF", "LABEL", - "ENUM", "STRUCT", "UNION", "TYPE", "FTYPE", "DTYPE", "CONTEXT", "SIZEOF", - "OFFSETOF", "ATTRIBUTE", "EXTENSION", "IF", "ELSE", "SWITCH", "CASE", - "DEFAULT", "DO", "WHILE", "FOR", "BREAK", "CONTINUE", "GOTO", "RETURN", - "CHOOSE", "DISABLE", "ENABLE", "FALLTHRU", "TRY", "CATCH", "CATCHRESUME", - "FINALLY", "THROW", "THROWRESUME", "AT", "ASM", "ALIGNAS", "ALIGNOF", - "ATOMIC", "GENERIC", "NORETURN", "STATICASSERT", "THREADLOCAL", - "IDENTIFIER", "QUOTED_IDENTIFIER", "TYPEDEFname", "TYPEGENname", - "ATTR_IDENTIFIER", "ATTR_TYPEDEFname", "ATTR_TYPEGENname", + "SIGNED", "UNSIGNED", "VALIST", "BOOL", "COMPLEX", "IMAGINARY", "TYPEOF", + "LABEL", "ENUM", "STRUCT", "UNION", "OTYPE", "FTYPE", "DTYPE", "TRAIT", + "SIZEOF", "OFFSETOF", "ATTRIBUTE", "EXTENSION", "IF", "ELSE", "SWITCH", + "CASE", "DEFAULT", "DO", "WHILE", "FOR", "BREAK", "CONTINUE", "GOTO", + "RETURN", "CHOOSE", "DISABLE", "ENABLE", "FALLTHRU", "TRY", "CATCH", + "CATCHRESUME", "FINALLY", "THROW", "THROWRESUME", "AT", "ASM", "ALIGNAS", + "ALIGNOF", "ATOMIC", "GENERIC", "NORETURN", "STATICASSERT", + "THREADLOCAL", "IDENTIFIER", "QUOTED_IDENTIFIER", "TYPEDEFname", + "TYPEGENname", "ATTR_IDENTIFIER", "ATTR_TYPEDEFname", "ATTR_TYPEGENname", "INTEGERconstant", "FLOATINGconstant", "CHARACTERconstant", "STRINGliteral", "ZERO", "ONE", "ARROW", "ICR", "DECR", "LS", "RS", "LE", @@ -1152,35 +1156,35 @@ "sue_declaration_specifier", "sue_type_specifier", "typedef_declaration_specifier", "typedef_type_specifier", - "elaborated_type_name", "aggregate_name", "aggregate_key", + "elaborated_type_name", "aggregate_name", "$@2", "aggregate_key", "field_declaration_list", "field_declaration", "new_field_declaring_list", "field_declaring_list", "field_declarator", "bit_subrange_size_opt", "bit_subrange_size", "enum_key", "enum_name", - "enumerator_list", "enumerator_value_opt", "new_parameter_type_list_opt", - "new_parameter_type_list", "new_parameter_list", - "new_abstract_parameter_list", "parameter_type_list_opt", - "parameter_type_list", "parameter_list", "new_parameter_declaration", - "new_abstract_parameter_declaration", "parameter_declaration", - "abstract_parameter_declaration", "identifier_list", - "identifier_or_type_name", "no_01_identifier_or_type_name", - "no_attr_identifier_or_type_name", "type_name_no_function", "type_name", - "initializer_opt", "initializer", "initializer_list", "designation", - "designator_list", "designator", "typegen_declaration_specifier", - "typegen_type_specifier", "typegen_name", "type_parameter_list", - "type_parameter", "$@2", "type_class", "assertion_list_opt", "assertion", - "type_name_list", "type_declaring_list", "type_declarator", - "type_declarator_name", "context_specifier", "$@3", - "context_declaration_list", "context_declaration", - "new_context_declaring_list", "context_declaring_list", - "translation_unit", "external_definition_list", - "external_definition_list_opt", "external_definition", "$@4", - "external_function_definition", "function_definition", "declarator", - "subrange", "asm_name_opt", "attribute_list_opt", "attribute_list", - "attribute", "attribute_parameter_list", "attrib", "any_word", - "variable_declarator", "paren_identifier", "variable_ptr", - "variable_array", "variable_function", "function_declarator", - "function_no_ptr", "function_ptr", "function_array", - "old_function_declarator", "old_function_no_ptr", "old_function_ptr", - "old_function_array", "type_redeclarator", "paren_type", "type_ptr", - "type_array", "type_function", "identifier_parameter_declarator", + "$@3", "enumerator_list", "enumerator_value_opt", + "new_parameter_type_list_opt", "new_parameter_type_list", + "new_parameter_list", "new_abstract_parameter_list", + "parameter_type_list_opt", "parameter_type_list", "parameter_list", + "new_parameter_declaration", "new_abstract_parameter_declaration", + "parameter_declaration", "abstract_parameter_declaration", + "identifier_list", "identifier_or_type_name", + "no_01_identifier_or_type_name", "no_attr_identifier_or_type_name", + "type_name_no_function", "type_name", "initializer_opt", "initializer", + "initializer_list", "designation", "designator_list", "designator", + "typegen_declaration_specifier", "typegen_type_specifier", + "typegen_name", "type_parameter_list", "type_parameter", "$@4", + "type_class", "assertion_list_opt", "assertion", "type_name_list", + "type_declaring_list", "type_declarator", "type_declarator_name", + "trait_specifier", "$@5", "trait_declaration_list", "trait_declaration", + "new_trait_declaring_list", "trait_declaring_list", "translation_unit", + "external_definition_list", "external_definition_list_opt", + "external_definition", "$@6", "external_function_definition", + "function_definition", "declarator", "subrange", "asm_name_opt", + "attribute_list_opt", "attribute_list", "attribute", + "attribute_parameter_list", "attrib", "any_word", "variable_declarator", + "paren_identifier", "variable_ptr", "variable_array", + "variable_function", "function_declarator", "function_no_ptr", + "function_ptr", "function_array", "old_function_declarator", + "old_function_no_ptr", "old_function_ptr", "old_function_array", + "type_redeclarator", "paren_type", "type_ptr", "type_array", + "type_function", "identifier_parameter_declarator", "identifier_parameter_ptr", "identifier_parameter_array", "identifier_parameter_function", "type_parameter_redeclarator", @@ -1219,8 +1223,8 @@ 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 362, 40, 41, - 91, 93, 46, 123, 125, 44, 58, 33, 42, 38, - 43, 45, 126, 47, 37, 60, 62, 94, 124, 63, - 61, 59 + 355, 356, 357, 358, 359, 360, 361, 362, 363, 40, + 41, 91, 93, 46, 123, 125, 44, 58, 33, 42, + 38, 43, 45, 126, 47, 37, 60, 62, 94, 124, + 63, 61, 59 }; # endif @@ -1229,80 +1233,80 @@ static const yytype_uint16 yyr1[] = { - 0, 132, 133, 134, 135, 135, 135, 136, 136, 136, - 137, 137, 138, 138, 139, 139, 140, 140, 141, 141, - 141, 141, 142, 142, 142, 142, 142, 142, 142, 142, - 142, 142, 142, 143, 143, 144, 144, 144, 144, 144, - 145, 145, 146, 146, 146, 146, 146, 147, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 147, 147, 147, 147, 147, 148, 148, 148, 148, 149, - 149, 149, 150, 150, 150, 150, 151, 151, 151, 152, - 152, 152, 153, 153, 153, 153, 153, 154, 154, 154, - 155, 155, 156, 156, 157, 157, 158, 158, 159, 159, - 160, 160, 160, 160, 161, 162, 162, 162, 162, 163, - 163, 164, 164, 164, 164, 165, 165, 166, 166, 166, - 166, 166, 166, 166, 166, 166, 166, 167, 167, 168, - 168, 169, 169, 169, 169, 169, 169, 169, 169, 169, - 170, 171, 171, 172, 172, 173, 173, 173, 173, 174, - 174, 175, 176, 176, 176, 176, 176, 176, 177, 177, - 177, 178, 178, 179, 179, 180, 180, 181, 182, 182, - 183, 183, 184, 184, 185, 185, 185, 185, 186, 186, - 187, 187, 188, 188, 188, 189, 189, 190, 190, 190, - 190, 190, 190, 190, 190, 190, 190, 191, 191, 191, - 192, 192, 192, 192, 192, 193, 193, 193, 193, 194, - 195, 195, 195, 195, 195, 196, 196, 196, 196, 196, - 197, 197, 198, 198, 199, 199, 200, 200, 201, 201, - 201, 202, 202, 203, 203, 204, 204, 205, 205, 206, - 206, 207, 207, 208, 208, 209, 209, 210, 210, 211, - 211, 211, 211, 211, 212, 212, 212, 213, 213, 213, - 214, 214, 214, 214, 214, 215, 215, 215, 216, 216, - 217, 217, 217, 218, 218, 218, 218, 218, 219, 219, - 220, 220, 220, 220, 221, 221, 222, 222, 222, 222, - 223, 223, 223, 223, 224, 224, 225, 225, 226, 226, - 227, 227, 227, 227, 227, 228, 227, 229, 229, 229, - 230, 230, 231, 232, 232, 232, 232, 232, 232, 232, - 232, 233, 233, 233, 233, 233, 233, 233, 233, 233, - 233, 233, 233, 234, 234, 234, 234, 234, 235, 235, - 236, 236, 236, 236, 237, 237, 237, 237, 238, 238, - 238, 238, 239, 239, 239, 240, 240, 240, 240, 241, - 241, 241, 242, 242, 243, 243, 243, 243, 243, 244, - 244, 245, 245, 246, 246, 246, 246, 247, 247, 247, - 247, 248, 248, 249, 249, 249, 249, 249, 250, 250, - 251, 252, 253, 253, 253, 254, 254, 255, 255, 256, - 256, 257, 257, 257, 257, 257, 258, 258, 258, 258, - 259, 259, 260, 260, 261, 261, 262, 262, 262, 262, - 263, 263, 263, 263, 263, 264, 264, 264, 264, 264, - 265, 265, 266, 266, 267, 267, 268, 268, 268, 269, - 269, 269, 270, 270, 270, 271, 271, 271, 272, 272, - 272, 272, 273, 273, 273, 274, 274, 275, 275, 275, - 275, 275, 276, 276, 277, 277, 278, 278, 278, 278, - 278, 278, 279, 279, 279, 279, 280, 280, 280, 281, - 282, 282, 284, 283, 283, 285, 285, 285, 286, 286, - 287, 287, 287, 288, 288, 288, 288, 289, 289, 289, - 290, 290, 291, 291, 292, 293, 292, 294, 294, 295, - 295, 296, 296, 296, 297, 297, 298, 298, 299, 299, - 300, 300, 301, 301, 301, 302, 301, 301, 303, 303, - 303, 304, 304, 304, 304, 304, 304, 304, 304, 304, - 305, 305, 305, 306, 307, 307, 308, 308, 309, 309, - 310, 311, 311, 312, 312, 312, 313, 313, 313, 313, - 314, 314, 314, 314, 315, 315, 316, 316, 316, 317, - 317, 317, 317, 318, 318, 319, 319, 319, 320, 320, - 320, 321, 321, 321, 322, 322, 322, 323, 323, 323, - 324, 324, 324, 325, 325, 325, 326, 326, 326, 327, - 327, 327, 327, 328, 328, 329, 329, 329, 330, 330, - 330, 330, 331, 331, 331, 332, 332, 332, 332, 333, - 333, 333, 334, 334, 334, 334, 335, 335, 335, 336, - 336, 336, 336, 337, 337, 338, 338, 338, 339, 339, - 340, 340, 341, 341, 341, 342, 342, 342, 342, 342, - 343, 343, 343, 343, 344, 344, 344, 345, 345, 345, - 346, 346, 346, 346, 347, 347, 347, 348, 348, 348, - 348, 348, 349, 349, 349, 349, 350, 350, 350, 351, - 351, 351, 352, 352, 352, 352, 352, 352, 353, 353, - 353, 354, 354, 354, 354, 354, 355, 355, 355, 355, - 356, 356, 357, 357, 357, 358, 358, 359, 359, 359, - 359, 359, 359, 360, 360, 360, 360, 360, 360, 360, - 360, 360, 360, 361, 361, 361, 361, 362, 362, 362, - 363, 363, 364, 364, 364, 364, 364, 364, 365, 365, - 365, 365, 365, 365, 366, 367, 367, 367, 368, 368, - 369, 369 + 0, 133, 134, 135, 136, 136, 136, 137, 137, 137, + 138, 138, 139, 139, 140, 140, 141, 141, 142, 142, + 142, 142, 143, 143, 143, 143, 143, 143, 143, 143, + 143, 143, 143, 144, 144, 145, 145, 145, 145, 145, + 146, 146, 147, 147, 147, 147, 147, 148, 148, 148, + 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, + 148, 148, 148, 148, 148, 149, 149, 149, 149, 150, + 150, 150, 151, 151, 151, 151, 152, 152, 152, 153, + 153, 153, 154, 154, 154, 154, 154, 155, 155, 155, + 156, 156, 157, 157, 158, 158, 159, 159, 160, 160, + 161, 161, 161, 161, 162, 163, 163, 163, 163, 164, + 164, 165, 165, 165, 165, 166, 166, 167, 167, 167, + 167, 167, 167, 167, 167, 167, 167, 168, 168, 169, + 169, 170, 170, 170, 170, 170, 170, 170, 170, 170, + 171, 172, 172, 173, 173, 174, 174, 174, 174, 175, + 175, 176, 177, 177, 177, 177, 177, 177, 178, 178, + 178, 179, 179, 180, 180, 181, 181, 182, 183, 183, + 184, 184, 185, 185, 186, 186, 186, 186, 187, 187, + 188, 188, 189, 189, 189, 190, 190, 191, 191, 191, + 191, 191, 191, 191, 191, 191, 191, 192, 192, 192, + 193, 193, 193, 193, 193, 194, 194, 194, 194, 195, + 196, 196, 196, 196, 196, 197, 197, 197, 197, 197, + 198, 198, 199, 199, 200, 200, 201, 201, 202, 202, + 202, 203, 203, 204, 204, 205, 205, 206, 206, 207, + 207, 208, 208, 209, 209, 210, 210, 211, 211, 212, + 212, 212, 212, 212, 213, 213, 213, 214, 214, 214, + 215, 215, 215, 215, 215, 216, 216, 216, 217, 217, + 218, 218, 218, 219, 219, 219, 219, 219, 220, 220, + 221, 221, 221, 221, 222, 222, 223, 223, 223, 223, + 224, 224, 224, 224, 225, 225, 226, 226, 227, 227, + 228, 228, 228, 228, 228, 229, 228, 230, 230, 230, + 231, 231, 232, 233, 233, 233, 233, 233, 233, 233, + 233, 234, 234, 234, 234, 234, 234, 234, 234, 234, + 234, 234, 234, 234, 235, 235, 235, 235, 235, 236, + 236, 237, 237, 237, 237, 238, 238, 238, 238, 239, + 239, 239, 239, 240, 240, 240, 241, 241, 241, 241, + 242, 242, 242, 243, 243, 244, 244, 245, 244, 244, + 244, 246, 246, 247, 247, 248, 248, 248, 248, 249, + 249, 249, 249, 250, 250, 251, 251, 251, 251, 251, + 252, 252, 253, 254, 255, 255, 256, 255, 257, 257, + 258, 258, 259, 259, 260, 260, 260, 260, 260, 261, + 261, 261, 261, 262, 262, 263, 263, 264, 264, 265, + 265, 265, 265, 266, 266, 266, 266, 266, 267, 267, + 267, 267, 267, 268, 268, 269, 269, 270, 270, 271, + 271, 271, 272, 272, 272, 273, 273, 273, 274, 274, + 274, 275, 275, 275, 275, 276, 276, 276, 277, 277, + 278, 278, 278, 278, 278, 279, 279, 280, 280, 281, + 281, 281, 281, 281, 281, 282, 282, 282, 282, 283, + 283, 283, 284, 285, 285, 287, 286, 286, 288, 288, + 288, 289, 289, 290, 290, 290, 291, 291, 291, 291, + 292, 292, 292, 293, 293, 294, 294, 295, 296, 295, + 297, 297, 298, 298, 299, 299, 299, 300, 300, 301, + 301, 302, 302, 303, 303, 304, 304, 304, 305, 304, + 304, 306, 306, 306, 307, 307, 307, 307, 307, 307, + 307, 307, 307, 308, 308, 308, 309, 310, 310, 311, + 311, 312, 312, 313, 314, 314, 315, 315, 315, 316, + 316, 316, 316, 317, 317, 317, 317, 318, 318, 319, + 319, 319, 320, 320, 320, 320, 321, 321, 322, 322, + 322, 323, 323, 323, 324, 324, 324, 325, 325, 325, + 326, 326, 326, 327, 327, 327, 328, 328, 328, 329, + 329, 329, 330, 330, 330, 330, 331, 331, 332, 332, + 332, 333, 333, 333, 333, 334, 334, 334, 335, 335, + 335, 335, 336, 336, 336, 337, 337, 337, 337, 338, + 338, 338, 339, 339, 339, 339, 340, 340, 341, 341, + 341, 342, 342, 343, 343, 344, 344, 344, 345, 345, + 345, 345, 345, 346, 346, 346, 346, 347, 347, 347, + 348, 348, 348, 349, 349, 349, 349, 350, 350, 350, + 351, 351, 351, 351, 351, 352, 352, 352, 352, 353, + 353, 353, 354, 354, 354, 355, 355, 355, 355, 355, + 355, 356, 356, 356, 357, 357, 357, 357, 357, 358, + 358, 358, 358, 359, 359, 360, 360, 360, 361, 361, + 362, 362, 362, 362, 362, 362, 363, 363, 363, 363, + 363, 363, 363, 363, 363, 363, 364, 364, 364, 364, + 365, 365, 365, 366, 366, 367, 367, 367, 367, 367, + 367, 368, 368, 368, 368, 368, 368, 369, 370, 370, + 370, 371, 371, 372, 372 }; @@ -1343,47 +1347,47 @@ 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 2, 2, 3, 3, 1, 3, - 1, 2, 2, 2, 4, 4, 4, 4, 1, 2, - 2, 3, 1, 2, 2, 1, 2, 2, 3, 1, - 2, 2, 1, 1, 4, 2, 5, 7, 2, 2, - 2, 1, 2, 2, 3, 2, 3, 1, 2, 3, - 2, 2, 4, 0, 1, 2, 2, 1, 0, 1, - 2, 2, 5, 6, 2, 2, 4, 0, 2, 0, - 1, 1, 1, 5, 5, 5, 1, 5, 5, 9, - 1, 5, 0, 1, 1, 5, 1, 1, 5, 5, - 1, 3, 3, 4, 1, 1, 1, 1, 2, 1, - 3, 3, 1, 2, 1, 3, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, - 1, 2, 0, 2, 2, 1, 4, 0, 1, 2, - 3, 4, 2, 2, 1, 2, 1, 2, 5, 5, - 7, 6, 1, 2, 2, 3, 1, 2, 2, 4, - 2, 4, 0, 4, 2, 1, 1, 1, 0, 2, - 5, 5, 13, 1, 1, 3, 3, 2, 3, 3, - 2, 4, 1, 6, 9, 0, 11, 1, 3, 3, - 3, 1, 1, 5, 2, 5, 0, 1, 1, 3, - 0, 1, 1, 1, 1, 0, 6, 2, 1, 2, - 4, 2, 3, 3, 3, 4, 5, 5, 5, 6, - 1, 1, 1, 3, 0, 5, 0, 1, 1, 2, - 6, 1, 3, 0, 1, 4, 1, 1, 1, 1, - 2, 1, 2, 2, 1, 3, 2, 3, 3, 2, - 4, 4, 3, 8, 3, 2, 1, 2, 6, 8, - 3, 2, 3, 3, 4, 4, 3, 1, 1, 1, - 4, 6, 3, 2, 3, 3, 4, 4, 3, 2, - 1, 2, 2, 1, 3, 2, 3, 3, 2, 4, - 4, 3, 6, 8, 3, 2, 1, 2, 2, 2, - 3, 3, 2, 4, 4, 3, 6, 8, 3, 2, - 1, 2, 2, 1, 1, 2, 3, 3, 2, 4, - 6, 8, 1, 2, 2, 1, 2, 2, 3, 3, - 1, 4, 4, 3, 5, 8, 3, 2, 3, 1, - 5, 5, 6, 6, 1, 2, 2, 1, 2, 2, - 3, 3, 1, 4, 4, 3, 5, 8, 3, 1, - 2, 1, 2, 6, 5, 6, 7, 7, 1, 2, - 2, 1, 2, 2, 3, 3, 1, 4, 4, 3, - 8, 3, 1, 1, 2, 1, 1, 2, 3, 2, - 3, 2, 3, 3, 2, 4, 3, 2, 3, 2, - 4, 3, 2, 6, 6, 6, 7, 1, 2, 1, - 1, 1, 2, 3, 2, 3, 2, 3, 3, 4, - 2, 3, 4, 2, 5, 5, 6, 6, 0, 1, - 0, 2 + 1, 1, 1, 1, 1, 2, 2, 3, 3, 1, + 3, 1, 2, 2, 2, 4, 4, 4, 4, 1, + 2, 2, 3, 1, 2, 2, 1, 2, 2, 3, + 1, 2, 2, 1, 1, 4, 2, 0, 6, 7, + 2, 2, 2, 1, 2, 2, 3, 2, 3, 1, + 2, 3, 2, 2, 4, 0, 1, 2, 2, 1, + 0, 1, 2, 2, 5, 2, 0, 7, 2, 4, + 0, 2, 0, 1, 1, 1, 5, 5, 5, 1, + 5, 5, 9, 1, 5, 0, 1, 1, 5, 1, + 1, 5, 5, 1, 3, 3, 4, 1, 1, 1, + 1, 2, 1, 3, 3, 1, 2, 1, 3, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 1, 1, 1, 2, 0, 2, 2, 1, 4, + 0, 1, 2, 3, 4, 2, 2, 1, 2, 1, + 2, 5, 5, 7, 6, 1, 2, 2, 3, 1, + 2, 2, 4, 2, 4, 0, 4, 2, 1, 1, + 1, 0, 2, 5, 5, 13, 1, 1, 3, 3, + 2, 3, 3, 2, 4, 1, 6, 9, 0, 11, + 1, 3, 3, 3, 1, 1, 5, 2, 5, 0, + 1, 1, 3, 0, 1, 1, 1, 1, 0, 6, + 2, 1, 2, 4, 2, 3, 3, 3, 4, 5, + 5, 5, 6, 1, 1, 1, 3, 0, 5, 0, + 1, 1, 2, 6, 1, 3, 0, 1, 4, 1, + 1, 1, 1, 2, 1, 2, 2, 1, 3, 2, + 3, 3, 2, 4, 4, 3, 8, 3, 2, 1, + 2, 6, 8, 3, 2, 3, 3, 4, 4, 3, + 1, 1, 1, 4, 6, 3, 2, 3, 3, 4, + 4, 3, 2, 1, 2, 2, 1, 3, 2, 3, + 3, 2, 4, 4, 3, 6, 8, 3, 2, 1, + 2, 2, 2, 3, 3, 2, 4, 4, 3, 6, + 8, 3, 2, 1, 2, 2, 1, 1, 2, 3, + 3, 2, 4, 6, 8, 1, 2, 2, 1, 2, + 2, 3, 3, 1, 4, 4, 3, 5, 8, 3, + 2, 3, 1, 5, 5, 6, 6, 1, 2, 2, + 1, 2, 2, 3, 3, 1, 4, 4, 3, 5, + 8, 3, 1, 2, 1, 2, 6, 5, 6, 7, + 7, 1, 2, 2, 1, 2, 2, 3, 3, 1, + 4, 4, 3, 8, 3, 1, 1, 2, 1, 1, + 2, 3, 2, 3, 2, 3, 3, 2, 4, 3, + 2, 3, 2, 4, 3, 2, 6, 6, 6, 7, + 1, 2, 1, 1, 1, 2, 3, 2, 3, 2, + 3, 3, 4, 2, 3, 4, 2, 5, 5, 6, + 6, 0, 1, 0, 2 }; @@ -1395,160 +1399,161 @@ 294, 294, 315, 313, 316, 314, 317, 318, 300, 302, 301, 0, 303, 329, 321, 326, 324, 325, 323, 322, - 327, 328, 330, 331, 332, 546, 546, 546, 0, 0, - 0, 294, 220, 304, 319, 320, 7, 359, 0, 8, - 14, 15, 0, 2, 294, 564, 9, 524, 522, 247, - 3, 452, 3, 260, 0, 3, 3, 3, 248, 3, - 0, 0, 0, 295, 296, 298, 294, 307, 310, 312, - 340, 286, 333, 338, 287, 348, 288, 355, 352, 362, - 0, 0, 363, 289, 472, 476, 3, 3, 0, 2, - 518, 523, 528, 299, 0, 0, 546, 576, 546, 2, - 587, 588, 589, 294, 0, 730, 731, 0, 12, 294, - 0, 13, 270, 271, 0, 295, 290, 291, 292, 293, - 525, 305, 391, 547, 548, 369, 370, 12, 443, 444, - 11, 439, 442, 0, 502, 497, 488, 443, 444, 0, - 0, 527, 221, 0, 294, 0, 0, 0, 0, 0, - 0, 0, 0, 294, 294, 2, 0, 732, 295, 581, - 593, 736, 729, 727, 734, 0, 0, 0, 254, 2, - 0, 531, 437, 438, 436, 0, 0, 0, 0, 546, - 0, 633, 634, 0, 0, 544, 540, 546, 561, 546, - 546, 541, 2, 542, 546, 600, 546, 546, 603, 0, - 0, 0, 294, 294, 313, 360, 2, 294, 261, 297, - 308, 341, 353, 477, 0, 2, 0, 452, 262, 295, - 334, 349, 356, 473, 0, 2, 0, 311, 335, 342, - 343, 0, 350, 354, 357, 361, 444, 294, 294, 365, - 368, 0, 394, 474, 478, 0, 0, 0, 1, 294, - 2, 529, 575, 577, 294, 2, 740, 295, 743, 544, - 544, 295, 0, 0, 0, 273, 546, 541, 2, 294, - 0, 0, 294, 549, 2, 500, 2, 553, 0, 0, - 0, 0, 0, 0, 18, 59, 4, 5, 6, 16, - 0, 0, 0, 294, 2, 0, 294, 65, 66, 67, - 68, 48, 19, 49, 22, 47, 69, 0, 72, 76, - 79, 82, 87, 90, 92, 94, 96, 98, 100, 105, - 494, 750, 450, 493, 0, 448, 449, 0, 565, 580, - 583, 586, 592, 595, 598, 359, 0, 2, 738, 0, - 294, 741, 2, 294, 3, 424, 0, 432, 295, 294, - 307, 333, 287, 348, 355, 3, 3, 406, 410, 420, - 425, 472, 294, 426, 705, 706, 294, 427, 429, 294, - 2, 582, 594, 728, 2, 2, 249, 2, 457, 0, - 455, 454, 453, 141, 2, 2, 251, 2, 2, 250, - 2, 281, 2, 282, 0, 280, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 566, 605, 0, 452, 2, - 560, 569, 659, 562, 563, 532, 294, 2, 599, 608, - 601, 602, 0, 276, 294, 294, 339, 295, 0, 295, - 0, 294, 733, 737, 735, 533, 294, 544, 255, 263, - 309, 0, 2, 534, 294, 498, 336, 337, 283, 351, - 358, 0, 294, 2, 383, 294, 371, 0, 0, 377, - 727, 294, 748, 397, 0, 475, 499, 252, 253, 519, - 294, 434, 0, 294, 237, 0, 2, 239, 0, 295, - 0, 257, 2, 258, 278, 0, 0, 2, 294, 544, - 294, 485, 487, 486, 0, 0, 750, 0, 294, 0, - 294, 489, 294, 559, 557, 558, 556, 0, 551, 554, - 0, 0, 294, 56, 294, 69, 52, 294, 62, 294, - 294, 50, 51, 64, 2, 127, 0, 0, 446, 0, - 445, 111, 294, 54, 55, 17, 0, 29, 30, 35, - 2, 0, 35, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 0, 0, 53, 0, 0, 0, 0, + 327, 328, 333, 330, 331, 332, 549, 549, 549, 0, + 0, 0, 294, 220, 304, 319, 320, 7, 360, 0, + 8, 14, 15, 0, 2, 294, 567, 9, 527, 525, + 247, 3, 455, 3, 260, 0, 3, 3, 3, 248, + 3, 0, 0, 0, 295, 296, 298, 294, 307, 310, + 312, 341, 286, 334, 339, 287, 349, 288, 356, 353, + 363, 0, 0, 364, 289, 475, 479, 3, 3, 0, + 2, 521, 526, 531, 299, 0, 0, 549, 579, 549, + 2, 590, 591, 592, 294, 0, 733, 734, 0, 12, + 294, 0, 13, 270, 271, 0, 295, 290, 291, 292, + 293, 528, 305, 393, 550, 551, 371, 372, 12, 446, + 447, 11, 442, 445, 0, 505, 500, 491, 446, 447, + 0, 0, 530, 221, 0, 294, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 294, 2, 0, 735, 295, + 584, 596, 739, 732, 730, 737, 0, 0, 0, 254, + 2, 0, 534, 440, 441, 439, 0, 0, 0, 0, + 549, 0, 636, 637, 0, 0, 547, 543, 549, 564, + 549, 549, 544, 2, 545, 549, 603, 549, 549, 606, + 0, 0, 0, 294, 294, 313, 361, 2, 294, 261, + 297, 308, 342, 354, 480, 0, 2, 0, 455, 262, + 295, 335, 350, 357, 476, 0, 2, 0, 311, 336, + 343, 344, 0, 351, 355, 358, 362, 447, 294, 294, + 366, 370, 0, 395, 477, 481, 0, 0, 0, 1, + 294, 2, 532, 578, 580, 294, 2, 743, 295, 746, + 547, 547, 295, 0, 0, 0, 273, 549, 544, 2, + 294, 0, 0, 294, 552, 2, 503, 2, 556, 0, + 0, 0, 0, 0, 0, 18, 59, 4, 5, 6, + 16, 0, 0, 0, 294, 2, 0, 294, 65, 66, + 67, 68, 48, 19, 49, 22, 47, 69, 0, 72, + 76, 79, 82, 87, 90, 92, 94, 96, 98, 100, + 105, 497, 753, 453, 496, 0, 451, 452, 0, 568, + 583, 586, 589, 595, 598, 601, 360, 0, 2, 741, + 0, 294, 744, 2, 294, 3, 427, 0, 435, 295, + 294, 307, 334, 287, 349, 356, 3, 3, 409, 413, + 423, 428, 475, 294, 429, 708, 709, 294, 430, 432, + 294, 2, 585, 597, 731, 2, 2, 249, 2, 460, + 0, 458, 457, 456, 141, 2, 2, 251, 2, 2, + 250, 2, 281, 2, 282, 0, 280, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 569, 608, 0, 455, + 2, 563, 572, 662, 565, 566, 535, 294, 2, 602, + 611, 604, 605, 0, 276, 294, 294, 340, 295, 0, + 295, 0, 294, 736, 740, 738, 536, 294, 547, 255, + 263, 309, 0, 2, 537, 294, 501, 337, 338, 283, + 352, 359, 0, 294, 2, 385, 294, 373, 0, 0, + 379, 730, 0, 751, 400, 0, 478, 502, 252, 253, + 522, 294, 437, 0, 294, 237, 0, 2, 239, 0, + 295, 0, 257, 2, 258, 278, 0, 0, 2, 294, + 547, 294, 488, 490, 489, 0, 0, 753, 0, 294, + 0, 294, 492, 294, 562, 560, 561, 559, 0, 554, + 557, 0, 0, 294, 56, 294, 69, 52, 294, 62, + 294, 294, 50, 51, 64, 2, 127, 0, 0, 449, + 0, 448, 111, 294, 54, 55, 17, 0, 29, 30, + 35, 2, 0, 35, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 0, 0, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 108, 2, 645, 451, - 642, 546, 546, 650, 479, 294, 2, 584, 585, 0, - 596, 597, 0, 2, 739, 742, 111, 294, 2, 294, - 0, 707, 295, 711, 702, 703, 709, 0, 2, 2, - 667, 546, 750, 616, 546, 546, 750, 546, 630, 546, - 546, 681, 433, 664, 546, 546, 672, 679, 294, 428, - 295, 0, 0, 294, 717, 295, 722, 750, 714, 294, - 719, 750, 294, 294, 294, 0, 111, 0, 18, 5, - 2, 0, 19, 0, 458, 748, 0, 0, 464, 241, - 0, 294, 0, 0, 0, 544, 568, 572, 574, 604, - 607, 611, 614, 567, 606, 0, 284, 657, 0, 294, - 277, 0, 0, 0, 0, 275, 2, 0, 259, 535, - 294, 0, 0, 0, 0, 294, 294, 0, 0, 691, - 381, 384, 388, 546, 388, 696, 387, 688, 546, 546, - 364, 372, 380, 373, 546, 375, 378, 294, 749, 0, - 0, 395, 748, 295, 3, 413, 3, 417, 416, 590, - 0, 530, 294, 3, 3, 294, 432, 295, 3, 426, - 427, 2, 0, 0, 0, 484, 306, 294, 480, 482, - 3, 2, 2, 0, 501, 3, 0, 553, 129, 0, - 0, 222, 0, 0, 0, 2, 0, 0, 36, 0, - 0, 111, 294, 20, 0, 21, 0, 691, 447, 0, - 109, 3, 2, 27, 2, 0, 33, 0, 2, 25, - 0, 106, 107, 73, 74, 75, 77, 78, 80, 81, - 85, 86, 83, 84, 88, 89, 91, 93, 95, 97, - 99, 0, 0, 751, 294, 0, 0, 0, 646, 647, - 643, 644, 496, 495, 294, 0, 3, 294, 713, 294, - 718, 295, 294, 294, 294, 661, 704, 660, 2, 294, - 0, 0, 0, 0, 0, 0, 0, 0, 682, 0, - 668, 619, 635, 669, 2, 615, 622, 430, 617, 618, - 431, 2, 629, 638, 631, 632, 665, 666, 680, 708, - 712, 710, 750, 268, 2, 744, 2, 421, 716, 721, - 422, 0, 400, 3, 3, 3, 3, 452, 3, 0, - 2, 467, 463, 749, 0, 459, 466, 2, 462, 465, - 0, 294, 242, 264, 3, 272, 274, 0, 452, 2, - 570, 571, 2, 609, 610, 0, 658, 536, 3, 345, - 344, 347, 346, 294, 537, 0, 538, 294, 374, 376, - 2, 0, 0, 0, 0, 104, 390, 692, 693, 385, - 389, 386, 689, 690, 379, 383, 366, 397, 392, 398, - 0, 0, 0, 435, 240, 0, 0, 3, 2, 667, - 428, 0, 526, 0, 750, 488, 0, 294, 294, 294, - 0, 550, 552, 130, 0, 0, 215, 0, 0, 0, - 223, 224, 57, 0, 63, 294, 0, 61, 60, 0, - 128, 692, 457, 70, 71, 110, 115, 3, 109, 0, - 0, 0, 24, 35, 3, 0, 32, 102, 0, 3, - 649, 653, 656, 648, 3, 591, 3, 715, 720, 2, - 294, 3, 3, 295, 0, 3, 621, 625, 628, 637, - 671, 675, 678, 294, 3, 620, 636, 670, 294, 294, - 423, 294, 294, 745, 0, 0, 0, 0, 256, 0, - 104, 0, 3, 3, 0, 460, 0, 456, 0, 0, - 245, 294, 0, 0, 129, 0, 0, 0, 0, 0, - 129, 0, 0, 109, 109, 2, 0, 0, 0, 3, - 131, 132, 2, 143, 133, 134, 135, 136, 137, 138, - 145, 147, 0, 0, 0, 285, 294, 294, 546, 0, - 539, 294, 111, 695, 699, 701, 694, 382, 396, 393, - 578, 2, 663, 662, 0, 668, 2, 481, 483, 503, - 3, 511, 512, 0, 2, 507, 3, 3, 0, 0, - 555, 222, 0, 0, 0, 222, 0, 0, 3, 37, - 748, 109, 0, 3, 660, 42, 3, 40, 3, 34, - 0, 3, 101, 103, 0, 2, 651, 652, 0, 0, - 294, 0, 0, 0, 3, 637, 0, 2, 623, 624, - 2, 639, 2, 673, 674, 0, 0, 3, 0, 3, - 3, 3, 3, 408, 407, 411, 2, 2, 747, 746, - 112, 0, 0, 0, 0, 3, 461, 3, 0, 243, - 146, 3, 295, 294, 0, 0, 0, 0, 2, 191, - 0, 189, 0, 0, 0, 0, 0, 0, 0, 0, - 111, 0, 546, 151, 148, 294, 0, 0, 267, 279, - 3, 3, 545, 612, 367, 2, 697, 698, 294, 266, - 294, 0, 514, 491, 294, 0, 0, 490, 505, 0, - 0, 0, 216, 0, 225, 58, 109, 0, 0, 116, - 113, 0, 0, 0, 0, 0, 0, 23, 0, 654, - 294, 579, 265, 723, 724, 725, 0, 676, 294, 294, - 294, 3, 3, 0, 684, 0, 0, 0, 0, 294, - 294, 3, 543, 468, 469, 0, 0, 246, 295, 0, - 0, 0, 0, 294, 192, 190, 0, 187, 193, 0, - 0, 0, 0, 197, 200, 198, 194, 0, 195, 35, - 129, 144, 142, 244, 0, 0, 294, 415, 419, 418, - 0, 508, 2, 509, 2, 510, 504, 294, 228, 0, - 226, 0, 228, 3, 660, 31, 114, 2, 45, 2, - 43, 41, 28, 112, 26, 3, 726, 3, 3, 3, - 0, 0, 683, 685, 626, 640, 269, 2, 405, 3, - 404, 0, 471, 468, 129, 0, 0, 129, 3, 0, - 129, 188, 0, 2, 2, 209, 199, 0, 0, 0, - 0, 140, 573, 613, 3, 2, 0, 0, 2, 229, - 0, 0, 217, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 686, 687, 294, 0, 470, 152, 0, 0, - 2, 165, 129, 154, 0, 182, 0, 129, 0, 2, - 156, 0, 2, 0, 2, 2, 2, 196, 32, 0, - 294, 513, 515, 506, 0, 0, 0, 0, 114, 38, - 3, 3, 655, 627, 641, 677, 409, 129, 158, 161, - 0, 160, 164, 3, 167, 166, 0, 129, 184, 129, - 3, 0, 294, 0, 294, 0, 2, 0, 2, 139, - 700, 2, 230, 231, 0, 227, 218, 0, 0, 0, - 153, 0, 0, 163, 233, 168, 2, 235, 183, 0, - 186, 172, 201, 3, 210, 214, 203, 3, 0, 294, - 0, 294, 0, 0, 0, 39, 46, 44, 159, 162, - 129, 0, 169, 294, 129, 129, 0, 173, 0, 0, - 691, 211, 212, 213, 0, 202, 3, 204, 3, 294, - 219, 232, 149, 170, 155, 129, 236, 185, 180, 178, - 174, 157, 129, 0, 692, 0, 0, 0, 0, 150, - 171, 181, 175, 179, 178, 176, 3, 3, 0, 0, - 492, 177, 205, 207, 3, 3, 206, 208 + 0, 0, 0, 0, 0, 0, 0, 108, 2, 648, + 454, 645, 549, 549, 653, 482, 294, 2, 587, 588, + 0, 599, 600, 0, 2, 742, 745, 111, 294, 2, + 294, 0, 710, 295, 714, 705, 706, 712, 0, 2, + 2, 670, 549, 753, 619, 549, 549, 753, 549, 633, + 549, 549, 684, 436, 667, 549, 549, 675, 682, 294, + 431, 295, 0, 0, 294, 720, 295, 725, 753, 717, + 294, 722, 753, 294, 294, 294, 0, 111, 0, 18, + 5, 2, 0, 19, 0, 461, 751, 0, 0, 467, + 241, 0, 294, 0, 0, 0, 547, 571, 575, 577, + 607, 610, 614, 617, 570, 609, 0, 284, 660, 0, + 294, 277, 0, 0, 0, 0, 275, 2, 0, 259, + 538, 294, 0, 0, 0, 0, 294, 294, 0, 0, + 694, 383, 386, 390, 549, 390, 699, 389, 691, 549, + 549, 365, 374, 382, 375, 549, 377, 380, 294, 752, + 0, 0, 398, 0, 295, 3, 416, 3, 420, 419, + 593, 0, 533, 294, 3, 3, 294, 435, 295, 3, + 429, 430, 2, 0, 0, 0, 487, 306, 294, 483, + 485, 3, 2, 2, 0, 504, 3, 0, 556, 129, + 0, 0, 222, 0, 0, 0, 2, 0, 0, 36, + 0, 0, 111, 294, 20, 0, 21, 0, 694, 450, + 0, 109, 3, 2, 27, 2, 0, 33, 0, 2, + 25, 0, 106, 107, 73, 74, 75, 77, 78, 80, + 81, 85, 86, 83, 84, 88, 89, 91, 93, 95, + 97, 99, 0, 0, 754, 294, 0, 0, 0, 649, + 650, 646, 647, 499, 498, 294, 0, 3, 294, 716, + 294, 721, 295, 294, 294, 294, 664, 707, 663, 2, + 294, 0, 0, 0, 0, 0, 0, 0, 0, 685, + 0, 671, 622, 638, 672, 2, 618, 625, 433, 620, + 621, 434, 2, 632, 641, 634, 635, 668, 669, 683, + 711, 715, 713, 753, 268, 2, 747, 2, 424, 719, + 724, 425, 0, 403, 3, 3, 3, 3, 455, 3, + 0, 2, 470, 466, 752, 0, 462, 469, 2, 465, + 468, 0, 294, 242, 264, 3, 272, 274, 0, 455, + 2, 573, 574, 2, 612, 613, 0, 661, 539, 3, + 346, 345, 348, 347, 294, 540, 0, 541, 294, 376, + 378, 2, 0, 0, 0, 0, 104, 392, 695, 696, + 387, 391, 388, 692, 693, 381, 385, 294, 400, 394, + 401, 751, 0, 0, 438, 240, 0, 0, 3, 2, + 670, 431, 0, 529, 0, 753, 491, 0, 294, 294, + 294, 0, 553, 555, 130, 0, 0, 215, 0, 0, + 0, 223, 224, 57, 0, 63, 294, 0, 61, 60, + 0, 128, 695, 460, 70, 71, 110, 115, 3, 109, + 0, 0, 0, 24, 35, 3, 0, 32, 102, 0, + 3, 652, 656, 659, 651, 3, 594, 3, 718, 723, + 2, 294, 3, 3, 295, 0, 3, 624, 628, 631, + 640, 674, 678, 681, 294, 3, 623, 639, 673, 294, + 294, 426, 294, 294, 748, 0, 0, 0, 0, 256, + 0, 104, 0, 3, 3, 0, 463, 0, 459, 0, + 0, 245, 294, 0, 0, 129, 0, 0, 0, 0, + 0, 129, 0, 0, 109, 109, 2, 0, 0, 0, + 3, 131, 132, 2, 143, 133, 134, 135, 136, 137, + 138, 145, 147, 0, 0, 0, 285, 294, 294, 549, + 0, 542, 294, 111, 698, 702, 704, 697, 384, 368, + 399, 0, 581, 2, 666, 665, 0, 671, 2, 484, + 486, 506, 3, 514, 515, 0, 2, 510, 3, 3, + 0, 0, 558, 222, 0, 0, 0, 222, 0, 0, + 3, 37, 751, 109, 0, 3, 663, 42, 3, 40, + 3, 34, 0, 3, 101, 103, 0, 2, 654, 655, + 0, 0, 294, 0, 0, 0, 3, 640, 0, 2, + 626, 627, 2, 642, 2, 676, 677, 0, 0, 3, + 0, 3, 3, 3, 3, 411, 410, 414, 2, 2, + 750, 749, 112, 0, 0, 0, 0, 3, 464, 3, + 0, 243, 146, 3, 295, 294, 0, 0, 0, 0, + 2, 191, 0, 189, 0, 0, 0, 0, 0, 0, + 0, 0, 111, 0, 549, 151, 148, 294, 0, 0, + 267, 279, 3, 3, 548, 615, 369, 2, 700, 701, + 397, 294, 266, 294, 0, 517, 494, 294, 0, 0, + 493, 508, 0, 0, 0, 216, 0, 225, 58, 109, + 0, 0, 116, 113, 0, 0, 0, 0, 0, 0, + 23, 0, 657, 294, 582, 265, 726, 727, 728, 0, + 679, 294, 294, 294, 3, 3, 0, 687, 0, 0, + 0, 0, 294, 294, 3, 546, 471, 472, 0, 0, + 246, 295, 0, 0, 0, 0, 294, 192, 190, 0, + 187, 193, 0, 0, 0, 0, 197, 200, 198, 194, + 0, 195, 35, 129, 144, 142, 244, 0, 0, 294, + 418, 422, 421, 0, 511, 2, 512, 2, 513, 507, + 294, 228, 0, 226, 0, 228, 3, 663, 31, 114, + 2, 45, 2, 43, 41, 28, 112, 26, 3, 729, + 3, 3, 3, 0, 0, 686, 688, 629, 643, 269, + 2, 408, 3, 407, 0, 474, 471, 129, 0, 0, + 129, 3, 0, 129, 188, 0, 2, 2, 209, 199, + 0, 0, 0, 0, 140, 576, 616, 3, 2, 0, + 0, 2, 229, 0, 0, 217, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 689, 690, 294, 0, 473, + 152, 0, 0, 2, 165, 129, 154, 0, 182, 0, + 129, 0, 2, 156, 0, 2, 0, 2, 2, 2, + 196, 32, 0, 294, 516, 518, 509, 0, 0, 0, + 0, 114, 38, 3, 3, 658, 630, 644, 680, 412, + 129, 158, 161, 0, 160, 164, 3, 167, 166, 0, + 129, 184, 129, 3, 0, 294, 0, 294, 0, 2, + 0, 2, 139, 703, 2, 230, 231, 0, 227, 218, + 0, 0, 0, 153, 0, 0, 163, 233, 168, 2, + 235, 183, 0, 186, 172, 201, 3, 210, 214, 203, + 3, 0, 294, 0, 294, 0, 0, 0, 39, 46, + 44, 159, 162, 129, 0, 169, 294, 129, 129, 0, + 173, 0, 0, 694, 211, 212, 213, 0, 202, 3, + 204, 3, 294, 219, 232, 149, 170, 155, 129, 236, + 185, 180, 178, 174, 157, 129, 0, 695, 0, 0, + 0, 0, 150, 171, 181, 175, 179, 178, 176, 3, + 3, 0, 0, 495, 177, 205, 207, 3, 3, 206, + 208 }; @@ -1556,193 +1561,194 @@ static const yytype_int16 yydefgoto[] = { - -1, 839, 474, 301, 45, 131, 132, 302, 303, 304, - 305, 785, 786, 1146, 1147, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 1051, - 525, 996, 321, 997, 554, 973, 1078, 1542, 1080, 1081, - 1082, 1083, 1543, 1084, 1085, 1459, 1460, 1421, 1422, 1423, - 1521, 1522, 1526, 1527, 1562, 1563, 1086, 1379, 1087, 1088, - 1313, 1314, 1315, 1503, 1089, 143, 979, 980, 981, 1400, - 1484, 1495, 1496, 475, 476, 901, 902, 1059, 48, 49, - 50, 51, 52, 345, 156, 55, 56, 57, 58, 59, - 347, 61, 62, 261, 64, 65, 272, 349, 350, 68, - 69, 70, 71, 116, 73, 202, 352, 117, 76, 118, - 78, 79, 80, 455, 456, 457, 458, 700, 939, 701, - 81, 82, 462, 721, 881, 882, 355, 356, 724, 725, - 726, 357, 358, 359, 360, 472, 339, 133, 134, 529, - 323, 168, 654, 655, 656, 657, 658, 83, 119, 85, - 495, 496, 965, 497, 275, 501, 324, 86, 135, 136, - 87, 1337, 1124, 1125, 1126, 1127, 88, 89, 742, 90, - 271, 91, 92, 185, 1053, 688, 410, 123, 93, 507, - 508, 509, 186, 266, 188, 189, 190, 267, 96, 97, - 98, 99, 100, 101, 102, 193, 194, 195, 196, 197, - 851, 613, 614, 615, 616, 198, 618, 619, 620, 579, - 580, 581, 582, 705, 103, 622, 623, 624, 625, 626, - 627, 938, 707, 708, 709, 603, 363, 364, 365, 366, - 325, 162, 105, 106, 107, 368, 719, 576 + -1, 840, 475, 302, 46, 132, 133, 303, 304, 305, + 306, 786, 787, 1148, 1149, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 1052, + 526, 997, 322, 998, 555, 974, 1079, 1545, 1081, 1082, + 1083, 1084, 1546, 1085, 1086, 1462, 1463, 1424, 1425, 1426, + 1524, 1525, 1529, 1530, 1565, 1566, 1087, 1382, 1088, 1089, + 1316, 1317, 1318, 1506, 1090, 144, 980, 981, 982, 1403, + 1487, 1498, 1499, 476, 477, 902, 903, 1060, 49, 50, + 51, 52, 53, 346, 157, 56, 57, 58, 59, 60, + 348, 62, 63, 262, 65, 66, 273, 350, 351, 69, + 70, 71, 72, 117, 74, 203, 353, 118, 77, 119, + 79, 80, 462, 81, 456, 457, 458, 459, 701, 940, + 702, 82, 83, 465, 463, 722, 882, 883, 356, 357, + 725, 726, 727, 358, 359, 360, 361, 473, 340, 134, + 135, 530, 324, 169, 655, 656, 657, 658, 659, 84, + 120, 86, 496, 497, 966, 498, 276, 502, 325, 87, + 136, 137, 88, 1340, 1126, 1127, 1128, 1129, 89, 90, + 743, 91, 272, 92, 93, 186, 1054, 689, 411, 124, + 94, 508, 509, 510, 187, 267, 189, 190, 191, 268, + 97, 98, 99, 100, 101, 102, 103, 194, 195, 196, + 197, 198, 852, 614, 615, 616, 617, 199, 619, 620, + 621, 580, 581, 582, 583, 706, 104, 623, 624, 625, + 626, 627, 628, 939, 708, 709, 710, 604, 364, 365, + 366, 367, 326, 163, 106, 107, 108, 369, 720, 577 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -1281 +#define YYPACT_NINF -1332 static const yytype_int16 yypact[] = { - 3705, 8889, -1281, 104, -1281, -1281, -1281, -1281, -1281, -1281, - -1281, 44, -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, - -1281, -1281, -1281, -1281, -1281, 155, 155, 155, 1205, 815, - 110, 6006, 222, -1281, -1281, -1281, -1281, -1281, 130, -1281, - -1281, -1281, 1267, 189, 3199, -1281, -1281, -1281, -1281, -1281, - -1281, 31, 144, -1281, 1338, -1281, -1281, -1281, -1281, 153, - 1410, 279, 82, 7674, -1281, -1281, 8086, 1234, -1281, -1281, - -1281, 981, 359, 7231, 925, 669, 981, 1012, -1281, -1281, - 738, 575, -1281, 981, 1119, -1281, 242, -1281, 416, 419, - -1281, -1281, -1281, -1281, 277, 144, 155, -1281, 155, -1281, - -1281, -1281, -1281, 9536, 1338, -1281, -1281, 1338, -1281, 9574, - 321, -1281, -1281, -1281, 2195, 9607, -1281, 565, 565, 565, - -1281, -1281, -1281, 155, -1281, -1281, -1281, 280, 366, 418, - -1281, -1281, -1281, 425, -1281, -1281, -1281, -1281, -1281, 443, - 475, -1281, -1281, 120, 8972, 3739, 375, 387, 486, 496, - 514, 527, 541, 8273, 7081, 550, 568, -1281, 9460, -1281, - -1281, -1281, -1281, 602, -1281, 121, 4456, 4456, -1281, 552, - 298, -1281, -1281, -1281, -1281, 634, 302, 306, 327, 155, - 590, -1281, -1281, 1410, 2454, 696, -1281, 90, -1281, 155, - 155, 144, -1281, -1281, 124, -1281, 155, 155, -1281, 2638, - 658, 667, 565, 6993, -1281, -1281, 678, 3199, -1281, -1281, - 981, -1281, -1281, -1281, 144, -1281, 1338, 31, -1281, 8010, - -1281, 565, 565, 565, 144, -1281, 1205, -1281, 5198, -1281, - -1281, 673, 565, -1281, 565, -1281, 130, 8972, 9002, 686, - -1281, 815, 694, 565, -1281, 1205, 728, 736, -1281, 6006, - 544, -1281, -1281, -1281, 9431, -1281, -1281, 3957, -1281, 696, - 79, 9607, 6464, 2195, 2638, -1281, 157, -1281, -1281, 9574, - 1338, 717, 7703, -1281, -1281, 699, -1281, 10744, 783, 831, - 3925, 787, 6306, 10567, -1281, 827, -1281, -1281, -1281, -1281, - 10625, 10625, 544, 8633, 829, 6306, 9085, -1281, -1281, -1281, - -1281, -1281, -1281, 862, -1281, 1121, 2197, 6306, -1281, 599, - 388, 472, 354, 593, 830, 867, 873, 970, 245, -1281, - -1281, 874, 650, -1281, 325, -1281, -1281, 3739, -1281, -1281, - 585, 901, -1281, 747, 901, 958, 130, -1281, -1281, 962, - 9536, -1281, 977, 8746, -1281, -1281, 957, 935, 8355, 6993, - 981, -1281, 981, 565, 565, -1281, -1281, -1281, -1281, -1281, - -1281, 565, 9645, 1338, -1281, -1281, 9683, 1067, -1281, 9123, - -1281, -1281, -1281, -1281, -1281, -1281, -1281, 990, 5315, 6306, - -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, - -1281, -1281, -1281, -1281, 2195, -1281, 846, 996, 998, 1002, - 864, 1005, 1008, 1026, 2454, -1281, -1281, 1031, 31, 1033, - -1281, -1281, 1061, -1281, -1281, -1281, 9431, -1281, -1281, -1281, - -1281, -1281, 2638, -1281, 8972, 8972, -1281, 565, 2195, 7112, - 1338, 8426, -1281, -1281, -1281, -1281, 9431, 79, -1281, -1281, - 981, 144, -1281, -1281, 9431, -1281, 6877, -1281, -1281, 565, - 565, 376, 9716, 1035, 1868, 2111, -1281, 334, 338, 815, - -1281, 9002, 1059, 1047, 815, 565, -1281, -1281, -1281, -1281, - 9940, -1281, 583, 6755, -1281, 144, 1065, -1281, 2195, 10825, - 10471, -1281, -1281, -1281, -1281, 889, 2638, -1281, 8497, 696, - 7558, -1281, -1281, -1281, 1286, 636, 874, 815, 7703, 868, - 9574, -1281, 7703, -1281, -1281, -1281, -1281, 638, -1281, 1073, - 831, 207, 8633, -1281, 9716, -1281, -1281, 8633, -1281, 8859, - 8633, -1281, -1281, -1281, 1071, -1281, 681, 1077, 668, 1078, - -1281, 4381, 6724, -1281, -1281, -1281, 328, -1281, -1281, 10490, - -1281, 385, 10490, -1281, -1281, -1281, -1281, -1281, -1281, -1281, - -1281, -1281, -1281, 6464, 6464, -1281, 6306, 6306, 6306, 6306, - 6306, 6306, 6306, 6306, 6306, 6306, 6306, 6306, 6306, 6306, - 6306, 6306, 6306, 6306, 4789, 6464, -1281, 650, 1062, -1281, - -1281, 155, 155, -1281, -1281, 8972, -1281, -1281, 1061, 544, - -1281, 1061, 10548, -1281, -1281, -1281, 5232, 6724, 1079, 9198, - 1080, -1281, 9754, -1281, -1281, 602, -1281, 1082, 1185, 1084, - 1899, 185, 874, -1281, 155, 155, 874, 233, -1281, 155, - 155, 1061, -1281, -1281, 155, 155, -1281, 901, 9792, 1338, - 10968, 234, 509, 9792, -1281, 5821, -1281, 874, -1281, 9645, - -1281, 293, 5525, 5525, 5525, 1338, -1281, 5054, 1072, 558, - 990, 1016, 1083, 1086, -1281, 1074, 4456, 592, -1281, 1172, - 1338, 5525, 544, 2195, 544, 696, 809, 901, -1281, -1281, - 814, 901, -1281, -1281, -1281, 831, -1281, 901, 144, 9940, - -1281, 682, 1095, 691, 1099, -1281, 1098, 144, -1281, -1281, - 9431, 144, 1103, 362, 407, 9825, 7200, 1999, 6306, 1917, - -1281, -1281, 1101, 94, 1101, -1281, -1281, -1281, 155, 155, - -1281, -1281, 815, -1281, 155, -1281, -1281, 3122, 815, 1107, - 6306, -1281, 1059, 10968, -1281, -1281, 1102, -1281, -1281, -1281, - 544, -1281, 10897, 6306, -1281, 5525, 675, 8355, -1281, -1281, - 602, 1108, 1109, 1286, 3745, -1281, -1281, 7703, -1281, -1281, - 1111, -1281, -1281, 1116, -1281, 1111, 1128, 10744, 6464, 146, - 1113, 53, 1136, 1115, 1137, 829, 1131, 1139, -1281, 1142, - 1143, 1696, 6843, -1281, 6464, -1281, 668, 1691, -1281, 6022, - 6464, 1138, -1281, -1281, 990, 708, -1281, 6464, -1281, -1281, - 727, -1281, -1281, -1281, -1281, -1281, 599, 599, 388, 388, - 472, 472, 472, 472, 354, 354, 593, 830, 867, 873, - 970, 6306, 755, -1281, 9940, 1148, 1149, 1152, 1062, -1281, - -1281, -1281, -1281, -1281, 9940, 713, 6306, 5525, -1281, 9645, - -1281, 7319, 9311, 9236, 7081, -1281, -1281, -1281, 1185, 9940, - 951, 1160, 1163, 1165, 1166, 1175, 1176, 1182, -1281, 3532, - 1899, -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, - -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, 1061, -1281, - -1281, -1281, 874, -1281, -1281, -1281, -1281, -1281, -1281, -1281, - -1281, 1183, -1281, 1187, 1189, -1281, -1281, 31, 1138, 5054, - -1281, -1281, -1281, 5315, 1180, -1281, -1281, -1281, -1281, -1281, - 815, 6243, 1272, -1281, -1281, -1281, -1281, 1188, 31, -1281, - -1281, 1061, -1281, -1281, 1061, 70, 1061, -1281, -1281, -1281, - -1281, -1281, -1281, 9498, -1281, 144, -1281, 9002, -1281, -1281, - 1201, 818, 1208, 1212, 1213, -1281, -1281, 1917, -1281, -1281, - -1281, -1281, -1281, -1281, -1281, 1868, -1281, 1047, -1281, -1281, - 1210, 1216, 1211, -1281, -1281, 1218, 1223, -1281, 675, 1777, - -1281, 562, -1281, 3745, 874, -1281, 1226, 7703, 9863, 8972, - 1230, -1281, -1281, 1225, 1235, 1238, -1281, 6306, 252, 40, - 1231, -1281, 1242, 544, 1242, 6724, 6464, -1281, -1281, 1242, - -1281, 1691, 5315, -1281, -1281, -1281, -1281, 1236, 6464, 1245, - 544, 5054, -1281, 10490, -1281, 544, -1281, -1281, 6464, -1281, - 850, 901, -1281, -1281, -1281, -1281, -1281, -1281, -1281, 990, - 8746, -1281, -1281, 7438, 1249, -1281, 856, 901, -1281, 872, - 904, 901, -1281, 565, 4646, -1281, -1281, -1281, 9940, 9940, - -1281, 8426, 8426, -1281, 1252, 1255, 1264, 1271, -1281, 1253, - 594, 247, 1138, -1281, 544, -1281, 4456, -1281, 6464, 459, - -1281, 6603, 1274, 1279, 10343, 1281, 1283, 301, 308, 344, - 6464, 1285, 144, 6464, 6464, 1284, 498, 1282, 1268, -1281, - -1281, -1281, 1289, -1281, -1281, -1281, -1281, -1281, -1281, -1281, - -1281, -1281, 815, 1296, 6464, -1281, 9940, 9940, 155, 1301, - -1281, 9349, 4935, 934, 901, -1281, -1281, -1281, -1281, -1281, - -1281, -1281, -1281, -1281, 1305, 1777, -1281, -1281, 1290, -1281, - 1111, -1281, -1281, 2195, 1309, -1281, -1281, -1281, 734, 1312, - -1281, 53, 1317, 6306, 1303, 53, 53, 1327, 1323, -1281, - 1074, 6464, 1328, 1236, 1036, 113, 1326, -1281, 1323, -1281, - 1331, 1326, -1281, -1281, 1337, -1281, -1281, 1061, 1340, 1343, - 6962, 1342, 1344, 1350, -1281, -1281, 1353, -1281, -1281, 1061, - -1281, -1281, -1281, -1281, 1061, 6464, 6464, 6306, 1355, -1281, - -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281, - -1281, 6306, 6306, 1356, 1357, 1326, -1281, -1281, 815, -1281, - -1281, -1281, 7939, 9863, 6464, 6464, 1423, 6464, -1281, -1281, - 1341, -1281, 1345, 6464, 1347, 1358, 6464, 1097, 1360, 74, - 8776, 1197, 155, -1281, -1281, 6243, 1361, 467, -1281, -1281, - -1281, -1281, -1281, -1281, -1281, -1281, -1281, 1061, 10467, -1281, - 8497, 1362, -1281, -1281, 9863, 482, 494, -1281, 1372, 1383, - 831, 1394, -1281, 66, -1281, -1281, 6464, 1395, 1393, -1281, - -1281, 1399, 430, 657, 544, 1400, 1401, -1281, 1406, -1281, - 9940, -1281, -1281, -1281, -1281, -1281, 1412, -1281, 9940, 9940, - 9940, -1281, -1281, 1413, -1281, 1415, 1425, 1427, 623, 8125, - 8240, -1281, -1281, 278, -1281, 1426, 1429, -1281, 8568, 745, - 759, 1430, 769, 6445, -1281, -1281, 502, -1281, -1281, 770, - 1434, 1436, 144, 1487, 911, -1281, -1281, 6464, -1281, 10490, - 10343, -1281, -1281, -1281, 1442, 1444, 9940, -1281, -1281, -1281, - 1437, -1281, -1281, -1281, -1281, -1281, -1281, 9863, 831, 269, - -1281, 1424, 831, 1236, 373, -1281, -1281, -1281, -1281, -1281, - -1281, -1281, -1281, 1443, -1281, -1281, -1281, -1281, -1281, -1281, - 1452, 1454, -1281, -1281, -1281, -1281, -1281, -1281, -1281, 1458, - -1281, 1457, -1281, -1281, 10343, 148, 6464, 10343, -1281, 1462, - 6464, -1281, 171, 1484, 1486, -1281, -1281, 1465, 1476, 1455, - 905, -1281, -1281, -1281, -1281, -1281, 1338, 2195, 1471, 862, - 918, 6306, -1281, 772, 1477, 6464, 544, 544, 1480, 1482, - 1483, 1485, -1281, -1281, 8426, 1472, -1281, 1555, 6306, 1493, - -1281, -1281, 10254, -1281, 790, -1281, 1467, 10343, 1468, -1281, - -1281, 1511, -1281, 1513, -1281, 1507, 1529, -1281, 1496, 1519, - 9863, -1281, -1281, -1281, 831, 544, 1520, 1499, 1515, -1281, - 1326, 1326, -1281, -1281, -1281, -1281, -1281, 10343, 258, -1281, - 922, -1281, -1281, 7790, -1281, -1281, 1501, 6464, -1281, 6464, - 7790, 144, 9716, 144, 9716, 1528, -1281, 1530, -1281, -1281, - -1281, 1524, 862, -1281, 794, -1281, -1281, 6464, 1540, 1542, - -1281, 6306, 6306, -1281, -1281, 1051, 133, -1281, -1281, 1510, - -1281, 1051, -1281, -1281, 2099, 544, -1281, -1281, 144, 9716, - 144, 9716, 1546, 1525, 544, -1281, -1281, -1281, -1281, -1281, - 10254, 1541, 1051, 7866, 6464, 10165, 1543, 1051, 1551, 2099, - 2338, -1281, -1281, -1281, 1552, -1281, -1281, -1281, -1281, 8972, - -1281, -1281, -1281, 10072, -1281, 10254, -1281, -1281, 1531, 9979, - -1281, -1281, 10165, 144, 2338, 144, 1557, 1559, 795, -1281, - 10072, -1281, -1281, -1281, 9979, -1281, -1281, -1281, 144, 144, - -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281 + 3506, 8076, -1332, 12, -1332, -1332, -1332, -1332, -1332, -1332, + -1332, 61, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, + -1332, -1332, -1332, -1332, -1332, -1332, 102, 102, 102, 1011, + 1062, 86, 5961, 228, -1332, -1332, -1332, -1332, -1332, 138, + -1332, -1332, -1332, 684, 144, 9470, -1332, -1332, -1332, -1332, + -1332, -1332, 190, 182, -1332, 1658, -1332, -1332, -1332, -1332, + 201, 1834, 303, 32, 4928, -1332, -1332, 9508, 1650, -1332, + -1332, -1332, 615, 401, 4443, 184, 589, 615, 1225, -1332, + -1332, 848, 938, -1332, 615, 1259, -1332, 301, -1332, 486, + 503, -1332, -1332, -1332, -1332, 316, 182, 102, -1332, 102, + -1332, -1332, -1332, -1332, 9240, 1658, -1332, -1332, 1658, -1332, + 9354, 391, -1332, -1332, -1332, 1948, 9876, -1332, 810, 810, + 810, -1332, -1332, -1332, 102, -1332, -1332, -1332, 426, 447, + 456, -1332, -1332, -1332, 477, -1332, -1332, -1332, -1332, -1332, + 485, 495, -1332, -1332, 36, 8974, 2459, 272, 545, 579, + 623, 632, 671, 733, 8777, 7372, 596, 719, -1332, 9546, + -1332, -1332, -1332, -1332, 739, -1332, 209, 3245, 3245, -1332, + 760, 213, -1332, -1332, -1332, -1332, 770, 237, 353, 362, + 102, 755, -1332, -1332, 1834, 1803, 846, -1332, 70, -1332, + 102, 102, 182, -1332, -1332, 98, -1332, 102, 102, -1332, + 2479, 820, 843, 810, 5405, -1332, -1332, 844, 9470, -1332, + -1332, 615, -1332, -1332, -1332, 182, -1332, 1658, 190, -1332, + 7926, -1332, 810, 810, 810, 182, -1332, 1011, -1332, 2880, + -1332, -1332, 827, 810, -1332, 810, -1332, 138, 8974, 8891, + 857, -1332, 1062, 864, 810, -1332, 1011, 870, 879, -1332, + 5961, 735, -1332, -1332, -1332, 9437, -1332, -1332, 3894, -1332, + 846, 69, 9876, 6310, 1948, 2479, -1332, 114, -1332, -1332, + 9354, 1658, 875, 11374, -1332, -1332, 546, -1332, 11116, 886, + 926, 10861, 905, 10919, 10938, -1332, 919, -1332, -1332, -1332, + -1332, 10996, 10996, 735, 8632, 928, 10919, 9088, -1332, -1332, + -1332, -1332, -1332, -1332, 949, -1332, 840, 2531, 10919, -1332, + 516, 336, 425, 270, 704, 934, 936, 960, 997, 52, + -1332, -1332, 974, 356, -1332, 290, -1332, -1332, 2459, -1332, + -1332, 600, 996, -1332, 701, 996, 1007, 138, -1332, -1332, + 1010, 9240, -1332, 1018, 8746, -1332, -1332, 1849, 1084, 8347, + 5405, 615, -1332, 615, 810, 810, -1332, -1332, -1332, -1332, + -1332, -1332, 810, 9914, 1658, -1332, -1332, 9987, 1975, -1332, + 9012, -1332, -1332, -1332, -1332, -1332, -1332, -1332, 1030, 3059, + 10919, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, + -1332, -1332, -1332, -1332, -1332, 1948, -1332, 773, 1012, 1034, + 1040, 889, 1045, 1051, 1053, 1803, -1332, -1332, 1063, 190, + 1064, -1332, -1332, 1066, -1332, -1332, -1332, 9437, -1332, -1332, + -1332, -1332, -1332, 2479, -1332, 8974, 8974, -1332, 810, 1948, + 6923, 1658, 8420, -1332, -1332, -1332, -1332, 9437, 69, -1332, + -1332, 615, 182, -1332, -1332, 9437, -1332, 3625, -1332, -1332, + 810, 810, 464, 10025, 1068, 907, 9695, -1332, 437, 475, + 1062, -1332, 1067, 1069, 1047, 1070, 810, -1332, -1332, -1332, + -1332, 10283, -1332, 522, 6793, -1332, 182, 1074, -1332, 1948, + 11198, 6368, -1332, -1332, -1332, -1332, 939, 2479, -1332, 8493, + 846, 5374, -1332, -1332, -1332, 828, 610, 974, 1062, 11374, + 861, 9354, -1332, 11374, -1332, -1332, -1332, -1332, 618, -1332, + 1073, 926, 326, 8632, -1332, 10025, -1332, -1332, 8632, -1332, + 8860, 8632, -1332, -1332, -1332, 1077, -1332, 619, 1082, 630, + 1087, -1332, 5066, 7012, -1332, -1332, -1332, 47, -1332, -1332, + 10784, -1332, 474, 10784, -1332, -1332, -1332, -1332, -1332, -1332, + -1332, -1332, -1332, -1332, 6310, 6310, -1332, 10919, 10919, 10919, + 10919, 10919, 10919, 10919, 10919, 10919, 10919, 10919, 10919, 10919, + 10919, 10919, 10919, 10919, 10919, 4001, 6310, -1332, 356, 777, + -1332, -1332, 102, 102, -1332, -1332, 8974, -1332, -1332, 1066, + 735, -1332, 1066, 10842, -1332, -1332, -1332, 6075, 7012, 1086, + 9202, 1093, -1332, 10055, -1332, -1332, 739, -1332, 1094, 690, + 1096, 1090, 157, 974, -1332, 102, 102, 974, 166, -1332, + 102, 102, 1066, -1332, -1332, 102, 102, -1332, 996, 10137, + 1658, 11343, 372, 531, 10137, -1332, 6678, -1332, 974, -1332, + 9914, -1332, 285, 8042, 8042, 8042, 1658, -1332, 5183, 1085, + 453, 1030, 955, 1095, 1097, -1332, 1099, 3245, 590, -1332, + 1182, 1658, 8042, 735, 1948, 735, 846, 706, 996, -1332, + -1332, 806, 996, -1332, -1332, -1332, 926, -1332, 996, 182, + 10283, -1332, 647, 1107, 688, 1108, -1332, 1109, 182, -1332, + -1332, 9437, 182, 1105, 497, 502, 10167, 7492, 1400, 10919, + 1678, -1332, -1332, 1103, 62, 1103, -1332, -1332, -1332, 102, + 102, -1332, -1332, 1062, -1332, 102, -1332, -1332, 8891, 1062, + 1110, 10919, -1332, 1062, 11343, -1332, -1332, 1113, -1332, -1332, + -1332, 735, -1332, 11271, 10919, -1332, 8042, 718, 8347, -1332, + -1332, 739, 1114, 1115, 828, 2655, -1332, -1332, 11374, -1332, + -1332, 1116, -1332, -1332, 1122, -1332, 1116, 1123, 11116, 6310, + 163, 1092, 54, 1131, 1128, 1135, 928, 1130, 1138, -1332, + 1140, 1141, 9733, 7132, -1332, 6310, -1332, 630, 1274, -1332, + 5523, 6310, 1139, -1332, -1332, 1030, 695, -1332, 6310, -1332, + -1332, 741, -1332, -1332, -1332, -1332, -1332, 516, 516, 336, + 336, 425, 425, 425, 425, 270, 270, 704, 934, 936, + 960, 997, 10919, 754, -1332, 10283, 1150, 1151, 1153, 777, + -1332, -1332, -1332, -1332, -1332, 10283, 748, 10919, 8042, -1332, + 9914, -1332, 7612, 9316, 9126, 7372, -1332, -1332, -1332, 690, + 10283, 950, 1164, 1165, 1171, 1172, 1179, 1180, 1181, -1332, + 3591, 1090, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, + -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, 1066, + -1332, -1332, -1332, 974, -1332, -1332, -1332, -1332, -1332, -1332, + -1332, -1332, 1183, -1332, 1184, 1187, -1332, -1332, 190, 1139, + 5183, -1332, -1332, -1332, 3059, 1185, -1332, -1332, -1332, -1332, + -1332, 1062, 6532, 1270, -1332, -1332, -1332, -1332, 1173, 190, + -1332, -1332, 1066, -1332, -1332, 1066, 152, 1066, -1332, -1332, + -1332, -1332, -1332, -1332, 9584, -1332, 182, -1332, 8891, -1332, + -1332, 1193, 795, 1199, 1200, 1204, -1332, -1332, 1678, -1332, + -1332, -1332, -1332, -1332, -1332, -1332, 907, 9763, 1047, -1332, + -1332, 1069, 1205, 1201, -1332, -1332, 1206, 1207, -1332, 718, + 1989, -1332, 634, -1332, 2655, 974, -1332, 1211, 11374, 10205, + 8974, 1214, -1332, -1332, 1212, 1217, 1213, -1332, 10919, 229, + 205, 1215, -1332, 1202, 735, 1202, 7012, 6310, -1332, -1332, + 1202, -1332, 1274, 3059, -1332, -1332, -1332, -1332, 1220, 6310, + 1228, 735, 5183, -1332, 10784, -1332, 735, -1332, -1332, 6310, + -1332, 863, 996, -1332, -1332, -1332, -1332, -1332, -1332, -1332, + 1030, 8746, -1332, -1332, 7732, 1219, -1332, 876, 996, -1332, + 883, 896, 996, -1332, 810, 4775, -1332, -1332, -1332, 10283, + 10283, -1332, 8420, 8420, -1332, 1221, 1226, 1233, 1235, -1332, + 1234, 643, 137, 1139, -1332, 735, -1332, 3245, -1332, 6310, + 517, -1332, 6892, 1245, 1249, 10726, 1253, 1258, 330, 380, + 387, 6310, 1265, 182, 6310, 6310, 1256, 294, 1269, 1250, + -1332, -1332, -1332, 1277, -1332, -1332, -1332, -1332, -1332, -1332, + -1332, -1332, -1332, 1062, 1285, 6310, -1332, 10283, 10283, 102, + 1287, -1332, 9845, 9622, 932, 996, -1332, -1332, -1332, -1332, + -1332, 1286, -1332, -1332, -1332, -1332, 1293, 1989, -1332, -1332, + 1275, -1332, 1116, -1332, -1332, 1948, 1290, -1332, -1332, -1332, + 749, 1292, -1332, 54, 1295, 10919, 1279, 54, 54, 1305, + 1301, -1332, 1099, 6310, 1308, 1220, 605, 89, 1306, -1332, + 1301, -1332, 1312, 1306, -1332, -1332, 1317, -1332, -1332, 1066, + 1319, 1322, 7252, 1323, 1325, 1326, -1332, -1332, 1329, -1332, + -1332, 1066, -1332, -1332, -1332, -1332, 1066, 6310, 6310, 10919, + 1330, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, + -1332, -1332, -1332, 10919, 10919, 1332, 1335, 1306, -1332, -1332, + 1062, -1332, -1332, -1332, 7853, 10205, 6310, 6310, 1394, 6310, + -1332, -1332, 1321, -1332, 1324, 6310, 1327, 1331, 6310, 1013, + 1333, 97, 8265, 1262, 102, -1332, -1332, 6532, 1334, 537, + -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, 1066, + -1332, 10544, -1332, 8493, 1345, -1332, -1332, 10205, 562, 563, + -1332, 1343, 1344, 926, 1352, -1332, 450, -1332, -1332, 6310, + 1355, 1349, -1332, -1332, 1356, 543, 613, 735, 1357, 1358, + -1332, 1361, -1332, 10283, -1332, -1332, -1332, -1332, -1332, 1365, + -1332, 10283, 10283, 10283, -1332, -1332, 1367, -1332, 1368, 1371, + 1372, 668, 8115, 8231, -1332, -1332, 457, -1332, 1376, 1378, + -1332, 8566, 750, 782, 1387, 793, 6762, -1332, -1332, 598, + -1332, -1332, 803, 1388, 1393, 182, 1445, 882, -1332, -1332, + 6310, -1332, 10784, 10726, -1332, -1332, -1332, 1396, 1404, 10283, + -1332, -1332, -1332, 1401, -1332, -1332, -1332, -1332, -1332, -1332, + 10205, 926, 254, -1332, 1384, 926, 1220, 366, -1332, -1332, + -1332, -1332, -1332, -1332, -1332, -1332, 1405, -1332, -1332, -1332, + -1332, -1332, -1332, 1406, 1409, -1332, -1332, -1332, -1332, -1332, + -1332, -1332, 1414, -1332, 1413, -1332, -1332, 10726, 84, 6310, + 10726, -1332, 1417, 6310, -1332, 99, 1433, 1434, -1332, -1332, + 1422, 1425, 1408, 852, -1332, -1332, -1332, -1332, -1332, 1658, + 1948, 1421, 949, 918, 10919, -1332, 832, 1426, 6310, 735, + 735, 1427, 1431, 1440, 1441, -1332, -1332, 8420, 1428, -1332, + 1501, 10919, 1437, -1332, -1332, 10637, -1332, 845, -1332, 1424, + 10726, 1436, -1332, -1332, 1460, -1332, 1461, -1332, 1476, 1481, + -1332, 1446, 1471, 10205, -1332, -1332, -1332, 926, 735, 1472, + 1452, 1468, -1332, 1306, 1306, -1332, -1332, -1332, -1332, -1332, + 10726, 295, -1332, 940, -1332, -1332, 5671, -1332, -1332, 1454, + 6310, -1332, 6310, 5671, 182, 10025, 182, 10025, 1478, -1332, + 1482, -1332, -1332, -1332, 1480, 949, -1332, 850, -1332, -1332, + 6310, 1479, 1487, -1332, 10919, 10919, -1332, -1332, 1054, 123, + -1332, -1332, 1465, -1332, 1054, -1332, -1332, 1818, 735, -1332, + -1332, 182, 10025, 182, 10025, 1492, 1474, 735, -1332, -1332, + -1332, -1332, -1332, 10637, 1488, 1054, 6242, 6310, 10548, 1495, + 1054, 1502, 1818, 2347, -1332, -1332, -1332, 1505, -1332, -1332, + -1332, -1332, 8974, -1332, -1332, -1332, 10415, -1332, 10637, -1332, + -1332, 1484, 10322, -1332, -1332, 10548, 182, 2347, 182, 1509, + 1510, 853, -1332, 10415, -1332, -1332, -1332, 10322, -1332, -1332, + -1332, 182, 182, -1332, -1332, -1332, -1332, -1332, -1332, -1332, + -1332 }; @@ -1750,28 +1756,28 @@ static const yytype_int16 yypgoto[] = { - -1281, 4254, 1590, -1281, 1409, -1281, 52, 0, -229, -1281, - 596, -527, -497, -931, -99, 4508, -1281, 358, 609, 563, - 518, 591, 1104, 1105, 1110, 1117, 1112, -1281, 613, -339, - 5346, -893, -690, -919, -1281, 401, -634, 444, -1281, 753, - -1281, 449, -1224, -1281, -1281, 191, -1281, -1265, -724, 305, - -1281, -1281, -1281, -1281, 129, -1170, -1281, -1281, -1281, -1281, - -1281, -1281, 382, -1175, 71, -1281, -381, -1281, 560, 356, - -1281, 229, -1281, -338, -1281, -1281, -1281, 632, -691, -1281, - -1281, 11, -1000, 10, 2865, -1281, -1281, -1281, -125, -1281, - 275, 363, -194, 1416, 4157, -1281, -1281, 24, 25, 374, - -202, 1621, -1281, 2138, -1281, -1281, 112, 2165, -1281, 2832, - 139, -1281, -1281, -416, -434, 1276, 1278, 786, 1028, 400, - -1281, -1281, 1269, 793, -513, -1281, -522, -57, -636, -1281, - -1281, -959, -994, 122, 819, 1153, 135, -1281, 1441, 296, - -299, -212, -109, 749, 844, -1281, 1087, -1281, 2859, 1478, - -462, 1000, -1281, -1281, 778, -1281, -233, -1281, -72, -1281, - -1281, -1281, -1232, 504, -1281, -1281, -1281, 1259, -1281, 68, - -1281, -1281, -850, -96, -1280, -93, 1665, -1281, 2401, -1281, - 993, -1281, -164, 689, -177, -176, -170, 2, -39, -33, - -28, 1052, 48, 75, 93, -100, -167, -166, -153, -148, - -277, -569, -500, -490, -543, -300, -514, -1281, -1281, -506, - 1174, 1177, 1181, 2149, 5126, -572, -549, -544, -523, -484, - -1281, -427, -665, -663, -660, -602, -320, -271, -1281, -1281, - 102, 140, -84, -1281, 3728, 128, -603, -447 + -1332, 4383, 1919, -1332, 1457, -1332, 41, 0, -257, -1332, + 544, -527, -514, -956, -190, 3713, -1332, 1485, 580, 585, + 548, 602, 1055, 1052, 1056, 1059, 1061, -1332, -217, -341, + 5350, -699, -697, -922, -1332, -83, -701, -678, -1332, 561, + -1332, 399, -1087, -1332, -1332, 141, -1332, -1329, -838, 252, + -1332, -1332, -1332, -1332, 71, -1078, -1332, -1332, -1332, -1332, + -1332, -1332, 325, -1308, 57, -1332, -297, -1332, 504, 305, + -1332, 173, -1332, -305, -1332, -1332, -1332, 558, -799, -1332, + -1332, 11, -1027, 151, 658, -1332, -1332, -1332, -52, -1332, + 117, 913, -200, 1494, 4071, -1332, -1332, 19, 107, 365, + -232, 1565, -1332, 2150, -1332, -1332, 134, 2571, -1332, 3063, + 1550, -1332, -1332, -1332, -643, -431, 1210, 1216, 707, 947, + 188, -1332, -1332, -1332, 945, 723, -404, -1332, -520, -362, + 293, -1332, -1332, -990, -995, 965, 1194, 1083, 304, -1332, + 150, 317, -75, -197, -129, 679, 781, -1332, 1020, -1332, + 3338, 1566, -427, 948, -1332, -1332, 710, -1332, -230, -1332, + -89, -1332, -1332, -1332, -1266, 433, -1332, -1332, -1332, 1195, + -1332, 22, -1332, -1332, -865, -105, -1331, -98, 1750, -1332, + 2253, -1332, 929, -1332, -168, 288, -180, -179, -173, 2, + -34, -29, -28, 687, 75, 77, 92, -161, -162, -153, + -151, -148, -320, -530, -516, -495, -552, -307, -529, -1332, + -1332, -506, 1106, 1117, 1121, 2218, 5180, -562, -569, -544, + -538, -550, -1332, -429, -691, -685, -671, -611, -246, -241, + -1332, -1332, 1149, 273, -84, -1332, 3714, 76, -612, -441 }; @@ -1779,2227 +1785,2307 @@ positive, shift that token. If negative, reduce the rule which number is the opposite. If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -522 +#define YYTABLE_NINF -525 static const yytype_int16 yytable[] = { - 46, 111, 95, 147, 451, 438, 397, 398, 426, 148, - 53, 113, 112, 399, 149, 790, 400, 401, 265, 258, - 405, 711, 767, 604, 66, 67, 870, 706, 111, 111, - 402, 46, 932, 95, 933, 403, 750, 934, 853, 841, - 755, 53, 46, 918, 46, 717, 159, 617, 1185, 748, - 511, 1091, 894, 110, 46, 66, 67, 381, 382, 845, - 46, 1201, 191, 46, 846, 214, 46, 852, 224, 341, - 612, 47, 819, 208, 1151, 504, 218, 217, 678, 1143, - 111, 111, 1183, 1184, 406, 847, 397, 398, 210, 994, - 150, 636, 408, 399, 844, 640, 400, 401, 687, 141, - 405, 778, 47, 423, 46, 1398, 691, 46, 842, 200, - 402, 932, 74, 933, 46, 403, 934, 151, 843, 950, - 883, 883, 883, 1195, 974, 682, 684, 856, 30, 477, - 885, 886, 30, 863, 289, 152, 1317, 166, 1461, 883, - 104, 104, 407, 74, 147, 46, 161, 159, 904, 1134, - 148, 535, 121, 46, 445, 149, 1135, 1465, 46, 201, - 371, 167, 30, 977, 406, 857, 481, 483, 739, 860, - 278, 104, 164, 466, 841, 1341, -234, -234, 1009, 1098, - 1218, 1219, 1342, 46, 46, 120, 159, 482, 1014, 175, - 877, 1418, 1419, 30, 880, 30, 676, 1262, 250, 46, - 409, 754, 212, 1025, 409, 1318, 104, 46, 1481, 159, - 1090, 161, 1461, 883, 1418, 1419, 46, 745, 140, 46, - 769, 441, 957, 30, 147, 1263, 111, 535, 279, 439, - 148, 150, 417, 142, 409, 149, 375, 164, 144, 259, - 673, 111, 260, 842, 440, 111, 1185, -234, 1259, 46, - 111, 95, 376, 843, 212, 1465, 595, 169, 151, 53, - 1465, 1420, 975, 46, 46, 487, 159, 409, 179, 841, - 46, 30, 326, 66, 67, 60, 152, 46, 1037, 604, - 1465, 759, 199, 711, 1429, 341, 823, 1465, 535, 845, - 702, 477, 111, 854, 846, 609, 1185, 212, 665, 1507, - 153, 1549, 471, 1201, 674, 883, 60, 1036, 604, 433, - 617, 477, 1013, 604, 1016, 847, 760, 469, 1153, 477, - 47, 1560, 673, 761, 1024, 830, 680, 46, 1564, 371, - 1183, 1184, 685, 535, 1536, 434, 1538, 1343, 842, 573, - 459, 861, 1191, 609, 523, 873, 46, 46, 843, 874, - 535, 437, 925, 1491, 704, 1550, 856, 245, 212, 936, - 1133, 74, -290, 46, 114, 326, 74, 46, 879, 1192, - 1200, 433, 108, 210, 574, 1091, 739, 1401, 652, 108, - 1192, 949, 1565, 40, 41, 250, 674, 853, -10, 104, - 40, 41, -112, -112, 46, 530, 212, 434, 161, 108, - 212, 482, 1180, 1181, 46, 489, 371, 157, -112, 845, - 40, 41, 506, 385, 846, 108, 248, 388, 870, -517, - 1185, 390, 46, 575, 164, 1040, 40, 41, 46, 386, - 46, 738, 1209, 389, 584, 847, 1215, 391, 782, 1211, - 585, 227, 392, 563, 564, 228, 915, 341, 232, 712, - 234, 262, 739, 714, 46, 1456, 108, 243, 393, 111, - 1230, 1231, 1213, 1201, 111, 713, 256, 40, 41, 715, - 1201, 606, 157, 111, -440, 1450, 1451, 712, 46, 565, - 566, 175, -112, 250, 328, 692, 46, 212, 371, 1405, - 46, 585, 95, 928, 46, 788, 329, 111, 637, 111, - 53, 108, 641, -112, 210, 1120, 1149, 322, 559, 560, - 1106, 1101, 40, 41, 66, 67, 338, 1117, 706, 652, - 397, 398, 714, 1201, 60, 110, -441, 399, 74, 478, - 400, 401, 978, 274, 1090, 405, 111, 1258, 929, 652, - 1347, 111, 652, 1037, 402, 1171, 1173, 895, 74, 403, - 617, 276, 326, 326, 459, 504, 74, 459, 1018, 561, - 562, 47, 830, 459, 1106, 477, 428, 906, 212, 284, - 432, 766, 908, 1035, 1198, 8, 9, 10, 11, 12, - 40, 41, 1198, 277, 227, 884, 884, 884, 783, 111, - 1199, 766, 727, 789, 766, 330, 46, 1332, 1323, 406, - 322, 454, 74, 30, 884, 331, 520, 954, 46, 1334, - 46, 341, 1380, 1333, 530, 108, 530, 774, 212, 530, - 875, 832, 530, 332, 876, 1335, 40, 41, 326, 46, - 104, 33, 432, 1381, 1355, 494, 333, -466, 1132, 738, - 516, 471, 1357, 1358, 1359, 46, 108, 326, 137, 138, - 334, 111, 830, 533, 534, 440, 528, 40, 41, 157, - 46, 369, 111, 46, 111, 555, 383, 711, -466, 1378, - -466, 896, -291, 875, -466, 1048, 370, 1116, 884, 8, - 9, 10, 11, 12, 567, 568, 1035, 341, 241, 94, - 1394, 478, 729, 586, 526, 409, 1095, 46, 730, 46, - 604, 534, 897, 594, 651, -105, 601, 30, 898, -105, - 374, 478, 111, 326, 905, 738, 907, 556, 111, 478, - 94, 395, 557, 558, 227, 634, 232, 606, 108, 638, - 111, 146, 338, 94, 1366, 33, 1128, 534, 1367, 40, - 41, 212, 387, 46, 46, 746, 1428, 756, 210, 187, - 1249, 747, 94, 757, 1253, 94, 871, 46, 577, 407, - 409, 606, 210, 736, 872, 60, 424, 1349, 578, 212, - 884, 1520, 1497, 673, 212, 425, 776, 1525, 409, 1497, - 887, 702, 953, 958, 1055, 609, 777, 322, 322, 430, - 773, 919, 1390, 959, 1251, 903, 774, 774, 1545, 461, - 921, 727, 74, 1552, 448, 171, 774, 464, 762, 108, - 763, 137, 236, 764, 227, 454, 770, 1002, 454, 459, - 40, 41, 1015, 1003, 454, 681, 683, 499, 730, 500, - 490, 830, 1546, 1499, 94, 1500, 114, 674, 46, 1175, - 739, 1006, 1003, 1247, 74, 704, 237, 94, 251, 585, - 46, 238, 1291, 1292, 1374, 589, 210, 409, 832, 467, - 774, 494, 212, 322, 932, 494, 933, 468, 1375, 934, - 774, 1008, 396, 187, 774, 528, 212, 528, 1377, 1382, - 528, 1447, 322, 528, 774, 774, 108, 1444, 137, 138, - 1547, 510, 506, 652, 338, 514, 94, 40, 41, 1466, - 111, 652, 978, 1513, 1570, 774, 978, 978, 94, 1514, - 585, 53, 289, 526, 793, 794, 795, 909, 526, 409, - 739, 526, 912, 46, 409, 66, 67, 328, 409, 2, - 204, 4, 5, 6, 7, 519, 727, 46, 94, 108, - 531, 137, 138, 535, 415, 46, 727, 1196, 322, 569, - 40, 41, 485, 1077, 250, 328, 409, 534, 1155, 828, - 409, 727, 601, 46, 1167, 478, 409, 435, 1387, 1388, - 212, 736, 417, 669, 409, 812, 751, 443, 1122, 1121, - 1170, 752, 609, 111, 1182, 2, 204, 4, 5, 6, - 7, 869, 652, 34, 570, 35, 601, 487, 328, 409, - 111, 571, 878, 652, 575, 111, 36, 478, 181, 182, - 39, 337, 1172, 74, 609, -292, 94, 40, 41, 1438, - 1003, 1339, 8, 9, 10, 11, 12, 1242, 36, 459, - 172, 173, 39, 1444, 1445, 1137, 611, 1492, 1493, 40, - 41, 104, 1235, 608, 409, 609, 527, 736, 440, 34, - 30, 35, 1145, 610, 111, 766, -3, 1145, 338, 854, - 328, 609, 1446, 572, 652, 370, -437, 111, 111, 111, - 593, 53, 8, 9, 10, 11, 12, 1532, 33, 1458, - 454, 800, 801, 802, 803, 1203, 67, 108, 596, 137, - 138, 534, 111, 187, 1418, 1419, 160, 326, 40, 41, - 30, 646, 940, 738, 940, 666, 1145, 667, 104, 1399, - 494, 668, 192, 1399, 670, 215, 1077, 671, 225, 1210, - 1212, 1214, -293, 46, 798, 799, 890, 1106, 33, 8, - 9, 10, 11, 12, 338, 672, 341, 993, 36, 675, - 172, 173, 39, 703, 677, -112, 695, -112, 871, 40, - 41, -112, 1518, 1458, 1310, 1311, 1312, 30, 804, 805, - 727, 727, 212, 1348, 1350, 1351, -112, -112, 796, 797, - 577, 255, 409, 74, 718, 374, 60, 720, -238, 94, - 578, 758, 771, 611, 534, 33, 775, 779, -12, 893, - 833, 835, 1017, 837, 689, 848, 828, 160, 111, -13, - 900, 104, 892, 459, 920, 536, 537, 538, 922, 923, - 372, -414, 208, 218, 217, 1482, 927, 698, 727, 727, - 46, 948, -521, 962, 969, 652, 747, 210, 731, 539, - 983, 540, 1369, 541, 542, 53, 160, 971, 2, 204, - 4, 5, 6, 7, 976, 982, 984, 986, 987, 66, - 67, 988, 989, 998, 1122, 1121, 36, 1010, 1011, 160, - 39, 1012, 111, 111, 111, 527, 226, 40, 41, 1026, - 527, 442, 1027, 527, 1028, 1029, 127, 1077, 128, 129, - 130, 536, 537, 538, 1030, 1031, 828, 40, 41, 728, - 454, 1032, 1043, 838, 1057, 609, -402, 840, -401, 611, - 1092, 1442, 34, 610, 35, 539, 1558, 540, 439, 541, - 1319, 935, 1102, 53, 1145, 1145, 1145, 1103, 1094, 652, - 652, 1104, 1105, 440, 1109, 1110, 1111, 1203, 67, 1112, - 494, 1123, 322, 935, 1113, 1119, 478, 74, 36, 1129, - 774, 212, 39, 104, 1130, 1079, 1136, 1122, 1121, 40, - 41, 1141, 397, 398, 1131, 992, 1144, 36, 1165, 399, - 1328, 39, 400, 401, 1190, 104, 405, 1186, 40, 41, - 1187, 766, 1077, 1188, 652, 42, 402, 652, 534, 372, - 1189, 403, 1204, 869, 104, 145, 931, 1205, 703, 1207, - 673, 1208, 727, 1216, 743, 1220, 46, 46, 1222, 1223, - 727, 727, 727, -3, 744, 1228, 111, 111, 1531, 36, - 1233, 172, 173, 39, 1239, 74, 63, 115, 499, 516, - 40, 41, 652, 1243, 1007, 1248, 1077, 652, 1250, 1077, - 406, 917, 840, 611, 1252, 736, 1255, 212, 1256, 1260, - 924, 1264, 1267, 104, 926, 111, 1269, 63, 727, 1271, - 1122, 1121, 1272, 1273, 674, 1274, 372, 652, 1145, 1145, - 158, 1275, 1277, 174, 454, 828, 1284, 1293, 1294, 1301, - 139, 1330, 1304, 53, 1077, 1322, 1305, 104, 1307, 1077, - 53, 36, 219, 181, 182, 39, 1336, 1203, 67, 1308, - 147, 1316, 40, 41, 1203, 67, 148, 1483, 728, 1338, - 60, 149, 1050, 1340, 46, 111, 1344, 1345, 1206, 1077, - 1346, 1352, 1353, 174, 111, 736, 174, 1354, 183, 257, - 652, 239, 242, 1356, 1362, 652, 1363, 840, 184, 46, - 46, 1441, 159, 53, 1364, 534, 1365, 1372, 1376, 611, - 1373, 213, 1383, 652, 1384, 652, 1312, 1203, 67, 652, - 1395, 1392, 652, 1393, 46, 1402, 371, 1533, 240, 1405, - 652, 327, 174, 1412, 652, 1413, 1541, -403, 1416, 257, - 348, 1427, 1077, 1435, 1505, 74, 1505, 1077, 478, 1431, - 104, 1433, 74, 338, 1436, 1443, 1437, 1367, 1448, 1452, - 935, 1453, 1454, 213, 1455, 1077, 1457, 1077, 1467, 1469, - 404, 1077, 1475, 104, 1077, 1299, 1300, 1123, 1302, 1462, - 104, 1505, 1077, 1505, 1306, 422, 1077, 1309, 427, 429, - 1471, 1152, 1473, 158, 1477, 174, 703, 1479, 1480, 1485, - 1486, 1487, 1498, 728, 703, 74, 213, 1508, 1512, 1510, - 165, 1524, 170, 728, 446, 176, 177, 178, 449, 180, - 450, 1516, 611, 1517, 1539, 1544, 1540, 1551, 728, 465, - 1553, 1555, 1561, 104, 231, 63, 1568, 326, 1569, 1079, - 479, 1050, 1221, 806, 1321, 807, 246, 247, 1100, 174, - 486, 808, 463, 1519, 211, 810, 174, 1430, 429, 809, - 122, 125, 126, 1571, 230, 1386, 1254, 213, 1403, 1501, - 1123, 8, 9, 10, 11, 12, 8, 9, 10, 11, + 47, 112, 96, 427, 398, 399, 768, 933, 452, 148, + 266, 400, 113, 934, 149, 150, 791, 406, 871, 67, + 259, 439, 401, 512, 407, 712, 707, 935, 613, 112, + 112, 402, 47, 403, 96, 1203, 404, 1092, 382, 383, + 846, 618, 111, 47, 895, 47, 505, 160, 1187, 854, + 1153, 67, 1185, 1186, 142, 47, 749, 48, 975, 853, + 201, 47, 857, 192, 47, 847, 215, 47, 864, 225, + 342, 848, 751, 820, 1401, 947, 756, 1145, 218, 842, + 845, 112, 112, 995, 398, 399, 933, 279, 409, 48, + 1464, 400, 934, 843, 121, 424, 1468, 406, 605, 1197, + 779, 31, 401, 1091, 407, 47, 935, 68, 47, 31, + 202, 402, 679, 403, 844, 47, 404, 61, 151, 109, + 152, 165, 637, 884, 884, 884, 641, 739, 1421, 1422, + 41, 42, 688, 408, 75, 153, 290, 31, 446, 68, + 692, 31, 884, 1421, 1422, 280, 47, 574, 160, 61, + 148, 54, 114, 31, 47, 149, 150, 467, 783, 47, + 1320, 372, 482, 484, 1464, 978, 75, -234, -234, 1510, + 122, 211, 858, 410, 1265, 746, 861, 1484, 483, 251, + 140, 410, 575, 54, 47, 47, 165, 160, 2, 205, + 4, 5, 6, 7, 1468, 141, 31, 878, 1423, 1468, + 47, 881, 1266, 478, 1539, 31, 1541, 418, 47, 410, + 160, 527, 677, 1432, 842, 209, 884, 47, 219, 1468, + 47, 327, 442, 488, 1080, 410, 1468, 112, 843, 1321, + 148, 240, 243, 1193, 536, 149, 150, 674, -234, 143, + 886, 887, 112, 740, 675, 536, 112, 145, 1187, 844, + 47, 112, 96, 35, 760, 36, 154, 596, 905, 151, + 1194, 152, 1099, 1202, 47, 47, 855, 160, 610, 67, + 846, 47, 470, 105, 105, 862, 153, 610, 47, 1203, + 976, 885, 885, 885, 435, 1102, 342, 703, 95, 1038, + 666, 857, 472, 112, 705, 847, 170, 167, 1187, 1037, + 885, 848, 1185, 1186, 618, 105, 200, 48, 884, 842, + 1025, 536, 1155, 1014, 327, 1136, -3, 180, 681, 674, + 95, 168, 1137, 843, 686, 376, 675, 441, 47, 386, + 372, 147, 958, 95, 524, 739, 536, 1346, 1135, 1111, + 105, 377, 682, 684, 844, 387, 435, 47, 47, 188, + 683, 685, 95, 389, 605, 95, 831, 68, 937, 176, + 564, 565, 1092, 1404, 47, 478, 285, 61, 47, 390, + 1217, 440, 479, 165, 885, 1220, 1221, 41, 42, 653, + 950, 251, 329, 605, 75, 478, 926, 1208, 605, 75, + 846, 1494, 464, 478, 483, 47, 566, 567, 854, 880, + 585, 54, 109, 521, -290, 47, 586, 372, 536, 260, + 871, 739, 261, 41, 42, 847, 576, 246, 1194, 916, + 607, 848, 1187, 47, 1017, 251, 755, 1459, 1091, 47, + 527, 47, 1041, 228, 95, 527, 761, 229, 527, 1203, + 233, 1552, 235, 762, 1262, 770, 1203, 95, 342, 244, + 1553, 740, 109, 1453, 1454, 47, 211, 560, 561, 109, + 112, 1563, 1211, 41, 42, 578, 885, 410, 1567, 391, + 41, 42, 397, 188, 112, 579, -112, 1568, 393, 47, + 1173, 1175, 936, 1408, 874, 392, 249, 47, 875, 372, + 1151, 47, 813, 96, 394, 47, 95, -112, 112, 1203, + 112, 327, 327, -520, 936, 979, 1215, 1383, 95, 1107, + 67, 824, 1213, 562, 563, 111, 712, 707, 398, 399, + 653, 438, 263, 105, 1119, 400, 505, 740, 896, 654, + 1261, 1036, 406, -469, 479, -10, 401, 112, 95, 407, + 653, 1122, 112, 653, 618, 402, 109, 403, 48, 1080, + 404, 75, 486, 713, 479, 1038, -443, 41, 42, 907, + 1344, 767, 479, 1107, -469, -444, -469, 1345, 909, 714, + -469, 75, -112, -112, 693, 490, 228, 327, 784, 75, + 586, 767, 507, 790, 767, 789, 275, 211, -112, 1019, + 112, 715, -291, 831, 277, 1008, 327, 47, 68, 8, + 9, 10, 11, 12, 278, 1381, 737, 716, 61, 47, + 717, 47, 342, 713, 172, 109, 95, 833, 715, 2, + 205, 4, 5, 6, 7, 75, 41, 42, 31, 929, + 47, 472, 730, 1200, 930, 557, 612, 1134, 731, 478, + 558, 559, 54, 876, 1036, 1394, 47, 877, 750, 1201, + 754, 176, 112, 1200, 1350, 330, 34, 252, 55, 55, + 1523, 47, 327, 112, 47, 112, 1528, 1500, 638, 1326, + 897, 712, 642, 1051, 1500, 500, 607, 501, 1335, 1337, + 1184, 955, 1431, 831, 35, 109, 36, 1548, 342, 331, + 55, 1049, 1555, 188, 1336, 1338, 41, 42, 47, 1420, + 47, 898, 1428, 652, 906, 872, 908, 899, 370, 587, + 607, 410, 1096, 112, 775, -112, 228, -112, 233, 112, + 747, -112, 55, 112, 1352, 55, 748, 1549, 757, 774, + 1384, 112, 161, 332, 758, 775, -112, -112, 441, 777, + 1130, 410, 333, 704, 47, 47, 876, 1467, 193, 778, + 1118, 216, 1471, 416, 226, -105, 37, 920, 47, -105, + 40, 936, 37, 775, 105, 1056, 40, 41, 42, 1502, + 674, 1503, 954, 41, 42, 605, 436, 675, 703, 95, + 1369, 334, 1493, 612, 1370, 705, 444, 8, 9, 10, + 11, 12, 1154, 43, 1254, 1393, 568, 569, 922, 839, + 739, 610, 892, 146, 775, 1003, 228, 109, 479, 611, + 590, 1004, 410, 347, 737, 910, 31, 410, 41, 42, + 8, 9, 10, 11, 12, 75, 1550, 959, 371, 610, + 763, 211, 764, 161, 1177, 765, 1252, 960, 771, 47, + 1256, 933, 1051, 335, 34, 211, 373, 934, 375, 31, + 479, 47, 1294, 1295, 833, 528, 1007, 1004, 1016, 1250, + 1377, 935, 831, 945, 731, 586, 775, 75, 1562, 948, + 775, 1009, 161, 464, 1562, 384, 979, 34, 55, 388, + 979, 979, 251, 329, 410, 1562, 578, 396, 410, 1562, + 737, 941, 1378, 941, 653, 161, 579, 841, 775, 612, + 37, 112, 653, 1380, 40, 329, 410, 443, 55, 775, + 408, 41, 42, 1385, 115, 913, 740, 410, 936, 775, + 109, 67, 138, 237, 47, 537, 538, 539, 1198, 425, + 1372, 41, 42, 109, 873, 138, 139, 744, 47, 211, + 1390, 1391, 1450, 1078, 41, 42, 47, 745, 1447, 540, + 888, 541, 426, 542, 543, 1469, 431, 238, 158, 449, + 1516, 775, 239, 1573, 47, 904, 1517, 1441, 1004, 586, + 752, -367, 1157, 919, 410, 753, 936, 936, -396, 37, + 1123, 182, 183, 40, 112, 1169, 932, 410, 704, 491, + 41, 42, 1172, 653, 610, 511, 1342, 740, 418, 670, + 410, 112, 468, 690, 653, 1174, 112, 610, 290, 68, + 109, 469, 138, 139, 515, 373, 698, 257, 410, 61, + 1245, 41, 42, 158, 699, 1139, 700, 109, 520, 138, + 139, 536, 841, 612, 1447, 1448, 75, 732, 41, 42, + 532, 1237, 1147, 410, 654, 767, 327, 1147, 488, 329, + 410, 1061, 242, 54, 570, 112, 1495, 1496, 323, 855, + 329, 610, 507, 1449, 571, 653, 891, 339, 112, 112, + 112, 1313, 1314, 1315, 528, 1351, 1353, 1354, 1535, 528, + 1461, 1205, 528, 128, 1402, 129, 130, 131, 1402, 572, + 347, 573, 373, 112, 41, 42, 1147, 872, 1421, 1422, + 8, 9, 10, 11, 12, 576, 1078, 338, 1010, 1212, + 1214, 1216, 801, 802, 803, 804, -440, 429, 1015, 594, + 1124, 433, 667, 1302, 1303, 47, 1305, 841, 1107, 31, + 597, 441, 1309, 1026, 109, 1312, 138, 139, 342, 612, + 797, 798, 647, 654, 668, 41, 42, 799, 800, 55, + 669, 323, 455, 1521, 1461, 671, 37, 34, 182, 183, + 40, 672, 37, 673, 182, 183, 40, 41, 42, 68, + 805, 806, 676, 41, 42, 105, 678, 256, 721, 479, + 696, 718, 759, 433, 723, 719, 495, 936, -238, 772, + 1485, 347, 776, 609, 162, 610, 75, 780, 834, 609, + 112, 610, -12, 611, 936, 836, 838, 529, 849, 611, + 158, 901, -13, 54, 893, 894, 218, 921, 923, 928, + 699, 924, 47, -417, 977, 949, 704, 653, -292, -524, + 963, 970, 748, 972, 704, 8, 9, 10, 11, 12, + 918, 983, 105, 1061, 984, 985, 67, 987, 988, 925, + 989, 990, 612, 927, 595, 999, 347, 602, 1123, 162, + 1011, 1012, -293, 1013, 31, 112, 112, 112, 1078, 8, + 9, 10, 11, 12, 1027, 1028, 635, 936, 936, 737, + 639, 1029, 1030, 339, 8, 9, 10, 11, 12, 1031, + 1032, 1033, 34, 1044, -405, 1445, 1427, -404, 31, 1093, + 1058, 347, 347, 347, 1095, 1103, 1147, 1147, 1147, 1104, + 1105, 211, 1561, 31, 1106, 1112, 993, 1113, 1114, 1115, + 347, 1121, 653, 653, 1131, 1205, 34, 1132, 775, 1167, + 1133, 1138, 1182, 1183, 68, 105, 1143, 1188, 323, 323, + 1146, 34, 1189, 1190, 61, 1191, 1192, 537, 538, 539, + 1300, 1123, 398, 399, 1206, 209, 219, 434, 1207, 400, + 737, 75, 1209, 767, 1078, 406, 455, 1210, 1222, 455, + 401, 540, 407, 541, 1218, 542, 1322, 653, 54, 402, + 653, 403, 1225, 777, 404, 410, 1224, 115, 460, 674, + 1232, 1233, -3, 778, 347, 1230, 675, 1235, 1124, 47, + 47, 1240, 1534, 1242, 500, 1246, 1251, 1253, 441, 112, + 112, 1255, 495, 68, 323, 1258, 495, 1259, 1078, 434, + 1263, 1078, 1267, 479, 1270, 653, 529, 1272, 529, 1274, + 653, 529, 1275, 323, 529, 1276, 728, 1277, 1278, 1280, + 75, 1304, 1287, 531, 1296, 339, 162, 1297, 112, 1325, + 1147, 1147, 440, 1307, 1123, 1333, 1308, 54, 1339, 1310, + 653, 1341, 1343, 1311, 1348, 1319, 1078, 1347, 1349, 1355, + 1356, 1078, 37, 1357, 182, 183, 40, 1359, 105, 1365, + 1366, 1367, 1368, 41, 42, 1205, 347, 1101, 1375, 1486, + 1376, 1124, 1205, 347, 64, 116, 1379, 1386, 148, 323, + 105, 1078, 1387, 149, 150, 1315, 1395, 47, 112, 698, + 829, 410, 175, 602, 1396, 1398, 1405, 112, 1415, 700, + 105, 1416, 1408, 653, -406, 1419, 64, 1430, 653, 1434, + 1436, 1438, 47, 47, 1439, 160, 1446, 1455, 1451, 159, + 1440, 1456, 870, 1460, 1370, 1205, 653, 602, 653, 1536, + 1457, 1458, 653, 879, 1465, 653, 1470, 47, 1544, 372, + 55, 220, 175, 653, 1078, 175, 1358, 653, 1472, 1078, + 1474, 1476, 1478, 68, 1360, 1361, 1362, 1480, 1482, 105, + 68, 1483, 1488, 479, 1489, 1490, 1501, 1078, 1511, 1078, + 479, 1519, 1513, 1078, 1124, 1515, 1078, 1527, 258, 1520, + 75, 1542, 460, 1547, 1078, 460, 1543, 75, 1078, 339, + 1554, 175, 1556, 105, 213, 1558, 1564, 54, 327, 1571, + 1572, 1223, 1397, 808, 54, 807, 1324, 55, 809, 212, + 214, 455, 810, 68, 1219, 811, 1522, 1433, 1574, 231, + 328, 1389, 1257, 479, 347, 728, 1504, 241, 258, 349, + 1406, 1229, 942, 1108, 2, 205, 4, 5, 6, 7, + 75, 495, 531, 694, 531, 729, 213, 531, 951, 695, + 531, 1110, 1142, 826, 175, 1057, 1120, 54, 900, 405, + 1334, 212, 214, 227, 816, 339, 742, 973, 8, 9, + 10, 11, 12, 0, 423, 817, 965, 428, 430, 818, + 347, 347, 159, 1444, 0, 0, 0, 0, 0, 213, + 0, 0, 0, 0, 0, 0, 105, 31, 0, 35, + 55, 36, 0, 447, 212, 214, 0, 450, 175, 451, + 37, 0, 173, 174, 40, 175, 0, 0, 466, 105, + 0, 41, 42, 1018, 64, 34, 105, 829, 0, 480, + 37, 0, 182, 183, 40, 0, 0, 0, 0, 487, + 0, 41, 42, 0, 0, 0, 0, 430, 517, 0, + 213, 0, 0, 0, 0, 0, 123, 126, 127, 0, + 728, 534, 535, 0, 0, 212, 214, 698, 0, 410, + 728, 0, 0, 556, 0, 0, 0, 700, 0, 105, + 0, 0, 0, 0, 175, 728, 0, 0, 213, 0, + 0, 0, 213, 8, 9, 10, 11, 12, 0, 0, + 486, 175, 0, 212, 214, 175, 0, 212, 214, 535, + 0, 0, 0, 0, 0, 258, 0, 829, 603, 0, + 0, 455, 31, 506, 631, 0, 0, 253, 0, 254, + 0, 0, 0, 0, 0, 0, 0, 636, 0, 0, + 455, 636, 55, 55, 258, 535, 0, 460, 0, 0, + 34, 0, 0, 0, 729, 37, 1388, 182, 183, 40, + 0, 495, 1125, 323, 0, 55, 41, 42, 175, 0, + 37, 0, 182, 183, 40, 0, 0, 0, 0, 213, + 0, 41, 42, 0, 0, 55, 37, 0, 182, 183, + 40, 480, 184, 0, 212, 214, 0, 41, 42, 0, + 0, 37, 185, 173, 174, 40, 349, 1532, 0, 410, + 395, 480, 41, 42, 870, 0, 0, 1533, 0, 480, + 414, 415, 0, 184, 0, 419, 0, 421, 422, 0, + 347, 347, 0, 185, 0, 0, 0, 0, 371, 55, + 0, 0, 0, 0, 55, 724, 0, 0, 430, 0, + 166, 0, 171, 0, 0, 177, 178, 179, 0, 181, + 213, 0, 0, 738, 0, 64, 0, 0, 0, 0, + 0, 0, 0, 430, 232, 212, 214, 430, 55, 8, + 9, 10, 11, 12, 728, 728, 247, 248, 0, 729, + 0, 0, 212, 0, 0, 455, 829, 0, 0, 729, + 37, 0, 182, 183, 40, 0, 258, 349, 31, 0, + 213, 41, 42, 0, 729, 1505, 0, 1509, 0, 0, + 0, 0, 794, 795, 796, 212, 214, 37, 0, 173, + 174, 40, 0, 0, 175, 0, 34, 264, 41, 42, + 0, 0, 728, 728, 0, 0, 0, 265, 0, 0, + 0, 0, 1538, 819, 1540, 347, 0, 460, 0, 0, + 0, 0, 0, 0, 375, 535, 0, 175, 0, 0, + 0, 636, 832, 0, 603, 0, 460, 0, 959, 0, + 610, 55, 0, 175, 0, 851, 0, 0, 960, 0, + 0, 0, 0, 0, 0, 0, 0, 1569, 175, 1570, + 0, 0, 0, 603, 55, 0, 0, 0, 603, 0, + 0, 55, 1577, 1578, 636, 339, 0, 349, 349, 349, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 213, 0, 0, 349, 0, 0, 0, + 1125, 0, 0, 0, 0, 0, 0, 0, 212, 214, + 0, 0, 0, 0, 724, 0, 0, 0, 0, 0, + 0, 213, 73, 0, 55, 480, 213, 0, 0, 0, + 258, 738, 0, 0, 938, 0, 212, 214, 0, 0, + 0, 212, 214, 0, 0, 0, 1331, 0, 0, 0, + 0, 0, 0, 0, 0, 175, 0, 221, 0, 535, + 0, 0, 0, 0, 0, 0, 0, 480, 0, 0, + 349, 0, 0, 729, 729, 0, 0, 0, 728, 964, + 0, 0, 430, 0, 0, 0, 728, 728, 728, 0, + 0, 460, 0, 1125, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 601, 608, 994, 258, 738, 0, 0, + 0, 0, 992, 0, 213, 632, 633, 0, 0, 125, + 125, 125, 0, 0, 0, 0, 0, 0, 213, 212, + 214, 729, 729, 0, 728, 0, 0, 0, 0, 0, + 0, 0, 0, 212, 214, 352, 0, 0, 0, 724, + 0, 0, 535, 0, 0, 0, 0, 0, 0, 724, + 0, 0, 349, 506, 636, 0, 0, 1024, 636, 832, + 0, 0, 821, 822, 724, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1035, 0, 0, 0, 0, 0, + 125, 0, 125, 0, 0, 0, 1125, 8, 9, 10, + 11, 12, 856, 0, 0, 859, 860, 0, 863, 0, + 865, 866, 0, 0, 0, 867, 868, 274, 0, 448, + 0, 175, 213, 0, 0, 0, 31, 0, 1507, 0, + 1507, 0, 0, 0, 0, 0, 64, 212, 214, 0, + 73, 0, 0, 0, 0, 73, 412, 0, 0, 0, + 0, 0, 0, 420, 34, 0, 0, 0, 636, 37, + 0, 182, 183, 40, 0, 1507, 0, 1507, 0, 0, + 41, 42, 0, 125, 0, 1332, 0, 0, 0, 0, + 0, 125, 0, 125, 125, 0, 0, 0, 125, 0, + 125, 125, 0, 0, 1117, 323, 1532, 0, 410, 943, + 944, 0, 430, 116, 0, 946, 1533, 729, 0, 8, + 9, 10, 11, 12, 0, 729, 729, 729, 0, 0, + 349, 0, 0, 0, 0, 412, 0, 0, 0, 8, + 9, 10, 11, 12, 0, 0, 0, 0, 31, 0, + 221, 0, 0, 0, 0, 0, 535, 0, 0, 0, + 0, 0, 0, 0, 0, 603, 0, 0, 31, 0, + 125, 0, 0, 729, 0, 0, 34, 0, 428, 0, + 0, 37, 0, 724, 724, 40, 349, 349, 0, 0, + 0, 584, 41, 42, 0, 0, 34, 517, 0, 588, + 0, 37, 591, 182, 183, 40, 1204, 0, 0, 0, + 0, 0, 41, 42, 0, 0, 0, 73, 43, 0, + 0, 76, 0, 0, 213, 0, 0, 0, 146, 0, + 0, 0, 352, 0, 0, 0, 0, 73, 264, 212, + 214, 724, 724, 0, 0, 73, 0, 636, 265, 0, + 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 412, 0, 0, 0, 420, + 0, 352, 0, 0, 1508, 0, 1508, 0, 544, 545, + 546, 547, 548, 549, 550, 551, 552, 553, 222, 352, + 0, 73, 0, 0, 952, 0, 953, 0, 0, 0, + 0, 0, 0, 956, 957, 0, 738, 0, 962, 0, + 0, 1508, 554, 1508, 535, 8, 9, 10, 11, 12, + 967, 0, 0, 0, 0, 971, 0, 0, 0, 175, + 0, 0, 0, 352, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 31, 0, 0, 0, 0, 1301, + 0, 1000, 0, 0, 412, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 258, 0, 0, 0, + 0, 64, 34, 0, 0, 0, 354, 37, 0, 0, + 0, 40, 0, 0, 0, 724, 0, 738, 41, 42, + 0, 116, 0, 0, 0, 0, 601, 0, 352, 0, + 0, 0, 0, 0, 213, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 744, 0, 0, 724, 0, 212, + 214, 0, 0, 0, 745, 724, 724, 724, 0, 0, + 0, 0, 0, 0, 0, 0, 349, 349, 0, 0, + 0, 0, 0, 352, 352, 352, 584, 584, 0, 0, + 1204, 0, 0, 1045, 1046, 1047, 1048, 0, 1050, 0, + 0, 0, 352, 0, 0, 0, 0, 0, 0, 0, + 0, 76, 0, 724, 1094, 0, 76, 0, 0, 0, + 352, 0, 0, 0, 116, 125, 125, 0, 1100, 0, + 0, 73, 0, 0, 0, 0, 0, 352, 0, 1234, + 0, 213, 0, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 125, 212, 214, 125, 125, + 0, 125, 0, 125, 125, 0, 0, 1116, 125, 125, + 0, 0, 0, 73, 0, 911, 352, 0, 0, 914, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, -294, 0, + 0, 349, 0, 0, 0, 0, 0, 1144, 0, 31, + 0, 222, 412, 352, 1152, 0, 0, 0, 0, 1156, + 0, 0, 0, 0, 1160, 0, 1161, 116, 0, 0, + 1163, 1164, 1165, 0, 0, 1168, 0, 34, 0, 0, + 0, 0, 0, 0, 1180, 0, 0, 125, -294, 0, + 1204, 0, 125, 125, 0, 352, 0, 1204, 125, 0, + 0, 0, 1195, 1196, 1323, 352, 0, 0, 352, 0, + 0, 0, 0, 221, 0, 352, 0, 0, 76, 0, + 352, 0, 0, 0, 0, 0, 0, 0, 0, 1226, + 0, 0, 1228, 354, 0, 0, 0, 0, 76, 0, + 0, 0, 0, 0, 0, 0, 76, 0, 0, 0, + 1204, 0, 0, 0, 0, 0, 0, 1557, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 584, 0, 0, + 0, 1244, 354, 0, 0, 0, 0, 1248, 1249, 0, + 0, 0, 73, 0, 0, 0, 0, 0, 0, 1260, + 354, 0, 76, 78, 1264, 0, 0, 1268, 0, 1269, + 0, 0, 1271, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1279, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 78, 281, 282, 1286, 283, + 1288, 1289, 1290, 1291, 354, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1298, 0, 1299, 0, + 0, 0, 171, 0, 0, 284, 0, 0, 0, 0, + 223, 649, 0, 138, 139, 286, 352, 0, 287, 650, + 289, 290, 41, 42, 0, 291, 292, 0, 0, 0, + 412, 1327, 1328, 293, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 294, 354, + 651, 0, 652, 379, 0, 0, 0, 296, 380, 298, + 299, 300, 301, 0, 0, 0, 0, 0, 0, 352, + 352, 0, 352, 352, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1363, 1364, 0, 0, 0, 0, 0, + 0, 0, 73, 1374, 354, 354, 354, 0, 355, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1158, + 0, 0, 0, 354, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1170, 0, 352, 352, 0, + 0, 354, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 76, 0, 0, 1407, 0, 0, 354, 0, + 0, 0, 0, 0, 0, 0, 0, 1411, 0, 1412, + 1413, 1414, 281, 282, 0, 283, 0, 0, 0, 0, + 0, 1418, 0, 0, 0, 0, 0, 0, 0, 0, + 1429, 0, 0, 0, 76, 0, 0, 354, 0, 0, + 0, 284, 352, 78, 0, 0, 1442, 285, 78, 0, + 0, 286, 1238, 0, 287, 288, 289, 290, 41, 42, + 0, 291, 292, 0, 0, 0, 0, 0, 85, 293, + 0, 0, 0, 0, 354, 0, 0, 0, 0, 0, + 0, 0, 125, 0, 294, 221, 378, 0, 0, 379, + 0, 0, 0, 296, 380, 298, 299, 300, 301, 0, + 85, 0, 1491, 1492, 0, 0, 0, 73, 0, 0, + 0, 0, 0, 0, 0, 1497, 354, 0, 0, 0, + 0, 352, 1497, 352, 0, 0, 354, 0, 0, 354, + 0, 0, 0, 0, 222, 224, 354, 0, 0, 0, + 0, 354, 0, 223, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 352, 0, 1531, 0, 0, 0, 1537, + 0, 352, 352, 352, 0, 0, 0, 0, 0, 0, + 0, 0, 352, 352, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 73, 0, 1559, 0, + 1560, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 76, 0, 0, 0, 125, 0, 352, + 78, 0, 0, 0, 0, 0, 0, 0, 1575, 1576, + 0, 0, 0, 362, 0, 355, 1579, 1580, 0, 0, + 78, 0, 0, 0, 0, 0, -519, 0, 78, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, -294, 1227, 25, 26, 27, 693, 30, - 694, 1107, 941, 722, 30, 213, 211, 1056, 478, 213, - 1108, 1140, 825, 1118, 899, 478, 935, 964, 1331, 741, - 972, 815, 0, 0, 816, 174, 257, 33, 817, 602, - 0, 252, 33, 253, 1391, 630, 0, 0, 0, 37, - 38, 0, 174, -294, 0, 0, 174, 1424, 635, 211, - 0, 0, 635, 0, 0, 257, 0, 8, 9, 10, - 11, 12, 0, 0, 0, 0, 0, 0, 478, 776, - 0, 409, 0, 1123, 935, 935, 337, 0, 0, 777, - 0, 0, 0, 0, 109, 30, 0, 0, 1417, 653, - 0, 1425, 0, 0, 0, 1217, 213, 0, 0, 0, - 0, 0, 479, 0, 0, 1504, 0, 1504, 0, 174, - 211, 0, 0, 33, 394, 0, 0, 348, 0, 0, - 0, 0, 479, 0, 413, 414, 0, 728, 728, 418, - 479, 420, 421, 0, 0, 0, 1464, 0, 0, 0, - 0, 1468, 1504, 0, 1504, 0, 0, 0, 211, 0, - 0, 0, 211, 0, 0, 958, 723, 609, 0, 429, - 0, 0, 0, 0, 0, 959, 0, 0, 505, 0, - 716, 1490, 322, 0, 737, 463, 63, 213, 0, 8, - 9, 10, 11, 12, 429, 728, 728, 0, 429, 0, - 0, 0, 0, 0, 0, 0, 0, 8, 9, 10, - 11, 12, 0, 600, 607, 0, 0, 30, 749, 36, - 753, 181, 182, 39, 0, 631, 632, 257, 348, 0, - 40, 41, 0, 0, 0, 30, 0, 213, 0, 0, - 0, 0, 0, 0, 0, 33, 0, 0, 0, 211, - 36, 0, 181, 182, 39, 0, 697, 0, 409, 0, - 0, 40, 41, 33, 698, 0, 699, 1559, 36, 0, - 181, 182, 39, 1559, 818, 0, 0, 0, 0, 40, - 41, 0, 0, 0, 1559, 174, 0, 608, 1559, 609, - 0, 0, 635, 831, 935, 602, 0, 610, 0, 0, - 0, 0, 0, 0, 0, 697, 850, 409, 0, 0, - 0, 935, 0, 0, 0, 699, 0, 0, 174, 0, - 0, 0, 0, 0, 602, 0, 0, 0, 0, 602, - 211, 0, 0, 0, 174, 635, 0, 1329, 348, 348, - 348, 0, 0, 0, 0, 1385, 0, 211, 0, 174, - 36, 0, 181, 182, 39, 0, 0, 348, 0, 0, - 213, 40, 41, 0, 0, 0, 0, 0, 0, 728, - 0, 0, 891, 0, 0, 723, 0, 728, 728, 728, - 211, 0, 0, 0, 935, 935, 479, 697, 213, 409, - 0, 257, 737, 213, 0, 937, 0, 699, 0, 0, - 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 72, 0, - 25, 26, 27, 0, 0, 728, 0, 0, 479, 30, - 452, 348, 0, 944, 0, 0, 0, 0, 0, 947, - 963, 0, 0, 429, 0, 75, 174, 0, 0, 72, - 36, 0, 181, 182, 39, 0, 0, 33, 0, 0, - 0, 40, 41, 0, 37, 38, 0, 257, 737, 0, - 0, 0, 0, 991, 0, 0, 75, 0, 0, 0, - 0, 213, 0, 0, 220, 0, 0, 1529, 0, 409, - 0, 0, 0, 0, 0, 213, 0, 1530, 485, 0, - 0, 453, 0, 211, 1502, 710, 1506, 0, 0, 109, - 723, 221, 0, 0, 0, 0, 0, 0, 0, 0, - 723, 0, 0, 348, 0, 635, 820, 821, 1023, 635, - 831, 211, 0, 0, 0, 723, 211, 0, 0, 0, - 0, 1535, 0, 1537, 0, 1034, 36, 0, 181, 182, - 39, 0, 0, 0, 0, 0, 855, 40, 41, 858, - 859, 0, 862, 0, 864, 865, 0, 0, 0, 866, - 867, 0, 351, 543, 544, 545, 546, 547, 548, 549, - 550, 551, 552, 263, 0, 0, 1566, 0, 1567, 213, - 0, 0, 0, 264, 951, 0, 952, 63, 0, 353, - 0, 1574, 1575, 955, 956, 0, 0, 553, 961, 0, - 0, 0, 174, 0, 653, 0, 411, 0, 0, 635, - 966, 1060, 0, 419, 211, 970, 0, 0, 8, 9, - 10, 11, 12, 0, 0, 0, 0, 0, 211, 0, - 0, 0, 0, 0, 0, 0, 447, 0, 0, 0, - 0, 999, 0, 942, 943, 1115, 30, 0, 505, 945, - 0, 0, 0, 429, 115, 0, 0, 72, 0, 0, - 0, 0, 72, 0, 0, 0, 0, 0, 0, 0, - 0, 348, 0, 0, 33, 0, 0, 0, 0, 36, - 0, 181, 182, 39, 75, 411, 600, 0, 0, 75, - 40, 41, 0, 0, 0, 0, 124, 124, 124, 0, - 0, 0, 0, 653, 0, 0, 602, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1529, 0, 409, 427, - 0, 0, 211, 0, 723, 723, 1530, 348, 348, 0, - 0, 0, 0, 0, 8, 9, 10, 11, 12, 0, - 0, 583, 0, 1044, 1045, 1046, 1047, 1202, 1049, 587, - 0, 0, 590, 0, 0, 0, 0, 220, 0, 0, - 0, 0, 30, 0, 1093, 0, 0, 124, 0, 124, - 0, 213, 0, 0, 0, 0, 0, 0, 1099, 0, - 0, 0, 723, 723, 221, 0, 0, 0, 635, 0, - 33, 0, 0, 0, 273, 36, 0, 181, 182, 39, - 0, 0, 0, 1060, 0, 0, 40, 41, 0, 0, - 0, 0, 0, 0, 0, 411, 0, 1114, 0, 419, - 0, 0, 0, 0, 72, 0, 0, 0, 0, 0, - 0, 0, 183, 0, 0, 0, 0, 0, 0, 351, - 0, 0, 184, 0, 72, 0, 737, 0, 0, 0, - 124, 75, 72, 0, 0, 0, 0, 1142, 124, 0, - 124, 124, 0, 0, 1150, 124, 353, 124, 124, 1154, - 0, 75, 0, 0, 1158, 0, 1159, 0, 351, 75, - 1161, 1162, 1163, 0, 0, 1166, 0, 0, 0, 1298, - 0, 0, 0, 0, 1178, 0, 351, 0, 72, 174, - 0, 0, 0, 0, 411, 353, 257, 0, 0, 1297, - 0, 63, 1193, 1194, 211, 0, 0, 0, 8, 9, - 10, 11, 12, 353, 723, 75, 737, 0, 0, 0, - 115, 0, 0, 0, 0, 0, 0, 124, 0, 1224, - 351, 0, 1226, 0, 0, 0, 30, 0, 0, 0, - 213, 0, 0, 0, 0, 0, 723, 0, 0, 0, - 0, 0, 0, 0, 723, 723, 723, 353, 0, 0, - 0, 0, 0, 0, 33, 348, 348, 0, 0, 36, - 1241, 181, 182, 39, 0, 0, 1245, 1246, 0, 1202, - 40, 41, 0, 0, 0, 0, 583, 583, 1257, 0, - 0, 0, 0, 1261, 0, 351, 1265, 0, 1266, 0, - 0, 1268, 723, 0, 0, 0, 263, 0, 0, 0, - 0, 0, 0, 115, 1276, 0, 264, 0, 0, 0, - 0, 0, 353, 1232, 0, 0, 0, 1283, 0, 1285, - 1286, 1287, 1288, 0, 0, 0, 213, 0, 0, 0, - 351, 351, 351, 0, 0, 1295, 0, 1296, 0, 0, - 0, 170, 0, 0, 0, 0, 0, 0, 0, 351, - 0, 0, 0, 0, 0, 174, 0, 353, 353, 353, - 0, 0, 0, 0, 0, 910, 0, 351, 0, 913, - 1324, 1325, 0, 211, 0, 0, 353, 0, 72, 0, - 348, 0, 77, 0, 351, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 353, 0, 0, 0, 0, 0, - 0, 0, 411, 0, 0, 75, 115, 0, 0, 84, - 0, 353, 0, 77, 0, 54, 54, 0, 0, 0, - 72, 1360, 1361, 351, 0, 0, 0, 0, 0, 1202, - 0, 1371, 0, 0, 0, 0, 1202, 1320, 0, 0, - 84, 0, 0, 0, 0, 0, 54, 75, 222, 0, - 353, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 351, 0, 0, 0, 0, 0, 0, 0, 0, 211, - 0, 0, 0, 0, 0, 223, 0, 0, 54, 0, - 0, 54, 0, 1404, 0, 0, 0, 353, 0, 1202, - 0, 0, 0, 0, 0, 1408, 1554, 1409, 1410, 1411, - 0, 0, 351, 0, 0, 0, 0, 0, 0, 1415, - 0, 0, 351, 0, 0, 351, 0, 583, 1426, 0, - 220, 0, 351, 0, 0, 0, 0, 351, 0, 353, - 0, 0, 124, 124, 1439, 0, 354, 0, 0, 353, - 0, 0, 353, 0, 0, 0, 0, 221, 0, 353, - 0, 0, 0, 0, 353, 0, 0, 0, 0, 0, - 0, 0, 124, 361, 0, 124, 124, 0, 124, 346, - 124, 124, 0, 0, 0, 124, 124, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 72, - 1488, 1489, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1494, 0, 0, 0, 0, 0, 0, - 1494, 0, 0, 0, 0, 0, 75, 0, 0, 0, + 22, 23, 24, 25, 355, 0, 26, 27, 28, 29, + 0, 0, 30, 0, 0, 31, 32, 0, 0, 0, + 0, 0, 355, 0, 78, 0, 0, 354, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 352, 0, 0, + 33, 0, 0, 34, 0, 35, 0, 36, 37, 0, + 38, 39, 40, 0, 0, 0, 0, 0, 85, 41, + 42, 0, 0, 85, 0, 0, 355, 0, 1034, 0, + 0, 8, 9, 10, 11, 12, 0, 0, 0, 0, + 354, 354, 0, 354, 354, 43, 73, 44, 0, 0, + 0, 0, 0, 73, 0, 45, 0, 0, 281, 282, + 31, 283, 0, 76, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -295, 0, 0, 0, 284, 34, 0, + 0, 355, 0, 285, 31, 0, 0, 286, 354, 354, + 287, 288, 289, 290, 41, 42, 73, 291, 292, 0, + 0, 0, 0, 0, 0, 293, 0, 0, 224, 0, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, + 294, 0, 378, -295, 0, 0, 355, 355, 355, 296, + 827, 298, 299, 300, 301, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 355, 0, 0, 0, 0, + 0, 0, 0, 354, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 355, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 78, 85, 0, 0, 0, 164, + 355, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 362, 0, 0, 0, 0, 85, 222, 0, 217, 0, + 0, 0, 0, 85, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 78, 0, 76, 355, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 362, + 0, 0, 354, 0, 354, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 164, 0, 0, 362, 0, 85, + 271, 0, 0, 0, 0, 0, 355, 0, 0, 0, + 0, 0, 0, 0, 354, 0, 0, 0, 0, 0, + 0, 0, 354, 354, 354, 0, 0, 0, 0, 164, + 0, 0, 0, 354, 354, 0, 0, 0, 0, 368, + 0, 362, 0, 374, 0, 0, 0, 76, 355, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 355, 0, + 0, 355, 0, 0, 0, 0, 223, 0, 355, 0, + 354, 0, 0, 355, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 164, 0, 26, 27, 28, 0, 0, 0, + 0, 0, 0, 31, 217, 0, 362, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 411, 77, 0, 0, 54, 0, 77, 0, 0, 0, - 0, 0, 0, 1528, 0, 0, 0, 1534, 0, 0, - 0, 0, 0, 0, 124, 0, 0, 0, 84, 124, - 124, 0, 0, 84, 54, 124, 0, 0, 0, 0, - 0, 0, 0, 351, 0, 0, 1556, 0, 1557, 0, + 0, 0, 164, 461, 0, 0, 0, 0, 0, 0, + 0, 34, 0, 0, 0, 78, 0, 0, 206, 39, + 0, 0, 0, 0, 0, 0, 374, 0, 0, 0, + 0, 362, 362, 362, 164, 0, 0, 0, 354, 0, + 0, 0, 0, 0, 514, 0, 516, 519, 0, 0, + 362, 0, 0, 0, 522, 523, 0, 0, 461, 516, + 516, 164, 0, 270, 0, 0, 0, 0, 362, 0, + 0, 516, 0, 0, 0, 0, 0, 0, 0, 85, + 0, 0, 0, 0, 0, 362, 0, 76, 281, 282, + 0, 283, 0, 0, 76, 0, 0, 0, 0, 355, + 0, 0, 0, 0, 0, 0, 0, 516, 606, 0, + 0, 0, 0, 630, 0, 0, 0, 284, 0, 0, + 0, 85, 0, 285, 362, 0, 0, 286, 0, 0, + 287, 288, 289, 290, 41, 42, 0, 291, 292, 0, + 0, 0, 0, 516, 0, 293, 0, 76, 0, 0, + 0, 0, 355, 355, 0, 355, 355, 0, 0, 0, + 294, 362, 378, 0, 0, 0, 0, 0, 812, 296, + 380, 298, 299, 300, 301, 78, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 210, 0, 0, 0, 164, + 164, 0, 0, 0, 0, 230, 368, 234, 0, 236, + 0, 0, 0, 362, 0, 0, 245, 0, 0, 0, + 355, 355, 0, 362, 0, 0, 362, 461, 0, 0, + 461, 224, 0, 362, 0, 0, 0, 0, 362, 0, + 0, 0, 0, 0, 0, 0, 0, 210, 0, 234, + 236, 245, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 741, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 164, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 355, 0, 461, 0, 461, + 210, 0, 461, 0, 164, 461, 0, 0, 0, 0, + 85, 0, 0, 0, 0, 0, 0, 368, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 223, 0, + 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, + 516, 516, 516, 516, 516, 516, 516, 516, 0, 0, + 78, 210, 0, 234, 236, 245, 0, 0, 0, 0, + 164, 0, 0, 0, 355, 0, 355, 0, 0, 0, + 0, 0, 368, 516, 606, 0, 0, 837, 0, 0, + 0, 0, 0, 0, 362, 0, 0, 0, 0, 210, + 0, 0, 0, 210, 0, 0, 355, 0, 0, 0, + 0, 0, 0, 606, 355, 355, 355, 0, 606, 504, + 0, 0, 0, 0, 0, 355, 355, 368, 368, 368, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 78, + 0, 0, 0, 0, 0, 0, 368, 362, 362, 0, + 362, 362, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 355, 0, 0, 0, 0, 0, 0, 210, + 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 741, 516, 0, 0, 0, 0, 0, 0, 0, + 210, 0, 0, 0, 0, 234, 236, 155, 0, 0, + 0, 0, 461, 245, 516, 362, 362, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 516, 0, 0, + 368, 0, 961, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 250, 0, 0, 210, 0, 0, 0, + 355, 0, 31, 255, 0, 0, 0, 741, 0, 0, + 0, 0, 0, 516, 210, 0, 0, 0, 0, 210, + 362, 210, 0, 0, 0, 0, 0, 0, 0, 0, + 34, 0, 0, 0, 0, 0, 0, 0, 210, 0, + 0, 210, 210, 0, 0, 516, 0, 0, 0, 78, + 0, 0, 0, 0, 0, 0, 78, 210, 0, 155, + 516, 0, 368, 224, 0, 0, 630, 0, 0, 368, + 0, 210, 0, 385, 0, 0, 0, 0, 210, 0, + 0, 0, 0, 0, 0, 85, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 417, 0, 0, 362, + 0, 362, 0, 0, 0, 0, 0, 0, 0, 78, + 432, 0, 0, 0, 0, 0, 0, 0, 0, 437, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 445, + 0, 362, 0, 0, 0, 0, 0, 0, 0, 362, + 362, 362, 0, 0, 0, 0, 0, 0, 0, 0, + 362, 362, 0, 0, 471, 0, 0, 0, 0, 481, + 0, 0, 461, 0, 85, 0, 0, 0, 0, 0, + 0, 0, 489, 0, 0, 0, 0, 0, 499, 0, + 503, 461, 0, 0, 0, 0, 0, 362, 0, 0, + 0, 0, 0, 0, 210, 0, 0, 0, 533, 0, + 0, 0, 0, 0, 164, 0, 0, 0, 0, 0, + 0, 516, 0, 0, 0, 0, 0, 0, 0, 0, + 368, 0, 210, 0, 0, 0, 0, 210, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 593, 516, 0, 0, 0, 598, 0, 0, 0, + 0, 0, 0, 0, 516, 606, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 644, 362, 368, 368, 645, 646, + 0, 648, 0, 0, 0, 0, 0, 0, 660, 661, + 0, 662, 663, 0, 664, 516, 665, 0, 0, 0, + 0, 0, 1178, 0, 0, 8, 9, 10, 11, 12, + 0, 0, 0, 593, 0, 210, 0, 0, 0, 0, + 0, 680, 0, 0, 85, 0, 0, 0, 0, 210, + 0, 85, 281, 282, 31, 283, 461, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 691, 0, 0, 504, + 0, 0, 0, 0, 0, 0, 0, 697, 0, 0, + 0, 284, 34, 0, 0, 0, 0, 285, 516, 0, + 0, 286, 0, 0, 287, 288, 289, 290, 41, 42, + 733, 291, 292, 0, 85, 0, 736, 0, 0, 293, + 0, 471, 0, 0, 0, 0, 741, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 378, 0, 0, 0, + 210, 0, 516, 296, 1179, 298, 299, 300, 301, 0, + 0, 0, 0, 210, 0, 0, 516, 516, 773, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 217, 0, + 0, 0, 210, 0, 788, 0, 0, 0, 0, 0, + 0, 204, 2, 205, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 741, 26, 27, + 28, 815, 0, 0, 0, 0, 0, 31, 0, 0, + 825, 0, 0, 0, 0, 0, 0, 828, 0, 0, + 0, 0, 835, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 850, 0, 34, 0, 35, 0, 36, + 37, 0, 206, 39, 40, 0, 368, 368, 0, 210, + 0, 41, 42, 0, 0, 217, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 890, 210, 0, 43, 0, 207, + 0, 0, 0, 0, 0, 0, 0, 208, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 210, 0, 0, 0, 0, 0, 0, + 835, 0, 0, 0, 0, 0, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, -294, 210, 26, 27, 28, 0, + 0, 0, 0, 0, 0, 31, 210, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 516, 0, 0, + 0, 0, 0, 0, 0, 250, 0, 0, 0, 0, + 0, 368, 0, 34, 516, 968, 969, 0, 0, 0, + 38, 39, 0, 0, -294, 0, 0, 0, 0, 986, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1001, 0, 1002, 0, + 0, 0, 1006, 0, 0, 643, 0, 338, 0, 0, + 0, 0, 0, 0, 0, 110, 0, 0, 210, 461, + 0, 461, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 516, 516, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 281, 282, 0, 283, 0, 0, 461, 0, 461, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1039, 0, + 0, 0, 0, 0, 0, 1040, 0, 0, 0, 284, + 0, 0, 0, 0, 0, 285, 164, 0, 1042, 286, + 1043, 0, 287, 288, 289, 290, 41, 42, 0, 291, + 292, 0, 0, 0, 1055, 210, 0, 293, 0, 0, + 0, 1059, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 294, 1097, 378, 0, 1098, 0, 0, 781, + 0, 296, 380, 298, 299, 300, 301, 0, 0, 0, + 0, 0, 0, 0, 598, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 341, 363, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 210, 0, 0, 413, 0, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 1162, 26, 27, 28, 29, 0, 0, + 30, 0, 0, 31, 32, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 0, 26, 27, 28, 33, 0, + 0, 34, 0, 35, 31, 36, 37, 413, 38, 39, + 40, 0, 0, 0, 0, 0, 0, 41, 42, 533, + 0, 0, 0, 0, 0, 0, 1227, 0, 0, 0, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 38, + 39, 0, 0, 43, 0, 44, 0, 0, 0, -523, + 0, 0, 0, 45, 0, 321, 1241, 0, 0, 0, + 0, 1243, 0, 413, 0, 345, 0, 0, 0, 1247, + 0, 413, 589, 0, 413, 592, 0, 381, 381, 0, + 0, 0, 0, 0, 363, 0, 0, 0, 622, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1273, 0, 0, 0, 0, 0, 0, 640, 0, 0, + 341, 0, 1281, 0, 0, 1282, 0, 1283, 0, 0, + 281, 282, 0, 283, 0, 0, 0, 0, 0, 0, + 0, 1292, 1293, 0, 0, 0, 0, 413, 0, 0, + 0, 413, 0, 0, 0, 0, 0, 0, 321, 284, + 0, 0, 0, 1306, 0, 285, 0, 0, 0, 286, + 0, 0, 287, 288, 289, 290, 41, 42, 0, 291, + 292, 0, 363, 485, 0, 0, 0, 293, 0, 0, + 1329, 0, 0, 0, 0, 0, 0, 0, 210, 0, + 0, 0, 294, 0, 378, 413, 0, 993, 0, 0, + 0, 296, 380, 298, 299, 300, 301, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 413, 0, 0, 363, + 0, 0, 0, 0, 1, 2, 205, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, -294, + 0, 26, 27, 28, 29, 0, 0, 30, 0, 413, + 31, 0, 341, 363, 0, 0, 0, 0, 1399, 0, + 1400, 0, 0, 0, 0, 0, 0, 0, 0, 381, + 0, 0, 0, 1409, 0, 1410, 0, 0, 34, 0, + 35, 0, 36, 0, 0, 38, 39, 0, 0, -294, + 0, 0, 0, 1417, 0, 0, 0, 0, 413, 413, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1435, + 1437, 0, 0, 0, 0, 0, 0, 830, 363, 0, + 363, 1443, 44, 0, 1247, 0, 0, 0, 0, 622, + 110, 622, 622, 0, 0, 0, 0, 0, 622, 0, + 0, 0, 0, 0, 0, 0, 1466, 0, 869, 363, + 0, 0, 0, 0, 363, 1473, 0, 0, 1475, 0, + 1477, 1479, 1481, 363, 363, 363, 0, 0, 0, 0, + 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 363, 0, 0, 0, 0, 413, 912, 0, + 0, 413, 915, 0, 0, 0, 0, 0, 917, 0, + 0, 0, 1512, 0, 1514, 0, 0, 1247, 0, 0, + 769, 0, 0, 0, 0, 0, 341, 363, 413, 0, + 413, 0, 1526, 782, 413, 0, 0, 0, 0, 0, + 769, 0, 0, 769, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 792, 793, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 363, 622, 0, 0, + 0, 0, 0, 0, 0, 0, 814, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 823, 0, 0, 0, + 0, 0, 0, 345, 0, 0, 0, 0, 782, 0, + 0, 0, 341, 363, 0, 0, 0, 413, 413, 0, + 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 29, 0, 0, 30, 889, 413, + 31, 32, 0, 0, 0, 0, 0, 381, 363, 0, + 0, 0, 0, 0, 830, 363, 0, 0, 0, 622, + 0, 622, 0, 0, 0, 33, 0, 0, 34, 0, + 35, 622, 36, 37, 0, 38, 39, 40, 0, 0, + 0, 0, 0, 0, 41, 42, 0, 345, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 43, 0, 44, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -294, 830, 26, 27, 28, 0, 0, + 0, 0, 413, 0, 31, 0, 0, 0, 413, 0, + 0, 0, 0, 782, 0, 991, 413, 0, 0, 0, + 0, 996, 0, 0, 0, 0, 0, 0, 1005, 622, + 622, 0, 34, 0, 0, 0, 0, 37, 0, 336, + 337, 40, 0, -294, 0, 0, 0, 0, 41, 42, + 0, 0, 0, 0, 0, 0, 363, 0, 0, 0, + 0, 0, 413, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1022, 1023, 643, 345, 338, 0, 0, 0, + 0, 413, 1159, 0, 634, 0, 0, 0, 0, 0, + 345, 363, 0, 0, 0, 0, 0, 413, 1171, 0, + 622, 622, 1176, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 363, 363, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1053, 0, 0, 0, 381, 1, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 29, 0, 0, 30, 0, + 0, 31, 0, 830, 413, 1239, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 622, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, + 0, 35, 0, 36, 0, 0, 38, 39, 0, 0, + 321, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1140, 1141, 0, 0, + 0, 0, 363, 381, 0, 0, 0, 281, 282, 996, + 283, 0, 1150, 44, 769, 0, 0, 0, 0, 0, + 0, 110, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1166, 0, 284, 0, 0, 0, + 0, 0, 285, 0, 0, 1181, 286, 0, 0, 287, + 288, 289, 290, 41, 42, 0, 291, 292, 0, 0, + 0, 0, 341, 0, 293, 281, 282, 381, 283, 1199, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, + 0, 378, 0, 363, 996, 996, 0, 0, 296, 380, + 298, 299, 300, 301, 284, 0, 0, 0, 0, 0, + 285, 0, 0, 0, 286, 1231, 0, 287, 288, 289, + 290, 41, 42, 0, 291, 292, 0, 0, 0, 0, + 0, 0, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 363, 363, 0, 0, 0, 294, 0, 378, + 0, 0, 0, 0, 0, 0, 296, 734, 298, 299, + 300, 301, 0, 996, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 889, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1284, 1285, 0, + 0, 0, 0, 0, 0, 1, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 29, 0, 0, 30, 281, + 282, 31, 1062, 1063, 0, 1064, 0, 0, 1065, 1066, + 1067, 1068, 1069, 1070, 1071, 1072, 0, 0, 0, 1073, + 0, 0, 0, 1074, 1075, 0, 33, 363, 284, 34, + 0, 35, 0, 36, 649, 0, 38, 39, 286, 996, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 1076, 0, 0, 170, 0, 0, 0, + 296, 297, 298, 299, 300, 301, 0, 0, 0, 0, + 1077, 0, 0, 0, -129, 0, 0, 0, 0, 0, + 1392, 0, 769, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 413, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 413, 413, 0, 0, 0, 31, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 413, 0, 0, + 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, + 0, 0, 206, 39, 0, 0, 0, 0, 1452, 0, + 0, 0, 0, 0, 0, 1, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 29, 0, 629, 30, 281, + 282, 31, 283, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 0, 0, 284, 34, + 0, 35, 31, 36, 285, 0, 38, 39, 286, 0, + 1518, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 34, 0, 0, 0, 0, 109, 0, 38, 39, 0, + 0, 294, 0, 1076, 0, 0, 41, 42, 0, 0, + 296, 297, 298, 299, 300, 301, 0, 0, 0, 0, + 0, 0, 321, 0, -129, 1, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 29, 0, 0, 30, 281, + 282, 31, 283, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 0, 0, 284, 34, + 0, 35, 31, 36, 285, 0, 38, 39, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 34, 0, 0, 0, 0, 0, 0, 206, 39, 0, + 0, 294, 0, 44, 0, 0, 0, 0, 0, 0, + 296, 297, 298, 299, 300, 301, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 281, + 282, 31, 283, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 284, 34, + 0, 35, 0, 36, 285, 0, 38, 39, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 343, 0, 0, 0, 0, 781, 0, + 296, 344, 298, 299, 300, 301, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 281, + 282, 31, 283, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 284, 34, + 0, 35, 0, 36, 285, 0, 38, 39, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 931, 0, 0, 0, 0, 781, 0, + 296, 344, 298, 299, 300, 301, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 281, + 282, 31, 283, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 284, 34, + 0, 35, 0, 36, 285, 0, 38, 39, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 931, 0, 0, 0, 0, 781, 0, + 296, 600, 298, 299, 300, 301, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 281, + 282, 31, 283, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 284, 34, + 0, 35, 0, 36, 285, 0, 38, 39, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 343, 0, 0, 0, 0, 0, 0, + 296, 344, 298, 299, 300, 301, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 281, + 282, 31, 283, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 284, 34, + 0, 35, 0, 36, 285, 0, 38, 39, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 931, 0, 0, 0, 0, 0, 0, + 296, 344, 298, 299, 300, 301, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 281, + 282, 31, 283, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 284, 34, + 0, 35, 0, 36, 285, 0, 206, 39, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 1020, 0, 0, 0, 0, 0, 0, + 296, 1021, 298, 299, 300, 301, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 281, + 282, 31, 283, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 284, 34, + 0, 35, 0, 36, 285, 0, 206, 39, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 378, 0, 0, 0, 0, 0, 0, + 296, 380, 298, 299, 300, 301, 204, 2, 205, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, + 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 34, 0, 35, 0, 36, 0, 0, 206, 39, 0, + 2, 205, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, + 0, 0, 0, 0, 207, 31, 0, 0, 0, 0, + 0, 0, 270, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 34, 0, 35, 0, 36, 37, 0, + 206, 39, 40, 0, 0, 0, 0, 0, 0, 41, + 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 43, 0, 207, 0, 0, + 0, 0, 0, 0, 0, 208, 2, 205, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 0, + 0, 31, 0, 0, 0, 0, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 34, + 0, 35, 0, 36, 0, 31, 38, 39, 0, 2, + 205, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 34, 0, 26, 27, 28, 109, 0, + 38, 39, -402, 687, 31, 0, 0, 0, 0, 41, + 42, 634, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 34, 0, 35, 0, 36, 44, 0, 38, + 39, 0, 0, 0, 0, 110, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1371, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 687, 0, 0, 0, + 0, 0, 0, 0, 634, 2, 205, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 0, 0, 0, 0, 0, 0, + 31, 0, 0, 0, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -294, 0, 26, 27, 28, 34, 0, + 35, 0, 36, 0, 31, 38, 39, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1373, 0, 0, + 0, 0, 34, 0, 0, 0, 0, 37, 0, 336, + 337, 40, 687, -294, 0, 0, 0, 0, 41, 42, + 634, 2, 205, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 338, 26, 27, 28, + 0, 0, 0, 0, 110, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 34, 0, 35, 0, 36, 0, + 0, 206, 39, 0, 2, 205, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, + 26, 27, 28, 0, 0, 0, 0, 0, 269, 31, + 0, 0, 0, 0, 0, 0, 629, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, + 0, 36, 0, 0, 38, 39, 0, 2, 205, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, + 0, 687, 31, 0, 0, 0, 0, 0, 0, 634, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 34, 0, 35, 0, 36, 0, 0, 38, 39, 0, + 2, 205, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, + 0, 0, 0, 0, 599, 31, 0, 0, 0, 0, + 0, 0, 634, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 34, 0, 35, 0, 36, 0, 0, + 206, 39, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 281, + 282, 31, 283, 0, 0, 0, 0, 207, 0, 0, + 0, 0, 0, 0, 0, 270, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 284, 34, + 0, 0, 0, 0, 285, 0, 38, 39, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 525, 0, 0, 170, 0, 0, 0, + 296, 297, 298, 299, 300, 301, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, + 0, 0, 0, 281, 282, 31, 283, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, + 0, 0, 284, 34, 0, 0, 31, 0, 285, 0, + 38, 39, 286, 0, 0, 287, 288, 289, 290, 41, + 42, 0, 291, 292, 0, 0, 0, 0, 0, 0, + 293, 0, 0, 0, 34, 0, 0, 0, 0, 37, + 0, 336, 337, 40, 0, 294, 0, 599, -3, 0, + 41, 42, 0, 0, 296, 600, 298, 299, 300, 301, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 338, 0, + 26, 27, 28, 0, 0, 0, 110, 281, 282, 31, + 283, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 0, 0, 284, 34, 0, 0, + 31, 453, 649, 0, 38, 39, 286, 0, 0, 287, + 288, 289, 290, 41, 42, 0, 291, 292, 0, 0, + 0, 0, 0, 0, 293, 0, 0, 0, 34, 0, + 0, 0, 0, 0, 0, 38, 39, 0, 0, 294, + -35, 766, 0, 0, 0, 0, 0, 0, 296, 297, + 298, 299, 300, 301, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 454, 0, 26, 27, 28, 0, 0, 0, + 110, 281, 282, 31, 283, 0, 0, 0, 0, 0, 0, 0, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, - 353, 25, 26, 27, 0, 0, 1572, 1573, 0, 1156, - 30, 452, 0, 0, 1576, 1577, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1168, 351, 351, 0, 351, - 351, 222, 0, 0, 0, 0, 0, 0, 33, 0, - 0, 0, 0, 0, 0, 37, 38, 0, 0, 72, - 0, 0, 0, 353, 353, 0, 353, 353, 223, 8, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 284, 34, 26, 27, 28, 0, 285, 0, 38, 39, + 286, 31, 0, 287, 288, 289, 290, 41, 42, 0, + 291, 292, 0, 0, 0, 0, 0, 0, 293, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, + 0, 0, 0, 294, 0, 295, 38, 39, 0, 0, + 0, 0, 296, 297, 298, 299, 300, 301, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 643, 0, 338, 0, 281, 282, 31, 283, 0, + 0, 110, 0, 0, 0, 0, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 284, 34, 26, 27, 28, 0, + 285, 0, 38, 39, 286, 31, 0, 287, 288, 289, + 290, 41, 42, 0, 291, 292, 0, 0, 0, 0, + 0, 0, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 34, 0, 0, 0, 294, 0, 156, + 38, 39, 0, 0, 0, 0, 296, 297, 298, 299, + 300, 301, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 643, 0, 338, 0, 281, + 282, 31, 283, 0, 0, 634, 0, 0, 0, 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 284, 34, + 26, 27, 28, 0, 285, 0, 38, 39, 286, 31, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, + 0, 294, 0, 599, 38, 39, 0, 0, 0, 0, + 296, 600, 298, 299, 300, 301, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, + 0, 256, 0, 281, 282, 31, 283, 0, 0, 110, + 0, 0, 0, 0, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 284, 34, 26, 27, 28, 0, 285, 0, + 38, 39, 286, 31, 0, 287, 288, 289, 290, 41, + 42, 0, 291, 292, 0, 0, 0, 0, 0, 0, + 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 34, 0, 0, 0, 294, 0, 378, 38, 39, + 0, 0, 0, 0, 296, 380, 298, 299, 300, 301, + 474, 2, 205, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 156, 0, 26, 27, 28, + 0, 0, 0, 110, 0, 0, 31, 0, 0, 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, + 26, 27, 28, 0, 34, 0, 35, 0, 36, 31, + 0, 38, 39, 0, 0, 0, 0, 0, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 34, 26, 27, + 28, 0, 37, 0, 38, 39, 40, 31, 0, 0, + 0, -3, 0, 41, 42, 0, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 34, 26, 27, 28, 43, + 37, 156, 38, 39, 40, 31, 0, 0, 0, 45, + 0, 41, 42, 0, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 34, 26, 27, 28, 43, 37, 44, + 206, 39, 40, 31, 0, 0, 0, 45, 0, 41, + 42, 0, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + -294, 34, 26, 27, 28, 43, 37, 269, 336, 337, + 40, 31, 0, 0, 0, 208, 0, 41, 42, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, + 0, 0, 0, 643, 0, 338, 38, 39, 0, 0, + -294, 0, 0, 634, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, + 0, 643, 0, 338, 31, 453, 0, 0, 0, 0, + 0, 634, 0, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, -294, 34, 26, 27, 28, 0, 0, 0, 38, + 39, 0, 31, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, + 34, 0, 31, 453, 0, 0, 454, 38, 39, 0, + 711, -294, 0, 0, 110, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 34, 0, 0, 0, 0, 0, 0, 38, 39, 0, + 0, 0, 0, 0, 338, 0, 0, 0, 0, 0, + 0, 0, 110, 0, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 454, 26, 27, 28, 1109, 0, + 0, 0, 110, 0, 31, 453, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, + 0, 0, 34, 0, 0, 31, 0, 0, 0, 38, + 39, 0, 0, 0, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 34, 26, 27, 28, 0, 0, 0, + 206, 39, 0, 31, 0, 0, 454, 0, 0, 0, + 1236, 0, 0, 0, 110, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 34, 0, 0, 0, 0, 0, 269, 38, 39, + 0, 0, 0, 0, 0, 270, 0, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, + 0, 0, 0, 0, 0, 256, 31, 0, 0, 0, + 0, 0, 0, 634, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 34, 26, 27, 28, 0, 0, + 0, 38, 39, 0, 31, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, + 0, 0, 34, 0, 31, 0, 0, 0, 338, 38, + 39, 0, 0, 0, 0, 0, 634, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 206, + 39, 0, 0, 0, 0, 0, 454, 0, 0, 0, + 0, 0, 0, 0, 110, 0, 0, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 269, 26, 27, 28, + 0, 0, 0, 0, 629, 0, 31, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, + 0, 0, 0, 0, 34, 0, 31, 0, 0, 0, + 0, 38, 39, 0, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 34, 26, 27, 28, 0, 0, + 0, 38, 39, 0, 31, 0, 0, 0, 599, 0, + 0, 0, 0, 0, 0, 0, 634, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 34, 0, 0, 0, 0, 0, 338, 38, + 39, 0, 0, 0, 0, 0, 110, 2, 205, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 44, 0, 0, 0, + 0, 0, 31, 0, 110, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 34, 0, 35, 0, 36, 0, 0, 38, 39, 281, + 282, 0, 283, 1063, 0, 1064, 0, 0, 1065, 1066, + 1067, 1068, 1069, 1070, 1071, 1072, 0, 0, 1551, 1073, + 0, 0, 0, 1074, 1075, 0, 33, 0, 284, 0, + 0, 0, 0, -415, 649, 0, 0, 0, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 0, 291, 292, + 0, 0, 0, 0, 0, 0, 293, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 378, 0, 0, 170, 0, 0, 0, + 296, 380, 298, 299, 300, 301, 0, 0, 0, 0, + 1077, 0, 281, 282, -129, 283, 1063, 0, 1064, 0, + 0, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 0, + 0, 0, 1073, 0, 0, 0, 1074, 1075, 0, 33, + 0, 284, 0, 0, 0, 0, 0, 649, 0, 0, + 0, 286, 0, 0, 287, 288, 289, 290, 41, 42, + 0, 291, 292, 0, 0, 0, 0, 0, 0, 293, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 378, 0, 0, 170, + 0, 0, 0, 296, 380, 298, 299, 300, 301, 0, + 0, 0, 0, 1077, 0, 0, 0, -129, 2, 205, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 0, 26, 27, 28, 0, 0, 0, + 0, 0, 0, 31, 0, 281, 282, 0, 283, 1063, + 0, 1064, 1421, 1422, 1065, 1066, 1067, 1068, 1069, 1070, + 1071, 1072, 0, 0, 1551, 1073, 0, 0, 0, 1074, + 1075, 34, 33, 35, 284, 36, 0, 0, 38, 39, + 649, 0, 0, 0, 286, 0, 0, 287, 288, 289, + 290, 41, 42, 0, 291, 292, 0, 0, 0, 0, + 1330, 0, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 294, 0, 378, + 0, 0, 170, 0, 0, 0, 296, 380, 298, 299, + 300, 301, 0, 0, 281, 282, 1077, 283, 1063, 0, + 1064, 1421, 1422, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 0, 0, 0, 1073, 0, 0, 0, 1074, 1075, + 0, 33, 0, 284, 0, 0, 0, 0, 0, 649, + 0, 0, 0, 286, 0, 0, 287, 288, 289, 290, + 41, 42, 0, 291, 292, 0, 0, 0, 0, 0, + 0, 293, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 294, 0, 378, 0, + 0, 170, 0, 0, 0, 296, 380, 298, 299, 300, + 301, 0, 0, 281, 282, 1077, 283, 1063, 0, 1064, + 0, 0, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, + 0, 0, 0, 1073, 0, 0, 0, 1074, 1075, 0, + 33, 0, 284, 0, 0, 0, 0, 0, 649, 0, + 0, 0, 286, 0, 0, 287, 288, 289, 290, 41, + 42, 0, 291, 292, 0, 0, 0, 0, 0, 0, + 293, 281, 282, 0, 283, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 294, 0, 378, 0, 0, + 170, 0, 0, 0, 296, 380, 298, 299, 300, 301, + 284, 0, 0, 0, 1077, 0, 649, 0, 0, 0, + 286, 0, 0, 287, 288, 289, 290, 41, 42, 0, + 291, 292, 0, 0, 0, 0, 0, 0, 293, 281, + 282, 0, 283, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 294, 0, 785, 0, 0, 281, 282, + 0, 283, 296, 380, 298, 299, 300, 301, 284, 0, + 0, 0, 0, 0, 285, 0, 0, 0, 286, 0, + 0, 287, 288, 289, 290, 41, 42, 284, 291, 292, + 0, 0, 0, 285, 0, 0, 293, 286, 0, 0, + 287, 288, 289, 290, 41, 42, 0, 291, 292, 0, + 0, 294, 0, 378, 0, 293, 281, 282, 0, 283, + 296, 827, 298, 299, 300, 301, 0, 0, 0, 0, + 513, 0, 0, 0, 0, 281, 282, 0, 283, 296, + 380, 298, 299, 300, 301, 284, 0, 0, 0, 0, + 0, 285, 0, 0, 0, 286, 0, 0, 287, 288, + 289, 290, 41, 42, 284, 291, 292, 0, 0, 0, + 285, 0, 0, 293, 286, 0, 0, 287, 288, 289, + 290, 41, 42, 0, 291, 292, 0, 0, 294, 0, + 0, 0, 293, 281, 282, 0, 283, 296, 380, 298, + 299, 300, 301, 0, 0, 0, 0, 518, 0, 0, + 0, 0, 0, 0, 0, 0, 296, 380, 298, 299, + 300, 301, 284, 0, 0, 0, 0, 0, 285, 0, + 0, 0, 286, 0, 0, 287, 288, 289, 290, 41, + 42, 0, 291, 292, 0, 0, 0, 0, 0, 0, + 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 521, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 380, 298, 299, 300, 301, + 2, 205, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 34, 0, 35, 0, 36, 37, 0, + 173, 174, 40, 0, 0, 0, 0, 0, 0, 41, + 42, 204, 2, 205, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 0, 0, 0, 0, 0, 31, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, + 0, 0, 206, 39, 474, 2, 205, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 0, 0, 0, 0, 0, 0, + 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, + 35, 0, 36, 0, 0, 38, 39, 2, 205, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, + 0, 0, 31, 0, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 0, 26, 27, 28, 492, 493, 494, + 34, 0, 35, 31, 36, 0, 0, 206, 39, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 34, 0, 0, 0, 0, 0, 0, 38, 39 +}; + +#define yypact_value_is_default(yystate) \ + ((yystate) == (-1332)) + +#define yytable_value_is_error(yytable_value) \ + YYID (0) + +static const yytype_int16 yycheck[] = +{ + 0, 1, 0, 203, 184, 184, 520, 698, 238, 43, + 115, 184, 1, 698, 43, 43, 543, 185, 629, 0, + 104, 218, 184, 280, 185, 456, 455, 698, 348, 29, + 30, 184, 32, 184, 32, 1062, 184, 902, 167, 168, + 609, 348, 1, 43, 656, 45, 278, 45, 1043, 611, + 1006, 32, 1042, 1043, 32, 55, 497, 0, 759, 611, + 28, 61, 612, 61, 64, 609, 64, 67, 618, 67, + 154, 609, 499, 579, 1340, 718, 503, 999, 67, 609, + 609, 81, 82, 780, 264, 264, 777, 51, 186, 32, + 1421, 264, 777, 609, 82, 200, 1425, 265, 344, 1055, + 529, 39, 264, 902, 265, 105, 777, 0, 108, 39, + 78, 264, 417, 264, 609, 115, 264, 0, 43, 72, + 43, 45, 363, 643, 644, 645, 367, 489, 44, 45, + 83, 84, 437, 64, 0, 43, 82, 39, 227, 32, + 445, 39, 662, 44, 45, 109, 146, 95, 146, 32, + 184, 0, 1, 39, 154, 184, 184, 246, 111, 159, + 63, 159, 260, 261, 1495, 111, 32, 44, 45, 1477, + 109, 64, 613, 111, 85, 495, 617, 1443, 109, 109, + 30, 111, 130, 32, 184, 185, 110, 185, 4, 5, + 6, 7, 8, 9, 1523, 109, 39, 638, 114, 1528, + 200, 642, 113, 255, 1512, 39, 1514, 109, 208, 111, + 208, 294, 409, 114, 744, 64, 736, 217, 67, 1548, + 220, 145, 220, 109, 902, 111, 1555, 227, 744, 132, + 264, 81, 82, 96, 82, 264, 264, 405, 115, 11, + 644, 645, 242, 489, 405, 82, 246, 109, 1243, 744, + 250, 251, 250, 69, 511, 71, 112, 341, 662, 184, + 123, 184, 110, 1062, 264, 265, 109, 265, 111, 250, + 839, 271, 250, 0, 1, 109, 184, 111, 278, 1306, + 117, 643, 644, 645, 208, 928, 370, 455, 0, 851, + 395, 841, 251, 293, 455, 839, 114, 107, 1293, 851, + 662, 839, 1292, 1293, 611, 32, 3, 250, 828, 839, + 839, 82, 1009, 819, 238, 110, 132, 116, 423, 487, + 32, 131, 117, 839, 429, 116, 487, 220, 328, 116, + 328, 43, 736, 45, 293, 697, 82, 1259, 109, 951, + 67, 132, 425, 426, 839, 132, 270, 347, 348, 61, + 425, 426, 64, 116, 600, 67, 597, 250, 699, 55, + 90, 91, 1227, 109, 364, 417, 72, 250, 368, 132, + 1071, 220, 255, 297, 736, 1074, 1075, 83, 84, 379, + 721, 109, 110, 629, 250, 437, 691, 1065, 634, 255, + 959, 96, 242, 445, 109, 395, 126, 127, 960, 640, + 110, 250, 72, 109, 3, 405, 116, 405, 82, 105, + 1021, 773, 108, 83, 84, 959, 131, 116, 123, 676, + 344, 959, 1417, 423, 828, 109, 501, 1417, 1227, 429, + 513, 431, 873, 68, 146, 518, 110, 72, 521, 1466, + 75, 1528, 77, 117, 1143, 520, 1473, 159, 532, 84, + 1528, 697, 72, 1409, 1410, 455, 349, 121, 122, 72, + 460, 1548, 132, 83, 84, 109, 828, 111, 1555, 116, + 83, 84, 184, 185, 474, 119, 110, 1555, 116, 479, + 1030, 1031, 699, 117, 112, 132, 0, 487, 116, 487, + 1004, 491, 575, 491, 132, 495, 208, 131, 498, 1526, + 500, 425, 426, 0, 721, 762, 119, 1306, 220, 938, + 491, 586, 132, 88, 89, 474, 947, 946, 698, 698, + 520, 217, 131, 250, 965, 698, 758, 773, 657, 379, + 1142, 851, 700, 80, 417, 109, 698, 537, 250, 700, + 540, 968, 542, 543, 851, 698, 72, 698, 491, 1227, + 698, 417, 264, 116, 437, 1117, 109, 83, 84, 664, + 110, 520, 445, 992, 111, 109, 113, 117, 666, 132, + 117, 437, 115, 116, 110, 271, 211, 501, 537, 445, + 116, 540, 278, 542, 543, 111, 109, 480, 131, 830, + 590, 116, 3, 834, 109, 812, 520, 597, 491, 10, + 11, 12, 13, 14, 109, 1306, 489, 132, 491, 609, + 460, 611, 696, 116, 53, 72, 328, 598, 116, 4, + 5, 6, 7, 8, 9, 491, 83, 84, 39, 132, + 630, 590, 110, 116, 132, 119, 348, 978, 116, 691, + 124, 125, 491, 112, 964, 1323, 646, 116, 498, 132, + 500, 347, 652, 116, 111, 110, 67, 96, 0, 1, + 1498, 661, 586, 663, 664, 665, 1504, 1466, 364, 132, + 80, 1102, 368, 890, 1473, 129, 600, 131, 116, 116, + 1042, 733, 1383, 924, 69, 72, 71, 1525, 772, 110, + 32, 888, 1530, 405, 132, 132, 83, 84, 698, 1377, + 700, 111, 1380, 113, 663, 629, 665, 117, 112, 109, + 634, 111, 909, 713, 116, 110, 351, 112, 353, 719, + 110, 116, 64, 723, 111, 67, 116, 1526, 110, 110, + 132, 731, 45, 110, 116, 116, 131, 132, 631, 109, + 970, 111, 110, 455, 744, 745, 112, 1425, 61, 119, + 116, 64, 1430, 192, 67, 112, 72, 110, 758, 116, + 76, 978, 72, 116, 491, 894, 76, 83, 84, 1470, + 938, 1472, 731, 83, 84, 1021, 215, 938, 946, 491, + 112, 110, 1460, 495, 116, 946, 225, 10, 11, 12, + 13, 14, 1009, 109, 1135, 1322, 92, 93, 110, 109, + 1162, 111, 652, 119, 116, 110, 441, 72, 691, 119, + 109, 116, 111, 155, 697, 109, 39, 111, 83, 84, + 10, 11, 12, 13, 14, 691, 1527, 109, 109, 111, + 513, 724, 515, 146, 1034, 518, 1133, 119, 521, 839, + 1137, 1532, 1059, 110, 67, 738, 159, 1532, 109, 39, + 733, 851, 1193, 1194, 835, 294, 115, 116, 110, 110, + 110, 1532, 1103, 713, 116, 116, 116, 733, 1546, 719, + 116, 117, 185, 723, 1552, 115, 1133, 67, 220, 109, + 1137, 1138, 109, 110, 111, 1563, 109, 132, 111, 1567, + 773, 703, 110, 705, 894, 208, 119, 609, 116, 611, + 72, 901, 902, 110, 76, 110, 111, 220, 250, 116, + 64, 83, 84, 110, 1, 109, 1162, 111, 1135, 116, + 72, 902, 74, 75, 924, 85, 86, 87, 1057, 109, + 1292, 83, 84, 72, 630, 74, 75, 109, 938, 832, + 58, 59, 110, 902, 83, 84, 946, 119, 116, 109, + 646, 111, 109, 113, 114, 110, 112, 109, 45, 132, + 110, 116, 114, 110, 964, 661, 116, 115, 116, 116, + 109, 114, 109, 680, 111, 114, 1193, 1194, 114, 72, + 969, 74, 75, 76, 984, 109, 698, 111, 700, 114, + 83, 84, 109, 993, 111, 109, 1253, 1243, 109, 110, + 111, 1001, 132, 442, 1004, 109, 1006, 111, 82, 902, + 72, 132, 74, 75, 109, 328, 109, 104, 111, 902, + 1125, 83, 84, 110, 117, 984, 119, 72, 109, 74, + 75, 82, 744, 745, 116, 117, 902, 476, 83, 84, + 112, 109, 1001, 111, 894, 1004, 970, 1006, 109, 110, + 111, 901, 114, 902, 120, 1055, 116, 117, 145, 109, + 110, 111, 758, 1404, 128, 1065, 111, 154, 1068, 1069, + 1070, 58, 59, 60, 513, 1265, 1266, 1267, 1507, 518, + 1421, 1062, 521, 72, 1341, 74, 75, 76, 1345, 129, + 432, 94, 405, 1093, 83, 84, 1055, 1021, 44, 45, + 10, 11, 12, 13, 14, 131, 1065, 111, 815, 1068, + 1069, 1070, 564, 565, 566, 567, 109, 204, 825, 109, + 969, 208, 110, 1206, 1207, 1125, 1209, 839, 1557, 39, + 112, 1024, 1215, 840, 72, 1218, 74, 75, 1222, 851, + 560, 561, 112, 993, 110, 83, 84, 562, 563, 491, + 110, 238, 239, 1494, 1495, 110, 72, 67, 74, 75, + 76, 110, 72, 110, 74, 75, 76, 83, 84, 1062, + 568, 569, 109, 83, 84, 902, 112, 111, 131, 1062, + 112, 114, 109, 270, 114, 116, 273, 1404, 114, 112, + 1447, 533, 110, 109, 45, 111, 1062, 110, 112, 109, + 1200, 111, 117, 119, 1421, 112, 112, 294, 112, 119, + 297, 29, 117, 1062, 117, 116, 1205, 110, 110, 114, + 117, 112, 1222, 110, 132, 115, 938, 1227, 3, 115, + 115, 109, 116, 110, 946, 10, 11, 12, 13, 14, + 679, 110, 969, 1093, 116, 110, 1227, 117, 110, 688, + 110, 110, 964, 692, 341, 116, 598, 344, 1247, 110, + 110, 110, 3, 110, 39, 1265, 1266, 1267, 1227, 10, + 11, 12, 13, 14, 110, 110, 363, 1494, 1495, 1162, + 367, 110, 110, 370, 10, 11, 12, 13, 14, 110, + 110, 110, 67, 110, 110, 1400, 1379, 110, 39, 29, + 115, 643, 644, 645, 131, 112, 1265, 1266, 1267, 110, + 110, 1204, 1542, 39, 110, 110, 114, 116, 112, 112, + 662, 110, 1322, 1323, 110, 1306, 67, 110, 116, 110, + 117, 116, 1039, 1040, 1227, 1062, 116, 116, 425, 426, + 112, 67, 116, 110, 1227, 110, 112, 85, 86, 87, + 1200, 1340, 1532, 1532, 109, 1204, 1205, 208, 109, 1532, + 1243, 1227, 109, 1322, 1323, 1533, 453, 109, 112, 456, + 1532, 109, 1533, 111, 109, 113, 114, 1377, 1227, 1532, + 1380, 1532, 132, 109, 1532, 111, 117, 474, 239, 1557, + 1097, 1098, 115, 119, 736, 110, 1557, 110, 1247, 1399, + 1400, 115, 1507, 110, 129, 115, 114, 112, 1301, 1409, + 1410, 132, 499, 1306, 501, 110, 503, 116, 1377, 270, + 112, 1380, 116, 1306, 112, 1425, 513, 110, 515, 110, + 1430, 518, 110, 520, 521, 112, 471, 112, 112, 110, + 1306, 47, 112, 294, 112, 532, 297, 112, 1448, 115, + 1409, 1410, 1301, 132, 1443, 110, 132, 1306, 115, 132, + 1460, 117, 110, 132, 115, 132, 1425, 112, 112, 112, + 112, 1430, 72, 112, 74, 75, 76, 112, 1205, 112, + 112, 110, 110, 83, 84, 1466, 828, 926, 112, 1448, + 112, 1340, 1473, 835, 0, 1, 109, 109, 1532, 586, + 1227, 1460, 109, 1532, 1532, 60, 110, 1507, 1508, 109, + 597, 111, 55, 600, 110, 114, 132, 1517, 112, 119, + 1247, 112, 117, 1523, 110, 112, 32, 110, 1528, 96, + 96, 109, 1532, 1533, 109, 1533, 115, 110, 112, 45, + 132, 110, 629, 42, 116, 1526, 1546, 634, 1548, 1508, + 110, 110, 1552, 640, 117, 1555, 132, 1557, 1517, 1557, + 902, 67, 105, 1563, 1523, 108, 1273, 1567, 132, 1528, + 110, 110, 96, 1466, 1281, 1282, 1283, 96, 132, 1306, + 1473, 110, 110, 1466, 132, 117, 132, 1546, 110, 1548, + 1473, 112, 110, 1552, 1443, 115, 1555, 132, 104, 112, + 1466, 109, 453, 115, 1563, 456, 132, 1473, 1567, 696, + 115, 154, 110, 1340, 64, 110, 132, 1466, 1542, 110, + 110, 1077, 1329, 571, 1473, 570, 1227, 969, 572, 64, + 64, 718, 573, 1526, 1073, 574, 1495, 1385, 1567, 74, + 146, 1316, 1138, 1526, 986, 680, 1473, 81, 154, 155, + 1345, 1093, 705, 946, 4, 5, 6, 7, 8, 9, + 1526, 748, 513, 453, 515, 471, 116, 518, 723, 453, + 521, 948, 993, 590, 217, 894, 966, 1526, 658, 185, + 1247, 116, 116, 33, 578, 772, 491, 758, 10, 11, + 12, 13, 14, -1, 200, 578, 748, 203, 204, 578, + 1042, 1043, 208, 1399, -1, -1, -1, -1, -1, 159, + -1, -1, -1, -1, -1, -1, 1443, 39, -1, 69, + 1062, 71, -1, 229, 159, 159, -1, 233, 271, 235, + 72, -1, 74, 75, 76, 278, -1, -1, 244, 1466, + -1, 83, 84, 830, 250, 67, 1473, 834, -1, 255, + 72, -1, 74, 75, 76, -1, -1, -1, -1, 265, + -1, 83, 84, -1, -1, -1, -1, 273, 283, -1, + 220, -1, -1, -1, -1, -1, 26, 27, 28, -1, + 815, 296, 297, -1, -1, 220, 220, 109, -1, 111, + 825, -1, -1, 308, -1, -1, -1, 119, -1, 1526, + -1, -1, -1, -1, 347, 840, -1, -1, 258, -1, + -1, -1, 262, 10, 11, 12, 13, 14, -1, -1, + 1532, 364, -1, 258, 258, 368, -1, 262, 262, 344, + -1, -1, -1, -1, -1, 341, -1, 924, 344, -1, + -1, 928, 39, 278, 350, -1, -1, 97, -1, 99, + -1, -1, -1, -1, -1, -1, -1, 363, -1, -1, + 947, 367, 1204, 1205, 370, 380, -1, 718, -1, -1, + 67, -1, -1, -1, 680, 72, 1315, 74, 75, 76, + -1, 968, 969, 970, -1, 1227, 83, 84, 431, -1, + 72, -1, 74, 75, 76, -1, -1, -1, -1, 349, + -1, 83, 84, -1, -1, 1247, 72, -1, 74, 75, + 76, 417, 109, -1, 349, 349, -1, 83, 84, -1, + -1, 72, 119, 74, 75, 76, 432, 109, -1, 111, + 180, 437, 83, 84, 1021, -1, -1, 119, -1, 445, + 190, 191, -1, 109, -1, 195, -1, 197, 198, -1, + 1292, 1293, -1, 119, -1, -1, -1, -1, 109, 1301, + -1, -1, -1, -1, 1306, 471, -1, -1, 474, -1, + 51, -1, 53, -1, -1, 56, 57, 58, -1, 60, + 430, -1, -1, 489, -1, 491, -1, -1, -1, -1, + -1, -1, -1, 499, 75, 430, 430, 503, 1340, 10, + 11, 12, 13, 14, 1039, 1040, 87, 88, -1, 815, + -1, -1, 447, -1, -1, 1102, 1103, -1, -1, 825, + 72, -1, 74, 75, 76, -1, 532, 533, 39, -1, + 480, 83, 84, -1, 840, 1474, -1, 1476, -1, -1, + -1, -1, 557, 558, 559, 480, 480, 72, -1, 74, + 75, 76, -1, -1, 597, -1, 67, 109, 83, 84, + -1, -1, 1097, 1098, -1, -1, -1, 119, -1, -1, + -1, -1, 1511, 579, 1513, 1417, -1, 928, -1, -1, + -1, -1, -1, -1, 109, 600, -1, 630, -1, -1, + -1, 597, 598, -1, 600, -1, 947, -1, 109, -1, + 111, 1443, -1, 646, -1, 611, -1, -1, 119, -1, + -1, -1, -1, -1, -1, -1, -1, 1556, 661, 1558, + -1, -1, -1, 629, 1466, -1, -1, -1, 634, -1, + -1, 1473, 1571, 1572, 640, 1222, -1, 643, 644, 645, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 0, -1, -1, 603, -1, -1, 662, -1, -1, -1, + 1247, -1, -1, -1, -1, -1, -1, -1, 603, 603, + -1, -1, -1, -1, 680, -1, -1, -1, -1, -1, + -1, 631, 32, -1, 1526, 691, 636, -1, -1, -1, + 696, 697, -1, -1, 700, -1, 631, 631, -1, -1, + -1, 636, 636, -1, -1, -1, 1241, -1, -1, -1, + -1, -1, -1, -1, -1, 758, -1, 67, -1, 734, + -1, -1, -1, -1, -1, -1, -1, 733, -1, -1, + 736, -1, -1, 1039, 1040, -1, -1, -1, 1273, 745, + -1, -1, 748, -1, -1, -1, 1281, 1282, 1283, -1, + -1, 1102, -1, 1340, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 344, 345, 780, 772, 773, -1, -1, + -1, -1, 778, -1, 724, 356, 357, -1, -1, 26, + 27, 28, -1, -1, -1, -1, -1, -1, 738, 724, + 724, 1097, 1098, -1, 1329, -1, -1, -1, -1, -1, + -1, -1, -1, 738, 738, 155, -1, -1, -1, 815, + -1, -1, 827, -1, -1, -1, -1, -1, -1, 825, + -1, -1, 828, 758, 830, -1, -1, 833, 834, 835, + -1, -1, 582, 583, 840, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 850, -1, -1, -1, -1, -1, + 97, -1, 99, -1, -1, -1, 1443, 10, 11, 12, + 13, 14, 612, -1, -1, 615, 616, -1, 618, -1, + 620, 621, -1, -1, -1, 625, 626, 124, -1, 229, + -1, 924, 832, -1, -1, -1, 39, -1, 1475, -1, + 1477, -1, -1, -1, -1, -1, 902, 832, 832, -1, + 250, -1, -1, -1, -1, 255, 188, -1, -1, -1, + -1, -1, -1, 195, 67, -1, -1, -1, 924, 72, + -1, 74, 75, 76, -1, 1512, -1, 1514, -1, -1, + 83, 84, -1, 180, -1, 1241, -1, -1, -1, -1, + -1, 188, -1, 190, 191, -1, -1, -1, 195, -1, + 197, 198, -1, -1, 960, 1542, 109, -1, 111, 709, + 710, -1, 968, 969, -1, 715, 119, 1273, -1, 10, + 11, 12, 13, 14, -1, 1281, 1282, 1283, -1, -1, + 986, -1, -1, -1, -1, 267, -1, -1, -1, 10, + 11, 12, 13, 14, -1, -1, -1, -1, 39, -1, + 350, -1, -1, -1, -1, -1, 1021, -1, -1, -1, + -1, -1, -1, -1, -1, 1021, -1, -1, 39, -1, + 267, -1, -1, 1329, -1, -1, 67, -1, 1034, -1, + -1, 72, -1, 1039, 1040, 76, 1042, 1043, -1, -1, + -1, 323, 83, 84, -1, -1, 67, 1062, -1, 331, + -1, 72, 334, 74, 75, 76, 1062, -1, -1, -1, + -1, -1, 83, 84, -1, -1, -1, 417, 109, -1, + -1, 0, -1, -1, 1024, -1, -1, -1, 119, -1, + -1, -1, 432, -1, -1, -1, -1, 437, 109, 1024, + 1024, 1097, 1098, -1, -1, 445, -1, 1103, 119, -1, + -1, -1, -1, 32, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 397, -1, -1, -1, 401, + -1, 471, -1, -1, 1475, -1, 1477, -1, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 67, 489, + -1, 491, -1, -1, 725, -1, 727, -1, -1, -1, + -1, -1, -1, 734, 735, -1, 1162, -1, 739, -1, + -1, 1512, 131, 1514, 1179, 10, 11, 12, 13, 14, + 751, -1, -1, -1, -1, 756, -1, -1, -1, 1222, + -1, -1, -1, 533, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 39, -1, -1, -1, -1, 1205, + -1, 782, -1, -1, 486, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1222, -1, -1, -1, + -1, 1227, 67, -1, -1, -1, 155, 72, -1, -1, + -1, 76, -1, -1, -1, 1241, -1, 1243, 83, 84, + -1, 1247, -1, -1, -1, -1, 827, -1, 598, -1, + -1, -1, -1, -1, 1204, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 109, -1, -1, 1273, -1, 1204, + 1204, -1, -1, -1, 119, 1281, 1282, 1283, -1, -1, + -1, -1, -1, -1, -1, -1, 1292, 1293, -1, -1, + -1, -1, -1, 643, 644, 645, 578, 579, -1, -1, + 1306, -1, -1, 884, 885, 886, 887, -1, 889, -1, + -1, -1, 662, -1, -1, -1, -1, -1, -1, -1, + -1, 250, -1, 1329, 905, -1, 255, -1, -1, -1, + 680, -1, -1, -1, 1340, 582, 583, -1, 919, -1, + -1, 691, -1, -1, -1, -1, -1, 697, -1, 1099, + -1, 1301, -1, -1, -1, -1, 1399, -1, -1, -1, + -1, -1, -1, -1, -1, 612, 1301, 1301, 615, 616, + -1, 618, -1, 620, 621, -1, -1, 958, 625, 626, + -1, -1, -1, 733, -1, 667, 736, -1, -1, 671, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, -1, + -1, 1417, -1, -1, -1, -1, -1, 998, -1, 39, + -1, 350, 704, 773, 1005, -1, -1, -1, -1, 1010, + -1, -1, -1, -1, 1015, -1, 1017, 1443, -1, -1, + 1021, 1022, 1023, -1, -1, 1026, -1, 67, -1, -1, + -1, -1, -1, -1, 1035, -1, -1, 704, 78, -1, + 1466, -1, 709, 710, -1, 815, -1, 1473, 715, -1, + -1, -1, 1053, 1054, 1224, 825, -1, -1, 828, -1, + -1, -1, -1, 833, -1, 835, -1, -1, 417, -1, + 840, -1, -1, -1, -1, -1, -1, -1, -1, 1080, + -1, -1, 1083, 432, -1, -1, -1, -1, 437, -1, + -1, -1, -1, -1, -1, -1, 445, -1, -1, -1, + 1526, -1, -1, -1, -1, -1, -1, 1533, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 819, -1, -1, + -1, 1122, 471, -1, -1, -1, -1, 1128, 1129, -1, + -1, -1, 902, -1, -1, -1, -1, -1, -1, 1140, + 489, -1, 491, 0, 1145, -1, -1, 1148, -1, 1150, + -1, -1, 1153, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1166, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 32, 37, 38, 1179, 40, + 1181, 1182, 1183, 1184, 533, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1197, -1, 1199, -1, + -1, -1, 1203, -1, -1, 66, -1, -1, -1, -1, + 67, 72, -1, 74, 75, 76, 986, -1, 79, 80, + 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, + 932, 1232, 1233, 94, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 109, 598, + 111, -1, 113, 114, -1, -1, -1, 118, 119, 120, + 121, 122, 123, -1, -1, -1, -1, -1, -1, 1039, + 1040, -1, 1042, 1043, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1284, 1285, -1, -1, -1, -1, -1, + -1, -1, 1062, 1294, 643, 644, 645, -1, 155, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1011, + -1, -1, -1, 662, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1027, -1, 1097, 1098, -1, + -1, 680, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 691, -1, -1, 1346, -1, -1, 697, -1, + -1, -1, -1, -1, -1, -1, -1, 1358, -1, 1360, + 1361, 1362, 37, 38, -1, 40, -1, -1, -1, -1, + -1, 1372, -1, -1, -1, -1, -1, -1, -1, -1, + 1381, -1, -1, -1, 733, -1, -1, 736, -1, -1, + -1, 66, 1162, 250, -1, -1, 1397, 72, 255, -1, + -1, 76, 1104, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, 0, 94, + -1, -1, -1, -1, 773, -1, -1, -1, -1, -1, + -1, -1, 1099, -1, 109, 1205, 111, -1, -1, 114, + -1, -1, -1, 118, 119, 120, 121, 122, 123, -1, + 32, -1, 1453, 1454, -1, -1, -1, 1227, -1, -1, + -1, -1, -1, -1, -1, 1466, 815, -1, -1, -1, + -1, 1241, 1473, 1243, -1, -1, 825, -1, -1, 828, + -1, -1, -1, -1, 833, 67, 835, -1, -1, -1, + -1, 840, -1, 350, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1273, -1, 1506, -1, -1, -1, 1510, + -1, 1281, 1282, 1283, -1, -1, -1, -1, -1, -1, + -1, -1, 1292, 1293, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1306, -1, 1539, -1, + 1541, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 902, -1, -1, -1, 1224, -1, 1329, + 417, -1, -1, -1, -1, -1, -1, -1, 1569, 1570, + -1, -1, -1, 155, -1, 432, 1577, 1578, -1, -1, + 437, -1, -1, -1, -1, -1, 0, -1, 445, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 471, -1, 30, 31, 32, 33, + -1, -1, 36, -1, -1, 39, 40, -1, -1, -1, + -1, -1, 489, -1, 491, -1, -1, 986, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1417, -1, -1, + 64, -1, -1, 67, -1, 69, -1, 71, 72, -1, + 74, 75, 76, -1, -1, -1, -1, -1, 250, 83, + 84, -1, -1, 255, -1, -1, 533, -1, 7, -1, + -1, 10, 11, 12, 13, 14, -1, -1, -1, -1, + 1039, 1040, -1, 1042, 1043, 109, 1466, 111, -1, -1, + -1, -1, -1, 1473, -1, 119, -1, -1, 37, 38, + 39, 40, -1, 1062, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, -1, -1, -1, 66, 67, -1, + -1, 598, -1, 72, 39, -1, -1, 76, 1097, 1098, + 79, 80, 81, 82, 83, 84, 1526, 86, 87, -1, + -1, -1, -1, -1, -1, 94, -1, -1, 350, -1, + -1, -1, 67, -1, -1, -1, -1, -1, -1, -1, + 109, -1, 111, 78, -1, -1, 643, 644, 645, 118, + 119, 120, 121, 122, 123, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 662, -1, -1, -1, -1, + -1, -1, -1, 1162, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 680, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 691, 417, -1, -1, -1, 45, + 697, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 432, -1, -1, -1, -1, 437, 1205, -1, 64, -1, + -1, -1, -1, 445, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 733, -1, 1227, 736, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 471, + -1, -1, 1241, -1, 1243, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 110, -1, -1, 489, -1, 491, + 116, -1, -1, -1, -1, -1, 773, -1, -1, -1, + -1, -1, -1, -1, 1273, -1, -1, -1, -1, -1, + -1, -1, 1281, 1282, 1283, -1, -1, -1, -1, 145, + -1, -1, -1, 1292, 1293, -1, -1, -1, -1, 155, + -1, 533, -1, 159, -1, -1, -1, 1306, 815, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 825, -1, + -1, 828, -1, -1, -1, -1, 833, -1, 835, -1, + 1329, -1, -1, 840, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 208, -1, 30, 31, 32, -1, -1, -1, + -1, -1, -1, 39, 220, -1, 598, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 238, 239, -1, -1, -1, -1, -1, -1, + -1, 67, -1, -1, -1, 902, -1, -1, 74, 75, + -1, -1, -1, -1, -1, -1, 262, -1, -1, -1, + -1, 643, 644, 645, 270, -1, -1, -1, 1417, -1, + -1, -1, -1, -1, 281, -1, 283, 284, -1, -1, + 662, -1, -1, -1, 291, 292, -1, -1, 294, 296, + 297, 297, -1, 119, -1, -1, -1, -1, 680, -1, + -1, 308, -1, -1, -1, -1, -1, -1, -1, 691, + -1, -1, -1, -1, -1, 697, -1, 1466, 37, 38, + -1, 40, -1, -1, 1473, -1, -1, -1, -1, 986, + -1, -1, -1, -1, -1, -1, -1, 344, 344, -1, + -1, -1, -1, 349, -1, -1, -1, 66, -1, -1, + -1, 733, -1, 72, 736, -1, -1, 76, -1, -1, + 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + -1, -1, -1, 380, -1, 94, -1, 1526, -1, -1, + -1, -1, 1039, 1040, -1, 1042, 1043, -1, -1, -1, + 109, 773, 111, -1, -1, -1, -1, -1, 117, 118, + 119, 120, 121, 122, 123, 1062, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 64, -1, -1, -1, 425, + 426, -1, -1, -1, -1, 74, 432, 76, -1, 78, + -1, -1, -1, 815, -1, -1, 85, -1, -1, -1, + 1097, 1098, -1, 825, -1, -1, 828, 453, -1, -1, + 456, 833, -1, 835, -1, -1, -1, -1, 840, -1, + -1, -1, -1, -1, -1, -1, -1, 116, -1, 118, + 119, 120, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 489, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 501, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1162, -1, 513, -1, 515, + 159, -1, 518, -1, 520, 521, -1, -1, -1, -1, + 902, -1, -1, -1, -1, -1, -1, 533, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1205, -1, + 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, + 567, 568, 569, 570, 571, 572, 573, 574, -1, -1, + 1227, 220, -1, 222, 223, 224, -1, -1, -1, -1, + 586, -1, -1, -1, 1241, -1, 1243, -1, -1, -1, + -1, -1, 598, 600, 600, -1, -1, 603, -1, -1, + -1, -1, -1, -1, 986, -1, -1, -1, -1, 258, + -1, -1, -1, 262, -1, -1, 1273, -1, -1, -1, + -1, -1, -1, 629, 1281, 1282, 1283, -1, 634, 278, + -1, -1, -1, -1, -1, 1292, 1293, 643, 644, 645, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1306, + -1, -1, -1, -1, -1, -1, 662, 1039, 1040, -1, + 1042, 1043, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1329, -1, -1, -1, -1, -1, -1, 328, + 1062, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 697, 699, -1, -1, -1, -1, -1, -1, -1, + 349, -1, -1, -1, -1, 354, 355, 44, -1, -1, + -1, -1, 718, 362, 721, 1097, 1098, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 734, -1, -1, + 736, -1, 738, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 90, -1, -1, 405, -1, -1, -1, + 1417, -1, 39, 100, -1, -1, -1, 773, -1, -1, + -1, -1, -1, 780, 423, -1, -1, -1, -1, 428, + 1162, 430, -1, -1, -1, -1, -1, -1, -1, -1, + 67, -1, -1, -1, -1, -1, -1, -1, 447, -1, + -1, 450, 451, -1, -1, 812, -1, -1, -1, 1466, + -1, -1, -1, -1, -1, -1, 1473, 466, -1, 156, + 827, -1, 828, 1205, -1, -1, 832, -1, -1, 835, + -1, 480, -1, 170, -1, -1, -1, -1, 487, -1, + -1, -1, -1, -1, -1, 1227, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 193, -1, -1, 1241, + -1, 1243, -1, -1, -1, -1, -1, -1, -1, 1526, + 207, -1, -1, -1, -1, -1, -1, -1, -1, 216, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 226, + -1, 1273, -1, -1, -1, -1, -1, -1, -1, 1281, + 1282, 1283, -1, -1, -1, -1, -1, -1, -1, -1, + 1292, 1293, -1, -1, 251, -1, -1, -1, -1, 256, + -1, -1, 928, -1, 1306, -1, -1, -1, -1, -1, + -1, -1, 269, -1, -1, -1, -1, -1, 275, -1, + 277, 947, -1, -1, -1, -1, -1, 1329, -1, -1, + -1, -1, -1, -1, 603, -1, -1, -1, 295, -1, + -1, -1, -1, -1, 970, -1, -1, -1, -1, -1, + -1, 978, -1, -1, -1, -1, -1, -1, -1, -1, + 986, -1, 631, -1, -1, -1, -1, 636, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 338, 1009, -1, -1, -1, 343, -1, -1, -1, + -1, -1, -1, -1, 1021, 1021, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 371, 1417, 1042, 1043, 375, 376, + -1, 378, -1, -1, -1, -1, -1, -1, 385, 386, + -1, 388, 389, -1, 391, 1062, 393, -1, -1, -1, + -1, -1, 7, -1, -1, 10, 11, 12, 13, 14, + -1, -1, -1, 410, -1, 724, -1, -1, -1, -1, + -1, 418, -1, -1, 1466, -1, -1, -1, -1, 738, + -1, 1473, 37, 38, 39, 40, 1102, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 443, -1, -1, 758, + -1, -1, -1, -1, -1, -1, -1, 454, -1, -1, + -1, 66, 67, -1, -1, -1, -1, 72, 1135, -1, + -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, + 477, 86, 87, -1, 1526, -1, 483, -1, -1, 94, + -1, 488, -1, -1, -1, -1, 1162, -1, -1, -1, + -1, -1, -1, -1, 109, -1, 111, -1, -1, -1, + 819, -1, 1179, 118, 119, 120, 121, 122, 123, -1, + -1, -1, -1, 832, -1, -1, 1193, 1194, 525, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1204, -1, + -1, -1, 851, -1, 541, -1, -1, -1, -1, -1, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, 1243, 30, 31, + 32, 578, -1, -1, -1, -1, -1, 39, -1, -1, + 587, -1, -1, -1, -1, -1, -1, 594, -1, -1, + -1, -1, 599, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 610, -1, 67, -1, 69, -1, 71, + 72, -1, 74, 75, 76, -1, 1292, 1293, -1, 938, + -1, 83, 84, -1, -1, 1301, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 651, 964, -1, 109, -1, 111, + -1, -1, -1, -1, -1, -1, -1, 119, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 992, -1, -1, -1, -1, -1, -1, + 687, -1, -1, -1, -1, -1, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 1024, 30, 31, 32, -1, + -1, -1, -1, -1, -1, 39, 1035, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1404, -1, -1, + -1, -1, -1, -1, -1, 742, -1, -1, -1, -1, + -1, 1417, -1, 67, 1421, 752, 753, -1, -1, -1, + 74, 75, -1, -1, 78, -1, -1, -1, -1, 766, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 783, -1, 785, -1, + -1, -1, 789, -1, -1, 109, -1, 111, -1, -1, + -1, -1, -1, -1, -1, 119, -1, -1, 1117, 1475, + -1, 1477, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1494, 1495, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 37, 38, -1, 40, -1, -1, 1512, -1, 1514, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 855, -1, + -1, -1, -1, -1, -1, 862, -1, -1, -1, 66, + -1, -1, -1, -1, -1, 72, 1542, -1, 875, 76, + 877, -1, 79, 80, 81, 82, 83, 84, -1, 86, + 87, -1, -1, -1, 891, 1204, -1, 94, -1, -1, + -1, 898, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 109, 910, 111, -1, 913, -1, -1, 116, + -1, 118, 119, 120, 121, 122, 123, -1, -1, -1, + -1, -1, -1, -1, 931, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 154, 155, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 188, -1, + -1, -1, 1301, -1, -1, 195, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, 1020, 30, 31, 32, 33, -1, -1, + 36, -1, -1, 39, 40, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, 30, 31, 32, 64, -1, + -1, 67, -1, 69, 39, 71, 72, 267, 74, 75, + 76, -1, -1, -1, -1, -1, -1, 83, 84, 1076, + -1, -1, -1, -1, -1, -1, 1083, -1, -1, -1, + -1, -1, 67, -1, -1, -1, -1, -1, -1, 74, + 75, -1, -1, 109, -1, 111, -1, -1, -1, 115, + -1, -1, -1, 119, -1, 145, 1113, -1, -1, -1, + -1, 1118, -1, 323, -1, 155, -1, -1, -1, 1126, + -1, 331, 332, -1, 334, 335, -1, 167, 168, -1, + -1, -1, -1, -1, 344, -1, -1, -1, 348, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1157, -1, -1, -1, -1, -1, -1, 367, -1, -1, + 370, -1, 1169, -1, -1, 1172, -1, 1174, -1, -1, + 37, 38, -1, 40, -1, -1, -1, -1, -1, -1, + -1, 1188, 1189, -1, -1, -1, -1, 397, -1, -1, + -1, 401, -1, -1, -1, -1, -1, -1, 238, 66, + -1, -1, -1, 1210, -1, 72, -1, -1, -1, 76, + -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, + 87, -1, 432, 263, -1, -1, -1, 94, -1, -1, + 1237, -1, -1, -1, -1, -1, -1, -1, 1557, -1, + -1, -1, 109, -1, 111, 455, -1, 114, -1, -1, + -1, 118, 119, 120, 121, 122, 123, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 486, -1, -1, 489, + -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 75, 0, 25, 26, - 27, 0, 453, 0, 351, 351, 946, 30, 0, 0, - 109, 0, 0, 0, 0, 0, 0, 0, 77, 0, - 0, 0, 1236, 0, 0, 0, 0, 0, 0, 0, - 0, 353, 353, 354, 0, 33, 0, 0, 77, 0, - 36, 0, 37, 38, 39, 84, 77, 0, 0, 0, - 0, 40, 41, 0, 0, 0, 0, 0, 0, 0, - 361, 0, 0, 0, 0, 84, 346, 0, 351, 0, - 0, 0, 354, 84, 0, 0, 0, 42, 0, 155, - 0, 0, 0, 0, 0, 0, 0, 44, 0, 0, - 354, 0, 77, 0, 0, 353, 0, 0, 0, 361, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 220, 0, 0, 0, 0, 0, 361, 0, 84, - 0, 0, 0, 0, 0, 54, 0, 0, 0, 0, - 0, 0, 0, 72, 354, 0, 0, 0, 221, 0, - 0, 0, 0, 0, 0, 0, 351, 0, 351, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 75, 361, 0, 0, 0, 0, 0, 346, 0, 0, - 0, 0, 0, 353, 0, 353, 0, 0, 351, 0, - 0, 0, 0, 0, 0, 0, 351, 351, 351, 0, - 0, 0, 0, 0, 0, 0, 0, 351, 351, 354, - 0, 0, 0, 0, 0, 353, 0, 0, 0, 0, - 0, 72, 0, 353, 353, 353, 0, 0, 0, 0, - 0, 0, 0, 0, 353, 353, 361, 0, 0, 0, - 0, 0, 346, 0, 351, 0, 0, 0, 75, 0, - 0, 0, 0, 0, 354, 354, 354, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 353, 0, 354, 0, 0, 0, 0, 0, 124, - 0, 361, 361, 361, 0, 0, 0, 346, 346, 346, - 0, 354, 0, 0, 0, 0, 0, 0, 0, 0, - 361, 0, 77, 0, 0, 0, 346, 0, 354, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 361, 1033, - 0, 0, 8, 9, 10, 11, 12, 0, 0, 84, - 0, 0, 351, 0, 0, 361, 0, 0, 0, 0, - 0, 0, 0, 0, 77, 0, 0, 354, 280, 281, - 30, 282, 0, 0, 0, 0, 0, 0, 0, 353, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 84, 0, 0, 361, 0, 0, 283, 33, 0, - 346, 72, 0, 284, 354, 0, 0, 285, 72, 0, - 286, 287, 288, 289, 40, 41, 0, 290, 291, 0, - 0, 0, 0, 124, 0, 292, 0, 0, 75, 0, - 0, 361, 0, 0, 0, 75, 0, 0, 0, 0, - 293, 0, 377, 0, 0, 0, 354, 0, 0, 295, - 826, 297, 298, 299, 300, 0, 354, 0, 0, 354, - 0, 72, 0, 0, 222, 0, 354, 0, 0, 0, - 0, 354, 0, 361, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 361, 0, 0, 361, 0, 75, 0, - 0, 223, 346, 361, 0, 0, 0, 0, 361, 346, - 0, 0, 0, 0, 0, -516, 0, 0, 1, 2, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + -1, 30, 31, 32, 33, -1, -1, 36, -1, 529, + 39, -1, 532, 533, -1, -1, -1, -1, 1335, -1, + 1337, -1, -1, -1, -1, -1, -1, -1, -1, 379, + -1, -1, -1, 1350, -1, 1352, -1, -1, 67, -1, + 69, -1, 71, -1, -1, 74, 75, -1, -1, 78, + -1, -1, -1, 1370, -1, -1, -1, -1, 578, 579, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1386, + 1387, -1, -1, -1, -1, -1, -1, 597, 598, -1, + 600, 1398, 111, -1, 1401, -1, -1, -1, -1, 609, + 119, 611, 612, -1, -1, -1, -1, -1, 618, -1, + -1, -1, -1, -1, -1, -1, 1423, -1, 628, 629, + -1, -1, -1, -1, 634, 1432, -1, -1, 1435, -1, + 1437, 1438, 1439, 643, 644, 645, -1, -1, -1, -1, + -1, 481, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 662, -1, -1, -1, -1, 667, 668, -1, + -1, 671, 672, -1, -1, -1, -1, -1, 678, -1, + -1, -1, 1479, -1, 1481, -1, -1, 1484, -1, -1, + 520, -1, -1, -1, -1, -1, 696, 697, 698, -1, + 700, -1, 1499, 533, 704, -1, -1, -1, -1, -1, + 540, -1, -1, 543, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 554, 555, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 736, 737, -1, -1, + -1, -1, -1, -1, -1, -1, 576, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 586, -1, -1, -1, + -1, -1, -1, 593, -1, -1, -1, -1, 598, -1, + -1, -1, 772, 773, -1, -1, -1, 777, 778, -1, + -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, 33, -1, -1, 36, 648, 819, + 39, 40, -1, -1, -1, -1, -1, 657, 828, -1, + -1, -1, -1, -1, 834, 835, -1, -1, -1, 839, + -1, 841, -1, -1, -1, 64, -1, -1, 67, -1, + 69, 851, 71, 72, -1, 74, 75, 76, -1, -1, + -1, -1, -1, -1, 83, 84, -1, 697, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 109, -1, 111, -1, -1, -1, -1, -1, -1, -1, + 119, -1, -1, -1, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 924, 30, 31, 32, -1, -1, + -1, -1, 932, -1, 39, -1, -1, -1, 938, -1, + -1, -1, -1, 773, -1, 775, 946, -1, -1, -1, + -1, 781, -1, -1, -1, -1, -1, -1, 788, 959, + 960, -1, 67, -1, -1, -1, -1, 72, -1, 74, + 75, 76, -1, 78, -1, -1, -1, -1, 83, 84, + -1, -1, -1, -1, -1, -1, 986, -1, -1, -1, + -1, -1, 992, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 832, 833, 109, 835, 111, -1, -1, -1, + -1, 1011, 1012, -1, 119, -1, -1, -1, -1, -1, + 850, 1021, -1, -1, -1, -1, -1, 1027, 1028, -1, + 1030, 1031, 1032, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1042, 1043, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 890, -1, -1, -1, 894, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, 33, -1, -1, 36, -1, + -1, 39, -1, 1103, 1104, 1105, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1117, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, + -1, 69, -1, 71, -1, -1, 74, 75, -1, -1, + 970, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 986, 987, -1, -1, + -1, -1, 1162, 993, -1, -1, -1, 37, 38, 999, + 40, -1, 1002, 111, 1004, -1, -1, -1, -1, -1, + -1, 119, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1024, -1, 66, -1, -1, -1, + -1, -1, 72, -1, -1, 1035, 76, -1, -1, 79, + 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, + -1, -1, 1222, -1, 94, 37, 38, 1057, 40, 1059, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, + -1, 111, -1, 1243, 1074, 1075, -1, -1, 118, 119, + 120, 121, 122, 123, 66, -1, -1, -1, -1, -1, + 72, -1, -1, -1, 76, 1095, -1, 79, 80, 81, + 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, + -1, -1, 94, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1292, 1293, -1, -1, -1, 109, -1, 111, + -1, -1, -1, -1, -1, -1, 118, 119, 120, 121, + 122, 123, -1, 1143, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1162, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1177, 1178, -1, + -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, 33, -1, -1, 36, 37, + 38, 39, 40, 41, -1, 43, -1, -1, 46, 47, + 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, + -1, -1, -1, 61, 62, -1, 64, 1417, 66, 67, + -1, 69, -1, 71, 72, -1, 74, 75, 76, 1259, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, 114, -1, -1, -1, + 118, 119, 120, 121, 122, 123, -1, -1, -1, -1, + 128, -1, -1, -1, 132, -1, -1, -1, -1, -1, + 1320, -1, 1322, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1507, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, 1532, 1533, -1, -1, -1, 39, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1557, -1, -1, + -1, -1, -1, -1, -1, 67, -1, -1, -1, -1, + -1, -1, 74, 75, -1, -1, -1, -1, 1408, -1, + -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, 33, -1, 119, 36, 37, + 38, 39, 40, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, -1, -1, 66, 67, + -1, 69, 39, 71, 72, -1, 74, 75, 76, -1, + 1490, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + 67, -1, -1, -1, -1, 72, -1, 74, 75, -1, + -1, 109, -1, 111, -1, -1, 83, 84, -1, -1, + 118, 119, 120, 121, 122, 123, -1, -1, -1, -1, + -1, -1, 1542, -1, 132, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, 33, -1, -1, 36, 37, + 38, 39, 40, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, -1, -1, 66, 67, + -1, 69, 39, 71, 72, -1, 74, 75, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + 67, -1, -1, -1, -1, -1, -1, 74, 75, -1, + -1, 109, -1, 111, -1, -1, -1, -1, -1, -1, + 118, 119, 120, 121, 122, 123, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, + 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, + -1, 69, -1, 71, 72, -1, 74, 75, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, -1, -1, 116, -1, + 118, 119, 120, 121, 122, 123, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, + 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, + -1, 69, -1, 71, 72, -1, 74, 75, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, -1, -1, 116, -1, + 118, 119, 120, 121, 122, 123, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, + 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, + -1, 69, -1, 71, 72, -1, 74, 75, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, -1, -1, 116, -1, + 118, 119, 120, 121, 122, 123, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, + 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, + -1, 69, -1, 71, 72, -1, 74, 75, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, -1, -1, -1, -1, + 118, 119, 120, 121, 122, 123, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, + 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, + -1, 69, -1, 71, 72, -1, 74, 75, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, -1, -1, -1, -1, + 118, 119, 120, 121, 122, 123, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, + 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, + -1, 69, -1, 71, 72, -1, 74, 75, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, -1, -1, -1, -1, + 118, 119, 120, 121, 122, 123, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, + 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, + -1, 69, -1, 71, 72, -1, 74, 75, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, -1, -1, -1, -1, + 118, 119, 120, 121, 122, 123, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, + -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 67, -1, 69, -1, 71, -1, -1, 74, 75, -1, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, + -1, -1, -1, -1, 111, 39, -1, -1, -1, -1, + -1, -1, 119, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 67, -1, 69, -1, 71, 72, -1, + 74, 75, 76, -1, -1, -1, -1, -1, -1, 83, + 84, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, + -1, -1, -1, -1, -1, 119, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, -1, + -1, 39, -1, -1, -1, -1, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, 30, 31, 32, 67, + -1, 69, -1, 71, -1, 39, 74, 75, -1, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 67, -1, 30, 31, 32, 72, -1, + 74, 75, 110, 111, 39, -1, -1, -1, -1, 83, + 84, 119, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 67, -1, 69, -1, 71, 111, -1, 74, + 75, -1, -1, -1, -1, 119, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 96, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 111, -1, -1, -1, + -1, -1, -1, -1, 119, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, -1, -1, -1, -1, -1, -1, + 39, -1, -1, -1, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, -1, 30, 31, 32, 67, -1, + 69, -1, 71, -1, 39, 74, 75, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 96, -1, -1, + -1, -1, 67, -1, -1, -1, -1, 72, -1, 74, + 75, 76, 111, 78, -1, -1, -1, -1, 83, 84, + 119, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, 111, 30, 31, 32, + -1, -1, -1, -1, 119, -1, 39, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 67, -1, 69, -1, 71, -1, + -1, 74, 75, -1, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, + 30, 31, 32, -1, -1, -1, -1, -1, 111, 39, + -1, -1, -1, -1, -1, -1, 119, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, + -1, 71, -1, -1, 74, 75, -1, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, + -1, 111, 39, -1, -1, -1, -1, -1, -1, 119, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 67, -1, 69, -1, 71, -1, -1, 74, 75, -1, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, + -1, -1, -1, -1, 111, 39, -1, -1, -1, -1, + -1, -1, 119, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 67, -1, 69, -1, 71, -1, -1, + 74, 75, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, + 38, 39, 40, -1, -1, -1, -1, 111, -1, -1, + -1, -1, -1, -1, -1, 119, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 66, 67, + -1, -1, -1, -1, 72, -1, 74, 75, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, 114, -1, -1, -1, + 118, 119, 120, 121, 122, 123, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, + -1, -1, -1, 37, 38, 39, 40, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, + -1, -1, 66, 67, -1, -1, 39, -1, 72, -1, + 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, + 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, + 94, -1, -1, -1, 67, -1, -1, -1, -1, 72, + -1, 74, 75, 76, -1, 109, -1, 111, 112, -1, + 83, 84, -1, -1, 118, 119, 120, 121, 122, 123, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 111, -1, + 30, 31, 32, -1, -1, -1, 119, 37, 38, 39, + 40, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, -1, -1, 66, 67, -1, -1, + 39, 40, 72, -1, 74, 75, 76, -1, -1, 79, + 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, + -1, -1, -1, -1, 94, -1, -1, -1, 67, -1, + -1, -1, -1, -1, -1, 74, 75, -1, -1, 109, + 110, 111, -1, -1, -1, -1, -1, -1, 118, 119, + 120, 121, 122, 123, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 111, -1, 30, 31, 32, -1, -1, -1, + 119, 37, 38, 39, 40, -1, -1, -1, -1, -1, + -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 66, 67, 30, 31, 32, -1, 72, -1, 74, 75, + 76, 39, -1, 79, 80, 81, 82, 83, 84, -1, + 86, 87, -1, -1, -1, -1, -1, -1, 94, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, + -1, -1, -1, 109, -1, 111, 74, 75, -1, -1, + -1, -1, 118, 119, 120, 121, 122, 123, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, 109, -1, 111, -1, 37, 38, 39, 40, -1, + -1, 119, -1, -1, -1, -1, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 66, 67, 30, 31, 32, -1, + 72, -1, 74, 75, 76, 39, -1, 79, 80, 81, + 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, + -1, -1, 94, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 67, -1, -1, -1, 109, -1, 111, + 74, 75, -1, -1, -1, -1, 118, 119, 120, 121, + 122, 123, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, 109, -1, 111, -1, 37, + 38, 39, 40, -1, -1, 119, -1, -1, -1, -1, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 66, 67, + 30, 31, 32, -1, 72, -1, 74, 75, 76, 39, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 67, -1, -1, + -1, 109, -1, 111, 74, 75, -1, -1, -1, -1, + 118, 119, 120, 121, 122, 123, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, + -1, 111, -1, 37, 38, 39, 40, -1, -1, 119, + -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 66, 67, 30, 31, 32, -1, 72, -1, + 74, 75, 76, 39, -1, 79, 80, 81, 82, 83, + 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, + 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 67, -1, -1, -1, 109, -1, 111, 74, 75, + -1, -1, -1, -1, 118, 119, 120, 121, 122, 123, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 0, 77, 25, 26, 27, 28, 0, 0, - 29, 0, 0, 30, 31, 0, 0, 0, 0, 8, - 9, 10, 11, 12, 0, 8, 9, 10, 11, 12, - 84, 0, 0, 0, 0, 0, 54, 0, 32, 0, - 0, 33, 163, 34, 0, 35, 36, 30, 37, 38, - 39, 0, 0, 30, 0, 0, 0, 40, 41, 0, - 0, 216, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, - 36, 33, 0, 42, 39, 43, 36, 354, 0, 0, - 39, 40, 41, 44, 0, 0, 0, 40, 41, 0, - 0, 0, 0, 54, 0, 0, 0, 163, 0, 0, - 0, 0, 0, 270, 361, 0, 0, 42, 0, 0, - 346, 0, 0, 743, 0, 0, 0, 145, 0, 0, - 0, 0, 0, 744, 0, 0, 0, 0, 0, 0, - 354, 354, 163, 354, 354, 0, 0, 0, 0, 0, - 0, 0, 367, 0, 0, 0, 373, 0, 0, 0, - 0, 0, 0, 77, 0, 0, 0, 361, 361, 0, - 361, 361, 0, 0, 0, 0, 346, 346, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 84, 0, 0, 0, 0, 0, 54, 0, 354, 354, - 0, 0, 0, 0, 0, 163, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 216, 0, 0, - 0, 0, 0, 0, 0, 361, 361, 0, 0, 0, - 0, 280, 281, 0, 282, 163, 460, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 0, 0, 25, 26, 27, 373, - 283, 0, 354, 0, 0, 30, 284, 163, 0, 0, - 285, 0, 0, 286, 287, 288, 289, 40, 41, 0, - 290, 291, 0, 0, 0, 0, 0, 0, 292, 361, - 0, 460, 0, 33, 163, 0, 0, 0, 0, 0, - 205, 38, 0, 512, 0, 222, 0, 0, 0, 0, - 0, 0, 295, 379, 297, 298, 299, 300, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 77, 0, 0, - 0, 0, 223, 0, 0, 0, 0, 54, 54, 0, - 354, 605, 354, 0, 0, 269, 629, 0, 0, 0, - 0, 0, 0, 0, 84, 0, 0, 0, 0, 0, - 54, 0, 0, 0, 0, 0, 0, 361, 0, 361, - 0, 0, 354, 0, 0, 0, 0, 0, 0, 54, - 354, 354, 354, 0, 0, 0, 0, 0, 0, 0, - 0, 354, 354, 0, 0, 0, 0, 0, 0, 361, - 0, 0, 0, 0, 0, 77, 0, 361, 361, 361, - 0, 0, 0, 0, 0, 0, 0, 0, 361, 361, - 0, 0, 163, 163, 346, 346, 0, 0, 354, 367, - 0, 0, 84, 54, 0, 0, 0, 0, 54, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 460, 0, 0, 460, 0, 361, 0, 0, 0, 460, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 740, 0, 0, 0, - 209, 0, 0, 0, 0, 0, 0, 0, 163, 0, - 229, 0, 233, 0, 235, 0, 0, 0, 0, 0, - 460, 244, 460, 0, 0, 460, 354, 163, 460, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 367, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 209, 361, 233, 235, 244, 0, 0, 346, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 77, 0, 154, 0, 0, - 0, 0, 77, 0, 0, 54, 0, 0, 0, 0, - 0, 0, 0, 163, 0, 209, 0, 0, 0, 0, - 0, 0, 84, 0, 0, 367, 0, 605, 54, 84, - 836, 0, 0, 0, 0, 54, 0, 0, 0, 0, - 0, 0, 0, 249, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 254, 0, 77, 605, 0, 0, 0, - 0, 605, 0, 0, 0, 0, 0, 0, 0, 0, - 367, 367, 367, 0, 0, 0, 209, 0, 233, 235, - 244, 0, 84, 0, 0, 0, 0, 0, 54, 367, - 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, -294, 154, - 25, 26, 27, 0, 209, 0, 0, 0, 209, 30, - 0, 0, 0, 384, 740, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 503, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 460, 416, 33, 0, 0, - 0, 0, 0, 0, 37, 38, 0, 0, -294, 0, - 431, 0, 0, 367, 0, 960, 0, 0, 0, 436, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 444, - 0, 0, 0, 0, 209, 0, 0, 0, 0, 642, - 0, 337, 280, 281, 0, 282, 0, 0, 0, 109, - 740, 0, 0, 0, 470, 209, 0, 0, 0, 480, - 233, 235, 0, 0, 0, 0, 0, 0, 244, 0, - 0, 283, 488, 0, 0, 0, 0, 284, 498, 0, - 502, 285, 0, 0, 286, 287, 288, 289, 40, 41, - 0, 290, 291, 0, 0, 0, 0, 0, 532, 292, - 0, 0, 0, 0, 0, 367, 0, 0, 0, 629, - 0, 209, 367, 0, 293, 0, 377, 0, 0, 378, - 0, 0, 0, 295, 379, 297, 298, 299, 300, 209, - 0, 0, 0, 0, 209, 0, 209, 0, 0, 0, - 0, 592, 0, 0, 0, 0, 597, 0, 0, 0, - 0, 0, 0, 209, 0, 0, 209, 209, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 209, 0, 643, 0, 0, 0, 644, 645, - 0, 647, 0, 0, 0, 0, 209, 0, 659, 660, - 0, 661, 662, 209, 663, 0, 664, 0, 0, 0, - 0, 0, 0, 1176, 0, 460, 8, 9, 10, 11, - 12, 0, 0, 592, 0, 0, 0, 0, 0, 0, - 0, 679, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 280, 281, 30, 282, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 690, 163, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 696, 0, 0, - 0, 283, 33, 367, 0, 0, 0, 284, 0, 0, - 0, 285, 0, 0, 286, 287, 288, 289, 40, 41, - 732, 290, 291, 0, 0, 0, 735, 0, 0, 292, - 0, 470, 0, 0, 0, 0, 0, 0, 605, 0, - 0, 0, 0, 0, 293, 0, 377, 0, 0, 209, - 0, 0, 0, 295, 1177, 297, 298, 299, 300, 367, - 367, 0, 0, 0, 0, 0, 0, 0, 772, 0, - 0, 0, 0, 0, 0, 0, 0, 209, 513, 0, - 515, 518, 209, 0, 787, 0, 0, 0, 521, 522, - 0, 0, 0, 515, 515, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 515, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 280, 281, 0, 282, 460, - 0, 814, 0, 0, 0, 0, 0, 0, 0, 0, - 824, 0, 0, 0, 0, 0, 0, 827, 0, 0, - 0, 515, 834, 0, 283, 0, 0, 0, 0, 0, - 284, 0, 0, 849, 285, 0, 0, 286, 287, 288, - 289, 40, 41, 0, 290, 291, 0, 0, 0, 0, - 209, 0, 292, 0, 0, 0, 0, 515, 740, 0, - 0, 0, 0, 0, 209, 0, 0, 293, 0, 377, - 0, 0, 0, 0, 889, 811, 295, 379, 297, 298, - 299, 300, 0, 0, 503, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 216, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 834, 0, 0, 0, 0, 8, 9, 10, 11, 12, + 23, 24, 25, 26, 27, 111, -1, 30, 31, 32, + -1, -1, -1, 119, -1, -1, 39, -1, -1, -1, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, + 30, 31, 32, -1, 67, -1, 69, -1, 71, 39, + -1, 74, 75, -1, -1, -1, -1, -1, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, 67, 30, 31, + 32, -1, 72, -1, 74, 75, 76, 39, -1, -1, + -1, 114, -1, 83, 84, -1, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, 67, 30, 31, 32, 109, + 72, 111, 74, 75, 76, 39, -1, -1, -1, 119, + -1, 83, 84, -1, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, 67, 30, 31, 32, 109, 72, 111, + 74, 75, 76, 39, -1, -1, -1, 119, -1, 83, + 84, -1, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 67, 30, 31, 32, 109, 72, 111, 74, 75, + 76, 39, -1, -1, -1, 119, -1, 83, 84, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, + -1, -1, -1, 109, -1, 111, 74, 75, -1, -1, + 78, -1, -1, 119, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, + -1, 109, -1, 111, 39, 40, -1, -1, -1, -1, + -1, 119, -1, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 67, 30, 31, 32, -1, -1, -1, 74, + 75, -1, 39, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, + 67, -1, 39, 40, -1, -1, 111, 74, 75, -1, + 115, 78, -1, -1, 119, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 67, -1, -1, -1, -1, -1, -1, 74, 75, -1, + -1, -1, -1, -1, 111, -1, -1, -1, -1, -1, + -1, -1, 119, -1, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, 111, 30, 31, 32, 115, -1, + -1, -1, 119, -1, 39, 40, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, + -1, -1, 67, -1, -1, 39, -1, -1, -1, 74, + 75, -1, -1, -1, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, 67, 30, 31, 32, -1, -1, -1, + 74, 75, -1, 39, -1, -1, 111, -1, -1, -1, + 115, -1, -1, -1, 119, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 67, -1, -1, -1, -1, -1, 111, 74, 75, + -1, -1, -1, -1, -1, 119, -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, -294, 0, 25, 26, 27, 0, 740, 0, - 0, 0, 0, 30, 0, 209, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 209, 0, - 0, 0, 0, 0, 0, 249, 0, 0, 0, 0, - 0, 33, 0, 0, 0, 967, 968, 209, 37, 38, - 0, 0, -294, 0, 0, 0, 0, 367, 367, 985, - 0, 0, 0, 0, 0, 0, 216, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1000, 0, 1001, 0, - 0, 0, 1005, 642, 0, 337, 0, 0, 0, 0, - 0, 0, 0, 633, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 515, 515, 515, 515, 515, 515, - 515, 515, 515, 515, 515, 515, 515, 515, 515, 515, - 515, 515, 0, 0, 0, 0, 0, 0, 0, 0, - 280, 281, 0, 282, 209, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 515, 1038, 0, - 0, 0, 0, 0, 0, 1039, 0, 0, 0, 283, - 209, 0, 0, 0, 0, 284, 0, 0, 1041, 285, - 1042, 0, 286, 287, 288, 289, 40, 41, 0, 290, - 291, 0, 367, 0, 1054, 0, 0, 292, 209, 0, - 0, 1058, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 293, 1096, 377, 0, 1097, 0, 0, 780, - 0, 295, 379, 297, 298, 299, 300, 0, 0, 0, - 209, 0, 0, 0, 597, 0, 0, 0, 0, 0, - 0, 209, 0, 0, 0, 0, 0, 0, 0, 0, - 460, 0, 460, 0, 0, 0, 515, 0, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, -294, 0, 0, 515, 0, - 0, 0, 0, 0, 0, 0, 30, 460, 0, 460, - 0, 515, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, -294, - 0, 25, 26, 27, 33, 0, 0, 163, 0, 0, - 30, 0, 209, 1160, 0, -294, 0, 0, 0, 340, - 362, 0, 0, 0, 0, 0, 0, 515, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, - 0, 0, 0, 36, 0, 335, 336, 39, 0, -294, - 0, 0, 0, 412, 40, 41, 0, 0, 0, 515, - 412, 0, 0, 0, 0, 0, 0, 0, 0, 532, - 0, 0, 0, 0, 515, 0, 1225, 0, 0, 0, - 642, 0, 337, 0, 0, 0, 0, 0, 0, 0, - 633, 280, 281, 0, 282, 0, 0, 0, 0, 209, - 0, 0, 0, 0, 0, 1238, 0, 0, 0, 0, - 1240, 0, 0, 0, 0, 0, 0, 0, 1244, 0, - 283, 0, 0, 0, 0, 0, 648, 0, 137, 138, - 285, 0, 412, 286, 649, 288, 289, 40, 41, 0, - 290, 291, 0, 0, 0, 0, 0, 0, 292, 1270, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1278, 0, 293, 1279, 650, 1280, 651, 378, 0, - 0, 0, 295, 379, 297, 298, 299, 300, 0, 0, - 1289, 1290, 0, 0, 0, 0, 0, 0, 412, 0, - 0, 0, 0, 0, 0, 209, 412, 588, 0, 412, - 591, 0, 1303, 0, 0, 0, 0, 0, 0, 362, - 0, 0, 0, 621, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 515, 0, 0, 0, 1326, - 320, 0, 639, 0, 0, 340, 0, 0, 0, 0, - 344, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 380, 380, 0, 0, 515, 0, 0, 0, - 0, 0, 412, 0, 0, 0, 412, 0, 515, 2, - 204, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, + -1, -1, -1, -1, -1, 111, 39, -1, -1, -1, + -1, -1, -1, 119, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, 67, 30, 31, 32, -1, -1, + -1, 74, 75, -1, 39, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, + -1, -1, 67, -1, 39, -1, -1, -1, 111, 74, + 75, -1, -1, -1, -1, -1, 119, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 67, -1, -1, -1, -1, -1, -1, 74, + 75, -1, -1, -1, -1, -1, 111, -1, -1, -1, + -1, -1, -1, -1, 119, -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 0, 0, 25, 26, 27, 362, 0, 0, - 0, 0, 0, 30, 0, 0, 0, 0, 0, 515, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 412, 0, 0, 320, 0, 0, 1396, 0, 1397, 0, - 0, 33, 0, 34, 0, 35, 0, 0, 37, 38, - 0, 1406, 0, 1407, 0, 0, 0, 0, 484, 0, - 0, 412, 0, 0, 362, 0, 0, 0, 0, 0, - 0, 1414, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, -399, 686, 0, 1432, 1434, 0, - 0, 515, 0, 633, 0, 0, 0, 0, 0, 1440, - 0, 0, 1244, 0, 412, 0, 0, 340, 362, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1463, 0, 0, 0, 0, 0, - 0, 0, 0, 1470, 0, 515, 1472, 0, 1474, 1476, - 1478, 0, 0, 0, 0, 0, 0, 0, 0, 515, - 515, 0, 0, 412, 412, 0, 0, 0, 0, 0, - 0, 209, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 829, 362, 380, 362, 0, 0, 0, 0, - 1509, 0, 1511, 0, 621, 1244, 621, 621, 0, 0, - 0, 0, 0, 621, 0, 0, 0, 0, 0, 0, - 1523, 0, 0, 868, 362, 0, 0, 0, 0, 362, - 0, 0, 0, 0, 0, 0, 0, 0, 362, 362, - 362, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 362, 0, 0, - 0, 0, 412, 911, 0, 0, 412, 914, 0, 0, - 0, 0, 0, 916, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 340, 362, 412, 0, 412, 734, 0, 0, 412, - 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 0, 0, - 25, 26, 27, 0, 0, 0, 0, 0, 0, 30, - 0, 362, 621, 0, 0, 768, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 781, 0, - 0, 0, 0, 0, 0, 768, 0, 33, 768, 0, - 0, 0, 0, 0, 205, 38, 0, 340, 362, 791, - 792, 0, 412, 412, 0, 0, 0, 0, 0, 515, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 813, 0, 0, 0, 0, 515, 0, 0, 0, - 0, 822, 0, 0, 0, 0, 0, 0, 344, 628, - 0, 0, 0, 781, 412, 0, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 0, 0, 0, 0, 829, - 362, 0, 0, 0, 621, 0, 621, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 621, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 888, 0, 0, 0, 0, 0, 515, - 515, 0, 380, 0, 0, 0, 0, 0, 0, 1, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 0, 0, 25, 26, 27, 28, 0, - 0, 29, 344, 0, 30, 31, 0, 0, 0, 829, - 0, 0, 0, 0, 0, 0, 0, 412, 280, 281, - 0, 282, 0, 412, 0, 0, 0, 0, 0, 32, - 0, 412, 33, 0, 34, 0, 35, 36, 0, 37, - 38, 39, 0, 0, 621, 621, 0, 283, 40, 41, - 0, 0, 0, 284, 0, 0, 0, 285, 0, 0, - 286, 287, 288, 289, 40, 41, 0, 290, 291, 0, - 0, 362, 0, 0, 42, 292, 43, 412, 781, 0, - 990, 0, 0, 0, 44, 0, 995, 0, 0, 0, - 293, 0, 377, 1004, 0, 992, 412, 1157, 0, 295, - 379, 297, 298, 299, 300, 0, 362, 0, 0, 0, - 0, 0, 412, 1169, 0, 621, 621, 1174, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 362, 362, 0, - 0, 0, 0, 0, 0, 0, 0, 1021, 1022, 0, - 344, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 344, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 829, 412, - 1237, 0, 0, 0, 0, 1052, 0, 0, 0, 380, - 0, 621, 0, 0, 0, 0, 1, 2, 204, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 23, 24, 25, 26, 27, -1, 111, 30, 31, 32, + -1, -1, -1, -1, 119, -1, 39, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, + -1, -1, -1, -1, 67, -1, 39, -1, -1, -1, + -1, 74, 75, -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 0, 0, 25, 26, 27, 28, 0, 0, 29, 280, - 281, 30, 1061, 1062, 0, 1063, 362, 0, 1064, 1065, - 1066, 1067, 1068, 1069, 1070, 1071, 0, 0, 0, 1072, - 0, 0, 0, 1073, 1074, 0, 32, 0, 283, 33, - 0, 34, 0, 35, 648, 320, 37, 38, 285, 0, - 0, 286, 287, 288, 289, 40, 41, 0, 290, 291, - 0, 1138, 1139, 0, 0, 0, 292, 0, 380, 0, - 0, 0, 280, 281, 995, 282, 340, 1148, 0, 768, - 0, 293, 0, 1075, 0, 0, 169, 0, 0, 0, - 295, 296, 297, 298, 299, 300, 362, 0, 0, 1164, - 1076, 283, 0, 0, -129, 0, 0, 284, 0, 0, - 1179, 285, 0, 0, 286, 287, 288, 289, 40, 41, - 0, 290, 291, 0, 0, 0, 0, 0, 0, 292, - 0, 0, 380, 0, 1197, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 293, 362, 362, 0, 0, 995, - 995, 0, 0, 295, 379, 297, 298, 299, 300, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1229, 0, 0, 0, 0, 0, 0, 0, 1, 2, - 204, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 0, 0, 25, 26, 27, 28, 0, 0, - 29, 280, 281, 30, 282, 0, 0, 995, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 280, 281, 0, 282, 0, 0, 888, 0, 0, 0, - 283, 33, 0, 34, 0, 35, 284, 0, 37, 38, - 285, 1281, 1282, 286, 287, 288, 289, 40, 41, 283, - 290, 291, 0, 0, 0, 284, 0, 0, 292, 285, - 362, 0, 286, 287, 288, 289, 40, 41, 0, 290, - 291, 0, 0, 293, 0, 1075, 0, 292, 0, 0, - 0, 0, 295, 296, 297, 298, 299, 300, 0, 0, - 0, 0, 293, 0, 377, 0, -129, 0, 0, 0, - 0, 295, 379, 297, 298, 299, 300, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 995, 0, 0, 0, 1, 2, 204, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 412, 0, 25, 26, 27, 28, 0, 0, 29, 280, - 281, 30, 282, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 412, 412, 0, 0, 0, - 0, 0, 0, 1389, 0, 768, 0, 0, 283, 33, - 0, 34, 0, 35, 284, 0, 37, 38, 285, 0, - 412, 286, 287, 288, 289, 40, 41, 0, 290, 291, - 0, 0, 0, 0, 0, 0, 292, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 293, 0, 43, 0, 0, 0, 0, 0, 0, - 295, 296, 297, 298, 299, 300, 0, 0, 2, 204, + 25, 26, 27, -1, 67, 30, 31, 32, -1, -1, + -1, 74, 75, -1, 39, -1, -1, -1, 111, -1, + -1, -1, -1, -1, -1, -1, 119, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 67, -1, -1, -1, -1, -1, 111, 74, + 75, -1, -1, -1, -1, -1, 119, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, 111, -1, -1, -1, + -1, -1, 39, -1, 119, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 67, -1, 69, -1, 71, -1, -1, 74, 75, 37, + 38, -1, 40, 41, -1, 43, -1, -1, 46, 47, + 48, 49, 50, 51, 52, 53, -1, -1, 56, 57, + -1, -1, -1, 61, 62, -1, 64, -1, 66, -1, + -1, -1, -1, 110, 72, -1, -1, -1, 76, -1, + -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 94, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, 114, -1, -1, -1, + 118, 119, 120, 121, 122, 123, -1, -1, -1, -1, + 128, -1, 37, 38, 132, 40, 41, -1, 43, -1, + -1, 46, 47, 48, 49, 50, 51, 52, 53, -1, + -1, -1, 57, -1, -1, -1, 61, 62, -1, 64, + -1, 66, -1, -1, -1, -1, -1, 72, -1, -1, + -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, -1, 94, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 109, -1, 111, -1, -1, 114, + -1, -1, -1, 118, 119, 120, 121, 122, 123, -1, + -1, -1, -1, 128, -1, -1, -1, 132, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, -1, 30, 31, 32, -1, -1, -1, + -1, -1, -1, 39, -1, 37, 38, -1, 40, 41, + -1, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, -1, -1, 56, 57, -1, -1, -1, 61, + 62, 67, 64, 69, 66, 71, -1, -1, 74, 75, + 72, -1, -1, -1, 76, -1, -1, 79, 80, 81, + 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, + 96, -1, 94, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, + -1, -1, 114, -1, -1, -1, 118, 119, 120, 121, + 122, 123, -1, -1, 37, 38, 128, 40, 41, -1, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, -1, -1, -1, 57, -1, -1, -1, 61, 62, + -1, 64, -1, 66, -1, -1, -1, -1, -1, 72, + -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, + 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, + -1, 94, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 109, -1, 111, -1, + -1, 114, -1, -1, -1, 118, 119, 120, 121, 122, + 123, -1, -1, 37, 38, 128, 40, 41, -1, 43, + -1, -1, 46, 47, 48, 49, 50, 51, 52, 53, + -1, -1, -1, 57, -1, -1, -1, 61, 62, -1, + 64, -1, 66, -1, -1, -1, -1, -1, 72, -1, + -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, + 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, + 94, 37, 38, -1, 40, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, + 114, -1, -1, -1, 118, 119, 120, 121, 122, 123, + 66, -1, -1, -1, 128, -1, 72, -1, -1, -1, + 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, + 86, 87, -1, -1, -1, -1, -1, -1, 94, 37, + 38, -1, 40, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 109, -1, 111, -1, -1, 37, 38, + -1, 40, 118, 119, 120, 121, 122, 123, 66, -1, + -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, + -1, 79, 80, 81, 82, 83, 84, 66, 86, 87, + -1, -1, -1, 72, -1, -1, 94, 76, -1, -1, + 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + -1, 109, -1, 111, -1, 94, 37, 38, -1, 40, + 118, 119, 120, 121, 122, 123, -1, -1, -1, -1, + 109, -1, -1, -1, -1, 37, 38, -1, 40, 118, + 119, 120, 121, 122, 123, 66, -1, -1, -1, -1, + -1, 72, -1, -1, -1, 76, -1, -1, 79, 80, + 81, 82, 83, 84, 66, 86, 87, -1, -1, -1, + 72, -1, -1, 94, 76, -1, -1, 79, 80, 81, + 82, 83, 84, -1, 86, 87, -1, -1, 109, -1, + -1, -1, 94, 37, 38, -1, 40, 118, 119, 120, + 121, 122, 123, -1, -1, -1, -1, 109, -1, -1, + -1, -1, -1, -1, -1, -1, 118, 119, 120, 121, + 122, 123, 66, -1, -1, -1, -1, -1, 72, -1, + -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, + 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, + 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 109, -1, -1, -1, -1, + -1, -1, -1, -1, 118, 119, 120, 121, 122, 123, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 1449, 0, 25, 26, 27, 0, 0, 0, 0, - 280, 281, 30, 282, 0, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 0, 0, 25, 26, 27, 0, 0, 283, - 33, 0, 34, 30, 35, 284, 0, 37, 38, 285, - 0, 0, 286, 287, 288, 289, 40, 41, 0, 290, - 291, 0, 0, 0, 0, 0, 0, 292, 0, 0, - 0, 33, 0, 0, 0, 0, 108, 0, 37, 38, - 0, 0, 293, 1515, 342, 0, 0, 40, 41, 780, - 0, 295, 343, 297, 298, 299, 300, 2, 204, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 0, 0, 25, 26, 27, 0, 0, 0, 0, 280, - 281, 30, 282, 0, 0, 320, 0, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, -295, 0, 0, 0, 283, 33, - 0, 34, 0, 35, 284, 30, 37, 38, 285, 0, - 0, 286, 287, 288, 289, 40, 41, 0, 290, 291, - 0, 0, 0, 0, 0, 0, 292, 0, 0, 0, - 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, - 0, 293, 0, 930, -295, 0, 0, 0, 780, 0, - 295, 343, 297, 298, 299, 300, 2, 204, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, - 0, 25, 26, 27, 0, 0, 0, 0, 280, 281, - 30, 282, 0, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 0, 0, 25, 26, 27, 0, 0, 283, 33, 0, - 34, 30, 35, 284, 0, 37, 38, 285, 0, 0, - 286, 287, 288, 289, 40, 41, 0, 290, 291, 0, - 0, 0, 0, 0, 0, 292, 0, 0, 0, 33, - 0, 0, 0, 0, 0, 0, 37, 38, 0, 0, - 293, 0, 930, 0, 0, 0, 0, 780, 0, 295, - 599, 297, 298, 299, 300, 2, 204, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 0, 0, - 25, 26, 27, 0, 0, 0, 0, 280, 281, 30, - 282, 0, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, - 0, 25, 26, 27, 0, 0, 283, 33, 0, 34, - 30, 35, 284, 0, 37, 38, 285, 0, 0, 286, - 287, 288, 289, 40, 41, 0, 290, 291, 0, 0, - 0, 0, 0, 0, 292, 0, 0, 0, 33, 0, - 0, 0, 0, 0, 0, 205, 38, 0, 0, 293, - 0, 342, 0, 0, 0, 0, 0, 0, 295, 343, - 297, 298, 299, 300, 2, 204, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, - 26, 27, 0, 0, 0, 0, 280, 281, 30, 282, - 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 0, 0, - 0, 0, 0, 0, 0, 283, 33, 0, 34, 30, - 35, 284, 0, 37, 38, 285, 0, 0, 286, 287, - 288, 289, 40, 41, 0, 290, 291, 0, 0, 0, - 0, 0, 0, 292, 0, 0, 0, 33, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 293, 0, - 930, 0, 0, 0, 0, 0, 0, 295, 343, 297, - 298, 299, 300, 2, 204, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, - 27, 0, 0, 0, 0, 280, 281, 30, 282, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 283, 33, 0, 34, 0, 35, - 284, 0, 205, 38, 285, 0, 0, 286, 287, 288, - 289, 40, 41, 0, 290, 291, 0, 0, 0, 0, - 0, 0, 292, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 293, 0, 1019, - 0, 0, 0, 0, 0, 0, 295, 1020, 297, 298, - 299, 300, 2, 204, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, - 0, 0, 0, 0, 280, 281, 30, 282, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 283, 33, 0, 34, 0, 35, 284, - 0, 205, 38, 285, 0, 0, 286, 287, 288, 289, - 40, 41, 0, 290, 291, 0, 0, 0, 0, 0, - 0, 292, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 293, 0, 377, 0, - 0, 0, 0, 0, 0, 295, 379, 297, 298, 299, - 300, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, - 28, 0, 0, 29, 0, 0, 30, 31, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 32, 0, 0, 33, 0, 34, 0, 35, 36, - 0, 37, 38, 39, 0, 0, 0, 0, 0, 0, - 40, 41, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 42, 0, 43, 0, - 0, 0, -520, 0, 0, 0, 44, 203, 2, 204, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 0, 0, 25, 26, 27, 0, 0, 0, 0, - 0, 0, 30, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 0, 0, 25, 26, 27, 491, 492, 493, 0, 0, - 33, 30, 34, 0, 35, 36, 0, 205, 38, 39, - 0, 0, 0, 0, 0, 0, 40, 41, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, - 0, 0, 0, 0, 0, 0, 37, 38, 0, 0, - 0, 0, 42, 0, 206, 0, 0, 0, 0, 0, - 0, 0, 207, 1, 2, 204, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, -294, 0, 25, - 26, 27, 28, 0, 0, 29, 0, 0, 30, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 33, 0, 34, 0, - 35, 0, 0, 37, 38, 0, 0, -294, 0, 1, - 2, 204, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 0, 0, 25, 26, 27, 28, 0, - 43, 29, 0, 0, 30, 0, 0, 0, 109, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 33, 0, 34, 0, 35, 0, 0, 37, - 38, 0, 203, 2, 204, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, - 27, 0, 0, 0, 0, 0, 43, 30, 0, 0, - 0, 0, 0, 0, 109, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 33, 0, 34, 0, 35, - 0, 0, 205, 38, 2, 204, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, - 26, 27, 0, 0, 0, 0, 0, 0, 30, 206, - 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 33, 0, 34, 0, - 35, 36, 0, 205, 38, 39, 0, 0, 0, 0, - 0, 0, 40, 41, 0, 0, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 0, 0, 25, 26, 27, 42, 0, - 206, 0, 0, 0, 30, 0, 0, 0, 207, 2, - 204, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 33, 0, 25, 26, 27, 36, 0, 37, - 38, 39, 0, 30, 0, 0, 0, 0, 40, 41, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 33, 0, 34, 42, 35, 43, 0, 37, 38, - 0, 0, 0, 0, 44, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1368, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 686, 0, 0, 0, 0, - 0, 0, 0, 633, 2, 204, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, - 26, 27, 0, 0, 0, 0, 0, 0, 30, 0, - 0, 0, 0, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 0, 0, 25, 26, 27, 0, 33, 0, 34, 0, - 35, 30, 0, 37, 38, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1370, 0, 0, 0, 33, - 0, 0, 0, 0, 36, 0, 335, 336, 39, 0, - 686, 0, 0, 0, 0, 40, 41, 0, 633, 2, - 204, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 0, 337, 25, 26, 27, 0, 0, 0, - 0, 109, 0, 30, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 33, 0, 34, 0, 35, 0, 0, 205, 38, - 2, 204, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 0, 0, 25, 26, 27, 0, 0, - 0, 0, 0, 0, 30, 268, 0, 0, 0, 0, - 0, 0, 0, 628, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 33, 0, 34, 0, 35, 0, 0, 37, - 38, 2, 204, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, - 0, 0, 0, 0, 0, 30, 686, 0, 0, 0, - 0, 0, 0, 0, 633, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 33, 0, 34, 0, 35, 0, 0, - 37, 38, 2, 204, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, - 0, 0, 0, 0, 0, 0, 30, 598, 0, 0, - 0, 0, 0, 0, 0, 633, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 33, 0, 34, 0, 35, 0, - 0, 205, 38, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 0, 0, 25, 26, 27, 0, 0, 0, 0, 280, - 281, 30, 282, 0, 0, 0, 0, 0, 206, 0, - 0, 0, 0, 0, 0, 0, 269, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 283, 33, - 0, 0, 0, 0, 284, 0, 37, 38, 285, 0, - 0, 286, 287, 288, 289, 40, 41, 0, 290, 291, - 0, 0, 0, 0, 0, 0, 292, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 293, 0, 524, 0, 0, 169, 0, 0, 0, - 295, 296, 297, 298, 299, 300, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 0, 0, 25, 26, 27, 0, 0, - 0, 0, 280, 281, 30, 282, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, -294, 0, 25, 26, 27, 0, 0, - 0, 283, 33, 0, 30, 0, 0, 284, 0, 37, - 38, 285, 0, 0, 286, 287, 288, 289, 40, 41, - 0, 290, 291, 0, 0, 0, 0, 0, 0, 292, - 0, 0, 33, 0, 0, 0, 0, 36, 0, 335, - 336, 39, 0, -294, 293, 0, 598, -3, 40, 41, - 0, 0, 0, 295, 599, 297, 298, 299, 300, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 337, 0, 25, 26, - 27, 0, 0, 0, 109, 280, 281, 30, 282, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 0, 0, 25, 26, - 27, 0, 0, 0, 283, 33, 0, 30, 0, 0, - 648, 0, 37, 38, 285, 0, 0, 286, 287, 288, - 289, 40, 41, 0, 290, 291, 0, 0, 0, 0, - 0, 0, 292, 0, 0, 33, 0, 0, 0, 0, - 108, 0, 37, 38, 0, 0, 0, 293, -35, 765, - 0, 40, 41, 0, 0, 0, 295, 296, 297, 298, - 299, 300, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 43, - 0, 25, 26, 27, 0, 0, 0, 109, 280, 281, - 30, 282, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, - 0, 25, 26, 27, 0, 0, 0, 283, 33, 0, - 30, 452, 0, 284, 0, 37, 38, 285, 0, 0, - 286, 287, 288, 289, 40, 41, 0, 290, 291, 0, - 0, 0, 0, 0, 0, 292, 0, 0, 33, 0, - 0, 0, 0, 0, 0, 37, 38, 0, 0, 0, - 293, 0, 294, 0, 0, 0, 0, 0, 0, 295, - 296, 297, 298, 299, 300, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 453, 0, 25, 26, 27, 0, 0, 0, - 109, 280, 281, 30, 282, 0, 0, 0, 0, 0, - 0, 0, 0, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 283, 33, 25, 26, 27, 0, 284, 0, 37, 38, - 285, 30, 0, 286, 287, 288, 289, 40, 41, 0, - 290, 291, 0, 0, 0, 0, 0, 0, 292, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, - 0, 0, 0, 293, 0, 155, 37, 38, 0, 0, - 0, 0, 295, 296, 297, 298, 299, 300, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, - 0, 642, 0, 337, 280, 281, 30, 282, 0, 0, - 0, 109, 0, 0, 0, 0, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 283, 33, 25, 26, 27, 0, 284, - 0, 37, 38, 285, 30, 0, 286, 287, 288, 289, - 40, 41, 0, 290, 291, 0, 0, 0, 0, 0, - 0, 292, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 33, 0, 0, 0, 293, 0, 598, 37, - 38, 0, 0, 0, 0, 295, 599, 297, 298, 299, - 300, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 0, 0, - 25, 26, 27, 0, 642, 0, 337, 280, 281, 30, - 282, 0, 0, 0, 633, 0, 0, 0, 0, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 283, 33, 25, 26, - 27, 0, 284, 0, 37, 38, 285, 30, 452, 286, - 287, 288, 289, 40, 41, 0, 290, 291, 0, 0, - 0, 0, 0, 0, 292, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 33, 0, 0, 0, 293, - 0, 377, 37, 38, 0, 0, 0, 0, 295, 379, - 297, 298, 299, 300, 473, 2, 204, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 0, 453, - 25, 26, 27, 1234, 0, 0, 0, 109, 0, 30, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, - 26, 27, 0, 0, 0, 0, 0, 33, 30, 34, - 0, 35, 0, 0, 37, 38, 0, 0, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 0, 33, 25, 26, 27, - 0, 36, 0, 205, 38, 39, 30, 0, 0, 0, - 0, 0, 40, 41, -3, 0, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 0, 33, 25, 26, 27, 42, 36, - 268, 335, 336, 39, 30, 0, 0, 0, 207, 0, - 40, 41, 0, 0, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 0, 33, 25, 26, 27, 642, 0, 337, 37, - 38, 0, 30, 0, 0, 0, 633, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, - 33, 0, 0, 0, 0, 30, 255, 37, 38, 0, - 0, 0, 0, 0, 109, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 0, 33, 25, 26, 27, 0, 0, 0, - 205, 38, 0, 30, 155, 0, 0, 0, 0, 0, - 0, 0, 109, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 0, 33, 25, 26, 27, 0, 0, 268, 37, 38, - 0, 30, 0, 0, 0, 269, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 0, 0, 25, 26, 27, 0, 33, - 0, 0, 0, 0, 30, 255, 37, 38, 0, 0, - 0, 0, 0, 633, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 0, 33, 25, 26, 27, 0, 0, 0, 37, - 38, 0, 30, 337, 0, 0, 0, 0, 0, 0, - 0, 633, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 0, - 33, 25, 26, 27, 0, 0, 453, 205, 38, 0, - 30, 0, 0, 0, 109, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 0, 0, 25, 26, 27, 0, 33, 0, - 0, 0, 0, 30, 268, 37, 38, 0, 0, 0, - 0, 0, 628, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 0, 33, 25, 26, 27, 0, 0, 0, 37, 38, - 0, 30, 598, 0, 0, 0, 0, 0, 0, 0, - 633, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, - 0, 0, 0, 0, 0, 337, 37, 38, 0, 0, - 0, 0, 0, 109, 2, 204, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, - 26, 27, 0, 43, 0, 0, 0, 0, 30, 0, - 0, 109, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 33, 0, 34, 0, - 35, 0, 0, 37, 38, 280, 281, 0, 282, 1062, - 0, 1063, 0, 0, 1064, 1065, 1066, 1067, 1068, 1069, - 1070, 1071, 0, 0, 1548, 1072, 0, 0, 0, 1073, - 1074, 0, 32, 0, 283, 0, 0, 0, 0, -412, - 648, 0, 0, 0, 285, 0, 0, 286, 287, 288, - 289, 40, 41, 0, 290, 291, 0, 0, 0, 0, - 0, 0, 292, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 293, 0, 377, - 0, 0, 169, 0, 0, 0, 295, 379, 297, 298, - 299, 300, 0, 0, 0, 0, 1076, 0, 280, 281, - -129, 282, 1062, 0, 1063, 0, 0, 1064, 1065, 1066, - 1067, 1068, 1069, 1070, 1071, 0, 0, 0, 1072, 0, - 0, 0, 1073, 1074, 0, 32, 0, 283, 0, 0, - 0, 0, 0, 648, 0, 0, 0, 285, 0, 0, - 286, 287, 288, 289, 40, 41, 0, 290, 291, 0, - 0, 0, 0, 0, 0, 292, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 293, 0, 377, 0, 0, 169, 0, 0, 0, 295, - 379, 297, 298, 299, 300, 0, 0, 0, 0, 1076, - 0, 280, 281, -129, 282, 1062, 0, 1063, 1418, 1419, - 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 0, 0, - 1548, 1072, 0, 0, 0, 1073, 1074, 0, 32, 0, - 283, 0, 0, 0, 0, 0, 648, 0, 0, 0, - 285, 0, 0, 286, 287, 288, 289, 40, 41, 0, - 290, 291, 0, 0, 0, 0, 0, 0, 292, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 293, 0, 377, 0, 0, 169, 0, - 0, 0, 295, 379, 297, 298, 299, 300, 0, 0, - 280, 281, 1076, 282, 1062, 0, 1063, 1418, 1419, 1064, - 1065, 1066, 1067, 1068, 1069, 1070, 1071, 0, 0, 0, - 1072, 0, 0, 0, 1073, 1074, 0, 32, 0, 283, - 0, 0, 0, 0, 0, 648, 0, 0, 0, 285, - 0, 0, 286, 287, 288, 289, 40, 41, 0, 290, - 291, 0, 0, 0, 0, 0, 0, 292, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 293, 0, 377, 0, 0, 169, 0, 0, - 0, 295, 379, 297, 298, 299, 300, 0, 0, 280, - 281, 1076, 282, 1062, 0, 1063, 0, 0, 1064, 1065, - 1066, 1067, 1068, 1069, 1070, 1071, 0, 0, 0, 1072, - 0, 0, 0, 1073, 1074, 0, 32, 0, 283, 0, - 0, 0, 0, 0, 648, 0, 0, 0, 285, 0, - 0, 286, 287, 288, 289, 40, 41, 0, 290, 291, - 0, 0, 0, 0, 0, 0, 292, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 293, 0, 377, 0, 0, 169, 0, 0, 0, - 295, 379, 297, 298, 299, 300, 0, 0, 0, 0, - 1076, 2, 204, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, - 0, 0, 0, 0, 0, 30, 0, 280, 281, 0, - 282, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 280, 281, 0, 282, - 0, 0, 0, 33, 0, 34, 283, 35, 0, 0, - 37, 38, 284, 0, 0, 0, 285, 0, 0, 286, - 287, 288, 289, 40, 41, 283, 290, 291, 0, 0, - 0, 648, 1327, 0, 292, 285, 0, 0, 286, 287, - 288, 289, 40, 41, 0, 290, 291, 0, 0, 293, - 0, 377, 0, 292, 280, 281, 0, 282, 295, 733, - 297, 298, 299, 300, 0, 0, 0, 0, 293, 0, - 784, 0, 0, 280, 281, 0, 282, 295, 379, 297, - 298, 299, 300, 283, 0, 0, 0, 0, 0, 284, - 0, 0, 0, 285, 0, 0, 286, 287, 288, 289, - 40, 41, 283, 290, 291, 0, 0, 0, 284, 0, - 0, 292, 285, 0, 0, 286, 287, 288, 289, 40, - 41, 0, 290, 291, 0, 0, 293, 0, 377, 0, - 292, 280, 281, 0, 282, 295, 826, 297, 298, 299, - 300, 0, 0, 0, 0, 517, 0, 0, 0, 0, - 0, 0, 0, 0, 295, 379, 297, 298, 299, 300, - 283, 0, 0, 0, 0, 0, 284, 0, 0, 0, - 285, 0, 0, 286, 287, 288, 289, 40, 41, 0, - 290, 291, 0, 0, 0, 0, 0, 0, 292, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 520, 0, 0, 0, 0, 0, 0, - 0, 0, 295, 379, 297, 298, 299, 300, 2, 204, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 33, 0, 34, 0, 35, 36, 0, 172, 173, 39, - 0, 0, 0, 0, 0, 0, 40, 41, 203, 2, - 204, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 0, 0, 25, 26, 27, 0, 0, 0, - 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 33, 0, 34, 0, 35, 0, 0, 205, 38, - 473, 2, 204, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 0, 0, 25, 26, 27, 0, - 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 33, 0, 34, 0, 35, 0, 0, - 37, 38, 2, 204, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 0, 0, 25, 26, 27, - 0, 0, 0, 0, 0, 0, 30, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 33, 0, 34, 0, 35, 0, - 0, 205, 38 -}; - -#define yypact_value_is_default(yystate) \ - ((yystate) == (-1281)) - -#define yytable_value_is_error(yytable_value) \ - YYID (0) - -static const yytype_int16 yycheck[] = -{ - 0, 1, 0, 42, 237, 217, 183, 183, 202, 42, - 0, 1, 1, 183, 42, 542, 183, 183, 114, 103, - 184, 455, 519, 343, 0, 0, 628, 454, 28, 29, - 183, 31, 697, 31, 697, 183, 498, 697, 610, 608, - 502, 31, 42, 679, 44, 461, 44, 347, 1042, 496, - 279, 901, 655, 1, 54, 31, 31, 166, 167, 608, - 60, 1061, 60, 63, 608, 63, 66, 610, 66, 153, - 347, 0, 578, 63, 1005, 277, 66, 66, 416, 998, - 80, 81, 1041, 1042, 184, 608, 263, 263, 63, 779, - 42, 362, 185, 263, 608, 366, 263, 263, 436, 31, - 264, 528, 31, 199, 104, 1337, 444, 107, 608, 27, - 263, 776, 0, 776, 114, 263, 776, 42, 608, 722, - 642, 643, 644, 1054, 758, 424, 425, 611, 38, 254, - 643, 644, 38, 617, 81, 42, 62, 106, 1418, 661, - 0, 1, 63, 31, 183, 145, 44, 145, 661, 109, - 183, 81, 108, 153, 226, 183, 116, 1422, 158, 77, - 158, 130, 38, 110, 264, 612, 259, 260, 488, 616, - 50, 31, 44, 245, 743, 109, 43, 44, 814, 109, - 1073, 1074, 116, 183, 184, 81, 184, 108, 824, 54, - 637, 43, 44, 38, 641, 38, 408, 84, 108, 199, - 110, 500, 63, 839, 110, 131, 66, 207, 1440, 207, - 901, 109, 1492, 735, 43, 44, 216, 494, 108, 219, - 519, 219, 735, 38, 263, 112, 226, 81, 108, 219, - 263, 183, 108, 11, 110, 263, 115, 109, 108, 104, - 404, 241, 107, 743, 219, 245, 1240, 114, 1141, 249, - 250, 249, 131, 743, 115, 1520, 340, 113, 183, 249, - 1525, 113, 116, 263, 264, 108, 264, 110, 115, 838, - 270, 38, 144, 249, 249, 0, 183, 277, 850, 599, - 1545, 510, 3, 717, 113, 369, 585, 1552, 81, 838, - 454, 416, 292, 108, 838, 110, 1290, 158, 394, 1474, - 111, 1525, 250, 1303, 404, 827, 31, 850, 628, 207, - 610, 436, 818, 633, 827, 838, 109, 249, 1008, 444, - 249, 1545, 486, 116, 838, 596, 422, 327, 1552, 327, - 1289, 1290, 428, 81, 1509, 207, 1511, 1256, 838, 94, - 238, 108, 95, 110, 292, 111, 346, 347, 838, 115, - 81, 216, 690, 95, 454, 1525, 840, 115, 219, 698, - 108, 249, 3, 363, 1, 237, 254, 367, 639, 122, - 1061, 269, 71, 348, 129, 1225, 696, 108, 378, 71, - 122, 720, 1552, 82, 83, 108, 486, 959, 108, 249, - 82, 83, 114, 115, 394, 293, 257, 269, 296, 71, - 261, 108, 1038, 1039, 404, 270, 404, 44, 130, 958, - 82, 83, 277, 115, 958, 71, 0, 115, 1020, 0, - 1414, 115, 422, 130, 296, 872, 82, 83, 428, 131, - 430, 488, 131, 131, 109, 958, 1070, 131, 110, 131, - 115, 67, 115, 89, 90, 71, 675, 531, 74, 115, - 76, 130, 772, 115, 454, 1414, 71, 83, 131, 459, - 1096, 1097, 118, 1463, 464, 131, 103, 82, 83, 131, - 1470, 343, 109, 473, 108, 1406, 1407, 115, 478, 125, - 126, 346, 109, 108, 109, 109, 486, 348, 486, 116, - 490, 115, 490, 131, 494, 110, 109, 497, 363, 499, - 490, 71, 367, 130, 479, 967, 1003, 144, 120, 121, - 937, 927, 82, 83, 490, 490, 153, 964, 945, 519, - 697, 697, 115, 1523, 249, 473, 108, 697, 416, 254, - 697, 697, 761, 108, 1225, 699, 536, 1140, 131, 539, - 110, 541, 542, 1115, 697, 1029, 1030, 656, 436, 697, - 850, 108, 424, 425, 452, 757, 444, 455, 829, 87, - 88, 490, 833, 461, 991, 690, 203, 663, 429, 71, - 207, 519, 665, 850, 115, 10, 11, 12, 13, 14, - 82, 83, 115, 108, 210, 642, 643, 644, 536, 589, - 131, 539, 470, 541, 542, 109, 596, 115, 131, 699, - 237, 238, 490, 38, 661, 109, 108, 732, 608, 115, - 610, 695, 1303, 131, 512, 71, 514, 115, 479, 517, - 111, 597, 520, 109, 115, 131, 82, 83, 500, 629, - 490, 66, 269, 131, 1270, 272, 109, 79, 977, 696, - 282, 589, 1278, 1279, 1280, 645, 71, 519, 73, 74, - 109, 651, 923, 295, 296, 630, 293, 82, 83, 296, - 660, 111, 662, 663, 664, 307, 114, 1101, 110, 1303, - 112, 79, 3, 111, 116, 887, 108, 115, 735, 10, - 11, 12, 13, 14, 91, 92, 963, 771, 113, 0, - 1326, 416, 109, 108, 293, 110, 908, 697, 115, 699, - 1020, 343, 110, 340, 112, 111, 343, 38, 116, 115, - 108, 436, 712, 585, 662, 772, 664, 118, 718, 444, - 31, 131, 123, 124, 350, 362, 352, 599, 71, 366, - 730, 42, 369, 44, 111, 66, 969, 379, 115, 82, - 83, 602, 108, 743, 744, 109, 1380, 109, 723, 60, - 1131, 115, 63, 115, 1135, 66, 628, 757, 108, 63, - 110, 633, 737, 488, 629, 490, 108, 110, 118, 630, - 827, 1495, 1463, 937, 635, 108, 108, 1501, 110, 1470, - 645, 945, 730, 108, 893, 110, 118, 424, 425, 111, - 109, 109, 1319, 118, 1133, 660, 115, 115, 1522, 113, - 109, 679, 690, 1527, 131, 52, 115, 113, 512, 71, - 514, 73, 74, 517, 440, 452, 520, 109, 455, 717, - 82, 83, 109, 115, 461, 424, 425, 128, 115, 130, - 113, 1102, 1523, 1467, 145, 1469, 473, 937, 838, 1033, - 1160, 114, 115, 109, 732, 945, 108, 158, 95, 115, - 850, 113, 1191, 1192, 109, 108, 831, 110, 834, 131, - 115, 498, 723, 500, 1529, 502, 1529, 131, 109, 1529, - 115, 116, 183, 184, 115, 512, 737, 514, 109, 109, - 517, 109, 519, 520, 115, 115, 71, 115, 73, 74, - 1524, 108, 757, 893, 531, 108, 207, 82, 83, 109, - 900, 901, 1131, 109, 109, 115, 1135, 1136, 219, 115, - 115, 901, 81, 512, 556, 557, 558, 108, 517, 110, - 1240, 520, 108, 923, 110, 901, 901, 109, 110, 4, - 5, 6, 7, 8, 9, 108, 814, 937, 249, 71, - 111, 73, 74, 81, 191, 945, 824, 1056, 585, 119, - 82, 83, 263, 901, 108, 109, 110, 599, 108, 596, - 110, 839, 599, 963, 108, 690, 110, 214, 57, 58, - 831, 696, 108, 109, 110, 574, 108, 224, 968, 968, - 108, 113, 110, 983, 1041, 4, 5, 6, 7, 8, - 9, 628, 992, 68, 127, 70, 633, 108, 109, 110, - 1000, 128, 639, 1003, 130, 1005, 71, 732, 73, 74, - 75, 110, 108, 901, 110, 3, 327, 82, 83, 114, - 115, 1250, 10, 11, 12, 13, 14, 1123, 71, 927, - 73, 74, 75, 115, 116, 983, 347, 115, 116, 82, - 83, 901, 108, 108, 110, 110, 293, 772, 1023, 68, - 38, 70, 1000, 118, 1054, 1003, 131, 1005, 695, 108, - 109, 110, 1401, 93, 1064, 108, 108, 1067, 1068, 1069, - 108, 1061, 10, 11, 12, 13, 14, 1504, 66, 1418, - 717, 563, 564, 565, 566, 1061, 1061, 71, 111, 73, - 74, 733, 1092, 404, 43, 44, 44, 969, 82, 83, - 38, 111, 702, 1160, 704, 109, 1054, 109, 968, 1338, - 747, 109, 60, 1342, 109, 63, 1064, 109, 66, 1067, - 1068, 1069, 3, 1123, 561, 562, 110, 1554, 66, 10, - 11, 12, 13, 14, 771, 109, 1220, 779, 71, 108, - 73, 74, 75, 454, 111, 109, 111, 111, 1020, 82, - 83, 115, 1491, 1492, 57, 58, 59, 38, 567, 568, - 1038, 1039, 1023, 1262, 1263, 1264, 130, 131, 559, 560, - 108, 110, 110, 1061, 115, 108, 901, 130, 113, 490, - 118, 108, 111, 494, 826, 66, 109, 109, 116, 115, - 111, 111, 829, 111, 441, 111, 833, 145, 1198, 116, - 28, 1061, 116, 1101, 109, 84, 85, 86, 109, 111, - 158, 109, 1202, 1203, 1203, 1444, 113, 116, 1096, 1097, - 1220, 114, 114, 114, 108, 1225, 115, 1202, 475, 108, - 115, 110, 1289, 112, 113, 1225, 184, 109, 4, 5, - 6, 7, 8, 9, 131, 109, 109, 116, 109, 1225, - 1225, 109, 109, 115, 1244, 1244, 71, 109, 109, 207, - 75, 109, 1262, 1263, 1264, 512, 32, 82, 83, 109, - 517, 219, 109, 520, 109, 109, 71, 1225, 73, 74, - 75, 84, 85, 86, 109, 109, 923, 82, 83, 470, - 927, 109, 109, 108, 114, 110, 109, 608, 109, 610, - 28, 1397, 68, 118, 70, 108, 1539, 110, 1298, 112, - 113, 698, 111, 1303, 1262, 1263, 1264, 109, 130, 1319, - 1320, 109, 109, 1298, 114, 109, 115, 1303, 1303, 111, - 967, 968, 969, 720, 111, 109, 1061, 1225, 71, 109, - 115, 1202, 75, 1203, 109, 901, 115, 1337, 1337, 82, - 83, 115, 1529, 1529, 116, 113, 111, 71, 109, 1529, - 1238, 75, 1529, 1529, 111, 1225, 1530, 115, 82, 83, - 115, 1319, 1320, 109, 1374, 108, 1529, 1377, 1020, 327, - 109, 1529, 108, 1020, 1244, 118, 697, 108, 699, 108, - 1554, 108, 1270, 108, 108, 111, 1396, 1397, 116, 131, - 1278, 1279, 1280, 114, 118, 109, 1406, 1407, 1504, 71, - 109, 73, 74, 75, 109, 1303, 0, 1, 128, 1061, - 82, 83, 1422, 114, 811, 113, 1374, 1427, 111, 1377, - 1530, 678, 743, 744, 131, 1160, 109, 1298, 115, 111, - 687, 115, 111, 1303, 691, 1445, 109, 31, 1326, 109, - 1440, 1440, 109, 111, 1554, 111, 404, 1457, 1406, 1407, - 44, 111, 109, 54, 1101, 1102, 111, 111, 111, 46, - 29, 109, 131, 1463, 1422, 114, 131, 1337, 131, 1427, - 1470, 71, 66, 73, 74, 75, 114, 1463, 1463, 131, - 1529, 131, 82, 83, 1470, 1470, 1529, 1445, 679, 116, - 1225, 1529, 889, 109, 1504, 1505, 111, 114, 1064, 1457, - 111, 111, 111, 104, 1514, 1240, 107, 111, 108, 103, - 1520, 80, 81, 111, 111, 1525, 111, 838, 118, 1529, - 1530, 1396, 1530, 1523, 109, 1177, 109, 111, 108, 850, - 111, 63, 108, 1543, 108, 1545, 59, 1523, 1523, 1549, - 113, 109, 1552, 109, 1554, 131, 1554, 1505, 80, 116, - 1560, 145, 153, 111, 1564, 111, 1514, 109, 111, 153, - 154, 109, 1520, 108, 1472, 1463, 1474, 1525, 1303, 95, - 1440, 95, 1470, 1220, 108, 114, 131, 115, 111, 109, - 977, 109, 109, 115, 109, 1543, 41, 1545, 131, 131, - 184, 1549, 95, 1463, 1552, 1204, 1205, 1244, 1207, 116, - 1470, 1509, 1560, 1511, 1213, 199, 1564, 1216, 202, 203, - 109, 1008, 109, 207, 95, 216, 937, 131, 109, 109, - 131, 116, 131, 814, 945, 1523, 158, 109, 114, 109, - 50, 131, 52, 824, 228, 55, 56, 57, 232, 59, - 234, 111, 963, 111, 108, 114, 131, 114, 839, 243, - 109, 109, 131, 1523, 74, 249, 109, 1539, 109, 1225, - 254, 1058, 1076, 569, 1225, 570, 86, 87, 925, 270, - 264, 571, 241, 1492, 63, 573, 277, 1382, 272, 572, - 25, 26, 27, 1564, 73, 1313, 1136, 219, 1342, 1470, - 1337, 10, 11, 12, 13, 14, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 1092, 29, 30, 31, 452, 38, - 452, 945, 704, 464, 38, 257, 115, 893, 1463, 261, - 947, 992, 589, 965, 657, 1470, 1133, 747, 1244, 490, - 757, 577, -1, -1, 577, 346, 340, 66, 577, 343, - -1, 96, 66, 98, 1320, 349, -1, -1, -1, 73, - 74, -1, 363, 77, -1, -1, 367, 1376, 362, 158, - -1, -1, 366, -1, -1, 369, -1, 10, 11, 12, - 13, 14, -1, -1, -1, -1, -1, -1, 1523, 108, - -1, 110, -1, 1440, 1191, 1192, 110, -1, -1, 118, - -1, -1, -1, -1, 118, 38, -1, -1, 1374, 378, - -1, 1377, -1, -1, -1, 1072, 348, -1, -1, -1, - -1, -1, 416, -1, -1, 1472, -1, 1474, -1, 430, - 219, -1, -1, 66, 179, -1, -1, 431, -1, -1, - -1, -1, 436, -1, 189, 190, -1, 1038, 1039, 194, - 444, 196, 197, -1, -1, -1, 1422, -1, -1, -1, - -1, 1427, 1509, -1, 1511, -1, -1, -1, 257, -1, - -1, -1, 261, -1, -1, 108, 470, 110, -1, 473, - -1, -1, -1, -1, -1, 118, -1, -1, 277, -1, - 459, 1457, 1539, -1, 488, 464, 490, 429, -1, 10, - 11, 12, 13, 14, 498, 1096, 1097, -1, 502, -1, - -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, - 13, 14, -1, 343, 344, -1, -1, 38, 497, 71, - 499, 73, 74, 75, -1, 355, 356, 531, 532, -1, - 82, 83, -1, -1, -1, 38, -1, 479, -1, -1, - -1, -1, -1, -1, -1, 66, -1, -1, -1, 348, - 71, -1, 73, 74, 75, -1, 108, -1, 110, -1, - -1, 82, 83, 66, 116, -1, 118, 1543, 71, -1, - 73, 74, 75, 1549, 578, -1, -1, -1, -1, 82, - 83, -1, -1, -1, 1560, 596, -1, 108, 1564, 110, - -1, -1, 596, 597, 1401, 599, -1, 118, -1, -1, - -1, -1, -1, -1, -1, 108, 610, 110, -1, -1, - -1, 1418, -1, -1, -1, 118, -1, -1, 629, -1, - -1, -1, -1, -1, 628, -1, -1, -1, -1, 633, - 429, -1, -1, -1, 645, 639, -1, 1238, 642, 643, - 644, -1, -1, -1, -1, 1312, -1, 446, -1, 660, - 71, -1, 73, 74, 75, -1, -1, 661, -1, -1, - 602, 82, 83, -1, -1, -1, -1, -1, -1, 1270, - -1, -1, 651, -1, -1, 679, -1, 1278, 1279, 1280, - 479, -1, -1, -1, 1491, 1492, 690, 108, 630, 110, - -1, 695, 696, 635, -1, 699, -1, 118, -1, -1, - -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 0, -1, - 29, 30, 31, -1, -1, 1326, -1, -1, 732, 38, - 39, 735, -1, 712, -1, -1, -1, -1, -1, 718, - 744, -1, -1, 747, -1, 0, 757, -1, -1, 31, - 71, -1, 73, 74, 75, -1, -1, 66, -1, -1, - -1, 82, 83, -1, 73, 74, -1, 771, 772, -1, - -1, -1, -1, 777, -1, -1, 31, -1, -1, -1, - -1, 723, -1, -1, 66, -1, -1, 108, -1, 110, - -1, -1, -1, -1, -1, 737, -1, 118, 1529, -1, - -1, 110, -1, 602, 1471, 114, 1473, -1, -1, 118, - 814, 66, -1, -1, -1, -1, -1, -1, -1, -1, - 824, -1, -1, 827, -1, 829, 581, 582, 832, 833, - 834, 630, -1, -1, -1, 839, 635, -1, -1, -1, - -1, 1508, -1, 1510, -1, 849, 71, -1, 73, 74, - 75, -1, -1, -1, -1, -1, 611, 82, 83, 614, - 615, -1, 617, -1, 619, 620, -1, -1, -1, 624, - 625, -1, 154, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 108, -1, -1, 1553, -1, 1555, 831, - -1, -1, -1, 118, 724, -1, 726, 901, -1, 154, - -1, 1568, 1569, 733, 734, -1, -1, 130, 738, -1, - -1, -1, 923, -1, 893, -1, 187, -1, -1, 923, - 750, 900, -1, 194, 723, 755, -1, -1, 10, 11, - 12, 13, 14, -1, -1, -1, -1, -1, 737, -1, - -1, -1, -1, -1, -1, -1, 228, -1, -1, -1, - -1, 781, -1, 708, 709, 959, 38, -1, 757, 714, - -1, -1, -1, 967, 968, -1, -1, 249, -1, -1, - -1, -1, 254, -1, -1, -1, -1, -1, -1, -1, - -1, 985, -1, -1, 66, -1, -1, -1, -1, 71, - -1, 73, 74, 75, 249, 266, 826, -1, -1, 254, - 82, 83, -1, -1, -1, -1, 25, 26, 27, -1, - -1, -1, -1, 992, -1, -1, 1020, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 108, -1, 110, 1033, - -1, -1, 831, -1, 1038, 1039, 118, 1041, 1042, -1, - -1, -1, -1, -1, 10, 11, 12, 13, 14, -1, - -1, 322, -1, 883, 884, 885, 886, 1061, 888, 330, - -1, -1, 333, -1, -1, -1, -1, 349, -1, -1, - -1, -1, 38, -1, 904, -1, -1, 96, -1, 98, - -1, 1023, -1, -1, -1, -1, -1, -1, 918, -1, - -1, -1, 1096, 1097, 349, -1, -1, -1, 1102, -1, - 66, -1, -1, -1, 123, 71, -1, 73, 74, 75, - -1, -1, -1, 1092, -1, -1, 82, 83, -1, -1, - -1, -1, -1, -1, -1, 396, -1, 957, -1, 400, - -1, -1, -1, -1, 416, -1, -1, -1, -1, -1, - -1, -1, 108, -1, -1, -1, -1, -1, -1, 431, - -1, -1, 118, -1, 436, -1, 1160, -1, -1, -1, - 179, 416, 444, -1, -1, -1, -1, 997, 187, -1, - 189, 190, -1, -1, 1004, 194, 431, 196, 197, 1009, - -1, 436, -1, -1, 1014, -1, 1016, -1, 470, 444, - 1020, 1021, 1022, -1, -1, 1025, -1, -1, -1, 1203, - -1, -1, -1, -1, 1034, -1, 488, -1, 490, 1220, - -1, -1, -1, -1, 485, 470, 1220, -1, -1, 1198, - -1, 1225, 1052, 1053, 1023, -1, -1, -1, 10, 11, - 12, 13, 14, 488, 1238, 490, 1240, -1, -1, -1, - 1244, -1, -1, -1, -1, -1, -1, 266, -1, 1079, - 532, -1, 1082, -1, -1, -1, 38, -1, -1, -1, - 1202, -1, -1, -1, -1, -1, 1270, -1, -1, -1, - -1, -1, -1, -1, 1278, 1279, 1280, 532, -1, -1, - -1, -1, -1, -1, 66, 1289, 1290, -1, -1, 71, - 1120, 73, 74, 75, -1, -1, 1126, 1127, -1, 1303, - 82, 83, -1, -1, -1, -1, 577, 578, 1138, -1, - -1, -1, -1, 1143, -1, 597, 1146, -1, 1148, -1, - -1, 1151, 1326, -1, -1, -1, 108, -1, -1, -1, - -1, -1, -1, 1337, 1164, -1, 118, -1, -1, -1, - -1, -1, 597, 1098, -1, -1, -1, 1177, -1, 1179, - 1180, 1181, 1182, -1, -1, -1, 1298, -1, -1, -1, - 642, 643, 644, -1, -1, 1195, -1, 1197, -1, -1, - -1, 1201, -1, -1, -1, -1, -1, -1, -1, 661, - -1, -1, -1, -1, -1, 1396, -1, 642, 643, 644, - -1, -1, -1, -1, -1, 666, -1, 679, -1, 670, - 1230, 1231, -1, 1202, -1, -1, 661, -1, 690, -1, - 1414, -1, 0, -1, 696, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 679, -1, -1, -1, -1, -1, - -1, -1, 703, -1, -1, 690, 1440, -1, -1, 0, - -1, 696, -1, 31, -1, 0, 1, -1, -1, -1, - 732, 1281, 1282, 735, -1, -1, -1, -1, -1, 1463, - -1, 1291, -1, -1, -1, -1, 1470, 1222, -1, -1, - 31, -1, -1, -1, -1, -1, 31, 732, 66, -1, - 735, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 772, -1, -1, -1, -1, -1, -1, -1, -1, 1298, - -1, -1, -1, -1, -1, 66, -1, -1, 63, -1, - -1, 66, -1, 1343, -1, -1, -1, 772, -1, 1523, - -1, -1, -1, -1, -1, 1355, 1530, 1357, 1358, 1359, - -1, -1, 814, -1, -1, -1, -1, -1, -1, 1369, - -1, -1, 824, -1, -1, 827, -1, 818, 1378, -1, - 832, -1, 834, -1, -1, -1, -1, 839, -1, 814, - -1, -1, 581, 582, 1394, -1, 154, -1, -1, 824, - -1, -1, 827, -1, -1, -1, -1, 832, -1, 834, - -1, -1, -1, -1, 839, -1, -1, -1, -1, -1, - -1, -1, 611, 154, -1, 614, 615, -1, 617, 154, - 619, 620, -1, -1, -1, 624, 625, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 901, - 1450, 1451, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1463, -1, -1, -1, -1, -1, -1, - 1470, -1, -1, -1, -1, -1, 901, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 931, 249, -1, -1, 219, -1, 254, -1, -1, -1, - -1, -1, -1, 1503, -1, -1, -1, 1507, -1, -1, - -1, -1, -1, -1, 703, -1, -1, -1, 249, 708, - 709, -1, -1, 254, 249, 714, -1, -1, -1, -1, - -1, -1, -1, 985, -1, -1, 1536, -1, 1538, -1, - -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, - 985, 29, 30, 31, -1, -1, 1566, 1567, -1, 1010, - 38, 39, -1, -1, 1574, 1575, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1026, 1038, 1039, -1, 1041, - 1042, 349, -1, -1, -1, -1, -1, -1, 66, -1, - -1, -1, -1, -1, -1, 73, 74, -1, -1, 1061, - -1, -1, -1, 1038, 1039, -1, 1041, 1042, 349, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 1061, -1, 29, 30, - 31, -1, 110, -1, 1096, 1097, 114, 38, -1, -1, - 118, -1, -1, -1, -1, -1, -1, -1, 416, -1, - -1, -1, 1103, -1, -1, -1, -1, -1, -1, -1, - -1, 1096, 1097, 431, -1, 66, -1, -1, 436, -1, - 71, -1, 73, 74, 75, 416, 444, -1, -1, -1, - -1, 82, 83, -1, -1, -1, -1, -1, -1, -1, - 431, -1, -1, -1, -1, 436, 431, -1, 1160, -1, - -1, -1, 470, 444, -1, -1, -1, 108, -1, 110, - -1, -1, -1, -1, -1, -1, -1, 118, -1, -1, - 488, -1, 490, -1, -1, 1160, -1, -1, -1, 470, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1203, -1, -1, -1, -1, -1, 488, -1, 490, - -1, -1, -1, -1, -1, 490, -1, -1, -1, -1, - -1, -1, -1, 1225, 532, -1, -1, -1, 1203, -1, - -1, -1, -1, -1, -1, -1, 1238, -1, 1240, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1225, 532, -1, -1, -1, -1, -1, 532, -1, -1, - -1, -1, -1, 1238, -1, 1240, -1, -1, 1270, -1, - -1, -1, -1, -1, -1, -1, 1278, 1279, 1280, -1, - -1, -1, -1, -1, -1, -1, -1, 1289, 1290, 597, - -1, -1, -1, -1, -1, 1270, -1, -1, -1, -1, - -1, 1303, -1, 1278, 1279, 1280, -1, -1, -1, -1, - -1, -1, -1, -1, 1289, 1290, 597, -1, -1, -1, - -1, -1, 597, -1, 1326, -1, -1, -1, 1303, -1, - -1, -1, -1, -1, 642, 643, 644, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1326, -1, 661, -1, -1, -1, -1, -1, 1098, - -1, 642, 643, 644, -1, -1, -1, 642, 643, 644, - -1, 679, -1, -1, -1, -1, -1, -1, -1, -1, - 661, -1, 690, -1, -1, -1, 661, -1, 696, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 679, 7, - -1, -1, 10, 11, 12, 13, 14, -1, -1, 690, - -1, -1, 1414, -1, -1, 696, -1, -1, -1, -1, - -1, -1, -1, -1, 732, -1, -1, 735, 36, 37, - 38, 39, -1, -1, -1, -1, -1, -1, -1, 1414, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 732, -1, -1, 735, -1, -1, 65, 66, -1, - 735, 1463, -1, 71, 772, -1, -1, 75, 1470, -1, - 78, 79, 80, 81, 82, 83, -1, 85, 86, -1, - -1, -1, -1, 1222, -1, 93, -1, -1, 1463, -1, - -1, 772, -1, -1, -1, 1470, -1, -1, -1, -1, - 108, -1, 110, -1, -1, -1, 814, -1, -1, 117, - 118, 119, 120, 121, 122, -1, 824, -1, -1, 827, - -1, 1523, -1, -1, 832, -1, 834, -1, -1, -1, - -1, 839, -1, 814, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 824, -1, -1, 827, -1, 1523, -1, - -1, 832, 827, 834, -1, -1, -1, -1, 839, 834, - -1, -1, -1, -1, -1, 0, -1, -1, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, -1, 901, 29, 30, 31, 32, -1, -1, - 35, -1, -1, 38, 39, -1, -1, -1, -1, 10, - 11, 12, 13, 14, -1, 10, 11, 12, 13, 14, - 901, -1, -1, -1, -1, -1, 901, -1, 63, -1, - -1, 66, 44, 68, -1, 70, 71, 38, 73, 74, - 75, -1, -1, 38, -1, -1, -1, 82, 83, -1, - -1, 63, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 66, -1, -1, -1, -1, - 71, 66, -1, 108, 75, 110, 71, 985, -1, -1, - 75, 82, 83, 118, -1, -1, -1, 82, 83, -1, - -1, -1, -1, 968, -1, -1, -1, 109, -1, -1, - -1, -1, -1, 115, 985, -1, -1, 108, -1, -1, - 985, -1, -1, 108, -1, -1, -1, 118, -1, -1, - -1, -1, -1, 118, -1, -1, -1, -1, -1, -1, - 1038, 1039, 144, 1041, 1042, -1, -1, -1, -1, -1, - -1, -1, 154, -1, -1, -1, 158, -1, -1, -1, - -1, -1, -1, 1061, -1, -1, -1, 1038, 1039, -1, - 1041, 1042, -1, -1, -1, -1, 1041, 1042, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1061, -1, -1, -1, -1, -1, 1061, -1, 1096, 1097, - -1, -1, -1, -1, -1, 207, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 219, -1, -1, - -1, -1, -1, -1, -1, 1096, 1097, -1, -1, -1, - -1, 36, 37, -1, 39, 237, 238, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, -1, -1, 29, 30, 31, 261, - 65, -1, 1160, -1, -1, 38, 71, 269, -1, -1, - 75, -1, -1, 78, 79, 80, 81, 82, 83, -1, - 85, 86, -1, -1, -1, -1, -1, -1, 93, 1160, - -1, 293, -1, 66, 296, -1, -1, -1, -1, -1, - 73, 74, -1, 108, -1, 1203, -1, -1, -1, -1, - -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1225, -1, -1, - -1, -1, 1203, -1, -1, -1, -1, 1202, 1203, -1, - 1238, 343, 1240, -1, -1, 118, 348, -1, -1, -1, - -1, -1, -1, -1, 1225, -1, -1, -1, -1, -1, - 1225, -1, -1, -1, -1, -1, -1, 1238, -1, 1240, - -1, -1, 1270, -1, -1, -1, -1, -1, -1, 1244, - 1278, 1279, 1280, -1, -1, -1, -1, -1, -1, -1, - -1, 1289, 1290, -1, -1, -1, -1, -1, -1, 1270, - -1, -1, -1, -1, -1, 1303, -1, 1278, 1279, 1280, - -1, -1, -1, -1, -1, -1, -1, -1, 1289, 1290, - -1, -1, 424, 425, 1289, 1290, -1, -1, 1326, 431, - -1, -1, 1303, 1298, -1, -1, -1, -1, 1303, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 452, -1, -1, 455, -1, 1326, -1, -1, -1, 461, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1337, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 488, -1, -1, -1, - 63, -1, -1, -1, -1, -1, -1, -1, 500, -1, - 73, -1, 75, -1, 77, -1, -1, -1, -1, -1, - 512, 84, 514, -1, -1, 517, 1414, 519, 520, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 532, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 115, 1414, 117, 118, 119, -1, -1, 1414, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1463, -1, 43, -1, -1, - -1, -1, 1470, -1, -1, 1440, -1, -1, -1, -1, - -1, -1, -1, 585, -1, 158, -1, -1, -1, -1, - -1, -1, 1463, -1, -1, 597, -1, 599, 1463, 1470, - 602, -1, -1, -1, -1, 1470, -1, -1, -1, -1, - -1, -1, -1, 89, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 99, -1, 1523, 628, -1, -1, -1, - -1, 633, -1, -1, -1, -1, -1, -1, -1, -1, - 642, 643, 644, -1, -1, -1, 219, -1, 221, 222, - 223, -1, 1523, -1, -1, -1, -1, -1, 1523, 661, - -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 155, - 29, 30, 31, -1, 257, -1, -1, -1, 261, 38, - -1, -1, -1, 169, 696, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 277, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 717, 192, 66, -1, -1, - -1, -1, -1, -1, 73, 74, -1, -1, 77, -1, - 206, -1, -1, 735, -1, 737, -1, -1, -1, 215, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 225, - -1, -1, -1, -1, 327, -1, -1, -1, -1, 108, - -1, 110, 36, 37, -1, 39, -1, -1, -1, 118, - 772, -1, -1, -1, 250, 348, -1, -1, -1, 255, - 353, 354, -1, -1, -1, -1, -1, -1, 361, -1, - -1, 65, 268, -1, -1, -1, -1, 71, 274, -1, - 276, 75, -1, -1, 78, 79, 80, 81, 82, 83, - -1, 85, 86, -1, -1, -1, -1, -1, 294, 93, - -1, -1, -1, -1, -1, 827, -1, -1, -1, 831, - -1, 404, 834, -1, 108, -1, 110, -1, -1, 113, - -1, -1, -1, 117, 118, 119, 120, 121, 122, 422, - -1, -1, -1, -1, 427, -1, 429, -1, -1, -1, - -1, 337, -1, -1, -1, -1, 342, -1, -1, -1, - -1, -1, -1, 446, -1, -1, 449, 450, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 465, -1, 370, -1, -1, -1, 374, 375, - -1, 377, -1, -1, -1, -1, 479, -1, 384, 385, - -1, 387, 388, 486, 390, -1, 392, -1, -1, -1, - -1, -1, -1, 7, -1, 927, 10, 11, 12, 13, - 14, -1, -1, 409, -1, -1, -1, -1, -1, -1, - -1, 417, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 36, 37, 38, 39, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 442, 969, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 453, -1, -1, - -1, 65, 66, 985, -1, -1, -1, 71, -1, -1, - -1, 75, -1, -1, 78, 79, 80, 81, 82, 83, - 476, 85, 86, -1, -1, -1, 482, -1, -1, 93, - -1, 487, -1, -1, -1, -1, -1, -1, 1020, -1, - -1, -1, -1, -1, 108, -1, 110, -1, -1, 602, - -1, -1, -1, 117, 118, 119, 120, 121, 122, 1041, - 1042, -1, -1, -1, -1, -1, -1, -1, 524, -1, - -1, -1, -1, -1, -1, -1, -1, 630, 280, -1, - 282, 283, 635, -1, 540, -1, -1, -1, 290, 291, - -1, -1, -1, 295, 296, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 307, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 36, 37, -1, 39, 1101, - -1, 577, -1, -1, -1, -1, -1, -1, -1, -1, - 586, -1, -1, -1, -1, -1, -1, 593, -1, -1, - -1, 343, 598, -1, 65, -1, -1, -1, -1, -1, - 71, -1, -1, 609, 75, -1, -1, 78, 79, 80, - 81, 82, 83, -1, 85, 86, -1, -1, -1, -1, - 723, -1, 93, -1, -1, -1, -1, 379, 1160, -1, - -1, -1, -1, -1, 737, -1, -1, 108, -1, 110, - -1, -1, -1, -1, 650, 116, 117, 118, 119, 120, - 121, 122, -1, -1, 757, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1202, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 686, -1, -1, -1, -1, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, -1, 29, 30, 31, -1, 1240, -1, - -1, -1, -1, 38, -1, 818, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 831, -1, - -1, -1, -1, -1, -1, 741, -1, -1, -1, -1, - -1, 66, -1, -1, -1, 751, 752, 850, 73, 74, - -1, -1, 77, -1, -1, -1, -1, 1289, 1290, 765, - -1, -1, -1, -1, -1, -1, 1298, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 782, -1, 784, -1, - -1, -1, 788, 108, -1, 110, -1, -1, -1, -1, - -1, -1, -1, 118, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 556, 557, 558, 559, 560, 561, - 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, - 572, 573, -1, -1, -1, -1, -1, -1, -1, -1, - 36, 37, -1, 39, 937, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 599, 854, -1, - -1, -1, -1, -1, -1, 861, -1, -1, -1, 65, - 963, -1, -1, -1, -1, 71, -1, -1, 874, 75, - 876, -1, 78, 79, 80, 81, 82, 83, -1, 85, - 86, -1, 1414, -1, 890, -1, -1, 93, 991, -1, - -1, 897, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 108, 909, 110, -1, 912, -1, -1, 115, - -1, 117, 118, 119, 120, 121, 122, -1, -1, -1, - 1023, -1, -1, -1, 930, -1, -1, -1, -1, -1, - -1, 1034, -1, -1, -1, -1, -1, -1, -1, -1, - 1472, -1, 1474, -1, -1, -1, 698, -1, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 720, -1, - -1, -1, -1, -1, -1, -1, 38, 1509, -1, 1511, - -1, 733, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - -1, 29, 30, 31, 66, -1, -1, 1539, -1, -1, - 38, -1, 1115, 1019, -1, 77, -1, -1, -1, 153, - 154, -1, -1, -1, -1, -1, -1, 779, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 66, -1, - -1, -1, -1, 71, -1, 73, 74, 75, -1, 77, - -1, -1, -1, 187, 82, 83, -1, -1, -1, 811, - 194, -1, -1, -1, -1, -1, -1, -1, -1, 1075, - -1, -1, -1, -1, 826, -1, 1082, -1, -1, -1, - 108, -1, 110, -1, -1, -1, -1, -1, -1, -1, - 118, 36, 37, -1, 39, -1, -1, -1, -1, 1202, - -1, -1, -1, -1, -1, 1111, -1, -1, -1, -1, - 1116, -1, -1, -1, -1, -1, -1, -1, 1124, -1, - 65, -1, -1, -1, -1, -1, 71, -1, 73, 74, - 75, -1, 266, 78, 79, 80, 81, 82, 83, -1, - 85, 86, -1, -1, -1, -1, -1, -1, 93, 1155, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1167, -1, 108, 1170, 110, 1172, 112, 113, -1, - -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, - 1186, 1187, -1, -1, -1, -1, -1, -1, 322, -1, - -1, -1, -1, -1, -1, 1298, 330, 331, -1, 333, - 334, -1, 1208, -1, -1, -1, -1, -1, -1, 343, - -1, -1, -1, 347, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 977, -1, -1, -1, 1235, - 144, -1, 366, -1, -1, 369, -1, -1, -1, -1, - 154, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 166, 167, -1, -1, 1008, -1, -1, -1, - -1, -1, 396, -1, -1, -1, 400, -1, 1020, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, -1, -1, 29, 30, 31, 431, -1, -1, - -1, -1, -1, 38, -1, -1, -1, -1, -1, 1061, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 454, -1, -1, 237, -1, -1, 1332, -1, 1334, -1, - -1, 66, -1, 68, -1, 70, -1, -1, 73, 74, - -1, 1347, -1, 1349, -1, -1, -1, -1, 262, -1, - -1, 485, -1, -1, 488, -1, -1, -1, -1, -1, - -1, 1367, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 109, 110, -1, 1383, 1384, -1, - -1, 1133, -1, 118, -1, -1, -1, -1, -1, 1395, - -1, -1, 1398, -1, 528, -1, -1, 531, 532, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 1420, -1, -1, -1, -1, -1, - -1, -1, -1, 1429, -1, 1177, 1432, -1, 1434, 1435, - 1436, -1, -1, -1, -1, -1, -1, -1, -1, 1191, - 1192, -1, -1, 577, 578, -1, -1, -1, -1, -1, - -1, 1554, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 596, 597, 378, 599, -1, -1, -1, -1, - 1476, -1, 1478, -1, 608, 1481, 610, 611, -1, -1, - -1, -1, -1, 617, -1, -1, -1, -1, -1, -1, - 1496, -1, -1, 627, 628, -1, -1, -1, -1, 633, - -1, -1, -1, -1, -1, -1, -1, -1, 642, 643, - 644, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 661, -1, -1, - -1, -1, 666, 667, -1, -1, 670, 671, -1, -1, - -1, -1, -1, 677, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 695, 696, 697, -1, 699, 480, -1, -1, 703, - -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, - 29, 30, 31, -1, -1, -1, -1, -1, -1, 38, - -1, 735, 736, -1, -1, 519, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 532, -1, - -1, -1, -1, -1, -1, 539, -1, 66, 542, -1, - -1, -1, -1, -1, 73, 74, -1, 771, 772, 553, - 554, -1, 776, 777, -1, -1, -1, -1, -1, 1401, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 575, -1, -1, -1, -1, 1418, -1, -1, -1, - -1, 585, -1, -1, -1, -1, -1, -1, 592, 118, - -1, -1, -1, 597, 818, -1, -1, -1, -1, -1, - -1, -1, -1, 827, -1, -1, -1, -1, -1, 833, - 834, -1, -1, -1, 838, -1, 840, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 850, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 647, -1, -1, -1, -1, -1, 1491, - 1492, -1, 656, -1, -1, -1, -1, -1, -1, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, -1, -1, 29, 30, 31, 32, -1, - -1, 35, 696, -1, 38, 39, -1, -1, -1, 923, - -1, -1, -1, -1, -1, -1, -1, 931, 36, 37, - -1, 39, -1, 937, -1, -1, -1, -1, -1, 63, - -1, 945, 66, -1, 68, -1, 70, 71, -1, 73, - 74, 75, -1, -1, 958, 959, -1, 65, 82, 83, - -1, -1, -1, 71, -1, -1, -1, 75, -1, -1, - 78, 79, 80, 81, 82, 83, -1, 85, 86, -1, - -1, 985, -1, -1, 108, 93, 110, 991, 772, -1, - 774, -1, -1, -1, 118, -1, 780, -1, -1, -1, - 108, -1, 110, 787, -1, 113, 1010, 1011, -1, 117, - 118, 119, 120, 121, 122, -1, 1020, -1, -1, -1, - -1, -1, 1026, 1027, -1, 1029, 1030, 1031, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1041, 1042, -1, - -1, -1, -1, -1, -1, -1, -1, 831, 832, -1, - 834, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 849, -1, -1, -1, -1, + 24, 25, 26, 27, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 1102, 1103, - 1104, -1, -1, -1, -1, 889, -1, -1, -1, 893, - -1, 1115, -1, -1, -1, -1, 3, 4, 5, 6, + -1, -1, -1, 67, -1, 69, -1, 71, 72, -1, + 74, 75, 76, -1, -1, -1, -1, -1, -1, 83, + 84, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, -1, -1, -1, -1, -1, 39, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 67, -1, 69, -1, 71, + -1, -1, 74, 75, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, -1, -1, -1, -1, -1, -1, + 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, + 69, -1, 71, -1, -1, 74, 75, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, -1, 29, 30, 31, 32, -1, -1, 35, 36, - 37, 38, 39, 40, -1, 42, 1160, -1, 45, 46, - 47, 48, 49, 50, 51, 52, -1, -1, -1, 56, - -1, -1, -1, 60, 61, -1, 63, -1, 65, 66, - -1, 68, -1, 70, 71, 969, 73, 74, 75, -1, - -1, 78, 79, 80, 81, 82, 83, -1, 85, 86, - -1, 985, 986, -1, -1, -1, 93, -1, 992, -1, - -1, -1, 36, 37, 998, 39, 1220, 1001, -1, 1003, - -1, 108, -1, 110, -1, -1, 113, -1, -1, -1, - 117, 118, 119, 120, 121, 122, 1240, -1, -1, 1023, - 127, 65, -1, -1, 131, -1, -1, 71, -1, -1, - 1034, 75, -1, -1, 78, 79, 80, 81, 82, 83, - -1, 85, 86, -1, -1, -1, -1, -1, -1, 93, - -1, -1, 1056, -1, 1058, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 108, 1289, 1290, -1, -1, 1073, - 1074, -1, -1, 117, 118, 119, 120, 121, 122, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1094, -1, -1, -1, -1, -1, -1, -1, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, -1, -1, 29, 30, 31, 32, -1, -1, - 35, 36, 37, 38, 39, -1, -1, 1141, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 36, 37, -1, 39, -1, -1, 1160, -1, -1, -1, - 65, 66, -1, 68, -1, 70, 71, -1, 73, 74, - 75, 1175, 1176, 78, 79, 80, 81, 82, 83, 65, - 85, 86, -1, -1, -1, 71, -1, -1, 93, 75, - 1414, -1, 78, 79, 80, 81, 82, 83, -1, 85, - 86, -1, -1, 108, -1, 110, -1, 93, -1, -1, - -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, - -1, -1, 108, -1, 110, -1, 131, -1, -1, -1, - -1, 117, 118, 119, 120, 121, 122, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1256, -1, -1, -1, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 1504, -1, 29, 30, 31, 32, -1, -1, 35, 36, - 37, 38, 39, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1529, 1530, -1, -1, -1, - -1, -1, -1, 1317, -1, 1319, -1, -1, 65, 66, - -1, 68, -1, 70, 71, -1, 73, 74, 75, -1, - 1554, 78, 79, 80, 81, 82, 83, -1, 85, 86, - -1, -1, -1, -1, -1, -1, 93, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 108, -1, 110, -1, -1, -1, -1, -1, -1, - 117, 118, 119, 120, 121, 122, -1, -1, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, + -1, -1, 39, -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 1405, -1, 29, 30, 31, -1, -1, -1, -1, - 36, 37, 38, 39, -1, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, -1, -1, 29, 30, 31, -1, -1, 65, - 66, -1, 68, 38, 70, 71, -1, 73, 74, 75, - -1, -1, 78, 79, 80, 81, 82, 83, -1, 85, - 86, -1, -1, -1, -1, -1, -1, 93, -1, -1, - -1, 66, -1, -1, -1, -1, 71, -1, 73, 74, - -1, -1, 108, 1487, 110, -1, -1, 82, 83, 115, - -1, 117, 118, 119, 120, 121, 122, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, -1, 29, 30, 31, -1, -1, -1, -1, 36, - 37, 38, 39, -1, -1, 1539, -1, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, -1, -1, -1, 65, 66, - -1, 68, -1, 70, 71, 38, 73, 74, 75, -1, - -1, 78, 79, 80, 81, 82, 83, -1, 85, 86, - -1, -1, -1, -1, -1, -1, 93, -1, -1, -1, - -1, -1, -1, 66, -1, -1, -1, -1, -1, -1, - -1, 108, -1, 110, 77, -1, -1, -1, 115, -1, - 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, - -1, 29, 30, 31, -1, -1, -1, -1, 36, 37, - 38, 39, -1, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, -1, 29, 30, 31, -1, -1, 65, 66, -1, - 68, 38, 70, 71, -1, 73, 74, 75, -1, -1, - 78, 79, 80, 81, 82, 83, -1, 85, 86, -1, - -1, -1, -1, -1, -1, 93, -1, -1, -1, 66, - -1, -1, -1, -1, -1, -1, 73, 74, -1, -1, - 108, -1, 110, -1, -1, -1, -1, 115, -1, 117, - 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, - 29, 30, 31, -1, -1, -1, -1, 36, 37, 38, - 39, -1, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, - -1, 29, 30, 31, -1, -1, 65, 66, -1, 68, - 38, 70, 71, -1, 73, 74, 75, -1, -1, 78, - 79, 80, 81, 82, 83, -1, 85, 86, -1, -1, - -1, -1, -1, -1, 93, -1, -1, -1, 66, -1, - -1, -1, -1, -1, -1, 73, 74, -1, -1, 108, - -1, 110, -1, -1, -1, -1, -1, -1, 117, 118, - 119, 120, 121, 122, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, - 30, 31, -1, -1, -1, -1, 36, 37, 38, 39, - -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, - -1, -1, -1, -1, -1, 65, 66, -1, 68, 38, - 70, 71, -1, 73, 74, 75, -1, -1, 78, 79, - 80, 81, 82, 83, -1, 85, 86, -1, -1, -1, - -1, -1, -1, 93, -1, -1, -1, 66, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 108, -1, - 110, -1, -1, -1, -1, -1, -1, 117, 118, 119, - 120, 121, 122, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, - 31, -1, -1, -1, -1, 36, 37, 38, 39, -1, + 26, 27, -1, -1, 30, 31, 32, 33, 34, 35, + 67, -1, 69, 39, 71, -1, -1, 74, 75, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 65, 66, -1, 68, -1, 70, - 71, -1, 73, 74, 75, -1, -1, 78, 79, 80, - 81, 82, 83, -1, 85, 86, -1, -1, -1, -1, - -1, -1, 93, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 108, -1, 110, - -1, -1, -1, -1, -1, -1, 117, 118, 119, 120, - 121, 122, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, - -1, -1, -1, -1, 36, 37, 38, 39, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 65, 66, -1, 68, -1, 70, 71, - -1, 73, 74, 75, -1, -1, 78, 79, 80, 81, - 82, 83, -1, 85, 86, -1, -1, -1, -1, -1, - -1, 93, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 108, -1, 110, -1, - -1, -1, -1, -1, -1, 117, 118, 119, 120, 121, - 122, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, - 32, -1, -1, 35, -1, -1, 38, 39, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 63, -1, -1, 66, -1, 68, -1, 70, 71, - -1, 73, 74, 75, -1, -1, -1, -1, -1, -1, - 82, 83, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 108, -1, 110, -1, - -1, -1, 114, -1, -1, -1, 118, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, -1, -1, 29, 30, 31, -1, -1, -1, -1, - -1, -1, 38, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, -1, 29, 30, 31, 32, 33, 34, -1, -1, - 66, 38, 68, -1, 70, 71, -1, 73, 74, 75, - -1, -1, -1, -1, -1, -1, 82, 83, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 66, - -1, -1, -1, -1, -1, -1, 73, 74, -1, -1, - -1, -1, 108, -1, 110, -1, -1, -1, -1, -1, - -1, -1, 118, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, -1, 29, - 30, 31, 32, -1, -1, 35, -1, -1, 38, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 66, -1, 68, -1, - 70, -1, -1, 73, 74, -1, -1, 77, -1, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, -1, -1, 29, 30, 31, 32, -1, - 110, 35, -1, -1, 38, -1, -1, -1, 118, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 66, -1, 68, -1, 70, -1, -1, 73, - 74, -1, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, - 31, -1, -1, -1, -1, -1, 110, 38, -1, -1, - -1, -1, -1, -1, 118, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 66, -1, 68, -1, 70, - -1, -1, 73, 74, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, - 30, 31, -1, -1, -1, -1, -1, -1, 38, 110, - -1, -1, -1, -1, -1, -1, -1, 118, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 66, -1, 68, -1, - 70, 71, -1, 73, 74, 75, -1, -1, -1, -1, - -1, -1, 82, 83, -1, -1, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, -1, -1, 29, 30, 31, 108, -1, - 110, -1, -1, -1, 38, -1, -1, -1, 118, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 66, -1, 29, 30, 31, 71, -1, 73, - 74, 75, -1, 38, -1, -1, -1, -1, 82, 83, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 66, -1, 68, 108, 70, 110, -1, 73, 74, - -1, -1, -1, -1, 118, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 95, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 110, -1, -1, -1, -1, - -1, -1, -1, 118, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, - 30, 31, -1, -1, -1, -1, -1, -1, 38, -1, - -1, -1, -1, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, -1, 29, 30, 31, -1, 66, -1, 68, -1, - 70, 38, -1, 73, 74, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 95, -1, -1, -1, 66, - -1, -1, -1, -1, 71, -1, 73, 74, 75, -1, - 110, -1, -1, -1, -1, 82, 83, -1, 118, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, -1, 110, 29, 30, 31, -1, -1, -1, - -1, 118, -1, 38, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 66, -1, 68, -1, 70, -1, -1, 73, 74, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, -1, -1, 29, 30, 31, -1, -1, - -1, -1, -1, -1, 38, 110, -1, -1, -1, -1, - -1, -1, -1, 118, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 66, -1, 68, -1, 70, -1, -1, 73, - 74, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, - -1, -1, -1, -1, -1, 38, 110, -1, -1, -1, - -1, -1, -1, -1, 118, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 66, -1, 68, -1, 70, -1, -1, - 73, 74, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, - -1, -1, -1, -1, -1, -1, 38, 110, -1, -1, - -1, -1, -1, -1, -1, 118, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 66, -1, 68, -1, 70, -1, - -1, 73, 74, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, -1, 29, 30, 31, -1, -1, -1, -1, 36, - 37, 38, 39, -1, -1, -1, -1, -1, 110, -1, - -1, -1, -1, -1, -1, -1, 118, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 65, 66, - -1, -1, -1, -1, 71, -1, 73, 74, 75, -1, - -1, 78, 79, 80, 81, 82, 83, -1, 85, 86, - -1, -1, -1, -1, -1, -1, 93, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 108, -1, 110, -1, -1, 113, -1, -1, -1, - 117, 118, 119, 120, 121, 122, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, -1, -1, 29, 30, 31, -1, -1, - -1, -1, 36, 37, 38, 39, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, 29, 30, 31, -1, -1, - -1, 65, 66, -1, 38, -1, -1, 71, -1, 73, - 74, 75, -1, -1, 78, 79, 80, 81, 82, 83, - -1, 85, 86, -1, -1, -1, -1, -1, -1, 93, - -1, -1, 66, -1, -1, -1, -1, 71, -1, 73, - 74, 75, -1, 77, 108, -1, 110, 111, 82, 83, - -1, -1, -1, 117, 118, 119, 120, 121, 122, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 110, -1, 29, 30, - 31, -1, -1, -1, 118, 36, 37, 38, 39, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, -1, -1, 29, 30, - 31, -1, -1, -1, 65, 66, -1, 38, -1, -1, - 71, -1, 73, 74, 75, -1, -1, 78, 79, 80, - 81, 82, 83, -1, 85, 86, -1, -1, -1, -1, - -1, -1, 93, -1, -1, 66, -1, -1, -1, -1, - 71, -1, 73, 74, -1, -1, -1, 108, 109, 110, - -1, 82, 83, -1, -1, -1, 117, 118, 119, 120, - 121, 122, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 110, - -1, 29, 30, 31, -1, -1, -1, 118, 36, 37, - 38, 39, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, - -1, 29, 30, 31, -1, -1, -1, 65, 66, -1, - 38, 39, -1, 71, -1, 73, 74, 75, -1, -1, - 78, 79, 80, 81, 82, 83, -1, 85, 86, -1, - -1, -1, -1, -1, -1, 93, -1, -1, 66, -1, - -1, -1, -1, -1, -1, 73, 74, -1, -1, -1, - 108, -1, 110, -1, -1, -1, -1, -1, -1, 117, - 118, 119, 120, 121, 122, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 110, -1, 29, 30, 31, -1, -1, -1, - 118, 36, 37, 38, 39, -1, -1, -1, -1, -1, - -1, -1, -1, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 65, 66, 29, 30, 31, -1, 71, -1, 73, 74, - 75, 38, -1, 78, 79, 80, 81, 82, 83, -1, - 85, 86, -1, -1, -1, -1, -1, -1, 93, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 66, - -1, -1, -1, 108, -1, 110, 73, 74, -1, -1, - -1, -1, 117, 118, 119, 120, 121, 122, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, - -1, 108, -1, 110, 36, 37, 38, 39, -1, -1, - -1, 118, -1, -1, -1, -1, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 65, 66, 29, 30, 31, -1, 71, - -1, 73, 74, 75, 38, -1, 78, 79, 80, 81, - 82, 83, -1, 85, 86, -1, -1, -1, -1, -1, - -1, 93, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 66, -1, -1, -1, 108, -1, 110, 73, - 74, -1, -1, -1, -1, 117, 118, 119, 120, 121, - 122, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, - 29, 30, 31, -1, 108, -1, 110, 36, 37, 38, - 39, -1, -1, -1, 118, -1, -1, -1, -1, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 65, 66, 29, 30, - 31, -1, 71, -1, 73, 74, 75, 38, 39, 78, - 79, 80, 81, 82, 83, -1, 85, 86, -1, -1, - -1, -1, -1, -1, 93, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 66, -1, -1, -1, 108, - -1, 110, 73, 74, -1, -1, -1, -1, 117, 118, - 119, 120, 121, 122, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, -1, 110, - 29, 30, 31, 114, -1, -1, -1, 118, -1, 38, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, - 30, 31, -1, -1, -1, -1, -1, 66, 38, 68, - -1, 70, -1, -1, 73, 74, -1, -1, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, -1, 66, 29, 30, 31, - -1, 71, -1, 73, 74, 75, 38, -1, -1, -1, - -1, -1, 82, 83, 113, -1, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, -1, 66, 29, 30, 31, 108, 71, - 110, 73, 74, 75, 38, -1, -1, -1, 118, -1, - 82, 83, -1, -1, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, -1, 66, 29, 30, 31, 108, -1, 110, 73, - 74, -1, 38, -1, -1, -1, 118, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, - 66, -1, -1, -1, -1, 38, 110, 73, 74, -1, - -1, -1, -1, -1, 118, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, -1, 66, 29, 30, 31, -1, -1, -1, - 73, 74, -1, 38, 110, -1, -1, -1, -1, -1, - -1, -1, 118, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, 66, 29, 30, 31, -1, -1, 110, 73, 74, - -1, 38, -1, -1, -1, 118, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, -1, -1, 29, 30, 31, -1, 66, - -1, -1, -1, -1, 38, 110, 73, 74, -1, -1, - -1, -1, -1, 118, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, -1, 66, 29, 30, 31, -1, -1, -1, 73, - 74, -1, 38, 110, -1, -1, -1, -1, -1, -1, - -1, 118, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, - 66, 29, 30, 31, -1, -1, 110, 73, 74, -1, - 38, -1, -1, -1, 118, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, -1, -1, 29, 30, 31, -1, 66, -1, - -1, -1, -1, 38, 110, 73, 74, -1, -1, -1, - -1, -1, 118, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, 66, 29, 30, 31, -1, -1, -1, 73, 74, - -1, 38, 110, -1, -1, -1, -1, -1, -1, -1, - 118, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 66, - -1, -1, -1, -1, -1, 110, 73, 74, -1, -1, - -1, -1, -1, 118, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, -1, -1, 29, - 30, 31, -1, 110, -1, -1, -1, -1, 38, -1, - -1, 118, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 66, -1, 68, -1, - 70, -1, -1, 73, 74, 36, 37, -1, 39, 40, - -1, 42, -1, -1, 45, 46, 47, 48, 49, 50, - 51, 52, -1, -1, 55, 56, -1, -1, -1, 60, - 61, -1, 63, -1, 65, -1, -1, -1, -1, 109, - 71, -1, -1, -1, 75, -1, -1, 78, 79, 80, - 81, 82, 83, -1, 85, 86, -1, -1, -1, -1, - -1, -1, 93, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 108, -1, 110, - -1, -1, 113, -1, -1, -1, 117, 118, 119, 120, - 121, 122, -1, -1, -1, -1, 127, -1, 36, 37, - 131, 39, 40, -1, 42, -1, -1, 45, 46, 47, - 48, 49, 50, 51, 52, -1, -1, -1, 56, -1, - -1, -1, 60, 61, -1, 63, -1, 65, -1, -1, - -1, -1, -1, 71, -1, -1, -1, 75, -1, -1, - 78, 79, 80, 81, 82, 83, -1, 85, 86, -1, - -1, -1, -1, -1, -1, 93, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 108, -1, 110, -1, -1, 113, -1, -1, -1, 117, - 118, 119, 120, 121, 122, -1, -1, -1, -1, 127, - -1, 36, 37, 131, 39, 40, -1, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, -1, -1, - 55, 56, -1, -1, -1, 60, 61, -1, 63, -1, - 65, -1, -1, -1, -1, -1, 71, -1, -1, -1, - 75, -1, -1, 78, 79, 80, 81, 82, 83, -1, - 85, 86, -1, -1, -1, -1, -1, -1, 93, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 108, -1, 110, -1, -1, 113, -1, - -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, - 36, 37, 127, 39, 40, -1, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, -1, -1, -1, - 56, -1, -1, -1, 60, 61, -1, 63, -1, 65, - -1, -1, -1, -1, -1, 71, -1, -1, -1, 75, - -1, -1, 78, 79, 80, 81, 82, 83, -1, 85, - 86, -1, -1, -1, -1, -1, -1, 93, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 108, -1, 110, -1, -1, 113, -1, -1, - -1, 117, 118, 119, 120, 121, 122, -1, -1, 36, - 37, 127, 39, 40, -1, 42, -1, -1, 45, 46, - 47, 48, 49, 50, 51, 52, -1, -1, -1, 56, - -1, -1, -1, 60, 61, -1, 63, -1, 65, -1, - -1, -1, -1, -1, 71, -1, -1, -1, 75, -1, - -1, 78, 79, 80, 81, 82, 83, -1, 85, 86, - -1, -1, -1, -1, -1, -1, 93, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 108, -1, 110, -1, -1, 113, -1, -1, -1, - 117, 118, 119, 120, 121, 122, -1, -1, -1, -1, - 127, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, - -1, -1, -1, -1, -1, 38, -1, 36, 37, -1, - 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 36, 37, -1, 39, - -1, -1, -1, 66, -1, 68, 65, 70, -1, -1, - 73, 74, 71, -1, -1, -1, 75, -1, -1, 78, - 79, 80, 81, 82, 83, 65, 85, 86, -1, -1, - -1, 71, 95, -1, 93, 75, -1, -1, 78, 79, - 80, 81, 82, 83, -1, 85, 86, -1, -1, 108, - -1, 110, -1, 93, 36, 37, -1, 39, 117, 118, - 119, 120, 121, 122, -1, -1, -1, -1, 108, -1, - 110, -1, -1, 36, 37, -1, 39, 117, 118, 119, - 120, 121, 122, 65, -1, -1, -1, -1, -1, 71, - -1, -1, -1, 75, -1, -1, 78, 79, 80, 81, - 82, 83, 65, 85, 86, -1, -1, -1, 71, -1, - -1, 93, 75, -1, -1, 78, 79, 80, 81, 82, - 83, -1, 85, 86, -1, -1, 108, -1, 110, -1, - 93, 36, 37, -1, 39, 117, 118, 119, 120, 121, - 122, -1, -1, -1, -1, 108, -1, -1, -1, -1, - -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, - 65, -1, -1, -1, -1, -1, 71, -1, -1, -1, - 75, -1, -1, 78, 79, 80, 81, 82, 83, -1, - 85, 86, -1, -1, -1, -1, -1, -1, 93, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 108, -1, -1, -1, -1, -1, -1, - -1, -1, 117, 118, 119, 120, 121, 122, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 38, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 66, -1, 68, -1, 70, 71, -1, 73, 74, 75, - -1, -1, -1, -1, -1, -1, 82, 83, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, -1, -1, 29, 30, 31, -1, -1, -1, - -1, -1, -1, 38, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 66, -1, 68, -1, 70, -1, -1, 73, 74, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, -1, -1, 29, 30, 31, -1, - -1, -1, -1, -1, -1, 38, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 66, -1, 68, -1, 70, -1, -1, - 73, 74, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, -1, -1, 29, 30, 31, - -1, -1, -1, -1, -1, -1, 38, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 66, -1, 68, -1, 70, -1, - -1, 73, 74 + -1, 67, -1, -1, -1, -1, -1, -1, 74, 75 }; @@ -4010,160 +4096,161 @@ 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 29, 30, 31, 32, 35, - 38, 39, 63, 66, 68, 70, 71, 73, 74, 75, - 82, 83, 108, 110, 118, 136, 139, 196, 210, 211, + 22, 23, 24, 25, 26, 27, 30, 31, 32, 33, + 36, 39, 40, 64, 67, 69, 71, 72, 74, 75, + 76, 83, 84, 109, 111, 119, 137, 140, 197, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 229, 230, 231, 232, - 233, 234, 235, 236, 238, 239, 240, 241, 242, 243, - 244, 252, 253, 279, 280, 281, 289, 292, 298, 299, - 301, 303, 304, 310, 315, 319, 320, 321, 322, 323, - 324, 325, 326, 346, 363, 364, 365, 366, 71, 118, - 138, 139, 213, 215, 223, 225, 235, 239, 241, 280, - 81, 108, 308, 309, 310, 308, 308, 71, 73, 74, - 75, 137, 138, 269, 270, 290, 291, 73, 74, 270, - 108, 301, 11, 197, 108, 118, 315, 320, 321, 322, - 324, 325, 326, 111, 133, 110, 216, 223, 225, 319, - 323, 362, 363, 366, 367, 134, 106, 130, 273, 113, - 134, 171, 73, 74, 136, 268, 134, 134, 134, 115, - 134, 73, 74, 108, 118, 305, 314, 315, 316, 317, - 318, 319, 323, 327, 328, 329, 330, 331, 337, 3, - 27, 77, 237, 3, 5, 73, 110, 118, 215, 226, - 230, 233, 242, 281, 319, 323, 366, 213, 215, 225, - 235, 239, 241, 280, 319, 323, 32, 231, 231, 226, - 233, 134, 231, 226, 231, 226, 74, 108, 113, 270, - 281, 113, 270, 231, 226, 115, 134, 134, 0, 133, - 108, 171, 308, 308, 133, 110, 223, 225, 364, 268, - 268, 225, 130, 108, 118, 305, 315, 319, 110, 118, - 366, 302, 228, 310, 108, 286, 108, 108, 50, 108, - 36, 37, 39, 65, 71, 75, 78, 79, 80, 81, - 85, 86, 93, 108, 110, 117, 118, 119, 120, 121, - 122, 135, 139, 140, 141, 142, 147, 148, 149, 150, + 222, 223, 224, 225, 226, 227, 228, 230, 231, 232, + 233, 234, 235, 236, 237, 239, 240, 241, 242, 243, + 244, 246, 254, 255, 282, 283, 284, 292, 295, 301, + 302, 304, 306, 307, 313, 318, 322, 323, 324, 325, + 326, 327, 328, 329, 349, 366, 367, 368, 369, 72, + 119, 139, 140, 214, 216, 224, 226, 236, 240, 242, + 283, 82, 109, 311, 312, 313, 311, 311, 72, 74, + 75, 76, 138, 139, 272, 273, 293, 294, 74, 75, + 273, 109, 304, 11, 198, 109, 119, 318, 323, 324, + 325, 327, 328, 329, 112, 134, 111, 217, 224, 226, + 322, 326, 365, 366, 369, 370, 135, 107, 131, 276, + 114, 135, 172, 74, 75, 137, 271, 135, 135, 135, + 116, 135, 74, 75, 109, 119, 308, 317, 318, 319, + 320, 321, 322, 326, 330, 331, 332, 333, 334, 340, + 3, 28, 78, 238, 3, 5, 74, 111, 119, 216, + 227, 231, 234, 243, 284, 322, 326, 369, 214, 216, + 226, 236, 240, 242, 283, 322, 326, 33, 232, 232, + 227, 234, 135, 232, 227, 232, 227, 75, 109, 114, + 273, 284, 114, 273, 232, 227, 116, 135, 135, 0, + 134, 109, 172, 311, 311, 134, 111, 224, 226, 367, + 271, 271, 226, 131, 109, 119, 308, 318, 322, 111, + 119, 369, 305, 229, 313, 109, 289, 109, 109, 51, + 109, 37, 38, 40, 66, 72, 76, 79, 80, 81, + 82, 86, 87, 94, 109, 111, 118, 119, 120, 121, + 122, 123, 136, 140, 141, 142, 143, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 162, 164, 223, 272, 288, 362, 367, 225, 109, 109, - 109, 109, 109, 109, 109, 73, 74, 110, 223, 268, - 346, 364, 110, 118, 162, 215, 216, 222, 225, 229, - 230, 235, 238, 239, 241, 258, 259, 263, 264, 265, - 266, 280, 346, 358, 359, 360, 361, 366, 367, 111, - 108, 319, 323, 366, 108, 115, 131, 110, 113, 118, - 162, 274, 274, 114, 133, 115, 131, 108, 115, 131, - 115, 131, 115, 131, 308, 131, 315, 316, 317, 318, - 328, 329, 330, 331, 225, 314, 327, 63, 307, 110, - 308, 345, 346, 308, 308, 171, 133, 108, 308, 345, - 308, 308, 225, 305, 108, 108, 224, 225, 223, 225, - 111, 133, 223, 362, 367, 171, 133, 268, 273, 215, - 230, 319, 323, 171, 133, 290, 225, 235, 131, 225, - 225, 288, 39, 110, 223, 245, 246, 247, 248, 362, - 366, 113, 254, 270, 113, 225, 290, 131, 131, 301, - 133, 138, 267, 3, 134, 205, 206, 220, 222, 225, - 133, 307, 108, 307, 162, 315, 225, 108, 133, 268, - 113, 32, 33, 34, 223, 282, 283, 285, 133, 128, - 130, 287, 133, 226, 232, 233, 268, 311, 312, 313, - 108, 140, 108, 147, 108, 147, 149, 108, 147, 108, - 108, 147, 147, 138, 110, 162, 167, 171, 223, 271, - 362, 111, 133, 149, 149, 81, 84, 85, 86, 108, - 110, 112, 113, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 130, 166, 149, 118, 123, 124, 120, - 121, 87, 88, 89, 90, 125, 126, 91, 92, 119, - 127, 128, 93, 94, 129, 130, 369, 108, 118, 341, - 342, 343, 344, 345, 109, 115, 108, 345, 346, 108, - 345, 346, 133, 108, 223, 364, 111, 133, 110, 118, - 134, 223, 225, 357, 358, 366, 367, 134, 108, 110, - 118, 315, 332, 333, 334, 335, 336, 337, 338, 339, - 340, 346, 347, 348, 349, 350, 351, 352, 118, 366, - 225, 134, 134, 118, 223, 225, 359, 268, 223, 346, - 359, 268, 108, 133, 133, 133, 111, 133, 71, 79, - 110, 112, 139, 270, 274, 275, 276, 277, 278, 133, - 133, 133, 133, 133, 133, 305, 109, 109, 109, 109, - 109, 109, 109, 314, 327, 108, 273, 111, 205, 133, - 305, 167, 272, 167, 272, 305, 110, 205, 307, 171, - 133, 205, 109, 247, 248, 111, 133, 108, 116, 118, - 249, 251, 314, 315, 327, 345, 353, 354, 355, 356, - 114, 246, 115, 131, 115, 131, 270, 245, 115, 368, - 130, 255, 254, 225, 260, 261, 262, 265, 266, 109, - 115, 171, 133, 118, 162, 133, 222, 225, 259, 358, - 366, 299, 300, 108, 118, 332, 109, 115, 369, 270, - 282, 108, 113, 270, 272, 282, 109, 115, 108, 140, - 109, 116, 271, 271, 271, 110, 138, 144, 162, 272, - 271, 111, 133, 109, 115, 109, 108, 118, 353, 109, - 115, 162, 110, 138, 110, 143, 144, 133, 110, 138, - 143, 162, 162, 149, 149, 149, 150, 150, 151, 151, - 152, 152, 152, 152, 153, 153, 154, 155, 156, 157, - 158, 116, 167, 162, 133, 342, 343, 344, 225, 341, - 308, 308, 162, 272, 133, 267, 118, 133, 223, 346, - 359, 225, 229, 111, 133, 111, 366, 111, 108, 133, - 315, 333, 334, 335, 338, 348, 349, 350, 111, 133, - 225, 332, 336, 347, 108, 308, 351, 369, 308, 308, - 369, 108, 308, 351, 308, 308, 308, 308, 346, 223, - 357, 367, 268, 111, 115, 111, 115, 369, 223, 359, - 369, 256, 257, 258, 259, 256, 256, 268, 162, 133, - 110, 270, 116, 115, 368, 274, 79, 110, 116, 278, - 28, 207, 208, 268, 256, 138, 305, 138, 307, 108, - 345, 346, 108, 345, 346, 140, 346, 171, 260, 109, - 109, 109, 109, 111, 171, 205, 171, 113, 131, 131, - 110, 315, 354, 355, 356, 160, 161, 225, 353, 250, - 251, 250, 308, 308, 270, 308, 114, 270, 114, 161, - 368, 134, 134, 138, 220, 134, 134, 256, 108, 118, - 366, 134, 114, 225, 283, 284, 134, 133, 133, 108, - 134, 109, 312, 167, 168, 116, 131, 110, 140, 198, - 199, 200, 109, 115, 109, 133, 116, 109, 109, 109, - 162, 225, 113, 149, 164, 162, 163, 165, 115, 134, - 133, 133, 109, 115, 162, 133, 114, 160, 116, 260, - 109, 109, 109, 341, 260, 109, 256, 223, 359, 110, - 118, 162, 162, 225, 338, 260, 109, 109, 109, 109, - 109, 109, 109, 7, 225, 332, 336, 347, 133, 133, - 369, 133, 133, 109, 134, 134, 134, 134, 273, 134, - 160, 161, 162, 306, 133, 274, 276, 114, 133, 209, - 270, 39, 40, 42, 45, 46, 47, 48, 49, 50, - 51, 52, 56, 60, 61, 110, 127, 138, 168, 169, - 170, 171, 172, 173, 175, 176, 188, 190, 191, 196, - 210, 304, 28, 134, 130, 273, 133, 133, 109, 134, - 171, 245, 111, 109, 109, 109, 353, 249, 255, 114, - 109, 115, 111, 111, 134, 225, 115, 369, 286, 109, - 282, 213, 215, 223, 294, 295, 296, 297, 288, 109, - 109, 116, 161, 108, 109, 116, 115, 138, 162, 162, - 275, 115, 134, 165, 111, 138, 145, 146, 162, 144, - 134, 145, 160, 164, 134, 108, 345, 346, 134, 134, - 133, 134, 134, 134, 162, 109, 134, 108, 345, 346, - 108, 351, 108, 351, 346, 224, 7, 118, 134, 162, - 260, 260, 259, 263, 263, 264, 115, 115, 109, 109, - 111, 95, 122, 134, 134, 145, 274, 162, 115, 131, - 210, 214, 225, 229, 108, 108, 169, 108, 108, 131, - 138, 131, 138, 118, 138, 168, 108, 171, 163, 163, - 111, 142, 116, 131, 134, 133, 134, 209, 109, 162, - 260, 260, 308, 109, 114, 108, 345, 346, 133, 109, - 133, 134, 305, 114, 133, 134, 134, 109, 113, 198, - 111, 161, 131, 198, 200, 109, 115, 134, 368, 163, - 111, 134, 84, 112, 115, 134, 134, 111, 134, 109, - 133, 109, 109, 111, 111, 111, 134, 109, 133, 133, - 133, 162, 162, 134, 111, 134, 134, 134, 134, 133, - 133, 161, 161, 111, 111, 134, 134, 270, 225, 167, - 167, 46, 167, 133, 131, 131, 167, 131, 131, 167, - 57, 58, 59, 192, 193, 194, 131, 62, 131, 113, - 308, 173, 114, 131, 134, 134, 133, 95, 265, 266, - 109, 295, 115, 131, 115, 131, 114, 293, 116, 140, - 109, 109, 116, 165, 111, 114, 111, 110, 146, 110, - 146, 146, 111, 111, 111, 260, 111, 260, 260, 260, - 134, 134, 111, 111, 109, 109, 111, 115, 95, 259, - 95, 134, 111, 111, 109, 109, 108, 109, 168, 189, - 210, 131, 109, 108, 108, 171, 194, 57, 58, 162, - 143, 169, 109, 109, 260, 113, 133, 133, 294, 140, - 201, 108, 131, 201, 134, 116, 133, 133, 134, 134, - 134, 134, 111, 111, 133, 134, 111, 169, 43, 44, - 113, 179, 180, 181, 167, 169, 134, 109, 168, 113, - 181, 95, 133, 95, 133, 108, 108, 131, 114, 134, - 133, 268, 305, 114, 115, 116, 161, 109, 111, 162, - 145, 145, 109, 109, 109, 109, 263, 41, 161, 177, - 178, 306, 116, 133, 169, 179, 109, 131, 169, 131, - 133, 109, 133, 109, 133, 95, 133, 95, 133, 131, - 109, 294, 140, 138, 202, 109, 131, 116, 134, 134, - 169, 95, 115, 116, 134, 203, 204, 210, 131, 168, - 168, 203, 171, 195, 223, 362, 171, 195, 109, 133, - 109, 133, 114, 109, 115, 162, 111, 111, 161, 177, - 180, 182, 183, 133, 131, 180, 184, 185, 134, 108, - 118, 305, 353, 138, 134, 171, 195, 171, 195, 108, - 131, 138, 169, 174, 114, 180, 210, 168, 55, 174, - 187, 114, 180, 109, 225, 109, 134, 134, 288, 169, - 174, 131, 186, 187, 174, 187, 171, 171, 109, 109, - 109, 186, 134, 134, 171, 171, 134, 134 + 161, 163, 165, 224, 275, 291, 365, 370, 226, 110, + 110, 110, 110, 110, 110, 110, 74, 75, 111, 224, + 271, 349, 367, 111, 119, 163, 216, 217, 223, 226, + 230, 231, 236, 239, 240, 242, 261, 262, 266, 267, + 268, 269, 283, 349, 361, 362, 363, 364, 369, 370, + 112, 109, 322, 326, 369, 109, 116, 132, 111, 114, + 119, 163, 277, 277, 115, 134, 116, 132, 109, 116, + 132, 116, 132, 116, 132, 311, 132, 318, 319, 320, + 321, 331, 332, 333, 334, 226, 317, 330, 64, 310, + 111, 311, 348, 349, 311, 311, 172, 134, 109, 311, + 348, 311, 311, 226, 308, 109, 109, 225, 226, 224, + 226, 112, 134, 224, 365, 370, 172, 134, 271, 276, + 216, 231, 322, 326, 172, 134, 293, 226, 236, 132, + 226, 226, 291, 40, 111, 224, 247, 248, 249, 250, + 365, 369, 245, 257, 273, 256, 226, 293, 132, 132, + 304, 134, 139, 270, 3, 135, 206, 207, 221, 223, + 226, 134, 310, 109, 310, 163, 318, 226, 109, 134, + 271, 114, 33, 34, 35, 224, 285, 286, 288, 134, + 129, 131, 290, 134, 227, 233, 234, 271, 314, 315, + 316, 109, 141, 109, 148, 109, 148, 150, 109, 148, + 109, 109, 148, 148, 139, 111, 163, 168, 172, 224, + 274, 365, 112, 134, 150, 150, 82, 85, 86, 87, + 109, 111, 113, 114, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 131, 167, 150, 119, 124, 125, + 121, 122, 88, 89, 90, 91, 126, 127, 92, 93, + 120, 128, 129, 94, 95, 130, 131, 372, 109, 119, + 344, 345, 346, 347, 348, 110, 116, 109, 348, 349, + 109, 348, 349, 134, 109, 224, 367, 112, 134, 111, + 119, 135, 224, 226, 360, 361, 369, 370, 135, 109, + 111, 119, 318, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 349, 350, 351, 352, 353, 354, 355, 119, + 369, 226, 135, 135, 119, 224, 226, 362, 271, 224, + 349, 362, 271, 109, 134, 134, 134, 112, 134, 72, + 80, 111, 113, 140, 273, 277, 278, 279, 280, 281, + 134, 134, 134, 134, 134, 134, 308, 110, 110, 110, + 110, 110, 110, 110, 317, 330, 109, 276, 112, 206, + 134, 308, 168, 275, 168, 275, 308, 111, 206, 310, + 172, 134, 206, 110, 249, 250, 112, 134, 109, 117, + 119, 251, 253, 317, 318, 330, 348, 356, 357, 358, + 359, 115, 248, 116, 132, 116, 132, 273, 114, 116, + 371, 131, 258, 114, 226, 263, 264, 265, 268, 269, + 110, 116, 172, 134, 119, 163, 134, 223, 226, 262, + 361, 369, 302, 303, 109, 119, 335, 110, 116, 372, + 273, 285, 109, 114, 273, 275, 285, 110, 116, 109, + 141, 110, 117, 274, 274, 274, 111, 139, 145, 163, + 275, 274, 112, 134, 110, 116, 110, 109, 119, 356, + 110, 116, 163, 111, 139, 111, 144, 145, 134, 111, + 139, 144, 163, 163, 150, 150, 150, 151, 151, 152, + 152, 153, 153, 153, 153, 154, 154, 155, 156, 157, + 158, 159, 117, 168, 163, 134, 345, 346, 347, 226, + 344, 311, 311, 163, 275, 134, 270, 119, 134, 224, + 349, 362, 226, 230, 112, 134, 112, 369, 112, 109, + 134, 318, 336, 337, 338, 341, 351, 352, 353, 112, + 134, 226, 335, 339, 350, 109, 311, 354, 372, 311, + 311, 372, 109, 311, 354, 311, 311, 311, 311, 349, + 224, 360, 370, 271, 112, 116, 112, 116, 372, 224, + 362, 372, 259, 260, 261, 262, 259, 259, 271, 163, + 134, 111, 273, 117, 116, 371, 277, 80, 111, 117, + 281, 29, 208, 209, 271, 259, 139, 308, 139, 310, + 109, 348, 349, 109, 348, 349, 141, 349, 172, 263, + 110, 110, 110, 110, 112, 172, 206, 172, 114, 132, + 132, 111, 318, 357, 358, 359, 161, 162, 226, 356, + 252, 253, 252, 311, 311, 273, 311, 247, 273, 115, + 162, 257, 135, 135, 139, 221, 135, 135, 259, 109, + 119, 369, 135, 115, 226, 286, 287, 135, 134, 134, + 109, 135, 110, 315, 168, 169, 117, 132, 111, 141, + 199, 200, 201, 110, 116, 110, 134, 117, 110, 110, + 110, 163, 226, 114, 150, 165, 163, 164, 166, 116, + 135, 134, 134, 110, 116, 163, 134, 115, 161, 117, + 263, 110, 110, 110, 344, 263, 110, 259, 224, 362, + 111, 119, 163, 163, 226, 341, 263, 110, 110, 110, + 110, 110, 110, 110, 7, 226, 335, 339, 350, 134, + 134, 372, 134, 134, 110, 135, 135, 135, 135, 276, + 135, 161, 162, 163, 309, 134, 277, 279, 115, 134, + 210, 273, 40, 41, 43, 46, 47, 48, 49, 50, + 51, 52, 53, 57, 61, 62, 111, 128, 139, 169, + 170, 171, 172, 173, 174, 176, 177, 189, 191, 192, + 197, 211, 307, 29, 135, 131, 276, 134, 134, 110, + 135, 172, 247, 112, 110, 110, 110, 356, 251, 115, + 258, 371, 110, 116, 112, 112, 135, 226, 116, 372, + 289, 110, 285, 214, 216, 224, 297, 298, 299, 300, + 291, 110, 110, 117, 162, 109, 110, 117, 116, 139, + 163, 163, 278, 116, 135, 166, 112, 139, 146, 147, + 163, 145, 135, 146, 161, 165, 135, 109, 348, 349, + 135, 135, 134, 135, 135, 135, 163, 110, 135, 109, + 348, 349, 109, 354, 109, 354, 349, 225, 7, 119, + 135, 163, 263, 263, 262, 266, 266, 267, 116, 116, + 110, 110, 112, 96, 123, 135, 135, 146, 277, 163, + 116, 132, 211, 215, 226, 230, 109, 109, 170, 109, + 109, 132, 139, 132, 139, 119, 139, 169, 109, 172, + 164, 164, 112, 143, 117, 132, 135, 134, 135, 210, + 110, 163, 263, 263, 311, 110, 115, 109, 348, 349, + 115, 134, 110, 134, 135, 308, 115, 134, 135, 135, + 110, 114, 199, 112, 162, 132, 199, 201, 110, 116, + 135, 371, 164, 112, 135, 85, 113, 116, 135, 135, + 112, 135, 110, 134, 110, 110, 112, 112, 112, 135, + 110, 134, 134, 134, 163, 163, 135, 112, 135, 135, + 135, 135, 134, 134, 162, 162, 112, 112, 135, 135, + 273, 226, 168, 168, 47, 168, 134, 132, 132, 168, + 132, 132, 168, 58, 59, 60, 193, 194, 195, 132, + 63, 132, 114, 311, 174, 115, 132, 135, 135, 134, + 96, 268, 269, 110, 298, 116, 132, 116, 132, 115, + 296, 117, 141, 110, 110, 117, 166, 112, 115, 112, + 111, 147, 111, 147, 147, 112, 112, 112, 263, 112, + 263, 263, 263, 135, 135, 112, 112, 110, 110, 112, + 116, 96, 262, 96, 135, 112, 112, 110, 110, 109, + 110, 169, 190, 211, 132, 110, 109, 109, 172, 195, + 58, 59, 163, 144, 170, 110, 110, 263, 114, 134, + 134, 297, 141, 202, 109, 132, 202, 135, 117, 134, + 134, 135, 135, 135, 135, 112, 112, 134, 135, 112, + 170, 44, 45, 114, 180, 181, 182, 168, 170, 135, + 110, 169, 114, 182, 96, 134, 96, 134, 109, 109, + 132, 115, 135, 134, 271, 308, 115, 116, 117, 162, + 110, 112, 163, 146, 146, 110, 110, 110, 110, 266, + 42, 162, 178, 179, 309, 117, 134, 170, 180, 110, + 132, 170, 132, 134, 110, 134, 110, 134, 96, 134, + 96, 134, 132, 110, 297, 141, 139, 203, 110, 132, + 117, 135, 135, 170, 96, 116, 117, 135, 204, 205, + 211, 132, 169, 169, 204, 172, 196, 224, 365, 172, + 196, 110, 134, 110, 134, 115, 110, 116, 163, 112, + 112, 162, 178, 181, 183, 184, 134, 132, 181, 185, + 186, 135, 109, 119, 308, 356, 139, 135, 172, 196, + 172, 196, 109, 132, 139, 170, 175, 115, 181, 211, + 169, 56, 175, 188, 115, 181, 110, 226, 110, 135, + 135, 291, 170, 175, 132, 187, 188, 175, 188, 172, + 172, 110, 110, 110, 187, 135, 135, 172, 172, 135, + 135 }; @@ -5002,5 +5089,5 @@ /* Line 1806 of yacc.c */ -#line 290 "parser.yy" +#line 292 "parser.yy" { typedefTable.enterScope(); @@ -5011,5 +5098,5 @@ /* Line 1806 of yacc.c */ -#line 296 "parser.yy" +#line 298 "parser.yy" { typedefTable.leaveScope(); @@ -5020,5 +5107,5 @@ /* Line 1806 of yacc.c */ -#line 305 "parser.yy" +#line 307 "parser.yy" { (yyval.constant) = new ConstantNode( ConstantNode::Integer, (yyvsp[(1) - (1)].tok) ); } break; @@ -5027,5 +5114,5 @@ /* Line 1806 of yacc.c */ -#line 306 "parser.yy" +#line 308 "parser.yy" { (yyval.constant) = new ConstantNode( ConstantNode::Float, (yyvsp[(1) - (1)].tok) ); } break; @@ -5034,5 +5121,5 @@ /* Line 1806 of yacc.c */ -#line 307 "parser.yy" +#line 309 "parser.yy" { (yyval.constant) = new ConstantNode( ConstantNode::Character, (yyvsp[(1) - (1)].tok) ); } break; @@ -5041,5 +5128,5 @@ /* Line 1806 of yacc.c */ -#line 332 "parser.yy" +#line 334 "parser.yy" { (yyval.constant) = new ConstantNode( ConstantNode::String, (yyvsp[(1) - (1)].tok) ); } break; @@ -5048,16 +5135,9 @@ /* Line 1806 of yacc.c */ -#line 333 "parser.yy" +#line 335 "parser.yy" { (yyval.constant) = (yyvsp[(1) - (2)].constant)->appendstr( (yyvsp[(2) - (2)].tok) ); } break; case 18: - -/* Line 1806 of yacc.c */ -#line 340 "parser.yy" - { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); } - break; - - case 19: /* Line 1806 of yacc.c */ @@ -5066,8 +5146,15 @@ break; + case 19: + +/* Line 1806 of yacc.c */ +#line 344 "parser.yy" + { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); } + break; + case 20: /* Line 1806 of yacc.c */ -#line 344 "parser.yy" +#line 346 "parser.yy" { (yyval.en) = (yyvsp[(2) - (3)].en); } break; @@ -5076,5 +5163,5 @@ /* Line 1806 of yacc.c */ -#line 346 "parser.yy" +#line 348 "parser.yy" { (yyval.en) = new ValofExprNode( (yyvsp[(2) - (3)].sn) ); } break; @@ -5083,5 +5170,5 @@ /* Line 1806 of yacc.c */ -#line 356 "parser.yy" +#line 358 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Index ), (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ); } break; @@ -5090,5 +5177,5 @@ /* Line 1806 of yacc.c */ -#line 358 "parser.yy" +#line 360 "parser.yy" { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ); } break; @@ -5097,5 +5184,5 @@ /* Line 1806 of yacc.c */ -#line 362 "parser.yy" +#line 364 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); } break; @@ -5104,5 +5191,5 @@ /* Line 1806 of yacc.c */ -#line 365 "parser.yy" +#line 367 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); } break; @@ -5111,5 +5198,5 @@ /* Line 1806 of yacc.c */ -#line 368 "parser.yy" +#line 370 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::IncrPost ), (yyvsp[(1) - (2)].en) ); } break; @@ -5118,5 +5205,5 @@ /* Line 1806 of yacc.c */ -#line 370 "parser.yy" +#line 372 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), (yyvsp[(1) - (2)].en) ); } break; @@ -5125,6 +5212,6 @@ /* Line 1806 of yacc.c */ -#line 372 "parser.yy" - { (yyval.en) = 0; } +#line 374 "parser.yy" + { (yyval.en) = new CompoundLiteralNode( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ); } break; @@ -5132,5 +5219,5 @@ /* Line 1806 of yacc.c */ -#line 374 "parser.yy" +#line 376 "parser.yy" { Token fn; fn.str = new std::string( "?{}" ); // location undefined @@ -5142,5 +5229,5 @@ /* Line 1806 of yacc.c */ -#line 383 "parser.yy" +#line 385 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); } break; @@ -5149,5 +5236,5 @@ /* Line 1806 of yacc.c */ -#line 388 "parser.yy" +#line 390 "parser.yy" { (yyval.en) = 0; } break; @@ -5156,5 +5243,5 @@ /* Line 1806 of yacc.c */ -#line 391 "parser.yy" +#line 393 "parser.yy" { (yyval.en) = (yyvsp[(3) - (3)].en)->set_argName( (yyvsp[(1) - (3)].tok) ); } break; @@ -5163,5 +5250,5 @@ /* Line 1806 of yacc.c */ -#line 396 "parser.yy" +#line 398 "parser.yy" { (yyval.en) = (yyvsp[(7) - (7)].en)->set_argName( (yyvsp[(3) - (7)].en) ); } break; @@ -5170,5 +5257,5 @@ /* Line 1806 of yacc.c */ -#line 398 "parser.yy" +#line 400 "parser.yy" { (yyval.en) = (yyvsp[(9) - (9)].en)->set_argName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (9)].en)->set_link( flattenCommas( (yyvsp[(5) - (9)].en) )))); } break; @@ -5177,5 +5264,5 @@ /* Line 1806 of yacc.c */ -#line 403 "parser.yy" +#line 405 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); } break; @@ -5184,5 +5271,5 @@ /* Line 1806 of yacc.c */ -#line 408 "parser.yy" +#line 410 "parser.yy" { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); } break; @@ -5191,5 +5278,5 @@ /* Line 1806 of yacc.c */ -#line 412 "parser.yy" +#line 414 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( (yyvsp[(1) - (3)].tok) ), (yyvsp[(3) - (3)].en) ); } break; @@ -5198,5 +5285,5 @@ /* Line 1806 of yacc.c */ -#line 414 "parser.yy" +#line 416 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en) ); } break; @@ -5205,5 +5292,5 @@ /* Line 1806 of yacc.c */ -#line 416 "parser.yy" +#line 418 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( (yyvsp[(1) - (3)].tok) ), (yyvsp[(3) - (3)].en) ); } break; @@ -5212,16 +5299,9 @@ /* Line 1806 of yacc.c */ -#line 418 "parser.yy" +#line 420 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en) ); } break; case 48: - -/* Line 1806 of yacc.c */ -#line 426 "parser.yy" - { (yyval.en) = (yyvsp[(1) - (1)].constant); } - break; - - case 49: /* Line 1806 of yacc.c */ @@ -5230,8 +5310,15 @@ break; + case 49: + +/* Line 1806 of yacc.c */ +#line 430 "parser.yy" + { (yyval.en) = (yyvsp[(1) - (1)].constant); } + break; + case 50: /* Line 1806 of yacc.c */ -#line 430 "parser.yy" +#line 432 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Incr ), (yyvsp[(2) - (2)].en) ); } break; @@ -5240,5 +5327,5 @@ /* Line 1806 of yacc.c */ -#line 432 "parser.yy" +#line 434 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Decr ), (yyvsp[(2) - (2)].en) ); } break; @@ -5247,5 +5334,5 @@ /* Line 1806 of yacc.c */ -#line 434 "parser.yy" +#line 436 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; @@ -5254,5 +5341,5 @@ /* Line 1806 of yacc.c */ -#line 436 "parser.yy" +#line 438 "parser.yy" { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); } break; @@ -5261,5 +5348,5 @@ /* Line 1806 of yacc.c */ -#line 438 "parser.yy" +#line 440 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Neg ), (yyvsp[(2) - (2)].en) ); } break; @@ -5268,5 +5355,5 @@ /* Line 1806 of yacc.c */ -#line 440 "parser.yy" +#line 442 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PointTo ), (yyvsp[(2) - (2)].en) ); } break; @@ -5275,5 +5362,5 @@ /* Line 1806 of yacc.c */ -#line 446 "parser.yy" +#line 448 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), (yyvsp[(2) - (2)].en) ); } break; @@ -5282,5 +5369,5 @@ /* Line 1806 of yacc.c */ -#line 448 "parser.yy" +#line 450 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), new TypeValueNode( (yyvsp[(3) - (4)].decl) )); } break; @@ -5289,5 +5376,5 @@ /* Line 1806 of yacc.c */ -#line 450 "parser.yy" +#line 452 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::OffsetOf ), new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) )); } break; @@ -5296,5 +5383,5 @@ /* Line 1806 of yacc.c */ -#line 452 "parser.yy" +#line 454 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (1)].tok) )); } break; @@ -5303,5 +5390,5 @@ /* Line 1806 of yacc.c */ -#line 454 "parser.yy" +#line 456 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), new TypeValueNode( (yyvsp[(3) - (4)].decl) )); } break; @@ -5310,5 +5397,5 @@ /* Line 1806 of yacc.c */ -#line 456 "parser.yy" +#line 458 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ); } break; @@ -5317,5 +5404,5 @@ /* Line 1806 of yacc.c */ -#line 458 "parser.yy" +#line 460 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), (yyvsp[(2) - (2)].en) ); } break; @@ -5324,5 +5411,5 @@ /* Line 1806 of yacc.c */ -#line 460 "parser.yy" +#line 462 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ); } break; @@ -5331,5 +5418,5 @@ /* Line 1806 of yacc.c */ -#line 462 "parser.yy" +#line 464 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( (yyvsp[(2) - (2)].tok), true ) ); } break; @@ -5338,5 +5425,5 @@ /* Line 1806 of yacc.c */ -#line 466 "parser.yy" +#line 468 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::AddressOf ); } break; @@ -5345,5 +5432,5 @@ /* Line 1806 of yacc.c */ -#line 467 "parser.yy" +#line 469 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::UnPlus ); } break; @@ -5352,5 +5439,5 @@ /* Line 1806 of yacc.c */ -#line 468 "parser.yy" +#line 470 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::UnMinus ); } break; @@ -5359,16 +5446,9 @@ /* Line 1806 of yacc.c */ -#line 469 "parser.yy" +#line 471 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::BitNeg ); } break; case 70: - -/* Line 1806 of yacc.c */ -#line 475 "parser.yy" - { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ); } - break; - - case 71: /* Line 1806 of yacc.c */ @@ -5377,8 +5457,15 @@ break; + case 71: + +/* Line 1806 of yacc.c */ +#line 479 "parser.yy" + { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ); } + break; + case 73: /* Line 1806 of yacc.c */ -#line 483 "parser.yy" +#line 485 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Mul ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5387,5 +5474,5 @@ /* Line 1806 of yacc.c */ -#line 485 "parser.yy" +#line 487 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Div ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5394,5 +5481,5 @@ /* Line 1806 of yacc.c */ -#line 487 "parser.yy" +#line 489 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Mod ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5401,5 +5488,5 @@ /* Line 1806 of yacc.c */ -#line 493 "parser.yy" +#line 495 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Plus ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5408,5 +5495,5 @@ /* Line 1806 of yacc.c */ -#line 495 "parser.yy" +#line 497 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Minus ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5415,5 +5502,5 @@ /* Line 1806 of yacc.c */ -#line 501 "parser.yy" +#line 503 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LShift ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5422,5 +5509,5 @@ /* Line 1806 of yacc.c */ -#line 503 "parser.yy" +#line 505 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::RShift ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5429,5 +5516,5 @@ /* Line 1806 of yacc.c */ -#line 509 "parser.yy" +#line 511 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5436,5 +5523,5 @@ /* Line 1806 of yacc.c */ -#line 511 "parser.yy" +#line 513 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::GThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5443,5 +5530,5 @@ /* Line 1806 of yacc.c */ -#line 513 "parser.yy" +#line 515 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LEThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5450,5 +5537,5 @@ /* Line 1806 of yacc.c */ -#line 515 "parser.yy" +#line 517 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::GEThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5457,5 +5544,5 @@ /* Line 1806 of yacc.c */ -#line 521 "parser.yy" +#line 523 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Eq ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5464,5 +5551,5 @@ /* Line 1806 of yacc.c */ -#line 523 "parser.yy" +#line 525 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Neq ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5471,5 +5558,5 @@ /* Line 1806 of yacc.c */ -#line 529 "parser.yy" +#line 531 "parser.yy" { (yyval.en) =new CompositeExprNode( new OperatorNode( OperatorNode::BitAnd ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5478,5 +5565,5 @@ /* Line 1806 of yacc.c */ -#line 535 "parser.yy" +#line 537 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Xor ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5485,5 +5572,5 @@ /* Line 1806 of yacc.c */ -#line 541 "parser.yy" +#line 543 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::BitOr ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5492,5 +5579,5 @@ /* Line 1806 of yacc.c */ -#line 547 "parser.yy" +#line 549 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::And ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5499,5 +5586,5 @@ /* Line 1806 of yacc.c */ -#line 553 "parser.yy" +#line 555 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Or ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5506,5 +5593,5 @@ /* Line 1806 of yacc.c */ -#line 559 "parser.yy" +#line 561 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*(yyvsp[(1) - (5)].en), *(yyvsp[(3) - (5)].en), *(yyvsp[(5) - (5)].en) ) ) ); } break; @@ -5513,5 +5600,5 @@ /* Line 1806 of yacc.c */ -#line 561 "parser.yy" +#line 563 "parser.yy" { (yyval.en)=new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ); } break; @@ -5520,5 +5607,5 @@ /* Line 1806 of yacc.c */ -#line 563 "parser.yy" +#line 565 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*(yyvsp[(1) - (5)].en), *(yyvsp[(3) - (5)].en), *(yyvsp[(5) - (5)].en) ) ) ); } break; @@ -5527,5 +5614,5 @@ /* Line 1806 of yacc.c */ -#line 574 "parser.yy" +#line 576 "parser.yy" { (yyval.en) =new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5534,5 +5621,5 @@ /* Line 1806 of yacc.c */ -#line 576 "parser.yy" +#line 578 "parser.yy" { (yyval.en) =new CompositeExprNode( (yyvsp[(2) - (3)].en), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5541,5 +5628,5 @@ /* Line 1806 of yacc.c */ -#line 578 "parser.yy" +#line 580 "parser.yy" { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); } break; @@ -5548,5 +5635,5 @@ /* Line 1806 of yacc.c */ -#line 583 "parser.yy" +#line 585 "parser.yy" { (yyval.en) = new NullExprNode; } break; @@ -5555,5 +5642,5 @@ /* Line 1806 of yacc.c */ -#line 591 "parser.yy" +#line 593 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); } break; @@ -5562,5 +5649,5 @@ /* Line 1806 of yacc.c */ -#line 593 "parser.yy" +#line 595 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (yyvsp[(3) - (5)].en) ); } break; @@ -5569,5 +5656,5 @@ /* Line 1806 of yacc.c */ -#line 595 "parser.yy" +#line 597 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ); } break; @@ -5576,5 +5663,5 @@ /* Line 1806 of yacc.c */ -#line 597 "parser.yy" +#line 599 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( flattenCommas( (yyvsp[(5) - (7)].en) ) ) ); } break; @@ -5583,5 +5670,5 @@ /* Line 1806 of yacc.c */ -#line 603 "parser.yy" +#line 605 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); } break; @@ -5590,5 +5677,5 @@ /* Line 1806 of yacc.c */ -#line 607 "parser.yy" +#line 609 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::MulAssn ); } break; @@ -5597,5 +5684,5 @@ /* Line 1806 of yacc.c */ -#line 608 "parser.yy" +#line 610 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::DivAssn ); } break; @@ -5604,5 +5691,5 @@ /* Line 1806 of yacc.c */ -#line 609 "parser.yy" +#line 611 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::ModAssn ); } break; @@ -5611,5 +5698,5 @@ /* Line 1806 of yacc.c */ -#line 610 "parser.yy" +#line 612 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::PlusAssn ); } break; @@ -5618,5 +5705,5 @@ /* Line 1806 of yacc.c */ -#line 611 "parser.yy" +#line 613 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::MinusAssn ); } break; @@ -5625,5 +5712,5 @@ /* Line 1806 of yacc.c */ -#line 612 "parser.yy" +#line 614 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::LSAssn ); } break; @@ -5632,5 +5719,5 @@ /* Line 1806 of yacc.c */ -#line 613 "parser.yy" +#line 615 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::RSAssn ); } break; @@ -5639,5 +5726,5 @@ /* Line 1806 of yacc.c */ -#line 614 "parser.yy" +#line 616 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::AndAssn ); } break; @@ -5646,5 +5733,5 @@ /* Line 1806 of yacc.c */ -#line 615 "parser.yy" +#line 617 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::ERAssn ); } break; @@ -5653,5 +5740,5 @@ /* Line 1806 of yacc.c */ -#line 616 "parser.yy" +#line 618 "parser.yy" { (yyval.en) = new OperatorNode( OperatorNode::OrAssn ); } break; @@ -5660,5 +5747,5 @@ /* Line 1806 of yacc.c */ -#line 622 "parser.yy" +#line 624 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5667,5 +5754,5 @@ /* Line 1806 of yacc.c */ -#line 627 "parser.yy" +#line 629 "parser.yy" { (yyval.en) = 0; } break; @@ -5674,5 +5761,5 @@ /* Line 1806 of yacc.c */ -#line 636 "parser.yy" +#line 638 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (1)].sn); } break; @@ -5681,5 +5768,5 @@ /* Line 1806 of yacc.c */ -#line 643 "parser.yy" +#line 645 "parser.yy" { Token fn; fn.str = new std::string( "^?{}" ); // location undefined @@ -5692,5 +5779,5 @@ /* Line 1806 of yacc.c */ -#line 652 "parser.yy" +#line 654 "parser.yy" { (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) ); @@ -5701,5 +5788,5 @@ /* Line 1806 of yacc.c */ -#line 659 "parser.yy" +#line 661 "parser.yy" { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); } break; @@ -5708,5 +5795,5 @@ /* Line 1806 of yacc.c */ -#line 666 "parser.yy" +#line 668 "parser.yy" { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); } break; @@ -5715,5 +5802,5 @@ /* Line 1806 of yacc.c */ -#line 672 "parser.yy" +#line 674 "parser.yy" { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } } break; @@ -5722,5 +5809,5 @@ /* Line 1806 of yacc.c */ -#line 677 "parser.yy" +#line 679 "parser.yy" { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } break; @@ -5729,5 +5816,5 @@ /* Line 1806 of yacc.c */ -#line 679 "parser.yy" +#line 681 "parser.yy" { (yyval.sn) = new StatementNode( (yyvsp[(2) - (2)].decl) ); } break; @@ -5736,5 +5823,5 @@ /* Line 1806 of yacc.c */ -#line 681 "parser.yy" +#line 683 "parser.yy" { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } break; @@ -5743,5 +5830,5 @@ /* Line 1806 of yacc.c */ -#line 688 "parser.yy" +#line 690 "parser.yy" { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } } break; @@ -5750,5 +5837,5 @@ /* Line 1806 of yacc.c */ -#line 693 "parser.yy" +#line 695 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); } break; @@ -5757,5 +5844,5 @@ /* Line 1806 of yacc.c */ -#line 699 "parser.yy" +#line 701 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); } break; @@ -5764,5 +5851,5 @@ /* Line 1806 of yacc.c */ -#line 701 "parser.yy" +#line 703 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); } break; @@ -5771,5 +5858,5 @@ /* Line 1806 of yacc.c */ -#line 703 "parser.yy" +#line 705 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); } break; @@ -5778,5 +5865,5 @@ /* Line 1806 of yacc.c */ -#line 705 "parser.yy" +#line 707 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ); /* xxx */ } break; @@ -5785,5 +5872,5 @@ /* Line 1806 of yacc.c */ -#line 710 "parser.yy" +#line 712 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Choose, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); } break; @@ -5792,5 +5879,5 @@ /* Line 1806 of yacc.c */ -#line 712 "parser.yy" +#line 714 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Choose, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ); } break; @@ -5799,5 +5886,5 @@ /* Line 1806 of yacc.c */ -#line 719 "parser.yy" +#line 721 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; @@ -5806,5 +5893,5 @@ /* Line 1806 of yacc.c */ -#line 721 "parser.yy" +#line 723 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; @@ -5813,5 +5900,5 @@ /* Line 1806 of yacc.c */ -#line 728 "parser.yy" +#line 730 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(tupleContents( (yyvsp[(1) - (3)].en) ))->set_link( (yyvsp[(3) - (3)].en) ) ); } break; @@ -5820,5 +5907,5 @@ /* Line 1806 of yacc.c */ -#line 732 "parser.yy" +#line 734 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(2) - (3)].en), 0 ); } break; @@ -5827,5 +5914,5 @@ /* Line 1806 of yacc.c */ -#line 733 "parser.yy" +#line 735 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Default ); } break; @@ -5834,5 +5921,5 @@ /* Line 1806 of yacc.c */ -#line 739 "parser.yy" +#line 741 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); } break; @@ -5841,5 +5928,5 @@ /* Line 1806 of yacc.c */ -#line 743 "parser.yy" +#line 745 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); } break; @@ -5848,5 +5935,5 @@ /* Line 1806 of yacc.c */ -#line 748 "parser.yy" +#line 750 "parser.yy" { (yyval.sn) = 0; } break; @@ -5855,5 +5942,5 @@ /* Line 1806 of yacc.c */ -#line 754 "parser.yy" +#line 756 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); } break; @@ -5862,5 +5949,5 @@ /* Line 1806 of yacc.c */ -#line 756 "parser.yy" +#line 758 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); } break; @@ -5869,5 +5956,5 @@ /* Line 1806 of yacc.c */ -#line 761 "parser.yy" +#line 763 "parser.yy" { (yyval.sn) = 0; } break; @@ -5876,5 +5963,5 @@ /* Line 1806 of yacc.c */ -#line 767 "parser.yy" +#line 769 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); } break; @@ -5883,5 +5970,5 @@ /* Line 1806 of yacc.c */ -#line 769 "parser.yy" +#line 771 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case((StatementNode *)mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].sn) ))); } break; @@ -5890,5 +5977,5 @@ /* Line 1806 of yacc.c */ -#line 771 "parser.yy" +#line 773 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); } break; @@ -5897,5 +5984,5 @@ /* Line 1806 of yacc.c */ -#line 773 "parser.yy" +#line 775 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_link( (yyvsp[(2) - (4)].sn)->append_last_case((StatementNode *)mkList((*(yyvsp[(3) - (4)].sn),*(yyvsp[(4) - (4)].sn) ))))); } break; @@ -5904,5 +5991,5 @@ /* Line 1806 of yacc.c */ -#line 778 "parser.yy" +#line 780 "parser.yy" { (yyval.sn) = 0; } break; @@ -5911,5 +5998,5 @@ /* Line 1806 of yacc.c */ -#line 783 "parser.yy" +#line 785 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Fallthru ); } break; @@ -5918,5 +6005,5 @@ /* Line 1806 of yacc.c */ -#line 784 "parser.yy" +#line 786 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Fallthru ); } break; @@ -5925,5 +6012,5 @@ /* Line 1806 of yacc.c */ -#line 789 "parser.yy" +#line 791 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); } break; @@ -5932,5 +6019,5 @@ /* Line 1806 of yacc.c */ -#line 791 "parser.yy" +#line 793 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); } break; @@ -5939,5 +6026,5 @@ /* Line 1806 of yacc.c */ -#line 793 "parser.yy" +#line 795 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); } break; @@ -5946,5 +6033,5 @@ /* Line 1806 of yacc.c */ -#line 798 "parser.yy" +#line 800 "parser.yy" { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); } break; @@ -5953,5 +6040,5 @@ /* Line 1806 of yacc.c */ -#line 800 "parser.yy" +#line 802 "parser.yy" { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); } break; @@ -5960,5 +6047,5 @@ /* Line 1806 of yacc.c */ -#line 805 "parser.yy" +#line 807 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); } break; @@ -5967,5 +6054,5 @@ /* Line 1806 of yacc.c */ -#line 809 "parser.yy" +#line 811 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); } break; @@ -5974,5 +6061,5 @@ /* Line 1806 of yacc.c */ -#line 812 "parser.yy" +#line 814 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Continue ); } break; @@ -5981,5 +6068,5 @@ /* Line 1806 of yacc.c */ -#line 816 "parser.yy" +#line 818 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); } break; @@ -5988,5 +6075,5 @@ /* Line 1806 of yacc.c */ -#line 819 "parser.yy" +#line 821 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Break ); } break; @@ -5995,5 +6082,5 @@ /* Line 1806 of yacc.c */ -#line 823 "parser.yy" +#line 825 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); } break; @@ -6002,5 +6089,5 @@ /* Line 1806 of yacc.c */ -#line 825 "parser.yy" +#line 827 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); } break; @@ -6009,5 +6096,5 @@ /* Line 1806 of yacc.c */ -#line 827 "parser.yy" +#line 829 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); } break; @@ -6016,5 +6103,5 @@ /* Line 1806 of yacc.c */ -#line 831 "parser.yy" +#line 833 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); } break; @@ -6023,16 +6110,9 @@ /* Line 1806 of yacc.c */ -#line 833 "parser.yy" +#line 835 "parser.yy" { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (5)].en), 0 ); } break; case 197: - -/* Line 1806 of yacc.c */ -#line 840 "parser.yy" - { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); } - break; - - case 198: /* Line 1806 of yacc.c */ @@ -6041,8 +6121,15 @@ break; + case 198: + +/* Line 1806 of yacc.c */ +#line 844 "parser.yy" + { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); } + break; + case 199: /* Line 1806 of yacc.c */ -#line 844 "parser.yy" +#line 846 "parser.yy" { (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) ); @@ -6054,5 +6141,5 @@ /* Line 1806 of yacc.c */ -#line 855 "parser.yy" +#line 857 "parser.yy" { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); } break; @@ -6061,5 +6148,5 @@ /* Line 1806 of yacc.c */ -#line 857 "parser.yy" +#line 859 "parser.yy" { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); } break; @@ -6068,5 +6155,5 @@ /* Line 1806 of yacc.c */ -#line 859 "parser.yy" +#line 861 "parser.yy" { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); } break; @@ -6075,5 +6162,5 @@ /* Line 1806 of yacc.c */ -#line 861 "parser.yy" +#line 863 "parser.yy" { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); } break; @@ -6082,5 +6169,5 @@ /* Line 1806 of yacc.c */ -#line 866 "parser.yy" +#line 868 "parser.yy" { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); } break; @@ -6089,5 +6176,5 @@ /* Line 1806 of yacc.c */ -#line 868 "parser.yy" +#line 870 "parser.yy" { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); } break; @@ -6096,5 +6183,5 @@ /* Line 1806 of yacc.c */ -#line 870 "parser.yy" +#line 872 "parser.yy" { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); } break; @@ -6103,5 +6190,5 @@ /* Line 1806 of yacc.c */ -#line 872 "parser.yy" +#line 874 "parser.yy" { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); } break; @@ -6110,5 +6197,5 @@ /* Line 1806 of yacc.c */ -#line 877 "parser.yy" +#line 879 "parser.yy" { (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) ); @@ -6120,5 +6207,5 @@ /* Line 1806 of yacc.c */ -#line 891 "parser.yy" +#line 893 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6130,5 +6217,5 @@ /* Line 1806 of yacc.c */ -#line 896 "parser.yy" +#line 898 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; @@ -6137,5 +6224,5 @@ /* Line 1806 of yacc.c */ -#line 898 "parser.yy" +#line 900 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6147,5 +6234,5 @@ /* Line 1806 of yacc.c */ -#line 907 "parser.yy" +#line 909 "parser.yy" { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); } break; @@ -6154,5 +6241,5 @@ /* Line 1806 of yacc.c */ -#line 909 "parser.yy" +#line 911 "parser.yy" { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); } break; @@ -6161,5 +6248,5 @@ /* Line 1806 of yacc.c */ -#line 911 "parser.yy" +#line 913 "parser.yy" { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); } break; @@ -6168,5 +6255,5 @@ /* Line 1806 of yacc.c */ -#line 913 "parser.yy" +#line 915 "parser.yy" { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].constant) ); } break; @@ -6175,5 +6262,5 @@ /* Line 1806 of yacc.c */ -#line 915 "parser.yy" +#line 917 "parser.yy" { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].constant), (yyvsp[(12) - (14)].label) ); } break; @@ -6182,5 +6269,5 @@ /* Line 1806 of yacc.c */ -#line 920 "parser.yy" +#line 922 "parser.yy" { (yyval.flag) = false; } break; @@ -6189,5 +6276,5 @@ /* Line 1806 of yacc.c */ -#line 922 "parser.yy" +#line 924 "parser.yy" { (yyval.flag) = true; } break; @@ -6196,5 +6283,5 @@ /* Line 1806 of yacc.c */ -#line 927 "parser.yy" +#line 929 "parser.yy" { (yyval.en) = 0; } break; @@ -6203,5 +6290,5 @@ /* Line 1806 of yacc.c */ -#line 934 "parser.yy" +#line 936 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); } break; @@ -6210,5 +6297,5 @@ /* Line 1806 of yacc.c */ -#line 939 "parser.yy" +#line 941 "parser.yy" { (yyval.en) = new AsmExprNode( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ); } break; @@ -6217,5 +6304,5 @@ /* Line 1806 of yacc.c */ -#line 941 "parser.yy" +#line 943 "parser.yy" { (yyval.en) = new AsmExprNode( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ); } break; @@ -6224,5 +6311,5 @@ /* Line 1806 of yacc.c */ -#line 946 "parser.yy" +#line 948 "parser.yy" { (yyval.constant) = 0; } break; @@ -6231,5 +6318,5 @@ /* Line 1806 of yacc.c */ -#line 948 "parser.yy" +#line 950 "parser.yy" { (yyval.constant) = (yyvsp[(1) - (1)].constant); } break; @@ -6238,5 +6325,5 @@ /* Line 1806 of yacc.c */ -#line 950 "parser.yy" +#line 952 "parser.yy" { (yyval.constant) = (ConstantNode *)(yyvsp[(1) - (3)].constant)->set_link( (yyvsp[(3) - (3)].constant) ); } break; @@ -6245,5 +6332,5 @@ /* Line 1806 of yacc.c */ -#line 955 "parser.yy" +#line 957 "parser.yy" { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); } break; @@ -6252,5 +6339,5 @@ /* Line 1806 of yacc.c */ -#line 957 "parser.yy" +#line 959 "parser.yy" { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); } break; @@ -6259,5 +6346,5 @@ /* Line 1806 of yacc.c */ -#line 964 "parser.yy" +#line 966 "parser.yy" { (yyval.decl) = 0; } break; @@ -6266,5 +6353,5 @@ /* Line 1806 of yacc.c */ -#line 971 "parser.yy" +#line 973 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; @@ -6273,5 +6360,5 @@ /* Line 1806 of yacc.c */ -#line 976 "parser.yy" +#line 978 "parser.yy" { (yyval.decl) = 0; } break; @@ -6280,5 +6367,5 @@ /* Line 1806 of yacc.c */ -#line 983 "parser.yy" +#line 985 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; @@ -6287,5 +6374,5 @@ /* Line 1806 of yacc.c */ -#line 997 "parser.yy" +#line 999 "parser.yy" {} break; @@ -6294,5 +6381,5 @@ /* Line 1806 of yacc.c */ -#line 998 "parser.yy" +#line 1000 "parser.yy" {} break; @@ -6301,8 +6388,8 @@ /* Line 1806 of yacc.c */ -#line 1027 "parser.yy" +#line 1029 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (2)].decl); + (yyval.decl) = (yyvsp[(1) - (2)].decl)->addInitializer( (yyvsp[(2) - (2)].in) ); } break; @@ -6311,8 +6398,8 @@ /* Line 1806 of yacc.c */ -#line 1034 "parser.yy" +#line 1036 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); - (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); + (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addInitializer( (yyvsp[(3) - (3)].in) );; } break; @@ -6321,8 +6408,8 @@ /* Line 1806 of yacc.c */ -#line 1039 "parser.yy" +#line 1041 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID ); - (yyval.decl) = (yyvsp[(1) - (6)].decl)->appendList( (yyvsp[(1) - (6)].decl)->cloneType( (yyvsp[(5) - (6)].tok) ) ); + (yyval.decl) = (yyvsp[(1) - (6)].decl)->appendList( (yyvsp[(1) - (6)].decl)->cloneType( (yyvsp[(5) - (6)].tok) )->addInitializer( (yyvsp[(6) - (6)].in) ) ); } break; @@ -6331,5 +6418,5 @@ /* Line 1806 of yacc.c */ -#line 1049 "parser.yy" +#line 1051 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); @@ -6341,5 +6428,5 @@ /* Line 1806 of yacc.c */ -#line 1054 "parser.yy" +#line 1056 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); @@ -6351,5 +6438,5 @@ /* Line 1806 of yacc.c */ -#line 1059 "parser.yy" +#line 1061 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) ); @@ -6361,5 +6448,5 @@ /* Line 1806 of yacc.c */ -#line 1067 "parser.yy" +#line 1069 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6371,5 +6458,5 @@ /* Line 1806 of yacc.c */ -#line 1072 "parser.yy" +#line 1074 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6381,5 +6468,5 @@ /* Line 1806 of yacc.c */ -#line 1077 "parser.yy" +#line 1079 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6391,5 +6478,5 @@ /* Line 1806 of yacc.c */ -#line 1082 "parser.yy" +#line 1084 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6401,5 +6488,5 @@ /* Line 1806 of yacc.c */ -#line 1087 "parser.yy" +#line 1089 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID ); @@ -6411,5 +6498,5 @@ /* Line 1806 of yacc.c */ -#line 1095 "parser.yy" +#line 1097 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true ); @@ -6420,5 +6507,5 @@ /* Line 1806 of yacc.c */ -#line 1118 "parser.yy" +#line 1120 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); @@ -6429,5 +6516,5 @@ /* Line 1806 of yacc.c */ -#line 1122 "parser.yy" +#line 1124 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); @@ -6438,5 +6525,5 @@ /* Line 1806 of yacc.c */ -#line 1129 "parser.yy" +#line 1131 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } break; @@ -6445,5 +6532,5 @@ /* Line 1806 of yacc.c */ -#line 1133 "parser.yy" +#line 1135 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); } break; @@ -6452,5 +6539,5 @@ /* Line 1806 of yacc.c */ -#line 1138 "parser.yy" +#line 1140 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6462,5 +6549,5 @@ /* Line 1806 of yacc.c */ -#line 1143 "parser.yy" +#line 1145 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6472,5 +6559,5 @@ /* Line 1806 of yacc.c */ -#line 1148 "parser.yy" +#line 1150 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD ); @@ -6482,5 +6569,5 @@ /* Line 1806 of yacc.c */ -#line 1159 "parser.yy" +#line 1161 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6492,5 +6579,5 @@ /* Line 1806 of yacc.c */ -#line 1164 "parser.yy" +#line 1166 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6502,5 +6589,5 @@ /* Line 1806 of yacc.c */ -#line 1169 "parser.yy" +#line 1171 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6512,5 +6599,5 @@ /* Line 1806 of yacc.c */ -#line 1174 "parser.yy" +#line 1176 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6522,5 +6609,5 @@ /* Line 1806 of yacc.c */ -#line 1179 "parser.yy" +#line 1181 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6532,5 +6619,5 @@ /* Line 1806 of yacc.c */ -#line 1188 "parser.yy" +#line 1190 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD ); @@ -6542,5 +6629,5 @@ /* Line 1806 of yacc.c */ -#line 1193 "parser.yy" +#line 1195 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD ); @@ -6552,5 +6639,5 @@ /* Line 1806 of yacc.c */ -#line 1210 "parser.yy" +#line 1212 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6562,5 +6649,5 @@ /* Line 1806 of yacc.c */ -#line 1215 "parser.yy" +#line 1217 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6572,5 +6659,5 @@ /* Line 1806 of yacc.c */ -#line 1237 "parser.yy" +#line 1239 "parser.yy" { (yyval.decl) = 0; } break; @@ -6579,5 +6666,5 @@ /* Line 1806 of yacc.c */ -#line 1249 "parser.yy" +#line 1251 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6586,5 +6673,5 @@ /* Line 1806 of yacc.c */ -#line 1260 "parser.yy" +#line 1262 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); } break; @@ -6593,5 +6680,5 @@ /* Line 1806 of yacc.c */ -#line 1262 "parser.yy" +#line 1264 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); } break; @@ -6600,5 +6687,5 @@ /* Line 1806 of yacc.c */ -#line 1264 "parser.yy" +#line 1266 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } break; @@ -6607,5 +6694,5 @@ /* Line 1806 of yacc.c */ -#line 1266 "parser.yy" +#line 1268 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } break; @@ -6614,5 +6701,5 @@ /* Line 1806 of yacc.c */ -#line 1268 "parser.yy" +#line 1270 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } break; @@ -6621,5 +6708,5 @@ /* Line 1806 of yacc.c */ -#line 1270 "parser.yy" +#line 1272 "parser.yy" { typedefTable.enterScope(); @@ -6630,5 +6717,5 @@ /* Line 1806 of yacc.c */ -#line 1274 "parser.yy" +#line 1276 "parser.yy" { typedefTable.leaveScope(); @@ -6640,5 +6727,5 @@ /* Line 1806 of yacc.c */ -#line 1283 "parser.yy" +#line 1285 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6647,5 +6734,5 @@ /* Line 1806 of yacc.c */ -#line 1285 "parser.yy" +#line 1287 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; @@ -6654,5 +6741,5 @@ /* Line 1806 of yacc.c */ -#line 1296 "parser.yy" +#line 1298 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6661,5 +6748,5 @@ /* Line 1806 of yacc.c */ -#line 1305 "parser.yy" +#line 1307 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } break; @@ -6668,5 +6755,5 @@ /* Line 1806 of yacc.c */ -#line 1307 "parser.yy" +#line 1309 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); } break; @@ -6675,5 +6762,5 @@ /* Line 1806 of yacc.c */ -#line 1309 "parser.yy" +#line 1311 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); } break; @@ -6682,5 +6769,5 @@ /* Line 1806 of yacc.c */ -#line 1311 "parser.yy" +#line 1313 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); } break; @@ -6689,5 +6776,5 @@ /* Line 1806 of yacc.c */ -#line 1313 "parser.yy" +#line 1315 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); } break; @@ -6696,5 +6783,5 @@ /* Line 1806 of yacc.c */ -#line 1315 "parser.yy" +#line 1317 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } break; @@ -6703,5 +6790,5 @@ /* Line 1806 of yacc.c */ -#line 1317 "parser.yy" +#line 1319 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); } break; @@ -6710,5 +6797,5 @@ /* Line 1806 of yacc.c */ -#line 1319 "parser.yy" +#line 1321 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); } break; @@ -6717,5 +6804,5 @@ /* Line 1806 of yacc.c */ -#line 1324 "parser.yy" +#line 1326 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); } break; @@ -6724,5 +6811,5 @@ /* Line 1806 of yacc.c */ -#line 1326 "parser.yy" +#line 1328 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); } break; @@ -6731,5 +6818,5 @@ /* Line 1806 of yacc.c */ -#line 1328 "parser.yy" +#line 1330 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); } break; @@ -6738,5 +6825,5 @@ /* Line 1806 of yacc.c */ -#line 1330 "parser.yy" +#line 1332 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); } break; @@ -6745,5 +6832,5 @@ /* Line 1806 of yacc.c */ -#line 1332 "parser.yy" +#line 1334 "parser.yy" { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); } break; @@ -6752,5 +6839,5 @@ /* Line 1806 of yacc.c */ -#line 1334 "parser.yy" +#line 1336 "parser.yy" { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); } break; @@ -6759,5 +6846,5 @@ /* Line 1806 of yacc.c */ -#line 1336 "parser.yy" +#line 1338 "parser.yy" { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); } break; @@ -6766,5 +6853,5 @@ /* Line 1806 of yacc.c */ -#line 1338 "parser.yy" +#line 1340 "parser.yy" { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); } break; @@ -6773,5 +6860,5 @@ /* Line 1806 of yacc.c */ -#line 1340 "parser.yy" +#line 1342 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); } break; @@ -6780,5 +6867,5 @@ /* Line 1806 of yacc.c */ -#line 1342 "parser.yy" +#line 1344 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); } break; @@ -6787,5 +6874,5 @@ /* Line 1806 of yacc.c */ -#line 1344 "parser.yy" +#line 1346 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); } break; @@ -6794,188 +6881,191 @@ /* Line 1806 of yacc.c */ -#line 1346 "parser.yy" +#line 1348 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); } break; - case 334: - -/* Line 1806 of yacc.c */ -#line 1353 "parser.yy" + case 333: + +/* Line 1806 of yacc.c */ +#line 1350 "parser.yy" + { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); } + break; + + case 335: + +/* Line 1806 of yacc.c */ +#line 1357 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 335: - -/* Line 1806 of yacc.c */ -#line 1355 "parser.yy" + case 336: + +/* Line 1806 of yacc.c */ +#line 1359 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 336: - -/* Line 1806 of yacc.c */ -#line 1357 "parser.yy" + case 337: + +/* Line 1806 of yacc.c */ +#line 1361 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 337: - -/* Line 1806 of yacc.c */ -#line 1359 "parser.yy" + case 338: + +/* Line 1806 of yacc.c */ +#line 1363 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); } break; - case 339: - -/* Line 1806 of yacc.c */ -#line 1365 "parser.yy" + case 340: + +/* Line 1806 of yacc.c */ +#line 1369 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 341: - -/* Line 1806 of yacc.c */ -#line 1372 "parser.yy" + case 342: + +/* Line 1806 of yacc.c */ +#line 1376 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 342: - -/* Line 1806 of yacc.c */ -#line 1374 "parser.yy" + case 343: + +/* Line 1806 of yacc.c */ +#line 1378 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 343: - -/* Line 1806 of yacc.c */ -#line 1376 "parser.yy" + case 344: + +/* Line 1806 of yacc.c */ +#line 1380 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); } break; - case 344: - -/* Line 1806 of yacc.c */ -#line 1381 "parser.yy" + case 345: + +/* Line 1806 of yacc.c */ +#line 1385 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (4)].decl); } break; - case 345: - -/* Line 1806 of yacc.c */ -#line 1383 "parser.yy" + case 346: + +/* Line 1806 of yacc.c */ +#line 1387 "parser.yy" { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); } break; - case 346: - -/* Line 1806 of yacc.c */ -#line 1385 "parser.yy" + case 347: + +/* Line 1806 of yacc.c */ +#line 1389 "parser.yy" { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); } break; - case 347: - -/* Line 1806 of yacc.c */ -#line 1387 "parser.yy" + case 348: + +/* Line 1806 of yacc.c */ +#line 1391 "parser.yy" { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } break; - case 349: - -/* Line 1806 of yacc.c */ -#line 1393 "parser.yy" + case 350: + +/* Line 1806 of yacc.c */ +#line 1397 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 350: - -/* Line 1806 of yacc.c */ -#line 1395 "parser.yy" + case 351: + +/* Line 1806 of yacc.c */ +#line 1399 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 351: - -/* Line 1806 of yacc.c */ -#line 1397 "parser.yy" + case 352: + +/* Line 1806 of yacc.c */ +#line 1401 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 353: - -/* Line 1806 of yacc.c */ -#line 1403 "parser.yy" + case 354: + +/* Line 1806 of yacc.c */ +#line 1407 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 354: - -/* Line 1806 of yacc.c */ -#line 1405 "parser.yy" + case 355: + +/* Line 1806 of yacc.c */ +#line 1409 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 356: - -/* Line 1806 of yacc.c */ -#line 1411 "parser.yy" + case 357: + +/* Line 1806 of yacc.c */ +#line 1415 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 357: - -/* Line 1806 of yacc.c */ -#line 1413 "parser.yy" + case 358: + +/* Line 1806 of yacc.c */ +#line 1417 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 358: - -/* Line 1806 of yacc.c */ -#line 1415 "parser.yy" + case 359: + +/* Line 1806 of yacc.c */ +#line 1419 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 359: - -/* Line 1806 of yacc.c */ -#line 1420 "parser.yy" + case 360: + +/* Line 1806 of yacc.c */ +#line 1424 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); } break; - case 360: - -/* Line 1806 of yacc.c */ -#line 1422 "parser.yy" + case 361: + +/* Line 1806 of yacc.c */ +#line 1426 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 361: - -/* Line 1806 of yacc.c */ -#line 1424 "parser.yy" + case 362: + +/* Line 1806 of yacc.c */ +#line 1428 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 364: - -/* Line 1806 of yacc.c */ -#line 1434 "parser.yy" + case 365: + +/* Line 1806 of yacc.c */ +#line 1438 "parser.yy" { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl) ); } break; - case 365: - -/* Line 1806 of yacc.c */ -#line 1436 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), 0, 0 ); } - break; - case 366: /* Line 1806 of yacc.c */ -#line 1438 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (5)].aggKey), (yyvsp[(2) - (5)].tok), 0, (yyvsp[(4) - (5)].decl) ); } +#line 1440 "parser.yy" + { + typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); + (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), 0, 0 ); + } break; @@ -6983,226 +7073,222 @@ /* Line 1806 of yacc.c */ -#line 1440 "parser.yy" +#line 1445 "parser.yy" + { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); } + break; + + case 368: + +/* Line 1806 of yacc.c */ +#line 1447 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl)); } + break; + + case 369: + +/* Line 1806 of yacc.c */ +#line 1449 "parser.yy" { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl) ); } break; - case 368: - -/* Line 1806 of yacc.c */ -#line 1442 "parser.yy" + case 370: + +/* Line 1806 of yacc.c */ +#line 1451 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl); } break; - case 369: - -/* Line 1806 of yacc.c */ -#line 1447 "parser.yy" + case 371: + +/* Line 1806 of yacc.c */ +#line 1456 "parser.yy" { (yyval.aggKey) = DeclarationNode::Struct; } break; - case 370: - -/* Line 1806 of yacc.c */ -#line 1449 "parser.yy" + case 372: + +/* Line 1806 of yacc.c */ +#line 1458 "parser.yy" { (yyval.aggKey) = DeclarationNode::Union; } break; - case 371: - -/* Line 1806 of yacc.c */ -#line 1454 "parser.yy" + case 373: + +/* Line 1806 of yacc.c */ +#line 1463 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (1)].decl); } break; - case 372: - -/* Line 1806 of yacc.c */ -#line 1456 "parser.yy" + case 374: + +/* Line 1806 of yacc.c */ +#line 1465 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ); } break; - case 374: - -/* Line 1806 of yacc.c */ -#line 1462 "parser.yy" + case 376: + +/* Line 1806 of yacc.c */ +#line 1471 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 376: - -/* Line 1806 of yacc.c */ -#line 1465 "parser.yy" + case 378: + +/* Line 1806 of yacc.c */ +#line 1474 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 378: - -/* Line 1806 of yacc.c */ -#line 1471 "parser.yy" + case 380: + +/* Line 1806 of yacc.c */ +#line 1480 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); } break; - case 379: - -/* Line 1806 of yacc.c */ -#line 1473 "parser.yy" + case 381: + +/* Line 1806 of yacc.c */ +#line 1482 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); } break; - case 380: - -/* Line 1806 of yacc.c */ -#line 1475 "parser.yy" + case 382: + +/* Line 1806 of yacc.c */ +#line 1484 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); } break; - case 381: - -/* Line 1806 of yacc.c */ -#line 1480 "parser.yy" + case 383: + +/* Line 1806 of yacc.c */ +#line 1489 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 382: - -/* Line 1806 of yacc.c */ -#line 1482 "parser.yy" + case 384: + +/* Line 1806 of yacc.c */ +#line 1491 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); } break; - case 383: - -/* Line 1806 of yacc.c */ -#line 1487 "parser.yy" + case 385: + +/* Line 1806 of yacc.c */ +#line 1496 "parser.yy" { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ } break; - case 384: - -/* Line 1806 of yacc.c */ -#line 1489 "parser.yy" + case 386: + +/* Line 1806 of yacc.c */ +#line 1498 "parser.yy" { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); } break; - case 385: - -/* Line 1806 of yacc.c */ -#line 1492 "parser.yy" + case 387: + +/* Line 1806 of yacc.c */ +#line 1501 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } break; - case 386: - -/* Line 1806 of yacc.c */ -#line 1495 "parser.yy" + case 388: + +/* Line 1806 of yacc.c */ +#line 1504 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } break; - case 388: - -/* Line 1806 of yacc.c */ -#line 1501 "parser.yy" + case 390: + +/* Line 1806 of yacc.c */ +#line 1510 "parser.yy" { (yyval.en) = 0; } break; - case 389: - -/* Line 1806 of yacc.c */ -#line 1503 "parser.yy" + case 391: + +/* Line 1806 of yacc.c */ +#line 1512 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; - case 390: - -/* Line 1806 of yacc.c */ -#line 1508 "parser.yy" + case 392: + +/* Line 1806 of yacc.c */ +#line 1517 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; - case 392: - -/* Line 1806 of yacc.c */ -#line 1517 "parser.yy" + case 394: + +/* Line 1806 of yacc.c */ +#line 1526 "parser.yy" { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); } break; - case 393: - -/* Line 1806 of yacc.c */ -#line 1519 "parser.yy" - { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (6)].tok), (yyvsp[(4) - (6)].decl) ); } - break; - - case 394: - -/* Line 1806 of yacc.c */ -#line 1521 "parser.yy" - { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (2)].tok), 0 ); } - break; - case 395: /* Line 1806 of yacc.c */ -#line 1526 "parser.yy" +#line 1528 "parser.yy" + { + typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); + (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (2)].tok), 0 ); + } + break; + + case 396: + +/* Line 1806 of yacc.c */ +#line 1533 "parser.yy" + { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); } + break; + + case 397: + +/* Line 1806 of yacc.c */ +#line 1535 "parser.yy" + { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); } + break; + + case 398: + +/* Line 1806 of yacc.c */ +#line 1540 "parser.yy" { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); } break; - case 396: - -/* Line 1806 of yacc.c */ -#line 1528 "parser.yy" + case 399: + +/* Line 1806 of yacc.c */ +#line 1542 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); } break; - case 397: - -/* Line 1806 of yacc.c */ -#line 1533 "parser.yy" + case 400: + +/* Line 1806 of yacc.c */ +#line 1547 "parser.yy" { (yyval.en) = 0; } break; - case 398: - -/* Line 1806 of yacc.c */ -#line 1535 "parser.yy" + case 401: + +/* Line 1806 of yacc.c */ +#line 1549 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; - case 399: - -/* Line 1806 of yacc.c */ -#line 1542 "parser.yy" + case 402: + +/* Line 1806 of yacc.c */ +#line 1556 "parser.yy" { (yyval.decl) = 0; } break; - case 403: - -/* Line 1806 of yacc.c */ -#line 1550 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } - break; - - case 404: - -/* Line 1806 of yacc.c */ -#line 1552 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } - break; - - case 405: - -/* Line 1806 of yacc.c */ -#line 1554 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } - break; - - case 407: - -/* Line 1806 of yacc.c */ -#line 1562 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } - break; - - case 408: + case 406: /* Line 1806 of yacc.c */ @@ -7211,78 +7297,106 @@ break; - case 409: + case 407: /* Line 1806 of yacc.c */ #line 1566 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } + break; + + case 408: + +/* Line 1806 of yacc.c */ +#line 1568 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } + break; + + case 410: + +/* Line 1806 of yacc.c */ +#line 1576 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } + break; + + case 411: + +/* Line 1806 of yacc.c */ +#line 1578 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } + break; + + case 412: + +/* Line 1806 of yacc.c */ +#line 1580 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); } break; - case 411: - -/* Line 1806 of yacc.c */ -#line 1572 "parser.yy" + case 414: + +/* Line 1806 of yacc.c */ +#line 1586 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 412: - -/* Line 1806 of yacc.c */ -#line 1577 "parser.yy" + case 415: + +/* Line 1806 of yacc.c */ +#line 1591 "parser.yy" { (yyval.decl) = 0; } break; - case 415: - -/* Line 1806 of yacc.c */ -#line 1584 "parser.yy" + case 418: + +/* Line 1806 of yacc.c */ +#line 1598 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; - case 418: - -/* Line 1806 of yacc.c */ -#line 1591 "parser.yy" + case 421: + +/* Line 1806 of yacc.c */ +#line 1605 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 419: - -/* Line 1806 of yacc.c */ -#line 1593 "parser.yy" + case 422: + +/* Line 1806 of yacc.c */ +#line 1607 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 421: - -/* Line 1806 of yacc.c */ -#line 1602 "parser.yy" + case 424: + +/* Line 1806 of yacc.c */ +#line 1616 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } break; - case 422: - -/* Line 1806 of yacc.c */ -#line 1605 "parser.yy" + case 425: + +/* Line 1806 of yacc.c */ +#line 1619 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } break; - case 423: - -/* Line 1806 of yacc.c */ -#line 1607 "parser.yy" + case 426: + +/* Line 1806 of yacc.c */ +#line 1621 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); } break; - case 428: - -/* Line 1806 of yacc.c */ -#line 1617 "parser.yy" + case 431: + +/* Line 1806 of yacc.c */ +#line 1631 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 430: - -/* Line 1806 of yacc.c */ -#line 1623 "parser.yy" + case 433: + +/* Line 1806 of yacc.c */ +#line 1637 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7291,8 +7405,8 @@ break; - case 431: - -/* Line 1806 of yacc.c */ -#line 1628 "parser.yy" + case 434: + +/* Line 1806 of yacc.c */ +#line 1642 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7301,75 +7415,40 @@ break; - case 433: - -/* Line 1806 of yacc.c */ -#line 1637 "parser.yy" + case 436: + +/* Line 1806 of yacc.c */ +#line 1651 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 434: - -/* Line 1806 of yacc.c */ -#line 1646 "parser.yy" + case 437: + +/* Line 1806 of yacc.c */ +#line 1660 "parser.yy" { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); } break; - case 435: - -/* Line 1806 of yacc.c */ -#line 1648 "parser.yy" + case 438: + +/* Line 1806 of yacc.c */ +#line 1662 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); } break; - case 447: - -/* Line 1806 of yacc.c */ -#line 1673 "parser.yy" + case 450: + +/* Line 1806 of yacc.c */ +#line 1687 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 451: - -/* Line 1806 of yacc.c */ -#line 1681 "parser.yy" + case 454: + +/* Line 1806 of yacc.c */ +#line 1695 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 452: - -/* Line 1806 of yacc.c */ -#line 1686 "parser.yy" - { (yyval.in) = 0; } - break; - - case 453: - -/* Line 1806 of yacc.c */ -#line 1688 "parser.yy" - { (yyval.in) = (yyvsp[(2) - (2)].in); } - break; - - case 454: - -/* Line 1806 of yacc.c */ -#line 1690 "parser.yy" - { (yyval.in) = (yyvsp[(2) - (2)].in); } - break; - case 455: - -/* Line 1806 of yacc.c */ -#line 1694 "parser.yy" - { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); } - break; - - case 456: - -/* Line 1806 of yacc.c */ -#line 1695 "parser.yy" - { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); } - break; - - case 457: /* Line 1806 of yacc.c */ @@ -7378,197 +7457,201 @@ break; + case 456: + +/* Line 1806 of yacc.c */ +#line 1702 "parser.yy" + { (yyval.in) = (yyvsp[(2) - (2)].in); } + break; + + case 457: + +/* Line 1806 of yacc.c */ +#line 1704 "parser.yy" + { (yyval.in) = (yyvsp[(2) - (2)].in); } + break; + + case 458: + +/* Line 1806 of yacc.c */ +#line 1708 "parser.yy" + { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); } + break; + case 459: /* Line 1806 of yacc.c */ -#line 1702 "parser.yy" +#line 1709 "parser.yy" + { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); } + break; + + case 460: + +/* Line 1806 of yacc.c */ +#line 1714 "parser.yy" + { (yyval.in) = 0; } + break; + + case 462: + +/* Line 1806 of yacc.c */ +#line 1716 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); } break; - case 460: - -/* Line 1806 of yacc.c */ -#line 1703 "parser.yy" + case 463: + +/* Line 1806 of yacc.c */ +#line 1717 "parser.yy" { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); } break; - case 461: - -/* Line 1806 of yacc.c */ -#line 1705 "parser.yy" + case 464: + +/* Line 1806 of yacc.c */ +#line 1719 "parser.yy" { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); } break; - case 463: - -/* Line 1806 of yacc.c */ -#line 1721 "parser.yy" + case 466: + +/* Line 1806 of yacc.c */ +#line 1735 "parser.yy" { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); } break; - case 465: - -/* Line 1806 of yacc.c */ -#line 1727 "parser.yy" + case 468: + +/* Line 1806 of yacc.c */ +#line 1741 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); } break; - case 466: - -/* Line 1806 of yacc.c */ -#line 1735 "parser.yy" + case 469: + +/* Line 1806 of yacc.c */ +#line 1749 "parser.yy" { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); } break; - case 467: - -/* Line 1806 of yacc.c */ -#line 1737 "parser.yy" + case 470: + +/* Line 1806 of yacc.c */ +#line 1751 "parser.yy" { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(2) - (2)].tok) ) ); } break; - case 468: - -/* Line 1806 of yacc.c */ -#line 1740 "parser.yy" + case 471: + +/* Line 1806 of yacc.c */ +#line 1754 "parser.yy" { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); } break; - case 469: - -/* Line 1806 of yacc.c */ -#line 1742 "parser.yy" + case 472: + +/* Line 1806 of yacc.c */ +#line 1756 "parser.yy" { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); } break; - case 470: - -/* Line 1806 of yacc.c */ -#line 1744 "parser.yy" + case 473: + +/* Line 1806 of yacc.c */ +#line 1758 "parser.yy" { (yyval.en) = new DesignatorNode( new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ), true ); } break; - case 471: - -/* Line 1806 of yacc.c */ -#line 1746 "parser.yy" + case 474: + +/* Line 1806 of yacc.c */ +#line 1760 "parser.yy" { (yyval.en) = new DesignatorNode( (yyvsp[(4) - (6)].en) ); } break; - case 473: - -/* Line 1806 of yacc.c */ -#line 1770 "parser.yy" + case 476: + +/* Line 1806 of yacc.c */ +#line 1784 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 474: - -/* Line 1806 of yacc.c */ -#line 1772 "parser.yy" + case 477: + +/* Line 1806 of yacc.c */ +#line 1786 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 475: - -/* Line 1806 of yacc.c */ -#line 1774 "parser.yy" + case 478: + +/* Line 1806 of yacc.c */ +#line 1788 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 477: - -/* Line 1806 of yacc.c */ -#line 1780 "parser.yy" + case 480: + +/* Line 1806 of yacc.c */ +#line 1794 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 478: - -/* Line 1806 of yacc.c */ -#line 1782 "parser.yy" + case 481: + +/* Line 1806 of yacc.c */ +#line 1796 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 479: - -/* Line 1806 of yacc.c */ -#line 1787 "parser.yy" + case 482: + +/* Line 1806 of yacc.c */ +#line 1801 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } break; - case 481: - -/* Line 1806 of yacc.c */ -#line 1793 "parser.yy" + case 484: + +/* Line 1806 of yacc.c */ +#line 1807 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); } break; - case 482: - -/* Line 1806 of yacc.c */ -#line 1798 "parser.yy" + case 485: + +/* Line 1806 of yacc.c */ +#line 1812 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); } break; - case 483: - -/* Line 1806 of yacc.c */ -#line 1800 "parser.yy" + case 486: + +/* Line 1806 of yacc.c */ +#line 1814 "parser.yy" { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); } break; - case 485: - -/* Line 1806 of yacc.c */ -#line 1806 "parser.yy" + case 488: + +/* Line 1806 of yacc.c */ +#line 1820 "parser.yy" { (yyval.tclass) = DeclarationNode::Type; } break; - case 486: - -/* Line 1806 of yacc.c */ -#line 1808 "parser.yy" + case 489: + +/* Line 1806 of yacc.c */ +#line 1822 "parser.yy" { (yyval.tclass) = DeclarationNode::Ftype; } break; - case 487: - -/* Line 1806 of yacc.c */ -#line 1810 "parser.yy" + case 490: + +/* Line 1806 of yacc.c */ +#line 1824 "parser.yy" { (yyval.tclass) = DeclarationNode::Dtype; } break; - case 488: - -/* Line 1806 of yacc.c */ -#line 1815 "parser.yy" - { (yyval.decl) = 0; } - break; - - case 489: - -/* Line 1806 of yacc.c */ -#line 1817 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (2)].decl) == 0 ? (yyvsp[(2) - (2)].decl) : (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ); } - break; - - case 490: - -/* Line 1806 of yacc.c */ -#line 1822 "parser.yy" - { - typedefTable.openContext( *(yyvsp[(2) - (5)].tok) ); - (yyval.decl) = DeclarationNode::newContextUse( (yyvsp[(2) - (5)].tok), (yyvsp[(4) - (5)].en) ); - } - break; - case 491: - -/* Line 1806 of yacc.c */ -#line 1827 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (5)].decl); } - break; - - case 492: /* Line 1806 of yacc.c */ @@ -7577,64 +7660,95 @@ break; + case 492: + +/* Line 1806 of yacc.c */ +#line 1831 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (2)].decl) == 0 ? (yyvsp[(2) - (2)].decl) : (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ); } + break; + case 493: /* Line 1806 of yacc.c */ -#line 1834 "parser.yy" +#line 1836 "parser.yy" + { + typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) ); + (yyval.decl) = DeclarationNode::newTraitUse( (yyvsp[(2) - (5)].tok), (yyvsp[(4) - (5)].en) ); + } + break; + + case 494: + +/* Line 1806 of yacc.c */ +#line 1841 "parser.yy" + { (yyval.decl) = (yyvsp[(4) - (5)].decl); } + break; + + case 495: + +/* Line 1806 of yacc.c */ +#line 1843 "parser.yy" + { (yyval.decl) = 0; } + break; + + case 496: + +/* Line 1806 of yacc.c */ +#line 1848 "parser.yy" { (yyval.en) = new TypeValueNode( (yyvsp[(1) - (1)].decl) ); } break; - case 495: - -/* Line 1806 of yacc.c */ -#line 1837 "parser.yy" + case 498: + +/* Line 1806 of yacc.c */ +#line 1851 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); } break; - case 496: - -/* Line 1806 of yacc.c */ -#line 1839 "parser.yy" + case 499: + +/* Line 1806 of yacc.c */ +#line 1853 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); } break; - case 497: - -/* Line 1806 of yacc.c */ -#line 1844 "parser.yy" + case 500: + +/* Line 1806 of yacc.c */ +#line 1858 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl); } break; - case 498: - -/* Line 1806 of yacc.c */ -#line 1846 "parser.yy" + case 501: + +/* Line 1806 of yacc.c */ +#line 1860 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); } break; - case 499: - -/* Line 1806 of yacc.c */ -#line 1848 "parser.yy" + case 502: + +/* Line 1806 of yacc.c */ +#line 1862 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); } break; - case 500: - -/* Line 1806 of yacc.c */ -#line 1853 "parser.yy" + case 503: + +/* Line 1806 of yacc.c */ +#line 1867 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); } break; - case 501: - -/* Line 1806 of yacc.c */ -#line 1855 "parser.yy" + case 504: + +/* Line 1806 of yacc.c */ +#line 1869 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); } break; - case 502: - -/* Line 1806 of yacc.c */ -#line 1860 "parser.yy" + case 505: + +/* Line 1806 of yacc.c */ +#line 1874 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD ); @@ -7643,8 +7757,8 @@ break; - case 503: - -/* Line 1806 of yacc.c */ -#line 1865 "parser.yy" + case 506: + +/* Line 1806 of yacc.c */ +#line 1879 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG ); @@ -7653,46 +7767,46 @@ break; - case 504: - -/* Line 1806 of yacc.c */ -#line 1873 "parser.yy" + case 507: + +/* Line 1806 of yacc.c */ +#line 1887 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID ); - (yyval.decl) = DeclarationNode::newContext( (yyvsp[(2) - (9)].tok), (yyvsp[(5) - (9)].decl), 0 ); + (yyval.decl) = DeclarationNode::newTrait( (yyvsp[(2) - (9)].tok), (yyvsp[(5) - (9)].decl), 0 ); } break; - case 505: - -/* Line 1806 of yacc.c */ -#line 1878 "parser.yy" + case 508: + +/* Line 1806 of yacc.c */ +#line 1892 "parser.yy" { - typedefTable.enterContext( *(yyvsp[(2) - (8)].tok) ); + typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) ); typedefTable.enterScope(); } break; - case 506: - -/* Line 1806 of yacc.c */ -#line 1883 "parser.yy" + case 509: + +/* Line 1806 of yacc.c */ +#line 1897 "parser.yy" { - typedefTable.leaveContext(); + typedefTable.leaveTrait(); typedefTable.addToEnclosingScope( *(yyvsp[(2) - (11)].tok), TypedefTable::ID ); - (yyval.decl) = DeclarationNode::newContext( (yyvsp[(2) - (11)].tok), (yyvsp[(5) - (11)].decl), (yyvsp[(10) - (11)].decl) ); + (yyval.decl) = DeclarationNode::newTrait( (yyvsp[(2) - (11)].tok), (yyvsp[(5) - (11)].decl), (yyvsp[(10) - (11)].decl) ); } break; - case 508: - -/* Line 1806 of yacc.c */ -#line 1893 "parser.yy" + case 511: + +/* Line 1806 of yacc.c */ +#line 1907 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; - case 511: - -/* Line 1806 of yacc.c */ -#line 1903 "parser.yy" + case 514: + +/* Line 1806 of yacc.c */ +#line 1917 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7701,8 +7815,8 @@ break; - case 512: - -/* Line 1806 of yacc.c */ -#line 1908 "parser.yy" + case 515: + +/* Line 1806 of yacc.c */ +#line 1922 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7711,8 +7825,8 @@ break; - case 513: - -/* Line 1806 of yacc.c */ -#line 1913 "parser.yy" + case 516: + +/* Line 1806 of yacc.c */ +#line 1927 "parser.yy" { typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID ); @@ -7721,8 +7835,8 @@ break; - case 514: - -/* Line 1806 of yacc.c */ -#line 1921 "parser.yy" + case 517: + +/* Line 1806 of yacc.c */ +#line 1935 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7731,8 +7845,8 @@ break; - case 515: - -/* Line 1806 of yacc.c */ -#line 1926 "parser.yy" + case 518: + +/* Line 1806 of yacc.c */ +#line 1940 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7741,15 +7855,15 @@ break; - case 516: - -/* Line 1806 of yacc.c */ -#line 1936 "parser.yy" + case 519: + +/* Line 1806 of yacc.c */ +#line 1950 "parser.yy" {} break; - case 517: - -/* Line 1806 of yacc.c */ -#line 1938 "parser.yy" + case 520: + +/* Line 1806 of yacc.c */ +#line 1952 "parser.yy" { if ( theTree ) { @@ -7761,29 +7875,29 @@ break; - case 519: - -/* Line 1806 of yacc.c */ -#line 1950 "parser.yy" + case 522: + +/* Line 1806 of yacc.c */ +#line 1964 "parser.yy" { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); } break; - case 520: - -/* Line 1806 of yacc.c */ -#line 1955 "parser.yy" + case 523: + +/* Line 1806 of yacc.c */ +#line 1969 "parser.yy" { (yyval.decl) = 0; } break; - case 524: - -/* Line 1806 of yacc.c */ -#line 1963 "parser.yy" + case 527: + +/* Line 1806 of yacc.c */ +#line 1977 "parser.yy" {} break; - case 525: - -/* Line 1806 of yacc.c */ -#line 1965 "parser.yy" + case 528: + +/* Line 1806 of yacc.c */ +#line 1979 "parser.yy" { linkageStack.push( linkage ); @@ -7792,8 +7906,8 @@ break; - case 526: - -/* Line 1806 of yacc.c */ -#line 1970 "parser.yy" + case 529: + +/* Line 1806 of yacc.c */ +#line 1984 "parser.yy" { linkage = linkageStack.top(); @@ -7803,15 +7917,15 @@ break; - case 527: - -/* Line 1806 of yacc.c */ -#line 1976 "parser.yy" + case 530: + +/* Line 1806 of yacc.c */ +#line 1990 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl); } break; - case 529: - -/* Line 1806 of yacc.c */ -#line 1986 "parser.yy" + case 532: + +/* Line 1806 of yacc.c */ +#line 2000 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7821,8 +7935,8 @@ break; - case 530: - -/* Line 1806 of yacc.c */ -#line 1992 "parser.yy" + case 533: + +/* Line 1806 of yacc.c */ +#line 2006 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7832,8 +7946,8 @@ break; - case 531: - -/* Line 1806 of yacc.c */ -#line 2001 "parser.yy" + case 534: + +/* Line 1806 of yacc.c */ +#line 2015 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7843,8 +7957,8 @@ break; - case 532: - -/* Line 1806 of yacc.c */ -#line 2007 "parser.yy" + case 535: + +/* Line 1806 of yacc.c */ +#line 2021 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7854,8 +7968,8 @@ break; - case 533: - -/* Line 1806 of yacc.c */ -#line 2013 "parser.yy" + case 536: + +/* Line 1806 of yacc.c */ +#line 2027 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7865,8 +7979,8 @@ break; - case 534: - -/* Line 1806 of yacc.c */ -#line 2019 "parser.yy" + case 537: + +/* Line 1806 of yacc.c */ +#line 2033 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7876,8 +7990,8 @@ break; - case 535: - -/* Line 1806 of yacc.c */ -#line 2025 "parser.yy" + case 538: + +/* Line 1806 of yacc.c */ +#line 2039 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7887,8 +8001,8 @@ break; - case 536: - -/* Line 1806 of yacc.c */ -#line 2033 "parser.yy" + case 539: + +/* Line 1806 of yacc.c */ +#line 2047 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7898,8 +8012,8 @@ break; - case 537: - -/* Line 1806 of yacc.c */ -#line 2039 "parser.yy" + case 540: + +/* Line 1806 of yacc.c */ +#line 2053 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7909,8 +8023,8 @@ break; - case 538: - -/* Line 1806 of yacc.c */ -#line 2047 "parser.yy" + case 541: + +/* Line 1806 of yacc.c */ +#line 2061 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7920,8 +8034,8 @@ break; - case 539: - -/* Line 1806 of yacc.c */ -#line 2053 "parser.yy" + case 542: + +/* Line 1806 of yacc.c */ +#line 2067 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7931,85 +8045,85 @@ break; - case 543: - -/* Line 1806 of yacc.c */ -#line 2068 "parser.yy" + case 546: + +/* Line 1806 of yacc.c */ +#line 2082 "parser.yy" { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); } break; - case 546: - -/* Line 1806 of yacc.c */ -#line 2078 "parser.yy" + case 549: + +/* Line 1806 of yacc.c */ +#line 2092 "parser.yy" { (yyval.decl) = 0; } break; - case 549: - -/* Line 1806 of yacc.c */ -#line 2085 "parser.yy" + case 552: + +/* Line 1806 of yacc.c */ +#line 2099 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 550: - -/* Line 1806 of yacc.c */ -#line 2091 "parser.yy" + case 553: + +/* Line 1806 of yacc.c */ +#line 2105 "parser.yy" { (yyval.decl) = 0; } break; - case 556: - -/* Line 1806 of yacc.c */ -#line 2106 "parser.yy" + case 559: + +/* Line 1806 of yacc.c */ +#line 2120 "parser.yy" {} break; - case 557: - -/* Line 1806 of yacc.c */ -#line 2107 "parser.yy" + case 560: + +/* Line 1806 of yacc.c */ +#line 2121 "parser.yy" {} break; - case 558: - -/* Line 1806 of yacc.c */ -#line 2108 "parser.yy" + case 561: + +/* Line 1806 of yacc.c */ +#line 2122 "parser.yy" {} break; - case 559: - -/* Line 1806 of yacc.c */ -#line 2109 "parser.yy" + case 562: + +/* Line 1806 of yacc.c */ +#line 2123 "parser.yy" {} break; - case 560: - -/* Line 1806 of yacc.c */ -#line 2144 "parser.yy" + case 563: + +/* Line 1806 of yacc.c */ +#line 2158 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 562: - -/* Line 1806 of yacc.c */ -#line 2147 "parser.yy" + case 565: + +/* Line 1806 of yacc.c */ +#line 2161 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 563: - -/* Line 1806 of yacc.c */ -#line 2149 "parser.yy" + case 566: + +/* Line 1806 of yacc.c */ +#line 2163 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 564: - -/* Line 1806 of yacc.c */ -#line 2154 "parser.yy" + case 567: + +/* Line 1806 of yacc.c */ +#line 2168 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8018,428 +8132,428 @@ break; - case 565: - -/* Line 1806 of yacc.c */ -#line 2159 "parser.yy" + case 568: + +/* Line 1806 of yacc.c */ +#line 2173 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 566: - -/* Line 1806 of yacc.c */ -#line 2164 "parser.yy" + case 569: + +/* Line 1806 of yacc.c */ +#line 2178 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 567: - -/* Line 1806 of yacc.c */ -#line 2166 "parser.yy" + case 570: + +/* Line 1806 of yacc.c */ +#line 2180 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 568: - -/* Line 1806 of yacc.c */ -#line 2168 "parser.yy" + case 571: + +/* Line 1806 of yacc.c */ +#line 2182 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 569: - -/* Line 1806 of yacc.c */ -#line 2173 "parser.yy" + case 572: + +/* Line 1806 of yacc.c */ +#line 2187 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 570: - -/* Line 1806 of yacc.c */ -#line 2175 "parser.yy" + case 573: + +/* Line 1806 of yacc.c */ +#line 2189 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 571: - -/* Line 1806 of yacc.c */ -#line 2177 "parser.yy" + case 574: + +/* Line 1806 of yacc.c */ +#line 2191 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 572: - -/* Line 1806 of yacc.c */ -#line 2179 "parser.yy" + case 575: + +/* Line 1806 of yacc.c */ +#line 2193 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 573: - -/* Line 1806 of yacc.c */ -#line 2184 "parser.yy" + case 576: + +/* Line 1806 of yacc.c */ +#line 2198 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 574: - -/* Line 1806 of yacc.c */ -#line 2186 "parser.yy" + case 577: + +/* Line 1806 of yacc.c */ +#line 2200 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 575: - -/* Line 1806 of yacc.c */ -#line 2196 "parser.yy" + case 578: + +/* Line 1806 of yacc.c */ +#line 2210 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 577: - -/* Line 1806 of yacc.c */ -#line 2199 "parser.yy" + case 580: + +/* Line 1806 of yacc.c */ +#line 2213 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 578: - -/* Line 1806 of yacc.c */ -#line 2204 "parser.yy" + case 581: + +/* Line 1806 of yacc.c */ +#line 2218 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; - case 579: - -/* Line 1806 of yacc.c */ -#line 2206 "parser.yy" + case 582: + +/* Line 1806 of yacc.c */ +#line 2220 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 580: - -/* Line 1806 of yacc.c */ -#line 2208 "parser.yy" + case 583: + +/* Line 1806 of yacc.c */ +#line 2222 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 581: - -/* Line 1806 of yacc.c */ -#line 2213 "parser.yy" + case 584: + +/* Line 1806 of yacc.c */ +#line 2227 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 582: - -/* Line 1806 of yacc.c */ -#line 2215 "parser.yy" + case 585: + +/* Line 1806 of yacc.c */ +#line 2229 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 583: - -/* Line 1806 of yacc.c */ -#line 2217 "parser.yy" + case 586: + +/* Line 1806 of yacc.c */ +#line 2231 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 584: - -/* Line 1806 of yacc.c */ -#line 2222 "parser.yy" + case 587: + +/* Line 1806 of yacc.c */ +#line 2236 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 585: - -/* Line 1806 of yacc.c */ -#line 2224 "parser.yy" + case 588: + +/* Line 1806 of yacc.c */ +#line 2238 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 586: - -/* Line 1806 of yacc.c */ -#line 2226 "parser.yy" + case 589: + +/* Line 1806 of yacc.c */ +#line 2240 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 590: - -/* Line 1806 of yacc.c */ -#line 2241 "parser.yy" + case 593: + +/* Line 1806 of yacc.c */ +#line 2255 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); } break; - case 591: - -/* Line 1806 of yacc.c */ -#line 2243 "parser.yy" + case 594: + +/* Line 1806 of yacc.c */ +#line 2257 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); } break; - case 592: - -/* Line 1806 of yacc.c */ -#line 2245 "parser.yy" + case 595: + +/* Line 1806 of yacc.c */ +#line 2259 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 593: - -/* Line 1806 of yacc.c */ -#line 2250 "parser.yy" + case 596: + +/* Line 1806 of yacc.c */ +#line 2264 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 594: - -/* Line 1806 of yacc.c */ -#line 2252 "parser.yy" + case 597: + +/* Line 1806 of yacc.c */ +#line 2266 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 595: - -/* Line 1806 of yacc.c */ -#line 2254 "parser.yy" + case 598: + +/* Line 1806 of yacc.c */ +#line 2268 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 596: - -/* Line 1806 of yacc.c */ -#line 2259 "parser.yy" + case 599: + +/* Line 1806 of yacc.c */ +#line 2273 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 597: - -/* Line 1806 of yacc.c */ -#line 2261 "parser.yy" + case 600: + +/* Line 1806 of yacc.c */ +#line 2275 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 598: - -/* Line 1806 of yacc.c */ -#line 2263 "parser.yy" + case 601: + +/* Line 1806 of yacc.c */ +#line 2277 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 599: - -/* Line 1806 of yacc.c */ -#line 2278 "parser.yy" + case 602: + +/* Line 1806 of yacc.c */ +#line 2292 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 601: - -/* Line 1806 of yacc.c */ -#line 2281 "parser.yy" + case 604: + +/* Line 1806 of yacc.c */ +#line 2295 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 602: - -/* Line 1806 of yacc.c */ -#line 2283 "parser.yy" + case 605: + +/* Line 1806 of yacc.c */ +#line 2297 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 604: - -/* Line 1806 of yacc.c */ -#line 2289 "parser.yy" + case 607: + +/* Line 1806 of yacc.c */ +#line 2303 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 605: - -/* Line 1806 of yacc.c */ -#line 2294 "parser.yy" + case 608: + +/* Line 1806 of yacc.c */ +#line 2308 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 606: - -/* Line 1806 of yacc.c */ -#line 2296 "parser.yy" + case 609: + +/* Line 1806 of yacc.c */ +#line 2310 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 607: - -/* Line 1806 of yacc.c */ -#line 2298 "parser.yy" + case 610: + +/* Line 1806 of yacc.c */ +#line 2312 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 608: - -/* Line 1806 of yacc.c */ -#line 2303 "parser.yy" + case 611: + +/* Line 1806 of yacc.c */ +#line 2317 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 609: - -/* Line 1806 of yacc.c */ -#line 2305 "parser.yy" + case 612: + +/* Line 1806 of yacc.c */ +#line 2319 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 610: - -/* Line 1806 of yacc.c */ -#line 2307 "parser.yy" + case 613: + +/* Line 1806 of yacc.c */ +#line 2321 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 611: - -/* Line 1806 of yacc.c */ -#line 2309 "parser.yy" + case 614: + +/* Line 1806 of yacc.c */ +#line 2323 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 612: - -/* Line 1806 of yacc.c */ -#line 2314 "parser.yy" + case 615: + +/* Line 1806 of yacc.c */ +#line 2328 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; - case 613: - -/* Line 1806 of yacc.c */ -#line 2316 "parser.yy" + case 616: + +/* Line 1806 of yacc.c */ +#line 2330 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 614: - -/* Line 1806 of yacc.c */ -#line 2318 "parser.yy" + case 617: + +/* Line 1806 of yacc.c */ +#line 2332 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 615: - -/* Line 1806 of yacc.c */ -#line 2328 "parser.yy" + case 618: + +/* Line 1806 of yacc.c */ +#line 2342 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 617: - -/* Line 1806 of yacc.c */ -#line 2331 "parser.yy" + case 620: + +/* Line 1806 of yacc.c */ +#line 2345 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 618: - -/* Line 1806 of yacc.c */ -#line 2333 "parser.yy" + case 621: + +/* Line 1806 of yacc.c */ +#line 2347 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 619: - -/* Line 1806 of yacc.c */ -#line 2338 "parser.yy" + case 622: + +/* Line 1806 of yacc.c */ +#line 2352 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 620: - -/* Line 1806 of yacc.c */ -#line 2340 "parser.yy" + case 623: + +/* Line 1806 of yacc.c */ +#line 2354 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 621: - -/* Line 1806 of yacc.c */ -#line 2342 "parser.yy" + case 624: + +/* Line 1806 of yacc.c */ +#line 2356 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 622: - -/* Line 1806 of yacc.c */ -#line 2347 "parser.yy" + case 625: + +/* Line 1806 of yacc.c */ +#line 2361 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 623: - -/* Line 1806 of yacc.c */ -#line 2349 "parser.yy" + case 626: + +/* Line 1806 of yacc.c */ +#line 2363 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 624: - -/* Line 1806 of yacc.c */ -#line 2351 "parser.yy" + case 627: + +/* Line 1806 of yacc.c */ +#line 2365 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 625: - -/* Line 1806 of yacc.c */ -#line 2353 "parser.yy" + case 628: + +/* Line 1806 of yacc.c */ +#line 2367 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 626: - -/* Line 1806 of yacc.c */ -#line 2358 "parser.yy" + case 629: + +/* Line 1806 of yacc.c */ +#line 2372 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; - case 627: - -/* Line 1806 of yacc.c */ -#line 2360 "parser.yy" + case 630: + +/* Line 1806 of yacc.c */ +#line 2374 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 628: - -/* Line 1806 of yacc.c */ -#line 2362 "parser.yy" + case 631: + +/* Line 1806 of yacc.c */ +#line 2376 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 629: - -/* Line 1806 of yacc.c */ -#line 2393 "parser.yy" + case 632: + +/* Line 1806 of yacc.c */ +#line 2407 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 631: - -/* Line 1806 of yacc.c */ -#line 2396 "parser.yy" + case 634: + +/* Line 1806 of yacc.c */ +#line 2410 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 632: - -/* Line 1806 of yacc.c */ -#line 2398 "parser.yy" + case 635: + +/* Line 1806 of yacc.c */ +#line 2412 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 633: - -/* Line 1806 of yacc.c */ -#line 2403 "parser.yy" + case 636: + +/* Line 1806 of yacc.c */ +#line 2417 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8448,8 +8562,8 @@ break; - case 634: - -/* Line 1806 of yacc.c */ -#line 2408 "parser.yy" + case 637: + +/* Line 1806 of yacc.c */ +#line 2422 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8458,687 +8572,687 @@ break; - case 635: - -/* Line 1806 of yacc.c */ -#line 2416 "parser.yy" + case 638: + +/* Line 1806 of yacc.c */ +#line 2430 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 636: - -/* Line 1806 of yacc.c */ -#line 2418 "parser.yy" + case 639: + +/* Line 1806 of yacc.c */ +#line 2432 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 637: - -/* Line 1806 of yacc.c */ -#line 2420 "parser.yy" + case 640: + +/* Line 1806 of yacc.c */ +#line 2434 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 638: - -/* Line 1806 of yacc.c */ -#line 2425 "parser.yy" + case 641: + +/* Line 1806 of yacc.c */ +#line 2439 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 639: - -/* Line 1806 of yacc.c */ -#line 2427 "parser.yy" + case 642: + +/* Line 1806 of yacc.c */ +#line 2441 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 640: - -/* Line 1806 of yacc.c */ -#line 2432 "parser.yy" + case 643: + +/* Line 1806 of yacc.c */ +#line 2446 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; - case 641: - -/* Line 1806 of yacc.c */ -#line 2434 "parser.yy" + case 644: + +/* Line 1806 of yacc.c */ +#line 2448 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 643: - -/* Line 1806 of yacc.c */ -#line 2449 "parser.yy" + case 646: + +/* Line 1806 of yacc.c */ +#line 2463 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 644: - -/* Line 1806 of yacc.c */ -#line 2451 "parser.yy" + case 647: + +/* Line 1806 of yacc.c */ +#line 2465 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 645: - -/* Line 1806 of yacc.c */ -#line 2456 "parser.yy" + case 648: + +/* Line 1806 of yacc.c */ +#line 2470 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; - case 646: - -/* Line 1806 of yacc.c */ -#line 2458 "parser.yy" + case 649: + +/* Line 1806 of yacc.c */ +#line 2472 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; - case 647: - -/* Line 1806 of yacc.c */ -#line 2460 "parser.yy" + case 650: + +/* Line 1806 of yacc.c */ +#line 2474 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 648: - -/* Line 1806 of yacc.c */ -#line 2462 "parser.yy" + case 651: + +/* Line 1806 of yacc.c */ +#line 2476 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 649: - -/* Line 1806 of yacc.c */ -#line 2464 "parser.yy" + case 652: + +/* Line 1806 of yacc.c */ +#line 2478 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 651: - -/* Line 1806 of yacc.c */ -#line 2470 "parser.yy" + case 654: + +/* Line 1806 of yacc.c */ +#line 2484 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 652: - -/* Line 1806 of yacc.c */ -#line 2472 "parser.yy" + case 655: + +/* Line 1806 of yacc.c */ +#line 2486 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 653: - -/* Line 1806 of yacc.c */ -#line 2474 "parser.yy" + case 656: + +/* Line 1806 of yacc.c */ +#line 2488 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 654: - -/* Line 1806 of yacc.c */ -#line 2479 "parser.yy" + case 657: + +/* Line 1806 of yacc.c */ +#line 2493 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); } break; - case 655: - -/* Line 1806 of yacc.c */ -#line 2481 "parser.yy" + case 658: + +/* Line 1806 of yacc.c */ +#line 2495 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 656: - -/* Line 1806 of yacc.c */ -#line 2483 "parser.yy" + case 659: + +/* Line 1806 of yacc.c */ +#line 2497 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 657: - -/* Line 1806 of yacc.c */ -#line 2489 "parser.yy" + case 660: + +/* Line 1806 of yacc.c */ +#line 2503 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } break; - case 658: - -/* Line 1806 of yacc.c */ -#line 2491 "parser.yy" + case 661: + +/* Line 1806 of yacc.c */ +#line 2505 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); } break; - case 660: - -/* Line 1806 of yacc.c */ -#line 2497 "parser.yy" + case 663: + +/* Line 1806 of yacc.c */ +#line 2511 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); } break; - case 661: - -/* Line 1806 of yacc.c */ -#line 2499 "parser.yy" + case 664: + +/* Line 1806 of yacc.c */ +#line 2513 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( 0 ); } break; - case 662: - -/* Line 1806 of yacc.c */ -#line 2501 "parser.yy" + case 665: + +/* Line 1806 of yacc.c */ +#line 2515 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); } break; - case 663: - -/* Line 1806 of yacc.c */ -#line 2503 "parser.yy" + case 666: + +/* Line 1806 of yacc.c */ +#line 2517 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); } break; - case 665: - -/* Line 1806 of yacc.c */ -#line 2518 "parser.yy" + case 668: + +/* Line 1806 of yacc.c */ +#line 2532 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 666: - -/* Line 1806 of yacc.c */ -#line 2520 "parser.yy" + case 669: + +/* Line 1806 of yacc.c */ +#line 2534 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 667: - -/* Line 1806 of yacc.c */ -#line 2525 "parser.yy" + case 670: + +/* Line 1806 of yacc.c */ +#line 2539 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; - case 668: - -/* Line 1806 of yacc.c */ -#line 2527 "parser.yy" + case 671: + +/* Line 1806 of yacc.c */ +#line 2541 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; - case 669: - -/* Line 1806 of yacc.c */ -#line 2529 "parser.yy" + case 672: + +/* Line 1806 of yacc.c */ +#line 2543 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 670: - -/* Line 1806 of yacc.c */ -#line 2531 "parser.yy" + case 673: + +/* Line 1806 of yacc.c */ +#line 2545 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 671: - -/* Line 1806 of yacc.c */ -#line 2533 "parser.yy" + case 674: + +/* Line 1806 of yacc.c */ +#line 2547 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 673: - -/* Line 1806 of yacc.c */ -#line 2539 "parser.yy" + case 676: + +/* Line 1806 of yacc.c */ +#line 2553 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 674: - -/* Line 1806 of yacc.c */ -#line 2541 "parser.yy" + case 677: + +/* Line 1806 of yacc.c */ +#line 2555 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 675: - -/* Line 1806 of yacc.c */ -#line 2543 "parser.yy" + case 678: + +/* Line 1806 of yacc.c */ +#line 2557 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 676: - -/* Line 1806 of yacc.c */ -#line 2548 "parser.yy" + case 679: + +/* Line 1806 of yacc.c */ +#line 2562 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); } break; - case 677: - -/* Line 1806 of yacc.c */ -#line 2550 "parser.yy" + case 680: + +/* Line 1806 of yacc.c */ +#line 2564 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 678: - -/* Line 1806 of yacc.c */ -#line 2552 "parser.yy" + case 681: + +/* Line 1806 of yacc.c */ +#line 2566 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 680: - -/* Line 1806 of yacc.c */ -#line 2559 "parser.yy" + case 683: + +/* Line 1806 of yacc.c */ +#line 2573 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 682: - -/* Line 1806 of yacc.c */ -#line 2570 "parser.yy" + case 685: + +/* Line 1806 of yacc.c */ +#line 2584 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } break; - case 683: - -/* Line 1806 of yacc.c */ -#line 2573 "parser.yy" + case 686: + +/* Line 1806 of yacc.c */ +#line 2587 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } break; - case 684: - -/* Line 1806 of yacc.c */ -#line 2575 "parser.yy" + case 687: + +/* Line 1806 of yacc.c */ +#line 2589 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); } break; - case 685: - -/* Line 1806 of yacc.c */ -#line 2578 "parser.yy" + case 688: + +/* Line 1806 of yacc.c */ +#line 2592 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } break; - case 686: - -/* Line 1806 of yacc.c */ -#line 2580 "parser.yy" + case 689: + +/* Line 1806 of yacc.c */ +#line 2594 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); } break; - case 687: - -/* Line 1806 of yacc.c */ -#line 2582 "parser.yy" + case 690: + +/* Line 1806 of yacc.c */ +#line 2596 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); } break; - case 689: - -/* Line 1806 of yacc.c */ -#line 2596 "parser.yy" + case 692: + +/* Line 1806 of yacc.c */ +#line 2610 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 690: - -/* Line 1806 of yacc.c */ -#line 2598 "parser.yy" + case 693: + +/* Line 1806 of yacc.c */ +#line 2612 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 691: - -/* Line 1806 of yacc.c */ -#line 2603 "parser.yy" + case 694: + +/* Line 1806 of yacc.c */ +#line 2617 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; - case 692: - -/* Line 1806 of yacc.c */ -#line 2605 "parser.yy" + case 695: + +/* Line 1806 of yacc.c */ +#line 2619 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; - case 693: - -/* Line 1806 of yacc.c */ -#line 2607 "parser.yy" + case 696: + +/* Line 1806 of yacc.c */ +#line 2621 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 694: - -/* Line 1806 of yacc.c */ -#line 2609 "parser.yy" + case 697: + +/* Line 1806 of yacc.c */ +#line 2623 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 695: - -/* Line 1806 of yacc.c */ -#line 2611 "parser.yy" + case 698: + +/* Line 1806 of yacc.c */ +#line 2625 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 697: - -/* Line 1806 of yacc.c */ -#line 2617 "parser.yy" + case 700: + +/* Line 1806 of yacc.c */ +#line 2631 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 698: - -/* Line 1806 of yacc.c */ -#line 2619 "parser.yy" + case 701: + +/* Line 1806 of yacc.c */ +#line 2633 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 699: - -/* Line 1806 of yacc.c */ -#line 2621 "parser.yy" + case 702: + +/* Line 1806 of yacc.c */ +#line 2635 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 700: - -/* Line 1806 of yacc.c */ -#line 2626 "parser.yy" + case 703: + +/* Line 1806 of yacc.c */ +#line 2640 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 701: - -/* Line 1806 of yacc.c */ -#line 2628 "parser.yy" + case 704: + +/* Line 1806 of yacc.c */ +#line 2642 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 704: - -/* Line 1806 of yacc.c */ -#line 2638 "parser.yy" + case 707: + +/* Line 1806 of yacc.c */ +#line 2652 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 707: - -/* Line 1806 of yacc.c */ -#line 2648 "parser.yy" + case 710: + +/* Line 1806 of yacc.c */ +#line 2662 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 708: - -/* Line 1806 of yacc.c */ -#line 2650 "parser.yy" + case 711: + +/* Line 1806 of yacc.c */ +#line 2664 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 709: - -/* Line 1806 of yacc.c */ -#line 2652 "parser.yy" + case 712: + +/* Line 1806 of yacc.c */ +#line 2666 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 710: - -/* Line 1806 of yacc.c */ -#line 2654 "parser.yy" + case 713: + +/* Line 1806 of yacc.c */ +#line 2668 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 711: - -/* Line 1806 of yacc.c */ -#line 2656 "parser.yy" + case 714: + +/* Line 1806 of yacc.c */ +#line 2670 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 712: - -/* Line 1806 of yacc.c */ -#line 2658 "parser.yy" + case 715: + +/* Line 1806 of yacc.c */ +#line 2672 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 713: - -/* Line 1806 of yacc.c */ -#line 2665 "parser.yy" + case 716: + +/* Line 1806 of yacc.c */ +#line 2679 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 714: - -/* Line 1806 of yacc.c */ -#line 2667 "parser.yy" + case 717: + +/* Line 1806 of yacc.c */ +#line 2681 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 715: - -/* Line 1806 of yacc.c */ -#line 2669 "parser.yy" + case 718: + +/* Line 1806 of yacc.c */ +#line 2683 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 716: - -/* Line 1806 of yacc.c */ -#line 2671 "parser.yy" + case 719: + +/* Line 1806 of yacc.c */ +#line 2685 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } break; - case 717: - -/* Line 1806 of yacc.c */ -#line 2673 "parser.yy" + case 720: + +/* Line 1806 of yacc.c */ +#line 2687 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 718: - -/* Line 1806 of yacc.c */ -#line 2675 "parser.yy" + case 721: + +/* Line 1806 of yacc.c */ +#line 2689 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 719: - -/* Line 1806 of yacc.c */ -#line 2677 "parser.yy" + case 722: + +/* Line 1806 of yacc.c */ +#line 2691 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 720: - -/* Line 1806 of yacc.c */ -#line 2679 "parser.yy" + case 723: + +/* Line 1806 of yacc.c */ +#line 2693 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 721: - -/* Line 1806 of yacc.c */ -#line 2681 "parser.yy" + case 724: + +/* Line 1806 of yacc.c */ +#line 2695 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } break; - case 722: - -/* Line 1806 of yacc.c */ -#line 2683 "parser.yy" + case 725: + +/* Line 1806 of yacc.c */ +#line 2697 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 723: - -/* Line 1806 of yacc.c */ -#line 2688 "parser.yy" + case 726: + +/* Line 1806 of yacc.c */ +#line 2702 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } break; - case 724: - -/* Line 1806 of yacc.c */ -#line 2690 "parser.yy" + case 727: + +/* Line 1806 of yacc.c */ +#line 2704 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } break; - case 725: - -/* Line 1806 of yacc.c */ -#line 2695 "parser.yy" + case 728: + +/* Line 1806 of yacc.c */ +#line 2709 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); } break; - case 726: - -/* Line 1806 of yacc.c */ -#line 2697 "parser.yy" + case 729: + +/* Line 1806 of yacc.c */ +#line 2711 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); } break; - case 728: - -/* Line 1806 of yacc.c */ -#line 2724 "parser.yy" + case 731: + +/* Line 1806 of yacc.c */ +#line 2738 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 732: - -/* Line 1806 of yacc.c */ -#line 2735 "parser.yy" + case 735: + +/* Line 1806 of yacc.c */ +#line 2749 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 733: - -/* Line 1806 of yacc.c */ -#line 2737 "parser.yy" + case 736: + +/* Line 1806 of yacc.c */ +#line 2751 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 734: - -/* Line 1806 of yacc.c */ -#line 2739 "parser.yy" + case 737: + +/* Line 1806 of yacc.c */ +#line 2753 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 735: - -/* Line 1806 of yacc.c */ -#line 2741 "parser.yy" + case 738: + +/* Line 1806 of yacc.c */ +#line 2755 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 736: - -/* Line 1806 of yacc.c */ -#line 2743 "parser.yy" + case 739: + +/* Line 1806 of yacc.c */ +#line 2757 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 737: - -/* Line 1806 of yacc.c */ -#line 2745 "parser.yy" + case 740: + +/* Line 1806 of yacc.c */ +#line 2759 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 738: - -/* Line 1806 of yacc.c */ -#line 2752 "parser.yy" + case 741: + +/* Line 1806 of yacc.c */ +#line 2766 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 739: - -/* Line 1806 of yacc.c */ -#line 2754 "parser.yy" + case 742: + +/* Line 1806 of yacc.c */ +#line 2768 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 740: - -/* Line 1806 of yacc.c */ -#line 2756 "parser.yy" + case 743: + +/* Line 1806 of yacc.c */ +#line 2770 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 741: - -/* Line 1806 of yacc.c */ -#line 2758 "parser.yy" + case 744: + +/* Line 1806 of yacc.c */ +#line 2772 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 742: - -/* Line 1806 of yacc.c */ -#line 2760 "parser.yy" + case 745: + +/* Line 1806 of yacc.c */ +#line 2774 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 743: - -/* Line 1806 of yacc.c */ -#line 2762 "parser.yy" + case 746: + +/* Line 1806 of yacc.c */ +#line 2776 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 744: - -/* Line 1806 of yacc.c */ -#line 2767 "parser.yy" + case 747: + +/* Line 1806 of yacc.c */ +#line 2781 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } break; - case 745: - -/* Line 1806 of yacc.c */ -#line 2772 "parser.yy" + case 748: + +/* Line 1806 of yacc.c */ +#line 2786 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); } break; - case 746: - -/* Line 1806 of yacc.c */ -#line 2774 "parser.yy" + case 749: + +/* Line 1806 of yacc.c */ +#line 2788 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); } break; - case 747: - -/* Line 1806 of yacc.c */ -#line 2776 "parser.yy" + case 750: + +/* Line 1806 of yacc.c */ +#line 2790 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); } break; - case 750: - -/* Line 1806 of yacc.c */ -#line 2800 "parser.yy" + case 753: + +/* Line 1806 of yacc.c */ +#line 2814 "parser.yy" { (yyval.en) = 0; } break; - case 751: - -/* Line 1806 of yacc.c */ -#line 2802 "parser.yy" + case 754: + +/* Line 1806 of yacc.c */ +#line 2816 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; @@ -9147,5 +9261,5 @@ /* Line 1806 of yacc.c */ -#line 9150 "Parser/parser.cc" +#line 9264 "Parser/parser.cc" default: break; } @@ -9378,5 +9492,5 @@ /* Line 2067 of yacc.c */ -#line 2805 "parser.yy" +#line 2819 "parser.yy" // ----end of grammar---- @@ -9385,5 +9499,5 @@ std::cout << "Error "; if ( yyfilename ) { - std::cout << "in file " << yyfilename << " "; + std::cout << "in file " << yyfilename << " "; } // if std::cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << std::endl; Index: src/Parser/parser.h =================================================================== --- src/Parser/parser.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/parser.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -59,88 +59,89 @@ SIGNED = 277, UNSIGNED = 278, - BOOL = 279, - COMPLEX = 280, - IMAGINARY = 281, - TYPEOF = 282, - LABEL = 283, - ENUM = 284, - STRUCT = 285, - UNION = 286, - TYPE = 287, - FTYPE = 288, - DTYPE = 289, - CONTEXT = 290, - SIZEOF = 291, - OFFSETOF = 292, - ATTRIBUTE = 293, - EXTENSION = 294, - IF = 295, - ELSE = 296, - SWITCH = 297, - CASE = 298, - DEFAULT = 299, - DO = 300, - WHILE = 301, - FOR = 302, - BREAK = 303, - CONTINUE = 304, - GOTO = 305, - RETURN = 306, - CHOOSE = 307, - DISABLE = 308, - ENABLE = 309, - FALLTHRU = 310, - TRY = 311, - CATCH = 312, - CATCHRESUME = 313, - FINALLY = 314, - THROW = 315, - THROWRESUME = 316, - AT = 317, - ASM = 318, - ALIGNAS = 319, - ALIGNOF = 320, - ATOMIC = 321, - GENERIC = 322, - NORETURN = 323, - STATICASSERT = 324, - THREADLOCAL = 325, - IDENTIFIER = 326, - QUOTED_IDENTIFIER = 327, - TYPEDEFname = 328, - TYPEGENname = 329, - ATTR_IDENTIFIER = 330, - ATTR_TYPEDEFname = 331, - ATTR_TYPEGENname = 332, - INTEGERconstant = 333, - FLOATINGconstant = 334, - CHARACTERconstant = 335, - STRINGliteral = 336, - ZERO = 337, - ONE = 338, - ARROW = 339, - ICR = 340, - DECR = 341, - LS = 342, - RS = 343, - LE = 344, - GE = 345, - EQ = 346, - NE = 347, - ANDAND = 348, - OROR = 349, - ELLIPSIS = 350, - MULTassign = 351, - DIVassign = 352, - MODassign = 353, - PLUSassign = 354, - MINUSassign = 355, - LSassign = 356, - RSassign = 357, - ANDassign = 358, - ERassign = 359, - ORassign = 360, - ATassign = 361, - THEN = 362 + VALIST = 279, + BOOL = 280, + COMPLEX = 281, + IMAGINARY = 282, + TYPEOF = 283, + LABEL = 284, + ENUM = 285, + STRUCT = 286, + UNION = 287, + OTYPE = 288, + FTYPE = 289, + DTYPE = 290, + TRAIT = 291, + SIZEOF = 292, + OFFSETOF = 293, + ATTRIBUTE = 294, + EXTENSION = 295, + IF = 296, + ELSE = 297, + SWITCH = 298, + CASE = 299, + DEFAULT = 300, + DO = 301, + WHILE = 302, + FOR = 303, + BREAK = 304, + CONTINUE = 305, + GOTO = 306, + RETURN = 307, + CHOOSE = 308, + DISABLE = 309, + ENABLE = 310, + FALLTHRU = 311, + TRY = 312, + CATCH = 313, + CATCHRESUME = 314, + FINALLY = 315, + THROW = 316, + THROWRESUME = 317, + AT = 318, + ASM = 319, + ALIGNAS = 320, + ALIGNOF = 321, + ATOMIC = 322, + GENERIC = 323, + NORETURN = 324, + STATICASSERT = 325, + THREADLOCAL = 326, + IDENTIFIER = 327, + QUOTED_IDENTIFIER = 328, + TYPEDEFname = 329, + TYPEGENname = 330, + ATTR_IDENTIFIER = 331, + ATTR_TYPEDEFname = 332, + ATTR_TYPEGENname = 333, + INTEGERconstant = 334, + FLOATINGconstant = 335, + CHARACTERconstant = 336, + STRINGliteral = 337, + ZERO = 338, + ONE = 339, + ARROW = 340, + ICR = 341, + DECR = 342, + LS = 343, + RS = 344, + LE = 345, + GE = 346, + EQ = 347, + NE = 348, + ANDAND = 349, + OROR = 350, + ELLIPSIS = 351, + MULTassign = 352, + DIVassign = 353, + MODassign = 354, + PLUSassign = 355, + MINUSassign = 356, + LSassign = 357, + RSassign = 358, + ANDassign = 359, + ERassign = 360, + ORassign = 361, + ATassign = 362, + THEN = 363 }; #endif @@ -167,88 +168,89 @@ #define SIGNED 277 #define UNSIGNED 278 -#define BOOL 279 -#define COMPLEX 280 -#define IMAGINARY 281 -#define TYPEOF 282 -#define LABEL 283 -#define ENUM 284 -#define STRUCT 285 -#define UNION 286 -#define TYPE 287 -#define FTYPE 288 -#define DTYPE 289 -#define CONTEXT 290 -#define SIZEOF 291 -#define OFFSETOF 292 -#define ATTRIBUTE 293 -#define EXTENSION 294 -#define IF 295 -#define ELSE 296 -#define SWITCH 297 -#define CASE 298 -#define DEFAULT 299 -#define DO 300 -#define WHILE 301 -#define FOR 302 -#define BREAK 303 -#define CONTINUE 304 -#define GOTO 305 -#define RETURN 306 -#define CHOOSE 307 -#define DISABLE 308 -#define ENABLE 309 -#define FALLTHRU 310 -#define TRY 311 -#define CATCH 312 -#define CATCHRESUME 313 -#define FINALLY 314 -#define THROW 315 -#define THROWRESUME 316 -#define AT 317 -#define ASM 318 -#define ALIGNAS 319 -#define ALIGNOF 320 -#define ATOMIC 321 -#define GENERIC 322 -#define NORETURN 323 -#define STATICASSERT 324 -#define THREADLOCAL 325 -#define IDENTIFIER 326 -#define QUOTED_IDENTIFIER 327 -#define TYPEDEFname 328 -#define TYPEGENname 329 -#define ATTR_IDENTIFIER 330 -#define ATTR_TYPEDEFname 331 -#define ATTR_TYPEGENname 332 -#define INTEGERconstant 333 -#define FLOATINGconstant 334 -#define CHARACTERconstant 335 -#define STRINGliteral 336 -#define ZERO 337 -#define ONE 338 -#define ARROW 339 -#define ICR 340 -#define DECR 341 -#define LS 342 -#define RS 343 -#define LE 344 -#define GE 345 -#define EQ 346 -#define NE 347 -#define ANDAND 348 -#define OROR 349 -#define ELLIPSIS 350 -#define MULTassign 351 -#define DIVassign 352 -#define MODassign 353 -#define PLUSassign 354 -#define MINUSassign 355 -#define LSassign 356 -#define RSassign 357 -#define ANDassign 358 -#define ERassign 359 -#define ORassign 360 -#define ATassign 361 -#define THEN 362 +#define VALIST 279 +#define BOOL 280 +#define COMPLEX 281 +#define IMAGINARY 282 +#define TYPEOF 283 +#define LABEL 284 +#define ENUM 285 +#define STRUCT 286 +#define UNION 287 +#define OTYPE 288 +#define FTYPE 289 +#define DTYPE 290 +#define TRAIT 291 +#define SIZEOF 292 +#define OFFSETOF 293 +#define ATTRIBUTE 294 +#define EXTENSION 295 +#define IF 296 +#define ELSE 297 +#define SWITCH 298 +#define CASE 299 +#define DEFAULT 300 +#define DO 301 +#define WHILE 302 +#define FOR 303 +#define BREAK 304 +#define CONTINUE 305 +#define GOTO 306 +#define RETURN 307 +#define CHOOSE 308 +#define DISABLE 309 +#define ENABLE 310 +#define FALLTHRU 311 +#define TRY 312 +#define CATCH 313 +#define CATCHRESUME 314 +#define FINALLY 315 +#define THROW 316 +#define THROWRESUME 317 +#define AT 318 +#define ASM 319 +#define ALIGNAS 320 +#define ALIGNOF 321 +#define ATOMIC 322 +#define GENERIC 323 +#define NORETURN 324 +#define STATICASSERT 325 +#define THREADLOCAL 326 +#define IDENTIFIER 327 +#define QUOTED_IDENTIFIER 328 +#define TYPEDEFname 329 +#define TYPEGENname 330 +#define ATTR_IDENTIFIER 331 +#define ATTR_TYPEDEFname 332 +#define ATTR_TYPEGENname 333 +#define INTEGERconstant 334 +#define FLOATINGconstant 335 +#define CHARACTERconstant 336 +#define STRINGliteral 337 +#define ZERO 338 +#define ONE 339 +#define ARROW 340 +#define ICR 341 +#define DECR 342 +#define LS 343 +#define RS 344 +#define LE 345 +#define GE 346 +#define EQ 347 +#define NE 348 +#define ANDAND 349 +#define OROR 350 +#define ELLIPSIS 351 +#define MULTassign 352 +#define DIVassign 353 +#define MODassign 354 +#define PLUSassign 355 +#define MINUSassign 356 +#define LSassign 357 +#define RSassign 358 +#define ANDassign 359 +#define ERassign 360 +#define ORassign 361 +#define ATassign 362 +#define THEN 363 @@ -260,5 +262,5 @@ /* Line 2068 of yacc.c */ -#line 110 "parser.yy" +#line 112 "parser.yy" Token tok; @@ -277,5 +279,5 @@ /* Line 2068 of yacc.c */ -#line 280 "Parser/parser.h" +#line 282 "Parser/parser.h" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/Parser/parser.yy (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Feb 1 18:22:42 2016 -// Update Count : 1483 +// Last Modified On : Wed Apr 13 16:58:43 2016 +// Update Count : 1519 // @@ -51,7 +51,8 @@ #include #include +#include "lex.h" +#include "parser.h" +#include "ParseNode.h" #include "TypedefTable.h" -#include "lex.h" -#include "ParseNode.h" #include "TypeData.h" #include "LinkageSpec.h" @@ -74,8 +75,9 @@ %token FORALL LVALUE // CFA %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED +%token VALIST // GCC %token BOOL COMPLEX IMAGINARY // C99 %token TYPEOF LABEL // GCC %token ENUM STRUCT UNION -%token TYPE FTYPE DTYPE CONTEXT // CFA +%token OTYPE FTYPE DTYPE TRAIT // CFA %token SIZEOF OFFSETOF %token ATTRIBUTE EXTENSION // GCC @@ -171,5 +173,5 @@ %type basic_declaration_specifier basic_type_name basic_type_specifier direct_type_name indirect_type_name -%type context_declaration context_declaration_list context_declaring_list context_specifier +%type trait_declaration trait_declaration_list trait_declaring_list trait_specifier %type declaration declaration_list declaration_list_opt declaration_qualifier_list @@ -197,5 +199,5 @@ %type new_array_parameter_1st_dimension -%type new_context_declaring_list new_declaration new_field_declaring_list +%type new_trait_declaring_list new_declaration new_field_declaring_list %type new_function_declaration new_function_return new_function_specifier @@ -370,5 +372,5 @@ { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), $1 ); } | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99 - { $$ = 0; } + { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); } | postfix_expression '{' argument_expression_list '}' // CFA { @@ -448,5 +450,5 @@ { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), new TypeValueNode( $3 )); } | OFFSETOF '(' type_name_no_function ',' no_attr_identifier ')' - { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::OffsetOf ), new TypeValueNode( $3 ), new VarRefNode( $5 )); } + { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::OffsetOf ), new TypeValueNode( $3 ), new VarRefNode( $5 )); } | ATTR_IDENTIFIER { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 )); } @@ -1020,5 +1022,5 @@ | new_function_declaration pop ';' | type_declaring_list pop ';' - | context_specifier pop ';' + | trait_specifier pop ';' ; @@ -1027,5 +1029,5 @@ { typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $1; + $$ = $1->addInitializer( $2 ); } | declaration_qualifier_list new_variable_specifier initializer_opt @@ -1034,10 +1036,10 @@ { typedefTable.addToEnclosingScope( TypedefTable::ID ); - $$ = $2->addQualifiers( $1 ); + $$ = $2->addQualifiers( $1 )->addInitializer( $3 );; } | new_variable_declaration pop ',' push identifier_or_type_name initializer_opt { typedefTable.addToEnclosingScope( *$5, TypedefTable::ID ); - $$ = $1->appendList( $1->cloneType( $5 ) ); + $$ = $1->appendList( $1->cloneType( $5 )->addInitializer( $6 ) ); } ; @@ -1345,4 +1347,6 @@ | IMAGINARY // C99 { $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); } + | VALIST // GCC, __builtin_va_list + { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); } ; @@ -1434,9 +1438,14 @@ { $$ = DeclarationNode::newAggregate( $1, 0, 0, $3 ); } | aggregate_key no_attr_identifier_or_type_name - { $$ = DeclarationNode::newAggregate( $1, $2, 0, 0 ); } - | aggregate_key no_attr_identifier_or_type_name '{' field_declaration_list '}' - { $$ = DeclarationNode::newAggregate( $1, $2, 0, $4 ); } + { + typedefTable.makeTypedef( *$2 ); + $$ = DeclarationNode::newAggregate( $1, $2, 0, 0 ); + } + | aggregate_key no_attr_identifier_or_type_name + { typedefTable.makeTypedef( *$2 ); } + '{' field_declaration_list '}' + { $$ = DeclarationNode::newAggregate( $1, $2, 0, $5); } | aggregate_key '(' type_name_list ')' '{' field_declaration_list '}' // CFA - { $$ = DeclarationNode::newAggregate( $1, 0, $3, $6 ); } + { $$ = DeclarationNode::newAggregate( $1, 0, $3, $6 ); } | aggregate_key typegen_name // CFA, S/R conflict { $$ = $2; } @@ -1516,8 +1525,13 @@ enum_key '{' enumerator_list comma_opt '}' { $$ = DeclarationNode::newEnum( 0, $3 ); } - | enum_key no_attr_identifier_or_type_name '{' enumerator_list comma_opt '}' - { $$ = DeclarationNode::newEnum( $2, $4 ); } | enum_key no_attr_identifier_or_type_name - { $$ = DeclarationNode::newEnum( $2, 0 ); } + { + typedefTable.makeTypedef( *$2 ); + $$ = DeclarationNode::newEnum( $2, 0 ); + } + | enum_key no_attr_identifier_or_type_name + { typedefTable.makeTypedef( *$2 ); } + '{' enumerator_list comma_opt '}' + { $$ = DeclarationNode::newEnum( $2, $5 ); } ; @@ -1803,5 +1817,5 @@ type_class: // CFA - TYPE + OTYPE { $$ = DeclarationNode::Type; } | DTYPE @@ -1821,10 +1835,10 @@ '|' no_attr_identifier_or_type_name '(' type_name_list ')' { - typedefTable.openContext( *$2 ); - $$ = DeclarationNode::newContextUse( $2, $4 ); - } - | '|' '{' push context_declaration_list '}' + typedefTable.openTrait( *$2 ); + $$ = DeclarationNode::newTraitUse( $2, $4 ); + } + | '|' '{' push trait_declaration_list '}' { $$ = $4; } - | '|' '(' push type_parameter_list pop ')' '{' push context_declaration_list '}' '(' type_name_list ')' + | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_name_list ')' { $$ = 0; } ; @@ -1841,7 +1855,7 @@ type_declaring_list: // CFA - TYPE type_declarator - { $$ = $2; } - | storage_class_list TYPE type_declarator + OTYPE type_declarator + { $$ = $2; } + | storage_class_list OTYPE type_declarator { $$ = $3->addQualifiers( $1 ); } | type_declaring_list ',' type_declarator @@ -1869,35 +1883,35 @@ ; -context_specifier: // CFA - CONTEXT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' '}' +trait_specifier: // CFA + TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' '}' { typedefTable.addToEnclosingScope( *$2, TypedefTable::ID ); - $$ = DeclarationNode::newContext( $2, $5, 0 ); - } - | CONTEXT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' - { - typedefTable.enterContext( *$2 ); + $$ = DeclarationNode::newTrait( $2, $5, 0 ); + } + | TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' + { + typedefTable.enterTrait( *$2 ); typedefTable.enterScope(); } - context_declaration_list '}' - { - typedefTable.leaveContext(); + trait_declaration_list '}' + { + typedefTable.leaveTrait(); typedefTable.addToEnclosingScope( *$2, TypedefTable::ID ); - $$ = DeclarationNode::newContext( $2, $5, $10 ); - } - ; - -context_declaration_list: // CFA - context_declaration - | context_declaration_list push context_declaration + $$ = DeclarationNode::newTrait( $2, $5, $10 ); + } + ; + +trait_declaration_list: // CFA + trait_declaration + | trait_declaration_list push trait_declaration { $$ = $1->appendList( $3 ); } ; -context_declaration: // CFA - new_context_declaring_list pop ';' - | context_declaring_list pop ';' - ; - -new_context_declaring_list: // CFA +trait_declaration: // CFA + new_trait_declaring_list pop ';' + | trait_declaring_list pop ';' + ; + +new_trait_declaring_list: // CFA new_variable_specifier { @@ -1910,5 +1924,5 @@ $$ = $1; } - | new_context_declaring_list pop ',' push identifier_or_type_name + | new_trait_declaring_list pop ',' push identifier_or_type_name { typedefTable.addToEnclosingScope2( *$5, TypedefTable::ID ); @@ -1917,5 +1931,5 @@ ; -context_declaring_list: // CFA +trait_declaring_list: // CFA type_specifier declarator { @@ -1923,5 +1937,5 @@ $$ = $2->addType( $1 ); } - | context_declaring_list pop ',' push declarator + | trait_declaring_list pop ',' push declarator { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -2809,5 +2823,5 @@ std::cout << "Error "; if ( yyfilename ) { - std::cout << "in file " << yyfilename << " "; + std::cout << "in file " << yyfilename << " "; } // if std::cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << std::endl; Index: src/ResolvExpr/AdjustExprType.cc =================================================================== --- src/ResolvExpr/AdjustExprType.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/AdjustExprType.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sat May 16 23:41:42 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat May 16 23:54:02 2015 -// Update Count : 3 +// Last Modified On : Wed Mar 2 17:34:53 2016 +// Update Count : 4 // @@ -33,7 +33,8 @@ virtual Type* mutate( UnionInstType *aggregateUseType ); virtual Type* mutate( EnumInstType *aggregateUseType ); - virtual Type* mutate( ContextInstType *aggregateUseType ); + virtual Type* mutate( TraitInstType *aggregateUseType ); virtual Type* mutate( TypeInstType *aggregateUseType ); virtual Type* mutate( TupleType *tupleType ); + virtual Type* mutate( VarArgsType *varArgsType ); const TypeEnvironment &env; @@ -86,5 +87,5 @@ } - Type *AdjustExprType::mutate( ContextInstType *aggregateUseType ) { + Type *AdjustExprType::mutate( TraitInstType *aggregateUseType ) { return aggregateUseType; } @@ -111,4 +112,8 @@ return tupleType; } + + Type *AdjustExprType::mutate( VarArgsType *varArgsType ) { + return varArgsType; + } } // namespace ResolvExpr Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/AlternativeFinder.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -848,4 +848,8 @@ } + void AlternativeFinder::visit( OffsetPackExpr *offsetPackExpr ) { + alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) ); + } + void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) { // assume no polymorphism Index: src/ResolvExpr/AlternativeFinder.h =================================================================== --- src/ResolvExpr/AlternativeFinder.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/AlternativeFinder.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -59,4 +59,5 @@ virtual void visit( UntypedOffsetofExpr *offsetofExpr ); virtual void visit( OffsetofExpr *offsetofExpr ); + virtual void visit( OffsetPackExpr *offsetPackExpr ); virtual void visit( AttrExpr *attrExpr ); virtual void visit( LogicalExpr *logicalExpr ); Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/CommonType.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 06:59:27 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 07:04:50 2015 -// Update Count : 2 +// Last Modified On : Wed Mar 2 17:35:34 2016 +// Update Count : 3 // @@ -35,7 +35,8 @@ virtual void visit( UnionInstType *aggregateUseType ); virtual void visit( EnumInstType *aggregateUseType ); - virtual void visit( ContextInstType *aggregateUseType ); + virtual void visit( TraitInstType *aggregateUseType ); virtual void visit( TypeInstType *aggregateUseType ); virtual void visit( TupleType *tupleType ); + virtual void visit( VarArgsType *varArgsType ); template< typename RefType > void handleRefType( RefType *inst, Type *other ); @@ -185,5 +186,5 @@ } - void CommonType::visit( ContextInstType *aggregateUseType ) { + void CommonType::visit( TraitInstType *aggregateUseType ) { } @@ -213,4 +214,7 @@ void CommonType::visit( TupleType *tupleType ) { } + + void CommonType::visit( VarArgsType *varArgsType ) { + } } // namespace ResolvExpr Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/ConversionCost.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 07:06:19 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 07:22:19 2015 -// Update Count : 4 +// Last Modified On : Wed Mar 2 17:35:46 2016 +// Update Count : 6 // @@ -206,5 +206,5 @@ } - void ConversionCost::visit(ContextInstType *inst) { + void ConversionCost::visit(TraitInstType *inst) { } @@ -247,4 +247,10 @@ } // if } + + void ConversionCost::visit(VarArgsType *varArgsType) { + if ( dynamic_cast< VarArgsType* >( dest ) ) { + cost = Cost::zero; + } + } } // namespace ResolvExpr Index: src/ResolvExpr/ConversionCost.h =================================================================== --- src/ResolvExpr/ConversionCost.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/ConversionCost.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 09:37:28 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 09:39:23 2015 -// Update Count : 2 +// Last Modified On : Wed Mar 2 17:35:56 2016 +// Update Count : 3 // @@ -37,7 +37,8 @@ virtual void visit(UnionInstType *aggregateUseType); virtual void visit(EnumInstType *aggregateUseType); - virtual void visit(ContextInstType *aggregateUseType); + virtual void visit(TraitInstType *aggregateUseType); virtual void visit(TypeInstType *aggregateUseType); virtual void visit(TupleType *tupleType); + virtual void visit(VarArgsType *varArgsType); protected: Type *dest; Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/PtrsAssignable.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 11:44:11 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Mon Sep 21 14:34:58 2015 -// Update Count : 7 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Mar 2 17:36:05 2016 +// Update Count : 8 // @@ -35,7 +35,8 @@ virtual void visit( UnionInstType *inst ); virtual void visit( EnumInstType *inst ); - virtual void visit( ContextInstType *inst ); + virtual void visit( TraitInstType *inst ); virtual void visit( TypeInstType *inst ); virtual void visit( TupleType *tupleType ); + virtual void visit( VarArgsType *varArgsType ); private: Type *dest; @@ -100,5 +101,5 @@ } - void PtrsAssignable::visit( ContextInstType *inst ) { + void PtrsAssignable::visit( TraitInstType *inst ) { // I definitely don't think we should be doing anything here } @@ -137,4 +138,7 @@ /// } } + + void PtrsAssignable::visit( VarArgsType *varArgsType ) { + } } // namespace ResolvExpr Index: src/ResolvExpr/PtrsCastable.cc =================================================================== --- src/ResolvExpr/PtrsCastable.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/PtrsCastable.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 11:48:00 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Mon Oct 05 14:49:12 2015 -// Update Count : 7 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Mar 2 17:36:18 2016 +// Update Count : 8 // @@ -36,7 +36,8 @@ virtual void visit(UnionInstType *inst); virtual void visit(EnumInstType *inst); - virtual void visit(ContextInstType *inst); + virtual void visit(TraitInstType *inst); virtual void visit(TypeInstType *inst); virtual void visit(TupleType *tupleType); + virtual void visit(VarArgsType *varArgsType); private: Type *dest; @@ -115,7 +116,7 @@ void PtrsCastable::visit(EnumInstType *inst) { - if ( dynamic_cast< EnumInstType* >( inst ) ) { + if ( dynamic_cast< EnumInstType* >( dest ) ) { result = 1; - } else if ( BasicType *bt = dynamic_cast< BasicType* >( inst ) ) { + } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) { if ( bt->get_kind() == BasicType::SignedInt ) { result = 0; @@ -128,5 +129,5 @@ } - void PtrsCastable::visit(ContextInstType *inst) { + void PtrsCastable::visit(TraitInstType *inst) { // I definitely don't think we should be doing anything here } @@ -139,4 +140,8 @@ result = objectCast( dest, env, indexer ); } + + void PtrsCastable::visit(VarArgsType *varArgsType) { + result = objectCast( dest, env, indexer ); + } } // namespace ResolvExpr Index: src/ResolvExpr/RenameVars.cc =================================================================== --- src/ResolvExpr/RenameVars.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/RenameVars.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 12:05:18 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jun 8 14:51:35 2015 -// Update Count : 4 +// Last Modified On : Wed Mar 2 17:36:32 2016 +// Update Count : 5 // @@ -86,5 +86,5 @@ } - void RenameVars::visit( ContextInstType *aggregateUseType ) { + void RenameVars::visit( TraitInstType *aggregateUseType ) { typeBefore( aggregateUseType ); acceptAll( aggregateUseType->get_parameters(), *this ); @@ -111,4 +111,9 @@ acceptAll( tupleType->get_types(), *this ); typeAfter( tupleType ); + } + + void RenameVars::visit( VarArgsType *varArgsType ) { + typeBefore( varArgsType ); + typeAfter( varArgsType ); } Index: src/ResolvExpr/RenameVars.h =================================================================== --- src/ResolvExpr/RenameVars.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/RenameVars.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 12:10:28 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 12:11:53 2015 -// Update Count : 2 +// Last Modified On : Wed Mar 2 17:36:39 2016 +// Update Count : 3 // @@ -40,7 +40,8 @@ virtual void visit( UnionInstType *aggregateUseType ); virtual void visit( EnumInstType *aggregateUseType ); - virtual void visit( ContextInstType *aggregateUseType ); + virtual void visit( TraitInstType *aggregateUseType ); virtual void visit( TypeInstType *aggregateUseType ); virtual void visit( TupleType *tupleType ); + virtual void visit( VarArgsType *varArgsType ); void typeBefore( Type *type ); Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/Resolver.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 12:17:01 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Feb 9 21:57:52 2016 -// Update Count : 179 +// Last Modified On : Thu Mar 24 16:43:11 2016 +// Update Count : 181 // @@ -165,6 +165,13 @@ Type *new_type = resolveTypeof( objectDecl->get_type(), *this ); objectDecl->set_type( new_type ); + // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable + // initContext is changed multiple time because the LHS is analysed twice. The second analysis changes + // initContext because of a function type can contain object declarations in the return and parameter types. So + // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting + // the RHS. + Type *temp = initContext; initContext = new_type; SymTab::Indexer::visit( objectDecl ); + initContext = temp; } Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/ResolvExpr/Unify.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// Unify.cc -- +// Unify.cc -- // // Author : Richard C. Bilson // Created On : Sun May 17 12:27:10 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Wed Sep 02 14:43:22 2015 -// Update Count : 36 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Mar 2 17:37:05 2016 +// Update Count : 37 // @@ -38,5 +38,5 @@ WidenMode operator&( const WidenMode &other ) { WidenMode newWM( *this ); newWM &= other; return newWM; } operator bool() { return widenFirst && widenSecond; } - + bool widenFirst : 1, widenSecond : 1; }; @@ -45,5 +45,5 @@ public: Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ); - + bool get_result() const { return result; } private: @@ -56,7 +56,8 @@ virtual void visit(UnionInstType *aggregateUseType); virtual void visit(EnumInstType *aggregateUseType); - virtual void visit(ContextInstType *aggregateUseType); + virtual void visit(TraitInstType *aggregateUseType); virtual void visit(TypeInstType *aggregateUseType); virtual void visit(TupleType *tupleType); + virtual void visit(VarArgsType *varArgsType); template< typename RefType > void handleRefType( RefType *inst, Type *other ); @@ -78,5 +79,5 @@ bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common ); bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ); - + bool typesCompatible( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { TypeEnvironment newEnv; @@ -136,5 +137,5 @@ case TypeDecl::Dtype: return ! isFtype( type, indexer ); - + case TypeDecl::Ftype: return isFtype( type, indexer ); @@ -195,5 +196,5 @@ bool widen1 = false, widen2 = false; Type *type1 = 0, *type2 = 0; - + if ( env.lookup( var1->get_name(), class1 ) ) { hasClass1 = true; @@ -216,5 +217,5 @@ widen2 = widenMode.widenSecond && class2.allowWidening; } // if - + if ( type1 && type2 ) { // std::cout << "has type1 && type2" << std::endl; @@ -435,7 +436,5 @@ // to unify, array types must both be VLA or both not VLA // and must both have a dimension expression or not have a dimension - if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() - && ((arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0) - || (arrayType->get_dimension() == 0 && otherArray->get_dimension() == 0))) { + if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() ) { // not positive this is correct in all cases, but it's needed for typedefs @@ -448,12 +447,15 @@ ConstantExpr * ce1 = dynamic_cast< ConstantExpr * >( arrayType->get_dimension() ); ConstantExpr * ce2 = dynamic_cast< ConstantExpr * >( otherArray->get_dimension() ); - assert(ce1 && ce2); - - Constant * c1 = ce1->get_constant(); - Constant * c2 = ce2->get_constant(); - - if ( c1->get_value() != c2->get_value() ) { - // does not unify if the dimension is different - return; + // see C11 Reference Manual 6.7.6.2.6 + // two array types with size specifiers that are integer constant expressions are + // compatible if both size specifiers have the same constant value + if ( ce1 && ce2 ) { + Constant * c1 = ce1->get_constant(); + Constant * c2 = ce2->get_constant(); + + if ( c1->get_value() != c2->get_value() ) { + // does not unify if the dimension is different + return; + } } } @@ -484,5 +486,5 @@ if ( unifyDeclList( functionType->get_parameters().begin(), functionType->get_parameters().end(), otherFunction->get_parameters().begin(), otherFunction->get_parameters().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) { - + if ( unifyDeclList( functionType->get_returnVals().begin(), functionType->get_returnVals().end(), otherFunction->get_returnVals().begin(), otherFunction->get_returnVals().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) { @@ -539,5 +541,5 @@ } - void Unify::visit(ContextInstType *contextInst) { + void Unify::visit(TraitInstType *contextInst) { handleRefType( contextInst, type2 ); } @@ -582,4 +584,8 @@ } + void Unify::visit(VarArgsType *varArgsType) { + result = dynamic_cast< VarArgsType* >( type2 ); + } + } // namespace ResolvExpr Index: src/SymTab/AddVisit.h =================================================================== --- src/SymTab/AddVisit.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/AddVisit.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 16:14:32 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Tue Jul 14 12:26:17 2015 -// Update Count : 4 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Apr 7 14:42:21 2016 +// Update Count : 5 // @@ -27,37 +27,6 @@ template< typename Visitor > - inline void addVisitStatement( Statement *stmt, Visitor &visitor ) { - maybeAccept( stmt, visitor ); -/// if ( ! declsToAdd.empty() ) { -/// CompoundStmt *compound = new CompoundStmt( noLabels ); -/// compound->get_kids().push_back( stmt ); -/// addDecls( declsToAdd, compound->get_kids(), compound->get_kids().end() ); -/// } - } - - template< typename Visitor > inline void addVisit(CompoundStmt *compoundStmt, Visitor &visitor) { addVisitStatementList( compoundStmt->get_kids(), visitor ); - } - - template< typename Visitor > - inline void addVisit(IfStmt *ifStmt, Visitor &visitor) { - addVisitStatement( ifStmt->get_thenPart(), visitor ); - addVisitStatement( ifStmt->get_elsePart(), visitor ); - maybeAccept( ifStmt->get_condition(), visitor ); - } - - template< typename Visitor > - inline void addVisit(WhileStmt *whileStmt, Visitor &visitor) { - addVisitStatement( whileStmt->get_body(), visitor ); - maybeAccept( whileStmt->get_condition(), visitor ); - } - - template< typename Visitor > - inline void addVisit(ForStmt *forStmt, Visitor &visitor) { - addVisitStatement( forStmt->get_body(), visitor ); - acceptAll( forStmt->get_initialization(), visitor ); - maybeAccept( forStmt->get_condition(), visitor ); - maybeAccept( forStmt->get_increment(), visitor ); } @@ -74,15 +43,9 @@ } - template< typename Visitor > - inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) { - addVisitStatementList( caseStmt->get_statements(), visitor ); - maybeAccept( caseStmt->get_condition(), visitor ); - } - - template< typename Visitor > - inline void addVisit(CatchStmt *cathStmt, Visitor &visitor) { - addVisitStatement( cathStmt->get_body(), visitor ); - maybeAccept( cathStmt->get_decl(), visitor ); - } + // template< typename Visitor > + // inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) { + // addVisitStatementList( caseStmt->get_statements(), visitor ); + // maybeAccept( caseStmt->get_condition(), visitor ); + // } } // namespace SymTab Index: src/SymTab/AggregateTable.h =================================================================== --- src/SymTab/AggregateTable.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,53 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// AggregateTable.h -- -// -// Author : Richard C. Bilson -// Created On : Sun May 17 16:17:26 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 16:19:29 2015 -// Update Count : 4 -// - -#ifndef AGGREGATETABLE_H -#define AGGREGATETABLE_H - -#include -#include -#include -#include - -#include "StackTable.h" -#include "SynTree/Declaration.h" - -namespace SymTab { - template< class AggregateDeclClass > - class AggregateTableConflictFunction : public std::binary_function< AggregateDeclClass *, AggregateDeclClass *, AggregateDeclClass *> { - public: - AggregateDeclClass *operator()( AggregateDeclClass *existing, AggregateDeclClass *added ) { - if ( existing->get_members().empty() ) { - return added; - } else if ( ! added->get_members().empty() ) { - throw SemanticError( "redeclaration of ", added ); - } // if - return existing; - } - }; - - typedef StackTable< StructDecl, AggregateTableConflictFunction< StructDecl > > StructTable; - typedef StackTable< EnumDecl, AggregateTableConflictFunction< EnumDecl > > EnumTable; - typedef StackTable< UnionDecl, AggregateTableConflictFunction< UnionDecl > > UnionTable; - typedef StackTable< ContextDecl, AggregateTableConflictFunction< ContextDecl > > ContextTable; -} // namespace SymTab - -#endif // AGGREGATETABLE_H - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SymTab/FixFunction.cc =================================================================== --- src/SymTab/FixFunction.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/FixFunction.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 16:19:49 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 16:22:54 2015 -// Update Count : 2 +// Last Modified On : Wed Mar 2 17:31:10 2016 +// Update Count : 3 // @@ -61,5 +61,5 @@ } - Type * FixFunction::mutate(ContextInstType *aggregateUseType) { + Type * FixFunction::mutate(TraitInstType *aggregateUseType) { return aggregateUseType; } @@ -72,4 +72,8 @@ return tupleType; } + + Type * FixFunction::mutate(VarArgsType *varArgsType) { + return varArgsType; + } } // namespace SymTab Index: src/SymTab/FixFunction.h =================================================================== --- src/SymTab/FixFunction.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/FixFunction.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 17:02:08 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 17:03:43 2015 -// Update Count : 2 +// Last Modified On : Wed Mar 2 17:34:06 2016 +// Update Count : 3 // @@ -38,7 +38,8 @@ virtual Type* mutate(UnionInstType *aggregateUseType); virtual Type* mutate(EnumInstType *aggregateUseType); - virtual Type* mutate(ContextInstType *aggregateUseType); + virtual Type* mutate(TraitInstType *aggregateUseType); virtual Type* mutate(TypeInstType *aggregateUseType); virtual Type* mutate(TupleType *tupleType); + virtual Type* mutate(VarArgsType *varArgsType); bool isVoid; Index: src/SymTab/IdTable.cc =================================================================== --- src/SymTab/IdTable.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,189 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// IdTable.cc -- -// -// Author : Richard C. Bilson -// Created On : Sun May 17 17:04:02 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jan 8 22:59:23 2016 -// Update Count : 74 -// - -#include - -#include "SynTree/Declaration.h" -#include "ResolvExpr/typeops.h" -#include "Indexer.h" -#include "Mangler.h" -#include "IdTable.h" -#include "Common/SemanticError.h" - -using std::string; - -namespace SymTab { - IdTable::IdTable() : scopeLevel( 0 ) { - } - - void IdTable::enterScope() { - scopeLevel++; - } - - void IdTable::leaveScope() { - for ( OuterTableType::iterator outer = table.begin(); outer != table.end(); ++outer ) { - for ( InnerTableType::iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) { - std::stack< DeclEntry >& entry = inner->second; - // xxx - should be while? - if ( ! entry.empty() && entry.top().second == scopeLevel ) { - entry.pop(); - } // if - } // for - } // for - - scopeLevel--; - assert( scopeLevel >= 0 ); - } - - void IdTable::addDecl( DeclarationWithType *decl ) { - const string &name = decl->get_name(); - string manglename; - if ( decl->get_linkage() == LinkageSpec::C ) { - manglename = name; - } else if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) { - // mangle the name without including the appropriate suffix, so overridable routines are placed into the - // same "bucket" as their user defined versions. - manglename = Mangler::mangle( decl, false ); - } else { - manglename = Mangler::mangle( decl ); - } // if - - InnerTableType &declTable = table[ name ]; - InnerTableType::iterator it = declTable.find( manglename ); - - if ( it == declTable.end() ) { - // first time this name mangling has been defined - declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) ); - } else { - std::stack< DeclEntry >& entry = it->second; - if ( ! entry.empty() && entry.top().second == scopeLevel ) { - // if we're giving the same name mangling to things of different types then there is something wrong - Declaration *old = entry.top().first; - assert( (dynamic_cast( decl ) && dynamic_cast( old ) ) - || (dynamic_cast( decl ) && dynamic_cast( old ) ) ); - - if ( LinkageSpec::isOverridable( old->get_linkage() ) ) { - // new definition shadows the autogenerated one, even at the same scope - declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) ); - } else if ( decl->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( decl->get_type(), entry.top().first->get_type(), Indexer() ) ) { - // typesCompatible doesn't really do the right thing here. When checking compatibility of function types, - // we should ignore outermost pointer qualifiers, except _Atomic? - FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( decl ); - FunctionDecl *oldentry = dynamic_cast< FunctionDecl* >( old ); - if ( newentry && oldentry ) { - if ( newentry->get_statements() && oldentry->get_statements() ) { - throw SemanticError( "duplicate function definition for 1 ", decl ); - } // if - } else { - // two objects with the same mangled name defined in the same scope. - // both objects must be marked extern or both must be intrinsic for this to be okay - // xxx - perhaps it's actually if either is intrinsic then this is okay? - // might also need to be same storage class? - ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( decl ); - ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( old ); - if (newobj->get_storageClass() != DeclarationNode::Extern && oldobj->get_storageClass() != DeclarationNode::Extern ) { - throw SemanticError( "duplicate definition for 3 ", decl ); - } // if - } // if - } else { - throw SemanticError( "duplicate definition for ", decl ); - } // if - } else { - // new scope level - shadow existing definition - declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) ); - } // if - } // if - // this ensures that no two declarations with the same unmangled name both have C linkage - for ( InnerTableType::iterator i = declTable.begin(); i != declTable.end(); ++i ) { - if ( ! i->second.empty() && i->second.top().first->get_linkage() == LinkageSpec::C && declTable.size() > 1 ) { - InnerTableType::iterator j = i; - for ( j++; j != declTable.end(); ++j ) { - if ( ! j->second.empty() && j->second.top().first->get_linkage() == LinkageSpec::C ) { - throw SemanticError( "invalid overload of C function " ); - } // if - } // for - } // if - } // for - } - - void IdTable::lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const { - OuterTableType::const_iterator outer = table.find( id ); - if ( outer == table.end() ) return; - const InnerTableType &declTable = outer->second; - for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) { - const std::stack< DeclEntry >& entry = it->second; - if ( ! entry.empty() ) { - decls.push_back( entry.top().first ); - } // if - } // for - } - - DeclarationWithType * IdTable::lookupId( const std::string &id) const { - DeclarationWithType* result = 0; - int depth = -1; - - OuterTableType::const_iterator outer = table.find( id ); - if ( outer == table.end() ) return 0; - const InnerTableType &declTable = outer->second; - for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) { - const std::stack< DeclEntry >& entry = it->second; - if ( ! entry.empty() && entry.top().second > depth ) { - result = entry.top().first; - depth = entry.top().second; - } // if - } // for - return result; - } - - void IdTable::dump( std::ostream &os ) const { - for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) { - for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) { -#if 0 - const std::stack< DeclEntry >& entry = inner->second; - if ( ! entry.empty() ) { // && entry.top().second == scopeLevel ) { - os << outer->first << " (" << inner->first << ") (" << entry.top().second << ")" << std::endl; - } else { - os << outer->first << " (" << inner->first << ") ( entry-empty)" << std::endl; - } // if -#endif -#if 0 - std::stack stack = inner->second; - os << "dumping a stack" << std::endl; - while ( ! stack.empty()) { - DeclEntry d = stack.top(); - os << outer->first << " (" << inner->first << ") (" << d.second << ") " << std::endl; - stack.pop(); - } // while -#endif - } // for - } // for -#if 0 - for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) { - for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) { - const std::stack< DeclEntry >& entry = inner->second; - if ( ! entry.empty() && entry.top().second == scopeLevel ) { - os << outer->first << " (" << inner->first << ") (" << scopeLevel << ")" << std::endl; - } // if - } // for - } // for -#endif - } -} // namespace SymTab - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SymTab/IdTable.h =================================================================== --- src/SymTab/IdTable.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,54 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// IdTable.h -- -// -// Author : Richard C. Bilson -// Created On : Sun May 17 21:30:02 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 19 16:49:33 2015 -// Update Count : 4 -// - -#ifndef IDTABLE_H -#define IDTABLE_H - -#include -#include -#include -#include - -#include "SynTree/SynTree.h" - -namespace SymTab { - class IdTable { - public: - IdTable(); - - void enterScope(); - void leaveScope(); - void addDecl( DeclarationWithType *decl ); - void lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const; - DeclarationWithType* lookupId( const std::string &id) const; - - void dump( std::ostream &os ) const; // debugging - private: - typedef std::pair< DeclarationWithType*, int > DeclEntry; - typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType; - typedef std::map< std::string, InnerTableType > OuterTableType; - - OuterTableType table; - int scopeLevel; - }; -} // namespace SymTab - -#endif // IDTABLE_H - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SymTab/ImplementationType.cc =================================================================== --- src/SymTab/ImplementationType.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/ImplementationType.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:32:01 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 21:34:40 2015 -// Update Count : 2 +// Last Modified On : Wed Mar 2 17:31:20 2016 +// Update Count : 3 // @@ -37,7 +37,8 @@ virtual void visit(UnionInstType *aggregateUseType); virtual void visit(EnumInstType *aggregateUseType); - virtual void visit(ContextInstType *aggregateUseType); + virtual void visit(TraitInstType *aggregateUseType); virtual void visit(TypeInstType *aggregateUseType); virtual void visit(TupleType *tupleType); + virtual void visit(VarArgsType *varArgsType); Type *result; // synthesized @@ -95,5 +96,5 @@ } - void ImplementationType::visit(ContextInstType *aggregateUseType) { + void ImplementationType::visit(TraitInstType *aggregateUseType) { } @@ -116,4 +117,7 @@ result = newType; } + + void ImplementationType::visit(VarArgsType *varArgsType) { + } } // namespace SymTab Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/Indexer.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -9,8 +9,22 @@ // Author : Richard C. Bilson // Created On : Sun May 17 21:37:33 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Wed Aug 05 13:52:42 2015 -// Update Count : 10 -// +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Mar 2 17:31:29 2016 +// Update Count : 11 +// + +#include "Indexer.h" + +#include +#include +#include +#include +#include + +#include "Mangler.h" + +#include "Common/utility.h" + +#include "ResolvExpr/typeops.h" #include "SynTree/Declaration.h" @@ -19,7 +33,4 @@ #include "SynTree/Initializer.h" #include "SynTree/Statement.h" -#include "Indexer.h" -#include -#include "Common/utility.h" #define debugPrint(x) if ( doDebug ) { std::cout << x; } @@ -33,7 +44,104 @@ } - Indexer::Indexer( bool useDebug ) : doDebug( useDebug ) {} - - Indexer::~Indexer() {} + typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable; + typedef std::unordered_map< std::string, MangleTable > IdTable; + typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable; + typedef std::unordered_map< std::string, StructDecl* > StructTable; + typedef std::unordered_map< std::string, EnumDecl* > EnumTable; + typedef std::unordered_map< std::string, UnionDecl* > UnionTable; + typedef std::unordered_map< std::string, TraitDecl* > TraitTable; + + void dump( const IdTable &table, std::ostream &os ) { + for ( IdTable::const_iterator id = table.begin(); id != table.end(); ++id ) { + for ( MangleTable::const_iterator mangle = id->second.begin(); mangle != id->second.end(); ++mangle ) { + os << mangle->second << std::endl; + } + } + } + + template< typename Decl > + void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) { + for ( typename std::unordered_map< std::string, Decl* >::const_iterator it = table.begin(); it != table.end(); ++it ) { + os << it->second << std::endl; + } // for + } + + struct Indexer::Impl { + Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(), + idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {} + Impl( unsigned long _scope, Indexer &&_base ) : refCount(1), scope( _scope ), size( 0 ), base( _base ), + idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {} + unsigned long refCount; ///< Number of references to these tables + unsigned long scope; ///< Scope these tables are associated with + unsigned long size; ///< Number of elements stored in this table + const Indexer base; ///< Base indexer this extends + + IdTable idTable; ///< Identifier namespace + TypeTable typeTable; ///< Type namespace + StructTable structTable; ///< Struct namespace + EnumTable enumTable; ///< Enum namespace + UnionTable unionTable; ///< Union namespace + TraitTable traitTable; ///< Trait namespace + }; + + Indexer::Impl *Indexer::newRef( Indexer::Impl *toClone ) { + if ( ! toClone ) return 0; + + // shorten the search chain by skipping empty links + Indexer::Impl *ret = toClone->size == 0 ? toClone->base.tables : toClone; + if ( ret ) { ++ret->refCount; } + + return ret; + } + + void Indexer::deleteRef( Indexer::Impl *toFree ) { + if ( ! toFree ) return; + + if ( --toFree->refCount == 0 ) delete toFree; + } + + void Indexer::makeWritable() { + if ( ! tables ) { + // create indexer if not yet set + tables = new Indexer::Impl( scope ); + } else if ( tables->refCount > 1 || tables->scope != scope ) { + // make this indexer the base of a fresh indexer at the current scope + tables = new Indexer::Impl( scope, std::move( *this ) ); + } + } + + Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {} + + Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {} + + Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) { + that.tables = 0; + } + + Indexer::~Indexer() { + deleteRef( tables ); + } + + Indexer& Indexer::operator= ( const Indexer &that ) { + deleteRef( tables ); + + tables = newRef( that.tables ); + scope = that.scope; + doDebug = that.doDebug; + + return *this; + } + + Indexer& Indexer::operator= ( Indexer &&that ) { + deleteRef( tables ); + + tables = that.tables; + scope = that.scope; + doDebug = that.doDebug; + + that.tables = 0; + + return *this; + } void Indexer::visit( ObjectDecl *objectDecl ) { @@ -45,5 +153,5 @@ if ( objectDecl->get_name() != "" ) { debugPrint( "Adding object " << objectDecl->get_name() << std::endl ); - idTable.addDecl( objectDecl ); + addId( objectDecl ); } // if } @@ -52,5 +160,5 @@ if ( functionDecl->get_name() == "" ) return; debugPrint( "Adding function " << functionDecl->get_name() << std::endl ); - idTable.addDecl( functionDecl ); + addId( functionDecl ); enterScope(); maybeAccept( functionDecl->get_functionType(), *this ); @@ -90,5 +198,5 @@ leaveScope(); debugPrint( "Adding type " << typeDecl->get_name() << std::endl ); - typeTable.add( typeDecl ); + addType( typeDecl ); acceptAll( typeDecl->get_assertions(), *this ); } @@ -100,5 +208,5 @@ leaveScope(); debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl ); - typeTable.add( typeDecl ); + addType( typeDecl ); } @@ -108,5 +216,5 @@ cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() ); debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl ); - structTable.add( &fwdDecl ); + addStruct( &fwdDecl ); enterScope(); @@ -117,5 +225,5 @@ debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl ); // this addition replaces the forward declaration - structTable.add( aggregateDecl ); + addStruct( aggregateDecl ); } @@ -125,5 +233,5 @@ cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() ); debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl ); - unionTable.add( &fwdDecl ); + addUnion( &fwdDecl ); enterScope(); @@ -133,15 +241,15 @@ debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl ); - unionTable.add( aggregateDecl ); + addUnion( aggregateDecl ); } void Indexer::visit( EnumDecl *aggregateDecl ) { debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl ); - enumTable.add( aggregateDecl ); + addEnum( aggregateDecl ); // unlike structs, contexts, and unions, enums inject their members into the global scope acceptAll( aggregateDecl->get_members(), *this ); } - void Indexer::visit( ContextDecl *aggregateDecl ) { + void Indexer::visit( TraitDecl *aggregateDecl ) { enterScope(); acceptAll( aggregateDecl->get_parameters(), *this ); @@ -150,5 +258,5 @@ debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl ); - contextTable.add( aggregateDecl ); + addTrait( aggregateDecl ); } @@ -236,4 +344,9 @@ maybeAccept( offsetofExpr->get_type(), *this ); maybeAccept( offsetofExpr->get_member(), *this ); + } + + void Indexer::visit( OffsetPackExpr *offsetPackExpr ) { + acceptAllNewScope( offsetPackExpr->get_results(), *this ); + maybeAccept( offsetPackExpr->get_type(), *this ); } @@ -293,5 +406,5 @@ - void Indexer::visit( ContextInstType *contextInst ) { + void Indexer::visit( TraitInstType *contextInst ) { acceptAll( contextInst->get_parameters(), *this ); acceptAll( contextInst->get_members(), *this ); @@ -299,7 +412,7 @@ void Indexer::visit( StructInstType *structInst ) { - if ( ! structTable.lookup( structInst->get_name() ) ) { + if ( ! lookupStruct( structInst->get_name() ) ) { debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl ); - structTable.add( structInst->get_name() ); + addStruct( structInst->get_name() ); } enterScope(); @@ -309,7 +422,7 @@ void Indexer::visit( UnionInstType *unionInst ) { - if ( ! unionTable.lookup( unionInst->get_name() ) ) { + if ( ! lookupUnion( unionInst->get_name() ) ) { debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl ); - unionTable.add( unionInst->get_name() ); + addUnion( unionInst->get_name() ); } enterScope(); @@ -325,90 +438,361 @@ } - - void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const { - idTable.lookupId( id, list ); - } - - DeclarationWithType* Indexer::lookupId( const std::string &id) const { - return idTable.lookupId(id); + + + void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const { + std::unordered_set< std::string > foundMangleNames; + + Indexer::Impl *searchTables = tables; + while ( searchTables ) { + + IdTable::const_iterator decls = searchTables->idTable.find( id ); + if ( decls != searchTables->idTable.end() ) { + const MangleTable &mangleTable = decls->second; + for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) { + // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found + if ( foundMangleNames.insert( decl->first ).second == false ) continue; + + out.push_back( decl->second ); + } + } + + // get declarations from base indexers + searchTables = searchTables->base.tables; + } } NamedTypeDecl *Indexer::lookupType( const std::string &id ) const { - return typeTable.lookup( id ); + if ( ! tables ) return 0; + + TypeTable::const_iterator ret = tables->typeTable.find( id ); + return ret != tables->typeTable.end() ? ret->second : tables->base.lookupType( id ); } StructDecl *Indexer::lookupStruct( const std::string &id ) const { - return structTable.lookup( id ); + if ( ! tables ) return 0; + + StructTable::const_iterator ret = tables->structTable.find( id ); + return ret != tables->structTable.end() ? ret->second : tables->base.lookupStruct( id ); } EnumDecl *Indexer::lookupEnum( const std::string &id ) const { - return enumTable.lookup( id ); + if ( ! tables ) return 0; + + EnumTable::const_iterator ret = tables->enumTable.find( id ); + return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnum( id ); } UnionDecl *Indexer::lookupUnion( const std::string &id ) const { - return unionTable.lookup( id ); - } - - ContextDecl * Indexer::lookupContext( const std::string &id ) const { - return contextTable.lookup( id ); + if ( ! tables ) return 0; + + UnionTable::const_iterator ret = tables->unionTable.find( id ); + return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnion( id ); + } + + TraitDecl *Indexer::lookupTrait( const std::string &id ) const { + if ( ! tables ) return 0; + + TraitTable::const_iterator ret = tables->traitTable.find( id ); + return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTrait( id ); + } + + DeclarationWithType *Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const { + if ( ! tables ) return 0; + if ( tables->scope < scope ) return 0; + + IdTable::const_iterator decls = tables->idTable.find( id ); + if ( decls != tables->idTable.end() ) { + const MangleTable &mangleTable = decls->second; + MangleTable::const_iterator decl = mangleTable.find( mangleName ); + if ( decl != mangleTable.end() ) return decl->second; + } + + return tables->base.lookupIdAtScope( id, mangleName, scope ); + } + + bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const { + if ( ! tables ) return false; + + IdTable::const_iterator decls = tables->idTable.find( id ); + if ( decls != tables->idTable.end() ) { + const MangleTable &mangleTable = decls->second; + for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) { + // check for C decls with the same name, skipping + // those with a compatible type (by mangleName) + if ( decl->second->get_linkage() == LinkageSpec::C && decl->first != mangleName ) return true; + } + } + + return tables->base.hasIncompatibleCDecl( id, mangleName ); + } + + NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const { + if ( ! tables ) return 0; + if ( tables->scope < scope ) return 0; + + TypeTable::const_iterator ret = tables->typeTable.find( id ); + return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope ); + } + + StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const { + if ( ! tables ) return 0; + if ( tables->scope < scope ) return 0; + + StructTable::const_iterator ret = tables->structTable.find( id ); + return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope ); + } + + EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const { + if ( ! tables ) return 0; + if ( tables->scope < scope ) return 0; + + EnumTable::const_iterator ret = tables->enumTable.find( id ); + return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope ); + } + + UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const { + if ( ! tables ) return 0; + if ( tables->scope < scope ) return 0; + + UnionTable::const_iterator ret = tables->unionTable.find( id ); + return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope ); + } + + TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const { + if ( ! tables ) return 0; + if ( tables->scope < scope ) return 0; + + TraitTable::const_iterator ret = tables->traitTable.find( id ); + return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTraitAtScope( id, scope ); + } + + bool addedIdConflicts( DeclarationWithType *existing, DeclarationWithType *added ) { + // if we're giving the same name mangling to things of different types then there is something wrong + assert( (dynamic_cast( added ) && dynamic_cast( existing ) ) + || (dynamic_cast( added ) && dynamic_cast( existing ) ) ); + + if ( LinkageSpec::isOverridable( existing->get_linkage() ) ) { + // new definition shadows the autogenerated one, even at the same scope + return false; + } else if ( added->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) { + // typesCompatible doesn't really do the right thing here. When checking compatibility of function types, + // we should ignore outermost pointer qualifiers, except _Atomic? + FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( added ); + FunctionDecl *oldentry = dynamic_cast< FunctionDecl* >( existing ); + if ( newentry && oldentry ) { + if ( newentry->get_statements() && oldentry->get_statements() ) { + throw SemanticError( "duplicate function definition for ", added ); + } // if + } else { + // two objects with the same mangled name defined in the same scope. + // both objects must be marked extern or both must be intrinsic for this to be okay + // xxx - perhaps it's actually if either is intrinsic then this is okay? + // might also need to be same storage class? + ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( added ); + ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing ); + if ( newobj->get_storageClass() != DeclarationNode::Extern && oldobj->get_storageClass() != DeclarationNode::Extern ) { + throw SemanticError( "duplicate object definition for ", added ); + } // if + } // if + } else { + throw SemanticError( "duplicate definition for ", added ); + } // if + + return true; + } + + void Indexer::addId( DeclarationWithType *decl ) { + makeWritable(); + + const std::string &name = decl->get_name(); + std::string mangleName; + if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) { + // mangle the name without including the appropriate suffix, so overridable routines are placed into the + // same "bucket" as their user defined versions. + mangleName = Mangler::mangle( decl, false ); + } else { + mangleName = Mangler::mangle( decl ); + } // if + + DeclarationWithType *existing = lookupIdAtScope( name, mangleName, scope ); + if ( ! existing || ! addedIdConflicts( existing, decl ) ) { + // this ensures that no two declarations with the same unmangled name both have C linkage + if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName ) ) { + throw SemanticError( "invalid overload of C function ", decl ); + } // NOTE this is broken in Richard's original code in such a way that it never triggers (it + // doesn't check decls that have the same manglename, and all C-linkage decls are defined to + // have their name as their manglename, hence the error can never trigger). + // The code here is closer to correct, but name mangling would have to be completely + // isomorphic to C type-compatibility, which it may not be. + + tables->idTable[ name ][ mangleName ] = decl; + ++tables->size; + } + } + + bool addedTypeConflicts( NamedTypeDecl *existing, NamedTypeDecl *added ) { + if ( existing->get_base() == 0 ) { + return false; + } else if ( added->get_base() == 0 ) { + return true; + } else { + throw SemanticError( "redeclaration of ", added ); + } + } + + void Indexer::addType( NamedTypeDecl *decl ) { + makeWritable(); + + const std::string &id = decl->get_name(); + TypeTable::iterator existing = tables->typeTable.find( id ); + if ( existing == tables->typeTable.end() ) { + NamedTypeDecl *parent = tables->base.lookupTypeAtScope( id, scope ); + if ( ! parent || ! addedTypeConflicts( parent, decl ) ) { + tables->typeTable.insert( existing, std::make_pair( id, decl ) ); + ++tables->size; + } + } else { + if ( ! addedTypeConflicts( existing->second, decl ) ) { + existing->second = decl; + } + } + } + + bool addedDeclConflicts( AggregateDecl *existing, AggregateDecl *added ) { + if ( existing->get_members().empty() ) { + return false; + } else if ( ! added->get_members().empty() ) { + throw SemanticError( "redeclaration of ", added ); + } // if + return true; + } + + void Indexer::addStruct( const std::string &id ) { + addStruct( new StructDecl( id ) ); + } + + void Indexer::addStruct( StructDecl *decl ) { + makeWritable(); + + const std::string &id = decl->get_name(); + StructTable::iterator existing = tables->structTable.find( id ); + if ( existing == tables->structTable.end() ) { + StructDecl *parent = tables->base.lookupStructAtScope( id, scope ); + if ( ! parent || ! addedDeclConflicts( parent, decl ) ) { + tables->structTable.insert( existing, std::make_pair( id, decl ) ); + ++tables->size; + } + } else { + if ( ! addedDeclConflicts( existing->second, decl ) ) { + existing->second = decl; + } + } + } + + void Indexer::addEnum( EnumDecl *decl ) { + makeWritable(); + + const std::string &id = decl->get_name(); + EnumTable::iterator existing = tables->enumTable.find( id ); + if ( existing == tables->enumTable.end() ) { + EnumDecl *parent = tables->base.lookupEnumAtScope( id, scope ); + if ( ! parent || ! addedDeclConflicts( parent, decl ) ) { + tables->enumTable.insert( existing, std::make_pair( id, decl ) ); + ++tables->size; + } + } else { + if ( ! addedDeclConflicts( existing->second, decl ) ) { + existing->second = decl; + } + } + } + + void Indexer::addUnion( const std::string &id ) { + addUnion( new UnionDecl( id ) ); + } + + void Indexer::addUnion( UnionDecl *decl ) { + makeWritable(); + + const std::string &id = decl->get_name(); + UnionTable::iterator existing = tables->unionTable.find( id ); + if ( existing == tables->unionTable.end() ) { + UnionDecl *parent = tables->base.lookupUnionAtScope( id, scope ); + if ( ! parent || ! addedDeclConflicts( parent, decl ) ) { + tables->unionTable.insert( existing, std::make_pair( id, decl ) ); + ++tables->size; + } + } else { + if ( ! addedDeclConflicts( existing->second, decl ) ) { + existing->second = decl; + } + } + } + + void Indexer::addTrait( TraitDecl *decl ) { + makeWritable(); + + const std::string &id = decl->get_name(); + TraitTable::iterator existing = tables->traitTable.find( id ); + if ( existing == tables->traitTable.end() ) { + TraitDecl *parent = tables->base.lookupTraitAtScope( id, scope ); + if ( ! parent || ! addedDeclConflicts( parent, decl ) ) { + tables->traitTable.insert( existing, std::make_pair( id, decl ) ); + ++tables->size; + } + } else { + if ( ! addedDeclConflicts( existing->second, decl ) ) { + existing->second = decl; + } + } } void Indexer::enterScope() { + ++scope; + if ( doDebug ) { - std::cout << "--- Entering scope" << std::endl; - } - idTable.enterScope(); - typeTable.enterScope(); - structTable.enterScope(); - enumTable.enterScope(); - unionTable.enterScope(); - contextTable.enterScope(); + std::cout << "--- Entering scope " << scope << std::endl; + } } void Indexer::leaveScope() { using std::cout; - using std::endl; - - if ( doDebug ) { - cout << "--- Leaving scope containing" << endl; - idTable.dump( cout ); - typeTable.dump( cout ); - structTable.dump( cout ); - enumTable.dump( cout ); - unionTable.dump( cout ); - contextTable.dump( cout ); - } - idTable.leaveScope(); - typeTable.leaveScope(); - structTable.leaveScope(); - enumTable.leaveScope(); - unionTable.leaveScope(); - contextTable.leaveScope(); + + assert( scope > 0 && "cannot leave initial scope" ); + --scope; + + while ( tables && tables->scope > scope ) { + if ( doDebug ) { + cout << "--- Leaving scope " << tables->scope << " containing" << std::endl; + dump( tables->idTable, cout ); + dump( tables->typeTable, cout ); + dump( tables->structTable, cout ); + dump( tables->enumTable, cout ); + dump( tables->unionTable, cout ); + dump( tables->traitTable, cout ); + } + + // swap tables for base table until we find one at an appropriate scope + Indexer::Impl *base = newRef( tables->base.tables ); + deleteRef( tables ); + tables = base; + } } void Indexer::print( std::ostream &os, int indent ) const { using std::cerr; - using std::endl; - - cerr << "===idTable===" << endl; - idTable.dump( os ); - cerr << "===typeTable===" << endl; - typeTable.dump( os ); - cerr << "===structTable===" << endl; - structTable.dump( os ); - cerr << "===enumTable===" << endl; - enumTable.dump( os ); - cerr << "===unionTable===" << endl; - unionTable.dump( os ); - cerr << "===contextTable===" << endl; - contextTable.dump( os ); -#if 0 - idTable.dump( os ); - typeTable.dump( os ); - structTable.dump( os ); - enumTable.dump( os ); - unionTable.dump( os ); - contextTable.dump( os ); -#endif + + cerr << "===idTable===" << std::endl; + if ( tables ) dump( tables->idTable, os ); + cerr << "===typeTable===" << std::endl; + if ( tables ) dump( tables->typeTable, os ); + cerr << "===structTable===" << std::endl; + if ( tables ) dump( tables->structTable, os ); + cerr << "===enumTable===" << std::endl; + if ( tables ) dump( tables->enumTable, os ); + cerr << "===unionTable===" << std::endl; + if ( tables ) dump( tables->unionTable, os ); + cerr << "===contextTable===" << std::endl; + if ( tables ) dump( tables->traitTable, os ); } } // namespace SymTab Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/Indexer.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Sun May 17 21:38:55 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Thu Sep 17 16:05:38 2015 -// Update Count : 5 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Mar 2 17:34:14 2016 +// Update Count : 6 // @@ -21,7 +21,4 @@ #include "SynTree/Visitor.h" -#include "IdTable.h" -#include "AggregateTable.h" -#include "TypeTable.h" namespace SymTab { @@ -29,5 +26,10 @@ public: Indexer( bool useDebug = false ); + + Indexer( const Indexer &that ); + Indexer( Indexer &&that ); virtual ~Indexer(); + Indexer& operator= ( const Indexer &that ); + Indexer& operator= ( Indexer &&that ); //using Visitor::visit; @@ -39,5 +41,5 @@ virtual void visit( UnionDecl *aggregateDecl ); virtual void visit( EnumDecl *aggregateDecl ); - virtual void visit( ContextDecl *aggregateDecl ); + virtual void visit( TraitDecl *aggregateDecl ); virtual void visit( CompoundStmt *compoundStmt ); @@ -57,4 +59,5 @@ virtual void visit( UntypedOffsetofExpr *offsetofExpr ); virtual void visit( OffsetofExpr *offsetofExpr ); + virtual void visit( OffsetPackExpr *offsetPackExpr ); virtual void visit( AttrExpr *attrExpr ); virtual void visit( LogicalExpr *logicalExpr ); @@ -67,5 +70,5 @@ virtual void visit( UntypedValofExpr *valofExpr ); - virtual void visit( ContextInstType *contextInst ); + virtual void visit( TraitInstType *contextInst ); virtual void visit( StructInstType *contextInst ); virtual void visit( UnionInstType *contextInst ); @@ -78,22 +81,51 @@ void leaveScope(); - void lookupId( const std::string &id, std::list< DeclarationWithType* >& ) const; - DeclarationWithType* lookupId( const std::string &id) const; + /// Gets all declarations with the given ID + void lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const; + /// Gets the top-most type declaration with the given ID NamedTypeDecl *lookupType( const std::string &id ) const; + /// Gets the top-most struct declaration with the given ID StructDecl *lookupStruct( const std::string &id ) const; + /// Gets the top-most enum declaration with the given ID EnumDecl *lookupEnum( const std::string &id ) const; + /// Gets the top-most union declaration with the given ID UnionDecl *lookupUnion( const std::string &id ) const; - ContextDecl *lookupContext( const std::string &id ) const; + /// Gets the top-most trait declaration with the given ID + TraitDecl *lookupTrait( const std::string &id ) const; void print( std::ostream &os, int indent = 0 ) const; private: - IdTable idTable; - TypeTable typeTable; - StructTable structTable; - EnumTable enumTable; - UnionTable unionTable; - ContextTable contextTable; - - bool doDebug; // display debugging trace + /// looks up a specific mangled ID at the given scope + DeclarationWithType *lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const; + /// returns true if there exists a declaration with C linkage and the given name with a different mangled name + bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const; + // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope) + NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const; + StructDecl *lookupStructAtScope( const std::string &id, unsigned long scope ) const; + EnumDecl *lookupEnumAtScope( const std::string &id, unsigned long scope ) const; + UnionDecl *lookupUnionAtScope( const std::string &id, unsigned long scope ) const; + TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const; + + void addId( DeclarationWithType *decl ); + void addType( NamedTypeDecl *decl ); + void addStruct( const std::string &id ); + void addStruct( StructDecl *decl ); + void addEnum( EnumDecl *decl ); + void addUnion( const std::string &id ); + void addUnion( UnionDecl *decl ); + void addTrait( TraitDecl *decl ); + + struct Impl; + Impl *tables; ///< Copy-on-write instance of table data structure + unsigned long scope; ///< Scope index of this pointer + bool doDebug; ///< Display debugging trace? + + /// Takes a new ref to a table (returns null if null) + static Impl *newRef( Impl *toClone ); + /// Clears a ref to a table (does nothing if null) + static void deleteRef( Impl *toFree ); + + /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope) + void makeWritable(); }; } // namespace SymTab Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/Mangler.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -224,4 +224,9 @@ acceptAll( tupleType->get_types(), *this ); mangleName << "_"; + } + + void Mangler::visit( VarArgsType *varArgsType ) { + printQualifiers( varArgsType ); + mangleName << "VARGS"; } Index: src/SymTab/Mangler.h =================================================================== --- src/SymTab/Mangler.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/Mangler.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -45,4 +45,5 @@ virtual void visit( TypeInstType *aggregateUseType ); virtual void visit( TupleType *tupleType ); + virtual void visit( VarArgsType *varArgsType ); std::string get_mangleName() { return mangleName.str(); } Index: src/SymTab/StackTable.cc =================================================================== --- src/SymTab/StackTable.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,84 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// StackTable.cc -- -// -// Author : Richard C. Bilson -// Created On : Sun May 17 21:45:15 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 19 16:51:53 2015 -// Update Count : 3 -// - -#include - -#include "StackTable.h" - -namespace SymTab { - template< typename Element, typename ConflictFunction > - StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 ) { - } - - template< typename Element, typename ConflictFunction > - void StackTable< Element, ConflictFunction >::enterScope() { - scopeLevel++; - } - - template< typename Element, typename ConflictFunction > - void StackTable< Element, ConflictFunction >::leaveScope() { - for ( typename TableType::iterator it = table.begin(); it != table.end(); ++it ) { - std::stack< Entry >& entry = it->second; - if ( ! entry.empty() && entry.top().second == scopeLevel ) { - entry.pop(); - } // if - } // for - scopeLevel--; - assert( scopeLevel >= 0 ); - } - - template< typename Element, typename ConflictFunction > - void StackTable< Element, ConflictFunction >::add( Element *type ) { - std::stack< Entry >& entry = table[ type->get_name() ]; - if ( ! entry.empty() && entry.top().second == scopeLevel ) { - entry.top().first = conflictFunction( entry.top().first, type ); - } else { - entry.push( Entry( type, scopeLevel ) ); - } // if - } - - template< typename Element, typename ConflictFunction > - void StackTable< Element, ConflictFunction >::add( std::string fwdDeclName ) { - add( new Element( fwdDeclName ) ); - } - - template< typename Element, typename ConflictFunction > - Element *StackTable< Element, ConflictFunction >::lookup( std::string id ) const { - typename TableType::const_iterator it = table.find( id ); - if ( it == table.end() ) { - return 0; - } else if ( ! it->second.empty() ) { - return it->second.top().first; - } else { - return 0; - } // if - } - - template< typename Element, typename ConflictFunction > - void StackTable< Element, ConflictFunction >::dump( std::ostream &os ) const { - for ( typename TableType::const_iterator it = table.begin(); it != table.end(); ++it ) { - const std::stack< Entry >& entry = it->second; - if ( ! entry.empty() && entry.top().second == scopeLevel ) { - os << it->first << std::endl; - } // if - } // for - } -} // namespace SymTab - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SymTab/StackTable.h =================================================================== --- src/SymTab/StackTable.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,55 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// StackTable.h -- -// -// Author : Richard C. Bilson -// Created On : Sun May 17 21:47:10 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 19 16:50:36 2015 -// Update Count : 4 -// - -#ifndef STACKTABLE_H -#define STACKTABLE_H - -#include -#include -#include -#include - -namespace SymTab { - template< typename Element, typename ConflictFunction > - class StackTable { - public: - StackTable(); - - void enterScope(); - void leaveScope(); - void add( Element *type ); - void add( std::string fwdDeclName ); - Element *lookup( std::string id ) const; - - void dump( std::ostream &os ) const; // debugging - private: - typedef std::pair< Element*, int > Entry; - typedef std::map< std::string, std::stack< Entry > > TableType; - - ConflictFunction conflictFunction; - TableType table; - int scopeLevel; - }; -} // SymTab - -#include "StackTable.cc" - -#endif // STACKTABLE_H - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SymTab/TypeEquality.cc =================================================================== --- src/SymTab/TypeEquality.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/TypeEquality.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -41,4 +41,5 @@ virtual void visit( EnumInstType *enumInst ); virtual void visit( TypeInstType *typeInst ); + virtual void visit( VarArgsType *varArgsType ); void handleQualifiers( Type * t ); @@ -191,3 +192,10 @@ } } + + void TypeEquality::visit( VarArgsType *varArgsType ) { + handleQualifiers( varArgsType ); + if ( ! dynamic_cast< VarArgsType * >( other ) ) { + result = false; + } + } } // namespace SymTab Index: src/SymTab/TypeTable.h =================================================================== --- src/SymTab/TypeTable.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,53 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// TypeTable.h -- -// -// Author : Richard C. Bilson -// Created On : Sun May 17 21:48:32 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 19 16:50:25 2015 -// Update Count : 3 -// - -#ifndef TYPETABLE_H -#define TYPETABLE_H - -#include -#include -#include -#include -#include - -#include "StackTable.h" -#include "SynTree/Declaration.h" - -namespace SymTab { - class TypeTableConflictFunction : public std::binary_function< NamedTypeDecl *, NamedTypeDecl *, NamedTypeDecl * > { - public: - NamedTypeDecl *operator()( NamedTypeDecl *existing, NamedTypeDecl *added ) { - if ( existing->get_base() == 0 ) { - return added; - } else if ( added->get_base() == 0 ) { - return existing; - } else { - throw SemanticError( "redeclaration of ", added ); - } // if - assert( false ); - return 0; - } - }; - - typedef StackTable< NamedTypeDecl, TypeTableConflictFunction > TypeTable; -} // namespace SymTab - -#endif // TYPETABLE_H - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/Validate.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:50:04 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jan 27 22:03:12 2016 -// Update Count : 225 +// Last Modified On : Wed Apr 13 16:39:30 2016 +// Update Count : 251 // @@ -40,8 +40,11 @@ #include #include +#include "Common/utility.h" +#include "Common/UniqueName.h" #include "Validate.h" #include "SynTree/Visitor.h" #include "SynTree/Mutator.h" #include "SynTree/Type.h" +#include "SynTree/Expression.h" #include "SynTree/Statement.h" #include "SynTree/TypeSubstitution.h" @@ -49,6 +52,5 @@ #include "FixFunction.h" // #include "ImplementationType.h" -#include "Common/utility.h" -#include "Common/UniqueName.h" +#include "GenPoly/DeclMutator.h" #include "AddVisit.h" #include "MakeLibCfa.h" @@ -70,11 +72,7 @@ virtual void visit( CompoundStmt *compoundStmt ); - virtual void visit( IfStmt *ifStmt ); - virtual void visit( WhileStmt *whileStmt ); - virtual void visit( ForStmt *forStmt ); virtual void visit( SwitchStmt *switchStmt ); virtual void visit( ChooseStmt *chooseStmt ); - virtual void visit( CaseStmt *caseStmt ); - virtual void visit( CatchStmt *catchStmt ); + // virtual void visit( CaseStmt *caseStmt ); private: HoistStruct(); @@ -101,5 +99,5 @@ virtual void visit( StructInstType *structInst ); virtual void visit( UnionInstType *unionInst ); - virtual void visit( ContextInstType *contextInst ); + virtual void visit( TraitInstType *contextInst ); virtual void visit( StructDecl *structDecl ); virtual void visit( UnionDecl *unionDecl ); @@ -137,5 +135,5 @@ virtual void visit( UnionDecl *structDecl ); virtual void visit( TypeDecl *typeDecl ); - virtual void visit( ContextDecl *ctxDecl ); + virtual void visit( TraitDecl *ctxDecl ); virtual void visit( FunctionDecl *functionDecl ); @@ -144,11 +142,7 @@ virtual void visit( CompoundStmt *compoundStmt ); - virtual void visit( IfStmt *ifStmt ); - virtual void visit( WhileStmt *whileStmt ); - virtual void visit( ForStmt *forStmt ); virtual void visit( SwitchStmt *switchStmt ); virtual void visit( ChooseStmt *chooseStmt ); - virtual void visit( CaseStmt *caseStmt ); - virtual void visit( CatchStmt *catchStmt ); + // virtual void visit( CaseStmt *caseStmt ); AutogenerateRoutines() : functionNesting( 0 ) {} @@ -166,5 +160,4 @@ /// and return something if the return type is non-void. static void checkFunctionReturns( std::list< Declaration * > & translationUnit ); - private: virtual void visit( FunctionDecl * functionDecl ); @@ -192,9 +185,12 @@ virtual Declaration *mutate( UnionDecl * unionDecl ); virtual Declaration *mutate( EnumDecl * enumDecl ); - virtual Declaration *mutate( ContextDecl * contextDecl ); + virtual Declaration *mutate( TraitDecl * contextDecl ); template AggDecl *handleAggregate( AggDecl * aggDecl ); + template + void addImplicitTypedef( AggDecl * aggDecl ); + typedef std::map< std::string, std::pair< TypedefDecl *, int > > TypedefMap; TypedefMap typedefNames; @@ -202,8 +198,17 @@ }; + class CompoundLiteral : public GenPoly::DeclMutator { + DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass; + + virtual DeclarationWithType * mutate( ObjectDecl *objectDecl ); + virtual Expression *mutate( CompoundLiteralExpr *compLitExpr ); + }; + void validate( std::list< Declaration * > &translationUnit, bool doDebug ) { Pass1 pass1; Pass2 pass2( doDebug, 0 ); Pass3 pass3( 0 ); + CompoundLiteral compoundliteral; + EliminateTypedef::eliminateTypedef( translationUnit ); HoistStruct::hoistStruct( translationUnit ); @@ -211,4 +216,5 @@ acceptAll( translationUnit, pass2 ); ReturnChecker::checkFunctionReturns( translationUnit ); + mutateAll( translationUnit, compoundliteral ); AutogenerateRoutines::autogenerateRoutines( translationUnit ); acceptAll( translationUnit, pass3 ); @@ -292,16 +298,4 @@ } - void HoistStruct::visit( IfStmt *ifStmt ) { - addVisit( ifStmt, *this ); - } - - void HoistStruct::visit( WhileStmt *whileStmt ) { - addVisit( whileStmt, *this ); - } - - void HoistStruct::visit( ForStmt *forStmt ) { - addVisit( forStmt, *this ); - } - void HoistStruct::visit( SwitchStmt *switchStmt ) { addVisit( switchStmt, *this ); @@ -312,11 +306,7 @@ } - void HoistStruct::visit( CaseStmt *caseStmt ) { - addVisit( caseStmt, *this ); - } - - void HoistStruct::visit( CatchStmt *cathStmt ) { - addVisit( cathStmt, *this ); - } + // void HoistStruct::visit( CaseStmt *caseStmt ) { + // addVisit( caseStmt, *this ); + // } void Pass1::visit( EnumDecl *enumDecl ) { @@ -404,7 +394,7 @@ } - void Pass2::visit( ContextInstType *contextInst ) { + void Pass2::visit( TraitInstType *contextInst ) { Parent::visit( contextInst ); - ContextDecl *ctx = indexer->lookupContext( contextInst->get_name() ); + TraitDecl *ctx = indexer->lookupTrait( contextInst->get_name() ); if ( ! ctx ) { throw SemanticError( "use of undeclared context " + contextInst->get_name() ); @@ -412,5 +402,5 @@ for ( std::list< TypeDecl * >::const_iterator i = ctx->get_parameters().begin(); i != ctx->get_parameters().end(); ++i ) { for ( std::list< DeclarationWithType * >::const_iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) { - if ( ContextInstType *otherCtx = dynamic_cast< ContextInstType * >(*assert ) ) { + if ( TraitInstType *otherCtx = dynamic_cast< TraitInstType * >(*assert ) ) { cloneAll( otherCtx->get_members(), contextInst->get_members() ); } else { @@ -476,5 +466,5 @@ while ( ! toBeDone.empty() ) { for ( std::list< DeclarationWithType * >::iterator assertion = toBeDone.begin(); assertion != toBeDone.end(); ++assertion ) { - if ( ContextInstType *ctx = dynamic_cast< ContextInstType * >( (*assertion )->get_type() ) ) { + if ( TraitInstType *ctx = dynamic_cast< TraitInstType * >( (*assertion )->get_type() ) ) { for ( std::list< Declaration * >::const_iterator i = ctx->get_members().begin(); i != ctx->get_members().end(); ++i ) { DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *i ); @@ -851,5 +841,5 @@ } - void AutogenerateRoutines::visit( ContextDecl *) { + void AutogenerateRoutines::visit( TraitDecl *) { // ensure that we don't add assignment ops for types defined as part of the context } @@ -874,16 +864,4 @@ } - void AutogenerateRoutines::visit( IfStmt *ifStmt ) { - visitStatement( ifStmt ); - } - - void AutogenerateRoutines::visit( WhileStmt *whileStmt ) { - visitStatement( whileStmt ); - } - - void AutogenerateRoutines::visit( ForStmt *forStmt ) { - visitStatement( forStmt ); - } - void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) { visitStatement( switchStmt ); @@ -894,11 +872,7 @@ } - void AutogenerateRoutines::visit( CaseStmt *caseStmt ) { - visitStatement( caseStmt ); - } - - void AutogenerateRoutines::visit( CatchStmt *cathStmt ) { - visitStatement( cathStmt ); - } + // void AutogenerateRoutines::visit( CaseStmt *caseStmt ) { + // visitStatement( caseStmt ); + // } void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) { @@ -1043,7 +1017,6 @@ } - // there may be typedefs nested within aggregates - // in order for everything to work properly, these - // should be removed as well + // there may be typedefs nested within aggregates in order for everything to work properly, these should be removed + // as well template AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) { @@ -1059,6 +1032,22 @@ return aggDecl; } - + + template + void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) { + if ( typedefNames.count( aggDecl->get_name() ) == 0 ) { + Type *type; + if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( aggDecl ) ) { + type = new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ); + } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( aggDecl ) ) { + type = new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ); + } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( aggDecl ) ) { + type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ); + } // if + TypedefDecl * tyDecl = new TypedefDecl( aggDecl->get_name(), DeclarationNode::NoStorageClass, type ); + typedefNames[ aggDecl->get_name() ] = std::make_pair( tyDecl, scopeLevel ); + } // if + } Declaration *EliminateTypedef::mutate( StructDecl * structDecl ) { + addImplicitTypedef( structDecl ); Mutator::mutate( structDecl ); return handleAggregate( structDecl ); @@ -1066,4 +1055,5 @@ Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) { + addImplicitTypedef( unionDecl ); Mutator::mutate( unionDecl ); return handleAggregate( unionDecl ); @@ -1071,13 +1061,34 @@ Declaration *EliminateTypedef::mutate( EnumDecl * enumDecl ) { + addImplicitTypedef( enumDecl ); Mutator::mutate( enumDecl ); return handleAggregate( enumDecl ); } - Declaration *EliminateTypedef::mutate( ContextDecl * contextDecl ) { + Declaration *EliminateTypedef::mutate( TraitDecl * contextDecl ) { Mutator::mutate( contextDecl ); return handleAggregate( contextDecl ); } + DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) { + storageclass = objectDecl->get_storageClass(); + DeclarationWithType * temp = Mutator::mutate( objectDecl ); + storageclass = DeclarationNode::NoStorageClass; + return temp; + } + + Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) { + // transform [storage_class] ... (struct S){ 3, ... }; + // into [storage_class] struct S temp = { 3, ... }; + static UniqueName indexName( "_compLit" ); + + ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageclass, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() ); + compLitExpr->set_type( 0 ); + compLitExpr->set_initializer( 0 ); + delete compLitExpr; + DeclarationWithType * newtempvar = mutate( tempvar ); + addDeclaration( newtempvar ); // add modified temporary to current block + return new VariableExpr( newtempvar ); + } } // namespace SymTab Index: src/SymTab/module.mk =================================================================== --- src/SymTab/module.mk (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SymTab/module.mk (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -15,6 +15,5 @@ ############################################################################### -SRC += SymTab/IdTable.cc \ - SymTab/Indexer.cc \ +SRC += SymTab/Indexer.cc \ SymTab/Mangler.cc \ SymTab/Validate.cc \ Index: src/SynTree/AggregateDecl.cc =================================================================== --- src/SynTree/AggregateDecl.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/AggregateDecl.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Sun May 17 23:56:39 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jun 13 08:12:49 2015 -// Update Count : 6 +// Last Modified On : Wed Mar 2 17:28:00 2016 +// Update Count : 7 // @@ -64,5 +64,5 @@ std::string EnumDecl::typeString() const { return "enum"; } -std::string ContextDecl::typeString() const { return "context"; } +std::string TraitDecl::typeString() const { return "context"; } // Local Variables: // Index: src/SynTree/CodeGenVisitor.cc =================================================================== --- src/SynTree/CodeGenVisitor.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,59 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// CodeGenVisitor.cc -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 18 07:57:51 2015 -// Update Count : 3 -// - -#include -#include - -#include "Statement.h" -#include "Expression.h" -#include "CodeGenVisitor.h" -using namespace std; - -void CodeGenVisitor::visit( Type *type ) { } -void CodeGenVisitor::visit( BasicType *basicType ) { } - -void CodeGenVisitor::visit( Constant *constant ) { - cout << constant->get_value() << endl; -} - -void CodeGenVisitor::visit( Expression *expr ) { } - -void CodeGenVisitor::visit( ConstantExpr *cnst ) { - if ( cnst != 0 ) - visit(cnst->get_constant()); -} - -void CodeGenVisitor::visit( Statement *stmt ) { } - -void CodeGenVisitor::visit( ExprStmt *exprStmt ) { - if ( exprStmt != 0 ) - exprStmt->get_expr()->accept( *this ); // visit(exprStmt->get_expr()) doesn't work -} - -void CodeGenVisitor::visit( SwitchStmt *switchStmt ) { - cout << "switch (" << endl; - // visit(switchStmt->get_condition()); // why doesn't this work? - switchStmt->get_condition()->accept(*this); - - cout << ") {" << endl; - // visit(switchStmt->get_body()); // why doesn't this work? - cout << "}" << endl; -} - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SynTree/CodeGenVisitor.h =================================================================== --- src/SynTree/CodeGenVisitor.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ (revision ) @@ -1,45 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// CodeGenVisitor.h -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 18 08:46:47 2015 -// Update Count : 4 -// - -#ifndef CODEGENV_H -#define CODEGENV_H - -#include - -#include "SynTree.h" -#include "Visitor.h" - -class CodeGenVisitor : public Visitor { - public: - virtual void visit( Type * ); - virtual void visit( BasicType * ); - - virtual void visit( Constant * ); - - virtual void visit( Expression * ); - virtual void visit( ConstantExpr * ); - - virtual void visit( Statement * ); - virtual void visit( ExprStmt * ); - virtual void visit( SwitchStmt * ); -}; - -#endif // CODEGENV_H - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SynTree/Constant.cc =================================================================== --- src/SynTree/Constant.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/Constant.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -16,4 +16,5 @@ #include #include +#include #include "Constant.h" @@ -28,4 +29,16 @@ Constant::~Constant() { delete type; } + +Constant Constant::from( int i ) { + return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ) ); +} + +Constant Constant::from( unsigned long i ) { + return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ) ); +} + +Constant Constant::from( double d ) { + return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ) ); +} Constant *Constant::clone() const { assert( false ); return 0; } Index: src/SynTree/Constant.h =================================================================== --- src/SynTree/Constant.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/Constant.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -32,4 +32,11 @@ void set_value( std::string newValue ) { value = newValue; } + /// generates an integer constant of the given int + static Constant from( int i ); + /// generates an integer constant of the given unsigned long int + static Constant from( unsigned long i ); + /// generates a floating point constant of the given double + static Constant from( double d ); + virtual Constant *clone() const; virtual void accept( Visitor &v ) { v.visit( this ); } Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/Declaration.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Wed Dec 09 14:08:22 2015 -// Update Count : 32 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Mar 2 17:28:11 2016 +// Update Count : 33 // @@ -246,11 +246,11 @@ }; -class ContextDecl : public AggregateDecl { - typedef AggregateDecl Parent; - public: - ContextDecl( const std::string &name ) : Parent( name ) {} - ContextDecl( const ContextDecl &other ) : Parent( other ) {} - - virtual ContextDecl *clone() const { return new ContextDecl( *this ); } +class TraitDecl : public AggregateDecl { + typedef AggregateDecl Parent; + public: + TraitDecl( const std::string &name ) : Parent( name ) {} + TraitDecl( const TraitDecl &other ) : Parent( other ) {} + + virtual TraitDecl *clone() const { return new TraitDecl( *this ); } virtual void accept( Visitor &v ) { v.visit( this ); } virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); } Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/Expression.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// Expression.cc -- +// Expression.cc -- // // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Wed Dec 09 14:10:29 2015 -// Update Count : 34 +// Last Modified By : Peter A. Buhr +// Last Modified On : Fri Apr 8 17:16:23 2016 +// Update Count : 40 // @@ -22,4 +22,5 @@ #include "Type.h" +#include "Initializer.h" #include "Expression.h" #include "Declaration.h" @@ -211,4 +212,25 @@ os << " of "; + + if ( type ) { + type->print(os, indent + 2); + } else { + os << ""; + } + + os << std::endl; + Expression::print( os, indent ); +} + +OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) { + add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) ); +} + +OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {} + +OffsetPackExpr::~OffsetPackExpr() { delete type; } + +void OffsetPackExpr::print( std::ostream &os, int indent ) const { + os << std::string( indent, ' ' ) << "Offset pack expression on "; if ( type ) { @@ -422,4 +444,7 @@ } +AsmExpr::AsmExpr( const AsmExpr & other ) : inout( maybeClone( other.inout ) ), constraint( maybeClone( other.constraint ) ), operand( maybeClone( other.operand ) ) {} + + void AsmExpr::print( std::ostream &os, int indent ) const { os << "Asm Expression: " << std::endl; @@ -429,4 +454,8 @@ } +UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {} + +UntypedValofExpr::~UntypedValofExpr() { delete body; } + void UntypedValofExpr::print( std::ostream &os, int indent ) const { os << std::string( indent, ' ' ) << "Valof Expression: " << std::endl; @@ -434,4 +463,23 @@ get_body()->print( os, indent + 2 ); } + + +CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) { + add_result( type->clone() ); +} + +CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {} + +CompoundLiteralExpr::~CompoundLiteralExpr() { + delete initializer; + delete type; +} + +void CompoundLiteralExpr::print( std::ostream &os, int indent ) const { + os << "Compound Literal Expression: " << std::endl; + if ( type ) type->print( os, indent + 2 ); + if ( initializer ) initializer->print( os, indent + 2 ); +} + std::ostream & operator<<( std::ostream & out, Expression * expr ) { Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/Expression.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -5,11 +5,11 @@ // file "LICENCE" distributed with Cforall. // -// Expression.h -- +// Expression.h -- // // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Wed Dec 09 14:10:21 2015 -// Update Count : 19 +// Last Modified By : Peter A. Buhr +// Last Modified On : Fri Apr 8 17:18:06 2016 +// Update Count : 21 // @@ -155,8 +155,9 @@ }; +// xxx - this doesn't appear to actually be hooked in anywhere. We should use this instead of the "&&"" UntypedExpr hack class LabelAddressExpr : public Expression { public: LabelAddressExpr( Expression *arg ); - LabelAddressExpr( const AddressExpr &other ); + LabelAddressExpr( const LabelAddressExpr &other ); virtual ~LabelAddressExpr(); @@ -251,5 +252,5 @@ }; -/// ConstantExpr represents an expression that simply refers to the value of a constant +/// ConstantExpr represents an expression that simply refers to the value of a constant class ConstantExpr : public Expression { public: @@ -359,4 +360,24 @@ Type *type; DeclarationWithType *member; +}; + +/// Expression representing a pack of field-offsets for a generic type +class OffsetPackExpr : public Expression { +public: + OffsetPackExpr( StructInstType *type_, Expression *aname_ = 0 ); + OffsetPackExpr( const OffsetPackExpr &other ); + virtual ~OffsetPackExpr(); + + StructInstType *get_type() const { return type; } + void set_type( StructInstType *newValue ) { type = newValue; } + + virtual OffsetPackExpr *clone() const { return new OffsetPackExpr( *this ); } + virtual void accept( Visitor &v ) { v.visit( this ); } + virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); } + + virtual void print( std::ostream &os, int indent = 0 ) const; + +private: + StructInstType *type; }; @@ -515,4 +536,5 @@ public: AsmExpr( Expression *inout, ConstantExpr *constraint, Expression *operand ) : inout( inout ), constraint( constraint ), operand( operand ) {} + AsmExpr( const AsmExpr & other ); virtual ~AsmExpr() { delete inout; delete constraint; delete operand; }; @@ -541,5 +563,6 @@ public: UntypedValofExpr( Statement *_body, Expression *_aname = 0 ) : Expression( _aname ), body ( _body ) {} - virtual ~UntypedValofExpr() {} + UntypedValofExpr( const UntypedValofExpr & other ); + virtual ~UntypedValofExpr(); Expression *get_value(); @@ -552,4 +575,26 @@ private: Statement *body; +}; + +/// CompoundLiteralExpr represents a C99 'compound literal' +class CompoundLiteralExpr : public Expression { + public: + CompoundLiteralExpr( Type * type, Initializer * initializer ); + CompoundLiteralExpr( const CompoundLiteralExpr &other ); + ~CompoundLiteralExpr(); + + Type * get_type() const { return type; } + void set_type( Type * t ) { type = t; } + + Initializer * get_initializer() const { return initializer; } + void set_initializer( Initializer * i ) { initializer = i; } + + virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); } + virtual void accept( Visitor &v ) { v.visit( this ); } + virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); } + virtual void print( std::ostream &os, int indent = 0 ) const; + private: + Type * type; + Initializer * initializer; }; Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/Mutator.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 25 19:21:33 2015 -// Update Count : 11 +// Last Modified On : Fri Apr 1 18:05:16 2016 +// Update Count : 16 // @@ -63,5 +63,5 @@ } -Declaration *Mutator::mutate( ContextDecl *aggregateDecl ) { +Declaration *Mutator::mutate( TraitDecl *aggregateDecl ) { handleAggregateDecl( aggregateDecl ); return aggregateDecl; @@ -274,4 +274,10 @@ } +Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) { + mutateAll( offsetPackExpr->get_results(), *this ); + offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) ); + return offsetPackExpr; +} + Expression *Mutator::mutate( AttrExpr *attrExpr ) { mutateAll( attrExpr->get_results(), *this ); @@ -336,4 +342,11 @@ } +Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) { + mutateAll( compLitExpr->get_results(), *this ); + compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) ); + compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) ); + return compLitExpr; +} + Type *Mutator::mutate( VoidType *voidType ) { mutateAll( voidType->get_forall(), *this ); @@ -387,5 +400,5 @@ } -Type *Mutator::mutate( ContextInstType *aggregateUseType ) { +Type *Mutator::mutate( TraitInstType *aggregateUseType ) { handleReferenceToType( aggregateUseType ); mutateAll( aggregateUseType->get_members(), *this ); @@ -421,4 +434,9 @@ } +Type *Mutator::mutate( VarArgsType *varArgsType ) { + mutateAll( varArgsType->get_forall(), *this ); + return varArgsType; +} + Initializer *Mutator::mutate( SingleInit *singleInit ) { singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) ); Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/Mutator.h (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Nov 19 22:26:16 2015 -// Update Count : 8 +// Last Modified On : Fri Apr 1 17:26:56 2016 +// Update Count : 10 // #include @@ -31,5 +31,5 @@ virtual Declaration* mutate( UnionDecl *aggregateDecl ); virtual Declaration* mutate( EnumDecl *aggregateDecl ); - virtual Declaration* mutate( ContextDecl *aggregateDecl ); + virtual Declaration* mutate( TraitDecl *aggregateDecl ); virtual TypeDecl* mutate( TypeDecl *typeDecl ); virtual Declaration* mutate( TypedefDecl *typeDecl ); @@ -67,4 +67,5 @@ virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr ); virtual Expression* mutate( OffsetofExpr *offsetofExpr ); + virtual Expression* mutate( OffsetPackExpr *offsetPackExpr ); virtual Expression* mutate( AttrExpr *attrExpr ); virtual Expression* mutate( LogicalExpr *logicalExpr ); @@ -76,4 +77,5 @@ virtual Expression* mutate( AsmExpr *asmExpr ); virtual Expression* mutate( UntypedValofExpr *valofExpr ); + virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ); virtual Type* mutate( VoidType *basicType ); @@ -85,9 +87,10 @@ virtual Type* mutate( UnionInstType *aggregateUseType ); virtual Type* mutate( EnumInstType *aggregateUseType ); - virtual Type* mutate( ContextInstType *aggregateUseType ); + virtual Type* mutate( TraitInstType *aggregateUseType ); virtual Type* mutate( TypeInstType *aggregateUseType ); virtual Type* mutate( TupleType *tupleType ); virtual Type* mutate( TypeofType *typeofType ); virtual Type* mutate( AttrType *attrType ); + virtual Type* mutate( VarArgsType *varArgsType ); virtual Initializer* mutate( SingleInit *singleInit ); Index: src/SynTree/ReferenceToType.cc =================================================================== --- src/SynTree/ReferenceToType.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/ReferenceToType.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Jun 7 08:31:48 2015 -// Update Count : 4 +// Last Modified On : Wed Mar 2 17:28:51 2016 +// Update Count : 5 // @@ -83,11 +83,11 @@ std::string EnumInstType::typeString() const { return "enum"; } -std::string ContextInstType::typeString() const { return "context"; } +std::string TraitInstType::typeString() const { return "context"; } -ContextInstType::ContextInstType( const ContextInstType &other ) : Parent( other ) { +TraitInstType::TraitInstType( const TraitInstType &other ) : Parent( other ) { cloneAll( other.members, members ); } -ContextInstType::~ContextInstType() { +TraitInstType::~TraitInstType() { deleteAll( members ); } Index: src/SynTree/Statement.cc =================================================================== --- src/SynTree/Statement.cc (revision c5833e8112dc702a276c3752677503416c1c0b38) +++ src/SynTree/Statement.cc (revision 0f9e4403ea9f501a7993ba07c5badb03d4c58742) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// Statement.cc -- +// Statement.cc -- // // Author : Richard C. Bilson @@ -36,13 +36,23 @@ ExprStmt::ExprStmt( std::list