Changeset 0f9e4403 for src

src/CodeGen/CodeGenerator.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 #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"
 …
+        }
         void CodeGenerator::visit( ContextDecl *aggregateDecl ) {}
+        void CodeGenerator::visit( TraitDecl *aggregateDecl ) {}
         void CodeGenerator::visit( TypedefDecl *typeDecl ) {
 …
         void CodeGenerator::visit( UntypedOffsetofExpr *offsetofExpr ) {
                 assert( false );
+                assert( false && "UntypedOffsetofExpr should not reach code generation" );
+        }
 …
                 output << ", " << mangleName( offsetofExpr->get_member() );
                 output << ")";
+        }
+        void CodeGenerator::visit( OffsetPackExpr *offsetPackExpr ) {
+                assert( false && "OffsetPackExpr should not reach code generation" );
+        }

src/CodeGen/CodeGenerator.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 #include <list>
+#include "SynTree/Declaration.h"
 #include "SynTree/SynTree.h"
 #include "SynTree/Visitor.h"
 #include "SymTab/Indexer.h"
 …
                 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 );
 …
                 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 );

src/CodeGen/GenType.cc

-              rc5833e8
+              r0f9e4403
 #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 {
 …
                 virtual void visit( EnumInstType *enumInst );
                 virtual void visit( TypeInstType *typeInst );
+                virtual void visit( VarArgsType *varArgsType );
           private:
 …
+        }
+        void GenType::visit( VarArgsType *varArgsType ) {
+                typeString = "__builtin_va_list " + typeString;
+                handleQualifiers( varArgsType );
+        }
         void GenType::handleQualifiers( Type *type ) {
                 if ( type->get_isConst() ) {

src/GenPoly/Box.cc

-              rc5833e8
+              r0f9e4403
 //
+#include <algorithm>
+#include <iterator>
+#include <list>
+#include <map>
 #include <set>
 #include <stack>
 #include <string>
 #include <iterator>
 #include <algorithm>
+#include <utility>
+#include <vector>
 #include <cassert>
 #include "Box.h"
 #include "InstantiateGeneric.h"
+#include "DeclMutator.h"
 #include "PolyMutator.h"
 #include "FindFunction.h"
+#include "ScopedMap.h"
+#include "ScopedSet.h"
 #include "ScrubTyVars.h"
 …
 #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"
 …
 #include "ResolvExpr/typeops.h"
+#include "SymTab/Indexer.h"
 #include "SymTab/Mangler.h"
 …
                 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* > &params, 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 {
 …
                         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 );
 …
                         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;
 …
                 };
+                /// 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:
 …
                         virtual Type *mutate( PointerType *pointerType );
                         virtual Type *mutate( FunctionType *funcType );
                   private:
                         void addAdapters( FunctionType *functionType );
 …
                 };
+                /// 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 );
 …
                         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
                 };
 …
         } // 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 >
 …
         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( &paramType );
+                        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( "?<?", lhs, rhs ), makeOp( "?=?", lhs->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 ////////////////////////////////////////////////////
 …
+                }
+                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
 …
                 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 ) ) {
 …
                         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;
 …
                                 } // for
-                                AdapterMap & adapters = Pass1::adapters.top();
                                 for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
                                         std::string mangleName = mangleAdapterName( *funType, scopeTyVars );
 …
                                 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;
 …
+                }
-                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() ) );
 …
                                 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" );
 …
+                                }
                                 seenTypes.insert( sizeName );
+                                seenTypes.insert( typeName );
+                        }
+                }
 …
                                         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
 …
                         } // for
+                }
                 FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
 …
                                         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
 …
                                 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() ) {
 …
                                                         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 );
 …
                                                         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() );
 …
                                                         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() ) {
 …
                                                         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
 …
                                                         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
 …
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
                         TyVarMap exprTyVars;
+                        TyVarMap exprTyVars( (TypeDecl::Kind)-1 );
                         makeTyVarMap( function, exprTyVars );
                         ReferenceToType *polyRetType = isPolyRet( function );
 …
                         boxParams( appExpr, function, arg, exprTyVars );
                         passAdapters( appExpr, function, exprTyVars );
 …
                                 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() );
 …
                                         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 );
 …
+                                                        }
+                                                }
+                                                // 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 ) );
 …
                 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();
+                }
 …
                 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 );
 …
                         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;
 …
                                 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;
 …
                         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 );
+                                }
+                        }
 …
                         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();
 …
                         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;
 …
+                }
                 Expression *MemberExprFixer::mutate( MemberExpr *memberExpr ) {
+                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
                         Expression *expr = Mutator::mutate( memberExpr );
 …
                         Type *objectType = hasPolyBase( objectDecl->get_type(), scopeTyVars, &tyDepth );
                         if ( ! objectType ) return memberExpr;
+                        findGeneric( objectType ); // ensure layout for this type is available
                         Expression *newMemberExpr = 0;
 …
+                }
+                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 );
 …
                         // 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
 …
+                }
+                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 );
 …
                         ScrubTyVars::scrub( decl, scopeTyVars );
                         scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return ret;
+                }
 …
                 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;
+                }

src/GenPoly/DeclMutator.cc

-              rc5833e8
+              r0f9e4403
+        }
         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 );
 …
         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 );
+        }
 …
                 newBack->splice( newBack->end(), *back );
                 declsToAdd.pop_back();
+                back = declsToAddAfter.rbegin();
+                newBack = back + 1;
+                newBack->splice( newBack->end(), *back );
+                declsToAddAfter.pop_back();
+        }
 …
                 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
 …
                 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;
+        }
 …
         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 );
 …
                         declsToAdd.back().clear();
+                }
                 doEndScope();
+        }
 …
         void DeclMutator::addDeclaration( Declaration *decl ) {
                 declsToAdd.back().push_back( decl );
+        }
+        void DeclMutator::addDeclarationAfter( Declaration *decl ) {
+                declsToAddAfter.back().push_back( decl );
+        }

src/GenPoly/DeclMutator.h

-              rc5833e8
+              r0f9e4403
                 /// 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

src/GenPoly/FindFunction.cc

-              rc5833e8
+              r0f9e4403
                         TyVarMap::iterator var = tyVars.find( (*i)->get_name() );
                         if ( var != tyVars.end() ) {
                                 tyVars.erase( var );
+                                tyVars.erase( var->first );
                         } // if
                 } // for
 …
         Type * FindFunction::mutate( FunctionType *functionType ) {
                 TyVarMap oldTyVars = tyVars;
+                tyVars.beginScope();
                 handleForall( functionType->get_forall() );
                 mutateAll( functionType->get_returnVals(), *this );
 …
                         } // 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;
+        }

src/GenPoly/GenPoly.cc

-              rc5833e8
+              r0f9e4403
 #include "GenPoly.h"
-#include "SymTab/Mangler.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Type.h"
 …
         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 );
 …
+        }
-        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

src/GenPoly/GenPoly.h

-              rc5833e8
+              r0f9e4403
 #define GENPOLY_H
-#include <map>
 #include <string>
 #include <iostream>
 #include <utility>
+#include "ErasableScopedMap.h"
+#include "SymTab/Mangler.h"
 #include "SynTree/Declaration.h"
 …
 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
 …
         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

src/GenPoly/Lvalue.cc

-              rc5833e8
+              r0f9e4403
 #include "Lvalue.h"
+#include "GenPoly.h"
 #include "SynTree/Declaration.h"
 …
         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;
+                }
 …
                         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 {

src/GenPoly/PolyMutator.cc

-              rc5833e8
+              r0f9e4403
+        }
+        PolyMutator::PolyMutator() : env( 0 ) {
+        }
+        PolyMutator::PolyMutator() : scopeTyVars( (TypeDecl::Kind)-1 ), env( 0 ) {}
         void PolyMutator::mutateStatementList( std::list< Statement* > &statements ) {

src/GenPoly/ScopedMap.h

-              rc5833e8
+              r0f9e4403
 #define _SCOPEDMAP_H
+#include <cassert>
 #include <iterator>
 #include <map>
 …
                         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) {}
 …
                                         --i;
                                         it = (*scopes)[i].begin();
                                         return *this;
+                                }
                                 ++it;
                                 return *this;
+                                } else {
+                                        ++it;
+                                }
+                                return next_valid();
+                        }
                         iterator& operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
 …
+                                }
                                 --it;
                                 return *this;
+                                return prev_valid();
+                        }
                         iterator& operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
 …
                         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) {}
 …
                                         --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; }
 …
+                                }
                                 --it;
                                 return *this;
+                                return prev_valid();
+                        }
                         const_iterator& operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
 …
                 void endScope() {
                         scopes.pop_back();
+                        assert( ! scopes.empty() );
+                }
 …
                 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); }
 …
                         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
 …
                         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
 …
+                }
                 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

src/GenPoly/ScrubTyVars.cc

-              rc5833e8
+              r0f9e4403
                 // 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 {
 …
                 // 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 {

src/GenPoly/module.mk

rc5833e8	r0f9e4403
23	23	GenPoly/CopyParams.cc \
24	24	GenPoly/FindFunction.cc \
25		~~GenPoly/InstantiateGeneric.cc \~~
26	25	GenPoly/DeclMutator.cc

src/InitTweak/InitModel.h

rc5833e8	r0f9e4403
75	75	void visit( UntypedOffsetofExpr * ) { throw 0; }
76	76	void visit( OffsetofExpr * ) { throw 0; }
	77	void visit( OffsetPackExpr * ) { throw 0; }
77	78	void visit( AttrExpr * ) { throw 0; }
78	79	void visit( LogicalExpr * ) { throw 0; }

src/Makefile.am

-              rc5833e8
+              r0f9e4403
 ## 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
 ###############################################################################
 …
 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}}

src/Makefile.in

-              rc5833e8
+              r0f9e4403
         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) \
 …
         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) \
 …
         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) \
 …
         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) \
 …
 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@
 …
         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 \
 …
         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 \
 …
         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}}
 …
           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
 …
         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) \
 …
         @$(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)
 …
         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) \
 …
 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)
 …
         -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)
 …
         -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)
 …
         -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)
 …
         -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)
 …
 @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@
 …
 @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@
 …
 @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@
 …
 @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@
 …
 @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
 …
 @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
 …
 @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
 …
 @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

src/Parser/DeclarationNode.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 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 {
 …
         newnode->linkage = linkage;
         return newnode;
+}
+} // DeclarationNode::clone
 DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) {
 …
         newnode->type->function->newStyle = newStyle;
         newnode->type->function->body = body;
+        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
         if ( body ) {
 …
         return newnode;
+}
+} // DeclarationNode::newFunction
 DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) {
 …
         newnode->type->qualifiers.push_back( q );
         return newnode;
+}
+} // DeclarationNode::newQualifier
 DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
 …
         newnode->storageClasses.push_back( sc );
         return newnode;
+}
+} // DeclarationNode::newStorageClass
 DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) {
 …
         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 ) {
 …
         newnode->type->basic->modifiers.push_back( mod );
         return newnode;
+}
+} // DeclarationNode::newModifier
 DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) {
 …
         newnode->type->forall = forall;
         return newnode;
+}
+} // DeclarationNode::newForall
 DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) {
 …
         newnode->type->symbolic->params = 0;
         return newnode;
+}
+} // DeclarationNode::newFromTypedef
 DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields ) {
 …
         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 ) {
 …
         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 ) {
 …
         newnode->name = assign_strptr( name );
         return newnode;
+}
+} // DeclarationNode::newName
 DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
 …
         newnode->type->symbolic->actuals = params;
         return newnode;
+}
+} // DeclarationNode::newFromTypeGen
 DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
 …
         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 ) {
 …
         newnode->type->symbolic->name = newnode->name;
         return newnode;
+}
+} // DeclarationNode::newTypeDecl
 DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
 …
         newnode->type = new TypeData( TypeData::Pointer );
         return newnode->addQualifiers( qualifiers );
+}
+} // DeclarationNode::newPointer
 DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
 …
         } // if
         return newnode->addQualifiers( qualifiers );
+}
+} // DeclarationNode::newArray
 DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
 …
                         errors.append( e );
                 } // try
                 cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast<DeclarationNode *>( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
 …
                           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:

src/Parser/ExpressionNode.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 #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"
 …
                 args.front() = new AddressExpr( args.front() );
                 break;
+          default:
+                /* do nothing */
+          default:              // do nothing
+                ;
+        }
+        } // switch
         switch ( op->get_type() ) {
 …
+}
+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 ) ) {

src/Parser/ParseNode.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
         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; }
 …
         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,
 …
         ValofExprNode( const ValofExprNode &other );
         ~ValofExprNode();
         virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
 …
         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[];
 …
         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 );
 …
         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 );
 …
         static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
         static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
+        static DeclarationNode *newBuiltinType( BuiltinType );
         DeclarationNode *addQualifiers( DeclarationNode *);
 …
         LinkageSpec::Type get_linkage() const { return linkage; }
         DeclarationNode *extractAggregate() const;
+        ExpressionNode *get_enumeratorValue() const { return enumeratorValue; }
         DeclarationNode();
 …
         std::list< std::string > attributes;
         ExpressionNode *bitfieldWidth;
+        ExpressionNode *enumeratorValue;
         InitializerNode *initializer;
         bool hasEllipsis;
 …
 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,
 …
         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;
 };

src/Parser/Parser.cc

-              rc5833e8
+              r0f9e4403
 // 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

src/Parser/TypeData.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 #include "SynTree/Expression.h"
 #include "SynTree/Statement.h"
+#include "SynTree/Initializer.h"
 TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) {
 …
                 typeexpr->expr = 0;
                 break;
+          case Builtin:
+                builtin = new Builtin_t;
+                break;
           case Attr:
                 attr = new Attr_t;
 …
                 delete typeexpr->expr;
                 delete typeexpr;
+                break;
+          case Builtin:
+                delete builtin;
                 break;
           case Attr:
 …
                 newtype->typeexpr->expr = maybeClone( typeexpr->expr );
                 break;
+          case Builtin:
+                newtype->builtin->type = builtin->type;
+                break;
           case Attr:
                 newtype->attr->expr = maybeClone( attr->expr );
 …
                         attr->type->print( os, indent + 2 );
                 } // if
+                break;
+          case Builtin:
+                os << "gcc builtin type";
                 break;
           default:
 …
           case Typeof:
                 return buildTypeof();
+          case Builtin:
+                return new VarArgsType( buildQualifiers() );
           case Attr:
                 return buildAttr();
 …
                 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;
 …
                         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:
 …
         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<DeclarationNode *>( cur->get_link() ), ++members ) {
+                if ( cur->get_enumeratorValue() != NULL ) {
+                        ObjectDecl *member = dynamic_cast<ObjectDecl *>(*members);
+                        member->set_init( new SingleInit( maybeBuild< Expression >( cur->get_enumeratorValue() ) ) );
+                } // if
+        } // for
         return ret;
+}

src/Parser/TypeData.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 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 );
 …
         };
+        struct Builtin_t {
+                DeclarationNode::BuiltinType type;
+        };
         struct Attr_t {
                 std::string name;
 …
                 Typeof_t * typeexpr;
                 Attr_t * attr;
+                Builtin_t * builtin;
         };

src/Parser/TypedefTable.cc

-              rc5833e8
+              r0f9e4403
 // 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 <map>
 #include <list>
+#include <cassert>
 #include "TypedefTable.h"
-#include <cassert>
 using namespace std;
 …
 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 );
 …
+}
 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() ) {
 …
+}
 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 = "";
+}

src/Parser/TypedefTable.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 #include <stack>
+#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 {
 …
         int currentScope;
         std::string currentContext;
+        std::string currentTrait;
         int contextScope;
 …
         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.
 …
         // 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;

src/Parser/lex.cc

-              rc5833e8
+              r0f9e4403
         (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. */
 …
         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,  114,  114,  117,  117,
+,  178,    7,    9,    8,  137,  116,  101,  142,  145,
+,  124,  125,  140,  138,  128,  139,  131,  141,  106,
+,  108,  129,  130,  147,  149,  148,  150,  178,  101,
+,  178,  123,  143,  101,  103,  101,  101,  101,  101,
+,  101,  101,  101,  101,  101,  101,  101,  101,  101,
+,  126,  146,  127,  144,    7,  178,    4,    4,  179,
+,  179,  105,  114,  115,  121,  117,  118,    7,    9,
+,    8,  154,  173,  101,    0,  166,  136,  159,  167,
+,  151,  162,  152,  163,  161,    0,  111,    3,    0,
+,  111,  109,    0,    0,  109,  109,    0,    0,  109,
+,  108,  108,    0,  108,  134,  135,  133,  155,  157,
+,  158,  156,    0,    0,    0,    0,    0,    0,    0,
+,    0,    0,    0,    0,    0,    0,    0,  102,  172,
+,  116,  113,  101,    0,    0,  169,    0,  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,   57,  101,  101,  101,
+,  101,  101,  101,  101,  101,  101,  101,  101,  101,
+,  101,  168,  160,    7,    0,    0,    0,    2,    0,
+,  104,    0,    0,    0,  114,    0,  120,  119,  119,
+,    0,    0,  117,    0,    0,    0,    0,    0,    0,
+,    0,    0,    0,    0,    0,    0,    0,    0,  132,
+,  111,    0,  111,  111,  111,    0,    6,  111,  109,
+,    0,    0,  111,    0,  109,  109,  109,  109,    0,
+,    0,    0,  108,  108,  108,  108,    0,  170,  171,
+,  176,  174,    0,    0,    0,  102,    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,   14,  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,
+,   88,  101,  101,  101,  101,  101,  101,  101,    0,
+,    0,    0,    0,    0,    0,    0,  119,    0,    0,
+,    0,    0,  119,    0,    0,  177,    0,    0,    0,
+,    0,    0,    0,  111,    0,  111,    0,  111,    0,
+,  111,  111,  109,  109,    0,    0,  110,  110,    0,
+,    0,  110,  108,  108,    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,   21,
+,   24,  101,   27,  101,  101,  101,  101,  101,  101,
+,   42,  101,   44,  101,  101,  101,  101,  101,  101,
+,   56,  101,   67,  101,  101,  101,  101,  101,  101,
+,  101,  101,  101,  101,   89,  101,  101,   96,  101,
+,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+,    0,    0,    0,    0,  119,    0,    0,    0,    0,
+,  111,  111,    0,    0,    0,    0,    0,  110,  110,
+,  112,    0,  110,  110,    0,    0,    0,    0,    0,
+,    0,    0,    0,    0,    0,    0,    0,  101,  101,
+,  101,  101,  101,  101,  101,  101,  101,   15,  101,
+,  101,  101,  101,  101,  101,  101,  101,  101,  101,
+,  101,  101,   23,   25,  101,   32,  101,  101,  101,
+,  101,   41,  101,  101,  101,  101,   49,  101,  101,
+,  101,  101,  101,  101,  101,   76,  101,  101,  101,
+,  101,   86,  101,  101,   94,  101,  101,  100,    0,
+,    0,    0,    0,    0,    0,  115,  115,  118,  118,
+,  179,    7,    9,    8,  138,  117,  102,  143,  146,
+,  125,  126,  141,  139,  129,  140,  132,  142,  107,
+,  109,  130,  131,  148,  150,  149,  151,  179,  102,
+,  179,  124,  144,  102,  104,  102,  102,  102,  102,
+,  102,  102,  102,  102,  102,  102,  102,  102,  102,
+,  102,  127,  147,  128,  145,    7,  179,    4,    4,
+,  105,  180,  106,  115,  116,  122,  118,  119,    7,
+,    0,    8,  155,  174,  102,    0,  167,  137,  160,
+,  165,  152,  163,  153,  164,  162,    0,  112,    3,
+,  166,  112,  110,    0,    0,  110,  110,    0,    0,
+,  109,  109,  109,    0,  109,  135,  136,  134,  156,
+,  154,  159,  157,    0,    0,    0,    0,    0,    0,
+,    0,    0,    0,    0,    0,    0,    0,    0,  103,
+,    0,  117,  114,  102,    0,    0,  170,    0,  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,   56,  102,  102,
+,  102,  102,  102,  102,  102,  102,  102,  102,  102,
+,  102,  102,  102,  169,  161,    7,    0,    0,    0,
+,    0,    5,  105,    0,    0,    0,  115,    0,  121,
+,  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,  112,    0,
+,  110,  112,  112,  112,  112,  112,  110,    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,   59,  101,  101,  101,
+,  101,  101,  101,  101,   28,  101,  101,  101,  101,
+,   43,   46,  101,  101,   52,  101,   61,   68,  101,
+,   75,   77,   80,   81,   83,   84,  101,  101,   91,
+,  101,    0,    1,    0,    0,    0,    0,    0,    0,
+,    0,    0,    0,  119,    0,    0,    0,    0,  112,
+,  112,  112,    0,    0,    0,    0,    0,    0,    0,
+,    0,  101,  101,   18,  101,  101,  101,  101,  101,
+,  101,   16,  101,  101,  101,   33,  101,  101,  101,
+,  101,  101,  101,  101,  101,  101,  101,   35,  101,
+,   38,  101,   48,   53,  101,  101,  101,   90,  101,
+,    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,   60,
+,   65,  101,  101,   78,   92,  101,  101,   36,   47,
+,   72,  101,   95,   97,    0,    0,    0,    0,    0,
+,    0,    0,    0,    0,    0,    0,  101,   69,  101,
+,   12,  101,  101,   30,   34,  101,  101,  101,   66,
+,  101,  101,  101,  101,  101,    0,    0,    0,    0,
+,    0,    0,    0,    0,    0,    0,    0,    0,   58,
+,  101,  101,  101,  101,  101,  101,   50,   63,   73,
+,   93,   98,  101,  101,    0,    0,    0,    0,    0,
+,    0,    0,  101,  101,   13,   19,  101,   31,  101,
+,  101,   26,   87,    0,    0,  101,  101,  101,  101,
+,   74,   99,  101,   85,   20,  101,   45,   82,  101,
+,  101,  101,   70,    0
+,  133,  112,  112,    0,  112,  112,    0,    0,    6,
+,  110,    0,    0,    0,  112,    0,  110,  110,  110,
+,    0,  111,    0,    0,  109,  109,  109,  109,    0,
+,  172,    0,  177,  175,    0,    0,    0,  103,    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,   14,  102,  102,
+,  102,  102,  102,  102,  102,  102,  102,  102,  102,
+,  102,  102,  102,  102,  102,   50,  102,  102,  102,
+,  102,  102,  102,  102,  102,  102,  102,  102,  102,
+,  102,  102,  102,  102,   89,  102,  102,  102,  102,
+,  102,  102,    0,    0,    0,    0,    0,    0,    0,
+,  120,    0,    0,    0,    0,    0,  120,    0,    0,
+,    0,    0,    0,    0,    0,    0,    0,  112,    0,
+,    0,  112,    0,    0,  112,    0,  110,  110,    0,
+,  111,  111,    0,  111,    0,  111,  109,  109,    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,   21,  102,   24,  102,   27,  102,  102,
+,  102,  102,  102,  102,   41,  102,   43,  102,  102,
+,  102,  102,  102,  102,   55,  102,   66,  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,
+,  120,    0,    0,    0,    0,    0,  112,    0,    0,
+,    0,    0,    0,  111,  111,    0,  113,    0,  111,
+,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+,    0,    0,    0,  102,  102,   22,  102,  102,  102,
+,  102,  102,  102,   15,  102,  102,  102,  102,  102,
+,  102,  102,  102,  102,  102,  102,  102,  102,   23,
+,  102,   32,  102,  102,  102,  102,   40,  102,  102,
+,  102,   48,  102,  102,   53,  102,  102,   70,  102,
+,  102,   76,  102,  102,  102,  102,  102,   86,   88,
+,  102,   94,  102,  102,  101,    0,    0,    0,    0,
+,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+,    0,    0,    0,    0,  113,    0,    0,  111,  113,
+,  113,  113,    0,  111,    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,   58,  102,  102,  102,  102,  102,  102,
+,  102,   28,  102,  102,  102,   39,   42,   45,  102,
+,   51,  102,   60,   67,  102,  102,   75,   77,   80,
+,   83,   84,  102,  102,   91,  102,  102,    0,    1,
+,    0,    0,    0,    0,    0,  105,    0,    0,    0,
+,    0,    0,    0,    0,  113,    0,  113,  113,    0,
+,    0,    0,    0,    0,    0,    0,    0,  102,  102,
+,  102,  102,  102,  102,  102,  102,  102,   16,  102,
+,  102,   33,  102,  102,  102,  102,  102,  102,  102,
+,  102,  102,  102,  102,   36,   37,  102,   47,   52,
+,  102,  102,   90,  102,  102,    0,    0,    0,    0,
+,    0,    0,    0,    0,    0,    0,    0,    0,   10,
+,   29,   54,  102,  102,  102,  102,  102,  102,  102,
+,  102,  102,  102,   59,   61,   64,  102,  102,   78,
+,  102,  102,   35,   46,   71,   72,  102,   95,   98,
+,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+,    0,  102,   68,  102,  102,   12,  102,  102,   30,
+,  102,  102,  102,   65,  102,  102,  102,  102,  102,
+,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+,    0,    0,    0,   57,  102,  102,  102,  102,  102,
+,  102,   49,   62,   73,   79,   93,   99,  102,  102,
+,    0,    0,    0,    0,    0,    0,    0,  102,  102,
+,   19,  102,  102,   31,  102,  102,  102,   26,   87,
+,    0,  102,  102,  102,  102,  102,  102,   74,  100,
+,   85,   20,  102,  102,   44,   82,  102,  102,  102,
+,  102,  102,  102,   96,   69,    0
     } ;
 …
 ,   17,   18,   19,   20,   21,   22,   23,   24,   25,
 ,   26,   26,   26,   26,   27,   28,   29,   30,   31,
 ,   33,   34,   35,   36,   37,   38,   39,   40,   39,
 ,   11,   42,   11,   11,   43,   11,   44,   11,   45,
 ,   46,   47,   48,   49,   11,   11,   50,   11,   11,
 ,   52,   53,   54,   55,   56,   57,   58,   59,   60,
 ,   62,   63,   64,   65,   11,   66,   67,   68,   69,
 ,   71,   11,   72,   73,   74,   75,   76,   77,   78,
 ,   80,   81,   82,   83,   84,    1,    1,    1,    1,
+,   33,   34,   35,   36,   37,   38,   39,   40,   41,
+,   11,   43,   11,   11,   44,   11,   45,   11,   46,
+,   47,   48,   49,   50,   11,   11,   51,   11,   11,
+,   53,   54,   55,   56,   57,   58,   59,   60,   61,
+,   63,   64,   65,   66,   11,   67,   68,   69,   70,
+,   72,   11,   73,   74,   75,   76,   77,   78,   79,
+,   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,
 …
     } ;
 static yyconst flex_int32_t yy_meta[85] =
+static yyconst flex_int32_t yy_meta[86] =
     {   0,
 ,    1,    2,    1,    1,    1,    1,    1,    3,    1,
 …
 ,    1,    7,    7,    7,    7,    7,    7,    1,    1,
 ,    8,    1,    1,    1,    9,    9,    9,    9,    9,
 ,    4,   10,    4,   11,    4,    4,    4,   10,    4,
 ,   12,    1,    1,   13,    1,    9,    9,    9,    9,
 ,    9,    4,    4,    4,    4,   10,    4,    4,    4,
 ,    4,    4,    4,   10,    4,    4,    4,    4,    4,
 ,    1,    1,    1
+,    4,    4,   10,    4,   11,    4,    4,    4,   10,
+,    1,   12,    1,    1,   13,    1,    9,    9,    9,
+,    9,    9,    4,    4,    4,    4,   10,    4,    4,
+,   11,    4,    4,    4,   10,    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,
+,   83, 2238, 2237,   93,    0,  175,  176,  177,  178,
+, 2782,  189, 2782,  195,   54, 2782, 2197,   59,  171,
+, 2782, 2782,   55,  186, 2782,  189,  187,  202,  214,
+,    0, 2213, 2782,  214, 2213,  150,  340,  153,  222,
+,  157, 2782,  215,  224, 2782,  207,  181,  221,  249,
+,  289,  155,  255,  218,  206,  266,  256,  323,  259,
+, 2782,  223, 2782, 2210,  377,  342, 2782, 2220, 2782,
+,  234, 2782,    0, 2782,  421,    0, 2782,  393, 2782,
+,  405, 2782,  492, 2184,  241, 2782, 2782, 2782, 2782,
+, 2201, 2782, 2200, 2782, 2782, 2211,  552, 2782, 2226,
+,  413,  393,  437,  493,  377,  318,  195,  430,  382,
+,  384,  321,  196,  427, 2782, 2782, 2782, 2194, 2782,
+, 2782, 2193, 2192,  252,  302, 2206,  342,  435,  422,
+,  455,  400,  494, 2185,  440, 2133,  469, 2163, 2782,
+, 2782, 2782,  520, 2159, 2157, 2782, 2128,  414,  463,
+,  325,  254,  479,  432,  274,  480,  423,  483,  498,
+,  503,  499,  509,  341,  455,  484,  377,  510,  512,
+,  518,  529,  530,  531,  537, 2154,  541,  536,  544,
+,  546,  566,  569,  538,  552,  548,  554,  588,  571,
+,  580, 2782, 2782,  645,  651, 2202,  657, 2782,  663,
+, 2152,  593, 2147, 2144,    0,  631, 2782, 2782,  669,
+, 2140, 2139,    0, 2160,  629,  635,  639,  678,  677,
+,  670,  671,  674, 2138,  681,  682, 2115, 2114, 2782,
+,  597,  702,  678,  676, 2111, 2160, 2782,  693,    0,
+,  723,  743,  762,  788,  707, 2782, 2119, 2094,    0,
+, 2138,  768,  723, 2782, 2113, 2086,  809, 2782, 2782,
+, 2782, 2782,  705,  710, 2098, 2097,  724, 2091, 2088,
+,    0, 2086,    0, 2056,  709,  682,  707,  712,  710,
+,  647,  750,  671,  786,  751,  748,  731,  778,  787,
+,  788,  792,  790,  758, 2084,  796,  806,  800,  813,
+,  810,  802,  816,  822,  819,  815,  826,  830,  829,
+,  832,  833,  837,  839,  841,  846,  843, 2081,  848,
+,  849,  851,  852,  854,  853,  857,  855,  858,  863,
+, 2080,  867,  912,  871,  878,  872,  879,  882,  937,
+, 2076, 2074, 2071,    0, 2070,    0,  927,  931, 2069,
+, 2067,    0, 2064,    0, 2084, 2782,  913,  926, 2064,
+,    0, 2057,    0, 2782,  942,  960,  953, 2782,  966,
+, 1005, 2053, 2782, 2782,  955,  968,  995,  968, 1028,
+, 1014,  970, 2782, 2782, 2049, 2047, 2045,    0, 2042,
+, 2040,    0, 2038,    0, 2782,  909,  944,  982,  943,
+,  911, 1012,  923, 1013, 1019, 1009, 1016, 1023, 1024,
+,  972, 1030, 1028,  989, 1026, 1034, 1027, 1039, 2038,
+, 2035, 1048, 2034, 1049, 1051, 1052, 1053, 1056, 1057,
+, 2033, 1059, 2031,  946, 1063, 1066, 1067, 1068, 1071,
+, 2028, 1075, 2025, 1077, 1080, 1079, 1082, 1084, 1086,
+, 1090, 1097, 1107, 1088, 1108, 1093, 1098, 2024, 1096,
+, 1164, 2020,    0, 2018,    0, 2015,    0, 2012,    0,
+, 2011,    0, 2010,    0, 2008, 2005, 2002,    0, 2001,
+, 1156, 2000, 1162, 1148, 1182, 1149, 1126, 1147, 2782,
+, 1215, 1241, 2010, 1983, 1992, 1991,    0, 1990,    0,
+,    0, 1985,    0, 1982,    0, 1981,    0, 1161, 1149,
+, 1179, 1140, 1180, 1117, 1182, 1192, 1199, 1181, 1163,
+, 1200, 1201, 1220, 1198, 1221, 1224,  604, 1226, 1227,
+, 1233, 1234, 1981, 1244, 1236, 1978, 1240, 1241, 1246,
+, 1243, 1975, 1250, 1251, 1253, 1254, 1974, 1255, 1267,
+, 1264, 1271, 1256, 1263, 1257, 1971, 1275, 1277, 1279,
+, 1281, 1290, 1285, 1288, 1968, 1289, 1291, 1967, 2015,
+,    0, 1958,    0, 1957,    0, 1956,    0, 1954,    0,
+,    0, 1919,    0, 1918,    0, 1336, 1342, 1369, 1353,
+, 2782, 1359, 1307, 1359, 1309, 1912, 2782, 1911,    0,
+,    0, 1908,    0, 1905,    0,    0,    0, 1905,    0,
+, 1295, 1292, 1323, 1337, 1338, 1296, 1349, 1351, 1355,
+, 1348, 1363, 1364, 1371, 1373, 1380, 1375, 1403, 1381,
+, 1389, 1094, 1387, 1390, 1904, 1391, 1393, 1397, 1401,
+, 1901, 1898, 1394, 1400, 1897, 1404, 1896, 1894, 1402,
+, 1891, 1890, 1889, 1887, 1884, 1880, 1417, 1412, 1876,
+, 1418, 1921, 2782, 1853,    0, 1852,    0,    0,    0,
+,    0,    0,    0, 2782,    0,    0,    0,    0, 1463,
+, 2782, 2782, 1469, 1846,    0, 1845,    0,    0,    0,
+, 1844, 1407, 1446, 1845, 1406, 1423, 1300, 1431, 1449,
+, 1447, 1842, 1457, 1448, 1459, 1464, 1460, 1490, 1474,
+, 1494, 1480, 1475, 1484, 1485, 1486, 1482, 1841, 1487,
+, 1838, 1489, 1835, 1834, 1491, 1493, 1497, 1833, 1498,
+,    0,    0,    0, 1828, 1825, 1824, 1548,    0, 1823,
+, 1818, 1817, 1816, 1817, 1814, 1813, 1812, 1505, 1510,
+, 1501, 1504, 1508, 1513, 1517, 1526, 1528, 1559, 1810,
+, 1807, 1534, 1535, 1544, 1545, 1538, 1539, 1806, 1805,
+, 1800, 1540, 1799, 1798, 1793, 1786, 1784, 1783, 1780,
+, 1778, 1776, 1759, 1750, 1749, 1746, 1546, 1742, 1549,
+, 1552, 1554, 1557, 1558, 1739, 1556, 1589, 1566, 1732,
+, 1572, 1577, 1579, 1567, 1578, 1727, 1726, 1705, 1704,
+, 1696, 1694, 1693, 1650, 1649, 1647, 1645, 1644, 1646,
+, 1584, 1582, 1581, 1586, 1593, 1595, 1645, 1644, 1597,
+, 1641, 1598, 1599, 1602, 1636, 1635, 1633, 1422, 1421,
+, 1201,  946, 1605, 1610,  910, 1603, 1607,  768, 1613,
+, 1619,  723,  605,  503,  370, 1609, 1620, 1623, 1624,
+,  338,  337, 1627,  290,  251, 1630,  200,  196, 1631,
+, 1637, 1633,  136, 2782, 1707, 1720, 1733, 1743, 1753,
+, 1776, 1789, 1802, 1815, 1823, 1833, 1840, 1847, 1854,
+, 1868, 1875, 1882, 1889, 1896, 1909, 1916, 1920, 1928,
+, 1938, 1945, 1952, 1955, 1962, 1968, 1981, 1994, 2001,
+, 2015, 2022, 2025, 2032, 2035, 2042, 2045, 2052, 2055,
+, 2065, 2072, 2075, 2082, 2085, 2092, 2100, 2107, 2114,
+, 2128, 2131, 2138, 2141, 2148, 2151, 2158, 2164, 2177,
+, 2191, 2194, 2201, 2204, 2211, 2214, 2221, 2224, 2231,
+, 2241, 2244, 2251, 2258, 2261, 2268, 2271, 2278, 2285,
+, 2295, 2302, 2305, 2312, 2315, 2322, 2325, 2332, 2335,
+, 2348, 2361, 2368, 2375, 2378, 2385, 2388, 2395, 2398,
+, 2408, 2415, 2418, 2425, 2428, 2435, 2438, 2445, 2448,
+, 2462, 2465, 2472, 2475, 2482, 2485, 2492, 2495, 2498,
+, 2511, 2520, 2527, 2534, 2537, 2544, 2547, 2550, 2556,
+, 2566, 2569, 2572, 2575, 2578, 2581, 2584, 2591, 2594,
+, 2604, 2607, 2610, 2613, 2623, 2630, 2633, 2636, 2639,
+, 2653, 2660, 2663, 2670, 2677, 2684, 2691, 2698, 2705,
+, 2719, 2726, 2733, 2740, 2747, 2754, 2761, 2768
+,   84, 2272, 2269,   94,    0,  177,  178,  179,  180,
+, 2822,  191, 2822,  197,   55, 2822, 2231,   60,  173,
+, 2822, 2822,   56,  188, 2822,  191,  189,  204,  216,
+,    0, 2249, 2822,  216, 2247,  152,  344,  155,  220,
+,  159, 2822,  217,  226, 2822,  185,  154,  212,  251,
+,  270,  235,  257,  241,  205,  193,  305,  314,  333,
+,  228, 2822,  225, 2822, 2242,  402,  390, 2822, 2253,
+, 2221,  235, 2822,    0, 2822,  426,    0, 2822,  417,
+,  439,  451, 2822,  498, 2219,  264, 2822, 2822, 2822,
+, 2822, 2235, 2822, 2232, 2822, 2822, 2244,  559, 2822,
+, 2822,  438,  444,  511,  534,  289,  253,  197,  380,
+,    0,  319,  280,  198,  322, 2822, 2822, 2822, 2230,
+, 2822, 2822, 2227, 2224,  218,  255, 2239,  298,  350,
+,  312,  440,  398,  405, 2220,  441, 2168,  446, 2196,
+,  335, 2822, 2822,  468, 2190, 2189, 2822, 2162,  439,
+,  433,  372,  281,  437,  434,  428,  570,  444,  466,
+,  469,  475,  321,  492,  438,  471,  445,  474,  512,
+,  503,  496,  521,  276,  515,  516, 2189,  526,  510,
+,  525,  543,  522,  560,  553,  523,  561,  551,  544,
+,  582,  593,  584, 2822, 2822,  660,  651, 2236,  666,
+,  678, 2822, 2183,  607, 2179, 2178,    0,  693, 2822,
+,  684, 2176, 2156, 2154,    0, 2177,  578,  608,  617,
+,  679,  650,  683,  684,  687, 2172,  690,  691, 2147,
+, 2822,    0,  683,  710,  686,  700, 2145, 2196, 2822,
+,    0,  427,  746,  764,  786,  808,  621, 2822, 2152,
+,    0,  794, 2171,  795,  709, 2822, 2147, 2121,  832,
+, 2822, 2152, 2822, 2822,  711,  714, 2129, 2129,  717,
+, 2123, 2120,    0, 2117,    0, 2088,  694,  679,  712,
+,  711,  698,  566,  726,  743,  771,  741,  790,  784,
+,  795,  742,  744,  814,  816,  818, 2118,  819,  745,
+,  821,  822,  823,  824,  746,  825,  748,  659,  831,
+,  833,  838,  839,  848,  850,  851,  844,  834,  857,
+,  858,  859,  860,  862,  861,  864,  865,  867,  868,
+,  871,  876,  872,  878, 2113,  880,  689,  881,  882,
+,  896,  893,  953,  954, 2109, 2108, 2106,    0, 2103,
+,  941,  945, 2102,    0, 2101,    0, 2099,    0, 2118,
+,  940,  941, 2094, 2088,    0, 2086,    0, 2822,  953,
+,  964, 2822,  981,  997, 1021, 2084, 2822, 2822,  939,
+, 1006,  982, 1041,  310, 1039, 1004, 2822, 2822, 2081,
+, 2077,    0, 2074,    0, 2071,    0, 2070,    0, 2822,
+,  941,  960,  962,  977,  976,  980,  982, 1017, 1010,
+,  998, 1022, 1031, 1028, 1033, 1034, 1037, 1040, 1043,
+, 1041, 1053, 2072, 1055, 2070, 1045, 2067, 1056, 1061,
+, 1065, 1066, 1067, 1070, 2064, 1071, 2063, 1073, 1074,
+, 1078, 1080, 1081, 1085, 2062, 1087, 2060, 1084, 1089,
+, 1097, 1099, 1092, 1102, 1103, 1105, 1106, 1108,  905,
+, 1116, 1110, 1122, 2057, 1120, 1123, 1179, 2051,    0,
+,    0, 2049,    0, 2047,    0, 1166, 2044,    0, 2041,
+, 2040, 2039, 2037,    0, 2034,    0, 1173, 2031, 1179,
+, 1195, 1181, 1178, 1176, 2822, 1219, 1231, 1253, 2042,
+, 2027, 2024,    0, 2021,    0, 2020,    0, 2019,    0,
+,    0, 2014,    0, 1141, 1172, 2014, 1180, 1155, 1196,
+, 1216, 1207, 1231, 1125, 1210, 1232, 1214, 1187, 1236,
+, 1237, 1238, 1272, 1249, 1252, 1250, 1253, 1254, 2013,
+, 1256, 2012, 1260, 1263, 1264, 1257, 2010, 1271, 1268,
+, 1273, 2007, 1275, 1282, 2006, 1283, 1284, 2005, 1276,
+, 1289, 2003, 1294, 1291, 1296, 1295, 1297, 1310, 2000,
+, 1308, 1999, 1307, 1300, 1998, 2046, 1960,    0, 1958,
+, 1957,    0, 1954,    0, 1951,    0, 1950,    0, 1949,
+, 1947,    0, 1355, 1361, 1389, 1372, 1944, 2822, 1378,
+, 1365, 1379, 1941, 2822, 1940,    0, 1939,    0, 1937,
+, 1934,    0,    0,    0, 1936,    0, 1366, 1312, 1311,
+, 1323, 1368, 1369, 1374, 1356, 1383, 1372, 1388, 1390,
+, 1395, 1396, 1398, 1400, 1431, 1406, 1407, 1411, 1408,
+, 1414, 1935, 1409, 1416, 1419, 1933, 1930, 1929, 1422,
+, 1928, 1429, 1926, 1923, 1425, 1430, 1919, 1915, 1911,
+, 1894, 1893, 1436, 1433, 1891, 1439, 1440, 1938, 2822,
+,    0, 1883,    0,    0,    0, 1884,    0,    0,    0,
+,    0,    0,    0,    0, 1486, 1878, 2822, 2822, 1492,
+,    0, 1876,    0,    0,    0,    0, 1874, 1447, 1444,
+, 1449, 1471, 1479, 1450, 1480, 1482, 1469, 1873, 1486,
+, 1488, 1502, 1452, 1510, 1504, 1491, 1519, 1506, 1498,
+, 1512, 1513, 1514, 1515, 1872, 1870, 1517, 1867, 1866,
+, 1520, 1523, 1865, 1521, 1525,    0,    0,    0, 1860,
+, 1856, 1575,    0, 1855, 1853, 1850, 1849, 1848, 1849,
+, 1845, 1844, 1531, 1536, 1527, 1528, 1552, 1533, 1537,
+, 1555, 1557, 1569, 1842, 1560, 1839, 1561, 1559, 1568,
+, 1567, 1573, 1838, 1837, 1835, 1828, 1574, 1826, 1825,
+, 1818, 1817, 1815, 1798, 1789, 1788, 1785, 1778, 1775,
+, 1766, 1576, 1768, 1577, 1581, 1580, 1579, 1584, 1585,
+, 1586, 1615, 1590, 1746, 1591, 1592, 1602, 1600, 1594,
+, 1742, 1735, 1733, 1732, 1690, 1689, 1686, 1685, 1683,
+, 1678, 1677, 1674, 1676, 1607, 1611, 1614, 1612, 1608,
+, 1620, 1675, 1623, 1624, 1530, 1453, 1630, 1625, 1629,
+, 1354, 1319, 1318, 1267, 1212, 1210, 1208, 1631, 1636,
+, 1639, 1635, 1643, 1177, 1644, 1646, 1650, 1126,  964,
+,  903, 1651, 1652, 1654, 1655, 1656, 1658,  788,  752,
+,  607,  487, 1662, 1663,  394,  357, 1664, 1666, 1668,
+, 1669, 1672, 1674,  233,  137, 2822, 1747, 1760, 1773,
+, 1793, 1806, 1816, 1829, 1842, 1855, 1863, 1873, 1880,
+, 1894, 1901, 1908, 1915, 1922, 1929, 1936, 1949, 1956,
+, 1968, 1971, 1978, 1985, 1992, 1995, 2002, 2008, 2021,
+, 2041, 2048, 2055, 2062, 2065, 2072, 2075, 2082, 2085,
+, 2095, 2102, 2105, 2112, 2115, 2122, 2125, 2132, 2140,
+, 2154, 2161, 2168, 2171, 2178, 2181, 2188, 2191, 2198,
+, 2217, 2224, 2231, 2234, 2241, 2244, 2251, 2254, 2261,
+, 2271, 2274, 2281, 2284, 2291, 2298, 2301, 2308, 2311,
+, 2325, 2332, 2335, 2342, 2345, 2352, 2355, 2362, 2365,
+, 2375, 2382, 2388, 2401, 2408, 2415, 2418, 2425, 2428,
+, 2438, 2445, 2448, 2455, 2458, 2465, 2468, 2475, 2478,
+, 2488, 2495, 2502, 2505, 2512, 2515, 2522, 2525, 2532,
+, 2538, 2544, 2551, 2560, 2567, 2574, 2577, 2584, 2587,
+, 2596, 2603, 2606, 2609, 2612, 2615, 2618, 2621, 2624,
+, 2634, 2641, 2644, 2647, 2650, 2653, 2663, 2670, 2673,
+, 2679, 2686, 2693, 2700, 2703, 2710, 2717, 2724, 2731,
+, 2745, 2752, 2759, 2766, 2773, 2780, 2787, 2794, 2801,
     } ;
 static yyconst flex_int16_t yy_def[1050] =
+static yyconst flex_int16_t yy_def[1062] =
     {   0,
+,    1,  876,  876,  875,    5,  877,  877,  878,  878,
+,  875,  875,  875,  875,  875,  875,  879,  875,  875,
+,  875,  875,  875,  875,  875,  875,  875,  875,  875,
+,   31,  875,  875,  875,  875,  875,  875,  880,  879,
+,  875,  875,  875,  879,  875,  879,  879,  879,  879,
+,  879,  879,  879,  879,  879,  879,  879,  879,  879,
+,  875,  875,  875,  875,  875,  881,  875,  875,  875,
+,  875,  875,  883,  875,  875,  884,  875,  875,  875,
+,  875,  875,  875,  879,  875,  875,  875,  875,  875,
+,  875,  875,  875,  875,  875,  875,  875,  875,  885,
+,   98,   30,  875,  875,  875,  875,  886,   30,  875,
+,  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,  887,  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,  875,  875,  875,  881,  881,  881,  875,  881,
+,  882,  875,  890,  891,  883,  875,  875,  875,  875,
+,  893,  894,  884,  875,  875,  875,  875,  875,  875,
+,  875,  875,  875,  875,  875,  875,  895,  896,  875,
+,  875,  875,  875,  875,   98,  897,  875,  875,  103,
+,  875,  875,  875,  875,  875,  875,  875,  875,  898,
+,  900,  875,  875,  875,  875,  875,  875,  875,  875,
+,  875,  875,  875,  875,  875,  887,  875,  901,  902,
+,  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,  908,
+,  910,  911,  912,  913,  914,  915,  875,  875,  916,
+,  918,  919,  920,  921,  875,  875,  875,  875,  875,
+,  923,  924,  925,  875,  875,  875,  875,  875,  875,
+,  367,  372,  875,  875,  926,  927,  928,  875,  875,
+,  928,  875,  875,  875,  929,  930,  931,  932,  933,
+,  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,
+,  940,  941,  942,  943,  944,  945,  946,  947,  948,
+,  949,  950,  951,  952,  953,  953,  954,  955,  956,
+,  875,  482,  875,  958,  875,  958,  875,  875,  875,
+,  875,  875,  875,  875,  959,  960,  961,  962,  963,
+,  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,  973,
+,  975,  976,  977,  978,  979,  980,  981,  982,  983,
+,  985,  986,  987,  988,  989,  875,  875,  875,  875,
+,  875,  589,  875,  875,  875,  593,  875,  991,  992,
+,  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, 1003,  875, 1004, 1005, 1006, 1007, 1008, 1009,
+, 1011, 1012, 1013,  875, 1014, 1015, 1016, 1017,  875,
+,  875,  875,  875, 1018, 1019, 1020, 1021, 1022, 1023,
+, 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,
+, 1027, 1028, 1029, 1030, 1031, 1032,  875, 1033, 1018,
+, 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, 1036, 1037, 1030, 1038, 1031,
+, 1032, 1040, 1041, 1034, 1042, 1035, 1026, 1026, 1026,
+, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026,
+, 1026, 1026, 1026, 1026, 1026, 1043, 1036, 1044, 1037,
+, 1038, 1046, 1039, 1047, 1040, 1048, 1041, 1042, 1026,
+, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026,
+, 1026, 1026, 1026, 1026, 1049, 1043, 1044, 1045, 1046,
+, 1047, 1048, 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,    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
+,    1,  888,  888,  887,    5,  889,  889,  890,  890,
+,  887,  887,  887,  887,  887,  887,  891,  887,  887,
+,  887,  887,  887,  887,  887,  887,  887,  887,  887,
+,   31,  887,  887,  887,  887,  887,  887,  892,  891,
+,  887,  887,  887,  891,  887,  891,  891,  891,  891,
+,  891,  891,  891,  891,  891,  891,  891,  891,  891,
+,  891,  887,  887,  887,  887,  887,  893,  887,  887,
+,  894,  887,  887,  895,  887,  887,  896,  887,  887,
+,  887,  887,  887,  887,  891,  887,  887,  887,  887,
+,  887,  887,  887,  887,  887,  887,  887,  887,  887,
+,  887,   99,   30,  887,  887,  887,  887,  898,   30,
+,   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,  899,
+,  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,  887,  887,  887,  893,  893,  893,
+,  893,  887,  894,  887,  902,  903,  895,  887,  887,
+,  887,  904,  905,  906,  896,  887,  887,  887,  887,
+,  887,  887,  887,  887,  887,  887,  887,  887,  907,
+,  887,   99,  887,  887,  887,  887,   99,  909,  887,
+,  104,  104,  887,  887,  887,  887,  887,  887,  887,
+,  910,  911,  912,  887,  887,  887,  887,  887,  887,
+,  887,  887,  887,  887,  887,  887,  887,  899,  887,
+,  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,  920,  921,  922,  923,  924,  925,  926,
+,  887,  887,  928,  929,  930,  931,  932,  933,  887,
+,  887,  887,  887,  934,  935,  936,  937,  887,  887,
+,  887,  887,  887,  887,  371,  376,  887,  887,  938,
+,  940,  887,  887,  887,  940,  887,  887,  887,  941,
+,  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,  952,  953,  954,
+,  956,  957,  958,  959,  960,  887,  961,  962,  963,
+,  965,  965,  966,  967,  968,  969,  887,  488,  887,
+,  887,  970,  887,  887,  887,  887,  887,  887,  887,
+,  971,  972,  973,  974,  975,  976,  977,  978,  979,
+,  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,  985,  986,  987,  988,
+,  990,  991,  992,  993,  994,  995,  996,  997,  998,
+, 1000, 1001,  887,  887,  887,  887, 1002,  887,  596,
+,  887,  887,  600,  887, 1003, 1004, 1005, 1006, 1007,
+, 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, 1015,  887,
+, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025,
+, 1026, 1027, 1028, 1029,  887,  686,  887,  887,  887,
+, 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, 1039, 1040, 1041, 1042,
+, 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,
+, 1049, 1042, 1050, 1043, 1051, 1044, 1052, 1053, 1046,
+, 1047, 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,
+, 1060, 1053, 1054, 1038, 1038, 1038, 1038, 1038, 1038,
+, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
+, 1055, 1056, 1057, 1058, 1032, 1059, 1060, 1038, 1038,
+, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
+, 1032, 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,
     } ;
 static yyconst flex_int16_t yy_nxt[2867] =
+static yyconst flex_int16_t yy_nxt[2908] =
     {   0,
 ,   13,   14,   15,   15,   15,   13,   16,   17,   12,
 …
 ,   29,   30,   31,   32,   32,   32,   32,   33,   34,
 ,   36,   37,   38,   39,   18,   18,   18,   18,   18,
+,   18,   40,   18,   18,   18,   18,   18,   40,   18,
+,   42,   43,   44,   45,   46,   47,   48,   49,   50,
+,   52,   53,   18,   54,   18,   55,   18,   18,   18,
+,   56,   57,   58,   59,   60,   61,   18,   18,   18,
+,   63,   64,   65,   66,   83,   91,   84,   84,   66,
+,   88,   67,   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,   71,   71,
+,   18,   18,   40,   18,   18,   18,   18,   18,   40,
+,   41,   42,   43,   44,   45,   46,   47,   48,   49,
+,   51,   52,   53,   18,   54,   18,   55,   18,   18,
+,   18,   57,   58,   59,   60,   61,   62,   18,   18,
+,   63,   64,   65,   66,   67,   84,   92,   85,   85,
+,   88,   89,   68,   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,   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,   70,   70,   70,   70,   75,   75,   78,
+,  122,  123,   89,  140,   78,   78,   86,   75,   75,
+,   80,   81,   81,   81,   79,   81,   80,   82,   82,
+,   81,   90,   92,  141,  145,   86,   97,   94,   98,
+,   98,   98,   98,   98,  250,  875,   93,   99,   84,
+,   96,   84,  100,  176,  117,   76,   76,   76,   76,
+,  146,   86,  101,  102,  143,  103,  103,  103,  103,
+,  104,  118,   86,  119,  120,  147,   86,  148,  252,
+,   86,  160,  105,  193,  192,  106,   86,   86,  149,
+,  151,  107,  108,  152,  153,  181,  154,  109,   86,
+,  156,   86,   86,  105,   86,  144,  161,  157,  158,
+,  159,  204,  261,  162,  262,   86,  179,  107,  228,
+,  108,  102,  180,  111,  111,  111,  111,  111,  111,
+,  168,   86,  169,  194,   86,   86,   86,  205,  164,
+,  105,  170,  165,  112,  229,  177,   86,  166,  186,
+,  281,  167,  178,  269,   86,  114,  187,  191,  182,
+,  142,  105,  261,  188,  262,  143,  284,  115,  184,
+,   86,  185,  198,  199,  171,  113,  124,  198,  189,
+,  125,  126,  172,  127,  173,  128,  129,  174,  130,
+,  131,  175,  256,  200,  200,  200,  200,  200,  200,
+,  133,  134,  261,   86,  262,   86,  144,  195,   80,
+,   81,   81,  195,  249,  280,  196,  257,   86,   86,
+,  190,   86,  136,   79,   80,   81,   81,   81,   79,
+,   80,   81,   81,   81,   81,   81,   80,   82,   82,
+,   81,  261,  305,  262,  240,  240,  240,  240,  246,
+,  138,  207,  208,  875,  247,  254,  207,   86,  209,
+,  261,  255,  262,  209,   98,   98,   98,   98,   98,
+,  263,  875,  210,  210,  210,  210,  241,  246,  308,
+,  247,  263,  261,  209,  262,  247,  102,  255,  104,
+,  104,  104,  104,  104,   86,  261,  239,  262,  211,
+,  261,  209,  262,   86,  255,  105,  209,  209,  875,
+,  209,  209,   86,  253,  264,  261,  277,  262,  209,
+,  242,  209,  254,  209,  212,  209,  105,  213,  215,
+,  255,  262,  216,  217,  283,   86,  875,  218,  219,
+,  220,  243,  221,   86,  244,  244,  244,  244,  244,
+,   86,  222,  223,  224,  261,  265,  262,  142,  306,
+,   86,  278,  143,   86,   86,  285,  286,  287,  279,
+,  289,  225,   86,  290,  226,  291,  245,  282,   86,
+,  292,  293,  294,   86,  295,  297,  875,  298,  301,
+,   86,  307,   86,  299,  300,  309,  303,   86,   86,
+,   86,  302,  227,  231,  231,  231,  231,  231,  231,
+,   86,   86,  312,  310,  311,  313,   86,   86,   86,
+,  233,   86,  234,  235,   86,  142,   86,  314,   86,
+,  315,  330,   86,  320,   86,  236,  318,   86,  316,
+,  232,  233,  232,  319,  325,  234,   86,  235,  322,
+,   86,   86,  331,  333,  328,  332,  629,  326,  323,
+,   86,  207,  208,  337,  335,  338,  207,  365,   86,
+,  342,  334,  336,  339,  327,  195,   80,   81,   81,
+,  195,  198,  199,  196,   86,   86,  198,  198,  199,
+,  365,  357,  198,  340,  199,  356,  343,  357,  340,
+,  341,  357,  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,
+,  356,  356,  357,  357,  356,  359,  357,  356,  356,
+,  357,  356,  356,  357,  357,  369,  365,  403,  366,
+,  366,   86,  349,  367,  367,  367,  367,  367,  367,
+,  232,  233,   86,  234,  235,  261,  369,  262,  369,
+,  261,  405,  262,  369,  104,  104,  104,  104,  104,
+,  398,  232,  233,  232,  374,  368,  234,   86,  235,
+,   86,  105,   86,  371,  244,  244,  244,  244,  244,
+,  384,  386,  397,   86,   86,  399,  253,  401,  400,
+,  374,   86,  105,  372,  372,  372,  372,  372,  372,
+,  104,  104,  104,  104,  104,  377,  384,  387,   86,
+,   86,   86,  234,  235,  243,  404,  243,  411,   86,
+,  244,  244,  244,  244,  244,  373,  410,  379,   86,
+,  232,  253,  232,  381,  409,  234,  419,  235,   86,
+,  111,  111,  111,  111,  111,  111,   86,   86,   86,
+,   86,  383,   86,  412,  415,  380,   86,  416,   86,
+,   86,  406,   86,  413,  414,  417,   86,  407,  408,
+,   86,  421,  258,   86,  420,   86,   86,  418,  424,
+,  423,  428,   86,  426,  427,  430,   86,  429,  425,
+,   86,   86,   86,   86,  431,  432,  433,   86,  437,
+,  435,   86,  438,   86,  439,  434,   86,  436,   86,
+,   86,   86,   86,   86,   86,   86,  443,   86,   86,
+,  441,  440,  446,   86,  442,  445,  451,   86,   86,
+,  450,   86,   86,  447,  449,  448,  456,  452,   86,
+,  459,  453,   86,  494,  460,  454,  455,  340,  199,
+,  199,  458,  340,  356,  341,  357,  197,  461,  209,
+,  209,  209,  348,  348,  348,  348,  356,  495,  357,
+,   86,   86,   86,  367,  367,  367,  367,  367,  367,
+,  509,  366,  514,   86,  367,  367,  367,  367,  367,
+,  471,  482,  482,  482,  482,  482,  482,  231,  231,
+,  231,  231,  231,   86,   86,  516,   86,  232,  486,
+,  234,  235,  240,  240,  240,  240,  104,  104,  487,
+,  510,  486,  512,  483,  377,  490,  545,  490,  232,
+,  232,  488,   86,  234,  486,  235,  372,  372,  372,
+,  372,  372,   86,  875,  371,  489,  379,  486,  380,
+,  525,  490,  381,  490,  491,  529,  491,  511,  382,
+,  492,  492,  492,  492,  492,  379,   86,  380,  373,
+,  383,  381,   86,   86,  380,  513,   86,  496,  381,
+,   86,  515,  517,   86,   86,  519,   86,   86,   86,
+,   86,  493,  518,  380,   86,  526,  521,  381,  520,
+,  522,  523,  524,  527,   86,  531,  532,  530,   86,
+,  528,   86,   86,   86,  533,   86,   86,   86,  534,
+,  535,  538,  541,   86,  543,  539,   86,   86,   86,
+,  536,   86,  542,  537,  544,   86,  540,   86,  551,
+,   86,  547,   86,  549,   86,  546,   86,   86,   86,
+,   86,  550,  552,   86,   86,  558,   86,   86,   86,
+,  553,  554,  556,  560,  561,  559,  557,   86,   86,
+,  566,   86,  716,  563,  562,  199,  564,   86,  568,
+,  569,  570,  209,  209,  209,  209,  565,  482,  482,
+,  482,  482,  482,  372,  372,  372,  372,  372,  372,
+,   86,  486,  486,  232,  592,  486,  234,  235,  588,
+,  588,  487,  591,  589,  589,  589,  589,  589,  589,
+,  614,   86,  612,   86,  232,  484,  232,  486,  486,
+,  592,  235,  492,  492,  492,  492,  492,  492,  611,
+,   86,   86,   86,  621,  620,  590,  593,  593,  593,
+,  593,  593,   86,  615,  613,  617,   86,  618,   86,
+,   86,   86,  594,  626,  875,  595,  596,  491,  856,
+,  619,  622,  492,  492,  492,  492,  492,  492,  597,
+,   86,   86,  624,  594,   86,  594,   86,   86,  595,
+,  596,   86,  627,   86,   86,  630,   86,  628,  635,
+,   86,   86,  633,   86,   86,  636,   86,   86,  632,
+,   86,   86,  641,   86,   86,   86,   86,   86,  638,
+,   86,  639,  640,   86,   86,  644,  637,   86,  643,
+,  646,   86,  647,  648,  652,   86,  651,   86,  650,
+,  649,   86,  656,  653,  658,   86,  655,  654,   86,
+,   86,   86,   86,  657,  659,   86,   86,  682,  660,
+,   86,  696,  695,  700,  662,  749,  661,  482,  482,
+,  482,  482,  482,  589,  589,  589,  589,  589,  589,
+,  682,  588,  682,   86,  589,  589,  589,  589,  589,
+,  593,  593,  593,  593,  593,  593,  697,   86,   86,
+,  680,  680,  680,  680,  680,  680,  683,   86,   86,
+,  683,   86,  693,   86,  698,   86,  594,  701,  703,
+,  596,  699,  597,   86,   86,  694,  704,  683,  702,
+,  705,   86,  681,   86,  683,   86,  712,  594,  706,
+,   86,   86,  595,  710,  596,   86,  707,   86,  708,
+,   86,   86,  711,   86,   86,  709,  713,   86,  715,
+,   86,   86,   86,   86,   86,  714,   86,   86,   86,
+,  722,  726,   86,  719,  723,  727,  720,   86,   86,
+,   86,  725,  729,   86,  875,  875,  728,  724,  745,
+,  748,   86,  747,  731,  680,  680,  680,  680,  680,
+,  593,  593,  593,  593,  593,  593,   86,   86,   86,
+,  594,  750,  751,  595,  596,   86,  746,   86,  752,
+,   86,  755,  759,  754,   86,  753,  681,  757,  756,
+,   86,  594,  684,  594,   86,   86,  595,  760,  596,
+,   86,  758,   86,  763,   86,   86,   86,   86,  764,
+,   86,   86,  765,   86,   86,  766,  769,   86,   86,
+,   86,   86,   86,  768,   86,   86,  774,  790,   86,
+,   86,  771,  770,   86,  792,  772,  791,   86,  773,
+,  680,  680,  680,  680,  680,  788,   86,  789,   86,
+,  794,  793,  798,   86,   86,   86,  799,  800,   86,
+,   86,  797,  801,  795,   86,   86,   86,  802,  803,
+,   86,  738,   86,  804,   86,  823,   86,   86,   86,
+,  825,  826,  805,  806,  828,   86,   86,   86,  822,
+,  821,   86,   86,  820,  827,  831,  824,   86,   86,
+,  832,   86,   86,  834,   86,  846,   86,  830,  833,
+,  847,  845,  844,   86,  835,   86,  849,   86,   86,
+,  851,  852,   86,   86,  848,   86,  859,   86,  853,
+,   86,  854,  850,   86,  857,  858,  861,  860,   86,
+,   86,  862,  863,   86,   86,   86,  866,   86,  868,
+,   86,   86,   86,   86,  867,  865,  875,   86,  875,
+,  871,   86,   86,  874,   86,   86,   86,  875,  875,
+,  843,  870,  875,  842,  872,  873,   68,   68,   68,
+,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+,   74,   74,   74,   74,   74,   74,   74,   74,   74,
+,   74,   74,   77,   77,   77,   77,   77,   77,   77,
+,   77,   77,   77,   77,   77,   85,  875,  840,   85,
+,   85,   85,   85,   85,   85,  139,  839,  875,  838,
+,  139,  139,  139,  139,  139,  197,  197,  197,  197,
+,  197,  197,  197,  197,  197,  197,  197,  197,  202,
+,  837,  202,   86,  202,  202,  202,  202,  202,  206,
+,  206,  206,   86,  206,  206,  206,  206,  206,  206,
+,  206,  214,  819,  875,  214,  214,  214,  214,  214,
+,  214,  214,  818,  214,  237,  237,  237,  237,  237,
+,  237,  237,  237,  237,  237,  237,  237,  251,  251,
+,  251,  875,  814,  875,  251,  267,  812,  875,  267,
+,  267,  267,  267,  267,  267,  271,  808,  271,   86,
+,   86,  271,  273,   86,  273,   86,   86,   86,  273,
+,   86,  344,   86,   86,   86,  344,  346,   86,  346,
+,  787,  785,  346,  350,  875,  350,  875,  782,  780,
+,  352,  778,  352,   86,   86,   86,  352,  354,   86,
+,   86,   86,   86,  354,  361,   86,  361,  744,  741,
+,  361,  363,  738,  363,  203,  734,  733,  363,  237,
+,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+,  237,  376,  664,  376,  378,  378,   86,  378,  378,
+,   86,  378,  251,  251,   86,  251,  388,   86,  388,
+,   86,   86,  388,  390,   86,  390,   86,   86,   86,
+,  392,   86,  392,   86,   86,   86,  392,  271,  691,
+,  394,  690,  394,  688,  686,  684,  394,  273,  591,
+,   85,  679,  678,   85,  676,   85,   85,   85,   85,
+,  197,  197,  197,  197,  197,  197,  197,  197,  197,
+,  197,  197,  197,  462,  462,  462,  462,  462,  462,
+,  462,  462,  462,  462,  462,  462,  463,  674,  463,
+,  670,  668,  463,  465,  666,  465,  664,   86,   86,
+,  467,   86,  467,   86,   86,   86,  467,  344,   86,
+,  469,   86,  469,   86,  610,  608,  469,  346,  606,
+,  472,  604,  472,  602,  600,  496,  472,  350,  598,
+,  474,  598,  474,  587,  586,  584,  474,  352,  477,
+,  476,  477,  476,  582,  580,  578,  476,  354,  576,
+,  478,  574,  478,  572,   86,   86,  478,  361,   86,
+,  480,   86,  480,   86,   86,   86,  480,  363,   86,
+,  485,  508,  485,  506,  485,  504,  485,  376,  502,
+,  500,  376,  498,  376,  378,  378,  484,  378,  378,
+,  481,  378,  497,  479,  497,  357,  357,  477,  497,
+,  475,  499,  473,  470,  468,  499,  501,  466,  501,
+,   86,   86,  501,  388,   86,  388,  503,  396,  503,
+,  393,  391,  503,  390,  389,  390,  505,  268,  505,
+,  262,  385,  505,  392,  385,  392,  507,  250,  507,
+,  375,  238,  507,  394,  370,  394,   85,  364,  362,
+,  360,   85,   85,   85,   85,   85,  462,  462,  462,
+,  462,  462,  462,  462,  462,  462,  462,  462,  462,
+,  356,  571,  355,  353,  351,  571,  463,  347,  463,
+,  345,  573,  203,  199,   86,  573,  465,  275,  465,
+,  274,  575,  272,  268,  263,  575,  467,  266,  467,
+,  263,  577,  261,  260,  259,  577,  469,  238,  469,
+,  230,  579,   84,   84,   86,  579,  472,  203,  472,
+,  201,  581,   84,  121,  116,  581,  474,   86,  474,
+,  875,  476,   69,   69,  875,  476,  583,  875,  583,
+,  875,  875,  583,  478,  875,  478,  585,  875,  585,
+,  875,  875,  585,  480,  875,  480,  485,  875,  485,
+,  485,  875,  485,  378,  875,  378,  875,  875,  875,
+,  599,  875,  599,  875,  875,  875,  599,  497,  875,
+,  601,  875,  601,  875,  875,  875,  601,  499,  875,
+,  603,  875,  603,  875,  875,  875,  603,  501,  875,
+,  605,  875,  605,  875,  875,  875,  605,  503,  875,
+,  607,  875,  607,  875,  875,  875,  607,  505,  875,
+,  609,  875,  609,  875,  875,  875,  609,  507,  875,
+,   85,  875,  875,   85,  875,   85,   85,   85,   85,
+,  663,  663,  663,  663,  663,  663,  663,  663,  663,
+,  663,  663,  663,  665,  875,  665,  875,  875,  875,
+,  571,  875,  571,  667,  875,  667,  875,  875,  875,
+,  573,  875,  573,  669,  875,  669,  875,  875,  875,
+,  575,  875,  575,  671,  875,  671,  875,  875,  875,
+,  577,  875,  577,  673,  875,  673,  875,  875,  875,
+,  579,  875,  579,  675,  875,  675,  875,  875,  875,
+,  581,  875,  581,  677,  875,  677,  875,  875,  875,
+,  583,  875,  583,   85,  875,   85,  875,  875,  875,
+,  585,  875,  585,  485,  875,  485,  875,  875,  875,
+,  685,  875,  685,  875,  875,  875,  685,  599,  875,
+,  687,  875,  687,  875,  875,  875,  687,  601,  875,
+,  689,  875,  689,  875,  875,  875,  689,  603,  875,
+,  139,  875,  139,  875,  875,  875,  139,  605,  875,
+,  692,  875,  692,  607,  875,  607,   85,  875,  875,
+,  875,   85,   85,   85,   85,   85,  609,  875,  609,
+,  663,  663,  663,  663,  663,  663,  663,  663,  663,
+,  663,  663,  732,  875,  732,  875,  875,  875,  732,
+,  875,  665,  202,  875,  202,  875,  875,  875,  202,
+,  875,  667,  735,  875,  735,  669,  875,  669,  202,
+,  875,  202,  875,  202,  202,  202,  202,  202,  671,
+,  671,  736,  875,  736,  673,  875,  673,  675,  875,
+,  737,  875,  737,  677,  875,  677,   85,  875,   85,
+,  875,  739,  875,  875,  875,  739,  685,  875,  685,
+,  875,  267,  875,  875,  875,  267,  687,  875,  687,
+,  875,  742,  689,  875,  689,  139,  875,  139,  743,
+,  743,  875,  875,  875,  743,   85,  875,  875,   85,
+,   85,   85,   85,   85,   85,  776,  875,  776,  732,
+,  732,  202,  875,  202,  777,  875,  777,  875,  875,
+,  777,  779,  875,  779,  875,  875,  875,  779,  781,
+,  781,  875,  875,  875,  781,  783,  875,  783,  784,
+,  784,  875,  875,  875,  784,  786,  875,  786,  875,
+,  875,  786,  807,  875,  807,  875,  875,  875,  807,
+,  875,  809,  875,  875,  875,  809,  811,  875,  811,
+,  875,  875,  811,  813,  875,  813,  875,  875,  875,
+,  815,  875,  815,  875,  875,  875,  815,  817,  875,
+,  875,  875,  875,  817,  609,  875,  609,  875,  875,
+,  609,  836,  875,  836,  875,  875,  875,  836,  671,
+,  671,  875,  875,  875,  671,  675,  875,  675,  875,
+,  875,  675,   85,  875,   85,  875,  875,  875,   85,
+,  875,  841,  875,  875,  875,  841,  139,  875,  139,
+,  875,  875,  139,  202,  875,  202,  875,  875,  875,
+,   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
+,   71,   71,   71,   71,   71,   71,   71,   71,   72,
+,   72,   72,   72,   72,   72,   72,   72,   72,   72,
+,   72,   72,   72,   72,   71,   73,   71,   71,   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,
+,   79,   79,  123,  124,   90,  141,   79,   79,   87,
+,   76,   80,   81,   82,   82,   82,   80,   82,   81,
+,   83,   83,   82,   91,   93,   87,  142,  146,   98,
+,   99,   99,   99,   99,   99,   99,  252,  887,   94,
+,   85,   96,   97,   85,  101,  161,  118,  143,   77,
+,   77,   77,  144,  147,  102,  103,   87,  104,  104,
+,  104,  105,  105,  119,   87,  120,  121,  148,  263,
+,  264,  254,  260,  183,  106,  195,   87,  159,  107,
+,  150,  151,  152,   87,  108,  109,  153,  154,  162,
+,  110,   87,  156,  157,  145,  163,  106,   87,  182,
+,  158,  164,  111,  206,   87,  263,   87,  264,   87,
+,  108,  194,   87,  109,  103,  250,  112,  112,  112,
+,  112,  112,   87,  169,  177,  170,  196,  193,   87,
+,  180,  165,  230,  106,  171,  166,  181,  113,  178,
+,  167,   87,  258,  114,  168,  179,  172,   87,  263,
+,  264,  248,   87,   87,  173,  106,  174,  249,  231,
+,  143,  116,  263,  176,  264,  144,  259,  317,  283,
+,  125,  280,  500,  249,  126,  127,   87,  128,  191,
+,  130,  256,  131,  249,  132,   87,  265,  257,  184,
+,  257,  248,   87,  133,  134,  135,  501,  188,  186,
+,  263,  187,  264,  271,   87,  189,  265,  145,  256,
+,  200,  201,  190,  257,  136,  200,  257,  137,  263,
+,  264,  192,  197,   81,   82,   82,   82,  197,   87,
+,  198,  202,  202,  202,  202,  202,  202,   80,   81,
+,   82,   82,   80,   87,  138,  139,  209,  210,  263,
+,  264,  209,  282,  211,  255,  263,  267,  264,  211,
+,   81,   82,   82,   82,   82,   87,  887,  212,  212,
+,  212,   82,   81,   83,   83,   83,   82,  887,  211,
+,   99,   99,   99,   99,   99,  242,  242,  242,  242,
+,  263,  263,  264,  264,  213,  143,  263,  211,  264,
+,  144,  375,  211,  211,   87,   87,  211,  211,   87,
+,   87,  286,  241,  887,  211,   87,   87,  211,  243,
+,  214,  211,  281,  215,  217,  278,  284,  285,  218,
+,  307,  298,  279,  220,  221,   87,  222,   87,  223,
+,   87,  887,   87,  309,  300,   87,   87,  224,  225,
+,  103,  303,  105,  105,  105,  105,  105,  105,   87,
+,   87,  301,  302,   87,  304,  308,  310,   87,  227,
+,  245,  228,  245,  306,   87,  246,  246,  246,  246,
+,  246,   87,  313,   87,  315,  244,   87,   87,  311,
+,   87,  106,   87,   87,   87,  323,   87,   87,  322,
+,  233,  233,  233,  233,  233,  233,  312,  333,  247,
+,  316,  328,  320,  318,   87,   87,  234,  235,  236,
+,  237,  236,   87,  324,   87,  325,  143,  335,  360,
+,  361,   87,   87,  238,  337,  326,  327,   87,  236,
+,  236,   87,  329,  237,  332,  236,  287,  288,  289,
+,  290,  291,  334,   87,  292,   87,  293,  407,  360,
+,  361,  294,  295,  296,   87,  297,  339,  360,  343,
+,   87,  200,  201,  338,  340,  346,  200,  341,   87,
+,  197,   81,   82,   82,   82,  197,  200,  201,  198,
+,  361,  200,  202,  202,  202,  202,  202,  202,  344,
+,  360,  347,  361,  344,  360,  345,  361,  202,  202,
+,  202,  202,  202,  209,  210,  378,  143,  361,  209,
+,  202,  202,  202,  202,  202,  352,  352,  352,  352,
+,   87,  361,  362,  360,  360,  361,  361,  360,  363,
+,  360,  360,  361,  361,  369,  369,  370,  369,  370,
+,   87,  371,  371,  371,  371,  371,  371,  373,  353,
+,   87,  263,  373,  264,  263,   87,  264,  369,  402,
+,  369,  234,  235,  236,  406,  237,  236,  388,  401,
+,   87,  373,   87,   87,  372,  390,  373,  105,  105,
+,  105,  105,  105,  236,  235,  236,  404,   87,  237,
+,  236,  403,  408,  388,  106,  246,  246,  246,  246,
+,  246,  391,   87,   87,   87,   87,   87,   87,  419,
+,  255,  425,  432,   87,  420,  434,  106,  376,  376,
+,  376,  376,  376,  381,  409,  413,  105,  105,  105,
+,  105,  105,   87,  234,  245,  236,  245,  237,  236,
+,  246,  246,  246,  246,  246,   87,  383,  410,  384,
+,  377,   87,  385,  411,  412,  236,   87,  236,  386,
+,  237,   87,  236,  112,  112,  112,  112,  112,  112,
+,  387,  415,  417,  418,  384,   87,  416,   87,  385,
+,   87,   87,   87,   87,   87,   87,   87,   87,  421,
+,  426,  433,   87,  437,   87,   87,  260,  423,  424,
+,   87,  436,  429,  428,  422,   87,  430,  431,  439,
+,  438,   87,   87,  446,  441,  440,  442,  443,   87,
+,   87,   87,   87,   87,  445,   87,   87,   87,   87,
+,  448,  447,   87,   87,  444,  449,  451,   87,  456,
+,  450,   87,   87,   87,  452,  455,  454,   87,  453,
+,  462,  460,  461,   87,   87,  458,  464,   87,  515,
+,  463,  465,  466,  344,  201,  201,   87,  887,  344,
+,  345,  199,  211,  211,  211,  211,  352,  352,  352,
+,  360,  360,  361,  361,  371,  371,  371,  371,  371,
+,  370,  569,  370,  492,  492,  371,  371,  371,  371,
+,  371,  887,   87,  493,  494,  477,  488,  488,  488,
+,  488,  488,  233,  233,  233,  233,  233,  233,  516,
+,  492,   87,  234,   87,  236,   87,  237,  236,  242,
+,  242,  242,  105,  105,  495,  381,  517,   87,   87,
+,  496,   87,  518,   87,  236,  374,  236,  519,  520,
+,  521,  236,  376,  376,  376,  376,  376,  376,  383,
+,  384,  375,  496,   87,  385,  522,  496,  497,  887,
+,  386,   87,  498,  498,  498,  498,  498,  498,   87,
+,  495,  526,  387,   87,  524,  377,  384,  523,  496,
+,  385,  383,   87,  384,   87,   87,  527,  385,   87,
+,  532,   87,   87,  502,   87,  499,   87,  535,  528,
+,  537,  530,  531,  533,   87,  387,   87,   87,  541,
+,  534,  538,   87,  385,   87,  536,   87,   87,   87,
+,  540,   87,   87,  546,   87,   87,   87,  544,  542,
+,  548,   87,   87,  547,  543,   87,   87,  549,   87,
+,   87,  552,   87,   87,  550,  556,  554,  551,   87,
+,   87,  553,  555,   87,   87,  557,   87,   87,  558,
+,   87,   87,  564,  560,  567,  563,  568,   87,  561,
+,  562,   87,  565,   87,   87,  571,   87,   87,  573,
+,  201,  492,  570,  576,  574,  572,  577,  211,  211,
+,  211,  493,   87,  575,  488,  488,  488,  488,  488,
+,  376,  376,  376,  376,  376,  376,   87,  492,   87,
+,  234,  595,  236,  595,  237,  236,  596,  596,  596,
+,  596,  596,  492,   87,  599,  492,  621,  489,   87,
+,  623,   87,  236,  490,  236,  598,  619,  237,   87,
+,  498,  498,  498,  498,  498,  498,  620,   87,  492,
+,  599,  492,  600,  600,  600,  600,  600,  600,   87,
+,  622,   87,  887,  625,  887,   87,  862,   87,  601,
+,  602,  497,  603,  602,  498,  498,  498,  498,  498,
+,  624,  628,   87,   87,  630,  604,   87,   87,   87,
+,  602,  633,  602,  626,  636,  603,  632,  602,  629,
+,   87,   87,  635,   87,   87,   87,  642,   87,   87,
+,  641,   87,   87,  640,   87,   87,  643,  647,  639,
+,   87,  887,   87,   87,   87,  638,   87,   87,  644,
+,  646,  648,  650,   87,   87,   87,  649,   87,  653,
+,   87,  652,   87,  654,  655,   87,   87,   87,   87,
+,  657,   87,  660,  659,  661,  664,   87,  658,   87,
+,  663,   87,   87,   87,  668,  665,  688,  688,  662,
+,  701,  702,  887,  887,   87,  667,  488,  488,  488,
+,  488,  488,  596,  596,  596,  596,  596,  596,  595,
+,  595,  704,   87,  596,  596,  596,  596,  596,  596,
+,  600,  600,  600,  600,  600,  703,  688,   87,  887,
+,  686,  686,  686,  686,  686,  686,  689,   87,  689,
+,   87,  689,  699,   87,  708,   87,  601,  706,  602,
+,  603,  602,  604,  707,   87,  700,  710,  709,  689,
+,  689,   87,  705,  687,   87,  689,   87,   87,  602,
+,  602,   87,  716,  603,  718,  602,  712,   87,   87,
+,   87,  711,   87,  714,   87,   87,  713,   87,  717,
+,   87,  721,  719,   87,  724,   87,   87,  722,  720,
+,   87,   87,   87,  725,   87,  731,  723,   87,  732,
+,   87,   87,  861,  728,  734,   87,  733,  730,   87,
+,   87,   87,  729,   87,   87,  751,  736,  686,  686,
+,  686,  686,  686,  600,  600,  600,  600,  600,  600,
+,   87,  755,   87,  601,  763,  602,  752,  603,  602,
+,   87,   87,  764,   87,  756,  754,  757,   87,  758,
+,  687,   87,   87,  759,  767,  602,  690,  602,  761,
+,  603,  766,  602,   87,  760,   87,  762,   87,  765,
+,  768,   87,  769,   87,   87,   87,   87,  770,   87,
+,   87,   87,   87,  771,   87,  774,   87,  772,   87,
+,  779,   87,   87,  795,   87,  780,  773,   87,   87,
+,   87,  775,  803,  777,  796,  778,  686,  686,  686,
+,  686,  686,  793,   87,  794,  799,   87,  798,   87,
+,   87,   87,   87,  797,  804,  805,  800,  806,   87,
+,   87,  802,  807,   87,   87,   87,  808,   87,   87,
+,   87,   87,   87,  809,  828,   87,   87,   87,  830,
+,  833,   87,   87,   87,  834,   87,  836,  810,  811,
+,  827,   87,  829,   87,  825,  832,  837,   87,   87,
+,  838,  839,   87,   87,  835,   87,   87,   87,  851,
+,  855,   87,  852,  840,   87,   87,   87,  853,  857,
+,   87,   87,   87,  854,  858,  859,   87,   87,  856,
+,   87,  863,  864,  865,   87,   87,  866,   87,  868,
+,  869,   87,   87,   87,  870,   87,   87,   87,  873,
+,  875,   87,  876,   87,   87,   87,  874,   87,  872,
+,   87,   87,  871,   87,  880,   87,   87,   87,  887,
+,  881,  887,  848,  877,  878,  886,  887,  847,  884,
+,  845,  882,  883,  887,  844,  885,   69,   69,   69,
+,   69,   69,   69,   69,   69,   69,   69,   69,   69,
+,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+,   75,   75,   78,   78,   78,   78,   78,   78,   78,
+,   78,   78,   78,   78,   78,   86,  887,  843,   86,
+,   86,   86,   86,   86,   86,  140,  842,   87,   87,
+,  140,  140,  140,  140,  140,  199,  199,  199,  199,
+,  199,  199,  199,  199,  199,  199,  199,  199,  204,
+,  887,  204,  824,  204,  204,  204,  204,  204,  208,
+,  208,  208,  823,  208,  208,  208,  208,  208,  208,
+,  208,  216,  887,  819,  216,  216,  216,  216,  216,
+,  216,  216,  887,  216,  239,  239,  239,  239,  239,
+,  239,  239,  239,  239,  239,  239,  239,  253,  253,
+,  253,  887,  815,  813,  253,  269,   87,   87,  269,
+,  269,  269,  269,  269,  269,  273,   87,  273,   87,
+,   87,  273,  275,   87,  275,   87,   87,   87,  275,
+,   87,  348,  887,  792,  790,  348,  350,  887,  350,
+,  787,  785,  350,  354,  783,  354,   87,   87,   87,
+,  356,   87,  356,   87,   87,   87,  356,  358,  749,
+,  746,  745,  743,  358,  365,  205,  365,  739,  738,
+,  365,  367,   87,  367,   87,   87,   87,  367,  239,
+,  239,  239,  239,  239,  239,  239,  239,  239,  239,
+,  239,  380,   87,  380,  382,  382,   87,  382,  382,
+,   87,  382,  253,  253,   87,  253,  392,   87,  392,
+,   87,   87,  392,  394,   87,  394,   87,   87,  697,
+,  396,  696,  396,  694,  692,  690,  396,  273,  598,
+,  398,  685,  398,  684,  682,  680,  398,  275,  678,
+,   86,  676,  674,   86,  672,   86,   86,   86,   86,
+,  199,  199,  199,  199,  199,  199,  199,  199,  199,
+,  199,  199,  199,  468,  468,  468,  468,  468,  468,
+,  468,  468,  468,  468,  468,  468,  469,  670,  469,
+,   87,   87,  469,  471,   87,  471,   87,   87,   87,
+,  473,   87,  473,   87,   87,   87,  473,  348,  617,
+,  475,  615,  475,  613,  611,  609,  475,  350,  607,
+,  478,  502,  478,  605,  605,  594,  478,  354,  593,
+,  480,  591,  480,  483,  483,  589,  480,  356,  587,
+,  482,  585,  482,  583,  581,  579,  482,  358,   87,
+,  484,   87,  484,   87,   87,   87,  484,  365,   87,
+,  486,   87,  486,   87,  514,  512,  486,  367,  510,
+,  491,  508,  491,  506,  491,  504,  491,  380,  490,
+,  487,  380,  485,  380,  382,  382,  361,  382,  382,
+,  361,  382,  503,  483,  503,  481,  479,  476,  503,
+,  474,  505,  472,  470,   87,  505,  507,   87,  507,
+,  400,  399,  507,  392,  397,  392,  509,  395,  509,
+,  270,  265,  509,  394,  264,  394,  511,  389,  511,
+,  252,  379,  511,  396,  379,  396,  513,  240,  513,
+,  368,  366,  513,  398,  364,  398,   86,  360,  359,
+,  357,   86,   86,   86,   86,   86,  468,  468,  468,
+,  468,  468,  468,  468,  468,  468,  468,  468,  468,
+,  355,  578,  351,  349,  205,  578,  469,  201,  469,
+,   87,  580,  277,  276,  274,  580,  471,  270,  471,
+,  265,  582,  268,  265,  263,  582,  473,  262,  473,
+,  261,  584,  240,  232,   85,  584,  475,   85,  475,
+,   87,  586,  205,  203,   85,  586,  478,  122,  478,
+,  117,  588,   87,  887,   70,  588,  480,   70,  480,
+,  887,  482,  887,  887,  887,  482,  590,  887,  590,
+,  887,  887,  590,  484,  887,  484,  592,  887,  592,
+,  887,  887,  592,  486,  887,  486,  491,  887,  491,
+,  491,  887,  491,  382,  887,  382,  887,  887,  887,
+,  606,  887,  606,  887,  887,  887,  606,  503,  887,
+,  608,  887,  608,  887,  887,  887,  608,  505,  887,
+,  610,  887,  610,  887,  887,  887,  610,  507,  887,
+,  612,  887,  612,  887,  887,  887,  612,  509,  887,
+,  614,  887,  614,  887,  887,  887,  614,  511,  887,
+,  616,  887,  616,  887,  887,  887,  616,  513,  887,
+,   86,  887,  887,   86,  887,   86,   86,   86,   86,
+,  669,  669,  669,  669,  669,  669,  669,  669,  669,
+,  669,  669,  669,  671,  887,  671,  887,  887,  887,
+,  578,  887,  578,  673,  887,  673,  887,  887,  887,
+,  580,  887,  580,  675,  887,  675,  887,  887,  887,
+,  582,  887,  582,  677,  887,  677,  887,  887,  887,
+,  584,  887,  584,  679,  887,  679,  887,  887,  887,
+,  586,  887,  586,  681,  887,  681,  887,  887,  887,
+,  588,  887,  588,  683,  887,  683,  887,  887,  887,
+,  590,  887,  590,   86,  887,   86,  887,  887,  887,
+,  592,  887,  592,  491,  887,  491,  887,  887,  887,
+,  691,  887,  691,  887,  887,  887,  691,  606,  887,
+,  693,  887,  693,  887,  887,  887,  693,  608,  887,
+,  695,  887,  695,  887,  887,  887,  695,  610,  887,
+,  140,  887,  140,  887,  887,  887,  140,  612,  887,
+,  698,  887,  698,  614,  887,  614,   86,  887,  887,
+,  887,   86,   86,   86,   86,   86,  616,  887,  616,
+,  669,  669,  669,  669,  669,  669,  669,  669,  669,
+,  669,  669,  737,  887,  737,  887,  887,  887,  737,
+,  887,  671,  204,  887,  204,  887,  887,  887,  204,
+,  887,  673,  740,  887,  740,  675,  887,  675,  204,
+,  887,  204,  887,  204,  204,  204,  204,  204,  677,
+,  677,  741,  887,  741,  679,  887,  679,  681,  887,
+,  742,  887,  742,  683,  887,  683,   86,  887,   86,
+,  887,  744,  887,  887,  887,  744,  691,  887,  691,
+,  887,  269,  887,  887,  887,  269,  693,  887,  693,
+,  887,  747,  695,  887,  695,  140,  887,  140,  748,
+,  748,  887,  887,  887,  748,   86,  887,  887,   86,
+,   86,   86,   86,   86,   86,  781,  887,  781,  737,
+,  737,  204,  887,  204,  782,  887,  782,  887,  887,
+,  782,  784,  887,  784,  887,  887,  887,  784,  786,
+,  786,  887,  887,  887,  786,  788,  887,  788,  789,
+,  789,  887,  887,  887,  789,  791,  887,  791,  887,
+,  887,  791,  812,  887,  812,  887,  887,  887,  812,
+,  887,  814,  887,  887,  887,  814,  816,  887,  816,
+,  887,  887,  816,  818,  887,  818,  887,  887,  887,
+,  820,  887,  820,  887,  887,  887,  820,  822,  887,
+,  887,  887,  887,  822,  616,  887,  616,  887,  887,
+,  616,  841,  887,  841,  887,  887,  887,  841,  677,
+,  677,  887,  887,  887,  677,  681,  887,  681,  887,
+,  887,  681,   86,  887,   86,  887,  887,  887,   86,
+,  887,  846,  887,  887,  887,  846,  140,  887,  140,
+,  887,  887,  140,  204,  887,  204,  887,  887,  887,
+,   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
     } ;
 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,    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,    2,    5,    5,    5,    5,    5,    5,    5,
+,    1,    1,    1,    1,    2,   16,   24,   16,   24,
+,   19,   19,    2,    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,    5,    5,    5,    5,    5,    5,
+,    5,    5,    5,    5,    5,    5,    7,    8,    9,
+,   37,   37,   20,   39,    9,   10,  874,    7,    8,
+,   13,   13,   13,   13,   13,   15,   15,   15,   15,
+,   15,   20,   25,   39,   42,   53,   28,   27,   28,
+,   28,   28,   28,   28,  108,  114,   25,   29,   25,
+,   27,   27,   29,   53,   35,    7,    8,    9,   10,
+,   42,   48,   29,   30,   40,   30,   30,   30,   30,
+,   30,   35,   61,   35,   35,   44,  869,   44,  108,
+,  868,   48,   30,   63,   61,   30,   56,   47,   45,
+,   45,   30,   30,   45,   45,   56,   45,   30,   55,
+,   45,   49,   40,   30,   45,   40,   49,   45,   47,
+,   47,   72,  125,   49,  125,   51,   55,   30,   86,
+,   30,   31,   55,   31,   31,   31,   31,   31,   31,
+,   51,  866,   51,   63,  153,   54,   58,   72,   50,
+,   31,   51,   50,   31,   86,   54,   57,   50,   58,
+,  153,   50,   54,  141,  156,   31,   58,   60,   57,
+,   59,   31,  126,   58,  126,   59,  156,   31,   57,
+,  865,   57,   67,   67,   52,   31,   38,   67,   59,
+,   38,   38,   52,   38,   52,   38,   38,   52,   38,
+,   38,   52,  113,   67,   67,   67,   67,   67,   67,
+,   38,   38,  128,   59,  128,  152,   59,   66,   66,
+,   66,   66,   66,  107,  152,   66,  113,  863,  862,
+,   59,  165,   38,   79,   79,   79,   79,   79,   79,
+,   81,   81,   81,   81,   81,   82,   82,   82,   82,
+,   82,  131,  165,  131,  103,  103,  103,  103,  106,
+,   38,   76,   76,  856,  106,  112,   76,  168,   76,
+,  133,  112,  133,   76,  102,  102,  102,  102,  102,
+,  130,  103,   76,   76,   76,   76,  103,  110,  168,
+,  106,  129,  130,   76,  130,  110,  104,  112,  104,
+,  104,  104,  104,  104,  149,  129,  102,  129,   76,
+,  136,   76,  136,  158,  115,  104,   76,   76,  109,
+,   76,   76,  155,  109,  132,  132,  149,  132,   76,
+,  104,   76,  115,   76,   76,   76,  104,   76,   84,
+,  115,  138,   84,   84,  155,  166,  109,   84,   84,
+,   84,  105,   84,  150,  105,  105,  105,  105,  105,
+,  151,   84,   84,   84,  134,  134,  134,  144,  166,
+,  157,  150,  144,  159,  167,  157,  157,  157,  151,
+,  157,   84,  161,  157,   84,  157,  105,  154,  160,
+,  157,  157,  157,  162,  157,  159,  855,  160,  162,
+,  169,  167,  170,  161,  161,  169,  163,  171,  172,
+,  144,  162,   84,   98,   98,   98,   98,   98,   98,
+,  174,  175,  171,  169,  170,  172,  179,  176,  185,
+,   98,  178,   98,   98,  180,  189,  182,  173,  187,
+,  174,  185,  186,  179,  188,   98,  178,  181,  175,
+,   98,   98,   98,  178,  182,   98,  183,   98,  181,
+,  191,  190,  186,  188,  184,  187,  528,  183,  181,
+,  192,  207,  207,  191,  190,  191,  207,  232,  189,
+,  203,  189,  190,  192,  183,  195,  195,  195,  195,
+,  195,  196,  196,  195,  528,  854,  196,  198,  198,
+,  232,  216,  198,  200,  200,  217,  203,  217,  200,
+,  200,  218,  196,  196,  196,  196,  196,  196,  198,
+,  198,  198,  198,  198,  200,  200,  200,  200,  200,
+,  210,  210,  210,  210,  219,  220,  221,  282,  221,
+,  222,  223,  222,  223,  224,  224,  224,  220,  219,
+,  219,  226,  227,  226,  227,  234,  235,  282,  233,
+,  233,  284,  210,  233,  233,  233,  233,  233,  233,
+,  239,  239,  277,  239,  239,  264,  234,  264,  234,
+,  265,  284,  265,  234,  242,  242,  242,  242,  242,
+,  277,  239,  239,  239,  246,  233,  239,  278,  239,
+,  280,  242,  279,  241,  243,  243,  243,  243,  243,
+,  254,  268,  276,  853,  281,  278,  242,  280,  279,
+,  246,  288,  242,  244,  244,  244,  244,  244,  244,
+,  253,  253,  253,  253,  253,  251,  254,  268,  287,
+,  283,  286,  244,  244,  245,  283,  245,  288,  295,
+,  245,  245,  245,  245,  245,  244,  287,  251,  849,
+,  244,  253,  244,  251,  286,  244,  295,  244,  289,
+,  258,  258,  258,  258,  258,  258,  285,  290,  292,
+,  294,  251,  293,  289,  291,  251,  297,  292,  301,
+,  299,  285,  303,  290,  290,  293,  298,  285,  285,
+,  302,  298,  258,  300,  297,  307,  304,  294,  301,
+,  300,  304,  305,  303,  303,  306,  308,  305,  302,
+,  309,  311,  312,  313,  307,  308,  309,  314,  313,
+,  311,  316,  314,  318,  315,  310,  317,  312,  320,
+,  321,  323,  324,  326,  325,  328,  318,  327,  329,
+,  316,  315,  322,  330,  317,  321,  327,  333,  331,
+,  326,  335,  337,  323,  325,  324,  333,  328,  336,
+,  337,  329,  339,  381,  338,  330,  331,  340,  340,
+,  341,  336,  340,  358,  340,  358,  341,  339,  348,
+,  348,  348,  349,  349,  349,  349,  359,  381,  359,
+,  846,  402,  334,  366,  366,  366,  366,  366,  366,
+,  397,  368,  402,  404,  368,  368,  368,  368,  368,
+,  348,  367,  367,  367,  367,  367,  367,  370,  370,
+,  370,  370,  370,  400,  398,  404,  435,  367,  376,
+,  367,  367,  371,  371,  371,  371,  371,  371,  376,
+,  398,  377,  400,  367,  378,  379,  435,  383,  367,
+,  367,  377,  412,  367,  376,  367,  372,  372,  372,
+,  372,  372,  399,  382,  371,  383,  378,  377,  378,
+,  412,  379,  378,  383,  380,  415,  380,  399,  378,
+,  380,  380,  380,  380,  380,  382,  401,  382,  372,
+,  378,  382,  403,  405,  378,  401,  408,  382,  378,
+,  411,  403,  405,  409,  410,  407,  416,  418,  414,
+,  413,  380,  406,  382,  417,  413,  409,  382,  408,
+,  410,  410,  411,  414,  421,  417,  418,  416,  423,
+,  414,  426,  427,  428,  419,  431,  429,  430,  421,
+,  423,  427,  429,  436,  431,  427,  437,  438,  439,
+,  425,  440,  430,  426,  433,  443,  428,  445,  441,
+,  446,  437,  448,  439,  449,  436,  450,  451,  455,
+,  452,  440,  443,  457,  633,  450,  460,  453,  458,
+,  445,  446,  448,  452,  453,  451,  449,  454,  456,
+,  457,  461,  633,  455,  454,  462,  456,  515,  460,
+,  461,  462,  471,  471,  471,  471,  456,  482,  482,
+,  482,  482,  482,  484,  484,  484,  484,  484,  484,
+,  513,  485,  487,  482,  489,  488,  482,  482,  486,
+,  486,  485,  487,  486,  486,  486,  486,  486,  486,
+,  513,  509,  510,  520,  482,  484,  482,  485,  487,
+,  489,  482,  491,  491,  491,  491,  491,  491,  509,
+,  514,  519,  516,  520,  519,  486,  492,  492,  492,
+,  492,  492,  517,  514,  512,  516,  521,  517,  525,
+,  522,  523,  492,  525,  842,  492,  492,  493,  841,
+,  518,  521,  493,  493,  493,  493,  493,  493,  492,
+,  524,  526,  523,  492,  527,  492,  529,  530,  492,
+,  492,  531,  526,  532,  533,  529,  536,  527,  535,
+,  538,  539,  532,  542,  535,  536,  540,  541,  531,
+,  544,  545,  542,  546,  547,  549,  554,  556,  539,
+,  561,  540,  541,  555,  552,  546,  538,  550,  545,
+,  549,  553,  550,  552,  556,  558,  555,  559,  554,
+,  553,  562,  561,  558,  563,  564,  560,  559,  565,
+,  563,  568,  613,  562,  564,  612,  617,  594,  565,
+,  698,  613,  612,  617,  568,  698,  567,  587,  587,
+,  587,  587,  587,  588,  588,  588,  588,  588,  588,
+,  594,  590,  596,  614,  590,  590,  590,  590,  590,
+,  593,  593,  593,  593,  593,  593,  614,  615,  616,
+,  589,  589,  589,  589,  589,  589,  595,  611,  622,
+,  595,  619,  611,  621,  615,  620,  589,  618,  620,
+,  589,  616,  593,  623,  624,  611,  621,  595,  619,
+,  622,  625,  589,  626,  595,  628,  629,  589,  623,
+,  627,  630,  589,  627,  589,  631,  624,  634,  625,
+,  635,  637,  628,  638,  644,  626,  630,  639,  632,
+,  645,  640,  650,  629,  647,  631,  696,  693,  651,
+,  640,  650,  659,  637,  644,  651,  638,  658,  662,
+,  661,  647,  659,  697,  840,  839,  658,  645,  693,
+,  697,  699,  696,  662,  680,  680,  680,  680,  680,
+,  684,  684,  684,  684,  684,  684,  694,  702,  705,
+,  680,  699,  700,  680,  680,  701,  694,  704,  701,
+,  708,  705,  709,  704,  707,  702,  680,  707,  706,
+,  711,  680,  684,  680,  710,  714,  680,  710,  680,
+,  713,  708,  718,  713,  715,  716,  717,  720,  714,
+,  709,  726,  715,  727,  712,  716,  720,  728,  730,
+,  731,  752,  751,  718,  753,  749,  730,  751,  754,
+,  750,  726,  723,  755,  753,  727,  752,  756,  728,
+,  738,  738,  738,  738,  738,  749,  757,  750,  758,
+,  755,  754,  759,  761,  763,  764,  761,  763,  767,
+,  773,  758,  764,  756,  765,  766,  788,  765,  766,
+,  791,  738,  792,  767,  793,  792,  797,  794,  795,
+,  794,  795,  768,  773,  798,  801,  799,  805,  791,
+,  790,  821,  802,  788,  797,  802,  793,  803,  806,
+,  803,  824,  823,  805,  822,  823,  825,  801,  804,
+,  824,  822,  821,  826,  806,  827,  826,  830,  833,
+,  830,  833,  835,  847,  825,  844,  847,  848,  834,
+,  845,  835,  827,  850,  844,  845,  850,  848,  851,
+,  858,  851,  852,  859,  860,  861,  859,  864,  861,
+,  867,  870,  871,  873,  860,  858,  838,  872,  837,
+,  870,  832,  831,  873,  829,  828,  820,  819,  818,
+,  817,  867,  816,  815,  871,  872,  876,  876,  876,
+,  876,  876,  876,  876,  876,  876,  876,  876,  876,
+,  877,  877,  877,  877,  877,  877,  877,  877,  877,
+,  877,  877,  878,  878,  878,  878,  878,  878,  878,
+,  878,  878,  878,  878,  878,  879,  814,  813,  879,
+,  879,  879,  879,  879,  879,  880,  811,  810,  809,
+,  880,  880,  880,  880,  880,  881,  881,  881,  881,
+,  881,  881,  881,  881,  881,  881,  881,  881,  882,
+,  807,  882,  800,  882,  882,  882,  882,  882,  883,
+,  883,  883,  789,  883,  883,  883,  883,  883,  883,
+,  883,  884,  786,  785,  884,  884,  884,  884,  884,
+,  884,  884,  784,  884,  885,  885,  885,  885,  885,
+,  885,  885,  885,  885,  885,  885,  885,  886,  886,
+,  886,  782,  781,  780,  886,  887,  779,  778,  887,
+,  887,  887,  887,  887,  887,  888,  776,  888,  775,
+,  772,  888,  889,  771,  889,  770,  769,  762,  889,
+,  760,  890,  748,  747,  746,  890,  891,  745,  891,
+,  743,  742,  891,  892,  741,  892,  740,  737,  736,
+,  893,  735,  893,  729,  725,  724,  893,  894,  722,
+,  721,  719,  703,  894,  895,  695,  895,  692,  687,
+,  895,  896,  681,  896,  671,  667,  665,  896,  897,
+,  897,  897,  897,  897,  897,  897,  897,  897,  897,
+,  897,  898,  663,  898,  899,  899,  660,  899,  899,
+,  657,  899,  900,  900,  656,  900,  901,  655,  901,
+,  653,  652,  901,  902,  649,  902,  648,  646,  643,
+,  903,  642,  903,  641,  636,  609,  903,  904,  605,
+,  905,  603,  905,  601,  599,  597,  905,  906,  591,
+,  907,  585,  583,  907,  581,  907,  907,  907,  907,
+,  908,  908,  908,  908,  908,  908,  908,  908,  908,
+,  908,  908,  908,  909,  909,  909,  909,  909,  909,
+,  909,  909,  909,  909,  909,  909,  910,  579,  910,
+,  575,  573,  910,  911,  571,  911,  570,  569,  566,
+,  912,  557,  912,  551,  548,  543,  912,  913,  537,
+,  914,  534,  914,  511,  507,  505,  914,  915,  503,
+,  916,  501,  916,  499,  497,  496,  916,  917,  495,
+,  918,  494,  918,  483,  480,  478,  918,  919,  477,
+,  920,  476,  920,  474,  472,  469,  920,  921,  467,
+,  922,  465,  922,  463,  459,  444,  922,  923,  442,
+,  924,  434,  924,  432,  424,  422,  924,  925,  420,
+,  926,  394,  926,  392,  926,  390,  926,  927,  388,
+,  387,  927,  386,  927,  928,  928,  373,  928,  928,
+,  363,  928,  929,  361,  929,  360,  356,  354,  929,
+,  352,  930,  350,  346,  344,  930,  931,  343,  931,
+,  332,  319,  931,  932,  296,  932,  933,  275,  933,
+,  271,  270,  933,  934,  269,  934,  935,  267,  935,
+,  261,  257,  935,  936,  256,  936,  937,  252,  937,
+,  248,  237,  937,  938,  236,  938,  939,  229,  228,
+,  225,  939,  939,  939,  939,  939,  940,  940,  940,
+,  940,  940,  940,  940,  940,  940,  940,  940,  940,
+,  215,  941,  213,  212,  211,  941,  942,  205,  942,
+,  204,  943,  202,  197,  177,  943,  944,  148,  944,
+,  146,  945,  145,  139,  137,  945,  946,  135,  946,
+,  127,  947,  124,  123,  119,  947,  948,  100,  948,
+,   97,  949,   94,   92,   85,  949,  950,   71,  950,
+,   69,  951,   65,   36,   33,  951,  952,   18,  952,
+,   11,  953,    4,    3,    0,  953,  954,    0,  954,
+,    0,    0,  954,  955,    0,  955,  956,    0,  956,
+,    0,    0,  956,  957,    0,  957,  958,    0,  958,
+,  958,    0,  958,  959,    0,  959,    0,    0,    0,
+,  960,    0,  960,    0,    0,    0,  960,  961,    0,
+,  962,    0,  962,    0,    0,    0,  962,  963,    0,
+,  964,    0,  964,    0,    0,    0,  964,  965,    0,
+,  966,    0,  966,    0,    0,    0,  966,  967,    0,
+,  968,    0,  968,    0,    0,    0,  968,  969,    0,
+,  970,    0,  970,    0,    0,    0,  970,  971,    0,
+,  972,    0,    0,  972,    0,  972,  972,  972,  972,
+,  973,  973,  973,  973,  973,  973,  973,  973,  973,
+,  973,  973,  973,  974,    0,  974,    0,    0,    0,
+,  975,    0,  975,  976,    0,  976,    0,    0,    0,
+,  977,    0,  977,  978,    0,  978,    0,    0,    0,
+,  979,    0,  979,  980,    0,  980,    0,    0,    0,
+,  981,    0,  981,  982,    0,  982,    0,    0,    0,
+,  983,    0,  983,  984,    0,  984,    0,    0,    0,
+,  985,    0,  985,  986,    0,  986,    0,    0,    0,
+,    5,    5,    5,    5,    5,    5,    5,    5,    7,
+,    9,   10,   37,   37,   20,   39,    9,   10,  886,
+,    8,   13,   13,   13,   13,   13,   13,   15,   15,
+,   15,   15,   15,   20,   25,   48,   39,   42,   28,
+,   28,   28,   28,   28,   28,   28,  109,  115,   25,
+,   25,   27,   27,   27,   29,   48,   35,   40,    7,
+,    9,   10,   40,   42,   29,   30,   47,   30,   30,
+,   30,   30,   30,   35,   57,   35,   35,   44,  126,
+,  126,  109,  115,   57,   30,   64,   56,   47,   30,
+,   45,   45,   45,   49,   30,   30,   45,   45,   49,
+,   30,   40,   45,   45,   40,   49,   30,   45,   56,
+,   45,   49,   30,   73,  885,  127,   53,  127,   51,
+,   30,   62,   55,   30,   31,  108,   31,   31,   31,
+,   31,   31,   50,   51,   53,   51,   64,   61,   54,
+,   55,   50,   87,   31,   51,   50,   55,   31,   54,
+,   50,   52,  114,   31,   50,   54,   52,  175,  129,
+,  129,  107,  154,  151,   52,   31,   52,  107,   87,
+,   60,   31,  132,   52,  132,   60,  114,  175,  154,
+,   38,  151,  385,  111,   38,   38,   58,   38,   60,
+,   38,  113,   38,  107,   38,   59,  130,  113,   58,
+,  116,  111,  164,   38,   38,   38,  385,   59,   58,
+,  130,   58,  130,  142,   60,   59,  131,   60,  116,
+,   68,   68,   59,  113,   38,   68,  116,   38,  131,
+,  131,   60,   67,   67,   67,   67,   67,   67,  877,
+,   67,   68,   68,   68,   68,   68,   68,   80,   80,
+,   80,   80,   80,  153,   38,   38,   77,   77,  134,
+,  134,   77,  153,   77,  110,  135,  135,  135,   77,
+,   82,   82,   82,   82,   82,  876,  243,   77,   77,
+,   77,   83,   83,   83,   83,   83,   83,  110,   77,
+,  103,  103,  103,  103,  103,  104,  104,  104,  104,
+,  133,  137,  133,  137,   77,  145,  139,   77,  139,
+,  145,  243,   77,   77,  152,  156,   77,   77,  155,
+,  150,  157,  103,  104,   77,  159,  168,   77,  104,
+,   77,   77,  152,   77,   85,  150,  155,  156,   85,
+,  166,  159,  150,   85,   85,  161,   85,  160,   85,
+,  162,  104,  167,  168,  161,  169,  163,   85,   85,
+,  105,  163,  105,  105,  105,  105,  105,  105,  873,
+,  171,  162,  162,  165,  163,  167,  169,  173,   85,
+,  106,   85,  106,  165,  172,  106,  106,  106,  106,
+,  106,  180,  171,  170,  173,  105,  176,  177,  170,
+,  181,  105,  174,  184,  187,  181,  182,  179,  180,
+,   99,   99,   99,   99,   99,   99,  170,  187,  106,
+,  174,  184,  179,  176,  183,  190,   99,   99,   99,
+,   99,   99,  189,  182,  186,  183,  191,  189,  218,
+,  218,  185,  188,   99,  190,  183,  183,  284,   99,
+,   99,  158,  185,   99,  186,   99,  158,  158,  158,
+,  158,  158,  188,  192,  158,  194,  158,  284,  219,
+,  219,  158,  158,  158,  193,  158,  192,  220,  194,
+,  191,  198,  198,  191,  192,  205,  198,  193,  872,
+,  197,  197,  197,  197,  197,  197,  200,  200,  197,
+,  221,  200,  198,  198,  198,  198,  198,  198,  202,
+,  223,  205,  223,  202,  221,  202,  221,  200,  200,
+,  200,  200,  200,  209,  209,  248,  338,  222,  209,
+,  202,  202,  202,  202,  202,  212,  212,  212,  212,
+,  309,  222,  224,  224,  225,  224,  225,  226,  226,
+,  228,  229,  228,  229,  234,  234,  235,  236,  235,
+,  279,  235,  235,  235,  235,  235,  235,  237,  212,
+,  338,  266,  237,  266,  267,  278,  267,  234,  279,
+,  236,  241,  241,  241,  283,  241,  241,  256,  278,
+,  281,  237,  282,  280,  235,  270,  237,  244,  244,
+,  244,  244,  244,  241,  241,  241,  281,  285,  241,
+,  241,  280,  285,  256,  244,  245,  245,  245,  245,
+,  245,  270,  288,  293,  286,  294,  300,  306,  293,
+,  244,  300,  306,  870,  294,  308,  244,  246,  246,
+,  246,  246,  246,  253,  286,  288,  255,  255,  255,
+,  255,  255,  287,  246,  247,  246,  247,  246,  246,
+,  247,  247,  247,  247,  247,  290,  253,  287,  253,
+,  246,  289,  253,  287,  287,  246,  292,  246,  253,
+,  246,  291,  246,  260,  260,  260,  260,  260,  260,
+,  253,  290,  292,  292,  253,  295,  291,  296,  253,
+,  299,  301,  302,  303,  304,  305,  307,  311,  295,
+,  301,  307,  310,  311,  312,  319,  260,  297,  299,
+,  314,  310,  304,  303,  296,  318,  305,  305,  313,
+,  312,  316,  317,  319,  315,  314,  316,  317,  320,
+,  323,  324,  326,  325,  318,  327,  328,  331,  329,
+,  322,  320,  332,  334,  317,  323,  325,  333,  330,
+,  324,  337,  339,  340,  326,  329,  328,  401,  327,
+,  337,  334,  335,  341,  343,  332,  340,  342,  401,
+,  339,  341,  342,  344,  344,  345,  460,  862,  344,
+,  344,  345,  352,  352,  352,  352,  353,  353,  353,
+,  362,  363,  362,  363,  370,  370,  370,  370,  370,
+,  372,  460,  372,  380,  381,  372,  372,  372,  372,
+,  372,  861,  402,  380,  381,  352,  371,  371,  371,
+,  371,  371,  374,  374,  374,  374,  374,  374,  402,
+,  381,  403,  371,  404,  371,  860,  371,  371,  375,
+,  375,  375,  375,  375,  383,  382,  403,  406,  405,
+,  383,  407,  404,  408,  371,  374,  371,  405,  406,
+,  407,  371,  376,  376,  376,  376,  376,  376,  382,
+,  382,  375,  387,  411,  382,  408,  383,  384,  386,
+,  382,  410,  384,  384,  384,  384,  384,  384,  409,
+,  387,  412,  382,  413,  410,  376,  382,  409,  387,
+,  382,  386,  414,  386,  416,  417,  413,  386,  418,
+,  417,  419,  422,  386,  420,  384,  427,  419,  414,
+,  421,  415,  416,  418,  423,  386,  425,  429,  427,
+,  418,  422,  430,  386,  431,  420,  432,  433,  434,
+,  425,  435,  437,  433,  439,  440,  441,  431,  429,
+,  435,  443,  444,  434,  430,  449,  445,  437,  447,
+,  450,  441,  451,  454,  439,  445,  443,  440,  452,
+,  453,  442,  444,  455,  456,  447,  457,  458,  449,
+,  461,  463,  455,  451,  458,  454,  459,  462,  452,
+,  453,  466,  456,  464,  467,  462,  525,  859,  463,
+,  468,  491,  461,  467,  464,  462,  468,  477,  477,
+,  477,  491,  515,  466,  488,  488,  488,  488,  488,
+,  490,  490,  490,  490,  490,  490,  519,  491,  521,
+,  488,  492,  488,  492,  488,  488,  492,  492,  492,
+,  492,  492,  494,  516,  495,  493,  519,  488,  855,
+,  521,  518,  488,  490,  488,  493,  516,  488,  529,
+,  497,  497,  497,  497,  497,  497,  518,  520,  494,
+,  495,  493,  498,  498,  498,  498,  498,  498,  523,
+,  520,  526,  848,  523,  847,  528,  846,  522,  498,
+,  498,  499,  498,  498,  499,  499,  499,  499,  499,
+,  522,  526,  524,  527,  528,  498,  531,  530,  532,
+,  498,  531,  498,  524,  534,  498,  530,  498,  527,
+,  535,  537,  533,  536,  538,  539,  541,  542,  547,
+,  539,  544,  541,  538,  545,  546,  542,  547,  537,
+,  551,  845,  549,  534,  552,  536,  554,  560,  544,
+,  546,  549,  551,  555,  557,  558,  550,  561,  555,
+,  562,  554,  565,  557,  558,  564,  567,  566,  568,
+,  561,  575,  565,  564,  566,  569,  571,  562,  574,
+,  568,  569,  620,  619,  575,  571,  601,  601,  567,
+,  619,  620,  844,  843,  622,  574,  594,  594,  594,
+,  594,  594,  595,  595,  595,  595,  595,  595,  597,
+,  597,  622,  621,  597,  597,  597,  597,  597,  597,
+,  600,  600,  600,  600,  600,  621,  602,  626,  842,
+,  596,  596,  596,  596,  596,  596,  603,  618,  603,
+,  624,  603,  618,  628,  626,  625,  596,  624,  596,
+,  596,  596,  600,  625,  627,  618,  628,  627,  603,
+,  603,  630,  623,  596,  631,  603,  632,  633,  596,
+,  596,  635,  634,  596,  636,  596,  630,  637,  638,
+,  644,  629,  639,  632,  641,  642,  631,  645,  635,
+,  646,  639,  637,  650,  642,  651,  656,  640,  638,
+,  653,  657,  636,  644,  665,  656,  641,  664,  657,
+,  667,  668,  841,  650,  665,  700,  664,  653,  699,
+,  702,  705,  651,  714,  837,  700,  668,  686,  686,
+,  686,  686,  686,  690,  690,  690,  690,  690,  690,
+,  708,  705,  703,  686,  714,  686,  702,  686,  686,
+,  704,  706,  715,  707,  706,  704,  707,  710,  708,
+,  686,  711,  717,  710,  718,  686,  690,  686,  712,
+,  686,  717,  686,  713,  711,  716,  713,  719,  716,
+,  719,  715,  720,  722,  723,  724,  725,  721,  728,
+,  718,  732,  735,  722,  733,  725,  736,  723,  756,
+,  735,  836,  754,  756,  759,  736,  724,  755,  760,
+,  761,  728,  764,  732,  757,  733,  743,  743,  743,
+,  743,  743,  754,  758,  755,  760,  762,  759,  763,
+,  769,  766,  768,  758,  766,  768,  761,  769,  772,
+,  764,  763,  770,  771,  773,  778,  771,  793,  795,
+,  798,  797,  796,  772,  797,  799,  800,  802,  799,
+,  803,  804,  806,  807,  804,  810,  807,  773,  778,
+,  796,  809,  798,  808,  793,  802,  808,  811,  826,
+,  809,  810,  827,  829,  806,  828,  803,  831,  828,
+,  831,  832,  829,  811,  834,  835,  839,  830,  835,
+,  840,  838,  849,  830,  838,  839,  853,  850,  832,
+,  852,  849,  850,  852,  854,  856,  853,  857,  856,
+,  857,  858,  863,  864,  858,  865,  866,  867,  865,
+,  867,  871,  868,  874,  875,  878,  866,  879,  864,
+,  882,  881,  863,  883,  878,  884,  833,  825,  824,
+,  879,  823,  822,  871,  874,  884,  821,  820,  882,
+,  818,  880,  881,  817,  816,  883,  888,  888,  888,
+,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+,  889,  889,  889,  889,  889,  889,  889,  889,  889,
+,  889,  889,  890,  890,  890,  890,  890,  890,  890,
+,  890,  890,  890,  890,  890,  891,  815,  814,  891,
+,  891,  891,  891,  891,  891,  892,  812,  805,  801,
+,  892,  892,  892,  892,  892,  893,  893,  893,  893,
+,  893,  893,  893,  893,  893,  893,  893,  893,  894,
+,  792,  894,  791,  894,  894,  894,  894,  894,  895,
+,  895,  895,  789,  895,  895,  895,  895,  895,  895,
+,  895,  896,  787,  786,  896,  896,  896,  896,  896,
+,  896,  896,  785,  896,  897,  897,  897,  897,  897,
+,  897,  897,  897,  897,  897,  897,  897,  898,  898,
+,  898,  783,  782,  781,  898,  899,  780,  779,  899,
+,  899,  899,  899,  899,  899,  900,  776,  900,  775,
+,  767,  900,  901,  765,  901,  753,  752,  751,  901,
+,  750,  902,  749,  748,  747,  902,  903,  746,  903,
+,  742,  741,  903,  904,  740,  904,  734,  730,  729,
+,  905,  727,  905,  726,  709,  701,  905,  906,  698,
+,  693,  691,  687,  906,  907,  677,  907,  673,  671,
+,  907,  908,  666,  908,  663,  662,  661,  908,  909,
+,  909,  909,  909,  909,  909,  909,  909,  909,  909,
+,  909,  910,  660,  910,  911,  911,  659,  911,  911,
+,  658,  911,  912,  912,  655,  912,  913,  654,  913,
+,  649,  648,  913,  914,  647,  914,  643,  616,  612,
+,  915,  610,  915,  608,  606,  604,  915,  916,  598,
+,  917,  592,  917,  590,  588,  586,  917,  918,  584,
+,  919,  582,  580,  919,  578,  919,  919,  919,  919,
+,  920,  920,  920,  920,  920,  920,  920,  920,  920,
+,  920,  920,  920,  921,  921,  921,  921,  921,  921,
+,  921,  921,  921,  921,  921,  921,  922,  577,  922,
+,  573,  570,  922,  923,  563,  923,  559,  556,  553,
+,  924,  548,  924,  543,  540,  517,  924,  925,  513,
+,  926,  511,  926,  509,  507,  505,  926,  927,  503,
+,  928,  502,  928,  501,  500,  489,  928,  929,  486,
+,  930,  484,  930,  483,  482,  480,  930,  931,  478,
+,  932,  475,  932,  473,  471,  469,  932,  933,  465,
+,  934,  448,  934,  446,  438,  436,  934,  935,  428,
+,  936,  426,  936,  424,  398,  396,  936,  937,  394,
+,  938,  392,  938,  391,  938,  390,  938,  939,  377,
+,  367,  939,  365,  939,  940,  940,  364,  940,  940,
+,  360,  940,  941,  358,  941,  356,  354,  350,  941,
+,  348,  942,  347,  346,  336,  942,  943,  321,  943,
+,  277,  275,  943,  944,  273,  944,  945,  272,  945,
+,  269,  268,  945,  946,  263,  946,  947,  259,  947,
+,  254,  251,  947,  948,  250,  948,  949,  239,  949,
+,  231,  230,  949,  950,  227,  950,  951,  217,  215,
+,  214,  951,  951,  951,  951,  951,  952,  952,  952,
+,  952,  952,  952,  952,  952,  952,  952,  952,  952,
+,  213,  953,  207,  206,  204,  953,  954,  199,  954,
+,  178,  955,  149,  147,  146,  955,  956,  140,  956,
+,  138,  957,  136,  128,  125,  957,  958,  124,  958,
+,  120,  959,  101,   98,   95,  959,  960,   93,  960,
+,   86,  961,   72,   70,   66,  961,  962,   36,  962,
+,   33,  963,   18,   11,    4,  963,  964,    3,  964,
+,    0,  965,    0,    0,    0,  965,  966,    0,  966,
+,    0,    0,  966,  967,    0,  967,  968,    0,  968,
+,    0,    0,  968,  969,    0,  969,  970,    0,  970,
+,  970,    0,  970,  971,    0,  971,    0,    0,    0,
+,  972,    0,  972,    0,    0,    0,  972,  973,    0,
+,  974,    0,  974,    0,    0,    0,  974,  975,    0,
+,  976,    0,  976,    0,    0,    0,  976,  977,    0,
+,  978,    0,  978,    0,    0,    0,  978,  979,    0,
+,  980,    0,  980,    0,    0,    0,  980,  981,    0,
+,  982,    0,  982,    0,    0,    0,  982,  983,    0,
+,  984,    0,    0,  984,    0,  984,  984,  984,  984,
+,  985,  985,  985,  985,  985,  985,  985,  985,  985,
+,  985,  985,  985,  986,    0,  986,    0,    0,    0,
 ,  987,    0,  987,  988,    0,  988,    0,    0,    0,
 ,  989,    0,  989,  990,    0,  990,    0,    0,    0,
+,  991,    0,  991,    0,    0,    0,  991,  992,    0,
+,  993,    0,  993,    0,    0,    0,  993,  994,    0,
+,  995,    0,  995,    0,    0,    0,  995,  996,    0,
+,  997,    0,  997,    0,    0,    0,  997,  998,    0,
+,  999,    0,  999, 1000,    0, 1000, 1001,    0,    0,
+,    0, 1001, 1001, 1001, 1001, 1001, 1002,    0, 1002,
+, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003,
+, 1003, 1003, 1004,    0, 1004,    0,    0,    0, 1004,
+,    0, 1005, 1006,    0, 1006,    0,    0,    0, 1006,
+,    0, 1007, 1008,    0, 1008, 1009,    0, 1009, 1010,
+,    0, 1010,    0, 1010, 1010, 1010, 1010, 1010, 1011,
+, 1011, 1012,    0, 1012, 1013,    0, 1013, 1014,    0,
+, 1015,    0, 1015, 1016,    0, 1016, 1017,    0, 1017,
+,    0, 1018,    0,    0,    0, 1018, 1019,    0, 1019,
+,    0, 1020,    0,    0,    0, 1020, 1021,    0, 1021,
+,    0, 1022, 1023,    0, 1023, 1024,    0, 1024, 1025,
+, 1025,    0,    0,    0, 1025, 1026,    0,    0, 1026,
+, 1026, 1026, 1026, 1026, 1026, 1027,    0, 1027, 1028,
+, 1028, 1029,    0, 1029, 1030,    0, 1030,    0,    0,
+, 1030, 1031,    0, 1031,    0,    0,    0, 1031, 1032,
+, 1032,    0,    0,    0, 1032, 1033,    0, 1033, 1034,
+, 1034,    0,    0,    0, 1034, 1035,    0, 1035,    0,
+,    0, 1035, 1036,    0, 1036,    0,    0,    0, 1036,
+,    0, 1037,    0,    0,    0, 1037, 1038,    0, 1038,
+,    0,    0, 1038, 1039,    0, 1039,    0,    0,    0,
+, 1040,    0, 1040,    0,    0,    0, 1040, 1041,    0,
+,    0,    0,    0, 1041, 1042,    0, 1042,    0,    0,
+,  991,    0,  991,  992,    0,  992,    0,    0,    0,
+,  993,    0,  993,  994,    0,  994,    0,    0,    0,
+,  995,    0,  995,  996,    0,  996,    0,    0,    0,
+,  997,    0,  997,  998,    0,  998,    0,    0,    0,
+,  999,    0,  999, 1000,    0, 1000,    0,    0,    0,
+, 1001,    0, 1001, 1002,    0, 1002,    0,    0,    0,
+, 1003,    0, 1003,    0,    0,    0, 1003, 1004,    0,
+, 1005,    0, 1005,    0,    0,    0, 1005, 1006,    0,
+, 1007,    0, 1007,    0,    0,    0, 1007, 1008,    0,
+, 1009,    0, 1009,    0,    0,    0, 1009, 1010,    0,
+, 1011,    0, 1011, 1012,    0, 1012, 1013,    0,    0,
+,    0, 1013, 1013, 1013, 1013, 1013, 1014,    0, 1014,
+, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015,
+, 1015, 1015, 1016,    0, 1016,    0,    0,    0, 1016,
+,    0, 1017, 1018,    0, 1018,    0,    0,    0, 1018,
+,    0, 1019, 1020,    0, 1020, 1021,    0, 1021, 1022,
+,    0, 1022,    0, 1022, 1022, 1022, 1022, 1022, 1023,
+, 1023, 1024,    0, 1024, 1025,    0, 1025, 1026,    0,
+, 1027,    0, 1027, 1028,    0, 1028, 1029,    0, 1029,
+,    0, 1030,    0,    0,    0, 1030, 1031,    0, 1031,
+,    0, 1032,    0,    0,    0, 1032, 1033,    0, 1033,
+,    0, 1034, 1035,    0, 1035, 1036,    0, 1036, 1037,
+, 1037,    0,    0,    0, 1037, 1038,    0,    0, 1038,
+, 1038, 1038, 1038, 1038, 1038, 1039,    0, 1039, 1040,
+, 1040, 1041,    0, 1041, 1042,    0, 1042,    0,    0,
 , 1042, 1043,    0, 1043,    0,    0,    0, 1043, 1044,
+, 1044,    0,    0,    0, 1044, 1045,    0, 1045,    0,
+,    0, 1045, 1046,    0, 1046,    0,    0,    0, 1046,
+,    0, 1047,    0,    0,    0, 1047, 1048,    0, 1048,
+,    0,    0, 1048, 1049,    0, 1049,    0,    0,    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
+, 1044,    0,    0,    0, 1044, 1045,    0, 1045, 1046,
+, 1046,    0,    0,    0, 1046, 1047,    0, 1047,    0,
+,    0, 1047, 1048,    0, 1048,    0,    0,    0, 1048,
+,    0, 1049,    0,    0,    0, 1049, 1050,    0, 1050,
+,    0,    0, 1050, 1051,    0, 1051,    0,    0,    0,
+, 1052,    0, 1052,    0,    0,    0, 1052, 1053,    0,
+,    0,    0,    0, 1053, 1054,    0, 1054,    0,    0,
+, 1054, 1055,    0, 1055,    0,    0,    0, 1055, 1056,
+, 1056,    0,    0,    0, 1056, 1057,    0, 1057,    0,
+,    0, 1057, 1058,    0, 1058,    0,    0,    0, 1058,
+,    0, 1059,    0,    0,    0, 1059, 1060,    0, 1060,
+,    0,    0, 1060, 1061,    0, 1061,    0,    0,    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
     } ;
 /* 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, 0, 1, 0, 1, 0, 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, 0, 0, 0, 1, 0, 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,
+, 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,
         };
+,     };
 static yy_state_type yy_last_accepting_state;
 …
  * 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"
 …
 #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;
 …
 #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 )
 …
 // 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
 …
 #line 1514 "Parser/lex.cc"
+#line 1531 "Parser/lex.cc"
 #define INITIAL 0
 …
         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) )
 …
+                                {
                                 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_cp;
+                        }
                 while ( yy_base[yy_current_state] != 2782 );
+                while ( yy_base[yy_current_state] != 2822 );
 yy_find_action:
 …
 /* rule 1 can match eol */
 YY_RULE_SETUP
 #line 139 "lex.ll"
+#line 141 "lex.ll"
+{
         /* " stop highlighting */
 …
 /* rule 2 can match eol */
 YY_RULE_SETUP
 #line 162 "lex.ll"
+#line 164 "lex.ll"
+;
         YY_BREAK
 …
 case 3:
 YY_RULE_SETUP
 #line 165 "lex.ll"
+#line 167 "lex.ll"
 { BEGIN COMMENT; }
         YY_BREAK
 …
 /* 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
 …
 /* rule 6 can match eol */
 YY_RULE_SETUP
 #line 170 "lex.ll"
+#line 172 "lex.ll"
+;
         YY_BREAK
 …
 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
 …
 /* rule 9 can match eol */
 YY_RULE_SETUP
 #line 175 "lex.ll"
+#line 177 "lex.ll"
 { NEWLINE_RETURN(); }
         YY_BREAK
 …
 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
 …
           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 ?
 …
         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):
 …
+                        {
                         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 = (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;
 …
 #define YYTABLES_NAME "yytables"
 #line 407 "lex.ll"
+#line 410 "lex.ll"

src/Parser/lex.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 void yyerror( const char * );
+#include <string>
+#include "ParseNode.h"
 // External declarations for information sharing between lexer and scanner
+#include "TypedefTable.h"
+class TypedefTable;
 extern TypedefTable typedefTable;

src/Parser/lex.ll

-              rc5833e8
+              r0f9e4403
  * 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
  */
 …
 #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;
 …
 #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 )
 …
 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}?
 …
 %%
                                    /* 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;
 …
 __const                 { KEYWORD_RETURN(CONST); }                              // GCC
 __const__               { KEYWORD_RETURN(CONST); }                              // GCC
-context                 { KEYWORD_RETURN(CONTEXT); }                    // CFA
 continue                { KEYWORD_RETURN(CONTINUE); }
 default                 { KEYWORD_RETURN(DEFAULT); }
 …
 _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
 …
 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
 …
 union                   { KEYWORD_RETURN(UNION); }
 unsigned                { KEYWORD_RETURN(UNSIGNED); }
+__builtin_va_list { KEYWORD_RETURN(VALIST); }                   // GCC
 void                    { KEYWORD_RETURN(VOID); }
 volatile                { KEYWORD_RETURN(VOLATILE); }

src/Parser/parser.cc

-              rc5833e8
+              r0f9e4403
 #include <cstdio>
 #include <stack>
+#include "lex.h"
+#include "parser.h"
+#include "ParseNode.h"
 #include "TypedefTable.h"
-#include "lex.h"
-#include "ParseNode.h"
 #include "TypeData.h"
 #include "LinkageSpec.h"
 …
 /* Line 268 of yacc.c  */
 #line 93 "Parser/parser.cc"
+#line 94 "Parser/parser.cc"
 /* Enabling traces.  */
 …
      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
 …
 #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
 …
 /* Line 293 of yacc.c  */
 #line 110 "parser.yy"
+#line 112 "parser.yy"
         Token tok;
 …
 /* Line 293 of yacc.c  */
 #line 359 "Parser/parser.cc"
+#line 362 "Parser/parser.cc"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 …
 /* Line 343 of yacc.c  */
 #line 371 "Parser/parser.cc"
+#line 374 "Parser/parser.cc"
 #ifdef short
 …
 /* 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)                                                \
 …
 ,     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,
 ,   109,   118,   120,   115,   121,   112,   123,     2,     2,
 ,     2,     2,     2,     2,     2,     2,     2,   116,   131,
 ,   130,   126,   129,     2,     2,     2,     2,     2,     2,
+,     2,     2,   118,     2,     2,     2,   125,   120,     2,
+,   110,   119,   121,   116,   122,   113,   124,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,   117,   132,
+,   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,
 ,   110,     2,   111,   127,     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,   113,   128,   114,   122,     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,
 …
 ,    86,    87,    88,    89,    90,    91,    92,    93,    94,
 ,    96,    97,    98,    99,   100,   101,   102,   103,   104,
 ,   106,   107
+,   106,   107,   108
 };
 …
 ,  1158,  1161,  1163,  1165,  1167,  1169,  1171,  1173,  1175,
 ,  1179,  1181,  1183,  1185,  1187,  1189,  1191,  1193,  1195,
 ,  1199,  1201,  1203,  1205,  1208,  1211,  1215,  1219,  1221,
 ,  1227,  1230,  1233,  1236,  1241,  1246,  1251,  1256,  1258,
 ,  1264,  1268,  1270,  1273,  1276,  1278,  1281,  1284,  1288,
 ,  1293,  1296,  1298,  1300,  1305,  1308,  1314,  1322,  1325,
 ,  1331,  1333,  1336,  1339,  1343,  1346,  1350,  1352,  1355,
 ,  1362,  1365,  1370,  1371,  1373,  1376,  1379,  1381,  1382,
 ,  1387,  1390,  1396,  1403,  1406,  1409,  1414,  1415,  1418,
 ,  1421,  1423,  1425,  1431,  1437,  1443,  1445,  1451,  1457,
 ,  1469,  1475,  1476,  1478,  1480,  1486,  1488,  1490,  1496,
 ,  1504,  1508,  1512,  1517,  1519,  1521,  1523,  1525,  1528,
 ,  1534,  1538,  1540,  1543,  1545,  1549,  1551,  1553,  1555,
 ,  1559,  1561,  1563,  1565,  1567,  1569,  1571,  1574,  1576,
 ,  1580,  1583,  1584,  1587,  1590,  1592,  1597,  1598,  1600,
 ,  1607,  1612,  1615,  1618,  1620,  1623,  1625,  1628,  1634,
 ,  1648,  1655,  1657,  1660,  1663,  1667,  1669,  1672,  1675,
 ,  1683,  1688,  1689,  1694,  1697,  1699,  1701,  1703,  1704,
 ,  1713,  1719,  1733,  1735,  1737,  1741,  1745,  1748,  1752,
 ,  1759,  1764,  1766,  1773,  1783,  1784,  1796,  1798,  1802,
 ,  1810,  1812,  1814,  1820,  1823,  1829,  1830,  1832,  1834,
 ,  1839,  1841,  1843,  1845,  1847,  1848,  1855,  1858,  1860,
 ,  1868,  1871,  1875,  1879,  1883,  1888,  1894,  1900,  1906,
 ,  1915,  1917,  1919,  1923,  1924,  1930,  1931,  1933,  1935,
 ,  1945,  1947,  1951,  1952,  1954,  1959,  1961,  1963,  1965,
 ,  1970,  1972,  1975,  1978,  1980,  1984,  1987,  1991,  1995,
 ,  2003,  2008,  2012,  2021,  2025,  2028,  2030,  2033,  2040,
 ,  2053,  2056,  2060,  2064,  2069,  2074,  2078,  2080,  2082,
 ,  2089,  2096,  2100,  2103,  2107,  2111,  2116,  2121,  2125,
 ,  2130,  2133,  2136,  2138,  2142,  2145,  2149,  2153,  2156,
 ,  2166,  2170,  2177,  2186,  2190,  2193,  2195,  2198,  2201,
 ,  2208,  2212,  2215,  2220,  2225,  2229,  2236,  2245,  2249,
 ,  2254,  2257,  2260,  2262,  2264,  2267,  2271,  2275,  2278,
 ,  2290,  2299,  2301,  2304,  2307,  2309,  2312,  2315,  2319,
 ,  2325,  2330,  2335,  2339,  2345,  2354,  2358,  2361,  2365,
 ,  2373,  2379,  2386,  2393,  2395,  2398,  2401,  2403,  2406,
 ,  2413,  2417,  2419,  2424,  2429,  2433,  2439,  2448,  2452,
 ,  2457,  2459,  2462,  2469,  2475,  2482,  2490,  2498,  2500,
 ,  2506,  2508,  2511,  2514,  2518,  2522,  2524,  2529,  2534,
 ,  2547,  2551,  2553,  2555,  2558,  2560,  2562,  2565,  2569,
 ,  2576,  2579,  2583,  2587,  2590,  2595,  2599,  2602,  2606,
 ,  2614,  2618,  2621,  2628,  2635,  2642,  2650,  2652,  2655,
 ,  2659,  2661,  2664,  2668,  2671,  2675,  2678,  2682,  2686,
 ,  2694,  2698,  2703,  2706,  2712,  2718,  2725,  2732,  2733,
 ,  2736
+,  1199,  1201,  1203,  1205,  1207,  1210,  1213,  1217,  1221,
+,  1227,  1229,  1232,  1235,  1238,  1243,  1248,  1253,  1258,
+,  1263,  1266,  1270,  1272,  1275,  1278,  1280,  1283,  1286,
+,  1292,  1295,  1298,  1300,  1302,  1307,  1310,  1311,  1318,
+,  1329,  1332,  1335,  1337,  1340,  1343,  1347,  1350,  1354,
+,  1359,  1363,  1366,  1369,  1374,  1375,  1377,  1380,  1383,
+,  1386,  1388,  1391,  1394,  1400,  1403,  1404,  1412,  1415,
+,  1421,  1424,  1425,  1427,  1429,  1431,  1437,  1443,  1449,
+,  1457,  1463,  1473,  1475,  1481,  1482,  1484,  1486,  1492,
+,  1496,  1502,  1508,  1510,  1514,  1518,  1523,  1525,  1527,
+,  1531,  1534,  1536,  1540,  1544,  1546,  1549,  1551,  1555,
+,  1559,  1561,  1563,  1565,  1567,  1569,  1571,  1573,  1575,
+,  1580,  1582,  1584,  1586,  1589,  1590,  1593,  1596,  1598,
+,  1604,  1606,  1609,  1613,  1618,  1621,  1624,  1626,  1629,
+,  1634,  1640,  1646,  1654,  1661,  1663,  1666,  1669,  1673,
+,  1678,  1681,  1686,  1689,  1694,  1695,  1700,  1703,  1705,
+,  1709,  1710,  1713,  1719,  1725,  1739,  1741,  1743,  1747,
+,  1754,  1758,  1762,  1765,  1770,  1772,  1779,  1789,  1790,
+,  1804,  1808,  1812,  1816,  1818,  1820,  1826,  1829,  1835,
+,  1838,  1840,  1844,  1845,  1847,  1849,  1851,  1853,  1854,
+,  1864,  1866,  1869,  1874,  1877,  1881,  1885,  1889,  1894,
+,  1906,  1912,  1919,  1921,  1923,  1925,  1929,  1930,  1936,
+,  1939,  1941,  1944,  1951,  1953,  1957,  1958,  1960,  1965,
+,  1969,  1971,  1973,  1976,  1978,  1981,  1984,  1986,  1990,
+,  1997,  2001,  2004,  2009,  2014,  2018,  2027,  2031,  2034,
+,  2039,  2046,  2055,  2059,  2062,  2066,  2070,  2075,  2080,
+,  2086,  2088,  2090,  2095,  2102,  2106,  2109,  2113,  2117,
+,  2127,  2131,  2134,  2136,  2139,  2142,  2144,  2148,  2151,
+,  2159,  2162,  2167,  2172,  2176,  2183,  2192,  2196,  2199,
+,  2204,  2207,  2210,  2214,  2218,  2221,  2226,  2231,  2235,
+,  2251,  2255,  2258,  2260,  2263,  2266,  2268,  2270,  2273,
+,  2281,  2284,  2289,  2296,  2305,  2307,  2310,  2313,  2315,
+,  2321,  2325,  2329,  2331,  2336,  2341,  2345,  2351,  2360,
+,  2367,  2371,  2373,  2379,  2385,  2392,  2399,  2401,  2404,
+,  2409,  2412,  2415,  2419,  2423,  2425,  2430,  2435,  2439,
+,  2454,  2458,  2460,  2463,  2465,  2468,  2475,  2481,  2488,
+,  2504,  2506,  2509,  2512,  2514,  2517,  2520,  2524,  2528,
+,  2535,  2540,  2544,  2553,  2557,  2559,  2561,  2564,  2566,
+,  2571,  2575,  2578,  2582,  2585,  2589,  2593,  2596,  2601,
+,  2608,  2612,  2615,  2620,  2624,  2627,  2634,  2641,  2648,
+,  2658,  2661,  2663,  2665,  2667,  2670,  2674,  2677,  2681,
+,  2688,  2692,  2697,  2700,  2704,  2709,  2712,  2718,  2724,
+,  2738,  2739,  2741,  2742
 };
 …
 static const yytype_int16 yyrhs[] =
+{
 ,     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,
 ,    -1,   108,   171,   109,    -1,   141,    -1,   142,   110,
 ,   162,   134,   111,    -1,   142,   108,   143,   109,    -1,
 ,   112,   138,    -1,   142,   112,   110,   133,   145,   134,
 ,    -1,   142,    84,   138,    -1,   142,    84,   110,   133,
 ,   134,   111,    -1,   142,    85,    -1,   142,    86,    -1,
 ,   271,   109,   113,   275,   368,   114,    -1,   142,   113,
 ,   114,    -1,   144,    -1,   143,   115,   144,    -1,    -1,
 ,    -1,   138,   116,   162,    -1,   110,   133,   162,   134,
 ,   116,   162,    -1,   110,   133,   162,   115,   165,   134,
 ,   116,   162,    -1,   146,    -1,   145,   115,   146,    -1,
 ,    -1,   138,   112,   146,    -1,   138,   112,   110,   133,
 ,   134,   111,    -1,   138,    84,   146,    -1,   138,    84,
 ,   133,   145,   134,   111,    -1,   142,    -1,   135,    -1,
 ,    -1,    85,   147,    -1,    86,   147,    -1,    39,   149,
       -1,   148,   149,    -1,   117,   149,    -1,   118,   149,    -1,
 ,   147,    -1,    36,   108,   271,   109,    -1,    37,   108,
 ,   115,   138,   109,    -1,    75,    -1,    75,   108,   272,
 ,    -1,    75,   108,   144,   109,    -1,    65,   147,    -1,
 ,   108,   271,   109,    -1,    93,   138,    -1,   119,    -1,
 ,    -1,   121,    -1,   122,    -1,   147,    -1,   108,   271,
 ,   149,    -1,   108,   271,   109,   164,    -1,   149,    -1,
 ,   118,   149,    -1,   150,   123,   149,    -1,   150,   124,
 ,    -1,   150,    -1,   151,   120,   150,    -1,   151,   121,
 ,    -1,   151,    -1,   152,    87,   151,    -1,   152,    88,
 ,    -1,   152,    -1,   153,   125,   152,    -1,   153,   126,
 ,    -1,   153,    89,   152,    -1,   153,    90,   152,    -1,
 ,    -1,   154,    91,   153,    -1,   154,    92,   153,    -1,
 ,    -1,   155,   119,   154,    -1,   155,    -1,   156,   127,
 ,    -1,   156,    -1,   157,   128,   156,    -1,   157,    -1,
 ,    93,   157,    -1,   158,    -1,   159,    94,   158,    -1,
 ,    -1,   159,   129,   167,   116,   160,    -1,   159,   129,
 ,   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,
 ,   133,   162,   134,   111,    -1,   110,   133,   115,   165,
 ,   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,
 ,   162,    -1,    -1,   167,    -1,   170,    -1,   171,    -1,
 ,    -1,   176,    -1,   188,    -1,   190,    -1,   191,    -1,
 ,    -1,   127,   142,   113,   143,   114,   131,    -1,   138,
 ,   308,   169,    -1,   113,   114,    -1,   113,   133,   133,
 ,   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,
 ,   167,   109,   169,    -1,    40,   108,   167,   109,   169,
 ,   169,    -1,    42,   108,   167,   109,   181,    -1,    42,
 ,   167,   109,   113,   133,   203,   182,   114,    -1,    52,
 ,   167,   109,   181,    -1,    52,   108,   167,   109,   113,
 ,   203,   184,   114,    -1,   161,    -1,   161,    95,   161,
       -1,   306,    -1,   177,    -1,   178,   115,   177,    -1,    43,
 ,   116,    -1,    44,   116,    -1,   179,    -1,   180,   179,
       -1,   180,   169,    -1,    -1,   183,    -1,   180,   174,    -1,
 ,   180,   174,    -1,    -1,   185,    -1,   180,   187,    -1,
 ,   174,   186,    -1,   185,   180,   187,    -1,   185,   180,
 ,   186,    -1,    -1,   187,    -1,    55,    -1,    55,   131,
       -1,    46,   108,   167,   109,   169,    -1,    45,   169,    46,
 ,   167,   109,   131,    -1,    47,   108,   133,   189,   109,
 ,    -1,   168,   134,   131,   168,   131,   168,    -1,   210,
 ,   131,   168,    -1,    50,   138,   131,    -1,    50,   118,
 ,   131,    -1,    49,   131,    -1,    49,   138,   131,    -1,
 ,   131,    -1,    48,   138,   131,    -1,    51,   168,   131,
       -1,    60,   163,   131,    -1,    61,   163,   131,    -1,    61,
 ,    62,   162,   131,    -1,    56,   171,   192,    -1,    56,
 ,   194,    -1,    56,   171,   192,   194,    -1,   193,    -1,
 ,   108,    95,   109,   171,    -1,   193,    57,   108,    95,
 ,   171,    -1,    58,   108,    95,   109,   171,    -1,   193,
 ,   108,    95,   109,   171,    -1,    57,   108,   133,   133,
 ,   134,   109,   171,   134,    -1,   193,    57,   108,   133,
 ,   195,   134,   109,   171,   134,    -1,    58,   108,   133,
 ,   195,   134,   109,   171,   134,    -1,   193,    58,   108,
 ,   133,   195,   134,   109,   171,   134,    -1,    59,   171,
       -1,   223,    -1,   223,   305,    -1,   223,   353,    -1,   362,
 ,    -1,   362,    -1,    63,   197,   108,   140,   109,   131,
       -1,    63,   197,   108,   140,   116,   198,   109,   131,    -1,
 ,   197,   108,   140,   116,   198,   116,   198,   109,   131,
       -1,    63,   197,   108,   140,   116,   198,   116,   198,   116,
 ,   109,   131,    -1,    63,   197,    50,   108,   140,   116,
 ,   198,   116,   201,   116,   202,   109,   131,    -1,    -1,
 ,    -1,    -1,   199,    -1,   200,    -1,   199,   115,   200,
       -1,   140,   108,   161,   109,    -1,   110,   161,   111,   140,
 ,   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,
 ,   209,   131,    -1,   208,    28,   209,   131,    -1,   270,
       -1,   209,   115,   270,    -1,   211,    -1,   220,    -1,   212,
 ,   131,    -1,   217,   134,   131,    -1,   214,   134,   131,
       -1,   289,   134,   131,    -1,   292,   134,   131,    -1,   213,
 ,    -1,   229,   213,   273,    -1,   212,   134,   115,   133,
 ,   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,
 ,   133,   268,    -1,   110,   111,   268,   108,   133,   256,
 ,   109,    -1,   366,   268,   108,   133,   256,   134,   109,
       -1,   216,   268,   108,   133,   256,   134,   109,    -1,   110,
 ,   258,   134,   111,    -1,   110,   133,   258,   134,   115,
 ,   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,
 ,    -1,   223,     3,   305,    -1,   223,     3,   225,   305,
       -1,     3,   138,   130,   162,    -1,   219,   134,   115,   133,
 ,   130,   162,    -1,   221,   134,   131,    -1,   218,   134,
 ,    -1,   219,   134,   131,    -1,   238,   134,   131,    -1,
 ,   305,   307,   273,    -1,   221,   115,   308,   305,   307,
 ,    -1,   234,    -1,   238,    -1,   240,    -1,   279,    -1,
 ,    -1,   239,    -1,   241,    -1,   280,    -1,    -1,   225,
       -1,   226,    -1,   225,   226,    -1,   227,    -1,   310,    -1,
 ,    -1,    12,    -1,    11,    -1,    14,    -1,    66,    -1,
       -1,    13,   108,   228,   282,   109,    -1,   230,    -1,   225,
 ,    -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,
+,     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,
+,    -1,   109,   172,   110,    -1,   142,    -1,   143,   111,
+,   163,   135,   112,    -1,   143,   109,   144,   110,    -1,
+,   113,   139,    -1,   143,   113,   111,   134,   146,   135,
+,    -1,   143,    85,   139,    -1,   143,    85,   111,   134,
+,   135,   112,    -1,   143,    86,    -1,   143,    87,    -1,
+,   274,   110,   114,   278,   371,   115,    -1,   143,   114,
+,   115,    -1,   145,    -1,   144,   116,   145,    -1,    -1,
+,    -1,   139,   117,   163,    -1,   111,   134,   163,   135,
+,   117,   163,    -1,   111,   134,   163,   116,   166,   135,
+,   117,   163,    -1,   147,    -1,   146,   116,   147,    -1,
+,    -1,   139,   113,   147,    -1,   139,   113,   111,   134,
+,   135,   112,    -1,   139,    85,   147,    -1,   139,    85,
+,   134,   146,   135,   112,    -1,   143,    -1,   136,    -1,
+,    -1,    86,   148,    -1,    87,   148,    -1,    40,   150,
+      -1,   149,   150,    -1,   118,   150,    -1,   119,   150,    -1,
+,   148,    -1,    37,   109,   274,   110,    -1,    38,   109,
+,   116,   139,   110,    -1,    76,    -1,    76,   109,   275,
+,    -1,    76,   109,   145,   110,    -1,    66,   148,    -1,
+,   109,   274,   110,    -1,    94,   139,    -1,   120,    -1,
+,    -1,   122,    -1,   123,    -1,   148,    -1,   109,   274,
+,   150,    -1,   109,   274,   110,   165,    -1,   150,    -1,
+,   119,   150,    -1,   151,   124,   150,    -1,   151,   125,
+,    -1,   151,    -1,   152,   121,   151,    -1,   152,   122,
+,    -1,   152,    -1,   153,    88,   152,    -1,   153,    89,
+,    -1,   153,    -1,   154,   126,   153,    -1,   154,   127,
+,    -1,   154,    90,   153,    -1,   154,    91,   153,    -1,
+,    -1,   155,    92,   154,    -1,   155,    93,   154,    -1,
+,    -1,   156,   120,   155,    -1,   156,    -1,   157,   128,
+,    -1,   157,    -1,   158,   129,   157,    -1,   158,    -1,
+,    94,   158,    -1,   159,    -1,   160,    95,   159,    -1,
+,    -1,   160,   130,   168,   117,   161,    -1,   160,   130,
+,   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,
+,   134,   163,   135,   112,    -1,   111,   134,   116,   166,
+,   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,
+,   163,    -1,    -1,   168,    -1,   171,    -1,   172,    -1,
+,    -1,   177,    -1,   189,    -1,   191,    -1,   192,    -1,
+,    -1,   128,   143,   114,   144,   115,   132,    -1,   139,
+,   311,   170,    -1,   114,   115,    -1,   114,   134,   134,
+,   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,
+,   168,   110,   170,    -1,    41,   109,   168,   110,   170,
+,   170,    -1,    43,   109,   168,   110,   182,    -1,    43,
+,   168,   110,   114,   134,   204,   183,   115,    -1,    53,
+,   168,   110,   182,    -1,    53,   109,   168,   110,   114,
+,   204,   185,   115,    -1,   162,    -1,   162,    96,   162,
+      -1,   309,    -1,   178,    -1,   179,   116,   178,    -1,    44,
+,   117,    -1,    45,   117,    -1,   180,    -1,   181,   180,
+      -1,   181,   170,    -1,    -1,   184,    -1,   181,   175,    -1,
+,   181,   175,    -1,    -1,   186,    -1,   181,   188,    -1,
+,   175,   187,    -1,   186,   181,   188,    -1,   186,   181,
+,   187,    -1,    -1,   188,    -1,    56,    -1,    56,   132,
+      -1,    47,   109,   168,   110,   170,    -1,    46,   170,    47,
+,   168,   110,   132,    -1,    48,   109,   134,   190,   110,
+,    -1,   169,   135,   132,   169,   132,   169,    -1,   211,
+,   132,   169,    -1,    51,   139,   132,    -1,    51,   119,
+,   132,    -1,    50,   132,    -1,    50,   139,   132,    -1,
+,   132,    -1,    49,   139,   132,    -1,    52,   169,   132,
+      -1,    61,   164,   132,    -1,    62,   164,   132,    -1,    62,
+,    63,   163,   132,    -1,    57,   172,   193,    -1,    57,
+,   195,    -1,    57,   172,   193,   195,    -1,   194,    -1,
+,   109,    96,   110,   172,    -1,   194,    58,   109,    96,
+,   172,    -1,    59,   109,    96,   110,   172,    -1,   194,
+,   109,    96,   110,   172,    -1,    58,   109,   134,   134,
+,   135,   110,   172,   135,    -1,   194,    58,   109,   134,
+,   196,   135,   110,   172,   135,    -1,    59,   109,   134,
+,   196,   135,   110,   172,   135,    -1,   194,    59,   109,
+,   134,   196,   135,   110,   172,   135,    -1,    60,   172,
+      -1,   224,    -1,   224,   308,    -1,   224,   356,    -1,   365,
+,    -1,   365,    -1,    64,   198,   109,   141,   110,   132,
+      -1,    64,   198,   109,   141,   117,   199,   110,   132,    -1,
+,   198,   109,   141,   117,   199,   117,   199,   110,   132,
+      -1,    64,   198,   109,   141,   117,   199,   117,   199,   117,
+,   110,   132,    -1,    64,   198,    51,   109,   141,   117,
+,   199,   117,   202,   117,   203,   110,   132,    -1,    -1,
+,    -1,    -1,   200,    -1,   201,    -1,   200,   116,   201,
+      -1,   141,   109,   162,   110,    -1,   111,   162,   112,   141,
+,   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,
+,   210,   132,    -1,   209,    29,   210,   132,    -1,   273,
+      -1,   210,   116,   273,    -1,   212,    -1,   221,    -1,   213,
+,   132,    -1,   218,   135,   132,    -1,   215,   135,   132,
+      -1,   292,   135,   132,    -1,   295,   135,   132,    -1,   214,
+,    -1,   230,   214,   276,    -1,   213,   135,   116,   134,
+,   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,
+,   134,   271,    -1,   111,   112,   271,   109,   134,   259,
+,   110,    -1,   369,   271,   109,   134,   259,   135,   110,
+      -1,   217,   271,   109,   134,   259,   135,   110,    -1,   111,
+,   261,   135,   112,    -1,   111,   134,   261,   135,   116,
+,   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,
+,    -1,   224,     3,   308,    -1,   224,     3,   226,   308,
+      -1,     3,   139,   131,   163,    -1,   220,   135,   116,   134,
+,   131,   163,    -1,   222,   135,   132,    -1,   219,   135,
+,    -1,   220,   135,   132,    -1,   239,   135,   132,    -1,
+,   308,   310,   276,    -1,   222,   116,   311,   308,   310,
+,    -1,   235,    -1,   239,    -1,   241,    -1,   282,    -1,
+,    -1,   240,    -1,   242,    -1,   283,    -1,    -1,   226,
+      -1,   227,    -1,   226,   227,    -1,   228,    -1,   313,    -1,
+,    -1,    12,    -1,    11,    -1,    14,    -1,    67,    -1,
+      -1,    13,   109,   229,   285,   110,    -1,   231,    -1,   226,
+,    -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,
+,   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,
+,   242,    -1,   239,   226,    -1,   241,    -1,   229,   241,
+      -1,   240,   231,    -1,   240,   231,   225,    -1,    73,    -1,
+,    73,    -1,   241,   226,    -1,   243,    -1,   253,    -1,
+,   113,   245,   114,    -1,   244,   270,    -1,   244,   270,
+,   245,   114,    -1,   244,   108,   288,   109,   113,   245,
+,    -1,   244,   281,    -1,    30,   308,    -1,    31,   308,
+      -1,   246,    -1,   245,   246,    -1,   247,   131,    -1,    39,
+,   131,    -1,   248,   131,    -1,    39,   248,   131,    -1,
+,    -1,   362,   270,    -1,   247,   115,   270,    -1,   247,
+,    -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,
+,   113,   254,   368,   114,    -1,   252,   270,   113,   254,
+,   114,    -1,   252,   270,    -1,   270,   255,    -1,   254,
+,   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,
+,    95,    -1,   263,    -1,   259,   134,   115,   133,   263,
+      -1,   258,   134,   115,   133,   263,    -1,   258,   134,   115,
+,   259,   134,   115,   133,   263,    -1,   264,    -1,   259,
+,   115,   133,   264,    -1,    -1,   261,    -1,   262,    -1,
+,   134,   115,   133,    95,    -1,   266,    -1,   265,    -1,
+,   134,   115,   133,   266,    -1,   262,   134,   115,   133,
+,    -1,   265,    -1,   358,   268,   369,    -1,   366,   268,
+,    -1,   225,   366,   268,   369,    -1,   215,    -1,   266,
+      -1,   358,    -1,   366,    -1,   225,   366,    -1,   367,    -1,
+,   332,   369,    -1,   222,   336,   369,    -1,   222,    -1,
+,   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,
+,   341,    -1,    -1,   130,   274,    -1,   106,   274,    -1,
+,    -1,   113,   275,   368,   114,    -1,    -1,   274,    -1,
+,   274,    -1,   275,   115,   274,    -1,   275,   115,   276,
+,    -1,   277,   116,    -1,   270,   116,    -1,   278,    -1,
+,   278,    -1,    79,    -1,   112,   270,    -1,   110,   133,
+,   134,   111,    -1,   110,   133,   306,   134,   111,    -1,
+,   133,   161,    95,   161,   134,   111,    -1,   112,   110,
+,   145,   134,   111,    -1,   280,    -1,   229,   280,    -1,
+,   231,    -1,   279,   231,   225,    -1,   281,    -1,   225,
+,    -1,   280,   226,    -1,    74,   108,   288,   109,    -1,
+,   369,    -1,   282,   115,   283,   369,    -1,    -1,   285,
+,   284,   286,    -1,   223,   332,    -1,    32,    -1,    34,
+      -1,    33,    -1,    -1,   286,   287,    -1,   128,   270,   108,
+,   109,    -1,   128,   113,   133,   294,   114,    -1,   128,
+,   133,   282,   134,   109,   113,   133,   294,   114,   108,
+,   109,    -1,   272,    -1,   162,    -1,   288,   115,   272,
+      -1,   288,   115,   162,    -1,    32,   290,    -1,   230,    32,
+,    -1,   289,   115,   290,    -1,   291,   286,    -1,   291,
+,   130,   272,    -1,   270,    -1,   269,   108,   133,   282,
+,   109,    -1,    35,   270,   108,   133,   282,   134,   109,
+,   114,    -1,    -1,    35,   270,   108,   133,   282,   134,
+,   113,   293,   294,   114,    -1,   295,    -1,   294,   133,
+,    -1,   296,   134,   131,    -1,   297,   134,   131,    -1,
+,    -1,   215,    -1,   296,   134,   115,   133,   268,    -1,
+,   305,    -1,   297,   134,   115,   133,   305,    -1,    -1,
+,    -1,   301,    -1,   299,   133,   301,    -1,    -1,   299,
+      -1,   210,    -1,   303,    -1,   196,    -1,    -1,     5,    81,
+,   113,   300,   114,    -1,    39,   301,    -1,   304,    -1,
+,   171,    -1,   323,   133,   205,   171,    -1,   214,   171,
+      -1,   222,   319,   171,    -1,   225,   319,   171,    -1,   229,
+,   171,    -1,   229,   225,   319,   171,    -1,   222,   323,
+,   205,   171,    -1,   225,   323,   133,   205,   171,    -1,
+,   323,   133,   205,   171,    -1,   229,   225,   323,   133,
+,   171,    -1,   314,    -1,   319,    -1,   327,    -1,   161,
+,   161,    -1,    -1,    63,   108,   140,   109,   308,    -1,
+      -1,   309,    -1,   310,    -1,   309,   310,    -1,    38,   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,
+,    -1,   317,   308,    -1,   318,   308,    -1,   136,    -1,
+,   315,   109,    -1,   118,   314,    -1,   118,   225,   314,
+      -1,   108,   316,   109,    -1,   315,   345,    -1,   108,   316,
+,   345,    -1,   108,   317,   109,   346,    -1,   108,   317,
+,    -1,   108,   316,   109,   108,   133,   260,   134,   109,
+      -1,   108,   318,   109,    -1,   320,   308,    -1,   321,    -1,
+,   308,    -1,   315,   108,   133,   260,   134,   109,    -1,
+,   321,   109,   108,   133,   260,   134,   109,    -1,   108,
+,   109,    -1,   118,   319,    -1,   118,   225,   319,    -1,
+,   321,   109,    -1,   108,   321,   109,   345,    -1,   108,
+,   109,   346,    -1,   108,   322,   109,    -1,   324,    -1,
+,    -1,   326,    -1,   315,   108,   267,   109,    -1,   108,
+,   109,   108,   267,   109,    -1,   108,   324,   109,    -1,
+,   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,
+,   308,    -1,   331,   308,    -1,   337,    -1,   108,   328,
+,    -1,   118,   327,    -1,   118,   225,   327,    -1,   108,
+,   109,    -1,   328,   345,    -1,   108,   329,   109,   345,
+      -1,   108,   330,   109,   346,    -1,   108,   330,   109,    -1,
+,   108,   133,   260,   134,   109,    -1,   108,   329,   109,
+,   133,   260,   134,   109,    -1,   108,   331,   109,    -1,
+,   308,    -1,   333,    -1,   334,   308,    -1,   335,   308,
+      -1,   118,   332,    -1,   118,   225,   332,    -1,   108,   333,
+,    -1,   315,   351,    -1,   108,   333,   109,   345,    -1,
+,   334,   109,   346,    -1,   108,   334,   109,    -1,   315,
+,   133,   260,   134,   109,    -1,   108,   333,   109,   108,
+,   260,   134,   109,    -1,   108,   335,   109,    -1,   337,
+,    -1,   338,    -1,   339,   308,    -1,   340,   308,    -1,
+,    -1,    74,    -1,   118,   336,    -1,   118,   225,   336,
+      -1,   108,   338,   109,    -1,   337,   351,    -1,   108,   338,
+,   351,    -1,   337,   108,   133,   260,   134,   109,    -1,
+,   338,   109,   108,   133,   260,   134,   109,    -1,   342,
+      -1,   343,   308,    -1,   344,   308,    -1,   118,    -1,   118,
+,    -1,   118,   341,    -1,   118,   225,   341,    -1,   108,
+,   109,    -1,   345,    -1,   108,   342,   109,   345,    -1,
+,   343,   109,   346,    -1,   108,   343,   109,    -1,   108,
+,   260,   134,   109,    -1,   108,   342,   109,   108,   133,
+,   134,   109,    -1,   108,   344,   109,    -1,   110,   111,
+      -1,   110,   111,   346,    -1,   346,    -1,   110,   133,   162,
+,   111,    -1,   110,   133,   118,   134,   111,    -1,   346,
+,   133,   162,   134,   111,    -1,   346,   110,   133,   118,
+,   111,    -1,   348,    -1,   349,   308,    -1,   350,   308,
+      -1,   118,    -1,   118,   225,    -1,   118,   347,    -1,   118,
+,   347,    -1,   108,   348,   109,    -1,   351,    -1,   108,
+,   109,   351,    -1,   108,   349,   109,   346,    -1,   108,
+,   109,    -1,   108,   133,   260,   134,   109,    -1,   108,
+,   109,   108,   133,   260,   134,   109,    -1,   108,   350,
+,    -1,   352,    -1,   352,   346,    -1,   346,    -1,   110,
+,    -1,   110,   133,   225,   118,   134,   111,    -1,   110,
+,   225,   134,   111,    -1,   110,   133,   225,   162,   134,
+,    -1,   110,   133,     7,   224,   162,   134,   111,    -1,
+,   133,   225,     7,   162,   134,   111,    -1,   354,    -1,
+,   308,    -1,   356,   308,    -1,   118,    -1,   118,   225,
+      -1,   118,   353,    -1,   118,   225,   353,    -1,   108,   354,
+,    -1,   345,    -1,   108,   354,   109,   345,    -1,   108,
+,   109,   346,    -1,   108,   355,   109,    -1,   108,   354,
+,   108,   133,   260,   134,   109,    -1,   108,   356,   109,
+      -1,   358,    -1,   366,    -1,   225,   366,    -1,   359,    -1,
+,    -1,   118,   223,    -1,   225,   118,   223,    -1,   118,
+,    -1,   225,   118,   367,    -1,   118,   357,    -1,   225,
+,   357,    -1,   110,   111,   223,    -1,   361,   223,    -1,
+,   111,   346,   223,    -1,   361,   346,   223,    -1,   346,
+,    -1,   110,   111,   359,    -1,   361,   359,    -1,   110,
+,   346,   359,    -1,   361,   346,   359,    -1,   346,   359,
+      -1,   110,   133,   225,   118,   134,   111,    -1,   110,   133,
+,   162,   134,   111,    -1,   110,   133,   229,   162,   134,
+,    -1,   110,   133,   229,   225,   162,   134,   111,    -1,
+,    -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,
+,    -1,   110,   111,   223,    -1,   110,   111,   346,   223,
+      -1,   346,   223,    -1,   110,   111,   364,    -1,   110,   111,
+,   364,    -1,   346,   364,    -1,   110,   133,   259,   134,
+,    -1,   110,   111,   108,   256,   109,    -1,   366,   108,
+,   256,   134,   109,    -1,   216,   108,   133,   256,   134,
+,    -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,
+,   232,    -1,   235,   232,   226,    -1,   235,   232,   236,
+      -1,   237,    -1,   225,   238,   225,    -1,   234,    -1,   226,
+,    -1,   237,   227,    -1,   237,   234,    -1,    28,   109,
+,   110,    -1,    28,   109,   168,   110,    -1,    78,   109,
+,   110,    -1,    78,   109,   168,   110,    -1,   240,    -1,
+,   240,    -1,   239,   232,    -1,   239,   232,   226,    -1,
+,    -1,   226,   243,    -1,   240,   227,    -1,   242,    -1,
+,   242,    -1,   241,   232,    -1,   241,   232,   226,    -1,
+,    -1,   226,    74,    -1,   242,   227,    -1,   244,    -1,
+,    -1,   246,   114,   247,   115,    -1,   246,   273,    -1,
+      -1,   246,   273,   245,   114,   247,   115,    -1,   246,   109,
+,   110,   114,   247,   115,    -1,   246,   284,    -1,    31,
+,    -1,    32,   311,    -1,   248,    -1,   247,   248,    -1,
+,   132,    -1,    40,   249,   132,    -1,   250,   132,    -1,
+,   250,   132,    -1,   365,    -1,   365,   273,    -1,   249,
+,   273,    -1,   249,   116,    -1,   224,   251,    -1,   250,
+,   311,   251,    -1,    -1,   253,    -1,   317,   252,    -1,
+,   252,    -1,   356,    -1,    -1,   253,    -1,   117,   162,
+      -1,    30,   311,    -1,   254,   114,   257,   371,   115,    -1,
+,   273,    -1,    -1,   254,   273,   256,   114,   257,   371,
+,    -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,
+,    96,    -1,   261,   135,   116,   134,    96,    -1,   266,
+      -1,   262,   135,   116,   134,   266,    -1,   261,   135,   116,
+,   266,    -1,   261,   135,   116,   134,   262,   135,   116,
+,   266,    -1,   267,    -1,   262,   135,   116,   134,   267,
+      -1,    -1,   264,    -1,   265,    -1,   265,   135,   116,   134,
+,    -1,   269,    -1,   268,    -1,   265,   135,   116,   134,
+,    -1,   265,   135,   116,   134,   268,    -1,   268,    -1,
+,   271,   372,    -1,   369,   271,   372,    -1,   226,   369,
+,   372,    -1,   216,    -1,   269,    -1,   361,    -1,   369,
+      -1,   226,   369,    -1,   370,    -1,   223,   335,   372,    -1,
+,   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,
+,    -1,   370,    -1,   224,    -1,   224,   344,    -1,    -1,
+,   277,    -1,   107,   277,    -1,   163,    -1,   114,   278,
+,   115,    -1,    -1,   277,    -1,   279,   277,    -1,   278,
+,   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,
+,   134,   309,   135,   112,    -1,   111,   134,   162,    96,
+,   135,   112,    -1,   113,   111,   134,   146,   135,   112,
+      -1,   283,    -1,   230,   283,    -1,   282,   232,    -1,   282,
+,   226,    -1,   284,    -1,   226,   284,    -1,   283,   227,
+      -1,    75,   109,   291,   110,    -1,   286,   372,    -1,   285,
+,   286,   372,    -1,    -1,   288,   273,   287,   289,    -1,
+,   335,    -1,    33,    -1,    35,    -1,    34,    -1,    -1,
+,   290,    -1,   129,   273,   109,   291,   110,    -1,   129,
+,   134,   297,   115,    -1,   129,   109,   134,   285,   135,
+,   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,
+,    -1,   294,   289,    -1,   294,   289,   131,   275,    -1,
+,    -1,   272,   109,   134,   285,   135,   110,    -1,    36,
+,   109,   134,   285,   135,   110,   114,   115,    -1,    -1,
+,   273,   109,   134,   285,   135,   110,   114,   296,   297,
+,    -1,   298,    -1,   297,   134,   298,    -1,   299,   135,
+,    -1,   300,   135,   132,    -1,   214,    -1,   216,    -1,
+,   135,   116,   134,   271,    -1,   224,   308,    -1,   300,
+,   116,   134,   308,    -1,    -1,   302,    -1,   304,    -1,
+,   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,
+,   206,   172,    -1,   215,   172,    -1,   223,   322,   172,
+      -1,   226,   322,   172,    -1,   230,   322,   172,    -1,   230,
+,   322,   172,    -1,   223,   326,   134,   206,   172,    -1,
+,   326,   134,   206,   172,    -1,   230,   326,   134,   206,
+,    -1,   230,   226,   326,   134,   206,   172,    -1,   317,
+      -1,   322,    -1,   330,    -1,   162,   123,   162,    -1,    -1,
+,   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,
+,   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,
+,   317,    -1,   119,   226,   317,    -1,   109,   319,   110,
+      -1,   318,   348,    -1,   109,   319,   110,   348,    -1,   109,
+,   110,   349,    -1,   109,   320,   110,    -1,   109,   319,
+,   109,   134,   263,   135,   110,    -1,   109,   321,   110,
+      -1,   323,   311,    -1,   324,    -1,   325,   311,    -1,   318,
+,   134,   263,   135,   110,    -1,   109,   324,   110,   109,
+,   263,   135,   110,    -1,   109,   323,   110,    -1,   119,
+,    -1,   119,   226,   322,    -1,   109,   324,   110,    -1,
+,   324,   110,   348,    -1,   109,   325,   110,   349,    -1,
+,   325,   110,    -1,   327,    -1,   328,    -1,   329,    -1,
+,   109,   270,   110,    -1,   109,   328,   110,   109,   270,
+,    -1,   109,   327,   110,    -1,   119,   326,    -1,   119,
+,   326,    -1,   109,   328,   110,    -1,   109,   328,   110,
+,    -1,   109,   329,   110,   349,    -1,   109,   329,   110,
+      -1,   331,   311,    -1,   332,    -1,   333,   311,    -1,   334,
+,    -1,   340,    -1,   109,   331,   110,    -1,   119,   330,
+      -1,   119,   226,   330,    -1,   109,   332,   110,    -1,   331,
+,    -1,   109,   332,   110,   348,    -1,   109,   333,   110,
+,    -1,   109,   333,   110,    -1,   331,   109,   134,   263,
+,   110,    -1,   109,   332,   110,   109,   134,   263,   135,
+,    -1,   109,   334,   110,    -1,   318,   311,    -1,   336,
+      -1,   337,   311,    -1,   338,   311,    -1,   119,   335,    -1,
+,   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,
+,    -1,   109,   336,   110,   109,   134,   263,   135,   110,
+      -1,   109,   338,   110,    -1,   340,   311,    -1,   341,    -1,
+,   311,    -1,   343,   311,    -1,    74,    -1,    75,    -1,
+,   339,    -1,   119,   226,   339,    -1,   109,   341,   110,
+      -1,   340,   354,    -1,   109,   341,   110,   354,    -1,   340,
+,   134,   263,   135,   110,    -1,   109,   341,   110,   109,
+,   263,   135,   110,    -1,   345,    -1,   346,   311,    -1,
+,   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,
+,   347,   110,    -1,   111,   112,    -1,   111,   112,   349,
+      -1,   349,    -1,   111,   134,   163,   135,   112,    -1,   111,
+,   119,   135,   112,    -1,   349,   111,   134,   163,   135,
+,    -1,   349,   111,   134,   119,   135,   112,    -1,   351,
+      -1,   352,   311,    -1,   353,   311,    -1,   119,    -1,   119,
+,    -1,   119,   350,    -1,   119,   226,   350,    -1,   109,
+,   110,    -1,   354,    -1,   109,   351,   110,   354,    -1,
+,   352,   110,   349,    -1,   109,   352,   110,    -1,   109,
+,   263,   135,   110,    -1,   109,   351,   110,   109,   134,
+,   135,   110,    -1,   109,   353,   110,    -1,   355,    -1,
+,   349,    -1,   349,    -1,   111,   112,    -1,   111,   134,
+,   119,   135,   112,    -1,   111,   134,   226,   135,   112,
+      -1,   111,   134,   226,   163,   135,   112,    -1,   111,   134,
+,   225,   163,   135,   112,    -1,   111,   134,   226,     7,
+,   135,   112,    -1,   357,    -1,   358,   311,    -1,   359,
+,    -1,   119,    -1,   119,   226,    -1,   119,   356,    -1,
+,   226,   356,    -1,   109,   357,   110,    -1,   348,    -1,
+,   357,   110,   348,    -1,   109,   358,   110,   349,    -1,
+,   358,   110,    -1,   109,   357,   110,   109,   134,   263,
+,   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,
+,    -1,   119,   360,    -1,   226,   119,   360,    -1,   111,
+,   224,    -1,   364,   224,    -1,   111,   112,   349,   224,
+      -1,   364,   349,   224,    -1,   349,   224,    -1,   111,   112,
+,    -1,   364,   362,    -1,   111,   112,   349,   362,    -1,
+,   349,   362,    -1,   349,   362,    -1,   111,   134,   226,
+,   135,   112,    -1,   111,   134,   226,   163,   135,   112,
+      -1,   111,   134,   230,   163,   135,   112,    -1,   111,   134,
+,   226,   163,   135,   112,    -1,   369,    -1,   226,   369,
+      -1,   366,    -1,   367,    -1,   368,    -1,   119,   224,    -1,
+,   119,   224,    -1,   119,   370,    -1,   226,   119,   370,
+      -1,   119,   365,    -1,   226,   119,   365,    -1,   111,   112,
+,    -1,   111,   112,   349,   224,    -1,   349,   224,    -1,
+,   112,   367,    -1,   111,   112,   349,   367,    -1,   349,
+,    -1,   111,   134,   262,   135,   112,    -1,   111,   112,
+,   259,   110,    -1,   369,   109,   134,   259,   135,   110,
+      -1,   217,   109,   134,   259,   135,   110,    -1,    -1,   116,
+      -1,    -1,   131,   163,    -1
 };
 …
 static const yytype_uint16 yyrline[] =
+{
 ,   290,   290,   296,   305,   306,   307,   311,   312,   313,
 ,   318,   322,   323,   327,   328,   332,   333,   339,   341,
 ,   345,   350,   351,   357,   361,   363,   364,   366,   367,
 ,   371,   373,   381,   382,   388,   389,   390,   395,   397,
 ,   403,   407,   411,   413,   415,   417,   422,   425,   427,
 ,   431,   433,   435,   437,   439,   445,   447,   449,   451,
 ,   455,   457,   459,   461,   466,   467,   468,   469,   473,
 ,   476,   481,   482,   484,   486,   491,   492,   494,   499,
 ,   502,   507,   508,   510,   512,   514,   519,   520,   522,
 ,   528,   533,   534,   539,   540,   545,   546,   551,   552,
 ,   558,   560,   562,   567,   572,   573,   575,   577,   583,
 ,   590,   592,   594,   596,   601,   602,   607,   608,   609,
 ,   611,   612,   613,   614,   615,   616,   620,   621,   627,
 ,   634,   635,   636,   637,   638,   639,   640,   641,   642,
 ,   658,   660,   670,   671,   676,   678,   680,   682,   686,
 ,   692,   697,   700,   702,   704,   709,   711,   719,   720,
 ,   726,   727,   732,   733,   738,   739,   743,   748,   749,
 ,   755,   761,   762,   766,   768,   770,   772,   778,   779,
 ,   784,   788,   790,   792,   797,   799,   804,   806,   810,
 ,   817,   820,   824,   826,   830,   832,   839,   841,   843,
 ,   854,   856,   858,   860,   865,   867,   869,   871,   876,
 ,   890,   895,   897,   902,   906,   908,   910,   912,   914,
 ,   921,   927,   928,   932,   933,   938,   940,   946,   947,
 ,   954,   956,   963,   965,   969,   970,   975,   977,   981,
 ,   986,   988,   992,   993,   997,   998,  1002,  1003,  1018,
 ,  1020,  1021,  1022,  1026,  1031,  1038,  1048,  1053,  1058,
 ,  1071,  1076,  1081,  1086,  1094,  1116,  1121,  1128,  1130,
 ,  1142,  1147,  1158,  1163,  1168,  1173,  1178,  1187,  1192,
 ,  1201,  1202,  1203,  1209,  1214,  1222,  1223,  1224,  1225,
 ,  1230,  1231,  1232,  1237,  1238,  1247,  1248,  1253,  1254,
 ,  1261,  1263,  1265,  1267,  1270,  1269,  1281,  1282,  1284,
 ,  1295,  1300,  1304,  1306,  1308,  1310,  1312,  1314,  1316,
 ,  1323,  1325,  1327,  1329,  1331,  1333,  1335,  1337,  1339,
 ,  1343,  1345,  1351,  1352,  1354,  1356,  1358,  1363,  1364,
 ,  1371,  1373,  1375,  1380,  1382,  1384,  1386,  1391,  1392,
 ,  1396,  1401,  1402,  1404,  1409,  1410,  1412,  1414,  1419,
 ,  1423,  1428,  1429,  1433,  1435,  1437,  1439,  1441,  1446,
 ,  1453,  1455,  1460,  1461,  1463,  1464,  1469,  1470,  1472,
 ,  1479,  1481,  1487,  1488,  1490,  1493,  1496,  1501,  1502,
 ,  1512,  1516,  1518,  1520,  1525,  1527,  1533,  1534,  1542,
 ,  1547,  1548,  1549,  1551,  1553,  1560,  1561,  1563,  1565,
 ,  1571,  1577,  1578,  1582,  1583,  1588,  1589,  1590,  1592,
 ,  1601,  1603,  1606,  1608,  1612,  1613,  1614,  1616,  1618,
 ,  1627,  1635,  1636,  1645,  1647,  1652,  1653,  1654,  1658,
 ,  1660,  1664,  1665,  1666,  1670,  1671,  1672,  1677,  1678,
 ,  1680,  1686,  1687,  1689,  1694,  1695,  1700,  1701,  1702,
 ,  1704,  1719,  1720,  1725,  1726,  1734,  1736,  1738,  1741,
 ,  1745,  1768,  1769,  1771,  1773,  1778,  1779,  1781,  1786,
 ,  1792,  1798,  1797,  1801,  1805,  1807,  1809,  1815,  1816,
 ,  1826,  1828,  1833,  1835,  1836,  1838,  1843,  1845,  1847,
 ,  1854,  1859,  1864,  1872,  1878,  1877,  1891,  1892,  1897,
 ,  1902,  1907,  1912,  1920,  1925,  1936,  1937,  1948,  1949,
 ,  1956,  1960,  1961,  1962,  1965,  1964,  1975,  1980,  1985,
 ,  2000,  2006,  2012,  2018,  2024,  2032,  2038,  2046,  2052,
 ,  2062,  2063,  2067,  2071,  2073,  2078,  2079,  2083,  2084,
 ,  2095,  2096,  2099,  2101,  2102,  2106,  2107,  2108,  2109,
 ,  2145,  2146,  2148,  2153,  2158,  2163,  2165,  2167,  2172,
 ,  2176,  2178,  2183,  2185,  2195,  2197,  2198,  2203,  2205,
 ,  2212,  2214,  2216,  2221,  2223,  2225,  2234,  2235,  2236,
 ,  2242,  2244,  2249,  2251,  2253,  2258,  2260,  2262,  2277,
 ,  2280,  2282,  2287,  2288,  2293,  2295,  2297,  2302,  2304,
 ,  2308,  2313,  2315,  2317,  2327,  2329,  2330,  2332,  2337,
 ,  2341,  2346,  2348,  2350,  2352,  2357,  2359,  2361,  2392,
 ,  2395,  2397,  2402,  2407,  2415,  2417,  2419,  2424,  2426,
 ,  2433,  2447,  2448,  2450,  2455,  2457,  2459,  2461,  2463,
 ,  2469,  2471,  2473,  2478,  2480,  2482,  2488,  2490,  2492,
 ,  2498,  2500,  2502,  2516,  2517,  2519,  2524,  2526,  2528,
 ,  2532,  2537,  2538,  2540,  2542,  2547,  2549,  2551,  2557,
 ,  2560,  2569,  2572,  2574,  2577,  2579,  2581,  2594,  2595,
 ,  2602,  2604,  2606,  2608,  2610,  2615,  2616,  2618,  2620,
 ,  2627,  2635,  2636,  2637,  2642,  2643,  2647,  2649,  2651,
 ,  2655,  2657,  2664,  2666,  2668,  2670,  2672,  2674,  2676,
 ,  2680,  2682,  2687,  2689,  2691,  2696,  2722,  2723,  2725,
 ,  2730,  2734,  2736,  2738,  2740,  2742,  2744,  2751,  2753,
 ,  2757,  2759,  2761,  2766,  2771,  2773,  2775,  2793,  2795,
 ,  2801
+,   292,   292,   298,   307,   308,   309,   313,   314,   315,
+,   320,   324,   325,   329,   330,   334,   335,   341,   343,
+,   347,   352,   353,   359,   363,   365,   366,   368,   369,
+,   373,   375,   383,   384,   390,   391,   392,   397,   399,
+,   405,   409,   413,   415,   417,   419,   424,   427,   429,
+,   433,   435,   437,   439,   441,   447,   449,   451,   453,
+,   457,   459,   461,   463,   468,   469,   470,   471,   475,
+,   478,   483,   484,   486,   488,   493,   494,   496,   501,
+,   504,   509,   510,   512,   514,   516,   521,   522,   524,
+,   530,   535,   536,   541,   542,   547,   548,   553,   554,
+,   560,   562,   564,   569,   574,   575,   577,   579,   585,
+,   592,   594,   596,   598,   603,   604,   609,   610,   611,
+,   613,   614,   615,   616,   617,   618,   622,   623,   629,
+,   636,   637,   638,   639,   640,   641,   642,   643,   644,
+,   660,   662,   672,   673,   678,   680,   682,   684,   688,
+,   694,   699,   702,   704,   706,   711,   713,   721,   722,
+,   728,   729,   734,   735,   740,   741,   745,   750,   751,
+,   757,   763,   764,   768,   770,   772,   774,   780,   781,
+,   786,   790,   792,   794,   799,   801,   806,   808,   812,
+,   819,   822,   826,   828,   832,   834,   841,   843,   845,
+,   856,   858,   860,   862,   867,   869,   871,   873,   878,
+,   892,   897,   899,   904,   908,   910,   912,   914,   916,
+,   923,   929,   930,   934,   935,   940,   942,   948,   949,
+,   956,   958,   965,   967,   971,   972,   977,   979,   983,
+,   988,   990,   994,   995,   999,  1000,  1004,  1005,  1020,
+,  1022,  1023,  1024,  1028,  1033,  1040,  1050,  1055,  1060,
+,  1073,  1078,  1083,  1088,  1096,  1118,  1123,  1130,  1132,
+,  1144,  1149,  1160,  1165,  1170,  1175,  1180,  1189,  1194,
+,  1203,  1204,  1205,  1211,  1216,  1224,  1225,  1226,  1227,
+,  1232,  1233,  1234,  1239,  1240,  1249,  1250,  1255,  1256,
+,  1263,  1265,  1267,  1269,  1272,  1271,  1283,  1284,  1286,
+,  1297,  1302,  1306,  1308,  1310,  1312,  1314,  1316,  1318,
+,  1325,  1327,  1329,  1331,  1333,  1335,  1337,  1339,  1341,
+,  1345,  1347,  1349,  1355,  1356,  1358,  1360,  1362,  1367,
+,  1374,  1375,  1377,  1379,  1384,  1386,  1388,  1390,  1395,
+,  1398,  1400,  1405,  1406,  1408,  1413,  1414,  1416,  1418,
+,  1425,  1427,  1432,  1433,  1437,  1439,  1445,  1444,  1448,
+,  1455,  1457,  1462,  1464,  1469,  1470,  1472,  1473,  1478,
+,  1481,  1483,  1488,  1490,  1496,  1497,  1499,  1502,  1505,
+,  1511,  1516,  1521,  1525,  1527,  1533,  1532,  1539,  1541,
+,  1548,  1556,  1557,  1561,  1562,  1563,  1565,  1567,  1574,
+,  1577,  1579,  1584,  1585,  1591,  1592,  1596,  1597,  1602,
+,  1604,  1606,  1614,  1615,  1617,  1620,  1622,  1626,  1627,
+,  1630,  1632,  1636,  1641,  1649,  1650,  1659,  1661,  1666,
+,  1668,  1672,  1673,  1674,  1678,  1679,  1680,  1684,  1685,
+,  1691,  1692,  1693,  1694,  1700,  1701,  1703,  1708,  1709,
+,  1715,  1716,  1717,  1718,  1733,  1734,  1739,  1740,  1748,
+,  1752,  1755,  1757,  1759,  1782,  1783,  1785,  1787,  1792,
+,  1795,  1800,  1805,  1806,  1812,  1811,  1815,  1819,  1821,
+,  1829,  1830,  1835,  1840,  1842,  1847,  1849,  1850,  1852,
+,  1859,  1861,  1866,  1868,  1873,  1878,  1886,  1892,  1891,
+,  1906,  1911,  1912,  1916,  1921,  1926,  1934,  1939,  1950,
+,  1962,  1963,  1969,  1970,  1974,  1975,  1976,  1979,  1978,
+,  1994,  1999,  2005,  2014,  2020,  2026,  2032,  2038,  2046,
+,  2060,  2066,  2075,  2076,  2077,  2081,  2085,  2087,  2092,
+,  2097,  2098,  2103,  2109,  2110,  2113,  2115,  2116,  2120,
+,  2122,  2123,  2157,  2159,  2160,  2162,  2167,  2172,  2177,
+,  2181,  2186,  2188,  2190,  2192,  2197,  2199,  2209,  2211,
+,  2217,  2219,  2221,  2226,  2228,  2230,  2235,  2237,  2239,
+,  2249,  2250,  2254,  2256,  2258,  2263,  2265,  2267,  2272,
+,  2276,  2291,  2293,  2294,  2296,  2301,  2302,  2307,  2309,
+,  2316,  2318,  2320,  2322,  2327,  2329,  2331,  2341,  2343,
+,  2346,  2351,  2353,  2355,  2360,  2362,  2364,  2366,  2371,
+,  2375,  2406,  2408,  2409,  2411,  2416,  2421,  2429,  2431,
+,  2438,  2440,  2445,  2447,  2461,  2462,  2464,  2469,  2471,
+,  2475,  2477,  2482,  2483,  2485,  2487,  2492,  2494,  2496,
+,  2504,  2506,  2510,  2512,  2514,  2516,  2530,  2531,  2533,
+,  2540,  2542,  2544,  2546,  2551,  2552,  2554,  2556,  2561,
+,  2565,  2571,  2572,  2574,  2583,  2586,  2588,  2591,  2593,
+,  2608,  2609,  2611,  2616,  2618,  2620,  2622,  2624,  2629,
+,  2632,  2634,  2639,  2641,  2649,  2650,  2651,  2656,  2657,
+,  2663,  2665,  2667,  2669,  2671,  2678,  2680,  2682,  2684,
+,  2688,  2690,  2692,  2694,  2696,  2701,  2703,  2705,  2710,
+,  2737,  2739,  2743,  2744,  2748,  2750,  2752,  2754,  2756,
+,  2765,  2767,  2769,  2771,  2773,  2775,  2780,  2785,  2787,
+,  2807,  2809,  2814,  2815
 };
 #endif
 …
   "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",
 …
   "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",
 …
 ,   336,   337,   338,   339,   340,   341,   342,   343,   344,
 ,   346,   347,   348,   349,   350,   351,   352,   353,   354,
 ,   356,   357,   358,   359,   360,   361,   362,    40,    41,
 ,    93,    46,   123,   125,    44,    58,    33,    42,    38,
 ,    45,   126,    47,    37,    60,    62,    94,   124,    63,
 ,    59
+,   356,   357,   358,   359,   360,   361,   362,   363,    40,
+,    91,    93,    46,   123,   125,    44,    58,    33,    42,
+,    43,    45,   126,    47,    37,    60,    62,    94,   124,
+,    61,    59
 };
 # endif
 …
 static const yytype_uint16 yyr1[] =
+{
 ,   132,   133,   134,   135,   135,   135,   136,   136,   136,
 ,   137,   138,   138,   139,   139,   140,   140,   141,   141,
 ,   141,   142,   142,   142,   142,   142,   142,   142,   142,
 ,   142,   142,   143,   143,   144,   144,   144,   144,   144,
 ,   145,   146,   146,   146,   146,   146,   147,   147,   147,
 ,   147,   147,   147,   147,   147,   147,   147,   147,   147,
 ,   147,   147,   147,   147,   148,   148,   148,   148,   149,
 ,   149,   150,   150,   150,   150,   151,   151,   151,   152,
 ,   152,   153,   153,   153,   153,   153,   154,   154,   154,
 ,   155,   156,   156,   157,   157,   158,   158,   159,   159,
 ,   160,   160,   160,   161,   162,   162,   162,   162,   163,
 ,   164,   164,   164,   164,   165,   165,   166,   166,   166,
 ,   166,   166,   166,   166,   166,   166,   167,   167,   168,
 ,   169,   169,   169,   169,   169,   169,   169,   169,   169,
 ,   171,   171,   172,   172,   173,   173,   173,   173,   174,
 ,   175,   176,   176,   176,   176,   176,   176,   177,   177,
 ,   178,   178,   179,   179,   180,   180,   181,   182,   182,
 ,   183,   184,   184,   185,   185,   185,   185,   186,   186,
 ,   187,   188,   188,   188,   189,   189,   190,   190,   190,
 ,   190,   190,   190,   190,   190,   190,   191,   191,   191,
 ,   192,   192,   192,   192,   193,   193,   193,   193,   194,
 ,   195,   195,   195,   195,   196,   196,   196,   196,   196,
 ,   197,   198,   198,   199,   199,   200,   200,   201,   201,
 ,   202,   202,   203,   203,   204,   204,   205,   205,   206,
 ,   207,   207,   208,   208,   209,   209,   210,   210,   211,
 ,   211,   211,   211,   212,   212,   212,   213,   213,   213,
 ,   214,   214,   214,   214,   215,   215,   215,   216,   216,
 ,   217,   217,   218,   218,   218,   218,   218,   219,   219,
 ,   220,   220,   220,   221,   221,   222,   222,   222,   222,
 ,   223,   223,   223,   224,   224,   225,   225,   226,   226,
 ,   227,   227,   227,   227,   228,   227,   229,   229,   229,
 ,   230,   231,   232,   232,   232,   232,   232,   232,   232,
 ,   233,   233,   233,   233,   233,   233,   233,   233,   233,
 ,   233,   233,   234,   234,   234,   234,   234,   235,   235,
 ,   236,   236,   236,   237,   237,   237,   237,   238,   238,
 ,   238,   239,   239,   239,   240,   240,   240,   240,   241,
 ,   241,   242,   242,   243,   243,   243,   243,   243,   244,
 ,   245,   245,   246,   246,   246,   246,   247,   247,   247,
 ,   248,   248,   249,   249,   249,   249,   249,   250,   250,
 ,   252,   253,   253,   253,   254,   254,   255,   255,   256,
 ,   257,   257,   257,   257,   257,   258,   258,   258,   258,
 ,   259,   260,   260,   261,   261,   262,   262,   262,   262,
 ,   263,   263,   263,   263,   264,   264,   264,   264,   264,
 ,   265,   266,   266,   267,   267,   268,   268,   268,   269,
 ,   269,   270,   270,   270,   271,   271,   271,   272,   272,
 ,   272,   273,   273,   273,   274,   274,   275,   275,   275,
 ,   275,   276,   276,   277,   277,   278,   278,   278,   278,
 ,   278,   279,   279,   279,   279,   280,   280,   280,   281,
 ,   282,   284,   283,   283,   285,   285,   285,   286,   286,
 ,   287,   287,   288,   288,   288,   288,   289,   289,   289,
 ,   290,   291,   291,   292,   293,   292,   294,   294,   295,
 ,   296,   296,   296,   297,   297,   298,   298,   299,   299,
 ,   300,   301,   301,   301,   302,   301,   301,   303,   303,
 ,   304,   304,   304,   304,   304,   304,   304,   304,   304,
 ,   305,   305,   306,   307,   307,   308,   308,   309,   309,
 ,   311,   311,   312,   312,   312,   313,   313,   313,   313,
 ,   314,   314,   314,   315,   315,   316,   316,   316,   317,
 ,   317,   317,   318,   318,   319,   319,   319,   320,   320,
 ,   321,   321,   321,   322,   322,   322,   323,   323,   323,
 ,   324,   324,   325,   325,   325,   326,   326,   326,   327,
 ,   327,   327,   328,   328,   329,   329,   329,   330,   330,
 ,   330,   331,   331,   331,   332,   332,   332,   332,   333,
 ,   333,   334,   334,   334,   334,   335,   335,   335,   336,
 ,   336,   336,   337,   337,   338,   338,   338,   339,   339,
 ,   340,   341,   341,   341,   342,   342,   342,   342,   342,
 ,   343,   343,   343,   344,   344,   344,   345,   345,   345,
 ,   346,   346,   346,   347,   347,   347,   348,   348,   348,
 ,   348,   349,   349,   349,   349,   350,   350,   350,   351,
 ,   351,   352,   352,   352,   352,   352,   352,   353,   353,
 ,   354,   354,   354,   354,   354,   355,   355,   355,   355,
 ,   356,   357,   357,   357,   358,   358,   359,   359,   359,
 ,   359,   359,   360,   360,   360,   360,   360,   360,   360,
 ,   360,   360,   361,   361,   361,   361,   362,   362,   362,
 ,   363,   364,   364,   364,   364,   364,   364,   365,   365,
 ,   365,   365,   365,   366,   367,   367,   367,   368,   368,
 ,   369
+,   133,   134,   135,   136,   136,   136,   137,   137,   137,
+,   138,   139,   139,   140,   140,   141,   141,   142,   142,
+,   142,   143,   143,   143,   143,   143,   143,   143,   143,
+,   143,   143,   144,   144,   145,   145,   145,   145,   145,
+,   146,   147,   147,   147,   147,   147,   148,   148,   148,
+,   148,   148,   148,   148,   148,   148,   148,   148,   148,
+,   148,   148,   148,   148,   149,   149,   149,   149,   150,
+,   150,   151,   151,   151,   151,   152,   152,   152,   153,
+,   153,   154,   154,   154,   154,   154,   155,   155,   155,
+,   156,   157,   157,   158,   158,   159,   159,   160,   160,
+,   161,   161,   161,   162,   163,   163,   163,   163,   164,
+,   165,   165,   165,   165,   166,   166,   167,   167,   167,
+,   167,   167,   167,   167,   167,   167,   168,   168,   169,
+,   170,   170,   170,   170,   170,   170,   170,   170,   170,
+,   172,   172,   173,   173,   174,   174,   174,   174,   175,
+,   176,   177,   177,   177,   177,   177,   177,   178,   178,
+,   179,   179,   180,   180,   181,   181,   182,   183,   183,
+,   184,   185,   185,   186,   186,   186,   186,   187,   187,
+,   188,   189,   189,   189,   190,   190,   191,   191,   191,
+,   191,   191,   191,   191,   191,   191,   192,   192,   192,
+,   193,   193,   193,   193,   194,   194,   194,   194,   195,
+,   196,   196,   196,   196,   197,   197,   197,   197,   197,
+,   198,   199,   199,   200,   200,   201,   201,   202,   202,
+,   203,   203,   204,   204,   205,   205,   206,   206,   207,
+,   208,   208,   209,   209,   210,   210,   211,   211,   212,
+,   212,   212,   212,   213,   213,   213,   214,   214,   214,
+,   215,   215,   215,   215,   216,   216,   216,   217,   217,
+,   218,   218,   219,   219,   219,   219,   219,   220,   220,
+,   221,   221,   221,   222,   222,   223,   223,   223,   223,
+,   224,   224,   224,   225,   225,   226,   226,   227,   227,
+,   228,   228,   228,   228,   229,   228,   230,   230,   230,
+,   231,   232,   233,   233,   233,   233,   233,   233,   233,
+,   234,   234,   234,   234,   234,   234,   234,   234,   234,
+,   234,   234,   234,   235,   235,   235,   235,   235,   236,
+,   237,   237,   237,   237,   238,   238,   238,   238,   239,
+,   239,   239,   240,   240,   240,   241,   241,   241,   241,
+,   242,   242,   243,   243,   244,   244,   245,   244,   244,
+,   246,   246,   247,   247,   248,   248,   248,   248,   249,
+,   249,   249,   250,   250,   251,   251,   251,   251,   251,
+,   252,   253,   254,   255,   255,   256,   255,   257,   257,
+,   258,   259,   259,   260,   260,   260,   260,   260,   261,
+,   261,   261,   262,   262,   263,   263,   264,   264,   265,
+,   265,   265,   266,   266,   266,   266,   266,   267,   267,
+,   267,   267,   268,   268,   269,   269,   270,   270,   271,
+,   271,   272,   272,   272,   273,   273,   273,   274,   274,
+,   275,   275,   275,   275,   276,   276,   276,   277,   277,
+,   278,   278,   278,   278,   279,   279,   280,   280,   281,
+,   281,   281,   281,   281,   282,   282,   282,   282,   283,
+,   283,   284,   285,   285,   287,   286,   286,   288,   288,
+,   289,   289,   290,   290,   290,   291,   291,   291,   291,
+,   292,   292,   293,   293,   294,   294,   295,   296,   295,
+,   297,   298,   298,   299,   299,   299,   300,   300,   301,
+,   302,   302,   303,   303,   304,   304,   304,   305,   304,
+,   306,   306,   306,   307,   307,   307,   307,   307,   307,
+,   307,   307,   308,   308,   308,   309,   310,   310,   311,
+,   312,   312,   313,   314,   314,   315,   315,   315,   316,
+,   316,   316,   317,   317,   317,   317,   318,   318,   319,
+,   319,   320,   320,   320,   320,   321,   321,   322,   322,
+,   323,   323,   323,   324,   324,   324,   325,   325,   325,
+,   326,   326,   327,   327,   327,   328,   328,   328,   329,
+,   329,   330,   330,   330,   330,   331,   331,   332,   332,
+,   333,   333,   333,   333,   334,   334,   334,   335,   335,
+,   335,   336,   336,   336,   337,   337,   337,   337,   338,
+,   338,   339,   339,   339,   339,   340,   340,   341,   341,
+,   342,   342,   343,   343,   344,   344,   344,   345,   345,
+,   345,   345,   346,   346,   346,   346,   347,   347,   347,
+,   348,   348,   349,   349,   349,   349,   350,   350,   350,
+,   351,   351,   351,   351,   352,   352,   352,   352,   353,
+,   353,   354,   354,   354,   355,   355,   355,   355,   355,
+,   356,   356,   356,   357,   357,   357,   357,   357,   358,
+,   358,   358,   359,   359,   360,   360,   360,   361,   361,
+,   362,   362,   362,   362,   362,   363,   363,   363,   363,
+,   363,   363,   363,   363,   363,   364,   364,   364,   364,
+,   365,   365,   366,   366,   367,   367,   367,   367,   367,
+,   368,   368,   368,   368,   368,   368,   369,   370,   370,
+,   371,   371,   372,   372
 };
 …
 ,     2,     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,
 ,     2,     2,     2,     4,     4,     4,     4,     1,     2,
 ,     3,     1,     2,     2,     1,     2,     2,     3,     1,
 ,     2,     1,     1,     4,     2,     5,     7,     2,     2,
 ,     1,     2,     2,     3,     2,     3,     1,     2,     3,
 ,     2,     4,     0,     1,     2,     2,     1,     0,     1,
 ,     2,     5,     6,     2,     2,     4,     0,     2,     0,
 ,     1,     1,     5,     5,     5,     1,     5,     5,     9,
 ,     5,     0,     1,     1,     5,     1,     1,     5,     5,
 ,     3,     3,     4,     1,     1,     1,     1,     2,     1,
 ,     3,     1,     2,     1,     3,     1,     1,     1,     1,
 ,     1,     1,     1,     1,     1,     1,     2,     1,     1,
 ,     2,     0,     2,     2,     1,     4,     0,     1,     2,
 ,     4,     2,     2,     1,     2,     1,     2,     5,     5,
 ,     6,     1,     2,     2,     3,     1,     2,     2,     4,
 ,     4,     0,     4,     2,     1,     1,     1,     0,     2,
 ,     5,    13,     1,     1,     3,     3,     2,     3,     3,
 ,     4,     1,     6,     9,     0,    11,     1,     3,     3,
 ,     1,     1,     5,     2,     5,     0,     1,     1,     3,
 ,     1,     1,     1,     1,     0,     6,     2,     1,     2,
 ,     2,     3,     3,     3,     4,     5,     5,     5,     6,
 ,     1,     1,     3,     0,     5,     0,     1,     1,     2,
 ,     1,     3,     0,     1,     4,     1,     1,     1,     1,
 ,     1,     2,     2,     1,     3,     2,     3,     3,     2,
 ,     4,     3,     8,     3,     2,     1,     2,     6,     8,
 ,     2,     3,     3,     4,     4,     3,     1,     1,     1,
 ,     6,     3,     2,     3,     3,     4,     4,     3,     2,
 ,     2,     2,     1,     3,     2,     3,     3,     2,     4,
 ,     3,     6,     8,     3,     2,     1,     2,     2,     2,
 ,     3,     2,     4,     4,     3,     6,     8,     3,     2,
 ,     2,     2,     1,     1,     2,     3,     3,     2,     4,
 ,     8,     1,     2,     2,     1,     2,     2,     3,     3,
 ,     4,     4,     3,     5,     8,     3,     2,     3,     1,
 ,     5,     6,     6,     1,     2,     2,     1,     2,     2,
 ,     3,     1,     4,     4,     3,     5,     8,     3,     1,
 ,     1,     2,     6,     5,     6,     7,     7,     1,     2,
 ,     1,     2,     2,     3,     3,     1,     4,     4,     3,
 ,     3,     1,     1,     2,     1,     1,     2,     3,     2,
 ,     2,     3,     3,     2,     4,     3,     2,     3,     2,
 ,     3,     2,     6,     6,     6,     7,     1,     2,     1,
 ,     1,     2,     3,     2,     3,     2,     3,     3,     4,
 ,     3,     4,     2,     5,     5,     6,     6,     0,     1,
 ,     2
+,     1,     1,     1,     1,     2,     2,     3,     3,     1,
+,     1,     2,     2,     2,     4,     4,     4,     4,     1,
+,     2,     3,     1,     2,     2,     1,     2,     2,     3,
+,     2,     2,     1,     1,     4,     2,     0,     6,     7,
+,     2,     2,     1,     2,     2,     3,     2,     3,     1,
+,     3,     2,     2,     4,     0,     1,     2,     2,     1,
+,     1,     2,     2,     5,     2,     0,     7,     2,     4,
+,     2,     0,     1,     1,     1,     5,     5,     5,     1,
+,     5,     9,     1,     5,     0,     1,     1,     5,     1,
+,     5,     5,     1,     3,     3,     4,     1,     1,     1,
+,     2,     1,     3,     3,     1,     2,     1,     3,     1,
+,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+,     1,     1,     1,     2,     0,     2,     2,     1,     4,
+,     1,     2,     3,     4,     2,     2,     1,     2,     1,
+,     5,     5,     7,     6,     1,     2,     2,     3,     1,
+,     2,     4,     2,     4,     0,     4,     2,     1,     1,
+,     0,     2,     5,     5,    13,     1,     1,     3,     3,
+,     3,     3,     2,     4,     1,     6,     9,     0,    11,
+,     3,     3,     3,     1,     1,     5,     2,     5,     0,
+,     1,     3,     0,     1,     1,     1,     1,     0,     6,
+,     1,     2,     4,     2,     3,     3,     3,     4,     5,
+,     5,     6,     1,     1,     1,     3,     0,     5,     0,
+,     1,     2,     6,     1,     3,     0,     1,     4,     1,
+,     1,     1,     2,     1,     2,     2,     1,     3,     2,
+,     3,     2,     4,     4,     3,     8,     3,     2,     1,
+,     6,     8,     3,     2,     3,     3,     4,     4,     3,
+,     1,     1,     4,     6,     3,     2,     3,     3,     4,
+,     3,     2,     1,     2,     2,     1,     3,     2,     3,
+,     2,     4,     4,     3,     6,     8,     3,     2,     1,
+,     2,     2,     3,     3,     2,     4,     4,     3,     6,
+,     3,     2,     1,     2,     2,     1,     1,     2,     3,
+,     2,     4,     6,     8,     1,     2,     2,     1,     2,
+,     3,     3,     1,     4,     4,     3,     5,     8,     3,
+,     3,     1,     5,     5,     6,     6,     1,     2,     2,
+,     2,     2,     3,     3,     1,     4,     4,     3,     5,
+,     3,     1,     2,     1,     2,     6,     5,     6,     7,
+,     1,     2,     2,     1,     2,     2,     3,     3,     1,
+,     4,     3,     8,     3,     1,     1,     2,     1,     1,
+,     3,     2,     3,     2,     3,     3,     2,     4,     3,
+,     3,     2,     4,     3,     2,     6,     6,     6,     7,
+,     2,     1,     1,     1,     2,     3,     2,     3,     2,
+,     3,     4,     2,     3,     4,     2,     5,     5,     6,
+,     0,     1,     0,     2
 };
 …
 ,   294,   315,   313,   316,   314,   317,   318,   300,   302,
 ,     0,   303,   329,   321,   326,   324,   325,   323,   322,
 ,   328,   330,   331,   332,   546,   546,   546,     0,     0,
 ,   294,   220,   304,   319,   320,     7,   359,     0,     8,
 ,    15,     0,     2,   294,   564,     9,   524,   522,   247,
 ,   452,     3,   260,     0,     3,     3,     3,   248,     3,
 ,     0,     0,   295,   296,   298,   294,   307,   310,   312,
 ,   286,   333,   338,   287,   348,   288,   355,   352,   362,
 ,     0,   363,   289,   472,   476,     3,     3,     0,     2,
 ,   523,   528,   299,     0,     0,   546,   576,   546,     2,
 ,   588,   589,   294,     0,   730,   731,     0,    12,   294,
 ,    13,   270,   271,     0,   295,   290,   291,   292,   293,
 ,   305,   391,   547,   548,   369,   370,    12,   443,   444,
 ,   439,   442,     0,   502,   497,   488,   443,   444,     0,
 ,   527,   221,     0,   294,     0,     0,     0,     0,     0,
 ,     0,     0,   294,   294,     2,     0,   732,   295,   581,
 ,   736,   729,   727,   734,     0,     0,     0,   254,     2,
 ,   531,   437,   438,   436,     0,     0,     0,     0,   546,
 ,   633,   634,     0,     0,   544,   540,   546,   561,   546,
 ,   541,     2,   542,   546,   600,   546,   546,   603,     0,
 ,     0,   294,   294,   313,   360,     2,   294,   261,   297,
 ,   341,   353,   477,     0,     2,     0,   452,   262,   295,
 ,   349,   356,   473,     0,     2,     0,   311,   335,   342,
 ,     0,   350,   354,   357,   361,   444,   294,   294,   365,
 ,     0,   394,   474,   478,     0,     0,     0,     1,   294,
 ,   529,   575,   577,   294,     2,   740,   295,   743,   544,
 ,   295,     0,     0,     0,   273,   546,   541,     2,   294,
 ,     0,   294,   549,     2,   500,     2,   553,     0,     0,
 ,     0,     0,     0,    18,    59,     4,     5,     6,    16,
 ,     0,     0,   294,     2,     0,   294,    65,    66,    67,
 ,    48,    19,    49,    22,    47,    69,     0,    72,    76,
 ,    82,    87,    90,    92,    94,    96,    98,   100,   105,
 ,   750,   450,   493,     0,   448,   449,     0,   565,   580,
 ,   586,   592,   595,   598,   359,     0,     2,   738,     0,
 ,   741,     2,   294,     3,   424,     0,   432,   295,   294,
 ,   333,   287,   348,   355,     3,     3,   406,   410,   420,
 ,   472,   294,   426,   705,   706,   294,   427,   429,   294,
 ,   582,   594,   728,     2,     2,   249,     2,   457,     0,
 ,   454,   453,   141,     2,     2,   251,     2,     2,   250,
 ,   281,     2,   282,     0,   280,     0,     0,     0,     0,
 ,     0,     0,     0,     0,   566,   605,     0,   452,     2,
 ,   569,   659,   562,   563,   532,   294,     2,   599,   608,
 ,   602,     0,   276,   294,   294,   339,   295,     0,   295,
 ,   294,   733,   737,   735,   533,   294,   544,   255,   263,
 ,     0,     2,   534,   294,   498,   336,   337,   283,   351,
 ,     0,   294,     2,   383,   294,   371,     0,     0,   377,
 ,   294,   748,   397,     0,   475,   499,   252,   253,   519,
 ,   434,     0,   294,   237,     0,     2,   239,     0,   295,
 ,   257,     2,   258,   278,     0,     0,     2,   294,   544,
 ,   485,   487,   486,     0,     0,   750,     0,   294,     0,
 ,   489,   294,   559,   557,   558,   556,     0,   551,   554,
 ,     0,   294,    56,   294,    69,    52,   294,    62,   294,
 ,    50,    51,    64,     2,   127,     0,     0,   446,     0,
 ,   111,   294,    54,    55,    17,     0,    29,    30,    35,
 ,     0,    35,   117,   118,   119,   120,   121,   122,   123,
 ,   125,   126,     0,     0,    53,     0,     0,     0,     0,
+,   328,   333,   330,   331,   332,   549,   549,   549,     0,
+,     0,   294,   220,   304,   319,   320,     7,   360,     0,
+,    14,    15,     0,     2,   294,   567,     9,   527,   525,
+,     3,   455,     3,   260,     0,     3,     3,     3,   248,
+,     0,     0,     0,   295,   296,   298,   294,   307,   310,
+,   341,   286,   334,   339,   287,   349,   288,   356,   353,
+,     0,     0,   364,   289,   475,   479,     3,     3,     0,
+,   521,   526,   531,   299,     0,     0,   549,   579,   549,
+,   590,   591,   592,   294,     0,   733,   734,     0,    12,
+,     0,    13,   270,   271,     0,   295,   290,   291,   292,
+,   528,   305,   393,   550,   551,   371,   372,    12,   446,
+,    11,   442,   445,     0,   505,   500,   491,   446,   447,
+,     0,   530,   221,     0,   294,     0,     0,     0,     0,
+,     0,     0,     0,   294,   294,     2,     0,   735,   295,
+,   596,   739,   732,   730,   737,     0,     0,     0,   254,
+,     0,   534,   440,   441,   439,     0,     0,     0,     0,
+,     0,   636,   637,     0,     0,   547,   543,   549,   564,
+,   549,   544,     2,   545,   549,   603,   549,   549,   606,
+,     0,     0,   294,   294,   313,   361,     2,   294,   261,
+,   308,   342,   354,   480,     0,     2,     0,   455,   262,
+,   335,   350,   357,   476,     0,     2,     0,   311,   336,
+,   344,     0,   351,   355,   358,   362,   447,   294,   294,
+,   370,     0,   395,   477,   481,     0,     0,     0,     1,
+,     2,   532,   578,   580,   294,     2,   743,   295,   746,
+,   547,   295,     0,     0,     0,   273,   549,   544,     2,
+,     0,     0,   294,   552,     2,   503,     2,   556,     0,
+,     0,     0,     0,     0,    18,    59,     4,     5,     6,
+,     0,     0,     0,   294,     2,     0,   294,    65,    66,
+,    68,    48,    19,    49,    22,    47,    69,     0,    72,
+,    79,    82,    87,    90,    92,    94,    96,    98,   100,
+,   497,   753,   453,   496,     0,   451,   452,     0,   568,
+,   586,   589,   595,   598,   601,   360,     0,     2,   741,
+,   294,   744,     2,   294,     3,   427,     0,   435,   295,
+,   307,   334,   287,   349,   356,     3,     3,   409,   413,
+,   428,   475,   294,   429,   708,   709,   294,   430,   432,
+,     2,   585,   597,   731,     2,     2,   249,     2,   460,
+,   458,   457,   456,   141,     2,     2,   251,     2,     2,
+,     2,   281,     2,   282,     0,   280,     0,     0,     0,
+,     0,     0,     0,     0,     0,   569,   608,     0,   455,
+,   563,   572,   662,   565,   566,   535,   294,     2,   602,
+,   604,   605,     0,   276,   294,   294,   340,   295,     0,
+,     0,   294,   736,   740,   738,   536,   294,   547,   255,
+,   309,     0,     2,   537,   294,   501,   337,   338,   283,
+,   359,     0,   294,     2,   385,   294,   373,     0,     0,
+,   730,     0,   751,   400,     0,   478,   502,   252,   253,
+,   294,   437,     0,   294,   237,     0,     2,   239,     0,
+,     0,   257,     2,   258,   278,     0,     0,     2,   294,
+,   294,   488,   490,   489,     0,     0,   753,     0,   294,
+,   294,   492,   294,   562,   560,   561,   559,     0,   554,
+,     0,     0,   294,    56,   294,    69,    52,   294,    62,
+,   294,    50,    51,    64,     2,   127,     0,     0,   449,
+,   448,   111,   294,    54,    55,    17,     0,    29,    30,
+,     2,     0,    35,   117,   118,   119,   120,   121,   122,
+,   124,   125,   126,     0,     0,    53,     0,     0,     0,
 ,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,   108,     2,   645,   451,
+,   546,   546,   650,   479,   294,     2,   584,   585,     0,
+,   597,     0,     2,   739,   742,   111,   294,     2,   294,
+,   707,   295,   711,   702,   703,   709,     0,     2,     2,
+,   546,   750,   616,   546,   546,   750,   546,   630,   546,
+,   681,   433,   664,   546,   546,   672,   679,   294,   428,
+,     0,     0,   294,   717,   295,   722,   750,   714,   294,
+,   750,   294,   294,   294,     0,   111,     0,    18,     5,
+,     0,    19,     0,   458,   748,     0,     0,   464,   241,
+,   294,     0,     0,     0,   544,   568,   572,   574,   604,
+,   611,   614,   567,   606,     0,   284,   657,     0,   294,
+,     0,     0,     0,     0,   275,     2,     0,   259,   535,
+,     0,     0,     0,     0,   294,   294,     0,     0,   691,
+,   384,   388,   546,   388,   696,   387,   688,   546,   546,
+,   372,   380,   373,   546,   375,   378,   294,   749,     0,
+,   395,   748,   295,     3,   413,     3,   417,   416,   590,
+,   530,   294,     3,     3,   294,   432,   295,     3,   426,
+,     2,     0,     0,     0,   484,   306,   294,   480,   482,
+,     2,     2,     0,   501,     3,     0,   553,   129,     0,
+,   222,     0,     0,     0,     2,     0,     0,    36,     0,
+,   111,   294,    20,     0,    21,     0,   691,   447,     0,
+,     3,     2,    27,     2,     0,    33,     0,     2,    25,
+,   106,   107,    73,    74,    75,    77,    78,    80,    81,
+,    86,    83,    84,    88,    89,    91,    93,    95,    97,
+,     0,     0,   751,   294,     0,     0,     0,   646,   647,
+,   644,   496,   495,   294,     0,     3,   294,   713,   294,
+,   295,   294,   294,   294,   661,   704,   660,     2,   294,
+,     0,     0,     0,     0,     0,     0,     0,   682,     0,
+,   619,   635,   669,     2,   615,   622,   430,   617,   618,
+,     2,   629,   638,   631,   632,   665,   666,   680,   708,
+,   710,   750,   268,     2,   744,     2,   421,   716,   721,
+,     0,   400,     3,     3,     3,     3,   452,     3,     0,
+,   467,   463,   749,     0,   459,   466,     2,   462,   465,
+,   294,   242,   264,     3,   272,   274,     0,   452,     2,
+,   571,     2,   609,   610,     0,   658,   536,     3,   345,
+,   347,   346,   294,   537,     0,   538,   294,   374,   376,
+,     0,     0,     0,     0,   104,   390,   692,   693,   385,
+,   386,   689,   690,   379,   383,   366,   397,   392,   398,
+,     0,     0,   435,   240,     0,     0,     3,     2,   667,
+,     0,   526,     0,   750,   488,     0,   294,   294,   294,
+,   550,   552,   130,     0,     0,   215,     0,     0,     0,
+,   224,    57,     0,    63,   294,     0,    61,    60,     0,
+,   692,   457,    70,    71,   110,   115,     3,   109,     0,
+,     0,    24,    35,     3,     0,    32,   102,     0,     3,
+,   653,   656,   648,     3,   591,     3,   715,   720,     2,
+,     3,     3,   295,     0,     3,   621,   625,   628,   637,
+,   675,   678,   294,     3,   620,   636,   670,   294,   294,
+,   294,   294,   745,     0,     0,     0,     0,   256,     0,
+,     0,     3,     3,     0,   460,     0,   456,     0,     0,
+,   294,     0,     0,   129,     0,     0,     0,     0,     0,
+,     0,     0,   109,   109,     2,     0,     0,     0,     3,
+,   132,     2,   143,   133,   134,   135,   136,   137,   138,
+,   147,     0,     0,     0,   285,   294,   294,   546,     0,
+,   294,   111,   695,   699,   701,   694,   382,   396,   393,
+,     2,   663,   662,     0,   668,     2,   481,   483,   503,
+,   511,   512,     0,     2,   507,     3,     3,     0,     0,
+,   222,     0,     0,     0,   222,     0,     0,     3,    37,
+,   109,     0,     3,   660,    42,     3,    40,     3,    34,
+,     3,   101,   103,     0,     2,   651,   652,     0,     0,
+,     0,     0,     0,     3,   637,     0,     2,   623,   624,
+,   639,     2,   673,   674,     0,     0,     3,     0,     3,
+,     3,     3,   408,   407,   411,     2,     2,   747,   746,
+,     0,     0,     0,     0,     3,   461,     3,     0,   243,
+,     3,   295,   294,     0,     0,     0,     0,     2,   191,
+,   189,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   546,   151,   148,   294,     0,     0,   267,   279,
+,     3,   545,   612,   367,     2,   697,   698,   294,   266,
+,     0,   514,   491,   294,     0,     0,   490,   505,     0,
+,     0,   216,     0,   225,    58,   109,     0,     0,   116,
+,     0,     0,     0,     0,     0,     0,    23,     0,   654,
+,   579,   265,   723,   724,   725,     0,   676,   294,   294,
+,     3,     3,     0,   684,     0,     0,     0,     0,   294,
+,     3,   543,   468,   469,     0,     0,   246,   295,     0,
+,     0,     0,   294,   192,   190,     0,   187,   193,     0,
+,     0,     0,   197,   200,   198,   194,     0,   195,    35,
+,   144,   142,   244,     0,     0,   294,   415,   419,   418,
+,   508,     2,   509,     2,   510,   504,   294,   228,     0,
+,     0,   228,     3,   660,    31,   114,     2,    45,     2,
+,    41,    28,   112,    26,     3,   726,     3,     3,     3,
+,     0,   683,   685,   626,   640,   269,     2,   405,     3,
+,     0,   471,   468,   129,     0,     0,   129,     3,     0,
+,   188,     0,     2,     2,   209,   199,     0,     0,     0,
+,   140,   573,   613,     3,     2,     0,     0,     2,   229,
+,     0,   217,     0,     0,     0,     0,     0,     0,     0,
+,     0,   686,   687,   294,     0,   470,   152,     0,     0,
+,   165,   129,   154,     0,   182,     0,   129,     0,     2,
+,     0,     2,     0,     2,     2,     2,   196,    32,     0,
+,   513,   515,   506,     0,     0,     0,     0,   114,    38,
+,     3,   655,   627,   641,   677,   409,   129,   158,   161,
+,   160,   164,     3,   167,   166,     0,   129,   184,   129,
+,     0,   294,     0,   294,     0,     2,     0,     2,   139,
+,     2,   230,   231,     0,   227,   218,     0,     0,     0,
+,     0,     0,   163,   233,   168,     2,   235,   183,     0,
+,   172,   201,     3,   210,   214,   203,     3,     0,   294,
+,   294,     0,     0,     0,    39,    46,    44,   159,   162,
+,     0,   169,   294,   129,   129,     0,   173,     0,     0,
+,   211,   212,   213,     0,   202,     3,   204,     3,   294,
+,   232,   149,   170,   155,   129,   236,   185,   180,   178,
+,   157,   129,     0,   692,     0,     0,     0,     0,   150,
+,   181,   175,   179,   178,   176,     3,     3,     0,     0,
+,   177,   205,   207,     3,     3,   206,   208
+,     0,     0,     0,     0,     0,     0,   108,     2,   648,
+,   645,   549,   549,   653,   482,   294,     2,   587,   588,
+,   599,   600,     0,     2,   742,   745,   111,   294,     2,
+,     0,   710,   295,   714,   705,   706,   712,     0,     2,
+,   670,   549,   753,   619,   549,   549,   753,   549,   633,
+,   549,   684,   436,   667,   549,   549,   675,   682,   294,
+,   295,     0,     0,   294,   720,   295,   725,   753,   717,
+,   722,   753,   294,   294,   294,     0,   111,     0,    18,
+,     2,     0,    19,     0,   461,   751,     0,     0,   467,
+,     0,   294,     0,     0,     0,   547,   571,   575,   577,
+,   610,   614,   617,   570,   609,     0,   284,   660,     0,
+,   277,     0,     0,     0,     0,   275,     2,     0,   259,
+,   294,     0,     0,     0,     0,   294,   294,     0,     0,
+,   383,   386,   390,   549,   390,   699,   389,   691,   549,
+,   365,   374,   382,   375,   549,   377,   380,   294,   752,
+,     0,   398,     0,   295,     3,   416,     3,   420,   419,
+,     0,   533,   294,     3,     3,   294,   435,   295,     3,
+,   430,     2,     0,     0,     0,   487,   306,   294,   483,
+,     3,     2,     2,     0,   504,     3,     0,   556,   129,
+,     0,   222,     0,     0,     0,     2,     0,     0,    36,
+,     0,   111,   294,    20,     0,    21,     0,   694,   450,
+,   109,     3,     2,    27,     2,     0,    33,     0,     2,
+,     0,   106,   107,    73,    74,    75,    77,    78,    80,
+,    85,    86,    83,    84,    88,    89,    91,    93,    95,
+,    99,     0,     0,   754,   294,     0,     0,     0,   649,
+,   646,   647,   499,   498,   294,     0,     3,   294,   716,
+,   721,   295,   294,   294,   294,   664,   707,   663,     2,
+,     0,     0,     0,     0,     0,     0,     0,     0,   685,
+,   671,   622,   638,   672,     2,   618,   625,   433,   620,
+,   434,     2,   632,   641,   634,   635,   668,   669,   683,
+,   715,   713,   753,   268,     2,   747,     2,   424,   719,
+,   425,     0,   403,     3,     3,     3,     3,   455,     3,
+,     2,   470,   466,   752,     0,   462,   469,     2,   465,
+,     0,   294,   242,   264,     3,   272,   274,     0,   455,
+,   573,   574,     2,   612,   613,     0,   661,   539,     3,
+,   345,   348,   347,   294,   540,     0,   541,   294,   376,
+,     2,     0,     0,     0,     0,   104,   392,   695,   696,
+,   391,   388,   692,   693,   381,   385,   294,   400,   394,
+,   751,     0,     0,   438,   240,     0,     0,     3,     2,
+,   431,     0,   529,     0,   753,   491,     0,   294,   294,
+,     0,   553,   555,   130,     0,     0,   215,     0,     0,
+,   223,   224,    57,     0,    63,   294,     0,    61,    60,
+,   128,   695,   460,    70,    71,   110,   115,     3,   109,
+,     0,     0,    24,    35,     3,     0,    32,   102,     0,
+,   652,   656,   659,   651,     3,   594,     3,   718,   723,
+,   294,     3,     3,   295,     0,     3,   624,   628,   631,
+,   674,   678,   681,   294,     3,   623,   639,   673,   294,
+,   426,   294,   294,   748,     0,     0,     0,     0,   256,
+,   104,     0,     3,     3,     0,   463,     0,   459,     0,
+,   245,   294,     0,     0,   129,     0,     0,     0,     0,
+,   129,     0,     0,   109,   109,     2,     0,     0,     0,
+,   131,   132,     2,   143,   133,   134,   135,   136,   137,
+,   145,   147,     0,     0,     0,   285,   294,   294,   549,
+,   542,   294,   111,   698,   702,   704,   697,   384,   368,
+,     0,   581,     2,   666,   665,     0,   671,     2,   484,
+,   506,     3,   514,   515,     0,     2,   510,     3,     3,
+,     0,   558,   222,     0,     0,     0,   222,     0,     0,
+,    37,   751,   109,     0,     3,   663,    42,     3,    40,
+,    34,     0,     3,   101,   103,     0,     2,   654,   655,
+,     0,   294,     0,     0,     0,     3,   640,     0,     2,
+,   627,     2,   642,     2,   676,   677,     0,     0,     3,
+,     3,     3,     3,     3,   411,   410,   414,     2,     2,
+,   749,   112,     0,     0,     0,     0,     3,   464,     3,
+,   243,   146,     3,   295,   294,     0,     0,     0,     0,
+,   191,     0,   189,     0,     0,     0,     0,     0,     0,
+,     0,   111,     0,   549,   151,   148,   294,     0,     0,
+,   279,     3,     3,   548,   615,   369,     2,   700,   701,
+,   294,   266,   294,     0,   517,   494,   294,     0,     0,
+,   508,     0,     0,     0,   216,     0,   225,    58,   109,
+,     0,   116,   113,     0,     0,     0,     0,     0,     0,
+,     0,   657,   294,   582,   265,   726,   727,   728,     0,
+,   294,   294,   294,     3,     3,     0,   687,     0,     0,
+,     0,   294,   294,     3,   546,   471,   472,     0,     0,
+,   295,     0,     0,     0,     0,   294,   192,   190,     0,
+,   193,     0,     0,     0,     0,   197,   200,   198,   194,
+,   195,    35,   129,   144,   142,   244,     0,     0,   294,
+,   422,   421,     0,   511,     2,   512,     2,   513,   507,
+,   228,     0,   226,     0,   228,     3,   663,    31,   114,
+,    45,     2,    43,    41,    28,   112,    26,     3,   729,
+,     3,     3,     0,     0,   686,   688,   629,   643,   269,
+,   408,     3,   407,     0,   474,   471,   129,     0,     0,
+,     3,     0,   129,   188,     0,     2,     2,   209,   199,
+,     0,     0,     0,   140,   576,   616,     3,     2,     0,
+,     2,   229,     0,     0,   217,     0,     0,     0,     0,
+,     0,     0,     0,     0,   689,   690,   294,     0,   473,
+,     0,     0,     2,   165,   129,   154,     0,   182,     0,
+,     0,     2,   156,     0,     2,     0,     2,     2,     2,
+,    32,     0,   294,   516,   518,   509,     0,     0,     0,
+,   114,    38,     3,     3,   658,   630,   644,   680,   412,
+,   158,   161,     0,   160,   164,     3,   167,   166,     0,
+,   184,   129,     3,     0,   294,     0,   294,     0,     2,
+,     2,   139,   703,     2,   230,   231,     0,   227,   218,
+,     0,     0,   153,     0,     0,   163,   233,   168,     2,
+,   183,     0,   186,   172,   201,     3,   210,   214,   203,
+,     0,   294,     0,   294,     0,     0,     0,    39,    46,
+,   159,   162,   129,     0,   169,   294,   129,   129,     0,
+,     0,     0,   694,   211,   212,   213,     0,   202,     3,
+,     3,   294,   219,   232,   149,   170,   155,   129,   236,
+,   180,   178,   174,   157,   129,     0,   695,     0,     0,
+,     0,   150,   171,   181,   175,   179,   178,   176,     3,
+,     0,     0,   495,   177,   205,   207,     3,     3,   206,
 };
 …
 static const yytype_int16 yydefgoto[] =
+{
       -1,   839,   474,   301,    45,   131,   132,   302,   303,   304,
 ,   785,   786,  1146,  1147,   306,   307,   308,   309,   310,
 ,   312,   313,   314,   315,   316,   317,   318,   319,  1051,
 ,   996,   321,   997,   554,   973,  1078,  1542,  1080,  1081,
 ,  1083,  1543,  1084,  1085,  1459,  1460,  1421,  1422,  1423,
 ,  1522,  1526,  1527,  1562,  1563,  1086,  1379,  1087,  1088,
 ,  1314,  1315,  1503,  1089,   143,   979,   980,   981,  1400,
 ,  1495,  1496,   475,   476,   901,   902,  1059,    48,    49,
 ,    51,    52,   345,   156,    55,    56,    57,    58,    59,
 ,    61,    62,   261,    64,    65,   272,   349,   350,    68,
 ,    70,    71,   116,    73,   202,   352,   117,    76,   118,
 ,    79,    80,   455,   456,   457,   458,   700,   939,   701,
 ,    82,   462,   721,   881,   882,   355,   356,   724,   725,
 ,   357,   358,   359,   360,   472,   339,   133,   134,   529,
 ,   168,   654,   655,   656,   657,   658,    83,   119,    85,
 ,   496,   965,   497,   275,   501,   324,    86,   135,   136,
 ,  1337,  1124,  1125,  1126,  1127,    88,    89,   742,    90,
 ,    91,    92,   185,  1053,   688,   410,   123,    93,   507,
 ,   509,   186,   266,   188,   189,   190,   267,    96,    97,
 ,    99,   100,   101,   102,   193,   194,   195,   196,   197,
 ,   613,   614,   615,   616,   198,   618,   619,   620,   579,
 ,   581,   582,   705,   103,   622,   623,   624,   625,   626,
 ,   938,   707,   708,   709,   603,   363,   364,   365,   366,
 ,   162,   105,   106,   107,   368,   719,   576
+      -1,   840,   475,   302,    46,   132,   133,   303,   304,   305,
+,   786,   787,  1148,  1149,   307,   308,   309,   310,   311,
+,   313,   314,   315,   316,   317,   318,   319,   320,  1052,
+,   997,   322,   998,   555,   974,  1079,  1545,  1081,  1082,
+,  1084,  1546,  1085,  1086,  1462,  1463,  1424,  1425,  1426,
+,  1525,  1529,  1530,  1565,  1566,  1087,  1382,  1088,  1089,
+,  1317,  1318,  1506,  1090,   144,   980,   981,   982,  1403,
+,  1498,  1499,   476,   477,   902,   903,  1060,    49,    50,
+,    52,    53,   346,   157,    56,    57,    58,    59,    60,
+,    62,    63,   262,    65,    66,   273,   350,   351,    69,
+,    71,    72,   117,    74,   203,   353,   118,    77,   119,
+,    80,   462,    81,   456,   457,   458,   459,   701,   940,
+,    82,    83,   465,   463,   722,   882,   883,   356,   357,
+,   726,   727,   358,   359,   360,   361,   473,   340,   134,
+,   530,   324,   169,   655,   656,   657,   658,   659,    84,
+,    86,   496,   497,   966,   498,   276,   502,   325,    87,
+,   137,    88,  1340,  1126,  1127,  1128,  1129,    89,    90,
+,    91,   272,    92,    93,   186,  1054,   689,   411,   124,
+,   508,   509,   510,   187,   267,   189,   190,   191,   268,
+,    98,    99,   100,   101,   102,   103,   194,   195,   196,
+,   198,   852,   614,   615,   616,   617,   199,   619,   620,
+,   580,   581,   582,   583,   706,   104,   623,   624,   625,
+,   627,   628,   939,   708,   709,   710,   604,   364,   365,
+,   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[] =
+{
+,  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,
+,  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,
+,   279,    82,  7674, -1281, -1281,  8086,  1234, -1281, -1281,
+   -1281,   981,   359,  7231,   925,   669,   981,  1012, -1281, -1281,
+,   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,
+, -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,
+, -1281, -1281,   120,  8972,  3739,   375,   387,   486,   496,
+,   527,   541,  8273,  7081,   550,   568, -1281,  9460, -1281,
+   -1281, -1281, -1281,   602, -1281,   121,  4456,  4456, -1281,   552,
+, -1281, -1281, -1281, -1281,   634,   302,   306,   327,   155,
+, -1281, -1281,  1410,  2454,   696, -1281,    90, -1281,   155,
+,   144, -1281, -1281,   124, -1281,   155,   155, -1281,  2638,
+,   667,   565,  6993, -1281, -1281,   678,  3199, -1281, -1281,
+, -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,
+, -1281, -1281, -1281,  9431, -1281, -1281,  3957, -1281,   696,
+,  9607,  6464,  2195,  2638, -1281,   157, -1281, -1281,  9574,
+,   717,  7703, -1281, -1281,   699, -1281, 10744,   783,   831,
+,   787,  6306, 10567, -1281,   827, -1281, -1281, -1281, -1281,
+, 10625,   544,  8633,   829,  6306,  9085, -1281, -1281, -1281,
+   -1281, -1281, -1281,   862, -1281,  1121,  2197,  6306, -1281,   599,
+,   472,   354,   593,   830,   867,   873,   970,   245, -1281,
+   -1281,   874,   650, -1281,   325, -1281, -1281,  3739, -1281, -1281,
+,   901, -1281,   747,   901,   958,   130, -1281, -1281,   962,
+, -1281,   977,  8746, -1281, -1281,   957,   935,  8355,  6993,
+, -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,
+,  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,
+,  8426, -1281, -1281, -1281, -1281,  9431,    79, -1281, -1281,
+,   144, -1281, -1281,  9431, -1281,  6877, -1281, -1281,   565,
+,   376,  9716,  1035,  1868,  2111, -1281,   334,   338,   815,
+   -1281,  9002,  1059,  1047,   815,   565, -1281, -1281, -1281, -1281,
+, -1281,   583,  6755, -1281,   144,  1065, -1281,  2195, 10825,
+, -1281, -1281, -1281, -1281,   889,  2638, -1281,  8497,   696,
+, -1281, -1281, -1281,  1286,   636,   874,   815,  7703,   868,
+, -1281,  7703, -1281, -1281, -1281, -1281,   638, -1281,  1073,
+,   207,  8633, -1281,  9716, -1281, -1281,  8633, -1281,  8859,
+, -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,  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,
+, -1281,  9754, -1281, -1281,   602, -1281,  1082,  1185,  1084,
+,   185,   874, -1281,   155,   155,   874,   233, -1281,   155,
+,  1061, -1281, -1281,   155,   155, -1281,   901,  9792,  1338,
+,   234,   509,  9792, -1281,  5821, -1281,   874, -1281,  9645,
+   -1281,   293,  5525,  5525,  5525,  1338, -1281,  5054,  1072,   558,
+,  1016,  1083,  1086, -1281,  1074,  4456,   592, -1281,  1172,
+,  5525,   544,  2195,   544,   696,   809,   901, -1281, -1281,
+,   901, -1281, -1281, -1281,   831, -1281,   901,   144,  9940,
+   -1281,   682,  1095,   691,  1099, -1281,  1098,   144, -1281, -1281,
+,   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,
+, -1281,  1059, 10968, -1281, -1281,  1102, -1281, -1281, -1281,
+, -1281, 10897,  6306, -1281,  5525,   675,  8355, -1281, -1281,
+,  1108,  1109,  1286,  3745, -1281, -1281,  7703, -1281, -1281,
+, -1281, -1281,  1116, -1281,  1111,  1128, 10744,  6464,   146,
+,    53,  1136,  1115,  1137,   829,  1131,  1139, -1281,  1142,
+,  1696,  6843, -1281,  6464, -1281,   668,  1691, -1281,  6022,
+,  1138, -1281, -1281,   990,   708, -1281,  6464, -1281, -1281,
+, -1281, -1281, -1281, -1281, -1281,   599,   599,   388,   388,
+,   472,   472,   472,   354,   354,   593,   830,   867,   873,
+,  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,
+,  1160,  1163,  1165,  1166,  1175,  1176,  1182, -1281,  3532,
+, -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,
+,  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,
+,   818,  1208,  1212,  1213, -1281, -1281,  1917, -1281, -1281,
+   -1281, -1281, -1281, -1281, -1281,  1868, -1281,  1047, -1281, -1281,
+,  1216,  1211, -1281, -1281,  1218,  1223, -1281,   675,  1777,
+   -1281,   562, -1281,  3745,   874, -1281,  1226,  7703,  9863,  8972,
+, -1281, -1281,  1225,  1235,  1238, -1281,  6306,   252,    40,
+, -1281,  1242,   544,  1242,  6724,  6464, -1281, -1281,  1242,
+   -1281,  1691,  5315, -1281, -1281, -1281, -1281,  1236,  6464,  1245,
+,  5054, -1281, 10490, -1281,   544, -1281, -1281,  6464, -1281,
+,   901, -1281, -1281, -1281, -1281, -1281, -1281, -1281,   990,
+, -1281, -1281,  7438,  1249, -1281,   856,   901, -1281,   872,
+,   901, -1281,   565,  4646, -1281, -1281, -1281,  9940,  9940,
+   -1281,  8426,  8426, -1281,  1252,  1255,  1264,  1271, -1281,  1253,
+,   247,  1138, -1281,   544, -1281,  4456, -1281,  6464,   459,
+   -1281,  6603,  1274,  1279, 10343,  1281,  1283,   301,   308,   344,
+,  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,
+, -1281, -1281,  2195,  1309, -1281, -1281, -1281,   734,  1312,
+   -1281,    53,  1317,  6306,  1303,    53,    53,  1327,  1323, -1281,
+,  6464,  1328,  1236,  1036,   113,  1326, -1281,  1323, -1281,
+,  1326, -1281, -1281,  1337, -1281, -1281,  1061,  1340,  1343,
+,  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,
+, -1281,  1345,  6464,  1347,  1358,  6464,  1097,  1360,    74,
+,  1197,   155, -1281, -1281,  6243,  1361,   467, -1281, -1281,
+   -1281, -1281, -1281, -1281, -1281, -1281, -1281,  1061, 10467, -1281,
+,  1362, -1281, -1281,  9863,   482,   494, -1281,  1372,  1383,
+,  1394, -1281,    66, -1281, -1281,  6464,  1395,  1393, -1281,
+   -1281,  1399,   430,   657,   544,  1400,  1401, -1281,  1406, -1281,
+, -1281, -1281, -1281, -1281, -1281,  1412, -1281,  9940,  9940,
+, -1281, -1281,  1413, -1281,  1415,  1425,  1427,   623,  8125,
+, -1281, -1281,   278, -1281,  1426,  1429, -1281,  8568,   745,
+,  1430,   769,  6445, -1281, -1281,   502, -1281, -1281,   770,
+,  1436,   144,  1487,   911, -1281, -1281,  6464, -1281, 10490,
+, -1281, -1281, -1281,  1442,  1444,  9940, -1281, -1281, -1281,
+, -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,
+,  1454, -1281, -1281, -1281, -1281, -1281, -1281, -1281,  1458,
+   -1281,  1457, -1281, -1281, 10343,   148,  6464, 10343, -1281,  1462,
+, -1281,   171,  1484,  1486, -1281, -1281,  1465,  1476,  1455,
+, -1281, -1281, -1281, -1281, -1281,  1338,  2195,  1471,   862,
+,  6306, -1281,   772,  1477,  6464,   544,   544,  1480,  1482,
+,  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,
+, -1281, -1281, -1281,   831,   544,  1520,  1499,  1515, -1281,
+,  1326, -1281, -1281, -1281, -1281, -1281, 10343,   258, -1281,
+, -1281, -1281,  7790, -1281, -1281,  1501,  6464, -1281,  6464,
+,   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,
+,  9716,  1546,  1525,   544, -1281, -1281, -1281, -1281, -1281,
+,  1541,  1051,  7866,  6464, 10165,  1543,  1051,  1551,  2099,
+, -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,
+, -1281, -1281, -1281,  9979, -1281, -1281, -1281,   144,   144,
+   -1281, -1281, -1281, -1281, -1281, -1281, -1281, -1281
+,  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,
+,    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,
+,  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,
+, -1332, -1332, -1332, -1332,   316,   182,   102, -1332,   102,
+   -1332, -1332, -1332, -1332,  9240,  1658, -1332, -1332,  1658, -1332,
+,   391, -1332, -1332, -1332,  1948,  9876, -1332,   810,   810,
+, -1332, -1332, -1332,   102, -1332, -1332, -1332,   426,   447,
+, -1332, -1332, -1332,   477, -1332, -1332, -1332, -1332, -1332,
+,   495, -1332, -1332,    36,  8974,  2459,   272,   545,   579,
+,   632,   671,   733,  8777,  7372,   596,   719, -1332,  9546,
+   -1332, -1332, -1332, -1332,   739, -1332,   209,  3245,  3245, -1332,
+,   213, -1332, -1332, -1332, -1332,   770,   237,   353,   362,
+,   755, -1332, -1332,  1834,  1803,   846, -1332,    70, -1332,
+,   102,   182, -1332, -1332,    98, -1332,   102,   102, -1332,
+,   820,   843,   810,  5405, -1332, -1332,   844,  9470, -1332,
+   -1332,   615, -1332, -1332, -1332,   182, -1332,  1658,   190, -1332,
+, -1332,   810,   810,   810,   182, -1332,  1011, -1332,  2880,
+   -1332, -1332,   827,   810, -1332,   810, -1332,   138,  8974,  8891,
+, -1332,  1062,   864,   810, -1332,  1011,   870,   879, -1332,
+,   735, -1332, -1332, -1332,  9437, -1332, -1332,  3894, -1332,
+,    69,  9876,  6310,  1948,  2479, -1332,   114, -1332, -1332,
+,  1658,   875, 11374, -1332, -1332,   546, -1332, 11116,   886,
+, 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,
+,   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,
+,  9240, -1332,  1018,  8746, -1332, -1332,  1849,  1084,  8347,
+,   615, -1332,   615,   810,   810, -1332, -1332, -1332, -1332,
+   -1332, -1332,   810,  9914,  1658, -1332, -1332,  9987,  1975, -1332,
+, -1332, -1332, -1332, -1332, -1332, -1332, -1332,  1030,  3059,
+, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332,
+   -1332, -1332, -1332, -1332, -1332,  1948, -1332,   773,  1012,  1034,
+,   889,  1045,  1051,  1053,  1803, -1332, -1332,  1063,   190,
+, -1332, -1332,  1066, -1332, -1332, -1332,  9437, -1332, -1332,
+   -1332, -1332, -1332,  2479, -1332,  8974,  8974, -1332,   810,  1948,
+,  1658,  8420, -1332, -1332, -1332, -1332,  9437,    69, -1332,
+   -1332,   615,   182, -1332, -1332,  9437, -1332,  3625, -1332, -1332,
+,   810,   464, 10025,  1068,   907,  9695, -1332,   437,   475,
+, -1332,  1067,  1069,  1047,  1070,   810, -1332, -1332, -1332,
+   -1332, 10283, -1332,   522,  6793, -1332,   182,  1074, -1332,  1948,
+,  6368, -1332, -1332, -1332, -1332,   939,  2479, -1332,  8493,
+,  5374, -1332, -1332, -1332,   828,   610,   974,  1062, 11374,
+,  9354, -1332, 11374, -1332, -1332, -1332, -1332,   618, -1332,
+,   926,   326,  8632, -1332, 10025, -1332, -1332,  8632, -1332,
+,  8632, -1332, -1332, -1332,  1077, -1332,   619,  1082,   630,
+, -1332,  5066,  7012, -1332, -1332, -1332,    47, -1332, -1332,
+, -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,  4001,  6310, -1332,   356,   777,
+   -1332, -1332,   102,   102, -1332, -1332,  8974, -1332, -1332,  1066,
+, -1332,  1066, 10842, -1332, -1332, -1332,  6075,  7012,  1086,
+,  1093, -1332, 10055, -1332, -1332,   739, -1332,  1094,   690,
+,  1090,   157,   974, -1332,   102,   102,   974,   166, -1332,
+,   102,  1066, -1332, -1332,   102,   102, -1332,   996, 10137,
+, 11343,   372,   531, 10137, -1332,  6678, -1332,   974, -1332,
+, -1332,   285,  8042,  8042,  8042,  1658, -1332,  5183,  1085,
+,  1030,   955,  1095,  1097, -1332,  1099,  3245,   590, -1332,
+,  1658,  8042,   735,  1948,   735,   846,   706,   996, -1332,
+   -1332,   806,   996, -1332, -1332, -1332,   926, -1332,   996,   182,
+, -1332,   647,  1107,   688,  1108, -1332,  1109,   182, -1332,
+   -1332,  9437,   182,  1105,   497,   502, 10167,  7492,  1400, 10919,
+, -1332, -1332,  1103,    62,  1103, -1332, -1332, -1332,   102,
+, -1332, -1332,  1062, -1332,   102, -1332, -1332,  8891,  1062,
+, 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,
+,  1092,    54,  1131,  1128,  1135,   928,  1130,  1138, -1332,
+,  1141,  9733,  7132, -1332,  6310, -1332,   630,  1274, -1332,
+,  6310,  1139, -1332, -1332,  1030,   695, -1332,  6310, -1332,
+   -1332,   741, -1332, -1332, -1332, -1332, -1332,   516,   516,   336,
+,   425,   425,   425,   425,   270,   270,   704,   934,   936,
+,   997, 10919,   754, -1332, 10283,  1150,  1151,  1153,   777,
+   -1332, -1332, -1332, -1332, -1332, 10283,   748, 10919,  8042, -1332,
+, -1332,  7612,  9316,  9126,  7372, -1332, -1332, -1332,   690,
+,   950,  1164,  1165,  1171,  1172,  1179,  1180,  1181, -1332,
+,  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,
+, -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,
+, -1332,   634, -1332,  2655,   974, -1332,  1211, 11374, 10205,
+,  1214, -1332, -1332,  1212,  1217,  1213, -1332, 10919,   229,
+,  1215, -1332,  1202,   735,  1202,  7012,  6310, -1332, -1332,
+, -1332,  1274,  3059, -1332, -1332, -1332, -1332,  1220,  6310,
+,   735,  5183, -1332, 10784, -1332,   735, -1332, -1332,  6310,
+   -1332,   863,   996, -1332, -1332, -1332, -1332, -1332, -1332, -1332,
+,  8746, -1332, -1332,  7732,  1219, -1332,   876,   996, -1332,
+,   896,   996, -1332,   810,  4775, -1332, -1332, -1332, 10283,
+, -1332,  8420,  8420, -1332,  1221,  1226,  1233,  1235, -1332,
+,   643,   137,  1139, -1332,   735, -1332,  3245, -1332,  6310,
+, -1332,  6892,  1245,  1249, 10726,  1253,  1258,   330,   380,
+,  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,
+, -1332,  9845,  9622,   932,   996, -1332, -1332, -1332, -1332,
+   -1332,  1286, -1332, -1332, -1332, -1332,  1293,  1989, -1332, -1332,
+, -1332,  1116, -1332, -1332,  1948,  1290, -1332, -1332, -1332,
+,  1292, -1332,    54,  1295, 10919,  1279,    54,    54,  1305,
+, -1332,  1099,  6310,  1308,  1220,   605,    89,  1306, -1332,
+, -1332,  1312,  1306, -1332, -1332,  1317, -1332, -1332,  1066,
+,  1322,  7252,  1323,  1325,  1326, -1332, -1332,  1329, -1332,
+   -1332,  1066, -1332, -1332, -1332, -1332,  1066,  6310,  6310, 10919,
+, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332, -1332,
+   -1332, -1332, -1332, 10919, 10919,  1332,  1335,  1306, -1332, -1332,
+, -1332, -1332, -1332,  7853, 10205,  6310,  6310,  1394,  6310,
+   -1332, -1332,  1321, -1332,  1324,  6310,  1327,  1331,  6310,  1013,
+,    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,
+,  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,
+,   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,
+, -1332, 10784, 10726, -1332, -1332, -1332,  1396,  1404, 10283,
+   -1332, -1332, -1332,  1401, -1332, -1332, -1332, -1332, -1332, -1332,
+,   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,
+, -1332,  1417,  6310, -1332,    99,  1433,  1434, -1332, -1332,
+,  1425,  1408,   852, -1332, -1332, -1332, -1332, -1332,  1658,
+,  1421,   949,   918, 10919, -1332,   832,  1426,  6310,   735,
+,  1427,  1431,  1440,  1441, -1332, -1332,  8420,  1428, -1332,
+, 10919,  1437, -1332, -1332, 10637, -1332,   845, -1332,  1424,
+,  1436, -1332, -1332,  1460, -1332,  1461, -1332,  1476,  1481,
+   -1332,  1446,  1471, 10205, -1332, -1332, -1332,   926,   735,  1472,
+,  1468, -1332,  1306,  1306, -1332, -1332, -1332, -1332, -1332,
+,   295, -1332,   940, -1332, -1332,  5671, -1332, -1332,  1454,
+, -1332,  6310,  5671,   182, 10025,   182, 10025,  1478, -1332,
+, -1332, -1332, -1332,  1480,   949, -1332,   850, -1332, -1332,
+,  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,
+,  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,
+,   853, -1332, 10415, -1332, -1332, -1332, 10322, -1332, -1332,
+   -1332,   182,   182, -1332, -1332, -1332, -1332, -1332, -1332, -1332,
+   -1332
 };
 …
 static const yytype_int16 yypgoto[] =
+{
    -1281,  4254,  1590, -1281,  1409, -1281,    52,     0,  -229, -1281,
 ,  -527,  -497,  -931,   -99,  4508, -1281,   358,   609,   563,
 ,   591,  1104,  1105,  1110,  1117,  1112, -1281,   613,  -339,
 ,  -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,
 ,   363,  -194,  1416,  4157, -1281, -1281,    24,    25,   374,
     -202,  1621, -1281,  2138, -1281, -1281,   112,  2165, -1281,  2832,
 , -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,
 , -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,
 ,  1177,  1181,  2149,  5126,  -572,  -549,  -544,  -523,  -484,
    -1281,  -427,  -665,  -663,  -660,  -602,  -320,  -271, -1281, -1281,
 ,   140,   -84, -1281,  3728,   128,  -603,  -447
+   -1332,  4383,  1919, -1332,  1457, -1332,    41,     0,  -257, -1332,
+,  -527,  -514,  -956,  -190,  3713, -1332,  1485,   580,   585,
+,   602,  1055,  1052,  1056,  1059,  1061, -1332,  -217,  -341,
+,  -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,
+,   913,  -200,  1494,  4071, -1332, -1332,    19,   107,   365,
+    -232,  1565, -1332,  2150, -1332, -1332,   134,  2571, -1332,  3063,
+, -1332, -1332, -1332,  -643,  -431,  1210,  1216,   707,   947,
+, -1332, -1332, -1332,   945,   723,  -404, -1332,  -520,  -362,
+, -1332, -1332,  -990,  -995,   965,  1194,  1083,   304, -1332,
+,   317,   -75,  -197,  -129,   679,   781, -1332,  1020, -1332,
+,  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,
+, -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
 };
 …
    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[] =
+{
+,   111,    95,   147,   451,   438,   397,   398,   426,   148,
+,   113,   112,   399,   149,   790,   400,   401,   265,   258,
+,   711,   767,   604,    66,    67,   870,   706,   111,   111,
+,    46,   932,    95,   933,   403,   750,   934,   853,   841,
+,    53,    46,   918,    46,   717,   159,   617,  1185,   748,
+,  1091,   894,   110,    46,    66,    67,   381,   382,   845,
+,  1201,   191,    46,   846,   214,    46,   852,   224,   341,
+,    47,   819,   208,  1151,   504,   218,   217,   678,  1143,
+,   111,  1183,  1184,   406,   847,   397,   398,   210,   994,
+,   636,   408,   399,   844,   640,   400,   401,   687,   141,
+,   778,    47,   423,    46,  1398,   691,    46,   842,   200,
+,   932,    74,   933,    46,   403,   934,   151,   843,   950,
+,   883,   883,  1195,   974,   682,   684,   856,    30,   477,
+,   886,    30,   863,   289,   152,  1317,   166,  1461,   883,
+,   104,   407,    74,   147,    46,   161,   159,   904,  1134,
+,   535,   121,    46,   445,   149,  1135,  1465,    46,   201,
+,   167,    30,   977,   406,   857,   481,   483,   739,   860,
+,   104,   164,   466,   841,  1341,  -234,  -234,  1009,  1098,
+,  1219,  1342,    46,    46,   120,   159,   482,  1014,   175,
+,  1418,  1419,    30,   880,    30,   676,  1262,   250,    46,
+,   754,   212,  1025,   409,  1318,   104,    46,  1481,   159,
+,   161,  1461,   883,  1418,  1419,    46,   745,   140,    46,
+,   441,   957,    30,   147,  1263,   111,   535,   279,   439,
+,   150,   417,   142,   409,   149,   375,   164,   144,   259,
+,   111,   260,   842,   440,   111,  1185,  -234,  1259,    46,
+,    95,   376,   843,   212,  1465,   595,   169,   151,    53,
+,  1420,   975,    46,    46,   487,   159,   409,   179,   841,
+,    30,   326,    66,    67,    60,   152,    46,  1037,   604,
+,   759,   199,   711,  1429,   341,   823,  1465,   535,   845,
+,   477,   111,   854,   846,   609,  1185,   212,   665,  1507,
+,  1549,   471,  1201,   674,   883,    60,  1036,   604,   433,
+,   477,  1013,   604,  1016,   847,   760,   469,  1153,   477,
+,  1560,   673,   761,  1024,   830,   680,    46,  1564,   371,
+,  1184,   685,   535,  1536,   434,  1538,  1343,   842,   573,
+,   861,  1191,   609,   523,   873,    46,    46,   843,   874,
+,   437,   925,  1491,   704,  1550,   856,   245,   212,   936,
+,    74,  -290,    46,   114,   326,    74,    46,   879,  1192,
+,   433,   108,   210,   574,  1091,   739,  1401,   652,   108,
+,   949,  1565,    40,    41,   250,   674,   853,   -10,   104,
+,    41,  -112,  -112,    46,   530,   212,   434,   161,   108,
+,   482,  1180,  1181,    46,   489,   371,   157,  -112,   845,
+,    41,   506,   385,   846,   108,   248,   388,   870,  -517,
+,   390,    46,   575,   164,  1040,    40,    41,    46,   386,
+,   738,  1209,   389,   584,   847,  1215,   391,   782,  1211,
+,   227,   392,   563,   564,   228,   915,   341,   232,   712,
+,   262,   739,   714,    46,  1456,   108,   243,   393,   111,
+,  1231,  1213,  1201,   111,   713,   256,    40,    41,   715,
+,   606,   157,   111,  -440,  1450,  1451,   712,    46,   565,
+,   175,  -112,   250,   328,   692,    46,   212,   371,  1405,
+,   585,    95,   928,    46,   788,   329,   111,   637,   111,
+,   108,   641,  -112,   210,  1120,  1149,   322,   559,   560,
+,  1101,    40,    41,    66,    67,   338,  1117,   706,   652,
+,   398,   714,  1201,    60,   110,  -441,   399,    74,   478,
+,   401,   978,   274,  1090,   405,   111,  1258,   929,   652,
+,   111,   652,  1037,   402,  1171,  1173,   895,    74,   403,
+,   276,   326,   326,   459,   504,    74,   459,  1018,   561,
+,    47,   830,   459,  1106,   477,   428,   906,   212,   284,
+,   766,   908,  1035,  1198,     8,     9,    10,    11,    12,
+,    41,  1198,   277,   227,   884,   884,   884,   783,   111,
+,   766,   727,   789,   766,   330,    46,  1332,  1323,   406,
+,   454,    74,    30,   884,   331,   520,   954,    46,  1334,
+,   341,  1380,  1333,   530,   108,   530,   774,   212,   530,
+,   832,   530,   332,   876,  1335,    40,    41,   326,    46,
+,    33,   432,  1381,  1355,   494,   333,  -466,  1132,   738,
+,   471,  1357,  1358,  1359,    46,   108,   326,   137,   138,
+,   111,   830,   533,   534,   440,   528,    40,    41,   157,
+,   369,   111,    46,   111,   555,   383,   711,  -466,  1378,
+    -466,   896,  -291,   875,  -466,  1048,   370,  1116,   884,     8,
+,    10,    11,    12,   567,   568,  1035,   341,   241,    94,
+,   478,   729,   586,   526,   409,  1095,    46,   730,    46,
+,   534,   897,   594,   651,  -105,   601,    30,   898,  -105,
+,   478,   111,   326,   905,   738,   907,   556,   111,   478,
+,   395,   557,   558,   227,   634,   232,   606,   108,   638,
+,   146,   338,    94,  1366,    33,  1128,   534,  1367,    40,
+,   212,   387,    46,    46,   746,  1428,   756,   210,   187,
+,   747,    94,   757,  1253,    94,   871,    46,   577,   407,
+,   606,   210,   736,   872,    60,   424,  1349,   578,   212,
+,  1520,  1497,   673,   212,   425,   776,  1525,   409,  1497,
+,   702,   953,   958,  1055,   609,   777,   322,   322,   430,
+,   919,  1390,   959,  1251,   903,   774,   774,  1545,   461,
+,   727,    74,  1552,   448,   171,   774,   464,   762,   108,
+,   137,   236,   764,   227,   454,   770,  1002,   454,   459,
+,    41,  1015,  1003,   454,   681,   683,   499,   730,   500,
+,   830,  1546,  1499,    94,  1500,   114,   674,    46,  1175,
+,  1006,  1003,  1247,    74,   704,   237,    94,   251,   585,
+,   238,  1291,  1292,  1374,   589,   210,   409,   832,   467,
+,   494,   212,   322,   932,   494,   933,   468,  1375,   934,
+,  1008,   396,   187,   774,   528,   212,   528,  1377,  1382,
+,  1447,   322,   528,   774,   774,   108,  1444,   137,   138,
+,   510,   506,   652,   338,   514,    94,    40,    41,  1466,
+,   652,   978,  1513,  1570,   774,   978,   978,    94,  1514,
+,    53,   289,   526,   793,   794,   795,   909,   526,   409,
+,   526,   912,    46,   409,    66,    67,   328,   409,     2,
+,     4,     5,     6,     7,   519,   727,    46,    94,   108,
+,   137,   138,   535,   415,    46,   727,  1196,   322,   569,
+,    41,   485,  1077,   250,   328,   409,   534,  1155,   828,
+,   727,   601,    46,  1167,   478,   409,   435,  1387,  1388,
+,   736,   417,   669,   409,   812,   751,   443,  1122,  1121,
+,   752,   609,   111,  1182,     2,   204,     4,     5,     6,
+,   869,   652,    34,   570,    35,   601,   487,   328,   409,
+,   571,   878,   652,   575,   111,    36,   478,   181,   182,
+,   337,  1172,    74,   609,  -292,    94,    40,    41,  1438,
+,  1339,     8,     9,    10,    11,    12,  1242,    36,   459,
+,   173,    39,  1444,  1445,  1137,   611,  1492,  1493,    40,
+,   104,  1235,   608,   409,   609,   527,   736,   440,    34,
+,    35,  1145,   610,   111,   766,    -3,  1145,   338,   854,
+,   609,  1446,   572,   652,   370,  -437,   111,   111,   111,
+,    53,     8,     9,    10,    11,    12,  1532,    33,  1458,
+,   800,   801,   802,   803,  1203,    67,   108,   596,   137,
+,   534,   111,   187,  1418,  1419,   160,   326,    40,    41,
+,   646,   940,   738,   940,   666,  1145,   667,   104,  1399,
+,   668,   192,  1399,   670,   215,  1077,   671,   225,  1210,
+,  1214,  -293,    46,   798,   799,   890,  1106,    33,     8,
+,    10,    11,    12,   338,   672,   341,   993,    36,   675,
+,   173,    39,   703,   677,  -112,   695,  -112,   871,    40,
+,  -112,  1518,  1458,  1310,  1311,  1312,    30,   804,   805,
+,   727,   212,  1348,  1350,  1351,  -112,  -112,   796,   797,
+,   255,   409,    74,   718,   374,    60,   720,  -238,    94,
+,   758,   771,   611,   534,    33,   775,   779,   -12,   893,
+,   835,  1017,   837,   689,   848,   828,   160,   111,   -13,
+,   104,   892,   459,   920,   536,   537,   538,   922,   923,
+,  -414,   208,   218,   217,  1482,   927,   698,   727,   727,
+,   948,  -521,   962,   969,   652,   747,   210,   731,   539,
+,   540,  1369,   541,   542,    53,   160,   971,     2,   204,
+,     5,     6,     7,   976,   982,   984,   986,   987,    66,
+,   988,   989,   998,  1122,  1121,    36,  1010,  1011,   160,
+,  1012,   111,   111,   111,   527,   226,    40,    41,  1026,
+,   442,  1027,   527,  1028,  1029,   127,  1077,   128,   129,
+,   536,   537,   538,  1030,  1031,   828,    40,    41,   728,
+,  1032,  1043,   838,  1057,   609,  -402,   840,  -401,   611,
+,  1442,    34,   610,    35,   539,  1558,   540,   439,   541,
+,   935,  1102,    53,  1145,  1145,  1145,  1103,  1094,   652,
+,  1104,  1105,   440,  1109,  1110,  1111,  1203,    67,  1112,
+,  1123,   322,   935,  1113,  1119,   478,    74,    36,  1129,
+,   212,    39,   104,  1130,  1079,  1136,  1122,  1121,    40,
+,  1141,   397,   398,  1131,   992,  1144,    36,  1165,   399,
+,    39,   400,   401,  1190,   104,   405,  1186,    40,    41,
+,   766,  1077,  1188,   652,    42,   402,   652,   534,   372,
+,   403,  1204,   869,   104,   145,   931,  1205,   703,  1207,
+,  1208,   727,  1216,   743,  1220,    46,    46,  1222,  1223,
+,   727,   727,    -3,   744,  1228,   111,   111,  1531,    36,
+,   172,   173,    39,  1239,    74,    63,   115,   499,   516,
+,    41,   652,  1243,  1007,  1248,  1077,   652,  1250,  1077,
+,   917,   840,   611,  1252,   736,  1255,   212,  1256,  1260,
+,  1264,  1267,   104,   926,   111,  1269,    63,   727,  1271,
+,  1121,  1272,  1273,   674,  1274,   372,   652,  1145,  1145,
+,  1275,  1277,   174,   454,   828,  1284,  1293,  1294,  1301,
+,  1330,  1304,    53,  1077,  1322,  1305,   104,  1307,  1077,
+,    36,   219,   181,   182,    39,  1336,  1203,    67,  1308,
+,  1316,    40,    41,  1203,    67,   148,  1483,   728,  1338,
+,   149,  1050,  1340,    46,   111,  1344,  1345,  1206,  1077,
+,  1352,  1353,   174,   111,   736,   174,  1354,   183,   257,
+,   239,   242,  1356,  1362,   652,  1363,   840,   184,    46,
+,  1441,   159,    53,  1364,   534,  1365,  1372,  1376,   611,
+,   213,  1383,   652,  1384,   652,  1312,  1203,    67,   652,
+,  1392,   652,  1393,    46,  1402,   371,  1533,   240,  1405,
+,   327,   174,  1412,   652,  1413,  1541,  -403,  1416,   257,
+,  1427,  1077,  1435,  1505,    74,  1505,  1077,   478,  1431,
+,  1433,    74,   338,  1436,  1443,  1437,  1367,  1448,  1452,
+,  1453,  1454,   213,  1455,  1077,  1457,  1077,  1467,  1469,
+,  1077,  1475,   104,  1077,  1299,  1300,  1123,  1302,  1462,
+,  1505,  1077,  1505,  1306,   422,  1077,  1309,   427,   429,
+,  1152,  1473,   158,  1477,   174,   703,  1479,  1480,  1485,
+,  1487,  1498,   728,   703,    74,   213,  1508,  1512,  1510,
+,  1524,   170,   728,   446,   176,   177,   178,   449,   180,
+,  1516,   611,  1517,  1539,  1544,  1540,  1551,   728,   465,
+,  1555,  1561,   104,   231,    63,  1568,   326,  1569,  1079,
+,  1050,  1221,   806,  1321,   807,   246,   247,  1100,   174,
+,   808,   463,  1519,   211,   810,   174,  1430,   429,   809,
+,   125,   126,  1571,   230,  1386,  1254,   213,  1403,  1501,
+,     8,     9,    10,    11,    12,     8,     9,    10,    11,
+,   112,    96,   427,   398,   399,   768,   933,   452,   148,
+,   400,   113,   934,   149,   150,   791,   406,   871,    67,
+,   439,   401,   512,   407,   712,   707,   935,   613,   112,
+,   402,    47,   403,    96,  1203,   404,  1092,   382,   383,
+,   618,   111,    47,   895,    47,   505,   160,  1187,   854,
+,    67,  1185,  1186,   142,    47,   749,    48,   975,   853,
+,    47,   857,   192,    47,   847,   215,    47,   864,   225,
+,   848,   751,   820,  1401,   947,   756,  1145,   218,   842,
+,   112,   112,   995,   398,   399,   933,   279,   409,    48,
+,   400,   934,   843,   121,   424,  1468,   406,   605,  1197,
+,    31,   401,  1091,   407,    47,   935,    68,    47,    31,
+,   402,   679,   403,   844,    47,   404,    61,   151,   109,
+,   165,   637,   884,   884,   884,   641,   739,  1421,  1422,
+,    42,   688,   408,    75,   153,   290,    31,   446,    68,
+,    31,   884,  1421,  1422,   280,    47,   574,   160,    61,
+,    54,   114,    31,    47,   149,   150,   467,   783,    47,
+,   372,   482,   484,  1464,   978,    75,  -234,  -234,  1510,
+,   211,   858,   410,  1265,   746,   861,  1484,   483,   251,
+,   410,   575,    54,    47,    47,   165,   160,     2,   205,
+,     5,     6,     7,  1468,   141,    31,   878,  1423,  1468,
+,   881,  1266,   478,  1539,    31,  1541,   418,    47,   410,
+,   527,   677,  1432,   842,   209,   884,    47,   219,  1468,
+,   327,   442,   488,  1080,   410,  1468,   112,   843,  1321,
+,   240,   243,  1193,   536,   149,   150,   674,  -234,   143,
+,   887,   112,   740,   675,   536,   112,   145,  1187,   844,
+,   112,    96,    35,   760,    36,   154,   596,   905,   151,
+,   152,  1099,  1202,    47,    47,   855,   160,   610,    67,
+,    47,   470,   105,   105,   862,   153,   610,    47,  1203,
+,   885,   885,   885,   435,  1102,   342,   703,    95,  1038,
+,   857,   472,   112,   705,   847,   170,   167,  1187,  1037,
+,   848,  1185,  1186,   618,   105,   200,    48,   884,   842,
+,   536,  1155,  1014,   327,  1136,    -3,   180,   681,   674,
+,   168,  1137,   843,   686,   376,   675,   441,    47,   386,
+,   147,   958,    95,   524,   739,   536,  1346,  1135,  1111,
+,   377,   682,   684,   844,   387,   435,    47,    47,   188,
+,   685,    95,   389,   605,    95,   831,    68,   937,   176,
+,   565,  1092,  1404,    47,   478,   285,    61,    47,   390,
+,   440,   479,   165,   885,  1220,  1221,    41,    42,   653,
+,   251,   329,   605,    75,   478,   926,  1208,   605,    75,
+,  1494,   464,   478,   483,    47,   566,   567,   854,   880,
+,    54,   109,   521,  -290,    47,   586,   372,   536,   260,
+,   739,   261,    41,    42,   847,   576,   246,  1194,   916,
+,   848,  1187,    47,  1017,   251,   755,  1459,  1091,    47,
+,    47,  1041,   228,    95,   527,   761,   229,   527,  1203,
+,  1552,   235,   762,  1262,   770,  1203,    95,   342,   244,
+,   740,   109,  1453,  1454,    47,   211,   560,   561,   109,
+,  1563,  1211,    41,    42,   578,   885,   410,  1567,   391,
+,    42,   397,   188,   112,   579,  -112,  1568,   393,    47,
+,  1175,   936,  1408,   874,   392,   249,    47,   875,   372,
+,    47,   813,    96,   394,    47,    95,  -112,   112,  1203,
+,   327,   327,  -520,   936,   979,  1215,  1383,    95,  1107,
+,   824,  1213,   562,   563,   111,   712,   707,   398,   399,
+,   438,   263,   105,  1119,   400,   505,   740,   896,   654,
+,  1036,   406,  -469,   479,   -10,   401,   112,    95,   407,
+,  1122,   112,   653,   618,   402,   109,   403,    48,  1080,
+,    75,   486,   713,   479,  1038,  -443,    41,    42,   907,
+,   767,   479,  1107,  -469,  -444,  -469,  1345,   909,   714,
+    -469,    75,  -112,  -112,   693,   490,   228,   327,   784,    75,
+,   767,   507,   790,   767,   789,   275,   211,  -112,  1019,
+,   715,  -291,   831,   277,  1008,   327,    47,    68,     8,
+,    10,    11,    12,   278,  1381,   737,   716,    61,    47,
+,    47,   342,   713,   172,   109,    95,   833,   715,     2,
+,     4,     5,     6,     7,    75,    41,    42,    31,   929,
+,   472,   730,  1200,   930,   557,   612,  1134,   731,   478,
+,   559,    54,   876,  1036,  1394,    47,   877,   750,  1201,
+,   176,   112,  1200,  1350,   330,    34,   252,    55,    55,
+,    47,   327,   112,    47,   112,  1528,  1500,   638,  1326,
+,   712,   642,  1051,  1500,   500,   607,   501,  1335,  1337,
+,   955,  1431,   831,    35,   109,    36,  1548,   342,   331,
+,  1049,  1555,   188,  1336,  1338,    41,    42,    47,  1420,
+,   898,  1428,   652,   906,   872,   908,   899,   370,   587,
+,   410,  1096,   112,   775,  -112,   228,  -112,   233,   112,
+,  -112,    55,   112,  1352,    55,   748,  1549,   757,   774,
+,   112,   161,   332,   758,   775,  -112,  -112,   441,   777,
+,   410,   333,   704,    47,    47,   876,  1467,   193,   778,
+,   216,  1471,   416,   226,  -105,    37,   920,    47,  -105,
+,   936,    37,   775,   105,  1056,    40,    41,    42,  1502,
+,  1503,   954,    41,    42,   605,   436,   675,   703,    95,
+,   334,  1493,   612,  1370,   705,   444,     8,     9,    10,
+,    12,  1154,    43,  1254,  1393,   568,   569,   922,   839,
+,   610,   892,   146,   775,  1003,   228,   109,   479,   611,
+,  1004,   410,   347,   737,   910,    31,   410,    41,    42,
+,     9,    10,    11,    12,    75,  1550,   959,   371,   610,
+,   211,   764,   161,  1177,   765,  1252,   960,   771,    47,
+,   933,  1051,   335,    34,   211,   373,   934,   375,    31,
+,    47,  1294,  1295,   833,   528,  1007,  1004,  1016,  1250,
+,   935,   831,   945,   731,   586,   775,    75,  1562,   948,
+,  1009,   161,   464,  1562,   384,   979,    34,    55,   388,
+,   979,   251,   329,   410,  1562,   578,   396,   410,  1562,
+,   941,  1378,   941,   653,   161,   579,   841,   775,   612,
+,   112,   653,  1380,    40,   329,   410,   443,    55,   775,
+,    41,    42,  1385,   115,   913,   740,   410,   936,   775,
+,    67,   138,   237,    47,   537,   538,   539,  1198,   425,
+,    41,    42,   109,   873,   138,   139,   744,    47,   211,
+,  1391,  1450,  1078,    41,    42,    47,   745,  1447,   540,
+,   541,   426,   542,   543,  1469,   431,   238,   158,   449,
+,   775,   239,  1573,    47,   904,  1517,  1441,  1004,   586,
+,  -367,  1157,   919,   410,   753,   936,   936,  -396,    37,
+,   182,   183,    40,   112,  1169,   932,   410,   704,   491,
+,    42,  1172,   653,   610,   511,  1342,   740,   418,   670,
+,   112,   468,   690,   653,  1174,   112,   610,   290,    68,
+,   469,   138,   139,   515,   373,   698,   257,   410,    61,
+,    41,    42,   158,   699,  1139,   700,   109,   520,   138,
+,   536,   841,   612,  1447,  1448,    75,   732,    41,    42,
+,  1237,  1147,   410,   654,   767,   327,  1147,   488,   329,
+,  1061,   242,    54,   570,   112,  1495,  1496,   323,   855,
+,   610,   507,  1449,   571,   653,   891,   339,   112,   112,
+,  1313,  1314,  1315,   528,  1351,  1353,  1354,  1535,   528,
+,  1205,   528,   128,  1402,   129,   130,   131,  1402,   572,
+,   573,   373,   112,    41,    42,  1147,   872,  1421,  1422,
+,     9,    10,    11,    12,   576,  1078,   338,  1010,  1212,
+,  1216,   801,   802,   803,   804,  -440,   429,  1015,   594,
+,   433,   667,  1302,  1303,    47,  1305,   841,  1107,    31,
+,   441,  1309,  1026,   109,  1312,   138,   139,   342,   612,
+,   798,   647,   654,   668,    41,    42,   799,   800,    55,
+,   323,   455,  1521,  1461,   671,    37,    34,   182,   183,
+,   672,    37,   673,   182,   183,    40,    41,    42,    68,
+,   806,   676,    41,    42,   105,   678,   256,   721,   479,
+,   718,   759,   433,   723,   719,   495,   936,  -238,   772,
+,   347,   776,   609,   162,   610,    75,   780,   834,   609,
+,   610,   -12,   611,   936,   836,   838,   529,   849,   611,
+,   901,   -13,    54,   893,   894,   218,   921,   923,   928,
+,   924,    47,  -417,   977,   949,   704,   653,  -292,  -524,
+,   970,   748,   972,   704,     8,     9,    10,    11,    12,
+,   983,   105,  1061,   984,   985,    67,   987,   988,   925,
+,   990,   612,   927,   595,   999,   347,   602,  1123,   162,
+,  1012,  -293,  1013,    31,   112,   112,   112,  1078,     8,
+,    10,    11,    12,  1027,  1028,   635,   936,   936,   737,
+,  1029,  1030,   339,     8,     9,    10,    11,    12,  1031,
+,  1033,    34,  1044,  -405,  1445,  1427,  -404,    31,  1093,
+,   347,   347,   347,  1095,  1103,  1147,  1147,  1147,  1104,
+,   211,  1561,    31,  1106,  1112,   993,  1113,  1114,  1115,
+,  1121,   653,   653,  1131,  1205,    34,  1132,   775,  1167,
+,  1138,  1182,  1183,    68,   105,  1143,  1188,   323,   323,
+,    34,  1189,  1190,    61,  1191,  1192,   537,   538,   539,
+,  1123,   398,   399,  1206,   209,   219,   434,  1207,   400,
+,    75,  1209,   767,  1078,   406,   455,  1210,  1222,   455,
+,   540,   407,   541,  1218,   542,  1322,   653,    54,   402,
+,   403,  1225,   777,   404,   410,  1224,   115,   460,   674,
+,  1233,    -3,   778,   347,  1230,   675,  1235,  1124,    47,
+,  1240,  1534,  1242,   500,  1246,  1251,  1253,   441,   112,
+,  1255,   495,    68,   323,  1258,   495,  1259,  1078,   434,
+,  1078,  1267,   479,  1270,   653,   529,  1272,   529,  1274,
+,   529,  1275,   323,   529,  1276,   728,  1277,  1278,  1280,
+,  1304,  1287,   531,  1296,   339,   162,  1297,   112,  1325,
+,  1147,   440,  1307,  1123,  1333,  1308,    54,  1339,  1310,
+,  1341,  1343,  1311,  1348,  1319,  1078,  1347,  1349,  1355,
+,  1078,    37,  1357,   182,   183,    40,  1359,   105,  1365,
+,  1367,  1368,    41,    42,  1205,   347,  1101,  1375,  1486,
+,  1124,  1205,   347,    64,   116,  1379,  1386,   148,   323,
+,  1078,  1387,   149,   150,  1315,  1395,    47,   112,   698,
+,   410,   175,   602,  1396,  1398,  1405,   112,  1415,   700,
+,  1416,  1408,   653,  -406,  1419,    64,  1430,   653,  1434,
+,  1438,    47,    47,  1439,   160,  1446,  1455,  1451,   159,
+,  1456,   870,  1460,  1370,  1205,   653,   602,   653,  1536,
+,  1458,   653,   879,  1465,   653,  1470,    47,  1544,   372,
+,   220,   175,   653,  1078,   175,  1358,   653,  1472,  1078,
+,  1476,  1478,    68,  1360,  1361,  1362,  1480,  1482,   105,
+,  1483,  1488,   479,  1489,  1490,  1501,  1078,  1511,  1078,
+,  1519,  1513,  1078,  1124,  1515,  1078,  1527,   258,  1520,
+,  1542,   460,  1547,  1078,   460,  1543,    75,  1078,   339,
+,   175,  1556,   105,   213,  1558,  1564,    54,   327,  1571,
+,  1223,  1397,   808,    54,   807,  1324,    55,   809,   212,
+,   455,   810,    68,  1219,   811,  1522,  1433,  1574,   231,
+,  1389,  1257,   479,   347,   728,  1504,   241,   258,   349,
+,  1229,   942,  1108,     2,   205,     4,     5,     6,     7,
+,   495,   531,   694,   531,   729,   213,   531,   951,   695,
+,  1110,  1142,   826,   175,  1057,  1120,    54,   900,   405,
+,   212,   214,   227,   816,   339,   742,   973,     8,     9,
+,    11,    12,     0,   423,   817,   965,   428,   430,   818,
+,   347,   159,  1444,     0,     0,     0,     0,     0,   213,
+,     0,     0,     0,     0,     0,   105,    31,     0,    35,
+,    36,     0,   447,   212,   214,     0,   450,   175,   451,
+,     0,   173,   174,    40,   175,     0,     0,   466,   105,
+,    41,    42,  1018,    64,    34,   105,   829,     0,   480,
+,     0,   182,   183,    40,     0,     0,     0,     0,   487,
+,    41,    42,     0,     0,     0,     0,   430,   517,     0,
+,     0,     0,     0,     0,     0,   123,   126,   127,     0,
+,   534,   535,     0,     0,   212,   214,   698,     0,   410,
+,     0,     0,   556,     0,     0,     0,   700,     0,   105,
+,     0,     0,     0,   175,   728,     0,     0,   213,     0,
+,     0,   213,     8,     9,    10,    11,    12,     0,     0,
+,   175,     0,   212,   214,   175,     0,   212,   214,   535,
+,     0,     0,     0,     0,   258,     0,   829,   603,     0,
+,   455,    31,   506,   631,     0,     0,   253,     0,   254,
+,     0,     0,     0,     0,     0,     0,   636,     0,     0,
+,   636,    55,    55,   258,   535,     0,   460,     0,     0,
+,     0,     0,     0,   729,    37,  1388,   182,   183,    40,
+,   495,  1125,   323,     0,    55,    41,    42,   175,     0,
+,     0,   182,   183,    40,     0,     0,     0,     0,   213,
+,    41,    42,     0,     0,    55,    37,     0,   182,   183,
+,   480,   184,     0,   212,   214,     0,    41,    42,     0,
+,    37,   185,   173,   174,    40,   349,  1532,     0,   410,
+,   480,    41,    42,   870,     0,     0,  1533,     0,   480,
+,   415,     0,   184,     0,   419,     0,   421,   422,     0,
+,   347,     0,   185,     0,     0,     0,     0,   371,    55,
+,     0,     0,     0,    55,   724,     0,     0,   430,     0,
+,     0,   171,     0,     0,   177,   178,   179,     0,   181,
+,     0,     0,   738,     0,    64,     0,     0,     0,     0,
+,     0,     0,   430,   232,   212,   214,   430,    55,     8,
+,    10,    11,    12,   728,   728,   247,   248,     0,   729,
+,     0,   212,     0,     0,   455,   829,     0,     0,   729,
+,     0,   182,   183,    40,     0,   258,   349,    31,     0,
+,    41,    42,     0,   729,  1505,     0,  1509,     0,     0,
+,     0,   794,   795,   796,   212,   214,    37,     0,   173,
+,    40,     0,     0,   175,     0,    34,   264,    41,    42,
+,     0,   728,   728,     0,     0,     0,   265,     0,     0,
+,     0,  1538,   819,  1540,   347,     0,   460,     0,     0,
+,     0,     0,     0,   375,   535,     0,   175,     0,     0,
+,   636,   832,     0,   603,     0,   460,     0,   959,     0,
+,    55,     0,   175,     0,   851,     0,     0,   960,     0,
+,     0,     0,     0,     0,     0,     0,  1569,   175,  1570,
+,     0,     0,   603,    55,     0,     0,     0,   603,     0,
+,    55,  1577,  1578,   636,   339,     0,   349,   349,   349,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   213,     0,     0,   349,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   212,   214,
+,     0,     0,     0,   724,     0,     0,     0,     0,     0,
+,   213,    73,     0,    55,   480,   213,     0,     0,     0,
+,   738,     0,     0,   938,     0,   212,   214,     0,     0,
+,   212,   214,     0,     0,     0,  1331,     0,     0,     0,
+,     0,     0,     0,     0,   175,     0,   221,     0,   535,
+,     0,     0,     0,     0,     0,     0,   480,     0,     0,
+,     0,     0,   729,   729,     0,     0,     0,   728,   964,
+,     0,   430,     0,     0,     0,   728,   728,   728,     0,
+,   460,     0,  1125,     0,     0,     0,     0,     0,     0,
+,     0,     0,   601,   608,   994,   258,   738,     0,     0,
+,     0,   992,     0,   213,   632,   633,     0,     0,   125,
+,   125,     0,     0,     0,     0,     0,     0,   213,   212,
+,   729,   729,     0,   728,     0,     0,     0,     0,     0,
+,     0,     0,   212,   214,   352,     0,     0,     0,   724,
+,     0,   535,     0,     0,     0,     0,     0,     0,   724,
+,     0,   349,   506,   636,     0,     0,  1024,   636,   832,
+,     0,   821,   822,   724,     0,     0,     0,     0,     0,
+,     0,     0,     0,  1035,     0,     0,     0,     0,     0,
+,     0,   125,     0,     0,     0,  1125,     8,     9,    10,
+,    12,   856,     0,     0,   859,   860,     0,   863,     0,
+,   866,     0,     0,     0,   867,   868,   274,     0,   448,
+,   175,   213,     0,     0,     0,    31,     0,  1507,     0,
+,     0,     0,     0,     0,     0,    64,   212,   214,     0,
+,     0,     0,     0,     0,    73,   412,     0,     0,     0,
+,     0,     0,   420,    34,     0,     0,     0,   636,    37,
+,   182,   183,    40,     0,  1507,     0,  1507,     0,     0,
+,    42,     0,   125,     0,  1332,     0,     0,     0,     0,
+,   125,     0,   125,   125,     0,     0,     0,   125,     0,
+,   125,     0,     0,  1117,   323,  1532,     0,   410,   943,
+,     0,   430,   116,     0,   946,  1533,   729,     0,     8,
+,    10,    11,    12,     0,   729,   729,   729,     0,     0,
+,     0,     0,     0,     0,   412,     0,     0,     0,     8,
+,    10,    11,    12,     0,     0,     0,     0,    31,     0,
+,     0,     0,     0,     0,     0,   535,     0,     0,     0,
+,     0,     0,     0,     0,   603,     0,     0,    31,     0,
+,     0,     0,   729,     0,     0,    34,     0,   428,     0,
+,    37,     0,   724,   724,    40,   349,   349,     0,     0,
+,   584,    41,    42,     0,     0,    34,   517,     0,   588,
+,    37,   591,   182,   183,    40,  1204,     0,     0,     0,
+,     0,    41,    42,     0,     0,     0,    73,    43,     0,
+,    76,     0,     0,   213,     0,     0,     0,   146,     0,
+,     0,   352,     0,     0,     0,     0,    73,   264,   212,
+,   724,   724,     0,     0,    73,     0,   636,   265,     0,
+,     0,     0,    76,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   412,     0,     0,     0,   420,
+,   352,     0,     0,  1508,     0,  1508,     0,   544,   545,
+,   547,   548,   549,   550,   551,   552,   553,   222,   352,
+,    73,     0,     0,   952,     0,   953,     0,     0,     0,
+,     0,     0,   956,   957,     0,   738,     0,   962,     0,
+,  1508,   554,  1508,   535,     8,     9,    10,    11,    12,
+,     0,     0,     0,     0,   971,     0,     0,     0,   175,
+,     0,     0,   352,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,    31,     0,     0,     0,     0,  1301,
+,  1000,     0,     0,   412,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,   258,     0,     0,     0,
+,    64,    34,     0,     0,     0,   354,    37,     0,     0,
+,    40,     0,     0,     0,   724,     0,   738,    41,    42,
+,   116,     0,     0,     0,     0,   601,     0,   352,     0,
+,     0,     0,     0,   213,     0,     0,     0,     0,     0,
+,     0,     0,     0,   744,     0,     0,   724,     0,   212,
+,     0,     0,     0,   745,   724,   724,   724,     0,     0,
+,     0,     0,     0,     0,     0,   349,   349,     0,     0,
+,     0,     0,   352,   352,   352,   584,   584,     0,     0,
+,     0,     0,  1045,  1046,  1047,  1048,     0,  1050,     0,
+,     0,   352,     0,     0,     0,     0,     0,     0,     0,
+,    76,     0,   724,  1094,     0,    76,     0,     0,     0,
+,     0,     0,     0,   116,   125,   125,     0,  1100,     0,
+,    73,     0,     0,     0,     0,     0,   352,     0,  1234,
+,   213,     0,     0,     0,     0,   175,     0,     0,     0,
+,     0,     0,     0,     0,   125,   212,   214,   125,   125,
+,   125,     0,   125,   125,     0,     0,  1116,   125,   125,
+,     0,     0,    73,     0,   911,   352,     0,     0,   914,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,  -294,     0,
+,   349,     0,     0,     0,     0,     0,  1144,     0,    31,
+,   222,   412,   352,  1152,     0,     0,     0,     0,  1156,
+,     0,     0,     0,  1160,     0,  1161,   116,     0,     0,
+,  1164,  1165,     0,     0,  1168,     0,    34,     0,     0,
+,     0,     0,     0,  1180,     0,     0,   125,  -294,     0,
+,     0,   125,   125,     0,   352,     0,  1204,   125,     0,
+,     0,  1195,  1196,  1323,   352,     0,     0,   352,     0,
+,     0,     0,   221,     0,   352,     0,     0,    76,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,  1226,
+,     0,  1228,   354,     0,     0,     0,     0,    76,     0,
+,     0,     0,     0,     0,     0,    76,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,  1557,     0,     0,
+,     0,     0,     0,     0,     0,     0,   584,     0,     0,
+,  1244,   354,     0,     0,     0,     0,  1248,  1249,     0,
+,     0,    73,     0,     0,     0,     0,     0,     0,  1260,
+,     0,    76,    78,  1264,     0,     0,  1268,     0,  1269,
+,     0,  1271,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,  1279,     0,     0,     0,     0,
+,     0,     0,     0,     0,    78,   281,   282,  1286,   283,
+,  1289,  1290,  1291,   354,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,  1298,     0,  1299,     0,
+,     0,   171,     0,     0,   284,     0,     0,     0,     0,
+,   649,     0,   138,   139,   286,   352,     0,   287,   650,
+,   290,    41,    42,     0,   291,   292,     0,     0,     0,
+,  1327,  1328,   293,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   294,   354,
+,     0,   652,   379,     0,     0,     0,   296,   380,   298,
+,   300,   301,     0,     0,     0,     0,     0,     0,   352,
+,     0,   352,   352,     0,     0,     0,     0,     0,     0,
+,     0,     0,  1363,  1364,     0,     0,     0,     0,     0,
+,     0,    73,  1374,   354,   354,   354,     0,   355,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,  1158,
+,     0,     0,   354,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,  1170,     0,   352,   352,     0,
+,   354,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,    76,     0,     0,  1407,     0,     0,   354,     0,
+,     0,     0,     0,     0,     0,     0,  1411,     0,  1412,
+,  1414,   281,   282,     0,   283,     0,     0,     0,     0,
+,  1418,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,    76,     0,     0,   354,     0,     0,
+,   284,   352,    78,     0,     0,  1442,   285,    78,     0,
+,   286,  1238,     0,   287,   288,   289,   290,    41,    42,
+,   291,   292,     0,     0,     0,     0,     0,    85,   293,
+,     0,     0,     0,   354,     0,     0,     0,     0,     0,
+,     0,   125,     0,   294,   221,   378,     0,     0,   379,
+,     0,     0,   296,   380,   298,   299,   300,   301,     0,
+,     0,  1491,  1492,     0,     0,     0,    73,     0,     0,
+,     0,     0,     0,     0,  1497,   354,     0,     0,     0,
+,   352,  1497,   352,     0,     0,   354,     0,     0,   354,
+,     0,     0,     0,   222,   224,   354,     0,     0,     0,
+,   354,     0,   223,     0,     0,     0,     0,     0,     0,
+,     0,     0,   352,     0,  1531,     0,     0,     0,  1537,
+,   352,   352,   352,     0,     0,     0,     0,     0,     0,
+,     0,   352,   352,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,    73,     0,  1559,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,    76,     0,     0,     0,   125,     0,   352,
+,     0,     0,     0,     0,     0,     0,     0,  1575,  1576,
+,     0,     0,   362,     0,   355,  1579,  1580,     0,     0,
+,     0,     0,     0,     0,     0,  -519,     0,    78,     1,
+,     3,     4,     5,     6,     7,     8,     9,    10,    11,
 ,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,  -294,  1227,    25,    26,    27,   693,    30,
+,  1107,   941,   722,    30,   213,   211,  1056,   478,   213,
+,  1140,   825,  1118,   899,   478,   935,   964,  1331,   741,
+,   815,     0,     0,   816,   174,   257,    33,   817,   602,
+,   252,    33,   253,  1391,   630,     0,     0,     0,    37,
+,     0,   174,  -294,     0,     0,   174,  1424,   635,   211,
+,     0,   635,     0,     0,   257,     0,     8,     9,    10,
+,    12,     0,     0,     0,     0,     0,     0,   478,   776,
+,   409,     0,  1123,   935,   935,   337,     0,     0,   777,
+,     0,     0,     0,   109,    30,     0,     0,  1417,   653,
+,  1425,     0,     0,     0,  1217,   213,     0,     0,     0,
+,     0,   479,     0,     0,  1504,     0,  1504,     0,   174,
+,     0,     0,    33,   394,     0,     0,   348,     0,     0,
+,     0,   479,     0,   413,   414,     0,   728,   728,   418,
+,   420,   421,     0,     0,     0,  1464,     0,     0,     0,
+,  1468,  1504,     0,  1504,     0,     0,     0,   211,     0,
+,     0,   211,     0,     0,   958,   723,   609,     0,   429,
+,     0,     0,     0,     0,   959,     0,     0,   505,     0,
+,  1490,   322,     0,   737,   463,    63,   213,     0,     8,
+,    10,    11,    12,   429,   728,   728,     0,   429,     0,
+,     0,     0,     0,     0,     0,     0,     8,     9,    10,
+,    12,     0,   600,   607,     0,     0,    30,   749,    36,
+,   181,   182,    39,     0,   631,   632,   257,   348,     0,
+,    41,     0,     0,     0,    30,     0,   213,     0,     0,
+,     0,     0,     0,     0,    33,     0,     0,     0,   211,
+,     0,   181,   182,    39,     0,   697,     0,   409,     0,
+,    40,    41,    33,   698,     0,   699,  1559,    36,     0,
+,   182,    39,  1559,   818,     0,     0,     0,     0,    40,
+,     0,     0,     0,  1559,   174,     0,   608,  1559,   609,
+,     0,   635,   831,   935,   602,     0,   610,     0,     0,
+,     0,     0,     0,     0,   697,   850,   409,     0,     0,
+,   935,     0,     0,     0,   699,     0,     0,   174,     0,
+,     0,     0,     0,   602,     0,     0,     0,     0,   602,
+,     0,     0,     0,   174,   635,     0,  1329,   348,   348,
+,     0,     0,     0,     0,  1385,     0,   211,     0,   174,
+,     0,   181,   182,    39,     0,     0,   348,     0,     0,
+,    40,    41,     0,     0,     0,     0,     0,     0,   728,
+,     0,   891,     0,     0,   723,     0,   728,   728,   728,
+,     0,     0,     0,   935,   935,   479,   697,   213,   409,
+,   257,   737,   213,     0,   937,     0,   699,     0,     0,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    72,     0,
+,    26,    27,     0,     0,   728,     0,     0,   479,    30,
+,   348,     0,   944,     0,     0,     0,     0,     0,   947,
+,     0,     0,   429,     0,    75,   174,     0,     0,    72,
+,     0,   181,   182,    39,     0,     0,    33,     0,     0,
+,    40,    41,     0,    37,    38,     0,   257,   737,     0,
+,     0,     0,   991,     0,     0,    75,     0,     0,     0,
+,   213,     0,     0,   220,     0,     0,  1529,     0,   409,
+,     0,     0,     0,     0,   213,     0,  1530,   485,     0,
+,   453,     0,   211,  1502,   710,  1506,     0,     0,   109,
+,   221,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   348,     0,   635,   820,   821,  1023,   635,
+,   211,     0,     0,     0,   723,   211,     0,     0,     0,
+,  1535,     0,  1537,     0,  1034,    36,     0,   181,   182,
+,     0,     0,     0,     0,     0,   855,    40,    41,   858,
+,     0,   862,     0,   864,   865,     0,     0,     0,   866,
+,     0,   351,   543,   544,   545,   546,   547,   548,   549,
+,   551,   552,   263,     0,     0,  1566,     0,  1567,   213,
+,     0,     0,   264,   951,     0,   952,    63,     0,   353,
+,  1574,  1575,   955,   956,     0,     0,   553,   961,     0,
+,     0,   174,     0,   653,     0,   411,     0,     0,   635,
+,  1060,     0,   419,   211,   970,     0,     0,     8,     9,
+,    11,    12,     0,     0,     0,     0,     0,   211,     0,
+,     0,     0,     0,     0,     0,   447,     0,     0,     0,
+,   999,     0,   942,   943,  1115,    30,     0,   505,   945,
+,     0,     0,   429,   115,     0,     0,    72,     0,     0,
+,     0,    72,     0,     0,     0,     0,     0,     0,     0,
+,   348,     0,     0,    33,     0,     0,     0,     0,    36,
+,   181,   182,    39,    75,   411,   600,     0,     0,    75,
+,    41,     0,     0,     0,     0,   124,   124,   124,     0,
+,     0,     0,   653,     0,     0,   602,     0,     0,     0,
+,     0,     0,     0,     0,     0,  1529,     0,   409,   427,
+,     0,   211,     0,   723,   723,  1530,   348,   348,     0,
+,     0,     0,     0,     8,     9,    10,    11,    12,     0,
+,   583,     0,  1044,  1045,  1046,  1047,  1202,  1049,   587,
+,     0,   590,     0,     0,     0,     0,   220,     0,     0,
+,     0,    30,     0,  1093,     0,     0,   124,     0,   124,
+,   213,     0,     0,     0,     0,     0,     0,  1099,     0,
+,     0,   723,   723,   221,     0,     0,     0,   635,     0,
+,     0,     0,     0,   273,    36,     0,   181,   182,    39,
+,     0,     0,  1060,     0,     0,    40,    41,     0,     0,
+,     0,     0,     0,     0,   411,     0,  1114,     0,   419,
+,     0,     0,     0,    72,     0,     0,     0,     0,     0,
+,     0,   183,     0,     0,     0,     0,     0,     0,   351,
+,     0,   184,     0,    72,     0,   737,     0,     0,     0,
+,    75,    72,     0,     0,     0,     0,  1142,   124,     0,
+,   124,     0,     0,  1150,   124,   353,   124,   124,  1154,
+,    75,     0,     0,  1158,     0,  1159,     0,   351,    75,
+,  1162,  1163,     0,     0,  1166,     0,     0,     0,  1298,
+,     0,     0,     0,  1178,     0,   351,     0,    72,   174,
+,     0,     0,     0,   411,   353,   257,     0,     0,  1297,
+,    63,  1193,  1194,   211,     0,     0,     0,     8,     9,
+,    11,    12,   353,   723,    75,   737,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   124,     0,  1224,
+,     0,  1226,     0,     0,     0,    30,     0,     0,     0,
+,     0,     0,     0,     0,     0,   723,     0,     0,     0,
+,     0,     0,     0,   723,   723,   723,   353,     0,     0,
+,     0,     0,     0,    33,   348,   348,     0,     0,    36,
+,   181,   182,    39,     0,     0,  1245,  1246,     0,  1202,
+,    41,     0,     0,     0,     0,   583,   583,  1257,     0,
+,     0,     0,  1261,     0,   351,  1265,     0,  1266,     0,
+,  1268,   723,     0,     0,     0,   263,     0,     0,     0,
+,     0,     0,   115,  1276,     0,   264,     0,     0,     0,
+,     0,   353,  1232,     0,     0,     0,  1283,     0,  1285,
+,  1287,  1288,     0,     0,     0,   213,     0,     0,     0,
+,   351,   351,     0,     0,  1295,     0,  1296,     0,     0,
+,   170,     0,     0,     0,     0,     0,     0,     0,   351,
+,     0,     0,     0,     0,   174,     0,   353,   353,   353,
+,     0,     0,     0,     0,   910,     0,   351,     0,   913,
+,  1325,     0,   211,     0,     0,   353,     0,    72,     0,
+,     0,    77,     0,   351,     0,     0,     0,     0,     0,
+,     0,     0,     0,   353,     0,     0,     0,     0,     0,
+,     0,   411,     0,     0,    75,   115,     0,     0,    84,
+,   353,     0,    77,     0,    54,    54,     0,     0,     0,
+,  1360,  1361,   351,     0,     0,     0,     0,     0,  1202,
+,  1371,     0,     0,     0,     0,  1202,  1320,     0,     0,
+,     0,     0,     0,     0,     0,    54,    75,   222,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,   211,
+,     0,     0,     0,     0,   223,     0,     0,    54,     0,
+,    54,     0,  1404,     0,     0,     0,   353,     0,  1202,
+,     0,     0,     0,     0,  1408,  1554,  1409,  1410,  1411,
+,     0,   351,     0,     0,     0,     0,     0,     0,  1415,
+,     0,   351,     0,     0,   351,     0,   583,  1426,     0,
+,     0,   351,     0,     0,     0,     0,   351,     0,   353,
+,     0,   124,   124,  1439,     0,   354,     0,     0,   353,
+,     0,   353,     0,     0,     0,     0,   221,     0,   353,
+,     0,     0,     0,   353,     0,     0,     0,     0,     0,
+,     0,   124,   361,     0,   124,   124,     0,   124,   346,
+,   124,     0,     0,     0,   124,   124,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,    72,
+,  1489,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,  1494,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,    75,     0,     0,     0,
+,    23,    24,    25,   355,     0,    26,    27,    28,    29,
+,     0,    30,     0,     0,    31,    32,     0,     0,     0,
+,     0,   355,     0,    78,     0,     0,   354,     0,     0,
+,     0,     0,     0,     0,     0,     0,   352,     0,     0,
+,     0,     0,    34,     0,    35,     0,    36,    37,     0,
+,    39,    40,     0,     0,     0,     0,     0,    85,    41,
+,     0,     0,    85,     0,     0,   355,     0,  1034,     0,
+,     8,     9,    10,    11,    12,     0,     0,     0,     0,
+,   354,     0,   354,   354,    43,    73,    44,     0,     0,
+,     0,     0,    73,     0,    45,     0,     0,   281,   282,
+,   283,     0,    76,     0,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,  -295,     0,     0,     0,   284,    34,     0,
+,   355,     0,   285,    31,     0,     0,   286,   354,   354,
+,   288,   289,   290,    41,    42,    73,   291,   292,     0,
+,     0,     0,     0,     0,   293,     0,     0,   224,     0,
+,     0,    34,     0,     0,     0,     0,     0,     0,     0,
+,     0,   378,  -295,     0,     0,   355,   355,   355,   296,
+,   298,   299,   300,   301,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   355,     0,     0,     0,     0,
+,     0,     0,   354,     0,     0,     0,     0,     0,     0,
+,     0,     0,   355,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,    78,    85,     0,     0,     0,   164,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,    85,   222,     0,   217,     0,
+,     0,     0,    85,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,    78,     0,    76,   355,
+,     0,     0,     0,     0,     0,     0,     0,     0,   362,
+,     0,   354,     0,   354,     0,     0,     0,     0,     0,
+,     0,     0,     0,   164,     0,     0,   362,     0,    85,
+,     0,     0,     0,     0,     0,   355,     0,     0,     0,
+,     0,     0,     0,   354,     0,     0,     0,     0,     0,
+,     0,   354,   354,   354,     0,     0,     0,     0,   164,
+,     0,     0,   354,   354,     0,     0,     0,     0,   368,
+,   362,     0,   374,     0,     0,     0,    76,   355,     0,
+,     0,     0,     0,     0,     0,     0,     0,   355,     0,
+,   355,     0,     0,     0,     0,   223,     0,   355,     0,
+,     0,     0,   355,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,   164,     0,    26,    27,    28,     0,     0,     0,
+,     0,     0,    31,   217,     0,   362,     0,     0,     0,
 ,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,    77,     0,     0,    54,     0,    77,     0,     0,     0,
+,     0,     0,  1528,     0,     0,     0,  1534,     0,     0,
+,     0,     0,     0,   124,     0,     0,     0,    84,   124,
+,     0,     0,    84,    54,   124,     0,     0,     0,     0,
+,     0,     0,   351,     0,     0,  1556,     0,  1557,     0,
+,     0,   164,   461,     0,     0,     0,     0,     0,     0,
+,    34,     0,     0,     0,    78,     0,     0,   206,    39,
+,     0,     0,     0,     0,     0,   374,     0,     0,     0,
+,   362,   362,   362,   164,     0,     0,     0,   354,     0,
+,     0,     0,     0,   514,     0,   516,   519,     0,     0,
+,     0,     0,     0,   522,   523,     0,     0,   461,   516,
+,   164,     0,   270,     0,     0,     0,     0,   362,     0,
+,   516,     0,     0,     0,     0,     0,     0,     0,    85,
+,     0,     0,     0,     0,   362,     0,    76,   281,   282,
+,   283,     0,     0,    76,     0,     0,     0,     0,   355,
+,     0,     0,     0,     0,     0,     0,   516,   606,     0,
+,     0,     0,   630,     0,     0,     0,   284,     0,     0,
+,    85,     0,   285,   362,     0,     0,   286,     0,     0,
+,   288,   289,   290,    41,    42,     0,   291,   292,     0,
+,     0,     0,   516,     0,   293,     0,    76,     0,     0,
+,     0,   355,   355,     0,   355,   355,     0,     0,     0,
+,   362,   378,     0,     0,     0,     0,     0,   812,   296,
+,   298,   299,   300,   301,    78,     0,     0,     0,     0,
+,     0,     0,     0,     0,   210,     0,     0,     0,   164,
+,     0,     0,     0,     0,   230,   368,   234,     0,   236,
+,     0,     0,   362,     0,     0,   245,     0,     0,     0,
+,   355,     0,   362,     0,     0,   362,   461,     0,     0,
+,   224,     0,   362,     0,     0,     0,     0,   362,     0,
+,     0,     0,     0,     0,     0,     0,   210,     0,   234,
+,   245,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   741,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   164,     0,     0,     0,     0,
+,     0,     0,     0,     0,   355,     0,   461,     0,   461,
+,     0,   461,     0,   164,   461,     0,     0,     0,     0,
+,     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,   223,     0,
+,   516,   516,   516,   516,   516,   516,   516,   516,   516,
+,   516,   516,   516,   516,   516,   516,   516,     0,     0,
+,   210,     0,   234,   236,   245,     0,     0,     0,     0,
+,     0,     0,     0,   355,     0,   355,     0,     0,     0,
+,     0,   368,   516,   606,     0,     0,   837,     0,     0,
+,     0,     0,     0,   362,     0,     0,     0,     0,   210,
+,     0,     0,   210,     0,     0,   355,     0,     0,     0,
+,     0,     0,   606,   355,   355,   355,     0,   606,   504,
+,     0,     0,     0,     0,   355,   355,   368,   368,   368,
+,     0,     0,     0,     0,     0,     0,     0,     0,    78,
+,     0,     0,     0,     0,     0,   368,   362,   362,     0,
+,   362,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   355,     0,     0,     0,     0,     0,     0,   210,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   741,   516,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   234,   236,   155,     0,     0,
+,     0,   461,   245,   516,   362,   362,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   516,     0,     0,
+,     0,   961,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,     0,   250,     0,     0,   210,     0,     0,     0,
+,     0,    31,   255,     0,     0,     0,   741,     0,     0,
+,     0,     0,   516,   210,     0,     0,     0,     0,   210,
+,   210,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   210,     0,
+,   210,   210,     0,     0,   516,     0,     0,     0,    78,
+,     0,     0,     0,     0,     0,    78,   210,     0,   155,
+,     0,   368,   224,     0,     0,   630,     0,     0,   368,
+,   210,     0,   385,     0,     0,     0,     0,   210,     0,
+,     0,     0,     0,     0,    85,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,   417,     0,     0,   362,
+,   362,     0,     0,     0,     0,     0,     0,     0,    78,
+,     0,     0,     0,     0,     0,     0,     0,     0,   437,
+,     0,     0,     0,     0,     0,     0,     0,     0,   445,
+,   362,     0,     0,     0,     0,     0,     0,     0,   362,
+,   362,     0,     0,     0,     0,     0,     0,     0,     0,
+,   362,     0,     0,   471,     0,     0,     0,     0,   481,
+,     0,   461,     0,    85,     0,     0,     0,     0,     0,
+,     0,   489,     0,     0,     0,     0,     0,   499,     0,
+,   461,     0,     0,     0,     0,     0,   362,     0,     0,
+,     0,     0,     0,   210,     0,     0,     0,   533,     0,
+,     0,     0,     0,   164,     0,     0,     0,     0,     0,
+,   516,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   210,     0,     0,     0,     0,   210,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   593,   516,     0,     0,     0,   598,     0,     0,     0,
+,     0,     0,     0,   516,   606,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,   644,   362,   368,   368,   645,   646,
+,   648,     0,     0,     0,     0,     0,     0,   660,   661,
+,   662,   663,     0,   664,   516,   665,     0,     0,     0,
+,     0,  1178,     0,     0,     8,     9,    10,    11,    12,
+,     0,     0,   593,     0,   210,     0,     0,     0,     0,
+,   680,     0,     0,    85,     0,     0,     0,     0,   210,
+,    85,   281,   282,    31,   283,   461,     0,     0,     0,
+,     0,     0,     0,     0,     0,   691,     0,     0,   504,
+,     0,     0,     0,     0,     0,     0,   697,     0,     0,
+,   284,    34,     0,     0,     0,     0,   285,   516,     0,
+,   286,     0,     0,   287,   288,   289,   290,    41,    42,
+,   291,   292,     0,    85,     0,   736,     0,     0,   293,
+,   471,     0,     0,     0,     0,   741,     0,     0,     0,
+,     0,     0,     0,   294,     0,   378,     0,     0,     0,
+,     0,   516,   296,  1179,   298,   299,   300,   301,     0,
+,     0,     0,   210,     0,     0,   516,   516,   773,     0,
+,     0,     0,     0,     0,     0,     0,     0,   217,     0,
+,     0,   210,     0,   788,     0,     0,     0,     0,     0,
+,   204,     2,   205,     4,     5,     6,     7,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,     0,   741,    26,    27,
+,   815,     0,     0,     0,     0,     0,    31,     0,     0,
+,     0,     0,     0,     0,     0,     0,   828,     0,     0,
+,     0,   835,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   850,     0,    34,     0,    35,     0,    36,
+,     0,   206,    39,    40,     0,   368,   368,     0,   210,
+,    41,    42,     0,     0,   217,     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,   208,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   210,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,  -294,   210,    26,    27,    28,     0,
+,     0,     0,     0,     0,    31,   210,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   516,     0,     0,
+,     0,     0,     0,     0,   250,     0,     0,     0,     0,
+,   368,     0,    34,   516,   968,   969,     0,     0,     0,
+,    39,     0,     0,  -294,     0,     0,     0,     0,   986,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,  1001,     0,  1002,     0,
+,     0,  1006,     0,     0,   643,     0,   338,     0,     0,
+,     0,     0,     0,     0,   110,     0,     0,   210,   461,
+,   461,     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,
+,   282,     0,   283,     0,     0,   461,     0,   461,     0,
+,     0,     0,     0,     0,     0,     0,     0,  1039,     0,
+,     0,     0,     0,     0,  1040,     0,     0,     0,   284,
+,     0,     0,     0,     0,   285,   164,     0,  1042,   286,
+,     0,   287,   288,   289,   290,    41,    42,     0,   291,
+,     0,     0,     0,  1055,   210,     0,   293,     0,     0,
+,  1059,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   294,  1097,   378,     0,  1098,     0,     0,   781,
+,   296,   380,   298,   299,   300,   301,     0,     0,     0,
+,     0,     0,     0,   598,     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,   413,     0,
+,     0,   210,     0,     0,   413,     0,     1,     2,     3,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,     0,  1162,    26,    27,    28,    29,     0,     0,
+,     0,     0,    31,    32,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,     0,     0,    26,    27,    28,    33,     0,
+,    34,     0,    35,    31,    36,    37,   413,    38,    39,
+,     0,     0,     0,     0,     0,     0,    41,    42,   533,
+,     0,     0,     0,     0,     0,  1227,     0,     0,     0,
+,     0,    34,     0,     0,     0,     0,     0,     0,    38,
+,     0,     0,    43,     0,    44,     0,     0,     0,  -523,
+,     0,     0,    45,     0,   321,  1241,     0,     0,     0,
+,  1243,     0,   413,     0,   345,     0,     0,     0,  1247,
+,   413,   589,     0,   413,   592,     0,   381,   381,     0,
+,     0,     0,     0,   363,     0,     0,     0,   622,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   640,     0,     0,
+,     0,  1281,     0,     0,  1282,     0,  1283,     0,     0,
+,   282,     0,   283,     0,     0,     0,     0,     0,     0,
+,  1292,  1293,     0,     0,     0,     0,   413,     0,     0,
+,   413,     0,     0,     0,     0,     0,     0,   321,   284,
+,     0,     0,  1306,     0,   285,     0,     0,     0,   286,
+,     0,   287,   288,   289,   290,    41,    42,     0,   291,
+,     0,   363,   485,     0,     0,     0,   293,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   210,     0,
+,     0,   294,     0,   378,   413,     0,   993,     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,   413,     0,     0,   363,
+,     0,     0,     0,     1,     2,   205,     4,     5,     6,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,  -294,
+,    26,    27,    28,    29,     0,     0,    30,     0,   413,
+,     0,   341,   363,     0,     0,     0,     0,  1399,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,   381,
+,     0,     0,  1409,     0,  1410,     0,     0,    34,     0,
+,     0,    36,     0,     0,    38,    39,     0,     0,  -294,
+,     0,     0,  1417,     0,     0,     0,     0,   413,   413,
+,     0,     0,     0,     0,     0,     0,     0,     0,  1435,
+,     0,     0,     0,     0,     0,     0,   830,   363,     0,
+,  1443,    44,     0,  1247,     0,     0,     0,     0,   622,
+,   622,   622,     0,     0,     0,     0,     0,   622,     0,
+,     0,     0,     0,     0,     0,  1466,     0,   869,   363,
+,     0,     0,     0,   363,  1473,     0,     0,  1475,     0,
+,  1479,  1481,   363,   363,   363,     0,     0,     0,     0,
+,   735,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   363,     0,     0,     0,     0,   413,   912,     0,
+,   413,   915,     0,     0,     0,     0,     0,   917,     0,
+,     0,  1512,     0,  1514,     0,     0,  1247,     0,     0,
+,     0,     0,     0,     0,     0,   341,   363,   413,     0,
+,     0,  1526,   782,   413,     0,     0,     0,     0,     0,
+,     0,     0,   769,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,   792,   793,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,   363,   622,     0,     0,
+,     0,     0,     0,     0,     0,   814,     0,     0,     0,
+,     0,     0,     0,     0,     0,   823,     0,     0,     0,
+,     0,     0,   345,     0,     0,     0,     0,   782,     0,
+,     0,   341,   363,     0,     0,     0,   413,   413,     0,
+,     0,     0,     0,     1,     2,     3,     4,     5,     6,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,     0,
+,    26,    27,    28,    29,     0,     0,    30,   889,   413,
+,    32,     0,     0,     0,     0,     0,   381,   363,     0,
+,     0,     0,     0,   830,   363,     0,     0,     0,   622,
+,   622,     0,     0,     0,    33,     0,     0,    34,     0,
+,   622,    36,    37,     0,    38,    39,    40,     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,    44,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,  -294,   830,    26,    27,    28,     0,     0,
+,     0,   413,     0,    31,     0,     0,     0,   413,     0,
+,     0,     0,   782,     0,   991,   413,     0,     0,     0,
+,   996,     0,     0,     0,     0,     0,     0,  1005,   622,
+,     0,    34,     0,     0,     0,     0,    37,     0,   336,
+,    40,     0,  -294,     0,     0,     0,     0,    41,    42,
+,     0,     0,     0,     0,     0,   363,     0,     0,     0,
+,     0,   413,     0,     0,     0,     0,     0,     0,     0,
+,     0,  1022,  1023,   643,   345,   338,     0,     0,     0,
+,   413,  1159,     0,   634,     0,     0,     0,     0,     0,
+,   363,     0,     0,     0,     0,     0,   413,  1171,     0,
+,   622,  1176,     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,     0,     0,   381,     1,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,    29,     0,     0,    30,     0,
+,    31,     0,   830,   413,  1239,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   622,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,    34,
+,    35,     0,    36,     0,     0,    38,    39,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,  1140,  1141,     0,     0,
+,     0,   363,   381,     0,     0,     0,   281,   282,   996,
+,     0,  1150,    44,   769,     0,     0,     0,     0,     0,
+,   110,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,  1166,     0,   284,     0,     0,     0,
+,     0,   285,     0,     0,  1181,   286,     0,     0,   287,
+,   289,   290,    41,    42,     0,   291,   292,     0,     0,
+,     0,   341,     0,   293,   281,   282,   381,   283,  1199,
+,     0,     0,     0,     0,     0,     0,     0,     0,   294,
+,   378,     0,   363,   996,   996,     0,     0,   296,   380,
+,   299,   300,   301,   284,     0,     0,     0,     0,     0,
+,     0,     0,     0,   286,  1231,     0,   287,   288,   289,
+,    41,    42,     0,   291,   292,     0,     0,     0,     0,
+,     0,   293,     0,     0,     0,     0,     0,     0,     0,
+,     0,   363,   363,     0,     0,     0,   294,     0,   378,
+,     0,     0,     0,     0,     0,   296,   734,   298,   299,
+,   301,     0,   996,     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,  1284,  1285,     0,
+,     0,     0,     0,     0,     1,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,    29,     0,     0,    30,   281,
+,    31,  1062,  1063,     0,  1064,     0,     0,  1065,  1066,
+,  1068,  1069,  1070,  1071,  1072,     0,     0,     0,  1073,
+,     0,     0,  1074,  1075,     0,    33,   363,   284,    34,
+,    35,     0,    36,   649,     0,    38,    39,   286,   996,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,  1076,     0,     0,   170,     0,     0,     0,
+,   297,   298,   299,   300,   301,     0,     0,     0,     0,
+,     0,     0,     0,  -129,     0,     0,     0,     0,     0,
+,     0,   769,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   413,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,     0,     0,    26,    27,
+,     0,   413,   413,     0,     0,     0,    31,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   413,     0,     0,
+,     0,     0,     0,     0,    34,     0,     0,     0,     0,
+,     0,   206,    39,     0,     0,     0,     0,  1452,     0,
+,     0,     0,     0,     0,     1,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,    29,     0,   629,    30,   281,
+,    31,   283,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,     0,    26,    27,    28,     0,     0,   284,    34,
+,    35,    31,    36,   285,     0,    38,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,   109,     0,    38,    39,     0,
+,   294,     0,  1076,     0,     0,    41,    42,     0,     0,
+,   297,   298,   299,   300,   301,     0,     0,     0,     0,
+,     0,   321,     0,  -129,     1,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,    29,     0,     0,    30,   281,
+,    31,   283,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,     0,    26,    27,    28,     0,     0,   284,    34,
+,    35,    31,    36,   285,     0,    38,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   206,    39,     0,
+,   294,     0,    44,     0,     0,     0,     0,     0,     0,
+,   297,   298,   299,   300,   301,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,     0,     0,     0,     0,   281,
+,    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,   284,    34,
+,    35,     0,    36,   285,     0,    38,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,   343,     0,     0,     0,     0,   781,     0,
+,   344,   298,   299,   300,   301,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,     0,     0,     0,     0,   281,
+,    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,   284,    34,
+,    35,     0,    36,   285,     0,    38,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,   931,     0,     0,     0,     0,   781,     0,
+,   344,   298,   299,   300,   301,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,     0,     0,     0,     0,   281,
+,    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,   284,    34,
+,    35,     0,    36,   285,     0,    38,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,   931,     0,     0,     0,     0,   781,     0,
+,   600,   298,   299,   300,   301,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,     0,     0,     0,     0,   281,
+,    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,   284,    34,
+,    35,     0,    36,   285,     0,    38,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,   343,     0,     0,     0,     0,     0,     0,
+,   344,   298,   299,   300,   301,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,     0,     0,     0,     0,   281,
+,    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,   284,    34,
+,    35,     0,    36,   285,     0,    38,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,   931,     0,     0,     0,     0,     0,     0,
+,   344,   298,   299,   300,   301,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,     0,     0,     0,     0,   281,
+,    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,   284,    34,
+,    35,     0,    36,   285,     0,   206,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,  1020,     0,     0,     0,     0,     0,     0,
+,  1021,   298,   299,   300,   301,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,     0,     0,     0,     0,   281,
+,    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,   284,    34,
+,    35,     0,    36,   285,     0,   206,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,   378,     0,     0,     0,     0,     0,     0,
+,   380,   298,   299,   300,   301,   204,     2,   205,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,     0,    26,    27,    28,     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,    35,     0,    36,     0,     0,   206,    39,     0,
+,   205,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,     0,     0,    26,    27,    28,     0,
+,     0,     0,     0,   207,    31,     0,     0,     0,     0,
+,     0,   270,     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,
+,    39,    40,     0,     0,     0,     0,     0,     0,    41,
+,     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,   208,     2,   205,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,     0,     0,     0,     0,     0,
+,    31,     0,     0,     0,     0,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,     0,     0,    26,    27,    28,    34,
+,    35,     0,    36,     0,    31,    38,    39,     0,     2,
+,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,    34,     0,    26,    27,    28,   109,     0,
+,    39,  -402,   687,    31,     0,     0,     0,     0,    41,
+,   634,     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,
+,     0,     0,     0,     0,   110,     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,   687,     0,     0,     0,
+,     0,     0,     0,   634,     2,   205,     4,     5,     6,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,     0,
+,    26,    27,    28,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,  -294,     0,    26,    27,    28,    34,     0,
+,     0,    36,     0,    31,    38,    39,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,  1373,     0,     0,
+,     0,    34,     0,     0,     0,     0,    37,     0,   336,
+,    40,   687,  -294,     0,     0,     0,     0,    41,    42,
+,     2,   205,     4,     5,     6,     7,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,     0,   338,    26,    27,    28,
+,     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,    34,     0,    35,     0,    36,     0,
+,   206,    39,     0,     2,   205,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,     0,     0,
+,    27,    28,     0,     0,     0,     0,     0,   269,    31,
+,     0,     0,     0,     0,     0,   629,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,    34,     0,    35,
+,    36,     0,     0,    38,    39,     0,     2,   205,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,     0,    26,    27,    28,     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,    35,     0,    36,     0,     0,    38,    39,     0,
+,   205,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,     0,     0,    26,    27,    28,     0,
+,     0,     0,     0,   599,    31,     0,     0,     0,     0,
+,     0,   634,     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,
+,    39,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,     0,     0,     0,     0,   281,
+,    31,   283,     0,     0,     0,     0,   207,     0,     0,
+,     0,     0,     0,     0,   270,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   284,    34,
+,     0,     0,     0,   285,     0,    38,    39,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,   525,     0,     0,   170,     0,     0,     0,
+,   297,   298,   299,   300,   301,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,     0,     0,    26,    27,    28,     0,
+,     0,     0,   281,   282,    31,   283,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,     0,     0,    26,    27,    28,
+,     0,   284,    34,     0,     0,    31,     0,   285,     0,
+,    39,   286,     0,     0,   287,   288,   289,   290,    41,
+,     0,   291,   292,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,    34,     0,     0,     0,     0,    37,
+,   336,   337,    40,     0,   294,     0,   599,    -3,     0,
+,    42,     0,     0,   296,   600,   298,   299,   300,   301,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,   338,     0,
+,    27,    28,     0,     0,     0,   110,   281,   282,    31,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,     0,
+,    26,    27,    28,     0,     0,   284,    34,     0,     0,
+,   453,   649,     0,    38,    39,   286,     0,     0,   287,
+,   289,   290,    41,    42,     0,   291,   292,     0,     0,
+,     0,     0,     0,   293,     0,     0,     0,    34,     0,
+,     0,     0,     0,     0,    38,    39,     0,     0,   294,
+     -35,   766,     0,     0,     0,     0,     0,     0,   296,   297,
+,   299,   300,   301,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,   454,     0,    26,    27,    28,     0,     0,     0,
+,   281,   282,    31,   283,     0,     0,     0,     0,     0,
 ,     0,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,     0,
+,    25,    26,    27,     0,     0,  1572,  1573,     0,  1156,
+,   452,     0,     0,  1576,  1577,     0,     0,     0,     0,
+,     0,     0,     0,     0,  1168,   351,   351,     0,   351,
+,   222,     0,     0,     0,     0,     0,     0,    33,     0,
+,     0,     0,     0,     0,    37,    38,     0,     0,    72,
+,     0,     0,   353,   353,     0,   353,   353,   223,     8,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    34,    26,    27,    28,     0,   285,     0,    38,    39,
+,    31,     0,   287,   288,   289,   290,    41,    42,     0,
+,   292,     0,     0,     0,     0,     0,     0,   293,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,    34,
+,     0,     0,   294,     0,   295,    38,    39,     0,     0,
+,     0,   296,   297,   298,   299,   300,   301,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,     0,     0,    26,    27,
+,   643,     0,   338,     0,   281,   282,    31,   283,     0,
+,   110,     0,     0,     0,     0,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,   284,    34,    26,    27,    28,     0,
+,     0,    38,    39,   286,    31,     0,   287,   288,   289,
+,    41,    42,     0,   291,   292,     0,     0,     0,     0,
+,     0,   293,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,    34,     0,     0,     0,   294,     0,   156,
+,    39,     0,     0,     0,     0,   296,   297,   298,   299,
+,   301,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,     0,    26,    27,    28,   643,     0,   338,     0,   281,
+,    31,   283,     0,     0,   634,     0,     0,     0,     0,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,   284,    34,
+,    27,    28,     0,   285,     0,    38,    39,   286,    31,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,    34,     0,     0,
+,   294,     0,   599,    38,    39,     0,     0,     0,     0,
+,   600,   298,   299,   300,   301,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,     0,     0,    26,    27,    28,     0,
+,   256,     0,   281,   282,    31,   283,     0,     0,   110,
+,     0,     0,     0,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,   284,    34,    26,    27,    28,     0,   285,     0,
+,    39,   286,    31,     0,   287,   288,   289,   290,    41,
+,     0,   291,   292,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,    34,     0,     0,     0,   294,     0,   378,    38,    39,
+,     0,     0,     0,   296,   380,   298,   299,   300,   301,
+,     2,   205,     4,     5,     6,     7,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,   156,     0,    26,    27,    28,
+,     0,     0,   110,     0,     0,    31,     0,     0,     0,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,     0,     0,
+,    27,    28,     0,    34,     0,    35,     0,    36,    31,
+,    38,    39,     0,     0,     0,     0,     0,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,     0,    34,    26,    27,
+,     0,    37,     0,    38,    39,    40,    31,     0,     0,
+,    -3,     0,    41,    42,     0,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,     0,    34,    26,    27,    28,    43,
+,   156,    38,    39,    40,    31,     0,     0,     0,    45,
+,    41,    42,     0,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,     0,    34,    26,    27,    28,    43,    37,    44,
+,    39,    40,    31,     0,     0,     0,    45,     0,    41,
+,     0,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+    -294,    34,    26,    27,    28,    43,    37,   269,   336,   337,
+,    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,    34,
+,     0,     0,   643,     0,   338,    38,    39,     0,     0,
+    -294,     0,     0,   634,     0,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,     0,     0,    26,    27,    28,     0,     0,
+,   643,     0,   338,    31,   453,     0,     0,     0,     0,
+,   634,     0,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,  -294,    34,    26,    27,    28,     0,     0,     0,    38,
+,     0,    31,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,     0,    26,    27,    28,     0,     0,     0,     0,
+,     0,    31,   453,     0,     0,   454,    38,    39,     0,
+,  -294,     0,     0,   110,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,    38,    39,     0,
+,     0,     0,     0,   338,     0,     0,     0,     0,     0,
+,     0,   110,     0,     0,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,     0,   454,    26,    27,    28,  1109,     0,
+,     0,   110,     0,    31,   453,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,     0,     0,    26,    27,    28,     0,
+,     0,    34,     0,     0,    31,     0,     0,     0,    38,
+,     0,     0,     0,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,     0,    34,    26,    27,    28,     0,     0,     0,
+,    39,     0,    31,     0,     0,   454,     0,     0,     0,
+,     0,     0,     0,   110,     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,   270,     0,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,     0,     0,    26,    27,    28,
+,     0,     0,     0,     0,   256,    31,     0,     0,     0,
+,     0,     0,   634,     0,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,     0,    34,    26,    27,    28,     0,     0,
+,    38,    39,     0,    31,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,     0,     0,    26,    27,    28,     0,     0,
+,     0,    34,     0,    31,     0,     0,     0,   338,    38,
+,     0,     0,     0,     0,     0,   634,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,    34,     0,     0,     0,     0,     0,     0,   206,
+,     0,     0,     0,     0,     0,   454,     0,     0,     0,
+,     0,     0,     0,   110,     0,     0,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,     0,   269,    26,    27,    28,
+,     0,     0,     0,   629,     0,    31,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,     0,     0,    26,    27,    28,
+,     0,     0,     0,    34,     0,    31,     0,     0,     0,
+,    38,    39,     0,     0,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,     0,    34,    26,    27,    28,     0,     0,
+,    38,    39,     0,    31,     0,     0,     0,   599,     0,
+,     0,     0,     0,     0,     0,   634,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,    34,     0,     0,     0,     0,     0,   338,    38,
+,     0,     0,     0,     0,     0,   110,     2,   205,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,     0,    26,    27,    28,    44,     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,    35,     0,    36,     0,     0,    38,    39,   281,
+,     0,   283,  1063,     0,  1064,     0,     0,  1065,  1066,
+,  1068,  1069,  1070,  1071,  1072,     0,     0,  1551,  1073,
+,     0,     0,  1074,  1075,     0,    33,     0,   284,     0,
+,     0,     0,  -415,   649,     0,     0,     0,   286,     0,
+,   287,   288,   289,   290,    41,    42,     0,   291,   292,
+,     0,     0,     0,     0,     0,   293,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   294,     0,   378,     0,     0,   170,     0,     0,     0,
+,   380,   298,   299,   300,   301,     0,     0,     0,     0,
+,     0,   281,   282,  -129,   283,  1063,     0,  1064,     0,
+,  1065,  1066,  1067,  1068,  1069,  1070,  1071,  1072,     0,
+,     0,  1073,     0,     0,     0,  1074,  1075,     0,    33,
+,   284,     0,     0,     0,     0,     0,   649,     0,     0,
+,   286,     0,     0,   287,   288,   289,   290,    41,    42,
+,   291,   292,     0,     0,     0,     0,     0,     0,   293,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,   294,     0,   378,     0,     0,   170,
+,     0,     0,   296,   380,   298,   299,   300,   301,     0,
+,     0,     0,  1077,     0,     0,     0,  -129,     2,   205,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,     0,     0,    26,    27,    28,     0,     0,     0,
+,     0,     0,    31,     0,   281,   282,     0,   283,  1063,
+,  1064,  1421,  1422,  1065,  1066,  1067,  1068,  1069,  1070,
+,  1072,     0,     0,  1551,  1073,     0,     0,     0,  1074,
+,    34,    33,    35,   284,    36,     0,     0,    38,    39,
+,     0,     0,     0,   286,     0,     0,   287,   288,   289,
+,    41,    42,     0,   291,   292,     0,     0,     0,     0,
+,     0,   293,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   294,     0,   378,
+,     0,   170,     0,     0,     0,   296,   380,   298,   299,
+,   301,     0,     0,   281,   282,  1077,   283,  1063,     0,
+,  1421,  1422,  1065,  1066,  1067,  1068,  1069,  1070,  1071,
+,     0,     0,     0,  1073,     0,     0,     0,  1074,  1075,
+,    33,     0,   284,     0,     0,     0,     0,     0,   649,
+,     0,     0,   286,     0,     0,   287,   288,   289,   290,
+,    42,     0,   291,   292,     0,     0,     0,     0,     0,
+,   293,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,   294,     0,   378,     0,
+,   170,     0,     0,     0,   296,   380,   298,   299,   300,
+,     0,     0,   281,   282,  1077,   283,  1063,     0,  1064,
+,     0,  1065,  1066,  1067,  1068,  1069,  1070,  1071,  1072,
+,     0,     0,  1073,     0,     0,     0,  1074,  1075,     0,
+,     0,   284,     0,     0,     0,     0,     0,   649,     0,
+,     0,   286,     0,     0,   287,   288,   289,   290,    41,
+,     0,   291,   292,     0,     0,     0,     0,     0,     0,
+,   281,   282,     0,   283,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   294,     0,   378,     0,     0,
+,     0,     0,     0,   296,   380,   298,   299,   300,   301,
+,     0,     0,     0,  1077,     0,   649,     0,     0,     0,
+,     0,     0,   287,   288,   289,   290,    41,    42,     0,
+,   292,     0,     0,     0,     0,     0,     0,   293,   281,
+,     0,   283,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   294,     0,   785,     0,     0,   281,   282,
+,   283,   296,   380,   298,   299,   300,   301,   284,     0,
+,     0,     0,     0,   285,     0,     0,     0,   286,     0,
+,   287,   288,   289,   290,    41,    42,   284,   291,   292,
+,     0,     0,   285,     0,     0,   293,   286,     0,     0,
+,   288,   289,   290,    41,    42,     0,   291,   292,     0,
+,   294,     0,   378,     0,   293,   281,   282,     0,   283,
+,   827,   298,   299,   300,   301,     0,     0,     0,     0,
+,     0,     0,     0,     0,   281,   282,     0,   283,   296,
+,   298,   299,   300,   301,   284,     0,     0,     0,     0,
+,   285,     0,     0,     0,   286,     0,     0,   287,   288,
+,   290,    41,    42,   284,   291,   292,     0,     0,     0,
+,     0,     0,   293,   286,     0,     0,   287,   288,   289,
+,    41,    42,     0,   291,   292,     0,     0,   294,     0,
+,     0,   293,   281,   282,     0,   283,   296,   380,   298,
+,   300,   301,     0,     0,     0,     0,   518,     0,     0,
+,     0,     0,     0,     0,     0,   296,   380,   298,   299,
+,   301,   284,     0,     0,     0,     0,     0,   285,     0,
+,     0,   286,     0,     0,   287,   288,   289,   290,    41,
+,     0,   291,   292,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   521,     0,     0,     0,     0,
+,     0,     0,     0,   296,   380,   298,   299,   300,   301,
+,   205,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,     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,    34,     0,    35,     0,    36,    37,     0,
+,   174,    40,     0,     0,     0,     0,     0,     0,    41,
+,   204,     2,   205,     4,     5,     6,     7,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,     0,     0,    26,    27,
+,     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,    34,     0,    35,     0,    36,
+,     0,   206,    39,   474,     2,   205,     4,     5,     6,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,     0,
+,    26,    27,    28,     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,    34,     0,
+,     0,    36,     0,     0,    38,    39,     2,   205,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,     0,    26,    27,    28,     0,     0,     0,     0,
+,     0,    31,     0,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,     0,     0,    26,    27,    28,   492,   493,   494,
+,     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,
+,    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[] =
+{
+,     1,     0,   203,   184,   184,   520,   698,   238,    43,
+,   184,     1,   698,    43,    43,   543,   185,   629,     0,
+,   218,   184,   280,   185,   456,   455,   698,   348,    29,
+,   184,    32,   184,    32,  1062,   184,   902,   167,   168,
+,   348,     1,    43,   656,    45,   278,    45,  1043,   611,
+,    32,  1042,  1043,    32,    55,   497,     0,   759,   611,
+,    61,   612,    61,    64,   609,    64,    67,   618,    67,
+,   609,   499,   579,  1340,   718,   503,   999,    67,   609,
+,    81,    82,   780,   264,   264,   777,    51,   186,    32,
+,   264,   777,   609,    82,   200,  1425,   265,   344,  1055,
+,    39,   264,   902,   265,   105,   777,     0,   108,    39,
+,   264,   417,   264,   609,   115,   264,     0,    43,    72,
+,    45,   363,   643,   644,   645,   367,   489,    44,    45,
+,    84,   437,    64,     0,    43,    82,    39,   227,    32,
+,    39,   662,    44,    45,   109,   146,    95,   146,    32,
+,     0,     1,    39,   154,   184,   184,   246,   111,   159,
+,   159,   260,   261,  1495,   111,    32,    44,    45,  1477,
+,    64,   613,   111,    85,   495,   617,  1443,   109,   109,
+,   111,   130,    32,   184,   185,   110,   185,     4,     5,
+,     7,     8,     9,  1523,   109,    39,   638,   114,  1528,
+,   642,   113,   255,  1512,    39,  1514,   109,   208,   111,
+,   294,   409,   114,   744,    64,   736,   217,    67,  1548,
+,   145,   220,   109,   902,   111,  1555,   227,   744,   132,
+,    81,    82,    96,    82,   264,   264,   405,   115,    11,
+,   645,   242,   489,   405,    82,   246,   109,  1243,   744,
+,   251,   250,    69,   511,    71,   112,   341,   662,   184,
+,   184,   110,  1062,   264,   265,   109,   265,   111,   250,
+,   271,   250,     0,     1,   109,   184,   111,   278,  1306,
+,   643,   644,   645,   208,   928,   370,   455,     0,   851,
+,   841,   251,   293,   455,   839,   114,   107,  1293,   851,
+,   839,  1292,  1293,   611,    32,     3,   250,   828,   839,
+,    82,  1009,   819,   238,   110,   132,   116,   423,   487,
+,   131,   117,   839,   429,   116,   487,   220,   328,   116,
+,    43,   736,    45,   293,   697,    82,  1259,   109,   951,
+,   132,   425,   426,   839,   132,   270,   347,   348,    61,
+,   426,    64,   116,   600,    67,   597,   250,   699,    55,
+,    91,  1227,   109,   364,   417,    72,   250,   368,   132,
+,   220,   255,   297,   736,  1074,  1075,    83,    84,   379,
+,   109,   110,   629,   250,   437,   691,  1065,   634,   255,
+,    96,   242,   445,   109,   395,   126,   127,   960,   640,
+,   250,    72,   109,     3,   405,   116,   405,    82,   105,
+,   773,   108,    83,    84,   959,   131,   116,   123,   676,
+,   959,  1417,   423,   828,   109,   501,  1417,  1227,   429,
+,   431,   873,    68,   146,   518,   110,    72,   521,  1466,
+,  1528,    77,   117,  1143,   520,  1473,   159,   532,    84,
+,   697,    72,  1409,  1410,   455,   349,   121,   122,    72,
+,  1548,   132,    83,    84,   109,   828,   111,  1555,   116,
+,    84,   184,   185,   474,   119,   110,  1555,   116,   479,
+,  1031,   699,   117,   112,   132,     0,   487,   116,   487,
+,   491,   575,   491,   132,   495,   208,   131,   498,  1526,
+,   425,   426,     0,   721,   762,   119,  1306,   220,   938,
+,   586,   132,    88,    89,   474,   947,   946,   698,   698,
+,   217,   131,   250,   965,   698,   758,   773,   657,   379,
+,   851,   700,    80,   417,   109,   698,   537,   250,   700,
+,   968,   542,   543,   851,   698,    72,   698,   491,  1227,
+,   417,   264,   116,   437,  1117,   109,    83,    84,   664,
+,   520,   445,   992,   111,   109,   113,   117,   666,   132,
+,   437,   115,   116,   110,   271,   211,   501,   537,   445,
+,   540,   278,   542,   543,   111,   109,   480,   131,   830,
+,   116,     3,   834,   109,   812,   520,   597,   491,    10,
+,    12,    13,    14,   109,  1306,   489,   132,   491,   609,
+,   611,   696,   116,    53,    72,   328,   598,   116,     4,
+,     6,     7,     8,     9,   491,    83,    84,    39,   132,
+,   590,   110,   116,   132,   119,   348,   978,   116,   691,
+,   125,   491,   112,   964,  1323,   646,   116,   498,   132,
+,   347,   652,   116,   111,   110,    67,    96,     0,     1,
+,   661,   586,   663,   664,   665,  1504,  1466,   364,   132,
+,  1102,   368,   890,  1473,   129,   600,   131,   116,   116,
+,   733,  1383,   924,    69,    72,    71,  1525,   772,   110,
+,   888,  1530,   405,   132,   132,    83,    84,   698,  1377,
+,   111,  1380,   113,   663,   629,   665,   117,   112,   109,
+,   111,   909,   713,   116,   110,   351,   112,   353,   719,
+,   116,    64,   723,   111,    67,   116,  1526,   110,   110,
+,   731,    45,   110,   116,   116,   131,   132,   631,   109,
+,   111,   110,   455,   744,   745,   112,  1425,    61,   119,
+,    64,  1430,   192,    67,   112,    72,   110,   758,   116,
+,   978,    72,   116,   491,   894,    76,    83,    84,  1470,
+,  1472,   731,    83,    84,  1021,   215,   938,   946,   491,
+,   110,  1460,   495,   116,   946,   225,    10,    11,    12,
+,    14,  1009,   109,  1135,  1322,    92,    93,   110,   109,
+,   111,   652,   119,   116,   110,   441,    72,   691,   119,
+,   116,   111,   155,   697,   109,    39,   111,    83,    84,
+,    11,    12,    13,    14,   691,  1527,   109,   109,   111,
+,   724,   515,   146,  1034,   518,  1133,   119,   521,   839,
+,  1532,  1059,   110,    67,   738,   159,  1532,   109,    39,
+,   851,  1193,  1194,   835,   294,   115,   116,   110,   110,
+,  1532,  1103,   713,   116,   116,   116,   733,  1546,   719,
+,   117,   185,   723,  1552,   115,  1133,    67,   220,   109,
+,  1138,   109,   110,   111,  1563,   109,   132,   111,  1567,
+,   703,   110,   705,   894,   208,   119,   609,   116,   611,
+,   901,   902,   110,    76,   110,   111,   220,   250,   116,
+,    83,    84,   110,     1,   109,  1162,   111,  1135,   116,
+,   902,    74,    75,   924,    85,    86,    87,  1057,   109,
+,    83,    84,    72,   630,    74,    75,   109,   938,   832,
+,    59,   110,   902,    83,    84,   946,   119,   116,   109,
+,   111,   109,   113,   114,   110,   112,   109,    45,   132,
+,   116,   114,   110,   964,   661,   116,   115,   116,   116,
+,   114,   109,   680,   111,   114,  1193,  1194,   114,    72,
+,    74,    75,    76,   984,   109,   698,   111,   700,   114,
+,    84,   109,   993,   111,   109,  1253,  1243,   109,   110,
+,  1001,   132,   442,  1004,   109,  1006,   111,    82,   902,
+,   132,    74,    75,   109,   328,   109,   104,   111,   902,
+,    83,    84,   110,   117,   984,   119,    72,   109,    74,
+,    82,   744,   745,   116,   117,   902,   476,    83,    84,
+,   109,  1001,   111,   894,  1004,   970,  1006,   109,   110,
+,   901,   114,   902,   120,  1055,   116,   117,   145,   109,
+,   111,   758,  1404,   128,  1065,   111,   154,  1068,  1069,
+,    58,    59,    60,   513,  1265,  1266,  1267,  1507,   518,
+,  1062,   521,    72,  1341,    74,    75,    76,  1345,   129,
+,    94,   405,  1093,    83,    84,  1055,  1021,    44,    45,
+,    11,    12,    13,    14,   131,  1065,   111,   815,  1068,
+,  1070,   564,   565,   566,   567,   109,   204,   825,   109,
+,   208,   110,  1206,  1207,  1125,  1209,   839,  1557,    39,
+,  1024,  1215,   840,    72,  1218,    74,    75,  1222,   851,
+,   561,   112,   993,   110,    83,    84,   562,   563,   491,
+,   238,   239,  1494,  1495,   110,    72,    67,    74,    75,
+,   110,    72,   110,    74,    75,    76,    83,    84,  1062,
+,   569,   109,    83,    84,   902,   112,   111,   131,  1062,
+,   114,   109,   270,   114,   116,   273,  1404,   114,   112,
+,   533,   110,   109,    45,   111,  1062,   110,   112,   109,
+,   111,   117,   119,  1421,   112,   112,   294,   112,   119,
+,    29,   117,  1062,   117,   116,  1205,   110,   110,   114,
+,   112,  1222,   110,   132,   115,   938,  1227,     3,   115,
+,   109,   116,   110,   946,    10,    11,    12,    13,    14,
+,   110,   969,  1093,   116,   110,  1227,   117,   110,   688,
+,   110,   964,   692,   341,   116,   598,   344,  1247,   110,
+,   110,     3,   110,    39,  1265,  1266,  1267,  1227,    10,
+,    12,    13,    14,   110,   110,   363,  1494,  1495,  1162,
+,   110,   110,   370,    10,    11,    12,    13,    14,   110,
+,   110,    67,   110,   110,  1400,  1379,   110,    39,    29,
+,   643,   644,   645,   131,   112,  1265,  1266,  1267,   110,
+,  1204,  1542,    39,   110,   110,   114,   116,   112,   112,
+,   110,  1322,  1323,   110,  1306,    67,   110,   116,   110,
+,   116,  1039,  1040,  1227,  1062,   116,   116,   425,   426,
+,    67,   116,   110,  1227,   110,   112,    85,    86,    87,
+,  1340,  1532,  1532,   109,  1204,  1205,   208,   109,  1532,
+,  1227,   109,  1322,  1323,  1533,   453,   109,   112,   456,
+,   109,  1533,   111,   109,   113,   114,  1377,  1227,  1532,
+,  1532,   132,   109,  1532,   111,   117,   474,   239,  1557,
+,  1098,   115,   119,   736,   110,  1557,   110,  1247,  1399,
+,   115,  1507,   110,   129,   115,   114,   112,  1301,  1409,
+,   132,   499,  1306,   501,   110,   503,   116,  1377,   270,
+,  1380,   116,  1306,   112,  1425,   513,   110,   515,   110,
+,   518,   110,   520,   521,   112,   471,   112,   112,   110,
+,    47,   112,   294,   112,   532,   297,   112,  1448,   115,
+,  1410,  1301,   132,  1443,   110,   132,  1306,   115,   132,
+,   117,   110,   132,   115,   132,  1425,   112,   112,   112,
+,  1430,    72,   112,    74,    75,    76,   112,  1205,   112,
+,   110,   110,    83,    84,  1466,   828,   926,   112,  1448,
+,  1340,  1473,   835,     0,     1,   109,   109,  1532,   586,
+,  1460,   109,  1532,  1532,    60,   110,  1507,  1508,   109,
+,   111,    55,   600,   110,   114,   132,  1517,   112,   119,
+,   112,   117,  1523,   110,   112,    32,   110,  1528,    96,
+,   109,  1532,  1533,   109,  1533,   115,   110,   112,    45,
+,   110,   629,    42,   116,  1526,  1546,   634,  1548,  1508,
+,   110,  1552,   640,   117,  1555,   132,  1557,  1517,  1557,
+,    67,   105,  1563,  1523,   108,  1273,  1567,   132,  1528,
+,   110,    96,  1466,  1281,  1282,  1283,    96,   132,  1306,
+,   110,   110,  1466,   132,   117,   132,  1546,   110,  1548,
+,   112,   110,  1552,  1443,   115,  1555,   132,   104,   112,
+,   109,   453,   115,  1563,   456,   132,  1473,  1567,   696,
+,   154,   110,  1340,    64,   110,   132,  1466,  1542,   110,
+,  1077,  1329,   571,  1473,   570,  1227,   969,   572,    64,
+,   718,   573,  1526,  1073,   574,  1495,  1385,  1567,    74,
+,  1316,  1138,  1526,   986,   680,  1473,    81,   154,   155,
+,  1093,   705,   946,     4,     5,     6,     7,     8,     9,
+,   748,   513,   453,   515,   471,   116,   518,   723,   453,
+,   948,   993,   590,   217,   894,   966,  1526,   658,   185,
+,   116,   116,    33,   578,   772,   491,   758,    10,    11,
+,    13,    14,    -1,   200,   578,   748,   203,   204,   578,
+,  1043,   208,  1399,    -1,    -1,    -1,    -1,    -1,   159,
+      -1,    -1,    -1,    -1,    -1,    -1,  1443,    39,    -1,    69,
+,    71,    -1,   229,   159,   159,    -1,   233,   271,   235,
+,    -1,    74,    75,    76,   278,    -1,    -1,   244,  1466,
+      -1,    83,    84,   830,   250,    67,  1473,   834,    -1,   255,
+,    -1,    74,    75,    76,    -1,    -1,    -1,    -1,   265,
+      -1,    83,    84,    -1,    -1,    -1,    -1,   273,   283,    -1,
+,    -1,    -1,    -1,    -1,    -1,    26,    27,    28,    -1,
+,   296,   297,    -1,    -1,   220,   220,   109,    -1,   111,
+,    -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,
+,   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,
+,   367,  1204,  1205,   370,   380,    -1,   718,    -1,    -1,
+,    -1,    -1,    -1,   680,    72,  1315,    74,    75,    76,
+      -1,   968,   969,   970,    -1,  1227,    83,    84,   431,    -1,
+,    -1,    74,    75,    76,    -1,    -1,    -1,    -1,   349,
+      -1,    83,    84,    -1,    -1,  1247,    72,    -1,    74,    75,
+,   417,   109,    -1,   349,   349,    -1,    83,    84,    -1,
+      -1,    72,   119,    74,    75,    76,   432,   109,    -1,   111,
+,   437,    83,    84,  1021,    -1,    -1,   119,    -1,   445,
+,   191,    -1,   109,    -1,   195,    -1,   197,   198,    -1,
+,  1293,    -1,   119,    -1,    -1,    -1,    -1,   109,  1301,
+      -1,    -1,    -1,    -1,  1306,   471,    -1,    -1,   474,    -1,
+,    -1,    53,    -1,    -1,    56,    57,    58,    -1,    60,
+,    -1,    -1,   489,    -1,   491,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   499,    75,   430,   430,   503,  1340,    10,
+,    12,    13,    14,  1039,  1040,    87,    88,    -1,   815,
+      -1,    -1,   447,    -1,    -1,  1102,  1103,    -1,    -1,   825,
+,    -1,    74,    75,    76,    -1,   532,   533,    39,    -1,
+,    83,    84,    -1,   840,  1474,    -1,  1476,    -1,    -1,
+      -1,    -1,   557,   558,   559,   480,   480,    72,    -1,    74,
+,    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,
+,  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,
+,    -1,    -1,   603,    -1,    -1,   662,    -1,    -1,    -1,
+,    -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,
+,   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,
+,    -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,
+,    28,    -1,    -1,    -1,    -1,    -1,    -1,   738,   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,
+,    -1,    99,    -1,    -1,    -1,  1443,    10,    11,    12,
+,    14,   612,    -1,    -1,   615,   616,    -1,   618,    -1,
+,   621,    -1,    -1,    -1,   625,   626,   124,    -1,   229,
+      -1,   924,   832,    -1,    -1,    -1,    39,    -1,  1475,    -1,
+,    -1,    -1,    -1,    -1,    -1,   902,   832,   832,    -1,
+,    -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,
+,    84,    -1,   180,    -1,  1241,    -1,    -1,    -1,    -1,
+      -1,   188,    -1,   190,   191,    -1,    -1,    -1,   195,    -1,
+,   198,    -1,    -1,   960,  1542,   109,    -1,   111,   709,
+,    -1,   968,   969,    -1,   715,   119,  1273,    -1,    10,
+,    12,    13,    14,    -1,  1281,  1282,  1283,    -1,    -1,
+,    -1,    -1,    -1,    -1,   267,    -1,    -1,    -1,    10,
+,    12,    13,    14,    -1,    -1,    -1,    -1,    39,    -1,
+,    -1,    -1,    -1,    -1,    -1,  1021,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,  1021,    -1,    -1,    39,    -1,
+,    -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,
+,  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,
+,   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,
+,    -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,
+,    -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,
+,    -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,
+,    -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,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    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,
+,  1022,  1023,    -1,    -1,  1026,    -1,    67,    -1,    -1,
+      -1,    -1,    -1,    -1,  1035,    -1,    -1,   704,    78,    -1,
+,    -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,
+,    -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,
+,    -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,
+,    -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,
+,  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,
+,    72,    -1,    74,    75,    76,   986,    -1,    79,    80,
+,    82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,
+,  1232,  1233,    94,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,   598,
+,    -1,   113,   114,    -1,    -1,    -1,   118,   119,   120,
+,   122,   123,    -1,    -1,    -1,    -1,    -1,    -1,  1039,
+,    -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,
+,  1362,    37,    38,    -1,    40,    -1,    -1,    -1,    -1,
+      -1,  1372,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    -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,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   902,    -1,    -1,    -1,  1224,    -1,  1329,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1569,  1570,
+      -1,    -1,    -1,   155,    -1,   432,  1577,  1578,    -1,    -1,
+,    -1,    -1,    -1,    -1,    -1,     0,    -1,   445,     3,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    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,
+,    -1,    -1,    67,    -1,    69,    -1,    71,    72,    -1,
+,    75,    76,    -1,    -1,    -1,    -1,    -1,   250,    83,
+,    -1,    -1,   255,    -1,    -1,   533,    -1,     7,    -1,
+      -1,    10,    11,    12,    13,    14,    -1,    -1,    -1,    -1,
+,  1040,    -1,  1042,  1043,   109,  1466,   111,    -1,    -1,
+      -1,    -1,    -1,  1473,    -1,   119,    -1,    -1,    37,    38,
+,    40,    -1,  1062,    -1,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    27,    28,    -1,    -1,    -1,    66,    67,    -1,
+      -1,   598,    -1,    72,    39,    -1,    -1,    76,  1097,  1098,
+,    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,
+,    -1,   111,    78,    -1,    -1,   643,   644,   645,   118,
+,   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,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    -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,
+,    -1,    -1,   840,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    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,
+,    -1,    -1,    -1,   291,   292,    -1,    -1,   294,   296,
+,   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,
+,    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,
+,   773,   111,    -1,    -1,    -1,    -1,    -1,   117,   118,
+,   120,   121,   122,   123,  1062,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    64,    -1,    -1,    -1,   425,
+,    -1,    -1,    -1,    -1,    74,   432,    76,    -1,    78,
+      -1,    -1,    -1,   815,    -1,    -1,    85,    -1,    -1,    -1,
+,  1098,    -1,   825,    -1,    -1,   828,   453,    -1,    -1,
+,   833,    -1,   835,    -1,    -1,    -1,    -1,   840,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,    -1,   118,
+,   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,
+,    -1,   518,    -1,   520,   521,    -1,    -1,    -1,    -1,
+,    -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,
+,   558,   559,   560,   561,   562,   563,   564,   565,   566,
+,   568,   569,   570,   571,   572,   573,   574,    -1,    -1,
+,   220,    -1,   222,   223,   224,    -1,    -1,    -1,    -1,
+,    -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,
+,  1043,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,  1329,    -1,    -1,    -1,    -1,    -1,    -1,   328,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   697,   699,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    -1,   738,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    -1,    -1,    90,    -1,    -1,   405,    -1,    -1,    -1,
+,    -1,    39,   100,    -1,    -1,    -1,   773,    -1,    -1,
+      -1,    -1,    -1,   780,   423,    -1,    -1,    -1,    -1,   428,
+,   430,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    -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,
+,    -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,
+,  1283,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,  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,
+,   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,
+,    -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,
+,    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,
+,    -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,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    27,    -1,  1243,    30,    31,
+,   578,    -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,
+,    -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,
+,    -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,
+,    -1,    -1,    -1,    -1,    -1,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    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,
+,    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,
+,    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,
+,    -1,    79,    80,    81,    82,    83,    84,    -1,    86,
+,    -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,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    27,    -1,  1020,    30,    31,    32,    33,    -1,    -1,
+,    -1,    -1,    39,    40,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    27,    -1,    -1,    30,    31,    32,    64,    -1,
+      -1,    67,    -1,    69,    39,    71,    72,   267,    74,    75,
+,    -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,
+,    -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,
+,    -1,    -1,    -1,    -1,    -1,    -1,   367,    -1,    -1,
+,    -1,  1169,    -1,    -1,  1172,    -1,  1174,    -1,    -1,
+,    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,
+,    -1,   432,   263,    -1,    -1,    -1,    94,    -1,    -1,
+,    -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,
 ,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    75,     0,    25,    26,
+,     0,   453,     0,   351,   351,   946,    30,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,    77,     0,
+,     0,  1236,     0,     0,     0,     0,     0,     0,     0,
+,   353,   353,   354,     0,    33,     0,     0,    77,     0,
+,     0,    37,    38,    39,    84,    77,     0,     0,     0,
+,    40,    41,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,    84,   346,     0,   351,     0,
+,     0,   354,    84,     0,     0,     0,    42,     0,   155,
+,     0,     0,     0,     0,     0,     0,    44,     0,     0,
+,     0,    77,     0,     0,   353,     0,     0,     0,   361,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   220,     0,     0,     0,     0,     0,   361,     0,    84,
+,     0,     0,     0,     0,    54,     0,     0,     0,     0,
+,     0,     0,    72,   354,     0,     0,     0,   221,     0,
+,     0,     0,     0,     0,     0,   351,     0,   351,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   361,     0,     0,     0,     0,     0,   346,     0,     0,
+,     0,     0,   353,     0,   353,     0,     0,   351,     0,
+,     0,     0,     0,     0,     0,   351,   351,   351,     0,
+,     0,     0,     0,     0,     0,     0,   351,   351,   354,
+,     0,     0,     0,     0,   353,     0,     0,     0,     0,
+,    72,     0,   353,   353,   353,     0,     0,     0,     0,
+,     0,     0,     0,   353,   353,   361,     0,     0,     0,
+,     0,   346,     0,   351,     0,     0,     0,    75,     0,
+,     0,     0,     0,   354,   354,   354,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   353,     0,   354,     0,     0,     0,     0,     0,   124,
+,   361,   361,   361,     0,     0,     0,   346,   346,   346,
+,   354,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,    77,     0,     0,     0,   346,     0,   354,     0,
+,     0,     0,     0,     0,     0,     0,     0,   361,  1033,
+,     0,     8,     9,    10,    11,    12,     0,     0,    84,
+,     0,   351,     0,     0,   361,     0,     0,     0,     0,
+,     0,     0,     0,    77,     0,     0,   354,   280,   281,
+,   282,     0,     0,     0,     0,     0,     0,     0,   353,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,    84,     0,     0,   361,     0,     0,   283,    33,     0,
+,    72,     0,   284,   354,     0,     0,   285,    72,     0,
+,   287,   288,   289,    40,    41,     0,   290,   291,     0,
+,     0,     0,   124,     0,   292,     0,     0,    75,     0,
+,   361,     0,     0,     0,    75,     0,     0,     0,     0,
+,     0,   377,     0,     0,     0,   354,     0,     0,   295,
+,   297,   298,   299,   300,     0,   354,     0,     0,   354,
+,    72,     0,     0,   222,     0,   354,     0,     0,     0,
+,   354,     0,   361,     0,     0,     0,     0,     0,     0,
+,     0,     0,   361,     0,     0,   361,     0,    75,     0,
+,   223,   346,   361,     0,     0,     0,     0,   361,   346,
+,     0,     0,     0,     0,  -516,     0,     0,     1,     2,
+,    20,    21,    22,    23,    24,    25,    26,    27,    28,
+      -1,    30,    31,    32,    33,    -1,    -1,    36,    -1,   529,
+,    -1,   532,   533,    -1,    -1,    -1,    -1,  1335,    -1,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   379,
+      -1,    -1,    -1,  1350,    -1,  1352,    -1,    -1,    67,    -1,
+,    -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,
+,    -1,    -1,    -1,    -1,    -1,    -1,   597,   598,    -1,
+,  1398,   111,    -1,  1401,    -1,    -1,    -1,    -1,   609,
+,   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,
+,  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,
+,    -1,    -1,    -1,    -1,    -1,   696,   697,   698,    -1,
+,    -1,  1499,   533,   704,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
+      -1,    30,    31,    32,    33,    -1,    -1,    36,   648,   819,
+,    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,
+,   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,
+,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,    -1,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    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,
+,    -1,    67,    -1,    -1,    -1,    -1,    72,    -1,    74,
+,    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,
+,  1021,    -1,    -1,    -1,    -1,    -1,  1027,  1028,    -1,
+,  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,
+,    -1,    -1,    -1,   894,     3,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    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,
+,    -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,
+,    -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,
+,    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,
+,   121,   122,   123,    66,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,    76,  1095,    -1,    79,    80,    81,
+,    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,
+,   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,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    33,    -1,    -1,    36,    37,
+,    39,    40,    41,    -1,    43,    -1,    -1,    46,    47,
+,    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,
+,   119,   120,   121,   122,   123,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,   132,    -1,    -1,    -1,    -1,    -1,
+,    -1,  1322,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1507,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    27,    -1,    -1,    30,    31,
+,    -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,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    33,    -1,   119,    36,    37,
+,    39,    40,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    -1,    -1,    30,    31,    32,    -1,    -1,    66,    67,
+      -1,    69,    39,    71,    72,    -1,    74,    75,    76,    -1,
+,    79,    80,    81,    82,    83,    84,    -1,    86,    87,
+      -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,    -1,
+,    -1,    -1,    -1,    -1,    72,    -1,    74,    75,    -1,
+      -1,   109,    -1,   111,    -1,    -1,    83,    84,    -1,    -1,
+,   119,   120,   121,   122,   123,    -1,    -1,    -1,    -1,
+      -1,    -1,  1542,    -1,   132,     3,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    33,    -1,    -1,    36,    37,
+,    39,    40,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    -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,
+,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,    -1,
+      -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,
+,   119,   120,   121,   122,   123,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
+,    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,
+,   119,   120,   121,   122,   123,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
+,    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,
+,   119,   120,   121,   122,   123,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
+,    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,
+,   119,   120,   121,   122,   123,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
+,    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,
+,   119,   120,   121,   122,   123,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
+,    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,
+,   119,   120,   121,   122,   123,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
+,    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,
+,   119,   120,   121,   122,   123,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
+,    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,
+,   119,   120,   121,   122,   123,     3,     4,     5,     6,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    -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,
+,    -1,    69,    -1,    71,    -1,    -1,    74,    75,    -1,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    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,
+,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    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,   109,    -1,   111,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   119,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    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,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    27,    -1,    -1,    30,    31,    32,    67,
+      -1,    69,    -1,    71,    -1,    39,    74,    75,    -1,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    27,    67,    -1,    30,    31,    32,    72,    -1,
+,    75,   110,   111,    39,    -1,    -1,    -1,    -1,    83,
+,   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,
+,    -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,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
+      -1,    30,    31,    32,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,    -1,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    27,    28,    -1,    30,    31,    32,    67,    -1,
+,    -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,
+,    76,   111,    78,    -1,    -1,    -1,    -1,    83,    84,
+,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    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,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    27,    -1,    -1,
+,    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,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    -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,
+,    -1,    69,    -1,    71,    -1,    -1,    74,    75,    -1,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    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,
+,    75,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
+,    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,
+,   119,   120,   121,   122,   123,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    27,    -1,    -1,    30,    31,    32,    -1,
+      -1,    -1,    -1,    37,    38,    39,    40,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,    26,    27,    -1,    -1,    30,    31,    32,
+      -1,    -1,    66,    67,    -1,    -1,    39,    -1,    72,    -1,
+,    75,    76,    -1,    -1,    79,    80,    81,    82,    83,
+,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,    67,    -1,    -1,    -1,    -1,    72,
+      -1,    74,    75,    76,    -1,   109,    -1,   111,   112,    -1,
+,    84,    -1,    -1,   118,   119,   120,   121,   122,   123,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    27,   111,    -1,
+,    31,    32,    -1,    -1,    -1,   119,    37,    38,    39,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
+      -1,    30,    31,    32,    -1,    -1,    66,    67,    -1,    -1,
+,    40,    72,    -1,    74,    75,    76,    -1,    -1,    79,
+,    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,
+,   111,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,
+,   121,   122,   123,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    27,   111,    -1,    30,    31,    32,    -1,    -1,    -1,
+,    37,    38,    39,    40,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+,    67,    30,    31,    32,    -1,    72,    -1,    74,    75,
+,    39,    -1,    79,    80,    81,    82,    83,    84,    -1,
+,    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,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    27,    -1,    -1,    30,    31,
+,   109,    -1,   111,    -1,    37,    38,    39,    40,    -1,
+      -1,   119,    -1,    -1,    -1,    -1,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    27,    66,    67,    30,    31,    32,    -1,
+,    -1,    74,    75,    76,    39,    -1,    79,    80,    81,
+,    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,
+,    75,    -1,    -1,    -1,    -1,   118,   119,   120,   121,
+,   123,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    -1,    30,    31,    32,   109,    -1,   111,    -1,    37,
+,    39,    40,    -1,    -1,   119,    -1,    -1,    -1,    -1,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    27,    66,    67,
+,    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,
+,   119,   120,   121,   122,   123,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    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,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    27,    66,    67,    30,    31,    32,    -1,    72,    -1,
+,    75,    76,    39,    -1,    79,    80,    81,    82,    83,
+,    -1,    86,    87,    -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,    -1,    -1,   118,   119,   120,   121,   122,   123,
 ,     4,     5,     6,     7,     8,     9,    10,    11,    12,
 ,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,     0,    77,    25,    26,    27,    28,     0,     0,
+,     0,     0,    30,    31,     0,     0,     0,     0,     8,
+,    10,    11,    12,     0,     8,     9,    10,    11,    12,
+,     0,     0,     0,     0,     0,    54,     0,    32,     0,
+,    33,   163,    34,     0,    35,    36,    30,    37,    38,
+,     0,     0,    30,     0,     0,     0,    40,    41,     0,
+,   216,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,    33,     0,     0,     0,     0,
+,    33,     0,    42,    39,    43,    36,   354,     0,     0,
+,    40,    41,    44,     0,     0,     0,    40,    41,     0,
+,     0,     0,    54,     0,     0,     0,   163,     0,     0,
+,     0,     0,   270,   361,     0,     0,    42,     0,     0,
+,     0,     0,   743,     0,     0,     0,   145,     0,     0,
+,     0,     0,   744,     0,     0,     0,     0,     0,     0,
+,   354,   163,   354,   354,     0,     0,     0,     0,     0,
+,     0,   367,     0,     0,     0,   373,     0,     0,     0,
+,     0,     0,    77,     0,     0,     0,   361,   361,     0,
+,   361,     0,     0,     0,     0,   346,   346,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,    54,     0,   354,   354,
+,     0,     0,     0,     0,   163,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   216,     0,     0,
+,     0,     0,     0,     0,   361,   361,     0,     0,     0,
+,   280,   281,     0,   282,   163,   460,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,     0,     0,    25,    26,    27,   373,
+,     0,   354,     0,     0,    30,   284,   163,     0,     0,
+,     0,     0,   286,   287,   288,   289,    40,    41,     0,
+,   291,     0,     0,     0,     0,     0,     0,   292,   361,
+,   460,     0,    33,   163,     0,     0,     0,     0,     0,
+,    38,     0,   512,     0,   222,     0,     0,     0,     0,
+,     0,   295,   379,   297,   298,   299,   300,     0,     0,
+,     0,     0,     0,     0,     0,     0,    77,     0,     0,
+,     0,   223,     0,     0,     0,     0,    54,    54,     0,
+,   605,   354,     0,     0,   269,   629,     0,     0,     0,
+,     0,     0,     0,    84,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   361,     0,   361,
+,     0,   354,     0,     0,     0,     0,     0,     0,    54,
+,   354,   354,     0,     0,     0,     0,     0,     0,     0,
+,   354,   354,     0,     0,     0,     0,     0,     0,   361,
+,     0,     0,     0,     0,    77,     0,   361,   361,   361,
+,     0,     0,     0,     0,     0,     0,     0,   361,   361,
+,     0,   163,   163,   346,   346,     0,     0,   354,   367,
+,     0,    84,    54,     0,     0,     0,     0,    54,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   460,     0,   361,     0,     0,     0,   460,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,    54,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,   740,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   163,     0,
+,     0,   233,     0,   235,     0,     0,     0,     0,     0,
+,   244,   460,     0,     0,   460,   354,   163,   460,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     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,    77,     0,   154,     0,     0,
+,     0,    77,     0,     0,    54,     0,     0,     0,     0,
+,     0,     0,   163,     0,   209,     0,     0,     0,     0,
+,     0,    84,     0,     0,   367,     0,   605,    54,    84,
+,     0,     0,     0,     0,    54,     0,     0,     0,     0,
+,     0,     0,   249,     0,     0,     0,     0,     0,     0,
+,     0,     0,   254,     0,    77,   605,     0,     0,     0,
+,   605,     0,     0,     0,     0,     0,     0,     0,     0,
+,   367,   367,     0,     0,     0,   209,     0,   233,   235,
+,     0,    84,     0,     0,     0,     0,     0,    54,   367,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,  -294,   154,
+,    26,    27,     0,   209,     0,     0,     0,   209,    30,
+,     0,     0,   384,   740,     0,     0,     0,     0,     0,
+,     0,     0,     0,   503,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   460,   416,    33,     0,     0,
+,     0,     0,     0,    37,    38,     0,     0,  -294,     0,
+,     0,     0,   367,     0,   960,     0,     0,     0,   436,
+,     0,     0,     0,     0,     0,     0,     0,     0,   444,
+,     0,     0,     0,   209,     0,     0,     0,     0,   642,
+,   337,   280,   281,     0,   282,     0,     0,     0,   109,
+,     0,     0,     0,   470,   209,     0,     0,     0,   480,
+,   235,     0,     0,     0,     0,     0,     0,   244,     0,
+,   283,   488,     0,     0,     0,     0,   284,   498,     0,
+,   285,     0,     0,   286,   287,   288,   289,    40,    41,
+,   290,   291,     0,     0,     0,     0,     0,   532,   292,
+,     0,     0,     0,     0,   367,     0,     0,     0,   629,
+,   209,   367,     0,   293,     0,   377,     0,     0,   378,
+,     0,     0,   295,   379,   297,   298,   299,   300,   209,
+,     0,     0,     0,   209,     0,   209,     0,     0,     0,
+,   592,     0,     0,     0,     0,   597,     0,     0,     0,
+,     0,     0,   209,     0,     0,   209,   209,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   209,     0,   643,     0,     0,     0,   644,   645,
+,   647,     0,     0,     0,     0,   209,     0,   659,   660,
+,   661,   662,   209,   663,     0,   664,     0,     0,     0,
+,     0,     0,  1176,     0,   460,     8,     9,    10,    11,
+,     0,     0,   592,     0,     0,     0,     0,     0,     0,
+,   679,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   280,   281,    30,   282,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,   690,   163,     0,     0,
+,     0,     0,     0,     0,     0,     0,   696,     0,     0,
+,   283,    33,   367,     0,     0,     0,   284,     0,     0,
+,   285,     0,     0,   286,   287,   288,   289,    40,    41,
+,   290,   291,     0,     0,     0,   735,     0,     0,   292,
+,   470,     0,     0,     0,     0,     0,     0,   605,     0,
+,     0,     0,     0,   293,     0,   377,     0,     0,   209,
+,     0,     0,   295,  1177,   297,   298,   299,   300,   367,
+,     0,     0,     0,     0,     0,     0,     0,   772,     0,
+,     0,     0,     0,     0,     0,     0,   209,   513,     0,
+,   518,   209,     0,   787,     0,     0,     0,   521,   522,
+,     0,     0,   515,   515,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   515,     0,     0,     0,     0,
+,     0,     0,     0,     0,   280,   281,     0,   282,   460,
+,   814,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   827,     0,     0,
+,   515,   834,     0,   283,     0,     0,     0,     0,     0,
+,     0,     0,   849,   285,     0,     0,   286,   287,   288,
+,    40,    41,     0,   290,   291,     0,     0,     0,     0,
+,     0,   292,     0,     0,     0,     0,   515,   740,     0,
+,     0,     0,     0,   209,     0,     0,   293,     0,   377,
+,     0,     0,     0,   889,   811,   295,   379,   297,   298,
+,   300,     0,     0,   503,     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,     8,     9,    10,    11,    12,
+,    24,    25,    26,    27,   111,    -1,    30,    31,    32,
+      -1,    -1,    -1,   119,    -1,    -1,    39,    -1,    -1,    -1,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    27,    -1,    -1,
+,    31,    32,    -1,    67,    -1,    69,    -1,    71,    39,
+      -1,    74,    75,    -1,    -1,    -1,    -1,    -1,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    27,    -1,    67,    30,    31,
+,    -1,    72,    -1,    74,    75,    76,    39,    -1,    -1,
+      -1,   114,    -1,    83,    84,    -1,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    27,    -1,    67,    30,    31,    32,   109,
+,   111,    74,    75,    76,    39,    -1,    -1,    -1,   119,
+      -1,    83,    84,    -1,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    27,    -1,    67,    30,    31,    32,   109,    72,   111,
+,    75,    76,    39,    -1,    -1,    -1,   119,    -1,    83,
+,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+,    67,    30,    31,    32,   109,    72,   111,    74,    75,
+,    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,
+,    -1,    -1,   119,    -1,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    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,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    28,    67,    30,    31,    32,    -1,    -1,    -1,    74,
+,    -1,    39,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
+,    -1,    39,    40,    -1,    -1,   111,    74,    75,    -1,
+,    78,    -1,    -1,   119,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    27,    -1,   111,    30,    31,    32,   115,    -1,
+      -1,    -1,   119,    -1,    39,    40,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    27,    -1,    -1,    30,    31,    32,    -1,
+      -1,    -1,    67,    -1,    -1,    39,    -1,    -1,    -1,    74,
+,    -1,    -1,    -1,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    27,    -1,    67,    30,    31,    32,    -1,    -1,    -1,
+,    75,    -1,    39,    -1,    -1,   111,    -1,    -1,    -1,
+,    -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,
 ,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,  -294,     0,    25,    26,    27,     0,   740,     0,
+,     0,     0,    30,     0,   209,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   209,     0,
+,     0,     0,     0,     0,   249,     0,     0,     0,     0,
+,    33,     0,     0,     0,   967,   968,   209,    37,    38,
+,     0,  -294,     0,     0,     0,     0,   367,   367,   985,
+,     0,     0,     0,     0,     0,   216,     0,     0,     0,
+,     0,     0,     0,     0,     0,  1000,     0,  1001,     0,
+,     0,  1005,   642,     0,   337,     0,     0,     0,     0,
+,     0,     0,   633,     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,     0,     0,     0,     0,     0,     0,     0,     0,
+,   281,     0,   282,   209,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   515,  1038,     0,
+,     0,     0,     0,     0,  1039,     0,     0,     0,   283,
+,     0,     0,     0,     0,   284,     0,     0,  1041,   285,
+,     0,   286,   287,   288,   289,    40,    41,     0,   290,
+,     0,   367,     0,  1054,     0,     0,   292,   209,     0,
+,  1058,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   293,  1096,   377,     0,  1097,     0,     0,   780,
+,   295,   379,   297,   298,   299,   300,     0,     0,     0,
+,     0,     0,     0,   597,     0,     0,     0,     0,     0,
+,   209,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   460,     0,     0,     0,   515,     0,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,  -294,     0,     0,   515,     0,
+,     0,     0,     0,     0,     0,    30,   460,     0,   460,
+,   515,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,  -294,
+,    25,    26,    27,    33,     0,     0,   163,     0,     0,
+,     0,   209,  1160,     0,  -294,     0,     0,     0,   340,
+,     0,     0,     0,     0,     0,     0,   515,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,    33,     0,
+,     0,     0,    36,     0,   335,   336,    39,     0,  -294,
+,     0,     0,   412,    40,    41,     0,     0,     0,   515,
+,     0,     0,     0,     0,     0,     0,     0,     0,   532,
+,     0,     0,     0,   515,     0,  1225,     0,     0,     0,
+,     0,   337,     0,     0,     0,     0,     0,     0,     0,
+,   280,   281,     0,   282,     0,     0,     0,     0,   209,
+,     0,     0,     0,     0,  1238,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,  1244,     0,
+,     0,     0,     0,     0,     0,   648,     0,   137,   138,
+,     0,   412,   286,   649,   288,   289,    40,    41,     0,
+,   291,     0,     0,     0,     0,     0,     0,   292,  1270,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,  1278,     0,   293,  1279,   650,  1280,   651,   378,     0,
+,     0,   295,   379,   297,   298,   299,   300,     0,     0,
+,  1290,     0,     0,     0,     0,     0,     0,   412,     0,
+,     0,     0,     0,     0,   209,   412,   588,     0,   412,
+,     0,  1303,     0,     0,     0,     0,     0,     0,   362,
+,     0,     0,   621,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   515,     0,     0,     0,  1326,
+,     0,   639,     0,     0,   340,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   380,   380,     0,     0,   515,     0,     0,     0,
+,     0,   412,     0,     0,     0,   412,     0,   515,     2,
+,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+,    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,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    27,    -1,    67,    30,    31,    32,    -1,    -1,
+      -1,    74,    75,    -1,    39,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
+      -1,    -1,    67,    -1,    39,    -1,    -1,    -1,   111,    74,
+,    -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,
+,    -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   119,    -1,    -1,    10,    11,    12,
 ,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,     0,     0,    25,    26,    27,   362,     0,     0,
+,     0,     0,    30,     0,     0,     0,     0,     0,   515,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   320,     0,     0,  1396,     0,  1397,     0,
+,    33,     0,    34,     0,    35,     0,     0,    37,    38,
+,  1406,     0,  1407,     0,     0,     0,     0,   484,     0,
+,   412,     0,     0,   362,     0,     0,     0,     0,     0,
+,  1414,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,  -399,   686,     0,  1432,  1434,     0,
+,   515,     0,   633,     0,     0,     0,     0,     0,  1440,
+,     0,  1244,     0,   412,     0,     0,   340,   362,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,  1463,     0,     0,     0,     0,     0,
+,     0,     0,  1470,     0,   515,  1472,     0,  1474,  1476,
+,     0,     0,     0,     0,     0,     0,     0,     0,   515,
+,     0,     0,   412,   412,     0,     0,     0,     0,     0,
+,   209,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   829,   362,   380,   362,     0,     0,     0,     0,
+,     0,  1511,     0,   621,  1244,   621,   621,     0,     0,
+,     0,     0,   621,     0,     0,     0,     0,     0,     0,
+,     0,     0,   868,   362,     0,     0,     0,     0,   362,
+,     0,     0,     0,     0,     0,     0,     0,   362,   362,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   362,     0,     0,
+,     0,   412,   911,     0,     0,   412,   914,     0,     0,
+,     0,     0,   916,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   340,   362,   412,     0,   412,   734,     0,     0,   412,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,     0,     0,
+,    26,    27,     0,     0,     0,     0,     0,     0,    30,
+,   362,   621,     0,     0,   768,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   781,     0,
+,     0,     0,     0,     0,   768,     0,    33,   768,     0,
+,     0,     0,     0,   205,    38,     0,   340,   362,   791,
+,     0,   412,   412,     0,     0,     0,     0,     0,   515,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   813,     0,     0,     0,     0,   515,     0,     0,     0,
+,   822,     0,     0,     0,     0,     0,     0,   344,   628,
+,     0,     0,   781,   412,     0,     0,     0,     0,     0,
+,     0,     0,   362,     0,     0,     0,     0,     0,   829,
+,     0,     0,     0,   621,     0,   621,     0,     0,     0,
+,     0,     0,     0,     0,     0,   621,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   888,     0,     0,     0,     0,     0,   515,
+,     0,   380,     0,     0,     0,     0,     0,     0,     1,
+,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,     0,     0,    25,    26,    27,    28,     0,
+,    29,   344,     0,    30,    31,     0,     0,     0,   829,
+,     0,     0,     0,     0,     0,     0,   412,   280,   281,
+,   282,     0,   412,     0,     0,     0,     0,     0,    32,
+,   412,    33,     0,    34,     0,    35,    36,     0,    37,
+,    39,     0,     0,   621,   621,     0,   283,    40,    41,
+,     0,     0,   284,     0,     0,     0,   285,     0,     0,
+,   287,   288,   289,    40,    41,     0,   290,   291,     0,
+,   362,     0,     0,    42,   292,    43,   412,   781,     0,
+,     0,     0,     0,    44,     0,   995,     0,     0,     0,
+,     0,   377,  1004,     0,   992,   412,  1157,     0,   295,
+,   297,   298,   299,   300,     0,   362,     0,     0,     0,
+,     0,   412,  1169,     0,   621,   621,  1174,     0,     0,
+,     0,     0,     0,     0,     0,     0,   362,   362,     0,
+,     0,     0,     0,     0,     0,     0,  1021,  1022,     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,   829,   412,
+,     0,     0,     0,     0,  1052,     0,     0,     0,   380,
+,   621,     0,     0,     0,     0,     1,     2,   204,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    24,    25,    26,    27,    -1,   111,    30,    31,    32,
+      -1,    -1,    -1,    -1,   119,    -1,    39,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    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,
 ,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,    25,    26,    27,    28,     0,     0,    29,   280,
+,    30,  1061,  1062,     0,  1063,   362,     0,  1064,  1065,
+,  1067,  1068,  1069,  1070,  1071,     0,     0,     0,  1072,
+,     0,     0,  1073,  1074,     0,    32,     0,   283,    33,
+,    34,     0,    35,   648,   320,    37,    38,   285,     0,
+,   286,   287,   288,   289,    40,    41,     0,   290,   291,
+,  1138,  1139,     0,     0,     0,   292,     0,   380,     0,
+,     0,   280,   281,   995,   282,   340,  1148,     0,   768,
+,   293,     0,  1075,     0,     0,   169,     0,     0,     0,
+,   296,   297,   298,   299,   300,   362,     0,     0,  1164,
+,   283,     0,     0,  -129,     0,     0,   284,     0,     0,
+,   285,     0,     0,   286,   287,   288,   289,    40,    41,
+,   290,   291,     0,     0,     0,     0,     0,     0,   292,
+,     0,   380,     0,  1197,     0,     0,     0,     0,     0,
+,     0,     0,     0,   293,   362,   362,     0,     0,   995,
+,     0,     0,   295,   379,   297,   298,   299,   300,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     1,     2,
+,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,     0,     0,    25,    26,    27,    28,     0,     0,
+,   280,   281,    30,   282,     0,     0,   995,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   281,     0,   282,     0,     0,   888,     0,     0,     0,
+,    33,     0,    34,     0,    35,   284,     0,    37,    38,
+,  1281,  1282,   286,   287,   288,   289,    40,    41,   283,
+,   291,     0,     0,     0,   284,     0,     0,   292,   285,
+,     0,   286,   287,   288,   289,    40,    41,     0,   290,
+,     0,     0,   293,     0,  1075,     0,   292,     0,     0,
+,     0,   295,   296,   297,   298,   299,   300,     0,     0,
+,     0,   293,     0,   377,     0,  -129,     0,     0,     0,
+,   295,   379,   297,   298,   299,   300,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   995,     0,     0,     0,     1,     2,   204,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,    25,    26,    27,    28,     0,     0,    29,   280,
+,    30,   282,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,   412,   412,     0,     0,     0,
+,     0,     0,  1389,     0,   768,     0,     0,   283,    33,
+,    34,     0,    35,   284,     0,    37,    38,   285,     0,
+,   286,   287,   288,   289,    40,    41,     0,   290,   291,
+,     0,     0,     0,     0,     0,   292,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   293,     0,    43,     0,     0,     0,     0,     0,     0,
+,   296,   297,   298,   299,   300,     0,     0,     2,   204,
+,    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,
+,    -1,    -1,    -1,    -1,    -1,   119,     4,     5,     6,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    -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,
+,    -1,    69,    -1,    71,    -1,    -1,    74,    75,    37,
+,    -1,    40,    41,    -1,    43,    -1,    -1,    46,    47,
+,    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,
+,   119,   120,   121,   122,   123,    -1,    -1,    -1,    -1,
+,    -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,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    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,
+,    53,    -1,    -1,    56,    57,    -1,    -1,    -1,    61,
+,    67,    64,    69,    66,    71,    -1,    -1,    74,    75,
+,    -1,    -1,    -1,    76,    -1,    -1,    79,    80,    81,
+,    83,    84,    -1,    86,    87,    -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,
+,   123,    -1,    -1,    37,    38,   128,    40,    41,    -1,
+,    44,    45,    46,    47,    48,    49,    50,    51,    52,
+,    -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,
+,    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,
+,    -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,
+,    -1,    66,    -1,    -1,    -1,    -1,    -1,    72,    -1,
+      -1,    -1,    76,    -1,    -1,    79,    80,    81,    82,    83,
+,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,
+,    37,    38,    -1,    40,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,
+,    -1,    -1,    -1,   118,   119,   120,   121,   122,   123,
+,    -1,    -1,    -1,   128,    -1,    72,    -1,    -1,    -1,
+,    -1,    -1,    79,    80,    81,    82,    83,    84,    -1,
+,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,    37,
+,    -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,
+,    80,    81,    82,    83,    84,    -1,    86,    87,    -1,
+      -1,   109,    -1,   111,    -1,    94,    37,    38,    -1,    40,
+,   119,   120,   121,   122,   123,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,   118,
+,   120,   121,   122,   123,    66,    -1,    -1,    -1,    -1,
+      -1,    72,    -1,    -1,    -1,    76,    -1,    -1,    79,    80,
+,    82,    83,    84,    66,    86,    87,    -1,    -1,    -1,
+,    -1,    -1,    94,    76,    -1,    -1,    79,    80,    81,
+,    83,    84,    -1,    86,    87,    -1,    -1,   109,    -1,
+      -1,    -1,    94,    37,    38,    -1,    40,   118,   119,   120,
+,   122,   123,    -1,    -1,    -1,    -1,   109,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,
+,   123,    66,    -1,    -1,    -1,    -1,    -1,    72,    -1,
+      -1,    -1,    76,    -1,    -1,    79,    80,    81,    82,    83,
+,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
 ,     5,     6,     7,     8,     9,    10,    11,    12,    13,
 ,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,  1449,     0,    25,    26,    27,     0,     0,     0,     0,
+,   281,    30,   282,     0,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,     0,     0,    25,    26,    27,     0,     0,   283,
+,     0,    34,    30,    35,   284,     0,    37,    38,   285,
+,     0,   286,   287,   288,   289,    40,    41,     0,   290,
+,     0,     0,     0,     0,     0,     0,   292,     0,     0,
+,    33,     0,     0,     0,     0,   108,     0,    37,    38,
+,     0,   293,  1515,   342,     0,     0,    40,    41,   780,
+,   295,   343,   297,   298,   299,   300,     2,   204,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,    25,    26,    27,     0,     0,     0,     0,   280,
+,    30,   282,     0,     0,   320,     0,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,  -295,     0,     0,     0,   283,    33,
+,    34,     0,    35,   284,    30,    37,    38,   285,     0,
+,   286,   287,   288,   289,    40,    41,     0,   290,   291,
+,     0,     0,     0,     0,     0,   292,     0,     0,     0,
+,     0,     0,    33,     0,     0,     0,     0,     0,     0,
+,   293,     0,   930,  -295,     0,     0,     0,   780,     0,
+,   343,   297,   298,   299,   300,     2,   204,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,     0,
+,    25,    26,    27,     0,     0,     0,     0,   280,   281,
+,   282,     0,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,    25,    26,    27,     0,     0,   283,    33,     0,
+,    30,    35,   284,     0,    37,    38,   285,     0,     0,
+,   287,   288,   289,    40,    41,     0,   290,   291,     0,
+,     0,     0,     0,     0,   292,     0,     0,     0,    33,
+,     0,     0,     0,     0,     0,    37,    38,     0,     0,
+,     0,   930,     0,     0,     0,     0,   780,     0,   295,
+,   297,   298,   299,   300,     2,   204,     4,     5,     6,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,     0,     0,
+,    26,    27,     0,     0,     0,     0,   280,   281,    30,
+,     0,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,     0,
+,    25,    26,    27,     0,     0,   283,    33,     0,    34,
+,    35,   284,     0,    37,    38,   285,     0,     0,   286,
+,   288,   289,    40,    41,     0,   290,   291,     0,     0,
+,     0,     0,     0,   292,     0,     0,     0,    33,     0,
+,     0,     0,     0,     0,   205,    38,     0,     0,   293,
+,   342,     0,     0,     0,     0,     0,     0,   295,   343,
+,   298,   299,   300,     2,   204,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,     0,     0,    25,
+,    27,     0,     0,     0,     0,   280,   281,    30,   282,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,     0,     0,
+,     0,     0,     0,     0,   283,    33,     0,    34,    30,
+,   284,     0,    37,    38,   285,     0,     0,   286,   287,
+,   289,    40,    41,     0,   290,   291,     0,     0,     0,
+,     0,     0,   292,     0,     0,     0,    33,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   293,     0,
+,     0,     0,     0,     0,     0,     0,   295,   343,   297,
+,   299,   300,     2,   204,     4,     5,     6,     7,     8,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,     0,     0,    25,    26,
+,     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,   283,    33,     0,    34,     0,    35,
+,     0,   205,    38,   285,     0,     0,   286,   287,   288,
+,    40,    41,     0,   290,   291,     0,     0,     0,     0,
+,     0,   292,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   293,     0,  1019,
+,     0,     0,     0,     0,     0,   295,  1020,   297,   298,
+,   300,     2,   204,     4,     5,     6,     7,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,     0,     0,    25,    26,    27,
+,     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,   283,    33,     0,    34,     0,    35,   284,
+,   205,    38,   285,     0,     0,   286,   287,   288,   289,
+,    41,     0,   290,   291,     0,     0,     0,     0,     0,
+,   292,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,   293,     0,   377,     0,
+,     0,     0,     0,     0,   295,   379,   297,   298,   299,
+,     1,     2,     3,     4,     5,     6,     7,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,     0,     0,    25,    26,    27,
+,     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,
+,    32,     0,     0,    33,     0,    34,     0,    35,    36,
+,    37,    38,    39,     0,     0,     0,     0,     0,     0,
+,    41,     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,  -520,     0,     0,     0,    44,   203,     2,   204,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,     0,     0,    25,    26,    27,     0,     0,     0,     0,
+,     0,    30,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,    25,    26,    27,   491,   492,   493,     0,     0,
+,    30,    34,     0,    35,    36,     0,   205,    38,    39,
+,     0,     0,     0,     0,     0,    40,    41,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,    33,
+,     0,     0,     0,     0,     0,    37,    38,     0,     0,
+,     0,    42,     0,   206,     0,     0,     0,     0,     0,
+,     0,   207,     1,     2,   204,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,  -294,     0,    25,
+,    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,    33,     0,    34,     0,
+,     0,     0,    37,    38,     0,     0,  -294,     0,     1,
+,   204,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,     0,     0,    25,    26,    27,    28,     0,
+,    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,    33,     0,    34,     0,    35,     0,     0,    37,
+,     0,   203,     2,   204,     4,     5,     6,     7,     8,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,     0,     0,    25,    26,
+,     0,     0,     0,     0,     0,    43,    30,     0,     0,
+,     0,     0,     0,   109,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,    33,     0,    34,     0,    35,
+,     0,   205,    38,     2,   204,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,     0,     0,    25,
+,    27,     0,     0,     0,     0,     0,     0,    30,   206,
+,     0,     0,     0,     0,     0,     0,   269,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,    33,     0,    34,     0,
+,    36,     0,   205,    38,    39,     0,     0,     0,     0,
+,     0,    40,    41,     0,     0,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,     0,     0,    25,    26,    27,    42,     0,
+,     0,     0,     0,    30,     0,     0,     0,   207,     2,
+,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    33,     0,    25,    26,    27,    36,     0,    37,
+,    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,
+,    33,     0,    34,    42,    35,    43,     0,    37,    38,
+,     0,     0,     0,    44,     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,   686,     0,     0,     0,     0,
+,     0,     0,   633,     2,   204,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,     0,     0,    25,
+,    27,     0,     0,     0,     0,     0,     0,    30,     0,
+,     0,     0,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,    25,    26,    27,     0,    33,     0,    34,     0,
+,    30,     0,    37,    38,     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,    36,     0,   335,   336,    39,     0,
+,     0,     0,     0,     0,    40,    41,     0,   633,     2,
+,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,     0,   337,    25,    26,    27,     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,
+,    33,     0,    34,     0,    35,     0,     0,   205,    38,
+,   204,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,     0,     0,    25,    26,    27,     0,     0,
+,     0,     0,     0,    30,   268,     0,     0,     0,     0,
+,     0,     0,   628,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,    33,     0,    34,     0,    35,     0,     0,    37,
+,     2,   204,     4,     5,     6,     7,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,     0,     0,    25,    26,    27,     0,
+,     0,     0,     0,     0,    30,   686,     0,     0,     0,
+,     0,     0,     0,   633,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,    33,     0,    34,     0,    35,     0,     0,
+,    38,     2,   204,     4,     5,     6,     7,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,     0,     0,    25,    26,    27,
+,     0,     0,     0,     0,     0,    30,   598,     0,     0,
+,     0,     0,     0,     0,   633,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,    33,     0,    34,     0,    35,     0,
+,   205,    38,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,     0,    25,    26,    27,     0,     0,     0,     0,   280,
+,    30,   282,     0,     0,     0,     0,     0,   206,     0,
+,     0,     0,     0,     0,     0,   269,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,   283,    33,
+,     0,     0,     0,   284,     0,    37,    38,   285,     0,
+,   286,   287,   288,   289,    40,    41,     0,   290,   291,
+,     0,     0,     0,     0,     0,   292,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   293,     0,   524,     0,     0,   169,     0,     0,     0,
+,   296,   297,   298,   299,   300,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,     0,     0,    25,    26,    27,     0,     0,
+,     0,   280,   281,    30,   282,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,  -294,     0,    25,    26,    27,     0,     0,
+,   283,    33,     0,    30,     0,     0,   284,     0,    37,
+,   285,     0,     0,   286,   287,   288,   289,    40,    41,
+,   290,   291,     0,     0,     0,     0,     0,     0,   292,
+,     0,    33,     0,     0,     0,     0,    36,     0,   335,
+,    39,     0,  -294,   293,     0,   598,    -3,    40,    41,
+,     0,     0,   295,   599,   297,   298,   299,   300,     8,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,   337,     0,    25,    26,
+,     0,     0,     0,   109,   280,   281,    30,   282,     8,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,     0,     0,    25,    26,
+,     0,     0,     0,   283,    33,     0,    30,     0,     0,
+,     0,    37,    38,   285,     0,     0,   286,   287,   288,
+,    40,    41,     0,   290,   291,     0,     0,     0,     0,
+,     0,   292,     0,     0,    33,     0,     0,     0,     0,
+,     0,    37,    38,     0,     0,     0,   293,   -35,   765,
+,    40,    41,     0,     0,     0,   295,   296,   297,   298,
+,   300,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    43,
+,    25,    26,    27,     0,     0,     0,   109,   280,   281,
+,   282,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,     0,
+,    25,    26,    27,     0,     0,     0,   283,    33,     0,
+,   452,     0,   284,     0,    37,    38,   285,     0,     0,
+,   287,   288,   289,    40,    41,     0,   290,   291,     0,
+,     0,     0,     0,     0,   292,     0,     0,    33,     0,
+,     0,     0,     0,     0,    37,    38,     0,     0,     0,
+,     0,   294,     0,     0,     0,     0,     0,     0,   295,
+,   297,   298,   299,   300,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,   453,     0,    25,    26,    27,     0,     0,     0,
+,   280,   281,    30,   282,     0,     0,     0,     0,     0,
+,     0,     0,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    33,    25,    26,    27,     0,   284,     0,    37,    38,
+,    30,     0,   286,   287,   288,   289,    40,    41,     0,
+,   291,     0,     0,     0,     0,     0,     0,   292,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,    33,
+,     0,     0,   293,     0,   155,    37,    38,     0,     0,
+,     0,   295,   296,   297,   298,   299,   300,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,     0,     0,    25,    26,    27,
+,   642,     0,   337,   280,   281,    30,   282,     0,     0,
+,   109,     0,     0,     0,     0,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,   283,    33,    25,    26,    27,     0,   284,
+,    37,    38,   285,    30,     0,   286,   287,   288,   289,
+,    41,     0,   290,   291,     0,     0,     0,     0,     0,
+,   292,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,    33,     0,     0,     0,   293,     0,   598,    37,
+,     0,     0,     0,     0,   295,   599,   297,   298,   299,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,     0,     0,
+,    26,    27,     0,   642,     0,   337,   280,   281,    30,
+,     0,     0,     0,   633,     0,     0,     0,     0,     8,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,   283,    33,    25,    26,
+,     0,   284,     0,    37,    38,   285,    30,   452,   286,
+,   288,   289,    40,    41,     0,   290,   291,     0,     0,
+,     0,     0,     0,   292,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,    33,     0,     0,     0,   293,
+,   377,    37,    38,     0,     0,     0,     0,   295,   379,
+,   298,   299,   300,   473,     2,   204,     4,     5,     6,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,     0,   453,
+,    26,    27,  1234,     0,     0,     0,   109,     0,    30,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,     0,     0,    25,
+,    27,     0,     0,     0,     0,     0,    33,    30,    34,
+,    35,     0,     0,    37,    38,     0,     0,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,     0,    33,    25,    26,    27,
+,    36,     0,   205,    38,    39,    30,     0,     0,     0,
+,     0,    40,    41,    -3,     0,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,     0,    33,    25,    26,    27,    42,    36,
+,   335,   336,    39,    30,     0,     0,     0,   207,     0,
+,    41,     0,     0,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,     0,    33,    25,    26,    27,   642,     0,   337,    37,
+,     0,    30,     0,     0,     0,   633,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,     0,     0,    25,    26,    27,     0,
+,     0,     0,     0,     0,    30,   255,    37,    38,     0,
+,     0,     0,     0,   109,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,     0,    33,    25,    26,    27,     0,     0,     0,
+,    38,     0,    30,   155,     0,     0,     0,     0,     0,
+,     0,   109,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    33,    25,    26,    27,     0,     0,   268,    37,    38,
+,    30,     0,     0,     0,   269,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,     0,     0,    25,    26,    27,     0,    33,
+,     0,     0,     0,    30,   255,    37,    38,     0,     0,
+,     0,     0,   633,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,     0,    33,    25,    26,    27,     0,     0,     0,    37,
+,     0,    30,   337,     0,     0,     0,     0,     0,     0,
+,   633,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,     0,
+,    25,    26,    27,     0,     0,   453,   205,    38,     0,
+,     0,     0,     0,   109,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,     0,     0,    25,    26,    27,     0,    33,     0,
+,     0,     0,    30,   268,    37,    38,     0,     0,     0,
+,     0,   628,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    33,    25,    26,    27,     0,     0,     0,    37,    38,
+,    30,   598,     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,     0,     0,     0,   337,    37,    38,     0,     0,
+,     0,     0,   109,     2,   204,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,     0,     0,    25,
+,    27,     0,    43,     0,     0,     0,     0,    30,     0,
+,   109,     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,
+,     0,     0,    37,    38,   280,   281,     0,   282,  1062,
+,  1063,     0,     0,  1064,  1065,  1066,  1067,  1068,  1069,
+,  1071,     0,     0,  1548,  1072,     0,     0,     0,  1073,
+,     0,    32,     0,   283,     0,     0,     0,     0,  -412,
+,     0,     0,     0,   285,     0,     0,   286,   287,   288,
+,    40,    41,     0,   290,   291,     0,     0,     0,     0,
+,     0,   292,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   293,     0,   377,
+,     0,   169,     0,     0,     0,   295,   379,   297,   298,
+,   300,     0,     0,     0,     0,  1076,     0,   280,   281,
+    -129,   282,  1062,     0,  1063,     0,     0,  1064,  1065,  1066,
+,  1068,  1069,  1070,  1071,     0,     0,     0,  1072,     0,
+,     0,  1073,  1074,     0,    32,     0,   283,     0,     0,
+,     0,     0,   648,     0,     0,     0,   285,     0,     0,
+,   287,   288,   289,    40,    41,     0,   290,   291,     0,
+,     0,     0,     0,     0,   292,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   377,     0,     0,   169,     0,     0,     0,   295,
+,   297,   298,   299,   300,     0,     0,     0,     0,  1076,
+,   280,   281,  -129,   282,  1062,     0,  1063,  1418,  1419,
+,  1065,  1066,  1067,  1068,  1069,  1070,  1071,     0,     0,
+,  1072,     0,     0,     0,  1073,  1074,     0,    32,     0,
+,     0,     0,     0,     0,     0,   648,     0,     0,     0,
+,     0,     0,   286,   287,   288,   289,    40,    41,     0,
+,   291,     0,     0,     0,     0,     0,     0,   292,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   293,     0,   377,     0,     0,   169,     0,
+,     0,   295,   379,   297,   298,   299,   300,     0,     0,
+,   281,  1076,   282,  1062,     0,  1063,  1418,  1419,  1064,
+,  1066,  1067,  1068,  1069,  1070,  1071,     0,     0,     0,
+,     0,     0,     0,  1073,  1074,     0,    32,     0,   283,
+,     0,     0,     0,     0,   648,     0,     0,     0,   285,
+,     0,   286,   287,   288,   289,    40,    41,     0,   290,
+,     0,     0,     0,     0,     0,     0,   292,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   293,     0,   377,     0,     0,   169,     0,     0,
+,   295,   379,   297,   298,   299,   300,     0,     0,   280,
+,  1076,   282,  1062,     0,  1063,     0,     0,  1064,  1065,
+,  1067,  1068,  1069,  1070,  1071,     0,     0,     0,  1072,
+,     0,     0,  1073,  1074,     0,    32,     0,   283,     0,
+,     0,     0,     0,   648,     0,     0,     0,   285,     0,
+,   286,   287,   288,   289,    40,    41,     0,   290,   291,
+,     0,     0,     0,     0,     0,   292,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,   293,     0,   377,     0,     0,   169,     0,     0,     0,
+,   379,   297,   298,   299,   300,     0,     0,     0,     0,
+,     2,   204,     4,     5,     6,     7,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,     0,     0,    25,    26,    27,     0,
+,     0,     0,     0,     0,    30,     0,   280,   281,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,   280,   281,     0,   282,
+,     0,     0,    33,     0,    34,   283,    35,     0,     0,
+,    38,   284,     0,     0,     0,   285,     0,     0,   286,
+,   288,   289,    40,    41,   283,   290,   291,     0,     0,
+,   648,  1327,     0,   292,   285,     0,     0,   286,   287,
+,   289,    40,    41,     0,   290,   291,     0,     0,   293,
+,   377,     0,   292,   280,   281,     0,   282,   295,   733,
+,   298,   299,   300,     0,     0,     0,     0,   293,     0,
+,     0,     0,   280,   281,     0,   282,   295,   379,   297,
+,   299,   300,   283,     0,     0,     0,     0,     0,   284,
+,     0,     0,   285,     0,     0,   286,   287,   288,   289,
+,    41,   283,   290,   291,     0,     0,     0,   284,     0,
+,   292,   285,     0,     0,   286,   287,   288,   289,    40,
+,     0,   290,   291,     0,     0,   293,     0,   377,     0,
+,   280,   281,     0,   282,   295,   826,   297,   298,   299,
+,     0,     0,     0,     0,   517,     0,     0,     0,     0,
+,     0,     0,     0,   295,   379,   297,   298,   299,   300,
+,     0,     0,     0,     0,     0,   284,     0,     0,     0,
+,     0,     0,   286,   287,   288,   289,    40,    41,     0,
+,   291,     0,     0,     0,     0,     0,     0,   292,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,   520,     0,     0,     0,     0,     0,     0,
+,     0,   295,   379,   297,   298,   299,   300,     2,   204,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,     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,    34,     0,    35,    36,     0,   172,   173,    39,
+,     0,     0,     0,     0,     0,    40,    41,   203,     2,
+,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,     0,     0,    25,    26,    27,     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,
+,    33,     0,    34,     0,    35,     0,     0,   205,    38,
+,     2,   204,     4,     5,     6,     7,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,     0,     0,    25,    26,    27,     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,    33,     0,    34,     0,    35,     0,     0,
+,    38,     2,   204,     4,     5,     6,     7,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,     0,     0,    25,    26,    27,
+,     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,    33,     0,    34,     0,    35,     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[] =
+{
+,     1,     0,    42,   237,   217,   183,   183,   202,    42,
+,     1,     1,   183,    42,   542,   183,   183,   114,   103,
+,   455,   519,   343,     0,     0,   628,   454,    28,    29,
+,    31,   697,    31,   697,   183,   498,   697,   610,   608,
+,    31,    42,   679,    44,   461,    44,   347,  1042,   496,
+,   901,   655,     1,    54,    31,    31,   166,   167,   608,
+,  1061,    60,    63,   608,    63,    66,   610,    66,   153,
+,     0,   578,    63,  1005,   277,    66,    66,   416,   998,
+,    81,  1041,  1042,   184,   608,   263,   263,    63,   779,
+,   362,   185,   263,   608,   366,   263,   263,   436,    31,
+,   528,    31,   199,   104,  1337,   444,   107,   608,    27,
+,   776,     0,   776,   114,   263,   776,    42,   608,   722,
+,   643,   644,  1054,   758,   424,   425,   611,    38,   254,
+,   644,    38,   617,    81,    42,    62,   106,  1418,   661,
+,     1,    63,    31,   183,   145,    44,   145,   661,   109,
+,    81,   108,   153,   226,   183,   116,  1422,   158,    77,
+,   130,    38,   110,   264,   612,   259,   260,   488,   616,
+,    31,    44,   245,   743,   109,    43,    44,   814,   109,
+,  1074,   116,   183,   184,    81,   184,   108,   824,    54,
+,    43,    44,    38,   641,    38,   408,    84,   108,   199,
+,   500,    63,   839,   110,   131,    66,   207,  1440,   207,
+,   109,  1492,   735,    43,    44,   216,   494,   108,   219,
+,   219,   735,    38,   263,   112,   226,    81,   108,   219,
+,   183,   108,    11,   110,   263,   115,   109,   108,   104,
+,   241,   107,   743,   219,   245,  1240,   114,  1141,   249,
+,   249,   131,   743,   115,  1520,   340,   113,   183,   249,
+,   113,   116,   263,   264,   108,   264,   110,   115,   838,
+,    38,   144,   249,   249,     0,   183,   277,   850,   599,
+,   510,     3,   717,   113,   369,   585,  1552,    81,   838,
+,   416,   292,   108,   838,   110,  1290,   158,   394,  1474,
+,  1525,   250,  1303,   404,   827,    31,   850,   628,   207,
+,   436,   818,   633,   827,   838,   109,   249,  1008,   444,
+,  1545,   486,   116,   838,   596,   422,   327,  1552,   327,
+,  1290,   428,    81,  1509,   207,  1511,  1256,   838,    94,
+,   108,    95,   110,   292,   111,   346,   347,   838,   115,
+,   216,   690,    95,   454,  1525,   840,   115,   219,   698,
+,   249,     3,   363,     1,   237,   254,   367,   639,   122,
+,   269,    71,   348,   129,  1225,   696,   108,   378,    71,
+,   720,  1552,    82,    83,   108,   486,   959,   108,   249,
+,    83,   114,   115,   394,   293,   257,   269,   296,    71,
+,   108,  1038,  1039,   404,   270,   404,    44,   130,   958,
+,    83,   277,   115,   958,    71,     0,   115,  1020,     0,
+,   115,   422,   130,   296,   872,    82,    83,   428,   131,
+,   488,   131,   131,   109,   958,  1070,   131,   110,   131,
+,    67,   115,    89,    90,    71,   675,   531,    74,   115,
+,   130,   772,   115,   454,  1414,    71,    83,   131,   459,
+,  1097,   118,  1463,   464,   131,   103,    82,    83,   131,
+,   343,   109,   473,   108,  1406,  1407,   115,   478,   125,
+,   346,   109,   108,   109,   109,   486,   348,   486,   116,
+,   115,   490,   131,   494,   110,   109,   497,   363,   499,
+,    71,   367,   130,   479,   967,  1003,   144,   120,   121,
+,   927,    82,    83,   490,   490,   153,   964,   945,   519,
+,   697,   115,  1523,   249,   473,   108,   697,   416,   254,
+,   697,   761,   108,  1225,   699,   536,  1140,   131,   539,
+,   541,   542,  1115,   697,  1029,  1030,   656,   436,   697,
+,   108,   424,   425,   452,   757,   444,   455,   829,    87,
+,   490,   833,   461,   991,   690,   203,   663,   429,    71,
+,   519,   665,   850,   115,    10,    11,    12,    13,    14,
+,    83,   115,   108,   210,   642,   643,   644,   536,   589,
+,   539,   470,   541,   542,   109,   596,   115,   131,   699,
+,   238,   490,    38,   661,   109,   108,   732,   608,   115,
+,   695,  1303,   131,   512,    71,   514,   115,   479,   517,
+,   597,   520,   109,   115,   131,    82,    83,   500,   629,
+,    66,   269,   131,  1270,   272,   109,    79,   977,   696,
+,   589,  1278,  1279,  1280,   645,    71,   519,    73,    74,
+,   651,   923,   295,   296,   630,   293,    82,    83,   296,
+,   111,   662,   663,   664,   307,   114,  1101,   110,  1303,
+,    79,     3,   111,   116,   887,   108,   115,   735,    10,
+,    12,    13,    14,    91,    92,   963,   771,   113,     0,
+,   416,   109,   108,   293,   110,   908,   697,   115,   699,
+,   343,   110,   340,   112,   111,   343,    38,   116,   115,
+,   436,   712,   585,   662,   772,   664,   118,   718,   444,
+,   131,   123,   124,   350,   362,   352,   599,    71,   366,
+,    42,   369,    44,   111,    66,   969,   379,   115,    82,
+,   602,   108,   743,   744,   109,  1380,   109,   723,    60,
+,   115,    63,   115,  1135,    66,   628,   757,   108,    63,
+,   633,   737,   488,   629,   490,   108,   110,   118,   630,
+,  1495,  1463,   937,   635,   108,   108,  1501,   110,  1470,
+,   945,   730,   108,   893,   110,   118,   424,   425,   111,
+,   109,  1319,   118,  1133,   660,   115,   115,  1522,   113,
+,   679,   690,  1527,   131,    52,   115,   113,   512,    71,
+,    73,    74,   517,   440,   452,   520,   109,   455,   717,
+,    83,   109,   115,   461,   424,   425,   128,   115,   130,
+,  1102,  1523,  1467,   145,  1469,   473,   937,   838,  1033,
+,   114,   115,   109,   732,   945,   108,   158,    95,   115,
+,   113,  1191,  1192,   109,   108,   831,   110,   834,   131,
+,   498,   723,   500,  1529,   502,  1529,   131,   109,  1529,
+,   116,   183,   184,   115,   512,   737,   514,   109,   109,
+,   109,   519,   520,   115,   115,    71,   115,    73,    74,
+,   108,   757,   893,   531,   108,   207,    82,    83,   109,
+,   901,  1131,   109,   109,   115,  1135,  1136,   219,   115,
+,   901,    81,   512,   556,   557,   558,   108,   517,   110,
+,   520,   108,   923,   110,   901,   901,   109,   110,     4,
+,     6,     7,     8,     9,   108,   814,   937,   249,    71,
+,    73,    74,    81,   191,   945,   824,  1056,   585,   119,
+,    83,   263,   901,   108,   109,   110,   599,   108,   596,
+,   839,   599,   963,   108,   690,   110,   214,    57,    58,
+,   696,   108,   109,   110,   574,   108,   224,   968,   968,
+,   113,   110,   983,  1041,     4,     5,     6,     7,     8,
+,   628,   992,    68,   127,    70,   633,   108,   109,   110,
+,   128,   639,  1003,   130,  1005,    71,   732,    73,    74,
+,   110,   108,   901,   110,     3,   327,    82,    83,   114,
+,  1250,    10,    11,    12,    13,    14,  1123,    71,   927,
+,    74,    75,   115,   116,   983,   347,   115,   116,    82,
+,   901,   108,   108,   110,   110,   293,   772,  1023,    68,
+,    70,  1000,   118,  1054,  1003,   131,  1005,   695,   108,
+,   110,  1401,    93,  1064,   108,   108,  1067,  1068,  1069,
+,  1061,    10,    11,    12,    13,    14,  1504,    66,  1418,
+,   563,   564,   565,   566,  1061,  1061,    71,   111,    73,
+,   733,  1092,   404,    43,    44,    44,   969,    82,    83,
+,   111,   702,  1160,   704,   109,  1054,   109,   968,  1338,
+,   109,    60,  1342,   109,    63,  1064,   109,    66,  1067,
+,  1069,     3,  1123,   561,   562,   110,  1554,    66,    10,
+,    12,    13,    14,   771,   109,  1220,   779,    71,   108,
+,    74,    75,   454,   111,   109,   111,   111,  1020,    82,
+,   115,  1491,  1492,    57,    58,    59,    38,   567,   568,
+,  1039,  1023,  1262,  1263,  1264,   130,   131,   559,   560,
+,   110,   110,  1061,   115,   108,   901,   130,   113,   490,
+,   108,   111,   494,   826,    66,   109,   109,   116,   115,
+,   111,   829,   111,   441,   111,   833,   145,  1198,   116,
+,  1061,   116,  1101,   109,    84,    85,    86,   109,   111,
+,   109,  1202,  1203,  1203,  1444,   113,   116,  1096,  1097,
+,   114,   114,   114,   108,  1225,   115,  1202,   475,   108,
+,   110,  1289,   112,   113,  1225,   184,   109,     4,     5,
+,     7,     8,     9,   131,   109,   109,   116,   109,  1225,
+,   109,   109,   115,  1244,  1244,    71,   109,   109,   207,
+,   109,  1262,  1263,  1264,   512,    32,    82,    83,   109,
+,   219,   109,   520,   109,   109,    71,  1225,    73,    74,
+,    84,    85,    86,   109,   109,   923,    82,    83,   470,
+,   109,   109,   108,   114,   110,   109,   608,   109,   610,
+,  1397,    68,   118,    70,   108,  1539,   110,  1298,   112,
+,   698,   111,  1303,  1262,  1263,  1264,   109,   130,  1319,
+,   109,   109,  1298,   114,   109,   115,  1303,  1303,   111,
+,   968,   969,   720,   111,   109,  1061,  1225,    71,   109,
+,  1202,    75,  1203,   109,   901,   115,  1337,  1337,    82,
+,   115,  1529,  1529,   116,   113,   111,    71,   109,  1529,
+,    75,  1529,  1529,   111,  1225,  1530,   115,    82,    83,
+,  1319,  1320,   109,  1374,   108,  1529,  1377,  1020,   327,
+,  1529,   108,  1020,  1244,   118,   697,   108,   699,   108,
+,   108,  1270,   108,   108,   111,  1396,  1397,   116,   131,
+,  1279,  1280,   114,   118,   109,  1406,  1407,  1504,    71,
+,    73,    74,    75,   109,  1303,     0,     1,   128,  1061,
+,    83,  1422,   114,   811,   113,  1374,  1427,   111,  1377,
+,   678,   743,   744,   131,  1160,   109,  1298,   115,   111,
+,   115,   111,  1303,   691,  1445,   109,    31,  1326,   109,
+,  1440,   109,   111,  1554,   111,   404,  1457,  1406,  1407,
+,   111,   109,    54,  1101,  1102,   111,   111,   111,    46,
+,   109,   131,  1463,  1422,   114,   131,  1337,   131,  1427,
+,    71,    66,    73,    74,    75,   114,  1463,  1463,   131,
+,   131,    82,    83,  1470,  1470,  1529,  1445,   679,   116,
+,  1529,   889,   109,  1504,  1505,   111,   114,  1064,  1457,
+,   111,   111,   104,  1514,  1240,   107,   111,   108,   103,
+,    80,    81,   111,   111,  1525,   111,   838,   118,  1529,
+,  1396,  1530,  1523,   109,  1177,   109,   111,   108,   850,
+,    63,   108,  1543,   108,  1545,    59,  1523,  1523,  1549,
+,   109,  1552,   109,  1554,   131,  1554,  1505,    80,   116,
+,   145,   153,   111,  1564,   111,  1514,   109,   111,   153,
+,   109,  1520,   108,  1472,  1463,  1474,  1525,  1303,    95,
+,    95,  1470,  1220,   108,   114,   131,   115,   111,   109,
+,   109,   109,   115,   109,  1543,    41,  1545,   131,   131,
+,  1549,    95,  1463,  1552,  1204,  1205,  1244,  1207,   116,
+,  1509,  1560,  1511,  1213,   199,  1564,  1216,   202,   203,
+,  1008,   109,   207,    95,   216,   937,   131,   109,   109,
+,   116,   131,   814,   945,  1523,   158,   109,   114,   109,
+,   131,    52,   824,   228,    55,    56,    57,   232,    59,
+,   111,   963,   111,   108,   114,   131,   114,   839,   243,
+,   109,   131,  1523,    74,   249,   109,  1539,   109,  1225,
+,  1058,  1076,   569,  1225,   570,    86,    87,   925,   270,
+,   571,   241,  1492,    63,   573,   277,  1382,   272,   572,
+,    26,    27,  1564,    73,  1313,  1136,   219,  1342,  1470,
+,    10,    11,    12,    13,    14,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    27,  1092,    29,    30,    31,   452,    38,
+,   945,   704,   464,    38,   257,   115,   893,  1463,   261,
+,   992,   589,   965,   657,  1470,  1133,   747,  1244,   490,
+,   577,    -1,    -1,   577,   346,   340,    66,   577,   343,
+      -1,    96,    66,    98,  1320,   349,    -1,    -1,    -1,    73,
+,    -1,   363,    77,    -1,    -1,   367,  1376,   362,   158,
+      -1,    -1,   366,    -1,    -1,   369,    -1,    10,    11,    12,
+,    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,
+,    -1,    -1,    66,   179,    -1,    -1,   431,    -1,    -1,
+      -1,    -1,   436,    -1,   189,   190,    -1,  1038,  1039,   194,
+,   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,
+,  1457,  1539,    -1,   488,   464,   490,   429,    -1,    10,
+,    12,    13,    14,   498,  1096,  1097,    -1,   502,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    10,    11,    12,
+,    14,    -1,   343,   344,    -1,    -1,    38,   497,    71,
+,    73,    74,    75,    -1,   355,   356,   531,   532,    -1,
+,    83,    -1,    -1,    -1,    38,    -1,   479,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    66,    -1,    -1,    -1,   348,
+,    -1,    73,    74,    75,    -1,   108,    -1,   110,    -1,
+      -1,    82,    83,    66,   116,    -1,   118,  1543,    71,    -1,
+,    74,    75,  1549,   578,    -1,    -1,    -1,    -1,    82,
+,    -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,
+,    -1,    -1,    -1,   645,   639,    -1,  1238,   642,   643,
+,    -1,    -1,    -1,    -1,  1312,    -1,   446,    -1,   660,
+,    -1,    73,    74,    75,    -1,    -1,   661,    -1,    -1,
+,    82,    83,    -1,    -1,    -1,    -1,    -1,    -1,  1270,
+      -1,    -1,   651,    -1,    -1,   679,    -1,  1278,  1279,  1280,
+,    -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,
+,    20,    21,    22,    23,    24,    25,    26,     0,    -1,
+,    30,    31,    -1,    -1,  1326,    -1,    -1,   732,    38,
+,   735,    -1,   712,    -1,    -1,    -1,    -1,    -1,   718,
+,    -1,    -1,   747,    -1,     0,   757,    -1,    -1,    31,
+,    -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,
+,    66,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,   827,    -1,   829,   581,   582,   832,   833,
+,   630,    -1,    -1,    -1,   839,   635,    -1,    -1,    -1,
+      -1,  1508,    -1,  1510,    -1,   849,    71,    -1,    73,    74,
+,    -1,    -1,    -1,    -1,    -1,   611,    82,    83,   614,
+,    -1,   617,    -1,   619,   620,    -1,    -1,    -1,   624,
+,    -1,   154,    96,    97,    98,    99,   100,   101,   102,
+,   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,
+,   900,    -1,   194,   723,   755,    -1,    -1,    10,    11,
+,    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,
+,    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,
+,    -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,
+,   416,   444,    -1,    -1,    -1,    -1,   997,   187,    -1,
+,   190,    -1,    -1,  1004,   194,   431,   196,   197,  1009,
+      -1,   436,    -1,    -1,  1014,    -1,  1016,    -1,   470,   444,
+,  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,
+,    13,    14,   488,  1238,   490,  1240,    -1,    -1,    -1,
+,    -1,    -1,    -1,    -1,    -1,    -1,   266,    -1,  1079,
+,    -1,  1082,    -1,    -1,    -1,    38,    -1,    -1,    -1,
+,    -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,
+,    73,    74,    75,    -1,    -1,  1126,  1127,    -1,  1303,
+,    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,
+,  1181,  1182,    -1,    -1,    -1,  1298,    -1,    -1,    -1,
+,   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,
+,  1231,    -1,  1202,    -1,    -1,   661,    -1,   690,    -1,
+,    -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,
+,  1281,  1282,   735,    -1,    -1,    -1,    -1,    -1,  1463,
+      -1,  1291,    -1,    -1,    -1,    -1,  1470,  1222,    -1,    -1,
+,    -1,    -1,    -1,    -1,    -1,    31,   732,    66,    -1,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    -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,
+,   620,    -1,    -1,    -1,   624,   625,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   901,
+,  1451,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,  1463,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,    -1,    -1,   901,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,   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,
+,    -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,
+,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+,    29,    30,    31,    -1,    -1,  1566,  1567,    -1,  1010,
+,    39,    -1,    -1,  1574,  1575,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,  1026,  1038,  1039,    -1,  1041,
+,   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,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,    26,  1061,    -1,    29,    30,
+,    -1,   110,    -1,  1096,  1097,   114,    38,    -1,    -1,
+,    -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,
+,    -1,    73,    74,    75,   416,   444,    -1,    -1,    -1,
+      -1,    82,    83,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    -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,
+,   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,
+,    -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,
+,    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,
+,  1463,    -1,    71,   772,    -1,    -1,    75,  1470,    -1,
+,    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,
+,    -1,   110,    -1,    -1,    -1,   814,    -1,    -1,   117,
+,   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,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    -1,   901,    29,    30,    31,    32,    -1,    -1,
+,    -1,    -1,    38,    39,    -1,    -1,    -1,    -1,    10,
+,    12,    13,    14,    -1,    10,    11,    12,    13,    14,
+,    -1,    -1,    -1,    -1,    -1,   901,    -1,    63,    -1,
+      -1,    66,    44,    68,    -1,    70,    71,    38,    73,    74,
+,    -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,
+,    66,    -1,   108,    75,   110,    71,   985,    -1,    -1,
+,    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,
+,    -1,    -1,   108,    -1,    -1,    -1,   118,    -1,    -1,
+      -1,    -1,    -1,   118,    -1,    -1,    -1,    -1,    -1,    -1,
+,  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,
+,  1042,    -1,    -1,    -1,    -1,  1041,  1042,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,    26,    -1,    -1,    29,    30,    31,   261,
+,    -1,  1160,    -1,    -1,    38,    71,   269,    -1,    -1,
+,    -1,    -1,    78,    79,    80,    81,    82,    83,    -1,
+,    86,    -1,    -1,    -1,    -1,    -1,    -1,    93,  1160,
+      -1,   293,    -1,    66,   296,    -1,    -1,    -1,    -1,    -1,
+,    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,
+,   343,  1240,    -1,    -1,   118,   348,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,  1225,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,    -1,    -1,    -1,  1238,    -1,  1240,
+      -1,    -1,  1270,    -1,    -1,    -1,    -1,    -1,    -1,  1244,
+,  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,
+,    -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,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   500,    -1,
+,    -1,    75,    -1,    77,    -1,    -1,    -1,    -1,    -1,
+,    84,   514,    -1,    -1,   517,  1414,   519,   520,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -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,
+,    -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,
+,   643,   644,    -1,    -1,    -1,   219,    -1,   221,   222,
+,    -1,  1523,    -1,    -1,    -1,    -1,    -1,  1523,   661,
+      -1,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    25,    26,    27,   155,
+,    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,
+,    -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,
+,    -1,    -1,    -1,   250,   348,    -1,    -1,    -1,   255,
+,   354,    -1,    -1,    -1,    -1,    -1,    -1,   361,    -1,
+      -1,    65,   268,    -1,    -1,    -1,    -1,    71,   274,    -1,
+,    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,
+,    -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,
+,    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,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   524,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   630,   280,    -1,
+,   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,
+,    -1,    -1,    -1,    -1,    -1,    -1,   593,    -1,    -1,
+      -1,   343,   598,    -1,    65,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,   609,    75,    -1,    -1,    78,    79,    80,
+,    82,    83,    -1,    85,    86,    -1,    -1,    -1,    -1,
+,    -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,
+,   122,    -1,    -1,   757,    -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,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    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,
+,   563,   564,   565,   566,   567,   568,   569,   570,   571,
+,   573,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    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,
+,    -1,    -1,    -1,    -1,    71,    -1,    -1,   874,    75,
+,    -1,    78,    79,    80,    81,    82,    83,    -1,    85,
+,    -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,
+,    -1,    -1,    -1,   930,    -1,    -1,    -1,    -1,    -1,
+      -1,  1034,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -1,  1474,    -1,    -1,    -1,   698,    -1,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    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,
+,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      -1,    29,    30,    31,    66,    -1,    -1,  1539,    -1,    -1,
+,    -1,  1115,  1019,    -1,    77,    -1,    -1,    -1,   153,
+,    -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,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1075,
+      -1,    -1,    -1,    -1,   826,    -1,  1082,    -1,    -1,    -1,
+,    -1,   110,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    36,    37,    -1,    39,    -1,    -1,    -1,    -1,  1202,
+      -1,    -1,    -1,    -1,    -1,  1111,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1124,    -1,
+,    -1,    -1,    -1,    -1,    -1,    71,    -1,    73,    74,
+,    -1,   266,    78,    79,    80,    81,    82,    83,    -1,
+,    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,
+,  1187,    -1,    -1,    -1,    -1,    -1,    -1,   322,    -1,
+      -1,    -1,    -1,    -1,    -1,  1298,   330,   331,    -1,   333,
+,    -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,
+,    -1,   366,    -1,    -1,   369,    -1,    -1,    -1,    -1,
+,    -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,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    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,
+,    -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,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1191,
+,    -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,
+,    -1,  1478,    -1,   608,  1481,   610,   611,    -1,    -1,
+      -1,    -1,    -1,   617,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,   627,   628,    -1,    -1,    -1,    -1,   633,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   642,   643,
+,    -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,
+,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
+,    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,
+,    -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,
+,    -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,
+,    -1,   656,    -1,    -1,    -1,    -1,    -1,    -1,     3,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    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,
+,    75,    -1,    -1,   958,   959,    -1,    65,    82,    83,
+      -1,    -1,    -1,    71,    -1,    -1,    -1,    75,    -1,    -1,
+,    79,    80,    81,    82,    83,    -1,    85,    86,    -1,
+      -1,   985,    -1,    -1,   108,    93,   110,   991,   772,    -1,
+,    -1,    -1,    -1,   118,    -1,   780,    -1,    -1,    -1,
+,    -1,   110,   787,    -1,   113,  1010,  1011,    -1,   117,
+,   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,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   849,    -1,    -1,    -1,    -1,
+,    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,
+,    -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,
+,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,
+,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    27,    -1,    -1,    30,    31,
+,    -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,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
+      -1,    30,    31,    32,    -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,    -1,    67,    -1,
+,    -1,    71,    -1,    -1,    74,    75,     4,     5,     6,
 ,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 ,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      -1,    -1,    29,    30,    31,    32,    -1,    -1,    35,    36,
+,    38,    39,    40,    -1,    42,  1160,    -1,    45,    46,
+,    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,
+,   118,   119,   120,   121,   122,  1240,    -1,    -1,  1023,
+,    65,    -1,    -1,   131,    -1,    -1,    71,    -1,    -1,
+,    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,
+,    -1,    -1,   117,   118,   119,   120,   121,   122,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    -1,    -1,    29,    30,    31,    32,    -1,    -1,
+,    36,    37,    38,    39,    -1,    -1,  1141,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+,    37,    -1,    39,    -1,    -1,  1160,    -1,    -1,    -1,
+,    66,    -1,    68,    -1,    70,    71,    -1,    73,    74,
+,  1175,  1176,    78,    79,    80,    81,    82,    83,    65,
+,    86,    -1,    -1,    -1,    71,    -1,    -1,    93,    75,
+,    -1,    78,    79,    80,    81,    82,    83,    -1,    85,
+,    -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,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    -1,    29,    30,    31,    32,    -1,    -1,    35,    36,
+,    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,
+,    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,
+,   118,   119,   120,   121,   122,    -1,    -1,     4,     5,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
+      -1,    -1,    39,    -1,    10,    11,    12,    13,    14,    15,
 ,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,  1405,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
+,    37,    38,    39,    -1,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    -1,    -1,    29,    30,    31,    -1,    -1,    65,
+,    -1,    68,    38,    70,    71,    -1,    73,    74,    75,
+      -1,    -1,    78,    79,    80,    81,    82,    83,    -1,    85,
+,    -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,
+,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    36,
+,    38,    39,    -1,    -1,  1539,    -1,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    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,
+,   118,   119,   120,   121,   122,     4,     5,     6,     7,
+,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+      -1,    29,    30,    31,    -1,    -1,    -1,    -1,    36,    37,
+,    39,    -1,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      -1,    -1,    29,    30,    31,    -1,    -1,    65,    66,    -1,
+,    38,    70,    71,    -1,    73,    74,    75,    -1,    -1,
+,    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,
+,    -1,   110,    -1,    -1,    -1,    -1,   115,    -1,   117,
+,   119,   120,   121,   122,     4,     5,     6,     7,     8,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
+,    30,    31,    -1,    -1,    -1,    -1,    36,    37,    38,
+,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+      -1,    29,    30,    31,    -1,    -1,    65,    66,    -1,    68,
+,    70,    71,    -1,    73,    74,    75,    -1,    -1,    78,
+,    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,
+,   120,   121,   122,     4,     5,     6,     7,     8,     9,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    -1,    -1,    29,
+,    31,    -1,    -1,    -1,    -1,    36,    37,    38,    39,
+      -1,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    65,    66,    -1,    68,    38,
+,    71,    -1,    73,    74,    75,    -1,    -1,    78,    79,
+,    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,
+,    -1,    -1,    -1,    -1,    -1,    -1,   117,   118,   119,
+,   121,   122,     4,     5,     6,     7,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,    26,    -1,    -1,    29,    30,
+,    -1,    -1,    -1,    -1,    36,    37,    38,    39,    -1,
+,    27,    -1,    -1,    30,    31,    32,    33,    34,    35,
+,    -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,
+,    -1,    73,    74,    75,    -1,    -1,    78,    79,    80,
+,    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,
+,   122,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    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,
+,    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,
+,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    -1,    -1,    29,    30,    31,
+,    -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,
+,    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,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,
+      -1,    -1,    38,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      -1,    -1,    29,    30,    31,    32,    33,    34,    -1,    -1,
+,    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,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    27,    -1,    29,
+,    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,
+,    -1,    -1,    73,    74,    -1,    -1,    77,    -1,     3,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    -1,    -1,    29,    30,    31,    32,    -1,
+,    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,
+,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,    26,    -1,    -1,    29,    30,
+,    -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,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    -1,    -1,    29,
+,    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,
+,    71,    -1,    73,    74,    75,    -1,    -1,    -1,    -1,
+      -1,    -1,    82,    83,    -1,    -1,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    -1,    -1,    29,    30,    31,   108,    -1,
+,    -1,    -1,    -1,    38,    -1,    -1,    -1,   118,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    66,    -1,    29,    30,    31,    71,    -1,    73,
+,    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,
+,    -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,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    -1,    -1,    29,
+,    31,    -1,    -1,    -1,    -1,    -1,    -1,    38,    -1,
+      -1,    -1,    -1,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      -1,    -1,    29,    30,    31,    -1,    66,    -1,    68,    -1,
+,    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,
+,    -1,    -1,    -1,    -1,    82,    83,    -1,   118,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    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,
+,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    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,
+,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    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,
+,    74,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    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,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+      -1,    -1,    29,    30,    31,    -1,    -1,    -1,    -1,    36,
+,    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,
+,   118,   119,   120,   121,   122,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    -1,    -1,    29,    30,    31,    -1,    -1,
+      -1,    -1,    36,    37,    38,    39,    10,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    27,    -1,    29,    30,    31,    -1,    -1,
+      -1,    65,    66,    -1,    38,    -1,    -1,    71,    -1,    73,
+,    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,
+,    75,    -1,    77,   108,    -1,   110,   111,    82,    83,
+      -1,    -1,    -1,   117,   118,   119,   120,   121,   122,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,    26,   110,    -1,    29,    30,
+,    -1,    -1,    -1,   118,    36,    37,    38,    39,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,    26,    -1,    -1,    29,    30,
+,    -1,    -1,    -1,    65,    66,    -1,    38,    -1,    -1,
+,    -1,    73,    74,    75,    -1,    -1,    78,    79,    80,
+,    82,    83,    -1,    85,    86,    -1,    -1,    -1,    -1,
+      -1,    -1,    93,    -1,    -1,    66,    -1,    -1,    -1,    -1,
+,    -1,    73,    74,    -1,    -1,    -1,   108,   109,   110,
+      -1,    82,    83,    -1,    -1,    -1,   117,   118,   119,   120,
+,   122,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,   110,
+      -1,    29,    30,    31,    -1,    -1,    -1,   118,    36,    37,
+,    39,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+      -1,    29,    30,    31,    -1,    -1,    -1,    65,    66,    -1,
+,    39,    -1,    71,    -1,    73,    74,    75,    -1,    -1,
+,    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,
+,    -1,   110,    -1,    -1,    -1,    -1,    -1,    -1,   117,
+,   119,   120,   121,   122,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,   110,    -1,    29,    30,    31,    -1,    -1,    -1,
+,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    10,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,    66,    29,    30,    31,    -1,    71,    -1,    73,    74,
+,    38,    -1,    78,    79,    80,    81,    82,    83,    -1,
+,    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,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    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,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    65,    66,    29,    30,    31,    -1,    71,
+      -1,    73,    74,    75,    38,    -1,    78,    79,    80,    81,
+,    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,
+,    -1,    -1,    -1,    -1,   117,   118,   119,   120,   121,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
+,    30,    31,    -1,   108,    -1,   110,    36,    37,    38,
+,    -1,    -1,    -1,   118,    -1,    -1,    -1,    -1,    10,
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,    26,    65,    66,    29,    30,
+,    -1,    71,    -1,    73,    74,    75,    38,    39,    78,
+,    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,
+,   120,   121,   122,     3,     4,     5,     6,     7,     8,
+,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+,    20,    21,    22,    23,    24,    25,    26,    -1,   110,
+,    30,    31,   114,    -1,    -1,    -1,   118,    -1,    38,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    -1,    -1,    29,
+,    31,    -1,    -1,    -1,    -1,    -1,    66,    38,    68,
+      -1,    70,    -1,    -1,    73,    74,    -1,    -1,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    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,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    -1,    66,    29,    30,    31,   108,    71,
+,    73,    74,    75,    38,    -1,    -1,    -1,   118,    -1,
+,    83,    -1,    -1,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    -1,    66,    29,    30,    31,   108,    -1,   110,    73,
+,    -1,    38,    -1,    -1,    -1,   118,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,    26,    -1,    -1,    29,    30,    31,    -1,
+,    -1,    -1,    -1,    -1,    38,   110,    73,    74,    -1,
+      -1,    -1,    -1,    -1,   118,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    -1,    66,    29,    30,    31,    -1,    -1,    -1,
+,    74,    -1,    38,   110,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   118,    10,    11,    12,    13,    14,    15,    16,
+,    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,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    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,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    -1,    66,    29,    30,    31,    -1,    -1,    -1,    73,
+,    -1,    38,   110,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   118,    10,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+,    29,    30,    31,    -1,    -1,   110,    73,    74,    -1,
+,    -1,    -1,    -1,   118,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    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,
+,    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,
+,    -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,
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    21,    22,    23,    24,    25,    26,    -1,    -1,    29,
+,    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,
+,    -1,    -1,    73,    74,    36,    37,    -1,    39,    40,
+      -1,    42,    -1,    -1,    45,    46,    47,    48,    49,    50,
+,    52,    -1,    -1,    55,    56,    -1,    -1,    -1,    60,
+,    -1,    63,    -1,    65,    -1,    -1,    -1,    -1,   109,
+,    -1,    -1,    -1,    75,    -1,    -1,    78,    79,    80,
+,    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,
+,   122,    -1,    -1,    -1,    -1,   127,    -1,    36,    37,
+,    39,    40,    -1,    42,    -1,    -1,    45,    46,    47,
+,    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,
+,    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,
+,    -1,   110,    -1,    -1,   113,    -1,    -1,    -1,   117,
+,   119,   120,   121,   122,    -1,    -1,    -1,    -1,   127,
+      -1,    36,    37,   131,    39,    40,    -1,    42,    43,    44,
+,    46,    47,    48,    49,    50,    51,    52,    -1,    -1,
+,    56,    -1,    -1,    -1,    60,    61,    -1,    63,    -1,
+,    -1,    -1,    -1,    -1,    -1,    71,    -1,    -1,    -1,
+,    -1,    -1,    78,    79,    80,    81,    82,    83,    -1,
+,    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,
+,    37,   127,    39,    40,    -1,    42,    43,    44,    45,
+,    47,    48,    49,    50,    51,    52,    -1,    -1,    -1,
+,    -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,
+,    -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,
+,   127,    39,    40,    -1,    42,    -1,    -1,    45,    46,
+,    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,
+,   118,   119,   120,   121,   122,    -1,    -1,    -1,    -1,
+,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    24,    25,    26,    -1,    -1,    29,    30,    31,    -1,
+      -1,    -1,    -1,    -1,    -1,    38,    -1,    36,    37,    -1,
+,    -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,
+,    74,    71,    -1,    -1,    -1,    75,    -1,    -1,    78,
+,    80,    81,    82,    83,    65,    85,    86,    -1,    -1,
+      -1,    71,    95,    -1,    93,    75,    -1,    -1,    78,    79,
+,    81,    82,    83,    -1,    85,    86,    -1,    -1,   108,
+      -1,   110,    -1,    93,    36,    37,    -1,    39,   117,   118,
+,   120,   121,   122,    -1,    -1,    -1,    -1,   108,    -1,
+,    -1,    -1,    36,    37,    -1,    39,   117,   118,   119,
+,   121,   122,    65,    -1,    -1,    -1,    -1,    -1,    71,
+      -1,    -1,    -1,    75,    -1,    -1,    78,    79,    80,    81,
+,    83,    65,    85,    86,    -1,    -1,    -1,    71,    -1,
+      -1,    93,    75,    -1,    -1,    78,    79,    80,    81,    82,
+,    -1,    85,    86,    -1,    -1,   108,    -1,   110,    -1,
+,    36,    37,    -1,    39,   117,   118,   119,   120,   121,
+,    -1,    -1,    -1,    -1,   108,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   117,   118,   119,   120,   121,   122,
+,    -1,    -1,    -1,    -1,    -1,    71,    -1,    -1,    -1,
+,    -1,    -1,    78,    79,    80,    81,    82,    83,    -1,
+,    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,
+,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    -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,
+,    -1,    68,    -1,    70,    71,    -1,    73,    74,    75,
+      -1,    -1,    -1,    -1,    -1,    -1,    82,    83,     3,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    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,
+,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+,    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,
+,    74,     4,     5,     6,     7,     8,     9,    10,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    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
 };
 …
 ,     3,     4,     5,     6,     7,     8,     9,    10,    11,
 ,    13,    14,    15,    16,    17,    18,    19,    20,    21,
 ,    23,    24,    25,    26,    29,    30,    31,    32,    35,
 ,    39,    63,    66,    68,    70,    71,    73,    74,    75,
 ,    83,   108,   110,   118,   136,   139,   196,   210,   211,
+,    23,    24,    25,    26,    27,    30,    31,    32,    33,
+,    39,    40,    64,    67,    69,    71,    72,    74,    75,
+,    83,    84,   109,   111,   119,   137,   140,   197,   211,
 ,   213,   214,   215,   216,   217,   218,   219,   220,   221,
 ,   223,   224,   225,   226,   227,   229,   230,   231,   232,
 ,   234,   235,   236,   238,   239,   240,   241,   242,   243,
 ,   252,   253,   279,   280,   281,   289,   292,   298,   299,
 ,   303,   304,   310,   315,   319,   320,   321,   322,   323,
 ,   325,   326,   346,   363,   364,   365,   366,    71,   118,
 ,   139,   213,   215,   223,   225,   235,   239,   241,   280,
 ,   108,   308,   309,   310,   308,   308,    71,    73,    74,
 ,   137,   138,   269,   270,   290,   291,    73,    74,   270,
 ,   301,    11,   197,   108,   118,   315,   320,   321,   322,
 ,   325,   326,   111,   133,   110,   216,   223,   225,   319,
 ,   362,   363,   366,   367,   134,   106,   130,   273,   113,
 ,   171,    73,    74,   136,   268,   134,   134,   134,   115,
 ,    73,    74,   108,   118,   305,   314,   315,   316,   317,
 ,   319,   323,   327,   328,   329,   330,   331,   337,     3,
 ,    77,   237,     3,     5,    73,   110,   118,   215,   226,
 ,   233,   242,   281,   319,   323,   366,   213,   215,   225,
 ,   239,   241,   280,   319,   323,    32,   231,   231,   226,
 ,   134,   231,   226,   231,   226,    74,   108,   113,   270,
 ,   113,   270,   231,   226,   115,   134,   134,     0,   133,
 ,   171,   308,   308,   133,   110,   223,   225,   364,   268,
 ,   225,   130,   108,   118,   305,   315,   319,   110,   118,
 ,   302,   228,   310,   108,   286,   108,   108,    50,   108,
 ,    37,    39,    65,    71,    75,    78,    79,    80,    81,
 ,    86,    93,   108,   110,   117,   118,   119,   120,   121,
 ,   135,   139,   140,   141,   142,   147,   148,   149,   150,
+,   223,   224,   225,   226,   227,   228,   230,   231,   232,
+,   234,   235,   236,   237,   239,   240,   241,   242,   243,
+,   246,   254,   255,   282,   283,   284,   292,   295,   301,
+,   304,   306,   307,   313,   318,   322,   323,   324,   325,
+,   327,   328,   329,   349,   366,   367,   368,   369,    72,
+,   139,   140,   214,   216,   224,   226,   236,   240,   242,
+,    82,   109,   311,   312,   313,   311,   311,    72,    74,
+,    76,   138,   139,   272,   273,   293,   294,    74,    75,
+,   109,   304,    11,   198,   109,   119,   318,   323,   324,
+,   327,   328,   329,   112,   134,   111,   217,   224,   226,
+,   326,   365,   366,   369,   370,   135,   107,   131,   276,
+,   135,   172,    74,    75,   137,   271,   135,   135,   135,
+,   135,    74,    75,   109,   119,   308,   317,   318,   319,
+,   321,   322,   326,   330,   331,   332,   333,   334,   340,
+,    28,    78,   238,     3,     5,    74,   111,   119,   216,
+,   231,   234,   243,   284,   322,   326,   369,   214,   216,
+,   236,   240,   242,   283,   322,   326,    33,   232,   232,
+,   234,   135,   232,   227,   232,   227,    75,   109,   114,
+,   284,   114,   273,   232,   227,   116,   135,   135,     0,
+,   109,   172,   311,   311,   134,   111,   224,   226,   367,
+,   271,   226,   131,   109,   119,   308,   318,   322,   111,
+,   369,   305,   229,   313,   109,   289,   109,   109,    51,
+,    37,    38,    40,    66,    72,    76,    79,    80,    81,
+,    86,    87,    94,   109,   111,   118,   119,   120,   121,
+,   123,   136,   140,   141,   142,   143,   148,   149,   150,
 ,   152,   153,   154,   155,   156,   157,   158,   159,   160,
+,   164,   223,   272,   288,   362,   367,   225,   109,   109,
+,   109,   109,   109,   109,    73,    74,   110,   223,   268,
+,   364,   110,   118,   162,   215,   216,   222,   225,   229,
+,   235,   238,   239,   241,   258,   259,   263,   264,   265,
+,   280,   346,   358,   359,   360,   361,   366,   367,   111,
+,   319,   323,   366,   108,   115,   131,   110,   113,   118,
+,   274,   274,   114,   133,   115,   131,   108,   115,   131,
+,   131,   115,   131,   308,   131,   315,   316,   317,   318,
+,   329,   330,   331,   225,   314,   327,    63,   307,   110,
+,   345,   346,   308,   308,   171,   133,   108,   308,   345,
+,   308,   225,   305,   108,   108,   224,   225,   223,   225,
+,   133,   223,   362,   367,   171,   133,   268,   273,   215,
+,   319,   323,   171,   133,   290,   225,   235,   131,   225,
+,   288,    39,   110,   223,   245,   246,   247,   248,   362,
+,   113,   254,   270,   113,   225,   290,   131,   131,   301,
+,   138,   267,     3,   134,   205,   206,   220,   222,   225,
+,   307,   108,   307,   162,   315,   225,   108,   133,   268,
+,    32,    33,    34,   223,   282,   283,   285,   133,   128,
+,   287,   133,   226,   232,   233,   268,   311,   312,   313,
+,   140,   108,   147,   108,   147,   149,   108,   147,   108,
+,   147,   147,   138,   110,   162,   167,   171,   223,   271,
+,   111,   133,   149,   149,    81,    84,    85,    86,   108,
+,   112,   113,    96,    97,    98,    99,   100,   101,   102,
+,   104,   105,   130,   166,   149,   118,   123,   124,   120,
+,    87,    88,    89,    90,   125,   126,    91,    92,   119,
+,   128,    93,    94,   129,   130,   369,   108,   118,   341,
+,   343,   344,   345,   109,   115,   108,   345,   346,   108,
+,   346,   133,   108,   223,   364,   111,   133,   110,   118,
+,   223,   225,   357,   358,   366,   367,   134,   108,   110,
+,   315,   332,   333,   334,   335,   336,   337,   338,   339,
+,   346,   347,   348,   349,   350,   351,   352,   118,   366,
+,   134,   134,   118,   223,   225,   359,   268,   223,   346,
+,   268,   108,   133,   133,   133,   111,   133,    71,    79,
+,   112,   139,   270,   274,   275,   276,   277,   278,   133,
+,   133,   133,   133,   133,   305,   109,   109,   109,   109,
+,   109,   109,   314,   327,   108,   273,   111,   205,   133,
+,   167,   272,   167,   272,   305,   110,   205,   307,   171,
+,   205,   109,   247,   248,   111,   133,   108,   116,   118,
+,   251,   314,   315,   327,   345,   353,   354,   355,   356,
+,   246,   115,   131,   115,   131,   270,   245,   115,   368,
+,   255,   254,   225,   260,   261,   262,   265,   266,   109,
+,   171,   133,   118,   162,   133,   222,   225,   259,   358,
+,   299,   300,   108,   118,   332,   109,   115,   369,   270,
+,   108,   113,   270,   272,   282,   109,   115,   108,   140,
+,   116,   271,   271,   271,   110,   138,   144,   162,   272,
+,   111,   133,   109,   115,   109,   108,   118,   353,   109,
+,   162,   110,   138,   110,   143,   144,   133,   110,   138,
+,   162,   162,   149,   149,   149,   150,   150,   151,   151,
+,   152,   152,   152,   153,   153,   154,   155,   156,   157,
+,   116,   167,   162,   133,   342,   343,   344,   225,   341,
+,   308,   162,   272,   133,   267,   118,   133,   223,   346,
+,   225,   229,   111,   133,   111,   366,   111,   108,   133,
+,   333,   334,   335,   338,   348,   349,   350,   111,   133,
+,   332,   336,   347,   108,   308,   351,   369,   308,   308,
+,   108,   308,   351,   308,   308,   308,   308,   346,   223,
+,   367,   268,   111,   115,   111,   115,   369,   223,   359,
+,   256,   257,   258,   259,   256,   256,   268,   162,   133,
+,   270,   116,   115,   368,   274,    79,   110,   116,   278,
+,   207,   208,   268,   256,   138,   305,   138,   307,   108,
+,   346,   108,   345,   346,   140,   346,   171,   260,   109,
+,   109,   109,   111,   171,   205,   171,   113,   131,   131,
+,   315,   354,   355,   356,   160,   161,   225,   353,   250,
+,   250,   308,   308,   270,   308,   114,   270,   114,   161,
+,   134,   134,   138,   220,   134,   134,   256,   108,   118,
+,   134,   114,   225,   283,   284,   134,   133,   133,   108,
+,   109,   312,   167,   168,   116,   131,   110,   140,   198,
+,   200,   109,   115,   109,   133,   116,   109,   109,   109,
+,   225,   113,   149,   164,   162,   163,   165,   115,   134,
+,   133,   109,   115,   162,   133,   114,   160,   116,   260,
+,   109,   109,   341,   260,   109,   256,   223,   359,   110,
+,   162,   162,   225,   338,   260,   109,   109,   109,   109,
+,   109,   109,     7,   225,   332,   336,   347,   133,   133,
+,   133,   133,   109,   134,   134,   134,   134,   273,   134,
+,   161,   162,   306,   133,   274,   276,   114,   133,   209,
+,    39,    40,    42,    45,    46,    47,    48,    49,    50,
+,    52,    56,    60,    61,   110,   127,   138,   168,   169,
+,   171,   172,   173,   175,   176,   188,   190,   191,   196,
+,   304,    28,   134,   130,   273,   133,   133,   109,   134,
+,   245,   111,   109,   109,   109,   353,   249,   255,   114,
+,   115,   111,   111,   134,   225,   115,   369,   286,   109,
+,   213,   215,   223,   294,   295,   296,   297,   288,   109,
+,   116,   161,   108,   109,   116,   115,   138,   162,   162,
+,   115,   134,   165,   111,   138,   145,   146,   162,   144,
+,   145,   160,   164,   134,   108,   345,   346,   134,   134,
+,   134,   134,   134,   162,   109,   134,   108,   345,   346,
+,   351,   108,   351,   346,   224,     7,   118,   134,   162,
+,   260,   259,   263,   263,   264,   115,   115,   109,   109,
+,    95,   122,   134,   134,   145,   274,   162,   115,   131,
+,   214,   225,   229,   108,   108,   169,   108,   108,   131,
+,   131,   138,   118,   138,   168,   108,   171,   163,   163,
+,   142,   116,   131,   134,   133,   134,   209,   109,   162,
+,   260,   308,   109,   114,   108,   345,   346,   133,   109,
+,   134,   305,   114,   133,   134,   134,   109,   113,   198,
+,   161,   131,   198,   200,   109,   115,   134,   368,   163,
+,   134,    84,   112,   115,   134,   134,   111,   134,   109,
+,   109,   109,   111,   111,   111,   134,   109,   133,   133,
+,   162,   162,   134,   111,   134,   134,   134,   134,   133,
+,   161,   161,   111,   111,   134,   134,   270,   225,   167,
+,    46,   167,   133,   131,   131,   167,   131,   131,   167,
+,    58,    59,   192,   193,   194,   131,    62,   131,   113,
+,   173,   114,   131,   134,   134,   133,    95,   265,   266,
+,   295,   115,   131,   115,   131,   114,   293,   116,   140,
+,   109,   116,   165,   111,   114,   111,   110,   146,   110,
+,   146,   111,   111,   111,   260,   111,   260,   260,   260,
+,   134,   111,   111,   109,   109,   111,   115,    95,   259,
+,   134,   111,   111,   109,   109,   108,   109,   168,   189,
+,   131,   109,   108,   108,   171,   194,    57,    58,   162,
+,   169,   109,   109,   260,   113,   133,   133,   294,   140,
+,   108,   131,   201,   134,   116,   133,   133,   134,   134,
+,   134,   111,   111,   133,   134,   111,   169,    43,    44,
+,   179,   180,   181,   167,   169,   134,   109,   168,   113,
+,    95,   133,    95,   133,   108,   108,   131,   114,   134,
+,   268,   305,   114,   115,   116,   161,   109,   111,   162,
+,   145,   109,   109,   109,   109,   263,    41,   161,   177,
+,   306,   116,   133,   169,   179,   109,   131,   169,   131,
+,   109,   133,   109,   133,    95,   133,    95,   133,   131,
+,   294,   140,   138,   202,   109,   131,   116,   134,   134,
+,    95,   115,   116,   134,   203,   204,   210,   131,   168,
+,   203,   171,   195,   223,   362,   171,   195,   109,   133,
+,   133,   114,   109,   115,   162,   111,   111,   161,   177,
+,   182,   183,   133,   131,   180,   184,   185,   134,   108,
+,   305,   353,   138,   134,   171,   195,   171,   195,   108,
+,   138,   169,   174,   114,   180,   210,   168,    55,   174,
+,   114,   180,   109,   225,   109,   134,   134,   288,   169,
+,   131,   186,   187,   174,   187,   171,   171,   109,   109,
+,   186,   134,   134,   171,   171,   134,   134
+,   163,   165,   224,   275,   291,   365,   370,   226,   110,
+,   110,   110,   110,   110,   110,    74,    75,   111,   224,
+,   349,   367,   111,   119,   163,   216,   217,   223,   226,
+,   231,   236,   239,   240,   242,   261,   262,   266,   267,
+,   269,   283,   349,   361,   362,   363,   364,   369,   370,
+,   109,   322,   326,   369,   109,   116,   132,   111,   114,
+,   163,   277,   277,   115,   134,   116,   132,   109,   116,
+,   116,   132,   116,   132,   311,   132,   318,   319,   320,
+,   331,   332,   333,   334,   226,   317,   330,    64,   310,
+,   311,   348,   349,   311,   311,   172,   134,   109,   311,
+,   311,   311,   226,   308,   109,   109,   225,   226,   224,
+,   112,   134,   224,   365,   370,   172,   134,   271,   276,
+,   231,   322,   326,   172,   134,   293,   226,   236,   132,
+,   226,   291,    40,   111,   224,   247,   248,   249,   250,
+,   369,   245,   257,   273,   256,   226,   293,   132,   132,
+,   134,   139,   270,     3,   135,   206,   207,   221,   223,
+,   134,   310,   109,   310,   163,   318,   226,   109,   134,
+,   114,    33,    34,    35,   224,   285,   286,   288,   134,
+,   131,   290,   134,   227,   233,   234,   271,   314,   315,
+,   109,   141,   109,   148,   109,   148,   150,   109,   148,
+,   109,   148,   148,   139,   111,   163,   168,   172,   224,
+,   365,   112,   134,   150,   150,    82,    85,    86,    87,
+,   111,   113,   114,    97,    98,    99,   100,   101,   102,
+,   104,   105,   106,   131,   167,   150,   119,   124,   125,
+,   122,    88,    89,    90,    91,   126,   127,    92,    93,
+,   128,   129,    94,    95,   130,   131,   372,   109,   119,
+,   345,   346,   347,   348,   110,   116,   109,   348,   349,
+,   348,   349,   134,   109,   224,   367,   112,   134,   111,
+,   135,   224,   226,   360,   361,   369,   370,   135,   109,
+,   119,   318,   335,   336,   337,   338,   339,   340,   341,
+,   343,   349,   350,   351,   352,   353,   354,   355,   119,
+,   226,   135,   135,   119,   224,   226,   362,   271,   224,
+,   362,   271,   109,   134,   134,   134,   112,   134,    72,
+,   111,   113,   140,   273,   277,   278,   279,   280,   281,
+,   134,   134,   134,   134,   134,   308,   110,   110,   110,
+,   110,   110,   110,   317,   330,   109,   276,   112,   206,
+,   308,   168,   275,   168,   275,   308,   111,   206,   310,
+,   134,   206,   110,   249,   250,   112,   134,   109,   117,
+,   251,   253,   317,   318,   330,   348,   356,   357,   358,
+,   115,   248,   116,   132,   116,   132,   273,   114,   116,
+,   131,   258,   114,   226,   263,   264,   265,   268,   269,
+,   116,   172,   134,   119,   163,   134,   223,   226,   262,
+,   369,   302,   303,   109,   119,   335,   110,   116,   372,
+,   285,   109,   114,   273,   275,   285,   110,   116,   109,
+,   110,   117,   274,   274,   274,   111,   139,   145,   163,
+,   274,   112,   134,   110,   116,   110,   109,   119,   356,
+,   116,   163,   111,   139,   111,   144,   145,   134,   111,
+,   144,   163,   163,   150,   150,   150,   151,   151,   152,
+,   153,   153,   153,   153,   154,   154,   155,   156,   157,
+,   159,   117,   168,   163,   134,   345,   346,   347,   226,
+,   311,   311,   163,   275,   134,   270,   119,   134,   224,
+,   362,   226,   230,   112,   134,   112,   369,   112,   109,
+,   318,   336,   337,   338,   341,   351,   352,   353,   112,
+,   226,   335,   339,   350,   109,   311,   354,   372,   311,
+,   372,   109,   311,   354,   311,   311,   311,   311,   349,
+,   360,   370,   271,   112,   116,   112,   116,   372,   224,
+,   372,   259,   260,   261,   262,   259,   259,   271,   163,
+,   111,   273,   117,   116,   371,   277,    80,   111,   117,
+,    29,   208,   209,   271,   259,   139,   308,   139,   310,
+,   348,   349,   109,   348,   349,   141,   349,   172,   263,
+,   110,   110,   110,   112,   172,   206,   172,   114,   132,
+,   111,   318,   357,   358,   359,   161,   162,   226,   356,
+,   253,   252,   311,   311,   273,   311,   247,   273,   115,
+,   257,   135,   135,   139,   221,   135,   135,   259,   109,
+,   369,   135,   115,   226,   286,   287,   135,   134,   134,
+,   135,   110,   315,   168,   169,   117,   132,   111,   141,
+,   200,   201,   110,   116,   110,   134,   117,   110,   110,
+,   163,   226,   114,   150,   165,   163,   164,   166,   116,
+,   134,   134,   110,   116,   163,   134,   115,   161,   117,
+,   110,   110,   110,   344,   263,   110,   259,   224,   362,
+,   119,   163,   163,   226,   341,   263,   110,   110,   110,
+,   110,   110,   110,     7,   226,   335,   339,   350,   134,
+,   372,   134,   134,   110,   135,   135,   135,   135,   276,
+,   161,   162,   163,   309,   134,   277,   279,   115,   134,
+,   273,    40,    41,    43,    46,    47,    48,    49,    50,
+,    52,    53,    57,    61,    62,   111,   128,   139,   169,
+,   171,   172,   173,   174,   176,   177,   189,   191,   192,
+,   211,   307,    29,   135,   131,   276,   134,   134,   110,
+,   172,   247,   112,   110,   110,   110,   356,   251,   115,
+,   371,   110,   116,   112,   112,   135,   226,   116,   372,
+,   110,   285,   214,   216,   224,   297,   298,   299,   300,
+,   110,   110,   117,   162,   109,   110,   117,   116,   139,
+,   163,   278,   116,   135,   166,   112,   139,   146,   147,
+,   145,   135,   146,   161,   165,   135,   109,   348,   349,
+,   135,   134,   135,   135,   135,   163,   110,   135,   109,
+,   349,   109,   354,   109,   354,   349,   225,     7,   119,
+,   163,   263,   263,   262,   266,   266,   267,   116,   116,
+,   110,   112,    96,   123,   135,   135,   146,   277,   163,
+,   132,   211,   215,   226,   230,   109,   109,   170,   109,
+,   132,   139,   132,   139,   119,   139,   169,   109,   172,
+,   164,   112,   143,   117,   132,   135,   134,   135,   210,
+,   163,   263,   263,   311,   110,   115,   109,   348,   349,
+,   134,   110,   134,   135,   308,   115,   134,   135,   135,
+,   114,   199,   112,   162,   132,   199,   201,   110,   116,
+,   371,   164,   112,   135,    85,   113,   116,   135,   135,
+,   135,   110,   134,   110,   110,   112,   112,   112,   135,
+,   134,   134,   134,   163,   163,   135,   112,   135,   135,
+,   135,   134,   134,   162,   162,   112,   112,   135,   135,
+,   226,   168,   168,    47,   168,   134,   132,   132,   168,
+,   132,   168,    58,    59,    60,   193,   194,   195,   132,
+,   132,   114,   311,   174,   115,   132,   135,   135,   134,
+,   268,   269,   110,   298,   116,   132,   116,   132,   115,
+,   117,   141,   110,   110,   117,   166,   112,   115,   112,
+,   147,   111,   147,   147,   112,   112,   112,   263,   112,
+,   263,   263,   135,   135,   112,   112,   110,   110,   112,
+,    96,   262,    96,   135,   112,   112,   110,   110,   109,
+,   169,   190,   211,   132,   110,   109,   109,   172,   195,
+,    59,   163,   144,   170,   110,   110,   263,   114,   134,
+,   297,   141,   202,   109,   132,   202,   135,   117,   134,
+,   135,   135,   135,   135,   112,   112,   134,   135,   112,
+,    44,    45,   114,   180,   181,   182,   168,   170,   135,
+,   169,   114,   182,    96,   134,    96,   134,   109,   109,
+,   115,   135,   134,   271,   308,   115,   116,   117,   162,
+,   112,   163,   146,   146,   110,   110,   110,   110,   266,
+,   162,   178,   179,   309,   117,   134,   170,   180,   110,
+,   170,   132,   134,   110,   134,   110,   134,    96,   134,
+,   134,   132,   110,   297,   141,   139,   203,   110,   132,
+,   135,   135,   170,    96,   116,   117,   135,   204,   205,
+,   132,   169,   169,   204,   172,   196,   224,   365,   172,
+,   110,   134,   110,   134,   115,   110,   116,   163,   112,
+,   162,   178,   181,   183,   184,   134,   132,   181,   185,
+,   135,   109,   119,   308,   356,   139,   135,   172,   196,
+,   196,   109,   132,   139,   170,   175,   115,   181,   211,
+,    56,   175,   188,   115,   181,   110,   226,   110,   135,
+,   291,   170,   175,   132,   187,   188,   175,   188,   172,
+,   110,   110,   110,   187,   135,   135,   172,   172,   135,
 };
 …
 /* Line 1806 of yacc.c  */
 #line 290 "parser.yy"
+#line 292 "parser.yy"
+    {
                         typedefTable.enterScope();
 …
 /* Line 1806 of yacc.c  */
 #line 296 "parser.yy"
+#line 298 "parser.yy"
+    {
                         typedefTable.leaveScope();
 …
 /* Line 1806 of yacc.c  */
 #line 305 "parser.yy"
+#line 307 "parser.yy"
     { (yyval.constant) = new ConstantNode( ConstantNode::Integer, (yyvsp[(1) - (1)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 306 "parser.yy"
+#line 308 "parser.yy"
     { (yyval.constant) = new ConstantNode( ConstantNode::Float, (yyvsp[(1) - (1)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 307 "parser.yy"
+#line 309 "parser.yy"
     { (yyval.constant) = new ConstantNode( ConstantNode::Character, (yyvsp[(1) - (1)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 332 "parser.yy"
+#line 334 "parser.yy"
     { (yyval.constant) = new ConstantNode( ConstantNode::String, (yyvsp[(1) - (1)].tok) ); }
     break;
 …
 /* 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  */
 …
     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;
 …
 /* Line 1806 of yacc.c  */
 #line 346 "parser.yy"
+#line 348 "parser.yy"
     { (yyval.en) = new ValofExprNode( (yyvsp[(2) - (3)].sn) ); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 374 "parser.yy"
+#line 376 "parser.yy"
+    {
                         Token fn; fn.str = new std::string( "?{}" ); // location undefined
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 388 "parser.yy"
+#line 390 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 408 "parser.yy"
+#line 410 "parser.yy"
     { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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  */
 …
     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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 434 "parser.yy"
+#line 436 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 466 "parser.yy"
+#line 468 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::AddressOf ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 467 "parser.yy"
+#line 469 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::UnPlus ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 468 "parser.yy"
+#line 470 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::UnMinus ); }
     break;
 …
 /* 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  */
 …
     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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 583 "parser.yy"
+#line 585 "parser.yy"
     { (yyval.en) = new NullExprNode; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 591 "parser.yy"
+#line 593 "parser.yy"
     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 607 "parser.yy"
+#line 609 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::MulAssn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 608 "parser.yy"
+#line 610 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::DivAssn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 609 "parser.yy"
+#line 611 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::ModAssn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 610 "parser.yy"
+#line 612 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::PlusAssn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 611 "parser.yy"
+#line 613 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::MinusAssn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 612 "parser.yy"
+#line 614 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::LSAssn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 613 "parser.yy"
+#line 615 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::RSAssn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 614 "parser.yy"
+#line 616 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::AndAssn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 615 "parser.yy"
+#line 617 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::ERAssn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 616 "parser.yy"
+#line 618 "parser.yy"
     { (yyval.en) = new OperatorNode( OperatorNode::OrAssn ); }
     break;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 627 "parser.yy"
+#line 629 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 636 "parser.yy"
+#line 638 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 643 "parser.yy"
+#line 645 "parser.yy"
+    {
                         Token fn; fn.str = new std::string( "^?{}" ); // location undefined
 …
 /* 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) );
 …
 /* Line 1806 of yacc.c  */
 #line 659 "parser.yy"
+#line 661 "parser.yy"
     { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 666 "parser.yy"
+#line 668 "parser.yy"
     { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
     break;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 677 "parser.yy"
+#line 679 "parser.yy"
     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 679 "parser.yy"
+#line 681 "parser.yy"
     { (yyval.sn) = new StatementNode( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 681 "parser.yy"
+#line 683 "parser.yy"
     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 719 "parser.yy"
+#line 721 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 733 "parser.yy"
+#line 735 "parser.yy"
     { (yyval.sn) = new StatementNode( StatementNode::Default ); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 748 "parser.yy"
+#line 750 "parser.yy"
     { (yyval.sn) = 0; }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 761 "parser.yy"
+#line 763 "parser.yy"
     { (yyval.sn) = 0; }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 778 "parser.yy"
+#line 780 "parser.yy"
     { (yyval.sn) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 783 "parser.yy"
+#line 785 "parser.yy"
     { (yyval.sn) = new StatementNode( StatementNode::Fallthru ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 784 "parser.yy"
+#line 786 "parser.yy"
     { (yyval.sn) = new StatementNode( StatementNode::Fallthru ); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 805 "parser.yy"
+#line 807 "parser.yy"
     { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 809 "parser.yy"
+#line 811 "parser.yy"
     { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 812 "parser.yy"
+#line 814 "parser.yy"
     { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 816 "parser.yy"
+#line 818 "parser.yy"
     { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 819 "parser.yy"
+#line 821 "parser.yy"
     { (yyval.sn) = new StatementNode( StatementNode::Break ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 823 "parser.yy"
+#line 825 "parser.yy"
     { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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  */
 …
     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) );
 …
 /* Line 1806 of yacc.c  */
 #line 855 "parser.yy"
+#line 857 "parser.yy"
     { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
     break;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 859 "parser.yy"
+#line 861 "parser.yy"
     { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 877 "parser.yy"
+#line 879 "parser.yy"
+    {
                         (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
 …
 /* Line 1806 of yacc.c  */
 #line 891 "parser.yy"
+#line 893 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 898 "parser.yy"
+#line 900 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 920 "parser.yy"
+#line 922 "parser.yy"
     { (yyval.flag) = false; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 922 "parser.yy"
+#line 924 "parser.yy"
     { (yyval.flag) = true; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 927 "parser.yy"
+#line 929 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 946 "parser.yy"
+#line 948 "parser.yy"
     { (yyval.constant) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 948 "parser.yy"
+#line 950 "parser.yy"
     { (yyval.constant) = (yyvsp[(1) - (1)].constant); }
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 964 "parser.yy"
+#line 966 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 976 "parser.yy"
+#line 978 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 997 "parser.yy"
+#line 999 "parser.yy"
     {}
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 998 "parser.yy"
+#line 1000 "parser.yy"
     {}
     break;
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 1049 "parser.yy"
+#line 1051 "parser.yy"
+    {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1054 "parser.yy"
+#line 1056 "parser.yy"
+    {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1059 "parser.yy"
+#line 1061 "parser.yy"
+    {
                         typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1067 "parser.yy"
+#line 1069 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1072 "parser.yy"
+#line 1074 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1077 "parser.yy"
+#line 1079 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1082 "parser.yy"
+#line 1084 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1087 "parser.yy"
+#line 1089 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
 …
 /* 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 );
 …
 /* 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 );
 …
 /* 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 );
 …
 /* Line 1806 of yacc.c  */
 #line 1129 "parser.yy"
+#line 1131 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     break;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 1138 "parser.yy"
+#line 1140 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1143 "parser.yy"
+#line 1145 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1148 "parser.yy"
+#line 1150 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1159 "parser.yy"
+#line 1161 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1164 "parser.yy"
+#line 1166 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1169 "parser.yy"
+#line 1171 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1174 "parser.yy"
+#line 1176 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1179 "parser.yy"
+#line 1181 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1188 "parser.yy"
+#line 1190 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1193 "parser.yy"
+#line 1195 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1210 "parser.yy"
+#line 1212 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1215 "parser.yy"
+#line 1217 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1237 "parser.yy"
+#line 1239 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 1260 "parser.yy"
+#line 1262 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1262 "parser.yy"
+#line 1264 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1264 "parser.yy"
+#line 1266 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1266 "parser.yy"
+#line 1268 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1268 "parser.yy"
+#line 1270 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1270 "parser.yy"
+#line 1272 "parser.yy"
+    {
                         typedefTable.enterScope();
 …
 /* Line 1806 of yacc.c  */
 #line 1274 "parser.yy"
+#line 1276 "parser.yy"
+    {
                         typedefTable.leaveScope();
 …
 /* 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;
 …
 /* 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;
 …
 /* 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;
 …
 /* Line 1806 of yacc.c  */
 #line 1305 "parser.yy"
+#line 1307 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1307 "parser.yy"
+#line 1309 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1309 "parser.yy"
+#line 1311 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1311 "parser.yy"
+#line 1313 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1313 "parser.yy"
+#line 1315 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1315 "parser.yy"
+#line 1317 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1317 "parser.yy"
+#line 1319 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1319 "parser.yy"
+#line 1321 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1324 "parser.yy"
+#line 1326 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1326 "parser.yy"
+#line 1328 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1328 "parser.yy"
+#line 1330 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1330 "parser.yy"
+#line 1332 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1332 "parser.yy"
+#line 1334 "parser.yy"
     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1334 "parser.yy"
+#line 1336 "parser.yy"
     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1336 "parser.yy"
+#line 1338 "parser.yy"
     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1338 "parser.yy"
+#line 1340 "parser.yy"
     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1340 "parser.yy"
+#line 1342 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1342 "parser.yy"
+#line 1344 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1344 "parser.yy"
+#line 1346 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
     break;
 …
 /* 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;
 …
 /* 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  */
 …
     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 );
 …
     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 );
 …
     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  */
 …
     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  */
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 ) {
 …
     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 );
 …
     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();
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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 );
 …
     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) );
 …
     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) );
 …
     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) );
 …
     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;
 …
 /* Line 1806 of yacc.c  */
 #line 9150 "Parser/parser.cc"
+#line 9264 "Parser/parser.cc"
       default: break;
+    }
 …
 /* Line 2067 of yacc.c  */
 #line 2805 "parser.yy"
+#line 2819 "parser.yy"
 // ----end of grammar----
 …
         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;

src/Parser/parser.h

-              rc5833e8
+              r0f9e4403
      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
 …
 #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
 …
 /* Line 2068 of yacc.c  */
 #line 110 "parser.yy"
+#line 112 "parser.yy"
         Token tok;
 …
 /* Line 2068 of yacc.c  */
 #line 280 "Parser/parser.h"
+#line 282 "Parser/parser.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1

src/Parser/parser.yy

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 #include <cstdio>
 #include <stack>
+#include "lex.h"
+#include "parser.h"
+#include "ParseNode.h"
 #include "TypedefTable.h"
-#include "lex.h"
-#include "ParseNode.h"
 #include "TypeData.h"
 #include "LinkageSpec.h"
 …
 %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
 …
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type_name indirect_type_name
 %type<decl> context_declaration context_declaration_list context_declaring_list context_specifier
+%type<decl> trait_declaration trait_declaration_list trait_declaring_list trait_specifier
 %type<decl> declaration declaration_list declaration_list_opt declaration_qualifier_list
 …
 %type<decl> new_array_parameter_1st_dimension
 %type<decl> new_context_declaring_list new_declaration new_field_declaring_list
+%type<decl> new_trait_declaring_list new_declaration new_field_declaring_list
 %type<decl> new_function_declaration new_function_return new_function_specifier
 …
                 { $$ = 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
+                {
 …
                 { $$ = 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 )); }
 …
         | new_function_declaration pop ';'
         | type_declaring_list pop ';'
         | context_specifier pop ';'
+        | trait_specifier pop ';'
+        ;
 …
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         $$ = $1;
+                        $$ = $1->addInitializer( $2 );
+                }
         | declaration_qualifier_list new_variable_specifier initializer_opt
 …
+                {
                         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 ) );
+                }
+        ;
 …
         | IMAGINARY                                                                                     // C99
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
+        | VALIST                                                                                        // GCC, __builtin_va_list
+                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
+        ;
 …
                 { $$ = 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; }
 …
         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 ); }
+        ;
 …
 type_class:                                                                                             // CFA
         TYPE
+        OTYPE
                 { $$ = DeclarationNode::Type; }
         | DTYPE
 …
         '|' 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; }
+        ;
 …
 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
 …
+        ;
 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
+                {
 …
                         $$ = $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 );
 …
+        ;
 context_declaring_list:                                                                 // CFA
+trait_declaring_list:                                                                   // CFA
         type_specifier declarator
+                {
 …
                         $$ = $2->addType( $1 );
+                }
         | context_declaring_list pop ',' push declarator
+        | trait_declaring_list pop ',' push declarator
+                {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
 …
         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;

src/ResolvExpr/AdjustExprType.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 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;
 …
+        }
         Type *AdjustExprType::mutate( ContextInstType *aggregateUseType ) {
+        Type *AdjustExprType::mutate( TraitInstType *aggregateUseType ) {
                 return aggregateUseType;
+        }
 …
                 return tupleType;
+        }
+        Type *AdjustExprType::mutate( VarArgsType *varArgsType ) {
+                return varArgsType;
+        }
 } // namespace ResolvExpr

src/ResolvExpr/AlternativeFinder.cc

-              rc5833e8
+              r0f9e4403
+        }
+        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

src/ResolvExpr/AlternativeFinder.h

rc5833e8	r0f9e4403
59	59	virtual void visit( UntypedOffsetofExpr *offsetofExpr );
60	60	virtual void visit( OffsetofExpr *offsetofExpr );
	61	virtual void visit( OffsetPackExpr *offsetPackExpr );
61	62	virtual void visit( AttrExpr *attrExpr );
62	63	virtual void visit( LogicalExpr *logicalExpr );

src/ResolvExpr/CommonType.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 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 );
 …
+        }
         void CommonType::visit( ContextInstType *aggregateUseType ) {
+        void CommonType::visit( TraitInstType *aggregateUseType ) {
+        }
 …
         void CommonType::visit( TupleType *tupleType ) {
+        }
+        void CommonType::visit( VarArgsType *varArgsType ) {
+        }
 } // namespace ResolvExpr

src/ResolvExpr/ConversionCost.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
+        }
         void ConversionCost::visit(ContextInstType *inst) {
+        void ConversionCost::visit(TraitInstType *inst) {
+        }
 …
                 } // if
+        }
+        void ConversionCost::visit(VarArgsType *varArgsType) {
+                if ( dynamic_cast< VarArgsType* >( dest ) ) {
+                        cost = Cost::zero;
+                }
+        }
 } // namespace ResolvExpr

src/ResolvExpr/ConversionCost.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 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;

src/ResolvExpr/PtrsAssignable.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 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;
 …
+        }
         void PtrsAssignable::visit( ContextInstType *inst ) {
+        void PtrsAssignable::visit( TraitInstType *inst ) {
                 // I definitely don't think we should be doing anything here
+        }
 …
 ///   }
+        }
+        void PtrsAssignable::visit( VarArgsType *varArgsType ) {
+        }
 } // namespace ResolvExpr

src/ResolvExpr/PtrsCastable.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 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;
 …
         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;
 …
+        }
         void PtrsCastable::visit(ContextInstType *inst) {
+        void PtrsCastable::visit(TraitInstType *inst) {
                 // I definitely don't think we should be doing anything here
+        }
 …
                 result = objectCast( dest, env, indexer );
+        }
+        void PtrsCastable::visit(VarArgsType *varArgsType) {
+                result = objectCast( dest, env, indexer );
+        }
 } // namespace ResolvExpr

src/ResolvExpr/RenameVars.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
+        }
         void RenameVars::visit( ContextInstType *aggregateUseType ) {
+        void RenameVars::visit( TraitInstType *aggregateUseType ) {
                 typeBefore( aggregateUseType );
                 acceptAll( aggregateUseType->get_parameters(), *this );
 …
                 acceptAll( tupleType->get_types(), *this );
                 typeAfter( tupleType );
+        }
+        void RenameVars::visit( VarArgsType *varArgsType ) {
+                typeBefore( varArgsType );
+                typeAfter( varArgsType );
+        }

src/ResolvExpr/RenameVars.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 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 );

src/ResolvExpr/Resolver.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 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;
+        }

src/ResolvExpr/Unify.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 WidenMode operator&( const WidenMode &other ) { WidenMode newWM( *this ); newWM &= other; return newWM; }
                 operator bool() { return widenFirst && widenSecond; }
                 bool widenFirst : 1, widenSecond : 1;
         };
 …
           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:
 …
                 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 );
 …
         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;
 …
                   case TypeDecl::Dtype:
                         return ! isFtype( type, indexer );
                   case TypeDecl::Ftype:
                         return isFtype( type, indexer );
 …
                 bool widen1 = false, widen2 = false;
                 Type *type1 = 0, *type2 = 0;
                 if ( env.lookup( var1->get_name(), class1 ) ) {
                         hasClass1 = true;
 …
                         widen2 = widenMode.widenSecond && class2.allowWidening;
                 } // if
                 if ( type1 && type2 ) {
 //    std::cout << "has type1 && type2" << std::endl;
 …
                 // 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
 …
                                 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;
+                                        }
+                                }
+                        }
 …
                         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 ) ) {
 …
+        }
         void Unify::visit(ContextInstType *contextInst) {
+        void Unify::visit(TraitInstType *contextInst) {
                 handleRefType( contextInst, type2 );
+        }
 …
+        }
+        void Unify::visit(VarArgsType *varArgsType) {
+                result = dynamic_cast< VarArgsType* >( type2 );
+        }
 } // namespace ResolvExpr

src/SymTab/AddVisit.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
         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 );
+        }
 …
+        }
+        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

src/SymTab/FixFunction.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
+        }
         Type * FixFunction::mutate(ContextInstType *aggregateUseType) {
+        Type * FixFunction::mutate(TraitInstType *aggregateUseType) {
                 return aggregateUseType;
+        }
 …
                 return tupleType;
+        }
+        Type * FixFunction::mutate(VarArgsType *varArgsType) {
+                return varArgsType;
+        }
 } // namespace SymTab

src/SymTab/FixFunction.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 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;

src/SymTab/ImplementationType.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
                 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
 …
+        }
         void ImplementationType::visit(ContextInstType *aggregateUseType) {
+        void ImplementationType::visit(TraitInstType *aggregateUseType) {
+        }
 …
                 result = newType;
+        }
+        void ImplementationType::visit(VarArgsType *varArgsType) {
+        }
 } // namespace SymTab

src/SymTab/Indexer.cc

-              rc5833e8
+              r0f9e4403
 // 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 <string>
+#include <typeinfo>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include "Mangler.h"
+#include "Common/utility.h"
+#include "ResolvExpr/typeops.h"
 #include "SynTree/Declaration.h"
 …
 #include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
-#include "Indexer.h"
-#include <typeinfo>
-#include "Common/utility.h"
 #define debugPrint(x) if ( doDebug ) { std::cout << x; }
 …
+        }
+        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 ) {
 …
                 if ( objectDecl->get_name() != "" ) {
                         debugPrint( "Adding object " << objectDecl->get_name() << std::endl );
                         idTable.addDecl( objectDecl );
+                        addId( objectDecl );
                 } // if
+        }
 …
                 if ( functionDecl->get_name() == "" ) return;
                 debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
                 idTable.addDecl( functionDecl );
+                addId( functionDecl );
                 enterScope();
                 maybeAccept( functionDecl->get_functionType(), *this );
 …
                 leaveScope();
                 debugPrint( "Adding type " << typeDecl->get_name() << std::endl );
                 typeTable.add( typeDecl );
+                addType( typeDecl );
                 acceptAll( typeDecl->get_assertions(), *this );
+        }
 …
                 leaveScope();
                 debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
                 typeTable.add( typeDecl );
+                addType( typeDecl );
+        }
 …
                 cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
                 debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl );
                 structTable.add( &fwdDecl );
+                addStruct( &fwdDecl );
                 enterScope();
 …
                 debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl );
                 // this addition replaces the forward declaration
                 structTable.add( aggregateDecl );
+                addStruct( aggregateDecl );
+        }
 …
                 cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
                 debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl );
                 unionTable.add( &fwdDecl );
+                addUnion( &fwdDecl );
                 enterScope();
 …
                 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 );
 …
                 debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
                 contextTable.add( aggregateDecl );
+                addTrait( aggregateDecl );
+        }
 …
                 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 );
+        }
 …
         void Indexer::visit( ContextInstType *contextInst ) {
+        void Indexer::visit( TraitInstType *contextInst ) {
                 acceptAll( contextInst->get_parameters(), *this );
                 acceptAll( contextInst->get_members(), *this );
 …
         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();
 …
         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();
 …
+        }
+        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<ObjectDecl*>( added ) && dynamic_cast<ObjectDecl*>( existing ) )
+                        || (dynamic_cast<FunctionDecl*>( added ) && dynamic_cast<FunctionDecl*>( 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

src/SymTab/Indexer.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 #include "SynTree/Visitor.h"
-#include "IdTable.h"
-#include "AggregateTable.h"
-#include "TypeTable.h"
 namespace SymTab {
 …
           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;
 …
                 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 );
 …
                 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 );
 …
                 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 );
 …
                 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

src/SymTab/Mangler.cc

-              rc5833e8
+              r0f9e4403
                 acceptAll( tupleType->get_types(), *this );
                 mangleName << "_";
+        }
+        void Mangler::visit( VarArgsType *varArgsType ) {
+                printQualifiers( varArgsType );
+                mangleName << "VARGS";
+        }

src/SymTab/Mangler.h

rc5833e8	r0f9e4403
45	45	virtual void visit( TypeInstType *aggregateUseType );
46	46	virtual void visit( TupleType *tupleType );
	47	virtual void visit( VarArgsType *varArgsType );
47	48
48	49	std::string get_mangleName() { return mangleName.str(); }

src/SymTab/TypeEquality.cc

-              rc5833e8
+              r0f9e4403
                 virtual void visit( EnumInstType *enumInst );
                 virtual void visit( TypeInstType *typeInst );
+                virtual void visit( VarArgsType *varArgsType );
                 void handleQualifiers( Type * t );
 …
+                }
+        }
+        void TypeEquality::visit( VarArgsType *varArgsType ) {
+                handleQualifiers( varArgsType );
+                if ( ! dynamic_cast< VarArgsType * >( other ) ) {
+                        result = false;
+                }
+        }
 } // namespace SymTab

src/SymTab/Validate.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 #include <list>
 #include <iterator>
+#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"
 …
 #include "FixFunction.h"
 // #include "ImplementationType.h"
+#include "Common/utility.h"
+#include "Common/UniqueName.h"
+#include "GenPoly/DeclMutator.h"
 #include "AddVisit.h"
 #include "MakeLibCfa.h"
 …
                 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();
 …
                 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 );
 …
                 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 );
 …
                 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 ) {}
 …
                 /// and return something if the return type is non-void.
                 static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
           private:
                 virtual void visit( FunctionDecl * functionDecl );
 …
                 virtual Declaration *mutate( UnionDecl * unionDecl );
                 virtual Declaration *mutate( EnumDecl * enumDecl );
                 virtual Declaration *mutate( ContextDecl * contextDecl );
+                virtual Declaration *mutate( TraitDecl * contextDecl );
                 template<typename AggDecl>
                 AggDecl *handleAggregate( AggDecl * aggDecl );
+                template<typename AggDecl>
+                void addImplicitTypedef( AggDecl * aggDecl );
                 typedef std::map< std::string, std::pair< TypedefDecl *, int > > TypedefMap;
                 TypedefMap typedefNames;
 …
         };
+        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 );
 …
                 acceptAll( translationUnit, pass2 );
                 ReturnChecker::checkFunctionReturns( translationUnit );
+                mutateAll( translationUnit, compoundliteral );
                 AutogenerateRoutines::autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
 …
+        }
-        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 );
 …
+        }
+        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 ) {
 …
+        }
         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() );
 …
                 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 {
 …
                         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 );
 …
+        }
         void AutogenerateRoutines::visit( ContextDecl *) {
+        void AutogenerateRoutines::visit( TraitDecl *) {
                 // ensure that we don't add assignment ops for types defined as part of the context
+        }
 …
+        }
-        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 );
 …
+        }
+        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 ) {
 …
+        }
+        // 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<typename AggDecl>
         AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
 …
                 return aggDecl;
+        }
+        template<typename AggDecl>
+        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 );
 …
         Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) {
+                addImplicitTypedef( unionDecl );
                 Mutator::mutate( unionDecl );
                 return handleAggregate( unionDecl );
 …
         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

src/SymTab/module.mk

-              rc5833e8
+              r0f9e4403
 ###############################################################################
+SRC += SymTab/IdTable.cc \
+       SymTab/Indexer.cc \
+SRC += SymTab/Indexer.cc \
        SymTab/Mangler.cc \
        SymTab/Validate.cc \

src/SynTree/AggregateDecl.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 std::string EnumDecl::typeString() const { return "enum"; }
 std::string ContextDecl::typeString() const { return "context"; }
+std::string TraitDecl::typeString() const { return "context"; }
 // Local Variables: //

src/SynTree/Constant.cc

-              rc5833e8
+              r0f9e4403
 #include <iostream>
 #include <list>
+#include <string>
 #include "Constant.h"
 …
 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; }

src/SynTree/Constant.h

-              rc5833e8
+              r0f9e4403
         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 ); }

src/SynTree/Declaration.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 };
 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 ); }

src/SynTree/Expression.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 #include "Type.h"
+#include "Initializer.h"
 #include "Expression.h"
 #include "Declaration.h"
 …
         os << " of ";
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+        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 ) {
 …
+}
+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;
 …
+}
+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;
 …
                 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 ) {

src/SynTree/Expression.h

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 };
+// 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();
 …
 };
 /// 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:
 …
         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;
 };
 …
   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; };
 …
   public:
         UntypedValofExpr( Statement *_body, Expression *_aname = 0 ) : Expression( _aname ), body ( _body ) {}
+        virtual ~UntypedValofExpr() {}
+        UntypedValofExpr( const UntypedValofExpr & other );
+        virtual ~UntypedValofExpr();
         Expression *get_value();
 …
   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;
 };

src/SynTree/Mutator.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
+}
 Declaration *Mutator::mutate( ContextDecl *aggregateDecl ) {
+Declaration *Mutator::mutate( TraitDecl *aggregateDecl ) {
         handleAggregateDecl( aggregateDecl );
         return aggregateDecl;
 …
+}
+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 );
 …
+}
+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 );
 …
+}
 Type *Mutator::mutate( ContextInstType *aggregateUseType ) {
+Type *Mutator::mutate( TraitInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         mutateAll( aggregateUseType->get_members(), *this );
 …
+}
+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 ) );

src/SynTree/Mutator.h

-              rc5833e8
+              r0f9e4403
 // 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 <cassert>
 …
         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 );
 …
         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 );
 …
         virtual Expression* mutate( AsmExpr *asmExpr );
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
+        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
         virtual Type* mutate( VoidType *basicType );
 …
         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 );

src/SynTree/ReferenceToType.cc

-              rc5833e8
+              r0f9e4403
 // 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
 //
 …
 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 );
+}

src/SynTree/Statement.cc

-              rc5833e8
+              r0f9e4403
 // file "LICENCE" distributed with Cforall.
 //
 // Statement.cc --
+// Statement.cc --
 //
 // Author           : Richard C. Bilson
 …
 ExprStmt::ExprStmt( std::list<Label> _labels, Expression *_expr ) : Statement( _labels ), expr( _expr ) {}
+ExprStmt::~ExprStmt() {}
+ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
+ExprStmt::~ExprStmt() {
+        delete expr;
+}
 void ExprStmt::print( std::ostream &os, int indent ) const {
         os << string( indent, ' ' ) << "Expression Statement:" << endl;
         expr->print( os, indent + 2 );
+}
+}
 AsmStmt::AsmStmt( std::list<Label> labels, bool voltile, ConstantExpr *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement( labels ), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
+AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
+  cloneAll( other.output, output );
+  cloneAll( other.input, input );
+  cloneAll( other.clobber, clobber );
+}
 AsmStmt::~AsmStmt() {
 …
                 os << endl << std::string( indent, ' ' ) << "output: " << endl;
                 printAll( output, os, indent + 2 );
         } // if
+        } // if
         if ( ! input.empty() ) {
                 os << std::string( indent, ' ' ) << "input: " << endl << std::string( indent, ' ' );
 …
                 printAll( clobber, os, indent + 2 );
         } // if
+}
+}
 …
 ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *_expr, bool throwP ) : Statement( labels ), expr( _expr ), isThrow( throwP ) {}
+ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ), isThrow( other.isThrow ) {}
 ReturnStmt::~ReturnStmt() {
         delete expr;
 …
         Statement( _labels ), condition( _condition ), thenPart( _thenPart ), elsePart( _elsePart ) {}
+IfStmt::IfStmt( const IfStmt & other ) :
+        Statement( other ), condition( maybeClone( other.condition ) ), thenPart( maybeClone( other.thenPart ) ), elsePart( maybeClone( other.elsePart ) ) {}
 IfStmt::~IfStmt() {}
 …
 SwitchStmt::SwitchStmt( std::list<Label> _labels, Expression * _condition, std::list<Statement *> &_branches ):
         Statement( _labels ), condition( _condition ), branches( _branches ) {
+}
+SwitchStmt::SwitchStmt( const SwitchStmt & other ):
+        Statement( other ), condition( maybeClone( other.condition ) ) {
+        cloneAll( other.branches, branches );
+}
 …
+}
 CaseStmt::CaseStmt( std::list<Label> _labels, Expression *_condition, std::list<Statement *> &_statements, bool deflt ) throw ( SemanticError ) :
+CaseStmt::CaseStmt( std::list<Label> _labels, Expression *_condition, std::list<Statement *> &_statements, bool deflt ) throw ( SemanticError ) :
         Statement( _labels ), condition( _condition ), stmts( _statements ), _isDefault( deflt ) {
         if ( isDefault() && condition != 0 )
                 throw SemanticError("default with conditions");
+}
+CaseStmt::CaseStmt( const CaseStmt & other ) :
+        Statement( other ), condition( maybeClone(other.condition ) ), _isDefault( other._isDefault ) {
+        cloneAll( other.stmts, stmts );
+}
 …
+}
+ChooseStmt::ChooseStmt( const ChooseStmt & other ):
+        Statement( other ), condition( maybeClone( other.condition ) ) {
+                cloneAll( other.branches, branches );
+}
 ChooseStmt::~ChooseStmt() {
         delete condition;
 …
+}
+WhileStmt::WhileStmt( const WhileStmt & other ):
+        Statement( other ), condition( maybeClone( other.condition ) ), body( maybeClone( other.body ) ), isDoWhile( other.isDoWhile ) {
+}
 WhileStmt::~WhileStmt() {
         delete body;
 …
 ForStmt::ForStmt( std::list<Label> labels, std::list<Statement *> initialization_, Expression *condition_, Expression *increment_, Statement *body_ ):
         Statement( labels ), initialization( initialization_ ), condition( condition_ ), increment( increment_ ), body( body_ ) {
+}
+ForStmt::ForStmt( const ForStmt & other ):
+        Statement( other ), condition( maybeClone( other.condition ) ), increment( maybeClone( other.increment ) ), body( maybeClone( other.body ) ) {
+                cloneAll( other.initialization, initialization );
+}
 …
         os << string( indent, ' ' ) << "For Statement" << endl ;
         os << string( indent + 2, ' ' ) << "initialization: \n";
+        os << string( indent + 2, ' ' ) << "initialization: \n";
         for ( std::list<Statement *>::const_iterator it = initialization.begin(); it != initialization.end(); ++it ) {
                 (*it)->print( os, indent + 4 );
+        }
         os << "\n" << string( indent + 2, ' ' ) << "condition: \n";
+        os << "\n" << string( indent + 2, ' ' ) << "condition: \n";
         if ( condition != 0 )
                 condition->print( os, indent + 4 );
         os << "\n" << string( indent + 2, ' ' ) << "increment: \n";
+        os << "\n" << string( indent + 2, ' ' ) << "increment: \n";
         if ( increment != 0 )
                 increment->print( os, indent + 4 );
         os << "\n" << string( indent + 2, ' ' ) << "statement block: \n";
+        os << "\n" << string( indent + 2, ' ' ) << "statement block: \n";
         if ( body != 0 )
                 body->print( os, indent + 4 );
 …
+}
+TryStmt::TryStmt( const TryStmt &other ) : Statement( other.labels ) {
+        block = other.block;
+        std::copy( other.handlers.begin(), other.handlers.end(), back_inserter( handlers ) );
+        finallyBlock = other.finallyBlock;
+TryStmt::TryStmt( const TryStmt &other ) : Statement( other ), block( maybeClone( other.block ) ), finallyBlock( maybeClone( other.finallyBlock ) ) {
+        cloneAll( other.handlers, handlers );
+}
 …
 CatchStmt::CatchStmt( std::list<Label> labels, Declaration *_decl, Statement *_body, bool isCatchRest ) :
         Statement( labels ), decl ( _decl ), body( _body ), catchRest ( isCatchRest ) {
+}
+CatchStmt::CatchStmt( const CatchStmt & other ) :
+        Statement( other ), decl ( maybeClone( other.decl ) ), body( maybeClone( other.body ) ), catchRest ( other.catchRest ) {
+}
 …
+}
+FinallyStmt::FinallyStmt( const FinallyStmt & other ) : Statement( other ), block( maybeClone( other.block ) ) {
+}
 FinallyStmt::~FinallyStmt() {
         delete block;
 …
 NullStmt::NullStmt( std::list<Label> labels ) : CompoundStmt( labels ) {}
 NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}
-NullStmt::~NullStmt() {}
 void NullStmt::print( std::ostream &os, int indent ) const {

src/SynTree/Statement.h

-              rc5833e8
+              r0f9e4403
 // file "LICENCE" distributed with Cforall.
 //
 // Statement.h --
+// Statement.h --
 //
 // Author           : Richard C. Bilson
 …
   public:
         ExprStmt( std::list<Label> labels, Expression *expr );
+        ExprStmt( const ExprStmt &other );
         virtual ~ExprStmt();
 …
   public:
         AsmStmt( std::list<Label> labels, bool voltile, ConstantExpr *instruction, std::list<Expression *> input, std::list<Expression *> output, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+        AsmStmt( const AsmStmt &other );
         virtual ~AsmStmt();
 …
   public:
         IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart );
+        IfStmt( const IfStmt &other );
         virtual ~IfStmt();
 …
         Statement *get_elsePart() { return elsePart; }
         void set_elsePart( Statement *newValue ) { elsePart = newValue; }
         virtual IfStmt *clone() const { return new IfStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
 …
   public:
         SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &branches );
+        SwitchStmt( const SwitchStmt &other );
         virtual ~SwitchStmt();
 …
   public:
         ChooseStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &branches );
+        ChooseStmt( const ChooseStmt &other );
         virtual ~ChooseStmt();
 …
 class CaseStmt : public Statement {
   public:
         CaseStmt( std::list<Label> labels, Expression *conditions,
+        CaseStmt( std::list<Label> labels, Expression *conditions,
               std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+        CaseStmt( const CaseStmt &other );
         virtual ~CaseStmt();
 …
         std::list<Statement *> &get_statements() { return stmts; }
         void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
 …
         WhileStmt( std::list<Label> labels, Expression *condition,
                Statement *body, bool isDoWhile = false );
+        WhileStmt( const WhileStmt &other );
         virtual ~WhileStmt();
 …
         bool get_isDoWhile() { return isDoWhile; }
         void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
         virtual WhileStmt *clone() const { return new WhileStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
 …
         ForStmt( std::list<Label> labels, std::list<Statement *> initialization,
              Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
+        ForStmt( const ForStmt &other );
         virtual ~ForStmt();
 …
         Statement *get_body() { return body; }
         void set_body( Statement *newValue ) { body = newValue; }
         virtual ForStmt *clone() const { return new ForStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
 …
         BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
         BranchStmt( std::list<Label> labels, Expression *computedTarget, Type ) throw (SemanticError);
-        virtual ~BranchStmt() {}
         Label get_originalTarget() { return originalTarget; }
         Label get_target() { return target; }
         void set_target( Label newValue ) { target = newValue; }
         Expression *get_computedTarget() { return computedTarget; }
         void set_target( Expression * newValue ) { computedTarget = newValue; }
 …
   public:
         ReturnStmt( std::list<Label> labels, Expression *expr, bool throwP = false );
+        ReturnStmt( const ReturnStmt &other );
         virtual ~ReturnStmt();
         Expression *get_expr() { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
         virtual ReturnStmt *clone() const { return new ReturnStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
 …
         NullStmt();
         NullStmt( std::list<Label> labels );
-        virtual ~NullStmt();
         virtual NullStmt *clone() const { return new NullStmt( *this ); }
 …
         virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
 };
 class TryStmt : public Statement {
+  private:
+};
+class TryStmt : public Statement {
   public:
         TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<Statement *> &handlers, FinallyStmt *finallyBlock = 0 );
 …
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         CompoundStmt *block;
         std::list<Statement *> handlers;
         FinallyStmt *finallyBlock;
 };
+};
 class CatchStmt : public Statement {
   public:
         CatchStmt( std::list<Label> labels, Declaration *decl, Statement *body, bool isCatchRest = false );
+        CatchStmt( const CatchStmt &other );
         virtual ~CatchStmt();
 …
         Statement *get_body() { return body; }
         void set_body( Statement *newValue ) { body = newValue; }
         virtual CatchStmt *clone() const { return new CatchStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         Declaration *decl;
 …
 };
 class FinallyStmt : public Statement {
+class FinallyStmt : public Statement {
   public:
         FinallyStmt( std::list<Label> labels, CompoundStmt *block );
+        FinallyStmt( const FinallyStmt &other );
         virtual ~FinallyStmt();
         CompoundStmt *get_block() const { return block; }
         void set_block( CompoundStmt *newValue ) { block = newValue; }
         virtual FinallyStmt *clone() const { return new FinallyStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
 …
   private:
         CompoundStmt *block;
 };
+};

src/SynTree/SynTree.h

-              rc5833e8
+              r0f9e4403
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 23 23:25:04 2015
 // Update Count     : 3
+// Last Modified On : Fri Apr  1 16:47:44 2016
+// Update Count     : 5
 //
 …
 class UnionDecl;
 class EnumDecl;
 class ContextDecl;
+class TraitDecl;
 class NamedTypeDecl;
 class TypeDecl;
 …
 class UntypedOffsetofExpr;
 class OffsetofExpr;
+class OffsetPackExpr;
 class AttrExpr;
 class LogicalExpr;
 …
 class AsmExpr;
 class UntypedValofExpr;
+class CompoundLiteralExpr;
 class Type;
 …
 class UnionInstType;
 class EnumInstType;
 class ContextInstType;
+class TraitInstType;
 class TypeInstType;
 class TupleType;
 class TypeofType;
 class AttrType;
+class VarArgsType;
 class Initializer;

src/SynTree/Type.h

-              rc5833e8
+              r0f9e4403
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Fri Dec 18 14:46:18 2015
 // Update Count     : 18
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Mar  2 17:29:08 2016
+// Update Count     : 21
 //
 …
 };
 class ContextInstType : public ReferenceToType {
+class TraitInstType : public ReferenceToType {
         typedef ReferenceToType Parent;
   public:
         ContextInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
         ContextInstType( const ContextInstType &other );
         ~ContextInstType();
+        TraitInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
+        TraitInstType( const TraitInstType &other );
+        ~TraitInstType();
         std::list< Declaration* >& get_members() { return members; }
         virtual ContextInstType *clone() const { return new ContextInstType( *this ); }
+        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
 …
 };
+/// Represents the GCC built-in varargs type
+class VarArgsType : public Type {
+  public:
+        VarArgsType();
+        VarArgsType( Type::Qualifiers tq );
+        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+};
 inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
         isConst |= other.isConst;

src/SynTree/TypeSubstitution.cc

-              rc5833e8
+              r0f9e4403
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 18 11:10:04 2015
 // Update Count     : 2
+// Last Modified On : Wed Mar  2 17:29:15 2016
+// Update Count     : 3
 //
 …
+}
 Type * TypeSubstitution::mutate( ContextInstType *aggregateUseType ) {
+Type * TypeSubstitution::mutate( TraitInstType *aggregateUseType ) {
         return handleType( aggregateUseType );
+}
 …
 Type * TypeSubstitution::mutate( TupleType *tupleType ) {
         return handleType( tupleType );
+}
+Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) {
+        return handleType( varArgsType );
+}

src/SynTree/TypeSubstitution.h

-              rc5833e8
+              r0f9e4403
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 18 11:12:30 2015
 // Update Count     : 1
+// Last Modified On : Wed Mar  2 17:33:19 2016
+// Update Count     : 2
 //
 …
         virtual Type* mutate(UnionInstType *aggregateUseType);
         virtual Type* mutate(EnumInstType *aggregateUseType);
         virtual Type* mutate(ContextInstType *aggregateUseType);
+        virtual Type* mutate(TraitInstType *aggregateUseType);
         virtual Type* mutate(TupleType *tupleType);
+        virtual Type* mutate(VarArgsType *varArgsType);
         // TODO: worry about traversing into a forall-qualified function type or type decl with assertions

src/SynTree/Visitor.cc

-              rc5833e8
+              r0f9e4403
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 24 16:11:05 2015
 // Update Count     : 15
+// Last Modified On : Fri Apr  1 18:05:13 2016
+// Update Count     : 18
 //
 …
+}
 void Visitor::visit( ContextDecl *aggregateDecl ) {
+void Visitor::visit( TraitDecl *aggregateDecl ) {
         visit( static_cast< AggregateDecl* >( aggregateDecl ) );
+}
 …
+}
+void Visitor::visit( OffsetPackExpr *offsetPackExpr ) {
+        acceptAll( offsetPackExpr->get_results(), *this );
+        maybeAccept( offsetPackExpr->get_type(), *this );
+}
 void Visitor::visit( AttrExpr *attrExpr ) {
         acceptAll( attrExpr->get_results(), *this );
 …
+}
+void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
+        acceptAll( compLitExpr->get_results(), *this );
+        maybeAccept( compLitExpr->get_type(), *this );
+        maybeAccept( compLitExpr->get_initializer(), *this );
+}
 void Visitor::visit( VoidType *voidType ) {
         acceptAll( voidType->get_forall(), *this );
 …
+}
 void Visitor::visit( ContextInstType *aggregateUseType ) {
+void Visitor::visit( TraitInstType *aggregateUseType ) {
         visit( static_cast< ReferenceToType * >( aggregateUseType ) );
         acceptAll( aggregateUseType->get_members(), *this );
 …
+}
+void Visitor::visit( VarArgsType *varArgsType ) {
+        acceptAll( varArgsType->get_forall(), *this );
+}
 void Visitor::visit( SingleInit *singleInit ) {
         singleInit->get_value()->accept( *this );

src/SynTree/Visitor.h

-              rc5833e8
+              r0f9e4403
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 25 21:20:44 2016
 // Update Count     : 5
+// Last Modified On : Fri Apr  1 17:26:55 2016
+// Update Count     : 7
 //
 …
         virtual void visit( UnionDecl *aggregateDecl );
         virtual void visit( EnumDecl *aggregateDecl );
         virtual void visit( ContextDecl *aggregateDecl );
+        virtual void visit( TraitDecl *aggregateDecl );
         virtual void visit( TypeDecl *typeDecl );
         virtual void visit( TypedefDecl *typeDecl );
 …
         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 );
 …
         virtual void visit( AsmExpr *asmExpr );
         virtual void visit( UntypedValofExpr *valofExpr );
+        virtual void visit( CompoundLiteralExpr *compLitExpr );
         virtual void visit( VoidType *basicType );
 …
         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( TypeofType *typeofType );
         virtual void visit( AttrType *attrType );
+        virtual void visit( VarArgsType *varArgsType );
         virtual void visit( SingleInit *singleInit );

src/SynTree/module.mk

-              rc5833e8
+              r0f9e4403
        SynTree/TypeofType.cc \
        SynTree/AttrType.cc \
+       SynTree/VarArgsType.cc \
        SynTree/Constant.cc \
        SynTree/Expression.cc \
 …
        SynTree/Visitor.cc \
        SynTree/Mutator.cc \
-       SynTree/CodeGenVisitor.cc \
        SynTree/TypeSubstitution.cc

src/Tuples/FlattenTuple.cc

rc5833e8	r0f9e4403
49	49	void FlattenTuple::CollectArgs::visit( UntypedOffsetofExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
50	50	void FlattenTuple::CollectArgs::visit( OffsetofExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
	51	void FlattenTuple::CollectArgs::visit( OffsetPackExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
51	52	void FlattenTuple::CollectArgs::visit( AttrExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
52	53	void FlattenTuple::CollectArgs::visit( LogicalExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }

src/Tuples/FlattenTuple.h

rc5833e8	r0f9e4403
45	45	virtual void visit( UntypedOffsetofExpr * );
46	46	virtual void visit( OffsetofExpr * );
	47	virtual void visit( OffsetPackExpr * );
47	48	virtual void visit( AttrExpr * );
48	49	virtual void visit( LogicalExpr * );

src/driver/Makefile.in

-              rc5833e8
+              r0f9e4403
           esac; \
         done; \
         echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/driver/Makefile'; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/driver/Makefile'; \
         $(am__cd) $(top_srcdir) && \
           $(AUTOMAKE) --gnu src/driver/Makefile
+          $(AUTOMAKE) --foreign src/driver/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status

src/driver/cfa.cc

-              rc5833e8
+              r0f9e4403
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 28 18:24:06 2016
 // Update Count     : 127
+// Last Modified On : Wed Apr  6 14:04:22 2016
+// Update Count     : 132
 //
 …
                                 nargs += 1;
                         } else if ( prefix( arg, "-std=" ) ) {
                                 std_flag = true;                                                // std=XX provided
+                                std_flag = true;                                                // -std=XX provided
                                 args[nargs] = argv[i];                                  // pass the argument along
                                 nargs += 1;
 …
                 nargs += 1;
                 if ( ! std_flag ) {                                                             // default c99, if none specified
                         args[nargs] = "-std=c99";
+                        args[nargs] = "-std=gnu99";
                         nargs += 1;
                 } // if

src/examples/Makefile.in

-              rc5833e8
+              r0f9e4403
           esac; \
         done; \
         echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/examples/Makefile'; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/examples/Makefile'; \
         $(am__cd) $(top_srcdir) && \
           $(AUTOMAKE) --gnu src/examples/Makefile
+          $(AUTOMAKE) --foreign src/examples/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status

src/examples/abs.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Thu Jan 28 18:26:16 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 09:32:04 2016
 // Update Count     : 44
+// Last Modified On : Wed Mar  2 15:07:26 2016
+// Update Count     : 51
 //
 …
         char ch = -65;
         sout | "char\t\t\t"                                     | ch     | "\tabs " | abs( ch ) | endl;
         sout | "signed int\t\t"                         | -65    | "\tabs " | abs( -65 ) | endl;
         sout | "signed long int\t\t"            | -65l   | "\tabs " | abs( -65l ) | endl;
         sout | "signed long long int\t"         | -65ll  | "\tabs " | abs( -65ll ) | endl;
         sout | "float\t\t\t"                            | -65.0f | "\tabs " | abs( -65.0f ) | endl;
         sout | "double\t\t\t"                           | -65.0  | "\tabs " | abs( -65.0 ) | endl;
         sout | "long double\t\t"                        | -65.0l | "\tabs " | abs( -65.0l ) | endl;
         sout | "float _Complex\t\t"                     | -65.0F-2.0iF | "\tabs " | abs( -65.0F-2.0iF ) | endl;
         sout | "double _Complex\t\t"            | -65.0D-2.0iD | "\tabs " | abs( -65.0D-2.0iD ) | endl;
         sout | "long double _Complex\t"         | -65.0L-2.0iL | "\tabs " | abs( -65.0L-2.0iL ) | endl;
+        sout | "signed int\t\t"                         | -65    | "\tabs" | abs( -65 ) | endl;
+        sout | "signed long int\t\t"            | -65l   | "\tabs" | abs( -65l ) | endl;
+        sout | "signed long long int\t"         | -65ll  | "\tabs" | abs( -65ll ) | endl;
+        sout | "float\t\t\t"                            | -65.0f | "\tabs" | abs( -65.0f ) | endl;
+        sout | "double\t\t\t"                           | -65.0  | "\tabs" | abs( -65.0 ) | endl;
+        sout | "long double\t\t"                        | -65.0l | "\tabs" | abs( -65.0l ) | endl;
+        sout | "float _Complex\t\t"                     | -65.0F-2.0iF | "\tabs" | abs( -65.0F-2.0iF ) | endl;
+        sout | "double _Complex\t\t"            | -65.0D-2.0iD | "\tabs" | abs( -65.0D-2.0iD ) | endl;
+        sout | "long double _Complex\t"         | -65.0L-2.0iL | "\tabs" | abs( -65.0L-2.0iL ) | endl;
 } // main

src/examples/array.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:10:13 2015
 // Update Count     : 2
+// Last Modified On : Wed Mar  2 18:13:52 2016
+// Update Count     : 3
 //
 #include "array.h"
 /// forall( type array_type, elt_type | bounded_array( array_type, elt_type ) )
+/// forall( otype array_type, elt_type | bounded_array( array_type, elt_type ) )
 /// [ array_iterator begin, array_iterator end ]
 /// get_iterators( array_type array )
 …
 // The first element is always at index 0.
 forall( type array_type, type elt_type | bounded_array( array_type, elt_type ) )
+forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) )
 elt_type * begin( array_type array ) {
         return &array[ 0 ];
 …
 // The end iterator should point one past the last element.
 forall( type array_type, type elt_type | bounded_array( array_type, elt_type ) )
+forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) )
 elt_type * end( array_type array ) {
         return &array[ last( array ) ] + 1;

src/examples/array.h

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jan 26 17:09:29 2016
 // Update Count     : 3
+// Last Modified On : Wed Mar  2 18:13:35 2016
+// Update Count     : 5
 //
 …
 // An array has contiguous elements accessible in any order using integer indicies. The first
 // element has index 0.
 context array( type array_type, type elt_type ) {
+trait array( otype array_type, otype elt_type ) {
         lvalue elt_type ?[?]( array_type, int );
 };
 // A bounded array is an array that carries its maximum index with it.
 context bounded_array( type array_type, type elt_type | array( array_type, elt_type ) ) {
+trait bounded_array( otype array_type, otype elt_type | array( array_type, elt_type ) ) {
         int last( array_type );
 };
 …
 typedef int array_iterator;
 /// forall( type array_type, elt_type | bounded_array( array_type, elt_type ) )
+/// forall( otype array_type, elt_type | bounded_array( array_type, elt_type ) )
 /// [ array_iterator begin, array_iterator end ] get_iterators( array_type );
 …
 // A bounded array can be iterated over by using a pointer to the element type. These functions
 // return iterators corresponding to the first element and the one-past-the-end element, STL-style.
 forall( type array_type, type elt_type | bounded_array( array_type, elt_type ) )
+forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) )
 elt_type *begin( array_type );
 forall( type array_type, type elt_type | bounded_array( array_type, elt_type ) )
+forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) )
 elt_type *end( array_type );

src/examples/ato.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Thu Feb  4 08:10:57 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 11:44:03 2016
 // Update Count     : 42
+// Last Modified On : Mon Feb 29 17:57:35 2016
+// Update Count     : 44
 //
 …
 int main( void ) {
         int i = ato( "-123" );
         sout | i | ' ' | "-123" | endl;
+        sout | i | "-123" | endl;
         unsigned int ui = ato( "123" );
         sout | ui | ' ' | "123" | endl;
+        sout | ui | "123" | endl;
         long int li = ato( "-123" );
         sout | li | ' ' | "-123" | endl;
+        sout | li | "-123" | endl;
         unsigned long int uli = ato( "123" );
         sout | uli | ' ' | "123" | endl;
+        sout | uli | "123" | endl;
         long long int lli = ato( "-123" );
         sout | lli | ' ' | "-123" | endl;
+        sout | lli | "-123" | endl;
         unsigned long long int ulli = ato( "123" );
         sout | ulli | ' ' | "123" | endl;
+        sout | ulli | "123" | endl;
         float f = ato( "-123.456" );
         sout | f | ' ' | "-123.456" | endl;
+        sout | f | "-123.456" | endl;
         double d = ato( "-123.4567890123456" );
         sout | d | ' ' | "-123.4567890123456" | endl;
+        sout | d | "-123.4567890123456" | endl;
         long double ld = ato( "-123.45678901234567890123456789" );
         sout | ld | ' ' | "-123.45678901234567890123456789" | endl;
+        sout | ld | "-123.45678901234567890123456789" | endl;
         float _Complex fc = ato( "-123.456-123.456i" );
         sout | fc | ' ' | "-123.456-123.456i" | endl;
+        sout | fc | "-123.456-123.456i" | endl;
         double _Complex dc = ato( "-123.4567890123456+123.4567890123456i" );
         sout | dc | ' ' | "-123.4567890123456+123.4567890123456i" | endl;
+        sout | dc | "-123.4567890123456+123.4567890123456i" | endl;
         long double _Complex ldc = ato( "123.45678901234567890123456789-123.45678901234567890123456789i" );
         sout | ldc | ' ' | "123.45678901234567890123456789-123.45678901234567890123456789i" | endl;
+        sout | ldc | "123.45678901234567890123456789-123.45678901234567890123456789i" | endl;
         long double _Complex ldc2 = ato( "123.45678901234-123.4567890i" );
         sout | ldc2 | ' ' | "123.45678901234567890123456789-123.45678901234567890123456789i" | endl;
+        sout | ldc2 | "123.45678901234-123.4567890i" | endl;
 } // main

src/examples/constants.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 25 23:44:12 2016
 // Update Count     : 76
+// Last Modified On : Fri Mar 11 16:27:38 2016
+// Update Count     : 81
 //
 …
 x_ff_FF_ff_FF_ff_FF_ff_FF;
 _223_372_036_854_775_807;
 _446_744_073_709_551_615;
+_446_744_073_709_551_615UL;
 .141_59f;
 .14159;
 …
         L'\x_ff_ee';
         L_"\x_ff_ee";
         L"a_b\r\Qyc\u_00_40  x_y_z\xff_AA";
         L_"a_b\r\Qyc\u_00_40\
+        L"a_b\r\vyc\u_00_40  x_y_z\xff_AA";
+        L_"a_b\r\vyc\u_00_40\
   x_y_z\xff_AA";
         "abc" "def" "ghi";

src/examples/ctxts.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:11:19 2015
 // Update Count     : 2
+// Last Modified On : Wed Mar  2 18:10:21 2016
+// Update Count     : 3
 //
 context has_f( type T ) {
+trait has_f( type T ) {
         T f( T );
 };
 context has_g( type U | has_f( U ) ) {
+trait has_g( type U | has_f( U ) ) {
         U g( U );
 };

src/examples/fstream_test.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 11:45:43 2016
 // Update Count     : 43
+// Last Modified On : Sun Mar  6 20:58:29 2016
+// Update Count     : 54
 //
 …
 int main( void ) {
         int nombre;
         sout | "Entrez un nombre, s'il vous plaît:\n";
+        sout | "Entrez un nombre, s'il vous plaît:" | endl;
         sin  | &nombre;
+        sout | "Vous avez entré " | nombre | " stocké à l'adresse " | &nombre | endl;
+        sout | "nombre " | nombre | " est "
+                 | (nombre > 0 ? "plus grand que" :
+                   nombre == 0 ? "égal à" : "moins de")
+                 | " zéro" | endl;
+        sout | "Vous avez entré" | nombre | "stocké à l'adresse" | &nombre | endl;
+        sout | "nombre" | nombre | "est"
+                 | (nombre > 0 ? "plus grand que" : nombre == 0 ? "égal à" : "moins de")
+                 | "zéro" | endl;
         sout | "Entrez trois nombres, s'il vous plaît:\n";
+        sout | "Entrez trois nombres, s'il vous plaît: " | endl;
         int i, j, k;
         sin  | &i | &j | &k;
+        sout | "Vous avez entré " | "i:" | i | " j:" | j | " k:" | k | endl;
+        sout | 3 | ' ' | 3.5 | ' ' | 'a' | ' ' | "abc" | endl;
+        sout | "Vous avez entré" | "i:" | "" | i | "j:" | "" | j | "k:" | "" | k | endl;
+}

src/examples/hello.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 12:11:45 2016
 // Update Count     : 8
+// Last Modified On : Mon Feb 29 18:06:17 2016
+// Update Count     : 10
 //
 …
 int main() {
         sout | "Bonjour au monde!\n";
+        sout | "Bonjour au monde!" | endl;
+}

src/examples/huge.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:15:34 2015
 // Update Count     : 1
+// Last Modified On : Tue Mar  8 22:16:32 2016
+// Update Count     : 2
 //
 int huge( int n, forall( type T ) T (*f)( T ) ) {
+int huge( int n, forall( otype T ) T (*f)( T ) ) {
         if ( n <= 0 )
                 return f( 0 );

src/examples/identity.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 12:17:32 2016
 // Update Count     : 10
+// Last Modified On : Tue Mar  8 22:15:08 2016
+// Update Count     : 13
 //
 #include <fstream>
 forall( type T )
+forall( otype T )
 T identity( T t ) {
         return t;

src/examples/includes.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 21 13:54:09 2015
 // Update Count     : 322
+// Last Modified On : Wed Mar  2 23:28:02 2016
+// Update Count     : 328
 //
 …
 #include <ctype.h>
 #include <curses.h>
 #include <demangle.h>           // enum / contains "type"
 #include <dialog.h>                     // enum / contains "type"
+#include <demangle.h>
+#include <dialog.h>
 #include <dirent.h>
 #include <dis-asm.h>
 …
 #include <err.h>
 #include <errno.h>
+#if 0
 #include <error.h>
+#endif
+#include <eti.h>
+#include <evdns.h>
+#include <event.h>
+#include <evhttp.h>
 #if 0
-#include <eti.h>
-#include <evdns.h>                      // subdirectory event2 contains "type"
-#include <event.h>
-#include <evhttp.h>                     // enum / subdirectory event2 contains "type"
 #include <evrpc.h>
 #include <evutil.h>
 #include <execinfo.h>
 #include <expat.h>                      // enum / contains "type" and "context"
+#include <expat.h>
 #include <expat_config.h>
 #include <expat_external.h>
 …
 #include <fmtmsg.h>
 #include <fnmatch.h>
 #include <form.h>                       // contains "type"
+#include <form.h>
 #include <fpu_control.h>
 #include <fstab.h>
 …
 #include <ftw.h>
 #include <gconv.h>
 //#include <gcrypt.h>           // enum / contains "type"
+//#include <gcrypt.h>
 //#include <gcrypt-module.h>
 #include <getopt.h>
 …
 #include <limits.h>
 #include <locale.h>
 #include <math.h>                       // contains "type"
+#include <math.h>
 #include <ncurses.h>
 #include <setjmp.h>

src/examples/index.h

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:17:31 2015
 // Update Count     : 1
+// Last Modified On : Wed Mar  2 18:10:46 2016
+// Update Count     : 2
 //
 context index( type T ) {
+trait index( type T ) {
         T ?+?( T, T );
         T ?-?( T, T );

src/examples/it_out.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:41:23 2015
 // Update Count     : 4
+// Last Modified On : Tue Mar  8 22:14:39 2016
+// Update Count     : 8
 //
 typedef unsigned long streamsize_type;
 context ostream( dtype os_type ) {
+trait ostream( dtype os_type ) {
         os_type *write( os_type *, const char *, streamsize_type );
         int fail( os_type * );
 };
 context writeable( type T ) {
+trait writeable( otype T ) {
         forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, T );
 };
 …
 forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, const char * );
 context istream( dtype is_type ) {
+trait istream( dtype is_type ) {
         is_type *read( is_type *, char *, streamsize_type );
         is_type *unread( is_type *, char );
 …
 };
 context readable( type T ) {
+trait readable( otype T ) {
         forall( dtype is_type | istream( is_type ) ) is_type * ?<<?( is_type *, T );
 };
 …
 forall( dtype is_type | istream( is_type ) ) is_type * ?>>?( is_type *, int* );
 context iterator( type iterator_type, type elt_type ) {
+trait iterator( otype iterator_type, otype elt_type ) {
         iterator_type ?++( iterator_type* );
         iterator_type ++?( iterator_type* );
 …
 };
 forall( type elt_type | writeable( elt_type ),
                 type iterator_type | iterator( iterator_type, elt_type ),
+forall( otype elt_type | writeable( elt_type ),
+                otype iterator_type | iterator( iterator_type, elt_type ),
                 dtype os_type | ostream( os_type ) )
 void write_all( iterator_type begin, iterator_type end, os_type *os );
 forall( type elt_type | writeable( elt_type ),
                 type iterator_type | iterator( iterator_type, elt_type ),
+forall( otype elt_type | writeable( elt_type ),
+                otype iterator_type | iterator( iterator_type, elt_type ),
                 dtype os_type | ostream( os_type ) )
 void write_all( elt_type begin, iterator_type end, os_type *os ) {

src/examples/limits.c

rc5833e8	r0f9e4403
98	98	// Local Variables: //
99	99	// tab-width: 4 //
100		// compile-command: "cfa ~~min~~.c" //
	100	// compile-command: "cfa limits.c" //
101	101	// End: //

src/examples/minmax.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 12:17:53 2016
 // Update Count     : 47
+// Last Modified On : Mon Feb 29 23:45:16 2016
+// Update Count     : 49
 //
 …
         sout | "char\t\t\t"                                     | 'z' | ' ' | 'a' | "\tmin " | min( 'z', 'a' ) | endl;
         sout | "signed int\t\t"                         | 4 | ' ' | 3 | "\tmin " | min( 4, 3 ) | endl;
         sout | "unsigned int\t\t"                       | 4u | ' ' | 3u | "\tmin " | min( 4u, 3u ) | endl;
         sout | "signed long int\t\t"            | 4l | ' ' | 3l | "\tmin " | min( 4l, 3l ) | endl;
         sout | "unsigned long int\t"            | 4ul | ' ' | 3ul | "\tmin " | min( 4ul, 3ul ) | endl;
         sout | "signed long long int\t"         | 4ll | ' ' | 3ll | "\tmin " | min( 4ll, 3ll ) | endl;
         sout | "unsigned long long int\t"       | 4ull | ' ' | 3ull | "\tmin " | min( 4ull, 3ull ) | endl;
         sout | "float\t\t\t"                            | 4.0f | ' ' | 3.1f | "\tmin " | min( 4.0f, 3.1f ) | endl;
         sout | "double\t\t\t"                           | 4.0 | ' ' | 3.1 | "\tmin " | min( 4.0, 3.1 ) | endl;
         sout | "long double\t\t"                        | 4.0l | ' ' | 3.1l | "\tmin " | min( 4.0l, 3.1l ) | endl;
+        sout | "signed int\t\t"                         | 4 | 3 | "\tmin" | min( 4, 3 ) | endl;
+        sout | "unsigned int\t\t"                       | 4u | 3u | "\tmin" | min( 4u, 3u ) | endl;
+        sout | "signed long int\t\t"            | 4l | 3l | "\tmin" | min( 4l, 3l ) | endl;
+        sout | "unsigned long int\t"            | 4ul | 3ul | "\tmin" | min( 4ul, 3ul ) | endl;
+        sout | "signed long long int\t"         | 4ll | 3ll | "\tmin" | min( 4ll, 3ll ) | endl;
+        sout | "unsigned long long int\t"       | 4ull | 3ull | "\tmin" | min( 4ull, 3ull ) | endl;
+        sout | "float\t\t\t"                            | 4.0f | 3.1f | "\tmin" | min( 4.0f, 3.1f ) | endl;
+        sout | "double\t\t\t"                           | 4.0 | 3.1 | "\tmin" | min( 4.0, 3.1 ) | endl;
+        sout | "long double\t\t"                        | 4.0l | 3.1l | "\tmin" | min( 4.0l, 3.1l ) | endl;
         sout | endl;
         sout | "char\t\t\t"                                     | 'z' | ' ' | 'a' | "\tmax " | max( 'z', 'a' ) | endl;
         sout | "signed int\t\t"                         | 4 | ' ' | 3 | "\tmax " | max( 4, 3 ) | endl;
         sout | "unsigned int\t\t"                       | 4u | ' ' | 3u | "\tmax " | max( 4u, 3u ) | endl;
         sout | "signed long int\t\t"            | 4l | ' ' | 3l | "\tmax " | max( 4l, 3l ) | endl;
         sout | "unsigned long int\t"            | 4ul | ' ' | 3ul | "\tmax " | max( 4ul, 3ul ) | endl;
         sout | "signed long long int\t"         | 4ll | ' ' | 3ll | "\tmax " | max( 4ll, 3ll ) | endl;
         sout | "unsigned long long int\t"       | 4ull | ' ' | 3ull | "\tmax " | max( 4ull, 3ull ) | endl;
         sout | "float\t\t\t"                            | 4.0f | ' ' | 3.1f | "\tmax " | max( 4.0f, 3.1f ) | endl;
         sout | "double\t\t\t"                           | 4.0 | ' ' | 3.1 | "\tmax " | max( 4.0, 3.1 ) | endl;
         sout | "long double\t\t"                        | 4.0l | ' ' | 3.1l | "\tmax " | max( 4.0l, 3.1l ) | endl;
+        sout | "signed int\t\t"                         | 4 | 3 | "\tmax" | max( 4, 3 ) | endl;
+        sout | "unsigned int\t\t"                       | 4u | 3u | "\tmax" | max( 4u, 3u ) | endl;
+        sout | "signed long int\t\t"            | 4l | 3l | "\tmax" | max( 4l, 3l ) | endl;
+        sout | "unsigned long int\t"            | 4ul | 3ul | "\tmax" | max( 4ul, 3ul ) | endl;
+        sout | "signed long long int\t"         | 4ll | 3ll | "\tmax" | max( 4ll, 3ll ) | endl;
+        sout | "unsigned long long int\t"       | 4ull | 3ull | "\tmax" | max( 4ull, 3ull ) | endl;
+        sout | "float\t\t\t"                            | 4.0f | 3.1f | "\tmax" | max( 4.0f, 3.1f ) | endl;
+        sout | "double\t\t\t"                           | 4.0 | 3.1 | "\tmax" | max( 4.0, 3.1 ) | endl;
+        sout | "long double\t\t"                        | 4.0l | 3.1l | "\tmax" | max( 4.0l, 3.1l ) | endl;
 } // main

src/examples/new.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 25 23:33:55 2016
 // Update Count     : 2
+// Last Modified On : Tue Mar  8 22:13:20 2016
+// Update Count     : 4
 //
 forall( type T )
+forall( otype T )
 void f( T *t ) {
         t--;

src/examples/prolog.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:25:52 2015
 // Update Count     : 1
+// Last Modified On : Tue Mar  8 22:09:39 2016
+// Update Count     : 5
 //
+extern "C" { extern int printf( const char *fmt, ... ); }
+#include <fstream>
 void printResult( int x ) { printf( "int\n" ); }
 void printResult( double x ) { printf( "double\n" ); }
 void printResult( char * x ) { printf( "char*\n" ); }
+void printResult( int x ) { sout | "int" | endl; }
+void printResult( double x ) { sout | "double" | endl; }
+void printResult( char * x ) { sout | "char*" | endl; }
 void is_arithmetic( int x ) {}
 …
 void is_integer( int x ) {}
 context ArithmeticType( type T ) {
+trait ArithmeticType( otype T ) {
         void is_arithmetic( T );
 };
 context IntegralType( type T | ArithmeticType( T ) ) {
+trait IntegralType( otype T | ArithmeticType( T ) ) {
         void is_integer( T );
 };
 forall( type T | IntegralType( T ) | { void printResult( T ); } )
+forall( otype T | IntegralType( T ) | { void printResult( T ); } )
 void hornclause( T param ) {
         printResult( param );

src/examples/quad.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 12:19:24 2016
 // Update Count     : 6
+// Last Modified On : Tue Mar  8 22:07:02 2016
+// Update Count     : 8
 //
 #include <fstream>
 forall( type T | { T ?*?( T, T ); } )
+forall( otype T | { T ?*?( T, T ); } )
 T square( T t ) {
         return t * t;
+}
 forall( type U | { U square( U ); } )
+forall( otype U | { U square( U ); } )
 U quad( U u ) {
         return square( square( u ) );
 …
 int main() {
         int N = 2;
         sout | "result of quad of " | N | " is " | quad( N ) | endl;
+        sout | "result of quad of" | N | "is" | quad( N ) | endl;
+}

src/examples/random.c

-              rc5833e8
+              r0f9e4403
 int main() {
         randseed( getpid() );                                                           // set random seed
+        rand48seed( getpid() );                                                         // set random seed
         // test polymorphic calls to random and stream
         char c = random();
+        char c = rand48();
         sout | c | endl;
         int i = random();
+        int i = rand48();
     sout | i | endl;
         unsigned int ui = random();
+        unsigned int ui = rand48();
     sout | ui | endl;
         long int li = random();
+        long int li = rand48();
     sout | li | endl;
         unsigned long int uli = random();
+        unsigned long int uli = rand48();
     sout | uli | endl;
     float f = random();
+    float f = rand48();
     sout | f | endl;
     double d = random();
+    double d = rand48();
     sout | d | endl;
     float _Complex fc = random();
+    float _Complex fc = rand48();
     sout | fc | endl;
     double _Complex dc = random();
+    double _Complex dc = rand48();
     sout | dc | endl;
     long double _Complex ldc = random();
+    long double _Complex ldc = rand48();
     sout | ldc | endl;
 } // main

src/examples/searchsort.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Thu Feb  4 18:17:50 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 12:21:04 2016
 // Update Count     : 46
+// Last Modified On : Tue Mar 22 22:16:46 2016
+// Update Count     : 55
 //
 …
                 sout | *v | ", ";
         } // for
+        sout | endl | endl;
+        // descending sort/search by changing < to >
+        for ( unsigned int i = 0; i < size; i += 1 ) {
+                iarr[i] = i + 1;
+                sout | iarr[i] | ", ";
+        } // for
+        sout | endl;
+        {
+                int ?<?( int x, int y ) { return x > y; }
+                qsort( iarr, size );
+                for ( unsigned int i = 0; i < size; i += 1 ) {
+                        sout | iarr[i] | ", ";
+                } // for
+                sout | endl;
+                for ( unsigned int i = 0; i < size; i += 1 ) {
+                        int *v = bsearch( size - i, iarr, size );
+                        sout | *v | ", ";
+                } // for
+        }
         sout | endl | endl;

src/examples/simplePoly.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:31:17 2015
 // Update Count     : 2
+// Last Modified On : Tue Mar  8 22:06:41 2016
+// Update Count     : 3
 //
 forall( type T, type U | { T f( T, U ); } )
+forall( otype T, otype U | { T f( T, U ); } )
 T q( T t, U u ) {
         return f( t, u );

src/examples/simpler.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:31:48 2015
 // Update Count     : 1
+// Last Modified On : Tue Mar  8 22:06:30 2016
+// Update Count     : 2
 //
 forall( type T ) T id( T, T );
+forall( otype T ) T id( T, T );
 int main() {

src/examples/specialize.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:32:26 2015
 // Update Count     : 2
+// Last Modified On : Tue Mar  8 22:06:17 2016
+// Update Count     : 3
 //
 …
+}
 forall( type T ) T f( T t )
+forall( otype T ) T f( T t )
+{
         printf( "in f; sizeof T is %d\n", sizeof( T ) );

src/examples/square.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 12:21:58 2016
 // Update Count     : 26
+// Last Modified On : Tue Mar  8 22:05:48 2016
+// Update Count     : 27
 //
 #include <fstream>
 forall( type T | { T ?*?( T, T ); } )
+forall( otype T | { T ?*?( T, T ); } )
 T square( T t ) {
         return t * t;

src/examples/sum.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb 16 23:49:31 2016
 // Update Count     : 189
+// Last Modified On : Fri Mar  4 15:06:47 2016
+// Update Count     : 196
 //
 #include <fstream>
 context sumable( type T ) {
+trait sumable( otype T ) {
         const T 0;
         T ?+?( T, T );
 …
 }; // sumable
 forall( type T | sumable( T ) )
+forall( otype T | sumable( T ) )
 T sum( unsigned int n, T a[] ) {
         T total = 0;                                                                            // instantiate T, select 0
 …
                 a[i] = v;
         } // for
         sout | "sum from " | low | " to " | High | " is "
                  | (int)sum( size, a ) | ", check " | (int)s | endl;
+        sout | "sum from" | low | "to" | High | "is"
+                 | (int)sum( size, a ) | "" | ", check" | (int)s | endl;
         int s = 0, a[size], v = low;
 …
                 a[i] = (int)v;
         } // for
         sout | "sum from " | low | " to " | High | " is "
                  | sum( size, (int *)a ) | ", check " | (int)s | endl;
+        sout | "sum from" | low | "to" | High | "is"
+                 | sum( size, (int *)a ) | "" | ", check" | (int)s | endl;
         float s = 0.0, a[size], v = low / 10.0;
 …
                 a[i] = (float)v;
         } // for
         sout | "sum from " | low / 10.0 | " to " | High / 10.0 | " is "
                  | sum( size, (float *)a ) | ", check " | (float)s | endl;
+        sout | "sum from" | low / 10.0 | "to" | High / 10.0 | "is"
+                 | sum( size, (float *)a ) | "" | ", check" | (float)s | endl;
         double s = 0, a[size], v = low / 10.0;
 …
                 a[i] = (double)v;
         } // for
         sout | "sum from " | low / 10.0 | " to " | High / 10.0 | " is "
                  | sum( size, (double *)a ) | ", check " | (double)s | endl;
+        sout | "sum from" | low / 10.0 | "to" | High / 10.0 | "is"
+                 | sum( size, (double *)a ) | "" | ", check" | (double)s | endl;
         struct S { int i, j; } 0 = { 0, 0 }, 1 = { 1, 1 };
 …
         S ++?( S *t ) { *t += 1; return *t; }
         S ?++( S *t ) { S temp = *t; *t += 1; return temp; }
         ofstream * ?|?( ofstream * os, S v ) { return os | v.i | ' ' | v.j; }
+        ofstream * ?|?( ofstream * os, S v ) { return os | v.i | v.j; }
         S s = 0, a[size], v = { low, low };
 …
                 a[i] = (S)v;
         } // for
         sout | "sum from " | low | " to " | High | " is "
                  | sum( size, (S *)a ) | ", check " | (S)s | endl;
+        sout | "sum from" | low | "to" | High | "is"
+                 | sum( size, (S *)a ) | "" | ", check" | (S)s | endl;
 } // main

src/examples/swap.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 12:22:12 2016
 // Update Count     : 64
+// Last Modified On : Wed Mar  2 16:15:11 2016
+// Update Count     : 65
 //
 …
         float f1 = 1.5, f2 = 2.5;
         sout | "float\t\t\t" | f1 | ' ' | f2 | "\t\t\tswap ";
+        sout | "float\t\t\t" | f1 | ' ' | f2 | "\t\tswap ";
         swap( &f1, &f2 );
         sout | '\t' | f1 | ' ' | f2 | endl;
         double d1 = 1.5, d2 = 2.5;
         sout | "double\t\t\t" | d1 | ' ' | d2 | "\t\t\tswap ";
+        sout | "double\t\t\t" | d1 | ' ' | d2 | "\t\tswap ";
         swap( &d1, &d2 );
         sout | '\t' | d1 | ' ' | d2 | endl;
         long double ld1 = 1.5, ld2 = 2.5;
         sout | "long double\t\t" | ld1 | ' ' | ld2 | "\t\t\tswap ";
+        sout | "long double\t\t" | ld1 | ' ' | ld2 | "\t\tswap ";
         swap( &ld1, &ld2 );
         sout | '\t' | ld1 | ' ' | ld2 | endl;

src/examples/tests/vector_test.out.txt

-              rc5833e8
+              r0f9e4403
 enter N elements and C-d on a separate line:
 Array elements:
 2 3 4 5
+2 3 4 5
 Array elements reversed:
 4 3 2 1
+4 3 2 1

src/examples/twice.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 12:23:25 2016
 // Update Count     : 13
+// Last Modified On : Tue Mar  8 22:04:58 2016
+// Update Count     : 16
 //
 #include <fstream>
 forall( type T | { T ?+?( T, T ); T ?++( T * ); [T] ?+=?( T *, T ); } )
+forall( otype T | { T ?+?( T, T ); T ?++( T * ); [T] ?+=?( T *, T ); } )
 T twice( const T t ) {
         return t + t;
 …
         char ?++( char *op ) { char temp = *op; *op += 1; return temp; }
         sout | twice( 'a' ) | ' ' | twice( 1 ) | ' ' | twice( 3.2 ) | endl;
+        sout | twice( 'a' ) | ' ' | twice( 1 ) | twice( 3.2 ) | endl;
+}

src/libcfa/Makefile.am

-              rc5833e8
+              r0f9e4403
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Wed Feb  3 11:19:35 2016
 ## Update Count     : 117
+## Last Modified On : Wed Apr  6 21:10:44 2016
+## Update Count     : 123
 ###############################################################################
 …
         ${CC} ${CFLAGS} -c -o $@ $<
 libs = stdlib iostream fstream iterator
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 cheaders = bfd bfdlink demangle dialog evdns evhttp evrpc expat fcntl form gcrypt math
 cfaheaders = limits
+cheaders = # expat
+cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}

src/libcfa/Makefile.in

-              rc5833e8
+              r0f9e4403
 libcfa_a_AR = $(AR) $(ARFLAGS)
 libcfa_a_LIBADD =
 am__objects_1 = stdlib.$(OBJEXT) iostream.$(OBJEXT) fstream.$(OBJEXT) \
         iterator.$(OBJEXT)
+am__objects_1 = limits.$(OBJEXT) stdlib.$(OBJEXT) iostream.$(OBJEXT) \
+        fstream.$(OBJEXT) iterator.$(OBJEXT) rational.$(OBJEXT)
 am_libcfa_a_OBJECTS = libcfa-prelude.$(OBJEXT) $(am__objects_1)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
 …
 MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} \
         ${addprefix ${libdir}/,${lib_LIBRARIES}} ${includedir}/*
 libs = stdlib iostream fstream iterator
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 cheaders = bfd bfdlink demangle dialog evdns evhttp evrpc expat fcntl form gcrypt math
 cfaheaders = limits
+cheaders = # expat
+cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
 all: all-am
 …
           esac; \
         done; \
         echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/libcfa/Makefile'; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/libcfa/Makefile'; \
         $(am__cd) $(top_srcdir) && \
           $(AUTOMAKE) --gnu src/libcfa/Makefile
+          $(AUTOMAKE) --foreign src/libcfa/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iterator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa-prelude.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/limits.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rational.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stdlib.Po@am__quote@

src/libcfa/builtins.cf

-              rc5833e8
+              r0f9e4403
 int __builtin_sprintf(char *, const char *, ...);
 int __builtin_sscanf(const char *, const char *, ...);
 int __builtin_vfprintf(struct _IO_FILE *, const char *, void **);
 int __builtin_vfscanf(struct _IO_FILE *, const char *, void **);
 int __builtin_vprintf(const char *, void **);
 int __builtin_vscanf(const char *, void **);
 int __builtin_vsnprintf(char *, unsigned long, const char *, void **);
 int __builtin_vsprintf(char *, const char *, void **);
 int __builtin_vsscanf(const char *, const char *, void **);
+int __builtin_vfprintf(struct _IO_FILE *, const char *, __builtin_va_list);
+int __builtin_vfscanf(struct _IO_FILE *, const char *, __builtin_va_list);
+int __builtin_vprintf(const char *, __builtin_va_list);
+int __builtin_vscanf(const char *, __builtin_va_list);
+int __builtin_vsnprintf(char *, unsigned long, const char *, __builtin_va_list);
+int __builtin_vsprintf(char *, const char *, __builtin_va_list);
+int __builtin_vsscanf(const char *, const char *, __builtin_va_list);
 int __builtin_isalnum(int);
 int __builtin_isalpha(int);
 …
 void __builtin_unwind_init();
 void __builtin_update_setjmp_buf(void *, int);
 void __builtin_va_copy(void **, void **);
 void __builtin_va_end(void **);
 void __builtin_va_start(void **, ...);
+void __builtin_va_copy(__builtin_va_list, __builtin_va_list);
+void __builtin_va_end(__builtin_va_list);
+void __builtin_va_start(__builtin_va_list, ...);
 int __builtin_va_arg_pack();
 int __builtin_va_arg_pack_len();
 …
 int __builtin___snprintf_chk(char *, unsigned long, int, unsigned long, const char *, ...);
 int __builtin___sprintf_chk(char *, int, unsigned long, const char *, ...);
 int __builtin___vsnprintf_chk(char *, unsigned long, int, unsigned long, const char *, void **);
 int __builtin___vsprintf_chk(char *, int, unsigned long, const char *, void **);
+int __builtin___vsnprintf_chk(char *, unsigned long, int, unsigned long, const char *, __builtin_va_list);
+int __builtin___vsprintf_chk(char *, int, unsigned long, const char *, __builtin_va_list);
 int __builtin___fprintf_chk(struct _IO_FILE *, int, const char *, ...);
 int __builtin___printf_chk(int, const char *, ...);
 int __builtin___vfprintf_chk(struct _IO_FILE *, int, const char *, void **);
 int __builtin___vprintf_chk(int, const char *, void **);
+int __builtin___vfprintf_chk(struct _IO_FILE *, int, const char *, __builtin_va_list);
+int __builtin___vprintf_chk(int, const char *, __builtin_va_list);
 void __cyg_profile_func_enter(void *, void *);
 void __cyg_profile_func_exit(void *, void *);
 …
 const char * __builtin_FUNCTION();
 int __builtin_LINE();
-typedef void ** __builtin_va_list;
 extern const char *__PRETTY_FUNCTION__;
-typedef int wchar_t;

src/libcfa/fstream

-              rc5833e8
+              r0f9e4403
 // fstream --
 //
 // Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 14:02:01 2016
 // Update Count     : 22
+// Last Modified On : Tue Apr  5 22:37:12 2016
+// Update Count     : 82
 //
 …
 #include "iostream"
+// implement context ostream
+struct ofstream;
+enum { separateSize = 16 };
+struct ofstream {
+        void *file;
+        _Bool sepDefault;
+        _Bool sepOnOff;
+        char separator[separateSize];
+}; // ofstream
+int fail( ofstream * os );
+int flush( ofstream * os );
+void open( ofstream ** os, const char * name, const char * mode );
+void close( ofstream * os );
+ofstream * write( ofstream * os, const char * data, streamsize_type size );
+_Bool sepPrt( ofstream * );
+void sepOn( ofstream * );
+void sepOff( ofstream * );
+void sepReset( ofstream * );
+void sepReset( ofstream *, _Bool );
+void sepSet( ofstream *, const char * );
+const char * sepGet( ofstream * );
+_Bool sepDisable( ofstream * );
+_Bool sepEnable( ofstream * );
+int fail( ofstream * );
+int flush( ofstream * );
+void open( ofstream *, const char * name, const char * mode );
+void close( ofstream * );
+ofstream * write( ofstream *, const char * data, unsigned long int size );
+int prtfmt( ofstream *, const char fmt[], ... );
 extern ofstream * sout, * serr;
 // implement context istream
+struct ifstream;
+struct ifstream {
+        void *file;
+}; // ifstream
 int fail( ifstream * is );
 int eof( ifstream * is );
 void open( ifstream ** is, const char * name, const char * mode );
+void open( ifstream * is, const char * name, const char * mode );
 void close( ifstream * is );
+ifstream * get( ifstream * is, int * data );
+ifstream * read( ifstream * is, char * data, streamsize_type size );
+ifstream * read( ifstream * is, char * data, unsigned long int size );
 ifstream * ungetc( ifstream * is, char c );
+int scanfmt( ifstream *, const char fmt[], ... );
 extern ifstream *sin;
 …
 // tab-width: 4 //
 // End: //

src/libcfa/fstream.c

-              rc5833e8
+              r0f9e4403
 // fstream.c --
 //
 // Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 14:03:05 2016
 // Update Count     : 76
+// Last Modified On : Wed Apr  6 17:55:27 2016
+// Update Count     : 176
 //
 …
 extern "C" {
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdio.h>                                                                              // vfprintf, vfscanf
+#include <stdlib.h>                                                                             // exit
+#include <stdarg.h>                                                                             // varargs
+#include <string.h>                                                                             // strlen
+#include <float.h>                                                                              // DBL_DIG, LDBL_DIG
+#include <complex.h>                                                                    // creal, cimag
+}
+struct ofstream {
+        FILE *file;
+};
+#define IO_MSG "I/O error: "
+#define IO_MSG "I/O error "
+_Bool sepPrt( ofstream * os ) { return os->sepOnOff; }
+void sepOn( ofstream * os ) { os->sepOnOff = 1; }
+void sepOff( ofstream * os ) { os->sepOnOff = 0; }
+void sepReset( ofstream * os ) { os->sepOnOff = os->sepDefault; }
+void sepReset( ofstream * os, _Bool reset ) { os->sepDefault = reset; os->sepOnOff = os->sepDefault; }
+void sepSet( ofstream * os, const char * s ) {
+        strncpy( &(os->separator[0]), s, separateSize - 1 );
+        os->separator[separateSize - 1] = '\0';
+} // sepSet
+const char * sepGet( ofstream * os ) { return &(os->separator[0]); }
+_Bool sepDisable( ofstream *os ) {
+        _Bool temp = os->sepDefault;
+        os->sepDefault = 0;
+        sepReset( os );
+        return temp;
+} // sepDisable
+_Bool sepEnable( ofstream *os ) {
+        _Bool temp = os->sepDefault;
+        os->sepDefault = 1;
+        sepReset( os );
+        return temp;
+} // sepEnable
 int fail( ofstream * os ) {
         return ferror( os->file );
+        return ferror( (FILE *)(os->file) );
 } // fail
 int flush( ofstream * os ) {
         return fflush( os->file );
+        return fflush( (FILE *)(os->file) );
 } // flush
+void open( ofstream ** os, const char * name, const char * mode ) {
+        FILE *t = fopen( name, mode );
+        if ( t == 0 ) {                                                                         // do not change unless successful
+                perror( IO_MSG "open output" );
+void open( ofstream * os, const char * name, const char * mode ) {
+        FILE *file = fopen( name, mode );
+        if ( file == 0 ) {                                                                      // do not change unless successful
+                fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
+                perror( 0 );
                 exit( EXIT_FAILURE );
         } // if
+        (*os)->file = t;
+        os->file = file;
+        sepOff( os );
+        sepSet( os, " " );
 } // open
 void close( ofstream * os ) {
         if ( os->file == stdout || os->file == stderr ) return;
+        if ( (FILE *)(os->file) == stdout || (FILE *)(os->file) == stderr ) return;
         if ( fclose( os->file ) == EOF ) {
+        if ( fclose( (FILE *)(os->file) ) == EOF ) {
                 perror( IO_MSG "close output" );
         } // if
 } // close
 ofstream * write( ofstream * os, const char * data, streamsize_type size ) {
+ofstream * write( ofstream * os, const char * data, unsigned long int size ) {
         if ( fail( os ) ) {
                 fprintf( stderr, "attempt write I/O on failed stream\n" );
 …
         } // if
         if ( fwrite( data, 1, size, os->file ) != size ) {
+        if ( fwrite( data, 1, size, (FILE *)(os->file) ) != size ) {
                 perror( IO_MSG "write" );
                 exit( EXIT_FAILURE );
 …
 } // write
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) };
+int prtfmt( ofstream * os, const char fmt[], ... ) {
+    va_list args;
+    va_start( args, fmt );
+    int len = vfprintf( (FILE *)(os->file), fmt, args );
+        if ( len == EOF ) {
+                if ( ferror( (FILE *)(os->file) ) ) {
+                        fprintf( stderr, "invalid write\n" );
+                        exit( EXIT_FAILURE );
+                } // if
+        } // if
+    va_end( args );
+        return len;
+} // prtfmt
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 1, 0, { ' ', '\0' } };
 ofstream *sout = &soutFile;
 static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 1, 0, { ' ', '\0' } };
 ofstream *serr = &serrFile;
 //---------------------------------------
-struct ifstream {
-        FILE *file;
-};
 int fail( ifstream * is ) {
         return ferror( is->file );
+        return ferror( (FILE *)(is->file) );
 } // fail
 int eof( ifstream * is ) {
         return feof( is->file );
+        return feof( (FILE *)(is->file) );
 } // eof
 ifstream * get( ifstream * is, int * data ) {
         if ( fscanf( is->file, "%d", data ) == EOF ) {
                 if ( ferror( is->file ) ) {
                         fprintf( stderr, "invalid int read\n" );
                         exit( EXIT_FAILURE );
                 } // if
+void open( ifstream * is, const char * name, const char * mode ) {
+        FILE *t = fopen( name, mode );
+        if ( t == 0 ) {                                                                         // do not change unless successful
+                fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
+                perror( 0 );
+                exit( EXIT_FAILURE );
         } // if
         return is;
 } // read
+        is->file = t;
+} // open
+ifstream * read( ifstream * is, char * data, streamsize_type size ) {
+void close( ifstream * is ) {
+        if ( (FILE *)(is->file) == stdin ) return;
+        if ( fclose( (FILE *)(is->file) ) == EOF ) {
+                perror( IO_MSG "close input" );
+        } // if
+} // close
+ifstream * read( ifstream * is, char * data, unsigned long int size ) {
         if ( fail( is ) ) {
                 fprintf( stderr, "attempt read I/O on failed stream\n" );
 …
         } // if
         if ( fread( data, size, 1, is->file ) == 0 ) {
+        if ( fread( data, size, 1, (FILE *)(is->file) ) == 0 ) {
                 perror( IO_MSG "read" );
                 exit( EXIT_FAILURE );
 …
         } // if
         if ( ungetc( c, is->file ) == EOF ) {
+        if ( ungetc( c, (FILE *)(is->file) ) == EOF ) {
                 perror( IO_MSG "ungetc" );
                 exit( EXIT_FAILURE );
 …
 } // ungetc
+void open( ifstream ** is, const char * name, const char * mode ) {
+        FILE *t = fopen( name, mode );
+        if ( t == 0 ) {                                                                         // do not change unless successful
+                perror( IO_MSG "open input" );
+                exit( EXIT_FAILURE );
+int scanfmt( ifstream * is, const char fmt[], ... ) {
+    va_list args;
+    va_start( args, fmt );
+    int len = vfscanf( (FILE *)(is->file), fmt, args );
+        if ( len == EOF ) {
+                if ( ferror( (FILE *)(is->file) ) ) {
+                        fprintf( stderr, "invalid read\n" );
+                        exit( EXIT_FAILURE );
+                } // if
         } // if
+        (*is)->file = t;
+} // open
+    va_end( args );
+        return len;
+} // prtfmt
-void close( ifstream * is ) {
-        if ( is->file == stdin ) return;
-        if ( fclose( is->file ) == EOF ) {
-                perror( IO_MSG "close input" );
-        } // if
-} // close
 static ifstream sinFile = { (FILE *)(&_IO_2_1_stdin_) };
 …
 // Local Variables: //
 // tab-width: 4 //
-// compile-command: "cfa fstream.c" //
 // End: //

src/libcfa/iostream

-              rc5833e8
+              r0f9e4403
 // iostream --
 //
 // Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 14:04:24 2016
 // Update Count     : 32
+// Last Modified On : Sun Apr 10 23:00:12 2016
+// Update Count     : 92
 //
 #ifndef IOSTREAM_H
 #define IOSTREAM_H
+#ifndef __IOSTREAM_H__
+#define __IOSTREAM_H__
 #include "iterator"
+typedef unsigned long streamsize_type;
+trait ostream( dtype ostype ) {
+        _Bool sepPrt( ostype * );                                                       // return separator state (on/off)
+        void sepOn( ostype * );                                                         // turn separator state on
+        void sepOff( ostype * );                                                        // turn separator state off
+        void sepReset( ostype * );                                                      // set separator state to default state
+        void sepReset( ostype *, _Bool );                                       // set separator and default state
+        void sepSet( ostype *, const char * );                          // set separator to string (15 character maximum)
+        const char * sepGet( ostype * );                                        // get separator string
+        _Bool sepDisable( ostype * );                                           // set default state to off, and return previous state
+        _Bool sepEnable( ostype * );                                            // set default state to on, and return previous state
-context ostream( dtype ostype ) {
         int fail( ostype * );
         int flush( ostype * );
+        ostype * write( ostype *, const char *, streamsize_type );
+        void open( ostype * os, const char * name, const char * mode );
+        void close( ostype * os );
+        ostype * write( ostype *, const char *, unsigned long int );
+        int prtfmt( ostype *, const char fmt[], ... );
 };
+context writeable( type T ) {
+trait writeable( otype T ) {
         forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
 };
 …
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, char );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, short int );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned short int );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, int );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned int );
 …
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned long int );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned long long int );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, float ); // FIX ME: should not be required
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, double );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, long double );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, float _Complex );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, double _Complex );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, long double _Complex );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char * );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );
 forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) ) retostype * ?|?( ostype *os, retostype * (* manip)(ostype*) );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, ostype * (*)( ostype * ) );
 forall( dtype ostype | ostream( ostype ) ) ostype * endl( ostype * );
+forall( dtype ostype | ostream( ostype ) ) ostype * sepOn( ostype * );
+forall( dtype ostype | ostream( ostype ) ) ostype * sepOff( ostype * );
+forall( dtype ostype | ostream( ostype ) ) ostype * sepDisable( ostype * );
+forall( dtype ostype | ostream( ostype ) ) ostype * sepEnable( ostype * );
 // writes the range [begin, end) to the given stream
 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
 void write( iterator_type begin, iterator_type end, os_type *os );
 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
 void write_reverse( iterator_type begin, iterator_type end, os_type *os );
 //---------------------------------------
 context istream( dtype istype ) {
+trait istream( dtype istype ) {
         int fail( istype * );
         int eof( istype * );
+        istype * get( istype *, int * );
+        istype * read( istype *, char *, streamsize_type );
+        void open( istype * is, const char * name, const char * mode );
+        void close( istype * is );
+        istype * read( istype *, char *, unsigned long int );
         istype * ungetc( istype *, char );
+        int scanfmt( istype *, const char fmt[], ... );
 };
 context readable( type T ) {
+trait readable( otype T ) {
         forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, T );
 };
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype *, char * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char * );
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype *, int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, short int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned short int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long long int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long long int * );
+#endif // IOSTREAM_H
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float _Complex * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double _Complex * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double _Complex * );
+struct _Istream_cstrUC { char * s; };
+_Istream_cstrUC cstr( char * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrUC );
+struct _Istream_cstrC { char * s; int size; };
+_Istream_cstrC cstr( char *, int size );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrC );
+#endif // __IOSTREAM_H__
 // Local Variables: //

src/libcfa/iostream.c

-              rc5833e8
+              r0f9e4403
 // iostream.c --
 //
 // Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 14:19:56 2016
 // Update Count     : 76
+// Last Modified On : Wed Apr  6 16:13:29 2016
+// Update Count     : 278
 //
 …
 #include <float.h>                                                                              // DBL_DIG, LDBL_DIG
 #include <complex.h>                                                                    // creal, cimag
+#include <ctype.h>                                                                              // isspace, ispunct
+}
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, char c ) {
+        return write( os, &c, 1 );
+        prtfmt( os, "%c", c );
+        sepOff( os );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, short int si ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%hd", si );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned short int usi ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%hu", usi );
+        return os;
 } // ?|?
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, int i ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%d", i ) );
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned int i ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%u", i ) );
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long int i ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%ld", i ) );
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long long int i ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%lld", i ) );
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned long int i ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%lu", i ) );
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned long long int i ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%llu", i ) );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%d", i );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned int ui ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%u", ui );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long int li ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%ld", li );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned long int uli ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%lu", uli );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long long int lli ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%lld", lli );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned long long int ulli ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%llu", ulli );
+        return os;
 } // ?|?
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, float f ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%g", f ) );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%g", f );
+        return os;
 } // ?|?
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, double d ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%.*lg", DBL_DIG, d ) );
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long double d ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%.*Lg", LDBL_DIG, d ) );
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, float _Complex c ) {
+        return os | crealf( c ) | (cimagf( c ) < 0 ? "" : "+") | cimagf( c ) | 'i';
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, double _Complex c ) {
+        return os | creal( c ) | (cimag( c ) < 0 ? "" : "+") | cimag( c ) | 'i';
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long double _Complex c ) {
+        return os | creall( c ) | (cimagl( c ) < 0 ? "" : "+") | cimagl( c ) | 'i';
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%.*lg", DBL_DIG, d );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long double ld ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%.*Lg", LDBL_DIG, ld );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, float _Complex fc ) {
+        os | crealf( fc );
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagf( fc ) >= 0 ) os | '+';                                      // negative value prints '-'
+        os | cimagf( fc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, double _Complex dc ) {
+        os | creal( dc );
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimag( dc ) >= 0 ) os | '+';                                       // negative value prints '-'
+        os | cimag( dc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long double _Complex ldc ) {
+        os | creall( ldc );
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagl( ldc ) >= 0 ) os | '+';                                     // negative value prints '-'
+        os | cimagl( ldc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, const char *cp ) {
+        enum { Open = 1, Close, OpenClose };
+        static const unsigned char mask[256] = {
+                // opening delimiters
+                ['('] : Open, ['['] : Open, ['{'] : Open,
+                ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
+                // closing delimiters
+                [','] : Close, ['.'] : Close, [':'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
+                [')'] : Close, [']'] : Close, ['}'] : Close,
+                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
+                // opening-closing delimiters
+                ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
+                ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
+        }; // mask
+        int len = strlen( cp );
+        // null string => no separator
+  if ( len == 0 ) { sepOff( os ); return os; }
+        // first character IS NOT spacing or closing punctuation => add left separator
+        unsigned char ch = cp[0];                                                       // must make unsigned
+        if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
+                prtfmt( os, "%s", sepGet( os ) );
+        } // if
+        // last character IS spacing or opening punctuation => turn off separator for next item
+        unsigned int posn = len - 1;
+        ch = cp[posn];                                                                          // must make unsigned
+        if ( mask[ ch ] == Open || mask[ ch ] == OpenClose ) {
+                sepOff( os );
+        } else {
+                sepOn( os );
+        } // if
+        return write( os, cp, len );
 } // ?|?
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, const void *p ) {
+        char buffer[32];
+        return write( os, buffer, sprintf( buffer, "%p", p ) );
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, const char *cp ) {
+        return write( os, cp, strlen( cp ) );
+} // ?|?
+forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) )
+retostype * ?|?( ostype *os, retostype * (*manip)(ostype*) ) {
+  return manip( os );
+}
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%p", p );
+        return os;
+} // ?|?
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, ostype * (* manip)( ostype * ) ) {
+        return manip( os );
+} // ?|?
 forall( dtype ostype | ostream( ostype ) )
 ostype * endl( ostype * os ) {
         os | "\n";
+        os | '\n';
         flush( os );
+        sepOff( os );
         return os;
 } // endl
+forall( dtype ostype | ostream( ostype ) )
+ostype * sepOn( ostype * os ) {
+        sepOn( os );
+        return os;
+} // sepOn
+forall( dtype ostype | ostream( ostype ) )
+ostype * sepOff( ostype * os ) {
+        sepOff( os );
+        return os;
+} // sepOff
+forall( dtype ostype | ostream( ostype ) )
+ostype * sepEnable( ostype * os ) {
+        sepEnable( os );
+        return os;
+} // sepEnable
+forall( dtype ostype | ostream( ostype ) )
+ostype * sepDisable( ostype * os ) {
+        sepDisable( os );
+        return os;
+} // sepDisable
 //---------------------------------------
+forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
+                dtype os_type | ostream( os_type ) )
+void write( iterator_type begin, iterator_type end, os_type *os ) {
+        void print( elt_type i ) { os | i | ' '; }
+forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
+void write( iteratortype begin, iteratortype end, ostype *os ) {
+        void print( elttype i ) { os | i; }
         for_each( begin, end, print );
 } // ?|?
+forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
+                dtype os_type | ostream( os_type ) )
+void write_reverse( iterator_type begin, iterator_type end, os_type *os ) {
+        void print( elt_type i ) { os | i | ' '; }
+forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
+void write_reverse( iteratortype begin, iteratortype end, ostype *os ) {
+        void print( elttype i ) { os | i; }
         for_each_reverse( begin, end, print );
 } // ?|?
 …
 forall( dtype istype | istream( istype ) )
+istype * ?|?( istype *is, char *cp ) {
+        return read( is, cp, 1 );
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype *is, int *ip ) {
+        return get( is, ip );
+} // ?|?
+istype * ?|?( istype * is, char * c ) {
+        scanfmt( is, "%c", c );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, short int * si ) {
+        scanfmt( is, "%hd", si );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned short int * usi ) {
+        scanfmt( is, "%hu", usi );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, int * i ) {
+        scanfmt( is, "%d", i );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned int * ui ) {
+        scanfmt( is, "%u", ui );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long int * li ) {
+        scanfmt( is, "%ld", li );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned long int * ulli ) {
+        scanfmt( is, "%lu", ulli );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long long int * lli ) {
+        scanfmt( is, "%lld", lli );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned long long int * ulli ) {
+        scanfmt( is, "%llu", ulli );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, float * f ) {
+        scanfmt( is, "%f", f );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, double * d ) {
+        scanfmt( is, "%lf", d );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long double * ld ) {
+        scanfmt( is, "%Lf", ld );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, float _Complex * fc ) {
+        float re, im;
+        scanfmt( is, "%g%gi", &re, &im );
+        *fc = re + im * _Complex_I;
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, double _Complex * dc ) {
+        double re, im;
+        scanfmt( is, "%lf%lfi", &re, &im );
+        *dc = re + im * _Complex_I;
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long double _Complex * ldc ) {
+        long double re, im;
+        scanfmt( is, "%Lf%Lfi", &re, &im );
+        *ldc = re + im * _Complex_I;
+        return is;
+} // ?|?
+_Istream_cstrUC cstr( char * s ) { _Istream_cstrUC s = { s }; return s; }
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, _Istream_cstrUC cstr ) {
+        scanfmt( is, "%s", cstr.s );
+        return is;
+} // cstr
+_Istream_cstrC cstr( char * s, int size ) { _Istream_cstrC s = { s, size }; return s; }
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, _Istream_cstrC cstr ) {
+        char buf[16];
+        sprintf( buf, "%%%ds", cstr.size );
+        scanfmt( is, buf, cstr.s );
+        return is;
+} // cstr
 // Local Variables: //

src/libcfa/iterator

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jan 27 23:49:13 2016
 // Update Count     : 7
+// Last Modified On : Wed Mar  2 18:06:05 2016
+// Update Count     : 9
 //
 …
 // An iterator can be used to traverse a data structure.
 context iterator( type iterator_type, type elt_type ) {
+trait iterator( otype iterator_type, otype elt_type ) {
         // point to the next element
 //      iterator_type ?++( iterator_type * );
 …
 };
 context iterator_for( type iterator_type, type collection_type, type elt_type | iterator( iterator_type, elt_type ) ) {
+trait iterator_for( otype iterator_type, otype collection_type, otype elt_type | iterator( iterator_type, elt_type ) ) {
 //      [ iterator_type begin, iterator_type end ] get_iterators( collection_type );
         iterator_type begin( collection_type );
 …
 };
 forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each( iterator_type begin, iterator_type end, void (*func)( elt_type ) );
 forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each_reverse( iterator_type begin, iterator_type end, void (*func)( elt_type ) );

src/libcfa/iterator.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jan 26 17:16:07 2016
 // Update Count     : 26
+// Last Modified On : Wed Mar  2 18:08:11 2016
+// Update Count     : 27
 //
 #include "iterator"
 forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each( iterator_type begin, iterator_type end, void (*func)( elt_type ) ) {
         for ( iterator_type i = begin; i != end; ++i ) {
 …
+}
 forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each_reverse( iterator_type begin, iterator_type end, void (*func)( elt_type ) ) {
         for ( iterator_type i = end; i != begin; ) {

src/libcfa/limits

-              rc5833e8
+              r0f9e4403
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// limits --
+//
+// Author           : Peter A. Buhr
+// Created On       : Wed Apr  6 18:06:52 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Apr  6 21:08:16 2016
+// Update Count     : 6
+//
 // Integral Constants
 const short int MIN = -32768;
 const int MIN = -2147483648;
 const long int MIN = -9223372036854775807L - 1L;
 const long long int MIN = -9223372036854775807LL - 1LL;
+extern const short int MIN;
+extern const int MIN;
+extern const long int MIN;
+extern const long long int MIN;
 const short int MAX = 32767;
 const unsigned short int MAX = 65535;
 const int MAX = 2147483647;
 const unsigned int MAX = 4294967295_U;
 const long int MAX = 9223372036854775807_L;
 const unsigned long int MAX = 4294967295_U;
 const long long int MAX = 9223372036854775807_LL;
 const unsigned long long int MAX = 18446744073709551615_ULL;
+extern const short int MAX;
+extern const unsigned short int MAX;
+extern const int MAX;
+extern const unsigned int MAX;
+extern const long int MAX;
+extern const unsigned long int MAX;
+extern const long long int MAX;
+extern const unsigned long long int MAX;
 // Floating-Point Constants
 const float PI = 3.141592_F;                            // pi
 const float PI_2 = 1.570796_F;                          // pi / 2
 const float PI_4 = 0.7853981_F;                         // pi / 4
 const float _1_PI = 0.3183098_F;                        // 1 / pi
 const float _2_PI = 0.6366197_F;                        // 2 / pi
 const float _2_SQRT_PI = 1.128379_F;                    // 2 / sqrt(pi)
+extern const float PI;                                                                  // pi
+extern const float PI_2;                                                                // pi / 2
+extern const float PI_4;                                                                // pi / 4
+extern const float _1_PI;                                                               // 1 / pi
+extern const float _2_PI;                                                               // 2 / pi
+extern const float _2_SQRT_PI;                                                  // 2 / sqrt(pi)
 const double PI = 3.14159265358979323846_D;             // pi
 const double PI_2 = 1.57079632679489661923_D;           // pi / 2
 const double PI_4 = 0.78539816339744830962_D;           // pi / 4
 const double _1_PI = 0.31830988618379067154_D;          // 1 / pi
 const double _2_PI = 0.63661977236758134308_D;          // 2 / pi
 const double _2_SQRT_PI = 1.12837916709551257390_D;     // 2 / sqrt(pi)
+extern const double PI;                                                                 // pi
+extern const double PI_2;                                                               // pi / 2
+extern const double PI_4;                                                               // pi / 4
+extern const double _1_PI;                                                              // 1 / pi
+extern const double _2_PI;                                                              // 2 / pi
+extern const double _2_SQRT_PI;                                                 // 2 / sqrt(pi)
 const long double PI = 3.1415926535897932384626433832795029_DL; // pi
 const long double PI_2 = 1.5707963267948966192313216916397514_DL; // pi / 2
 const long double PI_4 = 0.7853981633974483096156608458198757_DL; // pi / 4
 const long double _1_PI = 0.3183098861837906715377675267450287_DL; // 1 / pi
 const long double _2_PI = 0.6366197723675813430755350534900574_DL; // 2 / pi
 const long double _2_SQRT_PI = 1.1283791670955125738961589031215452_DL; // 2 / sqrt(pi)
+extern const long double PI;                                                    // pi
+extern const long double PI_2;                                                  // pi / 2
+extern const long double PI_4;                                                  // pi / 4
+extern const long double _1_PI;                                                 // 1 / pi
+extern const long double _2_PI;                                                 // 2 / pi
+extern const long double _2_SQRT_PI;                                    // 2 / sqrt(pi)
 const _Complex PI = 3.14159265358979323846_D+0.0_iD;    // pi
 const _Complex PI_2 = 1.57079632679489661923_D+0.0_iD;  // pi / 2
 const _Complex PI_4 = 0.78539816339744830962_D+0.0_iD;  // pi / 4
 const _Complex _1_PI = 0.31830988618379067154_D+0.0_iD; // 1 / pi
 const _Complex _2_PI = 0.63661977236758134308_D+0.0_iD; // 2 / pi
 const _Complex _2_SQRT_PI = 1.12837916709551257390_D+0.0_iD; // 2 / sqrt(pi)
+extern const _Complex PI;                                                               // pi
+extern const _Complex PI_2;                                                             // pi / 2
+extern const _Complex PI_4;                                                             // pi / 4
+extern const _Complex _1_PI;                                                    // 1 / pi
+extern const _Complex _2_PI;                                                    // 2 / pi
+extern const _Complex _2_SQRT_PI;                                               // 2 / sqrt(pi)
 const long _Complex PI = 3.1415926535897932384626433832795029_L+0.0iL; // pi
 const long _Complex PI_2 = 1.5707963267948966192313216916397514_L+0.0iL; // pi / 2
 const long _Complex PI_4 = 0.7853981633974483096156608458198757_L+0.0iL; // pi / 4
 const long _Complex _1_PI = 0.3183098861837906715377675267450287_L+0.0iL; // 1 / pi
 const long _Complex _2_PI = 0.6366197723675813430755350534900574_L+0.0iL; // 2 / pi
 const long _Complex _2_SQRT_PI = 1.1283791670955125738961589031215452_L+0.0iL; // 2 / sqrt(pi)
+extern const long _Complex PI;                                                  // pi
+extern const long _Complex PI_2;                                                // pi / 2
+extern const long _Complex PI_4;                                                // pi / 4
+extern const long _Complex _1_PI;                                               // 1 / pi
+extern const long _Complex _2_PI;                                               // 2 / pi
+extern const long _Complex _2_SQRT_PI;                                  // 2 / sqrt(pi)
 const float E = 2.718281;                               // e
 const float LOG2_E = 1.442695;                          // log_2(e)
 const float LOG10_E = 0.4342944;                        // log_10(e)
 const float LN_2 = 0.6931471;                           // log_e(2)
 const float LN_10 = 2.302585;                           // log_e(10)
 const float SQRT_2 = 1.414213;                          // sqrt(2)
 const float _1_SQRT_2 = 0.7071067;                      // 1 / sqrt(2)
+extern const float E;                                                                   // e
+extern const float LOG2_E;                                                              // log_2(e)
+extern const float LOG10_E;                                                             // log_10(e)
+extern const float LN_2;                                                                // log_e(2)
+extern const float LN_10;                                                               // log_e(10)
+extern const float SQRT_2;                                                              // sqrt(2)
+extern const float _1_SQRT_2;                                                   // 1 / sqrt(2)
 const double E = 2.7182818284590452354_D;               // e
 const double LOG2_E = 1.4426950408889634074_D;          // log_2(e)
 const double LOG10_E = 0.43429448190325182765_D;        // log_10(e)
 const double LN_2 = 0.69314718055994530942_D;           // log_e(2)
 const double LN_10 = 2.30258509299404568402_D;          // log_e(10)
 const double SQRT_2 = 1.41421356237309504880_D;         // sqrt(2)
 const double _1_SQRT_2 = 0.70710678118654752440_D;      // 1 / sqrt(2)
+extern const double E;                                                                  // e
+extern const double LOG2_E;                                                             // log_2(e)
+extern const double LOG10_E;                                                    // log_10(e)
+extern const double LN_2;                                                               // log_e(2)
+extern const double LN_10;                                                              // log_e(10)
+extern const double SQRT_2;                                                             // sqrt(2)
+extern const double _1_SQRT_2;                                                  // 1 / sqrt(2)
 const long double E = 2.7182818284590452353602874713526625_DL; // e
 const long double LOG2_E = 1.4426950408889634073599246810018921_DL; // log_2(e)
 const long double LOG10_E = 0.4342944819032518276511289189166051_DL; // log_10(e)
 const long double LN_2 = 0.6931471805599453094172321214581766_DL; // log_e(2)
 const long double LN_10 = 2.3025850929940456840179914546843642_DL; // log_e(10)
 const long double SQRT_2 = 1.4142135623730950488016887242096981_DL; // sqrt(2)
 const long double _1_SQRT_2 = 0.7071067811865475244008443621048490_DL; // 1/sqrt(2)
+extern const long double E;                                                             // e
+extern const long double LOG2_E;                                                // log_2(e)
+extern const long double LOG10_E;                                               // log_10(e)
+extern const long double LN_2;                                                  // log_e(2)
+extern const long double LN_10;                                                 // log_e(10)
+extern const long double SQRT_2;                                                // sqrt(2)
+extern const long double _1_SQRT_2;                                             // 1/sqrt(2)
 const _Complex E = 2.7182818284590452354_D+0.0_iD;      // e
 const _Complex LOG2_E = 1.4426950408889634074_D+0.0_iD; // log_2(e)
 const _Complex LOG10_E = 0.43429448190325182765_D+0.0_iD; // log_10(e)
 const _Complex LN_2 = 0.69314718055994530942_D+0.0_iD;  // log_e(2)
 const _Complex LN_10 = 2.30258509299404568402_D+0.0_iD; // log_e(10)
 const _Complex SQRT_2 = 1.41421356237309504880_D+0.0_iD;        // sqrt(2)
 const _Complex _1_SQRT_2 = 0.70710678118654752440_D+0.0_iD; // 1 / sqrt(2)
+extern const _Complex E;                                                                // e
+extern const _Complex LOG2_E;                                                   // log_2(e)
+extern const _Complex LOG10_E;                                                  // log_10(e)
+extern const _Complex LN_2;                                                             // log_e(2)
+extern const _Complex LN_10;                                                    // log_e(10)
+extern const _Complex SQRT_2;                                                   // sqrt(2)
+extern const _Complex _1_SQRT_2;                                                // 1 / sqrt(2)
+const long _Complex E = 2.7182818284590452353602874713526625_L+0.0_iL; // e
+const long _Complex LOG2_E = 1.4426950408889634073599246810018921_L+0.0_iL; // log_2(e)
+const long _Complex LOG10_E = 0.4342944819032518276511289189166051_L+0.0_iL; // log_10(e)
+const long _Complex LN_2 = 0.6931471805599453094172321214581766_L+0.0_iL; // log_e(2)
+const long _Complex LN_10 = 2.3025850929940456840179914546843642_L+0.0_iL; // log_e(10)
+const long _Complex SQRT_2 = 1.4142135623730950488016887242096981_L+0.0_iL; // sqrt(2)
+const long _Complex _1_SQRT_2 = 0.7071067811865475244008443621048490_L+0.0_iL; // 1 / sqrt(2)
+extern const long _Complex E;                                                   // e
+extern const long _Complex LOG2_E;                                              // log_2(e)
+extern const long _Complex LOG10_E;                                             // log_10(e)
+extern const long _Complex LN_2;                                                // log_e(2)
+extern const long _Complex LN_10;                                               // log_e(10)
+extern const long _Complex SQRT_2;                                              // sqrt(2)
+extern const long _Complex _1_SQRT_2;                                   // 1 / sqrt(2)
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //

src/libcfa/prelude.cf

-              rc5833e8
+              r0f9e4403
+# 2 "prelude.cf"  // needed for error messages from this file
 //                               -*- Mode: C -*-
 //
 …
 // Created On       : Sat Nov 29 07:23:41 2014
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan  4 11:13:26 2016
 // Update Count     : 81
+// Last Modified On : Wed Mar  2 18:03:41 2016
+// Update Count     : 89
 //
 …
 long double _Complex    ?--( long double _Complex * ),          ?--( volatile long double _Complex * );
 forall( type T ) T *                     ?++(                T ** );
 forall( type T ) const T *               ?++( const          T ** );
 forall( type T ) volatile T *            ?++(       volatile T ** );
 forall( type T ) const volatile T *      ?++( const volatile T ** );
 forall( type T ) T *                     ?--(                T ** );
 forall( type T ) const T *               ?--( const          T ** );
 forall( type T ) volatile T *            ?--(       volatile T ** );
 forall( type T ) const volatile T *      ?--( const volatile T ** );
 forall( type T ) lvalue T                ?[?](                T *,          ptrdiff_t );
 forall( type T ) const lvalue T          ?[?]( const          T *,          ptrdiff_t );
 forall( type T ) volatile lvalue T       ?[?](       volatile T *,          ptrdiff_t );
 forall( type T ) const volatile lvalue T ?[?]( const volatile T *,          ptrdiff_t );
 forall( type T ) lvalue T                ?[?](          ptrdiff_t,                T * );
 forall( type T ) const lvalue T          ?[?](          ptrdiff_t, const          T * );
 forall( type T ) volatile lvalue T       ?[?](          ptrdiff_t,       volatile T * );
 forall( type T ) const volatile lvalue T ?[?](          ptrdiff_t, const volatile T * );
+forall( otype T ) T *                    ?++(                T ** );
+forall( otype T ) const T *              ?++( const          T ** );
+forall( otype T ) volatile T *           ?++(       volatile T ** );
+forall( otype T ) const volatile T *     ?++( const volatile T ** );
+forall( otype T ) T *                    ?--(                T ** );
+forall( otype T ) const T *              ?--( const          T ** );
+forall( otype T ) volatile T *           ?--(       volatile T ** );
+forall( otype T ) const volatile T *     ?--( const volatile T ** );
+forall( otype T ) lvalue T               ?[?](                T *,          ptrdiff_t );
+forall( otype T ) const lvalue T         ?[?]( const          T *,          ptrdiff_t );
+forall( otype T ) volatile lvalue T      ?[?](       volatile T *,          ptrdiff_t );
+forall( otype T ) const volatile lvalue T ?[?]( const volatile T *,         ptrdiff_t );
+forall( otype T ) lvalue T               ?[?](          ptrdiff_t,                T * );
+forall( otype T ) const lvalue T         ?[?](          ptrdiff_t, const          T * );
+forall( otype T ) volatile lvalue T      ?[?](          ptrdiff_t,       volatile T * );
+forall( otype T ) const volatile lvalue T ?[?](         ptrdiff_t, const volatile T * );
 // ------------------------------------------------------------
 …
 long double _Complex    ++?( long double _Complex * ),          --?( long double _Complex * );
 forall( type T ) T *                     ++?(                T ** );
 forall( type T ) const T *               ++?( const          T ** );
 forall( type T ) volatile T *            ++?(       volatile T ** );
 forall( type T ) const volatile T *      ++?( const volatile T ** );
 forall( type T ) T *                     --?(                T ** );
 forall( type T ) const T *               --?( const          T ** );
 forall( type T ) volatile T *            --?(       volatile T ** );
 forall( type T ) const volatile T *      --?( const volatile T ** );
 forall( type T ) lvalue T                *?(                 T * );
 forall( type T ) const lvalue T          *?( const           T * );
 forall( type T ) volatile lvalue T       *?(       volatile  T * );
 forall( type T ) const volatile lvalue T *?( const volatile  T * );
+forall( otype T ) T *                    ++?(                T ** );
+forall( otype T ) const T *              ++?( const          T ** );
+forall( otype T ) volatile T *           ++?(       volatile T ** );
+forall( otype T ) const volatile T *     ++?( const volatile T ** );
+forall( otype T ) T *                    --?(                T ** );
+forall( otype T ) const T *              --?( const          T ** );
+forall( otype T ) volatile T *           --?(       volatile T ** );
+forall( otype T ) const volatile T *     --?( const volatile T ** );
+forall( otype T ) lvalue T               *?(                 T * );
+forall( otype T ) const lvalue T                 *?( const           T * );
+forall( otype T ) volatile lvalue T      *?(       volatile  T * );
+forall( otype T ) const volatile lvalue T *?( const volatile  T * );
 forall( ftype FT ) lvalue FT             *?( FT * );
 …
 long double _Complex    ?+?( long double _Complex, long double _Complex ),      ?-?( long double _Complex, long double _Complex );
 forall( type T ) T *                    ?+?(                T *,          ptrdiff_t );
 forall( type T ) T *                    ?+?(          ptrdiff_t,                T * );
 forall( type T ) const T *              ?+?( const          T *,          ptrdiff_t );
 forall( type T ) const T *              ?+?(          ptrdiff_t, const          T * );
 forall( type T ) volatile T *           ?+?(       volatile T *,          ptrdiff_t );
 forall( type T ) volatile T *           ?+?(          ptrdiff_t,       volatile T * );
 forall( type T ) const volatile T *     ?+?( const volatile T *,          ptrdiff_t );
 forall( type T ) const volatile T *     ?+?(          ptrdiff_t, const volatile T * );
 forall( type T ) T *                    ?-?(                T *,          ptrdiff_t );
 forall( type T ) const T *              ?-?( const          T *,          ptrdiff_t );
 forall( type T ) volatile T *           ?-?(       volatile T *,          ptrdiff_t );
 forall( type T ) const volatile T *     ?-?( const volatile T *,          ptrdiff_t );
 forall( type T ) ptrdiff_t              ?-?( const volatile T *, const volatile T * );
+forall( otype T ) T *                   ?+?(                T *,          ptrdiff_t );
+forall( otype T ) T *                   ?+?(          ptrdiff_t,                T * );
+forall( otype T ) const T *             ?+?( const          T *,          ptrdiff_t );
+forall( otype T ) const T *             ?+?(          ptrdiff_t, const          T * );
+forall( otype T ) volatile T *          ?+?(       volatile T *,          ptrdiff_t );
+forall( otype T ) volatile T *          ?+?(          ptrdiff_t,       volatile T * );
+forall( otype T ) const volatile T *    ?+?( const volatile T *,          ptrdiff_t );
+forall( otype T ) const volatile T *    ?+?(          ptrdiff_t, const volatile T * );
+forall( otype T ) T *                   ?-?(                T *,          ptrdiff_t );
+forall( otype T ) const T *             ?-?( const          T *,          ptrdiff_t );
+forall( otype T ) volatile T *          ?-?(       volatile T *,          ptrdiff_t );
+forall( otype T ) const volatile T *    ?-?( const volatile T *,          ptrdiff_t );
+forall( otype T ) ptrdiff_t             ?-?( const volatile T *, const volatile T * );
 // ------------------------------------------------------------
 …
 forall( ftype FT ) FT *                 ?=?( FT * volatile *, forall( ftype FT2 ) FT2 * );
 forall( type T ) T *                    ?+=?(                T *          *, ptrdiff_t );
 forall( type T ) T *                    ?+=?(                T * volatile *, ptrdiff_t );
 forall( type T ) const T *              ?+=?( const          T *          *, ptrdiff_t );
 forall( type T ) const T *              ?+=?( const          T * volatile *, ptrdiff_t );
 forall( type T ) volatile T *           ?+=?(       volatile T *          *, ptrdiff_t );
 forall( type T ) volatile T *           ?+=?(       volatile T * volatile *, ptrdiff_t );
 forall( type T ) const volatile T *     ?+=?( const volatile T *          *, ptrdiff_t );
 forall( type T ) const volatile T *     ?+=?( const volatile T * volatile *, ptrdiff_t );
 forall( type T ) T *                    ?-=?(                T *          *, ptrdiff_t );
 forall( type T ) T *                    ?-=?(                T * volatile *, ptrdiff_t );
 forall( type T ) const T *              ?-=?( const          T *          *, ptrdiff_t );
 forall( type T ) const T *              ?-=?( const          T * volatile *, ptrdiff_t );
 forall( type T ) volatile T *           ?-=?(       volatile T *          *, ptrdiff_t );
 forall( type T ) volatile T *           ?-=?(       volatile T * volatile *, ptrdiff_t );
 forall( type T ) const volatile T *     ?-=?( const volatile T *          *, ptrdiff_t );
 forall( type T ) const volatile T *     ?-=?( const volatile T * volatile *, ptrdiff_t );
+forall( otype T ) T *                   ?+=?(                T *          *, ptrdiff_t );
+forall( otype T ) T *                   ?+=?(                T * volatile *, ptrdiff_t );
+forall( otype T ) const T *             ?+=?( const          T *          *, ptrdiff_t );
+forall( otype T ) const T *             ?+=?( const          T * volatile *, ptrdiff_t );
+forall( otype T ) volatile T *          ?+=?(       volatile T *          *, ptrdiff_t );
+forall( otype T ) volatile T *          ?+=?(       volatile T * volatile *, ptrdiff_t );
+forall( otype T ) const volatile T *    ?+=?( const volatile T *          *, ptrdiff_t );
+forall( otype T ) const volatile T *    ?+=?( const volatile T * volatile *, ptrdiff_t );
+forall( otype T ) T *                   ?-=?(                T *          *, ptrdiff_t );
+forall( otype T ) T *                   ?-=?(                T * volatile *, ptrdiff_t );
+forall( otype T ) const T *             ?-=?( const          T *          *, ptrdiff_t );
+forall( otype T ) const T *             ?-=?( const          T * volatile *, ptrdiff_t );
+forall( otype T ) volatile T *          ?-=?(       volatile T *          *, ptrdiff_t );
+forall( otype T ) volatile T *          ?-=?(       volatile T * volatile *, ptrdiff_t );
+forall( otype T ) const volatile T *    ?-=?( const volatile T *          *, ptrdiff_t );
+forall( otype T ) const volatile T *    ?-=?( const volatile T * volatile *, ptrdiff_t );
 _Bool                   ?=?( _Bool *, _Bool ),                                  ?=?( volatile _Bool *, _Bool );

src/libcfa/stdlib

-              rc5833e8
+              r0f9e4403
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb  5 15:21:18 2016
 // Update Count     : 61
+// Last Modified On : Wed Apr 13 14:45:53 2016
+// Update Count     : 85
 //
 …
 } // extern "C"
+forall( type T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
+forall( type T ) T * memset( T * ptr );                                 // remove when default value available
+//---------------------------------------
+forall( type T ) T * malloc( void );
+forall( type T ) T * malloc( char fill );
+forall( type T ) T * malloc( size_t size );
+forall( type T ) T * malloc( T * ptr, size_t size );
+forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill );
+forall( type T ) T * calloc( size_t size );
+forall( type T ) T * realloc( T * ptr, size_t size );
+forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill );
+extern "C" {
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE    1                                                               // failing exit status
+#define EXIT_SUCCESS    0                                                               // successful exit status
+#endif // ! EXIT_FAILURE
+void exit( int rc );
+} // extern "C"
+forall( type T ) T * aligned_alloc( size_t alignment );
+forall( type T ) T * memalign( size_t alignment );              // deprecated
+forall( type T ) int posix_memalign( T ** ptr, size_t alignment );
+//---------------------------------------
+extern "C" {
+void * malloc( size_t );                                                                // use default C routine for void *
+} // extern "C"
+forall( otype T ) T * malloc( void );
+forall( otype T ) T * malloc( char fill );
+forall( otype T ) T * malloc( T * ptr, size_t size );
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
+extern "C" {
+void * calloc( size_t nmemb, size_t size );                             // use default C routine for void *
+} // extern "C"
+forall( otype T ) T * calloc( size_t nmemb );
+extern "C" {
+void * realloc( void * ptr, size_t size );                              // use default C routine for void *
+} // extern "C"
+forall( otype T ) T * realloc( T * ptr, size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * aligned_alloc( size_t alignment );
+forall( otype T ) T * memalign( size_t alignment );             // deprecated
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
+forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
+forall( otype T ) T * memset( T * ptr );                                // remove when default value available
 //---------------------------------------
 …
 //---------------------------------------
 forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( const T key, const T * arr, size_t dimension );
 forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension );
 //---------------------------------------
 forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
+forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T t1, T t2 );
 …
 char abs( char );
 extern "C" {
 int abs( int );         // use default C routine for int
 } // extern
+int abs( int );                                                                                 // use default C routine for int
+} // extern "C"
 long int abs( long int );
 long long int abs( long long int );
 …
 //---------------------------------------
 void randseed( long int s );
+char random();
+int random();
+unsigned int random();
 long int random();
+unsigned long int random();
 float random();
+double random();
+float _Complex random();
+double _Complex random();
 long double _Complex random();
+float floor( float );
+extern "C" {
+double floor( double );                                                                 // use C routine for double
+} // extern "C"
+long double floor( long double );
+float ceil( float );
+extern "C" {
+double ceil( double );                                                                  // use C routine for double
+} // extern "C"
+long double ceil( long double );
 //---------------------------------------
+forall( type T | { int ?<?( T, T ); } )
+void rand48seed( long int s );
+char rand48();
+int rand48();
+unsigned int rand48();
+long int rand48();
+unsigned long int rand48();
+float rand48();
+double rand48();
+float _Complex rand48();
+double _Complex rand48();
+long double _Complex rand48();
+//---------------------------------------
+forall( otype T | { int ?<?( T, T ); } )
 T min( const T t1, const T t2 );
 forall( type T | { int ?>?( T, T ); } )
+forall( otype T | { int ?>?( T, T ); } )
 T max( const T t1, const T t2 );
 forall( type T )
+forall( otype T )
 void swap( T * t1, T * t2 );

src/libcfa/stdlib.c

-              rc5833e8
+              r0f9e4403
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 10 15:45:56 2016
 // Update Count     : 140
+// Last Modified On : Wed Apr 13 14:49:58 2016
+// Update Count     : 155
 //
 …
 } // extern "C"
+forall( type T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
+        printf( "memset1\n" );
+    return (T *)memset( ptr, (int)fill, malloc_usable_size( ptr ) );
+} // memset
+forall( type T ) T * memset( T * ptr ) {                                // remove when default value available
+        printf( "memset2\n" );
+    return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
+} // memset
+forall( type T ) T * malloc( void ) {
+        printf( "malloc1\n" );
+forall( otype T ) T * malloc( void ) {
+        //printf( "malloc1\n" );
     return (T *)malloc( sizeof(T) );
 } // malloc
+forall( type T ) T * malloc( size_t size ) {
+        printf( "malloc2\n" );
+    return (T *)(void *)malloc( size );
+} // malloc
+forall( type T ) T * malloc( char fill ) {
+        printf( "malloc3\n" );
+forall( otype T ) T * malloc( char fill ) {
+        //printf( "malloc3\n" );
         T * ptr = (T *)malloc( sizeof(T) );
     return memset( ptr );
 } // malloc
 forall( type T ) T * calloc( size_t size ) {
         printf( "calloc\n" );
     return (T *)calloc( size, sizeof(T) );
+forall( otype T ) T * calloc( size_t nmemb ) {
+        //printf( "calloc\n" );
+    return (T *)calloc( nmemb, sizeof(T) );
 } // calloc
 forall( type T ) T * realloc( T * ptr, size_t size ) {
         printf( "realloc1\n" );
+forall( otype T ) T * realloc( T * ptr, size_t size ) {
+        //printf( "realloc1\n" );
     return (T *)(void *)realloc( (void *)ptr, size );
 } // realloc
 forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
         printf( "realloc2\n" );
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
+        //printf( "realloc2\n" );
     char * nptr = (T *)(void *)realloc( (void *)ptr, size );
     size_t unused = malloc_usable_size( nptr );
 …
 } // realloc
 forall( type T ) T * malloc( T * ptr, size_t size ) {
         printf( "malloc4\n" );
+forall( otype T ) T * malloc( T * ptr, size_t size ) {
+        //printf( "malloc4\n" );
     return (T *)realloc( ptr, size );
 } // malloc
 forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
         printf( "malloc5\n" );
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
+        //printf( "malloc5\n" );
     return (T *)realloc( ptr, size, fill );
 } // malloc
 forall( type T ) T * aligned_alloc( size_t alignment ) {
         printf( "aligned_alloc\n" );
+forall( otype T ) T * aligned_alloc( size_t alignment ) {
+        //printf( "aligned_alloc\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // aligned_alloc
 forall( type T ) T * memalign( size_t alignment ) {
         printf( "memalign\n" );
+forall( otype T ) T * memalign( size_t alignment ) {
+        //printf( "memalign\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // memalign
 forall( type T ) int posix_memalign( T ** ptr, size_t alignment ) {
         printf( "posix_memalign\n" );
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
+        //printf( "posix_memalign\n" );
     return posix_memalign( (void **)ptr, alignment, sizeof(T) );
 } // posix_memalign
+forall( otype T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
+        //printf( "memset1\n" );
+    return (T *)memset( ptr, (int)fill, malloc_usable_size( ptr ) );
+} // memset
+forall( otype T ) T * memset( T * ptr ) {                               // remove when default value available
+        //printf( "memset2\n" );
+    return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
+} // memset
 //---------------------------------------
 …
         return ulli;
+}
 float ato( const char * ptr ) {
         float f;
 …
         return ld;
+}
 float _Complex ato( const char * ptr ) {
         float re, im;
 …
         return strtoull( sptr, eptr, base );
+}
 float strto( const char * sptr, char ** eptr ) {
         return strtof( sptr, eptr );
 …
         return strtold( sptr, eptr );
+}
 float _Complex strto( const char * sptr, char ** eptr ) {
         float re, im;
 …
 //---------------------------------------
 forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( const T key, const T * arr, size_t dimension ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
 …
 } // bsearch
 forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
 …
 //---------------------------------------
 forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
+forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
 …
 //---------------------------------------
+void randseed( long int s ) { srand48( s ); }
+char random() { return lrand48(); }
+int random() { return mrand48(); }
+unsigned int random() { return lrand48(); }
+long int random() { return mrand48(); }
+unsigned long int random() { return lrand48(); }
+float random() { return (float)drand48(); }                             // otherwise float uses lrand48
+double random() { return drand48(); }
+float _Complex random() { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
+double _Complex random() { return drand48() + (double _Complex)(drand48() * _Complex_I); }
+long double _Complex random() { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
+//---------------------------------------
+forall( type T | { int ?<?( T, T ); } )
+float floor( float v ) { return floorf( v ); }
+long double floor( long double v ) { return floorl( v ); }
+float ceil( float v ) { return ceilf( v ); }
+long double ceil( long double v ) { return ceill( v ); }
+//---------------------------------------
+void rand48seed( long int s ) { srand48( s ); }
+char rand48() { return mrand48(); }
+int rand48() { return mrand48(); }
+unsigned int rand48() { return lrand48(); }
+long int rand48() { return mrand48(); }
+unsigned long int rand48() { return lrand48(); }
+float rand48() { return (float)drand48(); }                             // otherwise float uses lrand48
+double rand48() { return drand48(); }
+float _Complex rand48() { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
+double _Complex rand48() { return drand48() + (double _Complex)(drand48() * _Complex_I); }
+long double _Complex rand48() { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
+//---------------------------------------
+forall( otype T | { int ?<?( T, T ); } )
 T min( const T t1, const T t2 ) {
         return t1 < t2 ? t1 : t2;
 } // min
 forall( type T | { int ?>?( T, T ); } )
+forall( otype T | { int ?>?( T, T ); } )
 T max( const T t1, const T t2 ) {
         return t1 > t2 ? t1 : t2;
 } // max
 forall( type T )
+forall( otype T )
 void swap( T * t1, T * t2 ) {
         T temp = *t1;

Context Navigation

Legend:

Download in other formats: