Changeset 04273e9


Ignore:
Timestamp:
Aug 8, 2016, 5:29:03 PM (5 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
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   &