Changeset 04273e9


Ignore:
Timestamp:
Aug 8, 2016, 5:29:03 PM (9 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
03da511
Parents:
0853178 (diff), 7bf7fb9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into ctor

Conflicts:

src/SymTab/Autogen.cc

Files:
2 added
21 edited

Legend:

Unmodified
Added
Removed

  • doc/aaron_comp_II/comp_II.tex

    r0853178 r04273e9  
    8484\section{Introduction}
    8585
    86 \CFA\footnote{Pronounced ``C-for-all'', and written \CFA, CFA, or \CFL.} is an evolutionary modernization of the C programming language currently being designed and built at the University of Waterloo by a team led by Peter Buhr.
    87 \CFA adds multiple features to C, including name overloading, user-defined operators, parametric-polymorphic routines, and type constructors and destructors, among others.
    88 These features make \CFA significantly more powerful and expressive than C, but impose a significant compile-time cost to support, particularly in the expression resolver, which must evaluate the typing rules of a much more complex type system.
    89 The primary goal of this proposed research project is to develop a sufficiently performant expression resolution algorithm, experimentally validate its performance, and integrate it into \Index*{CFA-CC}, the \CFA reference compiler.
    90 Secondary goals of this project include the development of various new language features for \CFA; parametric-polymorphic (``generic'') types have already been designed and implemented, and reference types and user-defined conversions are under design consideration.
    91 The experimental performance-testing architecture for resolution algorithms will also be used to determine the compile-time cost of adding such new features to the \CFA type system.
    92 More broadly, this research should provide valuable data for implementers of compilers for other programming languages with similarly powerful static type systems.
     86\CFA\footnote{Pronounced ``C-for-all'', and written \CFA or \CFL.} is an evolutionary modernization of the C programming language currently being designed and built at the University of Waterloo by a team led by Peter Buhr.
     87\CFA both fixes existing design problems and adds multiple new features to C, including name overloading, user-defined operators, parametric-polymorphic routines, and type constructors and destructors, among others.
     88The new features make \CFA significantly more powerful and expressive than C, but impose a significant compile-time cost, particularly in the expression resolver, which must evaluate the typing rules of a much more complex type-system.
     89
     90The primary goal of this research project is to develop a sufficiently performant expression resolution algorithm, experimentally validate its performance, and integrate it into CFA, the \CFA reference compiler.
     91Secondary goals of this project include the development of various new language features for \CFA: parametric-polymorphic (``generic'') types have already been designed and implemented, and reference types and user-defined conversions are under design consideration.
     92An experimental performance-testing architecture for resolution algorithms is under development to determine the relative performance of different expression resolution algorithms, as well as the compile-time cost of adding various new features to the \CFA type-system.
     93More broadly, this research should provide valuable data for implementers of compilers for other programming languages with similarly powerful static type-systems.
    9394
    9495\section{\CFA}
    9596
    96 To make the scope of the proposed expression resolution problem more explicit, it is necessary to define the features of both C and \CFA (both current and proposed) which affect this algorithm.
    97 In some cases the interactions of multiple features make expression resolution a significantly more complex problem than any individual feature would; in others a feature which does not by itself add any complexity to expression resolution will trigger previously rare edge cases much more frequently.
     97To make the scope of the proposed expression resolution problem more explicit, it is necessary to define the features of both C and \CFA (both current and proposed) that affect this algorithm.
     98In some cases the interactions of multiple features make expression resolution a significantly more complex problem than any individual feature would; in other cases a feature that does not by itself add any complexity to expression resolution triggers previously rare edge cases more frequently.
     99
     100It is important to note that \CFA is not an object-oriented language.
     101\CFA does have a system of (possibly implicit) type conversions derived from C's type conversions; while these conversions may be thought of as something like an inheritance hierarchy the underlying semantics are significantly different and such an analogy is loose at best.
     102Particularly, \CFA has no concept of ``subclass'', and thus no need to integrate an inheritance-based form of polymorphism with its parametric and overloading-based polymorphism.
     103The graph structure of the \CFA type conversions is also markedly different than an inheritance graph; it has neither a top nor a bottom type, and does not satisfy the lattice properties typical of inheritance graphs.
    98104
    99105\subsection{Polymorphic Functions}
    … …  
    101107Such functions are written using a ©forall© clause (which gives the language its name):
    102108\begin{lstlisting}
    103 forall(otype T)
     109®forall(otype T)®
    104110T identity(T x) {
    105111    return x;
    … …  
    110116The ©identity© function above can be applied to any complete object type (or ``©otype©'').
    111117The type variable ©T© is transformed into a set of additional implicit parameters to ©identity© which encode sufficient information about ©T© to create and return a variable of that type.
    112 The current \CFA implementation passes the size and alignment of the type represented by an ©otype© parameter, as well as an assignment operator, constructor, copy constructor \& destructor.
     118The current \CFA implementation passes the size and alignment of the type represented by an ©otype© parameter, as well as an assignment operator, constructor, copy constructor and destructor.
    113119
    114120Since bare polymorphic types do not provide a great range of available operations, \CFA also provides a \emph{type assertion} mechanism to provide further information about a type:
    115121\begin{lstlisting}
    116 forall(otype T | { T twice(T); })
     122forall(otype T ®| { T twice(T); }®)
    117123T four_times(T x) {
    118124    return twice( twice(x) );
    … …  
    137143Finding appropriate functions to satisfy type assertions is essentially a recursive case of expression resolution, as it takes a name (that of the type assertion) and attempts to match it to a suitable declaration in the current scope.
    138144If a polymorphic function can be used to satisfy one of its own type assertions, this recursion may not terminate, as it is possible that function will be examined as a candidate for its own type assertion unboundedly repeatedly.
    139 To avoid infinite loops, the current \Index*{CFA-CC} compiler imposes a fixed limit on the possible depth of recursion, similar to that employed by most \Index*[C++]{\CC} compilers for template expansion; this restriction means that there are some semantically well-typed expressions which cannot be resolved by {CFA-CC}.
     145To avoid infinite loops, the current CFA compiler imposes a fixed limit on the possible depth of recursion, similar to that employed by most \CC compilers for template expansion; this restriction means that there are some semantically well-typed expressions which cannot be resolved by CFA.
    140146One area of potential improvement this project proposes to investigate is the possibility of using the compiler's knowledge of the current set of declarations to more precicely determine when further type assertion satisfaction recursion will not produce a well-typed expression.
     147
     148\subsubsection{Traits}
     149\CFA provides \emph{traits} as a means to name a group of type assertions, as in the example below:
     150\begin{lstlisting}
     151trait has_magnitude(otype T) {
     152    bool ?<?(T, T);        // comparison operator for T
     153    T -?(T);               // negation operator for T
     154    void ?{}(T*, zero_t);  // constructor from 0 literal
     155};
     156
     157forall(otype M | has_magnitude(M))
     158M abs( M m ) {
     159    M zero = 0;  // uses zero_t constructor from trait
     160    return m < zero ? -m : m;
     161}
     162
     163forall(otype M | has_magnitude(M))
     164M max_magnitude( M a, M b ) {
     165    M aa = abs(a), ab = abs(b);
     166    return aa < ab ? b : a;
     167}
     168\end{lstlisting}
     169
     170Semantically, a trait is merely a named list of type assertions, but they can be used in many of the same situations where an interface in Java or an abstract base class in \CC would be used.
     171Unlike Java interfaces or \CC base classes, \CFA types do not explicitly state any inheritance relationship to traits they satisfy; this can be considered a form of structural inheritance, similar to interface implementation in Go, as opposed to the nominal inheritance model of Java and \CC.
     172% TODO talk about modelling of nominal inheritance with structural inheritance, possibility of investigating some resolver algorithms that require nominal
    141173
    142174\subsection{Name Overloading}
    … …  
    174206Open research questions on this topic include whether a conversion graph can be generated that represents each allowable conversion in C with a unique minimal-length path, such that the path lengths accurately represent the relative costs of the conversions, whether such a graph representation can be usefully augmented to include user-defined types as well as built-in types, and whether the graph can be efficiently represented and included in the expression resolver.
    175207
    176 \subsection{Constructors \& Destructors}
     208\subsection{Constructors and Destructors}
    177209Rob Shluntz, a current member of the \CFA research team, has added constructors and destructors to \CFA.
    178210Each type has an overridable default-generated zero-argument constructor, copy constructor, assignment operator, and destructor; for struct types these functions each call their equivalents on each field of the struct.
    … …  
    180212
    181213\subsection{Generic Types}
    182 The author has added a generic type capability to \CFA, designed to efficiently and naturally integrate with \CFA's existing polymorphic functions.
     214I have already added a generic type capability to \CFA, designed to efficiently and naturally integrate with \CFA's existing polymorphic functions.
    183215A generic type can be declared by placing a ©forall© specifier on a struct or union declaration, and instantiated using a parenthesized list of types after the type name:
    184216\begin{lstlisting}
    … …  
    195227\end{lstlisting}
    196228For \emph{concrete} generic types, that is, those where none of the type parameters depend on polymorphic type variables (like ©pair(const char*, int)© above), the struct is essentially template expanded to a new struct type; for \emph{polymorphic} generic types (such as ©pair(const char*, T)© above), member access is handled by a runtime calculation of the field offset, based on the size and alignment information of the polymorphic parameter type.
    197 The default-generated constructors, destructor \& assignment operator for a generic type are polymorphic functions with the same list of type parameters as the generic type definition.
    198 
    199 Aside from giving users the ability to create more parameterized types than just the built-in pointer, array \& function types, the combination of generic types with polymorphic functions and implicit conversions makes the edge case where a polymorphic function can match its own assertions much more common, as follows:
     229The default-generated constructors, destructor and assignment operator for a generic type are polymorphic functions with the same list of type parameters as the generic type definition.
     230
     231Aside from giving users the ability to create more parameterized types than just the built-in pointer, array and function types, the combination of generic types with polymorphic functions and implicit conversions makes the edge case where a polymorphic function can match its own assertions much more common, as follows:
    200232\begin{itemize}
    201233\item Given an expression in an untyped context, such as a top-level function call with no assignment of return values, apply a polymorphic implicit conversion to the expression that can produce multiple types (the built-in conversion from ©void*© to any other pointer type is one, but not the only).
    … …  
    221253
    222254\subsection{Reference Types}
    223 The author, in collaboration with the rest of the \CFA research team, has been designing \emph{reference types} for \CFA.
     255I have been designing \emph{reference types} for \CFA, in collaboration with the rest of the \CFA research team.
    224256Given some type ©T©, a ©T&© (``reference to ©T©'') is essentially an automatically dereferenced pointer; with these semantics most of the C standard's discussions of lvalues can be expressed in terms of references instead, with the benefit of being able to express the difference between the reference and non-reference version of a type in user code.
    225257References preserve C's existing qualifier-dropping lvalue-to-rvalue conversion (\eg a ©const volatile int&© can be implicitly converted to a bare ©int©); the reference proposal also adds a rvalue-to-lvalue conversion to \CFA, implemented by storing the value in a new compiler-generated temporary and passing a reference to the temporary.
    … …  
    229261
    230262\subsection{Literal Types}
    231 Another proposal currently under consideration for the \CFA type system is assigning special types to the literal values ©0© and ©1©.%, say ©zero_t© and ©one_t©.
     263Another proposal currently under consideration for the \CFA type-system is assigning special types to the literal values ©0© and ©1©.%, say ©zero_t© and ©one_t©.
    232264Implicit conversions from these types would allow ©0© and ©1© to be considered as values of many different types, depending on context, allowing expression desugarings like ©if ( x ) {}© $\Rightarrow$ ©if ( x != 0 ) {}© to be implemented efficiently and precicely.
    233265This is a generalization of C's existing behaviour of treating ©0© as either an integer zero or a null pointer constant, and treating either of those values as boolean false.
    … …  
    248280Expression resolution is somewhat unavoidably exponential in $p$, the number of function parameters, and $d$, the depth of the expression tree, but these values are fixed by the user programmer, and generally bounded by reasonably small constants.
    249281$k$, on the other hand, is mostly dependent on the representation of types in the system and the efficiency of type assertion checking; if a candidate argument combination can be compared to a function parameter list in linear time in the length of the list (\ie $k = 1$), then the $p^{k \cdot d}$ term is linear in the input size of the source code for the expression, otherwise the resolution algorithm will exibit sub-linear performance scaling on code containing more-deeply nested expressions.
    250 The number of valid interpretations of any subexpression, $i$, is bounded by the number of types in the system, which is possibly infinite, though practical resolution algorithms for \CFA must be able to place some finite bound on $i$, possibly at the expense of type system completeness.
     282The number of valid interpretations of any subexpression, $i$, is bounded by the number of types in the system, which is possibly infinite, though practical resolution algorithms for \CFA must be able to place some finite bound on $i$, possibly at the expense of type-system completeness.
    251283
    252284The research goal of this project is to develop a performant expression resolver for \CFA; this analysis suggests two primary areas of investigation to accomplish that end.
    253 The first is efficient argument-parameter matching; Bilson\cite{Bilson03} mentions significant optimization opportunities available in the current literature to improve on the existing {CFA-CC} compiler.
     285The first is efficient argument-parameter matching; Bilson\cite{Bilson03} mentions significant optimization opportunities available in the current literature to improve on the existing CFA compiler.
    254286%TODO: look up and lit review
    255287The second, and likely more fruitful, area of investigation is heuristics and algorithmic approaches to reduce the number of argument interpretations considered in the common case; given the large ($p+1$) exponent on number of interpretations considered in the runtime analysis, even small reductions here could have a significant effect on overall resolver runtime.
    … …  
    299331Another approach would be to generate a set of possible implicit conversions for each set of interpretations of a given argument.
    300332This would have the benefit of detecting ambiguous interpretations of arguments at the level of the argument rather than its containing call, would also never find more than one interpretation of the argument with a given type, and would re-use calculation of implicit conversions between function candidates.
    301 On the other hand, this approach may unncessarily generate argument interpretations that will never match a parameter, wasting work.
     333On the other hand, this approach may unncessarily generate argument interpretations that will never match a parameter, wasting work.
     334Further, in the presence of tuple types this approach may lead to a combinatorial explosion of argument interpretations considered, unless the tuple can be considered as a sequence of elements rather than a unified whole.
    302335
    303336\subsection{Candidate Set Generation}
    304 Cormack\cite{Cormack81}, Baker\cite{Baker82} \& Bilson\cite{Bilson03} all generate the complete set of candidate argument interpretations before attempting to match the containing function call expression.
     337Cormack\cite{Cormack81}, Baker\cite{Baker82} and Bilson\cite{Bilson03} all generate the complete set of candidate argument interpretations before attempting to match the containing function call expression.
    305338However, given that the top-level expression interpretation that is ultimately chosen will be the minimal-cost valid interpretation, any consideration of non-minimal-cost interpretations is in some sense wasted work.
    306339If we assume that user programmers will generally write function calls with relatively low-cost interpretations, a possible work-saving heuristic is to generate only the lowest-cost argument interpretations first, attempt to find a valid top-level interpretation using them, and only if that fails generate the higher-cost argument interpretations.
    307340
    308341\subsubsection{Eager}
    309 Within the eager approach taken by Cormack, Baker \& Bilson, there are still variants to explore.
    310 Cormack \& Baker do not account for implict conversions, and thus do not account for the possibility of multiple valid interpretations with distinct costs; Bilson, on the other hand, sorts the list of interpretations to aid in finding minimal-cost interpretations.
     342Within the eager approach taken by Cormack, Baker and Bilson, there are still variants to explore.
     343Cormack and Baker do not account for implict conversions, and thus do not account for the possibility of multiple valid interpretations with distinct costs; Bilson, on the other hand, sorts the list of interpretations to aid in finding minimal-cost interpretations.
    311344Sorting the lists of argument or function call interpretations by cost at some point during resolution may provide useful opportunities to short-circuit expression evaluation when a minimal-cost interpretation is found, though it is not clear if this short-circuiting behaviour would justify the cost of the sort.
    312345
    … …  
    315348However, if user programmers actually use relatively few implicit conversions, then the ``on arguments'' approach to implicit conversions will generate a large number of high-cost interpretations which may never be used.
    316349The essence of the lazy approach to candidate set generation is to wrap the matching algorithm into the element generator of a lazy list type, only generating as few elements at a time as possible to ensure that the next-smallest-cost interpretation has been generated.
    317 Assuming that argument interpretations are provided to the parameter matching algorithm in sorted order, a sorted list of function call interpretations can be produced by generating combinations of arguments sorted by total cost\footnote{The author has developed a lazy $n$-way combination generation algorithm that can perform this task.}, then generating function call interpretations in the order suggested by this list.
     350Assuming that argument interpretations are provided to the parameter matching algorithm in sorted order, a sorted list of function call interpretations can be produced by generating combinations of arguments sorted by total cost\footnote{I have already developed a lazy $n$-way combination generation algorithm to perform this task.}, then generating function call interpretations in the order suggested by this list.
    318351Note that the function call interpretation chosen may have costs of its own, for instance polymorphic type binding, so in some cases a number of argument combinations (any combination whose marginal cost does not exceed the cost of the function call interpretation itself) may need to be considered to determine the next-smallest-cost function call interpretation.
    319352Ideally, this candidate generation approach will lead to very few unused candidates being generated (in the expected case where the user programmer has, in fact, provided a validly-typable program), but this research project will need to determine whether or not the overheads of lazy generation exceed the benefit produced from considering fewer interpretations.
    … …  
    333366%\subsection{Parameter-Directed}
    334367%\textbf{TODO: Richard's algorithm isn't Baker (Cormack?), disentangle from this section \ldots}.
    335 %The expression resolution algorithm used by the existing iteration of {CFA-CC} is based on Baker's\cite{Baker82} algorithm for overload resolution in Ada.
     368%The expression resolution algorithm used by the existing iteration of CFA is based on Baker's\cite{Baker82} algorithm for overload resolution in Ada.
    336369%The essential idea of this algorithm is to first find the possible interpretations of the most deeply nested subexpressions, then to use these interpretations to recursively generate valid interpretations of their superexpressions.
    337370%To simplify matters, the only expressions considered in this discussion of the algorithm are function application and literal expressions; other expression types can generally be considered to be variants of one of these for the purposes of the resolver, \eg variables are essentially zero-argument functions.
    … …  
    341374%\textbf{TODO: Figure}
    342375%
    343 %Baker's algorithm was designed to account for name overloading; Richard Bilson\cite{Bilson03} extended this algorithm to also handle polymorphic functions, implicit conversions \& multiple return types when designing the original \CFA compiler.
     376%Baker's algorithm was designed to account for name overloading; Richard Bilson\cite{Bilson03} extended this algorithm to also handle polymorphic functions, implicit conversions and multiple return types when designing the original \CFA compiler.
    344377%The core of the algorithm is a function which Baker refers to as $gen\_calls$.
    345378%$gen\_calls$ takes as arguments the name of a function $f$ and a list containing the set of possible subexpression interpretations $S_j$ for each argument of the function and returns a set of possible interpretations of calling that function on those arguments.
    … …  
    363396\section{Proposal}
    364397Baker\cite{Baker82} discussed various expression resolution algorithms that could handle name overloading, but left experimental comparison of those algorithms to future work; Bilson\cite{Bilson03} described one extension of Baker's algorithm to handle implicit conversions, but did not fully explore the space of algorithmic approaches to handle both overloaded names and implicit conversions.
    365 This project is intended to experimentally test a number of expression resolution algorithms which are powerful enough to handle the \CFA type system, including both name overloading and implicit conversions.
     398This project is intended to experimentally test a number of expression resolution algorithms which are powerful enough to handle the \CFA type-system, including both name overloading and implicit conversions.
    366399This comparison will close Baker's open research question, as well as potentially improving on Bilson's \CFA compiler.
    367400
    368 Rather than testing all of these algorithms in-place in the \CFA compiler, a resolver prototype will be developed which acts on a simplified input language encapsulating the essential details of the \CFA type system\footnote{Note that this simplified input language is not required to be a usable programming language.}.
     401Rather than testing all of these algorithms in-place in the \CFA compiler, a resolver prototype will be developed which acts on a simplified input language encapsulating the essential details of the \CFA type-system\footnote{Note that this simplified input language is not required to be a usable programming language.}.
    369402Multiple variants of this resolver prototype will be implemented, each encapsulating a different expression resolution variant, sharing as much code as feasible.
    370403These variants will be instrumented to test runtime performance, and run on a variety of input files; the input files may be generated programmatically or from exisiting code in \CFA or similar languages.
    371 These experimental results will allow the research team to determine the algorithm likely to be most performant in practical use, and replace {CFA-CC}'s existing expression resolver with that code.
     404These experimental results will allow the research team to determine the algorithm likely to be most performant in practical use, and replace CFA's existing expression resolver with that code.
    372405The experimental results will also provide some empirical sense of the compile-time cost of various language features by comparing the results of the most performant resolver variant that supports the feature with the most performant resolver variant that doesn't, a useful capability to guide language design.
    373406
    374 This proposed project should provide valuable data on how to implement a performant compiler for modern programming languages such as \CFA with powerful static type systems, specifically targeting the feature interaction between name overloading and implicit conversions.
     407This proposed project should provide valuable data on how to implement a performant compiler for modern programming languages such as \CFA with powerful static type-systems, specifically targeting the feature interaction between name overloading and implicit conversions.
    375408
    376409\appendix
    … …  
    379412\begin{center}
    380413\begin{tabular}{ | r @{--} l | p{4in} | }
    381 \hline       May 2015 & April 2016   & Project familiarization and generic types design \& implementation. \\
    382 \hline       May 2016 & April 2017   & Design \& implement resolver prototype and run performance experiments. \\
    383 \hline       May 2017 & August 2017  & Integrate new language features and best-performing resolver prototype into {CFA-CC}. \\
    384 \hline September 2017 & January 2018 & Thesis writing \& defense. \\
     414\hline       May 2015 & April 2016   & Project familiarization and generic types design and implementation. \\
     415\hline       May 2016 & April 2017   & Design and implement resolver prototype and run performance experiments. \\
     416\hline       May 2017 & August 2017  & Integrate new language features and best-performing resolver prototype into CFA. \\
     417\hline September 2017 & January 2018 & Thesis writing and defense. \\
    385418\hline
    386419\end{tabular}

  • doc/working/resolver_design.md

    r0853178 r04273e9  
    3737
    3838An alternate possibility would be to only count two-arg constructors
    39 `void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and  
     39`void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and
    4040explicit conversions should also have a compiler-enforced restriction to
    4141ensure that they are two-arg functions (this restriction may be valuable
    … …  
    6969two chains of conversions, one among the signed integral types, another among
    7070the unsigned, and to use monomorphic conversions to allow conversions between
    71 signed and unsigned integer types).   
     71signed and unsigned integer types).
    7272
    7373### Implementation Details ###
    … …  
    509509A variant of the above scheme would be to fix a maximum depth of polymorphic
    510510type variables (16 seems like a reasonable choice) at which a parameter would
    511 be considered to be effectively monomorphic, and to subtract the value  
     511be considered to be effectively monomorphic, and to subtract the value
    512512described above from that maximum, clamping the result to a minimum of 0.
    513513Under this scheme, assuming a maximum value of 4, `int` has value 0, `T` has
    … …  
    577577specifying the (completely arbitrary) maximum depth as part of the language or
    578578allowing the compiler to refuse to accept otherwise well-typed deeply-nested
    579 polymorphic types. 
     579polymorphic types.
    580580
    581581For purposes of determining polymorphism, the list of return types of a
    … …  
    951951`sizeof`, `alignof`, and `offsetof` expressions have at most a single
    952952interpretation, of type `size_t`.
    953 `sizeof` and `alignof` expressions take either a type or an expression as a 
    954 an argument; if the argument is a type, it must be a complete type which is
    955 not a function type, if an expression, the expression must have a single
     953`sizeof` and `alignof` expressions take either a type or an expression as an
     954argument; if the argument is a type, it must be a complete type which is not a
     955function type, if an expression, the expression must have a single
    956956interpretation, the type of which conforms to the same rules.
    957957`offsetof` takes two arguments, a type and a member name; the type must be
    … …  
    16201620                        = delete;
    16211621        }
     1622
     1623## Appendix E: Features to Add in Resolver Re-write ##
     1624* Reference types
     1625* Special types for 0 and 1 literals
     1626* Expression type for return statement that resolves similarly to ?=?
     1627  - This is to get rid of the kludge in the box pass that effectively
     1628    re-implements the resolver poorly.

  • src/GenPoly/Box.cc

    r0853178 r04273e9  
    6262
    6363                FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
    64 
    65                 /// Abstracts type equality for a list of parameter types
    66                 struct TypeList {
    67                         TypeList() : params() {}
    68                         TypeList( const std::list< Type* > &_params ) : params() { cloneAll(_params, params); }
    69                         TypeList( std::list< Type* > &&_params ) : params( _params ) {}
    70 
    71                         TypeList( const TypeList &that ) : params() { cloneAll(that.params, params); }
    72                         TypeList( TypeList &&that ) : params( std::move( that.params ) ) {}
    73 
    74                         /// Extracts types from a list of TypeExpr*
    75                         TypeList( const std::list< TypeExpr* >& _params ) : params() {
    76                                 for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) {
    77                                         params.push_back( (*param)->get_type()->clone() );
    78                                 }
    79                         }
    80 
    81                         TypeList& operator= ( const TypeList &that ) {
    82                                 deleteAll( params );
    83 
    84                                 params.clear();
    85                                 cloneAll( that.params, params );
    86 
    87                                 return *this;
    88                         }
    89 
    90                         TypeList& operator= ( TypeList &&that ) {
    91                                 deleteAll( params );
    92 
    93                                 params = std::move( that.params );
    94 
    95                                 return *this;
    96                         }
    97 
    98                         ~TypeList() { deleteAll( params ); }
    99 
    100                         bool operator== ( const TypeList& that ) const {
    101                                 if ( params.size() != that.params.size() ) return false;
    102 
    103                                 SymTab::Indexer dummy;
    104                                 for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
    105                                         if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
    106                                 }
    107                                 return true;
    108                         }
    109 
    110                         std::list< Type* > params;  ///< Instantiation parameters
    111                 };
    112 
    113                 /// Maps a key and a TypeList to the some value, accounting for scope
    114                 template< typename Key, typename Value >
    115                 class InstantiationMap {
    116                         /// Wraps value for a specific (Key, TypeList) combination
    117                         typedef std::pair< TypeList, Value* > Instantiation;
    118                         /// List of TypeLists paired with their appropriate values
    119                         typedef std::vector< Instantiation > ValueList;
    120                         /// Underlying map type; maps keys to a linear list of corresponding TypeLists and values
    121                         typedef ScopedMap< Key*, ValueList > InnerMap;
    122 
    123                         InnerMap instantiations;  ///< instantiations
    124 
    125                 public:
    126                         /// Starts a new scope
    127                         void beginScope() { instantiations.beginScope(); }
    128 
    129                         /// Ends a scope
    130                         void endScope() { instantiations.endScope(); }
    131 
    132                         /// Gets the value for the (key, typeList) pair, returns NULL on none such.
    133                         Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {
    134                                 TypeList typeList( params );
    135 
    136                                 // scan scopes for matches to the key
    137                                 for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {
    138                                         for ( typename ValueList::const_reverse_iterator inst = insts->second.rbegin(); inst != insts->second.rend(); ++inst ) {
    139                                                 if ( inst->first == typeList ) return inst->second;
    140                                         }
    141                                 }
    142                                 // no matching instantiations found
    143                                 return 0;
    144                         }
    145 
    146                         /// Adds a value for a (key, typeList) pair to the current scope
    147                         void insert( Key *key, const std::list< TypeExpr* > &params, Value *value ) {
    148                                 instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) );
    149                         }
    150                 };
    15164
    15265                /// Adds layout-generation functions to polymorphic types
    … …  
    239152                };
    240153
    241                 /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
    242                 class GenericInstantiator : public DeclMutator {
    243                         /// Map of (generic type, parameter list) pairs to concrete type instantiations
    244                         InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
    245                         /// Namer for concrete types
    246                         UniqueName typeNamer;
    247 
    248                 public:
    249                         GenericInstantiator() : DeclMutator(), instantiations(), typeNamer("_conc_") {}
    250 
    251                         virtual Type* mutate( StructInstType *inst );
    252                         virtual Type* mutate( UnionInstType *inst );
    253 
    254         //              virtual Expression* mutate( MemberExpr *memberExpr );
    255 
    256                         virtual void doBeginScope();
    257                         virtual void doEndScope();
    258                 private:
    259                         /// Wrap instantiation lookup for structs
    260                         StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)instantiations.lookup( inst->get_baseStruct(), typeSubs ); }
    261                         /// Wrap instantiation lookup for unions
    262                         UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)instantiations.lookup( inst->get_baseUnion(), typeSubs ); }
    263                         /// Wrap instantiation insertion for structs
    264                         void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { instantiations.insert( inst->get_baseStruct(), typeSubs, decl ); }
    265                         /// Wrap instantiation insertion for unions
    266                         void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { instantiations.insert( inst->get_baseUnion(), typeSubs, decl ); }
    267                 };
    268 
    269154                /// Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions.
    270155                /// * Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference
    … …  
    354239                Pass1 pass1;
    355240                Pass2 pass2;
    356                 GenericInstantiator instantiator;
    357241                PolyGenericCalculator polyCalculator;
    358242                Pass3 pass3;
    … …  
    361245                mutateTranslationUnit/*All*/( translationUnit, pass1 );
    362246                mutateTranslationUnit/*All*/( translationUnit, pass2 );
    363                 instantiator.mutateDeclarationList( translationUnit );
    364247                mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
    365248                mutateTranslationUnit/*All*/( translationUnit, pass3 );
    … …  
    889772                                                arg++;
    890773                                        } else {
    891                                                 /// xxx - should this be an assertion?
     774                                                // xxx - should this be an assertion?
    892775                                                throw SemanticError( "unbound type variable: " + tyParm->first + " in application ", appExpr );
    893776                                        } // if
    … …  
    902785                        std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
    903786                        std::list< Expression* >::const_iterator fnArg = arg;
    904                         std::set< std::string > seenTypes; //< names for generic types we've seen
     787                        std::set< std::string > seenTypes; ///< names for generic types we've seen
    905788
    906789                        // a polymorphic return type may need to be added to the argument list
    … …  
    1042925                /// this gets rid of warnings from gcc.
    1043926                void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) {
    1044                         Type * newType = formal->clone();
    1045                         if ( getFunctionType( newType ) ) {
     927                        if ( getFunctionType( formal ) ) {
     928                                Type * newType = formal->clone();
    1046929                                newType = ScrubTyVars::scrub( newType, tyVars );
    1047930                                actual = new CastExpr( actual, newType );
    … …  
    17751658                }
    17761659
    1777 //////////////////////////////////////// GenericInstantiator //////////////////////////////////////////////////
    1778 
    1779                 /// Makes substitutions of params into baseParams; returns true if all parameters substituted for a concrete type
    1780                 bool makeSubstitutions( const std::list< TypeDecl* >& baseParams, const std::list< Expression* >& params, std::list< TypeExpr* >& out ) {
    1781                         bool allConcrete = true;  // will finish the substitution list even if they're not all concrete
    1782 
    1783                         // substitute concrete types for given parameters, and incomplete types for placeholders
    1784                         std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();
    1785                         std::list< Expression* >::const_iterator param = params.begin();
    1786                         for ( ; baseParam != baseParams.end() && param != params.end(); ++baseParam, ++param ) {
    1787         //                      switch ( (*baseParam)->get_kind() ) {
    1788         //                      case TypeDecl::Any: {   // any type is a valid substitution here; complete types can be used to instantiate generics
    1789                                         TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
    1790                                         assert(paramType && "Aggregate parameters should be type expressions");
    1791                                         out.push_back( paramType->clone() );
    1792                                         // check that the substituted type isn't a type variable itself
    1793                                         if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) {
    1794                                                 allConcrete = false;
    1795                                         }
    1796         //                              break;
    1797         //                      }
    1798         //                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
    1799         //                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
    1800         //                              break;
    1801         //                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
    1802         //                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
    1803         //                              break;
    1804         //                      }
    1805                         }
    1806 
    1807                         // if any parameters left over, not done
    1808                         if ( baseParam != baseParams.end() ) return false;
    1809         //              // if not enough parameters given, substitute remaining incomplete types for placeholders
    1810         //              for ( ; baseParam != baseParams.end(); ++baseParam ) {
    1811         //                      switch ( (*baseParam)->get_kind() ) {
    1812         //                      case TypeDecl::Any:    // no more substitutions here, fail early
    1813         //                              return false;
    1814         //                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
    1815         //                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
    1816         //                              break;
    1817         //                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
    1818         //                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
    1819         //                              break;
    1820         //                      }
    1821         //              }
    1822 
    1823                         return allConcrete;
    1824                 }
    1825 
    1826                 /// Substitutes types of members of in according to baseParams => typeSubs, appending the result to out
    1827                 void substituteMembers( const std::list< Declaration* >& in, const std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs,
    1828                                                                 std::list< Declaration* >& out ) {
    1829                         // substitute types into new members
    1830                         TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
    1831                         for ( std::list< Declaration* >::const_iterator member = in.begin(); member != in.end(); ++member ) {
    1832                                 Declaration *newMember = (*member)->clone();
    1833                                 subs.apply(newMember);
    1834                                 out.push_back( newMember );
    1835                         }
    1836                 }
    1837 
    1838                 Type* GenericInstantiator::mutate( StructInstType *inst ) {
    1839                         // mutate subtypes
    1840                         Type *mutated = Mutator::mutate( inst );
    1841                         inst = dynamic_cast< StructInstType* >( mutated );
    1842                         if ( ! inst ) return mutated;
    1843 
    1844                         // exit early if no need for further mutation
    1845                         if ( inst->get_parameters().empty() ) return inst;
    1846                         assert( inst->get_baseParameters() && "Base struct has parameters" );
    1847 
    1848                         // check if type can be concretely instantiated; put substitutions into typeSubs
    1849                         std::list< TypeExpr* > typeSubs;
    1850                         if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) {
    1851                                 deleteAll( typeSubs );
    1852                                 return inst;
    1853                         }
    1854 
    1855                         // make concrete instantiation of generic type
    1856                         StructDecl *concDecl = lookup( inst, typeSubs );
    1857                         if ( ! concDecl ) {
    1858                                 // set concDecl to new type, insert type declaration into statements to add
    1859                                 concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) );
    1860                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs,        concDecl->get_members() );
    1861                                 DeclMutator::addDeclaration( concDecl );
    1862                                 insert( inst, typeSubs, concDecl );
    1863                         }
    1864                         StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );
    1865                         newInst->set_baseStruct( concDecl );
    1866 
    1867                         deleteAll( typeSubs );
    1868                         delete inst;
    1869                         return newInst;
    1870                 }
    1871 
    1872                 Type* GenericInstantiator::mutate( UnionInstType *inst ) {
    1873                         // mutate subtypes
    1874                         Type *mutated = Mutator::mutate( inst );
    1875                         inst = dynamic_cast< UnionInstType* >( mutated );
    1876                         if ( ! inst ) return mutated;
    1877 
    1878                         // exit early if no need for further mutation
    1879                         if ( inst->get_parameters().empty() ) return inst;
    1880                         assert( inst->get_baseParameters() && "Base union has parameters" );
    1881 
    1882                         // check if type can be concretely instantiated; put substitutions into typeSubs
    1883                         std::list< TypeExpr* > typeSubs;
    1884                         if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) {
    1885                                 deleteAll( typeSubs );
    1886                                 return inst;
    1887                         }
    1888 
    1889                         // make concrete instantiation of generic type
    1890                         UnionDecl *concDecl = lookup( inst, typeSubs );
    1891                         if ( ! concDecl ) {
    1892                                 // set concDecl to new type, insert type declaration into statements to add
    1893                                 concDecl = new UnionDecl( typeNamer.newName( inst->get_name() ) );
    1894                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
    1895                                 DeclMutator::addDeclaration( concDecl );
    1896                                 insert( inst, typeSubs, concDecl );
    1897                         }
    1898                         UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );
    1899                         newInst->set_baseUnion( concDecl );
    1900 
    1901                         deleteAll( typeSubs );
    1902                         delete inst;
    1903                         return newInst;
    1904                 }
    1905 
    1906         //      /// Gets the base struct or union declaration for a member expression; NULL if not applicable
    1907         //      AggregateDecl* getMemberBaseDecl( MemberExpr *memberExpr ) {
    1908         //              // get variable for member aggregate
    1909         //              VariableExpr *varExpr = dynamic_cast< VariableExpr* >( memberExpr->get_aggregate() );
    1910         //              if ( ! varExpr ) return NULL;
    1911         //
    1912         //              // get object for variable
    1913         //              ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( varExpr->get_var() );
    1914         //              if ( ! objectDecl ) return NULL;
    1915         //
    1916         //              // get base declaration from object type
    1917         //              Type *objectType = objectDecl->get_type();
    1918         //              StructInstType *structType = dynamic_cast< StructInstType* >( objectType );
    1919         //              if ( structType ) return structType->get_baseStruct();
    1920         //              UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType );
    1921         //              if ( unionType ) return unionType->get_baseUnion();
    1922         //
    1923         //              return NULL;
    1924         //      }
    1925         //
    1926         //      /// Finds the declaration with the given name, returning decls.end() if none such
    1927         //      std::list< Declaration* >::const_iterator findDeclNamed( const std::list< Declaration* > &decls, const std::string &name ) {
    1928         //              for( std::list< Declaration* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
    1929         //                      if ( (*decl)->get_name() == name ) return decl;
    1930         //              }
    1931         //              return decls.end();
    1932         //      }
    1933         //
    1934         //      Expression* Instantiate::mutate( MemberExpr *memberExpr ) {
    1935         //              // mutate, exiting early if no longer MemberExpr
    1936         //              Expression *expr = Mutator::mutate( memberExpr );
    1937         //              memberExpr = dynamic_cast< MemberExpr* >( expr );
    1938         //              if ( ! memberExpr ) return expr;
    1939         //
    1940         //              // get declaration of member and base declaration of member, exiting early if not found
    1941         //              AggregateDecl *memberBase = getMemberBaseDecl( memberExpr );
    1942         //              if ( ! memberBase ) return memberExpr;
    1943         //              DeclarationWithType *memberDecl = memberExpr->get_member();
    1944         //              std::list< Declaration* >::const_iterator baseIt = findDeclNamed( memberBase->get_members(), memberDecl->get_name() );
    1945         //              if ( baseIt == memberBase->get_members().end() ) return memberExpr;
    1946         //              DeclarationWithType *baseDecl = dynamic_cast< DeclarationWithType* >( *baseIt );
    1947         //              if ( ! baseDecl ) return memberExpr;
    1948         //
    1949         //              // check if stated type of the member is not the type of the member's declaration; if so, need a cast
    1950         //              // this *SHOULD* be safe, I don't think anything but the void-replacements I put in for dtypes would make it past the typechecker
    1951         //              SymTab::Indexer dummy;
    1952         //              if ( ResolvExpr::typesCompatible( memberDecl->get_type(), baseDecl->get_type(), dummy ) ) return memberExpr;
    1953         //              else return new CastExpr( memberExpr, memberDecl->get_type() );
    1954         //      }
    1955 
    1956                 void GenericInstantiator::doBeginScope() {
    1957                         DeclMutator::doBeginScope();
    1958                         instantiations.beginScope();
    1959                 }
    1960 
    1961                 void GenericInstantiator::doEndScope() {
    1962                         DeclMutator::doEndScope();
    1963                         instantiations.endScope();
    1964                 }
    1965 
    19661660////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////////////////////////
    19671661
    … …  
    21071801                        findGeneric( objectType ); // ensure layout for this type is available
    21081802
     1803                        // replace member expression with dynamically-computed layout expression
    21091804                        Expression *newMemberExpr = 0;
    21101805                        if ( StructInstType *structType = dynamic_cast< StructInstType* >( objectType ) ) {

  • src/GenPoly/module.mk

    r0853178 r04273e9  
    2323       GenPoly/CopyParams.cc \
    2424       GenPoly/FindFunction.cc \
    25        GenPoly/DeclMutator.cc
     25       GenPoly/DeclMutator.cc \
     26       GenPoly/InstantiateGeneric.cc

  • src/Makefile.in

    r0853178 r04273e9  
    121121        GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \
    122122        GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \
     123        GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \
    123124        InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT) \
    124125        InitTweak/driver_cfa_cpp-FixInit.$(OBJEXT) \
    … …  
    377378        GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
    378379        GenPoly/CopyParams.cc GenPoly/FindFunction.cc \
    379         GenPoly/DeclMutator.cc InitTweak/GenInit.cc \
    380         InitTweak/FixInit.cc InitTweak/FixGlobalInit.cc \
    381         InitTweak/InitTweak.cc Parser/parser.yy Parser/lex.ll \
    382         Parser/TypedefTable.cc Parser/ParseNode.cc \
    383         Parser/DeclarationNode.cc Parser/ExpressionNode.cc \
    384         Parser/StatementNode.cc Parser/InitializerNode.cc \
    385         Parser/TypeData.cc Parser/LinkageSpec.cc \
    386         Parser/parseutility.cc Parser/Parser.cc \
     380        GenPoly/DeclMutator.cc GenPoly/InstantiateGeneric.cc \
     381        InitTweak/GenInit.cc InitTweak/FixInit.cc \
     382        InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \
     383        Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \
     384        Parser/ParseNode.cc Parser/DeclarationNode.cc \
     385        Parser/ExpressionNode.cc Parser/StatementNode.cc \
     386        Parser/InitializerNode.cc Parser/TypeData.cc \
     387        Parser/LinkageSpec.cc Parser/parseutility.cc Parser/Parser.cc \
    387388        ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \
    388389        ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \
    … …  
    585586GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
    586587        GenPoly/$(DEPDIR)/$(am__dirstamp)
     588GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT):  \
     589        GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
    587590InitTweak/$(am__dirstamp):
    588591        @$(MKDIR_P) InitTweak
    … …  
    828831        -rm -f GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT)
    829832        -rm -f GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT)
     833        -rm -f GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT)
    830834        -rm -f GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT)
    831835        -rm -f GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT)
    … …  
    937941@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@
    938942@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@
     943@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@
    939944@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@
    940945@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@
    … …  
    13881393@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
    13891394
     1395GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc
     1396@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(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
     1397@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po
     1398@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/InstantiateGeneric.cc' object='GenPoly/driver_cfa_cpp-InstantiateGeneric.o' libtool=no @AMDEPBACKSLASH@
     1399@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1400@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(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
     1401
     1402GenPoly/driver_cfa_cpp-InstantiateGeneric.obj: GenPoly/InstantiateGeneric.cc
     1403@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(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`
     1404@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po
     1405@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/InstantiateGeneric.cc' object='GenPoly/driver_cfa_cpp-InstantiateGeneric.obj' libtool=no @AMDEPBACKSLASH@
     1406@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1407@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(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`
     1408
    13901409InitTweak/driver_cfa_cpp-GenInit.o: InitTweak/GenInit.cc
    13911410@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-GenInit.o -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-GenInit.Tpo -c -o InitTweak/driver_cfa_cpp-GenInit.o `test -f 'InitTweak/GenInit.cc' || echo '$(srcdir)/'`InitTweak/GenInit.cc

  • src/Parser/DeclarationNode.cc

    r0853178 r04273e9  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 20:49:31 2016
    13 // Update Count     : 164
     12// Last Modified On : Sun Aug  7 08:01:55 2016
     13// Update Count     : 165
    1414//
    1515
    … …  
    4949        newnode->name = name;
    5050        newnode->storageClasses = storageClasses;
    51         newnode->bitfieldWidth = maybeClone( bitfieldWidth );
     51//PAB   newnode->bitfieldWidth = maybeClone( bitfieldWidth );
     52        newnode->bitfieldWidth = bitfieldWidth;
    5253        newnode->hasEllipsis = hasEllipsis;
    5354        newnode->initializer = initializer;

  • src/Parser/ExpressionNode.cc

    r0853178 r04273e9  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 07:56:23 2016
    13 // Update Count     : 375
     12// Last Modified On : Sun Aug  7 09:23:12 2016
     13// Update Count     : 437
    1414//
    1515
    1616#include <cassert>
    1717#include <cctype>
     18#include <climits>
     19#include <cstdio>
    1820#include <algorithm>
    1921#include <sstream>
    20 #include <cstdio>
    2122
    2223#include "ParseNode.h"
    … …  
    3738ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ), extension( other.extension ) {
    3839        if ( other.argName ) {
     40                std::cout << "ExpressionNode" << std::endl;
    3941                argName = other.argName->clone();
    4042        } else {
    … …  
    8385}
    8486
    85 // CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ) {
    86 //      return new CommaExprNode( this, exp );
    87 // }
    88 
    89 //##############################################################################
    90 
    91 ConstantNode::ConstantNode( ConstantExpr *expr ) : expr( expr ) {
    92 } // ConstantNode::ConstantNode
    93 
    94 ConstantNode *ConstantNode::appendstr( const std::string *newValue ) {
    95         assert( newValue != 0 );
    96 
    97         string value = expr->get_constant()->get_value();
    98 
    99         // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
    100         value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) );
    101         expr->get_constant()->set_value( value );
    102 
    103         delete newValue;                                                                        // allocated by lexer
    104         return this;
    105 }
    106 
    107 void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
    108         // os << string( indent, ' ' );
    109         // printDesignation( os );
    110 
    111         // switch ( type ) {
    112         //   case Integer:
    113         //   case Float:
    114         //      os << value ;
    115         //      break;
    116         //   case Character:
    117         //      os << "'" << value << "'";
    118         //      break;
    119         //   case String:
    120         //      os << '"' << value << '"';
    121         //      break;
    122         // } // switch
    123 
    124         // os << ' ';
    125 }
    126 
    127 void ConstantNode::print( std::ostream &os, int indent ) const {
    128         printOneLine( os, indent );
    129         os << endl;
    130 }
    131 
    132 Expression *ConstantNode::build() const {
    133         return expr->clone();
    134 }
    135 
    136 //##############################################################################
    137 
    138 VarRefNode::VarRefNode() : isLabel( false ) {}
    139 
    140 VarRefNode::VarRefNode( const string *name_, bool labelp ) : ExpressionNode( name_ ), isLabel( labelp ) {}
     87//##############################################################################
     88
     89// Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
     90//
     91//              prefix action constant action suffix
     92//
     93// Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
     94//
     95//              constant BEGIN CONT ...
     96//              <CONT>(...)? BEGIN 0 ... // possible empty suffix
     97//
     98// because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
     99// type.
     100
     101static Type::Qualifiers emptyQualifiers;                                // no qualifiers on constants
     102
     103static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
     104static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
     105static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
     106static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
     107static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
     108static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
     109
     110ConstantNode *build_constantInteger( std::string & str ) {
     111        static const BasicType::Kind kind[2][3] = {
     112                { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
     113                { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
     114        };
     115        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
     116        int size;                                                                                       // 0 => int, 1 => long, 2 => long long
     117        unsigned long long v;                                                           // converted integral value
     118        size_t last = str.length() - 1;                                         // last character of constant
     119
     120        if ( str[0] == '0' ) {                                                          // octal/hex constant ?
     121                dec = false;
     122                if ( last != 0 && checkX( str[1] ) ) {                  // hex constant ?
     123                        sscanf( (char *)str.c_str(), "%llx", &v );
     124                        //printf( "%llx %llu\n", v, v );
     125                } else {                                                                                // octal constant
     126                        sscanf( (char *)str.c_str(), "%llo", &v );
     127                        //printf( "%llo %llu\n", v, v );
     128                } // if
     129        } else {                                                                                        // decimal constant ?
     130                sscanf( (char *)str.c_str(), "%llu", &v );
     131                //printf( "%llu %llu\n", v, v );
     132        } // if
     133
     134        if ( v <= INT_MAX ) {                                                           // signed int
     135                size = 0;
     136        } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
     137                size = 0;
     138                Unsigned = true;                                                                // unsigned
     139        } else if ( v <= LONG_MAX ) {                                           // signed long int
     140                size = 1;
     141        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
     142                size = 1;
     143                Unsigned = true;                                                                // unsigned long int
     144        } else if ( v <= LLONG_MAX ) {                                          // signed long long int
     145                size = 2;
     146        } else {                                                                                        // unsigned long long int
     147                size = 2;
     148                Unsigned = true;                                                                // unsigned long long int
     149        } // if
     150
     151        if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
     152                Unsigned = true;
     153                if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'l' ?
     154                        size = 1;
     155                        if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?
     156                                size = 2;
     157                        } // if
     158                } // if
     159        } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
     160                size = 1;
     161                if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'll' ?
     162                        size = 2;
     163                        if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?
     164                                Unsigned = true;
     165                        } // if
     166                } else {
     167                        if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?
     168                                Unsigned = true;
     169                        } // if
     170                } // if
     171        } // if
     172
     173        return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ) ) );
     174} // build_constantInteger
     175
     176ConstantNode *build_constantFloat( std::string & str ) {
     177        static const BasicType::Kind kind[2][3] = {
     178                { BasicType::Float, BasicType::Double, BasicType::LongDouble },
     179                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
     180        };
     181
     182        bool complx = false;                                                            // real, complex
     183        int size = 1;                                                                           // 0 => float, 1 => double (default), 2 => long double
     184        // floating-point constant has minimum of 2 characters: 1. or .1
     185        size_t last = str.length() - 1;
     186
     187        if ( checkI( str[last] ) ) {                                            // imaginary ?
     188                complx = true;
     189                last -= 1;                                                                              // backup one character
     190        } // if
     191
     192        if ( checkF( str[last] ) ) {                                            // float ?
     193                size = 0;
     194        } else if ( checkD( str[last] ) ) {                                     // double ?
     195                size = 1;
     196        } else if ( checkL( str[last] ) ) {                                     // long double ?
     197                size = 2;
     198        } // if
     199        if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
     200                complx = true;
     201        } // if
     202
     203        return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ) ) );
     204} // build_constantFloat
     205
     206ConstantNode *build_constantChar( std::string & str ) {
     207        return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ) ) );
     208} // build_constantChar
     209
     210ConstantNode *build_constantStr( std::string & str ) {
     211        // string should probably be a primitive type
     212        ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ),
     213                                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),
     214                                                                                        toString( str.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
     215                                                                   false, false );
     216        return new ConstantNode( new ConstantExpr( Constant( at, str ) ) );
     217} // build_constantStr
     218
     219//##############################################################################
     220
     221//Expression *build_varref( ExpressionNode expr ) {
     222//      return new NameExpr( get_name(), maybeBuild<Expression>( get_argName() ) );
     223//}
     224
     225VarRefNode::VarRefNode( const string *name, bool labelp ) : ExpressionNode( name ), isLabel( labelp ) {}
    141226
    142227VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {
    … …  
    171256                        double value;
    172257                        if ( ss >> value ) {
    173                                 // this is a floating point constant. It MUST be
    174                                 // ".0" or ".1", otherwise the program is invalid
     258                                // this is a floating point constant. It MUST be ".0" or ".1", otherwise the program is invalid
    175259                                if ( ! (var->get_name() == ".0" || var->get_name() == ".1") ) {
    176260                                        throw SemanticError( "invalid designator name: " + var->get_name() );
    … …  
    201285
    202286        if ( isArrayIndex ) {
    203                 // need to traverse entire structure and change any instances of 0 or 1 to
    204                 // ConstantExpr
     287                // need to traverse entire structure and change any instances of 0 or 1 to ConstantExpr
    205288                DesignatorFixer fixer;
    206289                ret = ret->acceptMutator( fixer );
    … …  
    238321//##############################################################################
    239322
    240 static const char *opName[] = {
    241         "TupleC", "Comma", "TupleFieldSel", // "TuplePFieldSel", // n-adic
    242         // triadic
    243         "Cond", "NCond",
     323static const char *OperName[] = {
    244324        // diadic
    245         "SizeOf", "AlignOf", "OffsetOf", "Attr", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
     325        "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
    246326        "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
    247327        "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
    248         "?[?]", "FieldSel", "PFieldSel", "...",
     328        "?[?]", "...",
    249329        // monadic
    250330        "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&"
    251331};
    252332
    253 OperatorNode::OperatorNode( Type t ) : type( t ) {}
    254 
    255 OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) {
    256 }
    257 
    258 OperatorNode::~OperatorNode() {}
    259 
    260 OperatorNode::Type OperatorNode::get_type( void ) const {
    261         return type;
    262 }
    263 
    264 void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
    265         printDesignation( os );
    266         os << opName[ type ] << ' ';
    267 }
    268 
    269 void OperatorNode::print( std::ostream &os, int indent ) const{
    270         printDesignation( os );
    271         os << string( indent, ' ' ) << "Operator: " << opName[type] << endl;
    272         return;
    273 }
    274 
    275 const char *OperatorNode::get_typename( void ) const{
    276         return opName[ type ];
    277 }
    278 
    279 //##############################################################################
    280 
    281 CompositeExprNode::CompositeExprNode() : ExpressionNode(), function( 0 ), arguments( 0 ) {
    282 }
    283 
    284 CompositeExprNode::CompositeExprNode( const string *name_ ) : ExpressionNode( name_ ), function( 0 ), arguments( 0 ) {
    285 }
    286 
    287 CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ):
    288         function( f ), arguments( args ) {
    289 }
    290 
    291 CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
    292         function( f ), arguments( arg1 ) {
    293         arguments->set_link( arg2 );
    294 }
    295 
    296 CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ), arguments( 0 ) {
    297         ParseNode *cur = other.arguments;
    298         while ( cur ) {
    299                 if ( arguments ) {
    300                         arguments->set_link( cur->clone() );
    301                 } else {
    302                         arguments = ( ExpressionNode*)cur->clone();
    303                 } // if
    304                 cur = cur->get_link();
    305         }
    306 }
    307 
    308 CompositeExprNode::~CompositeExprNode() {
    309         delete function;
    310         delete arguments;
    311 }
    312 
     333//##############################################################################
    313334
    314335Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node ) {
    … …  
    369390}
    370391
    371 Expression *build_opr1( OperatorNode::Type op, ExpressionNode *expr_node ) {
     392Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) {
     393        std::list<Expression *> args;
     394        args.push_back( maybeBuild<Expression>(expr_node) );
     395        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     396}
     397Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) {
    372398        std::list<Expression *> args;
    373399        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) );
    374         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
    375 }
    376 Expression *build_opr2( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
     400        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     401}
     402Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
    377403        std::list<Expression *> args;
    378404        args.push_back( maybeBuild<Expression>(expr_node1) );
    379405        args.push_back( maybeBuild<Expression>(expr_node2) );
    380         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
     406        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     407}
     408Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
     409        std::list<Expression *> args;
     410        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node1) ) );
     411        args.push_back( maybeBuild<Expression>(expr_node2) );
     412        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
    381413}
    382414
    … …  
    389421}
    390422
    391 CompositeExprNode2::CompositeExprNode2( Expression *expr ) : expr( expr ) {}
    392 CompositeExprNode2::CompositeExprNode2( const CompositeExprNode2 &other ) : expr( other.expr->clone() ) {}
    393 CompositeExprNode2::~CompositeExprNode2() { delete expr; }
    394 void CompositeExprNode2::print( std::ostream &, int indent ) const { assert( false ); }
    395 void CompositeExprNode2::printOneLine( std::ostream &, int indent ) const { assert( false ); }
    396 
    397 
    398 Expression *CompositeExprNode::build() const {
    399         OperatorNode *op;
     423Expression *build_attr( VarRefNode *var, ExpressionNode * expr ) {
     424        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr ) ) {
     425                return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() );
     426        } else {
     427                return new AttrExpr( maybeBuild<Expression>(var), maybeBuild<Expression>(expr) );
     428        } // if
     429}
     430
     431Expression *build_tuple( ExpressionNode * expr ) {
     432        TupleExpr *ret = new TupleExpr();
     433        buildList( expr, ret->get_exprs() );
     434        return ret;
     435}
     436
     437Expression *build_func( ExpressionNode * function, ExpressionNode * expr ) {
    400438        std::list<Expression *> args;
    401439
    402         buildList( get_args(), args );
    403 
    404         if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator
    405                 return new UntypedExpr( maybeBuild<Expression>(function), args, maybeBuild< Expression >( get_argName() ));
    406         } // if
    407 
    408         switch ( op->get_type() ) {
    409           case OperatorNode::Assign:
    410           case OperatorNode::MulAssn:
    411           case OperatorNode::DivAssn:
    412           case OperatorNode::ModAssn:
    413           case OperatorNode::PlusAssn:
    414           case OperatorNode::MinusAssn:
    415           case OperatorNode::LSAssn:
    416           case OperatorNode::RSAssn:
    417           case OperatorNode::AndAssn:
    418           case OperatorNode::ERAssn:
    419           case OperatorNode::OrAssn:
    420                 assert( ! args.empty() );
    421                 args.front() = new AddressExpr( args.front() );
    422           case OperatorNode::UnPlus:
    423           case OperatorNode::UnMinus:
    424           case OperatorNode::PointTo:
    425           case OperatorNode::Neg:
    426           case OperatorNode::BitNeg:
    427           case OperatorNode::LabelAddress:
    428                 return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
    429 
    430           case OperatorNode::Attr:
    431                 {
    432                         VarRefNode *var = dynamic_cast<VarRefNode *>( get_args() );
    433                         assert( var );
    434                         if ( ! get_args()->get_link() ) {
    435                                 return new AttrExpr( maybeBuild<Expression>(var), ( Expression*)0);
    436                         } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link() ) ) {
    437                                 return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() );
    438                         } else {
    439                                 return new AttrExpr( maybeBuild<Expression>(var), args.back() );
    440                         } // if
    441                 }
    442           case OperatorNode::Cond:
    443                 {
    444                         assert( args.size() == 3);
    445                         std::list< Expression * >::const_iterator i = args.begin();
    446                         Expression *arg1 = notZeroExpr( *i++ );
    447                         Expression *arg2 = *i++;
    448                         Expression *arg3 = *i++;
    449                         return new ConditionalExpr( arg1, arg2, arg3 );
    450                 }
    451           case OperatorNode::NCond:
    452                 throw UnimplementedError( "GNU 2-argument conditional expression" );
    453                 // Tuples
    454           case OperatorNode::TupleC:
    455                 {
    456                         TupleExpr *ret = new TupleExpr();
    457                         std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
    458                         return ret;
    459                 }
    460           default:
    461                 assert( ((void)"CompositeExprNode::build", false) );
    462                 return 0;
    463         } // switch
    464 }
    465 
    466 void CompositeExprNode::printOneLine( std::ostream &os, int indent ) const {
    467         printDesignation( os );
    468         os << "( ";
    469         function->printOneLine( os, indent );
    470         for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
    471                 cur->printOneLine( os, indent );
    472         } // for
    473         os << ") ";
    474 }
    475 
    476 void CompositeExprNode::print( std::ostream &os, int indent ) const {
    477         printDesignation( os );
    478         os << string( indent, ' ' ) << "Application of: " << endl;
    479         function->print( os, indent + ParseNode::indent_by );
    480 
    481         os << string( indent, ' ' ) ;
    482         if ( arguments ) {
    483                 os << "... on arguments: " << endl;
    484                 arguments->printList( os, indent + ParseNode::indent_by );
    485         } else
    486                 os << "... on no arguments: " << endl;
    487 }
    488 
    489 void CompositeExprNode::set_function( ExpressionNode *f ) {
    490         function = f;
    491 }
    492 
    493 void CompositeExprNode::set_args( ExpressionNode *args ) {
    494         arguments = args;
    495 }
    496 
    497 ExpressionNode *CompositeExprNode::get_function( void ) const {
    498         return function;
    499 }
    500 
    501 ExpressionNode *CompositeExprNode::get_args( void ) const {
    502         return arguments;
    503 }
    504 
    505 void CompositeExprNode::add_arg( ExpressionNode *arg ) {
    506         if ( arguments )
    507                 arguments->set_link( arg );
    508         else
    509                 set_args( arg );
     440        buildList( expr, args );
     441        return new UntypedExpr( maybeBuild<Expression>(function), args, nullptr );
     442}
     443
     444Expression *build_range( ExpressionNode * low, ExpressionNode *high ) {
     445        Expression *low_cexpr = maybeBuild<Expression>( low );
     446        Expression *high_cexpr = maybeBuild<Expression>( high );
     447        return new RangeExpr( low_cexpr, high_cexpr );
    510448}
    511449
    … …  
    698636}
    699637
    700 ExpressionNode *flattenCommas( ExpressionNode *list ) {
    701         if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
    702                 OperatorNode *op;
    703                 if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) {
    704                         if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
    705                                 composite->add_arg( next );
    706                         return flattenCommas( composite->get_args() );
    707                 } // if
    708         } // if
    709 
    710         if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
    711                 list->set_next( flattenCommas( next ) );
    712 
    713         return list;
    714 }
    715 
    716 ExpressionNode *tupleContents( ExpressionNode *tuple ) {
    717         if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
    718                 OperatorNode *op = 0;
    719                 if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )
    720                         return composite->get_args();
    721         } // if
    722         return tuple;
    723 }
    724 
    725638// Local Variables: //
    726639// tab-width: 4 //

  • src/Parser/ParseNode.cc

    r0853178 r04273e9  
    1010// Created On       : Sat May 16 13:26:29 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jul 24 02:17:01 2016
    13 // Update Count     : 90
     12// Last Modified On : Sat Aug  6 08:26:11 2016
     13// Update Count     : 93
    1414//
    1515
    16 #include <climits>
    1716#include "ParseNode.h"
    1817using namespace std;
    19 
    20 // Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
    21 //
    22 //              prefix action constant action suffix
    23 //
    24 // Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
    25 //
    26 //              constant BEGIN CONT ...
    27 //              <CONT>(...)? BEGIN 0 ... // possible empty suffix
    28 //
    29 // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
    30 // type.
    31 
    32 static Type::Qualifiers emptyQualifiers;                                // no qualifiers on constants
    33 
    34 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
    35 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
    36 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
    37 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
    38 static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
    39 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
    40 
    41 ConstantNode *makeConstantInteger( std::string & str ) {
    42         static const BasicType::Kind kind[2][3] = {
    43                 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
    44                 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
    45         };
    46         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
    47         int size;                                                                                       // 0 => int, 1 => long, 2 => long long
    48         unsigned long long v;                                                           // converted integral value
    49         size_t last = str.length() - 1;                                         // last character of constant
    50 
    51         if ( str[0] == '0' ) {                                                          // octal/hex constant ?
    52                 dec = false;
    53                 if ( last != 0 && checkX( str[1] ) ) {                  // hex constant ?
    54                         sscanf( (char *)str.c_str(), "%llx", &v );
    55                         //printf( "%llx %llu\n", v, v );
    56                 } else {                                                                                // octal constant
    57                         sscanf( (char *)str.c_str(), "%llo", &v );
    58                         //printf( "%llo %llu\n", v, v );
    59                 } // if
    60         } else {                                                                                        // decimal constant ?
    61                 sscanf( (char *)str.c_str(), "%llu", &v );
    62                 //printf( "%llu %llu\n", v, v );
    63         } // if
    64 
    65         if ( v <= INT_MAX ) {                                                           // signed int
    66                 size = 0;
    67         } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
    68                 size = 0;
    69                 Unsigned = true;                                                                // unsigned
    70         } else if ( v <= LONG_MAX ) {                                           // signed long int
    71                 size = 1;
    72         } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
    73                 size = 1;
    74                 Unsigned = true;                                                                // unsigned long int
    75         } else if ( v <= LLONG_MAX ) {                                          // signed long long int
    76                 size = 2;
    77         } else {                                                                                        // unsigned long long int
    78                 size = 2;
    79                 Unsigned = true;                                                                // unsigned long long int
    80         } // if
    81 
    82         if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
    83                 Unsigned = true;
    84                 if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'l' ?
    85                         size = 1;
    86                         if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?
    87                                 size = 2;
    88                         } // if
    89                 } // if
    90         } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
    91                 size = 1;
    92                 if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'll' ?
    93                         size = 2;
    94                         if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?
    95                                 Unsigned = true;
    96                         } // if
    97                 } else {
    98                         if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?
    99                                 Unsigned = true;
    100                         } // if
    101                 } // if
    102         } // if
    103 
    104         return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ), nullptr ) );
    105 } // makeConstantInteger
    106 
    107 ConstantNode *makeConstantFloat( std::string & str ) {
    108         static const BasicType::Kind kind[2][3] = {
    109                 { BasicType::Float, BasicType::Double, BasicType::LongDouble },
    110                 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
    111         };
    112 
    113         bool complx = false;                                                            // real, complex
    114         int size = 1;                                                                           // 0 => float, 1 => double (default), 2 => long double
    115         // floating-point constant has minimum of 2 characters: 1. or .1
    116         size_t last = str.length() - 1;
    117 
    118         if ( checkI( str[last] ) ) {                                            // imaginary ?
    119                 complx = true;
    120                 last -= 1;                                                                              // backup one character
    121         } // if
    122 
    123         if ( checkF( str[last] ) ) {                                            // float ?
    124                 size = 0;
    125         } else if ( checkD( str[last] ) ) {                                     // double ?
    126                 size = 1;
    127         } else if ( checkL( str[last] ) ) {                                     // long double ?
    128                 size = 2;
    129         } // if
    130         if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
    131                 complx = true;
    132         } // if
    133 
    134         return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ), nullptr ) );
    135 } // makeConstantFloat
    136 
    137 ConstantNode *makeConstantChar( std::string & str ) {
    138         return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ), nullptr ) );
    139 } // makeConstantChar
    140 
    141 ConstantNode *makeConstantStr( std::string & str ) {
    142         // string should probably be a primitive type
    143         ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ),
    144                                                                    new ConstantExpr(
    145                                                                            Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),
    146                                                                                                  toString( str.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
    147                                                                    false, false );
    148         return new ConstantNode( new ConstantExpr( Constant( at, str ), nullptr ) );
    149 } // makeConstantStr
    150 
    15118
    15219// Builder

  • src/Parser/ParseNode.h

    r0853178 r04273e9  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 07:49:32 2016
    13 // Update Count     : 288
     12// Last Modified On : Sun Aug  7 09:37:16 2016
     13// Update Count     : 333
    1414//
    1515
    … …  
    3030#include "SynTree/Label.h"
    3131
    32 class ExpressionNode;
    33 class CompositeExprNode;
    34 class CommaExprNode;
    3532class StatementNode;
    3633class CompoundStmtNode;
    … …  
    5653        void set_name( const std::string &newValue ) { name = newValue; }
    5754
    58         virtual void print( std::ostream &, int indent = 0 ) const;
    59         virtual void printList( std::ostream &, int indent = 0 ) const;
     55        virtual void print( std::ostream &os, int indent = 0 ) const;
     56        virtual void printList( std::ostream &os, int indent = 0 ) const;
    6057
    6158        ParseNode &operator,( ParseNode &);
    … …  
    6865ParseNode *mkList( ParseNode & );
    6966
     67//##############################################################################
     68
    7069class ExpressionNode : public ParseNode {
    7170  public:
    … …  
    7372        ExpressionNode( const std::string * );
    7473        ExpressionNode( const ExpressionNode &other );
    75         virtual ~ExpressionNode() { delete argName; } // cannot delete argName because it might be referenced elsewhere
     74        virtual ~ExpressionNode() { delete argName; }
    7675
    7776        virtual ExpressionNode *clone() const = 0;
    78 
    79         // virtual CommaExprNode *add_to_list( ExpressionNode * );
    8077
    8178        ExpressionNode *get_argName() const { return argName; }
    … …  
    8582        ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
    8683
    87         virtual void print( std::ostream &, int indent = 0) const = 0;
    88         virtual void printOneLine( std::ostream &, int indent = 0) const = 0;
     84        virtual void print( std::ostream &os, int indent = 0) const = 0;
     85        virtual void printOneLine( std::ostream &os, int indent = 0) const = 0;
    8986
    9087        virtual Expression *build() const = 0;
    9188  protected:
    92         void printDesignation ( std::ostream &, int indent = 0) const;
     89        void printDesignation ( std::ostream &os, int indent = 0) const;
    9390  private:
    9491        ExpressionNode *argName = 0;
    … …  
    109106};
    110107
     108//##############################################################################
     109
    111110// NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ]
    112111class NullExprNode : public ExpressionNode {
    … …  
    116115        virtual NullExprNode *clone() const;
    117116
    118         virtual void print( std::ostream &, int indent = 0) const;
    119         virtual void printOneLine( std::ostream &, int indent = 0) const;
     117        virtual void print( std::ostream &os, int indent = 0) const;
     118        virtual void printOneLine( std::ostream &os, int indent = 0) const;
    120119
    121120        virtual Expression *build() const;
    122121};
    123122
     123//##############################################################################
     124
    124125class ConstantNode : public ExpressionNode {
    125126  public:
    126         enum Type { Integer, Float, Character, String };
    127 
    128         ConstantNode( ConstantExpr * );
    129         ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {};
    130         ~ConstantNode() { delete expr; }
    131 
    132         virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
    133         virtual void print( std::ostream &, int indent = 0) const;
    134         virtual void printOneLine( std::ostream &, int indent = 0) const;
    135 
    136         ConstantNode *appendstr( const std::string *newValue );
    137 
    138         Expression *build() const;
     127        ConstantNode( ConstantExpr *expr ) : expr( expr ) {}
     128        ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {}
     129        virtual ~ConstantNode() {}
     130
     131        virtual ConstantNode *clone() const { assert( false ); return new ConstantNode( *this ); }
     132
     133        ConstantExpr *get_expr() const { return expr; }
     134
     135        virtual void print( std::ostream &os, int indent = 0 ) const {}
     136        virtual void printOneLine( std::ostream &os, int indent = 0 ) const {}
     137
     138        Expression *build() const { return expr; }
    139139  private:
    140140        ConstantExpr *expr;
    141141};
    142142
    143 ConstantNode *makeConstantInteger( std::string & );
    144 ConstantNode *makeConstantFloat( std::string & );
    145 ConstantNode *makeConstantChar( std::string & );
    146 ConstantNode *makeConstantStr( std::string & );
     143ConstantNode *build_constantInteger( std::string &str );
     144ConstantNode *build_constantFloat( std::string &str );
     145ConstantNode *build_constantChar( std::string &str );
     146ConstantNode *build_constantStr( std::string &str );
     147
     148//##############################################################################
    147149
    148150class VarRefNode : public ExpressionNode {
    149151  public:
    150         VarRefNode();
    151152        VarRefNode( const std::string *, bool isLabel = false );
    152153        VarRefNode( const VarRefNode &other );
    … …  
    156157        virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
    157158
    158         virtual void print( std::ostream &, int indent = 0 ) const;
    159         virtual void printOneLine( std::ostream &, int indent = 0 ) const;
     159        virtual void print( std::ostream &os, int indent = 0 ) const;
     160        virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
    160161  private:
    161162        bool isLabel;
    162163};
     164
     165//##############################################################################
    163166
    164167class DesignatorNode : public ExpressionNode {
    … …  
    170173        virtual DesignatorNode *clone() const { return new DesignatorNode( *this ); }
    171174
    172         virtual void print( std::ostream &, int indent = 0 ) const;
    173         virtual void printOneLine( std::ostream &, int indent = 0 ) const;
     175        virtual void print( std::ostream &os, int indent = 0 ) const;
     176        virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
    174177  private:
    175178        bool isArrayIndex;
    176179};
     180
     181//##############################################################################
    177182
    178183class TypeValueNode : public ExpressionNode {
    … …  
    187192        virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
    188193
    189         virtual void print( std::ostream &, int indent = 0) const;
    190         virtual void printOneLine( std::ostream &, int indent = 0) const;
     194        virtual void print( std::ostream &os, int indent = 0) const;
     195        virtual void printOneLine( std::ostream &os, int indent = 0) const;
    191196  private:
    192197        DeclarationNode *decl;
    193198};
    194199
    195 class OperatorNode : public ExpressionNode {
    196   public:
    197         enum Type { TupleC, Comma, TupleFieldSel, // n-adic
    198                                 // triadic
    199                                 Cond, NCond,
    200                                 // diadic
    201                                 SizeOf, AlignOf, OffsetOf, Attr, Plus, Minus, Mul, Div, Mod, Or, And,
    202                                 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
    203                                 Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
    204                                 Index, FieldSel, PFieldSel, Range,
    205                                 // monadic
    206                                 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
    207                                 Ctor, Dtor,
    208         };
    209 
    210         OperatorNode( Type t );
    211         OperatorNode( const OperatorNode &other );
    212         virtual ~OperatorNode();
    213 
    214         virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
    215 
    216         Type get_type() const;
    217         const char *get_typename() const;
    218 
    219         virtual void print( std::ostream &, int indent = 0) const;
    220         virtual void printOneLine( std::ostream &, int indent = 0) const;
    221 
    222         virtual Expression *build() const { return 0; }
    223   private:
    224         Type type;
     200//##############################################################################
     201
     202class CompositeExprNode : public ExpressionNode {
     203  public:
     204        CompositeExprNode( Expression *expr ) : expr( expr ) {}
     205        CompositeExprNode( const CompositeExprNode &other ) : expr( other.expr->clone() ) {}
     206        virtual ~CompositeExprNode() {}
     207
     208        CompositeExprNode *clone() const { assert( false ); return new CompositeExprNode( *this ); }
     209
     210        Expression *build() const { return expr; }
     211
     212        void print( std::ostream &os, int indent = 0 ) const {}
     213        void printOneLine( std::ostream &os, int indent = 0 ) const {}
     214  private:
     215        Expression *expr;
     216};
     217
     218enum class OperKinds {
     219        // diadic
     220        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
     221        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
     222        Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
     223        Index, Range,
     224        // monadic
     225        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
     226        Ctor, Dtor,
    225227};
    226228
    … …  
    234236Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
    235237Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
    236 Expression *build_opr1( OperatorNode::Type op, ExpressionNode *expr_node );
    237 Expression *build_opr2( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     238Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node );
     239Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node );
     240Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     241Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
    238242Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
    239243Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
    240 
    241 class CompositeExprNode2 : public ExpressionNode {
    242   public:
    243         CompositeExprNode2( Expression *expr );
    244         CompositeExprNode2( const CompositeExprNode2 &other );
    245         virtual ~CompositeExprNode2();
    246 
    247         virtual CompositeExprNode2 *clone() const { return new CompositeExprNode2( *this ); }
    248         virtual Expression *build() const { return expr->clone(); }
    249 
    250         virtual void print( std::ostream &, int indent = 0) const;
    251         virtual void printOneLine( std::ostream &, int indent = 0) const;
    252   private:
    253         Expression *expr;
    254 };
    255 
    256 class CompositeExprNode : public ExpressionNode {
    257   public:
    258         CompositeExprNode();
    259         CompositeExprNode( const std::string * );
    260         CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 );
    261         CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 );
    262         CompositeExprNode( const CompositeExprNode &other );
    263         virtual ~CompositeExprNode();
    264 
    265         virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
    266         virtual Expression *build() const;
    267 
    268         virtual void print( std::ostream &, int indent = 0) const;
    269         virtual void printOneLine( std::ostream &, int indent = 0) const;
    270 
    271         void set_function( ExpressionNode * );
    272         void set_args( ExpressionNode * );
    273 
    274         void add_arg( ExpressionNode * );
    275 
    276         ExpressionNode *get_function() const;
    277         ExpressionNode *get_args() const;
    278   private:
    279         ExpressionNode *function;
    280         ExpressionNode *arguments;
    281 };
     244Expression *build_attr( VarRefNode *var, ExpressionNode * expr = 0 );
     245Expression *build_tuple( ExpressionNode * expr = 0 );
     246Expression *build_func( ExpressionNode * function, ExpressionNode * expr );
     247Expression *build_range( ExpressionNode * low, ExpressionNode *high );
     248
     249//##############################################################################
    282250
    283251class AsmExprNode : public ExpressionNode {
    … …  
    290258        virtual Expression *build() const;
    291259
    292         virtual void print( std::ostream &, int indent = 0) const;
    293         virtual void printOneLine( std::ostream &, int indent = 0) const;
     260        virtual void print( std::ostream &os, int indent = 0) const;
     261        virtual void printOneLine( std::ostream &os, int indent = 0) const;
    294262
    295263        ExpressionNode *get_inout() const { return inout; };
    … …  
    307275};
    308276
     277//##############################################################################
     278
    309279class LabelNode : public ExpressionNode {
    310280  public:
    … …  
    312282        virtual LabelNode *clone() const { return new LabelNode( *this ); }
    313283
    314         virtual void print( std::ostream &, int indent = 0) const;
    315         virtual void printOneLine( std::ostream &, int indent = 0) const;
     284        virtual void print( std::ostream &os, int indent = 0) const;
     285        virtual void printOneLine( std::ostream &os, int indent = 0) const;
    316286
    317287        const std::list< Label > &get_labels() const { return labels; };
    … …  
    320290        std::list< Label > labels;
    321291};
     292
     293//##############################################################################
    322294
    323295class ForCtlExprNode : public ExpressionNode {
    … …  
    334306        virtual Expression *build() const;
    335307
    336         virtual void print( std::ostream &, int indent = 0 ) const;
    337         virtual void printOneLine( std::ostream &, int indent = 0 ) const;
     308        virtual void print( std::ostream &os, int indent = 0 ) const;
     309        virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
    338310  private:
    339311        StatementNode *init;
    … …  
    341313        ExpressionNode *change;
    342314};
     315
     316//##############################################################################
    343317
    344318class ValofExprNode : public ExpressionNode {
    … …  
    352326
    353327        StatementNode *get_body() const { return body; }
    354         void print( std::ostream &, int indent = 0 ) const;
    355         void printOneLine( std::ostream &, int indent = 0 ) const;
     328        void print( std::ostream &os, int indent = 0 ) const;
     329        void printOneLine( std::ostream &os, int indent = 0 ) const;
    356330        Expression *build() const;
    357331
    … …  
    359333        StatementNode *body;
    360334};
     335
     336//##############################################################################
    361337
    362338class TypeData;
    … …  
    433409
    434410        DeclarationNode *clone() const;
    435         void print( std::ostream &, int indent = 0 ) const;
    436         void printList( std::ostream &, int indent = 0 ) const;
     411        void print( std::ostream &os, int indent = 0 ) const;
     412        void printList( std::ostream &os, int indent = 0 ) const;
    437413
    438414        Declaration *build() const;
    … …  
    468444}; // DeclarationNode
    469445
     446//##############################################################################
     447
    470448class StatementNode : public ParseNode {
    471449  public:
    … …  
    507485        StatementNode *append_last_case( StatementNode * );
    508486
    509         void print( std::ostream &, int indent = 0) const;
     487        void print( std::ostream &os, int indent = 0) const;
    510488        virtual StatementNode *clone() const;
    511489        virtual Statement *build() const;
    … …  
    521499}; // StatementNode
    522500
     501//##############################################################################
     502
    523503class CompoundStmtNode : public StatementNode {
    524504  public:
    … …  
    530510        void add_statement( StatementNode * );
    531511
    532         void print( std::ostream &, int indent = 0 ) const;
     512        void print( std::ostream &os, int indent = 0 ) const;
    533513        virtual Statement *build() const;
    534514  private:
    535515        StatementNode *first, *last;
    536516};
     517
     518//##############################################################################
    537519
    538520class AsmStmtNode : public StatementNode {
    … …  
    541523        ~AsmStmtNode();
    542524
    543         void print( std::ostream &, int indent = 0 ) const;
     525        void print( std::ostream &os, int indent = 0 ) const;
    544526        Statement *build() const;
    545527  private:
    … …  
    551533};
    552534
     535//##############################################################################
     536
    553537class InitializerNode : public ParseNode {
    554538  public:
    … …  
    567551        InitializerNode *next_init() const { return kids; }
    568552
    569         void print( std::ostream &, int indent = 0 ) const;
     553        void print( std::ostream &os, int indent = 0 ) const;
    570554        void printOneLine( std::ostream & ) const;
    571555
    … …  
    579563};
    580564
     565//##############################################################################
     566
    581567class CompoundLiteralNode : public ExpressionNode {
    582568  public:
    … …  
    593579        CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
    594580
    595         void print( std::ostream &, int indent = 0 ) const;
    596         void printOneLine( std::ostream &, int indent = 0 ) const;
     581        void print( std::ostream &os, int indent = 0 ) const;
     582        void printOneLine( std::ostream &os, int indent = 0 ) const;
    597583
    598584        virtual Expression *build() const;
    … …  
    631617void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
    632618
    633 // in ExpressionNode.cc
    634 ExpressionNode *flattenCommas( ExpressionNode *list );
    635 ExpressionNode *tupleContents( ExpressionNode *tuple );
    636 
    637619#endif // PARSENODE_H
    638620

  • src/Parser/StatementNode.cc

    r0853178 r04273e9  
    1010// Created On       : Sat May 16 14:59:41 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 17:21:02 2016
    13 // Update Count     : 133
     12// Last Modified On : Sun Aug  7 06:42:38 2016
     13// Update Count     : 135
    1414//
    1515
    … …  
    106106        return this;
    107107}
    108 
    109 // StatementNode *StatementNode::add_controlexp( ExpressionNode *e ) {
    110 //      if ( control && e )
    111 //              control->add_to_list( e ); // xxx - check this
    112 //      return this;
    113 // }
    114108
    115109StatementNode *StatementNode::append_block( StatementNode *stmt ) {
    … …  
    176170                } // if
    177171                if ( block ) {
    178                         os << string( indent + ParseNode::indent_by, ' ' ) << "Branches of execution: " << endl;
     172                        os << string( indent + ParseNode::indent_by, ' ' ) << "Cases: " << endl;
    179173                        block->printList( os, indent + 2 * ParseNode::indent_by );
    180174                } // if

  • src/Parser/TypeData.cc

    r0853178 r04273e9  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 13 18:03:29 2016
    13 // Update Count     : 56
     12// Last Modified On : Sun Aug  7 07:51:48 2016
     13// Update Count     : 58
    1414//
    1515
    … …  
    182182                break;
    183183          case Array:
    184                 newtype->array->dimension = maybeClone( array->dimension );
     184//PAB           newtype->array->dimension = maybeClone( array->dimension );
     185                newtype->array->dimension = array->dimension;
    185186                newtype->array->isVarLen = array->isVarLen;
    186187                newtype->array->isStatic = array->isStatic;

  • src/Parser/parser.cc

    r0853178 r04273e9  
    8989TypedefTable typedefTable;
    9090
     91void appendStr( std::string &to, std::string *from ) {
     92        // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
     93        to.insert( to.length() - 1, from->substr( 1, from->length() - 2 ) );
     94} // appendStr
     95
    9196
    9297/* Line 268 of yacc.c  */
    93 #line 94 "Parser/parser.cc"
     98#line 99 "Parser/parser.cc"
    9499
    95100/* Enabling traces.  */
    … …  
    342347
    343348/* Line 293 of yacc.c  */
    344 #line 110 "parser.yy"
     349#line 115 "parser.yy"
    345350
    346351        Token tok;
    … …  
    354359        LabelNode *label;
    355360        InitializerNode *in;
    356         OperatorNode::Type op;
     361        OperKinds op;
    357362        bool flag;
    358363
    … …  
    360365
    361366/* Line 293 of yacc.c  */
    362 #line 363 "Parser/parser.cc"
     367#line 368 "Parser/parser.cc"
    363368} YYSTYPE;
    364369# define YYSTYPE_IS_TRIVIAL 1
    … …  
    372377
    373378/* Line 343 of yacc.c  */
    374 #line 375 "Parser/parser.cc"
     379#line 380 "Parser/parser.cc"
    375380
    376381#ifdef short
    … …  
    589594
    590595/* YYFINAL -- State number of the termination state.  */
    591 #define YYFINAL  252
     596#define YYFINAL  251
    592597/* YYLAST -- Last index in YYTABLE.  */
    593 #define YYLAST   12080
     598#define YYLAST   10969
    594599
    595600/* YYNTOKENS -- Number of terminals.  */
    … …  
    598603#define YYNNTS  241
    599604/* YYNRULES -- Number of rules.  */
    600 #define YYNRULES  755
     605#define YYNRULES  754
    601606/* YYNRULES -- Number of states.  */
    602 #define YYNSTATES  1579
     607#define YYNSTATES  1577
    603608
    604609/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
    … …  
    663668     172,   175,   178,   181,   184,   187,   190,   195,   202,   204,
    664669     209,   214,   217,   222,   224,   226,   228,   230,   232,   234,
    665      236,   238,   243,   248,   250,   254,   258,   262,   264,   268,
    666      272,   274,   278,   282,   284,   288,   292,   296,   300,   302,
    667      306,   310,   312,   316,   318,   322,   324,   328,   330,   334,
    668      336,   340,   342,   348,   353,   359,   361,   363,   367,   371,
    669      374,   375,   377,   380,   386,   393,   401,   403,   407,   409,
    670      411,   413,   415,   417,   419,   421,   423,   425,   427,   429,
    671      433,   434,   436,   438,   440,   442,   444,   446,   448,   450,
    672      452,   459,   464,   467,   475,   477,   481,   483,   486,   488,
    673      491,   493,   496,   499,   505,   513,   519,   529,   535,   545,
    674      547,   551,   553,   555,   559,   563,   566,   568,   571,   574,
    675      575,   577,   580,   584,   585,   587,   590,   594,   598,   603,
    676      604,   606,   608,   611,   617,   625,   632,   639,   644,   648,
    677      653,   656,   660,   663,   667,   671,   675,   679,   685,   689,
    678      693,   698,   700,   706,   713,   719,   726,   736,   747,   757,
    679      768,   771,   773,   776,   779,   782,   784,   791,   800,   811,
    680      824,   839,   840,   842,   843,   845,   847,   851,   856,   864,
    681      865,   867,   871,   873,   877,   879,   881,   883,   887,   889,
    682      891,   893,   897,   898,   900,   904,   909,   911,   915,   917,
    683      919,   923,   927,   931,   935,   939,   942,   946,   953,   957,
    684      961,   966,   968,   971,   974,   978,   984,   993,  1001,  1009,
    685     1015,  1025,  1028,  1031,  1037,  1041,  1047,  1052,  1056,  1061,
    686     1066,  1074,  1078,  1082,  1086,  1090,  1095,  1102,  1104,  1106,
    687     1108,  1110,  1112,  1114,  1116,  1118,  1119,  1121,  1123,  1126,
    688     1128,  1130,  1132,  1134,  1136,  1138,  1140,  1141,  1147,  1149,
    689     1152,  1156,  1158,  1161,  1163,  1165,  1167,  1169,  1171,  1173,
    690     1175,  1177,  1179,  1181,  1183,  1185,  1187,  1189,  1191,  1193,
    691     1195,  1197,  1199,  1201,  1203,  1205,  1207,  1210,  1213,  1217,
    692     1221,  1223,  1227,  1229,  1232,  1235,  1238,  1243,  1248,  1253,
    693     1258,  1260,  1263,  1266,  1270,  1272,  1275,  1278,  1280,  1283,
    694     1286,  1290,  1292,  1295,  1298,  1300,  1302,  1307,  1310,  1311,
    695     1318,  1326,  1329,  1332,  1335,  1336,  1339,  1342,  1346,  1349,
    696     1353,  1355,  1358,  1362,  1365,  1368,  1373,  1374,  1376,  1379,
    697     1382,  1384,  1385,  1387,  1390,  1393,  1399,  1402,  1403,  1411,
    698     1414,  1419,  1420,  1423,  1424,  1426,  1428,  1430,  1436,  1442,
    699     1448,  1450,  1456,  1462,  1472,  1474,  1480,  1481,  1483,  1485,
    700     1491,  1493,  1495,  1501,  1507,  1509,  1513,  1517,  1522,  1524,
    701     1526,  1528,  1530,  1533,  1535,  1539,  1543,  1545,  1548,  1550,
    702     1554,  1556,  1558,  1560,  1562,  1564,  1566,  1568,  1570,  1572,
    703     1574,  1576,  1579,  1581,  1583,  1585,  1588,  1589,  1592,  1595,
    704     1597,  1602,  1603,  1605,  1608,  1612,  1617,  1620,  1623,  1625,
    705     1628,  1630,  1633,  1639,  1645,  1653,  1660,  1662,  1665,  1668,
    706     1672,  1674,  1677,  1680,  1685,  1688,  1693,  1694,  1699,  1702,
    707     1704,  1706,  1708,  1709,  1712,  1718,  1724,  1738,  1740,  1742,
    708     1746,  1750,  1753,  1757,  1761,  1764,  1769,  1771,  1778,  1788,
    709     1789,  1801,  1803,  1807,  1811,  1815,  1817,  1819,  1825,  1828,
    710     1834,  1835,  1837,  1839,  1843,  1844,  1846,  1848,  1850,  1852,
    711     1853,  1860,  1863,  1865,  1868,  1873,  1876,  1880,  1884,  1888,
    712     1893,  1899,  1905,  1911,  1918,  1920,  1922,  1924,  1928,  1929,
    713     1935,  1936,  1938,  1940,  1943,  1950,  1952,  1956,  1957,  1959,
    714     1964,  1966,  1968,  1970,  1972,  1975,  1977,  1980,  1983,  1985,
    715     1989,  1992,  1996,  2000,  2003,  2008,  2013,  2017,  2026,  2030,
    716     2033,  2035,  2038,  2045,  2054,  2058,  2061,  2065,  2069,  2074,
    717     2079,  2083,  2085,  2087,  2089,  2094,  2101,  2105,  2108,  2112,
    718     2116,  2121,  2126,  2130,  2133,  2135,  2138,  2141,  2143,  2147,
    719     2150,  2154,  2158,  2161,  2166,  2171,  2175,  2182,  2191,  2195,
    720     2198,  2200,  2203,  2206,  2209,  2213,  2217,  2220,  2225,  2230,
    721     2234,  2241,  2250,  2254,  2257,  2259,  2262,  2265,  2267,  2269,
    722     2272,  2276,  2280,  2283,  2288,  2295,  2304,  2306,  2309,  2312,
    723     2314,  2317,  2320,  2324,  2328,  2330,  2335,  2340,  2344,  2350,
    724     2359,  2363,  2366,  2370,  2372,  2378,  2384,  2391,  2398,  2400,
    725     2403,  2406,  2408,  2411,  2414,  2418,  2422,  2424,  2429,  2434,
    726     2438,  2444,  2453,  2457,  2459,  2462,  2464,  2467,  2474,  2480,
    727     2487,  2495,  2503,  2505,  2508,  2511,  2513,  2516,  2519,  2523,
    728     2527,  2529,  2534,  2539,  2543,  2552,  2556,  2558,  2560,  2563,
    729     2565,  2567,  2570,  2574,  2577,  2581,  2584,  2588,  2592,  2595,
    730     2600,  2604,  2607,  2611,  2614,  2619,  2623,  2626,  2633,  2640,
    731     2647,  2655,  2657,  2660,  2662,  2664,  2666,  2669,  2673,  2676,
    732     2680,  2683,  2687,  2691,  2696,  2699,  2703,  2708,  2711,  2717,
    733     2723,  2730,  2737,  2738,  2740,  2741
     670     236,   241,   246,   248,   252,   256,   260,   262,   266,   270,
     671     272,   276,   280,   282,   286,   290,   294,   298,   300,   304,
     672     308,   310,   314,   316,   320,   322,   326,   328,   332,   334,
     673     338,   340,   346,   351,   357,   359,   361,   365,   368,   369,
     674     371,   373,   375,   377,   379,   381,   383,   385,   387,   389,
     675     391,   393,   396,   402,   409,   417,   419,   423,   425,   429,
     676     430,   432,   434,   436,   438,   440,   442,   444,   446,   448,
     677     455,   460,   463,   471,   473,   477,   479,   482,   484,   487,
     678     489,   492,   495,   501,   509,   515,   525,   531,   541,   543,
     679     547,   549,   551,   555,   559,   562,   564,   567,   570,   571,
     680     573,   576,   580,   581,   583,   586,   590,   594,   599,   600,
     681     602,   604,   607,   613,   621,   628,   635,   640,   644,   649,
     682     652,   656,   659,   663,   667,   671,   675,   681,   685,   689,
     683     694,   696,   702,   709,   715,   722,   732,   743,   753,   764,
     684     767,   769,   772,   775,   778,   780,   787,   796,   807,   820,
     685     835,   836,   838,   839,   841,   843,   847,   852,   860,   861,
     686     863,   867,   869,   873,   875,   877,   879,   883,   885,   887,
     687     889,   893,   894,   896,   900,   905,   907,   911,   913,   915,
     688     919,   923,   927,   931,   935,   938,   942,   949,   953,   957,
     689     962,   964,   967,   970,   974,   980,   989,   997,  1005,  1011,
     690    1021,  1024,  1027,  1033,  1037,  1043,  1048,  1052,  1057,  1062,
     691    1070,  1074,  1078,  1082,  1086,  1091,  1098,  1100,  1102,  1104,
     692    1106,  1108,  1110,  1112,  1114,  1115,  1117,  1119,  1122,  1124,
     693    1126,  1128,  1130,  1132,  1134,  1136,  1137,  1143,  1145,  1148,
     694    1152,  1154,  1157,  1159,  1161,  1163,  1165,  1167,  1169,  1171,
     695    1173,  1175,  1177,  1179,  1181,  1183,  1185,  1187,  1189,  1191,
     696    1193,  1195,  1197,  1199,  1201,  1203,  1206,  1209,  1213,  1217,
     697    1219,  1223,  1225,  1228,  1231,  1234,  1239,  1244,  1249,  1254,
     698    1256,  1259,  1262,  1266,  1268,  1271,  1274,  1276,  1279,  1282,
     699    1286,  1288,  1291,  1294,  1296,  1298,  1303,  1306,  1307,  1314,
     700    1322,  1325,  1328,  1331,  1332,  1335,  1338,  1342,  1345,  1349,
     701    1351,  1354,  1358,  1361,  1364,  1369,  1370,  1372,  1375,  1378,
     702    1380,  1381,  1383,  1386,  1389,  1395,  1398,  1399,  1407,  1410,
     703    1415,  1416,  1419,  1420,  1422,  1424,  1426,  1432,  1438,  1444,
     704    1446,  1452,  1458,  1468,  1470,  1476,  1477,  1479,  1481,  1487,
     705    1489,  1491,  1497,  1503,  1505,  1509,  1513,  1518,  1520,  1522,
     706    1524,  1526,  1529,  1531,  1535,  1539,  1541,  1544,  1546,  1550,
     707    1552,  1554,  1556,  1558,  1560,  1562,  1564,  1566,  1568,  1570,
     708    1572,  1575,  1577,  1579,  1581,  1584,  1585,  1588,  1591,  1593,
     709    1598,  1599,  1601,  1604,  1608,  1613,  1616,  1619,  1621,  1624,
     710    1626,  1629,  1635,  1641,  1649,  1656,  1658,  1661,  1664,  1668,
     711    1670,  1673,  1676,  1681,  1684,  1689,  1690,  1695,  1698,  1700,
     712    1702,  1704,  1705,  1708,  1714,  1720,  1734,  1736,  1738,  1742,
     713    1746,  1749,  1753,  1757,  1760,  1765,  1767,  1774,  1784,  1785,
     714    1797,  1799,  1803,  1807,  1811,  1813,  1815,  1821,  1824,  1830,
     715    1831,  1833,  1835,  1839,  1840,  1842,  1844,  1846,  1848,  1849,
     716    1856,  1859,  1861,  1864,  1869,  1872,  1876,  1880,  1884,  1889,
     717    1895,  1901,  1907,  1914,  1916,  1918,  1920,  1924,  1925,  1931,
     718    1932,  1934,  1936,  1939,  1946,  1948,  1952,  1953,  1955,  1960,
     719    1962,  1964,  1966,  1968,  1971,  1973,  1976,  1979,  1981,  1985,
     720    1988,  1992,  1996,  1999,  2004,  2009,  2013,  2022,  2026,  2029,
     721    2031,  2034,  2041,  2050,  2054,  2057,  2061,  2065,  2070,  2075,
     722    2079,  2081,  2083,  2085,  2090,  2097,  2101,  2104,  2108,  2112,
     723    2117,  2122,  2126,  2129,  2131,  2134,  2137,  2139,  2143,  2146,
     724    2150,  2154,  2157,  2162,  2167,  2171,  2178,  2187,  2191,  2194,
     725    2196,  2199,  2202,  2205,  2209,  2213,  2216,  2221,  2226,  2230,
     726    2237,  2246,  2250,  2253,  2255,  2258,  2261,  2263,  2265,  2268,
     727    2272,  2276,  2279,  2284,  2291,  2300,  2302,  2305,  2308,  2310,
     728    2313,  2316,  2320,  2324,  2326,  2331,  2336,  2340,  2346,  2355,
     729    2359,  2362,  2366,  2368,  2374,  2380,  2387,  2394,  2396,  2399,
     730    2402,  2404,  2407,  2410,  2414,  2418,  2420,  2425,  2430,  2434,
     731    2440,  2449,  2453,  2455,  2458,  2460,  2463,  2470,  2476,  2483,
     732    2491,  2499,  2501,  2504,  2507,  2509,  2512,  2515,  2519,  2523,
     733    2525,  2530,  2535,  2539,  2548,  2552,  2554,  2556,  2559,  2561,
     734    2563,  2566,  2570,  2573,  2577,  2580,  2584,  2588,  2591,  2596,
     735    2600,  2603,  2607,  2610,  2615,  2619,  2622,  2629,  2636,  2643,
     736    2651,  2653,  2656,  2658,  2660,  2662,  2665,  2669,  2672,  2676,
     737    2679,  2683,  2687,  2692,  2695,  2699,  2704,  2707,  2713,  2719,
     738    2726,  2733,  2734,  2736,  2737
    734739};
    735740
    … …  
    749754     144,   115,    -1,   145,    -1,   144,   116,   145,    -1,    -1,
    750755     164,    -1,   139,   117,   164,    -1,   111,   134,   164,   135,
    751      112,   117,   164,    -1,   111,   134,   164,   116,   167,   135,
     756     112,   117,   164,    -1,   111,   134,   164,   116,   168,   135,
    752757     112,   117,   164,    -1,   147,    -1,   146,   116,   147,    -1,
    753758     139,    -1,   139,   113,   147,    -1,   139,   113,   111,   134,
    … …  
    759764     110,    -1,    76,    -1,    76,   109,   276,   110,    -1,    76,
    760765     109,   145,   110,    -1,    66,   148,    -1,    66,   109,   275,
    761      110,    -1,   118,    -1,   119,    -1,    94,    -1,   120,    -1,
    762      121,    -1,   122,    -1,   123,    -1,   148,    -1,   109,   275,
    763      110,   151,    -1,   109,   275,   110,   166,    -1,   151,    -1,
    764      152,   118,   151,    -1,   152,   124,   151,    -1,   152,   125,
    765      151,    -1,   152,    -1,   153,   120,   152,    -1,   153,   121,
    766      152,    -1,   153,    -1,   154,    88,   153,    -1,   154,    89,
    767      153,    -1,   154,    -1,   155,   126,   154,    -1,   155,   127,
    768      154,    -1,   155,    90,   154,    -1,   155,    91,   154,    -1,
    769      155,    -1,   156,    92,   155,    -1,   156,    93,   155,    -1,
    770      156,    -1,   157,   119,   156,    -1,   157,    -1,   158,   128,
    771      157,    -1,   158,    -1,   159,   129,   158,    -1,   159,    -1,
    772      160,    94,   159,    -1,   160,    -1,   161,    95,   160,    -1,
    773      161,    -1,   161,   130,   169,   117,   162,    -1,   161,   130,
    774      117,   162,    -1,   161,   130,   169,   117,   166,    -1,   162,
    775       -1,   162,    -1,   148,   131,   164,    -1,   148,   168,   164,
    776       -1,   166,   373,    -1,    -1,   164,    -1,   111,   112,    -1,
    777      111,   134,   164,   135,   112,    -1,   111,   134,   116,   167,
    778      135,   112,    -1,   111,   134,   164,   116,   167,   135,   112,
    779       -1,   165,    -1,   167,   116,   165,    -1,    97,    -1,    98,
    780       -1,    99,    -1,   100,    -1,   101,    -1,   102,    -1,   103,
    781       -1,   104,    -1,   105,    -1,   106,    -1,   164,    -1,   169,
    782      116,   164,    -1,    -1,   169,    -1,   172,    -1,   173,    -1,
    783      177,    -1,   178,    -1,   190,    -1,   192,    -1,   193,    -1,
    784      198,    -1,   128,   143,   114,   144,   115,   132,    -1,    72,
    785      117,   312,   171,    -1,   114,   115,    -1,   114,   134,   134,
    786      209,   174,   135,   115,    -1,   175,    -1,   174,   134,   175,
    787       -1,   212,    -1,    40,   212,    -1,   308,    -1,   171,   135,
    788       -1,   171,    -1,   176,   171,    -1,   170,   132,    -1,    41,
    789      109,   169,   110,   171,    -1,    41,   109,   169,   110,   171,
    790       42,   171,    -1,    43,   109,   169,   110,   183,    -1,    43,
    791      109,   169,   110,   114,   134,   205,   184,   115,    -1,    53,
    792      109,   169,   110,   183,    -1,    53,   109,   169,   110,   114,
    793      134,   205,   186,   115,    -1,   163,    -1,   163,    96,   163,
    794       -1,   310,    -1,   179,    -1,   180,   116,   179,    -1,    44,
    795      180,   117,    -1,    45,   117,    -1,   181,    -1,   182,   181,
    796       -1,   182,   171,    -1,    -1,   185,    -1,   182,   176,    -1,
    797      185,   182,   176,    -1,    -1,   187,    -1,   182,   189,    -1,
    798      182,   176,   188,    -1,   187,   182,   189,    -1,   187,   182,
    799      176,   188,    -1,    -1,   189,    -1,    56,    -1,    56,   132,
    800       -1,    47,   109,   169,   110,   171,    -1,    46,   171,    47,
    801      109,   169,   110,   132,    -1,    48,   109,   134,   191,   110,
    802      171,    -1,   170,   135,   132,   170,   132,   170,    -1,   212,
    803      170,   132,   170,    -1,    51,    72,   132,    -1,    51,   118,
    804      169,   132,    -1,    50,   132,    -1,    50,    72,   132,    -1,
    805       49,   132,    -1,    49,    72,   132,    -1,    52,   170,   132,
    806       -1,    61,   165,   132,    -1,    62,   165,   132,    -1,    62,
    807      165,    63,   164,   132,    -1,    57,   173,   194,    -1,    57,
    808      173,   196,    -1,    57,   173,   194,   196,    -1,   195,    -1,
    809       58,   109,    96,   110,   173,    -1,   195,    58,   109,    96,
    810      110,   173,    -1,    59,   109,    96,   110,   173,    -1,   195,
    811       59,   109,    96,   110,   173,    -1,    58,   109,   134,   134,
    812      197,   135,   110,   173,   135,    -1,   195,    58,   109,   134,
    813      134,   197,   135,   110,   173,   135,    -1,    59,   109,   134,
    814      134,   197,   135,   110,   173,   135,    -1,   195,    59,   109,
    815      134,   134,   197,   135,   110,   173,   135,    -1,    60,   173,
    816       -1,   225,    -1,   225,   309,    -1,   225,   357,    -1,   366,
    817      139,    -1,   366,    -1,    64,   199,   109,   141,   110,   132,
    818       -1,    64,   199,   109,   141,   117,   200,   110,   132,    -1,
    819       64,   199,   109,   141,   117,   200,   117,   200,   110,   132,
    820       -1,    64,   199,   109,   141,   117,   200,   117,   200,   117,
    821      203,   110,   132,    -1,    64,   199,    51,   109,   141,   117,
    822      117,   200,   117,   203,   117,   204,   110,   132,    -1,    -1,
    823       11,    -1,    -1,   201,    -1,   202,    -1,   201,   116,   202,
    824       -1,   141,   109,   163,   110,    -1,   111,   163,   112,   141,
    825      109,   163,   110,    -1,    -1,   141,    -1,   203,   116,   141,
    826       -1,   139,    -1,   204,   116,   139,    -1,   135,    -1,   206,
    827       -1,   212,    -1,   206,   134,   212,    -1,   135,    -1,   208,
    828       -1,   222,    -1,   208,   134,   222,    -1,    -1,   210,    -1,
    829       29,   211,   132,    -1,   210,    29,   211,   132,    -1,   274,
    830       -1,   211,   116,   274,    -1,   213,    -1,   222,    -1,   214,
    831      135,   132,    -1,   219,   135,   132,    -1,   216,   135,   132,
    832       -1,   293,   135,   132,    -1,   296,   135,   132,    -1,   215,
    833      277,    -1,   231,   215,   277,    -1,   214,   135,   116,   134,
    834      272,   277,    -1,   367,   272,   311,    -1,   370,   272,   311,
    835       -1,   227,   370,   272,   311,    -1,   217,    -1,   227,   217,
    836       -1,   231,   217,    -1,   231,   227,   217,    -1,   216,   135,
    837      116,   134,   272,    -1,   111,   112,   272,   109,   134,   260,
    838      135,   110,    -1,   370,   272,   109,   134,   260,   135,   110,
    839       -1,   218,   272,   109,   134,   260,   135,   110,    -1,   111,
    840      134,   262,   135,   112,    -1,   111,   134,   262,   135,   116,
    841      134,   263,   135,   112,    -1,     3,   215,    -1,     3,   217,
    842       -1,   219,   135,   116,   134,   139,    -1,     3,   225,   309,
    843       -1,   220,   135,   116,   134,   309,    -1,   227,     3,   225,
    844      309,    -1,   225,     3,   309,    -1,   225,     3,   227,   309,
    845       -1,     3,   139,   131,   164,    -1,   221,   135,   116,   134,
    846      139,   131,   164,    -1,   223,   135,   132,    -1,   220,   135,
    847      132,    -1,   221,   135,   132,    -1,   240,   135,   132,    -1,
    848      224,   309,   311,   277,    -1,   223,   116,   312,   309,   311,
    849      277,    -1,   236,    -1,   240,    -1,   242,    -1,   283,    -1,
    850      237,    -1,   241,    -1,   243,    -1,   284,    -1,    -1,   227,
    851       -1,   228,    -1,   227,   228,    -1,   229,    -1,   314,    -1,
    852       10,    -1,    12,    -1,    11,    -1,    14,    -1,    67,    -1,
    853       -1,    13,   109,   230,   286,   110,    -1,   232,    -1,   227,
    854      232,    -1,   231,   227,   232,    -1,   233,    -1,   232,   233,
    855       -1,   234,    -1,     5,    -1,     7,    -1,     4,    -1,     6,
    856       -1,     8,    -1,     9,    -1,    69,    -1,    71,    -1,    16,
    857       -1,    21,    -1,    20,    -1,    18,    -1,    19,    -1,    17,
    858       -1,    22,    -1,    23,    -1,    15,    -1,    25,    -1,    26,
    859       -1,    27,    -1,    24,    -1,   237,    -1,   231,   237,    -1,
    860      236,   233,    -1,   236,   233,   227,    -1,   236,   233,   237,
    861       -1,   238,    -1,   226,   239,   226,    -1,   235,    -1,   227,
    862      235,    -1,   238,   228,    -1,   238,   235,    -1,    28,   109,
    863      276,   110,    -1,    28,   109,   169,   110,    -1,    78,   109,
    864      276,   110,    -1,    78,   109,   169,   110,    -1,   241,    -1,
    865      231,   241,    -1,   240,   233,    -1,   240,   233,   227,    -1,
    866      244,    -1,   227,   244,    -1,   241,   228,    -1,   243,    -1,
    867      231,   243,    -1,   242,   233,    -1,   242,   233,   227,    -1,
    868       74,    -1,   227,    74,    -1,   243,   228,    -1,   245,    -1,
    869      256,    -1,   247,   114,   248,   115,    -1,   247,   274,    -1,
    870       -1,   247,   274,   246,   114,   248,   115,    -1,   247,   109,
    871      292,   110,   114,   248,   115,    -1,   247,   285,    -1,    31,
    872      312,    -1,    32,   312,    -1,    -1,   248,   249,    -1,   250,
    873      132,    -1,    40,   250,   132,    -1,   251,   132,    -1,    40,
    874      251,   132,    -1,   366,    -1,   366,   274,    -1,   250,   116,
    875      274,    -1,   250,   116,    -1,   225,   252,    -1,   251,   116,
    876      312,   252,    -1,    -1,   254,    -1,   318,   253,    -1,   331,
    877      253,    -1,   357,    -1,    -1,   254,    -1,   117,   163,    -1,
    878       30,   312,    -1,   255,   114,   258,   372,   115,    -1,   255,
    879      274,    -1,    -1,   255,   274,   257,   114,   258,   372,   115,
    880       -1,   274,   259,    -1,   258,   116,   274,   259,    -1,    -1,
    881      131,   163,    -1,    -1,   261,    -1,   263,    -1,   262,    -1,
    882      262,   135,   116,   134,   263,    -1,   263,   135,   116,   134,
    883       96,    -1,   262,   135,   116,   134,    96,    -1,   267,    -1,
    884      263,   135,   116,   134,   267,    -1,   262,   135,   116,   134,
    885      267,    -1,   262,   135,   116,   134,   263,   135,   116,   134,
    886      267,    -1,   268,    -1,   263,   135,   116,   134,   268,    -1,
    887       -1,   265,    -1,   266,    -1,   266,   135,   116,   134,    96,
    888       -1,   270,    -1,   269,    -1,   266,   135,   116,   134,   270,
    889       -1,   266,   135,   116,   134,   269,    -1,   269,    -1,   362,
    890      272,   373,    -1,   370,   272,   373,    -1,   227,   370,   272,
    891      373,    -1,   217,    -1,   270,    -1,   362,    -1,   370,    -1,
    892      227,   370,    -1,   371,    -1,   224,   336,   373,    -1,   224,
    893      340,   373,    -1,   224,    -1,   224,   351,    -1,   139,    -1,
    894      271,   116,   139,    -1,   137,    -1,    74,    -1,    75,    -1,
    895      138,    -1,    74,    -1,    75,    -1,   139,    -1,    74,    -1,
    896       75,    -1,   366,    -1,   225,    -1,   225,   357,    -1,   366,
    897       -1,   371,    -1,   225,    -1,   225,   345,    -1,    -1,   131,
    898      278,    -1,   107,   278,    -1,   164,    -1,   114,   279,   372,
    899      115,    -1,    -1,   278,    -1,   280,   278,    -1,   279,   116,
    900      278,    -1,   279,   116,   280,   278,    -1,   281,   117,    -1,
    901      274,   117,    -1,   282,    -1,   281,   282,    -1,    80,    -1,
    902      113,   274,    -1,   111,   134,   164,   135,   112,    -1,   111,
    903      134,   310,   135,   112,    -1,   111,   134,   163,    96,   163,
    904      135,   112,    -1,   113,   111,   134,   146,   135,   112,    -1,
    905      284,    -1,   231,   284,    -1,   283,   233,    -1,   283,   233,
    906      227,    -1,   285,    -1,   227,   285,    -1,   284,   228,    -1,
    907       75,   109,   292,   110,    -1,   287,   373,    -1,   286,   116,
    908      287,   373,    -1,    -1,   289,   274,   288,   290,    -1,   225,
    909      336,    -1,    33,    -1,    35,    -1,    34,    -1,    -1,   290,
    910      291,    -1,   129,   274,   109,   292,   110,    -1,   129,   114,
    911      134,   298,   115,    -1,   129,   109,   134,   286,   135,   110,
    912      114,   134,   298,   115,   109,   292,   110,    -1,   276,    -1,
    913      164,    -1,   292,   116,   276,    -1,   292,   116,   164,    -1,
    914       33,   294,    -1,   232,    33,   294,    -1,   293,   116,   294,
    915       -1,   295,   290,    -1,   295,   290,   131,   276,    -1,   274,
    916       -1,   273,   109,   134,   286,   135,   110,    -1,    36,   274,
    917      109,   134,   286,   135,   110,   114,   115,    -1,    -1,    36,
    918      274,   109,   134,   286,   135,   110,   114,   297,   298,   115,
    919       -1,   299,    -1,   298,   134,   299,    -1,   300,   135,   132,
    920       -1,   301,   135,   132,    -1,   215,    -1,   217,    -1,   300,
    921      135,   116,   134,   272,    -1,   225,   309,    -1,   301,   135,
    922      116,   134,   309,    -1,    -1,   303,    -1,   305,    -1,   303,
    923      134,   305,    -1,    -1,   303,    -1,   212,    -1,   307,    -1,
    924      198,    -1,    -1,     5,    82,   306,   114,   304,   115,    -1,
    925       40,   305,    -1,   308,    -1,   323,   173,    -1,   327,   134,
    926      207,   173,    -1,   216,   173,    -1,   224,   323,   173,    -1,
    927      227,   323,   173,    -1,   231,   323,   173,    -1,   231,   227,
    928      323,   173,    -1,   224,   327,   134,   207,   173,    -1,   227,
    929      327,   134,   207,   173,    -1,   231,   327,   134,   207,   173,
    930       -1,   231,   227,   327,   134,   207,   173,    -1,   318,    -1,
    931      331,    -1,   323,    -1,   163,   123,   163,    -1,    -1,    64,
    932      109,   141,   110,   312,    -1,    -1,   313,    -1,   314,    -1,
    933      313,   314,    -1,    39,   109,   109,   315,   110,   110,    -1,
    934      316,    -1,   315,   116,   316,    -1,    -1,   317,    -1,   317,
    935      109,   170,   110,    -1,   272,    -1,   234,    -1,   235,    -1,
    936      228,    -1,   319,   312,    -1,   320,    -1,   321,   312,    -1,
    937      322,   312,    -1,   137,    -1,   109,   319,   110,    -1,   149,
    938      318,    -1,   149,   227,   318,    -1,   109,   320,   110,    -1,
    939      319,   349,    -1,   109,   320,   110,   349,    -1,   109,   321,
    940      110,   350,    -1,   109,   321,   110,    -1,   109,   320,   110,
    941      109,   134,   264,   135,   110,    -1,   109,   322,   110,    -1,
    942      324,   312,    -1,   325,    -1,   326,   312,    -1,   319,   109,
    943      134,   264,   135,   110,    -1,   109,   325,   110,   109,   134,
    944      264,   135,   110,    -1,   109,   324,   110,    -1,   149,   323,
    945       -1,   149,   227,   323,    -1,   109,   325,   110,    -1,   109,
    946      325,   110,   349,    -1,   109,   326,   110,   350,    -1,   109,
    947      326,   110,    -1,   328,    -1,   329,    -1,   330,    -1,   319,
    948      109,   271,   110,    -1,   109,   329,   110,   109,   271,   110,
    949       -1,   109,   328,   110,    -1,   149,   327,    -1,   149,   227,
    950      327,    -1,   109,   329,   110,    -1,   109,   329,   110,   349,
    951       -1,   109,   330,   110,   350,    -1,   109,   330,   110,    -1,
    952      332,   312,    -1,   333,    -1,   334,   312,    -1,   335,   312,
    953       -1,   341,    -1,   109,   332,   110,    -1,   149,   331,    -1,
    954      149,   227,   331,    -1,   109,   333,   110,    -1,   332,   349,
    955       -1,   109,   333,   110,   349,    -1,   109,   334,   110,   350,
    956       -1,   109,   334,   110,    -1,   332,   109,   134,   264,   135,
    957      110,    -1,   109,   333,   110,   109,   134,   264,   135,   110,
    958       -1,   109,   335,   110,    -1,   319,   312,    -1,   337,    -1,
    959      338,   312,    -1,   339,   312,    -1,   149,   336,    -1,   149,
    960      227,   336,    -1,   109,   337,   110,    -1,   319,   355,    -1,
    961      109,   337,   110,   349,    -1,   109,   338,   110,   350,    -1,
    962      109,   338,   110,    -1,   319,   109,   134,   264,   135,   110,
    963       -1,   109,   337,   110,   109,   134,   264,   135,   110,    -1,
    964      109,   339,   110,    -1,   341,   312,    -1,   342,    -1,   343,
    965      312,    -1,   344,   312,    -1,    74,    -1,    75,    -1,   149,
    966      340,    -1,   149,   227,   340,    -1,   109,   342,   110,    -1,
    967      341,   355,    -1,   109,   342,   110,   355,    -1,   341,   109,
    968      134,   264,   135,   110,    -1,   109,   342,   110,   109,   134,
    969      264,   135,   110,    -1,   346,    -1,   347,   312,    -1,   348,
    970      312,    -1,   149,    -1,   149,   227,    -1,   149,   345,    -1,
    971      149,   227,   345,    -1,   109,   346,   110,    -1,   349,    -1,
    972      109,   346,   110,   349,    -1,   109,   347,   110,   350,    -1,
    973      109,   347,   110,    -1,   109,   134,   264,   135,   110,    -1,
    974      109,   346,   110,   109,   134,   264,   135,   110,    -1,   109,
    975      348,   110,    -1,   111,   112,    -1,   111,   112,   350,    -1,
    976      350,    -1,   111,   134,   164,   135,   112,    -1,   111,   134,
    977      118,   135,   112,    -1,   350,   111,   134,   164,   135,   112,
    978       -1,   350,   111,   134,   118,   135,   112,    -1,   352,    -1,
    979      353,   312,    -1,   354,   312,    -1,   149,    -1,   149,   227,
    980       -1,   149,   351,    -1,   149,   227,   351,    -1,   109,   352,
    981      110,    -1,   355,    -1,   109,   352,   110,   355,    -1,   109,
    982      353,   110,   350,    -1,   109,   353,   110,    -1,   109,   134,
    983      264,   135,   110,    -1,   109,   352,   110,   109,   134,   264,
    984      135,   110,    -1,   109,   354,   110,    -1,   356,    -1,   356,
    985      350,    -1,   350,    -1,   111,   112,    -1,   111,   134,   227,
    986      118,   135,   112,    -1,   111,   134,   227,   135,   112,    -1,
    987      111,   134,   227,   164,   135,   112,    -1,   111,   134,     7,
    988      226,   164,   135,   112,    -1,   111,   134,   227,     7,   164,
    989      135,   112,    -1,   358,    -1,   359,   312,    -1,   360,   312,
    990       -1,   149,    -1,   149,   227,    -1,   149,   357,    -1,   149,
    991      227,   357,    -1,   109,   358,   110,    -1,   349,    -1,   109,
    992      358,   110,   349,    -1,   109,   359,   110,   350,    -1,   109,
    993      359,   110,    -1,   109,   358,   110,   109,   134,   264,   135,
    994      110,    -1,   109,   360,   110,    -1,   362,    -1,   370,    -1,
    995      227,   370,    -1,   363,    -1,   364,    -1,   149,   225,    -1,
    996      227,   149,   225,    -1,   149,   371,    -1,   227,   149,   371,
    997       -1,   149,   361,    -1,   227,   149,   361,    -1,   111,   112,
    998      225,    -1,   365,   225,    -1,   111,   112,   350,   225,    -1,
    999      365,   350,   225,    -1,   350,   225,    -1,   111,   112,   363,
    1000       -1,   365,   363,    -1,   111,   112,   350,   363,    -1,   365,
    1001      350,   363,    -1,   350,   363,    -1,   111,   134,   227,   118,
    1002      135,   112,    -1,   111,   134,   227,   164,   135,   112,    -1,
    1003      111,   134,   231,   164,   135,   112,    -1,   111,   134,   231,
    1004      227,   164,   135,   112,    -1,   370,    -1,   227,   370,    -1,
    1005      367,    -1,   368,    -1,   369,    -1,   149,   225,    -1,   227,
    1006      149,   225,    -1,   149,   371,    -1,   227,   149,   371,    -1,
    1007      149,   366,    -1,   227,   149,   366,    -1,   111,   112,   225,
    1008       -1,   111,   112,   350,   225,    -1,   350,   225,    -1,   111,
    1009      112,   368,    -1,   111,   112,   350,   368,    -1,   350,   368,
    1010       -1,   111,   134,   263,   135,   112,    -1,   111,   112,   109,
    1011      260,   110,    -1,   370,   109,   134,   260,   135,   110,    -1,
    1012      218,   109,   134,   260,   135,   110,    -1,    -1,   116,    -1,
    1013       -1,   131,   164,    -1
     766     110,    -1,   118,    -1,   119,    -1,   120,    -1,   121,    -1,
     767     122,    -1,   123,    -1,   148,    -1,   109,   275,   110,   151,
     768      -1,   109,   275,   110,   167,    -1,   151,    -1,   152,   118,
     769     151,    -1,   152,   124,   151,    -1,   152,   125,   151,    -1,
     770     152,    -1,   153,   120,   152,    -1,   153,   121,   152,    -1,
     771     153,    -1,   154,    88,   153,    -1,   154,    89,   153,    -1,
     772     154,    -1,   155,   126,   154,    -1,   155,   127,   154,    -1,
     773     155,    90,   154,    -1,   155,    91,   154,    -1,   155,    -1,
     774     156,    92,   155,    -1,   156,    93,   155,    -1,   156,    -1,
     775     157,   119,   156,    -1,   157,    -1,   158,   128,   157,    -1,
     776     158,    -1,   159,   129,   158,    -1,   159,    -1,   160,    94,
     777     159,    -1,   160,    -1,   161,    95,   160,    -1,   161,    -1,
     778     161,   130,   169,   117,   162,    -1,   161,   130,   117,   162,
     779      -1,   161,   130,   169,   117,   167,    -1,   162,    -1,   162,
     780      -1,   148,   166,   164,    -1,   167,   373,    -1,    -1,   164,
     781      -1,   131,    -1,    97,    -1,    98,    -1,    99,    -1,   100,
     782      -1,   101,    -1,   102,    -1,   103,    -1,   104,    -1,   105,
     783      -1,   106,    -1,   111,   112,    -1,   111,   134,   164,   135,
     784     112,    -1,   111,   134,   116,   168,   135,   112,    -1,   111,
     785     134,   164,   116,   168,   135,   112,    -1,   165,    -1,   168,
     786     116,   165,    -1,   164,    -1,   169,   116,   164,    -1,    -1,
     787     169,    -1,   172,    -1,   173,    -1,   177,    -1,   178,    -1,
     788     190,    -1,   192,    -1,   193,    -1,   198,    -1,   128,   143,
     789     114,   144,   115,   132,    -1,    72,   117,   312,   171,    -1,
     790     114,   115,    -1,   114,   134,   134,   209,   174,   135,   115,
     791      -1,   175,    -1,   174,   134,   175,    -1,   212,    -1,    40,
     792     212,    -1,   308,    -1,   171,   135,    -1,   171,    -1,   176,
     793     171,    -1,   170,   132,    -1,    41,   109,   169,   110,   171,
     794      -1,    41,   109,   169,   110,   171,    42,   171,    -1,    43,
     795     109,   169,   110,   183,    -1,    43,   109,   169,   110,   114,
     796     134,   205,   184,   115,    -1,    53,   109,   169,   110,   183,
     797      -1,    53,   109,   169,   110,   114,   134,   205,   186,   115,
     798      -1,   163,    -1,   163,    96,   163,    -1,   310,    -1,   179,
     799      -1,   180,   116,   179,    -1,    44,   180,   117,    -1,    45,
     800     117,    -1,   181,    -1,   182,   181,    -1,   182,   171,    -1,
     801      -1,   185,    -1,   182,   176,    -1,   185,   182,   176,    -1,
     802      -1,   187,    -1,   182,   189,    -1,   182,   176,   188,    -1,
     803     187,   182,   189,    -1,   187,   182,   176,   188,    -1,    -1,
     804     189,    -1,    56,    -1,    56,   132,    -1,    47,   109,   169,
     805     110,   171,    -1,    46,   171,    47,   109,   169,   110,   132,
     806      -1,    48,   109,   134,   191,   110,   171,    -1,   170,   135,
     807     132,   170,   132,   170,    -1,   212,   170,   132,   170,    -1,
     808      51,    72,   132,    -1,    51,   118,   169,   132,    -1,    50,
     809     132,    -1,    50,    72,   132,    -1,    49,   132,    -1,    49,
     810      72,   132,    -1,    52,   170,   132,    -1,    61,   165,   132,
     811      -1,    62,   165,   132,    -1,    62,   165,    63,   164,   132,
     812      -1,    57,   173,   194,    -1,    57,   173,   196,    -1,    57,
     813     173,   194,   196,    -1,   195,    -1,    58,   109,    96,   110,
     814     173,    -1,   195,    58,   109,    96,   110,   173,    -1,    59,
     815     109,    96,   110,   173,    -1,   195,    59,   109,    96,   110,
     816     173,    -1,    58,   109,   134,   134,   197,   135,   110,   173,
     817     135,    -1,   195,    58,   109,   134,   134,   197,   135,   110,
     818     173,   135,    -1,    59,   109,   134,   134,   197,   135,   110,
     819     173,   135,    -1,   195,    59,   109,   134,   134,   197,   135,
     820     110,   173,   135,    -1,    60,   173,    -1,   225,    -1,   225,
     821     309,    -1,   225,   357,    -1,   366,   139,    -1,   366,    -1,
     822      64,   199,   109,   141,   110,   132,    -1,    64,   199,   109,
     823     141,   117,   200,   110,   132,    -1,    64,   199,   109,   141,
     824     117,   200,   117,   200,   110,   132,    -1,    64,   199,   109,
     825     141,   117,   200,   117,   200,   117,   203,   110,   132,    -1,
     826      64,   199,    51,   109,   141,   117,   117,   200,   117,   203,
     827     117,   204,   110,   132,    -1,    -1,    11,    -1,    -1,   201,
     828      -1,   202,    -1,   201,   116,   202,    -1,   141,   109,   163,
     829     110,    -1,   111,   163,   112,   141,   109,   163,   110,    -1,
     830      -1,   141,    -1,   203,   116,   141,    -1,   139,    -1,   204,
     831     116,   139,    -1,   135,    -1,   206,    -1,   212,    -1,   206,
     832     134,   212,    -1,   135,    -1,   208,    -1,   222,    -1,   208,
     833     134,   222,    -1,    -1,   210,    -1,    29,   211,   132,    -1,
     834     210,    29,   211,   132,    -1,   274,    -1,   211,   116,   274,
     835      -1,   213,    -1,   222,    -1,   214,   135,   132,    -1,   219,
     836     135,   132,    -1,   216,   135,   132,    -1,   293,   135,   132,
     837      -1,   296,   135,   132,    -1,   215,   277,    -1,   231,   215,
     838     277,    -1,   214,   135,   116,   134,   272,   277,    -1,   367,
     839     272,   311,    -1,   370,   272,   311,    -1,   227,   370,   272,
     840     311,    -1,   217,    -1,   227,   217,    -1,   231,   217,    -1,
     841     231,   227,   217,    -1,   216,   135,   116,   134,   272,    -1,
     842     111,   112,   272,   109,   134,   260,   135,   110,    -1,   370,
     843     272,   109,   134,   260,   135,   110,    -1,   218,   272,   109,
     844     134,   260,   135,   110,    -1,   111,   134,   262,   135,   112,
     845      -1,   111,   134,   262,   135,   116,   134,   263,   135,   112,
     846      -1,     3,   215,    -1,     3,   217,    -1,   219,   135,   116,
     847     134,   139,    -1,     3,   225,   309,    -1,   220,   135,   116,
     848     134,   309,    -1,   227,     3,   225,   309,    -1,   225,     3,
     849     309,    -1,   225,     3,   227,   309,    -1,     3,   139,   131,
     850     164,    -1,   221,   135,   116,   134,   139,   131,   164,    -1,
     851     223,   135,   132,    -1,   220,   135,   132,    -1,   221,   135,
     852     132,    -1,   240,   135,   132,    -1,   224,   309,   311,   277,
     853      -1,   223,   116,   312,   309,   311,   277,    -1,   236,    -1,
     854     240,    -1,   242,    -1,   283,    -1,   237,    -1,   241,    -1,
     855     243,    -1,   284,    -1,    -1,   227,    -1,   228,    -1,   227,
     856     228,    -1,   229,    -1,   314,    -1,    10,    -1,    12,    -1,
     857      11,    -1,    14,    -1,    67,    -1,    -1,    13,   109,   230,
     858     286,   110,    -1,   232,    -1,   227,   232,    -1,   231,   227,
     859     232,    -1,   233,    -1,   232,   233,    -1,   234,    -1,     5,
     860      -1,     7,    -1,     4,    -1,     6,    -1,     8,    -1,     9,
     861      -1,    69,    -1,    71,    -1,    16,    -1,    21,    -1,    20,
     862      -1,    18,    -1,    19,    -1,    17,    -1,    22,    -1,    23,
     863      -1,    15,    -1,    25,    -1,    26,    -1,    27,    -1,    24,
     864      -1,   237,    -1,   231,   237,    -1,   236,   233,    -1,   236,
     865     233,   227,    -1,   236,   233,   237,    -1,   238,    -1,   226,
     866     239,   226,    -1,   235,    -1,   227,   235,    -1,   238,   228,
     867      -1,   238,   235,    -1,    28,   109,   276,   110,    -1,    28,
     868     109,   169,   110,    -1,    78,   109,   276,   110,    -1,    78,
     869     109,   169,   110,    -1,   241,    -1,   231,   241,    -1,   240,
     870     233,    -1,   240,   233,   227,    -1,   244,    -1,   227,   244,
     871      -1,   241,   228,    -1,   243,    -1,   231,   243,    -1,   242,
     872     233,    -1,   242,   233,   227,    -1,    74,    -1,   227,    74,
     873      -1,   243,   228,    -1,   245,    -1,   256,    -1,   247,   114,
     874     248,   115,    -1,   247,   274,    -1,    -1,   247,   274,   246,
     875     114,   248,   115,    -1,   247,   109,   292,   110,   114,   248,
     876     115,    -1,   247,   285,    -1,    31,   312,    -1,    32,   312,
     877      -1,    -1,   248,   249,    -1,   250,   132,    -1,    40,   250,
     878     132,    -1,   251,   132,    -1,    40,   251,   132,    -1,   366,
     879      -1,   366,   274,    -1,   250,   116,   274,    -1,   250,   116,
     880      -1,   225,   252,    -1,   251,   116,   312,   252,    -1,    -1,
     881     254,    -1,   318,   253,    -1,   331,   253,    -1,   357,    -1,
     882      -1,   254,    -1,   117,   163,    -1,    30,   312,    -1,   255,
     883     114,   258,   372,   115,    -1,   255,   274,    -1,    -1,   255,
     884     274,   257,   114,   258,   372,   115,    -1,   274,   259,    -1,
     885     258,   116,   274,   259,    -1,    -1,   131,   163,    -1,    -1,
     886     261,    -1,   263,    -1,   262,    -1,   262,   135,   116,   134,
     887     263,    -1,   263,   135,   116,   134,    96,    -1,   262,   135,
     888     116,   134,    96,    -1,   267,    -1,   263,   135,   116,   134,
     889     267,    -1,   262,   135,   116,   134,   267,    -1,   262,   135,
     890     116,   134,   263,   135,   116,   134,   267,    -1,   268,    -1,
     891     263,   135,   116,   134,   268,    -1,    -1,   265,    -1,   266,
     892      -1,   266,   135,   116,   134,    96,    -1,   270,    -1,   269,
     893      -1,   266,   135,   116,   134,   270,    -1,   266,   135,   116,
     894     134,   269,    -1,   269,    -1,   362,   272,   373,    -1,   370,
     895     272,   373,    -1,   227,   370,   272,   373,    -1,   217,    -1,
     896     270,    -1,   362,    -1,   370,    -1,   227,   370,    -1,   371,
     897      -1,   224,   336,   373,    -1,   224,   340,   373,    -1,   224,
     898      -1,   224,   351,    -1,   139,    -1,   271,   116,   139,    -1,
     899     137,    -1,    74,    -1,    75,    -1,   138,    -1,    74,    -1,
     900      75,    -1,   139,    -1,    74,    -1,    75,    -1,   366,    -1,
     901     225,    -1,   225,   357,    -1,   366,    -1,   371,    -1,   225,
     902      -1,   225,   345,    -1,    -1,   131,   278,    -1,   107,   278,
     903      -1,   164,    -1,   114,   279,   372,   115,    -1,    -1,   278,
     904      -1,   280,   278,    -1,   279,   116,   278,    -1,   279,   116,
     905     280,   278,    -1,   281,   117,    -1,   274,   117,    -1,   282,
     906      -1,   281,   282,    -1,    80,    -1,   113,   274,    -1,   111,
     907     134,   164,   135,   112,    -1,   111,   134,   310,   135,   112,
     908      -1,   111,   134,   163,    96,   163,   135,   112,    -1,   113,
     909     111,   134,   146,   135,   112,    -1,   284,    -1,   231,   284,
     910      -1,   283,   233,    -1,   283,   233,   227,    -1,   285,    -1,
     911     227,   285,    -1,   284,   228,    -1,    75,   109,   292,   110,
     912      -1,   287,   373,    -1,   286,   116,   287,   373,    -1,    -1,
     913     289,   274,   288,   290,    -1,   225,   336,    -1,    33,    -1,
     914      35,    -1,    34,    -1,    -1,   290,   291,    -1,   129,   274,
     915     109,   292,   110,    -1,   129,   114,   134,   298,   115,    -1,
     916     129,   109,   134,   286,   135,   110,   114,   134,   298,   115,
     917     109,   292,   110,    -1,   276,    -1,   164,    -1,   292,   116,
     918     276,    -1,   292,   116,   164,    -1,    33,   294,    -1,   232,
     919      33,   294,    -1,   293,   116,   294,    -1,   295,   290,    -1,
     920     295,   290,   131,   276,    -1,   274,    -1,   273,   109,   134,
     921     286,   135,   110,    -1,    36,   274,   109,   134,   286,   135,
     922     110,   114,   115,    -1,    -1,    36,   274,   109,   134,   286,
     923     135,   110,   114,   297,   298,   115,    -1,   299,    -1,   298,
     924     134,   299,    -1,   300,   135,   132,    -1,   301,   135,   132,
     925      -1,   215,    -1,   217,    -1,   300,   135,   116,   134,   272,
     926      -1,   225,   309,    -1,   301,   135,   116,   134,   309,    -1,
     927      -1,   303,    -1,   305,    -1,   303,   134,   305,    -1,    -1,
     928     303,    -1,   212,    -1,   307,    -1,   198,    -1,    -1,     5,
     929      82,   306,   114,   304,   115,    -1,    40,   305,    -1,   308,
     930      -1,   323,   173,    -1,   327,   134,   207,   173,    -1,   216,
     931     173,    -1,   224,   323,   173,    -1,   227,   323,   173,    -1,
     932     231,   323,   173,    -1,   231,   227,   323,   173,    -1,   224,
     933     327,   134,   207,   173,    -1,   227,   327,   134,   207,   173,
     934      -1,   231,   327,   134,   207,   173,    -1,   231,   227,   327,
     935     134,   207,   173,    -1,   318,    -1,   331,    -1,   323,    -1,
     936     163,   123,   163,    -1,    -1,    64,   109,   141,   110,   312,
     937      -1,    -1,   313,    -1,   314,    -1,   313,   314,    -1,    39,
     938     109,   109,   315,   110,   110,    -1,   316,    -1,   315,   116,
     939     316,    -1,    -1,   317,    -1,   317,   109,   170,   110,    -1,
     940     272,    -1,   234,    -1,   235,    -1,   228,    -1,   319,   312,
     941      -1,   320,    -1,   321,   312,    -1,   322,   312,    -1,   137,
     942      -1,   109,   319,   110,    -1,   149,   318,    -1,   149,   227,
     943     318,    -1,   109,   320,   110,    -1,   319,   349,    -1,   109,
     944     320,   110,   349,    -1,   109,   321,   110,   350,    -1,   109,
     945     321,   110,    -1,   109,   320,   110,   109,   134,   264,   135,
     946     110,    -1,   109,   322,   110,    -1,   324,   312,    -1,   325,
     947      -1,   326,   312,    -1,   319,   109,   134,   264,   135,   110,
     948      -1,   109,   325,   110,   109,   134,   264,   135,   110,    -1,
     949     109,   324,   110,    -1,   149,   323,    -1,   149,   227,   323,
     950      -1,   109,   325,   110,    -1,   109,   325,   110,   349,    -1,
     951     109,   326,   110,   350,    -1,   109,   326,   110,    -1,   328,
     952      -1,   329,    -1,   330,    -1,   319,   109,   271,   110,    -1,
     953     109,   329,   110,   109,   271,   110,    -1,   109,   328,   110,
     954      -1,   149,   327,    -1,   149,   227,   327,    -1,   109,   329,
     955     110,    -1,   109,   329,   110,   349,    -1,   109,   330,   110,
     956     350,    -1,   109,   330,   110,    -1,   332,   312,    -1,   333,
     957      -1,   334,   312,    -1,   335,   312,    -1,   341,    -1,   109,
     958     332,   110,    -1,   149,   331,    -1,   149,   227,   331,    -1,
     959     109,   333,   110,    -1,   332,   349,    -1,   109,   333,   110,
     960     349,    -1,   109,   334,   110,   350,    -1,   109,   334,   110,
     961      -1,   332,   109,   134,   264,   135,   110,    -1,   109,   333,
     962     110,   109,   134,   264,   135,   110,    -1,   109,   335,   110,
     963      -1,   319,   312,    -1,   337,    -1,   338,   312,    -1,   339,
     964     312,    -1,   149,   336,    -1,   149,   227,   336,    -1,   109,
     965     337,   110,    -1,   319,   355,    -1,   109,   337,   110,   349,
     966      -1,   109,   338,   110,   350,    -1,   109,   338,   110,    -1,
     967     319,   109,   134,   264,   135,   110,    -1,   109,   337,   110,
     968     109,   134,   264,   135,   110,    -1,   109,   339,   110,    -1,
     969     341,   312,    -1,   342,    -1,   343,   312,    -1,   344,   312,
     970      -1,    74,    -1,    75,    -1,   149,   340,    -1,   149,   227,
     971     340,    -1,   109,   342,   110,    -1,   341,   355,    -1,   109,
     972     342,   110,   355,    -1,   341,   109,   134,   264,   135,   110,
     973      -1,   109,   342,   110,   109,   134,   264,   135,   110,    -1,
     974     346,    -1,   347,   312,    -1,   348,   312,    -1,   149,    -1,
     975     149,   227,    -1,   149,   345,    -1,   149,   227,   345,    -1,
     976     109,   346,   110,    -1,   349,    -1,   109,   346,   110,   349,
     977      -1,   109,   347,   110,   350,    -1,   109,   347,   110,    -1,
     978     109,   134,   264,   135,   110,    -1,   109,   346,   110,   109,
     979     134,   264,   135,   110,    -1,   109,   348,   110,    -1,   111,
     980     112,    -1,   111,   112,   350,    -1,   350,    -1,   111,   134,
     981     164,   135,   112,    -1,   111,   134,   118,   135,   112,    -1,
     982     350,   111,   134,   164,   135,   112,    -1,   350,   111,   134,
     983     118,   135,   112,    -1,   352,    -1,   353,   312,    -1,   354,
     984     312,    -1,   149,    -1,   149,   227,    -1,   149,   351,    -1,
     985     149,   227,   351,    -1,   109,   352,   110,    -1,   355,    -1,
     986     109,   352,   110,   355,    -1,   109,   353,   110,   350,    -1,
     987     109,   353,   110,    -1,   109,   134,   264,   135,   110,    -1,
     988     109,   352,   110,   109,   134,   264,   135,   110,    -1,   109,
     989     354,   110,    -1,   356,    -1,   356,   350,    -1,   350,    -1,
     990     111,   112,    -1,   111,   134,   227,   118,   135,   112,    -1,
     991     111,   134,   227,   135,   112,    -1,   111,   134,   227,   164,
     992     135,   112,    -1,   111,   134,     7,   226,   164,   135,   112,
     993      -1,   111,   134,   227,     7,   164,   135,   112,    -1,   358,
     994      -1,   359,   312,    -1,   360,   312,    -1,   149,    -1,   149,
     995     227,    -1,   149,   357,    -1,   149,   227,   357,    -1,   109,
     996     358,   110,    -1,   349,    -1,   109,   358,   110,   349,    -1,
     997     109,   359,   110,   350,    -1,   109,   359,   110,    -1,   109,
     998     358,   110,   109,   134,   264,   135,   110,    -1,   109,   360,
     999     110,    -1,   362,    -1,   370,    -1,   227,   370,    -1,   363,
     1000      -1,   364,    -1,   149,   225,    -1,   227,   149,   225,    -1,
     1001     149,   371,    -1,   227,   149,   371,    -1,   149,   361,    -1,
     1002     227,   149,   361,    -1,   111,   112,   225,    -1,   365,   225,
     1003      -1,   111,   112,   350,   225,    -1,   365,   350,   225,    -1,
     1004     350,   225,    -1,   111,   112,   363,    -1,   365,   363,    -1,
     1005     111,   112,   350,   363,    -1,   365,   350,   363,    -1,   350,
     1006     363,    -1,   111,   134,   227,   118,   135,   112,    -1,   111,
     1007     134,   227,   164,   135,   112,    -1,   111,   134,   231,   164,
     1008     135,   112,    -1,   111,   134,   231,   227,   164,   135,   112,
     1009      -1,   370,    -1,   227,   370,    -1,   367,    -1,   368,    -1,
     1010     369,    -1,   149,   225,    -1,   227,   149,   225,    -1,   149,
     1011     371,    -1,   227,   149,   371,    -1,   149,   366,    -1,   227,
     1012     149,   366,    -1,   111,   112,   225,    -1,   111,   112,   350,
     1013     225,    -1,   350,   225,    -1,   111,   112,   368,    -1,   111,
     1014     112,   350,   368,    -1,   350,   368,    -1,   111,   134,   263,
     1015     135,   112,    -1,   111,   112,   109,   260,   110,    -1,   370,
     1016     109,   134,   260,   135,   110,    -1,   218,   109,   134,   260,
     1017     135,   110,    -1,    -1,   116,    -1,    -1,   131,   164,    -1
    10141018};
    10151019
    … …  
    10171021static const yytype_uint16 yyrline[] =
    10181022{
    1019        0,   292,   292,   298,   307,   308,   309,   313,   314,   315,
    1020      319,   320,   324,   325,   329,   330,   334,   335,   341,   343,
    1021      345,   347,   352,   353,   359,   363,   365,   366,   368,   369,
    1022      371,   373,   375,   383,   384,   390,   391,   392,   397,   399,
    1023      404,   405,   409,   413,   415,   417,   419,   424,   427,   429,
    1024      431,   436,   439,   441,   443,   445,   447,   449,   451,   453,
    1025      455,   457,   459,   466,   467,   469,   473,   474,   475,   476,
    1026      480,   481,   483,   488,   489,   491,   493,   498,   499,   501,
    1027      506,   507,   509,   514,   515,   517,   519,   521,   526,   527,
    1028      529,   534,   535,   540,   541,   546,   547,   552,   553,   558,
    1029      559,   564,   565,   568,   570,   575,   580,   581,   583,   585,
    1030      591,   592,   598,   600,   602,   604,   609,   610,   615,   616,
    1031      617,   618,   619,   620,   621,   622,   623,   624,   628,   629,
    1032      636,   637,   643,   644,   645,   646,   647,   648,   649,   650,
    1033      651,   661,   668,   670,   680,   681,   686,   688,   694,   696,
    1034      700,   701,   706,   711,   714,   716,   718,   728,   730,   741,
    1035      742,   744,   748,   750,   754,   755,   760,   761,   765,   770,
    1036      771,   775,   777,   783,   784,   788,   790,   792,   794,   800,
    1037      801,   805,   807,   812,   814,   816,   821,   823,   828,   830,
    1038      834,   837,   841,   844,   848,   850,   854,   856,   863,   865,
    1039      867,   876,   878,   880,   882,   884,   889,   891,   893,   895,
    1040      900,   913,   914,   919,   921,   926,   930,   932,   934,   936,
    1041      938,   944,   945,   951,   952,   956,   957,   962,   964,   970,
    1042      971,   973,   978,   980,   987,   989,   993,   994,   999,  1001,
    1043     1005,  1006,  1010,  1012,  1016,  1017,  1021,  1022,  1026,  1027,
    1044     1042,  1043,  1044,  1045,  1046,  1050,  1055,  1062,  1072,  1077,
    1045     1082,  1090,  1095,  1100,  1105,  1110,  1118,  1140,  1145,  1152,
    1046     1154,  1161,  1166,  1171,  1182,  1187,  1192,  1197,  1202,  1211,
    1047     1216,  1224,  1225,  1226,  1227,  1233,  1238,  1246,  1247,  1248,
    1048     1249,  1253,  1254,  1255,  1256,  1261,  1262,  1271,  1272,  1277,
    1049     1278,  1283,  1285,  1287,  1289,  1291,  1294,  1293,  1305,  1306,
    1050     1308,  1318,  1319,  1324,  1328,  1330,  1332,  1334,  1336,  1338,
    1051     1340,  1342,  1347,  1349,  1351,  1353,  1355,  1357,  1359,  1361,
    1052     1363,  1365,  1367,  1369,  1371,  1377,  1378,  1380,  1382,  1384,
    1053     1389,  1390,  1396,  1397,  1399,  1401,  1406,  1408,  1410,  1412,
    1054     1417,  1418,  1420,  1422,  1427,  1428,  1430,  1435,  1436,  1438,
    1055     1440,  1445,  1447,  1449,  1454,  1455,  1459,  1461,  1467,  1466,
    1056     1470,  1472,  1477,  1479,  1485,  1486,  1491,  1492,  1494,  1495,
    1057     1504,  1505,  1507,  1509,  1514,  1516,  1522,  1523,  1525,  1528,
    1058     1531,  1536,  1537,  1542,  1547,  1551,  1553,  1559,  1558,  1565,
    1059     1567,  1573,  1574,  1582,  1583,  1587,  1588,  1589,  1591,  1593,
    1060     1600,  1601,  1603,  1605,  1610,  1611,  1617,  1618,  1622,  1623,
    1061     1628,  1629,  1630,  1632,  1640,  1641,  1643,  1646,  1648,  1652,
    1062     1653,  1654,  1656,  1658,  1662,  1667,  1675,  1676,  1685,  1687,
    1063     1692,  1693,  1694,  1698,  1699,  1700,  1704,  1705,  1706,  1710,
    1064     1711,  1712,  1717,  1718,  1719,  1720,  1726,  1727,  1729,  1734,
    1065     1735,  1740,  1741,  1742,  1743,  1744,  1759,  1760,  1765,  1766,
    1066     1774,  1776,  1778,  1781,  1783,  1785,  1808,  1809,  1811,  1813,
    1067     1818,  1819,  1821,  1826,  1831,  1832,  1838,  1837,  1841,  1845,
    1068     1847,  1849,  1855,  1856,  1861,  1866,  1868,  1873,  1875,  1876,
    1069     1878,  1883,  1885,  1887,  1892,  1894,  1899,  1904,  1912,  1918,
    1070     1917,  1931,  1932,  1937,  1938,  1942,  1947,  1952,  1960,  1965,
    1071     1976,  1977,  1988,  1989,  1995,  1996,  2000,  2001,  2002,  2005,
    1072     2004,  2015,  2024,  2030,  2036,  2045,  2051,  2057,  2063,  2069,
    1073     2077,  2083,  2091,  2097,  2106,  2107,  2108,  2112,  2116,  2118,
    1074     2123,  2124,  2128,  2129,  2134,  2140,  2141,  2144,  2146,  2147,
    1075     2151,  2152,  2153,  2154,  2188,  2190,  2191,  2193,  2198,  2203,
    1076     2208,  2210,  2212,  2217,  2219,  2221,  2223,  2228,  2230,  2239,
    1077     2241,  2242,  2247,  2249,  2251,  2256,  2258,  2260,  2265,  2267,
    1078     2269,  2278,  2279,  2280,  2284,  2286,  2288,  2293,  2295,  2297,
    1079     2302,  2304,  2306,  2321,  2323,  2324,  2326,  2331,  2332,  2337,
    1080     2339,  2341,  2346,  2348,  2350,  2352,  2357,  2359,  2361,  2371,
    1081     2373,  2374,  2376,  2381,  2383,  2385,  2390,  2392,  2394,  2396,
    1082     2401,  2403,  2405,  2436,  2438,  2439,  2441,  2446,  2451,  2459,
    1083     2461,  2463,  2468,  2470,  2475,  2477,  2491,  2492,  2494,  2499,
    1084     2501,  2503,  2505,  2507,  2512,  2513,  2515,  2517,  2522,  2524,
    1085     2526,  2532,  2534,  2536,  2540,  2542,  2544,  2546,  2560,  2561,
    1086     2563,  2568,  2570,  2572,  2574,  2576,  2581,  2582,  2584,  2586,
    1087     2591,  2593,  2595,  2601,  2602,  2604,  2613,  2616,  2618,  2621,
    1088     2623,  2625,  2638,  2639,  2641,  2646,  2648,  2650,  2652,  2654,
    1089     2659,  2660,  2662,  2664,  2669,  2671,  2679,  2680,  2681,  2686,
    1090     2687,  2691,  2693,  2695,  2697,  2699,  2701,  2708,  2710,  2712,
    1091     2714,  2716,  2718,  2720,  2722,  2724,  2726,  2731,  2733,  2735,
    1092     2740,  2766,  2767,  2769,  2773,  2774,  2778,  2780,  2782,  2784,
    1093     2786,  2788,  2795,  2797,  2799,  2801,  2803,  2805,  2810,  2815,
    1094     2817,  2819,  2837,  2839,  2844,  2845
     1023       0,   296,   296,   302,   311,   312,   313,   317,   318,   319,
     1024     323,   324,   328,   329,   333,   334,   338,   339,   350,   352,
     1025     354,   356,   361,   362,   368,   372,   374,   375,   377,   378,
     1026     380,   382,   384,   393,   394,   400,   401,   402,   407,   409,
     1027     414,   415,   419,   423,   425,   427,   429,   434,   437,   439,
     1028     441,   446,   459,   461,   463,   465,   467,   469,   471,   473,
     1029     475,   477,   479,   486,   487,   493,   494,   495,   496,   500,
     1030     501,   503,   508,   509,   511,   513,   518,   519,   521,   526,
     1031     527,   529,   534,   535,   537,   539,   541,   546,   547,   549,
     1032     554,   555,   560,   561,   566,   567,   572,   573,   578,   579,
     1033     584,   585,   588,   590,   595,   600,   601,   603,   609,   610,
     1034     614,   615,   616,   617,   618,   619,   620,   621,   622,   623,
     1035     624,   630,   632,   634,   636,   641,   642,   647,   648,   654,
     1036     655,   661,   662,   663,   664,   665,   666,   667,   668,   669,
     1037     679,   686,   688,   698,   699,   704,   706,   712,   714,   718,
     1038     719,   724,   729,   732,   734,   736,   746,   748,   759,   760,
     1039     762,   766,   768,   772,   773,   778,   779,   783,   788,   789,
     1040     793,   795,   801,   802,   806,   808,   810,   812,   818,   819,
     1041     823,   825,   830,   832,   834,   839,   841,   846,   848,   852,
     1042     855,   859,   862,   866,   868,   872,   874,   881,   883,   885,
     1043     894,   896,   898,   900,   902,   907,   909,   911,   913,   918,
     1044     931,   932,   937,   939,   944,   948,   950,   952,   954,   956,
     1045     962,   963,   969,   970,   974,   975,   980,   982,   988,   989,
     1046     991,   996,   998,  1005,  1007,  1011,  1012,  1017,  1019,  1023,
     1047    1024,  1028,  1030,  1034,  1035,  1039,  1040,  1044,  1045,  1060,
     1048    1061,  1062,  1063,  1064,  1068,  1073,  1080,  1090,  1095,  1100,
     1049    1108,  1113,  1118,  1123,  1128,  1136,  1158,  1163,  1170,  1172,
     1050    1179,  1184,  1189,  1200,  1205,  1210,  1215,  1220,  1229,  1234,
     1051    1242,  1243,  1244,  1245,  1251,  1256,  1264,  1265,  1266,  1267,
     1052    1271,  1272,  1273,  1274,  1279,  1280,  1289,  1290,  1295,  1296,
     1053    1301,  1303,  1305,  1307,  1309,  1312,  1311,  1323,  1324,  1326,
     1054    1336,  1337,  1342,  1346,  1348,  1350,  1352,  1354,  1356,  1358,
     1055    1360,  1365,  1367,  1369,  1371,  1373,  1375,  1377,  1379,  1381,
     1056    1383,  1385,  1387,  1389,  1395,  1396,  1398,  1400,  1402,  1407,
     1057    1408,  1414,  1415,  1417,  1419,  1424,  1426,  1428,  1430,  1435,
     1058    1436,  1438,  1440,  1445,  1446,  1448,  1453,  1454,  1456,  1458,
     1059    1463,  1465,  1467,  1472,  1473,  1477,  1479,  1485,  1484,  1488,
     1060    1490,  1495,  1497,  1503,  1504,  1509,  1510,  1512,  1513,  1522,
     1061    1523,  1525,  1527,  1532,  1534,  1540,  1541,  1543,  1546,  1549,
     1062    1554,  1555,  1560,  1565,  1569,  1571,  1577,  1576,  1583,  1585,
     1063    1591,  1592,  1600,  1601,  1605,  1606,  1607,  1609,  1611,  1618,
     1064    1619,  1621,  1623,  1628,  1629,  1635,  1636,  1640,  1641,  1646,
     1065    1647,  1648,  1650,  1658,  1659,  1661,  1664,  1666,  1670,  1671,
     1066    1672,  1674,  1676,  1680,  1685,  1693,  1694,  1703,  1705,  1710,
     1067    1711,  1712,  1716,  1717,  1718,  1722,  1723,  1724,  1728,  1729,
     1068    1730,  1735,  1736,  1737,  1738,  1744,  1745,  1747,  1752,  1753,
     1069    1758,  1759,  1760,  1761,  1762,  1777,  1778,  1783,  1784,  1792,
     1070    1794,  1796,  1799,  1801,  1803,  1826,  1827,  1829,  1831,  1836,
     1071    1837,  1839,  1844,  1849,  1850,  1856,  1855,  1859,  1863,  1865,
     1072    1867,  1873,  1874,  1879,  1884,  1886,  1891,  1893,  1894,  1896,
     1073    1901,  1903,  1905,  1910,  1912,  1917,  1922,  1930,  1936,  1935,
     1074    1949,  1950,  1955,  1956,  1960,  1965,  1970,  1978,  1983,  1994,
     1075    1995,  2006,  2007,  2013,  2014,  2018,  2019,  2020,  2023,  2022,
     1076    2033,  2042,  2048,  2054,  2063,  2069,  2075,  2081,  2087,  2095,
     1077    2101,  2109,  2115,  2124,  2125,  2126,  2130,  2134,  2136,  2141,
     1078    2142,  2146,  2147,  2152,  2158,  2159,  2162,  2164,  2165,  2169,
     1079    2170,  2171,  2172,  2206,  2208,  2209,  2211,  2216,  2221,  2226,
     1080    2228,  2230,  2235,  2237,  2239,  2241,  2246,  2248,  2257,  2259,
     1081    2260,  2265,  2267,  2269,  2274,  2276,  2278,  2283,  2285,  2287,
     1082    2296,  2297,  2298,  2302,  2304,  2306,  2311,  2313,  2315,  2320,
     1083    2322,  2324,  2339,  2341,  2342,  2344,  2349,  2350,  2355,  2357,
     1084    2359,  2364,  2366,  2368,  2370,  2375,  2377,  2379,  2389,  2391,
     1085    2392,  2394,  2399,  2401,  2403,  2408,  2410,  2412,  2414,  2419,
     1086    2421,  2423,  2454,  2456,  2457,  2459,  2464,  2469,  2477,  2479,
     1087    2481,  2486,  2488,  2493,  2495,  2509,  2510,  2512,  2517,  2519,
     1088    2521,  2523,  2525,  2530,  2531,  2533,  2535,  2540,  2542,  2544,
     1089    2550,  2552,  2554,  2558,  2560,  2562,  2564,  2578,  2579,  2581,
     1090    2586,  2588,  2590,  2592,  2594,  2599,  2600,  2602,  2604,  2609,
     1091    2611,  2613,  2619,  2620,  2622,  2631,  2634,  2636,  2639,  2641,
     1092    2643,  2656,  2657,  2659,  2664,  2666,  2668,  2670,  2672,  2677,
     1093    2678,  2680,  2682,  2687,  2689,  2697,  2698,  2699,  2704,  2705,
     1094    2709,  2711,  2713,  2715,  2717,  2719,  2726,  2728,  2730,  2732,
     1095    2734,  2736,  2738,  2740,  2742,  2744,  2749,  2751,  2753,  2758,
     1096    2784,  2785,  2787,  2791,  2792,  2796,  2798,  2800,  2802,  2804,
     1097    2806,  2813,  2815,  2817,  2819,  2821,  2823,  2828,  2833,  2835,
     1098    2837,  2855,  2857,  2862,  2863
    10951099};
    10961100#endif
    … …  
    11301134  "logical_AND_expression", "logical_OR_expression",
    11311135  "conditional_expression", "constant_expression", "assignment_expression",
    1132   "assignment_expression_opt", "tuple", "tuple_expression_list",
    1133   "assignment_operator", "comma_expression", "comma_expression_opt",
     1136  "assignment_expression_opt", "assignment_operator", "tuple",
     1137  "tuple_expression_list", "comma_expression", "comma_expression_opt",
    11341138  "statement", "labeled_statement", "compound_statement",
    11351139  "block_item_list", "block_item", "statement_list",
    … …  
    12401244     146,   146,   147,   147,   147,   147,   147,   148,   148,   148,
    12411245     148,   148,   148,   148,   148,   148,   148,   148,   148,   148,
    1242      148,   148,   148,   149,   149,   149,   150,   150,   150,   150,
    1243      151,   151,   151,   152,   152,   152,   152,   153,   153,   153,
    1244      154,   154,   154,   155,   155,   155,   155,   155,   156,   156,
    1245      156,   157,   157,   158,   158,   159,   159,   160,   160,   161,
    1246      161,   162,   162,   162,   162,   163,   164,   164,   164,   164,
    1247      165,   165,   166,   166,   166,   166,   167,   167,   168,   168,
    1248      168,   168,   168,   168,   168,   168,   168,   168,   169,   169,
    1249      170,   170,   171,   171,   171,   171,   171,   171,   171,   171,
    1250      171,   172,   173,   173,   174,   174,   175,   175,   175,   175,
    1251      176,   176,   177,   178,   178,   178,   178,   178,   178,   179,
    1252      179,   179,   180,   180,   181,   181,   182,   182,   183,   184,
    1253      184,   185,   185,   186,   186,   187,   187,   187,   187,   188,
    1254      188,   189,   189,   190,   190,   190,   191,   191,   192,   192,
    1255      192,   192,   192,   192,   192,   192,   192,   192,   193,   193,
    1256      193,   194,   194,   194,   194,   194,   195,   195,   195,   195,
    1257      196,   197,   197,   197,   197,   197,   198,   198,   198,   198,
    1258      198,   199,   199,   200,   200,   201,   201,   202,   202,   203,
    1259      203,   203,   204,   204,   205,   205,   206,   206,   207,   207,
    1260      208,   208,   209,   209,   210,   210,   211,   211,   212,   212,
    1261      213,   213,   213,   213,   213,   214,   214,   214,   215,   215,
    1262      215,   216,   216,   216,   216,   216,   217,   217,   217,   218,
    1263      218,   219,   219,   219,   220,   220,   220,   220,   220,   221,
    1264      221,   222,   222,   222,   222,   223,   223,   224,   224,   224,
    1265      224,   225,   225,   225,   225,   226,   226,   227,   227,   228,
    1266      228,   229,   229,   229,   229,   229,   230,   229,   231,   231,
    1267      231,   232,   232,   233,   234,   234,   234,   234,   234,   234,
    1268      234,   234,   235,   235,   235,   235,   235,   235,   235,   235,
    1269      235,   235,   235,   235,   235,   236,   236,   236,   236,   236,
    1270      237,   237,   238,   238,   238,   238,   239,   239,   239,   239,
    1271      240,   240,   240,   240,   241,   241,   241,   242,   242,   242,
    1272      242,   243,   243,   243,   244,   244,   245,   245,   246,   245,
    1273      245,   245,   247,   247,   248,   248,   249,   249,   249,   249,
    1274      250,   250,   250,   250,   251,   251,   252,   252,   252,   252,
    1275      252,   253,   253,   254,   255,   256,   256,   257,   256,   258,
    1276      258,   259,   259,   260,   260,   261,   261,   261,   261,   261,
    1277      262,   262,   262,   262,   263,   263,   264,   264,   265,   265,
    1278      266,   266,   266,   266,   267,   267,   267,   267,   267,   268,
    1279      268,   268,   268,   268,   269,   269,   270,   270,   271,   271,
    1280      272,   272,   272,   273,   273,   273,   274,   274,   274,   275,
    1281      275,   275,   276,   276,   276,   276,   277,   277,   277,   278,
    1282      278,   279,   279,   279,   279,   279,   280,   280,   281,   281,
    1283      282,   282,   282,   282,   282,   282,   283,   283,   283,   283,
    1284      284,   284,   284,   285,   286,   286,   288,   287,   287,   289,
    1285      289,   289,   290,   290,   291,   291,   291,   292,   292,   292,
    1286      292,   293,   293,   293,   294,   294,   295,   295,   296,   297,
    1287      296,   298,   298,   299,   299,   300,   300,   300,   301,   301,
    1288      302,   302,   303,   303,   304,   304,   305,   305,   305,   306,
    1289      305,   305,   307,   307,   307,   308,   308,   308,   308,   308,
    1290      308,   308,   308,   308,   309,   309,   309,   310,   311,   311,
    1291      312,   312,   313,   313,   314,   315,   315,   316,   316,   316,
    1292      317,   317,   317,   317,   318,   318,   318,   318,   319,   319,
    1293      320,   320,   320,   321,   321,   321,   321,   322,   322,   323,
    1294      323,   323,   324,   324,   324,   325,   325,   325,   326,   326,
    1295      326,   327,   327,   327,   328,   328,   328,   329,   329,   329,
    1296      330,   330,   330,   331,   331,   331,   331,   332,   332,   333,
    1297      333,   333,   334,   334,   334,   334,   335,   335,   335,   336,
    1298      336,   336,   336,   337,   337,   337,   338,   338,   338,   338,
    1299      339,   339,   339,   340,   340,   340,   340,   341,   341,   342,
    1300      342,   342,   343,   343,   344,   344,   345,   345,   345,   346,
    1301      346,   346,   346,   346,   347,   347,   347,   347,   348,   348,
    1302      348,   349,   349,   349,   350,   350,   350,   350,   351,   351,
    1303      351,   352,   352,   352,   352,   352,   353,   353,   353,   353,
    1304      354,   354,   354,   355,   355,   355,   356,   356,   356,   356,
    1305      356,   356,   357,   357,   357,   358,   358,   358,   358,   358,
    1306      359,   359,   359,   359,   360,   360,   361,   361,   361,   362,
    1307      362,   363,   363,   363,   363,   363,   363,   364,   364,   364,
    1308      364,   364,   364,   364,   364,   364,   364,   365,   365,   365,
    1309      365,   366,   366,   366,   367,   367,   368,   368,   368,   368,
    1310      368,   368,   369,   369,   369,   369,   369,   369,   370,   371,
    1311      371,   371,   372,   372,   373,   373
     1246     148,   148,   148,   149,   149,   150,   150,   150,   150,   151,
     1247     151,   151,   152,   152,   152,   152,   153,   153,   153,   154,
     1248     154,   154,   155,   155,   155,   155,   155,   156,   156,   156,
     1249     157,   157,   158,   158,   159,   159,   160,   160,   161,   161,
     1250     162,   162,   162,   162,   163,   164,   164,   164,   165,   165,
     1251     166,   166,   166,   166,   166,   166,   166,   166,   166,   166,
     1252     166,   167,   167,   167,   167,   168,   168,   169,   169,   170,
     1253     170,   171,   171,   171,   171,   171,   171,   171,   171,   171,
     1254     172,   173,   173,   174,   174,   175,   175,   175,   175,   176,
     1255     176,   177,   178,   178,   178,   178,   178,   178,   179,   179,
     1256     179,   180,   180,   181,   181,   182,   182,   183,   184,   184,
     1257     185,   185,   186,   186,   187,   187,   187,   187,   188,   188,
     1258     189,   189,   190,   190,   190,   191,   191,   192,   192,   192,
     1259     192,   192,   192,   192,   192,   192,   192,   193,   193,   193,
     1260     194,   194,   194,   194,   194,   195,   195,   195,   195,   196,
     1261     197,   197,   197,   197,   197,   198,   198,   198,   198,   198,
     1262     199,   199,   200,   200,   201,   201,   202,   202,   203,   203,
     1263     203,   204,   204,   205,   205,   206,   206,   207,   207,   208,
     1264     208,   209,   209,   210,   210,   211,   211,   212,   212,   213,
     1265     213,   213,   213,   213,   214,   214,   214,   215,   215,   215,
     1266     216,   216,   216,   216,   216,   217,   217,   217,   218,   218,
     1267     219,   219,   219,   220,   220,   220,   220,   220,   221,   221,
     1268     222,   222,   222,   222,   223,   223,   224,   224,   224,   224,
     1269     225,   225,   225,   225,   226,   226,   227,   227,   228,   228,
     1270     229,   229,   229,   229,   229,   230,   229,   231,   231,   231,
     1271     232,   232,   233,   234,   234,   234,   234,   234,   234,   234,
     1272     234,   235,   235,   235,   235,   235,   235,   235,   235,   235,
     1273     235,   235,   235,   235,   236,   236,   236,   236,   236,   237,
     1274     237,   238,   238,   238,   238,   239,   239,   239,   239,   240,
     1275     240,   240,   240,   241,   241,   241,   242,   242,   242,   242,
     1276     243,   243,   243,   244,   244,   245,   245,   246,   245,   245,
     1277     245,   247,   247,   248,   248,   249,   249,   249,   249,   250,
     1278     250,   250,   250,   251,   251,   252,   252,   252,   252,   252,
     1279     253,   253,   254,   255,   256,   256,   257,   256,   258,   258,
     1280     259,   259,   260,   260,   261,   261,   261,   261,   261,   262,
     1281     262,   262,   262,   263,   263,   264,   264,   265,   265,   266,
     1282     266,   266,   266,   267,   267,   267,   267,   267,   268,   268,
     1283     268,   268,   268,   269,   269,   270,   270,   271,   271,   272,
     1284     272,   272,   273,   273,   273,   274,   274,   274,   275,   275,
     1285     275,   276,   276,   276,   276,   277,   277,   277,   278,   278,
     1286     279,   279,   279,   279,   279,   280,   280,   281,   281,   282,
     1287     282,   282,   282,   282,   282,   283,   283,   283,   283,   284,
     1288     284,   284,   285,   286,   286,   288,   287,   287,   289,   289,
     1289     289,   290,   290,   291,   291,   291,   292,   292,   292,   292,
     1290     293,   293,   293,   294,   294,   295,   295,   296,   297,   296,
     1291     298,   298,   299,   299,   300,   300,   300,   301,   301,   302,
     1292     302,   303,   303,   304,   304,   305,   305,   305,   306,   305,
     1293     305,   307,   307,   307,   308,   308,   308,   308,   308,   308,
     1294     308,   308,   308,   309,   309,   309,   310,   311,   311,   312,
     1295     312,   313,   313,   314,   315,   315,   316,   316,   316,   317,
     1296     317,   317,   317,   318,   318,   318,   318,   319,   319,   320,
     1297     320,   320,   321,   321,   321,   321,   322,   322,   323,   323,
     1298     323,   324,   324,   324,   325,   325,   325,   326,   326,   326,
     1299     327,   327,   327,   328,   328,   328,   329,   329,   329,   330,
     1300     330,   330,   331,   331,   331,   331,   332,   332,   333,   333,
     1301     333,   334,   334,   334,   334,   335,   335,   335,   336,   336,
     1302     336,   336,   337,   337,   337,   338,   338,   338,   338,   339,
     1303     339,   339,   340,   340,   340,   340,   341,   341,   342,   342,
     1304     342,   343,   343,   344,   344,   345,   345,   345,   346,   346,
     1305     346,   346,   346,   347,   347,   347,   347,   348,   348,   348,
     1306     349,   349,   349,   350,   350,   350,   350,   351,   351,   351,
     1307     352,   352,   352,   352,   352,   353,   353,   353,   353,   354,
     1308     354,   354,   355,   355,   355,   356,   356,   356,   356,   356,
     1309     356,   357,   357,   357,   358,   358,   358,   358,   358,   359,
     1310     359,   359,   359,   360,   360,   361,   361,   361,   362,   362,
     1311     363,   363,   363,   363,   363,   363,   364,   364,   364,   364,
     1312     364,   364,   364,   364,   364,   364,   365,   365,   365,   365,
     1313     366,   366,   366,   367,   367,   368,   368,   368,   368,   368,
     1314     368,   369,   369,   369,   369,   369,   369,   370,   371,   371,
     1315     371,   372,   372,   373,   373
    13121316};
    13131317
    … …  
    13221326       2,     2,     2,     2,     2,     2,     4,     6,     1,     4,
    13231327       4,     2,     4,     1,     1,     1,     1,     1,     1,     1,
    1324        1,     4,     4,     1,     3,     3,     3,     1,     3,     3,
    1325        1,     3,     3,     1,     3,     3,     3,     3,     1,     3,
    1326        3,     1,     3,     1,     3,     1,     3,     1,     3,     1,
    1327        3,     1,     5,     4,     5,     1,     1,     3,     3,     2,
    1328        0,     1,     2,     5,     6,     7,     1,     3,     1,     1,
    1329        1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
    1330        0,     1,     1,     1,     1,     1,     1,     1,     1,     1,
    1331        6,     4,     2,     7,     1,     3,     1,     2,     1,     2,
    1332        1,     2,     2,     5,     7,     5,     9,     5,     9,     1,
    1333        3,     1,     1,     3,     3,     2,     1,     2,     2,     0,
    1334        1,     2,     3,     0,     1,     2,     3,     3,     4,     0,
    1335        1,     1,     2,     5,     7,     6,     6,     4,     3,     4,
    1336        2,     3,     2,     3,     3,     3,     3,     5,     3,     3,
    1337        4,     1,     5,     6,     5,     6,     9,    10,     9,    10,
    1338        2,     1,     2,     2,     2,     1,     6,     8,    10,    12,
    1339       14,     0,     1,     0,     1,     1,     3,     4,     7,     0,
    1340        1,     3,     1,     3,     1,     1,     1,     3,     1,     1,
    1341        1,     3,     0,     1,     3,     4,     1,     3,     1,     1,
    1342        3,     3,     3,     3,     3,     2,     3,     6,     3,     3,
    1343        4,     1,     2,     2,     3,     5,     8,     7,     7,     5,
    1344        9,     2,     2,     5,     3,     5,     4,     3,     4,     4,
    1345        7,     3,     3,     3,     3,     4,     6,     1,     1,     1,
    1346        1,     1,     1,     1,     1,     0,     1,     1,     2,     1,
    1347        1,     1,     1,     1,     1,     1,     0,     5,     1,     2,
    1348        3,     1,     2,     1,     1,     1,     1,     1,     1,     1,
     1328       4,     4,     1,     3,     3,     3,     1,     3,     3,     1,
     1329       3,     3,     1,     3,     3,     3,     3,     1,     3,     3,
     1330       1,     3,     1,     3,     1,     3,     1,     3,     1,     3,
     1331       1,     5,     4,     5,     1,     1,     3,     2,     0,     1,
    13491332       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
    1350        1,     1,     1,     1,     1,     1,     2,     2,     3,     3,
    1351        1,     3,     1,     2,     2,     2,     4,     4,     4,     4,
    1352        1,     2,     2,     3,     1,     2,     2,     1,     2,     2,
    1353        3,     1,     2,     2,     1,     1,     4,     2,     0,     6,
    1354        7,     2,     2,     2,     0,     2,     2,     3,     2,     3,
    1355        1,     2,     3,     2,     2,     4,     0,     1,     2,     2,
    1356        1,     0,     1,     2,     2,     5,     2,     0,     7,     2,
    1357        4,     0,     2,     0,     1,     1,     1,     5,     5,     5,
    1358        1,     5,     5,     9,     1,     5,     0,     1,     1,     5,
    1359        1,     1,     5,     5,     1,     3,     3,     4,     1,     1,
    1360        1,     1,     2,     1,     3,     3,     1,     2,     1,     3,
     1333       1,     2,     5,     6,     7,     1,     3,     1,     3,     0,
     1334       1,     1,     1,     1,     1,     1,     1,     1,     1,     6,
     1335       4,     2,     7,     1,     3,     1,     2,     1,     2,     1,
     1336       2,     2,     5,     7,     5,     9,     5,     9,     1,     3,
     1337       1,     1,     3,     3,     2,     1,     2,     2,     0,     1,
     1338       2,     3,     0,     1,     2,     3,     3,     4,     0,     1,
     1339       1,     2,     5,     7,     6,     6,     4,     3,     4,     2,
     1340       3,     2,     3,     3,     3,     3,     5,     3,     3,     4,
     1341       1,     5,     6,     5,     6,     9,    10,     9,    10,     2,
     1342       1,     2,     2,     2,     1,     6,     8,    10,    12,    14,
     1343       0,     1,     0,     1,     1,     3,     4,     7,     0,     1,
     1344       3,     1,     3,     1,     1,     1,     3,     1,     1,     1,
     1345       3,     0,     1,     3,     4,     1,     3,     1,     1,     3,
     1346       3,     3,     3,     3,     2,     3,     6,     3,     3,     4,
     1347       1,     2,     2,     3,     5,     8,     7,     7,     5,     9,
     1348       2,     2,     5,     3,     5,     4,     3,     4,     4,     7,
     1349       3,     3,     3,     3,     4,     6,     1,     1,     1,     1,
     1350       1,     1,     1,     1,     0,     1,     1,     2,     1,     1,
     1351       1,     1,     1,     1,     1,     0,     5,     1,     2,     3,
     1352       1,     2,     1,     1,     1,     1,     1,     1,     1,     1,
    13611353       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
    1362        1,     2,     1,     1,     1,     2,     0,     2,     2,     1,
    1363        4,     0,     1,     2,     3,     4,     2,     2,     1,     2,
    1364        1,     2,     5,     5,     7,     6,     1,     2,     2,     3,
    1365        1,     2,     2,     4,     2,     4,     0,     4,     2,     1,
    1366        1,     1,     0,     2,     5,     5,    13,     1,     1,     3,
    1367        3,     2,     3,     3,     2,     4,     1,     6,     9,     0,
    1368       11,     1,     3,     3,     3,     1,     1,     5,     2,     5,
    1369        0,     1,     1,     3,     0,     1,     1,     1,     1,     0,
    1370        6,     2,     1,     2,     4,     2,     3,     3,     3,     4,
    1371        5,     5,     5,     6,     1,     1,     1,     3,     0,     5,
    1372        0,     1,     1,     2,     6,     1,     3,     0,     1,     4,
    1373        1,     1,     1,     1,     2,     1,     2,     2,     1,     3,
    1374        2,     3,     3,     2,     4,     4,     3,     8,     3,     2,
    1375        1,     2,     6,     8,     3,     2,     3,     3,     4,     4,
    1376        3,     1,     1,     1,     4,     6,     3,     2,     3,     3,
    1377        4,     4,     3,     2,     1,     2,     2,     1,     3,     2,
    1378        3,     3,     2,     4,     4,     3,     6,     8,     3,     2,
    1379        1,     2,     2,     2,     3,     3,     2,     4,     4,     3,
    1380        6,     8,     3,     2,     1,     2,     2,     1,     1,     2,
    1381        3,     3,     2,     4,     6,     8,     1,     2,     2,     1,
    1382        2,     2,     3,     3,     1,     4,     4,     3,     5,     8,
    1383        3,     2,     3,     1,     5,     5,     6,     6,     1,     2,
    1384        2,     1,     2,     2,     3,     3,     1,     4,     4,     3,
    1385        5,     8,     3,     1,     2,     1,     2,     6,     5,     6,
    1386        7,     7,     1,     2,     2,     1,     2,     2,     3,     3,
    1387        1,     4,     4,     3,     8,     3,     1,     1,     2,     1,
    1388        1,     2,     3,     2,     3,     2,     3,     3,     2,     4,
    1389        3,     2,     3,     2,     4,     3,     2,     6,     6,     6,
    1390        7,     1,     2,     1,     1,     1,     2,     3,     2,     3,
    1391        2,     3,     3,     4,     2,     3,     4,     2,     5,     5,
    1392        6,     6,     0,     1,     0,     2
     1354       1,     1,     1,     1,     1,     2,     2,     3,     3,     1,
     1355       3,     1,     2,     2,     2,     4,     4,     4,     4,     1,
     1356       2,     2,     3,     1,     2,     2,     1,     2,     2,     3,
     1357       1,     2,     2,     1,     1,     4,     2,     0,     6,     7,
     1358       2,     2,     2,     0,     2,     2,     3,     2,     3,     1,
     1359       2,     3,     2,     2,     4,     0,     1,     2,     2,     1,
     1360       0,     1,     2,     2,     5,     2,     0,     7,     2,     4,
     1361       0,     2,     0,     1,     1,     1,     5,     5,     5,     1,
     1362       5,     5,     9,     1,     5,     0,     1,     1,     5,     1,
     1363       1,     5,     5,     1,     3,     3,     4,     1,     1,     1,
     1364       1,     2,     1,     3,     3,     1,     2,     1,     3,     1,
     1365       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1366       2,     1,     1,     1,     2,     0,     2,     2,     1,     4,
     1367       0,     1,     2,     3,     4,     2,     2,     1,     2,     1,
     1368       2,     5,     5,     7,     6,     1,     2,     2,     3,     1,
     1369       2,     2,     4,     2,     4,     0,     4,     2,     1,     1,
     1370       1,     0,     2,     5,     5,    13,     1,     1,     3,     3,
     1371       2,     3,     3,     2,     4,     1,     6,     9,     0,    11,
     1372       1,     3,     3,     3,     1,     1,     5,     2,     5,     0,
     1373       1,     1,     3,     0,     1,     1,     1,     1,     0,     6,
     1374       2,     1,     2,     4,     2,     3,     3,     3,     4,     5,
     1375       5,     5,     6,     1,     1,     1,     3,     0,     5,     0,
     1376       1,     1,     2,     6,     1,     3,     0,     1,     4,     1,
     1377       1,     1,     1,     2,     1,     2,     2,     1,     3,     2,
     1378       3,     3,     2,     4,     4,     3,     8,     3,     2,     1,
     1379       2,     6,     8,     3,     2,     3,     3,     4,     4,     3,
     1380       1,     1,     1,     4,     6,     3,     2,     3,     3,     4,
     1381       4,     3,     2,     1,     2,     2,     1,     3,     2,     3,
     1382       3,     2,     4,     4,     3,     6,     8,     3,     2,     1,
     1383       2,     2,     2,     3,     3,     2,     4,     4,     3,     6,
     1384       8,     3,     2,     1,     2,     2,     1,     1,     2,     3,
     1385       3,     2,     4,     6,     8,     1,     2,     2,     1,     2,
     1386       2,     3,     3,     1,     4,     4,     3,     5,     8,     3,
     1387       2,     3,     1,     5,     5,     6,     6,     1,     2,     2,
     1388       1,     2,     2,     3,     3,     1,     4,     4,     3,     5,
     1389       8,     3,     1,     2,     1,     2,     6,     5,     6,     7,
     1390       7,     1,     2,     2,     1,     2,     2,     3,     3,     1,
     1391       4,     4,     3,     8,     3,     1,     1,     2,     1,     1,
     1392       2,     3,     2,     3,     2,     3,     3,     2,     4,     3,
     1393       2,     3,     2,     4,     3,     2,     6,     6,     6,     7,
     1394       1,     2,     1,     1,     1,     2,     3,     2,     3,     2,
     1395       3,     3,     4,     2,     3,     4,     2,     5,     5,     6,
     1396       6,     0,     1,     0,     2
    13931397};
    13941398
    … …  
    13981402static const yytype_uint16 yydefact[] =
    13991403{
    1400      295,   295,   316,   314,   317,   315,   318,   319,   301,   303,
    1401      302,     0,   304,   330,   322,   327,   325,   326,   324,   323,
    1402      328,   329,   334,   331,   332,   333,   550,   550,   550,     0,
    1403        0,     0,   295,   221,   305,   320,   321,     7,   361,     0,
    1404        8,    14,    15,    65,     0,     2,    63,    64,   568,     9,
    1405      295,   528,   526,   248,     3,   456,     3,   261,     0,     3,
    1406        3,     3,   249,     3,     0,     0,     0,   296,   297,   299,
    1407      295,   308,   311,   313,   342,   287,   335,   340,   288,   350,
    1408      289,   357,   354,   364,     0,     0,   365,   290,   476,   480,
    1409        3,     3,     0,     2,   522,   527,   532,   300,     0,     0,
    1410      550,   580,   550,     2,   591,   592,   593,   295,     0,   734,
    1411      735,     0,    12,     0,    13,   295,   271,   272,     0,   296,
    1412      291,   292,   293,   294,   529,   306,   394,   551,   552,   372,
    1413      373,    12,   447,   448,    11,   443,   446,     0,   506,   501,
    1414      492,   447,   448,     0,     0,   531,   222,     0,   295,     0,
    1415        0,     0,     0,     0,     0,     0,     0,   295,   295,     2,
    1416        0,   736,   296,   585,   597,   740,   733,   731,   738,     0,
    1417        0,     0,   255,     2,     0,   535,   441,   442,   440,     0,
    1418        0,     0,     0,   550,     0,   637,   638,     0,     0,   548,
    1419      544,   550,   565,   550,   550,   546,     2,   545,   550,   604,
    1420      550,   550,   607,     0,     0,     0,   295,   295,   314,   362,
    1421        2,   295,   262,   298,   309,   343,   355,   481,     0,     2,
    1422        0,   456,   263,   296,   336,   351,   358,   477,     0,     2,
    1423        0,   312,   337,   344,   345,     0,   352,   356,   359,   363,
    1424      448,   295,   374,   367,   371,     0,   396,   478,   482,     0,
    1425        0,     0,     1,   295,     2,   533,   579,   581,   295,     2,
    1426      744,   296,   747,   548,   548,     0,   296,     0,     0,   274,
    1427      550,   546,     2,   295,     0,     0,   295,   553,     2,   504,
    1428        2,   557,     0,     0,     0,     0,     0,     0,    18,    58,
    1429        4,     5,     6,    16,     0,     0,   295,     2,    66,    67,
    1430       68,    69,    48,    19,    49,    22,    47,    70,   295,     0,
    1431       73,    77,    80,    83,    88,    91,    93,    95,    97,    99,
    1432      101,   106,   498,   754,   454,   497,     0,   452,   453,     0,
    1433      569,   584,   587,   590,   596,   599,   602,   361,     0,     2,
    1434      742,     0,   295,   745,     2,    63,   295,     3,   428,     0,
    1435      436,   296,   295,   308,   335,   288,   350,   357,     3,     3,
    1436      410,   414,   424,   429,   476,   295,   430,   709,   710,   295,
    1437      431,   433,   295,     2,   586,   598,   732,     2,     2,   250,
    1438        2,   461,     0,   459,   458,   457,   142,     2,     2,   252,
    1439        2,     2,   251,     2,   282,     2,   283,     0,   281,     0,
    1440        0,     0,     0,     0,     0,     0,     0,     0,   570,   609,
    1441        0,   456,     2,   564,   573,   663,   566,   567,   536,   295,
    1442        2,   603,   612,   605,   606,     0,   277,   295,   295,   341,
    1443      296,     0,   296,     0,   295,   737,   741,   739,   537,   295,
    1444      548,   256,   264,   310,     0,     2,   538,   295,   502,   338,
    1445      339,   284,   353,   360,     0,   295,     0,   752,   401,     0,
    1446      479,   503,   253,   254,   523,   295,   438,     0,   295,   238,
    1447        0,     2,   240,     0,   296,     0,   258,     2,   259,   279,
    1448        0,     0,     2,   295,   548,   295,   489,   491,   490,     0,
    1449        0,   754,     0,   295,     0,   295,   493,   295,   563,   561,
    1450      562,   560,     0,   555,   558,     0,     0,   295,    55,   295,
    1451       70,    50,   295,    61,   295,   295,    53,    54,     2,   128,
    1452        0,     0,   450,     0,   449,   731,   112,   295,    17,     0,
    1453       29,    30,    35,     2,     0,    35,   118,   119,   120,   121,
    1454      122,   123,   124,   125,   126,   127,     0,     0,    51,    52,
     1404     294,   294,   315,   313,   316,   314,   317,   318,   300,   302,
     1405     301,     0,   303,   329,   321,   326,   324,   325,   323,   322,
     1406     327,   328,   333,   330,   331,   332,   549,   549,   549,     0,
     1407       0,     0,   294,   220,   304,   319,   320,     7,   360,     0,
     1408       8,    14,    15,     0,     2,    63,    64,   567,     9,   294,
     1409     527,   525,   247,     3,   455,     3,   260,     0,     3,     3,
     1410       3,   248,     3,     0,     0,     0,   295,   296,   298,   294,
     1411     307,   310,   312,   341,   286,   334,   339,   287,   349,   288,
     1412     356,   353,   363,     0,     0,   364,   289,   475,   479,     3,
     1413       3,     0,     2,   521,   526,   531,   299,     0,     0,   549,
     1414     579,   549,     2,   590,   591,   592,   294,     0,   733,   734,
     1415       0,    12,     0,    13,   294,   270,   271,     0,   295,   290,
     1416     291,   292,   293,   528,   305,   393,   550,   551,   371,   372,
     1417      12,   446,   447,    11,   442,   445,     0,   505,   500,   491,
     1418     446,   447,     0,     0,   530,   221,     0,   294,     0,     0,
     1419       0,     0,     0,     0,     0,     0,   294,   294,     2,     0,
     1420     735,   295,   584,   596,   739,   732,   730,   737,     0,     0,
     1421       0,   254,     2,     0,   534,   440,   441,   439,     0,     0,
     1422       0,     0,   549,     0,   636,   637,     0,     0,   547,   543,
     1423     549,   564,   549,   549,   545,     2,   544,   549,   603,   549,
     1424     549,   606,     0,     0,     0,   294,   294,   313,   361,     2,
     1425     294,   261,   297,   308,   342,   354,   480,     0,     2,     0,
     1426     455,   262,   295,   335,   350,   357,   476,     0,     2,     0,
     1427     311,   336,   343,   344,     0,   351,   355,   358,   362,   447,
     1428     294,   373,   366,   370,     0,   395,   477,   481,     0,     0,
     1429       0,     1,   294,     2,   532,   578,   580,   294,     2,   743,
     1430     295,   746,   547,   547,     0,   295,     0,     0,   273,   549,
     1431     545,     2,   294,     0,     0,   294,   552,     2,   503,     2,
     1432     556,     0,     0,     0,     0,     0,     0,    18,    58,     4,
     1433       5,     6,    16,     0,     0,   294,     2,    65,    66,    67,
     1434      68,    48,    19,    49,    22,    47,    69,   294,     0,    72,
     1435      76,    79,    82,    87,    90,    92,    94,    96,    98,   100,
     1436     105,   497,   753,   453,   496,     0,   451,   452,     0,   568,
     1437     583,   586,   589,   595,   598,   601,   360,     0,     2,   741,
     1438       0,   294,   744,     2,    63,   294,     3,   427,     0,   435,
     1439     295,   294,   307,   334,   287,   349,   356,     3,     3,   409,
     1440     413,   423,   428,   475,   294,   429,   708,   709,   294,   430,
     1441     432,   294,     2,   585,   597,   731,     2,     2,   249,     2,
     1442     460,     0,   458,   457,   456,   141,     2,     2,   251,     2,
     1443       2,   250,     2,   281,     2,   282,     0,   280,     0,     0,
     1444       0,     0,     0,     0,     0,     0,     0,   569,   608,     0,
     1445     455,     2,   563,   572,   662,   565,   566,   535,   294,     2,
     1446     602,   611,   604,   605,     0,   276,   294,   294,   340,   295,
     1447       0,   295,     0,   294,   736,   740,   738,   536,   294,   547,
     1448     255,   263,   309,     0,     2,   537,   294,   501,   337,   338,
     1449     283,   352,   359,     0,   294,     0,   751,   400,     0,   478,
     1450     502,   252,   253,   522,   294,   437,     0,   294,   237,     0,
     1451       2,   239,     0,   295,     0,   257,     2,   258,   278,     0,
     1452       0,     2,   294,   547,   294,   488,   490,   489,     0,     0,
     1453     753,     0,   294,     0,   294,   492,   294,   562,   560,   561,
     1454     559,     0,   554,   557,     0,     0,   294,    55,   294,    69,
     1455      50,   294,    61,   294,   294,    53,    54,     2,   127,     0,
     1456       0,   449,     0,   448,   730,   121,   294,    17,     0,    29,
     1457      30,    35,     2,     0,    35,   111,   112,   113,   114,   115,
     1458     116,   117,   118,   119,   120,   110,     0,    51,    52,     0,
    14551459       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    1456        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    1457      109,     2,   649,   455,   646,   550,   550,   654,   483,   295,
    1458        2,   588,   589,     0,   600,   601,     0,     2,   743,   746,
    1459      112,   295,     0,     2,   711,   296,   715,   706,   707,   713,
    1460        0,     2,     2,   671,   550,   754,   620,   550,   550,   754,
    1461      550,   634,   550,   550,   685,   437,   668,   550,   550,   676,
    1462      683,   295,   432,   296,     0,     0,   295,   721,   296,   726,
    1463      754,   718,   295,   723,   754,   295,   295,   295,     0,   112,
    1464        0,    18,     5,     2,     0,    19,     0,   462,   752,     0,
    1465        0,   468,   242,     0,   295,     0,     0,     0,   548,   572,
    1466      576,   578,   608,   611,   615,   618,   571,   610,     0,   285,
    1467      661,     0,   295,   278,     0,     0,     0,     0,   276,     2,
    1468        0,   260,   539,   295,     0,     0,   295,     2,   366,   386,
    1469      375,     0,     0,   380,   374,   753,     0,     0,   399,     0,
    1470      296,     3,   417,     3,   421,   420,   594,     0,   534,   295,
    1471       63,     3,   295,   436,   296,     3,   430,   431,     2,     0,
    1472        0,     0,   488,   307,   295,   484,   486,     3,     2,     2,
    1473        0,   505,     3,     0,   557,   130,     0,     0,   223,     0,
    1474        0,     0,     2,     0,     0,    36,     0,     0,   112,   295,
    1475       20,     0,    21,     0,   695,   700,   451,   692,   550,   550,
    1476        0,   110,     3,     2,    27,     2,     0,    33,     0,     2,
    1477       25,     0,   107,   108,    74,    75,    76,    78,    79,    81,
    1478       82,    86,    87,    84,    85,    89,    90,    92,    94,    96,
    1479       98,   100,     0,     0,   755,   295,     0,     0,     0,   650,
    1480      651,   647,   648,   500,   499,   295,     0,   295,   717,   295,
    1481      722,   296,   295,   665,   295,   295,   708,   664,     2,   295,
    1482        0,     0,     0,     0,     0,     0,     0,     0,   686,     0,
    1483      672,   623,   639,   673,     2,   619,   626,   434,   621,   622,
    1484      435,     2,   633,   642,   635,   636,   669,   670,   684,   712,
    1485      716,   714,   754,   269,     2,   748,     2,   425,   720,   725,
    1486      426,     0,   404,     3,     3,     3,     3,   456,     3,     0,
    1487        2,   471,   467,   753,     0,   463,   470,     2,   466,   469,
    1488        0,   295,   243,   265,     3,   273,   275,     0,   456,     2,
    1489      574,   575,     2,   613,   614,     0,   662,   540,     3,   347,
    1490      346,   349,   348,   295,   541,     0,   542,   374,     0,     0,
    1491      295,   295,     0,     0,   695,   384,   387,   391,   550,   391,
    1492      390,   383,   376,   550,   378,   381,   295,   401,   395,   105,
    1493      402,   752,     0,     0,   439,   241,     0,     0,     3,     2,
    1494      671,   432,     0,   530,     0,   754,   492,     0,   295,   295,
    1495      295,     0,   554,   556,   131,     0,     0,   216,     0,     0,
    1496        0,   224,   225,    56,     0,    62,   295,     0,    60,    59,
    1497        0,     2,   129,     0,     0,     0,   696,   697,   693,   694,
    1498      461,    71,    72,   111,   116,     3,   110,     0,     0,     0,
    1499       24,    35,     3,     0,    32,   103,     0,     3,   653,   657,
    1500      660,   652,     3,   595,     3,   719,   724,     2,    63,   295,
    1501        3,     3,   296,     0,     3,   625,   629,   632,   641,   675,
    1502      679,   682,   295,     3,   624,   640,   674,   295,   295,   427,
    1503      295,   295,   749,     0,     0,     0,     0,   257,     0,   105,
    1504        0,     3,     3,     0,   464,     0,   460,     0,     0,   246,
    1505      295,     0,     0,   130,     0,     0,     0,     0,     0,   130,
    1506        0,     0,   110,   110,    18,     2,     0,     0,     3,   132,
    1507      133,     2,   144,   134,   135,   136,   137,   138,   139,   146,
    1508      148,     0,     0,     0,   286,   295,   295,   550,     0,   543,
    1509      295,   377,   379,     0,   393,   696,   388,   392,   389,   382,
    1510      386,   369,   400,     0,   582,     2,   667,   666,     0,   672,
    1511        2,   485,   487,   507,     3,   515,   516,     0,     2,   511,
    1512        3,     3,     0,     0,   559,   223,     0,     0,     0,   223,
    1513        0,     0,     3,    37,   112,   699,   703,   705,   698,   752,
    1514      110,     0,     3,   664,    42,     3,    40,     3,    34,     0,
    1515        3,   102,   104,     0,     2,   655,   656,     0,     0,   295,
    1516        0,     0,     0,     3,   641,     0,     2,   627,   628,     2,
    1517      643,     2,   677,   678,     0,     0,    63,     0,     3,     3,
    1518        3,     3,   412,   411,   415,     2,     2,   751,   750,   113,
    1519        0,     0,     0,     0,     3,   465,     3,     0,   244,   147,
    1520        3,   296,   295,     0,     0,     0,     0,     2,     0,   192,
    1521        0,   190,     0,     0,     0,     0,     0,     0,     0,   550,
    1522      112,     0,   152,   149,   295,     0,     0,   268,   280,     3,
    1523        3,   549,   616,   370,   385,   398,   295,   267,   295,     0,
    1524      518,   495,   295,     0,     0,   494,   509,     0,     0,     0,
    1525      217,     0,   226,    57,   110,     0,     2,   701,   702,     0,
    1526      117,   114,     0,     0,     0,     0,     0,     0,    23,     0,
    1527      658,   295,   583,   266,   727,   728,   729,     0,   680,   295,
    1528      295,   295,     3,     3,     0,   688,     0,     0,     0,     0,
    1529      295,   295,     3,   547,   472,   473,     0,     0,   247,   296,
    1530        0,     0,     0,     0,   295,   193,   191,   188,     0,   194,
    1531        0,     0,     0,     0,   198,   201,   199,   195,     0,   196,
    1532      130,    35,   145,   143,   245,     0,     0,   419,   423,   422,
    1533        0,   512,     2,   513,     2,   514,   508,   295,   229,     0,
    1534      227,     0,   229,     3,   664,   295,    31,   115,     2,    45,
    1535        2,    43,    41,    28,   113,    26,     3,   730,     3,     3,
    1536        3,     0,     0,   687,   689,   630,   644,   270,     2,   409,
    1537        3,   408,     0,   475,   472,   130,     0,     0,   130,     3,
    1538        0,   130,   189,     0,     2,     2,   210,   200,     0,     0,
    1539        0,   141,     0,   577,   617,     2,     0,     0,     2,   230,
    1540        0,     0,   218,     0,     0,     0,     3,     0,     0,     0,
    1541        0,     0,     0,   690,   691,   295,     0,   474,   153,     0,
    1542        0,     2,   166,   130,   155,     0,   183,     0,   130,     0,
    1543        2,   157,     0,     2,     0,     2,     2,     2,   197,    32,
    1544      295,   517,   519,   510,     0,     0,     0,     0,   115,    38,
    1545        0,     3,     3,   659,   631,   645,   681,   413,   130,   159,
    1546      162,     0,   161,   165,     3,   168,   167,     0,   130,   185,
    1547      130,     3,     0,   295,     0,   295,     0,     2,     0,     2,
    1548      140,     2,   231,   232,     0,   228,   219,     0,   704,     0,
    1549        0,   154,     0,     0,   164,   234,   169,     2,   236,   184,
    1550        0,   187,   173,   202,     3,   211,   215,   204,     3,     0,
    1551      295,     0,   295,     0,     0,     0,    39,    46,    44,   160,
    1552      163,   130,     0,   170,   295,   130,   130,     0,   174,     0,
    1553        0,   695,   212,   213,   214,     0,   203,     3,   205,     3,
    1554      295,   220,   233,   150,   171,   156,   130,   237,   186,   181,
    1555      179,   175,   158,   130,     0,   696,     0,     0,     0,     0,
    1556      151,   172,   182,   176,   180,   179,   177,     3,     3,     0,
    1557        0,   496,   178,   206,   208,     3,     3,   207,   209
     1460       0,     0,     0,     0,     0,     0,     0,     0,     0,   107,
     1461       2,   648,   454,   645,   549,   549,   653,   482,   294,     2,
     1462     587,   588,     0,   599,   600,     0,     2,   742,   745,   121,
     1463     294,     0,     2,   710,   295,   714,   705,   706,   712,     0,
     1464       2,     2,   670,   549,   753,   619,   549,   549,   753,   549,
     1465     633,   549,   549,   684,   436,   667,   549,   549,   675,   682,
     1466     294,   431,   295,     0,     0,   294,   720,   295,   725,   753,
     1467     717,   294,   722,   753,   294,   294,   294,     0,   121,     0,
     1468      18,     5,     2,     0,    19,     0,   461,   751,     0,     0,
     1469     467,   241,     0,   294,     0,     0,     0,   547,   571,   575,
     1470     577,   607,   610,   614,   617,   570,   609,     0,   284,   660,
     1471       0,   294,   277,     0,     0,     0,     0,   275,     2,     0,
     1472     259,   538,   294,     0,     0,   294,     2,   365,   385,   374,
     1473       0,     0,   379,   373,   752,     0,     0,   398,     0,   295,
     1474       3,   416,     3,   420,   419,   593,     0,   533,   294,    63,
     1475       3,   294,   435,   295,     3,   429,   430,     2,     0,     0,
     1476       0,   487,   306,   294,   483,   485,     3,     2,     2,     0,
     1477     504,     3,     0,   556,   129,     0,     0,   222,     0,     0,
     1478       0,     2,     0,     0,    36,     0,     0,   121,   294,    20,
     1479       0,    21,     0,   694,   699,   450,   691,   549,   549,     0,
     1480     108,     3,     2,    27,     2,     0,    33,     0,     2,    25,
     1481       0,   106,    73,    74,    75,    77,    78,    80,    81,    85,
     1482      86,    83,    84,    88,    89,    91,    93,    95,    97,    99,
     1483       0,     0,   754,   294,     0,     0,     0,   649,   650,   646,
     1484     647,   499,   498,   294,     0,   294,   716,   294,   721,   295,
     1485     294,   664,   294,   294,   707,   663,     2,   294,     0,     0,
     1486       0,     0,     0,     0,     0,     0,   685,     0,   671,   622,
     1487     638,   672,     2,   618,   625,   433,   620,   621,   434,     2,
     1488     632,   641,   634,   635,   668,   669,   683,   711,   715,   713,
     1489     753,   268,     2,   747,     2,   424,   719,   724,   425,     0,
     1490     403,     3,     3,     3,     3,   455,     3,     0,     2,   470,
     1491     466,   752,     0,   462,   469,     2,   465,   468,     0,   294,
     1492     242,   264,     3,   272,   274,     0,   455,     2,   573,   574,
     1493       2,   612,   613,     0,   661,   539,     3,   346,   345,   348,
     1494     347,   294,   540,     0,   541,   373,     0,     0,   294,   294,
     1495       0,     0,   694,   383,   386,   390,   549,   390,   389,   382,
     1496     375,   549,   377,   380,   294,   400,   394,   104,   401,   751,
     1497       0,     0,   438,   240,     0,     0,     3,     2,   670,   431,
     1498       0,   529,     0,   753,   491,     0,   294,   294,   294,     0,
     1499     553,   555,   130,     0,     0,   215,     0,     0,     0,   223,
     1500     224,    56,     0,    62,   294,     0,    60,    59,     0,     2,
     1501     128,     0,     0,     0,   695,   696,   692,   693,   460,    70,
     1502      71,   109,   125,     3,   108,     0,     0,     0,    24,    35,
     1503       3,     0,    32,   102,     0,     3,   652,   656,   659,   651,
     1504       3,   594,     3,   718,   723,     2,    63,   294,     3,     3,
     1505     295,     0,     3,   624,   628,   631,   640,   674,   678,   681,
     1506     294,     3,   623,   639,   673,   294,   294,   426,   294,   294,
     1507     748,     0,     0,     0,     0,   256,     0,   104,     0,     3,
     1508       3,     0,   463,     0,   459,     0,     0,   245,   294,     0,
     1509       0,   129,     0,     0,     0,     0,     0,   129,     0,     0,
     1510     108,   108,    18,     2,     0,     0,     3,   131,   132,     2,
     1511     143,   133,   134,   135,   136,   137,   138,   145,   147,     0,
     1512       0,     0,   285,   294,   294,   549,     0,   542,   294,   376,
     1513     378,     0,   392,   695,   387,   391,   388,   381,   385,   368,
     1514     399,     0,   581,     2,   666,   665,     0,   671,     2,   484,
     1515     486,   506,     3,   514,   515,     0,     2,   510,     3,     3,
     1516       0,     0,   558,   222,     0,     0,     0,   222,     0,     0,
     1517       3,    37,   121,   698,   702,   704,   697,   751,   108,     0,
     1518       3,   663,    42,     3,    40,     3,    34,     0,     3,   101,
     1519     103,     0,     2,   654,   655,     0,     0,   294,     0,     0,
     1520       0,     3,   640,     0,     2,   626,   627,     2,   642,     2,
     1521     676,   677,     0,     0,    63,     0,     3,     3,     3,     3,
     1522     411,   410,   414,     2,     2,   750,   749,   122,     0,     0,
     1523       0,     0,     3,   464,     3,     0,   243,   146,     3,   295,
     1524     294,     0,     0,     0,     0,     2,     0,   191,     0,   189,
     1525       0,     0,     0,     0,     0,     0,     0,   549,   121,     0,
     1526     151,   148,   294,     0,     0,   267,   279,     3,     3,   548,
     1527     615,   369,   384,   397,   294,   266,   294,     0,   517,   494,
     1528     294,     0,     0,   493,   508,     0,     0,     0,   216,     0,
     1529     225,    57,   108,     0,     2,   700,   701,     0,   126,   123,
     1530       0,     0,     0,     0,     0,     0,    23,     0,   657,   294,
     1531     582,   265,   726,   727,   728,     0,   679,   294,   294,   294,
     1532       3,     3,     0,   687,     0,     0,     0,     0,   294,   294,
     1533       3,   546,   471,   472,     0,     0,   246,   295,     0,     0,
     1534       0,     0,   294,   192,   190,   187,     0,   193,     0,     0,
     1535       0,     0,   197,   200,   198,   194,     0,   195,   129,    35,
     1536     144,   142,   244,     0,     0,   418,   422,   421,     0,   511,
     1537       2,   512,     2,   513,   507,   294,   228,     0,   226,     0,
     1538     228,     3,   663,   294,    31,   124,     2,    45,     2,    43,
     1539      41,    28,   122,    26,     3,   729,     3,     3,     3,     0,
     1540       0,   686,   688,   629,   643,   269,     2,   408,     3,   407,
     1541       0,   474,   471,   129,     0,     0,   129,     3,     0,   129,
     1542     188,     0,     2,     2,   209,   199,     0,     0,     0,   140,
     1543       0,   576,   616,     2,     0,     0,     2,   229,     0,     0,
     1544     217,     0,     0,     0,     3,     0,     0,     0,     0,     0,
     1545       0,   689,   690,   294,     0,   473,   152,     0,     0,     2,
     1546     165,   129,   154,     0,   182,     0,   129,     0,     2,   156,
     1547       0,     2,     0,     2,     2,     2,   196,    32,   294,   516,
     1548     518,   509,     0,     0,     0,     0,   124,    38,     0,     3,
     1549       3,   658,   630,   644,   680,   412,   129,   158,   161,     0,
     1550     160,   164,     3,   167,   166,     0,   129,   184,   129,     3,
     1551       0,   294,     0,   294,     0,     2,     0,     2,   139,     2,
     1552     230,   231,     0,   227,   218,     0,   703,     0,     0,   153,
     1553       0,     0,   163,   233,   168,     2,   235,   183,     0,   186,
     1554     172,   201,     3,   210,   214,   203,     3,     0,   294,     0,
     1555     294,     0,     0,     0,    39,    46,    44,   159,   162,   129,
     1556       0,   169,   294,   129,   129,     0,   173,     0,     0,   694,
     1557     211,   212,   213,     0,   202,     3,   204,     3,   294,   219,
     1558     232,   149,   170,   155,   129,   236,   185,   180,   178,   174,
     1559     157,   129,     0,   695,     0,     0,     0,     0,   150,   171,
     1560     181,   175,   179,   178,   176,     3,     3,     0,     0,   495,
     1561     177,   205,   207,     3,     3,   206,   208
    15581562};
    15591563
    … …  
    15611565static const yytype_int16 yydefgoto[] =
    15621566{
    1563       -1,   819,   469,   302,    48,   135,   136,   303,   304,   305,
    1564      306,   766,   767,  1145,  1146,   307,   382,   309,   310,   311,
    1565      312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
    1566     1040,   519,   984,   323,   985,   547,   954,  1067,  1543,  1069,
    1567     1070,  1071,  1072,  1544,  1073,  1074,  1460,  1461,  1422,  1423,
    1568     1424,  1522,  1523,  1527,  1528,  1563,  1564,  1075,  1380,  1076,
    1569     1077,  1314,  1315,  1316,  1504,  1078,   147,   960,   961,   962,
    1570     1400,  1484,  1496,  1497,   470,   471,   881,   882,  1048,    52,
    1571       53,    54,    55,    56,   348,   160,    59,    60,    61,    62,
    1572       63,   350,    65,    66,   266,    68,    69,   276,   352,   353,
    1573       72,    73,    74,    75,   120,    77,   206,   355,   121,    80,
    1574      122,    82,    83,   456,    84,   455,   690,   691,   692,   915,
    1575     1096,   916,    85,    86,   459,   457,   698,   861,   862,   358,
    1576      359,   701,   702,   703,   360,   361,   362,   363,   467,   341,
    1577      137,   138,   523,   325,   172,   647,   648,   649,   650,   651,
    1578       87,   123,    89,   490,   491,   946,   492,   279,   496,   326,
    1579       90,   139,   140,    91,  1337,  1118,  1119,  1120,  1121,    92,
    1580       93,   719,    94,   275,    95,    96,   189,  1042,   681,   413,
    1581      127,    97,   502,   503,   504,   190,   270,   192,   193,   194,
    1582      271,   100,   101,   102,   103,   104,   105,   106,   197,   198,
    1583      199,   200,   201,   831,   606,   607,   608,   609,   202,   611,
    1584      612,   613,   573,   574,   575,   576,   755,   107,   615,   616,
    1585      617,   618,   619,   620,   977,   757,   758,   759,   596,   366,
    1586      367,   368,   369,   327,   166,   109,   110,   111,   371,   696,
    1587      570
     1567      -1,   817,   468,   301,    47,   134,   135,   302,   303,   304,
     1568     305,   765,   766,  1143,  1144,   306,   381,   308,   309,   310,
     1569     311,   312,   313,   314,   315,   316,   317,   318,   319,   320,
     1570    1038,   518,   982,   546,   322,   983,   952,  1065,  1541,  1067,
     1571    1068,  1069,  1070,  1542,  1071,  1072,  1458,  1459,  1420,  1421,
     1572    1422,  1520,  1521,  1525,  1526,  1561,  1562,  1073,  1378,  1074,
     1573    1075,  1312,  1313,  1314,  1502,  1076,   146,   958,   959,   960,
     1574    1398,  1482,  1494,  1495,   469,   470,   879,   880,  1046,    51,
     1575      52,    53,    54,    55,   347,   159,    58,    59,    60,    61,
     1576      62,   349,    64,    65,   265,    67,    68,   275,   351,   352,
     1577      71,    72,    73,    74,   119,    76,   205,   354,   120,    79,
     1578     121,    81,    82,   455,    83,   454,   689,   690,   691,   913,
     1579    1094,   914,    84,    85,   458,   456,   697,   859,   860,   357,
     1580     358,   700,   701,   702,   359,   360,   361,   362,   466,   340,
     1581     136,   137,   522,   324,   171,   646,   647,   648,   649,   650,
     1582      86,   122,    88,   489,   490,   944,   491,   278,   495,   325,
     1583      89,   138,   139,    90,  1335,  1116,  1117,  1118,  1119,    91,
     1584      92,   718,    93,   274,    94,    95,   188,  1040,   680,   412,
     1585     126,    96,   501,   502,   503,   189,   269,   191,   192,   193,
     1586     270,    99,   100,   101,   102,   103,   104,   105,   196,   197,
     1587     198,   199,   200,   829,   605,   606,   607,   608,   201,   610,
     1588     611,   612,   572,   573,   574,   575,   754,   106,   614,   615,
     1589     616,   617,   618,   619,   975,   756,   757,   758,   595,   365,
     1590     366,   367,   368,   326,   165,   108,   109,   110,   370,   695,
     1591     569
    15881592};
    15891593
    15901594/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    15911595   STATE-NUM.  */
    1592 #define YYPACT_NINF -1414
     1596#define YYPACT_NINF -1315
    15931597static const yytype_int16 yypact[] =
    15941598{
    1595     4857,  9883, -1414,    35, -1414, -1414, -1414, -1414, -1414, -1414,
    1596    -1414,   142, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414,
    1597    -1414, -1414, -1414, -1414, -1414, -1414,    98,    98,    98,  1334,
    1598      684,   153,  7496,   290, -1414, -1414, -1414, -1414, -1414,   204,
    1599    -1414, -1414, -1414, -1414,   901,   229, -1414, -1414, -1414, -1414,
    1600     9565, -1414, -1414, -1414, -1414,   -15,   301, -1414,  1624, -1414,
    1601    -1414, -1414, -1414,   302,  1806,   471,   143,  7613, -1414, -1414,
    1602     9603,  1367, -1414, -1414, -1414,  1721,   510,  3394,  1032,  1137,
    1603     1721,  1303, -1414, -1414,  1174,  1520, -1414,  1721,  1532, -1414,
    1604      385, -1414,   421,   523, -1414, -1414, -1414, -1414,   460,   301,
    1605       98, -1414,    98, -1414, -1414, -1414, -1414, 10414,  1624, -1414,
    1606    -1414,  1624, -1414,   447, -1414, 10444, -1414, -1414,  2082, 10554,
    1607    -1414,   399,   399,   399, -1414, -1414, -1414,    98, -1414, -1414,
    1608    -1414,   544,   555,   575, -1414, -1414, -1414,   617, -1414, -1414,
    1609    -1414, -1414, -1414,   621,   629, -1414, -1414,    11,  9069,  3253,
    1610      578,   492,   499,   631,   635,   642,   647,  9853,  7015,   649,
    1611      656, -1414,  9713, -1414, -1414, -1414, -1414,   661, -1414,   193,
    1612     3453,  3453, -1414,   667,   251, -1414, -1414, -1414, -1414,   692,
    1613      327,   346,   368,    98,   673, -1414, -1414,  1806,  3136,   748,
    1614    -1414,    12, -1414,    98,    98,   301, -1414, -1414,    75, -1414,
    1615       98,    98, -1414,  3167,   711,   722,   399,  6806, -1414, -1414,
    1616      726,  9565, -1414, -1414,  1721, -1414, -1414, -1414,   301, -1414,
    1617     1624,   -15, -1414,  7963, -1414,   399,   399,   399,   301, -1414,
    1618     1334, -1414,  5769, -1414, -1414,   709,   399, -1414,   399, -1414,
    1619      204,  9069, -1414,   763, -1414,   684,   765,   399, -1414,  1334,
    1620      750,   766, -1414,  7496,   705, -1414, -1414, -1414,  9532, -1414,
    1621    -1414, 10864, -1414,   748,    63,  6244, 10554,  2082,  3167, -1414,
    1622       85, -1414, -1414, 10444,  1624,   804,  7644, -1414, -1414,   319,
    1623    -1414, 11778,   782,   851,  4657,   828,  4994, 11639, -1414,   839,
    1624    -1414, -1414, -1414, -1414, 11658, 11658,  8841,   844, -1414, -1414,
    1625    -1414, -1414, -1414, -1414,   869, -1414,   759,  2440,  9183,  4994,
    1626    -1414,   593,   571,   645,   313,   861,   842,   858,   843,   911,
    1627      -20, -1414, -1414,   876,   326, -1414,    83, -1414, -1414,  3253,
    1628    -1414, -1414,   139,   900, -1414,   422,   900,   905,   204, -1414,
    1629    -1414,   909, 10414, -1414,   912,   917,  9297, -1414, -1414,  1382,
    1630     2358,  8427,  6806,  1721, -1414,  1721,   399,   399, -1414, -1414,
    1631    -1414, -1414, -1414, -1414,   399, 10414,  1624, -1414, -1414, 10584,
    1632     1776, -1414, 10304, -1414, -1414, -1414, -1414, -1414, -1414, -1414,
    1633      936, 11446,  4994, -1414, -1414, -1414, -1414, -1414, -1414, -1414,
    1634    -1414, -1414, -1414, -1414, -1414, -1414, -1414,  2082, -1414,   836,
    1635      947,   962,   963,   923,   965,   970,   972,  3136, -1414, -1414,
    1636      959,   -15,   975, -1414, -1414,   978, -1414, -1414, -1414,  9532,
    1637    -1414, -1414, -1414, -1414, -1414,  3167, -1414,  9069,  9069, -1414,
    1638      399,  2082,  6926,  1624,  8543, -1414, -1414, -1414, -1414,  9532,
    1639       63, -1414, -1414,  1721,   301, -1414, -1414,  9532, -1414,  6689,
    1640    -1414, -1414,   399,   399,   271, 10023,   907,   977,   960,   988,
    1641      399, -1414, -1414, -1414, -1414, 10980, -1414,   500,  6556, -1414,
    1642      301,   990, -1414,  2082, 11860, 11504, -1414, -1414, -1414, -1414,
    1643      935,  3167, -1414,  8659,   748,  6228, -1414, -1414, -1414,  1482,
    1644      550,   876,   684,  7644,  1180, 10444, -1414,  7644, -1414, -1414,
    1645    -1414, -1414,   561, -1414,   997,   851,   -13,  8841, -1414, 10694,
    1646    -1414, -1414,  8841, -1414,  8955,  8841, -1414, -1414,   996, -1414,
    1647      585,  1003,   455,  1017, -1414, -1414,  9993,  6037, -1414,   419,
    1648    -1414, -1414, 11562, -1414,   469, 11562, -1414, -1414, -1414, -1414,
    1649    -1414, -1414, -1414, -1414, -1414, -1414,  6244,  6244, -1414, -1414,
    1650     4994,  4994,  4994,  4994,  4994,  4994,  4994,  4994,  4994,  4994,
    1651     4994,  4994,  4994,  4994,  4994,  4994,  4994,  4994,  3735,  6244,
    1652    -1414,   326,  1049, -1414, -1414,    98,    98, -1414, -1414,  9069,
    1653    -1414, -1414,   978,   705, -1414,   978, 11581, -1414, -1414, -1414,
    1654     3645,  6037,  1016,  1018, -1414, 10554, -1414, -1414,   661, -1414,
    1655     1020,  1157,  1025,  2611,    95,   876, -1414,    98,    98,   876,
    1656      134, -1414,    98,    98,   978, -1414, -1414,    98,    98, -1414,
    1657      900, 10724,  1624, 12005,    69,   227, 10724, -1414, 10864, -1414,
    1658      876, -1414, 10414, -1414,   218,  8079,  8079,  8079,  1624, -1414,
    1659     5555,  1012,   260,   936,   778,  1021,  1024, -1414,  1026,  3453,
    1660      343, -1414,  1115,  1624,  8079,   705,  2082,   705,   748,   534,
    1661      900, -1414, -1414,   596,   900, -1414, -1414, -1414,   851, -1414,
    1662      900,   301, 10980, -1414,   687,  1042,   700,  1043, -1414,  1044,
    1663      301, -1414, -1414,  9532,   301,  1041, 10694,  1045, -1414,  2066,
    1664    -1414,   408,   416,   684, -1414,   684,  1047,  4994, -1414,   684,
    1665    12005, -1414, -1414,  1053, -1414, -1414, -1414,   705, -1414, 11933,
    1666      917, -1414,  8079,   489,  8427, -1414, -1414,   661,  1055,  1056,
    1667     1482,  3284, -1414, -1414,  7644, -1414, -1414,  1038, -1414, -1414,
    1668     1064, -1414,  1038,  1070, 11778,  6244,    93,  1051,   138,  1074,
    1669     1058,  1075,   844,  1069,  1077, -1414,  1079,  1081, 10133,  6775,
    1670    -1414,  6244, -1414,   455,  1974, -1414, -1414, -1414,    98,    98,
    1671     6104,  6244,  1076, -1414, -1414,   936,   707, -1414,  6244, -1414,
    1672    -1414,   677, -1414, -1414, -1414, -1414, -1414,   593,   593,   571,
    1673      571,   645,   645,   645,   645,   313,   313,   861,   842,   858,
    1674      843,   911,  4994,   847, -1414, 10980,  1083,  1084,  1088,  1049,
    1675    -1414, -1414, -1414, -1414, -1414, 10980,   717,  8079, -1414, 10414,
    1676    -1414,  7135,  9411, -1414, 10304,  7015, -1414, -1414,  1157, 10980,
    1677      945,  1089,  1090,  1095,  1096,  1099,  1100,  1105, -1414,  4392,
    1678     2611, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414,
    1679    -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414,   978, -1414,
    1680    -1414, -1414,   876, -1414, -1414, -1414, -1414, -1414, -1414, -1414,
    1681    -1414,  1112, -1414,  1113,  1118, -1414, -1414,   -15,  1076,  5555,
    1682    -1414, -1414, -1414, 11446,  1116, -1414, -1414, -1414, -1414, -1414,
    1683      684,  6369,  1201, -1414, -1414, -1414, -1414,  1103,   -15, -1414,
    1684    -1414,   978, -1414, -1414,   978,   126,   978, -1414, -1414, -1414,
    1685    -1414, -1414, -1414,  9743, -1414,   301, -1414, -1414,   438,   452,
    1686    10584,  7255,  2372,  4994,  2870, -1414, -1414,  1127,    39,  1127,
    1687    -1414,   684, -1414,    98, -1414, -1414, 10163,   960, -1414, -1414,
    1688    -1414,   977,  1143,  1131, -1414, -1414,  1150,  1153, -1414,   489,
    1689     1995, -1414,   363, -1414,  3284,   876, -1414,  1160,  7644, 10834,
    1690     9069,  1161, -1414, -1414,  1151,  1162,  1156, -1414,  4994,   120,
    1691      279,  1163, -1414,  1166,   705,  1166,  6037,  6244, -1414, -1414,
    1692     1166,  1165, -1414,  1176,  1182,  1185,  1974, -1414, -1414, -1414,
    1693    11446, -1414, -1414, -1414, -1414,  1168,  6244,  1188,   705,  5555,
    1694    -1414, 11562, -1414,   705, -1414, -1414,  6244, -1414,   614,   900,
    1695    -1414, -1414, -1414, -1414, -1414, -1414, -1414,   936,   917,  9297,
    1696    -1414, -1414,  7375,  1187, -1414,   758,   900, -1414,   785,   797,
    1697      900, -1414,   399,  5912, -1414, -1414, -1414, 10980, 10980, -1414,
    1698     8543,  8543, -1414,  1186,  1189,  1191,  1199, -1414,  1206,   439,
    1699      119,  1076, -1414,   705, -1414,  3453, -1414,  6244,   480, -1414,
    1700     6655,  1211,  1212, 11388,  1213,  1217,    -6,    58,   117,  6244,
    1701     1221,   301,  6244,  6244,  1215,  1222,   610,  1203, -1414, -1414,
    1702    -1414,  1218, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414,
    1703    -1414,   684,  1226,  6244, -1414, 10980, 10980,    98,  1228, -1414,
    1704    10273, -1414, -1414,   864, -1414,  2870, -1414, -1414, -1414, -1414,
    1705     2066, -1414, -1414,  1230, -1414, -1414, -1414, -1414,  1231,  1995,
    1706    -1414, -1414,  1223, -1414,  1038, -1414, -1414,  2082,  1235, -1414,
    1707    -1414, -1414,   744,  1237, -1414,   138,  1245,  4994,  1232,   138,
    1708      138,  1250,  1246, -1414,  9993,   825,   900, -1414, -1414,  1026,
    1709     6244,  1251,  1168,   536,   161,  1261, -1414,  1246, -1414,  1254,
    1710     1261, -1414, -1414,  1257, -1414, -1414,   978,  1270,  1271,  6895,
    1711     1272,  1275,  1280, -1414, -1414,  1283, -1414, -1414,   978, -1414,
    1712    -1414, -1414, -1414,   978,  6244,  6244,   917,  1282, -1414, -1414,
    1713    -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414,
    1714     4994,  4994,  1284,  1286,  1261, -1414, -1414,   684, -1414, -1414,
    1715    -1414,  5291, 10834,  6244,  6244,  1335,  6244, -1414,  1263, -1414,
    1716     1267, -1414,  1281,  6244,  1288,  6244,  1039,  1290,    28,    98,
    1717     5165,   856, -1414, -1414,  6369,  1287,   488, -1414, -1414, -1414,
    1718    -1414, -1414, -1414, -1414, -1414, -1414, 11206, -1414,  8659,  1304,
    1719    -1414, -1414, 10834,   490,   498, -1414,  1301,  1306,   851,  1317,
    1720    -1414,   418, -1414, -1414,  6244,  1316, -1414, -1414,   978,  1314,
    1721    -1414, -1414,  1318,   589,   691,   705,  1320,  1322, -1414,  1329,
    1722    -1414, 10980, -1414, -1414, -1414, -1414, -1414,  1330, -1414, 10980,
    1723    10980, 10980, -1414, -1414,  1332, -1414,  1333,  1336,  1339,   517,
    1724     8195,  8311, -1414, -1414,   123, -1414,  1343,  1348, -1414,  8775,
    1725      755,   768,  1342,   770,  6525, -1414, -1414, -1414,   508, -1414,
    1726      777,  1352,  1353,   301,  1403,   933, -1414, -1414,  6244, -1414,
    1727    11388, 11562, -1414, -1414, -1414,  1359,  1364, -1414, -1414, -1414,
    1728     1363, -1414, -1414, -1414, -1414, -1414, -1414, 10834,   851,   273,
    1729    -1414,  1347,   851,  1168,   268, 10980, -1414, -1414, -1414, -1414,
    1730    -1414, -1414, -1414, -1414,  1365, -1414, -1414, -1414, -1414, -1414,
    1731    -1414,  1368,  1371, -1414, -1414, -1414, -1414, -1414, -1414, -1414,
    1732     1375, -1414,  1374, -1414, -1414, 11388,    91,  6244, 11388, -1414,
    1733     1385,  6244, -1414,   288,  1402,  1405, -1414, -1414,  1390,  1393,
    1734     1376, -1414,   882, -1414, -1414, -1414,  1624,  2082,  1388,   869,
    1735      884,  4994, -1414,   803,  1394,  6244, -1414,   705,   705,  1399,
    1736     1406,  1407,  1409, -1414, -1414,  8543,  1397, -1414,  1473,  4994,
    1737     1404, -1414, -1414, 11299, -1414,   811, -1414,  1395, 11388,  1401,
    1738    -1414, -1414,  1410, -1414,  1412, -1414,  1433,  1441, -1414,  1415,
    1739    10834, -1414, -1414, -1414,   851,   705,  1429,  1417,  1436, -1414,
    1740     1446,  1261,  1261, -1414, -1414, -1414, -1414, -1414, 11388,   278,
    1741    -1414,   910, -1414, -1414,  7730, -1414, -1414,  1435,  6244, -1414,
    1742     6244,  7730,   301, 10694,   301, 10694,  1462, -1414,  1463, -1414,
    1743    -1414,  1460,   869, -1414,   812, -1414, -1414,  6244, -1414,  1465,
    1744     1466, -1414,  4994,  4994, -1414, -1414,  1007,    37, -1414, -1414,
    1745     1447, -1414,  1007, -1414, -1414,  2485,   705, -1414, -1414,   301,
    1746    10694,   301, 10694,  1472,  1450,   705, -1414, -1414, -1414, -1414,
    1747    -1414, 11299,  1468,  1007,  7847,  6244, 11210,  1475,  1007,  1477,
    1748     2485,  2994, -1414, -1414, -1414,  1495, -1414, -1414, -1414, -1414,
    1749     9069, -1414, -1414, -1414, 11077, -1414, 11299, -1414, -1414,  1476,
    1750    10984, -1414, -1414, 11210,   301,  2994,   301,  1502,  1506,   813,
    1751    -1414, 11077, -1414, -1414, -1414, 10984, -1414, -1414, -1414,   301,
    1752      301, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414
     1599    5006,  8237, -1315,    89, -1315, -1315, -1315, -1315, -1315, -1315,
     1600   -1315,   194, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315,
     1601   -1315, -1315, -1315, -1315, -1315, -1315,   314,   314,   314,   792,
     1602     787,   234,  7780,   219, -1315, -1315, -1315, -1315, -1315,   257,
     1603   -1315, -1315, -1315,   912,   264, -1315, -1315, -1315, -1315,  6920,
     1604   -1315, -1315, -1315, -1315,   120,   272, -1315,   823, -1315, -1315,
     1605   -1315, -1315,   302,  1619,   420,   112,  3706, -1315, -1315,  9405,
     1606    1262, -1315, -1315, -1315,   675,   440,  7333,  1133,  1444,   675,
     1607    1669, -1315, -1315,   482,   771, -1315,   675,  1807, -1315,   386,
     1608   -1315,   507,   517, -1315, -1315, -1315, -1315,   426,   272,   314,
     1609   -1315,   314, -1315, -1315, -1315, -1315,  8871,   823, -1315, -1315,
     1610     823, -1315,   415, -1315,  8985, -1315, -1315,  1777,  9099, -1315,
     1611     428,   428,   428, -1315, -1315, -1315,   314, -1315, -1315, -1315,
     1612     454,   468,   490, -1315, -1315, -1315,   500, -1315, -1315, -1315,
     1613   -1315, -1315,   504,   509, -1315, -1315,    76,  8833,  2235,   669,
     1614     439,   450,   519,   522,   537,   567,  8121,  7182,   529,   581,
     1615   -1315,  9443, -1315, -1315, -1315, -1315,   595, -1315,   216,  3771,
     1616    3771, -1315,   603,   313, -1315, -1315, -1315, -1315,   605,   316,
     1617     320,   345,   314,   589, -1315, -1315,  1619,  2809,   664, -1315,
     1618      49, -1315,   314,   314,   272, -1315, -1315,    87, -1315,   314,
     1619     314, -1315,  3249,   632,   636,   428,  7093, -1315, -1315,   646,
     1620    6920, -1315, -1315,   675, -1315, -1315, -1315,   272, -1315,   823,
     1621     120, -1315,  7972, -1315,   428,   428,   428,   272, -1315,   792,
     1622   -1315,  5155, -1315, -1315,   635,   428, -1315,   428, -1315,   257,
     1623    8833, -1315,   657, -1315,   787,   660,   428, -1315,   792,   679,
     1624     704, -1315,  7780,   574, -1315, -1315, -1315,  9296, -1315, -1315,
     1625    6389, -1315,   664,    74,  5169,  9099,  1777,  3249, -1315,    97,
     1626   -1315, -1315,  8985,   823,   708,  9849, -1315, -1315,   539, -1315,
     1627   10667,   680,   762, 10451,   751, 10470, 10528, -1315,   764, -1315,
     1628   -1315, -1315, -1315, 10547, 10547,  8605,   778, -1315, -1315, -1315,
     1629   -1315, -1315, -1315,   801, -1315,   969,  2181,  8947, 10470, -1315,
     1630     339,   731,   846,   265,   890,   795,   797,   810,   836,    33,
     1631   -1315, -1315,   812,   497, -1315,    59, -1315, -1315,  2235, -1315,
     1632   -1315,   588,   835, -1315,   622,   835,   847,   257, -1315, -1315,
     1633     863,  8871, -1315,   854,   878,  9061, -1315, -1315,   765,  1714,
     1634    8320,  7093,   675, -1315,   675,   428,   428, -1315, -1315, -1315,
     1635   -1315, -1315, -1315,   428,  8871,   823, -1315, -1315,  9213,   843,
     1636   -1315,  8757, -1315, -1315, -1315, -1315, -1315, -1315, -1315,   886,
     1637    3575, 10470, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315,
     1638   -1315, -1315, -1315, -1315, -1315, -1315,  1777, -1315,   793,   865,
     1639     884,   894,   869,   902,   905,   909,  2809, -1315, -1315,   918,
     1640     120,   935, -1315, -1315,   927, -1315, -1315, -1315,  9296, -1315,
     1641   -1315, -1315, -1315, -1315,  3249, -1315,  8833,  8833, -1315,   428,
     1642    1777,  7213,   823,  8393, -1315, -1315, -1315, -1315,  9296,    74,
     1643   -1315, -1315,   675,   272, -1315, -1315,  9296, -1315,  6557, -1315,
     1644   -1315,   428,   428,   295,  9519,   937,   942,   934,   955,   428,
     1645   -1315, -1315, -1315, -1315,  9927, -1315,   540,  6680, -1315,   272,
     1646     963, -1315,  1777, 10749,  5888, -1315, -1315, -1315, -1315,   899,
     1647    3249, -1315,  8466,   664,  7663, -1315, -1315, -1315,  1232,   551,
     1648     812,   787,  9849,   591,  8985, -1315,  9849, -1315, -1315, -1315,
     1649   -1315,   576, -1315,   980,   762,   283,  8605, -1315,  9699, -1315,
     1650   -1315,  8605, -1315,  8719,  8605, -1315, -1315,   987, -1315,   599,
     1651     996,   706,   999, -1315, -1315,  6048,  6769, -1315,   137, -1315,
     1652   -1315,  6053, -1315,   286,  6053, -1315, -1315, -1315, -1315, -1315,
     1653   -1315, -1315, -1315, -1315, -1315, -1315,  5169, -1315, -1315, 10470,
     1654   10470, 10470, 10470, 10470, 10470, 10470, 10470, 10470, 10470, 10470,
     1655   10470, 10470, 10470, 10470, 10470, 10470, 10470,  4672,  5169, -1315,
     1656     497,  1307, -1315, -1315,   314,   314, -1315, -1315,  8833, -1315,
     1657   -1315,   927,   574, -1315,   927, 10393, -1315, -1315, -1315,  9329,
     1658    6769,  1002,  1007, -1315,  9099, -1315, -1315,   595, -1315,  1019,
     1659     941,  1024,  1647,   103,   812, -1315,   314,   314,   812,   133,
     1660   -1315,   314,   314,   927, -1315, -1315,   314,   314, -1315,   835,
     1661    9781,   823, 10894,   412,   469,  9781, -1315,  6389, -1315,   812,
     1662   -1315,  8871, -1315,   191,  5383,  5383,  5383,   823, -1315,  4873,
     1663     979,   513,   886,   151,  1028,  1030, -1315,  1036,  3771,   531,
     1664   -1315,  1124,   823,  5383,   574,  1777,   574,   664,   782,   835,
     1665   -1315, -1315,   802,   835, -1315, -1315, -1315,   762, -1315,   835,
     1666     272,  9927, -1315,   606,  1050,   616,  1051, -1315,  1052,   272,
     1667   -1315, -1315,  9296,   272,  1054,  9699,  1053, -1315,  1508, -1315,
     1668     360,   367,   787, -1315,   787,  1056, 10470, -1315,   787, 10894,
     1669   -1315, -1315,  1059, -1315, -1315, -1315,   574, -1315, 10822,   878,
     1670   -1315,  5383,   769,  8320, -1315, -1315,   595,  1057,  1058,  1232,
     1671    3288, -1315, -1315,  9849, -1315, -1315,  1065, -1315, -1315,  1066,
     1672   -1315,  1065,  1064, 10667,  5169,   121,  1034,   100,  1074,  1071,
     1673    1075,   778,  1072,  1078, -1315,  1080,  1082,  9557,  6889, -1315,
     1674    5169, -1315,   706,  2222, -1315, -1315, -1315,   314,   314,  5021,
     1675    5169,  1079, -1315, -1315,   886,   619, -1315,  5169, -1315, -1315,
     1676     971, -1315, -1315, -1315, -1315,   339,   339,   731,   731,   846,
     1677     846,   846,   846,   265,   265,   890,   795,   797,   810,   836,
     1678   10470,   975, -1315,  9927,  1084,  1086,  1087,  1307, -1315, -1315,
     1679   -1315, -1315, -1315,  9927,   639,  5383, -1315,  8871, -1315,  7302,
     1680    9175, -1315,  8757,  7182, -1315, -1315,   941,  9927,   923,  1093,
     1681    1097,  1098,  1101,  1104,  1109,  1110, -1315,  3448,  1647, -1315,
     1682   -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315,
     1683   -1315, -1315, -1315, -1315, -1315, -1315,   927, -1315, -1315, -1315,
     1684     812, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315,  1111,
     1685   -1315,  1115,  1116, -1315, -1315,   120,  1079,  4873, -1315, -1315,
     1686   -1315,  3575,  1113, -1315, -1315, -1315, -1315, -1315,   787,  6479,
     1687    1200, -1315, -1315, -1315, -1315,  1100,   120, -1315, -1315,   927,
     1688   -1315, -1315,   927,   146,   927, -1315, -1315, -1315, -1315, -1315,
     1689   -1315,  9481, -1315,   272, -1315, -1315,   380,   387,  9213,  7422,
     1690    1947, 10470,  2081, -1315, -1315,  1121,    77,  1121, -1315,   787,
     1691   -1315,   314, -1315, -1315,  9630,   934, -1315, -1315, -1315,   942,
     1692    1122,  1117, -1315, -1315,  1129,  1130, -1315,   769,  2444, -1315,
     1693     476, -1315,  3288,   812, -1315,  1135,  9849,  9811,  8833,  1136,
     1694   -1315, -1315,  1127,  1137,  1131, -1315, 10470,   134,   293,  1138,
     1695   -1315,  1142,   574,  1142,  6769,  5169, -1315, -1315,  1142,  1139,
     1696   -1315,  1150,  1152,  1153,  2222, -1315, -1315, -1315,  3575, -1315,
     1697   -1315, -1315, -1315,  1156,  5169,  1140,   574,  4873, -1315,  6053,
     1698   -1315,   574, -1315, -1315,  5169, -1315,   842,   835, -1315, -1315,
     1699   -1315, -1315, -1315, -1315, -1315,   886,   878,  9061, -1315, -1315,
     1700    7542,  1163, -1315,   882,   835, -1315,   892,   926,   835, -1315,
     1701     428,  4553, -1315, -1315, -1315,  9927,  9927, -1315,  8393,  8393,
     1702   -1315,  1161,  1164,  1169,  1172, -1315,  1171,   527,    41,  1079,
     1703   -1315,   574, -1315,  3771, -1315,  5169,   423, -1315,  6649,  1175,
     1704    1177, 10335,  1178,  1181,     9,    73,    48,  5169,  1182,   272,
     1705    5169,  5169,  1132,  1180,   489,  1162, -1315, -1315, -1315,  1184,
     1706   -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315,   787,
     1707    1183,  5169, -1315,  9927,  9927,   314,  1186, -1315,  9668, -1315,
     1708   -1315,   984, -1315,  2081, -1315, -1315, -1315, -1315,  1508, -1315,
     1709   -1315,  1188, -1315, -1315, -1315, -1315,  1191,  2444, -1315, -1315,
     1710    1185, -1315,  1065, -1315, -1315,  1777,  1194, -1315, -1315, -1315,
     1711     640,  1198, -1315,   100,  1201, 10470,  1195,   100,   100,  1213,
     1712    1214, -1315,  6048,   959,   835, -1315, -1315,  1036,  5169,  1217,
     1713    1156,   654,    46,  1216, -1315,  1214, -1315,  1222,  1216, -1315,
     1714   -1315,  1226, -1315, -1315,   927,  1229,  1230,  7062,  1231,  1235,
     1715    1237, -1315, -1315,  1242, -1315, -1315,   927, -1315, -1315, -1315,
     1716   -1315,   927,  5169,  5169,   878,  1244, -1315, -1315, -1315, -1315,
     1717   -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, 10470, 10470,
     1718    1246,  1253,  1216, -1315, -1315,   787, -1315, -1315, -1315,  4813,
     1719    9811,  5169,  5169,  1321,  5169, -1315,  1239, -1315,  1247, -1315,
     1720    1248,  5169,  1250,  5169,   986,  1252,    81,   314,  9367,  1069,
     1721   -1315, -1315,  6479,  1261,   436, -1315, -1315, -1315, -1315, -1315,
     1722   -1315, -1315, -1315, -1315, 10153, -1315,  8466,  1268, -1315, -1315,
     1723    9811,   437,   451, -1315,  1270,  1271,   762,  1280, -1315,   352,
     1724   -1315, -1315,  5169,  1281, -1315, -1315,   927,  1277, -1315, -1315,
     1725    1284,   301,   375,   574,  1285,  1288, -1315,  1290, -1315,  9927,
     1726   -1315, -1315, -1315, -1315, -1315,  1291, -1315,  9927,  9927,  9927,
     1727   -1315, -1315,  1293, -1315,  1295,  1298,  1299,   590,  8088,  8204,
     1728   -1315, -1315,   304, -1315,  1302,  1303, -1315,  8539,   652,   671,
     1729    1308,   690,  6255, -1315, -1315, -1315,   471, -1315,   711,  1310,
     1730    1311,   272,  1363,  1043, -1315, -1315,  5169, -1315, 10335,  6053,
     1731   -1315, -1315, -1315,  1317,  1318, -1315, -1315, -1315,  1316, -1315,
     1732   -1315, -1315, -1315, -1315, -1315,  9811,   762,   155, -1315,  1300,
     1733     762,  1156,   297,  9927, -1315, -1315, -1315, -1315, -1315, -1315,
     1734   -1315, -1315,  1314, -1315, -1315, -1315, -1315, -1315, -1315,  1323,
     1735    1324, -1315, -1315, -1315, -1315, -1315, -1315, -1315,  1329, -1315,
     1736    1330, -1315, -1315, 10335,   135,  5169, 10335, -1315,  1333,  5169,
     1737   -1315,   281,  1344,  1348, -1315, -1315,  1340,  1343,  1331, -1315,
     1738     988, -1315, -1315, -1315,   823,  1777,  1338,   801,   995, 10470,
     1739   -1315,   713,  1349,  5169, -1315,   574,   574,  1350,  1355,  1356,
     1740    1358, -1315, -1315,  8393,  1359, -1315,  1430, 10470,  1360, -1315,
     1741   -1315, 10246, -1315,   722, -1315,  1347, 10335,  1352, -1315, -1315,
     1742    1366, -1315,  1370, -1315,  1385,  1386, -1315,  1354,  9811, -1315,
     1743   -1315, -1315,   762,   574,  1382,  1364,  1381, -1315,  1389,  1216,
     1744    1216, -1315, -1315, -1315, -1315, -1315, 10335,   197, -1315,  1000,
     1745   -1315, -1315,  7897, -1315, -1315,  1368,  5169, -1315,  5169,  7897,
     1746     272,  9699,   272,  9699,  1391, -1315,  1392, -1315, -1315,  1390,
     1747     801, -1315,   776, -1315, -1315,  5169, -1315,  1394,  1395, -1315,
     1748   10470, 10470, -1315, -1315,  1077,    85, -1315, -1315,  1372, -1315,
     1749    1077, -1315, -1315,  2494,   574, -1315, -1315,   272,  9699,   272,
     1750    9699,  1403,  1383,   574, -1315, -1315, -1315, -1315, -1315, 10246,
     1751    1401,  1077,  5739,  5169, 10157,  1402,  1077,  1408,  2494,  2404,
     1752   -1315, -1315, -1315,  1409, -1315, -1315, -1315, -1315,  8833, -1315,
     1753   -1315, -1315, 10024, -1315, 10246, -1315, -1315,  1388,  9931, -1315,
     1754   -1315, 10157,   272,  2404,   272,  1413,  1414,   857, -1315, 10024,
     1755   -1315, -1315, -1315,  9931, -1315, -1315, -1315,   272,   272, -1315,
     1756   -1315, -1315, -1315, -1315, -1315, -1315, -1315
    17531757};
    17541758
    … …  
    17561760static const yytype_int16 yypgoto[] =
    17571761{
    1758    -1414,  4377,  3077, -1414,  1645, -1414,   305,   958,   -11, -1414,
    1759      552,  -530,  -487,  -944,  -142,  3604,     0, -1414,  1277,   511,
    1760      529,   298,   549,  1057,  1060,  1054,  1062,  1065, -1414,  -211,
    1761     -327,  5116,  -961,  -725,  -952, -1414,  -200,  -594,   572, -1414,
    1762     1379, -1414,   397, -1413, -1414, -1414,   129, -1414, -1160,  -935,
    1763      246, -1414, -1414, -1414, -1414,    68, -1131, -1414, -1414, -1414,
    1764    -1414, -1414, -1414,   321, -1152,    33, -1414,  -696, -1414,   506,
    1765      296, -1414,   169, -1414,  -339, -1414, -1414, -1414,   558,  -728,
    1766    -1414, -1414,    19,  -974,   177,  2303, -1414, -1414, -1414,   -91,
    1767    -1414,   166,   269,  -194,  1705,  3615, -1414, -1414,    36,   224,
    1768      628,  -235,  1694, -1414,  1557, -1414, -1414,   200,  2163, -1414,
    1769     2278,   185, -1414, -1414, -1414,  -607, -1414,   956,   957,   545,
    1770      725,  -320, -1414, -1414, -1414,   950,   719,  -493, -1414,  -472,
    1771     -355,  1296, -1414, -1414,  -899,  -946,   440,   524,  1067,   168,
    1772    -1414,  1040,   317,  -281,  -198,  -141,   672,   781, -1414,  1005,
    1773    -1414,  2834,    55,  -450,   932, -1414, -1414,   712, -1414,  -228,
    1774    -1414,   104, -1414, -1414, -1414, -1285,   420, -1414, -1414, -1414,
    1775     1178, -1414,    31, -1414, -1414,  -862,   -94, -1364,  -152,  1641,
    1776    -1414,  3733, -1414,   927, -1414,  -170,   493,  -184,  -183,  -181,
    1777        7,   -42,   -36,   -33,  1610,     4,    10,    14,  -143,  -177,
    1778     -172,  -162,  -161,  -319,  -513,  -508,  -498,  -547,  -310,  -528,
    1779    -1414, -1414,  -511,  1101,  1102,  1110,  1575,  4802,  -565,  -560,
    1780     -559,  -541,  -551, -1414,  -506,  -744,  -736,  -732,  -593,  -267,
    1781     -227, -1414, -1414,   624,   294,   -85, -1414,  3753,    44,  -634,
    1782     -173
     1762   -1315,  4470,  3041, -1315,    39, -1315,  2507,   957,  -207, -1315,
     1763     461,  -523,  -489,  -955,  -200,  5636,     0, -1315,    72,   572,
     1764     580,   245,   566,   964,   967,   968,   966,   976, -1315,  1601,
     1765    -609,  5067,  -949, -1315,  -712,  -938,   430,  -728,   512, -1315,
     1766    1697, -1315,   311, -1200, -1315, -1315,    43, -1315, -1142, -1154,
     1767     154, -1315, -1315, -1315, -1315,   -26, -1161, -1315, -1315, -1315,
     1768   -1315, -1315, -1315,   231, -1202,    53, -1315,  -908, -1315,   416,
     1769     205, -1315,    78, -1315,  -367, -1315, -1315, -1315,   470,  -824,
     1770   -1315, -1315,    13,  -940,   465,  2639, -1315, -1315, -1315,  -107,
     1771   -1315,   102,   269,  -201,  1635,  4179, -1315, -1315,     5,   449,
     1772     756,  -259,  1489, -1315,  1725, -1315, -1315,    52,  2057, -1315,
     1773    2147,   612, -1315, -1315, -1315,  -616, -1315,   866,   867,   456,
     1774     631,   158, -1315, -1315, -1315,   858,   633,  -514, -1315,  -544,
     1775    -359,  1913, -1315, -1315,  -928,  -991,  1380,  1398,   990,   324,
     1776   -1315,   171,   457,  -332,  -192,  -147,   584,   695, -1315,   919,
     1777   -1315,  2794,  1328,  -442,   850, -1315, -1315,   625, -1315,  -238,
     1778   -1315,   -94, -1315, -1315, -1315, -1246,   330, -1315, -1315, -1315,
     1779    1091, -1315,    35, -1315, -1315,  -834,   -97, -1314,  -130,  1985,
     1780   -1315,  3026, -1315,   844, -1315,  -170,  1212,  -183,  -173,  -167,
     1781       7,   -35,   -34,   -33,   936,    18,    55,    61,  -143,  -159,
     1782    -156,  -153,  -151,  -323,  -535,  -528,  -526,  -542,  -318,  -520,
     1783   -1315, -1315,  -512,  1006,  1009,  1011,  2067,  4895,  -560,  -543,
     1784    -538,  -536,  -484, -1315,  -481,  -740,  -737,  -736,  -586,  -304,
     1785    -339, -1315, -1315,   856,   707,   -88, -1315,  3848,    29,  -599,
     1786    -291
    17831787};
    17841788
    … …  
    17861790   positive, shift that token.  If negative, reduce the rule which
    17871791   number is the opposite.  If YYTABLE_NINF, syntax error.  */
    1788 #define YYTABLE_NINF -526
     1792#define YYTABLE_NINF -525
    17891793static const yytype_int16 yytable[] =
    17901794{
    1791       50,   115,   151,   400,   401,   771,   402,    99,   152,   973,
    1792      403,   153,   429,   454,   874,   404,   756,   974,   408,  1080,
    1793      116,   975,   262,   441,   269,   405,   406,   744,   850,   384,
    1794      385,   605,    50,    51,  1142,   982,    70,   411,   833,    99,
    1795      610,   825,   826,   727,   149,   409,   499,   732,   154,  1150,
    1796       50,    31,  1398,   836,   155,  1462,   832,   163,   156,   843,
    1797      827,   800,   282,   145,   188,    51,  1208,   211,    70,   528,
    1798       50,   195,   343,   824,   218,   567,  1200,   228,    31,   597,
    1799      671,  -235,  -235,   400,   401,  1184,   402,   926,   821,   221,
    1800      403,  1318,   170,   822,   168,   404,   520,   737,   408,  1194,
    1801      680,  1217,  1218,   823,   738,   405,   406,   115,   684,   426,
    1802      568,   476,   478,  1550,    31,   115,   171,   124,   268,   273,
    1803      283,   254,   217,   412,    31,   409,  1209,   410,   715,  1462,
    1804     1210,  1182,  1183,  1561,    31,  1419,  1420,    31,   629,   244,
    1805     1565,   955,   633,   865,   866,   151,   675,   677,   308,   149,
    1806      412,   152,  -235,  1079,   153,  1481,   163,   115,   346,   168,
    1807     1319,   884,   211,   863,   863,   863,    64,   472,   973,   374,
    1808      722,   204,   477,    31,   217,   528,   974,    57,   117,  1260,
    1809      975,   853,   863,   920,   420,   854,   412,   188,   188,  1212,
    1810     1211,   154,   328,   578,   482,   163,   412,   155,    64,   579,
    1811       78,   156,   528,   268,   834,  1421,   602,   821,   528,    57,
    1812      956,    50,   822,   669,   731,  1190,   716,   217,   163,   938,
    1813      293,   205,   823,   211,    71,   151,   179,   674,   676,  1127,
    1814      444,   152,    78,   746,   153,  1213,  1087,   666,  -113,  -113,
    1815      863,   308,  1191,   841,   212,   602,  1263,   222,   580,   958,
    1816      412,   125,   216,    50,  -113,   437,    71,   589,   825,   826,
    1817       99,   273,   144,  1466,   667,  1026,   273,   268,   268,   836,
    1818      118,  1152,   506,   115,  1264,   163,   263,   827,   217,   264,
    1819      864,   864,   864,  1025,   464,   328,    51,   343,  1001,    70,
    1820     1013,   214,  1184,   610,   108,   108,   308,  1103,   804,   864,
    1821     1090,   146,  1343,   658,   216,   821,   113,   520,   308,   378,
    1822      822,   666,   520,   148,  1004,   520,   217,   437,   725,   161,
    1823      823,   217,  1199,  1508,   572,   379,   108,   477,   472,   149,
    1824     1200,   673,  1419,  1420,   448,   863,   374,   678,   667,   855,
    1825     -470,   157,   115,   856,   905,  1184,   346,   216,   472,   569,
    1826      603,   621,   168,   461,   597,   528,   472,   864,  1537,   597,
    1827     1539,  1466,  1080,   810,   108,   626,  1466,   388,   793,   626,
    1828      930,  -470,   115,  -470,  1492,   833,   260,  -470,  -113,   825,
    1829      826,   685,  1401,   389,   161,  1405,  1466,   579,   440,  1128,
    1830      599,  1182,  1183,  1466,   715,  1551,  1129,   268,   827,  -113,
    1831      442,  1191,  1430,   557,   558,   859,   217,   188,   216,     8,
    1832        9,    10,    11,    12,   374,   173,   850,   324,   183,    64,
    1833       43,   252,  1566,   876,   473,   268,   340,   308,   308,  1247,
    1834       57,   268,   837,  1251,   626,   571,   840,   412,    31,   559,
    1835      560,   343,   484,   391,    46,    47,   216,   443,   494,   501,
    1836      495,   216,   864,    78,   877,   115,   644,   857,    78,   392,
    1837      878,   860,   393,  1451,  1452,  1214,    34,  1170,  1172,  1184,
    1838     1138,   328,   328,   268,   203,   855,   431,    71,   394,  1110,
    1839      435,   268,   716,   626,   395,    50,   929,   217,   374,   721,
    1840     1200,   112,    99,    98,   736,   115,  1079,  1200,  1114,   499,
    1841      396,   249,    41,    42,  1148,  1259,   888,   308,   875,   115,
    1842      324,  1024,   308,  -291,   308,   308,  1457,   179,    51,   917,
    1843      610,    70,   754,  -521,   921,    98,   115,   346,  1341,   217,
    1844      763,   583,   923,   412,   630,  1342,   216,   150,   634,   328,
    1845      922,   112,   435,    98,  1026,   489,   919,   108,   924,    43,
    1846     1200,  -106,    41,    42,   921,  -106,   715,   191,   328,   466,
    1847       98,  1521,   886,    98,   753,   522,   412,  1526,   923,   254,
    1848     1091,   572,   572,    46,    47,   214,  1381,   161,   265,   308,
    1849      769,   995,  1006,    43,  1092,   473,  1094,   810,  1546,  1138,
    1850      626,   346,   472,  1553,   920,   621,  1197,  1097,   939,  1097,
    1851      602,   603,   331,   603,  1197,   473,  1332,    46,    47,   332,
    1852      706,   588,  1198,   473,  1334,   594,   707,   216,   935,    78,
    1853     1324,   626,  1333,   328,   751,  1024,   626,   812,   621,  1367,
    1854     1335,  1126,   626,  1368,   627,   626,   626,   626,   631,    78,
    1855     1382,   340,    98,   889,   716,   412,  -113,    78,  -113,   713,
    1856      217,    64,  -113,   -10,   626,    98,   268,   895,  1039,   216,
    1857      723,   112,    57,   343,  -444,   851,   724,  -113,  -113,  1037,
    1858      599,   733,    41,    42,   165,  1181,   810,   734,   217,  1029,
    1859      399,   191,   288,   217,  -445,    78,   115,   254,   330,   914,
    1860     1084,   553,   554,    41,    42,   750,   324,   324,   214,   231,
    1861     1348,   751,   929,   232,    98,   892,   236,   412,   238,    71,
    1862     1379,   550,   626,   940,   621,   247,    98,   551,   552,   515,
    1863      721,   721,  1122,  1154,   689,   412,   278,   959,   400,   401,
    1864      280,   402,  1044,   555,   556,   403,  1498,   118,   281,   165,
    1865      404,   333,   597,  1498,   408,   334,    98,   929,   115,   346,
    1866      405,   406,   335,   754,   754,   217,   112,   336,   141,   142,
    1867      480,   372,   489,   112,   324,   373,   489,    41,    42,   217,
    1868      377,   409,  1111,   113,    41,    42,   522,   112,   522,   108,
    1869      216,   522,   386,   324,   522,  1151,   973,  1429,    41,    42,
    1870      852,  1392,   994,   991,   974,   340,  1547,   899,   975,   572,
    1871     1249,   390,  1350,   751,   715,   398,   867,   626,   216,   626,
    1872      901,  1009,   410,   216,   626,   346,   751,   990,   603,   743,
    1873      427,   883,    98,   991,   739,   343,   740,  1003,  1174,   741,
    1874      603,   428,   747,   707,   764,   436,  1039,   743,   433,   770,
    1875      743,   451,   231,   604,   529,   530,   531,   443,   324,   473,
    1876      112,   812,   141,   142,  1245,   781,   782,   783,   784,   808,
    1877      579,    41,    42,  1292,  1293,  1375,   217,  1166,   532,   412,
    1878      533,   751,   534,   535,  1500,   473,  1501,  -368,  1376,  -397,
    1879     1378,   308,   462,    78,   751,   216,   751,  1383,   466,   870,
    1880      849,   505,   716,   751,  1169,   594,   602,   436,   463,   216,
    1881      191,   858,   501,   626,  1195,   704,  1171,   810,   602,    78,
    1882      115,   346,   914,  1447,   914,   713,   929,    70,   485,  1444,
    1883      524,  1467,  1514,  1571,   214,   666,   115,   751,  1515,   579,
    1884      917,  1548,   165,   293,  1256,  1370,   412,   509,   214,   940,
    1885      940,   529,   530,   531,   721,   254,   330,   412,   514,   115,
    1886      308,   528,   667,   561,   562,   689,   526,   919,    49,   114,
    1887      885,   563,   887,   751,   996,   532,   346,   533,  1115,   534,
    1888     1321,   716,   565,    37,   330,   412,   754,    40,    98,   929,
    1889      929,   231,   604,   236,    41,    42,   564,   114,   114,   705,
    1890       49,  1388,  1389,   489,   328,    43,   216,  1439,   991,  1533,
    1891     1444,  1445,    49,  1300,  1301,   566,  1303,   569,    49,   346,
    1892       44,   339,   934,  1308,  -441,  1310,    49,   340,   587,    46,
    1893       47,   694,    49,  1240,   590,    49,  1493,  1494,    49,    -3,
    1894      626,   626,   420,   662,   412,   214,     2,   208,     4,     5,
    1895        6,     7,   114,   114,   482,   330,   412,    64,   639,  1138,
    1896      308,  1419,  1420,   851,   834,   330,   602,   659,    57,     8,
    1897        9,    10,    11,    12,   777,   778,    49,   217,   668,    49,
    1898      143,   231,   660,   661,  1446,   663,    49,   713,  1005,   693,
    1899      664,    78,   665,   808,   779,   780,  1202,   670,    31,   259,
    1900      115,   697,  1459,   695,   820,   914,   604,  1311,  1312,  1313,
    1901      914,    35,   699,    36,  -239,    71,   735,    49,   748,   940,
    1902      785,   786,   704,   752,   959,    49,    34,   268,   959,   959,
    1903       49,  1349,  1351,  1352,   243,   246,  1116,   760,   813,   -12,
    1904      814,   524,   817,   524,   626,   343,   524,   828,   -13,   524,
    1905     -292,   872,   873,    43,   880,    49,    49,     8,     9,    10,
    1906       11,    12,   900,   902,   724,   907,   903,   910,   571,   346,
    1907      412,    49,   928,  -418,    -3,  1519,  1459,    46,    47,    49,
    1908     -525,   943,   808,   950,   964,   108,    31,  1425,    49,   340,
    1909      952,    49,   918,   957,   963,   965,   967,   968,   114,   969,
    1910      929,   970,   986,   998,   999,   689,   705,   216,  1000,  1015,
    1911     1016,   273,   115,   114,    34,  1017,  1018,   114,   929,  1019,
    1912     1020,    49,   114,   820,   604,  1021,   473,   489,  1117,   324,
    1913      115,   221,  1032,  -406,   308,    49,    49,    57,  -405,    37,
    1914     1081,  1046,    49,    40,  1083,   704,   443,  1339,   626,    49,
    1915       41,    42,   115,   108,   913,   704,   112,  1105,   141,   240,
    1916       78,    43,   112,  1104,   141,   142,   217,    41,    42,   704,
    1917       70,  1115,  1106,    41,    42,  1107,   818,   751,   602,  1131,
    1918     1113,  1123,  1124,  1125,    71,    46,    47,  1134,   849,  1130,
    1919      980,   929,   929,   241,  1140,   458,  1135,    49,   242,   728,
    1920      626,   626,  1136,  1144,   729,  1137,   743,  1164,  1144,   273,
    1921     1143,  1187,  1185,  1442,   308,  1186,  -293,    49,    49,  1188,
    1922      693,   820,  1559,     8,     9,    10,    11,    12,  1189,   705,
    1923     1203,  1204,  1206,   604,    49,   713,  1207,  1399,    49,   705,
    1924     1215,  1399,  1219,    -3,  1220,  1222,  1227,   115,  1232,   645,
    1925     1202,  1237,    31,   705,   108,  1235,   400,   401,  1144,   402,
    1926     1241,  1246,   494,   403,   217,    49,  1115,  1248,   404,   689,
    1927     1253,   408,  1254,  1261,  1250,    49,  1268,  1270,   405,   406,
    1928       34,     2,   208,     4,     5,     6,     7,  1265,   212,   222,
    1929     1272,  1273,  1302,    49,  1274,   666,   216,  1275,   409,    49,
    1930       64,    49,  1276,  1278,  1285,  1305,  1294,   268,  1295,  1306,
    1931      230,    57,  1323,   808,   713,  1093,   131,   918,   132,   133,
    1932      134,  1532,   667,  1307,  1330,   626,  1336,    41,    42,  1116,
    1933     1309,   646,  1317,  1338,    78,   214,   114,  1340,  1344,  1346,
    1934     1347,    49,  1353,  1482,  1354,   175,    35,   604,    36,    49,
    1935      115,  1355,  1357,    49,  1363,  1364,  1365,    49,    71,  1366,
    1936      114,  1377,   114,  1068,    37,  1373,   176,   177,    40,  1115,
    1937     1374,  1384,  1385,  1313,   115,    41,    42,   704,   704,  1393,
    1938      473,   115,   645,   115,  1394,   115,   442,  1395,   255,  1402,
    1939     1413,    57,  1405,  1414,   216,  -407,  1417,   114,   151,   340,
    1940      645,   373,   114,   645,   152,  1428,   108,   153,  1432,  1436,
    1941     1202,  1434,  1437,  1443,    78,  1531,  1448,  1202,  1438,  1453,
    1942      115,  1117,   115,  1368,  1116,  1458,  1454,  1455,   108,  1456,
    1943     1472,  1463,  1474,   443,   115,   704,   704,  1468,    71,  1476,
    1944     1531,  1531,   726,  1470,   730,  -294,   108,  1478,   163,  1485,
    1945      308,   114,     8,     9,    10,    11,    12,  1480,    49,  1486,
    1946      693,   705,   705,  1487,    37,  1531,  1488,    76,    40,    49,
    1947     1202,    49,   374,   511,  1441,    41,    42,  1499,  1144,  1144,
    1948     1144,    31,  1509,  1511,   418,  1513,    43,  1517,  1518,  1525,
    1949       49,  1540,  1541,  1545,   328,   548,   549,  1554,   918,    76,
    1950     1552,   720,   112,   918,   141,   142,    49,   438,   108,    34,
    1951       46,    47,   114,    41,    42,  1556,  1117,   446,  1562,   705,
    1952      705,    49,  1569,   114,    49,   114,  1570,  1116,  1221,   789,
    1953      787,  1322,  1520,   548,   788,  1205,   743,   224,   790,  1431,
    1954      473,   108,   791,  1572,   245,  1387,  1252,   473,  1403,  1226,
    1955     1502,    57,   908,   909,  1098,  1234,  1102,    49,    57,   931,
    1956      806,   114,  1139,   114,  1045,   879,   945,   114,  1112,   548,
    1957      164,   953,  1331,   718,    78,   114,     0,   126,   129,   130,
    1958        0,    78,   796,   797,   196,   521,  1328,   219,    49,    49,
    1959      229,   798,     0,     0,   871,     0,     0,     0,    71,     0,
    1960      473,     0,    49,     0,     0,    71,    37,     0,   176,   177,
    1961       40,    57,     0,   178,     0,    67,   119,    41,    42,  1117,
    1962        0,   704,  1144,  1144,   693,   354,     0,     0,     0,   704,
    1963      704,   704,     0,     0,    78,     2,   208,     4,     5,     6,
    1964        7,     0,     0,   925,   108,   927,     0,    67,     0,   458,
    1965        0,   256,  1505,   257,  1505,     0,     0,     0,    71,     0,
    1966     1483,     0,     0,   178,     0,   162,   178,     0,   108,   164,
    1967     1329,   215,     0,     0,     0,   108,   414,     0,     0,     0,
    1968        0,   234,   375,   422,     0,   223,    49,     0,     0,  1505,
    1969        0,  1505,     0,     0,     0,   704,     0,     0,    49,   450,
    1970       35,     0,    36,     0,     0,   705,  1068,     0,   164,     0,
    1971        0,     0,   178,   705,   705,   705,     0,     0,     0,   324,
    1972       76,  1534,   261,   215,     0,    76,     0,     0,   108,     0,
    1973     1542,   164,     0,   682,   397,     0,     0,   774,   775,   776,
    1974        0,   645,     0,   445,   416,   417,     0,     0,   114,   421,
    1975        0,   423,   424,     0,     0,   414,     0,     0,    37,   708,
    1976      176,   177,    40,     0,   329,     0,   215,     0,     0,    41,
    1977       42,    49,   261,   351,     0,   178,     0,     0,     0,   705,
    1978       49,     0,    49,     0,     0,     0,     0,     0,    37,   114,
    1979      185,   186,    40,     0,     0,   377,   521,     0,     0,    41,
    1980       42,   521,  1391,   407,   521,     0,     0,     0,     0,   577,
    1981       43,     0,    49,     0,     0,     0,     0,   581,   425,   224,
    1982      584,   430,   432,   646,     0,   187,   162,   215,     0,   178,
    1983     1049,     0,   114,     0,    46,    47,   178,     0,     0,     0,
    1984        0,     0,     0,     0,     0,     0,     0,   449,   645,   375,
    1985        0,   452,     0,   453,     0,     0,   114,  1418,     0,   645,
    1986     1426,   114,   460,     0,     0,   215,     0,     0,    67,     0,
    1987      215,  1099,     0,   474,     0,     0,     0,     0,   898,     0,
    1988        0,     0,     0,   481,   414,   500,    76,     0,   422,     0,
    1989        0,   432,     0,     0,     8,     9,    10,    11,    12,     0,
    1990        0,   354,     0,     0,   178,  1465,    76,     0,     0,     0,
    1991     1469,   114,     0,     0,    76,     8,     9,    10,    11,    12,
    1992        0,   178,     0,    31,     0,   178,     0,   375,     0,     0,
    1993      646,     0,   354,   480,     0,     0,     0,     0,     0,     0,
    1994     1491,     0,     0,     0,    31,     0,     0,   981,     0,   114,
    1995      354,    34,    76,     0,     0,   215,     0,   261,     0,     0,
    1996      897,   595,     0,    49,     0,   414,     0,   623,    49,   904,
    1997        0,     0,    34,   906,     0,     0,     0,     0,    43,     0,
    1998      628,     0,     0,     0,   628,    49,     0,   261,   178,     0,
    1999        0,     0,     0,   753,   354,   412,     0,     0,     0,    43,
    2000        0,   997,    46,    47,     0,     0,     0,  1506,     0,  1506,
    2001        0,  1002,     0,     0,   939,     0,   602,     0,     0,     0,
    2002        0,     0,     0,    46,    47,  1014,  1560,     0,     0,     0,
    2003        0,  1049,  1560,     0,   474,     0,   215,     0,     0,     0,
    2004        0,     0,     0,  1560,  1506,     0,  1506,  1560,    37,   351,
    2005      185,   186,    40,   215,   474,     0,   577,   577,   354,    41,
    2006       42,     0,   474,     0,    37,   114,   185,   186,    40,     0,
    2007       43,     0,     0,    79,     0,    41,    42,     0,   215,     0,
    2008      700,     0,     0,   432,     0,   912,    43,   412,    49,     0,
    2009        0,     0,     0,   913,    46,    47,     0,     0,   714,     0,
    2010       67,   267,   354,   354,   354,    79,     0,     0,   432,     0,
    2011       46,    47,   432,     0,     0,     0,     0,     0,     0,     0,
    2012        0,   354,     0,     0,     0,     0,   801,   802,     0,     0,
    2013        0,   114,   114,   114,     0,     0,     0,     0,     0,   354,
    2014        0,   261,   351,   225,   890,   178,     0,  1298,   893,     0,
    2015       76,     0,     0,     0,     0,   835,     0,     0,   838,   839,
    2016        0,   842,     0,   844,   845,     0,     0,     0,   846,   847,
    2017        0,     0,     0,     0,     0,     0,    76,   178,     0,   354,
    2018        0,     0,     0,     0,     0,     0,     0,   799,    81,   645,
    2019        0,     0,     0,   178,  1089,     0,   548,     0,     0,   215,
    2020        0,     0,     0,     0,     0,   628,   811,     0,   178,     0,
    2021        0,     0,     0,    58,    58,     0,   354,     0,   830,     0,
    2022       81,     0,     0,     0,     0,     0,     0,   215,     0,     0,
    2023        0,   356,   215,  1179,  1180,     0,   595,   511,     0,     0,
    2024        0,   595,     0,     0,     0,    58,     0,   628,     0,     0,
    2025      351,   351,   351,     0,     0,     0,     0,     0,   226,     0,
    2026        0,     0,   354,     0,    49,    49,     0,     0,     0,   351,
    2027        0,     0,   354,     0,   354,   114,   114,     0,     0,   224,
    2028       58,     0,   354,    58,   577,     0,   354,   700,     0,   178,
    2029        0,  1229,  1230,     0,     0,     0,     0,     0,   474,     0,
    2030        0,     0,     0,     0,   215,     0,     0,     0,     0,   978,
    2031      979,     0,     0,   114,     0,     0,     0,     0,   215,     0,
    2032        0,     0,     0,     0,   474,     0,    79,   351,     0,     0,
    2033        0,    79,     0,     0,     0,     0,   944,     0,   500,   432,
    2034       37,     0,   185,   186,    40,     0,   357,     0,    76,     0,
    2035     1216,    41,    42,     0,    37,     0,   185,   186,    40,     0,
    2036        0,     0,    43,   261,   714,    41,    42,     0,     0,   976,
    2037        0,   349,     0,    49,   114,     0,    43,   601,   354,   602,
    2038        0,     0,     0,   114,     0,     0,    46,    47,     0,     0,
    2039        0,   912,     0,   412,     0,     0,     0,     0,    49,    49,
    2040       46,    47,     0,   414,     0,     0,     0,     0,     0,     0,
    2041      700,     0,     0,     0,     0,   215,     0,     0,     0,     0,
    2042      700,     0,   351,    49,   628,   225,     0,  1012,     0,   628,
    2043      811,     0,     0,   354,   700,     0,    58,     0,     0,     0,
    2044        0,    81,     0,     0,  1023,     0,    81,   536,   537,   538,
    2045      539,   540,   541,   542,   543,   544,   545,     0,   178,     0,
    2046        0,     0,     0,     0,     0,     0,    58,    37,     0,   185,
    2047      186,    40,     0,     0,  1100,     0,     0,  1356,    41,    42,
    2048        0,   546,     0,  1155,     0,  1358,  1359,  1360,     0,    43,
    2049        0,     0,    79,     0,   354,   354,    67,   354,   354,     0,
    2050     1167,     0,     0,     0,  1530,     0,   412,   356,     0,     0,
    2051        0,     0,    79,    46,    47,     0,     0,    76,   628,     0,
    2052       79,     0,     0,     0,     0,   261,   714,     0,     0,  1095,
    2053        0,     8,     9,    10,    11,    12,     0,     0,   356,     0,
    2054      226,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2055        0,  1406,   354,   354,     0,  1109,   356,     0,    79,     0,
    2056       31,     0,     0,   432,   119,     0,     0,     0,     0,     0,
    2057        0,     0,     0,     0,     0,     0,     0,     0,   414,     0,
    2058        0,   351,     0,     0,     0,     0,     0,     0,    34,     0,
    2059        0,     0,     0,    37,     0,   185,   186,    40,     0,     0,
    2060      356,     0,  1386,     0,    41,    42,     0,    81,     0,     0,
    2061        0,     0,     0,     0,     0,    43,   215,     0,     0,     0,
    2062     1257,     0,   357,     0,   595,     0,   354,    81,     0,     0,
    2063      601,     0,   602,     0,     0,    81,     0,   430,  1231,    46,
    2064       47,     0,   700,   700,     0,   351,   351,   349,     0,     0,
    2065        0,     0,     0,   357,     0,     0,     0,     0,     0,     0,
    2066        0,     0,     0,     0,   356,  1201,     0,     0,     0,   224,
    2067        0,   357,     0,    81,     0,     0,     0,     0,     0,     0,
    2068        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2069        0,    76,     0,     0,     0,     0,     0,     0,    58,     0,
    2070      700,   700,     0,   354,     0,   354,     0,     0,   356,   356,
    2071      356,     0,     0,     0,     0,   357,     0,     0,     0,     0,
    2072        0,     0,     0,     0,     0,     0,     0,   356,     0,     0,
    2073        0,     0,     0,     0,     0,     0,     0,     0,   354,     0,
    2074      349,     0,     0,     0,    88,   356,   354,   354,   354,   628,
    2075        0,     0,     0,     0,     0,     0,    79,   354,   354,     0,
    2076        0,  1503,     0,  1507,     0,     0,     0,     0,     0,     0,
    2077     1320,    76,     0,     0,   714,   178,    88,     0,     0,   357,
    2078        0,     0,    79,     0,     0,   356,     0,     0,     0,     0,
    2079        8,     9,    10,    11,    12,     0,     0,     0,  1536,     0,
    2080     1538,     0,     0,     0,   349,   215,     0,     0,     0,     0,
    2081        0,     0,   354,     0,   227,     0,     0,  1299,     0,    31,
    2082        0,     0,   356,   357,   357,   357,     0,     0,     0,     0,
    2083        0,     0,     0,     0,     0,   261,     0,     0,     0,    67,
    2084        0,     0,   357,  1567,     0,  1568,     0,    34,   349,   349,
    2085      349,   700,    37,   714,   185,   186,    40,   119,  1575,  1576,
    2086      357,     0,     0,    41,    42,     0,     0,   349,   356,     0,
    2087        0,    81,     0,     0,    43,     0,     0,     0,   356,     0,
    2088      356,     0,   354,     0,     0,   225,   700,     0,   356,   912,
    2089        0,   412,   356,     0,   700,   700,   700,    81,    46,    47,
    2090      357,     0,   364,   215,     0,   351,   351,     0,     0,     0,
    2091        0,     0,     0,     0,     8,     9,    10,    11,    12,  1201,
    2092        0,     0,     0,     0,     0,   349,     0,     0,     0,     0,
    2093        0,    76,     0,     0,     0,     0,     0,   357,    76,     0,
    2094        0,     0,     0,    31,     0,     0,     0,     0,     0,     0,
    2095        0,   178,   119,     0,    79,     0,     0,     0,     0,     0,
    2096      700,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2097        0,    34,     0,     0,     0,     0,    37,     0,   185,   186,
    2098       40,     0,     0,   357,   356,     0,     0,    41,    42,     0,
    2099        0,    76,     0,   357,     0,   357,     0,    88,    43,     0,
    2100      226,     0,    88,   357,     0,     0,     0,   357,     0,     0,
    2101        0,     0,     0,  1530,     0,   412,     0,     0,     0,     0,
    2102      349,     0,    46,    47,     0,     0,     0,     0,   349,     0,
    2103      351,     0,     0,     0,     0,     0,     0,     0,     0,   356,
    2104        0,   169,     0,   174,     0,     0,   180,   181,   182,     0,
    2105      184,     0,     0,     0,     0,   119,     8,     9,    10,    11,
    2106       12,     0,     0,     0,     0,   235,     0,     0,     0,    81,
    2107        0,     0,     0,     0,     0,     0,     0,   250,   251,  1201,
    2108        0,     0,     0,     0,     0,    31,  1201,     8,     9,    10,
    2109       11,    12,     0,     0,    58,     0,   227,     0,     0,   357,
    2110      356,   356,     0,   356,   356,     0,     0,     0,     0,     0,
    2111        0,     0,     0,    34,     0,     0,    31,     0,    37,     0,
    2112      185,   186,    40,    79,     0,     0,     0,     0,     0,    41,
    2113       42,     0,     0,     0,     0,     0,     0,     0,     0,  1201,
    2114       43,     0,     0,     0,    34,     0,  1555,     0,     0,    37,
    2115        0,   185,   186,    40,   357,   187,     0,     0,   356,   356,
    2116       41,    42,    58,    88,    46,    47,     0,     0,     0,     0,
    2117        0,    43,     0,     8,     9,    10,    11,    12,   364,   349,
    2118        0,     0,     0,    88,     0,     0,   267,     0,     0,     0,
    2119        0,    88,     0,     0,     0,    46,    47,     0,     0,     0,
    2120        0,     0,    31,     0,     8,     9,    10,    11,    12,   364,
    2121        0,     0,     0,     0,     0,   357,   357,     0,   357,   357,
    2122        0,     0,     0,     0,     0,     0,     0,   364,     0,    88,
    2123       34,     0,   356,    31,     0,    37,     0,     0,    81,    40,
    2124        0,     0,     0,   349,   349,     0,    41,    42,     0,     0,
    2125        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2126        0,    34,     0,    58,     0,     0,    37,     0,     0,     0,
    2127       40,   364,    44,   357,   357,   225,     0,    41,    42,     0,
    2128        0,    46,    47,     0,     0,     0,     0,     0,    43,     0,
    2129        0,     0,     0,     0,     0,     0,     0,    79,     0,     0,
    2130        0,     0,     0,   720,     0,     0,     0,     0,     0,   356,
    2131        0,   356,    46,    47,     8,     9,    10,    11,    12,    13,
    2132       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2133       24,    25,   592,     0,   600,   364,     0,     0,     0,     0,
    2134        0,     0,     0,    31,   356,   624,   625,   357,     0,     0,
    2135        0,     0,   356,   356,   356,     0,     0,     0,     0,     0,
    2136        0,     0,     0,   356,   356,     0,     0,     0,     0,     0,
    2137        0,    34,     0,     0,     0,     0,     0,    79,     0,   364,
    2138      364,   364,     0,     0,     0,     0,     0,     0,     0,     0,
    2139      226,     0,     0,     0,     0,     0,     0,     0,   364,     0,
    2140      284,   285,     0,   286,     0,     0,     0,     0,     0,     0,
    2141        0,     0,    81,     0,    58,    58,   364,     0,   356,     0,
    2142        0,     0,     0,     0,   357,     0,   357,    88,     0,   287,
    2143        0,     0,     0,     0,     0,   288,     0,    58,     0,   289,
    2144        0,     0,   290,   291,   292,   293,    41,    42,     0,   294,
    2145      295,     0,     0,    88,     0,    58,   364,    43,     0,   357,
    2146        0,     0,     0,     0,     0,     0,     0,   357,   357,   357,
    2147        0,     0,   296,     0,   380,     0,     0,   381,   357,   357,
    2148        0,    46,    47,   298,   299,   300,   301,     0,   356,     0,
    2149        0,     0,    81,   364,     0,     0,     0,     0,     0,     0,
    2150        0,     0,     0,   349,   349,     0,     0,     0,     0,     0,
    2151        0,     0,    58,     0,     0,     0,     0,    58,     0,     0,
    2152        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2153        0,     0,     0,   357,     0,     0,     0,    79,     0,   364,
    2154        0,     0,     0,     0,    79,     0,     0,     0,     0,   364,
    2155       58,   364,     0,     0,     0,     0,   227,     0,     0,   364,
    2156        0,     0,     0,   364,     0,     8,     9,    10,    11,    12,
    2157       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2158       23,    24,    25,  -295,     0,    26,    27,    28,     0,     0,
    2159        0,     0,   213,     0,    31,     0,     0,    79,     0,     0,
    2160        0,     0,   233,   357,   237,     0,   239,     0,     0,     0,
    2161        0,     0,     0,   248,     0,     0,     0,     0,     0,     0,
    2162        0,     0,    34,     0,     0,    88,     0,    37,   349,   337,
    2163      338,    40,     0,  -295,     0,     0,     0,     0,    41,    42,
    2164        0,     0,     0,     0,   213,     0,   237,   239,   248,    43,
    2165        0,     0,    81,    58,     0,   364,     0,     0,     0,    81,
    2166        0,     0,     0,     0,   635,     0,   339,     0,     0,   128,
    2167      128,   128,     0,    46,    47,     0,     0,    58,     0,     0,
    2168        0,     0,   284,   285,    58,   286,     0,   213,   932,     0,
    2169      933,     0,     0,     0,     0,     0,     0,   936,   937,     0,
    2170        0,     0,   942,     0,     0,     0,     0,     0,     0,     0,
    2171      364,   287,    81,   167,   947,     0,     0,   288,     0,   951,
    2172        0,   289,     0,     0,   290,   291,   292,   293,    41,    42,
    2173      220,   294,   295,     0,     0,     0,     0,    58,     0,    43,
    2174        0,     0,     0,   128,     0,   128,     0,     0,   213,   987,
    2175      237,   239,   248,     0,   296,     0,   380,     0,     0,     0,
    2176        0,     0,   792,    46,    47,   298,   299,   300,   301,     0,
    2177      277,   364,   364,     0,   364,   364,     0,     0,   167,     0,
    2178        0,     0,   274,     0,     0,     0,   213,     0,     0,     0,
    2179        0,   213,     0,     0,    88,     0,     0,     0,   508,     0,
    2180      510,   513,     0,     0,     0,     0,   498,     0,   516,   517,
    2181        0,   167,     0,     0,     0,     0,     0,     0,     0,     0,
    2182        0,   370,   510,   510,     0,   376,   128,     0,     0,   364,
    2183      364,     0,     0,     0,   128,     0,   128,   128,     0,     0,
    2184        0,   128,     0,   128,   128,     0,     0,     0,     0,     0,
    2185     1033,  1034,  1035,  1036,   213,  1038,     0,     0,     0,     0,
    2186      510,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2187        0,  1082,     0,     0,   167,     0,   213,     0,     0,     0,
    2188        0,   237,   239,     0,     0,  1088,   220,     0,     0,   248,
    2189        0,     0,     0,     0,     0,     0,   510,     0,     0,     0,
    2190        0,     0,     0,   364,   167,     0,     0,     0,     0,     0,
    2191        0,     0,     0,   128,     0,     0,     0,     0,     0,     0,
    2192        0,     0,     0,     0,     0,  1108,     0,     0,     0,   376,
    2193        0,     0,   213,     0,     0,     0,   167,     0,     0,     0,
    2194        0,     0,     0,     0,     0,     0,   227,     0,     0,     0,
    2195      213,     0,     0,     0,     0,   213,     0,   213,     0,   525,
    2196        0,     0,     0,     0,     0,     0,     0,     0,    88,     0,
    2197        0,   167,  1141,     0,   213,     0,     0,   213,   213,  1149,
    2198      364,     0,   364,     0,  1153,   213,     0,     0,     0,  1157,
    2199        0,  1158,     0,     0,     0,  1160,     0,  1161,  1162,   213,
    2200        0,  1165,     0,     0,     0,     0,   213,     0,     0,   598,
    2201     1177,     0,     0,     0,   622,   364,     0,     0,     0,     0,
    2202        0,     0,     0,   364,   364,   364,     0,     0,  1192,  1193,
    2203        0,     0,     0,     0,   364,   364,     0,     0,     0,     0,
    2204        0,     0,     0,     0,     0,     0,     0,     0,    88,     0,
    2205        0,     0,     0,     0,     0,  1223,     0,     0,  1225,     0,
    2206        0,     0,     0,     0,   510,   510,   510,   510,   510,   510,
    2207      510,   510,   510,   510,   510,   510,   510,   510,   510,   510,
    2208      510,   510,     0,     0,     0,     0,     0,     0,     0,   364,
    2209      167,   167,     0,     0,     0,     0,     0,   370,     0,     0,
    2210        0,  1239,     0,     0,     0,     0,     0,  1243,  1244,     0,
    2211        0,     0,     0,     0,     0,     0,     0,     0,   525,  1255,
    2212      213,     0,     0,     0,     0,     0,     0,     0,     0,  1262,
    2213        0,     0,  1266,     0,  1267,     0,     0,  1269,     0,     0,
    2214        0,     0,     0,     0,     0,     0,   717,     0,   213,     0,
    2215     1277,     0,     0,   213,     0,     0,     0,     0,   167,   364,
    2216        0,     0,     0,  1284,     0,  1286,  1287,  1288,  1289,     0,
    2217      525,     0,   525,     0,     0,   525,     0,   167,   525,     0,
    2218        0,  1296,     0,  1297,     0,     0,     0,   174,     0,     0,
    2219      370,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2220        0,     0,     0,     0,     0,     0,     0,     0,    88,     0,
    2221        0,   510,     0,     0,     0,    88,  1325,  1326,   128,   128,
    2222        0,     0,     0,     0,     0,   213,     0,     0,     0,     0,
    2223        0,     0,     0,     0,     0,     0,     0,     0,     0,   213,
    2224        0,     0,   167,     0,     0,     0,     0,   128,     0,     0,
    2225      128,   128,     0,   128,   370,   128,   128,     0,   816,   498,
    2226      128,   128,     0,     0,     0,     0,     0,     0,    88,  1361,
    2227     1362,     0,     0,     0,   510,     0,     0,     0,     0,  1372,
    2228        0,     0,     0,     0,   598,     0,     0,     0,     0,   598,
    2229        0,     0,     0,     0,     0,     0,     0,     0,   370,   370,
    2230      370,     0,     0,     0,     0,     0,   510,     0,     0,  1022,
    2231        0,     0,     8,     9,    10,    11,    12,   370,     0,     0,
    2232        0,     0,     0,     0,   213,     0,     0,     0,     0,     0,
    2233     1404,     0,   158,     0,     0,     0,   213,     0,     0,   284,
    2234      285,    31,   286,  1409,     0,  1410,  1411,  1412,     0,   525,
    2235        0,     0,     0,     0,     0,   213,     0,  1416,     0,     0,
    2236        0,     0,     0,     0,     0,     0,  1427,     0,   287,    34,
    2237        0,     0,     0,     0,   288,   370,     0,   941,   289,     0,
    2238      253,   290,   291,   292,   293,    41,    42,     0,   294,   295,
    2239      258,     0,     0,  1450,     0,     0,    43,     0,     0,     0,
    2240        0,   128,   128,     0,     0,     0,     0,     0,     0,     0,
    2241        0,   296,   717,   380,     0,     0,     0,     0,     0,     0,
    2242      345,    47,   298,   299,   300,   301,     0,   510,     0,     0,
    2243        0,     0,     0,     0,     0,     0,     0,     0,  1489,  1490,
    2244        0,     0,     0,     0,     0,     0,   158,     0,     0,     0,
    2245        0,  1495,     0,     0,     0,     0,     0,     0,  1495,     0,
    2246      387,     0,     0,     0,     0,     0,     0,     0,     0,   213,
    2247      370,     0,   510,     0,   622,     0,     0,     0,   370,     0,
    2248        0,     0,     0,   419,     0,     0,     0,     0,     0,     0,
    2249        0,  1529,     0,     0,     0,  1535,     0,   434,     0,     0,
    2250        0,   213,     0,     0,     0,     0,   439,     0,     0,     0,
    2251      510,     0,     0,     0,     0,     0,   447,     0,     0,     0,
    2252        0,     0,     0,   510,  1557,     0,  1558,     0,     0,     0,
    2253        0,     0,     0,     0,     0,     0,     0,   213,     0,     0,
    2254        0,   465,     0,     0,     0,     0,   475,     0,   213,     0,
    2255        0,     0,     0,     0,  1573,  1574,     0,     0,     0,   483,
    2256        0,   128,  1577,  1578,   510,   493,   128,   497,     0,     0,
    2257        0,     0,     0,     0,   717,     0,     0,     0,     0,     0,
    2258        0,     0,     0,     0,   527,     0,     0,     0,     0,   525,
    2259        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2260        0,     0,     0,     0,   284,   285,     0,   286,     0,     0,
    2261        0,     0,     0,   167,     0,     0,     0,     0,     0,     0,
    2262      213,     0,     0,     0,     0,     0,   586,     0,     0,   370,
    2263        0,   591,     0,   287,   213,     0,     0,     0,     0,   288,
    2264        0,   510,     0,   289,     0,     0,   290,   291,   292,   293,
    2265       41,    42,     0,   294,   295,     0,     0,     0,     0,     0,
    2266      636,    43,     0,     0,   637,   638,     0,   640,     0,     0,
    2267        0,     0,   598,     0,   652,   653,   507,   654,   655,     0,
    2268      656,     0,   657,     0,     0,    46,    47,   298,   299,   300,
    2269      301,     0,     0,   370,   370,     0,     0,     0,     0,   586,
    2270        0,     0,     0,     0,   510,   510,     0,   672,     0,     0,
    2271        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2272        0,     0,     0,     0,     0,     0,   213,     0,     0,     0,
    2273      128,     0,   683,     0,     0,     0,     0,     0,     0,     0,
    2274        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2275        0,     0,     0,   525,     0,     0,     0,     0,   709,     0,
    2276        0,     0,     0,     0,   712,     0,     0,  -520,     0,   465,
    2277        1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
    2278       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    2279       21,    22,    23,    24,    25,     0,     0,    26,    27,    28,
    2280       29,     0,     0,    30,     0,   749,    31,    32,     0,     0,
    2281        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2282      768,     0,   717,     0,   213,     0,     0,     0,     0,     0,
    2283        0,    33,     0,     0,    34,     0,    35,     0,    36,    37,
    2284        0,    38,    39,    40,     0,     0,     0,     0,     0,     0,
    2285       41,    42,     0,     0,     0,     0,     0,     0,   795,     0,
    2286        0,    43,   128,     0,   220,     0,     0,   805,     0,   342,
    2287      365,     0,     0,     0,   807,     0,    44,     0,    45,     0,
    2288      815,     0,     0,     0,     0,    46,    47,     0,     0,   829,
    2289        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2290        0,   717,     0,   415,     0,     0,     0,     0,     0,     0,
    2291      415,     0,     0,     0,     0,   510,     0,     0,     0,     0,
    2292        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2293      869,     0,     0,   510,     0,     0,     0,     0,     0,     0,
    2294        0,   284,   285,     0,   286,     0,     0,     0,     0,     0,
    2295        0,     0,     0,   370,   370,     0,     0,     0,     0,     0,
    2296        0,     0,   220,     0,     0,     0,   815,     0,     0,     0,
    2297      287,     0,     0,     0,   911,     0,   288,     0,     0,     0,
    2298      289,     0,   415,   290,   291,   292,   293,    41,    42,     0,
    2299      294,   295,     0,     0,     0,     0,     0,     0,    43,     0,
    2300        0,     0,     0,     0,     0,   253,   510,   510,     0,     0,
    2301        0,     0,     0,   296,     0,   948,   949,     0,     0,     0,
    2302        0,     0,    46,    47,   298,   299,   300,   301,     0,   966,
    2303        0,     0,     0,     0,     0,     0,   415,     0,     0,     0,
    2304        0,     0,     0,     0,   415,   582,     0,   415,   585,     0,
    2305      988,     0,   989,     0,     0,     0,   993,     0,   365,     0,
    2306        0,     0,   614,     0,     0,     0,     0,     0,     0,     0,
    2307        0,     0,     0,     0,     0,     0,     0,     0,   370,     0,
    2308      213,   632,     0,     0,   342,     8,     9,    10,    11,    12,
    2309       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2310       23,    24,    25,  -295,     0,    26,    27,    28,     0,     0,
    2311        0,   415,     0,     0,    31,   415,     0,     0,     0,     0,
    2312        0,  1027,     0,     0,     0,     0,     0,     0,  1028,     0,
    2313        0,     0,     0,     0,     0,     0,   525,     0,   525,     0,
    2314        0,  1030,    34,  1031,     0,     0,   365,    37,     0,   337,
    2315      338,    40,     0,  -295,     0,     0,     0,  1043,    41,    42,
    2316        0,     0,     0,     0,  1047,     0,     0,     0,     0,    43,
    2317        0,     0,     0,   525,   322,   525,  1085,     0,     0,  1086,
    2318        0,     0,     0,     0,   347,     0,   339,     0,     0,     0,
    2319        0,     0,   415,    46,    47,   365,   383,   383,     0,     0,
    2320        0,     0,     0,   167,   207,     2,   208,     4,     5,     6,
    2321        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    2322       17,    18,    19,    20,    21,    22,    23,    24,    25,     0,
    2323        0,    26,    27,    28,   415,     0,     0,     0,   342,   365,
    2324       31,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2325        0,     0,     0,     0,     0,     0,     0,     0,   591,     0,
    2326        0,     0,     0,     0,     0,     0,     0,   322,    34,     0,
    2327       35,     0,    36,     0,     0,   209,    39,     0,     0,     0,
    2328        0,     0,     0,   415,   415,     0,     0,     0,     0,     0,
    2329        0,   479,     0,     0,  1159,    43,     0,     0,     0,     0,
    2330        0,     0,   809,   365,     0,     0,     0,     0,     0,     0,
    2331        0,     0,   210,   614,     0,   614,   614,     0,     0,    46,
    2332       47,     0,   614,     0,     0,     0,     0,     0,     0,     0,
    2333        0,     0,   848,   365,     0,     0,     0,     0,   365,     0,
    2334        0,     0,     0,     0,     0,     0,     0,   365,   365,   365,
    2335        0,     0,   527,     0,     0,     0,     0,     0,  1224,     0,
    2336        0,     0,     0,     0,     0,     0,   365,     0,     0,     0,
    2337        0,   415,   891,     0,     0,   415,   894,     0,     0,     0,
    2338        0,     0,   896,     0,     0,     0,     0,     0,     0,     0,
    2339        0,     0,  1236,     0,     0,     0,     0,  1238,     0,     0,
    2340        0,   415,     0,     0,     0,  1242,     0,   383,     0,     0,
    2341        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2342        0,     0,     0,     0,   365,   614,     0,     0,     0,     0,
    2343        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2344        0,  1271,     0,     0,     0,     0,     0,     0,     0,     0,
    2345        0,     0,     0,  1279,     0,     0,  1280,     0,  1281,     0,
    2346      342,   365,     0,     0,     0,   415,   415,     0,     0,     0,
    2347        0,     0,  1290,  1291,     0,     0,     0,     0,     0,     0,
    2348        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2349        0,     0,     0,     0,  1304,     0,     0,     0,     0,     0,
    2350        0,   711,   284,   285,     0,   286,     0,     0,     0,     0,
    2351        0,   415,     0,     0,     0,     0,     0,     0,     0,   365,
    2352        0,     0,     0,     0,     0,     0,   809,   365,     0,     0,
    2353      614,   287,   614,     0,     0,     0,     0,   288,     0,     0,
    2354      745,   289,   614,  1345,   290,   291,   292,   293,    41,    42,
    2355        0,   294,   295,   762,     0,     0,     0,     0,   745,    43,
    2356        0,   745,     0,     0,     0,     0,     0,     0,     0,     0,
    2357        0,     0,   772,   773,   296,     0,   380,     0,     0,     0,
    2358        0,   761,     0,    46,    47,   298,   299,   300,   301,     0,
    2359        0,     0,     0,     0,     0,   794,     0,     0,     0,     0,
    2360        0,     0,     0,     0,     0,   803,     0,     0,     0,     0,
    2361        0,     0,   347,     0,     0,   809,     0,   762,     0,  1396,
    2362        0,  1397,   342,   365,   415,     0,   415,     0,     0,     0,
    2363      415,     0,     0,     0,     0,  1407,     0,  1408,     0,     0,
    2364        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2365        0,   614,   614,     0,     0,  1415,     0,     0,     0,     0,
    2366        0,     0,     0,     0,     0,     0,   868,     0,     0,     0,
    2367        0,  1433,  1435,     0,     0,   383,     0,     0,   365,     0,
    2368        0,     0,  1440,     0,     0,  1242,     0,     0,   415,     8,
    2369        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    2370       19,    20,    21,    22,    23,    24,    25,  -295,  1464,     0,
    2371      415,  1156,     0,     0,     0,     0,     0,  1471,    31,     0,
    2372     1473,   365,  1475,  1477,  1479,     0,     0,   415,  1168,     0,
    2373      614,   614,  1173,     0,     0,     0,     0,     0,     0,     0,
    2374        0,     0,   365,   365,     0,     0,    34,     0,     0,     0,
    2375        0,     0,     0,     0,     0,     0,     0,  -295,     0,     0,
    2376        0,     0,     0,     0,  1510,     0,  1512,     0,  1242,     0,
    2377        0,     0,     0,     0,     0,   762,     0,   972,     0,     0,
    2378        0,     0,     0,     0,  1524,     0,     0,   983,     0,     0,
    2379        0,     0,     0,     0,   992,     0,     0,     0,     0,     0,
    2380        0,     0,     0,     0,     0,   415,     0,   415,     0,     0,
    2381        0,     0,   415,     0,     0,     0,     0,     0,     0,     0,
    2382        0,   614,     0,     0,     0,     0,     0,     0,     0,  1175,
    2383        0,     0,     8,     9,    10,    11,    12,  1010,  1011,     0,
    2384        0,   347,     0,     0,     0,     0,   809,   415,  1258,     0,
    2385        0,     0,     0,     0,     0,   347,     0,     0,     0,   284,
    2386      285,    31,   286,     0,     0,     0,     0,     0,     0,     0,
    2387        0,   365,     0,     0,     0,     0,     0,     0,     0,     0,
    2388        0,     0,     0,     0,     0,     0,     0,     0,   287,    34,
    2389        0,     0,     0,     0,   288,  1041,     0,     0,   289,   383,
    2390        0,   290,   291,   292,   293,    41,    42,     0,   294,   295,
    2391        0,     0,     0,     0,     0,     0,    43,     0,     0,     0,
    2392        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2393        0,   296,   342,   380,     0,     0,     0,   347,     0,     0,
    2394     1176,    47,   298,   299,   300,   301,     0,     0,     0,     0,
    2395      365,     2,   208,     4,     5,     6,     7,     8,     9,    10,
    2396       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    2397       21,    22,    23,    24,    25,     0,   322,    26,    27,    28,
    2398        0,     0,     0,     0,   284,   285,    31,   286,     0,     0,
    2399        0,     0,  1132,  1133,     0,     0,     0,     0,     0,     0,
    2400        0,     0,   365,   365,     0,     0,   383,     0,     0,     0,
    2401        0,     0,   983,   287,    34,  1147,    35,   745,    36,   288,
    2402        0,    38,    39,   289,     0,     0,   290,   291,   292,   293,
    2403       41,    42,     0,   294,   295,     0,     0,     0,  1163,     0,
    2404        0,    43,     0,     0,     0,     0,     0,     0,     0,  1178,
    2405        0,   284,   285,     0,   286,     0,   296,     0,   344,     0,
    2406        0,     0,     0,   761,     0,   345,    47,   298,   299,   300,
    2407      301,   383,     0,  1196,     0,     0,     0,     0,     0,     0,
    2408      287,     0,     0,     0,     0,     0,   288,     0,   983,   983,
    2409      289,     0,     0,   290,   291,   292,   293,    41,    42,     0,
    2410      294,   295,     0,     0,     0,     0,     0,     0,    43,  1228,
    2411        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2412        0,     0,     0,   296,     0,   380,     0,   365,   980,     0,
    2413        0,     0,    46,    47,   298,   299,   300,   301,     0,     0,
    2414        0,     1,     2,     3,     4,     5,     6,     7,     8,     9,
    2415       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
    2416       20,    21,    22,    23,    24,    25,   983,     0,    26,    27,
    2417       28,    29,     0,     0,    30,     0,     0,    31,    32,     0,
    2418        0,     0,     0,     0,     0,   868,     0,     0,     0,     0,
    2419        0,   284,   285,     0,   286,     0,     0,     0,     0,     0,
    2420     1282,  1283,    33,     0,     0,    34,     0,    35,     0,    36,
    2421       37,     0,    38,    39,    40,     0,     0,   415,     0,     0,
    2422      287,    41,    42,     0,     0,     0,   288,     0,     0,     0,
    2423      289,     0,    43,   290,   291,   292,   293,    41,    42,     0,
    2424      294,   295,   415,   415,     0,     0,     0,    44,    43,    45,
    2425        0,     0,     0,  -524,     0,     0,    46,    47,     0,     0,
    2426        0,     0,     0,   296,     0,   380,     0,   415,     0,     0,
    2427        0,     0,    46,    47,   298,   299,   300,   301,     0,     0,
    2428      983,     0,     1,     2,   208,     4,     5,     6,     7,     8,
    2429        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    2430       19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
    2431       27,    28,    29,     0,     0,    30,   284,   285,    31,  1050,
    2432     1051,     0,  1052,     0,     0,  1053,  1054,  1055,  1056,  1057,
    2433     1058,  1059,  1060,     0,     0,     0,  1061,     0,     0,     0,
    2434     1062,  1063,     0,    33,  1390,   287,    34,   745,    35,     0,
    2435       36,  1064,     0,    38,    39,   289,     0,     0,   290,   291,
    2436      292,   293,    41,    42,     0,   294,   295,     0,     0,     0,
    2437        0,     0,     0,    43,     0,     0,     0,     0,     0,     0,
    2438        0,     0,     0,     0,     0,     0,     0,     0,   296,     0,
    2439     1065,     0,     0,   173,     0,     0,     0,    46,    47,   298,
    2440      299,   300,   301,     0,     0,     0,     0,  1066,     0,     0,
    2441        0,  -130,     0,     0,     0,     0,     0,     0,     0,     0,
    2442        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2443        0,  1449,     0,     0,     0,     0,     0,     0,     1,     2,
    2444      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2445       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2446       23,    24,    25,     0,     0,    26,    27,    28,    29,     0,
    2447        0,    30,   284,   285,    31,   286,     8,     9,    10,    11,
     1795      49,   114,   453,   399,   428,    69,   953,    98,   150,   151,
     1796     152,   770,   971,   400,   115,   972,   973,   407,   261,   401,
     1797     268,   498,   383,   384,   743,   628,   604,   402,   440,   632,
     1798     403,   609,    49,   404,   848,   405,  1148,    69,  1182,    98,
     1799     755,   596,   831,   148,   408,  1078,  1140,   980,   872,    49,
     1800     726,   670,    77,    50,   731,  1077,   162,   823,   410,   798,
     1801     830,   153,   824,   187,   825,   819,   210,   144,   342,    49,
     1802     194,   679,   820,   217,   821,   505,   227,   924,   167,   683,
     1803     822,  1206,   220,   399,    77,    50,  1192,   928,    31,  1396,
     1804     861,   861,   861,   400,   674,   676,   177,   407,   154,   401,
     1805    1180,  1181,    63,  1460,   155,   425,   114,   402,  1198,   861,
     1806     403,  1215,  1216,   404,   114,   405,    31,   267,   272,   834,
     1807    1210,   863,   864,   714,   408,   841,    31,   281,   566,  -234,
     1808    -234,  1261,   475,   477,    63,   447,    31,  1188,   409,   882,
     1809     203,  1207,    31,   167,  1316,  1208,   177,   307,   148,   177,
     1810     471,   150,   151,   152,   460,   162,   114,   345,   253,  1262,
     1811     411,   210,   730,   567,  1189,   721,  1211,   861,   373,   577,
     1812     971,   123,    31,   972,   973,   578,   327,  1460,   715,  1417,
     1813    1418,   745,   292,   476,   819,   282,   187,   187,   411,  1258,
     1814     204,   820,  1479,   821,   162,   177,   419,   936,   411,   724,
     1815    -234,   142,   267,   527,   153,  1209,   481,   918,   411,   111,
     1816      49,   956,   832,  1317,   601,  1245,   527,   162,   668,  1249,
     1817      41,    42,   210,   111,  1197,   140,   141,   169,   527,   443,
     1818     145,   150,   151,   152,    41,    42,   665,   527,   954,   436,
     1819     307,   154,   839,  1125,   601,  1182,   802,   155,   762,  1419,
     1820     808,   170,    49,   588,   242,   245,  1085,    69,   177,    98,
     1821     272,   861,   868,   666,  1399,   272,   267,   267,  1024,   327,
     1822     117,  1506,   114,   823,   162,   862,   862,   862,   824,  1464,
     1823     825,   819,  1150,   342,   609,   999,  1023,   463,   820,  1088,
     1824     821,  1002,   857,  1490,   862,   307,  1011,   735,  1182,   657,
     1825     476,   436,  1092,   124,    77,    50,  1535,   307,  1537,    77,
     1826     665,   471,   177,   835,  1341,   903,   596,   838,   160,   177,
     1827    1189,   596,   568,   571,  1548,  1417,  1418,   672,   148,  1212,
     1828    1101,   471,   377,   677,   834,   373,   167,   666,   855,   471,
     1829    1519,   114,   858,   143,  1559,   345,  1524,  1124,   378,   602,
     1830     620,  1563,   862,    31,    63,   556,   557,   510,   111,   472,
     1831    1180,  1181,  1198,  1549,   625,   527,   147,  1544,   625,    41,
     1832      42,   114,  1551,   111,   598,   259,   156,  1464,   831,   547,
     1833     548,   178,  1464,   160,    41,    42,   172,   177,  1078,   714,
     1834    1564,   558,   559,   736,   823,  1428,   267,   768,  1077,   824,
     1835     737,   825,  1464,  1126,   177,   684,   187,  -122,   177,  1464,
     1836    1127,   578,  1346,   373,  1403,   457,   323,   547,   182,  -122,
     1837    -122,   848,  1182,   202,   267,   339,   307,   307,  -122,   387,
     1838     267,   262,   390,   625,   263,  -122,   392,   342,     8,     9,
     1839      10,    11,    12,  -290,   715,   388,   862,   111,   391,    70,
     1840    1449,  1450,   393,   547,   114,   327,   327,   549,    41,    42,
     1841     893,   394,  1339,   550,   551,    56,   116,    31,  1004,  1340,
     1842      77,   177,   267,   808,   498,   430,   919,   395,  1379,   434,
     1843     267,    70,   625,   921,    49,  1455,  1348,   373,   720,    69,
     1844      77,    98,   920,  1136,   114,    34,   919,    56,    77,   922,
     1845    1146,   873,   248,   921,  1112,  1022,   307,   251,   114,   323,
     1846     609,   307,  1089,   307,   307,   213,  1247,  -520,   915,  1090,
     1847     472,   753,  1198,   327,   851,   114,   345,   886,   852,  1198,
     1848     957,   211,  1168,  1170,   221,   253,    77,    50,  1257,  1195,
     1849     472,   434,   327,   439,   488,   917,   264,  1024,   472,   330,
     1850     714,   645,  1195,  1330,   111,  1196,   140,   239,   884,  1027,
     1851     331,   287,   808,   -10,   521,    41,    42,  1332,  1322,  1331,
     1852     571,   571,    41,    42,  1377,   471,   160,  -443,   307,  1290,
     1853    1291,   853,  1198,  1333,   712,   854,    63,   750,   853,   625,
     1854     345,   240,  1108,  -469,   620,   810,   241,   483,   514,  -444,
     1855     602,   933,   602,  1380,   500,   715,   570,   327,   411,   277,
     1856     587,   874,  1136,   279,   593,    45,    46,   918,   280,  1022,
     1857     625,   772,   773,   774,  -469,   625,  -469,   620,   177,   332,
     1858    -469,   625,   333,   626,   625,   625,   625,   630,  1496,  -105,
     1859     339,   371,   875,  -105,   643,  1496,   111,   334,   876,   849,
     1860     705,  1427,  1109,   625,   598,   267,   706,    41,    42,   342,
     1861     177,   722,   725,   111,   729,   140,   141,   723,   493,  1179,
     1862     494,   442,   178,  1035,    41,    42,   177,   335,   215,     2,
     1863     207,     4,     5,     6,     7,   114,   732,   441,   912,   629,
     1864     372,   177,   733,   633,  1082,   323,   323,   579,  1545,   411,
     1865     727,    70,  1365,   596,   376,   728,  1366,   107,   107,   749,
     1866    1120,   625,   938,   620,   389,   750,   897,    56,   385,   720,
     1867     720,   397,   750,   688,  1042,   519,   899,   399,   409,   988,
     1868     215,   582,   750,   411,    77,   989,   117,   400,  1498,   107,
     1869    1499,   426,   407,   401,    35,   427,    36,   114,   345,  1001,
     1870    1243,   402,   753,   753,   403,   706,   578,   404,   432,   405,
     1871      77,   488,  1373,   323,  -122,   488,  -122,   450,   750,   408,
     1872    -122,  -367,   177,   215,  -396,   521,   107,   521,   253,   329,
     1873     521,  1374,   323,   521,   472,  -122,  -122,   750,   971,   504,
     1874    1444,   972,   973,   808,   339,  1546,  1390,   571,   714,   213,
     1875    1376,   779,   780,   781,   782,   625,   750,   625,  1457,  1007,
     1876     472,   461,   625,   345,   869,   752,   602,   411,   810,  1172,
     1877     342,  1381,   484,  1445,    45,    46,   230,   750,   602,  1442,
     1878     231,   979,  1465,   235,   215,   237,   462,    37,   750,   175,
     1879     176,    40,   246,   111,   292,   140,   141,   323,    41,    42,
     1880     712,   552,   553,   715,    41,    42,   673,   675,   806,   111,
     1881     508,   140,   141,   923,   130,   925,   131,   132,   133,   457,
     1882      41,    42,   215,   513,   372,    41,    42,   215,   937,   307,
     1883     601,  1517,  1457,   527,    69,   244,  1512,    45,    46,   847,
     1884     525,   887,  1513,   411,   593,    37,  1193,   175,   176,    40,
     1885     856,   625,   253,   329,   411,   164,    41,    42,   114,   345,
     1886     912,   890,   912,   411,   562,    37,   957,   175,   176,    40,
     1887     957,   957,   213,   665,   114,   563,    41,    42,   915,  1368,
     1888     565,    77,   715,    70,   554,   555,   519,   938,   938,   564,
     1889     177,   519,   720,   568,   519,   850,   338,   114,   307,    56,
     1890     666,  1152,   376,   411,   688,   917,  -440,    48,   113,   107,
     1891    1113,   865,   215,   738,   345,   739,   589,  1569,   740,   230,
     1892     164,   746,   586,   578,   753,   658,   881,   327,   419,   661,
     1893     411,    63,   560,   561,    37,   163,   113,   113,    40,    48,
     1894      -3,  1164,   488,   411,   659,    41,    42,   791,   638,   195,
     1895      48,  1167,   218,   601,   660,   228,    48,   345,   481,   329,
     1896     411,   712,   662,    37,    48,   663,   339,    40,  1238,   664,
     1897      48,    43,  1531,    48,    41,    42,    48,   667,   625,   625,
     1898      45,    46,   832,   329,   601,  1169,   849,   601,   258,  1337,
     1899     113,   113,   645,   215,  1309,  1310,  1311,   669,   307,  1047,
     1900     816,   693,   601,  1200,   528,   529,   530,   500,   694,    45,
     1901      46,  1347,  1349,  1350,    48,   696,   435,    48,  1254,   698,
     1902     411,   442,  1136,  1095,    48,  1095,  1003,  -238,   531,   547,
     1903     532,   806,   533,   534,   163,   215,   992,   989,   114,   734,
     1904    1097,   750,   994,   912,   329,   411,   -12,   374,   912,   747,
     1905      77,  1386,  1387,  1437,   989,    48,   751,   938,   230,   759,
     1906     235,  1442,  1443,    48,   811,   267,  1491,  1492,    48,   812,
     1907     510,  1417,  1418,   163,   775,   776,   783,   784,   435,  1397,
     1908     342,   815,   625,  1397,   777,   778,   826,     2,   207,     4,
     1909       5,     6,     7,    48,    48,   -13,   163,   870,   213,   645,
     1910     472,   523,   871,   878,   528,   529,   530,   345,   444,    48,
     1911     898,   900,   213,   164,   901,   908,   955,    48,   905,  -417,
     1912     806,   926,  -524,   941,   950,   948,    48,   339,   531,    48,
     1913     532,   723,   533,  1319,   961,   963,   113,   962,   966,   965,
     1914     967,   107,   968,   688,   996,   984,   997,   998,   230,   272,
     1915     114,   113,    35,  1013,    36,   113,   215,  1014,  1015,    48,
     1916     113,  1016,    97,   220,  1017,   488,  1115,   323,   114,  1018,
     1917    1019,  1030,   307,    48,    48,  -405,  -404,    69,  1044,  1079,
     1918      48,  1081,  1102,  1103,   215,  1480,   625,    48,   911,   215,
     1919     114,  1104,  1105,   750,    97,  1111,  1121,  1122,  1123,  1217,
     1920    1047,  1132,  1141,  1113,  1128,   149,   978,   177,   213,   712,
     1921    1133,    97,  1134,  1135,   374,    -3,     2,   207,     4,     5,
     1922       6,     7,  1138,  1162,    77,   190,   847,  1183,    97,  1185,
     1923    1184,    97,  1186,  1187,  1201,    48,  1202,  1204,   625,   625,
     1924    1205,  1213,  1218,  1225,  1220,   229,  1230,   272,  1440,    -3,
     1925    1557,  1235,   307,  1233,    37,    48,    48,  1200,    40,  1239,
     1926     692,   215,  1244,  1246,   493,    41,    42,     8,     9,    10,
     1927      11,    12,    48,  1251,    63,   215,    48,  1248,    70,  1259,
     1928    1252,    35,  1263,    36,  1266,   114,  1268,   644,   712,  1270,
     1929    1271,   719,   374,  1272,    56,   399,    31,  1273,  1113,  1274,
     1930      45,    46,  1276,    48,    77,   400,  1283,   688,  1292,   407,
     1931      97,   401,   523,    48,   523,  1293,  1296,   523,  1300,   402,
     1932     523,  1303,   403,    97,    34,   404,  1321,   405,  1328,  1304,
     1933    1305,    48,  1307,   665,  1315,  1334,   408,    48,  1336,    48,
     1934    1338,  1066,  1344,  1342,   216,   267,  1345,  1351,   398,   190,
     1935    1352,   806,  1353,  1355,   472,  1361,  1530,  1362,  1363,  1364,
     1936     666,   243,  1114,   625,  1371,  1372,   570,  1375,   411,  1382,
     1937    1383,   215,    97,  1311,   113,    45,    46,  1391,  1392,    48,
     1938    1393,  1403,  1400,   177,    97,  1411,  1412,    48,   114,  -406,
     1939    1430,    48,  1415,  1426,  1432,    48,   216,  -291,   113,  1434,
     1940     113,  1113,  1435,  1441,     8,     9,    10,    11,    12,   442,
     1941    1451,  1446,   114,  1436,    97,  1452,  1453,  1200,  1454,   114,
     1942     644,   114,  1456,   114,  1200,  1366,  1470,  1461,   479,  1466,
     1943    1472,  1474,  1476,    31,  1468,   113,  1478,   339,   644,   216,
     1944     113,   644,  1483,   150,   151,   152,  1484,    70,  1485,  1486,
     1945    1497,  1507,  1509,  1529,  1523,  1511,  1515,  1516,   114,  1115,
     1946     114,    34,  1538,    56,    77,  1539,  1543,  1550,  1552,  1554,
     1947    1560,    77,   114,  1567,  1568,  1219,   785,  1200,  1529,  1529,
     1948     786,   788,   787,  1320,  1518,  1429,   162,  1570,   307,   113,
     1949      97,   692,   789,  1385,  1250,  1401,    48,  1500,  1096,  1224,
     1950     216,   906,   907,  1529,  1232,   214,   929,    48,  1100,    48,
     1951     373,   603,  1137,  1203,   472,   233,  1043,   327,   877,  1110,
     1952    1329,   472,   804,   943,    77,   717,   794,   951,    48,   795,
     1953      37,   796,   184,   185,    40,     0,   107,     0,   216,     0,
     1954       0,    41,    42,   216,    48,     0,     0,     0,     0,     0,
     1955     113,     0,     0,     0,  1115,     0,     0,   214,     0,    48,
     1956       0,   113,    48,   113,     0,     0,     0,   910,   190,   411,
     1957       0,     0,   215,     0,   472,   911,    45,    46,     0,     0,
     1958       0,  1298,  1299,     0,  1301,    66,   118,     0,     0,     0,
     1959       0,  1306,     0,  1308,     0,    48,     0,     0,   213,   113,
     1960     214,   113,     0,     0,   107,   113,     0,     8,     9,    10,
     1961      11,    12,     0,   113,   211,   221,     0,    66,     0,     0,
     1962       0,    70,  -292,     0,     0,     0,    48,    48,   216,     8,
     1963       9,    10,    11,    12,   161,     0,    31,    56,     0,     0,
     1964      48,    37,     0,   184,   185,    40,    97,     0,     0,     0,
     1965     603,     0,    41,    42,   222,  1114,     0,  1115,    31,     0,
     1966       0,   214,     0,     0,    34,     0,     0,     0,  1439,    37,
     1967       0,   184,   185,    40,     0,    75,     0,     0,   186,     0,
     1968      41,    42,     0,     0,  1066,     0,    34,    45,    46,     0,
     1969    1503,   260,  1503,     0,     0,     0,   442,     0,     0,   214,
     1970       0,    70,   174,     0,   214,   107,   600,    75,   601,   216,
     1971       0,     0,   441,     0,     0,    45,    46,    56,     0,   499,
     1972       0,     0,     0,    48,     0,     0,     0,  1503,     0,  1503,
     1973     692,     0,     0,   328,     0,    48,    37,     0,   184,   185,
     1974      40,   260,   350,     0,   223,   254,     0,    41,    42,     0,
     1975    1114,   216,     0,     0,     0,  1423,     0,   323,     0,     0,
     1976    -293,   215,   818,     0,   603,     0,     0,     8,     9,    10,
     1977      11,    12,   406,   600,     0,   601,     0,     0,   644,     0,
     1978    1389,     0,    45,    46,     0,   113,     0,   424,     0,   214,
     1979     429,   431,     0,     0,   703,   161,    31,     0,     0,    37,
     1980       0,   184,   185,    40,     0,     0,     0,     0,    48,     0,
     1981      41,    42,   704,     0,     0,     0,   448,    48,     0,    48,
     1982     451,     0,   452,     0,    34,     0,   113,     0,     0,     0,
     1983       0,   459,   353,     0,     0,  1416,   266,    66,  1424,     0,
     1984       0,   417,   473,     0,     0,    45,    46,     0,     0,    48,
     1985     916,     0,   480,  1114,     0,     0,     0,   107,     0,   215,
     1986     431,    70,     0,     0,   437,     0,     0,     0,    70,   113,
     1987     214,     0,   216,     0,   445,     0,     0,    56,     0,   107,
     1988       0,   818,   603,  1463,    56,   644,     0,   214,  1467,     0,
     1989       0,     0,     0,   113,   692,     0,   644,   107,   113,     0,
     1990     216,     0,     0,     0,     0,   216,   449,     0,     0,     0,
     1991       0,     0,   214,     0,     0,     0,     0,     0,  1489,     0,
     1992       0,    70,     0,     0,     0,     0,   260,    75,     0,     0,
     1993     594,     0,    75,     0,     0,     0,   622,    56,     0,     0,
     1994       0,     0,   520,     0,     0,     0,     0,     0,   113,   627,
     1995       0,     0,     0,   627,     0,     0,   260,     0,     0,   107,
     1996       0,   125,   128,   129,     0,     0,     0,     0,     0,    37,
     1997       0,   184,   185,    40,     0,     0,     0,   216,   818,     0,
     1998      41,    42,     0,     0,     0,     0,   113,     0,     0,     0,
     1999     603,   216,   107,     0,     0,     0,     0,     0,     0,     0,
     2000      48,   703,     0,   473,  1558,    48,   910,    78,   411,     0,
     2001    1558,     0,     0,     0,     0,    45,    46,     0,   350,   704,
     2002       0,  1558,    48,   473,     0,  1558,   223,     0,     0,     0,
     2003       0,   473,     0,   214,   255,     0,   256,     0,     0,    78,
     2004       0,     8,     9,    10,    11,    12,     0,     0,     0,   699,
     2005       0,     0,   431,     0,     0,     0,     0,     0,     0,     0,
     2006       0,   214,     0,     0,     0,     0,   214,   713,     0,    66,
     2007      31,     0,  1091,     0,   916,     0,   224,   431,     0,     0,
     2008       0,   431,     0,     0,     0,     0,     0,   216,     0,     0,
     2009     681,     0,     0,    75,     0,   107,     0,    80,    34,     0,
     2010       0,     0,   113,    37,   603,   184,   185,    40,   353,     0,
     2011     260,   350,     0,    75,    41,    42,   707,   396,     0,   107,
     2012       0,    75,     0,   703,     0,    48,   107,   415,   416,    80,
     2013       0,     0,   420,   703,   422,   423,     0,     0,   214,   353,
     2014     910,   704,   411,     0,     0,     0,     0,   703,     0,    45,
     2015      46,   704,   214,   520,     0,     0,   797,   353,   520,    75,
     2016       0,   520,     0,     0,   355,   704,   225,     0,   113,   113,
     2017     113,     0,   499,     0,   627,   809,     0,     0,     0,   107,
     2018       0,     0,     8,     9,    10,    11,    12,   828,     0,     0,
     2019       0,     0,     0,     0,     0,     8,     9,    10,    11,    12,
     2020       0,   353,     0,     0,     0,   594,     0,   413,     0,     0,
     2021     594,    31,     0,     0,   421,     0,   627,     0,     0,   350,
     2022     350,   350,     0,     0,    31,     0,   644,     0,   535,   536,
     2023     537,   538,   539,   540,   541,   542,   543,   544,   350,    34,
     2024       0,     0,     0,     0,     0,     0,     0,   927,   214,     0,
     2025       0,     0,    34,     0,   356,   916,   699,    37,     0,    78,
     2026     916,    40,   545,     0,    78,   353,     0,   473,    41,    42,
     2027       0,     0,     0,     0,     0,     0,     0,  1504,     0,  1504,
     2028       0,   752,     0,   411,     0,     0,   413,     0,   216,     0,
     2029      45,    46,     0,   473,    43,     0,   350,     0,     0,     0,
     2030       0,    48,    48,    45,    46,   942,     0,     0,   431,   353,
     2031     353,   353,   113,   113,  1504,     0,  1504,   895,     0,     0,
     2032       0,     0,     0,     0,     0,     0,   902,     0,   353,     0,
     2033     904,     0,   260,   713,     0,     0,     0,     0,   974,     0,
     2034     576,   993,     0,     0,     0,     0,   353,     0,   580,    80,
     2035     113,   583,     0,     0,    80,   703,   703,    75,   224,     0,
     2036       0,     0,     0,     0,     8,     9,    10,    11,    12,     0,
     2037       0,     0,     0,   704,   704,     0,     0,     0,   699,     0,
     2038       0,     0,     0,    75,     0,     0,   353,     0,   699,     0,
     2039     350,     0,   627,    31,     0,  1010,     0,   627,   809,     0,
     2040       0,     0,   699,     0,     8,     9,    10,    11,    12,     0,
     2041      48,   113,  1021,   703,   703,   413,     0,     0,  1037,   421,
     2042     113,    34,     0,   353,     0,    78,    37,     0,   184,   185,
     2043      40,   704,   704,    31,     0,    48,    48,    41,    42,     0,
     2044     355,     0,     0,     0,     0,    78,     0,     0,   225,   214,
     2045       0,     0,     0,    78,     0,     0,     0,     0,   112,     0,
     2046      48,    34,   927,  1528,    66,   411,     0,     0,   353,     0,
     2047       0,   355,    45,    46,     0,     0,     0,   216,   353,     0,
     2048     353,     0,     0,     0,     0,   223,   627,     0,   353,   355,
     2049       0,    78,   353,   260,   713,     0,   413,  1093,     0,     0,
     2050       0,     0,     0,   937,     0,   601,     0,   927,     0,   799,
     2051     800,     0,    45,    46,     0,    80,    37,     0,   184,   185,
     2052      40,     0,     0,  1107,     0,     0,     0,    41,    42,     0,
     2053     356,   431,   118,   355,   896,    80,     0,     0,   833,     0,
     2054       0,   836,   837,    80,   840,  1149,   842,   843,     0,   350,
     2055    1087,   844,   845,  1528,    75,   411,     0,     0,     0,     0,
     2056       0,   356,    45,    46,  1326,     0,     0,     0,     0,     0,
     2057       0,     0,     0,     0,     0,   216,     0,     0,     0,   356,
     2058       0,    80,  1327,     0,   353,     0,     0,   576,   576,    57,
     2059      57,     0,   594,     0,     0,     0,  1037,   355,     0,   703,
     2060       0,     0,     0,     0,     0,   429,     0,   703,   703,   703,
     2061     699,   699,     0,   350,   350,     0,     0,   704,     0,     0,
     2062       0,    57,     0,   356,     0,   704,   704,   704,     0,     0,
     2063       0,     0,     0,  1199,     0,     0,     0,     0,   214,   353,
     2064       0,   355,   355,   355,     0,     0,     0,     0,     0,     0,
     2065       0,     0,     0,     0,     0,    57,   995,     0,    57,     0,
     2066     355,     0,     0,     0,     0,     0,  1000,     0,   699,   699,
     2067       0,     0,     0,   703,     0,   888,   927,     0,   355,   891,
     2068    1012,     0,     0,     0,     0,     0,     0,   356,     0,    78,
     2069     479,   704,   976,   977,     0,     0,     0,     0,     0,     0,
     2070     353,   353,     0,   353,   353,     0,  1214,     0,     0,     0,
     2071     465,     0,     0,     0,     0,    78,     0,   627,   355,     0,
     2072       0,     0,     0,    75,     0,     0,     0,     0,     0,     0,
     2073       0,   356,   356,   356,     0,     0,   214,     0,     0,   927,
     2074     927,     0,   713,     0,    87,     0,   348,     0,     0,     0,
     2075     356,     0,     0,     0,     0,   355,     0,     0,   353,   353,
     2076       0,     0,     0,     0,     0,     0,     0,     0,   356,     8,
     2077       9,    10,    11,    12,     0,     0,    87,     0,     0,    80,
     2078       0,     0,     0,     0,     0,  1297,     0,     0,     0,     0,
     2079       0,     0,     0,     0,     0,     0,     0,     0,    31,     0,
     2080     355,     0,     0,   260,     0,    80,     0,    66,   356,     0,
     2081     355,    57,   355,   226,   576,     0,     0,   224,     0,   699,
     2082     355,   713,     0,     0,   355,   118,    34,     0,     0,     0,
     2083       0,    37,   353,   184,   185,    40,     0,     0,     0,     0,
     2084       0,    57,    41,    42,     0,   356,     0,     0,     0,     0,
     2085       0,     0,     0,     0,   699,     0,  1098,     0,     0,     0,
     2086       0,     0,   699,   699,   699,     0,     0,     0,   186,     0,
     2087       0,     0,     0,   350,   350,   223,     0,    45,    46,     0,
     2088       0,     0,     0,     0,     0,     0,    78,  1199,  1177,  1178,
     2089     356,     0,     0,     0,     0,     0,     0,    75,     0,     0,
     2090     356,   363,   356,     0,     0,     0,     0,   225,     0,   353,
     2091     356,   353,     0,     0,   356,     0,   355,     0,     0,     0,
     2092     118,     0,     0,     0,   112,     0,     0,     0,   699,     0,
     2093       0,     0,     0,   413,     0,     0,     0,     0,     0,     0,
     2094       0,     0,     0,     0,   353,     0,  1227,  1228,     0,     0,
     2095     927,     0,   353,   353,   353,     0,     0,     0,  1384,     0,
     2096       0,     0,     0,   353,   353,     0,     0,     0,   927,     0,
     2097     742,   355,     0,     0,     0,     0,    80,    75,     0,     0,
     2098       0,     0,     0,     0,     0,   763,     0,     0,   742,     0,
     2099     769,   742,     0,     0,     0,     0,    87,     0,   350,     0,
     2100       0,    87,   127,   127,   127,     0,   356,     0,     0,     0,
     2101       0,     0,     0,  1153,     0,     0,     0,     0,   353,     0,
     2102    1229,     0,   348,   118,     0,     0,     0,     0,     0,     0,
     2103    1165,     0,   355,   355,     0,   355,   355,     0,     0,   465,
     2104       0,   927,   927,     0,   168,     0,   173,  1199,     0,   179,
     2105     180,   181,     0,   183,  1199,    78,     0,     0,     0,     0,
     2106       0,   356,     0,     0,     0,     0,     0,     0,   234,     0,
     2107       0,     0,     0,    57,     0,   127,     0,   127,     0,     0,
     2108     249,   250,     0,     0,     0,     0,     0,     0,   353,     0,
     2109     355,   355,     0,     0,     0,   226,     0,     0,     0,     0,
     2110       0,     0,   276,     0,     0,     0,     0,  1199,   413,     0,
     2111       0,   883,     0,   885,  1553,   348,     0,  1501,     0,  1505,
     2112       0,     0,   356,   356,     0,   356,   356,     0,     0,     0,
     2113       0,     0,  1354,     0,     0,     0,     0,    75,     0,     0,
     2114    1356,  1357,  1358,     0,    75,    80,     0,     0,     0,     0,
     2115    1255,     0,  1318,     0,  1534,     0,  1536,     0,   127,     0,
     2116       0,     0,    87,   932,   355,     0,   127,     0,   127,   127,
     2117       0,     0,     0,   127,     0,   127,   127,   363,     0,   348,
     2118     356,   356,    87,     0,     0,     0,     0,     0,     0,     0,
     2119      87,     0,     0,     0,     0,     0,     0,    75,     0,  1565,
     2120       0,  1566,     0,     0,     0,     0,  1404,   224,   363,     8,
     2121       9,    10,    11,    12,  1573,  1574,     0,     0,     0,     0,
     2122       0,     0,     0,   348,   348,   348,   363,     0,    87,    78,
     2123       0,     0,     0,     0,     0,     0,     0,     0,    31,     0,
     2124       0,   355,   348,   355,     0,   127,     0,     0,     8,     9,
     2125      10,    11,    12,     0,   356,     0,     0,     0,     0,     0,
     2126       0,     0,     0,     0,     0,     0,    34,     0,     0,     0,
     2127     363,    37,     0,   184,   185,    40,   355,    31,     0,     0,
     2128       0,     0,    41,    42,   355,   355,   355,     0,     0,     0,
     2129       0,     0,     0,     0,     0,   355,   355,   225,     0,     0,
     2130     348,     0,     0,     0,     0,    34,     0,     0,   266,    78,
     2131      37,     0,     0,     0,    40,     0,     0,    45,    46,    80,
     2132       0,    41,    42,     0,     0,     0,     0,     0,     0,     0,
     2133       0,   356,     0,   356,   363,   591,     0,   599,     0,     0,
     2134       0,     0,     0,     0,     0,     0,     0,   719,   623,   624,
     2135     355,     0,     0,     0,     0,     0,    45,    46,     0,     0,
     2136       0,     0,     0,     0,     0,     0,   356,     0,     0,     0,
     2137       0,     0,     0,     0,   356,   356,   356,     0,   363,   363,
     2138     363,     0,     0,     0,     0,   356,   356,     0,     0,     0,
     2139       0,     0,     0,     0,   348,     0,     0,   363,     0,    80,
     2140       0,     0,   348,     0,     0,  1020,     0,     0,     8,     9,
     2141      10,    11,    12,     0,     0,   363,     0,     0,     0,  1129,
     2142     355,     0,     0,     0,     0,     0,    87,     0,     0,     0,
     2143       0,     0,     0,     0,     0,   283,   284,    31,   285,     0,
     2144     356,     0,     0,  1142,     0,     0,   742,     0,  1142,     0,
     2145       0,     0,    87,     0,     0,   363,     0,     0,     0,     0,
     2146       0,     0,     0,     0,   286,    34,     0,     0,    57,    78,
     2147     287,     0,     0,     0,   288,     0,    78,   289,   290,   291,
     2148     292,    41,    42,     0,   293,   294,     0,     0,     0,     0,
     2149       0,     0,   363,     0,     0,     0,     0,     0,  1142,     0,
     2150       0,     0,     0,     0,     0,     0,     0,   295,     0,   379,
     2151     356,     0,     0,     0,     0,     0,   344,    46,   297,   298,
     2152     299,   300,     0,     0,     0,     0,     0,     0,     0,    78,
     2153       0,     0,     0,     0,     0,     0,    57,   363,     0,     0,
     2154       0,     0,     0,     0,     0,     0,     0,   363,     0,   363,
     2155     127,   127,     0,   348,   226,     0,     0,   363,     0,    80,
     2156       0,   363,   283,   284,     0,   285,    80,     0,     0,     0,
     2157       0,     0,     0,     0,     0,     0,     0,     0,     0,   127,
     2158       0,     0,   127,   127,     0,   127,     0,   127,   127,     0,
     2159       0,   286,   127,   127,     0,     0,     0,   640,     0,   140,
     2160     141,   288,     0,     0,   289,   641,   291,   292,    41,    42,
     2161       0,   293,   294,     0,     0,     0,     0,   348,   348,    80,
     2162       0,     0,     0,    87,     0,     0,     0,     0,     0,     0,
     2163       0,     0,     0,     0,   295,     0,   642,    57,   643,   380,
     2164       0,     0,     0,    45,    46,   297,   298,   299,   300,     0,
     2165       0,     0,     0,   363,     0,     0,     0,     0,     0,   206,
     2166       2,   207,     4,     5,     6,     7,     8,     9,    10,    11,
    24482167      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
    24492168      22,    23,    24,    25,     0,     0,    26,    27,    28,     0,
    2450        0,   287,    34,     0,    35,    31,    36,   288,     0,    38,
    2451       39,   289,     0,  1516,   290,   291,   292,   293,    41,    42,
    2452        0,   294,   295,     0,     0,     0,     0,     0,     0,    43,
    2453        0,     0,     0,    34,     0,     0,     0,     0,   112,     0,
    2454       38,    39,     0,     0,   296,     0,  1065,     0,     0,    41,
    2455       42,     0,     0,    46,    47,   298,   299,   300,   301,     0,
    2456        0,     0,     0,     0,     0,     0,   322,  -130,     1,     2,
    2457      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2458       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2459       23,    24,    25,     0,     0,    26,    27,    28,    29,     0,
    2460        0,    30,   284,   285,    31,   286,     0,     0,     0,     8,
    2461        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    2462       19,    20,    21,    22,    23,    24,    25,  -296,     0,     0,
    2463        0,   287,    34,     0,    35,     0,    36,   288,    31,    38,
    2464       39,   289,     0,     0,   290,   291,   292,   293,    41,    42,
    2465        0,   294,   295,     0,     0,     0,     0,     0,     0,    43,
    2466        0,     0,     0,     0,     0,     0,    34,     0,     0,     0,
    2467        0,     0,     0,     0,   296,     0,    45,  -296,     0,     0,
    2468        0,     0,     0,    46,    47,   298,   299,   300,   301,     2,
    2469      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2470       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2471       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2472        0,     0,   284,   285,    31,   286,     8,     9,    10,    11,
    2473       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
    2474       22,    23,    24,    25,     0,     0,    26,    27,    28,     0,
    2475        0,   287,    34,     0,    35,    31,    36,   288,     0,    38,
    2476       39,   289,     0,     0,   290,   291,   292,   293,    41,    42,
    2477        0,   294,   295,     0,     0,     0,     0,     0,     0,    43,
    2478        0,     0,     0,    34,     0,     0,     0,     0,     0,     0,
    2479       38,    39,     0,     0,   296,     0,   971,     0,     0,     0,
    2480        0,   761,     0,   345,    47,   298,   299,   300,   301,     2,
    2481      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2482       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2483       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2484        0,     0,   284,   285,    31,   286,     8,     9,    10,    11,
    2485       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
    2486       22,    23,    24,    25,     0,     0,    26,    27,    28,     0,
    2487        0,   287,    34,     0,    35,    31,    36,   288,     0,    38,
    2488       39,   289,     0,     0,   290,   291,   292,   293,    41,    42,
    2489        0,   294,   295,     0,     0,     0,     0,     0,     0,    43,
    2490        0,     0,     0,    34,     0,     0,     0,     0,     0,     0,
    2491      209,    39,     0,     0,   296,     0,   971,     0,     0,     0,
    2492        0,   761,     0,    46,    47,   298,   299,   300,   301,     2,
    2493      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2494       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2495       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2496        0,     0,   284,   285,    31,   286,     0,     0,     0,     0,
     2169       0,   930,     0,   931,     0,    31,     0,     0,     0,     0,
     2170     934,   935,     0,     0,     0,   940,     0,     0,   363,     0,
     2171       0,     0,     0,     0,     0,     0,     0,   945,  1142,  1142,
     2172    1142,     0,   949,    34,     0,    35,     0,    36,    37,     0,
     2173     208,    39,    40,   127,   127,     0,     0,     0,     0,    41,
     2174      42,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2175       0,     0,   985,     0,     0,     0,     0,     0,   283,   284,
     2176       0,   285,     0,     0,     0,    43,     0,   209,     0,   363,
     2177     363,     0,   363,   363,    45,    46,   742,     0,     0,     0,
     2178       0,     0,     0,     0,     0,     0,     0,   286,    57,    57,
     2179       0,     0,    87,   287,     0,     0,     0,   288,     0,     0,
     2180     289,   290,   291,   292,    41,    42,     0,   293,   294,     0,
     2181       0,    57,     0,     0,     0,     0,     0,     0,     0,     0,
     2182       0,     0,     0,     0,     0,     0,     0,   363,   363,    57,
     2183     295,     0,   379,     0,     0,   380,     0,     0,     0,    45,
     2184      46,   297,   298,   299,   300,     0,     0,   166,     0,     0,
     2185       0,     0,  1031,  1032,  1033,  1034,     0,  1036,     0,     0,
     2186       0,     0,  1142,  1142,   219,     0,     0,     0,     0,     0,
     2187       0,     0,     0,  1080,     0,     0,     0,   348,   348,     0,
     2188       0,     0,     0,     0,     0,     0,    57,  1086,     0,     0,
     2189       0,    57,   127,     0,     0,     0,     0,   127,     0,     0,
     2190    1481,   363,     0,     0,     0,     0,     0,     0,     0,     0,
     2191       0,     0,   166,     0,     0,     0,   273,     0,     0,     0,
     2192       0,     0,     0,     0,    57,     0,     0,  1106,     0,     0,
    24972193       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2194       0,     0,     0,     0,   226,   166,     0,     0,     0,     0,
     2195       0,     0,     0,     0,     0,   369,     0,     0,     0,   375,
     2196       0,  1532,     0,     0,     0,     0,    87,     0,     0,     0,
     2197    1540,     0,     0,     0,  1139,     0,     0,     0,   363,     0,
     2198     363,  1147,     0,     0,     0,     0,  1151,     0,     0,     0,
     2199       0,  1155,     0,  1156,     0,     0,     0,  1158,     0,  1159,
     2200    1160,     0,   348,  1163,     0,     0,     0,     0,   166,     0,
     2201       0,     0,  1175,   363,     0,     0,     0,     0,     0,     0,
     2202     219,   363,   363,   363,     0,     0,     0,    57,     0,     0,
     2203    1190,  1191,   363,   363,     0,     0,     0,     0,   166,     0,
     2204       0,     0,     0,     0,     0,     0,    87,     0,     0,     0,
     2205       0,    57,     0,     0,     0,     0,     0,  1221,    57,     0,
     2206    1223,   127,     0,   375,     0,     0,     0,     0,     0,     0,
     2207     166,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2208       0,     0,     0,     0,     0,     0,     0,   363,     0,     0,
     2209       0,     0,     0,   524,     0,     0,     0,     0,     0,     0,
     2210       0,     0,     0,  1237,     0,   166,     0,     0,     0,  1241,
     2211    1242,    57,     0,     0,     0,     0,     0,     0,     0,     0,
     2212       0,  1253,     0,     0,     0,     0,     0,     0,     0,     0,
     2213       0,  1260,     0,     0,  1264,     0,  1265,     0,     0,  1267,
     2214       0,     0,     0,   597,     0,     0,     0,     0,   621,     0,
     2215       0,     0,  1275,     0,     0,     0,     0,   363,     0,     0,
     2216       0,     0,     0,     0,     0,  1282,     0,  1284,  1285,  1286,
     2217    1287,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2218       0,     0,     0,  1294,     0,  1295,     0,     0,     0,   173,
     2219       0,     0,     0,   127,     0,   212,     0,     0,     0,     0,
     2220       0,     0,     0,     0,     0,   232,    87,   236,     0,   238,
     2221       0,     0,     0,    87,     0,     0,   247,     0,  1323,  1324,
     2222       0,     0,     0,     0,   166,   166,     0,     0,     0,     0,
     2223       0,   369,     0,     0,     0,     0,     0,     0,     0,     0,
     2224       0,     0,     0,     0,     0,     0,     0,   212,     0,   236,
     2225     238,   247,   524,     0,     0,     0,     0,     0,     0,     0,
     2226       0,     0,     0,     0,     0,     0,    87,     0,     0,     0,
     2227       0,  1359,  1360,     0,     0,     0,     0,     0,     0,     0,
     2228     716,  1370,     0,     0,     0,     0,     0,     0,     0,     0,
     2229     212,     0,   166,     0,     0,     0,     0,     0,     0,     0,
     2230       0,     0,     0,     0,   524,     0,   524,     0,     0,   524,
     2231       0,   166,   524,     0,     0,     0,     0,     0,     0,     0,
     2232       0,     0,     0,     0,   369,     0,     0,     0,     0,     0,
     2233       0,     0,  1402,     0,     0,     0,     0,     0,     0,     0,
     2234       0,     0,     0,     0,     0,  1407,     0,  1408,  1409,  1410,
     2235       0,   212,     0,   236,   238,   247,     0,     0,     0,  1414,
     2236       0,     0,     0,     0,     0,     0,     0,     0,  1425,     0,
     2237       0,     0,     0,     0,     0,     0,   166,     0,     0,     0,
     2238       0,     0,     0,     0,     0,     0,     0,     0,   369,   212,
     2239       0,     0,   814,     0,   212,  1448,     0,     0,     0,     0,
     2240       0,     0,     0,     0,     0,     0,     0,     0,     0,   497,
     2241       0,     0,     0,     0,     0,     0,     0,     0,   597,     0,
     2242       0,     0,     0,   597,     0,     0,     0,     0,     0,     0,
     2243       0,     0,   369,   369,   369,     0,     0,     0,     0,     0,
     2244    1487,  1488,     0,     0,     0,     0,     0,     0,     0,     0,
     2245       0,   369,     0,  1493,     0,     0,     0,   212,     0,     0,
     2246    1493,     0,     0,     0,   157,     0,     0,     0,     0,     0,
     2247       0,     0,     0,     0,     0,     0,     0,     0,     0,   212,
     2248       0,     0,     0,   524,   236,   238,     0,     0,     0,     0,
     2249       0,     0,   247,  1527,     0,     0,     0,  1533,     0,     0,
     2250       0,     0,     0,     0,     0,     0,     0,     0,     0,   369,
     2251    1173,   939,   252,     8,     9,    10,    11,    12,     0,     0,
     2252       0,     0,   257,     0,     0,     0,  1555,     0,  1556,     0,
     2253       0,     0,     0,     0,     0,   212,     0,     0,     0,     0,
     2254     283,   284,    31,   285,     0,     0,   716,     0,     0,     0,
     2255       0,     0,     0,   212,     0,     0,  1571,  1572,   212,     0,
     2256     212,     0,     0,     0,  1575,  1576,     0,     0,     0,   286,
     2257      34,     0,     0,     0,     0,   287,     0,   212,   157,   288,
     2258     212,   212,   289,   290,   291,   292,    41,    42,   212,   293,
     2259     294,     0,   386,     0,     0,     0,     0,     0,     0,     0,
     2260       0,     0,   212,   369,     0,     0,     0,   621,     0,   212,
     2261       0,   369,   295,     0,   379,   418,     0,     0,     0,     0,
     2262       0,  1174,    46,   297,   298,   299,   300,     0,     0,   433,
     2263       0,     0,     0,     0,     0,     0,     0,     0,   438,     0,
     2264       0,     0,     0,     0,     0,     0,     0,     0,   446,     0,
     2265       0,     0,     0,     0,     0,     0,     0,     0,     0,   283,
     2266     284,     0,   285,     0,     0,     0,     0,     0,     0,     0,
     2267       0,     0,     0,   464,     0,     0,     0,     0,   474,     0,
     2268       0,     0,     0,     0,     0,     0,     0,     0,   286,     0,
     2269       0,   482,     0,     0,   287,     0,     0,   492,   288,   496,
     2270       0,   289,   290,   291,   292,    41,    42,   716,   293,   294,
     2271       0,     0,     0,     0,     0,     0,   526,     0,     0,     0,
     2272       0,     0,   524,   212,     0,     0,     0,     0,     0,     0,
     2273       0,   295,     0,   379,     0,     0,     0,     0,     0,   790,
     2274      45,    46,   297,   298,   299,   300,   166,     0,     0,     0,
     2275       0,   212,     0,     0,     0,     0,   212,     0,   585,     0,
     2276       0,     0,   369,   590,     0,     0,   206,     2,   207,     4,
     2277       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
     2278      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2279      25,     0,   635,    26,    27,    28,   636,   637,     0,   639,
     2280       0,     0,    31,     0,     0,   597,   651,   652,     0,   653,
     2281     654,     0,   655,     0,   656,     0,     0,     0,     0,     0,
     2282       0,     0,     0,     0,     0,     0,   369,   369,   212,     0,
     2283      34,   585,    35,     0,    36,     0,     0,   208,    39,   671,
     2284       0,     0,   212,     0,     0,     0,     0,     0,     0,     0,
    24982285       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2499        0,   287,    34,     0,    35,     0,    36,   288,     0,    38,
    2500       39,   289,     0,     0,   290,   291,   292,   293,    41,    42,
    2501        0,   294,   295,     0,     0,     0,     0,     0,     0,    43,
    2502        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2503        0,     0,     0,     0,   296,     0,   344,     0,     0,     0,
    2504        0,     0,     0,   345,    47,   298,   299,   300,   301,     2,
    2505      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2506       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2507       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2508        0,     0,   284,   285,    31,   286,     0,     0,     0,     0,
    2509        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2510        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2511        0,   287,    34,     0,    35,     0,    36,   288,     0,   209,
    2512       39,   289,     0,     0,   290,   291,   292,   293,    41,    42,
    2513        0,   294,   295,     0,     0,     0,     0,     0,     0,    43,
    2514        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2515        0,     0,     0,     0,   296,     0,  1007,     0,     0,     0,
    2516        0,     0,     0,  1008,    47,   298,   299,   300,   301,     2,
    2517      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2518       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2519       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2520        0,     0,   284,   285,    31,   286,     0,     0,     0,     0,
    2521        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2522        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2523        0,   287,    34,     0,    35,     0,    36,   288,     0,    38,
    2524       39,   289,     0,     0,   290,   291,   292,   293,    41,    42,
    2525        0,   294,   295,     0,     0,     0,     0,     0,     0,    43,
    2526        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2527        0,     0,     0,     0,   296,     0,   971,     0,     0,     0,
    2528        0,     0,     0,   345,    47,   298,   299,   300,   301,     2,
    2529      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2530       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2531       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2532        0,     0,   284,   285,    31,   286,     0,     0,     0,     0,
    2533        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2534        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2535        0,   287,    34,     0,    35,     0,    36,   288,     0,   209,
    2536       39,   289,     0,     0,   290,   291,   292,   293,    41,    42,
    2537        0,   294,   295,     0,     0,     0,     0,     0,     0,    43,
    2538        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2539        0,     0,     0,     0,   296,     0,   380,     0,     0,     0,
    2540        0,     0,     0,    46,    47,   298,   299,   300,   301,     1,
     2286     283,   284,   497,   285,   682,     0,     0,     0,     0,     0,
     2287       0,     0,     0,     0,   209,     0,     0,     0,     0,     0,
     2288       0,    45,    46,     0,     0,     0,   524,     0,     0,   286,
     2289     708,     0,     0,     0,     0,   287,   711,     0,     0,   288,
     2290       0,   464,   289,   290,   291,   292,    41,    42,     0,   293,
     2291     294,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2292       0,     0,     0,     0,     0,     0,   212,     0,     0,     0,
     2293       0,     0,   295,     0,   379,     0,     0,   748,   212,   760,
     2294       0,    45,    46,   297,   298,   299,   300,     0,     0,     0,
     2295       0,     0,   767,     0,     0,   716,  -519,   212,     0,     1,
    25412296       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
    25422297      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
    25432298      22,    23,    24,    25,     0,     0,    26,    27,    28,    29,
    2544        0,     0,    30,     0,     0,    31,    32,     0,     0,     0,
     2299     793,     0,    30,     0,     0,    31,    32,   219,     0,   803,
     2300       0,   341,   364,     0,     0,     0,   805,     0,   283,   284,
     2301       0,   285,   813,     0,     0,     0,     0,     0,     0,     0,
     2302      33,   827,     0,    34,     0,    35,     0,    36,    37,     0,
     2303      38,    39,    40,     0,   716,   414,     0,   286,     0,    41,
     2304      42,     0,   414,   287,     0,     0,     0,   288,     0,     0,
     2305     289,   290,   291,   292,    41,    42,     0,   293,   294,     0,
     2306       0,     0,   867,     0,     0,    43,     0,    44,     0,     0,
     2307       0,   212,     0,     0,    45,    46,     0,     0,     0,     0,
     2308     295,     0,   379,     0,     0,   978,   369,   369,     0,    45,
     2309      46,   297,   298,   299,   300,   219,     0,     0,   813,     0,
     2310       0,     0,     0,   212,     0,     0,   909,     0,     0,     0,
     2311       0,     0,     0,     0,   414,     8,     9,    10,    11,    12,
     2312      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     2313      23,    24,    25,  -294,     0,     0,     0,   252,     0,   212,
     2314       0,     0,     0,     0,    31,     0,     0,   946,   947,     0,
     2315     212,     0,     0,     0,     0,     0,   283,   284,     0,   285,
     2316       0,   964,     0,     0,   321,     0,     0,     0,   414,     0,
     2317       0,     0,    34,     0,   346,     0,   414,   581,     0,   414,
     2318     584,     0,   986,  -294,   987,   286,   382,   382,   991,     0,
     2319     364,   287,     0,     0,   613,   288,     0,     0,   289,   290,
     2320     291,   292,    41,    42,     0,   293,   294,     0,     0,     0,
     2321       0,   369,     0,   631,     0,     0,   341,     0,     0,     0,
     2322       0,     0,   212,     0,     0,     0,     0,     0,   295,     0,
     2323     379,     0,     0,     0,     0,     0,   212,    45,    46,   297,
     2324     298,   299,   300,   414,     0,     0,     0,   414,     0,     0,
     2325       0,     0,  1025,     0,     0,     0,     0,   321,     0,  1026,
     2326       0,     0,     0,     0,     0,     0,     0,     0,     0,   524,
     2327       0,   524,  1028,     0,  1029,     0,     0,     0,   364,     0,
     2328       0,   478,     0,     0,     0,     0,     0,     0,  1041,     0,
     2329       0,     0,     0,     0,     0,  1045,     0,     0,     0,     0,
     2330       0,     0,     0,     0,     0,     0,   524,  1083,   524,     0,
     2331    1084,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2332       0,     0,     0,     0,   414,     0,     0,   364,   212,     0,
     2333       0,     0,     0,     0,     0,     0,   166,     2,   207,     4,
     2334       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
     2335      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2336      25,     0,     0,    26,    27,    28,   414,     0,     0,     0,
     2337     341,   364,    31,     0,     0,     0,     0,     0,     0,     0,
     2338       0,     0,     0,     0,     0,     0,     0,     0,     0,   590,
     2339       0,     0,     0,     0,     0,     0,     0,   382,     0,     0,
     2340      34,     0,    35,     0,    36,     0,     0,    38,    39,     0,
     2341       0,     0,     0,     0,     0,   414,   414,     0,     0,     0,
     2342       0,     0,     0,     0,     0,  1157,   212,     0,     0,     0,
     2343       0,     0,     0,     0,   807,   364,     0,     0,     0,     0,
     2344       0,     0,     0,  -402,   678,   613,     0,   613,   613,     0,
     2345       0,    45,    46,     0,   613,     0,     0,     0,     0,     0,
     2346       0,     0,     0,     0,   846,   364,     0,     0,     0,     0,
     2347     364,     0,     0,     0,     0,     0,     0,     0,     0,   364,
     2348     364,   364,     0,   526,     0,     0,     0,     0,     0,  1222,
     2349       0,   710,     0,     0,     0,     0,     0,     0,   364,     0,
     2350       0,     0,     0,   414,   889,     0,     0,   414,   892,     0,
     2351       0,     0,     0,     0,   894,     0,     0,     0,     0,     0,
     2352       0,     0,     0,  1234,     0,     0,     0,     0,  1236,     0,
     2353     744,     0,     0,   414,     0,     0,  1240,     0,     0,     0,
     2354       0,     0,     0,   761,     0,     0,     0,     0,   744,     0,
     2355       0,   744,     0,     0,     0,     0,   364,   613,     0,     0,
     2356       0,     0,     0,   771,     0,     0,     0,     0,     0,     0,
     2357       0,     0,  1269,     0,     0,     0,     0,     0,     0,     0,
     2358       0,     0,     0,     0,  1277,   792,     0,  1278,     0,  1279,
     2359       0,     0,   341,   364,     0,   801,     0,   414,   414,     0,
     2360       0,     0,   346,  1288,  1289,     0,     0,   761,     0,     0,
     2361       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2362       0,     0,     0,     0,     0,  1302,     0,     0,     0,     0,
     2363       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2364       0,     0,   414,     0,     0,     0,     0,     0,     0,     0,
     2365     364,     0,     0,     0,     0,     0,   866,   807,   364,     0,
     2366       0,   613,     0,   613,     0,   382,     0,     0,     0,     0,
     2367       0,     0,     0,   613,  1343,     0,     0,     0,     0,     0,
     2368       0,     0,   212,     0,     0,     0,     0,     0,     0,     0,
     2369       0,     0,     1,     2,   207,     4,     5,     6,     7,     8,
     2370       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2371      19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
     2372      27,    28,    29,     0,     0,    30,     0,     0,    31,     0,
     2373       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2374       0,     0,     0,     0,     0,     0,   807,     0,     0,     0,
     2375    1394,     0,  1395,   341,   364,   414,    34,   414,    35,     0,
     2376      36,   414,     0,    38,    39,   761,  1405,   970,  1406,     0,
     2377       0,     0,     0,     0,     0,     0,     0,   981,     0,     0,
     2378       0,     0,   613,   613,   990,     0,  1413,     0,     0,     0,
     2379       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2380      44,     0,  1431,  1433,     0,     0,     0,    45,    46,   364,
     2381       0,     0,     0,  1438,     0,     0,  1240,     0,     0,   414,
     2382       0,     0,     0,     0,     0,     0,  1008,  1009,     0,     0,
     2383     346,     0,     0,     0,     0,     0,     0,     0,     0,  1462,
     2384       0,   414,  1154,     0,   346,     0,     0,     0,  1469,     0,
     2385       0,  1471,   364,  1473,  1475,  1477,     0,     0,   414,  1166,
     2386       0,   613,   613,  1171,     0,     0,     0,     0,     0,   507,
     2387       0,   509,   512,   364,   364,   283,   284,     0,   285,   515,
     2388     516,     0,     0,     0,  1039,     0,     0,     0,   382,     0,
     2389       0,     0,     0,   509,   509,  1508,     0,  1510,     0,  1240,
     2390       0,     0,     0,     0,   286,     0,     0,     0,     0,     0,
     2391     287,     0,     0,     0,   288,  1522,     0,   289,   290,   291,
     2392     292,    41,    42,     0,   293,   294,   346,     0,     0,     0,
     2393       0,   509,     0,     0,     0,     0,   414,     0,   414,     0,
     2394       0,     0,     0,   414,     0,     0,     0,   295,     0,   379,
     2395       0,     0,   613,     0,     0,     0,   709,    46,   297,   298,
     2396     299,   300,     0,     0,     0,   321,     0,   509,     0,     0,
     2397       0,     0,     0,     0,     0,     0,     0,   807,   414,  1256,
     2398       0,  1130,  1131,     0,     0,     0,     0,     0,     0,     0,
     2399       0,     0,     0,     0,     0,   382,     0,     0,     0,     0,
     2400       0,   981,   364,     0,  1145,     0,   744,     0,     8,     9,
     2401      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
     2402      20,    21,    22,    23,    24,    25,  -294,  1161,    26,    27,
     2403      28,     0,     0,     0,     0,     0,     0,    31,  1176,     0,
     2404     283,   284,     0,   285,     0,     0,     0,     0,     0,     0,
     2405       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2406     382,     0,  1194,   341,     0,    34,     0,     0,     0,   286,
     2407       0,     0,    38,    39,     0,   640,  -294,   981,   981,   288,
     2408       0,   364,   289,   290,   291,   292,    41,    42,     0,   293,
     2409     294,     0,     0,     0,     0,     0,     0,     0,  1226,     0,
     2410       0,     0,     0,     0,     0,     0,     0,   634,     0,   338,
     2411       0,     0,   295,     0,   764,     0,    45,    46,     0,     0,
     2412       0,    45,    46,   297,   298,   299,   300,     0,     0,     0,
     2413       0,     0,     0,   364,   364,   509,   509,   509,   509,   509,
     2414     509,   509,   509,   509,   509,   509,   509,   509,   509,   509,
     2415     509,   509,   509,     0,     0,   981,     0,     0,     0,     0,
     2416       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2417       0,     0,     0,     0,   866,     0,     0,     0,     0,     0,
     2418       0,     0,     0,     0,     0,     0,     0,     0,     0,  1280,
     2419    1281,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2420       0,     0,     0,     0,     0,     0,     0,     0,     1,     2,
     2421     207,     4,     5,     6,     7,     8,     9,    10,    11,    12,
     2422      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     2423      23,    24,    25,     0,     0,    26,    27,    28,    29,     0,
     2424       0,    30,   283,   284,    31,   285,     0,     0,     0,     0,
     2425       0,     0,     0,     0,     0,     0,     0,     0,   364,     0,
     2426       0,     0,     0,     0,     0,     0,     0,     0,     0,   981,
     2427       0,   286,    34,     0,    35,     0,    36,   287,     0,    38,
     2428      39,   288,   509,     0,   289,   290,   291,   292,    41,    42,
     2429       0,   293,   294,     0,     0,     0,     0,     0,     0,     0,
     2430       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2431       0,     0,     0,     0,   295,     0,  1063,     0,     0,     0,
     2432       0,     0,     0,    45,    46,   297,   298,   299,   300,     0,
     2433       0,     0,     0,  1388,     0,     0,   744,  -129,     0,     0,
     2434       0,     0,     0,     0,     0,   509,     0,     0,   414,     8,
     2435       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2436      19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
     2437      27,    28,     0,   414,   414,     0,   509,     0,    31,     0,
     2438       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2439       0,     0,     0,     0,     0,     0,     0,     0,   414,     0,
     2440       0,     0,     0,     0,     0,     0,    34,     0,     0,     0,
     2441       0,     0,     0,   208,    39,     0,     0,     0,     0,     0,
     2442    1447,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2443       0,     0,     1,     2,   207,     4,     5,     6,     7,     8,
     2444       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2445      19,    20,    21,    22,    23,    24,    25,    45,    46,    26,
     2446      27,    28,    29,     0,     0,    30,   283,   284,    31,  1048,
     2447    1049,     0,  1050,     0,     0,  1051,  1052,  1053,  1054,  1055,
     2448    1056,  1057,  1058,     0,     0,     0,  1059,     0,     0,     0,
     2449    1060,  1061,     0,    33,     0,   286,    34,   509,    35,     0,
     2450      36,  1062,  1514,    38,    39,   288,     0,     0,   289,   290,
     2451     291,   292,    41,    42,     0,   293,   294,     8,     9,    10,
     2452      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     2453      21,    22,    23,    24,    25,  -295,     0,     0,   295,     0,
     2454    1063,     0,   509,   172,     0,     0,    31,    45,    46,   297,
     2455     298,   299,   300,     0,     0,   321,     0,  1064,     0,     0,
     2456       0,  -129,     0,     0,     0,     0,     0,     0,     0,     0,
     2457       0,     0,     0,     0,    34,     0,     0,     0,     0,     0,
     2458     509,     0,     0,     0,     0,  -295,     0,     0,     0,     0,
     2459       0,     0,     0,   509,     0,     0,     0,     0,     0,     0,
     2460       0,     0,     1,     2,   207,     4,     5,     6,     7,     8,
     2461       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2462      19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
     2463      27,    28,    29,     0,   509,    30,   283,   284,    31,   285,
     2464       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     2465      18,    19,    20,    21,    22,    23,    24,    25,     0,     0,
     2466      26,    27,    28,     0,     0,   286,    34,     0,    35,    31,
     2467      36,   287,     0,    38,    39,   288,     0,     0,   289,   290,
     2468     291,   292,    41,    42,     0,   293,   294,     0,     0,     0,
     2469       0,     0,     0,     0,     0,     0,     0,    34,     0,     0,
     2470       0,     0,   111,     0,    38,    39,     0,     0,   295,     0,
     2471      44,   509,     0,    41,    42,     0,     0,    45,    46,   297,
     2472     298,   299,   300,     2,   207,     4,     5,     6,     7,     8,
     2473       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2474      19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
     2475      27,    28,     0,     0,     0,     0,   283,   284,    31,   285,
     2476       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2477       0,     0,     0,     0,   509,   509,     0,     0,     0,     0,
     2478       0,     0,     0,     0,     0,   286,    34,     0,    35,     0,
     2479      36,   287,     0,    38,    39,   288,     0,     0,   289,   290,
     2480     291,   292,    41,    42,     0,   293,   294,     0,     0,     0,
     2481       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2482       0,     0,     0,     0,     0,     0,     0,     0,   295,     0,
     2483     343,     0,     0,     0,     0,   760,     0,   344,    46,   297,
     2484     298,   299,   300,     2,   207,     4,     5,     6,     7,     8,
     2485       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2486      19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
     2487      27,    28,     0,     0,     0,     0,   283,   284,    31,   285,
     2488       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     2489      18,    19,    20,    21,    22,    23,    24,    25,     0,     0,
     2490      26,    27,    28,     0,     0,   286,    34,     0,    35,    31,
     2491      36,   287,     0,    38,    39,   288,     0,     0,   289,   290,
     2492     291,   292,    41,    42,     0,   293,   294,     0,     0,     0,
     2493       0,     0,     0,     0,     0,     0,     0,    34,     0,     0,
     2494       0,     0,    37,     0,    38,    39,    40,     0,   295,     0,
     2495     969,     0,     0,    41,    42,   760,     0,   344,    46,   297,
     2496     298,   299,   300,     0,     0,     0,     0,     0,     0,     0,
     2497       0,     0,     0,     0,     0,     0,     0,     0,     0,    43,
     2498       0,   158,     0,     0,     0,   509,     0,     0,    45,    46,
     2499       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2500       0,     0,     0,   509,     0,     0,     0,     0,     0,     0,
     2501       0,     0,     0,     0,     0,     0,     2,   207,     4,     5,
     2502       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     2503      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
     2504       0,     0,    26,    27,    28,     0,     0,     0,     0,   283,
     2505     284,    31,   285,     8,     9,    10,    11,    12,    13,    14,
     2506      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2507      25,     0,     0,    26,    27,    28,   509,   509,   286,    34,
     2508       0,    35,    31,    36,   287,     0,    38,    39,   288,     0,
     2509       0,   289,   290,   291,   292,    41,    42,     0,   293,   294,
     2510       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2511      34,     0,     0,     0,     0,     0,     0,    38,    39,     0,
     2512       0,   295,     0,   969,     0,     0,     0,     0,   760,     0,
     2513      45,    46,   297,   298,   299,   300,     2,   207,     4,     5,
     2514       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     2515      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
     2516       0,     0,    26,    27,    28,     0,     0,     0,     0,   283,
     2517     284,    31,   285,     8,     9,    10,    11,    12,    13,    14,
     2518      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2519      25,     0,     0,    26,    27,    28,     0,     0,   286,    34,
     2520       0,    35,    31,    36,   287,     0,    38,    39,   288,     0,
     2521       0,   289,   290,   291,   292,    41,    42,     0,   293,   294,
     2522       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2523      34,     0,     0,     0,     0,     0,     0,   208,    39,     0,
     2524       0,   295,     0,   343,     0,     0,     0,     0,     0,     0,
     2525     344,    46,   297,   298,   299,   300,     2,   207,     4,     5,
     2526       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     2527      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
     2528       0,     0,    26,    27,    28,     0,     0,     0,     0,   283,
     2529     284,    31,   285,     8,     9,    10,    11,    12,    13,    14,
     2530      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2531      25,     0,     0,     0,     0,     0,     0,     0,   286,    34,
     2532       0,    35,    31,    36,   287,     0,   208,    39,   288,     0,
     2533       0,   289,   290,   291,   292,    41,    42,     0,   293,   294,
     2534       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2535      34,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2536       0,   295,     0,  1005,     0,     0,     0,     0,     0,     0,
     2537    1006,    46,   297,   298,   299,   300,     2,   207,     4,     5,
     2538       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     2539      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
     2540       0,     0,    26,    27,    28,     0,     0,     0,     0,   283,
     2541     284,    31,   285,     0,     0,     0,     0,     0,     0,     0,
     2542       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2543       0,     0,     0,     0,     0,     0,     0,     0,   286,    34,
     2544       0,    35,     0,    36,   287,     0,    38,    39,   288,     0,
     2545       0,   289,   290,   291,   292,    41,    42,     0,   293,   294,
    25452546       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    25462547       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2547       33,     0,     0,    34,     0,    35,     0,    36,    37,     0,
    2548       38,    39,    40,     0,     0,     0,     0,     0,     0,    41,
    2549       42,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2550       43,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2551        0,     0,     0,     0,     0,    44,     0,    45,     0,     0,
    2552        0,     0,     0,     0,    46,    47,   207,     2,   208,     4,
     2548       0,   295,     0,   969,     0,     0,     0,     0,     0,     0,
     2549     344,    46,   297,   298,   299,   300,     2,   207,     4,     5,
     2550       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     2551      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
     2552       0,     0,    26,    27,    28,     0,     0,     0,     0,   283,
     2553     284,    31,   285,     0,     0,     0,     0,     0,     0,     0,
     2554       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2555       0,     0,     0,     0,     0,     0,     0,     0,   286,    34,
     2556       0,    35,     0,    36,   287,     0,   208,    39,   288,     0,
     2557       0,   289,   290,   291,   292,    41,    42,     0,   293,   294,
     2558       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2559       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2560       0,   295,     0,   379,     0,     0,     0,     0,     0,     0,
     2561      45,    46,   297,   298,   299,   300,     1,     2,     3,     4,
    25532562       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    25542563      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2555       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2556        0,     0,    31,     0,     8,     9,    10,    11,    12,    13,
    2557       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2558       24,    25,     0,     0,    26,    27,    28,   486,   487,   488,
    2559       34,     0,    35,    31,    36,    37,     0,   209,    39,    40,
     2564      25,     0,     0,    26,    27,    28,    29,     0,     0,    30,
     2565       0,     0,    31,    32,     0,     0,     0,     0,     0,     0,
     2566       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2567       0,     0,     0,     0,     0,     0,     0,    33,     0,     0,
     2568      34,     0,    35,     0,    36,    37,     0,    38,    39,    40,
    25602569       0,     0,     0,     0,     0,     0,    41,    42,     0,     0,
    2561        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2562        0,    34,     0,     0,     0,     0,     0,     0,    38,    39,
    2563        0,     0,    44,     0,   210,     0,     0,     0,     0,     0,
    2564        0,    46,    47,     1,     2,   208,     4,     5,     6,     7,
    2565        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
    2566       18,    19,    20,    21,    22,    23,    24,    25,  -295,     0,
    2567       26,    27,    28,    29,     0,     0,    30,     0,     0,    31,
    25682570       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    25692571       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2570        0,     0,     0,     0,     0,     0,     0,    34,     0,    35,
    2571        0,    36,     0,     0,    38,    39,     0,     0,  -295,     0,
     2572       0,     0,    43,     0,    44,     0,     0,     0,  -523,     0,
     2573       0,    45,    46,     1,     2,     3,     4,     5,     6,     7,
     2574       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     2575      18,    19,    20,    21,    22,    23,    24,    25,     0,     0,
     2576      26,    27,    28,    29,     0,     0,    30,     0,     0,    31,
     2577      32,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    25722578       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2573        0,     0,     0,     0,    43,     0,     0,     0,     0,     0,
     2579       0,     0,     0,     0,    33,     0,     0,    34,     0,    35,
     2580       0,    36,    37,     0,    38,    39,    40,     0,     0,     0,
     2581       0,     0,     0,    41,    42,     0,     0,     0,     0,     0,
    25742582       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2575        0,    45,     0,     0,     0,     0,     0,     0,    46,    47,
    2576        1,     2,   208,     4,     5,     6,     7,     8,     9,    10,
     2583       0,     0,     0,     0,     0,     0,     0,     0,     0,    43,
     2584       0,    44,     0,     0,     0,     0,     0,     0,    45,    46,
     2585       1,     2,   207,     4,     5,     6,     7,     8,     9,    10,
    25772586      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    2578       21,    22,    23,    24,    25,     0,     0,    26,    27,    28,
     2587      21,    22,    23,    24,    25,  -294,     0,    26,    27,    28,
    25792588      29,     0,     0,    30,     0,     0,    31,     0,     0,     0,
    25802589       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    25812590       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    25822591       0,     0,     0,     0,    34,     0,    35,     0,    36,     0,
    2583        0,    38,    39,     0,     0,     0,     0,     0,     0,     0,
     2592       0,    38,    39,     0,     0,  -294,     2,   207,     4,     5,
     2593       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     2594      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
     2595       0,     0,    26,    27,    28,     0,     0,     0,    44,     0,
     2596       0,    31,     0,     0,     0,    45,    46,     0,     0,     0,
    25842597       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2585        0,    43,     0,     0,     0,     0,     0,     0,     0,     0,
    2586        0,     0,     0,     0,     0,     0,     0,     0,    45,     0,
    2587        0,     0,     0,     0,     0,    46,    47,     2,   208,     4,
     2598       0,     0,     0,     0,     0,     0,     0,     0,     0,    34,
     2599       0,    35,     0,    36,    37,     0,   208,    39,    40,     0,
     2600       0,     0,     0,     0,     0,    41,    42,     0,     0,     0,
     2601       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2602       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2603       0,    43,     0,   209,     0,     0,     0,     0,     0,     0,
     2604      45,    46,     2,   207,     4,     5,     6,     7,     8,     9,
     2605      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
     2606      20,    21,    22,    23,    24,    25,     0,     0,    26,    27,
     2607      28,     0,     0,     0,     0,     0,     0,    31,     0,     0,
     2608       0,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     2609      17,    18,    19,    20,    21,    22,    23,    24,    25,     0,
     2610       0,    26,    27,    28,     0,    34,     0,    35,     0,    36,
     2611      31,     0,    38,    39,     0,     0,     0,     0,     0,     0,
     2612       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2613       0,     0,     0,     0,  1367,     0,     0,     0,    34,     0,
     2614       0,     0,     0,    37,     0,   336,   337,    40,     0,   678,
     2615       0,     0,     0,     0,    41,    42,    45,    46,     2,   207,
     2616       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
     2617      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
     2618      24,    25,   338,     0,    26,    27,    28,     0,     0,    45,
     2619      46,     0,     0,    31,     0,     0,     0,     8,     9,    10,
     2620      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     2621      21,    22,    23,    24,    25,     0,     0,    26,    27,    28,
     2622       0,    34,     0,    35,     0,    36,    31,     0,    38,    39,
     2623       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2624       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2625    1369,     0,     0,     0,    34,     0,     0,     0,     0,   111,
     2626       0,    38,    39,     0,     0,   678,     0,     0,     0,     0,
     2627      41,    42,    45,    46,     2,   207,     4,     5,     6,     7,
     2628       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     2629      18,    19,    20,    21,    22,    23,    24,    25,    44,     0,
     2630      26,    27,    28,     0,     0,    45,    46,     0,     0,    31,
     2631       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2632       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2633       0,     0,     0,     0,     0,     0,     0,    34,     0,    35,
     2634       0,    36,     0,     0,   208,    39,     0,     2,   207,     4,
    25882635       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    25892636      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25902637      25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2591        0,     0,    31,     0,     0,     0,     0,     0,     0,     0,
     2638       0,   271,    31,     0,     0,     0,     0,     0,    45,    46,
    25922639       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    25932640       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2594       34,     0,    35,     0,    36,    37,     0,   209,    39,    40,
    2595        0,     0,     0,     0,     0,     0,    41,    42,     0,     0,
    2596        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
     2641      34,     0,    35,     0,    36,     0,     0,    38,    39,     0,
     2642       2,   207,     4,     5,     6,     7,     8,     9,    10,    11,
     2643      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
     2644      22,    23,    24,    25,     0,     0,    26,    27,    28,     0,
     2645       0,     0,     0,     0,   678,    31,     0,     0,     0,     0,
     2646       0,    45,    46,     0,     0,     0,     0,     0,     0,     0,
    25972647       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2598        0,     0,    44,     0,   210,     0,     0,     0,     0,     0,
    2599        0,    46,    47,     2,   208,     4,     5,     6,     7,     8,
     2648       0,     0,     0,    34,     0,    35,     0,    36,     0,     0,
     2649      38,    39,     0,     2,   207,     4,     5,     6,     7,     8,
     2650       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2651      19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
     2652      27,    28,     0,     0,     0,     0,     0,   592,    31,     0,
     2653       0,     0,     0,     0,    45,    46,     0,     0,     0,     0,
     2654       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2655       0,     0,     0,     0,     0,     0,    34,     0,    35,     0,
     2656      36,     0,     0,   208,    39,     8,     9,    10,    11,    12,
     2657      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     2658      23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
     2659       0,     0,   283,   284,    31,   285,     0,     0,     0,     0,
     2660     209,     0,     0,     0,     0,     0,     0,    45,    46,     0,
     2661       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2662       0,   286,    34,     0,     0,     0,     0,   287,     0,    38,
     2663      39,   288,     0,     0,   289,   290,   291,   292,    41,    42,
     2664       0,   293,   294,     0,     0,     0,     0,     0,     0,     0,
     2665       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2666       0,     0,     0,     0,   295,     0,   517,     0,     0,   172,
     2667       0,     0,     0,    45,    46,   297,   298,   299,   300,     8,
     2668       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2669      19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
     2670      27,    28,     0,     0,     0,     0,   283,   284,    31,   285,
     2671       0,     0,     0,     0,     0,     0,     0,     8,     9,    10,
     2672      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     2673      21,    22,    23,    24,    25,   286,    34,    26,    27,    28,
     2674       0,   640,     0,    38,    39,   288,    31,     0,   289,   290,
     2675     291,   292,    41,    42,     0,   293,   294,     0,     0,     0,
     2676       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2677       0,     0,     0,     0,    34,     0,     0,     0,   295,   -35,
     2678     741,    38,    39,     0,     0,     0,     0,    45,    46,   297,
     2679     298,   299,   300,     8,     9,    10,    11,    12,    13,    14,
     2680      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2681      25,     0,     0,    26,    27,    28,   634,     0,   338,     0,
     2682     283,   284,    31,   285,     0,    45,    46,     0,     0,     0,
     2683       0,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     2684      17,    18,    19,    20,    21,    22,    23,    24,    25,   286,
     2685      34,    26,    27,    28,     0,   287,     0,    38,    39,   288,
     2686      31,     0,   289,   290,   291,   292,    41,    42,     0,   293,
     2687     294,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2688       0,     0,     0,     0,     0,     0,     0,     0,    34,     0,
     2689       0,     0,   295,     0,   296,    38,    39,     0,     0,     0,
     2690       0,    45,    46,   297,   298,   299,   300,     8,     9,    10,
     2691      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     2692      21,    22,    23,    24,    25,     0,     0,    26,    27,    28,
     2693       0,     0,   258,     0,   283,   284,    31,   285,     0,    45,
     2694      46,     0,     0,     0,     0,     8,     9,    10,    11,    12,
     2695      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     2696      23,    24,    25,   286,    34,    26,    27,    28,     0,   287,
     2697       0,    38,    39,   288,    31,     0,   289,   290,   291,   292,
     2698      41,    42,     0,   293,   294,     0,     0,     0,     0,     0,
     2699       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2700       0,     0,    34,     0,     0,     0,   295,     0,   158,    38,
     2701      39,     0,     0,     0,     0,    45,    46,   297,   298,   299,
     2702     300,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     2703      17,    18,    19,    20,    21,    22,    23,    24,    25,     0,
     2704       0,    26,    27,    28,     0,     0,   158,     0,   283,   284,
     2705      31,   285,     0,    45,    46,     0,     0,     0,     0,     8,
     2706       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2707      19,    20,    21,    22,    23,    24,    25,   286,    34,    26,
     2708      27,    28,     0,   287,     0,    38,    39,   288,    31,     0,
     2709     289,   290,   291,   292,    41,    42,     0,   293,   294,     0,
     2710       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2711       0,     0,     0,     0,     0,     0,    34,     0,     0,     0,
     2712     295,     0,   592,   208,    39,     0,     0,     0,     0,    45,
     2713      46,   297,   298,   299,   300,     8,     9,    10,    11,    12,
     2714      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     2715      23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
     2716     271,     0,   283,   284,    31,   285,     0,    45,    46,     0,
     2717       0,     0,     0,     8,     9,    10,    11,    12,    13,    14,
     2718      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2719      25,   286,    34,    26,    27,    28,     0,   287,     0,    38,
     2720      39,   288,    31,     0,   289,   290,   291,   292,    41,    42,
     2721       0,   293,   294,     0,     0,     0,     0,     0,     0,     0,
     2722       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2723      34,     0,     0,     0,   295,     0,   379,    38,    39,     0,
     2724       0,     0,     0,    45,    46,   297,   298,   299,   300,   467,
     2725       2,   207,     4,     5,     6,     7,     8,     9,    10,    11,
     2726      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
     2727      22,    23,    24,    25,   338,     0,    26,    27,    28,     0,
     2728       0,    45,    46,     0,     0,    31,     0,     0,     0,     8,
     2729       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2730      19,    20,    21,    22,    23,    24,    25,  -294,     0,    26,
     2731      27,    28,     0,    34,     0,    35,     0,    36,    31,     0,
     2732      38,    39,     0,     0,     0,     0,     0,     8,     9,    10,
     2733      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     2734      21,    22,    23,    24,    25,  -294,    34,    26,    27,    28,
     2735       0,    37,     0,   336,   337,    40,    31,  -294,     0,     0,
     2736      -3,     0,    41,    42,     0,     8,     9,    10,    11,    12,
     2737      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     2738      23,    24,    25,     0,    34,    26,    27,    28,   634,    37,
     2739     338,   336,   337,    40,    31,  -294,     0,    45,    46,     0,
     2740      41,    42,     0,     8,     9,    10,    11,    12,    13,    14,
     2741      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2742      25,     0,    34,    26,    27,    28,     0,    37,   338,    38,
     2743      39,    40,    31,     0,     0,    45,    46,     0,    41,    42,
     2744       0,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     2745      17,    18,    19,    20,    21,    22,    23,    24,    25,     0,
     2746      34,    26,    27,    28,    43,    37,    44,   208,    39,    40,
     2747      31,     0,     0,    45,    46,     0,    41,    42,     0,     8,
     2748       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2749      19,    20,    21,    22,    23,    24,    25,     0,    34,    26,
     2750      27,    28,    43,    37,   271,   336,   337,    40,    31,   685,
     2751       0,    45,    46,     0,    41,    42,     0,     8,     9,    10,
     2752      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     2753      21,    22,    23,    24,    25,  -294,    34,    26,    27,    28,
     2754     634,     0,   338,    38,    39,     0,    31,     0,     0,    45,
     2755      46,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2756       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2757       0,     0,     0,     0,    34,     0,     0,     0,     0,     0,
     2758     686,    38,    39,     0,   687,  -294,     0,    45,    46,     0,
     2759       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     2760      18,    19,    20,    21,    22,    23,    24,    25,     0,     0,
     2761      26,    27,    28,     0,     0,     0,     0,     0,   338,    31,
     2762     685,     0,     0,     0,     0,    45,    46,     0,     8,     9,
     2763      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
     2764      20,    21,    22,    23,    24,    25,     0,    34,    26,    27,
     2765      28,     0,     0,     0,    38,    39,     0,    31,   685,     8,
     2766       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2767      19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
     2768      27,    28,     0,     0,     0,    34,     0,     0,    31,     0,
     2769       0,   686,    38,    39,     0,  1099,     0,     0,    45,    46,
     2770       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2771       0,     0,     0,     0,     0,     0,    34,     0,     0,     0,
     2772       0,     0,     0,    38,    39,     0,     0,     0,     0,   686,
     2773       0,     0,     0,  1231,     0,     0,    45,    46,     0,     0,
     2774       0,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     2775      17,    18,    19,    20,    21,    22,    23,    24,    25,     0,
     2776     686,    26,    27,    28,     0,     0,     0,    45,    46,     0,
     2777      31,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     2778      17,    18,    19,    20,    21,    22,    23,    24,    25,     0,
     2779       0,    26,    27,    28,     0,     0,     0,     0,    34,     0,
     2780      31,     0,     0,     0,     0,    38,    39,     0,     0,     8,
     2781       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     2782      19,    20,    21,    22,    23,    24,    25,     0,    34,    26,
     2783      27,    28,   485,   486,   487,    38,    39,     0,    31,     0,
     2784       0,     0,   592,     0,     0,     0,     0,     0,     0,    45,
     2785      46,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2786       0,     0,     0,     0,     0,     0,    34,     0,     0,     0,
     2787       0,     0,    44,    38,    39,     0,     0,     0,     0,    45,
     2788      46,     2,   207,     4,     5,     6,     7,     8,     9,    10,
     2789      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     2790      21,    22,    23,    24,    25,     0,     0,    26,    27,    28,
     2791       0,     0,     0,     0,     0,     0,    31,     0,   283,   284,
     2792       0,   285,  1049,     0,  1050,     0,     0,  1051,  1052,  1053,
     2793    1054,  1055,  1056,  1057,  1058,     0,     0,  1547,  1059,     0,
     2794       0,     0,  1060,  1061,    34,    33,    35,   286,    36,     0,
     2795       0,    38,    39,  1062,     0,     0,     0,   288,     0,     0,
     2796     289,   290,   291,   292,    41,    42,     0,   293,   294,     0,
     2797       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2798       0,     0,     0,     0,     0,     0,     0,  -415,     0,     0,
     2799     295,     0,   379,     0,     0,   172,     0,     0,     0,    45,
     2800      46,   297,   298,   299,   300,     0,     0,     0,     0,  1064,
     2801       0,   283,   284,  -129,   285,  1049,     0,  1050,     0,     0,
     2802    1051,  1052,  1053,  1054,  1055,  1056,  1057,  1058,     0,     0,
     2803       0,  1059,     0,     0,     0,  1060,  1061,     0,    33,     0,
     2804     286,     0,     0,     0,     0,     0,  1062,     0,     0,     0,
     2805     288,     0,     0,   289,   290,   291,   292,    41,    42,     0,
     2806     293,   294,     0,     0,     0,     0,     0,     0,     0,     0,
     2807       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2808       0,     0,     0,   295,     0,   379,     0,     0,   172,     0,
     2809       0,     0,    45,    46,   297,   298,   299,   300,     0,     0,
     2810       0,     0,  1064,     0,     0,     0,  -129,     2,   207,     4,
     2811       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
     2812      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     2813      25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
     2814       0,     0,    31,     0,   283,   284,     0,   285,  1049,     0,
     2815    1050,  1417,  1418,  1051,  1052,  1053,  1054,  1055,  1056,  1057,
     2816    1058,     0,     0,  1547,  1059,     0,     0,     0,  1060,  1061,
     2817      34,    33,    35,   286,    36,     0,     0,    38,    39,  1062,
     2818       0,     0,     0,   288,     0,     0,   289,   290,   291,   292,
     2819      41,    42,     0,   293,   294,     0,     0,     0,     0,  1325,
     2820       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2821       0,     0,     0,     0,     0,     0,   295,     0,   379,     0,
     2822       0,   172,     0,     0,     0,    45,    46,   297,   298,   299,
     2823     300,     0,     0,   283,   284,  1064,   285,  1049,     0,  1050,
     2824    1417,  1418,  1051,  1052,  1053,  1054,  1055,  1056,  1057,  1058,
     2825       0,     0,     0,  1059,     0,     0,     0,  1060,  1061,     0,
     2826      33,     0,   286,     0,     0,     0,     0,     0,  1062,     0,
     2827       0,     0,   288,     0,     0,   289,   290,   291,   292,    41,
     2828      42,     0,   293,   294,     0,     0,     0,     0,     0,     0,
     2829       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2830       0,     0,     0,     0,     0,   295,     0,   379,     0,     0,
     2831     172,     0,     0,     0,    45,    46,   297,   298,   299,   300,
     2832       0,     0,   283,   284,  1064,   285,  1049,     0,  1050,     0,
     2833       0,  1051,  1052,  1053,  1054,  1055,  1056,  1057,  1058,     0,
     2834       0,     0,  1059,     0,     0,     0,  1060,  1061,     0,    33,
     2835       0,   286,     0,     0,     0,     0,     0,  1062,     0,     0,
     2836       0,   288,     0,     0,   289,   290,   291,   292,    41,    42,
     2837       0,   293,   294,     0,     0,     0,     0,     0,     0,     0,
     2838     283,   284,     0,   285,     0,     0,     0,     0,     0,     0,
     2839       0,     0,     0,     0,   295,     0,   379,     0,     0,   172,
     2840       0,     0,     0,    45,    46,   297,   298,   299,   300,   286,
     2841       0,     0,     0,  1064,     0,   287,     0,     0,     0,   288,
     2842       0,     0,   289,   290,   291,   292,    41,    42,     0,   293,
     2843     294,     0,     0,     0,     0,     0,     0,     0,   283,   284,
     2844       0,   285,     0,     0,     0,     0,     0,     0,     0,     0,
     2845       0,     0,   295,     0,   379,     0,     0,   283,   284,     0,
     2846     285,   344,    46,   297,   298,   299,   300,   286,     0,     0,
     2847       0,     0,     0,   287,     0,     0,     0,   288,     0,     0,
     2848     289,   290,   291,   292,    41,    42,   286,   293,   294,     0,
     2849       0,     0,   287,     0,     0,     0,   288,     0,     0,   289,
     2850     290,   291,   292,    41,    42,     0,   293,   294,     0,     0,
     2851     506,     0,     0,     0,     0,   283,   284,     0,   285,    45,
     2852      46,   297,   298,   299,   300,     0,     0,     0,     0,   295,
     2853       0,     0,     0,     0,   283,   284,     0,   285,    45,    46,
     2854     297,   298,   299,   300,   286,     0,     0,     0,     0,     0,
     2855     287,     0,     0,     0,   288,     0,     0,   289,   290,   291,
     2856     292,    41,    42,   286,   293,   294,     0,     0,     0,   287,
     2857       0,     0,     0,   288,     0,     0,   289,   290,   291,   292,
     2858      41,    42,     0,   293,   294,     0,     0,   511,     0,     0,
     2859       0,     0,     0,     0,     0,     0,    45,    46,   297,   298,
     2860     299,   300,     0,     0,     0,     0,   514,     0,     0,     0,
     2861       0,     0,     0,     0,     0,    45,    46,   297,   298,   299,
     2862     300,     2,   207,     4,     5,     6,     7,     8,     9,    10,
     2863      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     2864      21,    22,    23,    24,    25,     0,     0,     0,     0,     0,
     2865       0,     0,     0,     0,     0,     0,    31,     0,     0,     0,
     2866       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2867       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     2868       0,     0,     0,     0,    34,     0,    35,     0,    36,    37,
     2869       0,   175,   176,    40,     0,     0,     0,     0,     0,     0,
     2870      41,    42,   206,     2,   207,     4,     5,     6,     7,     8,
    26002871       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    26012872      19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
    … …  
    26042875       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    26052876       0,     0,     0,     0,     0,     0,    34,     0,    35,     0,
    2606       36,     0,     0,    38,    39,     0,     0,     0,     0,     0,
    2607        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2608        0,     0,     0,    43,     0,     0,     0,     0,     0,     0,
    2609        0,     0,     0,     0,     0,     0,     0,     0,     0,  -403,
    2610      679,     0,     0,     0,     0,     0,     0,    46,    47,     2,
    2611      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2612       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2613       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2614        0,     0,     0,     0,    31,     0,     0,     0,     0,     0,
    2615        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2616        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2617        0,     0,    34,     0,    35,     0,    36,     0,     0,    38,
    2618       39,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2619        0,     0,     0,     0,     0,     0,     0,     0,     0,    43,
    2620        0,  1369,     0,     0,     0,     0,     0,     0,     0,     0,
    2621        0,     0,     0,     0,     0,     0,   679,     0,     0,     0,
    2622        0,     0,     0,    46,    47,     2,   208,     4,     5,     6,
    2623        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    2624       17,    18,    19,    20,    21,    22,    23,    24,    25,     0,
    2625        0,    26,    27,    28,     0,     0,     0,     0,     0,     0,
    2626       31,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2627        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2628        0,     0,     0,     0,     0,     0,     0,     0,    34,     0,
    2629       35,     0,    36,     0,     0,    38,    39,     0,     0,     0,
    2630        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2631        0,     0,     0,     0,     0,    43,     0,  1371,     0,     0,
    2632        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2633        0,     0,   679,     0,     0,     0,     0,     0,     0,    46,
    2634       47,     2,   208,     4,     5,     6,     7,     8,     9,    10,
    2635       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    2636       21,    22,    23,    24,    25,     0,     0,    26,    27,    28,
    2637        0,     0,     0,     0,     0,     0,    31,     0,     0,     0,
    2638        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2639        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2640        0,     0,     0,     0,    34,     0,    35,     0,    36,     0,
    2641        0,   209,    39,     0,     0,     0,     0,     0,     0,     0,
    2642        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2643        0,    43,     0,     0,     0,     0,     0,     0,     0,     0,
    2644        0,     0,     0,     0,     0,     0,     0,     0,   272,     0,
    2645        0,     0,     0,     0,     0,    46,    47,     2,   208,     4,
    2646        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    2647       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2648       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2649        0,     0,    31,     0,     0,     0,     0,     0,     0,     0,
    2650        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2651        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2652       34,     0,    35,     0,    36,     0,     0,    38,    39,     0,
    2653        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2654        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2655        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2656        0,     0,     0,     0,   679,     0,     0,     0,     0,     0,
    2657        0,    46,    47,     2,   208,     4,     5,     6,     7,     8,
    2658        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    2659       19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
    2660       27,    28,     0,     0,     0,     0,     0,     0,    31,     0,
    2661        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2662        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2663        0,     0,     0,     0,     0,     0,    34,     0,    35,     0,
    2664       36,     0,     0,    38,    39,     0,     0,     0,     0,     0,
    2665        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2666        0,     0,     0,    43,     0,     0,     0,     0,     0,     0,
    2667        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2668      593,     0,     0,     0,     0,     0,     0,    46,    47,     2,
    2669      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2670       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2671       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2672        0,     0,     0,     0,    31,     0,     0,     0,     0,     0,
    2673        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2674        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2675        0,     0,    34,     0,    35,     0,    36,     0,     0,   209,
    2676       39,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    2677       17,    18,    19,    20,    21,    22,    23,    24,    25,    43,
    2678        0,    26,    27,    28,     0,     0,     0,     0,   284,   285,
    2679       31,   286,     0,     0,     0,     0,   210,     0,     0,     0,
    2680        0,     0,     0,    46,    47,     0,     0,     0,     0,     0,
    2681        0,     0,     0,     0,     0,     0,     0,   287,    34,     0,
    2682        0,     0,     0,   288,     0,    38,    39,   289,     0,     0,
    2683      290,   291,   292,   293,    41,    42,     0,   294,   295,     0,
    2684        0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
    2685        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2686      296,     0,   518,     0,     0,   173,     0,     0,     0,    46,
    2687       47,   298,   299,   300,   301,     8,     9,    10,    11,    12,
    2688       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2689       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2690        0,     0,   284,   285,    31,   286,     0,     0,     0,     0,
    2691        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2692        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2693        0,   287,    34,     0,     0,     0,     0,   641,     0,    38,
    2694       39,   289,     0,     0,   290,   291,   292,   293,    41,    42,
    2695        0,   294,   295,     0,     0,     0,     0,     0,     0,    43,
    2696        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2697        0,     0,     0,     0,   296,   -35,   742,     0,     0,     0,
    2698        0,     0,     0,    46,    47,   298,   299,   300,   301,     8,
    2699        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    2700       19,    20,    21,    22,    23,    24,    25,     0,     0,    26,
    2701       27,    28,     0,     0,     0,     0,   284,   285,    31,   286,
    2702        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2703        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2704        0,     0,     0,     0,     0,   287,    34,     0,     0,     0,
    2705        0,   288,     0,    38,    39,   289,     0,     0,   290,   291,
    2706      292,   293,    41,    42,     0,   294,   295,     0,     0,     0,
    2707        0,     0,     0,    43,     0,     0,     0,     0,     0,     0,
    2708        0,     0,     0,     0,     0,     0,     0,     0,   296,     0,
    2709      297,     0,     0,     0,     0,     0,     0,    46,    47,   298,
    2710      299,   300,   301,     8,     9,    10,    11,    12,    13,    14,
    2711       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2712       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2713      284,   285,    31,   286,     0,     0,     0,     0,     0,     0,
    2714        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2715        0,     0,     0,     0,     0,     0,     0,     0,     0,   287,
    2716       34,     0,     0,     0,     0,   288,     0,    38,    39,   289,
    2717        0,     0,   290,   291,   292,   293,    41,    42,     0,   294,
    2718      295,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2719        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2720        0,     0,   296,     0,   159,     0,     0,     0,     0,     0,
    2721        0,    46,    47,   298,   299,   300,   301,     8,     9,    10,
    2722       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    2723       21,    22,    23,    24,    25,     0,     0,    26,    27,    28,
    2724        0,     0,     0,     0,   284,   285,    31,   286,     0,     0,
    2725        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2726        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2727        0,     0,     0,   287,    34,     0,     0,     0,     0,   288,
    2728        0,    38,    39,   289,     0,     0,   290,   291,   292,   293,
    2729       41,    42,     0,   294,   295,     0,     0,     0,     0,     0,
    2730        0,    43,     0,     0,     0,     0,     0,     0,     0,     0,
    2731        0,     0,     0,     0,     0,     0,   296,     0,   593,     0,
    2732        0,     0,     0,     0,     0,    46,    47,   298,   299,   300,
    2733      301,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    2734       17,    18,    19,    20,    21,    22,    23,    24,    25,     0,
    2735        0,    26,    27,    28,     0,     0,     0,     0,   284,   285,
    2736       31,   286,     0,     0,     0,     0,     0,     0,     0,     0,
    2737        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2738        0,     0,     0,     0,     0,     0,     0,   287,    34,     0,
    2739        0,     0,     0,   288,     0,    38,    39,   289,     0,     0,
    2740      290,   291,   292,   293,    41,    42,     0,   294,   295,     0,
    2741        0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
    2742        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2743      296,     0,   380,     0,     0,     0,     0,     0,     0,    46,
    2744       47,   298,   299,   300,   301,   468,     2,   208,     4,     5,
     2877      36,     0,     0,   208,    39,   467,     2,   207,     4,     5,
    27452878       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
    27462879      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    27472880       0,     0,    26,    27,    28,     0,     0,     0,     0,     0,
    2748        0,    31,     0,     0,     0,     8,     9,    10,    11,    12,
    2749       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2750       23,    24,    25,     0,     0,    26,    27,    28,     0,    34,
    2751        0,    35,     0,    36,    31,     0,    38,    39,     0,     0,
    2752        0,     0,     0,     8,     9,    10,    11,    12,    13,    14,
    2753       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2754       25,     0,    34,    26,    27,    28,     0,    37,     0,    38,
    2755       39,    40,    31,     0,     0,     0,    -3,     0,    41,    42,
    2756        0,     0,     0,     0,     0,     0,     0,     0,     0,    43,
     2881       0,    31,     0,     0,     0,     0,     0,     0,     0,     0,
    27572882       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2758       34,     0,     0,     0,    44,    37,   159,    38,    39,    40,
    2759        0,     0,     0,    46,    47,     0,    41,    42,     0,     0,
    2760        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2761        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2762        0,     0,    44,     0,    45,     0,     0,     0,     0,     0,
    2763        0,    46,    47,     8,     9,    10,    11,    12,    13,    14,
    2764       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2765       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2766        0,     0,    31,     8,     9,    10,    11,    12,    13,    14,
    2767       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2768       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2769       34,     0,    31,     0,     0,    37,     0,   209,    39,    40,
    2770        0,     0,     0,     0,     0,     0,    41,    42,     0,     0,
    2771        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2772       34,     0,     0,     0,     0,    37,     0,   337,   338,    40,
    2773        0,     0,    44,     0,   272,     0,    41,    42,     0,     0,
    2774        0,    46,    47,     0,     0,     0,     0,    43,     0,     0,
    2775        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2776        0,     0,   635,     0,   339,     0,     0,     0,     0,     0,
    2777        0,    46,    47,     8,     9,    10,    11,    12,    13,    14,
    2778       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2779       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2780        0,     0,    31,     8,     9,    10,    11,    12,    13,    14,
    2781       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2782       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2783       34,     0,    31,     0,     0,    37,     0,   337,   338,    40,
    2784        0,     0,     0,     0,     0,     0,    41,    42,     0,     0,
    2785        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2786       34,     0,     0,     0,     0,   112,     0,    38,    39,     0,
    2787        0,     0,     0,     0,   339,     0,    41,    42,     0,     0,
    2788        0,    46,    47,     0,     0,     0,     0,    43,     0,     0,
    2789        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2790        0,     0,     0,     0,    45,     0,     0,     0,     0,     0,
    2791        0,    46,    47,     8,     9,    10,    11,    12,    13,    14,
    2792       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2793       25,  -295,     0,    26,    27,    28,     0,     0,     0,     0,
    2794        0,     0,    31,     8,     9,    10,    11,    12,    13,    14,
    2795       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2796       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2797       34,     0,    31,   686,     0,     0,     0,    38,    39,     0,
    2798        0,  -295,     0,     0,     0,     0,     0,     0,     0,     0,
    2799        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2800       34,     0,     0,     0,     0,     0,     0,    38,    39,     0,
    2801        0,     0,   635,     0,   339,     0,     0,     0,     0,     0,
    2802        0,    46,    47,     0,     0,     0,     0,    43,     0,     0,
    2803        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2804        0,     0,     0,     0,   687,     0,     0,     0,   688,     0,
    2805        0,    46,    47,     8,     9,    10,    11,    12,    13,    14,
    2806       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2807       25,  -295,     0,    26,    27,    28,     0,     0,     0,     0,
    2808        0,     0,    31,     8,     9,    10,    11,    12,    13,    14,
    2809       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2810       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2811       34,     0,    31,   686,     0,     0,     0,    38,    39,     0,
    2812        0,  -295,     0,     0,     0,     0,     0,     0,     0,     0,
    2813        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2814       34,     0,     0,     0,     0,     0,     0,    38,    39,     0,
    2815        0,     0,     0,     0,   339,     0,     0,     0,     0,     0,
    2816        0,    46,    47,     0,     0,     0,     0,    43,     0,     0,
    2817        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2818        0,     0,     0,     0,   687,     0,     0,     0,  1101,     0,
    2819        0,    46,    47,     8,     9,    10,    11,    12,    13,    14,
    2820       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2821       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2822        0,     0,    31,   686,     8,     9,    10,    11,    12,    13,
     2883       0,     0,     0,     0,     0,     0,     0,     0,     0,    34,
     2884       0,    35,     0,    36,     0,     0,    38,    39,     2,   207,
     2885       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
    28232886      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    28242887      24,    25,     0,     0,    26,    27,    28,     0,     0,     0,
    2825       34,     0,     0,    31,     0,     0,     0,    38,    39,     0,
    2826        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2827        0,     0,     0,     0,     0,     0,     0,    43,     0,     0,
    2828        0,    34,     0,     0,     0,     0,     0,     0,    38,    39,
    2829        0,     0,     0,     0,   687,     0,     0,     0,  1233,     0,
    2830        0,    46,    47,     0,     0,     0,     0,     0,    43,     0,
    2831        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2832        0,     0,     0,   635,     0,   339,     0,     0,     0,     0,
    2833        0,     0,    46,    47,     8,     9,    10,    11,    12,    13,
    2834       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2835       24,    25,     0,     0,    26,    27,    28,     0,     0,     0,
    2836        0,     0,     0,    31,     8,     9,    10,    11,    12,    13,
    2837       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2838       24,    25,     0,     0,    26,    27,    28,     0,     0,     0,
    2839        0,    34,     0,    31,     0,     0,     0,     0,    38,    39,
    2840        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2841        0,     0,     0,     0,     0,     0,     0,     0,    43,     0,
    2842        0,    34,     0,     0,     0,     0,     0,     0,    38,    39,
    2843        0,     0,     0,     0,     0,   259,     0,     0,     0,     0,
    2844        0,     0,    46,    47,     0,     0,     0,     0,    43,     0,
    2845        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2846        0,     0,     0,     0,     0,   159,     0,     0,     0,     0,
    2847        0,     0,    46,    47,     8,     9,    10,    11,    12,    13,
    2848       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2849       24,    25,     0,     0,    26,    27,    28,     0,     0,     0,
    2850        0,     0,     0,    31,     8,     9,    10,    11,    12,    13,
    2851       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2852       24,    25,     0,     0,    26,    27,    28,     0,     0,     0,
    2853        0,    34,     0,    31,     0,     0,     0,     0,   209,    39,
    2854        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2855        0,     0,     0,     0,     0,     0,     0,     0,    43,     0,
    2856        0,    34,     0,     0,     0,     0,     0,     0,    38,    39,
    2857        0,     0,     0,     0,     0,   272,     0,     0,     0,     0,
    2858        0,     0,    46,    47,     0,     0,     0,     0,    43,     0,
    2859        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2860        0,     0,     0,     0,     0,   339,     0,     0,     0,     0,
    2861        0,     0,    46,    47,     8,     9,    10,    11,    12,    13,
    2862       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2863       24,    25,     0,     0,    26,    27,    28,     0,     0,     0,
    2864        0,     0,     0,    31,     8,     9,    10,    11,    12,    13,
    2865       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2866       24,    25,     0,     0,    26,    27,    28,     0,     0,     0,
    2867        0,    34,     0,    31,     0,     0,     0,     0,    38,    39,
    2868        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2869        0,     0,     0,     0,     0,     0,     0,     0,    43,     0,
    2870        0,    34,     0,     0,     0,     0,     0,     0,    38,    39,
    2871        0,     0,     0,     0,     0,   687,     0,     0,     0,     0,
    2872        0,     0,    46,    47,     0,     0,     0,     0,    43,     0,
    2873        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2874        0,     0,     0,     0,     0,   593,     0,     0,     0,     0,
    2875        0,     0,    46,    47,     8,     9,    10,    11,    12,    13,
    2876       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2877       24,    25,     0,     0,    26,    27,    28,     0,     0,     0,
    2878        0,     0,     0,    31,     8,     9,    10,    11,    12,    13,
    2879       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    2880       24,    25,     0,     0,    26,    27,    28,     0,     0,     0,
    2881        0,    34,     0,    31,     0,     0,     0,     0,    38,    39,
    2882        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2883        0,     0,     0,     0,     0,     0,     0,     0,    43,     0,
    2884        0,    34,     0,     0,     0,     0,     0,     0,   209,    39,
    2885        0,     0,     0,     0,     0,    45,     0,     0,     0,     0,
    2886        0,     0,    46,    47,     0,     0,     0,     0,    43,     0,
     2888       0,     0,     0,    31,     0,     0,     0,     0,     0,     0,
    28872889       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    28882890       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2889        0,     0,    46,    47,     2,   208,     4,     5,     6,     7,
    2890        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
    2891       18,    19,    20,    21,    22,    23,    24,    25,     0,     0,
    2892       26,    27,    28,     0,     0,     0,     0,     0,     0,    31,
    2893        0,   284,   285,     0,   286,  1051,     0,  1052,     0,     0,
    2894     1053,  1054,  1055,  1056,  1057,  1058,  1059,  1060,     0,     0,
    2895     1549,  1061,     0,     0,     0,  1062,  1063,    34,    33,    35,
    2896      287,    36,     0,     0,    38,    39,  1064,     0,     0,     0,
    2897      289,     0,     0,   290,   291,   292,   293,    41,    42,     0,
    2898      294,   295,     0,     0,     0,     0,     0,     0,    43,     0,
    2899        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2900     -416,     0,     0,   296,     0,   380,     0,     0,   173,     0,
    2901        0,     0,    46,    47,   298,   299,   300,   301,     0,     0,
    2902        0,     0,  1066,     0,   284,   285,  -130,   286,  1051,     0,
    2903     1052,     0,     0,  1053,  1054,  1055,  1056,  1057,  1058,  1059,
    2904     1060,     0,     0,     0,  1061,     0,     0,     0,  1062,  1063,
    2905        0,    33,     0,   287,     0,     0,     0,     0,     0,  1064,
    2906        0,     0,     0,   289,     0,     0,   290,   291,   292,   293,
    2907       41,    42,     0,   294,   295,     0,     0,     0,     0,     0,
    2908        0,    43,     0,     0,     0,     0,     0,     0,     0,     0,
    2909        0,     0,     0,     0,     0,     0,   296,     0,   380,     0,
    2910        0,   173,     0,     0,     0,    46,    47,   298,   299,   300,
    2911      301,     0,     0,     0,     0,  1066,     0,     0,     0,  -130,
    2912        2,   208,     4,     5,     6,     7,     8,     9,    10,    11,
     2891       0,    34,     0,    35,     0,    36,     0,     0,   208,    39
     2892};
     2893
     2894#define yypact_value_is_default(yystate) \
     2895  ((yystate) == (-1315))
     2896
     2897#define yytable_value_is_error(yytable_value) \
     2898  YYID (0)
     2899
     2900static const yytype_int16 yycheck[] =
     2901{
     2902       0,     1,   240,   186,   205,     0,   734,     0,    43,    43,
     2903      43,   534,   752,   186,     1,   752,   752,   187,   106,   186,
     2904     117,   280,   169,   170,   513,   364,   349,   186,   220,   368,
     2905     186,   349,    32,   186,   620,   186,   991,    32,  1029,    32,
     2906     521,   345,   602,    43,   187,   879,   984,   759,   647,    49,
     2907     492,   418,     0,     0,   496,   879,    49,   600,   188,   571,
     2908     602,    43,   600,    63,   600,   600,    66,    32,   156,    69,
     2909      63,   438,   600,    66,   600,   282,    69,   693,    49,   446,
     2910     600,    72,    69,   266,    32,    32,  1041,   696,    39,  1335,
     2911     634,   635,   636,   266,   426,   427,    57,   267,    43,   266,
     2912    1028,  1029,     0,  1417,    43,   202,   106,   266,  1048,   653,
     2913     266,  1060,  1061,   266,   114,   266,    39,   117,   118,   603,
     2914      72,   635,   636,   482,   267,   609,    39,    51,    95,    44,
     2915      45,    85,   262,   263,    32,   229,    39,    96,    64,   653,
     2916      28,   132,    39,   114,    63,    72,   107,   147,   148,   110,
     2917     257,   186,   186,   186,   248,   148,   156,   157,   109,   113,
     2918     111,   161,   494,   130,   123,   488,   118,   711,   161,   110,
     2919     910,    82,    39,   910,   910,   116,   147,  1491,   482,    44,
     2920      45,   513,    82,   109,   719,   109,   186,   187,   111,  1138,
     2921      78,   719,  1438,   719,   187,   156,   109,   711,   111,   490,
     2922     115,    30,   202,    82,   186,   132,   109,   688,   111,    72,
     2923     210,   111,   109,   132,   111,  1123,    82,   210,   410,  1127,
     2924      83,    84,   222,    72,  1048,    74,    75,   107,    82,   222,
     2925      11,   266,   266,   266,    83,    84,   406,    82,   117,   210,
     2926     240,   186,   109,   109,   111,  1236,   578,   186,   111,   114,
     2927     589,   131,   252,   341,    83,    84,   110,   252,   219,   252,
     2928     260,   805,   111,   406,   109,   265,   266,   267,   828,   240,
     2929       1,  1473,   272,   816,   267,   634,   635,   636,   816,  1421,
     2930     816,   816,   994,   371,   602,   797,   828,   252,   816,   905,
     2931     816,   805,   631,    96,   653,   295,   816,   504,  1289,   396,
     2932     109,   272,   911,   109,   252,   252,  1508,   307,  1510,   257,
     2933     480,   418,   273,   604,  1252,   682,   620,   608,    49,   280,
     2934     123,   625,   131,   323,  1524,    44,    45,   424,   328,  1057,
     2935     929,   438,   116,   430,   818,   328,   307,   480,   629,   446,
     2936    1494,   341,   633,   109,  1544,   345,  1500,   956,   132,   349,
     2937     350,  1551,   711,    39,   252,    90,    91,   285,    72,   257,
     2938    1288,  1289,  1302,  1524,   364,    82,   109,  1521,   368,    83,
     2939      84,   371,  1526,    72,   345,   106,   112,  1519,   938,   307,
     2940     308,    57,  1524,   114,    83,    84,   114,   348,  1222,   748,
     2941    1551,   126,   127,   110,   937,   114,   396,   111,  1222,   937,
     2942     117,   937,  1544,   110,   365,   110,   406,   110,   369,  1551,
     2943     117,   116,   111,   406,   117,   244,   147,   345,   116,   115,
     2944     116,  1007,  1413,     3,   424,   156,   426,   427,   131,   116,
     2945     430,   107,   116,   433,   110,   131,   116,   525,    10,    11,
     2946      12,    13,    14,     3,   748,   132,   805,    72,   132,     0,
     2947    1405,  1406,   132,   381,   454,   426,   427,   118,    83,    84,
     2948     667,   116,   110,   124,   125,     0,     1,    39,   807,   117,
     2949     418,   432,   472,   812,   733,   206,   116,   132,  1302,   210,
     2950     480,    32,   482,   116,   484,  1413,   111,   480,   488,   484,
     2951     438,   484,   132,   974,   494,    67,   116,    32,   446,   132,
     2952     989,   648,   116,   116,   946,   828,   506,     0,   508,   240,
     2953     828,   511,   132,   513,   514,    66,  1125,     0,   688,   132,
     2954     418,   521,  1462,   494,   112,   525,   526,   657,   116,  1469,
     2955     737,    66,  1016,  1017,    69,   109,   484,   484,  1137,   116,
     2956     438,   272,   513,   219,   275,   688,   131,  1107,   446,   110,
     2957     909,   380,   116,   116,    72,   132,    74,    75,   655,   850,
     2958     110,    72,   901,   109,   295,    83,    84,   116,   132,   132,
     2959     570,   571,    83,    84,  1302,   682,   307,   109,   578,  1188,
     2960    1189,   112,  1522,   132,   482,   116,   484,   116,   112,   589,
     2961     590,   109,   116,    80,   594,   590,   114,   273,   109,   109,
     2962     600,   708,   602,   132,   280,   909,   109,   578,   111,   109,
     2963     341,    80,  1093,   109,   345,   118,   119,  1098,   109,   942,
     2964     620,   549,   550,   551,   111,   625,   113,   627,   589,   110,
     2965     117,   631,   110,   364,   634,   635,   636,   368,  1462,   112,
     2966     371,   112,   111,   116,   113,  1469,    72,   110,   117,   620,
     2967     110,  1379,   943,   653,   625,   655,   116,    83,    84,   747,
     2968     621,   110,   491,    72,   493,    74,    75,   116,   129,  1028,
     2969     131,   222,   348,   865,    83,    84,   637,   110,    66,     4,
     2970       5,     6,     7,     8,     9,   685,   110,   222,   688,   365,
     2971     109,   652,   116,   369,   886,   426,   427,   109,  1522,   111,
     2972     109,   252,   112,  1007,   109,   114,   116,     0,     1,   110,
     2973     948,   711,   712,   713,   109,   116,   110,   252,   115,   719,
     2974     720,   132,   116,   454,   871,   295,   110,   910,    64,   110,
     2975     118,   109,   116,   111,   682,   116,   467,   910,  1466,    32,
     2976    1468,   109,   912,   910,    69,   109,    71,   747,   748,   110,
     2977     110,   910,   752,   753,   910,   116,   116,   910,   112,   910,
     2978     708,   492,   110,   494,   110,   496,   112,   132,   116,   912,
     2979     116,   114,   733,   161,   114,   506,    69,   508,   109,   110,
     2980     511,   110,   513,   514,   682,   131,   132,   116,  1528,   109,
     2981    1399,  1528,  1528,  1132,   525,  1523,  1319,   797,  1157,   350,
     2982     110,   556,   557,   558,   559,   805,   116,   807,  1417,   809,
     2983     708,   132,   812,   813,   643,   109,   816,   111,   813,  1020,
     2984     908,   110,   114,   110,   118,   119,    70,   116,   828,   116,
     2985      74,   759,   110,    77,   222,    79,   132,    72,   116,    74,
     2986      75,    76,    86,    72,    82,    74,    75,   578,    83,    84,
     2987     748,   120,   121,  1157,    83,    84,   426,   427,   589,    72,
     2988     109,    74,    75,   692,    72,   694,    74,    75,    76,   698,
     2989      83,    84,   260,   109,   109,    83,    84,   265,   109,   879,
     2990     111,  1490,  1491,    82,   879,   114,   110,   118,   119,   620,
     2991     112,   109,   116,   111,   625,    72,  1043,    74,    75,    76,
     2992     631,   901,   109,   110,   111,    49,    83,    84,   908,   909,
     2993     910,   109,   912,   111,   119,    72,  1123,    74,    75,    76,
     2994    1127,  1128,   473,  1093,   924,   128,    83,    84,  1098,  1288,
     2995      94,   879,  1236,   484,    88,    89,   506,   937,   938,   129,
     2996     901,   511,   942,   131,   514,   621,   111,   947,   948,   484,
     2997    1093,   109,   109,   111,   685,  1098,   109,     0,     1,   252,
     2998     947,   637,   350,   506,   964,   508,   112,   110,   511,   213,
     2999     114,   514,   109,   116,   974,   110,   652,   948,   109,   110,
     3000     111,   879,    92,    93,    72,    49,    29,    30,    76,    32,
     3001     112,   109,   723,   111,   110,    83,    84,   567,   112,    63,
     3002      43,   109,    66,   111,   110,    69,    49,  1007,   109,   110,
     3003     111,   909,   110,    72,    57,   110,   747,    76,  1115,   110,
     3004      63,   109,  1503,    66,    83,    84,    69,   109,  1028,  1029,
     3005     118,   119,   109,   110,   111,   109,  1007,   111,   111,  1246,
     3006      83,    84,   871,   431,    58,    59,    60,   112,  1048,   878,
     3007     109,   114,   111,  1048,    85,    86,    87,   733,   116,   118,
     3008     119,  1261,  1262,  1263,   107,   131,   210,   110,   109,   114,
     3009     111,   622,  1553,   915,   117,   917,   807,   114,   109,  1007,
     3010     111,   812,   113,   114,   148,   473,   115,   116,  1088,   109,
     3011     919,   116,   117,  1093,   110,   111,   117,   161,  1098,   112,
     3012    1048,    58,    59,   115,   116,   148,   110,  1107,   352,   110,
     3013     354,   116,   117,   156,   112,  1115,   116,   117,   161,   112,
     3014    1048,    44,    45,   187,   552,   553,   560,   561,   272,  1336,
     3015    1218,   112,  1132,  1340,   554,   555,   112,     4,     5,     6,
     3016       7,     8,     9,   186,   187,   117,   210,   117,   699,   978,
     3017    1048,   295,   116,    29,    85,    86,    87,  1157,   222,   202,
     3018     110,   110,   713,   307,   112,   112,   132,   210,   114,   110,
     3019     901,   115,   115,   115,   110,   109,   219,   908,   109,   222,
     3020     111,   116,   113,   114,   110,   110,   229,   116,   110,   117,
     3021     110,   484,   110,   924,   110,   116,   110,   110,   442,  1199,
     3022    1200,   244,    69,   110,    71,   248,   594,   110,   110,   252,
     3023     253,   110,     0,  1200,   110,   946,   947,   948,  1218,   110,
     3024     110,   110,  1222,   266,   267,   110,   110,  1222,   115,    29,
     3025     273,   131,   110,   116,   622,  1442,  1236,   280,   117,   627,
     3026    1240,   112,   112,   116,    32,   110,   110,   110,   117,   117,
     3027    1079,   112,   112,  1240,   116,    43,   114,  1218,   809,  1157,
     3028     110,    49,   110,   110,   328,   132,     4,     5,     6,     7,
     3029       8,     9,   116,   110,  1222,    63,  1007,   116,    66,   110,
     3030     116,    69,   110,   112,   109,   328,   109,   109,  1288,  1289,
     3031     109,   109,   112,   110,   132,    33,   110,  1297,  1395,   115,
     3032    1538,   110,  1302,   115,    72,   348,   349,  1302,    76,   115,
     3033     454,   699,   114,   112,   129,    83,    84,    10,    11,    12,
     3034      13,    14,   365,   110,  1222,   713,   369,   132,   879,   112,
     3035     116,    69,   116,    71,   112,  1335,   110,   380,  1236,   110,
     3036     110,   109,   406,   112,   879,  1528,    39,   112,  1335,   112,
     3037     118,   119,   110,   396,  1302,  1528,   112,  1088,   112,  1529,
     3038     148,  1528,   506,   406,   508,   112,  1195,   511,    47,  1528,
     3039     514,   132,  1528,   161,    67,  1528,   115,  1528,   110,   132,
     3040     132,   424,   132,  1553,   132,   115,  1529,   430,   117,   432,
     3041     110,   879,   115,   112,    66,  1395,   112,   112,   186,   187,
     3042     112,  1132,   112,   112,  1302,   112,  1503,   112,   110,   110,
     3043    1553,    83,   947,  1413,   112,   112,   109,   109,   111,   109,
     3044     109,   809,   210,    60,   467,   118,   119,   110,   110,   472,
     3045     114,   117,   132,  1394,   222,   112,   112,   480,  1438,   110,
     3046      96,   484,   112,   110,    96,   488,   118,     3,   491,   109,
     3047     493,  1438,   109,   115,    10,    11,    12,    13,    14,  1010,
     3048     110,   112,  1462,   132,   252,   110,   110,  1462,   110,  1469,
     3049     513,  1471,    42,  1473,  1469,   116,   110,   117,   266,   132,
     3050     110,    96,    96,    39,   132,   528,   132,  1218,   531,   161,
     3051     533,   534,   110,  1528,  1528,  1528,   132,  1048,   117,   110,
     3052     132,   110,   110,  1503,   132,   115,   112,   112,  1508,  1240,
     3053    1510,    67,   109,  1048,  1462,   132,   115,   115,   110,   110,
     3054     132,  1469,  1522,   110,   110,  1064,   562,  1522,  1528,  1529,
     3055     563,   565,   564,  1222,  1491,  1381,  1529,  1563,  1538,   582,
     3056     328,   685,   566,  1312,  1128,  1340,   589,  1469,   917,  1079,
     3057     222,   685,   685,  1553,  1098,    66,   698,   600,   925,   602,
     3058    1553,   349,   978,  1051,  1462,    76,   871,  1538,   649,   944,
     3059    1240,  1469,   582,   723,  1522,   484,   570,   733,   621,   570,
     3060      72,   570,    74,    75,    76,    -1,   879,    -1,   260,    -1,
     3061      -1,    83,    84,   265,   637,    -1,    -1,    -1,    -1,    -1,
     3062     643,    -1,    -1,    -1,  1335,    -1,    -1,   118,    -1,   652,
     3063      -1,   654,   655,   656,    -1,    -1,    -1,   109,   406,   111,
     3064      -1,    -1,  1010,    -1,  1522,   117,   118,   119,    -1,    -1,
     3065      -1,  1201,  1202,    -1,  1204,     0,     1,    -1,    -1,    -1,
     3066      -1,  1211,    -1,  1213,    -1,   688,    -1,    -1,  1199,   692,
     3067     161,   694,    -1,    -1,   947,   698,    -1,    10,    11,    12,
     3068      13,    14,    -1,   706,  1199,  1200,    -1,    32,    -1,    -1,
     3069      -1,  1222,     3,    -1,    -1,    -1,   719,   720,   350,    10,
     3070      11,    12,    13,    14,    49,    -1,    39,  1222,    -1,    -1,
     3071     733,    72,    -1,    74,    75,    76,   484,    -1,    -1,    -1,
     3072     488,    -1,    83,    84,    69,  1240,    -1,  1438,    39,    -1,
     3073      -1,   222,    -1,    -1,    67,    -1,    -1,    -1,  1394,    72,
     3074      -1,    74,    75,    76,    -1,     0,    -1,    -1,   109,    -1,
     3075      83,    84,    -1,    -1,  1222,    -1,    67,   118,   119,    -1,
     3076    1471,   106,  1473,    -1,    -1,    -1,  1297,    -1,    -1,   260,
     3077      -1,  1302,    55,    -1,   265,  1048,   109,    32,   111,   431,
     3078      -1,    -1,  1297,    -1,    -1,   118,   119,  1302,    -1,   280,
     3079      -1,    -1,    -1,   816,    -1,    -1,    -1,  1508,    -1,  1510,
     3080     924,    -1,    -1,   148,    -1,   828,    72,    -1,    74,    75,
     3081      76,   156,   157,    -1,    69,    98,    -1,    83,    84,    -1,
     3082    1335,   473,    -1,    -1,    -1,  1375,    -1,  1538,    -1,    -1,
     3083       3,  1199,   600,    -1,   602,    -1,    -1,    10,    11,    12,
     3084      13,    14,   187,   109,    -1,   111,    -1,    -1,   871,    -1,
     3085    1318,    -1,   118,   119,    -1,   878,    -1,   202,    -1,   350,
     3086     205,   206,    -1,    -1,   464,   210,    39,    -1,    -1,    72,
     3087      -1,    74,    75,    76,    -1,    -1,    -1,    -1,   901,    -1,
     3088      83,    84,   464,    -1,    -1,    -1,   231,   910,    -1,   912,
     3089     235,    -1,   237,    -1,    67,    -1,   919,    -1,    -1,    -1,
     3090      -1,   246,   157,    -1,    -1,  1373,   109,   252,  1376,    -1,
     3091      -1,   194,   257,    -1,    -1,   118,   119,    -1,    -1,   942,
     3092     688,    -1,   267,  1438,    -1,    -1,    -1,  1200,    -1,  1297,
     3093     275,  1462,    -1,    -1,   217,    -1,    -1,    -1,  1469,   962,
     3094     431,    -1,   594,    -1,   227,    -1,    -1,  1462,    -1,  1222,
     3095      -1,   719,   720,  1421,  1469,   978,    -1,   448,  1426,    -1,
     3096      -1,    -1,    -1,   986,  1088,    -1,   989,  1240,   991,    -1,
     3097     622,    -1,    -1,    -1,    -1,   627,   231,    -1,    -1,    -1,
     3098      -1,    -1,   473,    -1,    -1,    -1,    -1,    -1,  1456,    -1,
     3099      -1,  1522,    -1,    -1,    -1,    -1,   341,   252,    -1,    -1,
     3100     345,    -1,   257,    -1,    -1,    -1,   351,  1522,    -1,    -1,
     3101      -1,    -1,   295,    -1,    -1,    -1,    -1,    -1,  1041,   364,
     3102      -1,    -1,    -1,   368,    -1,    -1,   371,    -1,    -1,  1302,
     3103      -1,    26,    27,    28,    -1,    -1,    -1,    -1,    -1,    72,
     3104      -1,    74,    75,    76,    -1,    -1,    -1,   699,   816,    -1,
     3105      83,    84,    -1,    -1,    -1,    -1,  1079,    -1,    -1,    -1,
     3106     828,   713,  1335,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3107    1093,   671,    -1,   418,  1542,  1098,   109,     0,   111,    -1,
     3108    1548,    -1,    -1,    -1,    -1,   118,   119,    -1,   433,   671,
     3109      -1,  1559,  1115,   438,    -1,  1563,   351,    -1,    -1,    -1,
     3110      -1,   446,    -1,   594,    99,    -1,   101,    -1,    -1,    32,
     3111      -1,    10,    11,    12,    13,    14,    -1,    -1,    -1,   464,
     3112      -1,    -1,   467,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3113      -1,   622,    -1,    -1,    -1,    -1,   627,   482,    -1,   484,
     3114      39,    -1,   910,    -1,   912,    -1,    69,   492,    -1,    -1,
     3115      -1,   496,    -1,    -1,    -1,    -1,    -1,   809,    -1,    -1,
     3116     443,    -1,    -1,   418,    -1,  1438,    -1,     0,    67,    -1,
     3117      -1,    -1,  1195,    72,   942,    74,    75,    76,   433,    -1,
     3118     525,   526,    -1,   438,    83,    84,   469,   182,    -1,  1462,
     3119      -1,   446,    -1,   793,    -1,  1218,  1469,   192,   193,    32,
     3120      -1,    -1,   197,   803,   199,   200,    -1,    -1,   699,   464,
     3121     109,   793,   111,    -1,    -1,    -1,    -1,   817,    -1,   118,
     3122     119,   803,   713,   506,    -1,    -1,   571,   482,   511,   484,
     3123      -1,   514,    -1,    -1,   157,   817,    69,    -1,  1261,  1262,
     3124    1263,    -1,   733,    -1,   589,   590,    -1,    -1,    -1,  1522,
     3125      -1,    -1,    10,    11,    12,    13,    14,   602,    -1,    -1,
     3126      -1,    -1,    -1,    -1,    -1,    10,    11,    12,    13,    14,
     3127      -1,   526,    -1,    -1,    -1,   620,    -1,   190,    -1,    -1,
     3128     625,    39,    -1,    -1,   197,    -1,   631,    -1,    -1,   634,
     3129     635,   636,    -1,    -1,    39,    -1,  1319,    -1,    97,    98,
     3130      99,   100,   101,   102,   103,   104,   105,   106,   653,    67,
     3131      -1,    -1,    -1,    -1,    -1,    -1,    -1,   696,   809,    -1,
     3132      -1,    -1,    67,    -1,   157,  1093,   671,    72,    -1,   252,
     3133    1098,    76,   131,    -1,   257,   590,    -1,   682,    83,    84,
     3134      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1471,    -1,  1473,
     3135      -1,   109,    -1,   111,    -1,    -1,   269,    -1,  1010,    -1,
     3136     118,   119,    -1,   708,   109,    -1,   711,    -1,    -1,    -1,
     3137      -1,  1394,  1395,   118,   119,   720,    -1,    -1,   723,   634,
     3138     635,   636,  1405,  1406,  1508,    -1,  1510,   670,    -1,    -1,
     3139      -1,    -1,    -1,    -1,    -1,    -1,   679,    -1,   653,    -1,
     3140     683,    -1,   747,   748,    -1,    -1,    -1,    -1,   753,    -1,
     3141     323,   790,    -1,    -1,    -1,    -1,   671,    -1,   331,   252,
     3142    1443,   334,    -1,    -1,   257,  1025,  1026,   682,   351,    -1,
     3143      -1,    -1,    -1,    -1,    10,    11,    12,    13,    14,    -1,
     3144      -1,    -1,    -1,  1025,  1026,    -1,    -1,    -1,   793,    -1,
     3145      -1,    -1,    -1,   708,    -1,    -1,   711,    -1,   803,    -1,
     3146     805,    -1,   807,    39,    -1,   810,    -1,   812,   813,    -1,
     3147      -1,    -1,   817,    -1,    10,    11,    12,    13,    14,    -1,
     3148    1503,  1504,   827,  1083,  1084,   398,    -1,    -1,   867,   402,
     3149    1513,    67,    -1,   748,    -1,   418,    72,    -1,    74,    75,
     3150      76,  1083,  1084,    39,    -1,  1528,  1529,    83,    84,    -1,
     3151     433,    -1,    -1,    -1,    -1,   438,    -1,    -1,   351,  1010,
     3152      -1,    -1,    -1,   446,    -1,    -1,    -1,    -1,     1,    -1,
     3153    1553,    67,   911,   109,   879,   111,    -1,    -1,   793,    -1,
     3154      -1,   464,   118,   119,    -1,    -1,    -1,  1199,   803,    -1,
     3155     805,    -1,    -1,    -1,    -1,   810,   901,    -1,   813,   482,
     3156      -1,   484,   817,   908,   909,    -1,   479,   912,    -1,    -1,
     3157      -1,    -1,    -1,   109,    -1,   111,    -1,   956,    -1,   574,
     3158     575,    -1,   118,   119,    -1,   418,    72,    -1,    74,    75,
     3159      76,    -1,    -1,   938,    -1,    -1,    -1,    83,    84,    -1,
     3160     433,   946,   947,   526,   671,   438,    -1,    -1,   603,    -1,
     3161      -1,   606,   607,   446,   609,   994,   611,   612,    -1,   964,
     3162     903,   616,   617,   109,   879,   111,    -1,    -1,    -1,    -1,
     3163      -1,   464,   118,   119,  1234,    -1,    -1,    -1,    -1,    -1,
     3164      -1,    -1,    -1,    -1,    -1,  1297,    -1,    -1,    -1,   482,
     3165      -1,   484,  1234,    -1,   909,    -1,    -1,   570,   571,     0,
     3166       1,    -1,  1007,    -1,    -1,    -1,  1045,   590,    -1,  1269,
     3167      -1,    -1,    -1,    -1,    -1,  1020,    -1,  1277,  1278,  1279,
     3168    1025,  1026,    -1,  1028,  1029,    -1,    -1,  1269,    -1,    -1,
     3169      -1,    32,    -1,   526,    -1,  1277,  1278,  1279,    -1,    -1,
     3170      -1,    -1,    -1,  1048,    -1,    -1,    -1,    -1,  1199,   964,
     3171      -1,   634,   635,   636,    -1,    -1,    -1,    -1,    -1,    -1,
     3172      -1,    -1,    -1,    -1,    -1,    66,   793,    -1,    69,    -1,
     3173     653,    -1,    -1,    -1,    -1,    -1,   803,    -1,  1083,  1084,
     3174      -1,    -1,    -1,  1343,    -1,   658,  1125,    -1,   671,   662,
     3175     817,    -1,    -1,    -1,    -1,    -1,    -1,   590,    -1,   682,
     3176    1528,  1343,   757,   758,    -1,    -1,    -1,    -1,    -1,    -1,
     3177    1025,  1026,    -1,  1028,  1029,    -1,  1059,    -1,    -1,    -1,
     3178     253,    -1,    -1,    -1,    -1,   708,    -1,  1132,   711,    -1,
     3179      -1,    -1,    -1,  1048,    -1,    -1,    -1,    -1,    -1,    -1,
     3180      -1,   634,   635,   636,    -1,    -1,  1297,    -1,    -1,  1188,
     3181    1189,    -1,  1157,    -1,     0,    -1,   157,    -1,    -1,    -1,
     3182     653,    -1,    -1,    -1,    -1,   748,    -1,    -1,  1083,  1084,
     3183      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   671,    10,
     3184      11,    12,    13,    14,    -1,    -1,    32,    -1,    -1,   682,
     3185      -1,    -1,    -1,    -1,    -1,  1200,    -1,    -1,    -1,    -1,
     3186      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,
     3187     793,    -1,    -1,  1218,    -1,   708,    -1,  1222,   711,    -1,
     3188     803,   222,   805,    69,   797,    -1,    -1,   810,    -1,  1234,
     3189     813,  1236,    -1,    -1,   817,  1240,    67,    -1,    -1,    -1,
     3190      -1,    72,  1157,    74,    75,    76,    -1,    -1,    -1,    -1,
     3191      -1,   252,    83,    84,    -1,   748,    -1,    -1,    -1,    -1,
     3192      -1,    -1,    -1,    -1,  1269,    -1,   921,    -1,    -1,    -1,
     3193      -1,    -1,  1277,  1278,  1279,    -1,    -1,    -1,   109,    -1,
     3194      -1,    -1,    -1,  1288,  1289,  1200,    -1,   118,   119,    -1,
     3195      -1,    -1,    -1,    -1,    -1,    -1,   879,  1302,  1025,  1026,
     3196     793,    -1,    -1,    -1,    -1,    -1,    -1,  1222,    -1,    -1,
     3197     803,   157,   805,    -1,    -1,    -1,    -1,   810,    -1,  1234,
     3198     813,  1236,    -1,    -1,   817,    -1,   909,    -1,    -1,    -1,
     3199    1335,    -1,    -1,    -1,   467,    -1,    -1,    -1,  1343,    -1,
     3200      -1,    -1,    -1,   916,    -1,    -1,    -1,    -1,    -1,    -1,
     3201      -1,    -1,    -1,    -1,  1269,    -1,  1083,  1084,    -1,    -1,
     3202    1399,    -1,  1277,  1278,  1279,    -1,    -1,    -1,  1311,    -1,
     3203      -1,    -1,    -1,  1288,  1289,    -1,    -1,    -1,  1417,    -1,
     3204     513,   964,    -1,    -1,    -1,    -1,   879,  1302,    -1,    -1,
     3205      -1,    -1,    -1,    -1,    -1,   528,    -1,    -1,   531,    -1,
     3206     533,   534,    -1,    -1,    -1,    -1,   252,    -1,  1413,    -1,
     3207      -1,   257,    26,    27,    28,    -1,   909,    -1,    -1,    -1,
     3208      -1,    -1,    -1,   996,    -1,    -1,    -1,    -1,  1343,    -1,
     3209    1085,    -1,   433,  1438,    -1,    -1,    -1,    -1,    -1,    -1,
     3210    1013,    -1,  1025,  1026,    -1,  1028,  1029,    -1,    -1,   582,
     3211      -1,  1490,  1491,    -1,    53,    -1,    55,  1462,    -1,    58,
     3212      59,    60,    -1,    62,  1469,  1048,    -1,    -1,    -1,    -1,
     3213      -1,   964,    -1,    -1,    -1,    -1,    -1,    -1,    77,    -1,
     3214      -1,    -1,    -1,   484,    -1,    99,    -1,   101,    -1,    -1,
     3215      89,    90,    -1,    -1,    -1,    -1,    -1,    -1,  1413,    -1,
     3216    1083,  1084,    -1,    -1,    -1,   351,    -1,    -1,    -1,    -1,
     3217      -1,    -1,   126,    -1,    -1,    -1,    -1,  1522,  1091,    -1,
     3218      -1,   654,    -1,   656,  1529,   526,    -1,  1470,    -1,  1472,
     3219      -1,    -1,  1025,  1026,    -1,  1028,  1029,    -1,    -1,    -1,
     3220      -1,    -1,  1269,    -1,    -1,    -1,    -1,  1462,    -1,    -1,
     3221    1277,  1278,  1279,    -1,  1469,  1048,    -1,    -1,    -1,    -1,
     3222    1133,    -1,  1217,    -1,  1507,    -1,  1509,    -1,   182,    -1,
     3223      -1,    -1,   418,   706,  1157,    -1,   190,    -1,   192,   193,
     3224      -1,    -1,    -1,   197,    -1,   199,   200,   433,    -1,   590,
     3225    1083,  1084,   438,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3226     446,    -1,    -1,    -1,    -1,    -1,    -1,  1522,    -1,  1552,
     3227      -1,  1554,    -1,    -1,    -1,    -1,  1343,  1200,   464,    10,
     3228      11,    12,    13,    14,  1567,  1568,    -1,    -1,    -1,    -1,
     3229      -1,    -1,    -1,   634,   635,   636,   482,    -1,   484,  1222,
     3230      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,
     3231      -1,  1234,   653,  1236,    -1,   269,    -1,    -1,    10,    11,
     3232      12,    13,    14,    -1,  1157,    -1,    -1,    -1,    -1,    -1,
     3233      -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,
     3234     526,    72,    -1,    74,    75,    76,  1269,    39,    -1,    -1,
     3235      -1,    -1,    83,    84,  1277,  1278,  1279,    -1,    -1,    -1,
     3236      -1,    -1,    -1,    -1,    -1,  1288,  1289,  1200,    -1,    -1,
     3237     711,    -1,    -1,    -1,    -1,    67,    -1,    -1,   109,  1302,
     3238      72,    -1,    -1,    -1,    76,    -1,    -1,   118,   119,  1222,
     3239      -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3240      -1,  1234,    -1,  1236,   590,   344,    -1,   346,    -1,    -1,
     3241      -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,   357,   358,
     3242    1343,    -1,    -1,    -1,    -1,    -1,   118,   119,    -1,    -1,
     3243      -1,    -1,    -1,    -1,    -1,    -1,  1269,    -1,    -1,    -1,
     3244      -1,    -1,    -1,    -1,  1277,  1278,  1279,    -1,   634,   635,
     3245     636,    -1,    -1,    -1,    -1,  1288,  1289,    -1,    -1,    -1,
     3246      -1,    -1,    -1,    -1,   805,    -1,    -1,   653,    -1,  1302,
     3247      -1,    -1,   813,    -1,    -1,     7,    -1,    -1,    10,    11,
     3248      12,    13,    14,    -1,    -1,   671,    -1,    -1,    -1,   962,
     3249    1413,    -1,    -1,    -1,    -1,    -1,   682,    -1,    -1,    -1,
     3250      -1,    -1,    -1,    -1,    -1,    37,    38,    39,    40,    -1,
     3251    1343,    -1,    -1,   986,    -1,    -1,   989,    -1,   991,    -1,
     3252      -1,    -1,   708,    -1,    -1,   711,    -1,    -1,    -1,    -1,
     3253      -1,    -1,    -1,    -1,    66,    67,    -1,    -1,   879,  1462,
     3254      72,    -1,    -1,    -1,    76,    -1,  1469,    79,    80,    81,
     3255      82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,    -1,
     3256      -1,    -1,   748,    -1,    -1,    -1,    -1,    -1,  1041,    -1,
     3257      -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,   111,
     3258    1413,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,
     3259     122,   123,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1522,
     3260      -1,    -1,    -1,    -1,    -1,    -1,   947,   793,    -1,    -1,
     3261      -1,    -1,    -1,    -1,    -1,    -1,    -1,   803,    -1,   805,
     3262     574,   575,    -1,   964,   810,    -1,    -1,   813,    -1,  1462,
     3263      -1,   817,    37,    38,    -1,    40,  1469,    -1,    -1,    -1,
     3264      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   603,
     3265      -1,    -1,   606,   607,    -1,   609,    -1,   611,   612,    -1,
     3266      -1,    66,   616,   617,    -1,    -1,    -1,    72,    -1,    74,
     3267      75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
     3268      -1,    86,    87,    -1,    -1,    -1,    -1,  1028,  1029,  1522,
     3269      -1,    -1,    -1,   879,    -1,    -1,    -1,    -1,    -1,    -1,
     3270      -1,    -1,    -1,    -1,   109,    -1,   111,  1048,   113,   114,
     3271      -1,    -1,    -1,   118,   119,   120,   121,   122,   123,    -1,
     3272      -1,    -1,    -1,   909,    -1,    -1,    -1,    -1,    -1,     3,
     3273       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
     3274      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
     3275      24,    25,    26,    27,    -1,    -1,    30,    31,    32,    -1,
     3276      -1,   700,    -1,   702,    -1,    39,    -1,    -1,    -1,    -1,
     3277     709,   710,    -1,    -1,    -1,   714,    -1,    -1,   964,    -1,
     3278      -1,    -1,    -1,    -1,    -1,    -1,    -1,   726,  1261,  1262,
     3279    1263,    -1,   731,    67,    -1,    69,    -1,    71,    72,    -1,
     3280      74,    75,    76,   757,   758,    -1,    -1,    -1,    -1,    83,
     3281      84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3282      -1,    -1,   761,    -1,    -1,    -1,    -1,    -1,    37,    38,
     3283      -1,    40,    -1,    -1,    -1,   109,    -1,   111,    -1,  1025,
     3284    1026,    -1,  1028,  1029,   118,   119,  1319,    -1,    -1,    -1,
     3285      -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,  1199,  1200,
     3286      -1,    -1,  1048,    72,    -1,    -1,    -1,    76,    -1,    -1,
     3287      79,    80,    81,    82,    83,    84,    -1,    86,    87,    -1,
     3288      -1,  1222,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3289      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1083,  1084,  1240,
     3290     109,    -1,   111,    -1,    -1,   114,    -1,    -1,    -1,   118,
     3291     119,   120,   121,   122,   123,    -1,    -1,    49,    -1,    -1,
     3292      -1,    -1,   861,   862,   863,   864,    -1,   866,    -1,    -1,
     3293      -1,    -1,  1405,  1406,    66,    -1,    -1,    -1,    -1,    -1,
     3294      -1,    -1,    -1,   882,    -1,    -1,    -1,  1288,  1289,    -1,
     3295      -1,    -1,    -1,    -1,    -1,    -1,  1297,   896,    -1,    -1,
     3296      -1,  1302,   916,    -1,    -1,    -1,    -1,   921,    -1,    -1,
     3297    1443,  1157,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3298      -1,    -1,   114,    -1,    -1,    -1,   118,    -1,    -1,    -1,
     3299      -1,    -1,    -1,    -1,  1335,    -1,    -1,   936,    -1,    -1,
     3300      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3301      -1,    -1,    -1,    -1,  1200,   147,    -1,    -1,    -1,    -1,
     3302      -1,    -1,    -1,    -1,    -1,   157,    -1,    -1,    -1,   161,
     3303      -1,  1504,    -1,    -1,    -1,    -1,  1222,    -1,    -1,    -1,
     3304    1513,    -1,    -1,    -1,   983,    -1,    -1,    -1,  1234,    -1,
     3305    1236,   990,    -1,    -1,    -1,    -1,   995,    -1,    -1,    -1,
     3306      -1,  1000,    -1,  1002,    -1,    -1,    -1,  1006,    -1,  1008,
     3307    1009,    -1,  1413,  1012,    -1,    -1,    -1,    -1,   210,    -1,
     3308      -1,    -1,  1021,  1269,    -1,    -1,    -1,    -1,    -1,    -1,
     3309     222,  1277,  1278,  1279,    -1,    -1,    -1,  1438,    -1,    -1,
     3310    1039,  1040,  1288,  1289,    -1,    -1,    -1,    -1,   240,    -1,
     3311      -1,    -1,    -1,    -1,    -1,    -1,  1302,    -1,    -1,    -1,
     3312      -1,  1462,    -1,    -1,    -1,    -1,    -1,  1066,  1469,    -1,
     3313    1069,  1085,    -1,   265,    -1,    -1,    -1,    -1,    -1,    -1,
     3314     272,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3315      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1343,    -1,    -1,
     3316      -1,    -1,    -1,   295,    -1,    -1,    -1,    -1,    -1,    -1,
     3317      -1,    -1,    -1,  1112,    -1,   307,    -1,    -1,    -1,  1118,
     3318    1119,  1522,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3319      -1,  1130,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3320      -1,  1140,    -1,    -1,  1143,    -1,  1145,    -1,    -1,  1148,
     3321      -1,    -1,    -1,   345,    -1,    -1,    -1,    -1,   350,    -1,
     3322      -1,    -1,  1161,    -1,    -1,    -1,    -1,  1413,    -1,    -1,
     3323      -1,    -1,    -1,    -1,    -1,  1174,    -1,  1176,  1177,  1178,
     3324    1179,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3325      -1,    -1,    -1,  1192,    -1,  1194,    -1,    -1,    -1,  1198,
     3326      -1,    -1,    -1,  1217,    -1,    66,    -1,    -1,    -1,    -1,
     3327      -1,    -1,    -1,    -1,    -1,    76,  1462,    78,    -1,    80,
     3328      -1,    -1,    -1,  1469,    -1,    -1,    87,    -1,  1227,  1228,
     3329      -1,    -1,    -1,    -1,   426,   427,    -1,    -1,    -1,    -1,
     3330      -1,   433,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3331      -1,    -1,    -1,    -1,    -1,    -1,    -1,   118,    -1,   120,
     3332     121,   122,   454,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3333      -1,    -1,    -1,    -1,    -1,    -1,  1522,    -1,    -1,    -1,
     3334      -1,  1280,  1281,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3335     482,  1290,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3336     161,    -1,   494,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3337      -1,    -1,    -1,    -1,   506,    -1,   508,    -1,    -1,   511,
     3338      -1,   513,   514,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3339      -1,    -1,    -1,    -1,   526,    -1,    -1,    -1,    -1,    -1,
     3340      -1,    -1,  1341,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3341      -1,    -1,    -1,    -1,    -1,  1354,    -1,  1356,  1357,  1358,
     3342      -1,   222,    -1,   224,   225,   226,    -1,    -1,    -1,  1368,
     3343      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1377,    -1,
     3344      -1,    -1,    -1,    -1,    -1,    -1,   578,    -1,    -1,    -1,
     3345      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   590,   260,
     3346      -1,    -1,   594,    -1,   265,  1404,    -1,    -1,    -1,    -1,
     3347      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   280,
     3348      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   620,    -1,
     3349      -1,    -1,    -1,   625,    -1,    -1,    -1,    -1,    -1,    -1,
     3350      -1,    -1,   634,   635,   636,    -1,    -1,    -1,    -1,    -1,
     3351    1449,  1450,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3352      -1,   653,    -1,  1462,    -1,    -1,    -1,   328,    -1,    -1,
     3353    1469,    -1,    -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,
     3354      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   350,
     3355      -1,    -1,    -1,   685,   355,   356,    -1,    -1,    -1,    -1,
     3356      -1,    -1,   363,  1502,    -1,    -1,    -1,  1506,    -1,    -1,
     3357      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   711,
     3358       7,   713,    92,    10,    11,    12,    13,    14,    -1,    -1,
     3359      -1,    -1,   102,    -1,    -1,    -1,  1535,    -1,  1537,    -1,
     3360      -1,    -1,    -1,    -1,    -1,   406,    -1,    -1,    -1,    -1,
     3361      37,    38,    39,    40,    -1,    -1,   748,    -1,    -1,    -1,
     3362      -1,    -1,    -1,   424,    -1,    -1,  1565,  1566,   429,    -1,
     3363     431,    -1,    -1,    -1,  1573,  1574,    -1,    -1,    -1,    66,
     3364      67,    -1,    -1,    -1,    -1,    72,    -1,   448,   158,    76,
     3365     451,   452,    79,    80,    81,    82,    83,    84,   459,    86,
     3366      87,    -1,   172,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3367      -1,    -1,   473,   805,    -1,    -1,    -1,   809,    -1,   480,
     3368      -1,   813,   109,    -1,   111,   195,    -1,    -1,    -1,    -1,
     3369      -1,   118,   119,   120,   121,   122,   123,    -1,    -1,   209,
     3370      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   218,    -1,
     3371      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   228,    -1,
     3372      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,
     3373      38,    -1,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3374      -1,    -1,    -1,   253,    -1,    -1,    -1,    -1,   258,    -1,
     3375      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    -1,
     3376      -1,   271,    -1,    -1,    72,    -1,    -1,   277,    76,   279,
     3377      -1,    79,    80,    81,    82,    83,    84,   909,    86,    87,
     3378      -1,    -1,    -1,    -1,    -1,    -1,   296,    -1,    -1,    -1,
     3379      -1,    -1,   924,   594,    -1,    -1,    -1,    -1,    -1,    -1,
     3380      -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,   117,
     3381     118,   119,   120,   121,   122,   123,   948,    -1,    -1,    -1,
     3382      -1,   622,    -1,    -1,    -1,    -1,   627,    -1,   338,    -1,
     3383      -1,    -1,   964,   343,    -1,    -1,     3,     4,     5,     6,
     3384       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     3385      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3386      27,    -1,   372,    30,    31,    32,   376,   377,    -1,   379,
     3387      -1,    -1,    39,    -1,    -1,  1007,   386,   387,    -1,   389,
     3388     390,    -1,   392,    -1,   394,    -1,    -1,    -1,    -1,    -1,
     3389      -1,    -1,    -1,    -1,    -1,    -1,  1028,  1029,   699,    -1,
     3390      67,   411,    69,    -1,    71,    -1,    -1,    74,    75,   419,
     3391      -1,    -1,   713,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3392      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3393      37,    38,   733,    40,   444,    -1,    -1,    -1,    -1,    -1,
     3394      -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,
     3395      -1,   118,   119,    -1,    -1,    -1,  1088,    -1,    -1,    66,
     3396     470,    -1,    -1,    -1,    -1,    72,   476,    -1,    -1,    76,
     3397      -1,   481,    79,    80,    81,    82,    83,    84,    -1,    86,
     3398      87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3399      -1,    -1,    -1,    -1,    -1,    -1,   797,    -1,    -1,    -1,
     3400      -1,    -1,   109,    -1,   111,    -1,    -1,   517,   809,   116,
     3401      -1,   118,   119,   120,   121,   122,   123,    -1,    -1,    -1,
     3402      -1,    -1,   532,    -1,    -1,  1157,     0,   828,    -1,     3,
     3403       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
     3404      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
     3405      24,    25,    26,    27,    -1,    -1,    30,    31,    32,    33,
     3406     570,    -1,    36,    -1,    -1,    39,    40,  1199,    -1,   579,
     3407      -1,   156,   157,    -1,    -1,    -1,   586,    -1,    37,    38,
     3408      -1,    40,   592,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3409      64,   601,    -1,    67,    -1,    69,    -1,    71,    72,    -1,
     3410      74,    75,    76,    -1,  1236,   190,    -1,    66,    -1,    83,
     3411      84,    -1,   197,    72,    -1,    -1,    -1,    76,    -1,    -1,
     3412      79,    80,    81,    82,    83,    84,    -1,    86,    87,    -1,
     3413      -1,    -1,   642,    -1,    -1,   109,    -1,   111,    -1,    -1,
     3414      -1,   942,    -1,    -1,   118,   119,    -1,    -1,    -1,    -1,
     3415     109,    -1,   111,    -1,    -1,   114,  1288,  1289,    -1,   118,
     3416     119,   120,   121,   122,   123,  1297,    -1,    -1,   678,    -1,
     3417      -1,    -1,    -1,   974,    -1,    -1,   686,    -1,    -1,    -1,
     3418      -1,    -1,    -1,    -1,   269,    10,    11,    12,    13,    14,
     3419      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     3420      25,    26,    27,    28,    -1,    -1,    -1,   717,    -1,  1010,
     3421      -1,    -1,    -1,    -1,    39,    -1,    -1,   727,   728,    -1,
     3422    1021,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
     3423      -1,   741,    -1,    -1,   147,    -1,    -1,    -1,   323,    -1,
     3424      -1,    -1,    67,    -1,   157,    -1,   331,   332,    -1,   334,
     3425     335,    -1,   762,    78,   764,    66,   169,   170,   768,    -1,
     3426     345,    72,    -1,    -1,   349,    76,    -1,    -1,    79,    80,
     3427      81,    82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,
     3428      -1,  1413,    -1,   368,    -1,    -1,   371,    -1,    -1,    -1,
     3429      -1,    -1,  1093,    -1,    -1,    -1,    -1,    -1,   109,    -1,
     3430     111,    -1,    -1,    -1,    -1,    -1,  1107,   118,   119,   120,
     3431     121,   122,   123,   398,    -1,    -1,    -1,   402,    -1,    -1,
     3432      -1,    -1,   832,    -1,    -1,    -1,    -1,   240,    -1,   839,
     3433      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1471,
     3434      -1,  1473,   852,    -1,   854,    -1,    -1,    -1,   433,    -1,
     3435      -1,   264,    -1,    -1,    -1,    -1,    -1,    -1,   868,    -1,
     3436      -1,    -1,    -1,    -1,    -1,   875,    -1,    -1,    -1,    -1,
     3437      -1,    -1,    -1,    -1,    -1,    -1,  1508,   887,  1510,    -1,
     3438     890,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3439      -1,    -1,    -1,    -1,   479,    -1,    -1,   482,  1199,    -1,
     3440      -1,    -1,    -1,    -1,    -1,    -1,  1538,     4,     5,     6,
     3441       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     3442      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3443      27,    -1,    -1,    30,    31,    32,   521,    -1,    -1,    -1,
     3444     525,   526,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3445      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   969,
     3446      -1,    -1,    -1,    -1,    -1,    -1,    -1,   380,    -1,    -1,
     3447      67,    -1,    69,    -1,    71,    -1,    -1,    74,    75,    -1,
     3448      -1,    -1,    -1,    -1,    -1,   570,   571,    -1,    -1,    -1,
     3449      -1,    -1,    -1,    -1,    -1,  1005,  1297,    -1,    -1,    -1,
     3450      -1,    -1,    -1,    -1,   589,   590,    -1,    -1,    -1,    -1,
     3451      -1,    -1,    -1,   110,   111,   600,    -1,   602,   603,    -1,
     3452      -1,   118,   119,    -1,   609,    -1,    -1,    -1,    -1,    -1,
     3453      -1,    -1,    -1,    -1,   619,   620,    -1,    -1,    -1,    -1,
     3454     625,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   634,
     3455     635,   636,    -1,  1063,    -1,    -1,    -1,    -1,    -1,  1069,
     3456      -1,   474,    -1,    -1,    -1,    -1,    -1,    -1,   653,    -1,
     3457      -1,    -1,    -1,   658,   659,    -1,    -1,   662,   663,    -1,
     3458      -1,    -1,    -1,    -1,   669,    -1,    -1,    -1,    -1,    -1,
     3459      -1,    -1,    -1,  1103,    -1,    -1,    -1,    -1,  1108,    -1,
     3460     513,    -1,    -1,   688,    -1,    -1,  1116,    -1,    -1,    -1,
     3461      -1,    -1,    -1,   526,    -1,    -1,    -1,    -1,   531,    -1,
     3462      -1,   534,    -1,    -1,    -1,    -1,   711,   712,    -1,    -1,
     3463      -1,    -1,    -1,   546,    -1,    -1,    -1,    -1,    -1,    -1,
     3464      -1,    -1,  1152,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3465      -1,    -1,    -1,    -1,  1164,   568,    -1,  1167,    -1,  1169,
     3466      -1,    -1,   747,   748,    -1,   578,    -1,   752,   753,    -1,
     3467      -1,    -1,   585,  1183,  1184,    -1,    -1,   590,    -1,    -1,
     3468      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3469      -1,    -1,    -1,    -1,    -1,  1205,    -1,    -1,    -1,    -1,
     3470      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3471      -1,    -1,   797,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3472     805,    -1,    -1,    -1,    -1,    -1,   639,   812,   813,    -1,
     3473      -1,   816,    -1,   818,    -1,   648,    -1,    -1,    -1,    -1,
     3474      -1,    -1,    -1,   828,  1254,    -1,    -1,    -1,    -1,    -1,
     3475      -1,    -1,  1553,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3476      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
     3477      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3478      21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
     3479      31,    32,    33,    -1,    -1,    36,    -1,    -1,    39,    -1,
     3480      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3481      -1,    -1,    -1,    -1,    -1,    -1,   901,    -1,    -1,    -1,
     3482    1330,    -1,  1332,   908,   909,   910,    67,   912,    69,    -1,
     3483      71,   916,    -1,    74,    75,   748,  1346,   750,  1348,    -1,
     3484      -1,    -1,    -1,    -1,    -1,    -1,    -1,   760,    -1,    -1,
     3485      -1,    -1,   937,   938,   767,    -1,  1366,    -1,    -1,    -1,
     3486      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3487     111,    -1,  1382,  1383,    -1,    -1,    -1,   118,   119,   964,
     3488      -1,    -1,    -1,  1393,    -1,    -1,  1396,    -1,    -1,   974,
     3489      -1,    -1,    -1,    -1,    -1,    -1,   809,   810,    -1,    -1,
     3490     813,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1419,
     3491      -1,   996,   997,    -1,   827,    -1,    -1,    -1,  1428,    -1,
     3492      -1,  1431,  1007,  1433,  1434,  1435,    -1,    -1,  1013,  1014,
     3493      -1,  1016,  1017,  1018,    -1,    -1,    -1,    -1,    -1,   283,
     3494      -1,   285,   286,  1028,  1029,    37,    38,    -1,    40,   293,
     3495     294,    -1,    -1,    -1,   867,    -1,    -1,    -1,   871,    -1,
     3496      -1,    -1,    -1,   307,   308,  1475,    -1,  1477,    -1,  1479,
     3497      -1,    -1,    -1,    -1,    66,    -1,    -1,    -1,    -1,    -1,
     3498      72,    -1,    -1,    -1,    76,  1495,    -1,    79,    80,    81,
     3499      82,    83,    84,    -1,    86,    87,   909,    -1,    -1,    -1,
     3500      -1,   345,    -1,    -1,    -1,    -1,  1091,    -1,  1093,    -1,
     3501      -1,    -1,    -1,  1098,    -1,    -1,    -1,   109,    -1,   111,
     3502      -1,    -1,  1107,    -1,    -1,    -1,   118,   119,   120,   121,
     3503     122,   123,    -1,    -1,    -1,   948,    -1,   381,    -1,    -1,
     3504      -1,    -1,    -1,    -1,    -1,    -1,    -1,  1132,  1133,  1134,
     3505      -1,   964,   965,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3506      -1,    -1,    -1,    -1,    -1,   978,    -1,    -1,    -1,    -1,
     3507      -1,   984,  1157,    -1,   987,    -1,   989,    -1,    10,    11,
    29133508      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
    2914       22,    23,    24,    25,     0,     0,    26,    27,    28,     0,
    2915        0,     0,     0,     0,     0,    31,     0,   284,   285,     0,
    2916      286,  1051,     0,  1052,  1419,  1420,  1053,  1054,  1055,  1056,
    2917     1057,  1058,  1059,  1060,     0,     0,  1549,  1061,     0,     0,
    2918        0,  1062,  1063,    34,    33,    35,   287,    36,     0,     0,
    2919       38,    39,  1064,     0,     0,     0,   289,     0,     0,   290,
    2920      291,   292,   293,    41,    42,     0,   294,   295,     0,     0,
    2921        0,     0,  1327,     0,    43,     0,     0,     0,     0,     0,
    2922        0,     0,     0,     0,     0,     0,     0,     0,     0,   296,
    2923        0,   380,     0,     0,   173,     0,     0,     0,    46,    47,
    2924      298,   299,   300,   301,     0,     0,   284,   285,  1066,   286,
    2925     1051,     0,  1052,  1419,  1420,  1053,  1054,  1055,  1056,  1057,
    2926     1058,  1059,  1060,     0,     0,     0,  1061,     0,     0,     0,
    2927     1062,  1063,     0,    33,     0,   287,     0,     0,     0,     0,
    2928        0,  1064,     0,     0,     0,   289,     0,     0,   290,   291,
    2929      292,   293,    41,    42,     0,   294,   295,     0,     0,     0,
    2930        0,     0,     0,    43,     0,     0,     0,     0,     0,     0,
    2931        0,     0,     0,     0,     0,     0,     0,     0,   296,     0,
    2932      380,     0,     0,   173,     0,     0,     0,    46,    47,   298,
    2933      299,   300,   301,     0,     0,   284,   285,  1066,   286,  1051,
    2934        0,  1052,     0,     0,  1053,  1054,  1055,  1056,  1057,  1058,
    2935     1059,  1060,     0,     0,     0,  1061,     0,     0,     0,  1062,
    2936     1063,     0,    33,     0,   287,     0,     0,     0,     0,     0,
    2937     1064,     0,     0,     0,   289,     0,     0,   290,   291,   292,
    2938      293,    41,    42,     0,   294,   295,     0,     0,     0,     0,
    2939        0,     0,    43,   284,   285,     0,   286,     0,     0,     0,
    2940        0,     0,     0,     0,     0,     0,     0,   296,     0,   380,
    2941        0,     0,   173,     0,     0,     0,    46,    47,   298,   299,
    2942      300,   301,   287,     0,     0,     0,  1066,     0,   641,     0,
    2943      141,   142,   289,     0,     0,   290,   642,   292,   293,    41,
    2944       42,     0,   294,   295,     0,     0,     0,     0,     0,     0,
    2945       43,   284,   285,     0,   286,     0,     0,     0,     0,     0,
    2946        0,     0,     0,     0,     0,   296,     0,   643,     0,   644,
    2947      381,     0,     0,     0,    46,    47,   298,   299,   300,   301,
    2948      287,     0,     0,     0,     0,     0,   288,     0,     0,     0,
    2949      289,     0,     0,   290,   291,   292,   293,    41,    42,     0,
    2950      294,   295,     0,     0,     0,     0,     0,     0,    43,   284,
    2951      285,     0,   286,     0,     0,     0,     0,     0,     0,     0,
    2952        0,     0,     0,   296,     0,   380,     0,     0,   284,   285,
    2953        0,   286,   710,    47,   298,   299,   300,   301,   287,     0,
    2954        0,     0,     0,     0,   641,     0,     0,     0,   289,     0,
    2955        0,   290,   291,   292,   293,    41,    42,   287,   294,   295,
    2956        0,     0,     0,   288,     0,     0,    43,   289,     0,     0,
    2957      290,   291,   292,   293,    41,    42,     0,   294,   295,     0,
    2958        0,   296,     0,   765,     0,    43,   284,   285,     0,   286,
    2959       46,    47,   298,   299,   300,   301,     0,     0,     0,     0,
    2960      296,     0,   380,     0,     0,   284,   285,     0,   286,   345,
    2961       47,   298,   299,   300,   301,   287,     0,     0,     0,     0,
    2962        0,   288,     0,     0,     0,   289,     0,     0,   290,   291,
    2963      292,   293,    41,    42,   287,   294,   295,     0,     0,     0,
    2964      288,     0,     0,    43,   289,     0,     0,   290,   291,   292,
    2965      293,    41,    42,     0,   294,   295,     0,     0,   512,     0,
    2966        0,     0,    43,     0,     0,     0,     0,    46,    47,   298,
    2967      299,   300,   301,     0,     0,     0,     0,   515,     0,     0,
    2968        0,     0,     0,     0,     0,     0,    46,    47,   298,   299,
    2969      300,   301,     2,   208,     4,     5,     6,     7,     8,     9,
    2970       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
    2971       20,    21,    22,    23,    24,    25,     0,     0,     0,     0,
    2972        0,     0,     0,     0,     0,     0,     0,    31,     0,     0,
    2973        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2974        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2975        0,     0,     0,     0,     0,    34,     0,    35,     0,    36,
    2976       37,     0,   176,   177,    40,     0,     0,     0,     0,     0,
    2977        0,    41,    42,   207,     2,   208,     4,     5,     6,     7,
    2978        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
    2979       18,    19,    20,    21,    22,    23,    24,    25,     0,     0,
    2980       26,    27,    28,     0,     0,     0,     0,     0,     0,    31,
    2981        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2982        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2983        0,     0,     0,     0,     0,     0,     0,    34,     0,    35,
    2984        0,    36,     0,     0,   209,    39,   468,     2,   208,     4,
     3509      22,    23,    24,    25,    26,    27,    28,  1010,    30,    31,
     3510      32,    -1,    -1,    -1,    -1,    -1,    -1,    39,  1021,    -1,
     3511      37,    38,    -1,    40,    -1,    -1,    -1,    -1,    -1,    -1,
     3512      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3513    1043,    -1,  1045,  1218,    -1,    67,    -1,    -1,    -1,    66,
     3514      -1,    -1,    74,    75,    -1,    72,    78,  1060,  1061,    76,
     3515      -1,  1236,    79,    80,    81,    82,    83,    84,    -1,    86,
     3516      87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1081,    -1,
     3517      -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,   111,
     3518      -1,    -1,   109,    -1,   111,    -1,   118,   119,    -1,    -1,
     3519      -1,   118,   119,   120,   121,   122,   123,    -1,    -1,    -1,
     3520      -1,    -1,    -1,  1288,  1289,   549,   550,   551,   552,   553,
     3521     554,   555,   556,   557,   558,   559,   560,   561,   562,   563,
     3522     564,   565,   566,    -1,    -1,  1138,    -1,    -1,    -1,    -1,
     3523      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3524      -1,    -1,    -1,    -1,  1157,    -1,    -1,    -1,    -1,    -1,
     3525      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1172,
     3526    1173,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3527      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
    29853528       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    29863529      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    2987       25,     0,     0,    26,    27,    28,     0,     0,     0,     0,
    2988        0,     0,    31,     0,     0,     0,     0,     0,     0,     0,
    2989        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2990        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2991       34,     0,    35,     0,    36,     0,     0,    38,    39,     2,
    2992      208,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    2993       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    2994       23,    24,    25,     0,     0,    26,    27,    28,     0,     0,
    2995        0,     0,     0,     0,    31,     0,     0,     0,     0,     0,
    2996        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2997        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    2998        0,     0,    34,     0,    35,     0,    36,     0,     0,   209,
    2999       39
    3000 };
    3001 
    3002 #define yypact_value_is_default(yystate) \
    3003   ((yystate) == (-1414))
    3004 
    3005 #define yytable_value_is_error(yytable_value) \
    3006   YYID (0)
    3007 
    3008 static const yytype_int16 yycheck[] =
    3009 {
    3010        0,     1,    44,   187,   187,   535,   187,     0,    44,   753,
    3011      187,    44,   206,   241,   648,   187,   522,   753,   188,   881,
    3012        1,   753,   107,   221,   118,   187,   187,   514,   621,   170,
    3013      171,   350,    32,     0,   986,   760,     0,   189,   603,    32,
    3014      350,   601,   601,   493,    44,   188,   281,   497,    44,   993,
    3015       50,    39,  1337,   604,    44,  1419,   603,    50,    44,   610,
    3016      601,   572,    51,    32,    64,    32,    72,    67,    32,    82,
    3017       70,    64,   157,   601,    67,    95,  1050,    70,    39,   346,
    3018      419,    44,    45,   267,   267,  1031,   267,   694,   601,    70,
    3019      267,    63,   107,   601,    50,   267,   296,   110,   268,  1043,
    3020      439,  1062,  1063,   601,   117,   267,   267,   107,   447,   203,
    3021      130,   263,   264,  1526,    39,   115,   131,    82,   118,   119,
    3022      109,   109,    67,   111,    39,   268,   132,    64,   483,  1493,
    3023       72,  1030,  1031,  1546,    39,    44,    45,    39,   365,    84,
    3024     1553,   735,   369,   636,   637,   187,   427,   428,   148,   149,
    3025      111,   187,   115,   881,   187,  1440,   149,   157,   158,   115,
    3026      132,   654,   162,   635,   636,   637,     0,   258,   912,   162,
    3027      489,    28,   109,    39,   119,    82,   912,     0,     1,  1140,
    3028      912,   112,   654,   689,   109,   116,   111,   187,   188,    72,
    3029      132,   187,   148,   110,   109,   188,   111,   187,    32,   116,
    3030        0,   187,    82,   203,   109,   114,   111,   720,    82,    32,
    3031      117,   211,   720,   411,   495,    96,   483,   162,   211,   712,
    3032       82,    78,   720,   223,     0,   267,    58,   427,   428,   109,
    3033      223,   267,    32,   514,   267,   118,   110,   407,   115,   116,
    3034      712,   241,   123,   109,    67,   111,    85,    70,   109,   111,
    3035      111,   109,    67,   253,   131,   211,    32,   342,   818,   818,
    3036      253,   261,   109,  1423,   407,   830,   266,   267,   268,   820,
    3037        1,   996,   283,   273,   113,   268,   108,   818,   223,   111,
    3038      635,   636,   637,   830,   253,   241,   253,   372,   799,   253,
    3039      818,    67,  1238,   603,     0,     1,   296,   931,   579,   654,
    3040      907,    11,  1254,   397,   119,   818,     1,   507,   308,   116,
    3041      818,   481,   512,   109,   807,   515,   261,   273,   491,    50,
    3042      818,   266,  1050,  1475,   324,   132,    32,   109,   419,   329,
    3043     1304,   425,    44,    45,   230,   807,   329,   431,   481,   112,
    3044       80,   112,   342,   116,   683,  1291,   346,   162,   439,   131,
    3045      350,   351,   308,   249,   621,    82,   447,   712,  1510,   626,
    3046     1512,  1521,  1224,   590,    70,   365,  1526,   116,   568,   369,
    3047      697,   111,   372,   113,    96,   940,   107,   117,   110,   939,
    3048      939,   110,   109,   132,   115,   117,  1546,   116,   220,   110,
    3049      346,  1290,  1291,  1553,   749,  1526,   117,   397,   939,   131,
    3050      223,   123,   114,    90,    91,   632,   351,   407,   223,    10,
    3051       11,    12,    13,    14,   407,   114,  1009,   148,   116,   253,
    3052       94,     0,  1553,    80,   258,   425,   157,   427,   428,  1125,
    3053      253,   431,   605,  1129,   434,   109,   609,   111,    39,   126,
    3054      127,   526,   274,   116,   118,   119,   261,   223,   129,   281,
    3055      131,   266,   807,   253,   111,   455,   113,   630,   258,   132,
    3056      117,   634,   116,  1407,  1408,  1059,    67,  1018,  1019,  1415,
    3057      976,   427,   428,   473,     3,   112,   207,   253,   132,   116,
    3058      211,   481,   749,   483,   116,   485,   697,   432,   481,   489,
    3059     1464,    72,   485,     0,   505,   495,  1224,  1471,   948,   734,
    3060      132,   116,    83,    84,   991,  1139,   658,   507,   649,   509,
    3061      241,   830,   512,     3,   514,   515,  1415,   349,   485,   689,
    3062      830,   485,   522,     0,   116,    32,   526,   527,   110,   474,
    3063      111,   109,   116,   111,   366,   117,   351,    44,   370,   495,
    3064      132,    72,   273,    50,  1109,   276,   689,   253,   132,    94,
    3065     1524,   112,    83,    84,   116,   116,   911,    64,   514,   254,
    3066       67,  1496,   656,    70,   109,   296,   111,  1502,   116,   109,
    3067      132,   571,   572,   118,   119,   351,  1304,   308,   131,   579,
    3068      111,   792,   809,    94,   132,   419,   913,   814,  1523,  1095,
    3069      590,   591,   683,  1528,  1100,   595,   116,   917,   109,   919,
    3070      111,   601,   110,   603,   116,   439,   116,   118,   119,   110,
    3071      110,   342,   132,   447,   116,   346,   116,   432,   709,   419,
    3072      132,   621,   132,   579,   116,   944,   626,   591,   628,   112,
    3073      132,   958,   632,   116,   365,   635,   636,   637,   369,   439,
    3074      132,   372,   149,   109,   911,   111,   110,   447,   112,   483,
    3075      595,   485,   116,   109,   654,   162,   656,   668,   869,   474,
    3076      110,    72,   485,   748,   109,   621,   116,   131,   132,   867,
    3077      626,   110,    83,    84,    50,  1030,   903,   116,   623,   852,
    3078      187,   188,    72,   628,   109,   485,   686,   109,   110,   689,
    3079      888,   120,   121,    83,    84,   110,   427,   428,   474,    71,
    3080      111,   116,   913,    75,   211,   109,    78,   111,    80,   485,
    3081     1304,   118,   712,   713,   714,    87,   223,   124,   125,   109,
    3082      720,   721,   950,   109,   455,   111,   109,   738,   912,   912,
    3083      109,   912,   873,    88,    89,   912,  1464,   468,   109,   115,
    3084      912,   110,  1009,  1471,   914,   110,   253,   958,   748,   749,
    3085      912,   912,   110,   753,   754,   700,    72,   110,    74,    75,
    3086      267,   112,   493,    72,   495,   109,   497,    83,    84,   714,
    3087      109,   914,   945,   468,    83,    84,   507,    72,   509,   485,
    3088      595,   512,   115,   514,   515,   996,  1530,  1381,    83,    84,
    3089      622,  1321,   115,   116,  1530,   526,  1524,   110,  1530,   799,
    3090     1127,   109,   111,   116,  1159,   132,   638,   807,   623,   809,
    3091      110,   811,    64,   628,   814,   815,   116,   110,   818,   514,
    3092      109,   653,   329,   116,   507,   910,   509,   110,  1022,   512,
    3093      830,   109,   515,   116,   529,   211,  1047,   532,   112,   534,
    3094      535,   132,   214,   350,    85,    86,    87,   623,   579,   683,
    3095       72,   815,    74,    75,   110,   557,   558,   559,   560,   590,
    3096      116,    83,    84,  1190,  1191,   110,   811,   109,   109,   111,
    3097      111,   116,   113,   114,  1468,   709,  1470,   114,   110,   114,
    3098      110,   881,   132,   683,   116,   700,   116,   110,   583,   111,
    3099      621,   109,  1159,   116,   109,   626,   111,   273,   132,   714,
    3100      407,   632,   734,   903,  1045,   465,   109,  1134,   111,   709,
    3101      910,   911,   912,   110,   914,   749,  1127,   881,   114,   116,
    3102      296,   110,   110,   110,   700,  1095,   926,   116,   116,   116,
    3103     1100,  1525,   308,    82,   109,  1290,   111,   109,   714,   939,
    3104      940,    85,    86,    87,   944,   109,   110,   111,   109,   949,
    3105      950,    82,  1095,    92,    93,   686,   112,  1100,     0,     1,
    3106      655,   119,   657,   116,   117,   109,   966,   111,   949,   113,
    3107      114,  1238,   129,    72,   110,   111,   976,    76,   485,  1190,
    3108     1191,   353,   489,   355,    83,    84,   128,    29,    30,   465,
    3109       32,    58,    59,   724,   950,    94,   811,   115,   116,  1505,
    3110      116,   117,    44,  1203,  1204,    94,  1206,   131,    50,  1009,
    3111      109,   111,   707,  1213,   109,  1215,    58,   748,   109,   118,
    3112      119,   114,    64,  1117,   112,    67,   116,   117,    70,   112,
    3113     1030,  1031,   109,   110,   111,   811,     4,     5,     6,     7,
    3114        8,     9,    84,    85,   109,   110,   111,   881,   112,  1555,
    3115     1050,    44,    45,  1009,   109,   110,   111,   110,   881,    10,
    3116       11,    12,    13,    14,   553,   554,   108,  1012,   109,   111,
    3117       30,   443,   110,   110,  1401,   110,   118,   911,   809,   455,
    3118      110,   881,   110,   814,   555,   556,  1050,   112,    39,   111,
    3119     1090,   131,  1419,   116,   601,  1095,   603,    58,    59,    60,
    3120     1100,    69,   114,    71,   114,   881,   109,   149,   112,  1109,
    3121      561,   562,   672,   110,  1125,   157,    67,  1117,  1129,  1130,
    3122      162,  1263,  1264,  1265,    84,    85,   949,   110,   112,   117,
    3123      112,   507,   112,   509,  1134,  1220,   512,   112,   117,   515,
    3124        3,   117,   116,    94,    29,   187,   188,    10,    11,    12,
    3125       13,    14,   110,   110,   116,   114,   112,   112,   109,  1159,
    3126      111,   203,   115,   110,   132,  1492,  1493,   118,   119,   211,
    3127      115,   115,   903,   109,   116,   881,    39,  1377,   220,   910,
    3128      110,   223,   689,   132,   110,   110,   117,   110,   230,   110,
    3129     1401,   110,   116,   110,   110,   926,   672,  1012,   110,   110,
    3130      110,  1201,  1202,   245,    67,   110,   110,   249,  1419,   110,
    3131      110,   253,   254,   720,   721,   110,  1050,   948,   949,   950,
    3132     1220,  1202,   110,   110,  1224,   267,   268,  1050,   110,    72,
    3133       29,   115,   274,    76,   131,   795,  1012,  1248,  1238,   281,
    3134       83,    84,  1242,   949,   117,   805,    72,   116,    74,    75,
    3135     1050,    94,    72,   110,    74,    75,  1201,    83,    84,   819,
    3136     1224,  1242,   112,    83,    84,   112,   109,   116,   111,   964,
    3137      110,   110,   110,   117,  1050,   118,   119,   112,  1009,   116,
    3138      114,  1492,  1493,   109,   116,   245,   110,   329,   114,   109,
    3139     1290,  1291,   110,   988,   114,   110,   991,   110,   993,  1299,
    3140      112,   110,   116,  1397,  1304,   116,     3,   349,   350,   110,
    3141      686,   818,  1540,    10,    11,    12,    13,    14,   112,   795,
    3142      109,   109,   109,   830,   366,  1159,   109,  1338,   370,   805,
    3143      109,  1342,   117,   115,   112,   132,   110,  1337,   110,   381,
    3144     1304,   110,    39,   819,  1050,   115,  1530,  1530,  1043,  1530,
    3145      115,   114,   129,  1530,  1299,   397,  1337,   112,  1530,  1090,
    3146      110,  1531,   116,   112,   132,   407,   112,   110,  1530,  1530,
    3147       67,     4,     5,     6,     7,     8,     9,   116,  1201,  1202,
    3148      110,   110,    47,   425,   112,  1555,  1201,   112,  1531,   431,
    3149     1224,   433,   112,   110,   112,   132,   112,  1397,   112,   132,
    3150       33,  1224,   115,  1134,  1238,   912,    72,   914,    74,    75,
    3151       76,  1505,  1555,   132,   110,  1415,   115,    83,    84,  1242,
    3152      132,   381,   132,   117,  1224,  1201,   468,   110,   112,   115,
    3153      112,   473,   112,  1444,   112,    56,    69,   944,    71,   481,
    3154     1440,   112,   112,   485,   112,   112,   110,   489,  1224,   110,
    3155      492,   109,   494,   881,    72,   112,    74,    75,    76,  1440,
    3156      112,   109,   109,    60,  1464,    83,    84,  1027,  1028,   110,
    3157     1304,  1471,   514,  1473,   110,  1475,  1299,   114,    99,   132,
    3158      112,  1304,   117,   112,  1299,   110,   112,   529,  1530,  1220,
    3159      532,   109,   534,   535,  1530,   110,  1202,  1530,    96,   109,
    3160     1464,    96,   109,   115,  1304,  1505,   112,  1471,   132,   110,
    3161     1510,  1242,  1512,   116,  1337,    42,   110,   110,  1224,   110,
    3162      110,   117,   110,  1299,  1524,  1085,  1086,   132,  1304,    96,
    3163     1530,  1531,   492,   132,   494,     3,  1242,    96,  1531,   110,
    3164     1540,   583,    10,    11,    12,    13,    14,   132,   590,   132,
    3165      926,  1027,  1028,   117,    72,  1555,   110,     0,    76,   601,
    3166     1524,   603,  1555,   286,  1396,    83,    84,   132,  1263,  1264,
    3167     1265,    39,   110,   110,   195,   115,    94,   112,   112,   132,
    3168      622,   109,   132,   115,  1540,   308,   309,   110,  1095,    32,
    3169      115,   109,    72,  1100,    74,    75,   638,   218,  1304,    67,
    3170      118,   119,   644,    83,    84,   110,  1337,   228,   132,  1085,
    3171     1086,   653,   110,   655,   656,   657,   110,  1440,  1066,   565,
    3172      563,  1224,  1493,   346,   564,  1053,  1321,    70,   566,  1383,
    3173     1464,  1337,   567,  1565,   114,  1314,  1130,  1471,  1342,  1081,
    3174     1471,  1464,   686,   686,   919,  1100,   927,   689,  1471,   699,
    3175      583,   693,   980,   695,   873,   650,   724,   699,   946,   382,
    3176       50,   734,  1242,   485,  1464,   707,    -1,    26,    27,    28,
    3177       -1,  1471,   571,   571,    64,   296,  1236,    67,   720,   721,
    3178       70,   571,    -1,    -1,   644,    -1,    -1,    -1,  1464,    -1,
    3179     1524,    -1,   734,    -1,    -1,  1471,    72,    -1,    74,    75,
    3180       76,  1524,    -1,    58,    -1,     0,     1,    83,    84,  1440,
    3181       -1,  1271,  1407,  1408,  1090,   158,    -1,    -1,    -1,  1279,
    3182     1280,  1281,    -1,    -1,  1524,     4,     5,     6,     7,     8,
    3183        9,    -1,    -1,   693,  1440,   695,    -1,    32,    -1,   699,
    3184       -1,   100,  1473,   102,  1475,    -1,    -1,    -1,  1524,    -1,
    3185     1445,    -1,    -1,   108,    -1,    50,   111,    -1,  1464,   149,
    3186     1236,    67,    -1,    -1,    -1,  1471,   191,    -1,    -1,    -1,
    3187       -1,    77,   162,   198,    -1,    70,   818,    -1,    -1,  1510,
    3188       -1,  1512,    -1,    -1,    -1,  1345,    -1,    -1,   830,   232,
    3189       69,    -1,    71,    -1,    -1,  1271,  1224,    -1,   188,    -1,
    3190       -1,    -1,   157,  1279,  1280,  1281,    -1,    -1,    -1,  1540,
    3191      253,  1506,   107,   119,    -1,   258,    -1,    -1,  1524,    -1,
    3192     1515,   211,    -1,   444,   183,    -1,    -1,   550,   551,   552,
    3193       -1,   873,    -1,   223,   193,   194,    -1,    -1,   880,   198,
    3194       -1,   200,   201,    -1,    -1,   270,    -1,    -1,    72,   470,
    3195       74,    75,    76,    -1,   149,    -1,   162,    -1,    -1,    83,
    3196       84,   903,   157,   158,    -1,   220,    -1,    -1,    -1,  1345,
    3197      912,    -1,   914,    -1,    -1,    -1,    -1,    -1,    72,   921,
    3198       74,    75,    76,    -1,    -1,   109,   507,    -1,    -1,    83,
    3199       84,   512,  1320,   188,   515,    -1,    -1,    -1,    -1,   324,
    3200       94,    -1,   944,    -1,    -1,    -1,    -1,   332,   203,   352,
    3201      335,   206,   207,   873,    -1,   109,   211,   223,    -1,   274,
    3202      880,    -1,   964,    -1,   118,   119,   281,    -1,    -1,    -1,
    3203       -1,    -1,    -1,    -1,    -1,    -1,    -1,   232,   980,   329,
    3204       -1,   236,    -1,   238,    -1,    -1,   988,  1375,    -1,   991,
    3205     1378,   993,   247,    -1,    -1,   261,    -1,    -1,   253,    -1,
    3206      266,   921,    -1,   258,    -1,    -1,    -1,    -1,   672,    -1,
    3207       -1,    -1,    -1,   268,   399,   281,   419,    -1,   403,    -1,
    3208       -1,   276,    -1,    -1,    10,    11,    12,    13,    14,    -1,
    3209       -1,   434,    -1,    -1,   349,  1423,   439,    -1,    -1,    -1,
    3210     1428,  1043,    -1,    -1,   447,    10,    11,    12,    13,    14,
    3211       -1,   366,    -1,    39,    -1,   370,    -1,   407,    -1,    -1,
    3212      980,    -1,   465,  1530,    -1,    -1,    -1,    -1,    -1,    -1,
    3213     1458,    -1,    -1,    -1,    39,    -1,    -1,   760,    -1,  1081,
    3214      483,    67,   485,    -1,    -1,   351,    -1,   342,    -1,    -1,
    3215      671,   346,    -1,  1095,    -1,   480,    -1,   352,  1100,   680,
    3216       -1,    -1,    67,   684,    -1,    -1,    -1,    -1,    94,    -1,
    3217      365,    -1,    -1,    -1,   369,  1117,    -1,   372,   433,    -1,
    3218       -1,    -1,    -1,   109,   527,   111,    -1,    -1,    -1,    94,
    3219       -1,   795,   118,   119,    -1,    -1,    -1,  1473,    -1,  1475,
    3220       -1,   805,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,
    3221       -1,    -1,    -1,   118,   119,   819,  1544,    -1,    -1,    -1,
    3222       -1,  1081,  1550,    -1,   419,    -1,   432,    -1,    -1,    -1,
    3223       -1,    -1,    -1,  1561,  1510,    -1,  1512,  1565,    72,   434,
    3224       74,    75,    76,   449,   439,    -1,   571,   572,   591,    83,
    3225       84,    -1,   447,    -1,    72,  1197,    74,    75,    76,    -1,
    3226       94,    -1,    -1,     0,    -1,    83,    84,    -1,   474,    -1,
    3227      465,    -1,    -1,   468,    -1,   109,    94,   111,  1220,    -1,
    3228       -1,    -1,    -1,   117,   118,   119,    -1,    -1,   483,    -1,
    3229      485,   109,   635,   636,   637,    32,    -1,    -1,   493,    -1,
    3230      118,   119,   497,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3231       -1,   654,    -1,    -1,    -1,    -1,   575,   576,    -1,    -1,
    3232       -1,  1263,  1264,  1265,    -1,    -1,    -1,    -1,    -1,   672,
    3233       -1,   526,   527,    70,   659,   590,    -1,  1197,   663,    -1,
    3234      683,    -1,    -1,    -1,    -1,   604,    -1,    -1,   607,   608,
    3235       -1,   610,    -1,   612,   613,    -1,    -1,    -1,   617,   618,
    3236       -1,    -1,    -1,    -1,    -1,    -1,   709,   622,    -1,   712,
    3237       -1,    -1,    -1,    -1,    -1,    -1,    -1,   572,     0,  1321,
    3238       -1,    -1,    -1,   638,   905,    -1,  1009,    -1,    -1,   595,
    3239       -1,    -1,    -1,    -1,    -1,   590,   591,    -1,   653,    -1,
    3240       -1,    -1,    -1,     0,     1,    -1,   749,    -1,   603,    -1,
    3241       32,    -1,    -1,    -1,    -1,    -1,    -1,   623,    -1,    -1,
    3242       -1,   158,   628,  1027,  1028,    -1,   621,  1050,    -1,    -1,
    3243       -1,   626,    -1,    -1,    -1,    32,    -1,   632,    -1,    -1,
    3244      635,   636,   637,    -1,    -1,    -1,    -1,    -1,    70,    -1,
    3245       -1,    -1,   795,    -1,  1396,  1397,    -1,    -1,    -1,   654,
    3246       -1,    -1,   805,    -1,   807,  1407,  1408,    -1,    -1,   812,
    3247       67,    -1,   815,    70,   799,    -1,   819,   672,    -1,   734,
    3248       -1,  1085,  1086,    -1,    -1,    -1,    -1,    -1,   683,    -1,
    3249       -1,    -1,    -1,    -1,   700,    -1,    -1,    -1,    -1,   758,
    3250      759,    -1,    -1,  1445,    -1,    -1,    -1,    -1,   714,    -1,
    3251       -1,    -1,    -1,    -1,   709,    -1,   253,   712,    -1,    -1,
    3252       -1,   258,    -1,    -1,    -1,    -1,   721,    -1,   734,   724,
    3253       72,    -1,    74,    75,    76,    -1,   158,    -1,   881,    -1,
    3254     1061,    83,    84,    -1,    72,    -1,    74,    75,    76,    -1,
    3255       -1,    -1,    94,   748,   749,    83,    84,    -1,    -1,   754,
    3256       -1,   158,    -1,  1505,  1506,    -1,    94,   109,   911,   111,
    3257       -1,    -1,    -1,  1515,    -1,    -1,   118,   119,    -1,    -1,
    3258       -1,   109,    -1,   111,    -1,    -1,    -1,    -1,  1530,  1531,
    3259      118,   119,    -1,   918,    -1,    -1,    -1,    -1,    -1,    -1,
    3260      795,    -1,    -1,    -1,    -1,   811,    -1,    -1,    -1,    -1,
    3261      805,    -1,   807,  1555,   809,   352,    -1,   812,    -1,   814,
    3262      815,    -1,    -1,   966,   819,    -1,   223,    -1,    -1,    -1,
    3263       -1,   253,    -1,    -1,   829,    -1,   258,    97,    98,    99,
    3264      100,   101,   102,   103,   104,   105,   106,    -1,   903,    -1,
    3265       -1,    -1,    -1,    -1,    -1,    -1,   253,    72,    -1,    74,
    3266       75,    76,    -1,    -1,   923,    -1,    -1,  1271,    83,    84,
    3267       -1,   131,    -1,   998,    -1,  1279,  1280,  1281,    -1,    94,
    3268       -1,    -1,   419,    -1,  1027,  1028,   881,  1030,  1031,    -1,
    3269     1015,    -1,    -1,    -1,   109,    -1,   111,   434,    -1,    -1,
    3270       -1,    -1,   439,   118,   119,    -1,    -1,  1050,   903,    -1,
    3271      447,    -1,    -1,    -1,    -1,   910,   911,    -1,    -1,   914,
    3272       -1,    10,    11,    12,    13,    14,    -1,    -1,   465,    -1,
    3273      352,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3274       -1,  1345,  1085,  1086,    -1,   940,   483,    -1,   485,    -1,
    3275       39,    -1,    -1,   948,   949,    -1,    -1,    -1,    -1,    -1,
    3276       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1093,    -1,
    3277       -1,   966,    -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,
    3278       -1,    -1,    -1,    72,    -1,    74,    75,    76,    -1,    -1,
    3279      527,    -1,  1313,    -1,    83,    84,    -1,   419,    -1,    -1,
    3280       -1,    -1,    -1,    -1,    -1,    94,  1012,    -1,    -1,    -1,
    3281     1135,    -1,   434,    -1,  1009,    -1,  1159,   439,    -1,    -1,
    3282      109,    -1,   111,    -1,    -1,   447,    -1,  1022,  1087,   118,
    3283      119,    -1,  1027,  1028,    -1,  1030,  1031,   434,    -1,    -1,
    3284       -1,    -1,    -1,   465,    -1,    -1,    -1,    -1,    -1,    -1,
    3285       -1,    -1,    -1,    -1,   591,  1050,    -1,    -1,    -1,  1202,
    3286       -1,   483,    -1,   485,    -1,    -1,    -1,    -1,    -1,    -1,
     3530      25,    26,    27,    -1,    -1,    30,    31,    32,    33,    -1,
     3531      -1,    36,    37,    38,    39,    40,    -1,    -1,    -1,    -1,
     3532      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1413,    -1,
     3533      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1252,
     3534      -1,    66,    67,    -1,    69,    -1,    71,    72,    -1,    74,
     3535      75,    76,   696,    -1,    79,    80,    81,    82,    83,    84,
     3536      -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    32873537      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3288       -1,  1224,    -1,    -1,    -1,    -1,    -1,    -1,   485,    -1,
    3289     1085,  1086,    -1,  1236,    -1,  1238,    -1,    -1,   635,   636,
    3290      637,    -1,    -1,    -1,    -1,   527,    -1,    -1,    -1,    -1,
    3291       -1,    -1,    -1,    -1,    -1,    -1,    -1,   654,    -1,    -1,
    3292       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1271,    -1,
    3293      527,    -1,    -1,    -1,     0,   672,  1279,  1280,  1281,  1134,
    3294       -1,    -1,    -1,    -1,    -1,    -1,   683,  1290,  1291,    -1,
    3295       -1,  1472,    -1,  1474,    -1,    -1,    -1,    -1,    -1,    -1,
    3296     1219,  1304,    -1,    -1,  1159,  1220,    32,    -1,    -1,   591,
    3297       -1,    -1,   709,    -1,    -1,   712,    -1,    -1,    -1,    -1,
    3298       10,    11,    12,    13,    14,    -1,    -1,    -1,  1509,    -1,
    3299     1511,    -1,    -1,    -1,   591,  1201,    -1,    -1,    -1,    -1,
    3300       -1,    -1,  1345,    -1,    70,    -1,    -1,  1202,    -1,    39,
    3301       -1,    -1,   749,   635,   636,   637,    -1,    -1,    -1,    -1,
    3302       -1,    -1,    -1,    -1,    -1,  1220,    -1,    -1,    -1,  1224,
    3303       -1,    -1,   654,  1554,    -1,  1556,    -1,    67,   635,   636,
    3304      637,  1236,    72,  1238,    74,    75,    76,  1242,  1569,  1570,
    3305      672,    -1,    -1,    83,    84,    -1,    -1,   654,   795,    -1,
    3306       -1,   683,    -1,    -1,    94,    -1,    -1,    -1,   805,    -1,
    3307      807,    -1,  1415,    -1,    -1,   812,  1271,    -1,   815,   109,
    3308       -1,   111,   819,    -1,  1279,  1280,  1281,   709,   118,   119,
    3309      712,    -1,   158,  1299,    -1,  1290,  1291,    -1,    -1,    -1,
    3310       -1,    -1,    -1,    -1,    10,    11,    12,    13,    14,  1304,
    3311       -1,    -1,    -1,    -1,    -1,   712,    -1,    -1,    -1,    -1,
    3312       -1,  1464,    -1,    -1,    -1,    -1,    -1,   749,  1471,    -1,
    3313       -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
    3314       -1,  1396,  1337,    -1,   881,    -1,    -1,    -1,    -1,    -1,
    3315     1345,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3316       -1,    67,    -1,    -1,    -1,    -1,    72,    -1,    74,    75,
    3317       76,    -1,    -1,   795,   911,    -1,    -1,    83,    84,    -1,
    3318       -1,  1524,    -1,   805,    -1,   807,    -1,   253,    94,    -1,
    3319      812,    -1,   258,   815,    -1,    -1,    -1,   819,    -1,    -1,
    3320       -1,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,    -1,
    3321      807,    -1,   118,   119,    -1,    -1,    -1,    -1,   815,    -1,
    3322     1415,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   966,
    3323       -1,    54,    -1,    56,    -1,    -1,    59,    60,    61,    -1,
    3324       63,    -1,    -1,    -1,    -1,  1440,    10,    11,    12,    13,
    3325       14,    -1,    -1,    -1,    -1,    78,    -1,    -1,    -1,   881,
    3326       -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    91,  1464,
    3327       -1,    -1,    -1,    -1,    -1,    39,  1471,    10,    11,    12,
    3328       13,    14,    -1,    -1,   881,    -1,   352,    -1,    -1,   911,
    3329     1027,  1028,    -1,  1030,  1031,    -1,    -1,    -1,    -1,    -1,
    3330       -1,    -1,    -1,    67,    -1,    -1,    39,    -1,    72,    -1,
    3331       74,    75,    76,  1050,    -1,    -1,    -1,    -1,    -1,    83,
    3332       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1524,
    3333       94,    -1,    -1,    -1,    67,    -1,  1531,    -1,    -1,    72,
    3334       -1,    74,    75,    76,   966,   109,    -1,    -1,  1085,  1086,
    3335       83,    84,   949,   419,   118,   119,    -1,    -1,    -1,    -1,
    3336       -1,    94,    -1,    10,    11,    12,    13,    14,   434,   966,
    3337       -1,    -1,    -1,   439,    -1,    -1,   109,    -1,    -1,    -1,
    3338       -1,   447,    -1,    -1,    -1,   118,   119,    -1,    -1,    -1,
    3339       -1,    -1,    39,    -1,    10,    11,    12,    13,    14,   465,
    3340       -1,    -1,    -1,    -1,    -1,  1027,  1028,    -1,  1030,  1031,
    3341       -1,    -1,    -1,    -1,    -1,    -1,    -1,   483,    -1,   485,
    3342       67,    -1,  1159,    39,    -1,    72,    -1,    -1,  1050,    76,
    3343       -1,    -1,    -1,  1030,  1031,    -1,    83,    84,    -1,    -1,
    3344       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    3345       -1,    67,    -1,  1050,    -1,    -1,    72,    -1,    -1,    -1,
    3346       76,   527,   109,  1085,  1086,  1202,    -1,    83,    84,    -1,
    3347       -1,   118,   119,    -1,    -1,    -1,    -1,    -1,    94,    -1,
    3348       -1,    -1,    -1,    -1,    -1,    -1,    -1,  1224,    -1,    -1,
    3349       -1,    -1,    -1,   109,    -1,    -1,    -1,    -1,    -1,  1236,
    3350       -1,  1238,   118,   119,    10,    11,    12,    13,    14,    15,
    3351       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    3352       26,    27,   345,    -1,   347,   591,    -1,    -1,    -1,    -1,
    3353       -1,    -1,    -1,    39,  1271,   358,   359,  1159,    -1,    -1,
    3354       -1,    -1,  1279,  1280,  1281,    -1,    -1,    -1,    -1,    -1,
    3355       -1,    -1,    -1,  1290,  1291,    -1,    -1,    -1,    -1,    -1,
    3356       -1,    67,    -1,    -1,    -1,    -1,    -1,  1304,    -1,   635,
    3357      636,   637,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3358     1202,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   654,    -1,
    3359       37,    38,    -1,    40,    -1,    -1,    -1,    -1,    -1,    -1,
    3360       -1,    -1,  1224,    -1,  1201,  1202,   672,    -1,  1345,    -1,
    3361       -1,    -1,    -1,    -1,  1236,    -1,  1238,   683,    -1,    66,
    3362       -1,    -1,    -1,    -1,    -1,    72,    -1,  1224,    -1,    76,
    3363       -1,    -1,    79,    80,    81,    82,    83,    84,    -1,    86,
    3364       87,    -1,    -1,   709,    -1,  1242,   712,    94,    -1,  1271,
    3365       -1,    -1,    -1,    -1,    -1,    -1,    -1,  1279,  1280,  1281,
    3366       -1,    -1,   109,    -1,   111,    -1,    -1,   114,  1290,  1291,
    3367       -1,   118,   119,   120,   121,   122,   123,    -1,  1415,    -1,
    3368       -1,    -1,  1304,   749,    -1,    -1,    -1,    -1,    -1,    -1,
    3369       -1,    -1,    -1,  1290,  1291,    -1,    -1,    -1,    -1,    -1,
    3370       -1,    -1,  1299,    -1,    -1,    -1,    -1,  1304,    -1,    -1,
    3371       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3372       -1,    -1,    -1,  1345,    -1,    -1,    -1,  1464,    -1,   795,
    3373       -1,    -1,    -1,    -1,  1471,    -1,    -1,    -1,    -1,   805,
    3374     1337,   807,    -1,    -1,    -1,    -1,   812,    -1,    -1,   815,
    3375       -1,    -1,    -1,   819,    -1,    10,    11,    12,    13,    14,
    3376       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3377       25,    26,    27,    28,    -1,    30,    31,    32,    -1,    -1,
    3378       -1,    -1,    67,    -1,    39,    -1,    -1,  1524,    -1,    -1,
    3379       -1,    -1,    77,  1415,    79,    -1,    81,    -1,    -1,    -1,
    3380       -1,    -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    -1,
    3381       -1,    -1,    67,    -1,    -1,   881,    -1,    72,  1415,    74,
    3382       75,    76,    -1,    78,    -1,    -1,    -1,    -1,    83,    84,
    3383       -1,    -1,    -1,    -1,   119,    -1,   121,   122,   123,    94,
    3384       -1,    -1,  1464,  1440,    -1,   911,    -1,    -1,    -1,  1471,
    3385       -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,    26,
    3386       27,    28,    -1,   118,   119,    -1,    -1,  1464,    -1,    -1,
    3387       -1,    -1,    37,    38,  1471,    40,    -1,   162,   701,    -1,
    3388      703,    -1,    -1,    -1,    -1,    -1,    -1,   710,   711,    -1,
    3389       -1,    -1,   715,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3390      966,    66,  1524,    50,   727,    -1,    -1,    72,    -1,   732,
    3391       -1,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
    3392       67,    86,    87,    -1,    -1,    -1,    -1,  1524,    -1,    94,
    3393       -1,    -1,    -1,   100,    -1,   102,    -1,    -1,   223,   762,
    3394      225,   226,   227,    -1,   109,    -1,   111,    -1,    -1,    -1,
    3395       -1,    -1,   117,   118,   119,   120,   121,   122,   123,    -1,
    3396      127,  1027,  1028,    -1,  1030,  1031,    -1,    -1,   115,    -1,
    3397       -1,    -1,   119,    -1,    -1,    -1,   261,    -1,    -1,    -1,
    3398       -1,   266,    -1,    -1,  1050,    -1,    -1,    -1,   284,    -1,
    3399      286,   287,    -1,    -1,    -1,    -1,   281,    -1,   294,   295,
    3400       -1,   148,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3401       -1,   158,   308,   309,    -1,   162,   183,    -1,    -1,  1085,
    3402     1086,    -1,    -1,    -1,   191,    -1,   193,   194,    -1,    -1,
    3403       -1,   198,    -1,   200,   201,    -1,    -1,    -1,    -1,    -1,
    3404      863,   864,   865,   866,   329,   868,    -1,    -1,    -1,    -1,
    3405      346,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3406       -1,   884,    -1,    -1,   211,    -1,   351,    -1,    -1,    -1,
    3407       -1,   356,   357,    -1,    -1,   898,   223,    -1,    -1,   364,
    3408       -1,    -1,    -1,    -1,    -1,    -1,   382,    -1,    -1,    -1,
    3409       -1,    -1,    -1,  1159,   241,    -1,    -1,    -1,    -1,    -1,
    3410       -1,    -1,    -1,   270,    -1,    -1,    -1,    -1,    -1,    -1,
    3411       -1,    -1,    -1,    -1,    -1,   938,    -1,    -1,    -1,   266,
    3412       -1,    -1,   407,    -1,    -1,    -1,   273,    -1,    -1,    -1,
    3413       -1,    -1,    -1,    -1,    -1,    -1,  1202,    -1,    -1,    -1,
    3414      425,    -1,    -1,    -1,    -1,   430,    -1,   432,    -1,   296,
    3415       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1224,    -1,
    3416       -1,   308,   985,    -1,   449,    -1,    -1,   452,   453,   992,
    3417     1236,    -1,  1238,    -1,   997,   460,    -1,    -1,    -1,  1002,
    3418       -1,  1004,    -1,    -1,    -1,  1008,    -1,  1010,  1011,   474,
    3419       -1,  1014,    -1,    -1,    -1,    -1,   481,    -1,    -1,   346,
    3420     1023,    -1,    -1,    -1,   351,  1271,    -1,    -1,    -1,    -1,
    3421       -1,    -1,    -1,  1279,  1280,  1281,    -1,    -1,  1041,  1042,
    3422       -1,    -1,    -1,    -1,  1290,  1291,    -1,    -1,    -1,    -1,
    3423       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1304,    -1,
    3424       -1,    -1,    -1,    -1,    -1,  1068,    -1,    -1,  1071,    -1,
    3425       -1,    -1,    -1,    -1,   550,   551,   552,   553,   554,   555,
    3426      556,   557,   558,   559,   560,   561,   562,   563,   564,   565,
    3427      566,   567,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1345,
    3428      427,   428,    -1,    -1,    -1,    -1,    -1,   434,    -1,    -1,
    3429       -1,  1114,    -1,    -1,    -1,    -1,    -1,  1120,  1121,    -1,
    3430       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   455,  1132,
    3431      595,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1142,
    3432       -1,    -1,  1145,    -1,  1147,    -1,    -1,  1150,    -1,    -1,
    3433       -1,    -1,    -1,    -1,    -1,    -1,   483,    -1,   623,    -1,
    3434     1163,    -1,    -1,   628,    -1,    -1,    -1,    -1,   495,  1415,
    3435       -1,    -1,    -1,  1176,    -1,  1178,  1179,  1180,  1181,    -1,
    3436      507,    -1,   509,    -1,    -1,   512,    -1,   514,   515,    -1,
    3437       -1,  1194,    -1,  1196,    -1,    -1,    -1,  1200,    -1,    -1,
    3438      527,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3439       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1464,    -1,
    3440       -1,   697,    -1,    -1,    -1,  1471,  1229,  1230,   575,   576,
    3441       -1,    -1,    -1,    -1,    -1,   700,    -1,    -1,    -1,    -1,
    3442       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   714,
    3443       -1,    -1,   579,    -1,    -1,    -1,    -1,   604,    -1,    -1,
    3444      607,   608,    -1,   610,   591,   612,   613,    -1,   595,   734,
    3445      617,   618,    -1,    -1,    -1,    -1,    -1,    -1,  1524,  1282,
    3446     1283,    -1,    -1,    -1,   760,    -1,    -1,    -1,    -1,  1292,
    3447       -1,    -1,    -1,    -1,   621,    -1,    -1,    -1,    -1,   626,
    3448       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   635,   636,
    3449      637,    -1,    -1,    -1,    -1,    -1,   792,    -1,    -1,     7,
    3450       -1,    -1,    10,    11,    12,    13,    14,   654,    -1,    -1,
    3451       -1,    -1,    -1,    -1,   799,    -1,    -1,    -1,    -1,    -1,
    3452     1343,    -1,    45,    -1,    -1,    -1,   811,    -1,    -1,    37,
    3453       38,    39,    40,  1356,    -1,  1358,  1359,  1360,    -1,   686,
    3454       -1,    -1,    -1,    -1,    -1,   830,    -1,  1370,    -1,    -1,
    3455       -1,    -1,    -1,    -1,    -1,    -1,  1379,    -1,    66,    67,
    3456       -1,    -1,    -1,    -1,    72,   712,    -1,   714,    76,    -1,
    3457       93,    79,    80,    81,    82,    83,    84,    -1,    86,    87,
    3458      103,    -1,    -1,  1406,    -1,    -1,    94,    -1,    -1,    -1,
    3459       -1,   758,   759,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3460       -1,   109,   749,   111,    -1,    -1,    -1,    -1,    -1,    -1,
    3461      118,   119,   120,   121,   122,   123,    -1,   913,    -1,    -1,
    3462       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1451,  1452,
    3463       -1,    -1,    -1,    -1,    -1,    -1,   159,    -1,    -1,    -1,
    3464       -1,  1464,    -1,    -1,    -1,    -1,    -1,    -1,  1471,    -1,
    3465      173,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   944,
    3466      807,    -1,   958,    -1,   811,    -1,    -1,    -1,   815,    -1,
    3467       -1,    -1,    -1,   196,    -1,    -1,    -1,    -1,    -1,    -1,
    3468       -1,  1504,    -1,    -1,    -1,  1508,    -1,   210,    -1,    -1,
    3469       -1,   976,    -1,    -1,    -1,    -1,   219,    -1,    -1,    -1,
    3470      996,    -1,    -1,    -1,    -1,    -1,   229,    -1,    -1,    -1,
    3471       -1,    -1,    -1,  1009,  1537,    -1,  1539,    -1,    -1,    -1,
    3472       -1,    -1,    -1,    -1,    -1,    -1,    -1,  1012,    -1,    -1,
    3473       -1,   254,    -1,    -1,    -1,    -1,   259,    -1,  1023,    -1,
    3474       -1,    -1,    -1,    -1,  1567,  1568,    -1,    -1,    -1,   272,
    3475       -1,   918,  1575,  1576,  1050,   278,   923,   280,    -1,    -1,
    3476       -1,    -1,    -1,    -1,   911,    -1,    -1,    -1,    -1,    -1,
    3477       -1,    -1,    -1,    -1,   297,    -1,    -1,    -1,    -1,   926,
    3478       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3479       -1,    -1,    -1,    -1,    37,    38,    -1,    40,    -1,    -1,
    3480       -1,    -1,    -1,   950,    -1,    -1,    -1,    -1,    -1,    -1,
    3481     1095,    -1,    -1,    -1,    -1,    -1,   339,    -1,    -1,   966,
    3482       -1,   344,    -1,    66,  1109,    -1,    -1,    -1,    -1,    72,
    3483       -1,  1127,    -1,    76,    -1,    -1,    79,    80,    81,    82,
    3484       83,    84,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,
    3485      373,    94,    -1,    -1,   377,   378,    -1,   380,    -1,    -1,
    3486       -1,    -1,  1009,    -1,   387,   388,   109,   390,   391,    -1,
    3487      393,    -1,   395,    -1,    -1,   118,   119,   120,   121,   122,
    3488      123,    -1,    -1,  1030,  1031,    -1,    -1,    -1,    -1,   412,
    3489       -1,    -1,    -1,    -1,  1190,  1191,    -1,   420,    -1,    -1,
    3490       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3491       -1,    -1,    -1,    -1,    -1,    -1,  1201,    -1,    -1,    -1,
    3492     1087,    -1,   445,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3493       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3494       -1,    -1,    -1,  1090,    -1,    -1,    -1,    -1,   471,    -1,
    3495       -1,    -1,    -1,    -1,   477,    -1,    -1,     0,    -1,   482,
    3496        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    3497       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    3498       23,    24,    25,    26,    27,    -1,    -1,    30,    31,    32,
    3499       33,    -1,    -1,    36,    -1,   518,    39,    40,    -1,    -1,
    3500       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3501      533,    -1,  1159,    -1,  1299,    -1,    -1,    -1,    -1,    -1,
    3502       -1,    64,    -1,    -1,    67,    -1,    69,    -1,    71,    72,
    3503       -1,    74,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,
    3504       83,    84,    -1,    -1,    -1,    -1,    -1,    -1,   571,    -1,
    3505       -1,    94,  1219,    -1,  1201,    -1,    -1,   580,    -1,   157,
    3506      158,    -1,    -1,    -1,   587,    -1,   109,    -1,   111,    -1,
    3507      593,    -1,    -1,    -1,    -1,   118,   119,    -1,    -1,   602,
    3508       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3509       -1,  1238,    -1,   191,    -1,    -1,    -1,    -1,    -1,    -1,
    3510      198,    -1,    -1,    -1,    -1,  1401,    -1,    -1,    -1,    -1,
    3511       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3512      643,    -1,    -1,  1419,    -1,    -1,    -1,    -1,    -1,    -1,
    3513       -1,    37,    38,    -1,    40,    -1,    -1,    -1,    -1,    -1,
    3514       -1,    -1,    -1,  1290,  1291,    -1,    -1,    -1,    -1,    -1,
    3515       -1,    -1,  1299,    -1,    -1,    -1,   679,    -1,    -1,    -1,
    3516       66,    -1,    -1,    -1,   687,    -1,    72,    -1,    -1,    -1,
    3517       76,    -1,   270,    79,    80,    81,    82,    83,    84,    -1,
    3518       86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,
    3519       -1,    -1,    -1,    -1,    -1,   718,  1492,  1493,    -1,    -1,
    3520       -1,    -1,    -1,   109,    -1,   728,   729,    -1,    -1,    -1,
    3521       -1,    -1,   118,   119,   120,   121,   122,   123,    -1,   742,
    3522       -1,    -1,    -1,    -1,    -1,    -1,   324,    -1,    -1,    -1,
    3523       -1,    -1,    -1,    -1,   332,   333,    -1,   335,   336,    -1,
    3524      763,    -1,   765,    -1,    -1,    -1,   769,    -1,   346,    -1,
    3525       -1,    -1,   350,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3526       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1415,    -1,
    3527     1555,   369,    -1,    -1,   372,    10,    11,    12,    13,    14,
    3528       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3529       25,    26,    27,    28,    -1,    30,    31,    32,    -1,    -1,
    3530       -1,   399,    -1,    -1,    39,   403,    -1,    -1,    -1,    -1,
    3531       -1,   834,    -1,    -1,    -1,    -1,    -1,    -1,   841,    -1,
    3532       -1,    -1,    -1,    -1,    -1,    -1,  1473,    -1,  1475,    -1,
    3533       -1,   854,    67,   856,    -1,    -1,   434,    72,    -1,    74,
    3534       75,    76,    -1,    78,    -1,    -1,    -1,   870,    83,    84,
    3535       -1,    -1,    -1,    -1,   877,    -1,    -1,    -1,    -1,    94,
    3536       -1,    -1,    -1,  1510,   148,  1512,   889,    -1,    -1,   892,
    3537       -1,    -1,    -1,    -1,   158,    -1,   111,    -1,    -1,    -1,
    3538       -1,    -1,   480,   118,   119,   483,   170,   171,    -1,    -1,
    3539       -1,    -1,    -1,  1540,     3,     4,     5,     6,     7,     8,
    3540        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    3541       19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
    3542       -1,    30,    31,    32,   522,    -1,    -1,    -1,   526,   527,
    3543       39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3544       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   971,    -1,
    3545       -1,    -1,    -1,    -1,    -1,    -1,    -1,   241,    67,    -1,
    3546       69,    -1,    71,    -1,    -1,    74,    75,    -1,    -1,    -1,
    3547       -1,    -1,    -1,   571,   572,    -1,    -1,    -1,    -1,    -1,
    3548       -1,   265,    -1,    -1,  1007,    94,    -1,    -1,    -1,    -1,
    3549       -1,    -1,   590,   591,    -1,    -1,    -1,    -1,    -1,    -1,
    3550       -1,    -1,   111,   601,    -1,   603,   604,    -1,    -1,   118,
    3551      119,    -1,   610,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3552       -1,    -1,   620,   621,    -1,    -1,    -1,    -1,   626,    -1,
    3553       -1,    -1,    -1,    -1,    -1,    -1,    -1,   635,   636,   637,
    3554       -1,    -1,  1065,    -1,    -1,    -1,    -1,    -1,  1071,    -1,
    3555       -1,    -1,    -1,    -1,    -1,    -1,   654,    -1,    -1,    -1,
    3556       -1,   659,   660,    -1,    -1,   663,   664,    -1,    -1,    -1,
    3557       -1,    -1,   670,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3558       -1,    -1,  1105,    -1,    -1,    -1,    -1,  1110,    -1,    -1,
    3559       -1,   689,    -1,    -1,    -1,  1118,    -1,   381,    -1,    -1,
    3560       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3561       -1,    -1,    -1,    -1,   712,   713,    -1,    -1,    -1,    -1,
    3562       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3563       -1,  1154,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3564       -1,    -1,    -1,  1166,    -1,    -1,  1169,    -1,  1171,    -1,
    3565      748,   749,    -1,    -1,    -1,   753,   754,    -1,    -1,    -1,
    3566       -1,    -1,  1185,  1186,    -1,    -1,    -1,    -1,    -1,    -1,
    3567       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3568       -1,    -1,    -1,    -1,  1207,    -1,    -1,    -1,    -1,    -1,
    3569       -1,   475,    37,    38,    -1,    40,    -1,    -1,    -1,    -1,
    3570       -1,   799,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   807,
    3571       -1,    -1,    -1,    -1,    -1,    -1,   814,   815,    -1,    -1,
    3572      818,    66,   820,    -1,    -1,    -1,    -1,    72,    -1,    -1,
    3573      514,    76,   830,  1256,    79,    80,    81,    82,    83,    84,
    3574       -1,    86,    87,   527,    -1,    -1,    -1,    -1,   532,    94,
    3575       -1,   535,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3576       -1,    -1,   546,   547,   109,    -1,   111,    -1,    -1,    -1,
    3577       -1,   116,    -1,   118,   119,   120,   121,   122,   123,    -1,
    3578       -1,    -1,    -1,    -1,    -1,   569,    -1,    -1,    -1,    -1,
    3579       -1,    -1,    -1,    -1,    -1,   579,    -1,    -1,    -1,    -1,
    3580       -1,    -1,   586,    -1,    -1,   903,    -1,   591,    -1,  1332,
    3581       -1,  1334,   910,   911,   912,    -1,   914,    -1,    -1,    -1,
    3582      918,    -1,    -1,    -1,    -1,  1348,    -1,  1350,    -1,    -1,
    3583       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3584       -1,   939,   940,    -1,    -1,  1368,    -1,    -1,    -1,    -1,
    3585       -1,    -1,    -1,    -1,    -1,    -1,   640,    -1,    -1,    -1,
    3586       -1,  1384,  1385,    -1,    -1,   649,    -1,    -1,   966,    -1,
    3587       -1,    -1,  1395,    -1,    -1,  1398,    -1,    -1,   976,    10,
    3588       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    3589       21,    22,    23,    24,    25,    26,    27,    28,  1421,    -1,
    3590      998,   999,    -1,    -1,    -1,    -1,    -1,  1430,    39,    -1,
    3591     1433,  1009,  1435,  1436,  1437,    -1,    -1,  1015,  1016,    -1,
    3592     1018,  1019,  1020,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3593       -1,    -1,  1030,  1031,    -1,    -1,    67,    -1,    -1,    -1,
    3594       -1,    -1,    -1,    -1,    -1,    -1,    -1,    78,    -1,    -1,
    3595       -1,    -1,    -1,    -1,  1477,    -1,  1479,    -1,  1481,    -1,
    3596       -1,    -1,    -1,    -1,    -1,   749,    -1,   751,    -1,    -1,
    3597       -1,    -1,    -1,    -1,  1497,    -1,    -1,   761,    -1,    -1,
    3598       -1,    -1,    -1,    -1,   768,    -1,    -1,    -1,    -1,    -1,
    3599       -1,    -1,    -1,    -1,    -1,  1093,    -1,  1095,    -1,    -1,
    3600       -1,    -1,  1100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3601       -1,  1109,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     7,
    3602       -1,    -1,    10,    11,    12,    13,    14,   811,   812,    -1,
    3603       -1,   815,    -1,    -1,    -1,    -1,  1134,  1135,  1136,    -1,
    3604       -1,    -1,    -1,    -1,    -1,   829,    -1,    -1,    -1,    37,
    3605       38,    39,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3606       -1,  1159,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3607       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
    3608       -1,    -1,    -1,    -1,    72,   869,    -1,    -1,    76,   873,
    3609       -1,    79,    80,    81,    82,    83,    84,    -1,    86,    87,
    3610       -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,    -1,
    3611       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3612       -1,   109,  1220,   111,    -1,    -1,    -1,   911,    -1,    -1,
    3613      118,   119,   120,   121,   122,   123,    -1,    -1,    -1,    -1,
    3614     1238,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    3615       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    3616       23,    24,    25,    26,    27,    -1,   950,    30,    31,    32,
    3617       -1,    -1,    -1,    -1,    37,    38,    39,    40,    -1,    -1,
    3618       -1,    -1,   966,   967,    -1,    -1,    -1,    -1,    -1,    -1,
    3619       -1,    -1,  1290,  1291,    -1,    -1,   980,    -1,    -1,    -1,
    3620       -1,    -1,   986,    66,    67,   989,    69,   991,    71,    72,
    3621       -1,    74,    75,    76,    -1,    -1,    79,    80,    81,    82,
    3622       83,    84,    -1,    86,    87,    -1,    -1,    -1,  1012,    -1,
    3623       -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1023,
    3624       -1,    37,    38,    -1,    40,    -1,   109,    -1,   111,    -1,
    3625       -1,    -1,    -1,   116,    -1,   118,   119,   120,   121,   122,
    3626      123,  1045,    -1,  1047,    -1,    -1,    -1,    -1,    -1,    -1,
    3627       66,    -1,    -1,    -1,    -1,    -1,    72,    -1,  1062,  1063,
    3628       76,    -1,    -1,    79,    80,    81,    82,    83,    84,    -1,
    3629       86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,  1083,
    3630       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3631       -1,    -1,    -1,   109,    -1,   111,    -1,  1415,   114,    -1,
    3632       -1,    -1,   118,   119,   120,   121,   122,   123,    -1,    -1,
    3633       -1,     3,     4,     5,     6,     7,     8,     9,    10,    11,
    3634       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
    3635       22,    23,    24,    25,    26,    27,  1140,    -1,    30,    31,
    3636       32,    33,    -1,    -1,    36,    -1,    -1,    39,    40,    -1,
    3637       -1,    -1,    -1,    -1,    -1,  1159,    -1,    -1,    -1,    -1,
    3638       -1,    37,    38,    -1,    40,    -1,    -1,    -1,    -1,    -1,
    3639     1174,  1175,    64,    -1,    -1,    67,    -1,    69,    -1,    71,
    3640       72,    -1,    74,    75,    76,    -1,    -1,  1505,    -1,    -1,
    3641       66,    83,    84,    -1,    -1,    -1,    72,    -1,    -1,    -1,
    3642       76,    -1,    94,    79,    80,    81,    82,    83,    84,    -1,
    3643       86,    87,  1530,  1531,    -1,    -1,    -1,   109,    94,   111,
    3644       -1,    -1,    -1,   115,    -1,    -1,   118,   119,    -1,    -1,
    3645       -1,    -1,    -1,   109,    -1,   111,    -1,  1555,    -1,    -1,
    3646       -1,    -1,   118,   119,   120,   121,   122,   123,    -1,    -1,
    3647     1254,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
     3538      -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,
     3539      -1,    -1,    -1,   118,   119,   120,   121,   122,   123,    -1,
     3540      -1,    -1,    -1,  1316,    -1,    -1,  1319,   132,    -1,    -1,
     3541      -1,    -1,    -1,    -1,    -1,   759,    -1,    -1,  1503,    10,
    36483542      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    36493543      21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
     3544      31,    32,    -1,  1528,  1529,    -1,   790,    -1,    39,    -1,
     3545      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3546      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1553,    -1,
     3547      -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,
     3548      -1,    -1,    -1,    74,    75,    -1,    -1,    -1,    -1,    -1,
     3549    1403,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3550      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
     3551      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3552      21,    22,    23,    24,    25,    26,    27,   118,   119,    30,
    36503553      31,    32,    33,    -1,    -1,    36,    37,    38,    39,    40,
    36513554      41,    -1,    43,    -1,    -1,    46,    47,    48,    49,    50,
    36523555      51,    52,    53,    -1,    -1,    -1,    57,    -1,    -1,    -1,
    3653       61,    62,    -1,    64,  1318,    66,    67,  1321,    69,    -1,
     3556      61,    62,    -1,    64,    -1,    66,    67,   911,    69,    -1,
     3557      71,    72,  1485,    74,    75,    76,    -1,    -1,    79,    80,
     3558      81,    82,    83,    84,    -1,    86,    87,    10,    11,    12,
     3559      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     3560      23,    24,    25,    26,    27,    28,    -1,    -1,   109,    -1,
     3561     111,    -1,   956,   114,    -1,    -1,    39,   118,   119,   120,
     3562     121,   122,   123,    -1,    -1,  1538,    -1,   128,    -1,    -1,
     3563      -1,   132,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3564      -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,    -1,    -1,
     3565     994,    -1,    -1,    -1,    -1,    78,    -1,    -1,    -1,    -1,
     3566      -1,    -1,    -1,  1007,    -1,    -1,    -1,    -1,    -1,    -1,
     3567      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
     3568      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3569      21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
     3570      31,    32,    33,    -1,  1048,    36,    37,    38,    39,    40,
     3571      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
     3572      20,    21,    22,    23,    24,    25,    26,    27,    -1,    -1,
     3573      30,    31,    32,    -1,    -1,    66,    67,    -1,    69,    39,
    36543574      71,    72,    -1,    74,    75,    76,    -1,    -1,    79,    80,
    36553575      81,    82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,
    3656       -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,
     3576      -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,
     3577      -1,    -1,    72,    -1,    74,    75,    -1,    -1,   109,    -1,
     3578     111,  1125,    -1,    83,    84,    -1,    -1,   118,   119,   120,
     3579     121,   122,   123,     4,     5,     6,     7,     8,     9,    10,
     3580      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3581      21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
     3582      31,    32,    -1,    -1,    -1,    -1,    37,    38,    39,    40,
     3583      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3584      -1,    -1,    -1,    -1,  1188,  1189,    -1,    -1,    -1,    -1,
     3585      -1,    -1,    -1,    -1,    -1,    66,    67,    -1,    69,    -1,
     3586      71,    72,    -1,    74,    75,    76,    -1,    -1,    79,    80,
     3587      81,    82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,
     3588      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    36573589      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,
    3658      111,    -1,    -1,   114,    -1,    -1,    -1,   118,   119,   120,
    3659      121,   122,   123,    -1,    -1,    -1,    -1,   128,    -1,    -1,
    3660       -1,   132,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3590     111,    -1,    -1,    -1,    -1,   116,    -1,   118,   119,   120,
     3591     121,   122,   123,     4,     5,     6,     7,     8,     9,    10,
     3592      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3593      21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
     3594      31,    32,    -1,    -1,    -1,    -1,    37,    38,    39,    40,
     3595      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
     3596      20,    21,    22,    23,    24,    25,    26,    27,    -1,    -1,
     3597      30,    31,    32,    -1,    -1,    66,    67,    -1,    69,    39,
     3598      71,    72,    -1,    74,    75,    76,    -1,    -1,    79,    80,
     3599      81,    82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,
     3600      -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,
     3601      -1,    -1,    72,    -1,    74,    75,    76,    -1,   109,    -1,
     3602     111,    -1,    -1,    83,    84,   116,    -1,   118,   119,   120,
     3603     121,   122,   123,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3604      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,
     3605      -1,   111,    -1,    -1,    -1,  1399,    -1,    -1,   118,   119,
    36613606      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3662       -1,  1405,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
    3663        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3664       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3665       25,    26,    27,    -1,    -1,    30,    31,    32,    33,    -1,
    3666       -1,    36,    37,    38,    39,    40,    10,    11,    12,    13,
    3667       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    3668       24,    25,    26,    27,    -1,    -1,    30,    31,    32,    -1,
    3669       -1,    66,    67,    -1,    69,    39,    71,    72,    -1,    74,
    3670       75,    76,    -1,  1487,    79,    80,    81,    82,    83,    84,
    3671       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,
    3672       -1,    -1,    -1,    67,    -1,    -1,    -1,    -1,    72,    -1,
    3673       74,    75,    -1,    -1,   109,    -1,   111,    -1,    -1,    83,
    3674       84,    -1,    -1,   118,   119,   120,   121,   122,   123,    -1,
    3675       -1,    -1,    -1,    -1,    -1,    -1,  1540,   132,     3,     4,
    3676        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3677       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3678       25,    26,    27,    -1,    -1,    30,    31,    32,    33,    -1,
    3679       -1,    36,    37,    38,    39,    40,    -1,    -1,    -1,    10,
    3680       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    3681       21,    22,    23,    24,    25,    26,    27,    28,    -1,    -1,
    3682       -1,    66,    67,    -1,    69,    -1,    71,    72,    39,    74,
    3683       75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
    3684       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,
    3685       -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,
    3686       -1,    -1,    -1,    -1,   109,    -1,   111,    78,    -1,    -1,
    3687       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,     4,
    3688        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3689       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3690       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    3691       -1,    -1,    37,    38,    39,    40,    10,    11,    12,    13,
    3692       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    3693       24,    25,    26,    27,    -1,    -1,    30,    31,    32,    -1,
    3694       -1,    66,    67,    -1,    69,    39,    71,    72,    -1,    74,
    3695       75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
    3696       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,
    3697       -1,    -1,    -1,    67,    -1,    -1,    -1,    -1,    -1,    -1,
    3698       74,    75,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,
    3699       -1,   116,    -1,   118,   119,   120,   121,   122,   123,     4,
    3700        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3701       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3702       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    3703       -1,    -1,    37,    38,    39,    40,    10,    11,    12,    13,
    3704       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    3705       24,    25,    26,    27,    -1,    -1,    30,    31,    32,    -1,
    3706       -1,    66,    67,    -1,    69,    39,    71,    72,    -1,    74,
    3707       75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
    3708       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,
    3709       -1,    -1,    -1,    67,    -1,    -1,    -1,    -1,    -1,    -1,
    3710       74,    75,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,
    3711       -1,   116,    -1,   118,   119,   120,   121,   122,   123,     4,
    3712        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3713       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3714       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    3715       -1,    -1,    37,    38,    39,    40,    -1,    -1,    -1,    -1,
     3607      -1,    -1,    -1,  1417,    -1,    -1,    -1,    -1,    -1,    -1,
     3608      -1,    -1,    -1,    -1,    -1,    -1,     4,     5,     6,     7,
     3609       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     3610      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
     3611      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
     3612      38,    39,    40,    10,    11,    12,    13,    14,    15,    16,
     3613      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3614      27,    -1,    -1,    30,    31,    32,  1490,  1491,    66,    67,
     3615      -1,    69,    39,    71,    72,    -1,    74,    75,    76,    -1,
     3616      -1,    79,    80,    81,    82,    83,    84,    -1,    86,    87,
     3617      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3618      67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,    -1,
     3619      -1,   109,    -1,   111,    -1,    -1,    -1,    -1,   116,    -1,
     3620     118,   119,   120,   121,   122,   123,     4,     5,     6,     7,
     3621       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     3622      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
     3623      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
     3624      38,    39,    40,    10,    11,    12,    13,    14,    15,    16,
     3625      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3626      27,    -1,    -1,    30,    31,    32,    -1,    -1,    66,    67,
     3627      -1,    69,    39,    71,    72,    -1,    74,    75,    76,    -1,
     3628      -1,    79,    80,    81,    82,    83,    84,    -1,    86,    87,
     3629      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3630      67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,    -1,
     3631      -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,
     3632     118,   119,   120,   121,   122,   123,     4,     5,     6,     7,
     3633       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     3634      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
     3635      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
     3636      38,    39,    40,    10,    11,    12,    13,    14,    15,    16,
     3637      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3638      27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
     3639      -1,    69,    39,    71,    72,    -1,    74,    75,    76,    -1,
     3640      -1,    79,    80,    81,    82,    83,    84,    -1,    86,    87,
     3641      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3642      67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3643      -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,
     3644     118,   119,   120,   121,   122,   123,     4,     5,     6,     7,
     3645       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     3646      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
     3647      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
     3648      38,    39,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3649      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3650      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
     3651      -1,    69,    -1,    71,    72,    -1,    74,    75,    76,    -1,
     3652      -1,    79,    80,    81,    82,    83,    84,    -1,    86,    87,
    37163653      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    37173654      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3718       -1,    66,    67,    -1,    69,    -1,    71,    72,    -1,    74,
    3719       75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
    3720       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,
     3655      -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,
     3656     118,   119,   120,   121,   122,   123,     4,     5,     6,     7,
     3657       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     3658      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
     3659      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,
     3660      38,    39,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    37213661      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3722       -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,
    3723       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,     4,
    3724        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3725       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3726       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    3727       -1,    -1,    37,    38,    39,    40,    -1,    -1,    -1,    -1,
     3662      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
     3663      -1,    69,    -1,    71,    72,    -1,    74,    75,    76,    -1,
     3664      -1,    79,    80,    81,    82,    83,    84,    -1,    86,    87,
    37283665      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    37293666      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3730       -1,    66,    67,    -1,    69,    -1,    71,    72,    -1,    74,
    3731       75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
    3732       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,
     3667      -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,
     3668     118,   119,   120,   121,   122,   123,     3,     4,     5,     6,
     3669       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     3670      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3671      27,    -1,    -1,    30,    31,    32,    33,    -1,    -1,    36,
     3672      -1,    -1,    39,    40,    -1,    -1,    -1,    -1,    -1,    -1,
    37333673      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3734       -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,
    3735       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,     4,
    3736        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3737       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3738       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    3739       -1,    -1,    37,    38,    39,    40,    -1,    -1,    -1,    -1,
     3674      -1,    -1,    -1,    -1,    -1,    -1,    -1,    64,    -1,    -1,
     3675      67,    -1,    69,    -1,    71,    72,    -1,    74,    75,    76,
     3676      -1,    -1,    -1,    -1,    -1,    -1,    83,    84,    -1,    -1,
    37403677      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    37413678      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3742       -1,    66,    67,    -1,    69,    -1,    71,    72,    -1,    74,
    3743       75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
    3744       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,
    3745       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3746       -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,
    3747       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,     4,
    3748        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3749       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3750       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    3751       -1,    -1,    37,    38,    39,    40,    -1,    -1,    -1,    -1,
    3752       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3753       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3754       -1,    66,    67,    -1,    69,    -1,    71,    72,    -1,    74,
    3755       75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
    3756       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,
    3757       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3758       -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,
    3759       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,     3,
    3760        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
    3761       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    3762       24,    25,    26,    27,    -1,    -1,    30,    31,    32,    33,
    3763       -1,    -1,    36,    -1,    -1,    39,    40,    -1,    -1,    -1,
    3764       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3765       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3766       64,    -1,    -1,    67,    -1,    69,    -1,    71,    72,    -1,
    3767       74,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,
    3768       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3769       94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3770       -1,    -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,
    3771       -1,    -1,    -1,    -1,   118,   119,     3,     4,     5,     6,
    3772        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    3773       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    3774       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    3775       -1,    -1,    39,    -1,    10,    11,    12,    13,    14,    15,
    3776       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    3777       26,    27,    -1,    -1,    30,    31,    32,    33,    34,    35,
    3778       67,    -1,    69,    39,    71,    72,    -1,    74,    75,    76,
    3779       -1,    -1,    -1,    -1,    -1,    -1,    83,    84,    -1,    -1,
    3780       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    3781       -1,    67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,
    3782       -1,    -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,
     3679      -1,    -1,   109,    -1,   111,    -1,    -1,    -1,   115,    -1,
    37833680      -1,   118,   119,     3,     4,     5,     6,     7,     8,     9,
    37843681      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
    3785       20,    21,    22,    23,    24,    25,    26,    27,    28,    -1,
     3682      20,    21,    22,    23,    24,    25,    26,    27,    -1,    -1,
    37863683      30,    31,    32,    33,    -1,    -1,    36,    -1,    -1,    39,
     3684      40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    37873685      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3686      -1,    -1,    -1,    -1,    64,    -1,    -1,    67,    -1,    69,
     3687      -1,    71,    72,    -1,    74,    75,    76,    -1,    -1,    -1,
     3688      -1,    -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,
    37883689      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3789       -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    69,
    3790       -1,    71,    -1,    -1,    74,    75,    -1,    -1,    78,    -1,
    3791       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3792       -1,    -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,
    3793       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3690      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,
    37943691      -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,
    37953692       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    37963693      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    3797       23,    24,    25,    26,    27,    -1,    -1,    30,    31,    32,
     3694      23,    24,    25,    26,    27,    28,    -1,    30,    31,    32,
    37983695      33,    -1,    -1,    36,    -1,    -1,    39,    -1,    -1,    -1,
    37993696      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    38003697      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    38013698      -1,    -1,    -1,    -1,    67,    -1,    69,    -1,    71,    -1,
    3802       -1,    74,    75,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3699      -1,    74,    75,    -1,    -1,    78,     4,     5,     6,     7,
     3700       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
     3701      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
     3702      -1,    -1,    30,    31,    32,    -1,    -1,    -1,   111,    -1,
     3703      -1,    39,    -1,    -1,    -1,   118,   119,    -1,    -1,    -1,
    38033704      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3804       -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3805       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,
    3806       -1,    -1,    -1,    -1,    -1,   118,   119,     4,     5,     6,
     3705      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,
     3706      -1,    69,    -1,    71,    72,    -1,    74,    75,    76,    -1,
     3707      -1,    -1,    -1,    -1,    -1,    83,    84,    -1,    -1,    -1,
     3708      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3709      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3710      -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,
     3711     118,   119,     4,     5,     6,     7,     8,     9,    10,    11,
     3712      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
     3713      22,    23,    24,    25,    26,    27,    -1,    -1,    30,    31,
     3714      32,    -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,
     3715      -1,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     3716      19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
     3717      -1,    30,    31,    32,    -1,    67,    -1,    69,    -1,    71,
     3718      39,    -1,    74,    75,    -1,    -1,    -1,    -1,    -1,    -1,
     3719      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3720      -1,    -1,    -1,    -1,    96,    -1,    -1,    -1,    67,    -1,
     3721      -1,    -1,    -1,    72,    -1,    74,    75,    76,    -1,   111,
     3722      -1,    -1,    -1,    -1,    83,    84,   118,   119,     4,     5,
     3723       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     3724      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
     3725      26,    27,   111,    -1,    30,    31,    32,    -1,    -1,   118,
     3726     119,    -1,    -1,    39,    -1,    -1,    -1,    10,    11,    12,
     3727      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     3728      23,    24,    25,    26,    27,    -1,    -1,    30,    31,    32,
     3729      -1,    67,    -1,    69,    -1,    71,    39,    -1,    74,    75,
     3730      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3731      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3732      96,    -1,    -1,    -1,    67,    -1,    -1,    -1,    -1,    72,
     3733      -1,    74,    75,    -1,    -1,   111,    -1,    -1,    -1,    -1,
     3734      83,    84,   118,   119,     4,     5,     6,     7,     8,     9,
     3735      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
     3736      20,    21,    22,    23,    24,    25,    26,    27,   111,    -1,
     3737      30,    31,    32,    -1,    -1,   118,   119,    -1,    -1,    39,
     3738      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3739      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3740      -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    69,
     3741      -1,    71,    -1,    -1,    74,    75,    -1,     4,     5,     6,
    38073742       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    38083743      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    38093744      27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    3810       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3745      -1,   111,    39,    -1,    -1,    -1,    -1,    -1,   118,   119,
    38113746      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    38123747      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3813       67,    -1,    69,    -1,    71,    72,    -1,    74,    75,    76,
    3814       -1,    -1,    -1,    -1,    -1,    -1,    83,    84,    -1,    -1,
    3815       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
     3748      67,    -1,    69,    -1,    71,    -1,    -1,    74,    75,    -1,
     3749       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
     3750      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
     3751      24,    25,    26,    27,    -1,    -1,    30,    31,    32,    -1,
     3752      -1,    -1,    -1,    -1,   111,    39,    -1,    -1,    -1,    -1,
     3753      -1,   118,   119,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    38163754      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3817       -1,    -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,
    3818       -1,   118,   119,     4,     5,     6,     7,     8,     9,    10,
     3755      -1,    -1,    -1,    67,    -1,    69,    -1,    71,    -1,    -1,
     3756      74,    75,    -1,     4,     5,     6,     7,     8,     9,    10,
     3757      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3758      21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
     3759      31,    32,    -1,    -1,    -1,    -1,    -1,   111,    39,    -1,
     3760      -1,    -1,    -1,    -1,   118,   119,    -1,    -1,    -1,    -1,
     3761      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3762      -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    69,    -1,
     3763      71,    -1,    -1,    74,    75,    10,    11,    12,    13,    14,
     3764      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     3765      25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
     3766      -1,    -1,    37,    38,    39,    40,    -1,    -1,    -1,    -1,
     3767     111,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,    -1,
     3768      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3769      -1,    66,    67,    -1,    -1,    -1,    -1,    72,    -1,    74,
     3770      75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
     3771      -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3772      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3773      -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,   114,
     3774      -1,    -1,    -1,   118,   119,   120,   121,   122,   123,    10,
     3775      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3776      21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
     3777      31,    32,    -1,    -1,    -1,    -1,    37,    38,    39,    40,
     3778      -1,    -1,    -1,    -1,    -1,    -1,    -1,    10,    11,    12,
     3779      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     3780      23,    24,    25,    26,    27,    66,    67,    30,    31,    32,
     3781      -1,    72,    -1,    74,    75,    76,    39,    -1,    79,    80,
     3782      81,    82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,
     3783      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3784      -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,   109,   110,
     3785     111,    74,    75,    -1,    -1,    -1,    -1,   118,   119,   120,
     3786     121,   122,   123,    10,    11,    12,    13,    14,    15,    16,
     3787      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3788      27,    -1,    -1,    30,    31,    32,   109,    -1,   111,    -1,
     3789      37,    38,    39,    40,    -1,   118,   119,    -1,    -1,    -1,
     3790      -1,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     3791      19,    20,    21,    22,    23,    24,    25,    26,    27,    66,
     3792      67,    30,    31,    32,    -1,    72,    -1,    74,    75,    76,
     3793      39,    -1,    79,    80,    81,    82,    83,    84,    -1,    86,
     3794      87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3795      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,
     3796      -1,    -1,   109,    -1,   111,    74,    75,    -1,    -1,    -1,
     3797      -1,   118,   119,   120,   121,   122,   123,    10,    11,    12,
     3798      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     3799      23,    24,    25,    26,    27,    -1,    -1,    30,    31,    32,
     3800      -1,    -1,   111,    -1,    37,    38,    39,    40,    -1,   118,
     3801     119,    -1,    -1,    -1,    -1,    10,    11,    12,    13,    14,
     3802      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     3803      25,    26,    27,    66,    67,    30,    31,    32,    -1,    72,
     3804      -1,    74,    75,    76,    39,    -1,    79,    80,    81,    82,
     3805      83,    84,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,
     3806      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3807      -1,    -1,    67,    -1,    -1,    -1,   109,    -1,   111,    74,
     3808      75,    -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,
     3809     123,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     3810      19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
     3811      -1,    30,    31,    32,    -1,    -1,   111,    -1,    37,    38,
     3812      39,    40,    -1,   118,   119,    -1,    -1,    -1,    -1,    10,
     3813      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3814      21,    22,    23,    24,    25,    26,    27,    66,    67,    30,
     3815      31,    32,    -1,    72,    -1,    74,    75,    76,    39,    -1,
     3816      79,    80,    81,    82,    83,    84,    -1,    86,    87,    -1,
     3817      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3818      -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,
     3819     109,    -1,   111,    74,    75,    -1,    -1,    -1,    -1,   118,
     3820     119,   120,   121,   122,   123,    10,    11,    12,    13,    14,
     3821      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     3822      25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
     3823     111,    -1,    37,    38,    39,    40,    -1,   118,   119,    -1,
     3824      -1,    -1,    -1,    10,    11,    12,    13,    14,    15,    16,
     3825      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3826      27,    66,    67,    30,    31,    32,    -1,    72,    -1,    74,
     3827      75,    76,    39,    -1,    79,    80,    81,    82,    83,    84,
     3828      -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3829      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3830      67,    -1,    -1,    -1,   109,    -1,   111,    74,    75,    -1,
     3831      -1,    -1,    -1,   118,   119,   120,   121,   122,   123,     3,
     3832       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
     3833      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
     3834      24,    25,    26,    27,   111,    -1,    30,    31,    32,    -1,
     3835      -1,   118,   119,    -1,    -1,    39,    -1,    -1,    -1,    10,
     3836      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3837      21,    22,    23,    24,    25,    26,    27,    28,    -1,    30,
     3838      31,    32,    -1,    67,    -1,    69,    -1,    71,    39,    -1,
     3839      74,    75,    -1,    -1,    -1,    -1,    -1,    10,    11,    12,
     3840      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     3841      23,    24,    25,    26,    27,    28,    67,    30,    31,    32,
     3842      -1,    72,    -1,    74,    75,    76,    39,    78,    -1,    -1,
     3843     114,    -1,    83,    84,    -1,    10,    11,    12,    13,    14,
     3844      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
     3845      25,    26,    27,    -1,    67,    30,    31,    32,   109,    72,
     3846     111,    74,    75,    76,    39,    78,    -1,   118,   119,    -1,
     3847      83,    84,    -1,    10,    11,    12,    13,    14,    15,    16,
     3848      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3849      27,    -1,    67,    30,    31,    32,    -1,    72,   111,    74,
     3850      75,    76,    39,    -1,    -1,   118,   119,    -1,    83,    84,
     3851      -1,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     3852      19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
     3853      67,    30,    31,    32,   109,    72,   111,    74,    75,    76,
     3854      39,    -1,    -1,   118,   119,    -1,    83,    84,    -1,    10,
     3855      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3856      21,    22,    23,    24,    25,    26,    27,    -1,    67,    30,
     3857      31,    32,   109,    72,   111,    74,    75,    76,    39,    40,
     3858      -1,   118,   119,    -1,    83,    84,    -1,    10,    11,    12,
     3859      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     3860      23,    24,    25,    26,    27,    28,    67,    30,    31,    32,
     3861     109,    -1,   111,    74,    75,    -1,    39,    -1,    -1,   118,
     3862     119,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3863      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3864      -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,    -1,    -1,
     3865     111,    74,    75,    -1,   115,    78,    -1,   118,   119,    -1,
     3866      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
     3867      20,    21,    22,    23,    24,    25,    26,    27,    -1,    -1,
     3868      30,    31,    32,    -1,    -1,    -1,    -1,    -1,   111,    39,
     3869      40,    -1,    -1,    -1,    -1,   118,   119,    -1,    10,    11,
     3870      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
     3871      22,    23,    24,    25,    26,    27,    -1,    67,    30,    31,
     3872      32,    -1,    -1,    -1,    74,    75,    -1,    39,    40,    10,
     3873      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3874      21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
     3875      31,    32,    -1,    -1,    -1,    67,    -1,    -1,    39,    -1,
     3876      -1,   111,    74,    75,    -1,   115,    -1,    -1,   118,   119,
     3877      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3878      -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,
     3879      -1,    -1,    -1,    74,    75,    -1,    -1,    -1,    -1,   111,
     3880      -1,    -1,    -1,   115,    -1,    -1,   118,   119,    -1,    -1,
     3881      -1,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     3882      19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
     3883     111,    30,    31,    32,    -1,    -1,    -1,   118,   119,    -1,
     3884      39,    10,    11,    12,    13,    14,    15,    16,    17,    18,
     3885      19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
     3886      -1,    30,    31,    32,    -1,    -1,    -1,    -1,    67,    -1,
     3887      39,    -1,    -1,    -1,    -1,    74,    75,    -1,    -1,    10,
     3888      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
     3889      21,    22,    23,    24,    25,    26,    27,    -1,    67,    30,
     3890      31,    32,    33,    34,    35,    74,    75,    -1,    39,    -1,
     3891      -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,   118,
     3892     119,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3893      -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,
     3894      -1,    -1,   111,    74,    75,    -1,    -1,    -1,    -1,   118,
     3895     119,     4,     5,     6,     7,     8,     9,    10,    11,    12,
     3896      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     3897      23,    24,    25,    26,    27,    -1,    -1,    30,    31,    32,
     3898      -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,    37,    38,
     3899      -1,    40,    41,    -1,    43,    -1,    -1,    46,    47,    48,
     3900      49,    50,    51,    52,    53,    -1,    -1,    56,    57,    -1,
     3901      -1,    -1,    61,    62,    67,    64,    69,    66,    71,    -1,
     3902      -1,    74,    75,    72,    -1,    -1,    -1,    76,    -1,    -1,
     3903      79,    80,    81,    82,    83,    84,    -1,    86,    87,    -1,
     3904      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3905      -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,    -1,
     3906     109,    -1,   111,    -1,    -1,   114,    -1,    -1,    -1,   118,
     3907     119,   120,   121,   122,   123,    -1,    -1,    -1,    -1,   128,
     3908      -1,    37,    38,   132,    40,    41,    -1,    43,    -1,    -1,
     3909      46,    47,    48,    49,    50,    51,    52,    53,    -1,    -1,
     3910      -1,    57,    -1,    -1,    -1,    61,    62,    -1,    64,    -1,
     3911      66,    -1,    -1,    -1,    -1,    -1,    72,    -1,    -1,    -1,
     3912      76,    -1,    -1,    79,    80,    81,    82,    83,    84,    -1,
     3913      86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3914      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3915      -1,    -1,    -1,   109,    -1,   111,    -1,    -1,   114,    -1,
     3916      -1,    -1,   118,   119,   120,   121,   122,   123,    -1,    -1,
     3917      -1,    -1,   128,    -1,    -1,    -1,   132,     4,     5,     6,
     3918       7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     3919      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     3920      27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
     3921      -1,    -1,    39,    -1,    37,    38,    -1,    40,    41,    -1,
     3922      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
     3923      53,    -1,    -1,    56,    57,    -1,    -1,    -1,    61,    62,
     3924      67,    64,    69,    66,    71,    -1,    -1,    74,    75,    72,
     3925      -1,    -1,    -1,    76,    -1,    -1,    79,    80,    81,    82,
     3926      83,    84,    -1,    86,    87,    -1,    -1,    -1,    -1,    96,
     3927      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3928      -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,   111,    -1,
     3929      -1,   114,    -1,    -1,    -1,   118,   119,   120,   121,   122,
     3930     123,    -1,    -1,    37,    38,   128,    40,    41,    -1,    43,
     3931      44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
     3932      -1,    -1,    -1,    57,    -1,    -1,    -1,    61,    62,    -1,
     3933      64,    -1,    66,    -1,    -1,    -1,    -1,    -1,    72,    -1,
     3934      -1,    -1,    76,    -1,    -1,    79,    80,    81,    82,    83,
     3935      84,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,
     3936      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3937      -1,    -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,
     3938     114,    -1,    -1,    -1,   118,   119,   120,   121,   122,   123,
     3939      -1,    -1,    37,    38,   128,    40,    41,    -1,    43,    -1,
     3940      -1,    46,    47,    48,    49,    50,    51,    52,    53,    -1,
     3941      -1,    -1,    57,    -1,    -1,    -1,    61,    62,    -1,    64,
     3942      -1,    66,    -1,    -1,    -1,    -1,    -1,    72,    -1,    -1,
     3943      -1,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
     3944      -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3945      37,    38,    -1,    40,    -1,    -1,    -1,    -1,    -1,    -1,
     3946      -1,    -1,    -1,    -1,   109,    -1,   111,    -1,    -1,   114,
     3947      -1,    -1,    -1,   118,   119,   120,   121,   122,   123,    66,
     3948      -1,    -1,    -1,   128,    -1,    72,    -1,    -1,    -1,    76,
     3949      -1,    -1,    79,    80,    81,    82,    83,    84,    -1,    86,
     3950      87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,
     3951      -1,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3952      -1,    -1,   109,    -1,   111,    -1,    -1,    37,    38,    -1,
     3953      40,   118,   119,   120,   121,   122,   123,    66,    -1,    -1,
     3954      -1,    -1,    -1,    72,    -1,    -1,    -1,    76,    -1,    -1,
     3955      79,    80,    81,    82,    83,    84,    66,    86,    87,    -1,
     3956      -1,    -1,    72,    -1,    -1,    -1,    76,    -1,    -1,    79,
     3957      80,    81,    82,    83,    84,    -1,    86,    87,    -1,    -1,
     3958     109,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,   118,
     3959     119,   120,   121,   122,   123,    -1,    -1,    -1,    -1,   109,
     3960      -1,    -1,    -1,    -1,    37,    38,    -1,    40,   118,   119,
     3961     120,   121,   122,   123,    66,    -1,    -1,    -1,    -1,    -1,
     3962      72,    -1,    -1,    -1,    76,    -1,    -1,    79,    80,    81,
     3963      82,    83,    84,    66,    86,    87,    -1,    -1,    -1,    72,
     3964      -1,    -1,    -1,    76,    -1,    -1,    79,    80,    81,    82,
     3965      83,    84,    -1,    86,    87,    -1,    -1,   109,    -1,    -1,
     3966      -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,
     3967     122,   123,    -1,    -1,    -1,    -1,   109,    -1,    -1,    -1,
     3968      -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,
     3969     123,     4,     5,     6,     7,     8,     9,    10,    11,    12,
     3970      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     3971      23,    24,    25,    26,    27,    -1,    -1,    -1,    -1,    -1,
     3972      -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,
     3973      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3974      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     3975      -1,    -1,    -1,    -1,    67,    -1,    69,    -1,    71,    72,
     3976      -1,    74,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,
     3977      83,    84,     3,     4,     5,     6,     7,     8,     9,    10,
    38193978      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    38203979      21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
    … …  
    38233982      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    38243983      -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    69,    -1,
    3825       71,    -1,    -1,    74,    75,    -1,    -1,    -1,    -1,    -1,
    3826       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3827       -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,
    3828       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,
    3829      111,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,     4,
    3830        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3831       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3832       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    3833       -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
    3834       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3835       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3836       -1,    -1,    67,    -1,    69,    -1,    71,    -1,    -1,    74,
    3837       75,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3838       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,
    3839       -1,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3840       -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,
    3841       -1,    -1,    -1,   118,   119,     4,     5,     6,     7,     8,
    3842        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    3843       19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
    3844       -1,    30,    31,    32,    -1,    -1,    -1,    -1,    -1,    -1,
    3845       39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3846       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3847       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,
    3848       69,    -1,    71,    -1,    -1,    74,    75,    -1,    -1,    -1,
    3849       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3850       -1,    -1,    -1,    -1,    -1,    94,    -1,    96,    -1,    -1,
    3851       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3852       -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,   118,
    3853      119,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    3854       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    3855       23,    24,    25,    26,    27,    -1,    -1,    30,    31,    32,
    3856       -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,
    3857       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3858       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3859       -1,    -1,    -1,    -1,    67,    -1,    69,    -1,    71,    -1,
    3860       -1,    74,    75,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3861       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3862       -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3863       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,
    3864       -1,    -1,    -1,    -1,    -1,   118,   119,     4,     5,     6,
    3865        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    3866       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    3867       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    3868       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3869       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3870       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3871       67,    -1,    69,    -1,    71,    -1,    -1,    74,    75,    -1,
    3872       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3873       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    3874       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3875       -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,
    3876       -1,   118,   119,     4,     5,     6,     7,     8,     9,    10,
    3877       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    3878       21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
    3879       31,    32,    -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,
    3880       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3881       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3882       -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    69,    -1,
    3883       71,    -1,    -1,    74,    75,    -1,    -1,    -1,    -1,    -1,
    3884       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3885       -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,
    3886       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3887      111,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,     4,
    3888        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    3889       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3890       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    3891       -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
    3892       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3893       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3894       -1,    -1,    67,    -1,    69,    -1,    71,    -1,    -1,    74,
    3895       75,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    3896       19,    20,    21,    22,    23,    24,    25,    26,    27,    94,
    3897       -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,    38,
    3898       39,    40,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,
    3899       -1,    -1,    -1,   118,   119,    -1,    -1,    -1,    -1,    -1,
    3900       -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    -1,
    3901       -1,    -1,    -1,    72,    -1,    74,    75,    76,    -1,    -1,
    3902       79,    80,    81,    82,    83,    84,    -1,    86,    87,    -1,
    3903       -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,
    3904       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3905      109,    -1,   111,    -1,    -1,   114,    -1,    -1,    -1,   118,
    3906      119,   120,   121,   122,   123,    10,    11,    12,    13,    14,
    3907       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3908       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    3909       -1,    -1,    37,    38,    39,    40,    -1,    -1,    -1,    -1,
    3910       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3911       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3912       -1,    66,    67,    -1,    -1,    -1,    -1,    72,    -1,    74,
    3913       75,    76,    -1,    -1,    79,    80,    81,    82,    83,    84,
    3914       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,
    3915       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3916       -1,    -1,    -1,    -1,   109,   110,   111,    -1,    -1,    -1,
    3917       -1,    -1,    -1,   118,   119,   120,   121,   122,   123,    10,
    3918       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    3919       21,    22,    23,    24,    25,    26,    27,    -1,    -1,    30,
    3920       31,    32,    -1,    -1,    -1,    -1,    37,    38,    39,    40,
    3921       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3922       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3923       -1,    -1,    -1,    -1,    -1,    66,    67,    -1,    -1,    -1,
    3924       -1,    72,    -1,    74,    75,    76,    -1,    -1,    79,    80,
    3925       81,    82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,
    3926       -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,
    3927       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,
    3928      111,    -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,
    3929      121,   122,   123,    10,    11,    12,    13,    14,    15,    16,
    3930       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    3931       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    3932       37,    38,    39,    40,    -1,    -1,    -1,    -1,    -1,    -1,
    3933       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3934       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,
    3935       67,    -1,    -1,    -1,    -1,    72,    -1,    74,    75,    76,
    3936       -1,    -1,    79,    80,    81,    82,    83,    84,    -1,    86,
    3937       87,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    3938       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3939       -1,    -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,
    3940       -1,   118,   119,   120,   121,   122,   123,    10,    11,    12,
    3941       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    3942       23,    24,    25,    26,    27,    -1,    -1,    30,    31,    32,
    3943       -1,    -1,    -1,    -1,    37,    38,    39,    40,    -1,    -1,
    3944       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3945       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3946       -1,    -1,    -1,    66,    67,    -1,    -1,    -1,    -1,    72,
    3947       -1,    74,    75,    76,    -1,    -1,    79,    80,    81,    82,
    3948       83,    84,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,
    3949       -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3950       -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,   111,    -1,
    3951       -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,   122,
    3952      123,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    3953       19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
    3954       -1,    30,    31,    32,    -1,    -1,    -1,    -1,    37,    38,
    3955       39,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3956       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3957       -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    -1,
    3958       -1,    -1,    -1,    72,    -1,    74,    75,    76,    -1,    -1,
    3959       79,    80,    81,    82,    83,    84,    -1,    86,    87,    -1,
    3960       -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,
    3961       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3962      109,    -1,   111,    -1,    -1,    -1,    -1,    -1,    -1,   118,
    3963      119,   120,   121,   122,   123,     3,     4,     5,     6,     7,
     3984      71,    -1,    -1,    74,    75,     3,     4,     5,     6,     7,
    39643985       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
    39653986      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
    39663987      -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,    -1,
    3967       -1,    39,    -1,    -1,    -1,    10,    11,    12,    13,    14,
    3968       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    3969       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    67,
    3970       -1,    69,    -1,    71,    39,    -1,    74,    75,    -1,    -1,
    3971       -1,    -1,    -1,    10,    11,    12,    13,    14,    15,    16,
    3972       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    3973       27,    -1,    67,    30,    31,    32,    -1,    72,    -1,    74,
    3974       75,    76,    39,    -1,    -1,    -1,   114,    -1,    83,    84,
    3975       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,
     3988      -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    39763989      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3977       67,    -1,    -1,    -1,   109,    72,   111,    74,    75,    76,
    3978       -1,    -1,    -1,   118,   119,    -1,    83,    84,    -1,    -1,
    3979       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    3980       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3981       -1,    -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,
    3982       -1,   118,   119,    10,    11,    12,    13,    14,    15,    16,
    3983       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    3984       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    3985       -1,    -1,    39,    10,    11,    12,    13,    14,    15,    16,
    3986       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    3987       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    3988       67,    -1,    39,    -1,    -1,    72,    -1,    74,    75,    76,
    3989       -1,    -1,    -1,    -1,    -1,    -1,    83,    84,    -1,    -1,
    3990       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    3991       67,    -1,    -1,    -1,    -1,    72,    -1,    74,    75,    76,
    3992       -1,    -1,   109,    -1,   111,    -1,    83,    84,    -1,    -1,
    3993       -1,   118,   119,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    3994       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    3995       -1,    -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,
    3996       -1,   118,   119,    10,    11,    12,    13,    14,    15,    16,
    3997       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    3998       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    3999       -1,    -1,    39,    10,    11,    12,    13,    14,    15,    16,
    4000       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    4001       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    4002       67,    -1,    39,    -1,    -1,    72,    -1,    74,    75,    76,
    4003       -1,    -1,    -1,    -1,    -1,    -1,    83,    84,    -1,    -1,
    4004       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    4005       67,    -1,    -1,    -1,    -1,    72,    -1,    74,    75,    -1,
    4006       -1,    -1,    -1,    -1,   111,    -1,    83,    84,    -1,    -1,
    4007       -1,   118,   119,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    4008       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4009       -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,
    4010       -1,   118,   119,    10,    11,    12,    13,    14,    15,    16,
    4011       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    4012       27,    28,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    4013       -1,    -1,    39,    10,    11,    12,    13,    14,    15,    16,
    4014       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    4015       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    4016       67,    -1,    39,    40,    -1,    -1,    -1,    74,    75,    -1,
    4017       -1,    78,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4018       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    4019       67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,    -1,
    4020       -1,    -1,   109,    -1,   111,    -1,    -1,    -1,    -1,    -1,
    4021       -1,   118,   119,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    4022       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4023       -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,   115,    -1,
    4024       -1,   118,   119,    10,    11,    12,    13,    14,    15,    16,
    4025       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    4026       27,    28,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    4027       -1,    -1,    39,    10,    11,    12,    13,    14,    15,    16,
    4028       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    4029       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    4030       67,    -1,    39,    40,    -1,    -1,    -1,    74,    75,    -1,
    4031       -1,    78,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4032       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    4033       67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,    -1,
    4034       -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,    -1,
    4035       -1,   118,   119,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    4036       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4037       -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,   115,    -1,
    4038       -1,   118,   119,    10,    11,    12,    13,    14,    15,    16,
    4039       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    4040       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    4041       -1,    -1,    39,    40,    10,    11,    12,    13,    14,    15,
     3990      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,
     3991      -1,    69,    -1,    71,    -1,    -1,    74,    75,     4,     5,
     3992       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
    40423993      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    40433994      26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,
    4044       67,    -1,    -1,    39,    -1,    -1,    -1,    74,    75,    -1,
    4045       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4046       -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
    4047       -1,    67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,
    4048       -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,   115,    -1,
    4049       -1,   118,   119,    -1,    -1,    -1,    -1,    -1,    94,    -1,
    4050       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4051       -1,    -1,    -1,   109,    -1,   111,    -1,    -1,    -1,    -1,
    4052       -1,    -1,   118,   119,    10,    11,    12,    13,    14,    15,
    4053       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    4054       26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,
    4055       -1,    -1,    -1,    39,    10,    11,    12,    13,    14,    15,
    4056       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    4057       26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,
    4058       -1,    67,    -1,    39,    -1,    -1,    -1,    -1,    74,    75,
    4059       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4060       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,
    4061       -1,    67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,
    4062       -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
    4063       -1,    -1,   118,   119,    -1,    -1,    -1,    -1,    94,    -1,
    4064       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4065       -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
    4066       -1,    -1,   118,   119,    10,    11,    12,    13,    14,    15,
    4067       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    4068       26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,
    4069       -1,    -1,    -1,    39,    10,    11,    12,    13,    14,    15,
    4070       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    4071       26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,
    4072       -1,    67,    -1,    39,    -1,    -1,    -1,    -1,    74,    75,
    4073       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4074       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,
    4075       -1,    67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,
    4076       -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
    4077       -1,    -1,   118,   119,    -1,    -1,    -1,    -1,    94,    -1,
    4078       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4079       -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
    4080       -1,    -1,   118,   119,    10,    11,    12,    13,    14,    15,
    4081       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    4082       26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,
    4083       -1,    -1,    -1,    39,    10,    11,    12,    13,    14,    15,
    4084       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    4085       26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,
    4086       -1,    67,    -1,    39,    -1,    -1,    -1,    -1,    74,    75,
    4087       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4088       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,
    4089       -1,    67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,
    4090       -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
    4091       -1,    -1,   118,   119,    -1,    -1,    -1,    -1,    94,    -1,
    4092       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4093       -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
    4094       -1,    -1,   118,   119,    10,    11,    12,    13,    14,    15,
    4095       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    4096       26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,
    4097       -1,    -1,    -1,    39,    10,    11,    12,    13,    14,    15,
    4098       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    4099       26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,
    4100       -1,    67,    -1,    39,    -1,    -1,    -1,    -1,    74,    75,
    4101       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4102       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,
    4103       -1,    67,    -1,    -1,    -1,    -1,    -1,    -1,    74,    75,
    4104       -1,    -1,    -1,    -1,    -1,   111,    -1,    -1,    -1,    -1,
    4105       -1,    -1,   118,   119,    -1,    -1,    -1,    -1,    94,    -1,
     3995      -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
    41063996      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    41073997      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4108       -1,    -1,   118,   119,     4,     5,     6,     7,     8,     9,
    4109       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
    4110       20,    21,    22,    23,    24,    25,    26,    27,    -1,    -1,
    4111       30,    31,    32,    -1,    -1,    -1,    -1,    -1,    -1,    39,
    4112       -1,    37,    38,    -1,    40,    41,    -1,    43,    -1,    -1,
    4113       46,    47,    48,    49,    50,    51,    52,    53,    -1,    -1,
    4114       56,    57,    -1,    -1,    -1,    61,    62,    67,    64,    69,
    4115       66,    71,    -1,    -1,    74,    75,    72,    -1,    -1,    -1,
    4116       76,    -1,    -1,    79,    80,    81,    82,    83,    84,    -1,
    4117       86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,    -1,
    4118       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4119      110,    -1,    -1,   109,    -1,   111,    -1,    -1,   114,    -1,
    4120       -1,    -1,   118,   119,   120,   121,   122,   123,    -1,    -1,
    4121       -1,    -1,   128,    -1,    37,    38,   132,    40,    41,    -1,
    4122       43,    -1,    -1,    46,    47,    48,    49,    50,    51,    52,
    4123       53,    -1,    -1,    -1,    57,    -1,    -1,    -1,    61,    62,
    4124       -1,    64,    -1,    66,    -1,    -1,    -1,    -1,    -1,    72,
    4125       -1,    -1,    -1,    76,    -1,    -1,    79,    80,    81,    82,
    4126       83,    84,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,
    4127       -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4128       -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,   111,    -1,
    4129       -1,   114,    -1,    -1,    -1,   118,   119,   120,   121,   122,
    4130      123,    -1,    -1,    -1,    -1,   128,    -1,    -1,    -1,   132,
    4131        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
    4132       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
    4133       24,    25,    26,    27,    -1,    -1,    30,    31,    32,    -1,
    4134       -1,    -1,    -1,    -1,    -1,    39,    -1,    37,    38,    -1,
    4135       40,    41,    -1,    43,    44,    45,    46,    47,    48,    49,
    4136       50,    51,    52,    53,    -1,    -1,    56,    57,    -1,    -1,
    4137       -1,    61,    62,    67,    64,    69,    66,    71,    -1,    -1,
    4138       74,    75,    72,    -1,    -1,    -1,    76,    -1,    -1,    79,
    4139       80,    81,    82,    83,    84,    -1,    86,    87,    -1,    -1,
    4140       -1,    -1,    96,    -1,    94,    -1,    -1,    -1,    -1,    -1,
    4141       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,
    4142       -1,   111,    -1,    -1,   114,    -1,    -1,    -1,   118,   119,
    4143      120,   121,   122,   123,    -1,    -1,    37,    38,   128,    40,
    4144       41,    -1,    43,    44,    45,    46,    47,    48,    49,    50,
    4145       51,    52,    53,    -1,    -1,    -1,    57,    -1,    -1,    -1,
    4146       61,    62,    -1,    64,    -1,    66,    -1,    -1,    -1,    -1,
    4147       -1,    72,    -1,    -1,    -1,    76,    -1,    -1,    79,    80,
    4148       81,    82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,
    4149       -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,
    4150       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,
    4151      111,    -1,    -1,   114,    -1,    -1,    -1,   118,   119,   120,
    4152      121,   122,   123,    -1,    -1,    37,    38,   128,    40,    41,
    4153       -1,    43,    -1,    -1,    46,    47,    48,    49,    50,    51,
    4154       52,    53,    -1,    -1,    -1,    57,    -1,    -1,    -1,    61,
    4155       62,    -1,    64,    -1,    66,    -1,    -1,    -1,    -1,    -1,
    4156       72,    -1,    -1,    -1,    76,    -1,    -1,    79,    80,    81,
    4157       82,    83,    84,    -1,    86,    87,    -1,    -1,    -1,    -1,
    4158       -1,    -1,    94,    37,    38,    -1,    40,    -1,    -1,    -1,
    4159       -1,    -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,   111,
    4160       -1,    -1,   114,    -1,    -1,    -1,   118,   119,   120,   121,
    4161      122,   123,    66,    -1,    -1,    -1,   128,    -1,    72,    -1,
    4162       74,    75,    76,    -1,    -1,    79,    80,    81,    82,    83,
    4163       84,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,
    4164       94,    37,    38,    -1,    40,    -1,    -1,    -1,    -1,    -1,
    4165       -1,    -1,    -1,    -1,    -1,   109,    -1,   111,    -1,   113,
    4166      114,    -1,    -1,    -1,   118,   119,   120,   121,   122,   123,
    4167       66,    -1,    -1,    -1,    -1,    -1,    72,    -1,    -1,    -1,
    4168       76,    -1,    -1,    79,    80,    81,    82,    83,    84,    -1,
    4169       86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    94,    37,
    4170       38,    -1,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4171       -1,    -1,    -1,   109,    -1,   111,    -1,    -1,    37,    38,
    4172       -1,    40,   118,   119,   120,   121,   122,   123,    66,    -1,
    4173       -1,    -1,    -1,    -1,    72,    -1,    -1,    -1,    76,    -1,
    4174       -1,    79,    80,    81,    82,    83,    84,    66,    86,    87,
    4175       -1,    -1,    -1,    72,    -1,    -1,    94,    76,    -1,    -1,
    4176       79,    80,    81,    82,    83,    84,    -1,    86,    87,    -1,
    4177       -1,   109,    -1,   111,    -1,    94,    37,    38,    -1,    40,
    4178      118,   119,   120,   121,   122,   123,    -1,    -1,    -1,    -1,
    4179      109,    -1,   111,    -1,    -1,    37,    38,    -1,    40,   118,
    4180      119,   120,   121,   122,   123,    66,    -1,    -1,    -1,    -1,
    4181       -1,    72,    -1,    -1,    -1,    76,    -1,    -1,    79,    80,
    4182       81,    82,    83,    84,    66,    86,    87,    -1,    -1,    -1,
    4183       72,    -1,    -1,    94,    76,    -1,    -1,    79,    80,    81,
    4184       82,    83,    84,    -1,    86,    87,    -1,    -1,   109,    -1,
    4185       -1,    -1,    94,    -1,    -1,    -1,    -1,   118,   119,   120,
    4186      121,   122,   123,    -1,    -1,    -1,    -1,   109,    -1,    -1,
    4187       -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,
    4188      122,   123,     4,     5,     6,     7,     8,     9,    10,    11,
    4189       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
    4190       22,    23,    24,    25,    26,    27,    -1,    -1,    -1,    -1,
    4191       -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,
    4192       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4193       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4194       -1,    -1,    -1,    -1,    -1,    67,    -1,    69,    -1,    71,
    4195       72,    -1,    74,    75,    76,    -1,    -1,    -1,    -1,    -1,
    4196       -1,    83,    84,     3,     4,     5,     6,     7,     8,     9,
    4197       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
    4198       20,    21,    22,    23,    24,    25,    26,    27,    -1,    -1,
    4199       30,    31,    32,    -1,    -1,    -1,    -1,    -1,    -1,    39,
    4200       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4201       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4202       -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    69,
    4203       -1,    71,    -1,    -1,    74,    75,     3,     4,     5,     6,
    4204        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    4205       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    4206       27,    -1,    -1,    30,    31,    32,    -1,    -1,    -1,    -1,
    4207       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4208       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4209       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4210       67,    -1,    69,    -1,    71,    -1,    -1,    74,    75,     4,
    4211        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    4212       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    4213       25,    26,    27,    -1,    -1,    30,    31,    32,    -1,    -1,
    4214       -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
    4215       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4216       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    4217       -1,    -1,    67,    -1,    69,    -1,    71,    -1,    -1,    74,
    4218       75
     3998      -1,    67,    -1,    69,    -1,    71,    -1,    -1,    74,    75
    42193999};
    42204000
    … …  
    42274007      22,    23,    24,    25,    26,    27,    30,    31,    32,    33,
    42284008      36,    39,    40,    64,    67,    69,    71,    72,    74,    75,
    4229       76,    83,    84,    94,   109,   111,   118,   119,   137,   140,
    4230      149,   198,   212,   213,   214,   215,   216,   217,   218,   219,
    4231      220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
    4232      231,   232,   233,   234,   235,   236,   237,   238,   240,   241,
    4233      242,   243,   244,   245,   247,   255,   256,   283,   284,   285,
    4234      293,   296,   302,   303,   305,   307,   308,   314,   319,   323,
    4235      324,   325,   326,   327,   328,   329,   330,   350,   367,   368,
    4236      369,   370,    72,   139,   140,   149,   215,   217,   225,   227,
    4237      237,   241,   243,   284,    82,   109,   312,   313,   314,   312,
    4238      312,    72,    74,    75,    76,   138,   139,   273,   274,   294,
    4239      295,    74,    75,   274,   109,   305,    11,   199,   109,   149,
    4240      319,   324,   325,   326,   328,   329,   330,   112,   134,   111,
    4241      218,   225,   227,   323,   327,   366,   367,   370,   371,   135,
    4242      107,   131,   277,   114,   135,   173,    74,    75,   137,   272,
    4243      135,   135,   135,   116,   135,    74,    75,   109,   149,   309,
    4244      318,   319,   320,   321,   322,   323,   327,   331,   332,   333,
    4245      334,   335,   341,     3,    28,    78,   239,     3,     5,    74,
    4246      111,   149,   217,   228,   232,   235,   244,   285,   323,   327,
    4247      370,   215,   217,   227,   237,   241,   243,   284,   323,   327,
    4248       33,   233,   233,   228,   235,   135,   233,   228,   233,   228,
    4249       75,   109,   114,   274,   285,   114,   274,   233,   228,   116,
    4250      135,   135,     0,   134,   109,   173,   312,   312,   134,   111,
    4251      225,   227,   368,   272,   272,   131,   227,   109,   149,   309,
    4252      319,   323,   111,   149,   370,   306,   230,   314,   109,   290,
    4253      109,   109,    51,   109,    37,    38,    40,    66,    72,    76,
    4254       79,    80,    81,    82,    86,    87,   109,   111,   120,   121,
    4255      122,   123,   136,   140,   141,   142,   143,   148,   149,   150,
    4256      151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
    4257      161,   162,   164,   166,   225,   276,   292,   366,   371,   227,
    4258      110,   110,   110,   110,   110,   110,   110,    74,    75,   111,
    4259      225,   272,   350,   368,   111,   118,   149,   164,   217,   218,
    4260      224,   227,   231,   232,   237,   240,   241,   243,   262,   263,
    4261      267,   268,   269,   270,   284,   350,   362,   363,   364,   365,
    4262      370,   371,   112,   109,   323,   327,   370,   109,   116,   132,
    4263      111,   114,   149,   164,   278,   278,   115,   134,   116,   132,
    4264      109,   116,   132,   116,   132,   116,   132,   312,   132,   319,
    4265      320,   321,   322,   332,   333,   334,   335,   227,   318,   331,
    4266       64,   311,   111,   312,   349,   350,   312,   312,   173,   134,
    4267      109,   312,   349,   312,   312,   227,   309,   109,   109,   226,
    4268      227,   225,   227,   112,   134,   225,   366,   371,   173,   134,
    4269      272,   277,   217,   232,   323,   327,   173,   134,   294,   227,
    4270      237,   132,   227,   227,   292,   248,   246,   258,   274,   257,
    4271      227,   294,   132,   132,   305,   134,   139,   271,     3,   135,
    4272      207,   208,   222,   224,   227,   134,   311,   109,   311,   164,
    4273      319,   227,   109,   134,   272,   114,    33,    34,    35,   225,
    4274      286,   287,   289,   134,   129,   131,   291,   134,   228,   234,
    4275      235,   272,   315,   316,   317,   109,   141,   109,   148,   109,
    4276      148,   151,   109,   148,   109,   109,   148,   148,   111,   164,
    4277      169,   173,   225,   275,   366,   370,   112,   134,    82,    85,
    4278       86,    87,   109,   111,   113,   114,    97,    98,    99,   100,
    4279      101,   102,   103,   104,   105,   106,   131,   168,   151,   151,
    4280      118,   124,   125,   120,   121,    88,    89,    90,    91,   126,
    4281      127,    92,    93,   119,   128,   129,    94,    95,   130,   131,
    4282      373,   109,   149,   345,   346,   347,   348,   349,   110,   116,
    4283      109,   349,   350,   109,   349,   350,   134,   109,   225,   368,
    4284      112,   134,   135,   111,   225,   227,   361,   362,   370,   371,
    4285      135,   109,   111,   149,   319,   336,   337,   338,   339,   340,
    4286      341,   342,   343,   344,   350,   351,   352,   353,   354,   355,
    4287      356,   149,   370,   227,   135,   135,   149,   225,   227,   363,
    4288      272,   225,   350,   363,   272,   109,   134,   134,   134,   112,
    4289      134,    72,    80,   111,   113,   140,   274,   278,   279,   280,
    4290      281,   282,   134,   134,   134,   134,   134,   134,   309,   110,
    4291      110,   110,   110,   110,   110,   110,   318,   331,   109,   277,
    4292      112,   207,   134,   309,   169,   276,   169,   276,   309,   111,
    4293      207,   311,   173,   134,   207,   110,    40,   111,   115,   225,
    4294      249,   250,   251,   366,   114,   116,   372,   131,   259,   114,
    4295      227,   264,   265,   266,   269,   270,   110,   116,   173,   134,
    4296      118,   164,   134,   224,   227,   263,   362,   370,   303,   304,
    4297      109,   149,   336,   110,   116,   373,   274,   286,   109,   114,
    4298      274,   276,   286,   110,   116,   109,   141,   110,   117,   275,
    4299      275,   275,   111,   139,   145,   164,   276,   275,   112,   134,
    4300      110,   116,   110,   109,   149,   349,   357,   358,   359,   360,
    4301      110,   116,   164,   111,   139,   111,   144,   145,   134,   111,
    4302      139,   144,   164,   164,   151,   151,   151,   152,   152,   153,
    4303      153,   154,   154,   154,   154,   155,   155,   156,   157,   158,
    4304      159,   160,   117,   169,   164,   134,   346,   347,   348,   227,
    4305      345,   312,   312,   164,   276,   134,   271,   134,   225,   350,
    4306      363,   227,   231,   112,   112,   134,   370,   112,   109,   134,
    4307      319,   337,   338,   339,   342,   352,   353,   354,   112,   134,
    4308      227,   336,   340,   351,   109,   312,   355,   373,   312,   312,
    4309      373,   109,   312,   355,   312,   312,   312,   312,   350,   225,
    4310      361,   371,   272,   112,   116,   112,   116,   373,   225,   363,
    4311      373,   260,   261,   262,   263,   260,   260,   272,   164,   134,
    4312      111,   274,   117,   116,   372,   278,    80,   111,   117,   282,
    4313       29,   209,   210,   272,   260,   139,   309,   139,   311,   109,
    4314      349,   350,   109,   349,   350,   141,   350,   173,   264,   110,
    4315      110,   110,   110,   112,   173,   207,   173,   114,   250,   251,
    4316      112,   134,   109,   117,   149,   252,   254,   318,   319,   331,
    4317      357,   116,   132,   116,   132,   274,   248,   274,   115,   162,
    4318      163,   258,   135,   135,   139,   222,   135,   135,   260,   109,
    4319      149,   370,   135,   115,   227,   287,   288,   135,   134,   134,
    4320      109,   135,   110,   316,   169,   170,   117,   132,   111,   141,
    4321      200,   201,   202,   110,   116,   110,   134,   117,   110,   110,
    4322      110,   111,   164,   358,   359,   360,   227,   357,   312,   312,
    4323      114,   151,   166,   164,   165,   167,   116,   135,   134,   134,
    4324      110,   116,   164,   134,   115,   162,   117,   264,   110,   110,
    4325      110,   345,   264,   110,   260,   225,   363,   111,   118,   149,
    4326      164,   164,   227,   342,   264,   110,   110,   110,   110,   110,
    4327      110,   110,     7,   227,   336,   340,   351,   134,   134,   373,
    4328      134,   134,   110,   135,   135,   135,   135,   277,   135,   162,
    4329      163,   164,   310,   134,   278,   280,   115,   134,   211,   274,
    4330       40,    41,    43,    46,    47,    48,    49,    50,    51,    52,
    4331       53,    57,    61,    62,    72,   111,   128,   170,   171,   172,
    4332      173,   174,   175,   177,   178,   190,   192,   193,   198,   212,
    4333      308,    29,   135,   131,   277,   134,   134,   110,   135,   173,
    4334      248,   132,   132,   319,   163,   227,   253,   254,   253,   274,
    4335      312,   115,   259,   372,   110,   116,   112,   112,   135,   227,
    4336      116,   373,   290,   110,   286,   215,   217,   225,   298,   299,
    4337      300,   301,   292,   110,   110,   117,   163,   109,   110,   117,
    4338      116,   139,   164,   164,   112,   110,   110,   110,   357,   279,
    4339      116,   135,   167,   112,   139,   146,   147,   164,   145,   135,
    4340      146,   162,   166,   135,   109,   349,   350,   135,   135,   134,
    4341      135,   135,   135,   164,   110,   135,   109,   349,   350,   109,
    4342      355,   109,   355,   350,   226,     7,   118,   135,   164,   264,
    4343      264,   263,   267,   267,   268,   116,   116,   110,   110,   112,
    4344       96,   123,   135,   135,   146,   278,   164,   116,   132,   212,
    4345      216,   227,   231,   109,   109,   171,   109,   109,    72,   132,
    4346       72,   132,    72,   118,   170,   109,   173,   165,   165,   117,
    4347      112,   143,   132,   135,   134,   135,   211,   110,   164,   264,
    4348      264,   312,   110,   115,   252,   115,   134,   110,   134,   135,
    4349      309,   115,   134,   135,   135,   110,   114,   200,   112,   163,
    4350      132,   200,   202,   110,   116,   135,   109,   349,   350,   372,
    4351      165,   112,   135,    85,   113,   116,   135,   135,   112,   135,
    4352      110,   134,   110,   110,   112,   112,   112,   135,   110,   134,
    4353      134,   134,   164,   164,   135,   112,   135,   135,   135,   135,
    4354      134,   134,   163,   163,   112,   112,   135,   135,   274,   227,
    4355      169,   169,    47,   169,   134,   132,   132,   132,   169,   132,
    4356      169,    58,    59,    60,   194,   195,   196,   132,    63,   132,
    4357      312,   114,   175,   115,   132,   135,   135,    96,   269,   270,
    4358      110,   299,   116,   132,   116,   132,   115,   297,   117,   141,
    4359      110,   110,   117,   167,   112,   134,   115,   112,   111,   147,
    4360      111,   147,   147,   112,   112,   112,   264,   112,   264,   264,
    4361      264,   135,   135,   112,   112,   110,   110,   112,   116,    96,
    4362      263,    96,   135,   112,   112,   110,   110,   109,   110,   170,
    4363      191,   212,   132,   110,   109,   109,   173,   196,    58,    59,
    4364      164,   171,   144,   110,   110,   114,   134,   134,   298,   141,
    4365      203,   109,   132,   203,   135,   117,   264,   134,   134,   135,
    4366      135,   135,   135,   112,   112,   134,   135,   112,   171,    44,
    4367       45,   114,   181,   182,   183,   169,   171,   135,   110,   170,
    4368      114,   183,    96,   134,    96,   134,   109,   109,   132,   115,
    4369      134,   272,   309,   115,   116,   117,   163,   110,   112,   164,
    4370      135,   146,   146,   110,   110,   110,   110,   267,    42,   163,
    4371      179,   180,   310,   117,   134,   171,   181,   110,   132,   171,
    4372      132,   134,   110,   134,   110,   134,    96,   134,    96,   134,
    4373      132,   298,   141,   139,   204,   110,   132,   117,   110,   135,
    4374      135,   171,    96,   116,   117,   135,   205,   206,   212,   132,
    4375      170,   170,   205,   173,   197,   225,   366,   173,   197,   110,
    4376      134,   110,   134,   115,   110,   116,   164,   112,   112,   163,
    4377      179,   182,   184,   185,   134,   132,   182,   186,   187,   135,
    4378      109,   149,   309,   357,   139,   135,   173,   197,   173,   197,
    4379      109,   132,   139,   171,   176,   115,   182,   212,   170,    56,
    4380      176,   189,   115,   182,   110,   227,   110,   135,   135,   292,
    4381      171,   176,   132,   188,   189,   176,   189,   173,   173,   110,
    4382      110,   110,   188,   135,   135,   173,   173,   135,   135
     4009      76,    83,    84,   109,   111,   118,   119,   137,   140,   149,
     4010     198,   212,   213,   214,   215,   216,   217,   218,   219,   220,
     4011     221,   222,   223,   224,   225,   226,   227,   228,   229,   231,
     4012     232,   233,   234,   235,   236,   237,   238,   240,   241,   242,
     4013     243,   244,   245,   247,   255,   256,   283,   284,   285,   293,
     4014     296,   302,   303,   305,   307,   308,   314,   319,   323,   324,
     4015     325,   326,   327,   328,   329,   330,   350,   367,   368,   369,
     4016     370,    72,   139,   140,   149,   215,   217,   225,   227,   237,
     4017     241,   243,   284,    82,   109,   312,   313,   314,   312,   312,
     4018      72,    74,    75,    76,   138,   139,   273,   274,   294,   295,
     4019      74,    75,   274,   109,   305,    11,   199,   109,   149,   319,
     4020     324,   325,   326,   328,   329,   330,   112,   134,   111,   218,
     4021     225,   227,   323,   327,   366,   367,   370,   371,   135,   107,
     4022     131,   277,   114,   135,   173,    74,    75,   137,   272,   135,
     4023     135,   135,   116,   135,    74,    75,   109,   149,   309,   318,
     4024     319,   320,   321,   322,   323,   327,   331,   332,   333,   334,
     4025     335,   341,     3,    28,    78,   239,     3,     5,    74,   111,
     4026     149,   217,   228,   232,   235,   244,   285,   323,   327,   370,
     4027     215,   217,   227,   237,   241,   243,   284,   323,   327,    33,
     4028     233,   233,   228,   235,   135,   233,   228,   233,   228,    75,
     4029     109,   114,   274,   285,   114,   274,   233,   228,   116,   135,
     4030     135,     0,   134,   109,   173,   312,   312,   134,   111,   225,
     4031     227,   368,   272,   272,   131,   227,   109,   149,   309,   319,
     4032     323,   111,   149,   370,   306,   230,   314,   109,   290,   109,
     4033     109,    51,   109,    37,    38,    40,    66,    72,    76,    79,
     4034      80,    81,    82,    86,    87,   109,   111,   120,   121,   122,
     4035     123,   136,   140,   141,   142,   143,   148,   149,   150,   151,
     4036     152,   153,   154,   155,   156,   157,   158,   159,   160,   161,
     4037     162,   164,   167,   225,   276,   292,   366,   371,   227,   110,
     4038     110,   110,   110,   110,   110,   110,    74,    75,   111,   225,
     4039     272,   350,   368,   111,   118,   149,   164,   217,   218,   224,
     4040     227,   231,   232,   237,   240,   241,   243,   262,   263,   267,
     4041     268,   269,   270,   284,   350,   362,   363,   364,   365,   370,
     4042     371,   112,   109,   323,   327,   370,   109,   116,   132,   111,
     4043     114,   149,   164,   278,   278,   115,   134,   116,   132,   109,
     4044     116,   132,   116,   132,   116,   132,   312,   132,   319,   320,
     4045     321,   322,   332,   333,   334,   335,   227,   318,   331,    64,
     4046     311,   111,   312,   349,   350,   312,   312,   173,   134,   109,
     4047     312,   349,   312,   312,   227,   309,   109,   109,   226,   227,
     4048     225,   227,   112,   134,   225,   366,   371,   173,   134,   272,
     4049     277,   217,   232,   323,   327,   173,   134,   294,   227,   237,
     4050     132,   227,   227,   292,   248,   246,   258,   274,   257,   227,
     4051     294,   132,   132,   305,   134,   139,   271,     3,   135,   207,
     4052     208,   222,   224,   227,   134,   311,   109,   311,   164,   319,
     4053     227,   109,   134,   272,   114,    33,    34,    35,   225,   286,
     4054     287,   289,   134,   129,   131,   291,   134,   228,   234,   235,
     4055     272,   315,   316,   317,   109,   141,   109,   148,   109,   148,
     4056     151,   109,   148,   109,   109,   148,   148,   111,   164,   169,
     4057     173,   225,   275,   366,   370,   112,   134,    82,    85,    86,
     4058      87,   109,   111,   113,   114,    97,    98,    99,   100,   101,
     4059     102,   103,   104,   105,   106,   131,   166,   151,   151,   118,
     4060     124,   125,   120,   121,    88,    89,    90,    91,   126,   127,
     4061      92,    93,   119,   128,   129,    94,    95,   130,   131,   373,
     4062     109,   149,   345,   346,   347,   348,   349,   110,   116,   109,
     4063     349,   350,   109,   349,   350,   134,   109,   225,   368,   112,
     4064     134,   135,   111,   225,   227,   361,   362,   370,   371,   135,
     4065     109,   111,   149,   319,   336,   337,   338,   339,   340,   341,
     4066     342,   343,   344,   350,   351,   352,   353,   354,   355,   356,
     4067     149,   370,   227,   135,   135,   149,   225,   227,   363,   272,
     4068     225,   350,   363,   272,   109,   134,   134,   134,   112,   134,
     4069      72,    80,   111,   113,   140,   274,   278,   279,   280,   281,
     4070     282,   134,   134,   134,   134,   134,   134,   309,   110,   110,
     4071     110,   110,   110,   110,   110,   318,   331,   109,   277,   112,
     4072     207,   134,   309,   169,   276,   169,   276,   309,   111,   207,
     4073     311,   173,   134,   207,   110,    40,   111,   115,   225,   249,
     4074     250,   251,   366,   114,   116,   372,   131,   259,   114,   227,
     4075     264,   265,   266,   269,   270,   110,   116,   173,   134,   118,
     4076     164,   134,   224,   227,   263,   362,   370,   303,   304,   109,
     4077     149,   336,   110,   116,   373,   274,   286,   109,   114,   274,
     4078     276,   286,   110,   116,   109,   141,   110,   117,   275,   275,
     4079     275,   111,   139,   145,   164,   276,   275,   112,   134,   110,
     4080     116,   110,   109,   149,   349,   357,   358,   359,   360,   110,
     4081     116,   164,   111,   139,   111,   144,   145,   134,   111,   139,
     4082     144,   164,   151,   151,   151,   152,   152,   153,   153,   154,
     4083     154,   154,   154,   155,   155,   156,   157,   158,   159,   160,
     4084     117,   169,   164,   134,   346,   347,   348,   227,   345,   312,
     4085     312,   164,   276,   134,   271,   134,   225,   350,   363,   227,
     4086     231,   112,   112,   134,   370,   112,   109,   134,   319,   337,
     4087     338,   339,   342,   352,   353,   354,   112,   134,   227,   336,
     4088     340,   351,   109,   312,   355,   373,   312,   312,   373,   109,
     4089     312,   355,   312,   312,   312,   312,   350,   225,   361,   371,
     4090     272,   112,   116,   112,   116,   373,   225,   363,   373,   260,
     4091     261,   262,   263,   260,   260,   272,   164,   134,   111,   274,
     4092     117,   116,   372,   278,    80,   111,   117,   282,    29,   209,
     4093     210,   272,   260,   139,   309,   139,   311,   109,   349,   350,
     4094     109,   349,   350,   141,   350,   173,   264,   110,   110,   110,
     4095     110,   112,   173,   207,   173,   114,   250,   251,   112,   134,
     4096     109,   117,   149,   252,   254,   318,   319,   331,   357,   116,
     4097     132,   116,   132,   274,   248,   274,   115,   162,   163,   258,
     4098     135,   135,   139,   222,   135,   135,   260,   109,   149,   370,
     4099     135,   115,   227,   287,   288,   135,   134,   134,   109,   135,
     4100     110,   316,   169,   170,   117,   132,   111,   141,   200,   201,
     4101     202,   110,   116,   110,   134,   117,   110,   110,   110,   111,
     4102     164,   358,   359,   360,   227,   357,   312,   312,   114,   151,
     4103     167,   164,   165,   168,   116,   135,   134,   134,   110,   116,
     4104     164,   134,   115,   162,   117,   264,   110,   110,   110,   345,
     4105     264,   110,   260,   225,   363,   111,   118,   149,   164,   164,
     4106     227,   342,   264,   110,   110,   110,   110,   110,   110,   110,
     4107       7,   227,   336,   340,   351,   134,   134,   373,   134,   134,
     4108     110,   135,   135,   135,   135,   277,   135,   162,   163,   164,
     4109     310,   134,   278,   280,   115,   134,   211,   274,    40,    41,
     4110      43,    46,    47,    48,    49,    50,    51,    52,    53,    57,
     4111      61,    62,    72,   111,   128,   170,   171,   172,   173,   174,
     4112     175,   177,   178,   190,   192,   193,   198,   212,   308,    29,
     4113     135,   131,   277,   134,   134,   110,   135,   173,   248,   132,
     4114     132,   319,   163,   227,   253,   254,   253,   274,   312,   115,
     4115     259,   372,   110,   116,   112,   112,   135,   227,   116,   373,
     4116     290,   110,   286,   215,   217,   225,   298,   299,   300,   301,
     4117     292,   110,   110,   117,   163,   109,   110,   117,   116,   139,
     4118     164,   164,   112,   110,   110,   110,   357,   279,   116,   135,
     4119     168,   112,   139,   146,   147,   164,   145,   135,   146,   162,
     4120     167,   135,   109,   349,   350,   135,   135,   134,   135,   135,
     4121     135,   164,   110,   135,   109,   349,   350,   109,   355,   109,
     4122     355,   350,   226,     7,   118,   135,   164,   264,   264,   263,
     4123     267,   267,   268,   116,   116,   110,   110,   112,    96,   123,
     4124     135,   135,   146,   278,   164,   116,   132,   212,   216,   227,
     4125     231,   109,   109,   171,   109,   109,    72,   132,    72,   132,
     4126      72,   118,   170,   109,   173,   165,   165,   117,   112,   143,
     4127     132,   135,   134,   135,   211,   110,   164,   264,   264,   312,
     4128     110,   115,   252,   115,   134,   110,   134,   135,   309,   115,
     4129     134,   135,   135,   110,   114,   200,   112,   163,   132,   200,
     4130     202,   110,   116,   135,   109,   349,   350,   372,   165,   112,
     4131     135,    85,   113,   116,   135,   135,   112,   135,   110,   134,
     4132     110,   110,   112,   112,   112,   135,   110,   134,   134,   134,
     4133     164,   164,   135,   112,   135,   135,   135,   135,   134,   134,
     4134     163,   163,   112,   112,   135,   135,   274,   227,   169,   169,
     4135      47,   169,   134,   132,   132,   132,   169,   132,   169,    58,
     4136      59,    60,   194,   195,   196,   132,    63,   132,   312,   114,
     4137     175,   115,   132,   135,   135,    96,   269,   270,   110,   299,
     4138     116,   132,   116,   132,   115,   297,   117,   141,   110,   110,
     4139     117,   168,   112,   134,   115,   112,   111,   147,   111,   147,
     4140     147,   112,   112,   112,   264,   112,   264,   264,   264,   135,
     4141     135,   112,   112,   110,   110,   112,   116,    96,   263,    96,
     4142     135,   112,   112,   110,   110,   109,   110,   170,   191,   212,
     4143     132,   110,   109,   109,   173,   196,    58,    59,   164,   171,
     4144     144,   110,   110,   114,   134,   134,   298,   141,   203,   109,
     4145     132,   203,   135,   117,   264,   134,   134,   135,   135,   135,
     4146     135,   112,   112,   134,   135,   112,   171,    44,    45,   114,
     4147     181,   182,   183,   169,   171,   135,   110,   170,   114,   183,
     4148      96,   134,    96,   134,   109,   109,   132,   115,   134,   272,
     4149     309,   115,   116,   117,   163,   110,   112,   164,   135,   146,
     4150     146,   110,   110,   110,   110,   267,    42,   163,   179,   180,
     4151     310,   117,   134,   171,   181,   110,   132,   171,   132,   134,
     4152     110,   134,   110,   134,    96,   134,    96,   134,   132,   298,
     4153     141,   139,   204,   110,   132,   117,   110,   135,   135,   171,
     4154      96,   116,   117,   135,   205,   206,   212,   132,   170,   170,
     4155     205,   173,   197,   225,   366,   173,   197,   110,   134,   110,
     4156     134,   115,   110,   116,   164,   112,   112,   163,   179,   182,
     4157     184,   185,   134,   132,   182,   186,   187,   135,   109,   149,
     4158     309,   357,   139,   135,   173,   197,   173,   197,   109,   132,
     4159     139,   171,   176,   115,   182,   212,   170,    56,   176,   189,
     4160     115,   182,   110,   227,   110,   135,   135,   292,   171,   176,
     4161     132,   188,   189,   176,   189,   173,   173,   110,   110,   110,
     4162     188,   135,   135,   173,   173,   135,   135
    43834163};
    43844164
    … …  
    52174997
    52184998/* Line 1806 of yacc.c  */
    5219 #line 292 "parser.yy"
     4999#line 296 "parser.yy"
    52205000    {
    52215001                        typedefTable.enterScope();
    … …  
    52265006
    52275007/* Line 1806 of yacc.c  */
    5228 #line 298 "parser.yy"
     5008#line 302 "parser.yy"
    52295009    {
    52305010                        typedefTable.leaveScope();
    … …  
    52355015
    52365016/* Line 1806 of yacc.c  */
    5237 #line 307 "parser.yy"
    5238     { (yyval.constant) = makeConstantInteger( *(yyvsp[(1) - (1)].tok) ); }
     5017#line 311 "parser.yy"
     5018    { (yyval.constant) = build_constantInteger( *(yyvsp[(1) - (1)].tok) ); }
    52395019    break;
    52405020
    … …  
    52425022
    52435023/* Line 1806 of yacc.c  */
    5244 #line 308 "parser.yy"
    5245     { (yyval.constant) = makeConstantFloat( *(yyvsp[(1) - (1)].tok) ); }
     5024#line 312 "parser.yy"
     5025    { (yyval.constant) = build_constantFloat( *(yyvsp[(1) - (1)].tok) ); }
    52465026    break;
    52475027
    … …  
    52495029
    52505030/* Line 1806 of yacc.c  */
    5251 #line 309 "parser.yy"
    5252     { (yyval.constant) = makeConstantChar( *(yyvsp[(1) - (1)].tok) ); }
     5031#line 313 "parser.yy"
     5032    { (yyval.constant) = build_constantChar( *(yyvsp[(1) - (1)].tok) ); }
    52535033    break;
    52545034
    … …  
    52565036
    52575037/* Line 1806 of yacc.c  */
    5258 #line 334 "parser.yy"
    5259     { (yyval.constant) = makeConstantStr( *(yyvsp[(1) - (1)].tok) ); }
     5038#line 338 "parser.yy"
     5039    { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].tok) ); }
    52605040    break;
    52615041
    … …  
    52635043
    52645044/* Line 1806 of yacc.c  */
    5265 #line 335 "parser.yy"
    5266     { (yyval.constant) = (yyvsp[(1) - (2)].constant)->appendstr( (yyvsp[(2) - (2)].tok) ); }
     5045#line 340 "parser.yy"
     5046    {
     5047                        appendStr( (yyvsp[(1) - (2)].constant)->get_expr()->get_constant()->get_value(), (yyvsp[(2) - (2)].tok) );
     5048                        delete (yyvsp[(2) - (2)].tok);                                                                  // allocated by lexer
     5049                        (yyval.constant) = (yyvsp[(1) - (2)].constant);
     5050                }
    52675051    break;
    52685052
    … …  
    52705054
    52715055/* Line 1806 of yacc.c  */
    5272 #line 342 "parser.yy"
     5056#line 351 "parser.yy"
    52735057    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    52745058    break;
    … …  
    52775061
    52785062/* Line 1806 of yacc.c  */
    5279 #line 344 "parser.yy"
     5063#line 353 "parser.yy"
    52805064    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    52815065    break;
    … …  
    52845068
    52855069/* Line 1806 of yacc.c  */
    5286 #line 346 "parser.yy"
     5070#line 355 "parser.yy"
    52875071    { (yyval.en) = (yyvsp[(2) - (3)].en); }
    52885072    break;
    … …  
    52915075
    52925076/* Line 1806 of yacc.c  */
    5293 #line 348 "parser.yy"
     5077#line 357 "parser.yy"
    52945078    { (yyval.en) = new ValofExprNode( (yyvsp[(2) - (3)].sn) ); }
    52955079    break;
    … …  
    52985082
    52995083/* Line 1806 of yacc.c  */
    5300 #line 358 "parser.yy"
    5301     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
     5084#line 367 "parser.yy"
     5085    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    53025086    break;
    53035087
    … …  
    53055089
    53065090/* Line 1806 of yacc.c  */
    5307 #line 360 "parser.yy"
    5308     { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ); }
     5091#line 369 "parser.yy"
     5092    { (yyval.en) = new CompositeExprNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
    53095093    break;
    53105094
    … …  
    53125096
    53135097/* Line 1806 of yacc.c  */
    5314 #line 364 "parser.yy"
    5315     { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
     5098#line 373 "parser.yy"
     5099    { (yyval.en) = new CompositeExprNode( build_fieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
    53165100    break;
    53175101
    … …  
    53195103
    53205104/* Line 1806 of yacc.c  */
    5321 #line 367 "parser.yy"
    5322     { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
     5105#line 376 "parser.yy"
     5106    { (yyval.en) = new CompositeExprNode( build_pfieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
    53235107    break;
    53245108
    … …  
    53265110
    53275111/* Line 1806 of yacc.c  */
    5328 #line 370 "parser.yy"
    5329     { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
     5112#line 379 "parser.yy"
     5113    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    53305114    break;
    53315115
    … …  
    53335117
    53345118/* Line 1806 of yacc.c  */
    5335 #line 372 "parser.yy"
    5336     { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
     5119#line 381 "parser.yy"
     5120    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    53375121    break;
    53385122
    … …  
    53405124
    53415125/* Line 1806 of yacc.c  */
    5342 #line 374 "parser.yy"
     5126#line 383 "parser.yy"
    53435127    { (yyval.en) = new CompoundLiteralNode( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ); }
    53445128    break;
    … …  
    53475131
    53485132/* Line 1806 of yacc.c  */
    5349 #line 376 "parser.yy"
     5133#line 385 "parser.yy"
    53505134    {
    5351                         Token fn; fn.str = new std::string( "?{}" ); // location undefined
    5352                         (yyval.en) = new CompositeExprNode( new VarRefNode( fn ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_link( (yyvsp[(3) - (4)].en) ) );
     5135                        Token fn;
     5136                        fn.str = new std::string( "?{}" ); // location undefined
     5137                        (yyval.en) = new CompositeExprNode( build_func( new VarRefNode( fn ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_link( (yyvsp[(3) - (4)].en) ) ) );
    53535138                }
    53545139    break;
    … …  
    53575142
    53585143/* Line 1806 of yacc.c  */
    5359 #line 385 "parser.yy"
     5144#line 395 "parser.yy"
    53605145    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    53615146    break;
    … …  
    53645149
    53655150/* Line 1806 of yacc.c  */
    5366 #line 390 "parser.yy"
     5151#line 400 "parser.yy"
    53675152    { (yyval.en) = 0; }
    53685153    break;
    … …  
    53715156
    53725157/* Line 1806 of yacc.c  */
    5373 #line 393 "parser.yy"
     5158#line 403 "parser.yy"
    53745159    { (yyval.en) = (yyvsp[(3) - (3)].en)->set_argName( (yyvsp[(1) - (3)].tok) ); }
    53755160    break;
    … …  
    53785163
    53795164/* Line 1806 of yacc.c  */
    5380 #line 398 "parser.yy"
     5165#line 408 "parser.yy"
    53815166    { (yyval.en) = (yyvsp[(7) - (7)].en)->set_argName( (yyvsp[(3) - (7)].en) ); }
    53825167    break;
    … …  
    53855170
    53865171/* Line 1806 of yacc.c  */
    5387 #line 400 "parser.yy"
    5388     { (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) )))); }
     5172#line 410 "parser.yy"
     5173    { (yyval.en) = (yyvsp[(9) - (9)].en)->set_argName( new CompositeExprNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (9)].en)->set_link( (yyvsp[(5) - (9)].en) ) ) ) ); }
    53895174    break;
    53905175
    … …  
    53925177
    53935178/* Line 1806 of yacc.c  */
    5394 #line 405 "parser.yy"
     5179#line 415 "parser.yy"
    53955180    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    53965181    break;
    … …  
    53995184
    54005185/* Line 1806 of yacc.c  */
    5401 #line 410 "parser.yy"
     5186#line 420 "parser.yy"
    54025187    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    54035188    break;
    … …  
    54065191
    54075192/* Line 1806 of yacc.c  */
    5408 #line 414 "parser.yy"
    5409     { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
     5193#line 424 "parser.yy"
     5194    { (yyval.en) = new CompositeExprNode( build_fieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    54105195    break;
    54115196
    … …  
    54135198
    54145199/* Line 1806 of yacc.c  */
    5415 #line 416 "parser.yy"
    5416     { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
     5200#line 426 "parser.yy"
     5201    { (yyval.en) = new CompositeExprNode( build_fieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
    54175202    break;
    54185203
    … …  
    54205205
    54215206/* Line 1806 of yacc.c  */
    5422 #line 418 "parser.yy"
    5423     { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
     5207#line 428 "parser.yy"
     5208    { (yyval.en) = new CompositeExprNode( build_pfieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    54245209    break;
    54255210
    … …  
    54275212
    54285213/* Line 1806 of yacc.c  */
    5429 #line 420 "parser.yy"
    5430     { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
     5214#line 430 "parser.yy"
     5215    { (yyval.en) = new CompositeExprNode( build_pfieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
    54315216    break;
    54325217
    … …  
    54345219
    54355220/* Line 1806 of yacc.c  */
    5436 #line 428 "parser.yy"
     5221#line 438 "parser.yy"
    54375222    { (yyval.en) = (yyvsp[(1) - (1)].constant); }
    54385223    break;
    … …  
    54415226
    54425227/* Line 1806 of yacc.c  */
    5443 #line 430 "parser.yy"
     5228#line 440 "parser.yy"
    54445229    { (yyval.en) = (yyvsp[(1) - (1)].constant); }
    54455230    break;
    … …  
    54485233
    54495234/* Line 1806 of yacc.c  */
    5450 #line 432 "parser.yy"
     5235#line 442 "parser.yy"
    54515236    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    54525237    break;
    … …  
    54555240
    54565241/* Line 1806 of yacc.c  */
    5457 #line 437 "parser.yy"
    5458     { (yyval.en) = (yyvsp[(1) - (2)].op) == OperatorNode::AddressOf ? (ExpressionNode*) new CompositeExprNode2( build_addressOf( (yyvsp[(2) - (2)].en) ) )
    5459                                                                                         : (ExpressionNode*)new CompositeExprNode( new OperatorNode ( (yyvsp[(1) - (2)].op) ), (yyvsp[(2) - (2)].en) ); }
     5242#line 447 "parser.yy"
     5243    {
     5244                        switch ( (yyvsp[(1) - (2)].op) ) {
     5245                          case OperKinds::AddressOf:
     5246                                (yyval.en) = new CompositeExprNode( build_addressOf( (yyvsp[(2) - (2)].en) ) );
     5247                                break;
     5248                          case OperKinds::PointTo:
     5249                                (yyval.en) = new CompositeExprNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) );
     5250                                break;
     5251                          default:
     5252                                assert( false );
     5253                        }
     5254                }
    54605255    break;
    54615256
    … …  
    54635258
    54645259/* Line 1806 of yacc.c  */
    5465 #line 440 "parser.yy"
    5466     { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); }
     5260#line 460 "parser.yy"
     5261    { (yyval.en) = new CompositeExprNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
    54675262    break;
    54685263
    … …  
    54705265
    54715266/* Line 1806 of yacc.c  */
    5472 #line 442 "parser.yy"
    5473     { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::Incr, (yyvsp[(2) - (2)].en) ) ); }
     5267#line 462 "parser.yy"
     5268    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
    54745269    break;
    54755270
    … …  
    54775272
    54785273/* Line 1806 of yacc.c  */
    5479 #line 444 "parser.yy"
    5480     { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::Decr, (yyvsp[(2) - (2)].en) ) ); }
     5274#line 464 "parser.yy"
     5275    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
    54815276    break;
    54825277
    … …  
    54845279
    54855280/* Line 1806 of yacc.c  */
    5486 #line 446 "parser.yy"
    5487     { (yyval.en) = new CompositeExprNode2( build_sizeOf( (yyvsp[(2) - (2)].en) ) ); }
     5281#line 466 "parser.yy"
     5282    { (yyval.en) = new CompositeExprNode( build_sizeOf( (yyvsp[(2) - (2)].en) ) ); }
    54885283    break;
    54895284
    … …  
    54915286
    54925287/* Line 1806 of yacc.c  */
    5493 #line 448 "parser.yy"
    5494     { (yyval.en) = new CompositeExprNode2( build_sizeOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
     5288#line 468 "parser.yy"
     5289    { (yyval.en) = new CompositeExprNode( build_sizeOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    54955290    break;
    54965291
    … …  
    54985293
    54995294/* Line 1806 of yacc.c  */
    5500 #line 450 "parser.yy"
    5501     { (yyval.en) = new CompositeExprNode2( build_offsetOf( new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) ) ) ); }
     5295#line 470 "parser.yy"
     5296    { (yyval.en) = new CompositeExprNode( build_offsetOf( new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) ) ) ); }
    55025297    break;
    55035298
    … …  
    55055300
    55065301/* Line 1806 of yacc.c  */
    5507 #line 452 "parser.yy"
    5508     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
     5302#line 472 "parser.yy"
     5303    { (yyval.en) = new CompositeExprNode( build_attr( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ) ); }
    55095304    break;
    55105305
    … …  
    55125307
    55135308/* Line 1806 of yacc.c  */
    5514 #line 454 "parser.yy"
    5515     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ); }
     5309#line 474 "parser.yy"
     5310    { (yyval.en) = new CompositeExprNode( build_attr( new VarRefNode( (yyvsp[(1) - (4)].tok) ), new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    55165311    break;
    55175312
    … …  
    55195314
    55205315/* Line 1806 of yacc.c  */
    5521 #line 456 "parser.yy"
    5522     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ); }
     5316#line 476 "parser.yy"
     5317    { (yyval.en) = new CompositeExprNode( build_attr( new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
    55235318    break;
    55245319
    … …  
    55265321
    55275322/* Line 1806 of yacc.c  */
    5528 #line 458 "parser.yy"
    5529     { (yyval.en) = new CompositeExprNode2( build_alignOf( (yyvsp[(2) - (2)].en) ) ); }
     5323#line 478 "parser.yy"
     5324    { (yyval.en) = new CompositeExprNode( build_alignOf( (yyvsp[(2) - (2)].en) ) ); }
    55305325    break;
    55315326
    … …  
    55335328
    55345329/* Line 1806 of yacc.c  */
    5535 #line 460 "parser.yy"
    5536     { (yyval.en) = new CompositeExprNode2( build_alignOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
     5330#line 480 "parser.yy"
     5331    { (yyval.en) = new CompositeExprNode( build_alignOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    55375332    break;
    55385333
    … …  
    55405335
    55415336/* Line 1806 of yacc.c  */
    5542 #line 466 "parser.yy"
    5543     { (yyval.op) = OperatorNode::PointTo; }
     5337#line 486 "parser.yy"
     5338    { (yyval.op) = OperKinds::PointTo; }
    55445339    break;
    55455340
    … …  
    55475342
    55485343/* Line 1806 of yacc.c  */
    5549 #line 467 "parser.yy"
    5550     { (yyval.op) = OperatorNode::AddressOf; }
     5344#line 487 "parser.yy"
     5345    { (yyval.op) = OperKinds::AddressOf; }
    55515346    break;
    55525347
    … …  
    55545349
    55555350/* Line 1806 of yacc.c  */
    5556 #line 469 "parser.yy"
    5557     { (yyval.op) = OperatorNode::And; }
     5351#line 493 "parser.yy"
     5352    { (yyval.op) = OperKinds::UnPlus; }
    55585353    break;
    55595354
    … …  
    55615356
    55625357/* Line 1806 of yacc.c  */
    5563 #line 473 "parser.yy"
    5564     { (yyval.en) = new OperatorNode( OperatorNode::UnPlus ); }
     5358#line 494 "parser.yy"
     5359    { (yyval.op) = OperKinds::UnMinus; }
    55655360    break;
    55665361
    … …  
    55685363
    55695364/* Line 1806 of yacc.c  */
    5570 #line 474 "parser.yy"
    5571     { (yyval.en) = new OperatorNode( OperatorNode::UnMinus ); }
     5365#line 495 "parser.yy"
     5366    { (yyval.op) = OperKinds::Neg; }
    55725367    break;
    55735368
    … …  
    55755370
    55765371/* Line 1806 of yacc.c  */
    5577 #line 475 "parser.yy"
    5578     { (yyval.en) = new OperatorNode( OperatorNode::Neg ); }
    5579     break;
    5580 
    5581   case 69:
    5582 
    5583 /* Line 1806 of yacc.c  */
    5584 #line 476 "parser.yy"
    5585     { (yyval.en) = new OperatorNode( OperatorNode::BitNeg ); }
     5372#line 496 "parser.yy"
     5373    { (yyval.op) = OperKinds::BitNeg; }
     5374    break;
     5375
     5376  case 70:
     5377
     5378/* Line 1806 of yacc.c  */
     5379#line 502 "parser.yy"
     5380    { (yyval.en) = new CompositeExprNode( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    55865381    break;
    55875382
    … …  
    55895384
    55905385/* Line 1806 of yacc.c  */
    5591 #line 482 "parser.yy"
    5592     { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    5593     break;
    5594 
    5595   case 72:
    5596 
    5597 /* Line 1806 of yacc.c  */
    5598 #line 484 "parser.yy"
    5599     { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
     5386#line 504 "parser.yy"
     5387    { (yyval.en) = new CompositeExprNode( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
     5388    break;
     5389
     5390  case 73:
     5391
     5392/* Line 1806 of yacc.c  */
     5393#line 510 "parser.yy"
     5394    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56005395    break;
    56015396
    … …  
    56035398
    56045399/* Line 1806 of yacc.c  */
    5605 #line 490 "parser.yy"
    5606     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5400#line 512 "parser.yy"
     5401    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56075402    break;
    56085403
    … …  
    56105405
    56115406/* Line 1806 of yacc.c  */
    5612 #line 492 "parser.yy"
    5613     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5614     break;
    5615 
    5616   case 76:
    5617 
    5618 /* Line 1806 of yacc.c  */
    5619 #line 494 "parser.yy"
    5620     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5407#line 514 "parser.yy"
     5408    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5409    break;
     5410
     5411  case 77:
     5412
     5413/* Line 1806 of yacc.c  */
     5414#line 520 "parser.yy"
     5415    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56215416    break;
    56225417
    … …  
    56245419
    56255420/* Line 1806 of yacc.c  */
    5626 #line 500 "parser.yy"
    5627     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5628     break;
    5629 
    5630   case 79:
    5631 
    5632 /* Line 1806 of yacc.c  */
    5633 #line 502 "parser.yy"
    5634     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5421#line 522 "parser.yy"
     5422    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5423    break;
     5424
     5425  case 80:
     5426
     5427/* Line 1806 of yacc.c  */
     5428#line 528 "parser.yy"
     5429    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56355430    break;
    56365431
    … …  
    56385433
    56395434/* Line 1806 of yacc.c  */
    5640 #line 508 "parser.yy"
    5641     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5642     break;
    5643 
    5644   case 82:
    5645 
    5646 /* Line 1806 of yacc.c  */
    5647 #line 510 "parser.yy"
    5648     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5435#line 530 "parser.yy"
     5436    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5437    break;
     5438
     5439  case 83:
     5440
     5441/* Line 1806 of yacc.c  */
     5442#line 536 "parser.yy"
     5443    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56495444    break;
    56505445
    … …  
    56525447
    56535448/* Line 1806 of yacc.c  */
    5654 #line 516 "parser.yy"
    5655     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5449#line 538 "parser.yy"
     5450    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56565451    break;
    56575452
    … …  
    56595454
    56605455/* Line 1806 of yacc.c  */
    5661 #line 518 "parser.yy"
    5662     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5456#line 540 "parser.yy"
     5457    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56635458    break;
    56645459
    … …  
    56665461
    56675462/* Line 1806 of yacc.c  */
    5668 #line 520 "parser.yy"
    5669     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5670     break;
    5671 
    5672   case 87:
    5673 
    5674 /* Line 1806 of yacc.c  */
    5675 #line 522 "parser.yy"
    5676     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5463#line 542 "parser.yy"
     5464    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5465    break;
     5466
     5467  case 88:
     5468
     5469/* Line 1806 of yacc.c  */
     5470#line 548 "parser.yy"
     5471    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56775472    break;
    56785473
    … …  
    56805475
    56815476/* Line 1806 of yacc.c  */
    5682 #line 528 "parser.yy"
    5683     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5684     break;
    5685 
    5686   case 90:
    5687 
    5688 /* Line 1806 of yacc.c  */
    5689 #line 530 "parser.yy"
    5690     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5691     break;
    5692 
    5693   case 92:
    5694 
    5695 /* Line 1806 of yacc.c  */
    5696 #line 536 "parser.yy"
    5697     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5698     break;
    5699 
    5700   case 94:
    5701 
    5702 /* Line 1806 of yacc.c  */
    5703 #line 542 "parser.yy"
    5704     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5705     break;
    5706 
    5707   case 96:
    5708 
    5709 /* Line 1806 of yacc.c  */
    5710 #line 548 "parser.yy"
    5711     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5712     break;
    5713 
    5714   case 98:
    5715 
    5716 /* Line 1806 of yacc.c  */
    5717 #line 554 "parser.yy"
    5718     { (yyval.en) = new CompositeExprNode2( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
    5719     break;
    5720 
    5721   case 100:
    5722 
    5723 /* Line 1806 of yacc.c  */
    5724 #line 560 "parser.yy"
    5725     { (yyval.en) = new CompositeExprNode2( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
     5477#line 550 "parser.yy"
     5478    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5479    break;
     5480
     5481  case 91:
     5482
     5483/* Line 1806 of yacc.c  */
     5484#line 556 "parser.yy"
     5485    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5486    break;
     5487
     5488  case 93:
     5489
     5490/* Line 1806 of yacc.c  */
     5491#line 562 "parser.yy"
     5492    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5493    break;
     5494
     5495  case 95:
     5496
     5497/* Line 1806 of yacc.c  */
     5498#line 568 "parser.yy"
     5499    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5500    break;
     5501
     5502  case 97:
     5503
     5504/* Line 1806 of yacc.c  */
     5505#line 574 "parser.yy"
     5506    { (yyval.en) = new CompositeExprNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
     5507    break;
     5508
     5509  case 99:
     5510
     5511/* Line 1806 of yacc.c  */
     5512#line 580 "parser.yy"
     5513    { (yyval.en) = new CompositeExprNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
     5514    break;
     5515
     5516  case 101:
     5517
     5518/* Line 1806 of yacc.c  */
     5519#line 586 "parser.yy"
     5520    { (yyval.en) = new CompositeExprNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    57265521    break;
    57275522
    … …  
    57295524
    57305525/* Line 1806 of yacc.c  */
    5731 #line 567 "parser.yy"
    5732     { (yyval.en) = new CompositeExprNode2( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     5526#line 589 "parser.yy"
     5527    { (yyval.en) = new CompositeExprNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
    57335528    break;
    57345529
    … …  
    57365531
    57375532/* Line 1806 of yacc.c  */
    5738 #line 569 "parser.yy"
    5739     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    5740     break;
    5741 
    5742   case 104:
    5743 
    5744 /* Line 1806 of yacc.c  */
    5745 #line 571 "parser.yy"
    5746     { (yyval.en) = new CompositeExprNode2( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     5533#line 591 "parser.yy"
     5534    { (yyval.en) = new CompositeExprNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     5535    break;
     5536
     5537  case 106:
     5538
     5539/* Line 1806 of yacc.c  */
     5540#line 602 "parser.yy"
     5541    { (yyval.en) = new CompositeExprNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    57475542    break;
    57485543
    … …  
    57505545
    57515546/* Line 1806 of yacc.c  */
    5752 #line 582 "parser.yy"
    5753     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5547#line 604 "parser.yy"
     5548    { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new CompositeExprNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
    57545549    break;
    57555550
    … …  
    57575552
    57585553/* Line 1806 of yacc.c  */
    5759 #line 584 "parser.yy"
    5760     { (yyval.en) = new CompositeExprNode( (yyvsp[(2) - (3)].en), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    5761     break;
    5762 
    5763   case 109:
    5764 
    5765 /* Line 1806 of yacc.c  */
    5766 #line 586 "parser.yy"
    5767     { (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) ); }
     5554#line 609 "parser.yy"
     5555    { (yyval.en) = new NullExprNode; }
    57685556    break;
    57695557
    … …  
    57715559
    57725560/* Line 1806 of yacc.c  */
    5773 #line 591 "parser.yy"
    5774     { (yyval.en) = new NullExprNode; }
     5561#line 614 "parser.yy"
     5562    { (yyval.op) = OperKinds::Assign; }
     5563    break;
     5564
     5565  case 111:
     5566
     5567/* Line 1806 of yacc.c  */
     5568#line 615 "parser.yy"
     5569    { (yyval.op) = OperKinds::MulAssn; }
    57755570    break;
    57765571
    … …  
    57785573
    57795574/* Line 1806 of yacc.c  */
    5780 #line 599 "parser.yy"
    5781     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
     5575#line 616 "parser.yy"
     5576    { (yyval.op) = OperKinds::DivAssn; }
    57825577    break;
    57835578
    … …  
    57855580
    57865581/* Line 1806 of yacc.c  */
    5787 #line 601 "parser.yy"
    5788     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (yyvsp[(3) - (5)].en) ); }
     5582#line 617 "parser.yy"
     5583    { (yyval.op) = OperKinds::ModAssn; }
    57895584    break;
    57905585
    … …  
    57925587
    57935588/* Line 1806 of yacc.c  */
    5794 #line 603 "parser.yy"
    5795     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ); }
     5589#line 618 "parser.yy"
     5590    { (yyval.op) = OperKinds::PlusAssn; }
    57965591    break;
    57975592
    … …  
    57995594
    58005595/* Line 1806 of yacc.c  */
    5801 #line 605 "parser.yy"
    5802     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( flattenCommas( (yyvsp[(5) - (7)].en) ) ) ); }
     5596#line 619 "parser.yy"
     5597    { (yyval.op) = OperKinds::MinusAssn; }
     5598    break;
     5599
     5600  case 116:
     5601
     5602/* Line 1806 of yacc.c  */
     5603#line 620 "parser.yy"
     5604    { (yyval.op) = OperKinds::LSAssn; }
    58035605    break;
    58045606
    … …  
    58065608
    58075609/* Line 1806 of yacc.c  */
    5808 #line 611 "parser.yy"
     5610#line 621 "parser.yy"
     5611    { (yyval.op) = OperKinds::RSAssn; }
     5612    break;
     5613
     5614  case 118:
     5615
     5616/* Line 1806 of yacc.c  */
     5617#line 622 "parser.yy"
     5618    { (yyval.op) = OperKinds::AndAssn; }
     5619    break;
     5620
     5621  case 119:
     5622
     5623/* Line 1806 of yacc.c  */
     5624#line 623 "parser.yy"
     5625    { (yyval.op) = OperKinds::ERAssn; }
     5626    break;
     5627
     5628  case 120:
     5629
     5630/* Line 1806 of yacc.c  */
     5631#line 624 "parser.yy"
     5632    { (yyval.op) = OperKinds::OrAssn; }
     5633    break;
     5634
     5635  case 121:
     5636
     5637/* Line 1806 of yacc.c  */
     5638#line 631 "parser.yy"
     5639    { (yyval.en) = new CompositeExprNode( build_tuple() ); }
     5640    break;
     5641
     5642  case 122:
     5643
     5644/* Line 1806 of yacc.c  */
     5645#line 633 "parser.yy"
     5646    { (yyval.en) = new CompositeExprNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
     5647    break;
     5648
     5649  case 123:
     5650
     5651/* Line 1806 of yacc.c  */
     5652#line 635 "parser.yy"
     5653    { (yyval.en) = new CompositeExprNode( build_tuple( (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ) ); }
     5654    break;
     5655
     5656  case 124:
     5657
     5658/* Line 1806 of yacc.c  */
     5659#line 637 "parser.yy"
     5660    { (yyval.en) = new CompositeExprNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( (yyvsp[(5) - (7)].en) ) ) ); }
     5661    break;
     5662
     5663  case 126:
     5664
     5665/* Line 1806 of yacc.c  */
     5666#line 643 "parser.yy"
    58095667    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    58105668    break;
    58115669
    5812   case 118:
    5813 
    5814 /* Line 1806 of yacc.c  */
    5815 #line 615 "parser.yy"
    5816     { (yyval.en) = new OperatorNode( OperatorNode::MulAssn ); }
    5817     break;
    5818 
    5819   case 119:
    5820 
    5821 /* Line 1806 of yacc.c  */
    5822 #line 616 "parser.yy"
    5823     { (yyval.en) = new OperatorNode( OperatorNode::DivAssn ); }
    5824     break;
    5825 
    5826   case 120:
    5827 
    5828 /* Line 1806 of yacc.c  */
    5829 #line 617 "parser.yy"
    5830     { (yyval.en) = new OperatorNode( OperatorNode::ModAssn ); }
    5831     break;
    5832 
    5833   case 121:
    5834 
    5835 /* Line 1806 of yacc.c  */
    5836 #line 618 "parser.yy"
    5837     { (yyval.en) = new OperatorNode( OperatorNode::PlusAssn ); }
    5838     break;
    5839 
    5840   case 122:
    5841 
    5842 /* Line 1806 of yacc.c  */
    5843 #line 619 "parser.yy"
    5844     { (yyval.en) = new OperatorNode( OperatorNode::MinusAssn ); }
    5845     break;
    5846 
    5847   case 123:
    5848 
    5849 /* Line 1806 of yacc.c  */
    5850 #line 620 "parser.yy"
    5851     { (yyval.en) = new OperatorNode( OperatorNode::LSAssn ); }
    5852     break;
    5853 
    5854   case 124:
    5855 
    5856 /* Line 1806 of yacc.c  */
    5857 #line 621 "parser.yy"
    5858     { (yyval.en) = new OperatorNode( OperatorNode::RSAssn ); }
    5859     break;
    5860 
    5861   case 125:
    5862 
    5863 /* Line 1806 of yacc.c  */
    5864 #line 622 "parser.yy"
    5865     { (yyval.en) = new OperatorNode( OperatorNode::AndAssn ); }
    5866     break;
    5867 
    5868   case 126:
    5869 
    5870 /* Line 1806 of yacc.c  */
    5871 #line 623 "parser.yy"
    5872     { (yyval.en) = new OperatorNode( OperatorNode::ERAssn ); }
    5873     break;
    5874 
    5875   case 127:
    5876 
    5877 /* Line 1806 of yacc.c  */
    5878 #line 624 "parser.yy"
    5879     { (yyval.en) = new OperatorNode( OperatorNode::OrAssn ); }
     5670  case 128:
     5671
     5672/* Line 1806 of yacc.c  */
     5673#line 649 "parser.yy"
     5674    { (yyval.en) = new CompositeExprNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    58805675    break;
    58815676
    … …  
    58835678
    58845679/* Line 1806 of yacc.c  */
    5885 #line 631 "parser.yy"
    5886     { (yyval.en) = new CompositeExprNode2( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5887     break;
    5888 
    5889   case 130:
    5890 
    5891 /* Line 1806 of yacc.c  */
    5892 #line 636 "parser.yy"
     5680#line 654 "parser.yy"
    58935681    { (yyval.en) = 0; }
    58945682    break;
    58955683
    5896   case 134:
    5897 
    5898 /* Line 1806 of yacc.c  */
    5899 #line 645 "parser.yy"
     5684  case 133:
     5685
     5686/* Line 1806 of yacc.c  */
     5687#line 663 "parser.yy"
    59005688    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    59015689    break;
    59025690
     5691  case 139:
     5692
     5693/* Line 1806 of yacc.c  */
     5694#line 670 "parser.yy"
     5695    {
     5696                        Token fn;
     5697                        fn.str = new std::string( "^?{}" ); // location undefined
     5698                        (yyval.sn) = new StatementNode( StatementNode::Exp, new CompositeExprNode( build_func( new VarRefNode( fn ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_link( (yyvsp[(4) - (6)].en) ) ) ), 0 );
     5699                }
     5700    break;
     5701
    59035702  case 140:
    59045703
    59055704/* Line 1806 of yacc.c  */
    5906 #line 652 "parser.yy"
    5907     {
    5908                         Token fn; fn.str = new std::string( "^?{}" ); // location undefined
    5909                         (yyval.sn) = new StatementNode( StatementNode::Exp, new CompositeExprNode( new VarRefNode( fn ),
    5910                                 (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_link( (yyvsp[(4) - (6)].en) ) ), 0 );
    5911                 }
    5912     break;
    5913 
    5914   case 141:
    5915 
    5916 /* Line 1806 of yacc.c  */
    5917 #line 662 "parser.yy"
     5705#line 680 "parser.yy"
    59185706    {
    59195707                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
    … …  
    59215709    break;
    59225710
     5711  case 141:
     5712
     5713/* Line 1806 of yacc.c  */
     5714#line 687 "parser.yy"
     5715    { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
     5716    break;
     5717
    59235718  case 142:
    59245719
    59255720/* Line 1806 of yacc.c  */
    5926 #line 669 "parser.yy"
    5927     { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
    5928     break;
    5929 
    5930   case 143:
    5931 
    5932 /* Line 1806 of yacc.c  */
    5933 #line 676 "parser.yy"
     5721#line 694 "parser.yy"
    59345722    { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
    59355723    break;
    59365724
     5725  case 144:
     5726
     5727/* Line 1806 of yacc.c  */
     5728#line 700 "parser.yy"
     5729    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
     5730    break;
     5731
    59375732  case 145:
    59385733
    59395734/* Line 1806 of yacc.c  */
    5940 #line 682 "parser.yy"
    5941     { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
     5735#line 705 "parser.yy"
     5736    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    59425737    break;
    59435738
    … …  
    59455740
    59465741/* Line 1806 of yacc.c  */
    5947 #line 687 "parser.yy"
    5948     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    5949     break;
    5950 
    5951   case 147:
    5952 
    5953 /* Line 1806 of yacc.c  */
    5954 #line 689 "parser.yy"
     5742#line 707 "parser.yy"
    59555743    {   // mark all fields in list
    59565744                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
    … …  
    59605748    break;
    59615749
    5962   case 148:
    5963 
    5964 /* Line 1806 of yacc.c  */
    5965 #line 695 "parser.yy"
     5750  case 147:
     5751
     5752/* Line 1806 of yacc.c  */
     5753#line 713 "parser.yy"
    59665754    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    59675755    break;
    59685756
     5757  case 150:
     5758
     5759/* Line 1806 of yacc.c  */
     5760#line 720 "parser.yy"
     5761    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
     5762    break;
     5763
    59695764  case 151:
    59705765
    59715766/* Line 1806 of yacc.c  */
    5972 #line 702 "parser.yy"
    5973     { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
     5767#line 725 "parser.yy"
     5768    { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); }
    59745769    break;
    59755770
    … …  
    59775772
    59785773/* Line 1806 of yacc.c  */
    5979 #line 707 "parser.yy"
    5980     { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); }
     5774#line 731 "parser.yy"
     5775    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    59815776    break;
    59825777
    … …  
    59845779
    59855780/* Line 1806 of yacc.c  */
    5986 #line 713 "parser.yy"
    5987     { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
     5781#line 733 "parser.yy"
     5782    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); }
    59885783    break;
    59895784
    … …  
    59915786
    59925787/* Line 1806 of yacc.c  */
    5993 #line 715 "parser.yy"
    5994     { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); }
     5788#line 735 "parser.yy"
     5789    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    59955790    break;
    59965791
    … …  
    59985793
    59995794/* Line 1806 of yacc.c  */
    6000 #line 717 "parser.yy"
    6001     { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    6002     break;
    6003 
    6004   case 156:
    6005 
    6006 /* Line 1806 of yacc.c  */
    6007 #line 719 "parser.yy"
     5795#line 737 "parser.yy"
    60085796    {
    60095797                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
    … …  
    60175805    break;
    60185806
     5807  case 156:
     5808
     5809/* Line 1806 of yacc.c  */
     5810#line 747 "parser.yy"
     5811    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
     5812    break;
     5813
    60195814  case 157:
    60205815
    60215816/* Line 1806 of yacc.c  */
    6022 #line 729 "parser.yy"
    6023     { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    6024     break;
    6025 
    6026   case 158:
    6027 
    6028 /* Line 1806 of yacc.c  */
    6029 #line 731 "parser.yy"
     5817#line 749 "parser.yy"
    60305818    {
    60315819                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
    … …  
    60345822    break;
    60355823
     5824  case 158:
     5825
     5826/* Line 1806 of yacc.c  */
     5827#line 759 "parser.yy"
     5828    { (yyval.en) = (yyvsp[(1) - (1)].en); }
     5829    break;
     5830
    60365831  case 159:
    60375832
    60385833/* Line 1806 of yacc.c  */
    6039 #line 741 "parser.yy"
    6040     { (yyval.en) = (yyvsp[(1) - (1)].en); }
    6041     break;
    6042 
    6043   case 160:
    6044 
    6045 /* Line 1806 of yacc.c  */
    6046 #line 743 "parser.yy"
    6047     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Range, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5834#line 761 "parser.yy"
     5835    { (yyval.en) = new CompositeExprNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5836    break;
     5837
     5838  case 161:
     5839
     5840/* Line 1806 of yacc.c  */
     5841#line 766 "parser.yy"
     5842    { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(1) - (1)].en), 0 ); }
    60485843    break;
    60495844
    … …  
    60515846
    60525847/* Line 1806 of yacc.c  */
    6053 #line 748 "parser.yy"
    6054     { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(1) - (1)].en), 0 ); }
     5848#line 768 "parser.yy"
     5849    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode( StatementNode::Case, (yyvsp[(3) - (3)].en), 0 ) ) ); }
    60555850    break;
    60565851
    … …  
    60585853
    60595854/* Line 1806 of yacc.c  */
    6060 #line 750 "parser.yy"
    6061     { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode( StatementNode::Case, (yyvsp[(3) - (3)].en), 0 ) ) ); }
     5855#line 772 "parser.yy"
     5856    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    60625857    break;
    60635858
    … …  
    60655860
    60665861/* Line 1806 of yacc.c  */
    6067 #line 754 "parser.yy"
    6068     { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    6069     break;
    6070 
    6071   case 165:
    6072 
    6073 /* Line 1806 of yacc.c  */
    6074 #line 755 "parser.yy"
     5862#line 773 "parser.yy"
    60755863    { (yyval.sn) = new StatementNode( StatementNode::Default ); }
    60765864    break;
    60775865
     5866  case 166:
     5867
     5868/* Line 1806 of yacc.c  */
     5869#line 779 "parser.yy"
     5870    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
     5871    break;
     5872
    60785873  case 167:
    60795874
    60805875/* Line 1806 of yacc.c  */
    6081 #line 761 "parser.yy"
    6082     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
     5876#line 783 "parser.yy"
     5877    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    60835878    break;
    60845879
    … …  
    60865881
    60875882/* Line 1806 of yacc.c  */
    6088 #line 765 "parser.yy"
     5883#line 788 "parser.yy"
     5884    { (yyval.sn) = 0; }
     5885    break;
     5886
     5887  case 170:
     5888
     5889/* Line 1806 of yacc.c  */
     5890#line 794 "parser.yy"
    60895891    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    60905892    break;
    60915893
    6092   case 169:
    6093 
    6094 /* Line 1806 of yacc.c  */
    6095 #line 770 "parser.yy"
     5894  case 171:
     5895
     5896/* Line 1806 of yacc.c  */
     5897#line 796 "parser.yy"
     5898    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
     5899    break;
     5900
     5901  case 172:
     5902
     5903/* Line 1806 of yacc.c  */
     5904#line 801 "parser.yy"
    60965905    { (yyval.sn) = 0; }
    60975906    break;
    60985907
    6099   case 171:
    6100 
    6101 /* Line 1806 of yacc.c  */
    6102 #line 776 "parser.yy"
    6103     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    6104     break;
    6105 
    6106   case 172:
    6107 
    6108 /* Line 1806 of yacc.c  */
    6109 #line 778 "parser.yy"
    6110     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    6111     break;
    6112 
    6113   case 173:
    6114 
    6115 /* Line 1806 of yacc.c  */
    6116 #line 783 "parser.yy"
     5908  case 174:
     5909
     5910/* Line 1806 of yacc.c  */
     5911#line 807 "parser.yy"
     5912    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
     5913    break;
     5914
     5915  case 175:
     5916
     5917/* Line 1806 of yacc.c  */
     5918#line 809 "parser.yy"
     5919    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
     5920    break;
     5921
     5922  case 176:
     5923
     5924/* Line 1806 of yacc.c  */
     5925#line 811 "parser.yy"
     5926    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
     5927    break;
     5928
     5929  case 177:
     5930
     5931/* Line 1806 of yacc.c  */
     5932#line 813 "parser.yy"
     5933    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_link( (yyvsp[(2) - (4)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(3) - (4)].sn), *(yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
     5934    break;
     5935
     5936  case 178:
     5937
     5938/* Line 1806 of yacc.c  */
     5939#line 818 "parser.yy"
     5940    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
     5941    break;
     5942
     5943  case 180:
     5944
     5945/* Line 1806 of yacc.c  */
     5946#line 824 "parser.yy"
    61175947    { (yyval.sn) = 0; }
    61185948    break;
    61195949
    6120   case 175:
    6121 
    6122 /* Line 1806 of yacc.c  */
    6123 #line 789 "parser.yy"
    6124     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    6125     break;
    6126 
    6127   case 176:
    6128 
    6129 /* Line 1806 of yacc.c  */
    6130 #line 791 "parser.yy"
    6131     { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
    6132     break;
    6133 
    6134   case 177:
    6135 
    6136 /* Line 1806 of yacc.c  */
    6137 #line 793 "parser.yy"
    6138     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    6139     break;
    6140 
    6141   case 178:
    6142 
    6143 /* Line 1806 of yacc.c  */
    6144 #line 795 "parser.yy"
    6145     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_link( (yyvsp[(2) - (4)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(3) - (4)].sn), *(yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
    6146     break;
    6147 
    6148   case 179:
    6149 
    6150 /* Line 1806 of yacc.c  */
    6151 #line 800 "parser.yy"
     5950  case 181:
     5951
     5952/* Line 1806 of yacc.c  */
     5953#line 826 "parser.yy"
     5954    { (yyval.sn) = 0; }
     5955    break;
     5956
     5957  case 182:
     5958
     5959/* Line 1806 of yacc.c  */
     5960#line 831 "parser.yy"
     5961    { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
     5962    break;
     5963
     5964  case 183:
     5965
     5966/* Line 1806 of yacc.c  */
     5967#line 833 "parser.yy"
     5968    { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
     5969    break;
     5970
     5971  case 184:
     5972
     5973/* Line 1806 of yacc.c  */
     5974#line 835 "parser.yy"
     5975    { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
     5976    break;
     5977
     5978  case 185:
     5979
     5980/* Line 1806 of yacc.c  */
     5981#line 840 "parser.yy"
     5982    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
     5983    break;
     5984
     5985  case 186:
     5986
     5987/* Line 1806 of yacc.c  */
     5988#line 842 "parser.yy"
     5989    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
     5990    break;
     5991
     5992  case 187:
     5993
     5994/* Line 1806 of yacc.c  */
     5995#line 847 "parser.yy"
     5996    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
     5997    break;
     5998
     5999  case 188:
     6000
     6001/* Line 1806 of yacc.c  */
     6002#line 851 "parser.yy"
     6003    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
     6004    break;
     6005
     6006  case 189:
     6007
     6008/* Line 1806 of yacc.c  */
     6009#line 854 "parser.yy"
     6010    { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
     6011    break;
     6012
     6013  case 190:
     6014
     6015/* Line 1806 of yacc.c  */
     6016#line 858 "parser.yy"
     6017    { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
     6018    break;
     6019
     6020  case 191:
     6021
     6022/* Line 1806 of yacc.c  */
     6023#line 861 "parser.yy"
    61526024    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    61536025    break;
    61546026
    6155   case 181:
    6156 
    6157 /* Line 1806 of yacc.c  */
    6158 #line 806 "parser.yy"
    6159     { (yyval.sn) = 0; }
    6160     break;
    6161 
    6162   case 182:
    6163 
    6164 /* Line 1806 of yacc.c  */
    6165 #line 808 "parser.yy"
    6166     { (yyval.sn) = 0; }
    6167     break;
    6168 
    6169   case 183:
    6170 
    6171 /* Line 1806 of yacc.c  */
    6172 #line 813 "parser.yy"
    6173     { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    6174     break;
    6175 
    6176   case 184:
    6177 
    6178 /* Line 1806 of yacc.c  */
    6179 #line 815 "parser.yy"
    6180     { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
    6181     break;
    6182 
    6183   case 185:
    6184 
    6185 /* Line 1806 of yacc.c  */
    6186 #line 817 "parser.yy"
    6187     { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
    6188     break;
    6189 
    6190   case 186:
    6191 
    6192 /* Line 1806 of yacc.c  */
    6193 #line 822 "parser.yy"
    6194     { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    6195     break;
    6196 
    6197   case 187:
    6198 
    6199 /* Line 1806 of yacc.c  */
    6200 #line 824 "parser.yy"
    6201     { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    6202     break;
    6203 
    6204   case 188:
    6205 
    6206 /* Line 1806 of yacc.c  */
    6207 #line 829 "parser.yy"
    6208     { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
    6209     break;
    6210 
    6211   case 189:
    6212 
    6213 /* Line 1806 of yacc.c  */
    6214 #line 833 "parser.yy"
    6215     { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
    6216     break;
    6217 
    6218   case 190:
    6219 
    6220 /* Line 1806 of yacc.c  */
    6221 #line 836 "parser.yy"
    6222     { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
    6223     break;
    6224 
    6225   case 191:
    6226 
    6227 /* Line 1806 of yacc.c  */
    6228 #line 840 "parser.yy"
    6229     { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
    6230     break;
    6231 
    62326027  case 192:
    62336028
    62346029/* Line 1806 of yacc.c  */
    6235 #line 843 "parser.yy"
    6236     { (yyval.sn) = new StatementNode( StatementNode::Break ); }
     6030#line 865 "parser.yy"
     6031    { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
    62376032    break;
    62386033
    … …  
    62406035
    62416036/* Line 1806 of yacc.c  */
    6242 #line 847 "parser.yy"
    6243     { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
     6037#line 867 "parser.yy"
     6038    { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
    62446039    break;
    62456040
    … …  
    62476042
    62486043/* Line 1806 of yacc.c  */
    6249 #line 849 "parser.yy"
    6250     { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
     6044#line 869 "parser.yy"
     6045    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    62516046    break;
    62526047
    … …  
    62546049
    62556050/* Line 1806 of yacc.c  */
    6256 #line 851 "parser.yy"
     6051#line 873 "parser.yy"
    62576052    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    62586053    break;
    … …  
    62616056
    62626057/* Line 1806 of yacc.c  */
    6263 #line 855 "parser.yy"
    6264     { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
     6058#line 875 "parser.yy"
     6059    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (5)].en), 0 ); }
    62656060    break;
    62666061
    … …  
    62686063
    62696064/* Line 1806 of yacc.c  */
    6270 #line 857 "parser.yy"
    6271     { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (5)].en), 0 ); }
     6065#line 882 "parser.yy"
     6066    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    62726067    break;
    62736068
    … …  
    62756070
    62766071/* Line 1806 of yacc.c  */
    6277 #line 864 "parser.yy"
     6072#line 884 "parser.yy"
    62786073    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    62796074    break;
    … …  
    62826077
    62836078/* Line 1806 of yacc.c  */
    6284 #line 866 "parser.yy"
    6285     { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    6286     break;
    6287 
    6288   case 200:
    6289 
    6290 /* Line 1806 of yacc.c  */
    6291 #line 868 "parser.yy"
     6079#line 886 "parser.yy"
    62926080    {
    62936081                        (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
    … …  
    62966084    break;
    62976085
     6086  case 201:
     6087
     6088/* Line 1806 of yacc.c  */
     6089#line 897 "parser.yy"
     6090    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
     6091    break;
     6092
    62986093  case 202:
    62996094
    63006095/* Line 1806 of yacc.c  */
    6301 #line 879 "parser.yy"
     6096#line 899 "parser.yy"
     6097    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
     6098    break;
     6099
     6100  case 203:
     6101
     6102/* Line 1806 of yacc.c  */
     6103#line 901 "parser.yy"
    63026104    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    63036105    break;
    63046106
    6305   case 203:
    6306 
    6307 /* Line 1806 of yacc.c  */
    6308 #line 881 "parser.yy"
     6107  case 204:
     6108
     6109/* Line 1806 of yacc.c  */
     6110#line 903 "parser.yy"
    63096111    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    63106112    break;
    63116113
    6312   case 204:
    6313 
    6314 /* Line 1806 of yacc.c  */
    6315 #line 883 "parser.yy"
    6316     { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    6317     break;
    6318 
    63196114  case 205:
    63206115
    63216116/* Line 1806 of yacc.c  */
    6322 #line 885 "parser.yy"
    6323     { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
     6117#line 908 "parser.yy"
     6118    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    63246119    break;
    63256120
    … …  
    63276122
    63286123/* Line 1806 of yacc.c  */
    6329 #line 890 "parser.yy"
     6124#line 910 "parser.yy"
     6125    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
     6126    break;
     6127
     6128  case 207:
     6129
     6130/* Line 1806 of yacc.c  */
     6131#line 912 "parser.yy"
    63306132    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    63316133    break;
    63326134
    6333   case 207:
    6334 
    6335 /* Line 1806 of yacc.c  */
    6336 #line 892 "parser.yy"
     6135  case 208:
     6136
     6137/* Line 1806 of yacc.c  */
     6138#line 914 "parser.yy"
    63376139    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    63386140    break;
    63396141
    6340   case 208:
    6341 
    6342 /* Line 1806 of yacc.c  */
    6343 #line 894 "parser.yy"
    6344     { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    6345     break;
    6346 
    63476142  case 209:
    63486143
    63496144/* Line 1806 of yacc.c  */
    6350 #line 896 "parser.yy"
    6351     { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    6352     break;
    6353 
    6354   case 210:
    6355 
    6356 /* Line 1806 of yacc.c  */
    6357 #line 901 "parser.yy"
     6145#line 919 "parser.yy"
    63586146    {
    63596147                        (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
    … …  
    63626150    break;
    63636151
    6364   case 212:
    6365 
    6366 /* Line 1806 of yacc.c  */
    6367 #line 915 "parser.yy"
     6152  case 211:
     6153
     6154/* Line 1806 of yacc.c  */
     6155#line 933 "parser.yy"
    63686156    {
    63696157                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    63726160    break;
    63736161
     6162  case 212:
     6163
     6164/* Line 1806 of yacc.c  */
     6165#line 938 "parser.yy"
     6166    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     6167    break;
     6168
    63746169  case 213:
    63756170
    63766171/* Line 1806 of yacc.c  */
    6377 #line 920 "parser.yy"
    6378     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    6379     break;
    6380 
    6381   case 214:
    6382 
    6383 /* Line 1806 of yacc.c  */
    6384 #line 922 "parser.yy"
     6172#line 940 "parser.yy"
    63856173    {
    63866174                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    63896177    break;
    63906178
     6179  case 215:
     6180
     6181/* Line 1806 of yacc.c  */
     6182#line 949 "parser.yy"
     6183    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
     6184    break;
     6185
    63916186  case 216:
    63926187
    63936188/* Line 1806 of yacc.c  */
    6394 #line 931 "parser.yy"
    6395     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
     6189#line 951 "parser.yy"
     6190    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
    63966191    break;
    63976192
    … …  
    63996194
    64006195/* Line 1806 of yacc.c  */
    6401 #line 933 "parser.yy"
    6402     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
     6196#line 953 "parser.yy"
     6197    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
    64036198    break;
    64046199
    … …  
    64066201
    64076202/* Line 1806 of yacc.c  */
    6408 #line 935 "parser.yy"
    6409     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
     6203#line 955 "parser.yy"
     6204    { (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) ); }
    64106205    break;
    64116206
    … …  
    64136208
    64146209/* Line 1806 of yacc.c  */
    6415 #line 937 "parser.yy"
    6416     { (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) ); }
     6210#line 957 "parser.yy"
     6211    { (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) ); }
    64176212    break;
    64186213
    … …  
    64206215
    64216216/* Line 1806 of yacc.c  */
    6422 #line 939 "parser.yy"
    6423     { (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) ); }
     6217#line 962 "parser.yy"
     6218    { (yyval.flag) = false; }
    64246219    break;
    64256220
    … …  
    64276222
    64286223/* Line 1806 of yacc.c  */
    6429 #line 944 "parser.yy"
    6430     { (yyval.flag) = false; }
     6224#line 964 "parser.yy"
     6225    { (yyval.flag) = true; }
    64316226    break;
    64326227
    … …  
    64346229
    64356230/* Line 1806 of yacc.c  */
    6436 #line 946 "parser.yy"
    6437     { (yyval.flag) = true; }
    6438     break;
    6439 
    6440   case 223:
    6441 
    6442 /* Line 1806 of yacc.c  */
    6443 #line 951 "parser.yy"
     6231#line 969 "parser.yy"
    64446232    { (yyval.en) = 0; }
    64456233    break;
    64466234
     6235  case 225:
     6236
     6237/* Line 1806 of yacc.c  */
     6238#line 976 "parser.yy"
     6239    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
     6240    break;
     6241
    64476242  case 226:
    64486243
    64496244/* Line 1806 of yacc.c  */
    6450 #line 958 "parser.yy"
    6451     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
     6245#line 981 "parser.yy"
     6246    { (yyval.en) = new AsmExprNode( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ); }
    64526247    break;
    64536248
    … …  
    64556250
    64566251/* Line 1806 of yacc.c  */
    6457 #line 963 "parser.yy"
    6458     { (yyval.en) = new AsmExprNode( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ); }
     6252#line 983 "parser.yy"
     6253    { (yyval.en) = new AsmExprNode( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ); }
    64596254    break;
    64606255
    … …  
    64626257
    64636258/* Line 1806 of yacc.c  */
    6464 #line 965 "parser.yy"
    6465     { (yyval.en) = new AsmExprNode( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ); }
     6259#line 988 "parser.yy"
     6260    { (yyval.constant) = 0; }
    64666261    break;
    64676262
    … …  
    64696264
    64706265/* Line 1806 of yacc.c  */
    6471 #line 970 "parser.yy"
    6472     { (yyval.constant) = 0; }
     6266#line 990 "parser.yy"
     6267    { (yyval.constant) = (yyvsp[(1) - (1)].constant); }
    64736268    break;
    64746269
    … …  
    64766271
    64776272/* Line 1806 of yacc.c  */
    6478 #line 972 "parser.yy"
    6479     { (yyval.constant) = (yyvsp[(1) - (1)].constant); }
     6273#line 992 "parser.yy"
     6274    { (yyval.constant) = (ConstantNode *)(yyvsp[(1) - (3)].constant)->set_link( (yyvsp[(3) - (3)].constant) ); }
    64806275    break;
    64816276
    … …  
    64836278
    64846279/* Line 1806 of yacc.c  */
    6485 #line 974 "parser.yy"
    6486     { (yyval.constant) = (ConstantNode *)(yyvsp[(1) - (3)].constant)->set_link( (yyvsp[(3) - (3)].constant) ); }
     6280#line 997 "parser.yy"
     6281    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
    64876282    break;
    64886283
    … …  
    64906285
    64916286/* Line 1806 of yacc.c  */
    6492 #line 979 "parser.yy"
    6493     { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
     6287#line 999 "parser.yy"
     6288    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
    64946289    break;
    64956290
    … …  
    64976292
    64986293/* Line 1806 of yacc.c  */
    6499 #line 981 "parser.yy"
    6500     { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
    6501     break;
    6502 
    6503   case 234:
    6504 
    6505 /* Line 1806 of yacc.c  */
    6506 #line 988 "parser.yy"
     6294#line 1006 "parser.yy"
    65076295    { (yyval.decl) = 0; }
    65086296    break;
    65096297
     6298  case 236:
     6299
     6300/* Line 1806 of yacc.c  */
     6301#line 1013 "parser.yy"
     6302    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     6303    break;
     6304
    65106305  case 237:
    65116306
    65126307/* Line 1806 of yacc.c  */
    6513 #line 995 "parser.yy"
     6308#line 1018 "parser.yy"
     6309    { (yyval.decl) = 0; }
     6310    break;
     6311
     6312  case 240:
     6313
     6314/* Line 1806 of yacc.c  */
     6315#line 1025 "parser.yy"
    65146316    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    65156317    break;
    65166318
    6517   case 238:
    6518 
    6519 /* Line 1806 of yacc.c  */
    6520 #line 1000 "parser.yy"
    6521     { (yyval.decl) = 0; }
    6522     break;
    6523 
    6524   case 241:
    6525 
    6526 /* Line 1806 of yacc.c  */
    6527 #line 1007 "parser.yy"
    6528     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     6319  case 245:
     6320
     6321/* Line 1806 of yacc.c  */
     6322#line 1039 "parser.yy"
     6323    {}
    65296324    break;
    65306325
    … …  
    65326327
    65336328/* Line 1806 of yacc.c  */
    6534 #line 1021 "parser.yy"
     6329#line 1040 "parser.yy"
    65356330    {}
    65366331    break;
    65376332
    6538   case 247:
    6539 
    6540 /* Line 1806 of yacc.c  */
    6541 #line 1022 "parser.yy"
    6542     {}
    6543     break;
    6544 
    6545   case 255:
    6546 
    6547 /* Line 1806 of yacc.c  */
    6548 #line 1051 "parser.yy"
     6333  case 254:
     6334
     6335/* Line 1806 of yacc.c  */
     6336#line 1069 "parser.yy"
    65496337    {
    65506338                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    65536341    break;
    65546342
    6555   case 256:
    6556 
    6557 /* Line 1806 of yacc.c  */
    6558 #line 1058 "parser.yy"
     6343  case 255:
     6344
     6345/* Line 1806 of yacc.c  */
     6346#line 1076 "parser.yy"
    65596347    {
    65606348                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    65636351    break;
    65646352
    6565   case 257:
    6566 
    6567 /* Line 1806 of yacc.c  */
    6568 #line 1063 "parser.yy"
     6353  case 256:
     6354
     6355/* Line 1806 of yacc.c  */
     6356#line 1081 "parser.yy"
    65696357    {
    65706358                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
    … …  
    65736361    break;
    65746362
    6575   case 258:
    6576 
    6577 /* Line 1806 of yacc.c  */
    6578 #line 1073 "parser.yy"
     6363  case 257:
     6364
     6365/* Line 1806 of yacc.c  */
     6366#line 1091 "parser.yy"
    65796367    {
    65806368                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
    … …  
    65836371    break;
    65846372
    6585   case 259:
    6586 
    6587 /* Line 1806 of yacc.c  */
    6588 #line 1078 "parser.yy"
     6373  case 258:
     6374
     6375/* Line 1806 of yacc.c  */
     6376#line 1096 "parser.yy"
    65896377    {
    65906378                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
    … …  
    65936381    break;
    65946382
    6595   case 260:
    6596 
    6597 /* Line 1806 of yacc.c  */
    6598 #line 1083 "parser.yy"
     6383  case 259:
     6384
     6385/* Line 1806 of yacc.c  */
     6386#line 1101 "parser.yy"
    65996387    {
    66006388                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
    … …  
    66036391    break;
    66046392
    6605   case 261:
    6606 
    6607 /* Line 1806 of yacc.c  */
    6608 #line 1091 "parser.yy"
     6393  case 260:
     6394
     6395/* Line 1806 of yacc.c  */
     6396#line 1109 "parser.yy"
    66096397    {
    66106398                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    66136401    break;
    66146402
    6615   case 262:
    6616 
    6617 /* Line 1806 of yacc.c  */
    6618 #line 1096 "parser.yy"
     6403  case 261:
     6404
     6405/* Line 1806 of yacc.c  */
     6406#line 1114 "parser.yy"
    66196407    {
    66206408                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    66236411    break;
    66246412
    6625   case 263:
    6626 
    6627 /* Line 1806 of yacc.c  */
    6628 #line 1101 "parser.yy"
     6413  case 262:
     6414
     6415/* Line 1806 of yacc.c  */
     6416#line 1119 "parser.yy"
    66296417    {
    66306418                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    66336421    break;
    66346422
    6635   case 264:
    6636 
    6637 /* Line 1806 of yacc.c  */
    6638 #line 1106 "parser.yy"
     6423  case 263:
     6424
     6425/* Line 1806 of yacc.c  */
     6426#line 1124 "parser.yy"
    66396427    {
    66406428                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    66436431    break;
    66446432
    6645   case 265:
    6646 
    6647 /* Line 1806 of yacc.c  */
    6648 #line 1111 "parser.yy"
     6433  case 264:
     6434
     6435/* Line 1806 of yacc.c  */
     6436#line 1129 "parser.yy"
    66496437    {
    66506438                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
    … …  
    66536441    break;
    66546442
    6655   case 266:
    6656 
    6657 /* Line 1806 of yacc.c  */
    6658 #line 1119 "parser.yy"
     6443  case 265:
     6444
     6445/* Line 1806 of yacc.c  */
     6446#line 1137 "parser.yy"
    66596447    {
    66606448                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
    … …  
    66626450    break;
    66636451
    6664   case 267:
    6665 
    6666 /* Line 1806 of yacc.c  */
    6667 #line 1142 "parser.yy"
     6452  case 266:
     6453
     6454/* Line 1806 of yacc.c  */
     6455#line 1160 "parser.yy"
    66686456    {
    66696457                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
    … …  
    66716459    break;
    66726460
    6673   case 268:
    6674 
    6675 /* Line 1806 of yacc.c  */
    6676 #line 1146 "parser.yy"
     6461  case 267:
     6462
     6463/* Line 1806 of yacc.c  */
     6464#line 1164 "parser.yy"
    66776465    {
    66786466                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
    … …  
    66806468    break;
    66816469
     6470  case 268:
     6471
     6472/* Line 1806 of yacc.c  */
     6473#line 1171 "parser.yy"
     6474    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     6475    break;
     6476
    66826477  case 269:
    66836478
    66846479/* Line 1806 of yacc.c  */
    6685 #line 1153 "parser.yy"
    6686     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     6480#line 1175 "parser.yy"
     6481    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    66876482    break;
    66886483
    … …  
    66906485
    66916486/* Line 1806 of yacc.c  */
    6692 #line 1157 "parser.yy"
    6693     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    6694     break;
    6695 
    6696   case 271:
    6697 
    6698 /* Line 1806 of yacc.c  */
    6699 #line 1162 "parser.yy"
     6487#line 1180 "parser.yy"
    67006488    {
    67016489                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    67046492    break;
    67056493
    6706   case 272:
    6707 
    6708 /* Line 1806 of yacc.c  */
    6709 #line 1167 "parser.yy"
     6494  case 271:
     6495
     6496/* Line 1806 of yacc.c  */
     6497#line 1185 "parser.yy"
    67106498    {
    67116499                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    67146502    break;
    67156503
    6716   case 273:
    6717 
    6718 /* Line 1806 of yacc.c  */
    6719 #line 1172 "parser.yy"
     6504  case 272:
     6505
     6506/* Line 1806 of yacc.c  */
     6507#line 1190 "parser.yy"
    67206508    {
    67216509                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
    … …  
    67246512    break;
    67256513
    6726   case 274:
    6727 
    6728 /* Line 1806 of yacc.c  */
    6729 #line 1183 "parser.yy"
     6514  case 273:
     6515
     6516/* Line 1806 of yacc.c  */
     6517#line 1201 "parser.yy"
    67306518    {
    67316519                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    67346522    break;
    67356523
    6736   case 275:
    6737 
    6738 /* Line 1806 of yacc.c  */
    6739 #line 1188 "parser.yy"
     6524  case 274:
     6525
     6526/* Line 1806 of yacc.c  */
     6527#line 1206 "parser.yy"
    67406528    {
    67416529                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    67446532    break;
    67456533
    6746   case 276:
    6747 
    6748 /* Line 1806 of yacc.c  */
    6749 #line 1193 "parser.yy"
     6534  case 275:
     6535
     6536/* Line 1806 of yacc.c  */
     6537#line 1211 "parser.yy"
    67506538    {
    67516539                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    67546542    break;
    67556543
    6756   case 277:
    6757 
    6758 /* Line 1806 of yacc.c  */
    6759 #line 1198 "parser.yy"
     6544  case 276:
     6545
     6546/* Line 1806 of yacc.c  */
     6547#line 1216 "parser.yy"
    67606548    {
    67616549                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    67646552    break;
    67656553
    6766   case 278:
    6767 
    6768 /* Line 1806 of yacc.c  */
    6769 #line 1203 "parser.yy"
     6554  case 277:
     6555
     6556/* Line 1806 of yacc.c  */
     6557#line 1221 "parser.yy"
    67706558    {
    67716559                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    67746562    break;
    67756563
    6776   case 279:
    6777 
    6778 /* Line 1806 of yacc.c  */
    6779 #line 1212 "parser.yy"
     6564  case 278:
     6565
     6566/* Line 1806 of yacc.c  */
     6567#line 1230 "parser.yy"
    67806568    {
    67816569                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
    … …  
    67846572    break;
    67856573
    6786   case 280:
    6787 
    6788 /* Line 1806 of yacc.c  */
    6789 #line 1217 "parser.yy"
     6574  case 279:
     6575
     6576/* Line 1806 of yacc.c  */
     6577#line 1235 "parser.yy"
    67906578    {
    67916579                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
    … …  
    67946582    break;
    67956583
    6796   case 285:
    6797 
    6798 /* Line 1806 of yacc.c  */
    6799 #line 1234 "parser.yy"
     6584  case 284:
     6585
     6586/* Line 1806 of yacc.c  */
     6587#line 1252 "parser.yy"
    68006588    {
    68016589                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    68046592    break;
    68056593
    6806   case 286:
    6807 
    6808 /* Line 1806 of yacc.c  */
    6809 #line 1239 "parser.yy"
     6594  case 285:
     6595
     6596/* Line 1806 of yacc.c  */
     6597#line 1257 "parser.yy"
    68106598    {
    68116599                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    68146602    break;
    68156603
    6816   case 295:
    6817 
    6818 /* Line 1806 of yacc.c  */
    6819 #line 1261 "parser.yy"
     6604  case 294:
     6605
     6606/* Line 1806 of yacc.c  */
     6607#line 1279 "parser.yy"
    68206608    { (yyval.decl) = 0; }
    68216609    break;
    68226610
    6823   case 298:
    6824 
    6825 /* Line 1806 of yacc.c  */
    6826 #line 1273 "parser.yy"
     6611  case 297:
     6612
     6613/* Line 1806 of yacc.c  */
     6614#line 1291 "parser.yy"
    68276615    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68286616    break;
    68296617
     6618  case 300:
     6619
     6620/* Line 1806 of yacc.c  */
     6621#line 1302 "parser.yy"
     6622    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
     6623    break;
     6624
    68306625  case 301:
    68316626
    68326627/* Line 1806 of yacc.c  */
    6833 #line 1284 "parser.yy"
    6834     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
     6628#line 1304 "parser.yy"
     6629    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    68356630    break;
    68366631
    … …  
    68386633
    68396634/* Line 1806 of yacc.c  */
    6840 #line 1286 "parser.yy"
    6841     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
     6635#line 1306 "parser.yy"
     6636    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    68426637    break;
    68436638
    … …  
    68456640
    68466641/* Line 1806 of yacc.c  */
    6847 #line 1288 "parser.yy"
    6848     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
     6642#line 1308 "parser.yy"
     6643    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    68496644    break;
    68506645
    … …  
    68526647
    68536648/* Line 1806 of yacc.c  */
    6854 #line 1290 "parser.yy"
    6855     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
     6649#line 1310 "parser.yy"
     6650    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    68566651    break;
    68576652
    … …  
    68596654
    68606655/* Line 1806 of yacc.c  */
    6861 #line 1292 "parser.yy"
    6862     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    6863     break;
    6864 
    6865   case 306:
    6866 
    6867 /* Line 1806 of yacc.c  */
    6868 #line 1294 "parser.yy"
     6656#line 1312 "parser.yy"
    68696657    {
    68706658                        typedefTable.enterScope();
    … …  
    68726660    break;
    68736661
    6874   case 307:
    6875 
    6876 /* Line 1806 of yacc.c  */
    6877 #line 1298 "parser.yy"
     6662  case 306:
     6663
     6664/* Line 1806 of yacc.c  */
     6665#line 1316 "parser.yy"
    68786666    {
    68796667                        typedefTable.leaveScope();
    … …  
    68826670    break;
    68836671
     6672  case 308:
     6673
     6674/* Line 1806 of yacc.c  */
     6675#line 1325 "parser.yy"
     6676    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6677    break;
     6678
    68846679  case 309:
    68856680
    68866681/* Line 1806 of yacc.c  */
    6887 #line 1307 "parser.yy"
     6682#line 1327 "parser.yy"
     6683    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     6684    break;
     6685
     6686  case 311:
     6687
     6688/* Line 1806 of yacc.c  */
     6689#line 1338 "parser.yy"
    68886690    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68896691    break;
    68906692
    6891   case 310:
    6892 
    6893 /* Line 1806 of yacc.c  */
    6894 #line 1309 "parser.yy"
     6693  case 313:
     6694
     6695/* Line 1806 of yacc.c  */
     6696#line 1347 "parser.yy"
     6697    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
     6698    break;
     6699
     6700  case 314:
     6701
     6702/* Line 1806 of yacc.c  */
     6703#line 1349 "parser.yy"
     6704    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
     6705    break;
     6706
     6707  case 315:
     6708
     6709/* Line 1806 of yacc.c  */
     6710#line 1351 "parser.yy"
     6711    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
     6712    break;
     6713
     6714  case 316:
     6715
     6716/* Line 1806 of yacc.c  */
     6717#line 1353 "parser.yy"
     6718    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     6719    break;
     6720
     6721  case 317:
     6722
     6723/* Line 1806 of yacc.c  */
     6724#line 1355 "parser.yy"
     6725    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
     6726    break;
     6727
     6728  case 318:
     6729
     6730/* Line 1806 of yacc.c  */
     6731#line 1357 "parser.yy"
     6732    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     6733    break;
     6734
     6735  case 319:
     6736
     6737/* Line 1806 of yacc.c  */
     6738#line 1359 "parser.yy"
     6739    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
     6740    break;
     6741
     6742  case 320:
     6743
     6744/* Line 1806 of yacc.c  */
     6745#line 1361 "parser.yy"
     6746    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
     6747    break;
     6748
     6749  case 321:
     6750
     6751/* Line 1806 of yacc.c  */
     6752#line 1366 "parser.yy"
     6753    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     6754    break;
     6755
     6756  case 322:
     6757
     6758/* Line 1806 of yacc.c  */
     6759#line 1368 "parser.yy"
     6760    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
     6761    break;
     6762
     6763  case 323:
     6764
     6765/* Line 1806 of yacc.c  */
     6766#line 1370 "parser.yy"
     6767    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     6768    break;
     6769
     6770  case 324:
     6771
     6772/* Line 1806 of yacc.c  */
     6773#line 1372 "parser.yy"
     6774    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
     6775    break;
     6776
     6777  case 325:
     6778
     6779/* Line 1806 of yacc.c  */
     6780#line 1374 "parser.yy"
     6781    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
     6782    break;
     6783
     6784  case 326:
     6785
     6786/* Line 1806 of yacc.c  */
     6787#line 1376 "parser.yy"
     6788    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
     6789    break;
     6790
     6791  case 327:
     6792
     6793/* Line 1806 of yacc.c  */
     6794#line 1378 "parser.yy"
     6795    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
     6796    break;
     6797
     6798  case 328:
     6799
     6800/* Line 1806 of yacc.c  */
     6801#line 1380 "parser.yy"
     6802    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
     6803    break;
     6804
     6805  case 329:
     6806
     6807/* Line 1806 of yacc.c  */
     6808#line 1382 "parser.yy"
     6809    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     6810    break;
     6811
     6812  case 330:
     6813
     6814/* Line 1806 of yacc.c  */
     6815#line 1384 "parser.yy"
     6816    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
     6817    break;
     6818
     6819  case 331:
     6820
     6821/* Line 1806 of yacc.c  */
     6822#line 1386 "parser.yy"
     6823    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
     6824    break;
     6825
     6826  case 332:
     6827
     6828/* Line 1806 of yacc.c  */
     6829#line 1388 "parser.yy"
     6830    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
     6831    break;
     6832
     6833  case 333:
     6834
     6835/* Line 1806 of yacc.c  */
     6836#line 1390 "parser.yy"
     6837    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
     6838    break;
     6839
     6840  case 335:
     6841
     6842/* Line 1806 of yacc.c  */
     6843#line 1397 "parser.yy"
     6844    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6845    break;
     6846
     6847  case 336:
     6848
     6849/* Line 1806 of yacc.c  */
     6850#line 1399 "parser.yy"
     6851    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6852    break;
     6853
     6854  case 337:
     6855
     6856/* Line 1806 of yacc.c  */
     6857#line 1401 "parser.yy"
    68956858    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68966859    break;
    68976860
    6898   case 312:
    6899 
    6900 /* Line 1806 of yacc.c  */
    6901 #line 1320 "parser.yy"
     6861  case 338:
     6862
     6863/* Line 1806 of yacc.c  */
     6864#line 1403 "parser.yy"
     6865    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
     6866    break;
     6867
     6868  case 340:
     6869
     6870/* Line 1806 of yacc.c  */
     6871#line 1409 "parser.yy"
     6872    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     6873    break;
     6874
     6875  case 342:
     6876
     6877/* Line 1806 of yacc.c  */
     6878#line 1416 "parser.yy"
     6879    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6880    break;
     6881
     6882  case 343:
     6883
     6884/* Line 1806 of yacc.c  */
     6885#line 1418 "parser.yy"
    69026886    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69036887    break;
    69046888
    6905   case 314:
    6906 
    6907 /* Line 1806 of yacc.c  */
    6908 #line 1329 "parser.yy"
    6909     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    6910     break;
    6911 
    6912   case 315:
    6913 
    6914 /* Line 1806 of yacc.c  */
    6915 #line 1331 "parser.yy"
    6916     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    6917     break;
    6918 
    6919   case 316:
    6920 
    6921 /* Line 1806 of yacc.c  */
    6922 #line 1333 "parser.yy"
    6923     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    6924     break;
    6925 
    6926   case 317:
    6927 
    6928 /* Line 1806 of yacc.c  */
    6929 #line 1335 "parser.yy"
    6930     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    6931     break;
    6932 
    6933   case 318:
    6934 
    6935 /* Line 1806 of yacc.c  */
    6936 #line 1337 "parser.yy"
    6937     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    6938     break;
    6939 
    6940   case 319:
    6941 
    6942 /* Line 1806 of yacc.c  */
    6943 #line 1339 "parser.yy"
    6944     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    6945     break;
    6946 
    6947   case 320:
    6948 
    6949 /* Line 1806 of yacc.c  */
    6950 #line 1341 "parser.yy"
    6951     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    6952     break;
    6953 
    6954   case 321:
    6955 
    6956 /* Line 1806 of yacc.c  */
    6957 #line 1343 "parser.yy"
    6958     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    6959     break;
    6960 
    6961   case 322:
    6962 
    6963 /* Line 1806 of yacc.c  */
    6964 #line 1348 "parser.yy"
    6965     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    6966     break;
    6967 
    6968   case 323:
    6969 
    6970 /* Line 1806 of yacc.c  */
    6971 #line 1350 "parser.yy"
    6972     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    6973     break;
    6974 
    6975   case 324:
    6976 
    6977 /* Line 1806 of yacc.c  */
    6978 #line 1352 "parser.yy"
    6979     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    6980     break;
    6981 
    6982   case 325:
    6983 
    6984 /* Line 1806 of yacc.c  */
    6985 #line 1354 "parser.yy"
    6986     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    6987     break;
    6988 
    6989   case 326:
    6990 
    6991 /* Line 1806 of yacc.c  */
    6992 #line 1356 "parser.yy"
    6993     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
    6994     break;
    6995 
    6996   case 327:
    6997 
    6998 /* Line 1806 of yacc.c  */
    6999 #line 1358 "parser.yy"
    7000     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
    7001     break;
    7002 
    7003   case 328:
    7004 
    7005 /* Line 1806 of yacc.c  */
    7006 #line 1360 "parser.yy"
    7007     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
    7008     break;
    7009 
    7010   case 329:
    7011 
    7012 /* Line 1806 of yacc.c  */
    7013 #line 1362 "parser.yy"
    7014     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
    7015     break;
    7016 
    7017   case 330:
    7018 
    7019 /* Line 1806 of yacc.c  */
    7020 #line 1364 "parser.yy"
    7021     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    7022     break;
    7023 
    7024   case 331:
    7025 
    7026 /* Line 1806 of yacc.c  */
    7027 #line 1366 "parser.yy"
    7028     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    7029     break;
    7030 
    7031   case 332:
    7032 
    7033 /* Line 1806 of yacc.c  */
    7034 #line 1368 "parser.yy"
    7035     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    7036     break;
    7037 
    7038   case 333:
    7039 
    7040 /* Line 1806 of yacc.c  */
    7041 #line 1370 "parser.yy"
    7042     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    7043     break;
    7044 
    7045   case 334:
    7046 
    7047 /* Line 1806 of yacc.c  */
    7048 #line 1372 "parser.yy"
    7049     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    7050     break;
    7051 
    7052   case 336:
    7053 
    7054 /* Line 1806 of yacc.c  */
    7055 #line 1379 "parser.yy"
    7056     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7057     break;
    7058 
    7059   case 337:
    7060 
    7061 /* Line 1806 of yacc.c  */
    7062 #line 1381 "parser.yy"
    7063     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    7064     break;
    7065 
    7066   case 338:
    7067 
    7068 /* Line 1806 of yacc.c  */
    7069 #line 1383 "parser.yy"
    7070     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    7071     break;
    7072 
    7073   case 339:
    7074 
    7075 /* Line 1806 of yacc.c  */
    7076 #line 1385 "parser.yy"
    7077     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    7078     break;
    7079 
    7080   case 341:
    7081 
    7082 /* Line 1806 of yacc.c  */
    7083 #line 1391 "parser.yy"
    7084     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    7085     break;
    7086 
    7087   case 343:
    7088 
    7089 /* Line 1806 of yacc.c  */
    7090 #line 1398 "parser.yy"
    7091     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7092     break;
    7093 
    70946889  case 344:
    70956890
    70966891/* Line 1806 of yacc.c  */
    7097 #line 1400 "parser.yy"
    7098     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6892#line 1420 "parser.yy"
     6893    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    70996894    break;
    71006895
    … …  
    71026897
    71036898/* Line 1806 of yacc.c  */
    7104 #line 1402 "parser.yy"
    7105     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
     6899#line 1425 "parser.yy"
     6900    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    71066901    break;
    71076902
    … …  
    71096904
    71106905/* Line 1806 of yacc.c  */
    7111 #line 1407 "parser.yy"
    7112     { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
     6906#line 1427 "parser.yy"
     6907    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    71136908    break;
    71146909
    … …  
    71166911
    71176912/* Line 1806 of yacc.c  */
    7118 #line 1409 "parser.yy"
    7119     { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
     6913#line 1429 "parser.yy"
     6914    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    71206915    break;
    71216916
    … …  
    71236918
    71246919/* Line 1806 of yacc.c  */
    7125 #line 1411 "parser.yy"
    7126     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    7127     break;
    7128 
    7129   case 349:
    7130 
    7131 /* Line 1806 of yacc.c  */
    7132 #line 1413 "parser.yy"
     6920#line 1431 "parser.yy"
    71336921    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    71346922    break;
    71356923
    7136   case 351:
    7137 
    7138 /* Line 1806 of yacc.c  */
    7139 #line 1419 "parser.yy"
    7140     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7141     break;
    7142 
    7143   case 352:
    7144 
    7145 /* Line 1806 of yacc.c  */
    7146 #line 1421 "parser.yy"
    7147     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    7148     break;
    7149 
    7150   case 353:
    7151 
    7152 /* Line 1806 of yacc.c  */
    7153 #line 1423 "parser.yy"
    7154     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    7155     break;
    7156 
    7157   case 355:
    7158 
    7159 /* Line 1806 of yacc.c  */
    7160 #line 1429 "parser.yy"
    7161     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7162     break;
    7163 
    7164   case 356:
    7165 
    7166 /* Line 1806 of yacc.c  */
    7167 #line 1431 "parser.yy"
    7168     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    7169     break;
    7170 
    7171   case 358:
     6924  case 350:
    71726925
    71736926/* Line 1806 of yacc.c  */
    … …  
    71766929    break;
    71776930
    7178   case 359:
     6931  case 351:
    71796932
    71806933/* Line 1806 of yacc.c  */
    … …  
    71836936    break;
    71846937
    7185   case 360:
     6938  case 352:
    71866939
    71876940/* Line 1806 of yacc.c  */
    … …  
    71906943    break;
    71916944
     6945  case 354:
     6946
     6947/* Line 1806 of yacc.c  */
     6948#line 1447 "parser.yy"
     6949    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6950    break;
     6951
     6952  case 355:
     6953
     6954/* Line 1806 of yacc.c  */
     6955#line 1449 "parser.yy"
     6956    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6957    break;
     6958
     6959  case 357:
     6960
     6961/* Line 1806 of yacc.c  */
     6962#line 1455 "parser.yy"
     6963    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6964    break;
     6965
     6966  case 358:
     6967
     6968/* Line 1806 of yacc.c  */
     6969#line 1457 "parser.yy"
     6970    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6971    break;
     6972
     6973  case 359:
     6974
     6975/* Line 1806 of yacc.c  */
     6976#line 1459 "parser.yy"
     6977    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     6978    break;
     6979
     6980  case 360:
     6981
     6982/* Line 1806 of yacc.c  */
     6983#line 1464 "parser.yy"
     6984    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
     6985    break;
     6986
    71926987  case 361:
    71936988
    71946989/* Line 1806 of yacc.c  */
    7195 #line 1446 "parser.yy"
    7196     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
     6990#line 1466 "parser.yy"
     6991    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    71976992    break;
    71986993
    … …  
    72006995
    72016996/* Line 1806 of yacc.c  */
    7202 #line 1448 "parser.yy"
    7203     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7204     break;
    7205 
    7206   case 363:
    7207 
    7208 /* Line 1806 of yacc.c  */
    7209 #line 1450 "parser.yy"
     6997#line 1468 "parser.yy"
    72106998    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    72116999    break;
    72127000
     7001  case 365:
     7002
     7003/* Line 1806 of yacc.c  */
     7004#line 1478 "parser.yy"
     7005    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
     7006    break;
     7007
    72137008  case 366:
    72147009
    72157010/* Line 1806 of yacc.c  */
    7216 #line 1460 "parser.yy"
    7217     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
    7218     break;
    7219 
    7220   case 367:
    7221 
    7222 /* Line 1806 of yacc.c  */
    7223 #line 1462 "parser.yy"
     7011#line 1480 "parser.yy"
    72247012    {
    72257013                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
    … …  
    72287016    break;
    72297017
     7018  case 367:
     7019
     7020/* Line 1806 of yacc.c  */
     7021#line 1485 "parser.yy"
     7022    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     7023    break;
     7024
    72307025  case 368:
    72317026
    72327027/* Line 1806 of yacc.c  */
    7233 #line 1467 "parser.yy"
    7234     { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     7028#line 1487 "parser.yy"
     7029    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
    72357030    break;
    72367031
    … …  
    72387033
    72397034/* Line 1806 of yacc.c  */
    7240 #line 1469 "parser.yy"
    7241     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
     7035#line 1489 "parser.yy"
     7036    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    72427037    break;
    72437038
    … …  
    72457040
    72467041/* Line 1806 of yacc.c  */
    7247 #line 1471 "parser.yy"
    7248     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
     7042#line 1491 "parser.yy"
     7043    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    72497044    break;
    72507045
    … …  
    72527047
    72537048/* Line 1806 of yacc.c  */
    7254 #line 1473 "parser.yy"
    7255     { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
     7049#line 1496 "parser.yy"
     7050    { (yyval.aggKey) = DeclarationNode::Struct; }
    72567051    break;
    72577052
    … …  
    72597054
    72607055/* Line 1806 of yacc.c  */
    7261 #line 1478 "parser.yy"
    7262     { (yyval.aggKey) = DeclarationNode::Struct; }
     7056#line 1498 "parser.yy"
     7057    { (yyval.aggKey) = DeclarationNode::Union; }
    72637058    break;
    72647059
    … …  
    72667061
    72677062/* Line 1806 of yacc.c  */
    7268 #line 1480 "parser.yy"
    7269     { (yyval.aggKey) = DeclarationNode::Union; }
     7063#line 1503 "parser.yy"
     7064    { (yyval.decl) = 0; }
    72707065    break;
    72717066
    … …  
    72737068
    72747069/* Line 1806 of yacc.c  */
    7275 #line 1485 "parser.yy"
    7276     { (yyval.decl) = 0; }
    7277     break;
    7278 
    7279   case 375:
    7280 
    7281 /* Line 1806 of yacc.c  */
    7282 #line 1487 "parser.yy"
     7070#line 1505 "parser.yy"
    72837071    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    72847072    break;
    72857073
    7286   case 377:
    7287 
    7288 /* Line 1806 of yacc.c  */
    7289 #line 1493 "parser.yy"
     7074  case 376:
     7075
     7076/* Line 1806 of yacc.c  */
     7077#line 1511 "parser.yy"
    72907078    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    72917079    break;
    72927080
    7293   case 379:
    7294 
    7295 /* Line 1806 of yacc.c  */
    7296 #line 1496 "parser.yy"
     7081  case 378:
     7082
     7083/* Line 1806 of yacc.c  */
     7084#line 1514 "parser.yy"
    72977085    {   // mark all fields in list
    72987086                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
    … …  
    73027090    break;
    73037091
     7092  case 380:
     7093
     7094/* Line 1806 of yacc.c  */
     7095#line 1524 "parser.yy"
     7096    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
     7097    break;
     7098
    73047099  case 381:
    73057100
    73067101/* Line 1806 of yacc.c  */
    7307 #line 1506 "parser.yy"
    7308     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
     7102#line 1526 "parser.yy"
     7103    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    73097104    break;
    73107105
    … …  
    73127107
    73137108/* Line 1806 of yacc.c  */
    7314 #line 1508 "parser.yy"
    7315     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
     7109#line 1528 "parser.yy"
     7110    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    73167111    break;
    73177112
    … …  
    73197114
    73207115/* Line 1806 of yacc.c  */
    7321 #line 1510 "parser.yy"
    7322     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
     7116#line 1533 "parser.yy"
     7117    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73237118    break;
    73247119
    … …  
    73267121
    73277122/* Line 1806 of yacc.c  */
    7328 #line 1515 "parser.yy"
    7329     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     7123#line 1535 "parser.yy"
     7124    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    73307125    break;
    73317126
    … …  
    73337128
    73347129/* Line 1806 of yacc.c  */
    7335 #line 1517 "parser.yy"
    7336     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
     7130#line 1540 "parser.yy"
     7131    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    73377132    break;
    73387133
    … …  
    73407135
    73417136/* Line 1806 of yacc.c  */
    7342 #line 1522 "parser.yy"
    7343     { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
     7137#line 1542 "parser.yy"
     7138    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    73447139    break;
    73457140
    … …  
    73477142
    73487143/* Line 1806 of yacc.c  */
    7349 #line 1524 "parser.yy"
    7350     { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
     7144#line 1545 "parser.yy"
     7145    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    73517146    break;
    73527147
    … …  
    73547149
    73557150/* Line 1806 of yacc.c  */
    7356 #line 1527 "parser.yy"
     7151#line 1548 "parser.yy"
    73577152    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    73587153    break;
    73597154
    7360   case 389:
    7361 
    7362 /* Line 1806 of yacc.c  */
    7363 #line 1530 "parser.yy"
    7364     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     7155  case 390:
     7156
     7157/* Line 1806 of yacc.c  */
     7158#line 1554 "parser.yy"
     7159    { (yyval.en) = 0; }
    73657160    break;
    73667161
    … …  
    73687163
    73697164/* Line 1806 of yacc.c  */
    7370 #line 1536 "parser.yy"
    7371     { (yyval.en) = 0; }
     7165#line 1556 "parser.yy"
     7166    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    73727167    break;
    73737168
    … …  
    73757170
    73767171/* Line 1806 of yacc.c  */
    7377 #line 1538 "parser.yy"
    7378     { (yyval.en) = (yyvsp[(1) - (1)].en); }
    7379     break;
    7380 
    7381   case 393:
    7382 
    7383 /* Line 1806 of yacc.c  */
    7384 #line 1543 "parser.yy"
     7172#line 1561 "parser.yy"
    73857173    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    73867174    break;
    73877175
     7176  case 394:
     7177
     7178/* Line 1806 of yacc.c  */
     7179#line 1570 "parser.yy"
     7180    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
     7181    break;
     7182
    73887183  case 395:
    73897184
    73907185/* Line 1806 of yacc.c  */
    7391 #line 1552 "parser.yy"
    7392     { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
    7393     break;
    7394 
    7395   case 396:
    7396 
    7397 /* Line 1806 of yacc.c  */
    7398 #line 1554 "parser.yy"
     7186#line 1572 "parser.yy"
    73997187    {
    74007188                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
    … …  
    74037191    break;
    74047192
     7193  case 396:
     7194
     7195/* Line 1806 of yacc.c  */
     7196#line 1577 "parser.yy"
     7197    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     7198    break;
     7199
    74057200  case 397:
    74067201
    74077202/* Line 1806 of yacc.c  */
    7408 #line 1559 "parser.yy"
    7409     { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     7203#line 1579 "parser.yy"
     7204    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    74107205    break;
    74117206
    … …  
    74137208
    74147209/* Line 1806 of yacc.c  */
    7415 #line 1561 "parser.yy"
    7416     { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
     7210#line 1584 "parser.yy"
     7211    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    74177212    break;
    74187213
    … …  
    74207215
    74217216/* Line 1806 of yacc.c  */
    7422 #line 1566 "parser.yy"
    7423     { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
     7217#line 1586 "parser.yy"
     7218    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    74247219    break;
    74257220
    … …  
    74277222
    74287223/* Line 1806 of yacc.c  */
    7429 #line 1568 "parser.yy"
    7430     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
     7224#line 1591 "parser.yy"
     7225    { (yyval.en) = 0; }
    74317226    break;
    74327227
    … …  
    74347229
    74357230/* Line 1806 of yacc.c  */
    7436 #line 1573 "parser.yy"
    7437     { (yyval.en) = 0; }
     7231#line 1593 "parser.yy"
     7232    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    74387233    break;
    74397234
    … …  
    74417236
    74427237/* Line 1806 of yacc.c  */
    7443 #line 1575 "parser.yy"
    7444     { (yyval.en) = (yyvsp[(2) - (2)].en); }
    7445     break;
    7446 
    7447   case 403:
    7448 
    7449 /* Line 1806 of yacc.c  */
    7450 #line 1582 "parser.yy"
     7238#line 1600 "parser.yy"
    74517239    { (yyval.decl) = 0; }
    74527240    break;
    74537241
     7242  case 406:
     7243
     7244/* Line 1806 of yacc.c  */
     7245#line 1608 "parser.yy"
     7246    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7247    break;
     7248
    74547249  case 407:
    74557250
    74567251/* Line 1806 of yacc.c  */
    7457 #line 1590 "parser.yy"
     7252#line 1610 "parser.yy"
     7253    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     7254    break;
     7255
     7256  case 408:
     7257
     7258/* Line 1806 of yacc.c  */
     7259#line 1612 "parser.yy"
     7260    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     7261    break;
     7262
     7263  case 410:
     7264
     7265/* Line 1806 of yacc.c  */
     7266#line 1620 "parser.yy"
    74587267    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74597268    break;
    74607269
    7461   case 408:
    7462 
    7463 /* Line 1806 of yacc.c  */
    7464 #line 1592 "parser.yy"
     7270  case 411:
     7271
     7272/* Line 1806 of yacc.c  */
     7273#line 1622 "parser.yy"
     7274    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7275    break;
     7276
     7277  case 412:
     7278
     7279/* Line 1806 of yacc.c  */
     7280#line 1624 "parser.yy"
     7281    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
     7282    break;
     7283
     7284  case 414:
     7285
     7286/* Line 1806 of yacc.c  */
     7287#line 1630 "parser.yy"
     7288    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7289    break;
     7290
     7291  case 415:
     7292
     7293/* Line 1806 of yacc.c  */
     7294#line 1635 "parser.yy"
     7295    { (yyval.decl) = 0; }
     7296    break;
     7297
     7298  case 418:
     7299
     7300/* Line 1806 of yacc.c  */
     7301#line 1642 "parser.yy"
    74657302    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    74667303    break;
    74677304
    7468   case 409:
    7469 
    7470 /* Line 1806 of yacc.c  */
    7471 #line 1594 "parser.yy"
    7472     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    7473     break;
    7474 
    7475   case 411:
    7476 
    7477 /* Line 1806 of yacc.c  */
    7478 #line 1602 "parser.yy"
     7305  case 421:
     7306
     7307/* Line 1806 of yacc.c  */
     7308#line 1649 "parser.yy"
    74797309    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74807310    break;
    74817311
    7482   case 412:
    7483 
    7484 /* Line 1806 of yacc.c  */
    7485 #line 1604 "parser.yy"
     7312  case 422:
     7313
     7314/* Line 1806 of yacc.c  */
     7315#line 1651 "parser.yy"
    74867316    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74877317    break;
    74887318
    7489   case 413:
    7490 
    7491 /* Line 1806 of yacc.c  */
    7492 #line 1606 "parser.yy"
    7493     { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    7494     break;
    7495 
    7496   case 415:
    7497 
    7498 /* Line 1806 of yacc.c  */
    7499 #line 1612 "parser.yy"
    7500     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7501     break;
    7502 
    7503   case 416:
    7504 
    7505 /* Line 1806 of yacc.c  */
    7506 #line 1617 "parser.yy"
    7507     { (yyval.decl) = 0; }
    7508     break;
    7509 
    7510   case 419:
    7511 
    7512 /* Line 1806 of yacc.c  */
    7513 #line 1624 "parser.yy"
    7514     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    7515     break;
    7516 
    7517   case 422:
    7518 
    7519 /* Line 1806 of yacc.c  */
    7520 #line 1631 "parser.yy"
    7521     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7522     break;
    7523 
    7524   case 423:
    7525 
    7526 /* Line 1806 of yacc.c  */
    7527 #line 1633 "parser.yy"
    7528     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7319  case 424:
     7320
     7321/* Line 1806 of yacc.c  */
     7322#line 1660 "parser.yy"
     7323    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    75297324    break;
    75307325
    … …  
    75327327
    75337328/* Line 1806 of yacc.c  */
    7534 #line 1642 "parser.yy"
     7329#line 1663 "parser.yy"
    75357330    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    75367331    break;
    … …  
    75397334
    75407335/* Line 1806 of yacc.c  */
    7541 #line 1645 "parser.yy"
    7542     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    7543     break;
    7544 
    7545   case 427:
    7546 
    7547 /* Line 1806 of yacc.c  */
    7548 #line 1647 "parser.yy"
     7336#line 1665 "parser.yy"
    75497337    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    75507338    break;
    75517339
    7552   case 432:
    7553 
    7554 /* Line 1806 of yacc.c  */
    7555 #line 1657 "parser.yy"
     7340  case 431:
     7341
     7342/* Line 1806 of yacc.c  */
     7343#line 1675 "parser.yy"
    75567344    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75577345    break;
    75587346
    7559   case 434:
    7560 
    7561 /* Line 1806 of yacc.c  */
    7562 #line 1663 "parser.yy"
     7347  case 433:
     7348
     7349/* Line 1806 of yacc.c  */
     7350#line 1681 "parser.yy"
    75637351    {
    75647352                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    75677355    break;
    75687356
    7569   case 435:
    7570 
    7571 /* Line 1806 of yacc.c  */
    7572 #line 1668 "parser.yy"
     7357  case 434:
     7358
     7359/* Line 1806 of yacc.c  */
     7360#line 1686 "parser.yy"
    75737361    {
    75747362                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    75777365    break;
    75787366
     7367  case 436:
     7368
     7369/* Line 1806 of yacc.c  */
     7370#line 1695 "parser.yy"
     7371    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     7372    break;
     7373
    75797374  case 437:
    75807375
    75817376/* Line 1806 of yacc.c  */
    7582 #line 1677 "parser.yy"
     7377#line 1704 "parser.yy"
     7378    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
     7379    break;
     7380
     7381  case 438:
     7382
     7383/* Line 1806 of yacc.c  */
     7384#line 1706 "parser.yy"
     7385    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
     7386    break;
     7387
     7388  case 450:
     7389
     7390/* Line 1806 of yacc.c  */
     7391#line 1731 "parser.yy"
    75837392    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    75847393    break;
    75857394
    7586   case 438:
    7587 
    7588 /* Line 1806 of yacc.c  */
    7589 #line 1686 "parser.yy"
    7590     { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    7591     break;
    7592 
    7593   case 439:
    7594 
    7595 /* Line 1806 of yacc.c  */
    7596 #line 1688 "parser.yy"
    7597     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    7598     break;
    7599 
    7600   case 451:
    7601 
    7602 /* Line 1806 of yacc.c  */
    7603 #line 1713 "parser.yy"
     7395  case 454:
     7396
     7397/* Line 1806 of yacc.c  */
     7398#line 1739 "parser.yy"
    76047399    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    76057400    break;
    … …  
    76087403
    76097404/* Line 1806 of yacc.c  */
    7610 #line 1721 "parser.yy"
    7611     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     7405#line 1744 "parser.yy"
     7406    { (yyval.in) = 0; }
    76127407    break;
    76137408
    … …  
    76157410
    76167411/* Line 1806 of yacc.c  */
    7617 #line 1726 "parser.yy"
     7412#line 1746 "parser.yy"
     7413    { (yyval.in) = (yyvsp[(2) - (2)].in); }
     7414    break;
     7415
     7416  case 457:
     7417
     7418/* Line 1806 of yacc.c  */
     7419#line 1748 "parser.yy"
     7420    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
     7421    break;
     7422
     7423  case 458:
     7424
     7425/* Line 1806 of yacc.c  */
     7426#line 1752 "parser.yy"
     7427    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
     7428    break;
     7429
     7430  case 459:
     7431
     7432/* Line 1806 of yacc.c  */
     7433#line 1753 "parser.yy"
     7434    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
     7435    break;
     7436
     7437  case 460:
     7438
     7439/* Line 1806 of yacc.c  */
     7440#line 1758 "parser.yy"
    76187441    { (yyval.in) = 0; }
    76197442    break;
    76207443
    7621   case 457:
    7622 
    7623 /* Line 1806 of yacc.c  */
    7624 #line 1728 "parser.yy"
    7625     { (yyval.in) = (yyvsp[(2) - (2)].in); }
    7626     break;
    7627 
    7628   case 458:
    7629 
    7630 /* Line 1806 of yacc.c  */
    7631 #line 1730 "parser.yy"
    7632     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    7633     break;
    7634 
    7635   case 459:
    7636 
    7637 /* Line 1806 of yacc.c  */
    7638 #line 1734 "parser.yy"
    7639     { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    7640     break;
    7641 
    7642   case 460:
    7643 
    7644 /* Line 1806 of yacc.c  */
    7645 #line 1735 "parser.yy"
    7646     { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    7647     break;
    7648 
    7649   case 461:
    7650 
    7651 /* Line 1806 of yacc.c  */
    7652 #line 1740 "parser.yy"
    7653     { (yyval.in) = 0; }
     7444  case 462:
     7445
     7446/* Line 1806 of yacc.c  */
     7447#line 1760 "parser.yy"
     7448    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    76547449    break;
    76557450
    … …  
    76577452
    76587453/* Line 1806 of yacc.c  */
    7659 #line 1742 "parser.yy"
    7660     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
     7454#line 1761 "parser.yy"
     7455    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
    76617456    break;
    76627457
    … …  
    76647459
    76657460/* Line 1806 of yacc.c  */
    7666 #line 1743 "parser.yy"
    7667     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
    7668     break;
    7669 
    7670   case 465:
    7671 
    7672 /* Line 1806 of yacc.c  */
    7673 #line 1745 "parser.yy"
     7461#line 1763 "parser.yy"
    76747462    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    76757463    break;
    76767464
    7677   case 467:
    7678 
    7679 /* Line 1806 of yacc.c  */
    7680 #line 1761 "parser.yy"
     7465  case 466:
     7466
     7467/* Line 1806 of yacc.c  */
     7468#line 1779 "parser.yy"
    76817469    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); }
    76827470    break;
    76837471
     7472  case 468:
     7473
     7474/* Line 1806 of yacc.c  */
     7475#line 1785 "parser.yy"
     7476    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); }
     7477    break;
     7478
    76847479  case 469:
    76857480
    76867481/* Line 1806 of yacc.c  */
    7687 #line 1767 "parser.yy"
    7688     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); }
     7482#line 1793 "parser.yy"
     7483    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
    76897484    break;
    76907485
    … …  
    76927487
    76937488/* Line 1806 of yacc.c  */
    7694 #line 1775 "parser.yy"
    7695     { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
     7489#line 1795 "parser.yy"
     7490    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(2) - (2)].tok) ) ); }
    76967491    break;
    76977492
    … …  
    76997494
    77007495/* Line 1806 of yacc.c  */
    7701 #line 1777 "parser.yy"
    7702     { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(2) - (2)].tok) ) ); }
     7496#line 1798 "parser.yy"
     7497    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    77037498    break;
    77047499
    … …  
    77067501
    77077502/* Line 1806 of yacc.c  */
    7708 #line 1780 "parser.yy"
     7503#line 1800 "parser.yy"
    77097504    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    77107505    break;
    … …  
    77137508
    77147509/* Line 1806 of yacc.c  */
    7715 #line 1782 "parser.yy"
    7716     { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
     7510#line 1802 "parser.yy"
     7511    { (yyval.en) = new DesignatorNode( new CompositeExprNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ), true ); }
    77177512    break;
    77187513
    … …  
    77207515
    77217516/* Line 1806 of yacc.c  */
    7722 #line 1784 "parser.yy"
    7723     { (yyval.en) = new DesignatorNode( new CompositeExprNode2( build_opr2( OperatorNode::Range, (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ), true ); }
    7724     break;
    7725 
    7726   case 475:
    7727 
    7728 /* Line 1806 of yacc.c  */
    7729 #line 1786 "parser.yy"
     7517#line 1804 "parser.yy"
    77307518    { (yyval.en) = new DesignatorNode( (yyvsp[(4) - (6)].en) ); }
    77317519    break;
    77327520
     7521  case 476:
     7522
     7523/* Line 1806 of yacc.c  */
     7524#line 1828 "parser.yy"
     7525    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7526    break;
     7527
    77337528  case 477:
    77347529
    77357530/* Line 1806 of yacc.c  */
    7736 #line 1810 "parser.yy"
     7531#line 1830 "parser.yy"
     7532    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     7533    break;
     7534
     7535  case 478:
     7536
     7537/* Line 1806 of yacc.c  */
     7538#line 1832 "parser.yy"
     7539    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     7540    break;
     7541
     7542  case 480:
     7543
     7544/* Line 1806 of yacc.c  */
     7545#line 1838 "parser.yy"
    77377546    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    77387547    break;
    77397548
    7740   case 478:
    7741 
    7742 /* Line 1806 of yacc.c  */
    7743 #line 1812 "parser.yy"
     7549  case 481:
     7550
     7551/* Line 1806 of yacc.c  */
     7552#line 1840 "parser.yy"
    77447553    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    77457554    break;
    77467555
    7747   case 479:
    7748 
    7749 /* Line 1806 of yacc.c  */
    7750 #line 1814 "parser.yy"
    7751     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    7752     break;
    7753 
    7754   case 481:
    7755 
    7756 /* Line 1806 of yacc.c  */
    7757 #line 1820 "parser.yy"
    7758     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7759     break;
    7760 
    77617556  case 482:
    77627557
    77637558/* Line 1806 of yacc.c  */
    7764 #line 1822 "parser.yy"
    7765     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    7766     break;
    7767 
    7768   case 483:
    7769 
    7770 /* Line 1806 of yacc.c  */
    7771 #line 1827 "parser.yy"
     7559#line 1845 "parser.yy"
    77727560    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    77737561    break;
    77747562
     7563  case 484:
     7564
     7565/* Line 1806 of yacc.c  */
     7566#line 1851 "parser.yy"
     7567    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
     7568    break;
     7569
    77757570  case 485:
    77767571
    77777572/* Line 1806 of yacc.c  */
    7778 #line 1833 "parser.yy"
    7779     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
     7573#line 1856 "parser.yy"
     7574    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    77807575    break;
    77817576
    … …  
    77837578
    77847579/* Line 1806 of yacc.c  */
    7785 #line 1838 "parser.yy"
    7786     { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    7787     break;
    7788 
    7789   case 487:
    7790 
    7791 /* Line 1806 of yacc.c  */
    7792 #line 1840 "parser.yy"
     7580#line 1858 "parser.yy"
    77937581    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    77947582    break;
    77957583
     7584  case 488:
     7585
     7586/* Line 1806 of yacc.c  */
     7587#line 1864 "parser.yy"
     7588    { (yyval.tclass) = DeclarationNode::Type; }
     7589    break;
     7590
    77967591  case 489:
    77977592
    77987593/* Line 1806 of yacc.c  */
    7799 #line 1846 "parser.yy"
    7800     { (yyval.tclass) = DeclarationNode::Type; }
     7594#line 1866 "parser.yy"
     7595    { (yyval.tclass) = DeclarationNode::Ftype; }
    78017596    break;
    78027597
    … …  
    78047599
    78057600/* Line 1806 of yacc.c  */
    7806 #line 1848 "parser.yy"
    7807     { (yyval.tclass) = DeclarationNode::Ftype; }
     7601#line 1868 "parser.yy"
     7602    { (yyval.tclass) = DeclarationNode::Dtype; }
    78087603    break;
    78097604
    … …  
    78117606
    78127607/* Line 1806 of yacc.c  */
    7813 #line 1850 "parser.yy"
    7814     { (yyval.tclass) = DeclarationNode::Dtype; }
     7608#line 1873 "parser.yy"
     7609    { (yyval.decl) = 0; }
    78157610    break;
    78167611
    … …  
    78187613
    78197614/* Line 1806 of yacc.c  */
    7820 #line 1855 "parser.yy"
    7821     { (yyval.decl) = 0; }
     7615#line 1875 "parser.yy"
     7616    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    78227617    break;
    78237618
    … …  
    78257620
    78267621/* Line 1806 of yacc.c  */
    7827 #line 1857 "parser.yy"
    7828     { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    7829     break;
    7830 
    7831   case 494:
    7832 
    7833 /* Line 1806 of yacc.c  */
    7834 #line 1862 "parser.yy"
     7622#line 1880 "parser.yy"
    78357623    {
    78367624                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
    … …  
    78397627    break;
    78407628
     7629  case 494:
     7630
     7631/* Line 1806 of yacc.c  */
     7632#line 1885 "parser.yy"
     7633    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
     7634    break;
     7635
    78417636  case 495:
    78427637
    78437638/* Line 1806 of yacc.c  */
    7844 #line 1867 "parser.yy"
    7845     { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
     7639#line 1887 "parser.yy"
     7640    { (yyval.decl) = 0; }
    78467641    break;
    78477642
    … …  
    78497644
    78507645/* Line 1806 of yacc.c  */
    7851 #line 1869 "parser.yy"
    7852     { (yyval.decl) = 0; }
    7853     break;
    7854 
    7855   case 497:
    7856 
    7857 /* Line 1806 of yacc.c  */
    7858 #line 1874 "parser.yy"
     7646#line 1892 "parser.yy"
    78597647    { (yyval.en) = new TypeValueNode( (yyvsp[(1) - (1)].decl) ); }
    78607648    break;
    78617649
     7650  case 498:
     7651
     7652/* Line 1806 of yacc.c  */
     7653#line 1895 "parser.yy"
     7654    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); }
     7655    break;
     7656
    78627657  case 499:
    78637658
    78647659/* Line 1806 of yacc.c  */
    7865 #line 1877 "parser.yy"
    7866     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); }
     7660#line 1897 "parser.yy"
     7661    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    78677662    break;
    78687663
    … …  
    78707665
    78717666/* Line 1806 of yacc.c  */
    7872 #line 1879 "parser.yy"
    7873     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
     7667#line 1902 "parser.yy"
     7668    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    78747669    break;
    78757670
    … …  
    78777672
    78787673/* Line 1806 of yacc.c  */
    7879 #line 1884 "parser.yy"
    7880     { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
     7674#line 1904 "parser.yy"
     7675    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    78817676    break;
    78827677
    … …  
    78847679
    78857680/* Line 1806 of yacc.c  */
    7886 #line 1886 "parser.yy"
    7887     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
     7681#line 1906 "parser.yy"
     7682    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    78887683    break;
    78897684
    … …  
    78917686
    78927687/* Line 1806 of yacc.c  */
    7893 #line 1888 "parser.yy"
    7894     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
     7688#line 1911 "parser.yy"
     7689    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    78957690    break;
    78967691
    … …  
    78987693
    78997694/* Line 1806 of yacc.c  */
    7900 #line 1893 "parser.yy"
    7901     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
     7695#line 1913 "parser.yy"
     7696    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    79027697    break;
    79037698
    … …  
    79057700
    79067701/* Line 1806 of yacc.c  */
    7907 #line 1895 "parser.yy"
    7908     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    7909     break;
    7910 
    7911   case 506:
    7912 
    7913 /* Line 1806 of yacc.c  */
    7914 #line 1900 "parser.yy"
     7702#line 1918 "parser.yy"
    79157703    {
    79167704                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
    … …  
    79197707    break;
    79207708
    7921   case 507:
    7922 
    7923 /* Line 1806 of yacc.c  */
    7924 #line 1905 "parser.yy"
     7709  case 506:
     7710
     7711/* Line 1806 of yacc.c  */
     7712#line 1923 "parser.yy"
    79257713    {
    79267714                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
    … …  
    79297717    break;
    79307718
    7931   case 508:
    7932 
    7933 /* Line 1806 of yacc.c  */
    7934 #line 1913 "parser.yy"
     7719  case 507:
     7720
     7721/* Line 1806 of yacc.c  */
     7722#line 1931 "parser.yy"
    79357723    {
    79367724                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
    … …  
    79397727    break;
    79407728
    7941   case 509:
    7942 
    7943 /* Line 1806 of yacc.c  */
    7944 #line 1918 "parser.yy"
     7729  case 508:
     7730
     7731/* Line 1806 of yacc.c  */
     7732#line 1936 "parser.yy"
    79457733    {
    79467734                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
    … …  
    79497737    break;
    79507738
    7951   case 510:
    7952 
    7953 /* Line 1806 of yacc.c  */
    7954 #line 1923 "parser.yy"
     7739  case 509:
     7740
     7741/* Line 1806 of yacc.c  */
     7742#line 1941 "parser.yy"
    79557743    {
    79567744                        typedefTable.leaveTrait();
    … …  
    79607748    break;
    79617749
    7962   case 512:
    7963 
    7964 /* Line 1806 of yacc.c  */
    7965 #line 1933 "parser.yy"
     7750  case 511:
     7751
     7752/* Line 1806 of yacc.c  */
     7753#line 1951 "parser.yy"
    79667754    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    79677755    break;
    79687756
    7969   case 515:
    7970 
    7971 /* Line 1806 of yacc.c  */
    7972 #line 1943 "parser.yy"
     7757  case 514:
     7758
     7759/* Line 1806 of yacc.c  */
     7760#line 1961 "parser.yy"
    79737761    {
    79747762                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    79777765    break;
    79787766
    7979   case 516:
    7980 
    7981 /* Line 1806 of yacc.c  */
    7982 #line 1948 "parser.yy"
     7767  case 515:
     7768
     7769/* Line 1806 of yacc.c  */
     7770#line 1966 "parser.yy"
    79837771    {
    79847772                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    79877775    break;
    79887776
    7989   case 517:
    7990 
    7991 /* Line 1806 of yacc.c  */
    7992 #line 1953 "parser.yy"
     7777  case 516:
     7778
     7779/* Line 1806 of yacc.c  */
     7780#line 1971 "parser.yy"
    79937781    {
    79947782                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
    … …  
    79977785    break;
    79987786
    7999   case 518:
    8000 
    8001 /* Line 1806 of yacc.c  */
    8002 #line 1961 "parser.yy"
     7787  case 517:
     7788
     7789/* Line 1806 of yacc.c  */
     7790#line 1979 "parser.yy"
    80037791    {
    80047792                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    80077795    break;
    80087796
    8009   case 519:
    8010 
    8011 /* Line 1806 of yacc.c  */
    8012 #line 1966 "parser.yy"
     7797  case 518:
     7798
     7799/* Line 1806 of yacc.c  */
     7800#line 1984 "parser.yy"
    80137801    {
    80147802                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    80177805    break;
    80187806
     7807  case 519:
     7808
     7809/* Line 1806 of yacc.c  */
     7810#line 1994 "parser.yy"
     7811    {}
     7812    break;
     7813
    80197814  case 520:
    80207815
    80217816/* Line 1806 of yacc.c  */
    8022 #line 1976 "parser.yy"
    8023     {}
    8024     break;
    8025 
    8026   case 521:
    8027 
    8028 /* Line 1806 of yacc.c  */
    8029 #line 1978 "parser.yy"
     7817#line 1996 "parser.yy"
    80307818    {
    80317819                        if ( theTree ) {
    … …  
    80377825    break;
    80387826
     7827  case 522:
     7828
     7829/* Line 1806 of yacc.c  */
     7830#line 2008 "parser.yy"
     7831    { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
     7832    break;
     7833
    80397834  case 523:
    80407835
    80417836/* Line 1806 of yacc.c  */
    8042 #line 1990 "parser.yy"
    8043     { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    8044     break;
    8045 
    8046   case 524:
    8047 
    8048 /* Line 1806 of yacc.c  */
    8049 #line 1995 "parser.yy"
     7837#line 2013 "parser.yy"
    80507838    { (yyval.decl) = 0; }
    80517839    break;
    80527840
     7841  case 527:
     7842
     7843/* Line 1806 of yacc.c  */
     7844#line 2021 "parser.yy"
     7845    {}
     7846    break;
     7847
    80537848  case 528:
    80547849
    80557850/* Line 1806 of yacc.c  */
    8056 #line 2003 "parser.yy"
    8057     {}
    8058     break;
    8059 
    8060   case 529:
    8061 
    8062 /* Line 1806 of yacc.c  */
    8063 #line 2005 "parser.yy"
     7851#line 2023 "parser.yy"
    80647852    {
    80657853                        linkageStack.push( linkage );
    … …  
    80687856    break;
    80697857
    8070   case 530:
    8071 
    8072 /* Line 1806 of yacc.c  */
    8073 #line 2010 "parser.yy"
     7858  case 529:
     7859
     7860/* Line 1806 of yacc.c  */
     7861#line 2028 "parser.yy"
    80747862    {
    80757863                        linkage = linkageStack.top();
    … …  
    80797867    break;
    80807868
    8081   case 531:
    8082 
    8083 /* Line 1806 of yacc.c  */
    8084 #line 2016 "parser.yy"
     7869  case 530:
     7870
     7871/* Line 1806 of yacc.c  */
     7872#line 2034 "parser.yy"
    80857873    {   // mark all fields in list
    80867874                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
    … …  
    80907878    break;
    80917879
    8092   case 533:
    8093 
    8094 /* Line 1806 of yacc.c  */
    8095 #line 2031 "parser.yy"
     7880  case 532:
     7881
     7882/* Line 1806 of yacc.c  */
     7883#line 2049 "parser.yy"
    80967884    {
    80977885                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    81017889    break;
    81027890
    8103   case 534:
    8104 
    8105 /* Line 1806 of yacc.c  */
    8106 #line 2037 "parser.yy"
     7891  case 533:
     7892
     7893/* Line 1806 of yacc.c  */
     7894#line 2055 "parser.yy"
    81077895    {
    81087896                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    81127900    break;
    81137901
    8114   case 535:
    8115 
    8116 /* Line 1806 of yacc.c  */
    8117 #line 2046 "parser.yy"
     7902  case 534:
     7903
     7904/* Line 1806 of yacc.c  */
     7905#line 2064 "parser.yy"
    81187906    {
    81197907                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    81237911    break;
    81247912
    8125   case 536:
    8126 
    8127 /* Line 1806 of yacc.c  */
    8128 #line 2052 "parser.yy"
     7913  case 535:
     7914
     7915/* Line 1806 of yacc.c  */
     7916#line 2070 "parser.yy"
    81297917    {
    81307918                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    81347922    break;
    81357923
    8136   case 537:
    8137 
    8138 /* Line 1806 of yacc.c  */
    8139 #line 2058 "parser.yy"
     7924  case 536:
     7925
     7926/* Line 1806 of yacc.c  */
     7927#line 2076 "parser.yy"
    81407928    {
    81417929                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    81457933    break;
    81467934
    8147   case 538:
    8148 
    8149 /* Line 1806 of yacc.c  */
    8150 #line 2064 "parser.yy"
     7935  case 537:
     7936
     7937/* Line 1806 of yacc.c  */
     7938#line 2082 "parser.yy"
    81517939    {
    81527940                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    81567944    break;
    81577945
    8158   case 539:
    8159 
    8160 /* Line 1806 of yacc.c  */
    8161 #line 2070 "parser.yy"
     7946  case 538:
     7947
     7948/* Line 1806 of yacc.c  */
     7949#line 2088 "parser.yy"
    81627950    {
    81637951                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    81677955    break;
    81687956
    8169   case 540:
    8170 
    8171 /* Line 1806 of yacc.c  */
    8172 #line 2078 "parser.yy"
     7957  case 539:
     7958
     7959/* Line 1806 of yacc.c  */
     7960#line 2096 "parser.yy"
    81737961    {
    81747962                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    81787966    break;
    81797967
    8180   case 541:
    8181 
    8182 /* Line 1806 of yacc.c  */
    8183 #line 2084 "parser.yy"
     7968  case 540:
     7969
     7970/* Line 1806 of yacc.c  */
     7971#line 2102 "parser.yy"
    81847972    {
    81857973                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    81897977    break;
    81907978
    8191   case 542:
    8192 
    8193 /* Line 1806 of yacc.c  */
    8194 #line 2092 "parser.yy"
     7979  case 541:
     7980
     7981/* Line 1806 of yacc.c  */
     7982#line 2110 "parser.yy"
    81957983    {
    81967984                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    82007988    break;
    82017989
    8202   case 543:
    8203 
    8204 /* Line 1806 of yacc.c  */
    8205 #line 2098 "parser.yy"
     7990  case 542:
     7991
     7992/* Line 1806 of yacc.c  */
     7993#line 2116 "parser.yy"
    82067994    {
    82077995                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    82117999    break;
    82128000
    8213   case 547:
    8214 
    8215 /* Line 1806 of yacc.c  */
    8216 #line 2113 "parser.yy"
    8217     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Range, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    8218     break;
    8219 
    8220   case 550:
    8221 
    8222 /* Line 1806 of yacc.c  */
    8223 #line 2123 "parser.yy"
     8001  case 546:
     8002
     8003/* Line 1806 of yacc.c  */
     8004#line 2131 "parser.yy"
     8005    { (yyval.en) = new CompositeExprNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     8006    break;
     8007
     8008  case 549:
     8009
     8010/* Line 1806 of yacc.c  */
     8011#line 2141 "parser.yy"
    82248012    { (yyval.decl) = 0; }
    82258013    break;
    82268014
     8015  case 552:
     8016
     8017/* Line 1806 of yacc.c  */
     8018#line 2148 "parser.yy"
     8019    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     8020    break;
     8021
    82278022  case 553:
    82288023
    82298024/* Line 1806 of yacc.c  */
    8230 #line 2130 "parser.yy"
    8231     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    8232     break;
    8233 
    8234   case 554:
    8235 
    8236 /* Line 1806 of yacc.c  */
    8237 #line 2136 "parser.yy"
     8025#line 2154 "parser.yy"
    82388026    { (yyval.decl) = 0; }
    82398027    break;
    82408028
     8029  case 559:
     8030
     8031/* Line 1806 of yacc.c  */
     8032#line 2169 "parser.yy"
     8033    {}
     8034    break;
     8035
    82418036  case 560:
    82428037
    82438038/* Line 1806 of yacc.c  */
    8244 #line 2151 "parser.yy"
     8039#line 2170 "parser.yy"
    82458040    {}
    82468041    break;
    … …  
    82498044
    82508045/* Line 1806 of yacc.c  */
    8251 #line 2152 "parser.yy"
     8046#line 2171 "parser.yy"
    82528047    {}
    82538048    break;
    … …  
    82568051
    82578052/* Line 1806 of yacc.c  */
    8258 #line 2153 "parser.yy"
     8053#line 2172 "parser.yy"
    82598054    {}
    82608055    break;
    … …  
    82638058
    82648059/* Line 1806 of yacc.c  */
    8265 #line 2154 "parser.yy"
    8266     {}
    8267     break;
    8268 
    8269   case 564:
    8270 
    8271 /* Line 1806 of yacc.c  */
    8272 #line 2189 "parser.yy"
     8060#line 2207 "parser.yy"
    82738061    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82748062    break;
    82758063
     8064  case 565:
     8065
     8066/* Line 1806 of yacc.c  */
     8067#line 2210 "parser.yy"
     8068    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8069    break;
     8070
    82768071  case 566:
    82778072
    82788073/* Line 1806 of yacc.c  */
    8279 #line 2192 "parser.yy"
     8074#line 2212 "parser.yy"
    82808075    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82818076    break;
    … …  
    82848079
    82858080/* Line 1806 of yacc.c  */
    8286 #line 2194 "parser.yy"
    8287     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8288     break;
    8289 
    8290   case 568:
    8291 
    8292 /* Line 1806 of yacc.c  */
    8293 #line 2199 "parser.yy"
     8081#line 2217 "parser.yy"
    82948082    {
    82958083                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    82988086    break;
    82998087
     8088  case 568:
     8089
     8090/* Line 1806 of yacc.c  */
     8091#line 2222 "parser.yy"
     8092    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8093    break;
     8094
    83008095  case 569:
    83018096
    83028097/* Line 1806 of yacc.c  */
    8303 #line 2204 "parser.yy"
    8304     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8098#line 2227 "parser.yy"
     8099    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    83058100    break;
    83068101
    … …  
    83088103
    83098104/* Line 1806 of yacc.c  */
    8310 #line 2209 "parser.yy"
    8311     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8105#line 2229 "parser.yy"
     8106    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    83128107    break;
    83138108
    83148109  case 571:
    8315 
    8316 /* Line 1806 of yacc.c  */
    8317 #line 2211 "parser.yy"
    8318     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8319     break;
    8320 
    8321   case 572:
    8322 
    8323 /* Line 1806 of yacc.c  */
    8324 #line 2213 "parser.yy"
    8325     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8326     break;
    8327 
    8328   case 573:
    8329 
    8330 /* Line 1806 of yacc.c  */
    8331 #line 2218 "parser.yy"
    8332     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8333     break;
    8334 
    8335   case 574:
    8336 
    8337 /* Line 1806 of yacc.c  */
    8338 #line 2220 "parser.yy"
    8339     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8340     break;
    8341 
    8342   case 575:
    8343 
    8344 /* Line 1806 of yacc.c  */
    8345 #line 2222 "parser.yy"
    8346     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8347     break;
    8348 
    8349   case 576:
    8350 
    8351 /* Line 1806 of yacc.c  */
    8352 #line 2224 "parser.yy"
    8353     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8354     break;
    8355 
    8356   case 577:
    8357 
    8358 /* Line 1806 of yacc.c  */
    8359 #line 2229 "parser.yy"
    8360     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8361     break;
    8362 
    8363   case 578:
    83648110
    83658111/* Line 1806 of yacc.c  */
    … …  
    83688114    break;
    83698115
    8370   case 579:
     8116  case 572:
     8117
     8118/* Line 1806 of yacc.c  */
     8119#line 2236 "parser.yy"
     8120    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8121    break;
     8122
     8123  case 573:
     8124
     8125/* Line 1806 of yacc.c  */
     8126#line 2238 "parser.yy"
     8127    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8128    break;
     8129
     8130  case 574:
    83718131
    83728132/* Line 1806 of yacc.c  */
    83738133#line 2240 "parser.yy"
     8134    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8135    break;
     8136
     8137  case 575:
     8138
     8139/* Line 1806 of yacc.c  */
     8140#line 2242 "parser.yy"
     8141    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8142    break;
     8143
     8144  case 576:
     8145
     8146/* Line 1806 of yacc.c  */
     8147#line 2247 "parser.yy"
     8148    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8149    break;
     8150
     8151  case 577:
     8152
     8153/* Line 1806 of yacc.c  */
     8154#line 2249 "parser.yy"
     8155    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8156    break;
     8157
     8158  case 578:
     8159
     8160/* Line 1806 of yacc.c  */
     8161#line 2258 "parser.yy"
    83748162    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83758163    break;
    83768164
     8165  case 580:
     8166
     8167/* Line 1806 of yacc.c  */
     8168#line 2261 "parser.yy"
     8169    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8170    break;
     8171
    83778172  case 581:
    83788173
    83798174/* Line 1806 of yacc.c  */
    8380 #line 2243 "parser.yy"
    8381     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8175#line 2266 "parser.yy"
     8176    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    83828177    break;
    83838178
    … …  
    83858180
    83868181/* Line 1806 of yacc.c  */
    8387 #line 2248 "parser.yy"
    8388     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8182#line 2268 "parser.yy"
     8183    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83898184    break;
    83908185
    83918186  case 583:
    8392 
    8393 /* Line 1806 of yacc.c  */
    8394 #line 2250 "parser.yy"
    8395     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8396     break;
    8397 
    8398   case 584:
    8399 
    8400 /* Line 1806 of yacc.c  */
    8401 #line 2252 "parser.yy"
    8402     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8403     break;
    8404 
    8405   case 585:
    8406 
    8407 /* Line 1806 of yacc.c  */
    8408 #line 2257 "parser.yy"
    8409     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8410     break;
    8411 
    8412   case 586:
    8413 
    8414 /* Line 1806 of yacc.c  */
    8415 #line 2259 "parser.yy"
    8416     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8417     break;
    8418 
    8419   case 587:
    8420 
    8421 /* Line 1806 of yacc.c  */
    8422 #line 2261 "parser.yy"
    8423     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8424     break;
    8425 
    8426   case 588:
    8427 
    8428 /* Line 1806 of yacc.c  */
    8429 #line 2266 "parser.yy"
    8430     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8431     break;
    8432 
    8433   case 589:
    8434 
    8435 /* Line 1806 of yacc.c  */
    8436 #line 2268 "parser.yy"
    8437     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8438     break;
    8439 
    8440   case 590:
    84418187
    84428188/* Line 1806 of yacc.c  */
    … …  
    84458191    break;
    84468192
     8193  case 584:
     8194
     8195/* Line 1806 of yacc.c  */
     8196#line 2275 "parser.yy"
     8197    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8198    break;
     8199
     8200  case 585:
     8201
     8202/* Line 1806 of yacc.c  */
     8203#line 2277 "parser.yy"
     8204    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8205    break;
     8206
     8207  case 586:
     8208
     8209/* Line 1806 of yacc.c  */
     8210#line 2279 "parser.yy"
     8211    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8212    break;
     8213
     8214  case 587:
     8215
     8216/* Line 1806 of yacc.c  */
     8217#line 2284 "parser.yy"
     8218    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8219    break;
     8220
     8221  case 588:
     8222
     8223/* Line 1806 of yacc.c  */
     8224#line 2286 "parser.yy"
     8225    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8226    break;
     8227
     8228  case 589:
     8229
     8230/* Line 1806 of yacc.c  */
     8231#line 2288 "parser.yy"
     8232    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8233    break;
     8234
     8235  case 593:
     8236
     8237/* Line 1806 of yacc.c  */
     8238#line 2303 "parser.yy"
     8239    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
     8240    break;
     8241
    84478242  case 594:
    84488243
    84498244/* Line 1806 of yacc.c  */
    8450 #line 2285 "parser.yy"
    8451     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
     8245#line 2305 "parser.yy"
     8246    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    84528247    break;
    84538248
    84548249  case 595:
    8455 
    8456 /* Line 1806 of yacc.c  */
    8457 #line 2287 "parser.yy"
    8458     { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    8459     break;
    8460 
    8461   case 596:
    8462 
    8463 /* Line 1806 of yacc.c  */
    8464 #line 2289 "parser.yy"
    8465     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8466     break;
    8467 
    8468   case 597:
    8469 
    8470 /* Line 1806 of yacc.c  */
    8471 #line 2294 "parser.yy"
    8472     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8473     break;
    8474 
    8475   case 598:
    8476 
    8477 /* Line 1806 of yacc.c  */
    8478 #line 2296 "parser.yy"
    8479     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8480     break;
    8481 
    8482   case 599:
    8483 
    8484 /* Line 1806 of yacc.c  */
    8485 #line 2298 "parser.yy"
    8486     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8487     break;
    8488 
    8489   case 600:
    8490 
    8491 /* Line 1806 of yacc.c  */
    8492 #line 2303 "parser.yy"
    8493     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8494     break;
    8495 
    8496   case 601:
    8497 
    8498 /* Line 1806 of yacc.c  */
    8499 #line 2305 "parser.yy"
    8500     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8501     break;
    8502 
    8503   case 602:
    85048250
    85058251/* Line 1806 of yacc.c  */
    … …  
    85088254    break;
    85098255
    8510   case 603:
    8511 
    8512 /* Line 1806 of yacc.c  */
    8513 #line 2322 "parser.yy"
     8256  case 596:
     8257
     8258/* Line 1806 of yacc.c  */
     8259#line 2312 "parser.yy"
     8260    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8261    break;
     8262
     8263  case 597:
     8264
     8265/* Line 1806 of yacc.c  */
     8266#line 2314 "parser.yy"
     8267    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8268    break;
     8269
     8270  case 598:
     8271
     8272/* Line 1806 of yacc.c  */
     8273#line 2316 "parser.yy"
     8274    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8275    break;
     8276
     8277  case 599:
     8278
     8279/* Line 1806 of yacc.c  */
     8280#line 2321 "parser.yy"
     8281    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8282    break;
     8283
     8284  case 600:
     8285
     8286/* Line 1806 of yacc.c  */
     8287#line 2323 "parser.yy"
     8288    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8289    break;
     8290
     8291  case 601:
     8292
     8293/* Line 1806 of yacc.c  */
     8294#line 2325 "parser.yy"
     8295    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8296    break;
     8297
     8298  case 602:
     8299
     8300/* Line 1806 of yacc.c  */
     8301#line 2340 "parser.yy"
    85148302    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85158303    break;
    85168304
     8305  case 604:
     8306
     8307/* Line 1806 of yacc.c  */
     8308#line 2343 "parser.yy"
     8309    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8310    break;
     8311
    85178312  case 605:
    85188313
    85198314/* Line 1806 of yacc.c  */
    8520 #line 2325 "parser.yy"
     8315#line 2345 "parser.yy"
    85218316    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85228317    break;
    85238318
    8524   case 606:
    8525 
    8526 /* Line 1806 of yacc.c  */
    8527 #line 2327 "parser.yy"
     8319  case 607:
     8320
     8321/* Line 1806 of yacc.c  */
     8322#line 2351 "parser.yy"
     8323    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8324    break;
     8325
     8326  case 608:
     8327
     8328/* Line 1806 of yacc.c  */
     8329#line 2356 "parser.yy"
     8330    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8331    break;
     8332
     8333  case 609:
     8334
     8335/* Line 1806 of yacc.c  */
     8336#line 2358 "parser.yy"
     8337    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8338    break;
     8339
     8340  case 610:
     8341
     8342/* Line 1806 of yacc.c  */
     8343#line 2360 "parser.yy"
     8344    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8345    break;
     8346
     8347  case 611:
     8348
     8349/* Line 1806 of yacc.c  */
     8350#line 2365 "parser.yy"
     8351    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8352    break;
     8353
     8354  case 612:
     8355
     8356/* Line 1806 of yacc.c  */
     8357#line 2367 "parser.yy"
     8358    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8359    break;
     8360
     8361  case 613:
     8362
     8363/* Line 1806 of yacc.c  */
     8364#line 2369 "parser.yy"
     8365    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8366    break;
     8367
     8368  case 614:
     8369
     8370/* Line 1806 of yacc.c  */
     8371#line 2371 "parser.yy"
     8372    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8373    break;
     8374
     8375  case 615:
     8376
     8377/* Line 1806 of yacc.c  */
     8378#line 2376 "parser.yy"
     8379    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8380    break;
     8381
     8382  case 616:
     8383
     8384/* Line 1806 of yacc.c  */
     8385#line 2378 "parser.yy"
     8386    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8387    break;
     8388
     8389  case 617:
     8390
     8391/* Line 1806 of yacc.c  */
     8392#line 2380 "parser.yy"
     8393    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8394    break;
     8395
     8396  case 618:
     8397
     8398/* Line 1806 of yacc.c  */
     8399#line 2390 "parser.yy"
    85288400    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85298401    break;
    85308402
    8531   case 608:
    8532 
    8533 /* Line 1806 of yacc.c  */
    8534 #line 2333 "parser.yy"
     8403  case 620:
     8404
     8405/* Line 1806 of yacc.c  */
     8406#line 2393 "parser.yy"
     8407    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8408    break;
     8409
     8410  case 621:
     8411
     8412/* Line 1806 of yacc.c  */
     8413#line 2395 "parser.yy"
     8414    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8415    break;
     8416
     8417  case 622:
     8418
     8419/* Line 1806 of yacc.c  */
     8420#line 2400 "parser.yy"
     8421    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8422    break;
     8423
     8424  case 623:
     8425
     8426/* Line 1806 of yacc.c  */
     8427#line 2402 "parser.yy"
     8428    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8429    break;
     8430
     8431  case 624:
     8432
     8433/* Line 1806 of yacc.c  */
     8434#line 2404 "parser.yy"
    85358435    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85368436    break;
    85378437
    8538   case 609:
    8539 
    8540 /* Line 1806 of yacc.c  */
    8541 #line 2338 "parser.yy"
    8542     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8543     break;
    8544 
    8545   case 610:
    8546 
    8547 /* Line 1806 of yacc.c  */
    8548 #line 2340 "parser.yy"
    8549     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8550     break;
    8551 
    8552   case 611:
    8553 
    8554 /* Line 1806 of yacc.c  */
    8555 #line 2342 "parser.yy"
     8438  case 625:
     8439
     8440/* Line 1806 of yacc.c  */
     8441#line 2409 "parser.yy"
     8442    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8443    break;
     8444
     8445  case 626:
     8446
     8447/* Line 1806 of yacc.c  */
     8448#line 2411 "parser.yy"
     8449    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8450    break;
     8451
     8452  case 627:
     8453
     8454/* Line 1806 of yacc.c  */
     8455#line 2413 "parser.yy"
     8456    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8457    break;
     8458
     8459  case 628:
     8460
     8461/* Line 1806 of yacc.c  */
     8462#line 2415 "parser.yy"
    85568463    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85578464    break;
    85588465
    8559   case 612:
    8560 
    8561 /* Line 1806 of yacc.c  */
    8562 #line 2347 "parser.yy"
    8563     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8564     break;
    8565 
    8566   case 613:
    8567 
    8568 /* Line 1806 of yacc.c  */
    8569 #line 2349 "parser.yy"
    8570     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8571     break;
    8572 
    8573   case 614:
    8574 
    8575 /* Line 1806 of yacc.c  */
    8576 #line 2351 "parser.yy"
    8577     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8578     break;
    8579 
    8580   case 615:
    8581 
    8582 /* Line 1806 of yacc.c  */
    8583 #line 2353 "parser.yy"
     8466  case 629:
     8467
     8468/* Line 1806 of yacc.c  */
     8469#line 2420 "parser.yy"
     8470    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8471    break;
     8472
     8473  case 630:
     8474
     8475/* Line 1806 of yacc.c  */
     8476#line 2422 "parser.yy"
     8477    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8478    break;
     8479
     8480  case 631:
     8481
     8482/* Line 1806 of yacc.c  */
     8483#line 2424 "parser.yy"
    85848484    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85858485    break;
    85868486
    8587   case 616:
    8588 
    8589 /* Line 1806 of yacc.c  */
    8590 #line 2358 "parser.yy"
    8591     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8592     break;
    8593 
    8594   case 617:
    8595 
    8596 /* Line 1806 of yacc.c  */
    8597 #line 2360 "parser.yy"
    8598     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8599     break;
    8600 
    8601   case 618:
    8602 
    8603 /* Line 1806 of yacc.c  */
    8604 #line 2362 "parser.yy"
    8605     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8606     break;
    8607 
    8608   case 619:
    8609 
    8610 /* Line 1806 of yacc.c  */
    8611 #line 2372 "parser.yy"
     8487  case 632:
     8488
     8489/* Line 1806 of yacc.c  */
     8490#line 2455 "parser.yy"
    86128491    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86138492    break;
    86148493
    8615   case 621:
    8616 
    8617 /* Line 1806 of yacc.c  */
    8618 #line 2375 "parser.yy"
     8494  case 634:
     8495
     8496/* Line 1806 of yacc.c  */
     8497#line 2458 "parser.yy"
    86198498    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86208499    break;
    86218500
    8622   case 622:
    8623 
    8624 /* Line 1806 of yacc.c  */
    8625 #line 2377 "parser.yy"
     8501  case 635:
     8502
     8503/* Line 1806 of yacc.c  */
     8504#line 2460 "parser.yy"
    86268505    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86278506    break;
    86288507
    8629   case 623:
    8630 
    8631 /* Line 1806 of yacc.c  */
    8632 #line 2382 "parser.yy"
    8633     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8634     break;
    8635 
    8636   case 624:
    8637 
    8638 /* Line 1806 of yacc.c  */
    8639 #line 2384 "parser.yy"
    8640     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8641     break;
    8642 
    8643   case 625:
    8644 
    8645 /* Line 1806 of yacc.c  */
    8646 #line 2386 "parser.yy"
    8647     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8648     break;
    8649 
    8650   case 626:
    8651 
    8652 /* Line 1806 of yacc.c  */
    8653 #line 2391 "parser.yy"
    8654     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8655     break;
    8656 
    8657   case 627:
    8658 
    8659 /* Line 1806 of yacc.c  */
    8660 #line 2393 "parser.yy"
    8661     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8662     break;
    8663 
    8664   case 628:
    8665 
    8666 /* Line 1806 of yacc.c  */
    8667 #line 2395 "parser.yy"
    8668     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8669     break;
    8670 
    8671   case 629:
    8672 
    8673 /* Line 1806 of yacc.c  */
    8674 #line 2397 "parser.yy"
    8675     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8676     break;
    8677 
    8678   case 630:
    8679 
    8680 /* Line 1806 of yacc.c  */
    8681 #line 2402 "parser.yy"
    8682     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8683     break;
    8684 
    8685   case 631:
    8686 
    8687 /* Line 1806 of yacc.c  */
    8688 #line 2404 "parser.yy"
    8689     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8690     break;
    8691 
    8692   case 632:
    8693 
    8694 /* Line 1806 of yacc.c  */
    8695 #line 2406 "parser.yy"
    8696     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8697     break;
    8698 
    8699   case 633:
    8700 
    8701 /* Line 1806 of yacc.c  */
    8702 #line 2437 "parser.yy"
    8703     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8704     break;
    8705 
    8706   case 635:
    8707 
    8708 /* Line 1806 of yacc.c  */
    8709 #line 2440 "parser.yy"
    8710     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8711     break;
    8712 
    87138508  case 636:
    87148509
    87158510/* Line 1806 of yacc.c  */
    8716 #line 2442 "parser.yy"
    8717     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8718     break;
    8719 
    8720   case 637:
    8721 
    8722 /* Line 1806 of yacc.c  */
    8723 #line 2447 "parser.yy"
     8511#line 2465 "parser.yy"
    87248512    {
    87258513                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    87288516    break;
    87298517
    8730   case 638:
    8731 
    8732 /* Line 1806 of yacc.c  */
    8733 #line 2452 "parser.yy"
     8518  case 637:
     8519
     8520/* Line 1806 of yacc.c  */
     8521#line 2470 "parser.yy"
    87348522    {
    87358523                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    87388526    break;
    87398527
     8528  case 638:
     8529
     8530/* Line 1806 of yacc.c  */
     8531#line 2478 "parser.yy"
     8532    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8533    break;
     8534
    87408535  case 639:
    87418536
    87428537/* Line 1806 of yacc.c  */
    8743 #line 2460 "parser.yy"
     8538#line 2480 "parser.yy"
     8539    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8540    break;
     8541
     8542  case 640:
     8543
     8544/* Line 1806 of yacc.c  */
     8545#line 2482 "parser.yy"
     8546    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8547    break;
     8548
     8549  case 641:
     8550
     8551/* Line 1806 of yacc.c  */
     8552#line 2487 "parser.yy"
     8553    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8554    break;
     8555
     8556  case 642:
     8557
     8558/* Line 1806 of yacc.c  */
     8559#line 2489 "parser.yy"
     8560    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8561    break;
     8562
     8563  case 643:
     8564
     8565/* Line 1806 of yacc.c  */
     8566#line 2494 "parser.yy"
     8567    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8568    break;
     8569
     8570  case 644:
     8571
     8572/* Line 1806 of yacc.c  */
     8573#line 2496 "parser.yy"
     8574    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8575    break;
     8576
     8577  case 646:
     8578
     8579/* Line 1806 of yacc.c  */
     8580#line 2511 "parser.yy"
     8581    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8582    break;
     8583
     8584  case 647:
     8585
     8586/* Line 1806 of yacc.c  */
     8587#line 2513 "parser.yy"
     8588    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8589    break;
     8590
     8591  case 648:
     8592
     8593/* Line 1806 of yacc.c  */
     8594#line 2518 "parser.yy"
     8595    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     8596    break;
     8597
     8598  case 649:
     8599
     8600/* Line 1806 of yacc.c  */
     8601#line 2520 "parser.yy"
     8602    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     8603    break;
     8604
     8605  case 650:
     8606
     8607/* Line 1806 of yacc.c  */
     8608#line 2522 "parser.yy"
    87448609    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    87458610    break;
    87468611
    8747   case 640:
    8748 
    8749 /* Line 1806 of yacc.c  */
    8750 #line 2462 "parser.yy"
     8612  case 651:
     8613
     8614/* Line 1806 of yacc.c  */
     8615#line 2524 "parser.yy"
    87518616    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    87528617    break;
    87538618
    8754   case 641:
    8755 
    8756 /* Line 1806 of yacc.c  */
    8757 #line 2464 "parser.yy"
     8619  case 652:
     8620
     8621/* Line 1806 of yacc.c  */
     8622#line 2526 "parser.yy"
    87588623    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87598624    break;
    87608625
    8761   case 642:
    8762 
    8763 /* Line 1806 of yacc.c  */
    8764 #line 2469 "parser.yy"
     8626  case 654:
     8627
     8628/* Line 1806 of yacc.c  */
     8629#line 2532 "parser.yy"
     8630    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8631    break;
     8632
     8633  case 655:
     8634
     8635/* Line 1806 of yacc.c  */
     8636#line 2534 "parser.yy"
     8637    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8638    break;
     8639
     8640  case 656:
     8641
     8642/* Line 1806 of yacc.c  */
     8643#line 2536 "parser.yy"
     8644    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8645    break;
     8646
     8647  case 657:
     8648
     8649/* Line 1806 of yacc.c  */
     8650#line 2541 "parser.yy"
     8651    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
     8652    break;
     8653
     8654  case 658:
     8655
     8656/* Line 1806 of yacc.c  */
     8657#line 2543 "parser.yy"
     8658    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8659    break;
     8660
     8661  case 659:
     8662
     8663/* Line 1806 of yacc.c  */
     8664#line 2545 "parser.yy"
     8665    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8666    break;
     8667
     8668  case 660:
     8669
     8670/* Line 1806 of yacc.c  */
     8671#line 2551 "parser.yy"
     8672    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     8673    break;
     8674
     8675  case 661:
     8676
     8677/* Line 1806 of yacc.c  */
     8678#line 2553 "parser.yy"
     8679    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
     8680    break;
     8681
     8682  case 663:
     8683
     8684/* Line 1806 of yacc.c  */
     8685#line 2559 "parser.yy"
     8686    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
     8687    break;
     8688
     8689  case 664:
     8690
     8691/* Line 1806 of yacc.c  */
     8692#line 2561 "parser.yy"
     8693    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
     8694    break;
     8695
     8696  case 665:
     8697
     8698/* Line 1806 of yacc.c  */
     8699#line 2563 "parser.yy"
     8700    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
     8701    break;
     8702
     8703  case 666:
     8704
     8705/* Line 1806 of yacc.c  */
     8706#line 2565 "parser.yy"
     8707    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
     8708    break;
     8709
     8710  case 668:
     8711
     8712/* Line 1806 of yacc.c  */
     8713#line 2580 "parser.yy"
     8714    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8715    break;
     8716
     8717  case 669:
     8718
     8719/* Line 1806 of yacc.c  */
     8720#line 2582 "parser.yy"
     8721    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8722    break;
     8723
     8724  case 670:
     8725
     8726/* Line 1806 of yacc.c  */
     8727#line 2587 "parser.yy"
     8728    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     8729    break;
     8730
     8731  case 671:
     8732
     8733/* Line 1806 of yacc.c  */
     8734#line 2589 "parser.yy"
     8735    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     8736    break;
     8737
     8738  case 672:
     8739
     8740/* Line 1806 of yacc.c  */
     8741#line 2591 "parser.yy"
     8742    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8743    break;
     8744
     8745  case 673:
     8746
     8747/* Line 1806 of yacc.c  */
     8748#line 2593 "parser.yy"
     8749    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8750    break;
     8751
     8752  case 674:
     8753
     8754/* Line 1806 of yacc.c  */
     8755#line 2595 "parser.yy"
     8756    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8757    break;
     8758
     8759  case 676:
     8760
     8761/* Line 1806 of yacc.c  */
     8762#line 2601 "parser.yy"
     8763    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8764    break;
     8765
     8766  case 677:
     8767
     8768/* Line 1806 of yacc.c  */
     8769#line 2603 "parser.yy"
     8770    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8771    break;
     8772
     8773  case 678:
     8774
     8775/* Line 1806 of yacc.c  */
     8776#line 2605 "parser.yy"
     8777    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8778    break;
     8779
     8780  case 679:
     8781
     8782/* Line 1806 of yacc.c  */
     8783#line 2610 "parser.yy"
     8784    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
     8785    break;
     8786
     8787  case 680:
     8788
     8789/* Line 1806 of yacc.c  */
     8790#line 2612 "parser.yy"
     8791    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8792    break;
     8793
     8794  case 681:
     8795
     8796/* Line 1806 of yacc.c  */
     8797#line 2614 "parser.yy"
     8798    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8799    break;
     8800
     8801  case 683:
     8802
     8803/* Line 1806 of yacc.c  */
     8804#line 2621 "parser.yy"
    87658805    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    87668806    break;
    87678807
    8768   case 643:
    8769 
    8770 /* Line 1806 of yacc.c  */
    8771 #line 2471 "parser.yy"
     8808  case 685:
     8809
     8810/* Line 1806 of yacc.c  */
     8811#line 2632 "parser.yy"
     8812    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     8813    break;
     8814
     8815  case 686:
     8816
     8817/* Line 1806 of yacc.c  */
     8818#line 2635 "parser.yy"
     8819    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     8820    break;
     8821
     8822  case 687:
     8823
     8824/* Line 1806 of yacc.c  */
     8825#line 2637 "parser.yy"
     8826    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
     8827    break;
     8828
     8829  case 688:
     8830
     8831/* Line 1806 of yacc.c  */
     8832#line 2640 "parser.yy"
     8833    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
     8834    break;
     8835
     8836  case 689:
     8837
     8838/* Line 1806 of yacc.c  */
     8839#line 2642 "parser.yy"
     8840    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
     8841    break;
     8842
     8843  case 690:
     8844
     8845/* Line 1806 of yacc.c  */
     8846#line 2644 "parser.yy"
     8847    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
     8848    break;
     8849
     8850  case 692:
     8851
     8852/* Line 1806 of yacc.c  */
     8853#line 2658 "parser.yy"
     8854    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8855    break;
     8856
     8857  case 693:
     8858
     8859/* Line 1806 of yacc.c  */
     8860#line 2660 "parser.yy"
     8861    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8862    break;
     8863
     8864  case 694:
     8865
     8866/* Line 1806 of yacc.c  */
     8867#line 2665 "parser.yy"
     8868    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     8869    break;
     8870
     8871  case 695:
     8872
     8873/* Line 1806 of yacc.c  */
     8874#line 2667 "parser.yy"
     8875    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     8876    break;
     8877
     8878  case 696:
     8879
     8880/* Line 1806 of yacc.c  */
     8881#line 2669 "parser.yy"
     8882    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8883    break;
     8884
     8885  case 697:
     8886
     8887/* Line 1806 of yacc.c  */
     8888#line 2671 "parser.yy"
     8889    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8890    break;
     8891
     8892  case 698:
     8893
     8894/* Line 1806 of yacc.c  */
     8895#line 2673 "parser.yy"
     8896    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8897    break;
     8898
     8899  case 700:
     8900
     8901/* Line 1806 of yacc.c  */
     8902#line 2679 "parser.yy"
    87728903    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87738904    break;
    87748905
    8775   case 644:
    8776 
    8777 /* Line 1806 of yacc.c  */
    8778 #line 2476 "parser.yy"
    8779     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8780     break;
    8781 
    8782   case 645:
    8783 
    8784 /* Line 1806 of yacc.c  */
    8785 #line 2478 "parser.yy"
     8906  case 701:
     8907
     8908/* Line 1806 of yacc.c  */
     8909#line 2681 "parser.yy"
     8910    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8911    break;
     8912
     8913  case 702:
     8914
     8915/* Line 1806 of yacc.c  */
     8916#line 2683 "parser.yy"
     8917    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8918    break;
     8919
     8920  case 703:
     8921
     8922/* Line 1806 of yacc.c  */
     8923#line 2688 "parser.yy"
    87868924    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87878925    break;
    87888926
    8789   case 647:
    8790 
    8791 /* Line 1806 of yacc.c  */
    8792 #line 2493 "parser.yy"
    8793     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8794     break;
    8795 
    8796   case 648:
    8797 
    8798 /* Line 1806 of yacc.c  */
    8799 #line 2495 "parser.yy"
    8800     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8801     break;
    8802 
    8803   case 649:
    8804 
    8805 /* Line 1806 of yacc.c  */
    8806 #line 2500 "parser.yy"
    8807     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    8808     break;
    8809 
    8810   case 650:
    8811 
    8812 /* Line 1806 of yacc.c  */
    8813 #line 2502 "parser.yy"
    8814     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    8815     break;
    8816 
    8817   case 651:
    8818 
    8819 /* Line 1806 of yacc.c  */
    8820 #line 2504 "parser.yy"
    8821     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8822     break;
    8823 
    8824   case 652:
    8825 
    8826 /* Line 1806 of yacc.c  */
    8827 #line 2506 "parser.yy"
    8828     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8829     break;
    8830 
    8831   case 653:
    8832 
    8833 /* Line 1806 of yacc.c  */
    8834 #line 2508 "parser.yy"
     8927  case 704:
     8928
     8929/* Line 1806 of yacc.c  */
     8930#line 2690 "parser.yy"
    88358931    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88368932    break;
    88378933
    8838   case 655:
    8839 
    8840 /* Line 1806 of yacc.c  */
    8841 #line 2514 "parser.yy"
    8842     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8843     break;
    8844 
    8845   case 656:
    8846 
    8847 /* Line 1806 of yacc.c  */
    8848 #line 2516 "parser.yy"
    8849     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8850     break;
    8851 
    8852   case 657:
    8853 
    8854 /* Line 1806 of yacc.c  */
    8855 #line 2518 "parser.yy"
    8856     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8857     break;
    8858 
    8859   case 658:
    8860 
    8861 /* Line 1806 of yacc.c  */
    8862 #line 2523 "parser.yy"
    8863     { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    8864     break;
    8865 
    8866   case 659:
    8867 
    8868 /* Line 1806 of yacc.c  */
    8869 #line 2525 "parser.yy"
    8870     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8871     break;
    8872 
    8873   case 660:
    8874 
    8875 /* Line 1806 of yacc.c  */
    8876 #line 2527 "parser.yy"
    8877     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8878     break;
    8879 
    8880   case 661:
    8881 
    8882 /* Line 1806 of yacc.c  */
    8883 #line 2533 "parser.yy"
    8884     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    8885     break;
    8886 
    8887   case 662:
    8888 
    8889 /* Line 1806 of yacc.c  */
    8890 #line 2535 "parser.yy"
    8891     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    8892     break;
    8893 
    8894   case 664:
    8895 
    8896 /* Line 1806 of yacc.c  */
    8897 #line 2541 "parser.yy"
    8898     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    8899     break;
    8900 
    8901   case 665:
    8902 
    8903 /* Line 1806 of yacc.c  */
    8904 #line 2543 "parser.yy"
    8905     { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    8906     break;
    8907 
    8908   case 666:
    8909 
    8910 /* Line 1806 of yacc.c  */
    8911 #line 2545 "parser.yy"
    8912     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    8913     break;
    8914 
    8915   case 667:
    8916 
    8917 /* Line 1806 of yacc.c  */
    8918 #line 2547 "parser.yy"
    8919     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    8920     break;
    8921 
    8922   case 669:
    8923 
    8924 /* Line 1806 of yacc.c  */
    8925 #line 2562 "parser.yy"
    8926     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8927     break;
    8928 
    8929   case 670:
    8930 
    8931 /* Line 1806 of yacc.c  */
    8932 #line 2564 "parser.yy"
    8933     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8934     break;
    8935 
    8936   case 671:
    8937 
    8938 /* Line 1806 of yacc.c  */
    8939 #line 2569 "parser.yy"
    8940     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    8941     break;
    8942 
    8943   case 672:
    8944 
    8945 /* Line 1806 of yacc.c  */
    8946 #line 2571 "parser.yy"
    8947     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    8948     break;
    8949 
    8950   case 673:
    8951 
    8952 /* Line 1806 of yacc.c  */
    8953 #line 2573 "parser.yy"
    8954     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8955     break;
    8956 
    8957   case 674:
    8958 
    8959 /* Line 1806 of yacc.c  */
    8960 #line 2575 "parser.yy"
    8961     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8962     break;
    8963 
    8964   case 675:
    8965 
    8966 /* Line 1806 of yacc.c  */
    8967 #line 2577 "parser.yy"
    8968     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8969     break;
    8970 
    8971   case 677:
    8972 
    8973 /* Line 1806 of yacc.c  */
    8974 #line 2583 "parser.yy"
    8975     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8976     break;
    8977 
    8978   case 678:
    8979 
    8980 /* Line 1806 of yacc.c  */
    8981 #line 2585 "parser.yy"
    8982     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8983     break;
    8984 
    8985   case 679:
    8986 
    8987 /* Line 1806 of yacc.c  */
    8988 #line 2587 "parser.yy"
    8989     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8990     break;
    8991 
    8992   case 680:
    8993 
    8994 /* Line 1806 of yacc.c  */
    8995 #line 2592 "parser.yy"
    8996     { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    8997     break;
    8998 
    8999   case 681:
    9000 
    9001 /* Line 1806 of yacc.c  */
    9002 #line 2594 "parser.yy"
    9003     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    9004     break;
    9005 
    9006   case 682:
    9007 
    9008 /* Line 1806 of yacc.c  */
    9009 #line 2596 "parser.yy"
    9010     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    9011     break;
    9012 
    9013   case 684:
    9014 
    9015 /* Line 1806 of yacc.c  */
    9016 #line 2603 "parser.yy"
    9017     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    9018     break;
    9019 
    9020   case 686:
    9021 
    9022 /* Line 1806 of yacc.c  */
    9023 #line 2614 "parser.yy"
    9024     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    9025     break;
    9026 
    9027   case 687:
    9028 
    9029 /* Line 1806 of yacc.c  */
    9030 #line 2617 "parser.yy"
     8934  case 707:
     8935
     8936/* Line 1806 of yacc.c  */
     8937#line 2700 "parser.yy"
     8938    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     8939    break;
     8940
     8941  case 710:
     8942
     8943/* Line 1806 of yacc.c  */
     8944#line 2710 "parser.yy"
     8945    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     8946    break;
     8947
     8948  case 711:
     8949
     8950/* Line 1806 of yacc.c  */
     8951#line 2712 "parser.yy"
     8952    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     8953    break;
     8954
     8955  case 712:
     8956
     8957/* Line 1806 of yacc.c  */
     8958#line 2714 "parser.yy"
     8959    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     8960    break;
     8961
     8962  case 713:
     8963
     8964/* Line 1806 of yacc.c  */
     8965#line 2716 "parser.yy"
     8966    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     8967    break;
     8968
     8969  case 714:
     8970
     8971/* Line 1806 of yacc.c  */
     8972#line 2718 "parser.yy"
     8973    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     8974    break;
     8975
     8976  case 715:
     8977
     8978/* Line 1806 of yacc.c  */
     8979#line 2720 "parser.yy"
     8980    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     8981    break;
     8982
     8983  case 716:
     8984
     8985/* Line 1806 of yacc.c  */
     8986#line 2727 "parser.yy"
     8987    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     8988    break;
     8989
     8990  case 717:
     8991
     8992/* Line 1806 of yacc.c  */
     8993#line 2729 "parser.yy"
     8994    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     8995    break;
     8996
     8997  case 718:
     8998
     8999/* Line 1806 of yacc.c  */
     9000#line 2731 "parser.yy"
     9001    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9002    break;
     9003
     9004  case 719:
     9005
     9006/* Line 1806 of yacc.c  */
     9007#line 2733 "parser.yy"
     9008    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     9009    break;
     9010
     9011  case 720:
     9012
     9013/* Line 1806 of yacc.c  */
     9014#line 2735 "parser.yy"
     9015    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     9016    break;
     9017
     9018  case 721:
     9019
     9020/* Line 1806 of yacc.c  */
     9021#line 2737 "parser.yy"
     9022    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9023    break;
     9024
     9025  case 722:
     9026
     9027/* Line 1806 of yacc.c  */
     9028#line 2739 "parser.yy"
     9029    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     9030    break;
     9031
     9032  case 723:
     9033
     9034/* Line 1806 of yacc.c  */
     9035#line 2741 "parser.yy"
     9036    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9037    break;
     9038
     9039  case 724:
     9040
     9041/* Line 1806 of yacc.c  */
     9042#line 2743 "parser.yy"
     9043    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     9044    break;
     9045
     9046  case 725:
     9047
     9048/* Line 1806 of yacc.c  */
     9049#line 2745 "parser.yy"
     9050    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     9051    break;
     9052
     9053  case 726:
     9054
     9055/* Line 1806 of yacc.c  */
     9056#line 2750 "parser.yy"
    90319057    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    90329058    break;
    90339059
    9034   case 688:
    9035 
    9036 /* Line 1806 of yacc.c  */
    9037 #line 2619 "parser.yy"
    9038     { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    9039     break;
    9040 
    9041   case 689:
    9042 
    9043 /* Line 1806 of yacc.c  */
    9044 #line 2622 "parser.yy"
     9060  case 727:
     9061
     9062/* Line 1806 of yacc.c  */
     9063#line 2752 "parser.yy"
    90459064    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    90469065    break;
    90479066
    9048   case 690:
    9049 
    9050 /* Line 1806 of yacc.c  */
    9051 #line 2624 "parser.yy"
    9052     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    9053     break;
    9054 
    9055   case 691:
    9056 
    9057 /* Line 1806 of yacc.c  */
    9058 #line 2626 "parser.yy"
    9059     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    9060     break;
    9061 
    9062   case 693:
    9063 
    9064 /* Line 1806 of yacc.c  */
    9065 #line 2640 "parser.yy"
    9066     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    9067     break;
    9068 
    9069   case 694:
    9070 
    9071 /* Line 1806 of yacc.c  */
    9072 #line 2642 "parser.yy"
    9073     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    9074     break;
    9075 
    9076   case 695:
    9077 
    9078 /* Line 1806 of yacc.c  */
    9079 #line 2647 "parser.yy"
    9080     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    9081     break;
    9082 
    9083   case 696:
    9084 
    9085 /* Line 1806 of yacc.c  */
    9086 #line 2649 "parser.yy"
    9087     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    9088     break;
    9089 
    9090   case 697:
    9091 
    9092 /* Line 1806 of yacc.c  */
    9093 #line 2651 "parser.yy"
    9094     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    9095     break;
    9096 
    9097   case 698:
    9098 
    9099 /* Line 1806 of yacc.c  */
    9100 #line 2653 "parser.yy"
    9101     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    9102     break;
    9103 
    9104   case 699:
    9105 
    9106 /* Line 1806 of yacc.c  */
    9107 #line 2655 "parser.yy"
    9108     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    9109     break;
    9110 
    9111   case 701:
    9112 
    9113 /* Line 1806 of yacc.c  */
    9114 #line 2661 "parser.yy"
    9115     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    9116     break;
    9117 
    9118   case 702:
    9119 
    9120 /* Line 1806 of yacc.c  */
    9121 #line 2663 "parser.yy"
    9122     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    9123     break;
    9124 
    9125   case 703:
    9126 
    9127 /* Line 1806 of yacc.c  */
    9128 #line 2665 "parser.yy"
    9129     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    9130     break;
    9131 
    9132   case 704:
    9133 
    9134 /* Line 1806 of yacc.c  */
    9135 #line 2670 "parser.yy"
    9136     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    9137     break;
    9138 
    9139   case 705:
    9140 
    9141 /* Line 1806 of yacc.c  */
    9142 #line 2672 "parser.yy"
    9143     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    9144     break;
    9145 
    9146   case 708:
    9147 
    9148 /* Line 1806 of yacc.c  */
    9149 #line 2682 "parser.yy"
     9067  case 728:
     9068
     9069/* Line 1806 of yacc.c  */
     9070#line 2757 "parser.yy"
     9071    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
     9072    break;
     9073
     9074  case 729:
     9075
     9076/* Line 1806 of yacc.c  */
     9077#line 2759 "parser.yy"
     9078    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
     9079    break;
     9080
     9081  case 731:
     9082
     9083/* Line 1806 of yacc.c  */
     9084#line 2786 "parser.yy"
    91509085    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    91519086    break;
    91529087
    9153   case 711:
    9154 
    9155 /* Line 1806 of yacc.c  */
    9156 #line 2692 "parser.yy"
     9088  case 735:
     9089
     9090/* Line 1806 of yacc.c  */
     9091#line 2797 "parser.yy"
    91579092    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91589093    break;
    91599094
    9160   case 712:
    9161 
    9162 /* Line 1806 of yacc.c  */
    9163 #line 2694 "parser.yy"
     9095  case 736:
     9096
     9097/* Line 1806 of yacc.c  */
     9098#line 2799 "parser.yy"
    91649099    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91659100    break;
    91669101
    9167   case 713:
    9168 
    9169 /* Line 1806 of yacc.c  */
    9170 #line 2696 "parser.yy"
     9102  case 737:
     9103
     9104/* Line 1806 of yacc.c  */
     9105#line 2801 "parser.yy"
    91719106    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91729107    break;
    91739108
    9174   case 714:
    9175 
    9176 /* Line 1806 of yacc.c  */
    9177 #line 2698 "parser.yy"
     9109  case 738:
     9110
     9111/* Line 1806 of yacc.c  */
     9112#line 2803 "parser.yy"
    91789113    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91799114    break;
    91809115
    9181   case 715:
    9182 
    9183 /* Line 1806 of yacc.c  */
    9184 #line 2700 "parser.yy"
     9116  case 739:
     9117
     9118/* Line 1806 of yacc.c  */
     9119#line 2805 "parser.yy"
    91859120    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91869121    break;
    91879122
    9188   case 716:
    9189 
    9190 /* Line 1806 of yacc.c  */
    9191 #line 2702 "parser.yy"
     9123  case 740:
     9124
     9125/* Line 1806 of yacc.c  */
     9126#line 2807 "parser.yy"
    91929127    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91939128    break;
    91949129
    9195   case 717:
    9196 
    9197 /* Line 1806 of yacc.c  */
    9198 #line 2709 "parser.yy"
     9130  case 741:
     9131
     9132/* Line 1806 of yacc.c  */
     9133#line 2814 "parser.yy"
    91999134    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    92009135    break;
    92019136
    9202   case 718:
    9203 
    9204 /* Line 1806 of yacc.c  */
    9205 #line 2711 "parser.yy"
     9137  case 742:
     9138
     9139/* Line 1806 of yacc.c  */
     9140#line 2816 "parser.yy"
     9141    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9142    break;
     9143
     9144  case 743:
     9145
     9146/* Line 1806 of yacc.c  */
     9147#line 2818 "parser.yy"
    92069148    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    92079149    break;
    92089150
    9209   case 719:
    9210 
    9211 /* Line 1806 of yacc.c  */
    9212 #line 2713 "parser.yy"
     9151  case 744:
     9152
     9153/* Line 1806 of yacc.c  */
     9154#line 2820 "parser.yy"
     9155    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9156    break;
     9157
     9158  case 745:
     9159
     9160/* Line 1806 of yacc.c  */
     9161#line 2822 "parser.yy"
    92139162    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    92149163    break;
    92159164
    9216   case 720:
    9217 
    9218 /* Line 1806 of yacc.c  */
    9219 #line 2715 "parser.yy"
    9220     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    9221     break;
    9222 
    9223   case 721:
    9224 
    9225 /* Line 1806 of yacc.c  */
    9226 #line 2717 "parser.yy"
     9165  case 746:
     9166
     9167/* Line 1806 of yacc.c  */
     9168#line 2824 "parser.yy"
    92279169    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    92289170    break;
    92299171
    9230   case 722:
    9231 
    9232 /* Line 1806 of yacc.c  */
    9233 #line 2719 "parser.yy"
    9234     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9235     break;
    9236 
    9237   case 723:
    9238 
    9239 /* Line 1806 of yacc.c  */
    9240 #line 2721 "parser.yy"
    9241     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    9242     break;
    9243 
    9244   case 724:
    9245 
    9246 /* Line 1806 of yacc.c  */
    9247 #line 2723 "parser.yy"
    9248     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9249     break;
    9250 
    9251   case 725:
    9252 
    9253 /* Line 1806 of yacc.c  */
    9254 #line 2725 "parser.yy"
    9255     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    9256     break;
    9257 
    9258   case 726:
    9259 
    9260 /* Line 1806 of yacc.c  */
    9261 #line 2727 "parser.yy"
    9262     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    9263     break;
    9264 
    9265   case 727:
    9266 
    9267 /* Line 1806 of yacc.c  */
    9268 #line 2732 "parser.yy"
    9269     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    9270     break;
    9271 
    9272   case 728:
    9273 
    9274 /* Line 1806 of yacc.c  */
    9275 #line 2734 "parser.yy"
    9276     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    9277     break;
    9278 
    9279   case 729:
    9280 
    9281 /* Line 1806 of yacc.c  */
    9282 #line 2739 "parser.yy"
    9283     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
    9284     break;
    9285 
    9286   case 730:
    9287 
    9288 /* Line 1806 of yacc.c  */
    9289 #line 2741 "parser.yy"
    9290     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
    9291     break;
    9292 
    9293   case 732:
    9294 
    9295 /* Line 1806 of yacc.c  */
    9296 #line 2768 "parser.yy"
    9297     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    9298     break;
    9299 
    9300   case 736:
    9301 
    9302 /* Line 1806 of yacc.c  */
    9303 #line 2779 "parser.yy"
    9304     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9305     break;
    9306 
    9307   case 737:
    9308 
    9309 /* Line 1806 of yacc.c  */
    9310 #line 2781 "parser.yy"
    9311     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9312     break;
    9313 
    9314   case 738:
    9315 
    9316 /* Line 1806 of yacc.c  */
    9317 #line 2783 "parser.yy"
    9318     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9319     break;
    9320 
    9321   case 739:
    9322 
    9323 /* Line 1806 of yacc.c  */
    9324 #line 2785 "parser.yy"
    9325     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9326     break;
    9327 
    9328   case 740:
    9329 
    9330 /* Line 1806 of yacc.c  */
    9331 #line 2787 "parser.yy"
    9332     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9333     break;
    9334 
    9335   case 741:
    9336 
    9337 /* Line 1806 of yacc.c  */
    9338 #line 2789 "parser.yy"
    9339     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9340     break;
    9341 
    9342   case 742:
    9343 
    9344 /* Line 1806 of yacc.c  */
    9345 #line 2796 "parser.yy"
    9346     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9347     break;
    9348 
    9349   case 743:
    9350 
    9351 /* Line 1806 of yacc.c  */
    9352 #line 2798 "parser.yy"
    9353     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9354     break;
    9355 
    9356   case 744:
    9357 
    9358 /* Line 1806 of yacc.c  */
    9359 #line 2800 "parser.yy"
    9360     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    9361     break;
    9362 
    9363   case 745:
    9364 
    9365 /* Line 1806 of yacc.c  */
    9366 #line 2802 "parser.yy"
    9367     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9368     break;
    9369 
    9370   case 746:
    9371 
    9372 /* Line 1806 of yacc.c  */
    9373 #line 2804 "parser.yy"
    9374     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9375     break;
    9376 
    93779172  case 747:
    93789173
    93799174/* Line 1806 of yacc.c  */
    9380 #line 2806 "parser.yy"
    9381     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     9175#line 2829 "parser.yy"
     9176    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    93829177    break;
    93839178
    … …  
    93859180
    93869181/* Line 1806 of yacc.c  */
    9387 #line 2811 "parser.yy"
    9388     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     9182#line 2834 "parser.yy"
     9183    { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); }
    93899184    break;
    93909185
    … …  
    93929187
    93939188/* Line 1806 of yacc.c  */
    9394 #line 2816 "parser.yy"
    9395     { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); }
     9189#line 2836 "parser.yy"
     9190    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    93969191    break;
    93979192
    … …  
    93999194
    94009195/* Line 1806 of yacc.c  */
    9401 #line 2818 "parser.yy"
     9196#line 2838 "parser.yy"
    94029197    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    94039198    break;
    94049199
    9405   case 751:
    9406 
    9407 /* Line 1806 of yacc.c  */
    9408 #line 2820 "parser.yy"
    9409     { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
     9200  case 753:
     9201
     9202/* Line 1806 of yacc.c  */
     9203#line 2862 "parser.yy"
     9204    { (yyval.en) = 0; }
    94109205    break;
    94119206
    … …  
    94139208
    94149209/* Line 1806 of yacc.c  */
    9415 #line 2844 "parser.yy"
    9416     { (yyval.en) = 0; }
    9417     break;
    9418 
    9419   case 755:
    9420 
    9421 /* Line 1806 of yacc.c  */
    9422 #line 2846 "parser.yy"
     9210#line 2864 "parser.yy"
    94239211    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    94249212    break;
    … …  
    94279215
    94289216/* Line 1806 of yacc.c  */
    9429 #line 9430 "Parser/parser.cc"
     9217#line 9218 "Parser/parser.cc"
    94309218      default: break;
    94319219    }
    … …  
    96589446
    96599447/* Line 2067 of yacc.c  */
    9660 #line 2849 "parser.yy"
     9448#line 2867 "parser.yy"
    96619449
    96629450// ----end of grammar----

  • src/Parser/parser.h

    r0853178 r04273e9  
    262262
    263263/* Line 2068 of yacc.c  */
    264 #line 110 "parser.yy"
     264#line 115 "parser.yy"
    265265
    266266        Token tok;
    … …  
    274274        LabelNode *label;
    275275        InitializerNode *in;
    276         OperatorNode::Type op;
     276        OperKinds op;
    277277        bool flag;
    278278

  • src/Parser/parser.yy

    r0853178 r04273e9  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 08:15:57 2016
    13 // Update Count     : 1721
     12// Last Modified On : Sun Aug  7 09:37:48 2016
     13// Update Count     : 1764
    1414//
    1515
    … …  
    6060std::stack< LinkageSpec::Type > linkageStack;
    6161TypedefTable typedefTable;
     62
     63void appendStr( std::string &to, std::string *from ) {
     64        // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
     65        to.insert( to.length() - 1, from->substr( 1, from->length() - 2 ) );
     66} // appendStr
    6267%}
    6368
    … …  
    119124        LabelNode *label;
    120125        InitializerNode *in;
    121         OperatorNode::Type op;
     126        OperKinds op;
    122127        bool flag;
    123128}
    … …  
    130135%type<constant> constant
    131136%type<en> tuple                                                 tuple_expression_list
    132 %type<op> ptrref_operator
    133 %type<en> unary_operator                                assignment_operator
     137%type<op> ptrref_operator                               unary_operator                          assignment_operator
    134138%type<en> primary_expression                    postfix_expression                      unary_expression
    135139%type<en> cast_expression                               multiplicative_expression       additive_expression                     shift_expression
    … …  
    305309constant:
    306310                // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
    307 INTEGERconstant                                                                 { $$ = makeConstantInteger( *$1 ); }
    308         | FLOATINGconstant                                                      { $$ = makeConstantFloat( *$1 ); }
    309         | CHARACTERconstant                                                     { $$ = makeConstantChar( *$1 ); }
     311INTEGERconstant                                                                 { $$ = build_constantInteger( *$1 ); }
     312        | FLOATINGconstant                                                      { $$ = build_constantFloat( *$1 ); }
     313        | CHARACTERconstant                                                     { $$ = build_constantChar( *$1 ); }
    310314        ;
    311315
    … …  
    332336
    333337string_literal_list:                                                                    // juxtaposed strings are concatenated
    334         STRINGliteral                                                           { $$ = makeConstantStr( *$1 ); }
    335         | string_literal_list STRINGliteral                     { $$ = $1->appendstr( $2 ); }
     338        STRINGliteral                                                           { $$ = build_constantStr( *$1 ); }
     339        | string_literal_list STRINGliteral
     340                {
     341                        appendStr( $1->get_expr()->get_constant()->get_value(), $2 );
     342                        delete $2;                                                                      // allocated by lexer
     343                        $$ = $1;
     344                }
    336345        ;
    337346
    … …  
    356365                // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
    357366                // equivalent to the old x[i,j].
    358                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Index, $1, $4 ) ); }
     367                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Index, $1, $4 ) ); }
    359368        | postfix_expression '(' argument_expression_list ')'
    360                 { $$ = new CompositeExprNode( $1, $3 ); }
     369                { $$ = new CompositeExprNode( build_func( $1, $3 ) ); }
    361370        // ambiguity with .0 so space required after field-selection, e.g.
    362371                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    363372        | postfix_expression '.' no_attr_identifier
    364                 { $$ = new CompositeExprNode2( build_fieldSel( $1, new VarRefNode( $3 ) ) ); }
     373                { $$ = new CompositeExprNode( build_fieldSel( $1, new VarRefNode( $3 ) ) ); }
    365374        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    366375        | postfix_expression ARROW no_attr_identifier
    367                 { $$ = new CompositeExprNode2( build_pfieldSel( $1, new VarRefNode( $3 ) ) ); }
     376                { $$ = new CompositeExprNode( build_pfieldSel( $1, new VarRefNode( $3 ) ) ); }
    368377        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
    369378        | postfix_expression ICR
    370                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::IncrPost, $1 ) ); }
     379                { $$ = new CompositeExprNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
    371380        | postfix_expression DECR
    372                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::DecrPost, $1 ) ); }
     381                { $$ = new CompositeExprNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
    373382        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
    374383                { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
    375384        | postfix_expression '{' argument_expression_list '}' // CFA
    376385                {
    377                         Token fn; fn.str = new std::string( "?{}" ); // location undefined
    378                         $$ = new CompositeExprNode( new VarRefNode( fn ), (ExpressionNode *)( $1 )->set_link( $3 ) );
     386                        Token fn;
     387                        fn.str = new std::string( "?{}" ); // location undefined
     388                        $$ = new CompositeExprNode( build_func( new VarRefNode( fn ), (ExpressionNode *)( $1 )->set_link( $3 ) ) );
    379389                }
    380390        ;
    … …  
    398408                { $$ = $7->set_argName( $3 ); }
    399409        | '[' push assignment_expression ',' tuple_expression_list pop ']' ':' assignment_expression
    400                 { $$ = $9->set_argName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 )))); }
     410                { $$ = $9->set_argName( new CompositeExprNode( build_tuple( (ExpressionNode *)$3->set_link( $5 ) ) ) ); }
    401411        ;
    402412
    … …  
    412422                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    413423        | no_attr_identifier '.' field
    414                 { $$ = new CompositeExprNode2( build_fieldSel( $3, new VarRefNode( $1 ) ) ); }
     424                { $$ = new CompositeExprNode( build_fieldSel( $3, new VarRefNode( $1 ) ) ); }
    415425        | no_attr_identifier '.' '[' push field_list pop ']'
    416                 { $$ = new CompositeExprNode2( build_fieldSel( $5, new VarRefNode( $1 ) ) ); }
     426                { $$ = new CompositeExprNode( build_fieldSel( $5, new VarRefNode( $1 ) ) ); }
    417427        | no_attr_identifier ARROW field
    418                 { $$ = new CompositeExprNode2( build_pfieldSel( $3, new VarRefNode( $1 ) ) ); }
     428                { $$ = new CompositeExprNode( build_pfieldSel( $3, new VarRefNode( $1 ) ) ); }
    419429        | no_attr_identifier ARROW '[' push field_list pop ']'
    420                 { $$ = new CompositeExprNode2( build_pfieldSel( $5, new VarRefNode( $1 ) ) ); }
     430                { $$ = new CompositeExprNode( build_pfieldSel( $5, new VarRefNode( $1 ) ) ); }
    421431        ;
    422432
    … …  
    435445                //              { * int X; } // CFA declaration of pointer to int
    436446        | ptrref_operator cast_expression                                       // CFA
    437                 { $$ = $1 == OperatorNode::AddressOf ? (ExpressionNode*) new CompositeExprNode2( build_addressOf( $2 ) )
    438                                                                                         : (ExpressionNode*)new CompositeExprNode( new OperatorNode ( $1 ), $2 ); }
     447                {
     448                        switch ( $1 ) {
     449                          case OperKinds::AddressOf:
     450                                $$ = new CompositeExprNode( build_addressOf( $2 ) );
     451                                break;
     452                          case OperKinds::PointTo:
     453                                $$ = new CompositeExprNode( build_unary_val( $1, $2 ) );
     454                                break;
     455                          default:
     456                                assert( false );
     457                        }
     458                }
    439459        | unary_operator cast_expression
    440                 { $$ = new CompositeExprNode( $1, $2 ); }
     460                        { $$ = new CompositeExprNode( build_unary_val( $1, $2 ) ); }
    441461        | ICR unary_expression
    442                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Incr, $2 ) ); }
     462                { $$ = new CompositeExprNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
    443463        | DECR unary_expression
    444                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Decr, $2 ) ); }
     464                { $$ = new CompositeExprNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
    445465        | SIZEOF unary_expression
    446                 { $$ = new CompositeExprNode2( build_sizeOf( $2 ) ); }
     466                { $$ = new CompositeExprNode( build_sizeOf( $2 ) ); }
    447467        | SIZEOF '(' type_name_no_function ')'
    448                 { $$ = new CompositeExprNode2( build_sizeOf( new TypeValueNode( $3 ) ) ); }
     468                { $$ = new CompositeExprNode( build_sizeOf( new TypeValueNode( $3 ) ) ); }
    449469        | OFFSETOF '(' type_name_no_function ',' no_attr_identifier ')'
    450                 { $$ = new CompositeExprNode2( build_offsetOf( new TypeValueNode( $3 ), new VarRefNode( $5 ) ) ); }
     470                { $$ = new CompositeExprNode( build_offsetOf( new TypeValueNode( $3 ), new VarRefNode( $5 ) ) ); }
    451471        | ATTR_IDENTIFIER
    452                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ) ); }
     472                { $$ = new CompositeExprNode( build_attr( new VarRefNode( $1 ) ) ); }
    453473        | ATTR_IDENTIFIER '(' type_name ')'
    454                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), new TypeValueNode( $3 ) ); }
     474                { $$ = new CompositeExprNode( build_attr( new VarRefNode( $1 ), new TypeValueNode( $3 ) ) ); }
    455475        | ATTR_IDENTIFIER '(' argument_expression ')'
    456                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), $3 ); }
     476                { $$ = new CompositeExprNode( build_attr( new VarRefNode( $1 ), $3 ) ); }
    457477        | ALIGNOF unary_expression                                                      // GCC, variable alignment
    458                 { $$ = new CompositeExprNode2( build_alignOf( $2 ) ); }
     478                { $$ = new CompositeExprNode( build_alignOf( $2 ) ); }
    459479        | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
    460                 { $$ = new CompositeExprNode2( build_alignOf( new TypeValueNode( $3 ) ) ); }
     480                { $$ = new CompositeExprNode( build_alignOf( new TypeValueNode( $3 ) ) ); }
    461481//      | ANDAND IDENTIFIER                                                                     // GCC, address of label
    462 //              { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
     482//              { $$ = new CompositeExprNode( new OperatorNode( OperKinds::LabelAddress ), new VarRefNode( $2, true ) ); }
    463483        ;
    464484
    465485ptrref_operator:
    466         '*'                                                                                     { $$ = OperatorNode::PointTo; }
    467         | '&'                                                                           { $$ = OperatorNode::AddressOf; }
     486        '*'                                                                                     { $$ = OperKinds::PointTo; }
     487        | '&'                                                                           { $$ = OperKinds::AddressOf; }
    468488                // GCC, address of label must be handled by semantic check for ref,ref,label
    469         | ANDAND                                                                        { $$ = OperatorNode::And; }
     489//      | ANDAND                                                                        { $$ = OperKinds::And; }
    470490        ;
    471491
    472492unary_operator:
    473         '+'                                                                                     { $$ = new OperatorNode( OperatorNode::UnPlus ); }
    474         | '-'                                                                           { $$ = new OperatorNode( OperatorNode::UnMinus ); }
    475         | '!'                                                                           { $$ = new OperatorNode( OperatorNode::Neg ); }
    476         | '~'                                                                           { $$ = new OperatorNode( OperatorNode::BitNeg ); }
     493        '+'                                                                                     { $$ = OperKinds::UnPlus; }
     494        | '-'                                                                           { $$ = OperKinds::UnMinus; }
     495        | '!'                                                                           { $$ = OperKinds::Neg; }
     496        | '~'                                                                           { $$ = OperKinds::BitNeg; }
    477497        ;
    478498
    … …  
    480500        unary_expression
    481501        | '(' type_name_no_function ')' cast_expression
    482                 { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
     502                { $$ = new CompositeExprNode( build_cast( new TypeValueNode( $2 ), $4 ) ); }
    483503        | '(' type_name_no_function ')' tuple
    484                 { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
     504                { $$ = new CompositeExprNode( build_cast( new TypeValueNode( $2 ), $4 ) ); }
    485505        ;
    486506
    … …  
    488508        cast_expression
    489509        | multiplicative_expression '*' cast_expression
    490                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mul, $1, $3 ) ); }
     510                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
    491511        | multiplicative_expression '/' cast_expression
    492                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Div, $1, $3 ) ); }
     512                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
    493513        | multiplicative_expression '%' cast_expression
    494                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mod, $1, $3 ) ); }
     514                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
    495515        ;
    496516
    … …  
    498518        multiplicative_expression
    499519        | additive_expression '+' multiplicative_expression
    500                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Plus, $1, $3 ) ); }
     520                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
    501521        | additive_expression '-' multiplicative_expression
    502                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Minus, $1, $3 ) ); }
     522                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
    503523        ;
    504524
    … …  
    506526        additive_expression
    507527        | shift_expression LS additive_expression
    508                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LShift, $1, $3 ) ); }
     528                { $$ = new CompositeExprNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
    509529        | shift_expression RS additive_expression
    510                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::RShift, $1, $3 ) ); }
     530                { $$ = new CompositeExprNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
    511531        ;
    512532
    … …  
    514534        shift_expression
    515535        | relational_expression '<' shift_expression
    516                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LThan, $1, $3 ) ); }
     536                { $$ = new CompositeExprNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
    517537        | relational_expression '>' shift_expression
    518                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GThan, $1, $3 ) ); }
     538                { $$ = new CompositeExprNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
    519539        | relational_expression LE shift_expression
    520                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LEThan, $1, $3 ) ); }
     540                { $$ = new CompositeExprNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
    521541        | relational_expression GE shift_expression
    522                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GEThan, $1, $3 ) ); }
     542                { $$ = new CompositeExprNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
    523543        ;
    524544
    … …  
    526546        relational_expression
    527547        | equality_expression EQ relational_expression
    528                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Eq, $1, $3 ) ); }
     548                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
    529549        | equality_expression NE relational_expression
    530                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Neq, $1, $3 ) ); }
     550                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
    531551        ;
    532552
    … …  
    534554        equality_expression
    535555        | AND_expression '&' equality_expression
    536                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitAnd, $1, $3 ) ); }
     556                { $$ = new CompositeExprNode( build_binary_val( OperKinds::BitAnd, $1, $3 ) ); }
    537557        ;
    538558
    … …  
    540560        AND_expression
    541561        | exclusive_OR_expression '^' AND_expression
    542                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Xor, $1, $3 ) ); }
     562                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Xor, $1, $3 ) ); }
    543563        ;
    544564
    … …  
    546566        exclusive_OR_expression
    547567        | inclusive_OR_expression '|' exclusive_OR_expression
    548                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitOr, $1, $3 ) ); }
     568                { $$ = new CompositeExprNode( build_binary_val( OperKinds::BitOr, $1, $3 ) ); }
    549569        ;
    550570
    … …  
    552572        inclusive_OR_expression
    553573        | logical_AND_expression ANDAND inclusive_OR_expression
    554                 { $$ = new CompositeExprNode2( build_and_or( $1, $3, true ) ); }
     574                { $$ = new CompositeExprNode( build_and_or( $1, $3, true ) ); }
    555575        ;
    556576
    … …  
    558578        logical_AND_expression
    559579        | logical_OR_expression OROR logical_AND_expression
    560                 { $$ = new CompositeExprNode2( build_and_or( $1, $3, false ) ); }
     580                { $$ = new CompositeExprNode( build_and_or( $1, $3, false ) ); }
    561581        ;
    562582
    … …  
    564584        logical_OR_expression
    565585        | logical_OR_expression '?' comma_expression ':' conditional_expression
    566                 { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
     586                { $$ = new CompositeExprNode( build_cond( $1, $3, $5 ) ); }
     587                // FIX ME: this hack computes $1 twice
    567588        | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
    568                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), $1, $4 ); }
     589                { $$ = new CompositeExprNode( build_cond( $1, $1, $4 ) ); }
    569590        | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression
    570                 { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
     591                { $$ = new CompositeExprNode( build_cond( $1, $3, $5 ) ); }
    571592        ;
    572593
    … …  
    578599                // CFA, assignment is separated from assignment_operator to ensure no assignment operations for tuples
    579600        conditional_expression
    580         | unary_expression '=' assignment_expression
    581                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $3 ); }
    582601        | unary_expression assignment_operator assignment_expression
    583                 { $$ = new CompositeExprNode( $2, $1, $3 ); }
     602                { $$ = new CompositeExprNode( build_binary_ptr( $2, $1, $3 ) ); }
    584603        | tuple assignment_opt                                                          // CFA, tuple expression
    585                 { $$ = ( $2 == 0 ) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); }
     604                { $$ = ( $2 == 0 ) ? $1 : new CompositeExprNode( build_binary_ptr( OperKinds::Assign, $1, $2 ) ); }
    586605        ;
    587606
    … …  
    592611        ;
    593612
     613assignment_operator:
     614        '='                                                                                     { $$ = OperKinds::Assign; }
     615        | MULTassign                                                            { $$ = OperKinds::MulAssn; }
     616        | DIVassign                                                                     { $$ = OperKinds::DivAssn; }
     617        | MODassign                                                                     { $$ = OperKinds::ModAssn; }
     618        | PLUSassign                                                            { $$ = OperKinds::PlusAssn; }
     619        | MINUSassign                                                           { $$ = OperKinds::MinusAssn; }
     620        | LSassign                                                                      { $$ = OperKinds::LSAssn; }
     621        | RSassign                                                                      { $$ = OperKinds::RSAssn; }
     622        | ANDassign                                                                     { $$ = OperKinds::AndAssn; }
     623        | ERassign                                                                      { $$ = OperKinds::ERAssn; }
     624        | ORassign                                                                      { $$ = OperKinds::OrAssn; }
     625        ;
     626
    594627tuple:                                                                                                  // CFA, tuple
    595628                // CFA, one assignment_expression is factored out of comma_expression to eliminate a shift/reduce conflict with
    596629                // comma_expression in new_identifier_parameter_array and new_abstract_array
    597630        '[' ']'
    598                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
     631                { $$ = new CompositeExprNode( build_tuple() ); }
    599632        | '[' push assignment_expression pop ']'
    600                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), $3 ); }
     633                { $$ = new CompositeExprNode( build_tuple( $3 ) ); }
    601634        | '[' push ',' tuple_expression_list pop ']'
    602                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( $4 ) ); }
     635                { $$ = new CompositeExprNode( build_tuple( (ExpressionNode *)(new NullExprNode)->set_link( $4 ) ) ); }
    603636        | '[' push assignment_expression ',' tuple_expression_list pop ']'
    604                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)$3->set_link( flattenCommas( $5 ) ) ); }
     637                { $$ = new CompositeExprNode( build_tuple( (ExpressionNode *)$3->set_link( $5 ) ) ); }
    605638        ;
    606639
    … …  
    611644        ;
    612645
    613 assignment_operator:
    614         MULTassign                                                                      { $$ = new OperatorNode( OperatorNode::MulAssn ); }
    615         | DIVassign                                                                     { $$ = new OperatorNode( OperatorNode::DivAssn ); }
    616         | MODassign                                                                     { $$ = new OperatorNode( OperatorNode::ModAssn ); }
    617         | PLUSassign                                                            { $$ = new OperatorNode( OperatorNode::PlusAssn ); }
    618         | MINUSassign                                                           { $$ = new OperatorNode( OperatorNode::MinusAssn ); }
    619         | LSassign                                                                      { $$ = new OperatorNode( OperatorNode::LSAssn ); }
    620         | RSassign                                                                      { $$ = new OperatorNode( OperatorNode::RSAssn ); }
    621         | ANDassign                                                                     { $$ = new OperatorNode( OperatorNode::AndAssn ); }
    622         | ERassign                                                                      { $$ = new OperatorNode( OperatorNode::ERAssn ); }
    623         | ORassign                                                                      { $$ = new OperatorNode( OperatorNode::OrAssn ); }
    624         ;
    625 
    626646comma_expression:
    627647        assignment_expression
    628         | comma_expression ',' assignment_expression    // { $$ = (ExpressionNode *)$1->add_to_list( $3 ); }
    629         //{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), $1, $3 ); }
    630                 { $$ = new CompositeExprNode2( build_comma( $1, $3 ) ); }
     648        | comma_expression ',' assignment_expression
     649                { $$ = new CompositeExprNode( build_comma( $1, $3 ) ); }
    631650        ;
    632651
    … …  
    650669        | '^' postfix_expression '{' argument_expression_list '}' ';' // CFA
    651670                {
    652                         Token fn; fn.str = new std::string( "^?{}" ); // location undefined
    653                         $$ = new StatementNode( StatementNode::Exp, new CompositeExprNode( new VarRefNode( fn ),
    654                                 (ExpressionNode *)( $2 )->set_link( $4 ) ), 0 );
     671                        Token fn;
     672                        fn.str = new std::string( "^?{}" ); // location undefined
     673                        $$ = new StatementNode( StatementNode::Exp, new CompositeExprNode( build_func( new VarRefNode( fn ), (ExpressionNode *)( $2 )->set_link( $4 ) ) ), 0 );
    655674                }
    656675        ;
    … …  
    740759        constant_expression                                                     { $$ = $1; }
    741760        | constant_expression ELLIPSIS constant_expression      // GCC, subrange
    742                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
     761                { $$ = new CompositeExprNode( build_range( $1, $3 ) ); }
    743762        | subrange                                                                                      // CFA, subrange
    744763        ;
    … …  
    17811800                { $$ = new DesignatorNode( $3, true ); }
    17821801        | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
    1783                 { $$ = new DesignatorNode( new CompositeExprNode2( build_opr2( OperatorNode::Range, $3, $5 ) ), true ); }
     1802                { $$ = new DesignatorNode( new CompositeExprNode( build_range( $3, $5 ) ), true ); }
    17841803        | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
    17851804                { $$ = new DesignatorNode( $4 ); }
    … …  
    21102129subrange:
    21112130        constant_expression '~' constant_expression                     // CFA, integer subrange
    2112                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
     2131                { $$ = new CompositeExprNode( build_range( $1, $3 ) ); }
    21132132        ;
    21142133

  • src/SymTab/Autogen.cc

    r0853178 r04273e9  
    173173        }
    174174
    175         void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, TypeSubstitution & genericSubs, bool isGeneric, bool forward = true ) {
    176                 if ( isGeneric ) {
    177                         // rewrite member type in terms of the type variables on this operator
    178                         field = field->clone();
    179                         genericSubs.apply( field );
    180 
    181                         if ( src ) {
    182                                 genericSubs.apply( src );
    183                         }
     175        void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, TypeSubstitution & genericSubs, bool isDynamicLayout, bool forward = true ) {
     176                if ( isDynamicLayout && src ) {
     177                        genericSubs.apply( src );
    184178                }
    185179
    … …  
    197191                genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
    198192
    199                 if ( isGeneric && returnVal ) {
     193                if ( isDynamicLayout && returnVal ) {
    200194                        UntypedExpr *derefRet = new UntypedExpr( new NameExpr( "*?" ) );
    201195                        derefRet->get_args().push_back( new VariableExpr( returnVal ) );
    … …  
    206200
    207201        template<typename Iterator>
    208         void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, TypeSubstitution & genericSubs, bool isGeneric, bool forward = true ) {
     202        void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, TypeSubstitution & genericSubs, bool isDynamicLayout, bool forward = true ) {
    209203                for ( ; member != end; ++member ) {
    210204                        if ( DeclarationWithType *field = dynamic_cast< DeclarationWithType * >( *member ) ) { // otherwise some form of type declaration, e.g. Aggregate
    … …  
    242236
    243237                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
    244                                 makeStructMemberOp( dstParam, srcselect, field, func, genericSubs, isGeneric, forward );
     238                                makeStructMemberOp( dstParam, srcselect, field, func, genericSubs, isDynamicLayout, forward );
    245239                        } // if
    246240                } // for
    … …  
    250244        /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
    251245        template<typename Iterator>
    252         void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func, TypeSubstitution & genericSubs, bool isGeneric ) {
     246        void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func, TypeSubstitution & genericSubs, bool isDynamicLayout ) {
    253247                FunctionType * ftype = func->get_functionType();
    254248                std::list<DeclarationWithType*> & params = ftype->get_parameters();
    … …  
    276270                                        // matching parameter, initialize field with copy ctor
    277271                                        Expression *srcselect = new VariableExpr(*parameter);
    278                                         makeStructMemberOp( dstParam, srcselect, field, func, genericSubs, isGeneric );
     272                                        makeStructMemberOp( dstParam, srcselect, field, func, genericSubs, isDynamicLayout );
    279273                                        ++parameter;
    280274                                } else {
    281275                                        // no matching parameter, initialize field with default ctor
    282                                         makeStructMemberOp( dstParam, NULL, field, func, genericSubs, isGeneric );
     276                                        makeStructMemberOp( dstParam, NULL, field, func, genericSubs, isDynamicLayout );
    283277                                }
    284278                        }
    … …  
    290284
    291285                // Make function polymorphic in same parameters as generic struct, if applicable
    292                 bool isGeneric = false;  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for union)
     286                bool isDynamicLayout = false;  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for union)
    293287                std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
    294288                std::list< Expression* > structParams;  // List of matching parameters to put on types
    295289                TypeSubstitution genericSubs; // Substitutions to make to member types of struct
    296290                for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
    297                         isGeneric = true;
     291                        if ( (*param)->get_kind() == TypeDecl::Any ) isDynamicLayout = true;
    298292                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
    299293                        assignType->get_forall().push_back( typeParam );
    … …  
    355349                        FunctionDecl * ctor = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, memCtorType->clone(), new CompoundStmt( noLabels ), true, false );
    356350                        ctor->fixUniqueId();
    357                         makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, genericSubs, isGeneric );
     351                        makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, genericSubs, isDynamicLayout );
    358352                        memCtors.push_back( ctor );
    359353                }
    … …  
    361355
    362356                // generate appropriate calls to member ctor, assignment
    363                 makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), assignDecl, genericSubs, isGeneric );
    364                 makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctorDecl, genericSubs, isGeneric );
    365                 makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), copyCtorDecl, genericSubs, isGeneric );
     357                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), assignDecl, genericSubs, isDynamicLayout );
     358                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctorDecl, genericSubs, isDynamicLayout );
     359                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), copyCtorDecl, genericSubs, isDynamicLayout );
    366360                // needs to do everything in reverse, so pass "forward" as false
    367                 makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dtorDecl, genericSubs, isGeneric, false );
    368 
    369                 if ( ! isGeneric ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
     361                makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dtorDecl, genericSubs, isDynamicLayout, false );
     362
     363                if ( ! isDynamicLayout ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
    370364
    371365                declsToAdd.push_back( assignDecl );
    … …  
    380374
    381375                // Make function polymorphic in same parameters as generic union, if applicable
    382                 bool isGeneric = false; // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for struct)
     376                bool isDynamicLayout = false; // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for struct)
    383377                std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
    384378                std::list< Expression* > unionParams;  // List of matching parameters to put on types
    385379                for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
    386                         isGeneric = true;
     380                        if ( (*param)->get_kind() == TypeDecl::Any ) isDynamicLayout = true;
    387381                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
    388382                        assignType->get_forall().push_back( typeParam );
    … …  
    420414
    421415                makeUnionFieldsAssignment( srcParam, dstParam, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
    422                 if ( isGeneric ) makeUnionFieldsAssignment( srcParam, returnVal, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
     416                if ( isDynamicLayout ) makeUnionFieldsAssignment( srcParam, returnVal, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
    423417                else assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
    424418

  • src/SynTree/Expression.cc

    r0853178 r04273e9  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug  3 17:06:51 2016
    13 // Update Count     : 45
     12// Last Modified On : Fri Aug  5 14:23:56 2016
     13// Update Count     : 49
    1414//
    1515
    … …  
    529529}
    530530
    531 RangeExpr::RangeExpr( ConstantExpr *low, ConstantExpr *high ) : low( low ), high( high ) {}
     531RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
    532532RangeExpr::RangeExpr( const RangeExpr &other ) : low( other.low->clone() ), high( other.high->clone() ) {}
    533533void RangeExpr::print( std::ostream &os, int indent ) const {

  • src/SynTree/Expression.h

    r0853178 r04273e9  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug  3 17:08:44 2016
    13 // Update Count     : 27
     12// Last Modified On : Sat Aug  6 08:52:53 2016
     13// Update Count     : 35
    1414//
    1515
    … …  
    2828class Expression {
    2929  public:
    30         Expression(Expression *_aname = 0 );
     30        Expression( Expression *_aname = nullptr );
    3131        Expression( const Expression &other );
    3232        virtual ~Expression();
    … …  
    7070typedef std::map< UniqueId, ParamEntry > InferredParams;
    7171
    72 /// ApplicationExpr represents the application of a function to a set of parameters.  This is the
    73 /// result of running an UntypedExpr through the expression analyzer.
     72/// ApplicationExpr represents the application of a function to a set of parameters.  This is the result of running an
     73/// UntypedExpr through the expression analyzer.
    7474class ApplicationExpr : public Expression {
    7575  public:
    … …  
    9393};
    9494
    95 /// UntypedExpr represents the application of a function to a set of parameters, but where the
    96 /// particular overload for the function name has not yet been determined.  Most operators are
    97 /// converted into functional form automatically, to permit operator overloading.
     95/// UntypedExpr represents the application of a function to a set of parameters, but where the particular overload for
     96/// the function name has not yet been determined.  Most operators are converted into functional form automatically, to
     97/// permit operator overloading.
    9898class UntypedExpr : public Expression {
    9999  public:
    100         UntypedExpr( Expression *function, Expression *_aname = 0 );
     100        UntypedExpr( Expression *function, Expression *_aname = nullptr );
    101101        UntypedExpr( const UntypedExpr &other );
    102         UntypedExpr( Expression *function, std::list<Expression *> &args, Expression *_aname = 0 );
     102        UntypedExpr( Expression *function, std::list<Expression *> &args, Expression *_aname = nullptr );
    103103        virtual ~UntypedExpr();
    104104
    … …  
    124124class NameExpr : public Expression {
    125125  public:
    126         NameExpr( std::string name, Expression *_aname = 0 );
     126        NameExpr( std::string name, Expression *_aname = nullptr );
    127127        NameExpr( const NameExpr &other );
    128128        virtual ~NameExpr();
    … …  
    145145class AddressExpr : public Expression {
    146146  public:
    147         AddressExpr( Expression *arg, Expression *_aname = 0 );
     147        AddressExpr( Expression *arg, Expression *_aname = nullptr );
    148148        AddressExpr( const AddressExpr &other );
    149149        virtual ~AddressExpr();
    … …  
    181181class CastExpr : public Expression {
    182182  public:
    183         CastExpr( Expression *arg, Expression *_aname = 0 );
    184         CastExpr( Expression *arg, Type *toType, Expression *_aname = 0 );
     183        CastExpr( Expression *arg, Expression *_aname = nullptr );
     184        CastExpr( Expression *arg, Type *toType, Expression *_aname = nullptr );
    185185        CastExpr( const CastExpr &other );
    186186        virtual ~CastExpr();
    … …  
    200200class UntypedMemberExpr : public Expression {
    201201  public:
    202         UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = 0 );
     202        UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = nullptr );
    203203        UntypedMemberExpr( const UntypedMemberExpr &other );
    204204        virtual ~UntypedMemberExpr();
    … …  
    221221class MemberExpr : public Expression {
    222222  public:
    223         MemberExpr( DeclarationWithType *member, Expression *aggregate, Expression *_aname = 0 );
     223        MemberExpr( DeclarationWithType *member, Expression *aggregate, Expression *_aname = nullptr );
    224224        MemberExpr( const MemberExpr &other );
    225225        virtual ~MemberExpr();
    … …  
    242242class VariableExpr : public Expression {
    243243  public:
    244         VariableExpr( DeclarationWithType *var, Expression *_aname = 0 );
     244        VariableExpr( DeclarationWithType *var, Expression *_aname = nullptr );
    245245        VariableExpr( const VariableExpr &other );
    246246        virtual ~VariableExpr();
    … …  
    260260class ConstantExpr : public Expression {
    261261  public:
    262         ConstantExpr( Constant constant, Expression *_aname = 0 );
     262        ConstantExpr( Constant constant, Expression *_aname = nullptr );
    263263        ConstantExpr( const ConstantExpr &other );
    264264        virtual ~ConstantExpr();
    … …  
    278278class SizeofExpr : public Expression {
    279279  public:
    280         SizeofExpr( Expression *expr, Expression *_aname = 0 );
     280        SizeofExpr( Expression *expr, Expression *_aname = nullptr );
    281281        SizeofExpr( const SizeofExpr &other );
    282         SizeofExpr( Type *type, Expression *_aname = 0 );
     282        SizeofExpr( Type *type, Expression *_aname = nullptr );
    283283        virtual ~SizeofExpr();
    284284
    … …  
    303303class AlignofExpr : public Expression {
    304304  public:
    305         AlignofExpr( Expression *expr, Expression *_aname = 0 );
     305        AlignofExpr( Expression *expr, Expression *_aname = nullptr );
    306306        AlignofExpr( const AlignofExpr &other );
    307         AlignofExpr( Type *type, Expression *_aname = 0 );
     307        AlignofExpr( Type *type, Expression *_aname = nullptr );
    308308        virtual ~AlignofExpr();
    309309
    … …  
    328328class UntypedOffsetofExpr : public Expression {
    329329  public:
    330         UntypedOffsetofExpr( Type *type, const std::string &member, Expression *_aname = 0 );
     330        UntypedOffsetofExpr( Type *type, const std::string &member, Expression *_aname = nullptr );
    331331        UntypedOffsetofExpr( const UntypedOffsetofExpr &other );
    332332        virtual ~UntypedOffsetofExpr();
    … …  
    349349class OffsetofExpr : public Expression {
    350350  public:
    351         OffsetofExpr( Type *type, DeclarationWithType *member, Expression *_aname = 0 );
     351        OffsetofExpr( Type *type, DeclarationWithType *member, Expression *_aname = nullptr );
    352352        OffsetofExpr( const OffsetofExpr &other );
    353353        virtual ~OffsetofExpr();
    … …  
    390390class AttrExpr : public Expression {
    391391  public:
    392         AttrExpr(Expression *attr, Expression *expr, Expression *_aname = 0 );
     392        AttrExpr(Expression *attr, Expression *expr, Expression *_aname = nullptr );
    393393        AttrExpr( const AttrExpr &other );
    394         AttrExpr( Expression *attr, Type *type, Expression *_aname = 0 );
     394        AttrExpr( Expression *attr, Type *type, Expression *_aname = nullptr );
    395395        virtual ~AttrExpr();
    396396
    … …  
    418418class LogicalExpr : public Expression {
    419419  public:
    420         LogicalExpr( Expression *arg1, Expression *arg2, bool andp = true, Expression *_aname = 0 );
     420        LogicalExpr( Expression *arg1, Expression *arg2, bool andp = true, Expression *_aname = nullptr );
    421421        LogicalExpr( const LogicalExpr &other );
    422422        virtual ~LogicalExpr();
    … …  
    441441class ConditionalExpr : public Expression {
    442442  public:
    443         ConditionalExpr( Expression *arg1, Expression *arg2, Expression *arg3, Expression *_aname = 0 );
     443        ConditionalExpr( Expression *arg1, Expression *arg2, Expression *arg3, Expression *_aname = nullptr );
    444444        ConditionalExpr( const ConditionalExpr &other );
    445445        virtual ~ConditionalExpr();
    … …  
    465465class CommaExpr : public Expression {
    466466  public:
    467         CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname = 0 );
     467        CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname = nullptr );
    468468        CommaExpr( const CommaExpr &other );
    469469        virtual ~CommaExpr();
    … …  
    486486class TupleExpr : public Expression {
    487487  public:
    488         TupleExpr( Expression *_aname = 0 );
     488        TupleExpr( Expression *_aname = nullptr );
    489489        TupleExpr( const TupleExpr &other );
    490490        virtual ~TupleExpr();
    … …  
    504504class SolvedTupleExpr : public Expression {
    505505  public:
    506         SolvedTupleExpr( Expression *_aname = 0 ) : Expression( _aname ) {}
    507         SolvedTupleExpr( std::list<Expression *> &, Expression *_aname = 0 );
     506        SolvedTupleExpr( Expression *_aname = nullptr ) : Expression( _aname ) {}
     507        SolvedTupleExpr( std::list<Expression *> &, Expression *_aname = nullptr );
    508508        SolvedTupleExpr( const SolvedTupleExpr &other );
    509509        virtual ~SolvedTupleExpr() {}
    … …  
    598598class UntypedValofExpr : public Expression {
    599599  public:
    600         UntypedValofExpr( Statement *_body, Expression *_aname = 0 ) : Expression( _aname ), body ( _body ) {}
     600        UntypedValofExpr( Statement *_body, Expression *_aname = nullptr ) : Expression( _aname ), body ( _body ) {}
    601601        UntypedValofExpr( const UntypedValofExpr & other );
    602602        virtual ~UntypedValofExpr();
    … …  
    637637class RangeExpr : public Expression {
    638638  public:
    639         RangeExpr( ConstantExpr *low, ConstantExpr *high );
     639        RangeExpr( Expression *low, Expression *high );
    640640        RangeExpr( const RangeExpr &other );
    641641
    642         ConstantExpr * get_low() const { return low.get(); }
    643         ConstantExpr * get_high() const { return high.get(); }
    644         RangeExpr * set_low( ConstantExpr *low ) { RangeExpr::low.reset( low ); return this; }
    645         RangeExpr * set_high( ConstantExpr *high ) { RangeExpr::high.reset( high ); return this; }
     642        Expression * get_low() const { return low; }
     643        Expression * get_high() const { return high; }
     644        RangeExpr * set_low( Expression *low ) { RangeExpr::low = low; return this; }
     645        RangeExpr * set_high( Expression *high ) { RangeExpr::high = high; return this; }
    646646
    647647        virtual RangeExpr *clone() const { return new RangeExpr( *this ); }
    … …  
    650650        virtual void print( std::ostream &os, int indent = 0 ) const;
    651651  private:
    652         std::unique_ptr<ConstantExpr> low, high;
     652        Expression *low, *high;
    653653};
    654654

  • src/driver/cfa.cc

    r0853178 r04273e9  
    1010// Created On       : Tue Aug 20 13:44:49 2002
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug  2 12:23:11 2016
    13 // Update Count     : 147
     12// Last Modified On : Sat Aug  6 16:14:55 2016
     13// Update Count     : 148
    1414//
    1515
    … …  
    8787        bool cpp_flag = false;                                                          // -E or -M flag, preprocessor only
    8888        bool std_flag = false;                                                          // -std= flag
    89         bool noincstd_flag = false;                                                     // -no-include-std= flag
     89        bool noincstd_flag = false;                                                     // -no-include-stdhdr= flag
    9090        bool debugging __attribute(( unused )) = false;         // -g flag
    9191
    … …  
    145145                        } else if ( arg == "-nohelp" ) {
    146146                                help = false;                                                   // strip the nohelp flag
    147                         } else if ( arg == "-no-include-std" ) {
    148                                 noincstd_flag = true;                                   // strip the no-include-std flag
     147                        } else if ( arg == "-no-include-stdhdr" ) {
     148                                noincstd_flag = true;                                   // strip the no-include-stdhdr flag
    149149                        } else if ( arg == "-compiler" ) {
    150150                                // use the user specified compiler

  • src/libcfa/Makefile.am

    r0853178 r04273e9  
    1111## Created On       : Sun May 31 08:54:01 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Tue Aug  2 12:17:23 2016
    14 ## Update Count     : 196
     13## Last Modified On : Sat Aug  6 16:15:15 2016
     14## Update Count     : 197
    1515###############################################################################
    1616
    … …  
    5353         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -c -o $@ $<
    5454
    55 CFLAGS = -quiet -no-include-std -g -Wall -Wno-unused-function @CFA_FLAGS@ -B${abs_top_srcdir}/src/driver -XCFA -t # TEMPORARY: does not build with -O2
     55CFLAGS = -quiet -no-include-stdhdr -g -Wall -Wno-unused-function @CFA_FLAGS@ -B${abs_top_srcdir}/src/driver -XCFA -t # TEMPORARY: does not build with -O2
    5656CC = ${abs_top_srcdir}/src/driver/cfa
    5757

  • src/libcfa/Makefile.in

    r0853178 r04273e9  
    136136CFA_LIBDIR = @CFA_LIBDIR@
    137137CFA_PREFIX = @CFA_PREFIX@
    138 CFLAGS = -quiet -no-include-std -g -Wall -Wno-unused-function @CFA_FLAGS@ -B${abs_top_srcdir}/src/driver -XCFA -t # TEMPORARY: does not build with -O2
     138CFLAGS = -quiet -no-include-stdhdr -g -Wall -Wno-unused-function @CFA_FLAGS@ -B${abs_top_srcdir}/src/driver -XCFA -t # TEMPORARY: does not build with -O2
    139139CPP = @CPP@
    140140CPPFLAGS = @CPPFLAGS@

  • src/main.cc

    r0853178 r04273e9  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul  5 15:23:11 2016
    13 // Update Count     : 209
     12// Last Modified On : Sat Aug  6 16:17:41 2016
     13// Update Count     : 210
    1414//
    1515
    … …  
    2828#include "GenPoly/Box.h"
    2929#include "GenPoly/CopyParams.h"
     30#include "GenPoly/InstantiateGeneric.h"
    3031#include "CodeGen/Generate.h"
    3132#include "CodeGen/FixNames.h"
    … …  
    192193                        input = fopen( argv[ optind ], "r" );
    193194                        if ( ! input ) {
    194                                 std::cout << "Error: can't open " << argv[ optind ] << std::endl;
     195                                std::cout << "Error: cannot open " << argv[ optind ] << std::endl;
    195196                                exit( EXIT_FAILURE );
    196197                        } // if
    … …  
    218219                        FILE * builtins = fopen( libcfap | treep ? "builtins.cf" : CFA_LIBDIR "/builtins.cf", "r" );
    219220                        if ( builtins == NULL ) {
    220                                 std::cerr << "Error: can't open builtins.cf" << std::endl;
     221                                std::cerr << "Error: cannot open builtins.cf" << std::endl;
    221222                                exit( EXIT_FAILURE );
    222223                        } // if
    … …  
    226227                        FILE * extras = fopen( libcfap | treep ? "extras.cf" : CFA_LIBDIR "/extras.cf", "r" );
    227228                        if ( extras == NULL ) {
    228                                 std::cerr << "Error: can't open extras.cf" << std::endl;
     229                                std::cerr << "Error: cannot open extras.cf" << std::endl;
    229230                                exit( EXIT_FAILURE );
    230231                        } // if
    … …  
    235236                                FILE * prelude = fopen( treep ? "prelude.cf" : CFA_LIBDIR "/prelude.cf", "r" );
    236237                                if ( prelude == NULL ) {
    237                                         std::cerr << "Error: can't open prelude.cf" << std::endl;
     238                                        std::cerr << "Error: cannot open prelude.cf" << std::endl;
    238239                                        exit( EXIT_FAILURE );
    239240                                } // if
    … …  
    309310                }
    310311
     312                OPTPRINT("instantiateGenerics")
     313                GenPoly::instantiateGeneric( translationUnit );
    311314                OPTPRINT( "copyParams" );
    312315                GenPoly::copyParams( translationUnit );
Note: See TracChangeset for help on using the changeset viewer.