Index: doc/aaron_comp_II/comp_II.tex =================================================================== --- doc/aaron_comp_II/comp_II.tex (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ doc/aaron_comp_II/comp_II.tex (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -400,4 +400,5 @@ \section{Expression Resolution} +\subsection{Analysis} The expression resolution problem is determining an optimal match between some combination of argument interpretations and the parameter list of some overloaded instance of a function; the argument interpretations are produced by recursive invocations of expression resolution, where the base case is zero-argument functions (which are, for purposes of this discussion, semantically equivalent to named variables or constant literal expressions). Assuming that the matching between a function's parameter list and a combination of argument interpretations can be done in $\bigO{p^k}$ time, where $p$ is the number of parameters and $k$ is some positive number, if there are $\bigO{i}$ valid interpretations for each subexpression, there will be $\bigO{i}$ candidate functions and $\bigO{i^p}$ possible argument combinations for each expression, so for a single recursive call expression resolution takes $\bigO{i^{p+1} \cdot p^k}$ time if it must compare all combinations, or $\bigO{i(p+1) \cdot p^k}$ time if argument-parameter matches can be chosen independently of each other. @@ -409,4 +410,28 @@ 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. +\subsection{Expression Costs} +The expression resolution problem involves minimization of a cost function; loosely defined, this cost function is the number of implicit conversions in the top-level expression interpretation. +With more specificity, the \emph{cost} of a particular expression interpretation is a lexicographically-ordered tuple, where each element of the tuple corresponds to a particular kind of conversion. +In \CFA today, cost is a three-tuple including the number of unsafe conversions, the number of polymorphic parameter bindings, and the number of safe conversions. +These counts include conversions used in subexpression interpretations, as well as those necessary to satisfy the type assertions of any polymorphic functions included in the interpretation. + +\begin{lstlisting} +void f(char, long); // $f_1$ - cost (2, 0, 1) +forall(otype T) void f(T, long); // $f_2$ - cost (0, 1, 1) +void f(long, long); // $f_{3a}$ - cost (0, 0, 2) +void f(int, float); // $f_{3b}$ - cost (0, 0, 2) +void f(int, long); // $f_4$ - cost (0, 0, 1) + +f(7, 11); +\end{lstlisting} + +In the example above, the expression resolves to $f_4$. +$f_1$ has an unsafe conversion (from ©int© to ©char©), and is thus the highest cost, followed by $f_2$, which has a polymorphic binding (from ©int© to ©T©). +Neither $f_{3a}$, $f_{3b}$, or $f_4$ match exactly with the type of the call expression (©void (*)(int, int)©), each involving safe conversions, but in this case $f_4$ is cheaper than $f_{3a}$, because it converts fewer arguments, and is also cheaper than $f_{3b}$, because ©long© is a closer match for ©int© than ©float© is. +If the declaration of $f_4$ was missing, the expression would be ambiguous, because the two single-step ©int©-to-©long© conversions in $f_{3a}$ cost the same as the one double-step ©int©-to-©float© conversion in $f_{3b}$. + +In the course of this project I may modify the cost tuple,\footnote{I have considered adding an element to distinguish between cast expressions used as conversions and those used as type ascriptions, and another element to differentiate interpretations based on closer qualifier matches. The existing costing of polymorphic functions could also be made more precice than a bare count of parameter bindings.} but the essential nature of the cost calculation should remain the same. + +\subsection{Objectives} The research goal of this project is to develop a performant expression resolver for \CFA; this analysis suggests three primary areas of investigation to accomplish that end. The first area of investigation is efficient argument-parameter matching; Bilson~\cite{Bilson03} mentions significant optimization opportunities available in the current literature to improve on the existing CFA compiler. Index: doc/proposals/concurrency/Makefile =================================================================== --- doc/proposals/concurrency/Makefile (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) +++ doc/proposals/concurrency/Makefile (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -0,0 +1,80 @@ +## Define the appropriate configuration variables. + +TeXLIB = .:../../LaTeXmacros:../../LaTeXmacros/listings:../../LaTeXmacros/enumitem:~/bibliographies: +LaTeX = TEXINPUTS=${TeXLIB} && export TEXINPUTS && latex -halt-on-error +BibTeX = BIBINPUTS=${TeXLIB} && export BIBINPUTS && bibtex + +## Define the text source files. + +SOURCES = ${addsuffix .tex, \ +concurrency \ +} + +FIGURES = ${addsuffix .tex, \ +} + +PICTURES = ${addsuffix .pstex, \ +} + +PROGRAMS = ${addsuffix .tex, \ +} + +GRAPHS = ${addsuffix .tex, \ +} + +## Define the documents that need to be made. + +DOCUMENT = concurrency.pdf + +# Directives # + +all : ${DOCUMENT} + +clean : + rm -f *.bbl *.aux *.dvi *.idx *.ilg *.ind *.brf *.out *.log *.toc *.blg *.pstex_t *.cf *.glg *.glo *.gls *.ist \ + ${FIGURES} ${PICTURES} ${PROGRAMS} ${GRAPHS} ${basename ${DOCUMENT}}.ps ${DOCUMENT} + +# File Dependencies # + +${DOCUMENT} : ${basename ${DOCUMENT}}.ps + ps2pdf $< + +${basename ${DOCUMENT}}.ps : ${basename ${DOCUMENT}}.dvi + dvips $< -o $@ + +${basename ${DOCUMENT}}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${basename ${DOCUMENT}}.tex \ + ../../LaTeXmacros/common.tex ../../LaTeXmacros/indexstyle + # Conditionally create an empty *.ind (index) file for inclusion until makeindex is run. + if [ ! -r ${basename $@}.ind ] ; then touch ${basename $@}.ind ; fi + # Must have *.aux file containing citations for bibtex + if [ ! -r ${basename $@}.aux ] ; then ${LaTeX} ${basename $@}.tex ; fi + -${BibTeX} ${basename $@} + # Some citations reference others so run steps again to resolve these citations + ${LaTeX} ${basename $@}.tex + -${BibTeX} ${basename $@} + # Make index from *.aux entries and input index at end of document + makeglossaries ${basename $@} + #${LaTeX} ${basename $@}.tex + # Run again to get index title into table of contents + ${LaTeX} ${basename $@}.tex + ${LaTeX} ${basename $@}.tex + + +predefined : + sed -f predefined.sed ${basename ${DOCUMENT}}.tex > ${basename $@}.cf + +## Define the default recipes. + +%.tex : %.fig + fig2dev -L eepic $< > $@ + +%.ps : %.fig + fig2dev -L ps $< > $@ + +%.pstex : %.fig + fig2dev -L pstex $< > $@ + fig2dev -L pstex_t -p $@ $< > $@_t + +# Local Variables: # +# compile-command: "make" # +# End: # Index: doc/proposals/concurrency/concurrency.tex =================================================================== --- doc/proposals/concurrency/concurrency.tex (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) +++ doc/proposals/concurrency/concurrency.tex (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -0,0 +1,705 @@ +% requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended + +% inline code �...� (copyright symbol) emacs: C-q M-) +% red highlighting �...� (registered trademark symbol) emacs: C-q M-. +% blue highlighting �...� (sharp s symbol) emacs: C-q M-_ +% green highlighting �...� (cent symbol) emacs: C-q M-" +% LaTex escape �...� (section symbol) emacs: C-q M-' +% keyword escape �...� (pilcrow symbol) emacs: C-q M-^ +% math escape $...$ (dollar symbol) + +\documentclass[twoside,11pt]{article} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Latex packages used in the document. +\usepackage[T1]{fontenc} % allow Latin1 (extended ASCII) characters +\usepackage{textcomp} +\usepackage[latin1]{inputenc} +\usepackage{fullpage,times,comment} +\usepackage{epic,eepic} +\usepackage{upquote} % switch curled `'" to straight +\usepackage{calc} +\usepackage{xspace} +\usepackage{graphicx} +\usepackage{tabularx} +\usepackage{glossaries} +\usepackage{varioref} % extended references +\usepackage{inconsolata} +\usepackage{listings} % format program code +\usepackage[flushmargin]{footmisc} % support label/reference in footnote +\usepackage{latexsym} % \Box glyph +\usepackage{mathptmx} % better math font with "times" +\usepackage[usenames]{color} +\usepackage[pagewise]{lineno} +\renewcommand{\linenumberfont}{\scriptsize\sffamily} +\input{common} % bespoke macros used in the document +\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref} +\usepackage{breakurl} + +\renewcommand{\UrlFont}{\small\sf} + +\setlength{\topmargin}{-0.45in} % move running title into header +\setlength{\headsep}{0.25in} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Names used in the document. + +\newcommand{\Version}{1.0.0} +\newcommand{\CS}{C\raisebox{-0.9ex}{\large$^\sharp$}\xspace} + +\newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}} +\newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}} +\newcommand{\R}[1]{\Textbf{#1}} +\newcommand{\B}[1]{{\Textbf[blue]{#1}}} +\newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}} +\newcommand{\uC}{$\mu$\CC} +\newcommand{\cit}{\textsuperscript{[Citation Needed]}\xspace} +\newcommand{\code}[1]{\lstinline{#1}} + +\input{glossary} + +\newsavebox{\LstBox} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\setcounter{secnumdepth}{3} % number subsubsections +\setcounter{tocdepth}{3} % subsubsections in table of contents +\makeindex + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{document} +% \linenumbers + +\title{Concurrency in \CFA} +\author{Thierry Delisle \\ +Dept. of Computer Science, University of Waterloo, \\ Waterloo, Ontario, Canada +} + +\maketitle +\section{Introduction} +This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build "higher level" features. The simplest possible core is a thread and a lock but this low level approach is hard to master. An easier approach for users is be to support higher level construct as the basis of the concurrency in \CFA. +Indeed, for higly productive parallel programming high-level approaches are much more popular\cite{HPP:Study}. Examples are task based parallelism, message passing, implicit threading. + +There are actually two problems that need to be solved in the design of the concurrency for a language. Which concurrency tools are available to the users and which parallelism tools are available. While these two concepts are often seen together, they are in fact distinct concepts that require different sorts of tools\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization while parallelism tools are more about performance, cost and ressource utilisation. + +\section{Concurrency} +Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared state, some languages and libraries simply disallow mutable shared state completely (Erlang\cite{Erlang}, Haskell\cite{Haskell}, Akka (Scala)\cit). In the paradigms, interaction between concurrent objects rely on message passing or other paradigms that often closely relate to networking concepts. However, in imperative or OO languages these approaches entail a clear distinction between concurrent and non concurrent paradigms. Which in turns mean that programmers need to learn two sets of designs patterns in order to be effective at their jobs. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. However for productivity reasons it is desireable to have a higher-level construct to be the core concurrency paradigm\cite{HPP:Study}. This paper proposes Monitors\cit as the core concurrency construct. + +Finally, an approach that is worth mentionning because it is gaining in popularity is transactionnal memory\cite{Dice10}. However, the performance and feature set is currently too restrictive to be possible to add such a paradigm to a language like C or \CC\cit, which is why it was rejected as the core paradigm for concurrency in \CFA. + +\section{Monitors} +A monitor is a set of routines that ensure mutual exclusion when accessing shared state. This concept is generally associated with Object-Oriented Languages like Java\cite{Java} or \uC\cite{uC++book} but does not strictly require OOP semantics. The only requirements is to be able to declare a handle to a shared object and a set of routines that act on it : +\begin{lstlisting} + typedef /*some monitor type*/ monitor; + int f(monitor & m); + + int main() { + monitor m; + f(m); + } +\end{lstlisting} + +\subsection{Call semantics} \label{call} +The above example of monitors already displays some of their intrinsic caracteristics. Indeed, it is necessary to use pass-by-reference over pass-by-value for monitor routines. This semantics is important because since at their core, monitors are simply implicit mutual exclusion objects (locks) and copying semantics of these is ill defined. Therefore, monitors are implicitly non-copyable. + +Another aspect to consider is when a monitor acquires its mutual exclusion. Indeed, a monitor may need to be passed to helper routines that do not acquire the monitor mutual exclusion on entry. Examples of this can be both generic helper routines (\code{swap}, \code{sort}, etc.) or specific helper routines like the following example : + +\begin{lstlisting} + mutex struct counter_t { /*...*/ }; + + void ?{}(counter_t & mutex this); + int ++?(counter_t & mutex this); + void ?{}(int * this, counter_t & mutex cnt); + + bool is_zero(counter_t & nomutex this) { + int val = this; + return val == 0; + } +\end{lstlisting} +*semantics of the declaration of \code{mutex struct counter_t} will be discussed in details in \ref{data} + +This is an example of a monitor used as safe(ish) counter for concurrency. This API, which offers the prefix increment operator and a conversion operator to \code{int}, guarantees that reading the value (by converting it to \code{int}) and incrementing it are mutually exclusive. Note that the \code{is_zero} routine uses the \code{nomutex} keyword. Indeed, since reading the value is already atomic, there is no point in maintaining the mutual exclusion once the value is copied locally (in the variable \code{val} ). + +Having both \code{mutex} and \code{nomutex} keywords could be argued to be redundant based on the meaning of a routine having neither of these keywords. If there were a meaning to routine \code{void foo(counter_t & this)} then one could argue that it should be to default to the safest option : \code{mutex}. On the other hand, the option of having routine \code{void foo(counter_t & this)} mean \code{nomutex} is unsafe by default and may easily cause subtle errors. It can be argued that this is the more "normal" behavior, \code{nomutex} effectively stating explicitly that "this routine has nothing special". An other alternative is to make one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routine \code{void foo(counter_t & this)}. Mandatory keywords would also have the added benefice of being more clearly self-documented but at the cost of extra typing. In the end, which solution should be picked is still up for debate. For the reminder of this proposal, the explicit approach will be used for the sake of clarity. + +Regardless of which keyword is kept, it is important to establish when mutex/nomutex may be used depending on type parameters. +\begin{lstlisting} + int f01(monitor & mutex m); + int f02(const monitor & mutex m); + int f03(monitor * mutex m); + int f04(monitor * mutex * m); + int f05(monitor ** mutex m); + int f06(monitor[10] mutex m); + int f07(monitor[] mutex m); + int f08(vector(monitor) & mutex m); + int f09(list(monitor) & mutex m); + int f10([monitor*, int] & mutex m); + int f11(graph(monitor*) & mutex m); +\end{lstlisting} + +For the first few routines it seems to make sense to support the mutex keyword for such small variations. The difference between pointers and reference (\code{f01} vs \code{f03}) or const and non-const (\code{f01} vs \code{f02}) has no significance to mutual exclusion. It may not always make sense to acquire the monitor when extra dereferences (\code{f04}, \code{f05}) are added but it is still technically feasible and the present of the explicit mutex keywork does make it very clear of the user's intentions. Passing in a known-sized array(\code{f06}) is also technically feasible but is close to the limits. Indeed, the size of the array is not actually enforced by the compiler and if replaced by a variable-sized array (\code{f07}) or a higher-level container (\code{f08}, \code{f09}) it becomes much more complex to properly acquire all the locks needed for such a complex critical section. This implicit acquisition also poses the question of what qualifies as a container. If the mutex keyword is supported on monitors stored inside of other types it can quickly become complex and unclear which monitor should be acquired and when. The extreme example of this is \code{f11} which takes a possibly cyclic graph of pointers to monitors. With such a routine signature the intuition of which monitors will be acquired on entry is lost\cite{Chicken}. Where to draw the lines is up for debate but it seems reasonnable to consider \code{f03} as accepted and \code{f06} as rejected. + +\subsection{Data semantics} \label{data} +Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contian shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appripriate protection. For example here is a more fleshed-out version of the counter showed in \ref{call}: +\begin{lstlisting} + mutex struct counter_t { + int value; + }; + + void ?{}(counter_t & mutex this) { + this.cnt = 0; + } + + int ++?(counter_t & mutex this) { + return ++this->value; + } + + void ?{}(int * this, counter_t & mutex cnt) { + *this = (int)cnt; + } +\end{lstlisting} +\begin{tabular}{ c c } +Thread 1 & Thread 2 \\ +\begin{lstlisting} + void main(counter_t & mutex c) { + for(;;) { + int count = c; + sout | count | endl; + } + } +\end{lstlisting} &\begin{lstlisting} + void main(counter_t & mutex c) { + for(;;) { + ++c; + } + } + +\end{lstlisting} +\end{tabular} +\\ + + +This simple counter offers an example of monitor usage. Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting. \\ + +These simple mutual exclusion semantics also naturally expand to multi-monitor calls. +\begin{lstlisting} + int f(MonitorA & mutex a, MonitorB & mutex b); + + MonitorA a; + MonitorB b; + f(a,b); +\end{lstlisting} + +This code acquires both locks before entering the critical section. In practice, writing multi-locking routines that can lead to deadlocks can be very tricky. Having language level support for such feature is therefore a significant asset for \CFA. However, as the this proposal shows, this does have significant repercussions relating to scheduling (see \ref{insched} and \ref{extsched}). The ability to acquire multiple monitors at the same time does incur a significant pitfall even without looking into scheduling. For example : +\begin{lstlisting} + void foo(A & mutex a, B & mutex a) { + //... + } + + void bar(A & mutex a, B & nomutex a) + //... + foo(a, b); + //... + } + + void baz(A & nomutex a, B & mutex a) + //... + foo(a, b); + //... + } +\end{lstlisting} + +TODO: dig further into monitor order aquiring + +Thoughs : calls to \code{baz} and \code{bar} are definitely incompatible because they explicitly acquire locks in reverse order and therefore are explicitly asking for a deadlock. The best that can be done in this situatuin is to detect the deadlock. The case of implicit ordering is less clear because in the case of monitors the runtime system \textit{may} be smart enough to figure out that someone is waiting with explicit ordering... maybe. + +\subsubsection{Internal scheduling} \label{insched} +Monitors should also be able to schedule what threads access it as a mean of synchronization. Internal scheduling is one of the simple examples of such a feature. It allows users to declare condition variables and wait for them to be signaled. Here is a simple example of such a technique : + +\begin{lstlisting} + mutex struct A { + condition e; + } + + void foo(A & mutex a) { + //... + wait(a.e); + //... + } + + void bar(A & mutex a) { + signal(a.e); + } +\end{lstlisting} + +Here routine \code{foo} waits on the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering. This can easily be extended to multi-monitor calls by offering the same guarantee. + +\begin{center} +\begin{tabular}{ c @{\hskip 0.65in} c } +Thread 1 & Thread 2 \\ +\begin{lstlisting} +void foo(monitor & mutex a, + monitor & mutex b) { + //... + wait(a.e); + //... +} + +foo(a, b); +\end{lstlisting} &\begin{lstlisting} +void bar(monitor & mutex a, + monitor & mutex b) { + signal(a.e); +} + + + +bar(a, b); +\end{lstlisting} +\end{tabular} +\end{center} + +A direct extension of the single monitor semantics would be to release all locks when waiting and transferring ownership of all locks when signalling. However, for the purpose of synchronization it may be usefull to only release some of the locks but keep others. On the technical side, partially releasing lock is feasible but from the user perspective a choice must be made for the syntax of this feature. It is possible to do without any extra syntax by relying on order of acquisition : + +\begin{center} +\begin{tabular}{|c|c|c|} +Context 1 & Context 2 & Context 3 \\ +\hline +\begin{lstlisting} +void foo(monitor & mutex a, + monitor & mutex b) { + wait(a.e); +} + + + + + + +foo(a,b); +\end{lstlisting} &\begin{lstlisting} +void bar(monitor & mutex a, + monitor & nomutex b) { + foo(a,b); +} + +void foo(monitor & mutex a, + monitor & mutex b) { + wait(a.e); +} + +bar(a, b); +\end{lstlisting} &\begin{lstlisting} +void bar(monitor & mutex a, + monitor & nomutex b) { + foo(a,b); +} + +void baz(monitor & nomutex a, + monitor & mutex b) { + wait(a.e); +} + +bar(a, b); +\end{lstlisting} +\end{tabular} +\end{center} + +This can be interpreted in two different ways : +\begin{enumerate} + \item \code{wait} atomically releases the monitors \underline{theoretically} acquired by the inner-most mutex routine. + \item \code{wait} atomically releases the monitors \underline{actually} acquired by the inner-most mutex routine. +\end{enumerate} +While the difference between these two is subtle, it has a significant impact. In the first case it means that the calls to \code{foo} would behave the same in Context 1 and 2. This semantic would also mean that the call to \code{wait} in routine \code{baz} would only release \code{monitor b}. While this may seem intuitive with these examples, it does have one significant implication, it creates a strong distinction between acquiring multiple monitors in sequence and acquiring the same monitors simulatenously. + +\begin{center} +\begin{tabular}{c @{\hskip 0.35in} c @{\hskip 0.35in} c} +\begin{lstlisting} +enterMonitor(a); +enterMonitor(b); +// do stuff +leaveMonitor(b); +leaveMonitor(a); +\end{lstlisting} & != &\begin{lstlisting} +enterMonitor(a); +enterMonitor(a, b); +// do stuff +leaveMonitor(a, b); +leaveMonitor(a); +\end{lstlisting} +\end{tabular} +\end{center} + +This is not intuitive because even if both methods will display the same monitors state both inside and outside the critical section respectively, the behavior is different. Furthermore, the actual acquiring order will be exaclty the same since acquiring a monitor from inside its mutual exclusion is a no-op. This means that even if the data and the actual control flow are the same using both methods, the behavior of the \code{wait} will be different. The alternative is option 2, that is releasing \underline{actually} acquired monitors. This solves the issue of having the two acquiring method differ at the cost of making routine \code{foo} behave differently depending on from which context it is called (Context 1 or 2). Indeed in Context 2, routine \code{foo} will actually behave like routine \code{baz} rather than having the same behavior than in context 1. The fact that both implicit approaches can be unintuitive depending on the perspective may be a sign that the explicit approach is superior. +\\ + +The following examples shows three alternatives of explicit wait semantics : +\\ + +\begin{center} +\begin{tabular}{|c|c|c|} +Case 1 & Case 2 & Case 3 \\ +Branding on construction & Explicit release list & Explicit ignore list \\ +\hline +\begin{lstlisting} +void foo(monitor & mutex a, + monitor & mutex b, + condition & c) +{ + // Releases monitors + // branded in ctor + wait(c); +} + +monitor a; +monitor b; +condition1 c1 = {a}; +condition2 c2 = {a, b}; + +//Will release only a +foo(a,b,c1); + +//Will release a and b +foo(a,b,c2); +\end{lstlisting} &\begin{lstlisting} +void foo(monitor & mutex a, + monitor & mutex b, + condition & c) +{ + // Releases monitor a + // Holds monitor b + waitRelease(c, [a]); +} + +monitor a; +monitor b; +condition c; + + + +foo(a,b,c); + + + +\end{lstlisting} &\begin{lstlisting} +void foo(monitor & mutex a, + monitor & mutex b, + condition & c) +{ + // Releases monitor a + // Holds monitor b + waitHold(c, [b]); +} + +monitor a; +monitor b; +condition c; + + + +foo(a,b,c); + + + +\end{lstlisting} +\end{tabular} +\end{center} +(Note : Case 2 and 3 use tuple semantics to pass a variable length list of elements.) +\\ + +All these cases have there pros and cons. Case 1 is more distinct because it means programmers need to be carefull about where the condition was initialized as well as where it is used. On the other hand, it is very clear and explicit which monitor will be released and which monitor will stay acquired. This is similar to Case 2, which releases only the monitors explictly listed. However, in Case 2, calling the \code{wait} routine instead of the \code{waitRelease} routine will release all the acquired monitor. The Case 3 is an improvement on that since it releases all the monitors except those specified. The result is that the \code{wait} routine can be written as follows : +\begin{lstlisting} +void wait(condition & cond) { + waitHold(cond, []); +} +\end{lstlisting} +This alternative offers nice and consistent behavior between \code{wait} and \code{waitHold}. However, one large pitfall is that mutual exclusion can now be violated by calls to library code. Indeed, even if the following example seems benign there is one significant problem : +\begin{lstlisting} +extern void doStuff(); + +void foo(monitor & mutex m) { + //... + doStuff(); //warning can release monitor m + //... +} +\end{lstlisting} + +Indeed, if Case 2 or 3 are chosen it any code can violate the mutual exclusion of calling code by issuing calls to \code{wait} or \code{waitHold} in a nested monitor context. Case 2 can be salvaged by removing the \code{wait} routine from the API but Case 3 cannot prevent users from calling \code{waitHold(someCondition, [])}. For this reason the syntax proposed in Case 3 is rejected. Note that syntaxes proposed in case 1 and 2 are not exclusive. Indeed, by supporting two types of condition as follows both cases can be supported : +\begin{lstlisting} +struct condition { /*...*/ }; + +// Second argument is a variable length tuple. +void wait(condition & cond, [...] monitorsToRelease); +void signal(condition & cond); + +struct conditionN { /*...*/ }; + +void ?{}(conditionN* this, /*list of N monitors to release*/); +void wait(conditionN & cond); +void signal(conditionN & cond); +\end{lstlisting} + +Regardless of the option chosen for wait semantics, signal must be symmetrical. In all cases, signal only needs a single parameter, the condition variable that needs to be signalled. But \code{signal} needs to be called from the same monitor(s) than the call to \code{wait}. Otherwise, mutual exclusion cannot be properly transferred back to the waiting monitor. + +Finally, an additionnal semantic which can be very usefull is the \code{signalBlock} routine. This routine behaves like signal for all of the semantics discussed above, but with the subtelty that mutual exclusion is transferred to the waiting task immediately rather than wating for the end of the critical section. + +\subsection{External scheduling} \label{extsched} +As one might expect, the alternative to Internal scheduling is to use External scheduling instead. This method is somewhat more robust to deadlocks since one of the threads keeps a relatively tight control on scheduling. Indeed, as the following examples will demontrate, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (see \uC) or in terms of data (see Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where chosen to stay consistent with the reset of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling which is loose object definitions and multi-monitor routines. The following example shows what a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages. + +\begin{center} +\begin{tabular}{|c|c|} +Internal Scheduling & External Scheduling \\ +\hline +\begin{lstlisting} + _Monitor blarg { + condition c; + public: + void f(); + void g() { signal} + void h() { wait(c); } + private: + } +\end{lstlisting}&\begin{lstlisting} + _Monitor blarg { + + public: + void f(); + void g(); + void h() { _Accept(g); } + private: + } +\end{lstlisting} +\end{tabular} +\end{center} + +In the case of internal scheduling, the call to \code{wait} only guarantees that \code{g} was the last routine to access the monitor. This intails that the routine \code{f} may have acquired mutual exclusion several times while routine \code{h} was waiting. On the other hand, external scheduling guarantees that while routine \code{h} was waiting, no routine other than \code{g} could acquire the monitor. + +\subsubsection{Loose object definitions} +In \uC monitor definitions include an exhaustive list of monitor operations. Since \CFA is not an object oriented it becomes much more difficult to implement but also much less clear for the user : + +\begin{lstlisting} + mutex struct A {}; + + void f(A & mutex a); + void g(A & mutex a); + void h(A & mutex a) { accept(g); } +\end{lstlisting} + +While this is the direct translation of the \uC code, at the time of compiling routine \code{f} the \CFA does not already have a declaration of \code{g} while the \uC compiler does. This means that either the compiler has to dynamically find which routines are "acceptable" or the language needs a way of statically listing "acceptable" routines. Since \CFA has no existing concept that resemble dynamic routine definitions or pattern matching, the static approach seems the more consistent with the current language paradigms. This approach leads to the \uC example being translated to : +\begin{lstlisting} + accept( void g(mutex struct A & mutex a) ) + mutex struct A {}; + + void f(A & mutex a) { accept(g); } + void g(A & mutex a); +\end{lstlisting} + +This syntax is the most consistent with the language since it somewhat mimics the \code{forall} declarations. However, the fact that it comes before the struct declaration does means the type needs to be forward declared (done inline in the example). Here are a few alternatives to this syntax : \\ +\begin{tabular}[t]{l l} +Alternative 1 & Alternative 2 \\ +\begin{lstlisting} +mutex struct A +accept( void g(A & mutex a) ) +{}; +\end{lstlisting} &\begin{lstlisting} +mutex struct A {} +accept( void g(A & mutex a) ); + +\end{lstlisting} \\ +Alternative 3 & Alternative 4 \\ +\begin{lstlisting} +mutex struct A { + accept( void g(A & mutex a) ) +}; + +\end{lstlisting} &\begin{lstlisting} +mutex struct A { + accept : + void g(A & mutex a) ); +}; +\end{lstlisting} +\end{tabular} + + +An other aspect to consider is what happens if multiple overloads of the same routine are used. For the time being it is assumed that multiple overloads of the same routine should be scheduled regardless of the overload used. However, this could easily be extended in the future. + +\subsubsection{Multi-monitor scheduling} + +External scheduling, like internal scheduling, becomes orders of magnitude more complex when we start introducing multi-monitor syntax. Even in the simplest possible case some new semantics need to be established : +\begin{lstlisting} + accept( void f(mutex struct A & mutex this)) + mutex struct A {}; + + mutex struct B {}; + + void g(A & mutex a, B & mutex b) { + accept(f); //ambiguous, which monitor + } +\end{lstlisting} + +The obvious solution is to specify the correct monitor as follows : + +\begin{lstlisting} + accept( void f(mutex struct A & mutex this)) + mutex struct A {}; + + mutex struct B {}; + + void g(A & mutex a, B & mutex b) { + accept( f, b ); + } +\end{lstlisting} + +This is unambiguous. The both locks will be acquired and kept, when routine \code{f} is called the lock for monitor \code{a} will be temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{b}). This behavior can be extended to multi-monitor accept statment as follows. + +\begin{lstlisting} + accept( void f(mutex struct A & mutex, mutex struct A & mutex)) + mutex struct A {}; + + mutex struct B {}; + + void g(A & mutex a, B & mutex b) { + accept( f, b, a ); + } +\end{lstlisting} + +Note that the set of monitors passed to the \code{accept} statement must be entirely contained in the set of monitor already acquired in the routine. \code{accept} used in any other context is Undefined Behaviour. + +\subsection{Implementation Details} +\textbf{\large{Work in progress...}} +\subsubsection{Interaction with polymorphism} +At first glance, interaction between monitors and \CFA's concept of polymorphism seem complexe to support. However, it can be reasoned that entry-point locking can solve most of the issues that could be present with polymorphism. + +First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore the main question is how to support \code{dtype} polymorphism. We must remember that monitors' main purpose is to ensure mutual exclusion when accessing shared data. This implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handle incomplete types (by definition) no \code{dtype} polymorphic routine can access shared data since the data would require knowledge about the type. Therefore the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. With callsite-locking, this would require significant amount of work since any \code{dtype} routine could have to obtain some lock before calling a routine. However, with entry-point-locking calling a monitor routine becomes exactly the same as calling it from anywhere else. + +\subsubsection{External scheduling queues} +To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they most be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects gut that is a reasonnable contraint. This algorithm choice has two consequences, the ofthe highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probably that half the multi-monitor queues will go unused for the entire duration of the program. + +\subsection{Other concurrency tools} + +\section{Parallelism} +Historically, computer performance was about processor speeds and instructions count. However, with heat dissipaction being an ever growing challenge, parallelism has become the new source of greatest performance \cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable create high-performance application without caring about parallelism. Indeed, parallelism an important aspect of performance and more specifically throughput and hardware utilization. The lowest level approach parallelism is to use \glspl{kthread}. However since these have significant costs and limitations, \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues which all have strengths and weaknesses. + +\subsection{User-level threads} +A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This is the most powerfull solution as it allows all the features of multi-threading while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading complexities are hidden, users still have to think about data races, deadlocks and synchronization issues. This can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself. + +Examples of languages that support are Java\cite{Java}, Haskell\cite{Haskell} and \uC\cite{uC++book}. + +\subsection{Jobs and thread pools} +The opposite approach is to base parallelism on \glspl{job}. Indeed, \glspl{job} offer limited flexibility but at the benefit of a simpler user interface. In \gls{job} based systems users express parallelism as units of work and the dependency graph (either explicit or implicit) that tie them together. This means users need not to worry about concurrency but significantly limits the interaction that can occur between different jobs. Indeed, any \gls{job} that blocks also blocks the underlying \gls{kthread}, this effectively mean the CPU utilization, and therefore throughput, will suffer noticeably. The golden standard of this implementation is Intel's TBB library\cite{TBB}. + +\subsection{Fibers : user-level threads without preemption} +Finally, in the middle of the flexibility versus complexity spectrum lay \glspl{fiber} which offer \glspl{uthread} without the complexity of preemption. This means users don't have to worry about other \glspl{fiber} suddenly executing between two instructions which signficantly reduces complexity. However, any call to IO or other concurrency primitives can lead to context switches. Furthermore, users can also block \glspl{fiber} in the middle of their execution without blocking a full processor core. This means users still have to worry about mutual exclusion, deadlocks and race conditions in their code, raising the complexity significantly. +\cite{Go} + +\subsection{Paradigm performance} +While the choice between the three paradigms listed above can have significant performance implication, it is difficult to pin the performance implications of chosing a model at the language level. Indeed, in many situations own of these paradigms will show better performance but it all depends on the usage. +Having mostly indepent units of work to execute almost guarantess that the \gls{job} based system will have the best performance. However, add interactions between jobs and the processor utilisation might suffer. User-level threads may allow maximum ressource utilisation but context switches will be more expansive and it is also harder for users to get perfect tunning. As with every example, fibers sit somewhat in the middle of the spectrum. + +\section{Parallelism in \CFA} +As a system level language, \CFA should offer both performance and flexibilty as its primary goals, simplicity and user-friendliness being a secondary concern. Therefore, the core of parallelism in \CFA should prioritize power and efficiency. + +\subsection{Kernel core}\label{kernel} +At the ro +\subsubsection{Threads} +\CFA threads have all the caracteristiques of + +\subsection{High-level options}\label{tasks} + +\subsubsection{Thread interface} +constructors destructors + initializer lists +monitors + +\subsubsection{Futures} + +\subsubsection{Implicit threading} +Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level. + +\begin{center} +\begin{tabular}[t]{|c|c|c|} +Sequential & System Parallel & Language Parallel \\ +\begin{lstlisting} +void big_sum(int* a, int* b, + int* out, + size_t length) +{ + for(int i = 0; i < length; ++i ) { + out[i] = a[i] + b[i]; + } +} + + + + + +int* a[10000]; +int* b[10000]; +int* c[10000]; +//... fill in a and b ... +big_sum(a, b, c, 10000); +\end{lstlisting} &\begin{lstlisting} +void big_sum(int* a, int* b, + int* out, + size_t length) +{ + range ar(a, a + length); + range br(b, b + length); + range or(out, out + length); + parfor( ai, bi, oi, + [](int* ai, int* bi, int* oi) { + oi = ai + bi; + }); +} + +int* a[10000]; +int* b[10000]; +int* c[10000]; +//... fill in a and b ... +big_sum(a, b, c, 10000); +\end{lstlisting}&\begin{lstlisting} +void big_sum(int* a, int* b, + int* out, + size_t length) +{ + for (ai, bi, oi) in (a, b, out) { + oi = ai + bi; + } +} + + + + + +int* a[10000]; +int* b[10000]; +int* c[10000]; +//... fill in a and b ... +big_sum(a, b, c, 10000); +\end{lstlisting} +\end{tabular} +\end{center} + +\subsection{Machine setup}\label{machine} +Threads are all good and well but wee still some OS support to fully utilize available hardware. + +\textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads? + +\section{Future work} +Concurrency and parallelism is still a very active field that strongly benefits from hardware advances. As such certain features that aren't necessarily mature enough in their current state could become relevant in the lifetime of \CFA. +\subsection{Transactions} + +\section*{Acknowledgements} + +\clearpage +\printglossary + +\clearpage +\bibliographystyle{plain} +\bibliography{pl,local} + + +\end{document} Index: doc/proposals/concurrency/glossary.tex =================================================================== --- doc/proposals/concurrency/glossary.tex (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) +++ doc/proposals/concurrency/glossary.tex (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -0,0 +1,32 @@ +\makeglossaries +\longnewglossaryentry{uthread} +{name={user-level thread}} +{ +Threads created and managed inside user-space. Each thread has its own stack and its own thread of execution. User-level threads are insisible to the underlying operating system. + +\textit{Synonyms : User threads, Lightweight threads, Green threads, Virtual threads, Tasks.} +} + +\longnewglossaryentry{kthread} +{name={kernel-level thread}} +{ +Threads created and managed inside kernel-space. Each thread has its own stack and its own thread of execution. Kernel-level threads are owned, managed and scheduled by the underlying operating system. + +\textit{Synonyms : OS threads, Hardware threads, Physical threads.} +} + +\longnewglossaryentry{fiber} +{name={fiber}} +{ +Fibers are non-preemptive user-level threads. They share most of the caracteristics of user-level threads except that they cannot be preempted by an other fiber. + +\textit{Synonyms : Tasks.} +} + +\longnewglossaryentry{job} +{name={job}} +{ +Unit of work, often send to a thread pool or worker pool to be executed. Has neither its own stack or its own thread of execution. + +\textit{Synonyms : Tasks.} +} Index: doc/proposals/concurrency/local.bib =================================================================== --- doc/proposals/concurrency/local.bib (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) +++ doc/proposals/concurrency/local.bib (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -0,0 +1,40 @@ +% Predefined journal names: +% acmcs: Computing Surveys acta: Acta Infomatica +% cacm: Communications of the ACM +% ibmjrd: IBM J. Research & Development ibmsj: IBM Systems Journal +% ieeese: IEEE Trans. on Soft. Eng. ieeetc: IEEE Trans. on Computers +% ieeetcad: IEEE Trans. on Computer-Aided Design of Integrated Circuits +% ipl: Information Processing Letters jacm: Journal of the ACM +% jcss: J. Computer & System Sciences scp: Science of Comp. Programming +% sicomp: SIAM J. on Computing tocs: ACM Trans. on Comp. Systems +% tods: ACM Trans. on Database Sys. tog: ACM Trans. on Graphics +% toms: ACM Trans. on Math. Software toois: ACM Trans. on Office Info. Sys. +% toplas: ACM Trans. on Prog. Lang. & Sys. +% tcs: Theoretical Computer Science +@string{ieeepds="IEEE Transactions on Parallel and Distributed Systems"} +@string{ieeese="IEEE Transactions on Software Engineering"} +@string{spe="Software---\-Practice and Experience"} +@string{sigplan="SIGPLAN Notices"} +@string{joop="Journal of Object-Oriented Programming"} +@string{popl="Conference Record of the ACM Symposium on Principles of Programming Languages"} +@string{osr="Operating Systems Review"} +@string{pldi="Programming Language Design and Implementation"} + + +@article{HPP:Study, + keywords = {Parallel, Productivity}, + author = {Lorin Hochstein and Jeff Carver and Forrest Shull and Sima Asgari and Victor Basili and Jeffrey K. Hollingsworth and Marvin V. Zelkowitz }, + title = {Parallel Programmer Productivity: A Case Study of Novice Parallel Programmers}, +} + +@article{Chicken, + keywords = {Chicken}, + author = {Doug Zongker}, + title = {Chicken Chicken Chicken: Chicken Chicken}, + year = 2006 +} + +@article{TBB, + keywords = {Intel, TBB}, + title = {Intel Thread Building Blocks}, +} Index: src/Common/DebugMalloc.cc =================================================================== --- src/Common/DebugMalloc.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) +++ src/Common/DebugMalloc.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -0,0 +1,71 @@ +#if 0 +#include +#include +#include + +bool recursion = false; + +static char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; + +static union { + void *addr; + unsigned char bytes[sizeof(void *)]; +}; + +struct Mallocmsg { + const char start[9]; + char addr[16]; + const char sep[3]; + char size[16]; + const char end[1]; +} mallocmsg = { + 'm', 'a', 'l', 'l', 'o', 'c', ' ', '0', 'x', + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ' ', '0', 'x', + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + '\n' +}; + +void * malloc( size_t size ) { + if ( recursion ) { write( STDERR_FILENO, "recursion\n", 10 ); abort(); } + recursion = true; + __typeof__( ::malloc ) *libc_malloc = (__typeof__( ::malloc ) *)dlsym(RTLD_NEXT, "malloc"); + addr = (void *)size; + for ( int i = 0, j = 7; i < 16; i += 2, j -= 1 ) { + mallocmsg.size[i] = hex[bytes[j] >> 4]; + mallocmsg.size[i + 1] = hex[bytes[j] & 0x0f]; + } // for + addr = libc_malloc( size ); + for ( int i = 0, j = 7; i < 16; i += 2, j -= 1 ) { + mallocmsg.addr[i] = hex[bytes[j] >> 4]; + mallocmsg.addr[i + 1] = hex[bytes[j] & 0x0f]; + } // for + write( STDERR_FILENO, &mallocmsg, sizeof(mallocmsg) ); + recursion = false; + return addr; +} + +struct Freemsg { + const char start[7]; + char addr[16]; + const char end[1]; +} freemsg = { + 'f', 'r', 'e', 'e', ' ', '0', 'x', + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + '\n' +}; + +void free( void * x ) { + if ( recursion ) { write( STDERR_FILENO, "recursion\n", 10 ); abort(); } + recursion = true; + __typeof__( ::free ) *libc_free = (__typeof__( ::free ) *)dlsym(RTLD_NEXT, "free"); + addr = x; + for ( int i = 0, j = 7; i < 16; i += 2, j -= 1 ) { + freemsg.addr[i] = hex[bytes[j] >> 4]; + freemsg.addr[i + 1] = hex[bytes[j] & 0x0f]; + } // for + write( STDERR_FILENO, &freemsg, sizeof(freemsg) ); + recursion = false; + libc_free( addr ); +} +#endif // 0 Index: src/Common/SemanticError.h =================================================================== --- src/Common/SemanticError.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Common/SemanticError.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jun 8 14:38:53 2015 -// Update Count : 4 +// Last Modified On : Sat Sep 24 15:13:42 2016 +// Update Count : 5 // @@ -46,5 +46,4 @@ } - #endif // SEMANTICERROR_H Index: src/Common/module.mk =================================================================== --- src/Common/module.mk (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Common/module.mk (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -11,9 +11,10 @@ ## Created On : Mon Jun 1 17:49:17 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Thu Aug 18 13:29:04 2016 -## Update Count : 2 +## Last Modified On : Tue Sep 27 11:06:38 2016 +## Update Count : 4 ############################################################################### SRC += Common/SemanticError.cc \ Common/UniqueName.cc \ + Common/DebugMalloc.cc \ Common/Assert.cc Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Common/utility.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jun 8 17:33:59 2016 -// Update Count : 22 +// Last Modified On : Fri Sep 23 11:46:47 2016 +// Update Count : 28 // @@ -25,4 +25,5 @@ #include #include +#include template< typename T > @@ -101,15 +102,4 @@ } // if } // for -} - -static inline std::string assign_strptr( const std::string *str ) { - if ( str == 0 ) { - return ""; - } else { - std::string tmp; - tmp = *str; - delete str; - return tmp; - } // if } @@ -141,10 +131,10 @@ template < typename T > -void toString_single ( std::ostream & os, const T & value ) { +void toString_single( std::ostream & os, const T & value ) { os << value; } template < typename T, typename... Params > -void toString_single ( std::ostream & os, const T & value, const Params & ... params ) { +void toString_single( std::ostream & os, const T & value, const Params & ... params ) { os << value; toString_single( os, params ... ); @@ -152,5 +142,5 @@ template < typename ... Params > -std::string toString ( const Params & ... params ) { +std::string toString( const Params & ... params ) { std::ostringstream os; toString_single( os, params... ); Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Makefile.am (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -11,6 +11,6 @@ ## Created On : Sun May 31 08:51:46 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Sat Aug 20 11:13:12 2016 -## Update Count : 71 +## Last Modified On : Sat Sep 24 15:03:52 2016 +## Update Count : 73 ############################################################################### @@ -40,5 +40,5 @@ cfa_cpplib_PROGRAMS = driver/cfa-cpp driver_cfa_cpp_SOURCES = ${SRC} -driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap +driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Makefile.in (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -98,4 +98,5 @@ Common/driver_cfa_cpp-SemanticError.$(OBJEXT) \ Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \ + Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) \ Common/driver_cfa_cpp-Assert.$(OBJEXT) \ ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT) \ @@ -358,5 +359,6 @@ CodeGen/CodeGenerator.cc CodeGen/GenType.cc \ CodeGen/FixNames.cc CodeGen/OperatorTable.cc \ - Common/SemanticError.cc Common/UniqueName.cc Common/Assert.cc \ + Common/SemanticError.cc Common/UniqueName.cc \ + Common/DebugMalloc.cc Common/Assert.cc \ ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \ ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \ @@ -412,5 +414,5 @@ cfa_cpplibdir = ${libdir} driver_cfa_cpp_SOURCES = ${SRC} -driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap +driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include all: $(BUILT_SOURCES) @@ -512,4 +514,6 @@ Common/$(DEPDIR)/$(am__dirstamp) Common/driver_cfa_cpp-UniqueName.$(OBJEXT): Common/$(am__dirstamp) \ + Common/$(DEPDIR)/$(am__dirstamp) +Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \ Common/$(DEPDIR)/$(am__dirstamp) Common/driver_cfa_cpp-Assert.$(OBJEXT): Common/$(am__dirstamp) \ @@ -784,4 +788,5 @@ -rm -f CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT) -rm -f Common/driver_cfa_cpp-Assert.$(OBJEXT) + -rm -f Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) -rm -f Common/driver_cfa_cpp-SemanticError.$(OBJEXT) -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT) @@ -889,4 +894,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/driver_cfa_cpp-OperatorTable.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@ @@ -1125,4 +1131,18 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-UniqueName.obj `if test -f 'Common/UniqueName.cc'; then $(CYGPATH_W) 'Common/UniqueName.cc'; else $(CYGPATH_W) '$(srcdir)/Common/UniqueName.cc'; fi` +Common/driver_cfa_cpp-DebugMalloc.o: Common/DebugMalloc.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc + +Common/driver_cfa_cpp-DebugMalloc.obj: Common/DebugMalloc.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.obj -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi` + Common/driver_cfa_cpp-Assert.o: Common/Assert.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-Assert.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo -c -o Common/driver_cfa_cpp-Assert.o `test -f 'Common/Assert.cc' || echo '$(srcdir)/'`Common/Assert.cc Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/DeclarationNode.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Sep 14 23:13:28 2016 -// Update Count : 502 +// Last Modified On : Mon Oct 3 18:03:08 2016 +// Update Count : 651 // @@ -31,13 +31,13 @@ // These must remain in the same order as the corresponding DeclarationNode enumerations. -const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" }; -const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" }; -const char *DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" }; -const char *DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" }; -const char *DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" }; -const char *DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" }; -const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" }; -const char *DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" }; -const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" }; +const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" }; +const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" }; +const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" }; +const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" }; +const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" }; +const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" }; +const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" }; +const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" }; +const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" }; UniqueName DeclarationNode::anonymous( "__anonymous" ); @@ -46,16 +46,19 @@ DeclarationNode::DeclarationNode() : - type( 0 ), + type( nullptr ), storageClass( NoStorageClass ), isInline( false ), isNoreturn( false ), - bitfieldWidth( 0 ), - initializer( 0 ), + bitfieldWidth( nullptr ), + initializer( nullptr ), hasEllipsis( false ), linkage( ::linkage ), extension( false ) { - variable.tyClass = DeclarationNode::Otype; + +// variable.name = nullptr; + variable.tyClass = NoTypeClass; variable.assertions = nullptr; +// attr.name = nullptr; attr.expr = nullptr; attr.type = nullptr; @@ -63,6 +66,11 @@ DeclarationNode::~DeclarationNode() { +// delete attr.name; delete attr.expr; delete attr.type; + +// delete variable.name; + delete variable.assertions; + delete type; delete bitfieldWidth; @@ -70,8 +78,8 @@ } -DeclarationNode *DeclarationNode::clone() const { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::clone() const { + DeclarationNode * newnode = new DeclarationNode; newnode->type = maybeClone( type ); - newnode->name = name; + newnode->name = name ? new string( *name ) : nullptr; newnode->storageClass = storageClass; newnode->isInline = isInline; @@ -83,8 +91,9 @@ newnode->linkage = linkage; +// newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr; + newnode->variable.tyClass = variable.tyClass; newnode->variable.assertions = maybeClone( variable.assertions ); - newnode->variable.name = variable.name; - newnode->variable.tyClass = variable.tyClass; - + +// newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr; newnode->attr.expr = maybeClone( attr.expr ); newnode->attr.type = maybeClone( attr.type ); @@ -98,12 +107,12 @@ void DeclarationNode::print( std::ostream &os, int indent ) const { os << string( indent, ' ' ); - if ( name == "" ) { + if ( name ) { + os << *name << ": "; + } else { os << "unnamed: "; - } else { - os << name << ": "; } // if if ( linkage != LinkageSpec::Cforall ) { - os << LinkageSpec::toString( linkage ) << " "; + os << LinkageSpec::linkageName( linkage ) << " "; } // if @@ -122,5 +131,5 @@ } // if - if ( initializer != 0 ) { + if ( initializer ) { os << endl << string( indent + 2, ' ' ) << "with initializer "; initializer->printOneLine( os ); @@ -139,13 +148,15 @@ } -DeclarationNode *DeclarationNode::newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); - +DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->name = name; newnode->type = new TypeData( TypeData::Function ); newnode->type->function.params = param; newnode->type->function.newStyle = newStyle; newnode->type->function.body = body; - typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID ); + // ignore unnamed routine declarations: void p( int (*)(int) ); + if ( newnode->name ) { + typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID ); + } // if if ( body ) { @@ -155,5 +166,5 @@ if ( ret ) { newnode->type->base = ret->type; - ret->type = 0; + ret->type = nullptr; delete ret; } // if @@ -163,5 +174,5 @@ DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData(); newnode->type->qualifiers[ q ] = 1; @@ -169,6 +180,6 @@ } // DeclarationNode::newQualifier -DeclarationNode * DeclarationNode::newForall( DeclarationNode *forall ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Unknown ); newnode->type->forall = forall; @@ -177,10 +188,5 @@ DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { - DeclarationNode *newnode = new DeclarationNode; - //switch (sc) { - // case Inline: newnode->isInline = true; break; - // case Noreturn: newnode->isNoreturn = true; break; - // default: newnode->storageClass = sc; break; - //} + DeclarationNode * newnode = new DeclarationNode; newnode->storageClass = sc; return newnode; @@ -188,5 +194,5 @@ DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); newnode->type->basictype = bt; @@ -195,5 +201,5 @@ DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); newnode->type->complextype = ct; @@ -202,5 +208,5 @@ DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); newnode->type->signedness = sn; @@ -209,5 +215,5 @@ DeclarationNode * DeclarationNode::newLength( Length lnth ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); newnode->type->length = lnth; @@ -215,20 +221,21 @@ } // DeclarationNode::newLength -DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newFromTypedef( string * name ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::SymbolicInst ); - newnode->type->symbolic.name = assign_strptr( name ); + newnode->type->symbolic.name = name; newnode->type->symbolic.isTypedef = true; - newnode->type->symbolic.params = 0; + newnode->type->symbolic.params = nullptr; return newnode; } // DeclarationNode::newFromTypedef -DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Aggregate ); newnode->type->aggregate.kind = kind; - newnode->type->aggregate.name = assign_strptr( name ); - if ( newnode->type->aggregate.name == "" ) { // anonymous aggregate ? - newnode->type->aggregate.name = anonymous.newName(); + if ( name ) { + newnode->type->aggregate.name = name; + } else { // anonymous aggregate ? + newnode->type->aggregate.name = new string( anonymous.newName() ); } // if newnode->type->aggregate.actuals = actuals; @@ -238,11 +245,11 @@ } // DeclarationNode::newAggregate -DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Enum ); - newnode->type->enumeration.name = newnode->name; - if ( newnode->type->enumeration.name == "" ) { // anonymous enumeration ? - newnode->type->enumeration.name = DeclarationNode::anonymous.newName(); + if ( name ) { + newnode->type->enumeration.name = name; + } else { // anonymous aggregate ? + newnode->type->enumeration.name = new string( anonymous.newName() ); } // if newnode->type->enumeration.constants = constants; @@ -250,22 +257,22 @@ } // DeclarationNode::newEnum -DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newEnumConstant( string * name, ExpressionNode * constant ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->name = name; newnode->enumeratorValue.reset( constant ); - typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID ); + typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID ); return newnode; } // DeclarationNode::newEnumConstant -DeclarationNode *DeclarationNode::newName( std::string *name ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newName( string * name ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->name = name; return newnode; } // DeclarationNode::newName -DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newFromTypeGen( string * name, ExpressionNode * params ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::SymbolicInst ); - newnode->type->symbolic.name = assign_strptr( name ); + newnode->type->symbolic.name = name; newnode->type->symbolic.isTypedef = false; newnode->type->symbolic.actuals = params; @@ -273,55 +280,56 @@ } // DeclarationNode::newFromTypeGen -DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); - newnode->type = new TypeData( TypeData::Variable ); +DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, string * name ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = nullptr; + assert( ! newnode->name ); +// newnode->variable.name = name; + newnode->name = name; newnode->variable.tyClass = tc; - newnode->variable.name = newnode->name; + newnode->variable.assertions = nullptr; return newnode; } // DeclarationNode::newTypeParam -DeclarationNode *DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newTrait( const string * name, DeclarationNode * params, DeclarationNode * asserts ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Aggregate ); + newnode->type->aggregate.name = name; newnode->type->aggregate.kind = Trait; newnode->type->aggregate.params = params; newnode->type->aggregate.fields = asserts; - newnode->type->aggregate.name = assign_strptr( name ); return newnode; } // DeclarationNode::newTrait -DeclarationNode *DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newTraitUse( const string * name, ExpressionNode * params ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::AggregateInst ); newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate ); newnode->type->aggInst.aggregate->aggregate.kind = Trait; - newnode->type->aggInst.aggregate->aggregate.name = assign_strptr( name ); + newnode->type->aggInst.aggregate->aggregate.name = name; newnode->type->aggInst.params = params; return newnode; } // DeclarationNode::newTraitUse -DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Symbolic ); newnode->type->symbolic.isTypedef = false; newnode->type->symbolic.params = typeParams; - newnode->type->symbolic.name = newnode->name; + newnode->type->symbolic.name = name; return newnode; } // DeclarationNode::newTypeDecl -DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Pointer ); return newnode->addQualifiers( qualifiers ); } // DeclarationNode::newPointer -DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Array ); newnode->type->array.dimension = size; newnode->type->array.isStatic = isStatic; - if ( newnode->type->array.dimension == 0 || newnode->type->array.dimension->isExpressionType() ) { + if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType() ) { newnode->type->array.isVarLen = false; } else { @@ -331,8 +339,8 @@ } // DeclarationNode::newArray -DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newVarArray( DeclarationNode * qualifiers ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Array ); - newnode->type->array.dimension = 0; + newnode->type->array.dimension = nullptr; newnode->type->array.isStatic = false; newnode->type->array.isVarLen = true; @@ -340,12 +348,12 @@ } -DeclarationNode *DeclarationNode::newBitfield( ExpressionNode *size ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newBitfield( ExpressionNode * size ) { + DeclarationNode * newnode = new DeclarationNode; newnode->bitfieldWidth = size; return newnode; } -DeclarationNode *DeclarationNode::newTuple( DeclarationNode *members ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newTuple( DeclarationNode * members ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Tuple ); newnode->type->tuple = members; @@ -353,6 +361,6 @@ } -DeclarationNode *DeclarationNode::newTypeof( ExpressionNode *expr ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Typeof ); newnode->type->typeexpr = expr; @@ -361,5 +369,5 @@ DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Builtin ); newnode->builtin = bt; @@ -367,16 +375,18 @@ } // DeclarationNode::newBuiltinType -DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Attr ); - newnode->attr.name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newAttr( string * name, ExpressionNode * expr ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = nullptr; +// newnode->attr.name = name; + newnode->name = name; newnode->attr.expr = expr; return newnode; } -DeclarationNode *DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) { - DeclarationNode *newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Attr ); - newnode->attr.name = assign_strptr( name ); +DeclarationNode * DeclarationNode::newAttr( string * name, DeclarationNode * type ) { + DeclarationNode * newnode = new DeclarationNode; + newnode->type = nullptr; +// newnode->attr.name = name; + newnode->name = name; newnode->attr.type = type; return newnode; @@ -389,5 +399,5 @@ } // appendError -void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) { +void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) { TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization @@ -401,5 +411,5 @@ } // DeclarationNode::checkQualifiers -void DeclarationNode::checkStorageClasses( DeclarationNode *q ) { +void DeclarationNode::checkStorageClasses( DeclarationNode * q ) { if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) { if ( storageClass == q->storageClass ) { // duplicate qualifier @@ -413,5 +423,5 @@ } // DeclarationNode::copyStorageClasses -DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) { +DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) { isInline = isInline || q->isInline; isNoreturn = isNoreturn || q->isNoreturn; @@ -424,5 +434,5 @@ } // DeclarationNode::copyStorageClasses -static void addQualifiersToType( TypeData *&src, TypeData *dst ) { +static void addQualifiersToType( TypeData *&src, TypeData * dst ) { if ( src->forall && dst->kind == TypeData::Function ) { if ( dst->forall ) { @@ -431,5 +441,5 @@ dst->forall = src->forall; } // if - src->forall = 0; + src->forall = nullptr; } // if if ( dst->base ) { @@ -437,5 +447,5 @@ } else if ( dst->kind == TypeData::Function ) { dst->base = src; - src = 0; + src = nullptr; } else { dst->qualifiers |= src->qualifiers; @@ -443,15 +453,19 @@ } // addQualifiersToType -DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) { - if ( ! q ) return this; +DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode * q ) { + if ( ! q ) { delete q; return this; } checkStorageClasses( q ); copyStorageClasses( q ); - if ( ! q->type ) { delete q; return this; } + if ( ! q->type ) { + delete q; + return this; + } // if if ( ! type ) { -// type = new TypeData; - type = q->type; + type = q->type; // reuse this structure + q->type = nullptr; + delete q; return this; } // if @@ -467,10 +481,10 @@ type->aggregate.params = q->type->forall; // change implicit typedef from TYPEDEFname to TYPEGENname - typedefTable.changeKind( type->aggregate.name, TypedefTable::TG ); + typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG ); } else { type->forall = q->type->forall; } // if } // if - q->type->forall = 0; + q->type->forall = nullptr; } // if delete q; @@ -485,5 +499,5 @@ dst->forall = src->forall; } // if - src->forall = 0; + src->forall = nullptr; } // if if ( dst->base ) { @@ -494,5 +508,5 @@ src->qualifiers |= dst->qualifiers; dst = src; - src = 0; + src = nullptr; break; case TypeData::Basic: @@ -504,15 +518,15 @@ dst->basictype = src->basictype; } else if ( src->basictype != DeclarationNode::NoBasicType ) - throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src ); if ( dst->complextype == DeclarationNode::NoComplexType ) { dst->complextype = src->complextype; } else if ( src->complextype != DeclarationNode::NoComplexType ) - throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src ); if ( dst->signedness == DeclarationNode::NoSignedness ) { dst->signedness = src->signedness; } else if ( src->signedness != DeclarationNode::NoSignedness ) - throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src ); if ( dst->length == DeclarationNode::NoLength ) { @@ -521,5 +535,5 @@ dst->length = DeclarationNode::LongLong; } else if ( src->length != DeclarationNode::NoLength ) - throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src ); + throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src ); } // if break; @@ -534,5 +548,5 @@ } // if dst->base->qualifiers |= src->qualifiers; - src = 0; + src = nullptr; break; default: @@ -542,7 +556,7 @@ dst->forall = src->forall; } // if - src->forall = 0; + src->forall = nullptr; dst->base = src; - src = 0; + src = nullptr; } // switch } // switch @@ -550,5 +564,5 @@ } -DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) { +DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) { if ( o ) { checkStorageClasses( o ); @@ -566,5 +580,5 @@ type = o->type; } // if - o->type = 0; + o->type = nullptr; } else { addTypeToType( o->type, type ); @@ -584,9 +598,9 @@ } -DeclarationNode *DeclarationNode::addTypedef() { - TypeData *newtype = new TypeData( TypeData::Symbolic ); - newtype->symbolic.params = 0; +DeclarationNode * DeclarationNode::addTypedef() { + TypeData * newtype = new TypeData( TypeData::Symbolic ); + newtype->symbolic.params = nullptr; newtype->symbolic.isTypedef = true; - newtype->symbolic.name = name; + newtype->symbolic.name = name ? new string( *name ) : nullptr; newtype->base = type; type = newtype; @@ -594,5 +608,14 @@ } -DeclarationNode *DeclarationNode::addAssertions( DeclarationNode *assertions ) { +DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) { + if ( variable.tyClass != NoTypeClass ) { + if ( variable.assertions ) { + variable.assertions->appendList( assertions ); + } else { + variable.assertions = assertions; + } // if + return this; + } // if + assert( type ); switch ( type->kind ) { @@ -604,11 +627,4 @@ } // if break; - case TypeData::Variable: - if ( variable.assertions ) { - variable.assertions->appendList( assertions ); - } else { - variable.assertions = assertions; - } // if - break; default: assert( false ); @@ -618,15 +634,16 @@ } -DeclarationNode *DeclarationNode::addName( std::string *newname ) { - name = assign_strptr( newname ); - return this; -} - -DeclarationNode *DeclarationNode::addBitfield( ExpressionNode *size ) { +DeclarationNode * DeclarationNode::addName( string * newname ) { + assert( ! name ); + name = newname; + return this; +} + +DeclarationNode * DeclarationNode::addBitfield( ExpressionNode * size ) { bitfieldWidth = size; return this; } -DeclarationNode *DeclarationNode::addVarArgs() { +DeclarationNode * DeclarationNode::addVarArgs() { assert( type ); hasEllipsis = true; @@ -634,8 +651,8 @@ } -DeclarationNode *DeclarationNode::addFunctionBody( StatementNode *body ) { +DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body ) { assert( type ); assert( type->kind == TypeData::Function ); - assert( type->function.body == 0 ); + assert( ! type->function.body ); type->function.body = body; type->function.hasBody = true; @@ -643,17 +660,17 @@ } -DeclarationNode *DeclarationNode::addOldDeclList( DeclarationNode *list ) { +DeclarationNode * DeclarationNode::addOldDeclList( DeclarationNode * list ) { assert( type ); assert( type->kind == TypeData::Function ); - assert( type->function.oldDeclList == 0 ); + assert( ! type->function.oldDeclList ); type->function.oldDeclList = list; return this; } -static void setBase( TypeData *&type, TypeData *newType ) { +static void setBase( TypeData *&type, TypeData * newType ) { if ( type ) { - TypeData *prevBase = type; - TypeData *curBase = type->base; - while ( curBase != 0 ) { + TypeData * prevBase = type; + TypeData * curBase = type->base; + while ( curBase != nullptr ) { prevBase = curBase; curBase = curBase->base; @@ -665,9 +682,9 @@ } -DeclarationNode *DeclarationNode::addPointer( DeclarationNode *p ) { +DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) { if ( p ) { assert( p->type->kind == TypeData::Pointer ); setBase( type, p->type ); - p->type = 0; + p->type = nullptr; delete p; } // if @@ -675,9 +692,9 @@ } -DeclarationNode *DeclarationNode::addArray( DeclarationNode *a ) { +DeclarationNode * DeclarationNode::addArray( DeclarationNode * a ) { if ( a ) { assert( a->type->kind == TypeData::Array ); setBase( type, a->type ); - a->type = 0; + a->type = nullptr; delete a; } // if @@ -685,5 +702,5 @@ } -DeclarationNode *DeclarationNode::addNewPointer( DeclarationNode *p ) { +DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) { if ( p ) { assert( p->type->kind == TypeData::Pointer ); @@ -703,5 +720,5 @@ p->type->base = type; } // switch - type = 0; + type = nullptr; } // if delete this; @@ -712,7 +729,7 @@ } -static TypeData *findLast( TypeData *a ) { +static TypeData * findLast( TypeData * a ) { assert( a ); - TypeData *cur = a; + TypeData * cur = a; while ( cur->base ) { cur = cur->base; @@ -721,8 +738,8 @@ } -DeclarationNode *DeclarationNode::addNewArray( DeclarationNode *a ) { +DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) { if ( a ) { assert( a->type->kind == TypeData::Array ); - TypeData *lastArray = findLast( a->type ); + TypeData * lastArray = findLast( a->type ); if ( type ) { switch ( type->kind ) { @@ -739,5 +756,5 @@ lastArray->base = type; } // switch - type = 0; + type = nullptr; } // if delete this; @@ -748,6 +765,6 @@ } -DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) { - TypeData *ftype = new TypeData( TypeData::Function ); +DeclarationNode * DeclarationNode::addParamList( DeclarationNode * params ) { + TypeData * ftype = new TypeData( TypeData::Function ); ftype->function.params = params; setBase( type, ftype ); @@ -755,5 +772,5 @@ } -static TypeData *addIdListToType( TypeData *type, DeclarationNode *ids ) { +static TypeData * addIdListToType( TypeData * type, DeclarationNode * ids ) { if ( type ) { if ( type->kind != TypeData::Function ) { @@ -764,134 +781,96 @@ return type; } else { - TypeData *newtype = new TypeData( TypeData::Function ); + TypeData * newtype = new TypeData( TypeData::Function ); newtype->function.idList = ids; return newtype; } // if -} - -DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) { +} // addIdListToType + +DeclarationNode * DeclarationNode::addIdList( DeclarationNode * ids ) { type = addIdListToType( type, ids ); return this; } -DeclarationNode *DeclarationNode::addInitializer( InitializerNode *init ) { - //assert +DeclarationNode * DeclarationNode::addInitializer( InitializerNode * init ) { initializer = init; return this; } -DeclarationNode *DeclarationNode::cloneBaseType( string *newName ) { - DeclarationNode *newnode = new DeclarationNode; - TypeData *srcType = type; - while ( srcType->base ) { - srcType = srcType->base; - } // while - newnode->type = maybeClone( srcType ); - if ( newnode->type->kind == TypeData::AggregateInst ) { - // don't duplicate members - if ( newnode->type->aggInst.aggregate->kind == TypeData::Enum ) { - delete newnode->type->aggInst.aggregate->enumeration.constants; - newnode->type->aggInst.aggregate->enumeration.constants = 0; - } else { - assert( newnode->type->aggInst.aggregate->kind == TypeData::Aggregate ); - delete newnode->type->aggInst.aggregate->aggregate.fields; - newnode->type->aggInst.aggregate->aggregate.fields = 0; - } // if - } // if - newnode->type->forall = maybeClone( type->forall ); - assert( storageClass == NoStorageClass ); - newnode->copyStorageClasses( this ); - newnode->name = assign_strptr( newName ); - return newnode; -} - -DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) { - if ( o ) { - o->copyStorageClasses( this ); - if ( type ) { - TypeData *srcType = type; - while ( srcType->base ) { - srcType = srcType->base; - } // while - TypeData *newType = srcType->clone(); - if ( newType->kind == TypeData::AggregateInst ) { - // don't duplicate members - if ( newType->aggInst.aggregate->kind == TypeData::Enum ) { - delete newType->aggInst.aggregate->enumeration.constants; - newType->aggInst.aggregate->enumeration.constants = 0; - } else { - assert( newType->aggInst.aggregate->kind == TypeData::Aggregate ); - delete newType->aggInst.aggregate->aggregate.fields; - newType->aggInst.aggregate->aggregate.fields = 0; - } // if - } // if - newType->forall = maybeClone( type->forall ); - if ( ! o->type ) { - o->type = newType; - } else { - addTypeToType( newType, o->type ); - delete newType; - } // if - } // if - } // if - return o; -} - -DeclarationNode *DeclarationNode::cloneType( string *newName ) { - DeclarationNode *newnode = new DeclarationNode; +DeclarationNode * DeclarationNode::cloneType( string * newName ) { + DeclarationNode * newnode = new DeclarationNode; newnode->type = maybeClone( type ); assert( storageClass == NoStorageClass ); newnode->copyStorageClasses( this ); - newnode->name = assign_strptr( newName ); - return newnode; -} - -DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) { - if ( o ) { - assert( storageClass == NoStorageClass ); - o->copyStorageClasses( this ); - if ( type ) { - TypeData *newType = type->clone(); - if ( ! o->type ) { - o->type = newType; + assert( newName ); + newnode->name = newName; + return newnode; +} + +DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) { + if ( ! o ) return nullptr; + + o->copyStorageClasses( this ); + if ( type ) { + TypeData * srcType = type; + + while ( srcType->base ) { + srcType = srcType->base; + } // while + + TypeData * newType = srcType->clone(); + if ( newType->kind == TypeData::AggregateInst ) { + // don't duplicate members + if ( newType->aggInst.aggregate->kind == TypeData::Enum ) { + delete newType->aggInst.aggregate->enumeration.constants; + newType->aggInst.aggregate->enumeration.constants = nullptr; } else { - addTypeToType( newType, o->type ); - delete newType; + assert( newType->aggInst.aggregate->kind == TypeData::Aggregate ); + delete newType->aggInst.aggregate->aggregate.fields; + newType->aggInst.aggregate->aggregate.fields = nullptr; } // if } // if - } // if - delete o; + + newType->forall = maybeClone( type->forall ); + if ( ! o->type ) { + o->type = newType; + } else { + addTypeToType( newType, o->type ); + delete newType; + } // if + } // if return o; } -DeclarationNode *DeclarationNode::extractAggregate() const { +DeclarationNode * DeclarationNode::extractAggregate() const { if ( type ) { - TypeData *ret = typeextractAggregate( type ); + TypeData * ret = typeextractAggregate( type ); if ( ret ) { - DeclarationNode *newnode = new DeclarationNode; + DeclarationNode * newnode = new DeclarationNode; newnode->type = ret; return newnode; } // if } // if - return 0; -} - -void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) { + return nullptr; +} + +void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList ) { SemanticError errors; std::back_insert_iterator< std::list< Declaration * > > out( outputList ); - const DeclarationNode *cur = firstNode; + const DeclarationNode * cur = firstNode; + while ( cur ) { try { - if ( DeclarationNode *extr = cur->extractAggregate() ) { + if ( DeclarationNode * extr = cur->extractAggregate() ) { // handle the case where a structure declaration is contained within an object or type declaration - Declaration *decl = extr->build(); + Declaration * decl = extr->build(); if ( decl ) { - *out++ = decl; + * out++ = decl; } // if delete extr; } // if - Declaration *decl = cur->build(); + + Declaration * decl = cur->build(); if ( decl ) { - *out++ = decl; + * out++ = decl; } // if } catch( SemanticError &e ) { @@ -900,26 +879,27 @@ cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); } // while + if ( ! errors.isEmpty() ) { throw errors; } // if -} - -void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ) { +} // buildList + +void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) { SemanticError errors; std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList ); - const DeclarationNode *cur = firstNode; + const DeclarationNode * cur = firstNode; while ( cur ) { try { - Declaration *decl = cur->build(); + Declaration * decl = cur->build(); if ( decl ) { - if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { - *out++ = dwt; - } else if ( StructDecl *agg = dynamic_cast< StructDecl * >( decl ) ) { - StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() ); - *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 ); + if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { + * out++ = dwt; + } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) { + StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() ); + * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr ); delete agg; - } else if ( UnionDecl *agg = dynamic_cast< UnionDecl * >( decl ) ) { - UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() ); - *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 ); + } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) { + UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() ); + * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr ); } // if } // if @@ -932,13 +912,14 @@ throw errors; } // if -} - -void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ) { +} // buildList + +void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ) { SemanticError errors; std::back_insert_iterator< std::list< Type * > > out( outputList ); - const DeclarationNode *cur = firstNode; + const DeclarationNode * cur = firstNode; + while ( cur ) { try { - *out++ = cur->buildType(); + * out++ = cur->buildType(); } catch( SemanticError &e ) { errors.append( e ); @@ -946,44 +927,59 @@ cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); } // while + if ( ! errors.isEmpty() ) { throw errors; } // if -} - -Declaration *DeclarationNode::build() const { +} // buildTypeList + +Declaration * DeclarationNode::build() const { if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this ); + +// if ( variable.name ) { + if ( variable.tyClass != NoTypeClass ) { + static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; +// TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] ); + TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] ); + buildList( variable.assertions, ret->get_assertions() ); + return ret; + } // if + if ( type ) { - if ( type->kind == TypeData::Variable ) { - static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; - TypeDecl * ret = new TypeDecl( variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ variable.tyClass ] ); - buildList( variable.assertions, ret->get_assertions() ); - return ret; - } else { - return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension ); - } // if - } // if + return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension ); + } // if + if ( ! isInline && ! isNoreturn ) { - return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension ); - } // if + assertf( name, "ObjectDecl are assumed to have names\n" ); + return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_extension( extension ); + } // if + throw SemanticError( "invalid function specifier ", this ); } -Type *DeclarationNode::buildType() const { +Type * DeclarationNode::buildType() const { assert( type ); + + if ( attr.expr ) { +// return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() ); + return new AttrType( buildQualifiers( type ), *name, attr.expr->build() ); + } else if ( attr.type ) { +// return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() ); + return new AttrType( buildQualifiers( type ), *name, attr.type->buildType() ); + } // if switch ( type->kind ) { case TypeData::Enum: - return new EnumInstType( buildQualifiers( type ), type->enumeration.name ); + return new EnumInstType( buildQualifiers( type ), *type->enumeration.name ); case TypeData::Aggregate: { - ReferenceToType *ret; + ReferenceToType * ret; switch ( type->aggregate.kind ) { case DeclarationNode::Struct: - ret = new StructInstType( buildQualifiers( type ), type->aggregate.name ); + ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name ); break; case DeclarationNode::Union: - ret = new UnionInstType( buildQualifiers( type ), type->aggregate.name ); + ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name ); break; case DeclarationNode::Trait: - ret = new TraitInstType( buildQualifiers( type ), type->aggregate.name ); + ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name ); break; default: @@ -994,18 +990,6 @@ } case TypeData::Symbolic: { - TypeInstType *ret = new TypeInstType( buildQualifiers( type ), type->symbolic.name, false ); + TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false ); buildList( type->symbolic.actuals, ret->get_parameters() ); - return ret; - } - case TypeData::Attr: { - assert( type->kind == TypeData::Attr ); - // assert( type->attr ); - AttrType * ret; - if ( attr.expr ) { - ret = new AttrType( buildQualifiers( type ), attr.name, attr.expr->build() ); - } else { - assert( attr.type ); - ret = new AttrType( buildQualifiers( type ), attr.name, attr.type->buildType() ); - } // if return ret; } Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/ExpressionNode.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 25 21:39:40 2016 -// Update Count : 503 +// Last Modified On : Fri Sep 16 16:27:44 2016 +// Update Count : 508 // @@ -31,6 +31,4 @@ using namespace std; - -ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.get_name() ), extension( other.extension ) {} //############################################################################## Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/InitializerNode.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:20:24 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 15 18:27:02 2016 -// Update Count : 20 +// Last Modified On : Sat Oct 1 23:09:51 2016 +// Update Count : 21 // @@ -23,5 +23,5 @@ InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des ) - : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { + : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { if ( aggrp ) kids = dynamic_cast< InitializerNode * >( get_next() ); @@ -32,5 +32,5 @@ InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des ) - : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { + : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { if ( init != 0 ) set_last( init ); @@ -79,9 +79,5 @@ Initializer *InitializerNode::build() const { - // if ( get_expression() == 0 ) return 0; // XXX (?) - if ( aggregate ) { - //assert( next_init() != 0 ); - std::list< Initializer * > initlist; buildList< Initializer, InitializerNode >( next_init(), initlist ); Index: src/Parser/LinkageSpec.cc =================================================================== --- src/Parser/LinkageSpec.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/LinkageSpec.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:22:09 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Aug 21 12:32:53 2016 -// Update Count : 17 +// Last Modified On : Sun Oct 2 23:16:21 2016 +// Update Count : 23 // @@ -17,21 +17,22 @@ #include #include +using namespace std; #include "LinkageSpec.h" #include "Common/SemanticError.h" -LinkageSpec::Spec LinkageSpec::fromString( const std::string &spec ) { - std::unique_ptr guard(&spec); // allocated by lexer - if ( spec == "\"Cforall\"" ) { +LinkageSpec::Spec LinkageSpec::linkageCheck( const string * spec ) { + unique_ptr guard( spec ); // allocated by lexer + if ( *spec == "\"Cforall\"" ) { return Cforall; - } else if ( spec == "\"C\"" ) { + } else if ( *spec == "\"C\"" ) { return C; } else { - throw SemanticError( "Invalid linkage specifier " + spec ); + throw SemanticError( "Invalid linkage specifier " + *spec ); } // if } -std::string LinkageSpec::toString( LinkageSpec::Spec linkage ) { - assert( linkage >= 0 && linkage < LinkageSpec::NoOfSpecs ); +string LinkageSpec::linkageName( LinkageSpec::Spec linkage ) { + assert( 0 <= linkage && linkage < LinkageSpec::NoOfSpecs ); static const char *linkageKinds[LinkageSpec::NoOfSpecs] = { "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in", @@ -41,5 +42,5 @@ bool LinkageSpec::isDecoratable( Spec spec ) { - assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs ); + assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs ); static bool decoratable[LinkageSpec::NoOfSpecs] = { // Intrinsic, Cforall, C, AutoGen, Compiler @@ -50,5 +51,5 @@ bool LinkageSpec::isGeneratable( Spec spec ) { - assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs ); + assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs ); static bool generatable[LinkageSpec::NoOfSpecs] = { // Intrinsic, Cforall, C, AutoGen, Compiler Index: src/Parser/LinkageSpec.h =================================================================== --- src/Parser/LinkageSpec.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/LinkageSpec.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:24:28 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Aug 20 19:22:23 2016 -// Update Count : 8 +// Last Modified On : Sat Oct 1 23:03:17 2016 +// Update Count : 11 // @@ -29,6 +29,6 @@ }; - static Spec fromString( const std::string & ); - static std::string toString( Spec ); + static Spec linkageCheck( const std::string * ); + static std::string linkageName( Spec ); static bool isDecoratable( Spec ); Index: src/Parser/ParseNode.cc =================================================================== --- src/Parser/ParseNode.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/ParseNode.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:26:29 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Aug 17 23:14:16 2016 -// Update Count : 126 +// Last Modified On : Sat Oct 1 23:10:43 2016 +// Update Count : 127 // @@ -20,6 +20,6 @@ std::ostream & operator<<( std::ostream & out, const ParseNode * node ) { - node->print( out ); - return out; + node->print( out ); + return out; } Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/ParseNode.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 12 08:00:05 2016 -// Update Count : 603 +// Last Modified On : Mon Oct 3 18:03:08 2016 +// Update Count : 636 // @@ -41,31 +41,27 @@ public: ParseNode() {}; - ParseNode( const std::string * name ) : name( * name ) { assert( false ); delete name; } - ParseNode( const std::string &name ) : name( name ) { assert( false ); } - virtual ~ParseNode() { delete next; }; + virtual ~ParseNode() { delete next; delete name; }; virtual ParseNode * clone() const = 0; ParseNode * get_next() const { return next; } ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; } + ParseNode * get_last() { ParseNode * current; - for ( current = this; current->get_next() != 0; current = current->get_next() ); + for ( current = this; current->get_next() != nullptr; current = current->get_next() ); return current; } ParseNode * set_last( ParseNode * newlast ) { - if ( newlast != 0 ) get_last()->set_next( newlast ); + if ( newlast != nullptr ) get_last()->set_next( newlast ); return this; } - - const std::string &get_name() const { return name; } - void set_name( const std::string &newValue ) { name = newValue; } virtual void print( std::ostream &os, int indent = 0 ) const {} virtual void printList( std::ostream &os, int indent = 0 ) const {} - private: + static int indent_by; ParseNode * next = nullptr; - std::string name; + std::string * name = nullptr; }; // ParseNode @@ -74,6 +70,6 @@ class InitializerNode : public ParseNode { public: - InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = 0 ); - InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0 ); + InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr ); + InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr ); ~InitializerNode(); virtual InitializerNode * clone() const { assert( false ); return nullptr; } @@ -106,5 +102,4 @@ public: ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {} - ExpressionNode( Expression * expr, const std::string * name ) : ParseNode( name ), expr( expr ) {} ExpressionNode( const ExpressionNode &other ); virtual ~ExpressionNode() {} @@ -183,5 +178,5 @@ Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ); Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ); -Expression * build_tuple( ExpressionNode * expr_node = 0 ); +Expression * build_tuple( ExpressionNode * expr_node = nullptr ); Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ); Expression * build_range( ExpressionNode * low, ExpressionNode * high ); @@ -203,6 +198,6 @@ enum Signedness { Signed, Unsigned, NoSignedness }; enum Length { Short, Long, LongLong, NoLength }; - enum Aggregate { Struct, Union, Trait }; - enum TypeClass { Otype, Dtype, Ftype }; + enum Aggregate { Struct, Union, Trait, NoAggregate }; + enum TypeClass { Otype, Dtype, Ftype, NoTypeClass }; enum BuiltinType { Valist }; @@ -219,5 +214,5 @@ static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false ); static DeclarationNode * newQualifier( Qualifier ); - static DeclarationNode * newForall( DeclarationNode *); + static DeclarationNode * newForall( DeclarationNode * ); static DeclarationNode * newStorageClass( StorageClass ); static DeclarationNode * newBasicType( BasicType ); @@ -226,13 +221,13 @@ static DeclarationNode * newLength( Length lnth ); static DeclarationNode * newBuiltinType( BuiltinType ); - static DeclarationNode * newFromTypedef( std::string *); + static DeclarationNode * newFromTypedef( std::string * ); static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants ); static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant ); - static DeclarationNode * newName( std::string *); + static DeclarationNode * newName( std::string * ); static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params ); - static DeclarationNode * newTypeParam( TypeClass, std::string *); - static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts ); - static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params ); + static DeclarationNode * newTypeParam( TypeClass, std::string * ); + static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts ); + static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params ); static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams ); static DeclarationNode * newPointer( DeclarationNode * qualifiers ); @@ -249,12 +244,12 @@ DeclarationNode * clone() const; - DeclarationNode * addQualifiers( DeclarationNode *); + DeclarationNode * addQualifiers( DeclarationNode * ); void checkQualifiers( const TypeData *, const TypeData * ); - void checkStorageClasses( DeclarationNode *q ); - DeclarationNode * copyStorageClasses( DeclarationNode *); - DeclarationNode * addType( DeclarationNode *); + void checkStorageClasses( DeclarationNode * ); + DeclarationNode * copyStorageClasses( DeclarationNode * ); + DeclarationNode * addType( DeclarationNode * ); DeclarationNode * addTypedef(); - DeclarationNode * addAssertions( DeclarationNode *); - DeclarationNode * addName( std::string *); + DeclarationNode * addAssertions( DeclarationNode * ); + DeclarationNode * addName( std::string * ); DeclarationNode * addBitfield( ExpressionNode * size ); DeclarationNode * addVarArgs(); @@ -270,7 +265,4 @@ DeclarationNode * cloneType( std::string * newName ); - DeclarationNode * cloneType( DeclarationNode * existing ); - DeclarationNode * cloneType( int ) { return cloneType( ( std::string *)0 ); } - DeclarationNode * cloneBaseType( std::string * newName ); DeclarationNode * cloneBaseType( DeclarationNode * newdecl ); @@ -286,5 +278,4 @@ bool get_hasEllipsis() const; - const std::string &get_name() const { return name; } LinkageSpec::Spec get_linkage() const { return linkage; } DeclarationNode * extractAggregate() const; @@ -295,10 +286,7 @@ DeclarationNode * set_extension( bool exten ) { extension = exten; return this; } public: - // StorageClass buildStorageClass() const; - // bool buildFuncSpecifier( StorageClass key ) const; - struct Variable_t { +// const std::string * name; DeclarationNode::TypeClass tyClass; - std::string name; DeclarationNode * assertions; }; @@ -306,5 +294,5 @@ struct Attr_t { - std::string name; +// const std::string * name; ExpressionNode * expr; DeclarationNode * type; @@ -315,5 +303,4 @@ TypeData * type; - std::string name; StorageClass storageClass; bool isInline, isNoreturn; @@ -331,5 +318,4 @@ Type * buildType( TypeData * type ); -//Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers ); static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) { @@ -393,5 +379,5 @@ Statement * build_finally( StatementNode * stmt ); Statement * build_compound( StatementNode * first ); -Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0 ); +Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr ); //############################################################################## Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/TypeData.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 12 21:11:22 2016 -// Update Count : 377 +// Last Modified On : Sat Sep 24 11:14:26 2016 +// Update Count : 415 // @@ -24,6 +24,7 @@ #include "SynTree/Statement.h" #include "SynTree/Initializer.h" - -TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) { +using namespace std; + +TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) { switch ( kind ) { case Unknown: @@ -37,5 +38,5 @@ case Array: // array = new Array_t; - array.dimension = 0; + array.dimension = nullptr; array.isVarLen = false; array.isStatic = false; @@ -43,8 +44,8 @@ case Function: // function = new Function_t; - function.params = 0; - function.idList = 0; - function.oldDeclList = 0; - function.body = 0; + function.params = nullptr; + function.idList = nullptr; + function.oldDeclList = nullptr; + function.body = nullptr; function.hasBody = false; function.newStyle = false; @@ -52,28 +53,26 @@ case Aggregate: // aggregate = new Aggregate_t; - aggregate.params = 0; - aggregate.actuals = 0; - aggregate.fields = 0; + aggregate.name = nullptr; + aggregate.params = nullptr; + aggregate.actuals = nullptr; + aggregate.fields = nullptr; break; case AggregateInst: // aggInst = new AggInst_t; - aggInst.aggregate = 0; - aggInst.params = 0; + aggInst.aggregate = nullptr; + aggInst.params = nullptr; break; case Enum: // enumeration = new Enumeration_t; - enumeration.constants = 0; + enumeration.name = nullptr; + enumeration.constants = nullptr; break; case Symbolic: case SymbolicInst: // symbolic = new Symbolic_t; - symbolic.params = 0; - symbolic.actuals = 0; - symbolic.assertions = 0; - break; - case Variable: - // variable = new Variable_t; - // variable.tyClass = DeclarationNode::Type; - // variable.assertions = 0; + symbolic.name = nullptr; + symbolic.params = nullptr; + symbolic.actuals = nullptr; + symbolic.assertions = nullptr; break; case Tuple: @@ -84,9 +83,4 @@ // typeexpr = new Typeof_t; typeexpr = nullptr; - break; - case Attr: - // attr = new Attr_t; - // attr.expr = nullptr; - // attr.type = nullptr; break; case Builtin: @@ -121,4 +115,5 @@ break; case Aggregate: + delete aggregate.name; delete aggregate.params; delete aggregate.actuals; @@ -132,4 +127,5 @@ break; case Enum: + delete enumeration.name; delete enumeration.constants; // delete enumeration; @@ -137,4 +133,5 @@ case Symbolic: case SymbolicInst: + delete symbolic.name; delete symbolic.params; delete symbolic.actuals; @@ -142,8 +139,4 @@ // delete symbolic; break; - case Variable: - // delete variable.assertions; - // delete variable; - break; case Tuple: // delete tuple->members; @@ -153,9 +146,4 @@ // delete typeexpr->expr; delete typeexpr; - break; - case Attr: - // delete attr.expr; - // delete attr.type; - // delete attr; break; case Builtin: @@ -197,8 +185,8 @@ break; case Aggregate: + newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr; newtype->aggregate.params = maybeClone( aggregate.params ); newtype->aggregate.actuals = maybeClone( aggregate.actuals ); newtype->aggregate.fields = maybeClone( aggregate.fields ); - newtype->aggregate.name = aggregate.name; newtype->aggregate.kind = aggregate.kind; newtype->aggregate.body = aggregate.body; @@ -209,20 +197,14 @@ break; case Enum: - newtype->enumeration.name = enumeration.name; + newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr; newtype->enumeration.constants = maybeClone( enumeration.constants ); break; case Symbolic: case SymbolicInst: + newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr; newtype->symbolic.params = maybeClone( symbolic.params ); newtype->symbolic.actuals = maybeClone( symbolic.actuals ); newtype->symbolic.assertions = maybeClone( symbolic.assertions ); newtype->symbolic.isTypedef = symbolic.isTypedef; - newtype->symbolic.name = symbolic.name; - break; - case Variable: - assert( false ); - // newtype->variable.assertions = maybeClone( variable.assertions ); - // newtype->variable.name = variable.name; - // newtype->variable.tyClass = variable.tyClass; break; case Tuple: @@ -231,9 +213,4 @@ case Typeof: newtype->typeexpr = maybeClone( typeexpr ); - break; - case Attr: - assert( false ); - // newtype->attr.expr = maybeClone( attr.expr ); - // newtype->attr.type = maybeClone( attr.type ); break; case Builtin: @@ -245,8 +222,5 @@ } // TypeData::clone -void TypeData::print( std::ostream &os, int indent ) const { - using std::endl; - using std::string; - +void TypeData::print( ostream &os, int indent ) const { for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) { if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' '; @@ -326,5 +300,5 @@ break; case Aggregate: - os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << aggregate.name << endl; + os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl; if ( aggregate.params ) { os << string( indent + 2, ' ' ) << "with type parameters " << endl; @@ -363,5 +337,5 @@ break; case SymbolicInst: - os << "instance of type " << symbolic.name; + os << "instance of type " << *symbolic.name; if ( symbolic.actuals ) { os << " with parameters" << endl; @@ -389,12 +363,4 @@ } // if break; - case Variable: - // os << DeclarationNode::typeClassName[ variable.tyClass ] << " variable "; - // if ( variable.assertions ) { - // os << endl << string( indent + 2, ' ' ) << "with assertions" << endl; - // variable.assertions->printList( os, indent + 4 ); - // os << string( indent + 2, ' ' ); - // } // if - break; case Tuple: os << "tuple "; @@ -409,13 +375,4 @@ typeexpr->print( os, indent + 2 ); } // if - break; - case Attr: - // os << "attribute type decl " << attr.name << " applied to "; - // if ( attr.expr ) { - // attr.expr->print( os, indent + 2 ); - // } // if - // if ( attr.type ) { - // attr.type->print( os, indent + 2 ); - // } // if break; case Builtin: @@ -437,24 +394,24 @@ // add dtor: void ^?{}(T *) FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false ); - dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) ); - td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, 0, false, false ) ); + dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) ); // add copy ctor: void ?{}(T *, T) FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false ); - copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) ); - copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) ); - td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, 0, false, false ) ); + copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) ); // add default ctor: void ?{}(T *) FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false ); - ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) ); - td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, 0, false, false ) ); + ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) ); // add assignment operator: T * ?=?(T *, T) FunctionType * assignType = new FunctionType( Type::Qualifiers(), false ); - assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0 ) ); - assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) ); - assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0 ) ); - td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) ); + assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); + assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); + td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) ); } // if } // for @@ -488,18 +445,14 @@ case TypeData::Builtin: return new VarArgsType( buildQualifiers( td ) ); - case TypeData::Attr: - assert( false ); - return buildAttr( td ); case TypeData::Symbolic: case TypeData::Enum: case TypeData::Aggregate: - case TypeData::Variable: assert( false ); } // switch - return 0; + return nullptr; } // typebuild TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) { - TypeData * ret = 0; + TypeData * ret = nullptr; switch ( td->kind ) { @@ -551,8 +504,8 @@ case DeclarationNode::Bool: if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); } // if if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); } // if @@ -567,5 +520,5 @@ if ( td->length != DeclarationNode::NoLength ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); } // if @@ -597,8 +550,8 @@ FloatingPoint: ; if ( td->signedness != DeclarationNode::NoSignedness ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); } // if if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) { - throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); } // if if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) { @@ -657,13 +610,13 @@ switch ( td->aggregate.kind ) { case DeclarationNode::Struct: - at = new StructDecl( td->aggregate.name ); + at = new StructDecl( *td->aggregate.name ); buildForall( td->aggregate.params, at->get_parameters() ); break; case DeclarationNode::Union: - at = new UnionDecl( td->aggregate.name ); + at = new UnionDecl( *td->aggregate.name ); buildForall( td->aggregate.params, at->get_parameters() ); break; case DeclarationNode::Trait: - at = new TraitDecl( td->aggregate.name ); + at = new TraitDecl( *td->aggregate.name ); buildList( td->aggregate.params, at->get_parameters() ); break; @@ -683,16 +636,17 @@ ReferenceToType * ret; if ( td->aggInst.aggregate->kind == TypeData::Enum ) { - ret = new EnumInstType( buildQualifiers( td ), td->aggInst.aggregate->enumeration.name ); + ret = new EnumInstType( buildQualifiers( td ), *td->aggInst.aggregate->enumeration.name ); } else { assert( td->aggInst.aggregate->kind == TypeData::Aggregate ); switch ( td->aggInst.aggregate->aggregate.kind ) { case DeclarationNode::Struct: - ret = new StructInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); + assert( td->aggInst.aggregate->aggregate.name ); + ret = new StructInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name ); break; case DeclarationNode::Union: - ret = new UnionInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); + ret = new UnionInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name ); break; case DeclarationNode::Trait: - ret = new TraitInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); + ret = new TraitInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name ); break; default: @@ -705,5 +659,5 @@ } // buildAggInst -NamedTypeDecl * buildSymbolic( const TypeData * td, const std::string & name, DeclarationNode::StorageClass sc ) { +NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) { assert( td->kind == TypeData::Symbolic ); NamedTypeDecl * ret; @@ -719,24 +673,13 @@ } // buildSymbolic -TypeDecl * buildVariable( const TypeData * td ) { - assert( false ); - return nullptr; - // assert( td->kind == TypeData::Variable ); - // static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; - - // TypeDecl * ret = new TypeDecl( td->variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable.tyClass ] ); - // buildList( td->variable.assertions, ret->get_assertions() ); - // return ret; -} // buildSymbolic - EnumDecl * buildEnum( const TypeData * td ) { assert( td->kind == TypeData::Enum ); - EnumDecl * ret = new EnumDecl( td->enumeration.name ); + EnumDecl * ret = new EnumDecl( *td->enumeration.name ); buildList( td->enumeration.constants, ret->get_members() ); - std::list< Declaration * >::iterator members = ret->get_members().begin(); + list< Declaration * >::iterator members = ret->get_members().begin(); for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) { if ( cur->has_enumeratorValue() ) { ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members); - member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), std::list< Expression * >() ) ); + member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) ); } // if } // for @@ -746,5 +689,5 @@ TypeInstType * buildSymbolicInst( const TypeData * td ) { assert( td->kind == TypeData::SymbolicInst ); - TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic.name, false ); + TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false ); buildList( td->symbolic.actuals, ret->get_parameters() ); buildForall( td->forall, ret->get_forall() ); @@ -767,20 +710,5 @@ } // buildTypeof -AttrType * buildAttr( const TypeData * td ) { - assert( false ); - return nullptr; - // assert( td->kind == TypeData::Attr ); - // // assert( td->attr ); - // AttrType * ret; - // if ( td->attr.expr ) { - // ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.expr->build() ); - // } else { - // assert( td->attr.type ); - // ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.type->buildType() ); - // } // if - // return ret; -} // buildAttr - -Declaration * buildDecl( const TypeData * td, std::string name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) { +Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) { if ( td->kind == TypeData::Function ) { FunctionDecl * decl; @@ -792,13 +720,13 @@ decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn ); } else { - // std::list< Label > ls; - decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( std::list< Label >() ), isInline, isNoreturn ); + // list< Label > ls; + decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( list< Label >() ), isInline, isNoreturn ); } // if } else { - decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), 0, isInline, isNoreturn ); - } // if - for ( DeclarationNode * cur = td->function.idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) { - if ( cur->get_name() != "" ) { - decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() ); + decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), nullptr, isInline, isNoreturn ); + } // if + for ( DeclarationNode * cur = td->function.idList; cur != nullptr; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) { + if ( cur->name ) { + decl->get_oldIdents().insert( decl->get_oldIdents().end(), *cur->name ); } // if } // for @@ -811,11 +739,8 @@ } else if ( td->kind == TypeData::Symbolic ) { return buildSymbolic( td, name, sc ); - } else if ( td->kind == TypeData::Variable ) { - assert( false ); - return buildVariable( td ); } else { - return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, std::list< Attribute * >(), isInline, isNoreturn ); + return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, list< Attribute * >(), isInline, isNoreturn ); } // if - return 0; + return nullptr; } // buildDecl @@ -833,8 +758,8 @@ break; default: - ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, 0, false, false, LinkageSpec::Cforall ) ) ); + ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall ) ) ); } // switch } else { - ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) ); + ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); } // if return ft; Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/TypeData.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 12 17:15:49 2016 -// Update Count : 129 +// Last Modified On : Mon Oct 3 12:34:08 2016 +// Update Count : 142 // @@ -23,12 +23,12 @@ struct TypeData { - enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst, - Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr }; + enum Kind { Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic, + SymbolicInst, Tuple, Typeof, Builtin, Unknown }; struct Aggregate_t { DeclarationNode::Aggregate kind; - std::string name; + const std::string * name; DeclarationNode * params; - ExpressionNode * actuals; // holds actual parameters later applied to AggInst + ExpressionNode * actuals; // holds actual parameters later applied to AggInst DeclarationNode * fields; bool body; @@ -47,5 +47,5 @@ struct Enumeration_t { - std::string name; + const std::string * name; DeclarationNode * constants; }; @@ -61,5 +61,5 @@ struct Symbolic_t { - std::string name; + const std::string * name; bool isTypedef; // false => TYPEGENname, true => TYPEDEFname DeclarationNode * params; @@ -88,5 +88,4 @@ DeclarationNode * tuple; ExpressionNode * typeexpr; - // Attr_t attr; // DeclarationNode::BuiltinType builtin; @@ -111,6 +110,5 @@ TupleType * buildTuple( const TypeData * ); TypeofType * buildTypeof( const TypeData * ); -AttrType * buildAttr( const TypeData * ); -Declaration * buildDecl( const TypeData *, std::string, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = 0 ); +Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = nullptr ); FunctionType * buildFunction( const TypeData * ); Index: src/Parser/parser.cc =================================================================== --- src/Parser/parser.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/parser.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -82,4 +82,5 @@ #include "TypeData.h" #include "LinkageSpec.h" +using namespace std; extern DeclarationNode * parseTree; @@ -87,7 +88,7 @@ extern TypedefTable typedefTable; -std::stack< LinkageSpec::Spec > linkageStack; - -void appendStr( std::string *to, std::string *from ) { +stack< LinkageSpec::Spec > linkageStack; + +void appendStr( string *to, string *from ) { // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string. to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) ); @@ -96,5 +97,5 @@ /* Line 268 of yacc.c */ -#line 99 "Parser/parser.cc" +#line 100 "Parser/parser.cc" /* Enabling traces. */ @@ -347,5 +348,5 @@ /* Line 293 of yacc.c */ -#line 115 "parser.yy" +#line 116 "parser.yy" Token tok; @@ -367,5 +368,5 @@ /* Line 293 of yacc.c */ -#line 370 "Parser/parser.cc" +#line 371 "Parser/parser.cc" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 @@ -379,5 +380,5 @@ /* Line 343 of yacc.c */ -#line 382 "Parser/parser.cc" +#line 383 "Parser/parser.cc" #ifdef short @@ -598,14 +599,14 @@ #define YYFINAL 250 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 10863 +#define YYLAST 10888 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 133 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 241 +#define YYNNTS 242 /* YYNRULES -- Number of rules. */ -#define YYNRULES 751 +#define YYNRULES 754 /* YYNRULES -- Number of states. */ -#define YYNSTATES 1555 +#define YYNSTATES 1558 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ @@ -666,77 +667,77 @@ 17, 19, 21, 23, 25, 27, 29, 31, 33, 36, 38, 40, 44, 48, 50, 57, 62, 66, 74, 78, - 86, 89, 92, 100, 105, 107, 111, 112, 114, 116, - 120, 122, 126, 134, 138, 146, 148, 150, 152, 155, - 158, 161, 164, 167, 170, 175, 178, 183, 190, 192, - 197, 202, 204, 206, 208, 210, 212, 214, 216, 221, - 226, 228, 232, 236, 240, 242, 246, 250, 252, 256, - 260, 262, 266, 270, 274, 278, 280, 284, 288, 290, - 294, 296, 300, 302, 306, 308, 312, 314, 318, 320, - 326, 331, 337, 339, 341, 345, 348, 349, 351, 353, - 355, 357, 359, 361, 363, 365, 367, 369, 371, 373, - 375, 378, 384, 391, 399, 401, 405, 407, 411, 412, - 414, 416, 418, 420, 422, 424, 426, 428, 430, 437, - 442, 445, 453, 455, 459, 461, 464, 466, 469, 471, - 474, 477, 483, 491, 497, 507, 513, 523, 525, 529, - 531, 533, 537, 541, 544, 546, 549, 552, 553, 555, - 558, 562, 563, 565, 568, 572, 576, 581, 582, 584, - 586, 589, 595, 603, 610, 617, 622, 626, 631, 634, - 638, 641, 645, 649, 653, 657, 663, 667, 671, 676, - 678, 684, 691, 697, 704, 714, 725, 735, 746, 749, - 751, 754, 757, 760, 762, 769, 778, 789, 802, 817, - 818, 820, 821, 823, 825, 829, 834, 842, 843, 845, - 849, 851, 855, 857, 859, 861, 865, 867, 869, 871, - 875, 876, 878, 882, 887, 889, 893, 895, 897, 901, - 905, 909, 913, 917, 920, 924, 931, 935, 939, 944, - 946, 949, 952, 956, 962, 971, 979, 987, 993, 1003, - 1006, 1009, 1015, 1019, 1025, 1030, 1034, 1039, 1044, 1052, - 1056, 1060, 1064, 1068, 1073, 1080, 1082, 1084, 1086, 1088, - 1090, 1092, 1094, 1096, 1097, 1099, 1101, 1104, 1106, 1108, - 1110, 1112, 1114, 1116, 1118, 1119, 1125, 1127, 1130, 1134, - 1136, 1139, 1141, 1143, 1145, 1147, 1149, 1151, 1153, 1155, - 1157, 1159, 1161, 1163, 1165, 1167, 1169, 1171, 1173, 1175, - 1177, 1179, 1181, 1183, 1186, 1189, 1193, 1197, 1199, 1203, - 1205, 1208, 1211, 1214, 1219, 1224, 1229, 1234, 1236, 1239, - 1242, 1246, 1248, 1251, 1254, 1256, 1259, 1262, 1266, 1268, - 1271, 1274, 1276, 1278, 1283, 1286, 1287, 1294, 1302, 1305, - 1308, 1311, 1312, 1315, 1318, 1322, 1325, 1329, 1331, 1334, - 1338, 1341, 1344, 1349, 1350, 1352, 1355, 1358, 1360, 1361, - 1363, 1366, 1369, 1375, 1378, 1379, 1387, 1390, 1395, 1396, - 1399, 1400, 1402, 1404, 1406, 1412, 1418, 1424, 1426, 1432, - 1438, 1448, 1450, 1456, 1457, 1459, 1461, 1467, 1469, 1471, - 1477, 1483, 1485, 1489, 1493, 1498, 1500, 1502, 1504, 1506, - 1509, 1511, 1515, 1519, 1521, 1524, 1526, 1530, 1532, 1534, - 1536, 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1555, - 1557, 1559, 1561, 1564, 1565, 1568, 1571, 1573, 1578, 1579, - 1581, 1584, 1588, 1593, 1596, 1599, 1601, 1604, 1607, 1613, - 1619, 1627, 1634, 1636, 1639, 1642, 1646, 1648, 1651, 1654, - 1659, 1662, 1667, 1668, 1673, 1676, 1678, 1680, 1682, 1683, - 1686, 1692, 1698, 1712, 1714, 1716, 1720, 1724, 1727, 1731, - 1735, 1738, 1743, 1745, 1752, 1762, 1763, 1775, 1777, 1781, - 1785, 1789, 1791, 1793, 1799, 1802, 1808, 1809, 1811, 1813, - 1817, 1818, 1820, 1822, 1824, 1826, 1827, 1834, 1837, 1839, - 1842, 1847, 1850, 1854, 1858, 1862, 1867, 1873, 1879, 1885, - 1892, 1894, 1896, 1898, 1902, 1903, 1909, 1910, 1912, 1914, - 1917, 1924, 1926, 1930, 1931, 1933, 1938, 1940, 1942, 1944, - 1946, 1949, 1951, 1954, 1957, 1959, 1963, 1966, 1970, 1974, - 1977, 1982, 1987, 1991, 2000, 2004, 2007, 2009, 2012, 2019, - 2028, 2032, 2035, 2039, 2043, 2048, 2053, 2057, 2059, 2061, - 2063, 2068, 2075, 2079, 2082, 2086, 2090, 2095, 2100, 2104, - 2107, 2109, 2112, 2115, 2117, 2121, 2124, 2128, 2132, 2135, - 2140, 2145, 2149, 2156, 2165, 2169, 2172, 2174, 2177, 2180, - 2183, 2187, 2191, 2194, 2199, 2204, 2208, 2215, 2224, 2228, - 2231, 2233, 2236, 2239, 2241, 2243, 2246, 2250, 2254, 2257, - 2262, 2269, 2278, 2280, 2283, 2286, 2288, 2291, 2294, 2298, - 2302, 2304, 2309, 2314, 2318, 2324, 2333, 2337, 2340, 2344, - 2346, 2352, 2358, 2365, 2372, 2374, 2377, 2380, 2382, 2385, - 2388, 2392, 2396, 2398, 2403, 2408, 2412, 2418, 2427, 2431, - 2433, 2436, 2438, 2441, 2448, 2454, 2461, 2469, 2477, 2479, - 2482, 2485, 2487, 2490, 2493, 2497, 2501, 2503, 2508, 2513, - 2517, 2526, 2530, 2532, 2534, 2537, 2539, 2541, 2544, 2548, - 2551, 2555, 2558, 2562, 2566, 2569, 2574, 2578, 2581, 2585, - 2588, 2593, 2597, 2600, 2607, 2614, 2621, 2629, 2631, 2634, - 2636, 2638, 2640, 2643, 2647, 2650, 2654, 2657, 2661, 2665, - 2670, 2673, 2677, 2682, 2685, 2691, 2697, 2704, 2711, 2712, - 2714, 2715 + 82, 90, 93, 96, 104, 109, 111, 115, 116, 118, + 120, 124, 126, 130, 138, 142, 150, 152, 154, 156, + 158, 160, 163, 166, 169, 172, 175, 178, 183, 186, + 191, 198, 200, 205, 210, 212, 214, 216, 218, 220, + 222, 224, 229, 234, 236, 240, 244, 248, 250, 254, + 258, 260, 264, 268, 270, 274, 278, 282, 286, 288, + 292, 296, 298, 302, 304, 308, 310, 314, 316, 320, + 322, 326, 328, 334, 339, 345, 347, 349, 353, 356, + 357, 359, 361, 363, 365, 367, 369, 371, 373, 375, + 377, 379, 381, 383, 386, 392, 399, 407, 409, 413, + 415, 419, 420, 422, 424, 426, 428, 430, 432, 434, + 436, 438, 445, 450, 453, 461, 463, 467, 469, 472, + 474, 477, 479, 482, 485, 491, 499, 505, 515, 521, + 531, 533, 537, 539, 541, 545, 549, 552, 554, 557, + 560, 561, 563, 566, 570, 571, 573, 576, 580, 584, + 589, 590, 592, 594, 597, 603, 611, 618, 625, 630, + 634, 639, 642, 646, 649, 653, 657, 661, 665, 671, + 675, 679, 684, 686, 692, 699, 705, 712, 722, 733, + 743, 754, 757, 759, 762, 765, 768, 770, 777, 786, + 797, 810, 825, 826, 828, 829, 831, 833, 837, 842, + 850, 851, 853, 857, 859, 863, 865, 867, 869, 873, + 875, 877, 879, 883, 884, 886, 890, 895, 897, 901, + 903, 905, 909, 913, 917, 921, 925, 928, 932, 939, + 943, 947, 952, 954, 957, 960, 964, 970, 979, 987, + 995, 1001, 1011, 1014, 1017, 1023, 1027, 1033, 1038, 1042, + 1047, 1052, 1060, 1064, 1068, 1072, 1076, 1081, 1088, 1090, + 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1105, 1107, 1109, + 1112, 1114, 1116, 1118, 1120, 1122, 1124, 1126, 1127, 1133, + 1135, 1138, 1142, 1144, 1147, 1149, 1151, 1153, 1155, 1157, + 1159, 1161, 1163, 1165, 1167, 1169, 1171, 1173, 1175, 1177, + 1179, 1181, 1183, 1185, 1187, 1189, 1191, 1194, 1197, 1201, + 1205, 1207, 1211, 1213, 1216, 1219, 1222, 1227, 1232, 1237, + 1242, 1244, 1247, 1250, 1254, 1256, 1259, 1262, 1264, 1267, + 1270, 1274, 1276, 1279, 1282, 1284, 1286, 1291, 1294, 1295, + 1302, 1310, 1313, 1316, 1319, 1320, 1323, 1326, 1330, 1333, + 1337, 1339, 1342, 1346, 1349, 1352, 1357, 1358, 1360, 1363, + 1366, 1368, 1369, 1371, 1374, 1377, 1383, 1386, 1387, 1395, + 1398, 1403, 1404, 1407, 1408, 1410, 1412, 1414, 1420, 1426, + 1432, 1434, 1440, 1446, 1456, 1458, 1464, 1465, 1467, 1469, + 1475, 1477, 1479, 1485, 1491, 1493, 1497, 1501, 1506, 1508, + 1510, 1512, 1514, 1517, 1519, 1523, 1527, 1529, 1532, 1534, + 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1554, 1556, + 1558, 1560, 1563, 1565, 1567, 1569, 1572, 1573, 1576, 1579, + 1581, 1586, 1587, 1589, 1592, 1596, 1601, 1604, 1607, 1609, + 1612, 1615, 1621, 1627, 1635, 1642, 1644, 1647, 1650, 1654, + 1656, 1659, 1662, 1667, 1670, 1675, 1676, 1681, 1684, 1686, + 1688, 1690, 1691, 1694, 1700, 1706, 1720, 1722, 1724, 1728, + 1732, 1735, 1739, 1743, 1746, 1751, 1753, 1760, 1770, 1771, + 1783, 1785, 1789, 1793, 1797, 1799, 1801, 1807, 1810, 1816, + 1817, 1819, 1821, 1825, 1826, 1828, 1830, 1832, 1834, 1835, + 1842, 1845, 1847, 1850, 1855, 1858, 1862, 1866, 1870, 1875, + 1881, 1887, 1893, 1900, 1902, 1904, 1906, 1910, 1911, 1917, + 1918, 1920, 1922, 1925, 1932, 1934, 1938, 1939, 1941, 1946, + 1948, 1950, 1952, 1954, 1957, 1959, 1962, 1965, 1967, 1971, + 1974, 1978, 1982, 1985, 1990, 1995, 1999, 2008, 2012, 2015, + 2017, 2020, 2027, 2036, 2040, 2043, 2047, 2051, 2056, 2061, + 2065, 2067, 2069, 2071, 2076, 2083, 2087, 2090, 2094, 2098, + 2103, 2108, 2112, 2115, 2117, 2120, 2123, 2125, 2129, 2132, + 2136, 2140, 2143, 2148, 2153, 2157, 2164, 2173, 2177, 2180, + 2182, 2185, 2188, 2191, 2195, 2199, 2202, 2207, 2212, 2216, + 2223, 2232, 2236, 2239, 2241, 2244, 2247, 2249, 2251, 2254, + 2258, 2262, 2265, 2270, 2277, 2286, 2288, 2291, 2294, 2296, + 2299, 2302, 2306, 2310, 2312, 2317, 2322, 2326, 2332, 2341, + 2345, 2348, 2352, 2354, 2360, 2366, 2373, 2380, 2382, 2385, + 2388, 2390, 2393, 2396, 2400, 2404, 2406, 2411, 2416, 2420, + 2426, 2435, 2439, 2441, 2444, 2446, 2449, 2456, 2462, 2469, + 2477, 2485, 2487, 2490, 2493, 2495, 2498, 2501, 2505, 2509, + 2511, 2516, 2521, 2525, 2534, 2538, 2540, 2542, 2545, 2547, + 2549, 2552, 2556, 2559, 2563, 2566, 2570, 2574, 2577, 2582, + 2586, 2589, 2593, 2596, 2601, 2605, 2608, 2615, 2622, 2629, + 2637, 2639, 2642, 2644, 2646, 2648, 2651, 2655, 2658, 2662, + 2665, 2669, 2673, 2678, 2681, 2685, 2690, 2693, 2699, 2705, + 2712, 2719, 2720, 2722, 2723 }; @@ -744,276 +745,277 @@ static const yytype_int16 yyrhs[] = { - 302, 0, -1, -1, -1, 79, -1, 80, -1, 81, + 303, 0, -1, -1, -1, 79, -1, 80, -1, 81, -1, 72, -1, 76, -1, 140, -1, 72, -1, 76, -1, 72, -1, 140, -1, 83, -1, 84, -1, 142, -1, 82, -1, 142, 82, -1, 72, -1, 140, -1, - 109, 170, 110, -1, 109, 174, 110, -1, 143, -1, - 144, 111, 134, 165, 135, 112, -1, 144, 109, 145, + 109, 171, 110, -1, 109, 175, 110, -1, 143, -1, + 144, 111, 134, 166, 135, 112, -1, 144, 109, 145, 110, -1, 144, 113, 139, -1, 144, 113, 111, 134, - 147, 135, 112, -1, 144, 85, 139, -1, 144, 85, - 111, 134, 147, 135, 112, -1, 144, 86, -1, 144, - 87, -1, 109, 275, 110, 114, 279, 372, 115, -1, - 144, 114, 145, 115, -1, 146, -1, 145, 116, 146, - -1, -1, 165, -1, 148, -1, 147, 116, 148, -1, - 139, -1, 139, 113, 148, -1, 139, 113, 111, 134, - 147, 135, 112, -1, 139, 85, 148, -1, 139, 85, - 111, 134, 147, 135, 112, -1, 144, -1, 136, -1, - 141, -1, 40, 152, -1, 150, 152, -1, 151, 152, - -1, 86, 149, -1, 87, 149, -1, 37, 149, -1, - 37, 109, 275, 110, -1, 66, 149, -1, 66, 109, - 275, 110, -1, 38, 109, 275, 116, 139, 110, -1, - 76, -1, 76, 109, 146, 110, -1, 76, 109, 276, - 110, -1, 117, -1, 118, -1, 119, -1, 120, -1, - 121, -1, 122, -1, 149, -1, 109, 275, 110, 152, - -1, 109, 275, 110, 168, -1, 152, -1, 153, 117, - 152, -1, 153, 123, 152, -1, 153, 124, 152, -1, - 153, -1, 154, 119, 153, -1, 154, 120, 153, -1, - 154, -1, 155, 88, 154, -1, 155, 89, 154, -1, - 155, -1, 156, 125, 155, -1, 156, 126, 155, -1, - 156, 90, 155, -1, 156, 91, 155, -1, 156, -1, - 157, 92, 156, -1, 157, 93, 156, -1, 157, -1, - 158, 118, 157, -1, 158, -1, 159, 127, 158, -1, - 159, -1, 160, 128, 159, -1, 160, -1, 161, 94, - 160, -1, 161, -1, 162, 95, 161, -1, 162, -1, - 162, 129, 170, 130, 163, -1, 162, 129, 130, 163, - -1, 162, 129, 170, 130, 168, -1, 163, -1, 163, - -1, 149, 167, 165, -1, 168, 373, -1, -1, 165, - -1, 131, -1, 107, -1, 97, -1, 98, -1, 99, - -1, 100, -1, 101, -1, 102, -1, 103, -1, 104, - -1, 105, -1, 106, -1, 111, 112, -1, 111, 134, - 165, 135, 112, -1, 111, 134, 116, 169, 135, 112, - -1, 111, 134, 165, 116, 169, 135, 112, -1, 166, - -1, 169, 116, 166, -1, 165, -1, 170, 116, 165, - -1, -1, 170, -1, 173, -1, 174, -1, 178, -1, - 179, -1, 191, -1, 193, -1, 194, -1, 199, -1, - 127, 144, 114, 145, 115, 132, -1, 72, 130, 312, - 172, -1, 114, 115, -1, 114, 134, 134, 210, 175, - 135, 115, -1, 176, -1, 175, 134, 176, -1, 213, - -1, 40, 213, -1, 308, -1, 172, 135, -1, 172, - -1, 177, 172, -1, 171, 132, -1, 41, 109, 170, - 110, 172, -1, 41, 109, 170, 110, 172, 42, 172, - -1, 43, 109, 170, 110, 184, -1, 43, 109, 170, - 110, 114, 134, 206, 185, 115, -1, 53, 109, 170, - 110, 184, -1, 53, 109, 170, 110, 114, 134, 206, - 187, 115, -1, 164, -1, 164, 96, 164, -1, 310, - -1, 180, -1, 181, 116, 180, -1, 44, 181, 130, - -1, 45, 130, -1, 182, -1, 183, 182, -1, 183, - 172, -1, -1, 186, -1, 183, 177, -1, 186, 183, - 177, -1, -1, 188, -1, 183, 190, -1, 183, 177, - 189, -1, 188, 183, 190, -1, 188, 183, 177, 189, - -1, -1, 190, -1, 56, -1, 56, 132, -1, 47, - 109, 170, 110, 172, -1, 46, 172, 47, 109, 170, - 110, 132, -1, 48, 109, 134, 192, 110, 172, -1, - 171, 135, 132, 171, 132, 171, -1, 213, 171, 132, - 171, -1, 51, 72, 132, -1, 51, 117, 170, 132, - -1, 50, 132, -1, 50, 72, 132, -1, 49, 132, - -1, 49, 72, 132, -1, 52, 171, 132, -1, 61, - 166, 132, -1, 62, 166, 132, -1, 62, 166, 63, - 165, 132, -1, 57, 174, 195, -1, 57, 174, 197, - -1, 57, 174, 195, 197, -1, 196, -1, 58, 109, - 96, 110, 174, -1, 196, 58, 109, 96, 110, 174, - -1, 59, 109, 96, 110, 174, -1, 196, 59, 109, - 96, 110, 174, -1, 58, 109, 134, 134, 198, 135, - 110, 174, 135, -1, 196, 58, 109, 134, 134, 198, - 135, 110, 174, 135, -1, 59, 109, 134, 134, 198, - 135, 110, 174, 135, -1, 196, 59, 109, 134, 134, - 198, 135, 110, 174, 135, -1, 60, 174, -1, 226, - -1, 226, 309, -1, 226, 357, -1, 366, 139, -1, - 366, -1, 64, 200, 109, 141, 110, 132, -1, 64, - 200, 109, 141, 130, 201, 110, 132, -1, 64, 200, - 109, 141, 130, 201, 130, 201, 110, 132, -1, 64, - 200, 109, 141, 130, 201, 130, 201, 130, 204, 110, - 132, -1, 64, 200, 51, 109, 141, 130, 130, 201, - 130, 204, 130, 205, 110, 132, -1, -1, 11, -1, - -1, 202, -1, 203, -1, 202, 116, 203, -1, 141, - 109, 164, 110, -1, 111, 164, 112, 141, 109, 164, - 110, -1, -1, 141, -1, 204, 116, 141, -1, 139, - -1, 205, 116, 139, -1, 135, -1, 207, -1, 213, - -1, 207, 134, 213, -1, 135, -1, 209, -1, 223, - -1, 209, 134, 223, -1, -1, 211, -1, 29, 212, - 132, -1, 211, 29, 212, 132, -1, 274, -1, 212, - 116, 274, -1, 214, -1, 223, -1, 215, 135, 132, - -1, 220, 135, 132, -1, 217, 135, 132, -1, 293, - 135, 132, -1, 296, 135, 132, -1, 216, 277, -1, - 232, 216, 277, -1, 215, 135, 116, 134, 272, 277, - -1, 367, 272, 311, -1, 370, 272, 311, -1, 228, - 370, 272, 311, -1, 218, -1, 228, 218, -1, 232, - 218, -1, 232, 228, 218, -1, 217, 135, 116, 134, - 272, -1, 111, 112, 272, 109, 134, 260, 135, 110, - -1, 370, 272, 109, 134, 260, 135, 110, -1, 219, - 272, 109, 134, 260, 135, 110, -1, 111, 134, 262, - 135, 112, -1, 111, 134, 262, 135, 116, 134, 263, - 135, 112, -1, 3, 216, -1, 3, 218, -1, 220, - 135, 116, 134, 139, -1, 3, 226, 309, -1, 221, - 135, 116, 134, 309, -1, 228, 3, 226, 309, -1, - 226, 3, 309, -1, 226, 3, 228, 309, -1, 3, - 139, 131, 165, -1, 222, 135, 116, 134, 139, 131, - 165, -1, 224, 135, 132, -1, 221, 135, 132, -1, - 222, 135, 132, -1, 240, 135, 132, -1, 225, 309, - 311, 277, -1, 224, 116, 312, 309, 311, 277, -1, - 236, -1, 240, -1, 242, -1, 283, -1, 237, -1, - 241, -1, 243, -1, 284, -1, -1, 228, -1, 229, - -1, 228, 229, -1, 230, -1, 314, -1, 10, -1, - 12, -1, 11, -1, 14, -1, 67, -1, -1, 13, - 109, 231, 286, 110, -1, 233, -1, 228, 233, -1, - 232, 228, 233, -1, 234, -1, 233, 234, -1, 5, - -1, 7, -1, 4, -1, 6, -1, 8, -1, 9, - -1, 69, -1, 71, -1, 16, -1, 21, -1, 20, - -1, 18, -1, 19, -1, 17, -1, 22, -1, 23, - -1, 15, -1, 25, -1, 26, -1, 27, -1, 24, - -1, 237, -1, 232, 237, -1, 236, 234, -1, 236, - 234, 228, -1, 236, 234, 237, -1, 238, -1, 227, - 239, 227, -1, 235, -1, 228, 235, -1, 238, 229, - -1, 238, 235, -1, 28, 109, 276, 110, -1, 28, - 109, 170, 110, -1, 78, 109, 276, 110, -1, 78, - 109, 170, 110, -1, 241, -1, 232, 241, -1, 240, - 234, -1, 240, 234, 228, -1, 244, -1, 228, 244, - -1, 241, 229, -1, 243, -1, 232, 243, -1, 242, - 234, -1, 242, 234, 228, -1, 74, -1, 228, 74, - -1, 243, 229, -1, 245, -1, 256, -1, 247, 114, - 248, 115, -1, 247, 274, -1, -1, 247, 274, 246, - 114, 248, 115, -1, 247, 109, 292, 110, 114, 248, - 115, -1, 247, 285, -1, 31, 312, -1, 32, 312, - -1, -1, 248, 249, -1, 250, 132, -1, 40, 250, - 132, -1, 251, 132, -1, 40, 251, 132, -1, 366, - -1, 366, 274, -1, 250, 116, 274, -1, 250, 116, - -1, 226, 252, -1, 251, 116, 312, 252, -1, -1, - 254, -1, 318, 253, -1, 331, 253, -1, 357, -1, - -1, 254, -1, 130, 164, -1, 30, 312, -1, 255, - 114, 258, 372, 115, -1, 255, 274, -1, -1, 255, - 274, 257, 114, 258, 372, 115, -1, 274, 259, -1, - 258, 116, 274, 259, -1, -1, 131, 164, -1, -1, - 261, -1, 263, -1, 262, -1, 262, 135, 116, 134, - 263, -1, 263, 135, 116, 134, 96, -1, 262, 135, - 116, 134, 96, -1, 267, -1, 263, 135, 116, 134, - 267, -1, 262, 135, 116, 134, 267, -1, 262, 135, - 116, 134, 263, 135, 116, 134, 267, -1, 268, -1, - 263, 135, 116, 134, 268, -1, -1, 265, -1, 266, - -1, 266, 135, 116, 134, 96, -1, 270, -1, 269, - -1, 266, 135, 116, 134, 270, -1, 266, 135, 116, - 134, 269, -1, 269, -1, 362, 272, 373, -1, 370, - 272, 373, -1, 228, 370, 272, 373, -1, 218, -1, - 270, -1, 362, -1, 370, -1, 228, 370, -1, 371, - -1, 225, 336, 373, -1, 225, 340, 373, -1, 225, - -1, 225, 351, -1, 139, -1, 271, 116, 139, -1, - 137, -1, 74, -1, 75, -1, 138, -1, 74, -1, - 75, -1, 139, -1, 74, -1, 75, -1, 366, -1, - 226, -1, 226, 357, -1, 366, -1, 371, -1, 226, - -1, 226, 345, -1, -1, 131, 278, -1, 107, 278, - -1, 165, -1, 114, 279, 372, 115, -1, -1, 278, - -1, 280, 278, -1, 279, 116, 278, -1, 279, 116, - 280, 278, -1, 281, 130, -1, 274, 130, -1, 282, - -1, 281, 282, -1, 113, 274, -1, 111, 134, 165, - 135, 112, -1, 111, 134, 310, 135, 112, -1, 111, - 134, 164, 96, 164, 135, 112, -1, 113, 111, 134, - 147, 135, 112, -1, 284, -1, 232, 284, -1, 283, - 234, -1, 283, 234, 228, -1, 285, -1, 228, 285, - -1, 284, 229, -1, 75, 109, 292, 110, -1, 287, - 373, -1, 286, 116, 287, 373, -1, -1, 289, 274, - 288, 290, -1, 226, 336, -1, 33, -1, 35, -1, - 34, -1, -1, 290, 291, -1, 128, 274, 109, 292, - 110, -1, 128, 114, 134, 298, 115, -1, 128, 109, - 134, 286, 135, 110, 114, 134, 298, 115, 109, 292, - 110, -1, 276, -1, 165, -1, 292, 116, 276, -1, - 292, 116, 165, -1, 33, 294, -1, 233, 33, 294, - -1, 293, 116, 294, -1, 295, 290, -1, 295, 290, - 131, 276, -1, 274, -1, 273, 109, 134, 286, 135, - 110, -1, 36, 274, 109, 134, 286, 135, 110, 114, - 115, -1, -1, 36, 274, 109, 134, 286, 135, 110, - 114, 297, 298, 115, -1, 299, -1, 298, 134, 299, - -1, 300, 135, 132, -1, 301, 135, 132, -1, 216, - -1, 218, -1, 300, 135, 116, 134, 272, -1, 226, - 309, -1, 301, 135, 116, 134, 309, -1, -1, 303, - -1, 305, -1, 303, 134, 305, -1, -1, 303, -1, - 213, -1, 307, -1, 199, -1, -1, 5, 82, 306, - 114, 304, 115, -1, 40, 305, -1, 308, -1, 323, - 174, -1, 327, 134, 208, 174, -1, 217, 174, -1, - 225, 323, 174, -1, 228, 323, 174, -1, 232, 323, - 174, -1, 232, 228, 323, 174, -1, 225, 327, 134, - 208, 174, -1, 228, 327, 134, 208, 174, -1, 232, - 327, 134, 208, 174, -1, 232, 228, 327, 134, 208, - 174, -1, 318, -1, 331, -1, 323, -1, 164, 122, - 164, -1, -1, 64, 109, 142, 110, 312, -1, -1, - 313, -1, 314, -1, 313, 314, -1, 39, 109, 109, - 315, 110, 110, -1, 316, -1, 315, 116, 316, -1, - -1, 317, -1, 317, 109, 171, 110, -1, 272, -1, - 234, -1, 235, -1, 229, -1, 319, 312, -1, 320, - -1, 321, 312, -1, 322, 312, -1, 137, -1, 109, - 319, 110, -1, 150, 318, -1, 150, 228, 318, -1, - 109, 320, 110, -1, 319, 349, -1, 109, 320, 110, - 349, -1, 109, 321, 110, 350, -1, 109, 321, 110, - -1, 109, 320, 110, 109, 134, 264, 135, 110, -1, - 109, 322, 110, -1, 324, 312, -1, 325, -1, 326, - 312, -1, 319, 109, 134, 264, 135, 110, -1, 109, - 325, 110, 109, 134, 264, 135, 110, -1, 109, 324, - 110, -1, 150, 323, -1, 150, 228, 323, -1, 109, - 325, 110, -1, 109, 325, 110, 349, -1, 109, 326, - 110, 350, -1, 109, 326, 110, -1, 328, -1, 329, - -1, 330, -1, 319, 109, 271, 110, -1, 109, 329, - 110, 109, 271, 110, -1, 109, 328, 110, -1, 150, - 327, -1, 150, 228, 327, -1, 109, 329, 110, -1, - 109, 329, 110, 349, -1, 109, 330, 110, 350, -1, - 109, 330, 110, -1, 332, 312, -1, 333, -1, 334, - 312, -1, 335, 312, -1, 341, -1, 109, 332, 110, - -1, 150, 331, -1, 150, 228, 331, -1, 109, 333, - 110, -1, 332, 349, -1, 109, 333, 110, 349, -1, - 109, 334, 110, 350, -1, 109, 334, 110, -1, 332, - 109, 134, 264, 135, 110, -1, 109, 333, 110, 109, - 134, 264, 135, 110, -1, 109, 335, 110, -1, 319, - 312, -1, 337, -1, 338, 312, -1, 339, 312, -1, - 150, 336, -1, 150, 228, 336, -1, 109, 337, 110, - -1, 319, 355, -1, 109, 337, 110, 349, -1, 109, - 338, 110, 350, -1, 109, 338, 110, -1, 319, 109, - 134, 264, 135, 110, -1, 109, 337, 110, 109, 134, - 264, 135, 110, -1, 109, 339, 110, -1, 341, 312, - -1, 342, -1, 343, 312, -1, 344, 312, -1, 74, - -1, 75, -1, 150, 340, -1, 150, 228, 340, -1, - 109, 342, 110, -1, 341, 355, -1, 109, 342, 110, - 355, -1, 341, 109, 134, 264, 135, 110, -1, 109, - 342, 110, 109, 134, 264, 135, 110, -1, 346, -1, - 347, 312, -1, 348, 312, -1, 150, -1, 150, 228, - -1, 150, 345, -1, 150, 228, 345, -1, 109, 346, - 110, -1, 349, -1, 109, 346, 110, 349, -1, 109, - 347, 110, 350, -1, 109, 347, 110, -1, 109, 134, - 264, 135, 110, -1, 109, 346, 110, 109, 134, 264, - 135, 110, -1, 109, 348, 110, -1, 111, 112, -1, - 111, 112, 350, -1, 350, -1, 111, 134, 165, 135, - 112, -1, 111, 134, 117, 135, 112, -1, 350, 111, - 134, 165, 135, 112, -1, 350, 111, 134, 117, 135, - 112, -1, 352, -1, 353, 312, -1, 354, 312, -1, - 150, -1, 150, 228, -1, 150, 351, -1, 150, 228, - 351, -1, 109, 352, 110, -1, 355, -1, 109, 352, - 110, 355, -1, 109, 353, 110, 350, -1, 109, 353, - 110, -1, 109, 134, 264, 135, 110, -1, 109, 352, - 110, 109, 134, 264, 135, 110, -1, 109, 354, 110, - -1, 356, -1, 356, 350, -1, 350, -1, 111, 112, - -1, 111, 134, 228, 117, 135, 112, -1, 111, 134, - 228, 135, 112, -1, 111, 134, 228, 165, 135, 112, - -1, 111, 134, 7, 227, 165, 135, 112, -1, 111, - 134, 228, 7, 165, 135, 112, -1, 358, -1, 359, - 312, -1, 360, 312, -1, 150, -1, 150, 228, -1, - 150, 357, -1, 150, 228, 357, -1, 109, 358, 110, - -1, 349, -1, 109, 358, 110, 349, -1, 109, 359, - 110, 350, -1, 109, 359, 110, -1, 109, 358, 110, - 109, 134, 264, 135, 110, -1, 109, 360, 110, -1, - 362, -1, 370, -1, 228, 370, -1, 363, -1, 364, - -1, 150, 226, -1, 228, 150, 226, -1, 150, 371, - -1, 228, 150, 371, -1, 150, 361, -1, 228, 150, - 361, -1, 111, 112, 226, -1, 365, 226, -1, 111, - 112, 350, 226, -1, 365, 350, 226, -1, 350, 226, - -1, 111, 112, 363, -1, 365, 363, -1, 111, 112, - 350, 363, -1, 365, 350, 363, -1, 350, 363, -1, - 111, 134, 228, 117, 135, 112, -1, 111, 134, 228, - 165, 135, 112, -1, 111, 134, 232, 165, 135, 112, - -1, 111, 134, 232, 228, 165, 135, 112, -1, 370, - -1, 228, 370, -1, 367, -1, 368, -1, 369, -1, - 150, 226, -1, 228, 150, 226, -1, 150, 371, -1, - 228, 150, 371, -1, 150, 366, -1, 228, 150, 366, - -1, 111, 112, 226, -1, 111, 112, 350, 226, -1, - 350, 226, -1, 111, 112, 368, -1, 111, 112, 350, - 368, -1, 350, 368, -1, 111, 134, 263, 135, 112, - -1, 111, 112, 109, 260, 110, -1, 370, 109, 134, - 260, 135, 110, -1, 219, 109, 134, 260, 135, 110, - -1, -1, 116, -1, -1, 131, 165, -1 + 147, 135, 112, -1, 144, 113, 79, -1, 144, 85, + 139, -1, 144, 85, 111, 134, 147, 135, 112, -1, + 144, 86, -1, 144, 87, -1, 109, 276, 110, 114, + 280, 373, 115, -1, 144, 114, 145, 115, -1, 146, + -1, 145, 116, 146, -1, -1, 166, -1, 148, -1, + 147, 116, 148, -1, 149, -1, 149, 113, 148, -1, + 149, 113, 111, 134, 147, 135, 112, -1, 149, 85, + 148, -1, 149, 85, 111, 134, 147, 135, 112, -1, + 139, -1, 79, -1, 144, -1, 136, -1, 141, -1, + 40, 153, -1, 151, 153, -1, 152, 153, -1, 86, + 150, -1, 87, 150, -1, 37, 150, -1, 37, 109, + 276, 110, -1, 66, 150, -1, 66, 109, 276, 110, + -1, 38, 109, 276, 116, 139, 110, -1, 76, -1, + 76, 109, 146, 110, -1, 76, 109, 277, 110, -1, + 117, -1, 118, -1, 119, -1, 120, -1, 121, -1, + 122, -1, 150, -1, 109, 276, 110, 153, -1, 109, + 276, 110, 169, -1, 153, -1, 154, 117, 153, -1, + 154, 123, 153, -1, 154, 124, 153, -1, 154, -1, + 155, 119, 154, -1, 155, 120, 154, -1, 155, -1, + 156, 88, 155, -1, 156, 89, 155, -1, 156, -1, + 157, 125, 156, -1, 157, 126, 156, -1, 157, 90, + 156, -1, 157, 91, 156, -1, 157, -1, 158, 92, + 157, -1, 158, 93, 157, -1, 158, -1, 159, 118, + 158, -1, 159, -1, 160, 127, 159, -1, 160, -1, + 161, 128, 160, -1, 161, -1, 162, 94, 161, -1, + 162, -1, 163, 95, 162, -1, 163, -1, 163, 129, + 171, 130, 164, -1, 163, 129, 130, 164, -1, 163, + 129, 171, 130, 169, -1, 164, -1, 164, -1, 150, + 168, 166, -1, 169, 374, -1, -1, 166, -1, 131, + -1, 107, -1, 97, -1, 98, -1, 99, -1, 100, + -1, 101, -1, 102, -1, 103, -1, 104, -1, 105, + -1, 106, -1, 111, 112, -1, 111, 134, 166, 135, + 112, -1, 111, 134, 116, 170, 135, 112, -1, 111, + 134, 166, 116, 170, 135, 112, -1, 167, -1, 170, + 116, 167, -1, 166, -1, 171, 116, 166, -1, -1, + 171, -1, 174, -1, 175, -1, 179, -1, 180, -1, + 192, -1, 194, -1, 195, -1, 200, -1, 127, 144, + 114, 145, 115, 132, -1, 72, 130, 313, 173, -1, + 114, 115, -1, 114, 134, 134, 211, 176, 135, 115, + -1, 177, -1, 176, 134, 177, -1, 214, -1, 40, + 214, -1, 309, -1, 173, 135, -1, 173, -1, 178, + 173, -1, 172, 132, -1, 41, 109, 171, 110, 173, + -1, 41, 109, 171, 110, 173, 42, 173, -1, 43, + 109, 171, 110, 185, -1, 43, 109, 171, 110, 114, + 134, 207, 186, 115, -1, 53, 109, 171, 110, 185, + -1, 53, 109, 171, 110, 114, 134, 207, 188, 115, + -1, 165, -1, 165, 96, 165, -1, 311, -1, 181, + -1, 182, 116, 181, -1, 44, 182, 130, -1, 45, + 130, -1, 183, -1, 184, 183, -1, 184, 173, -1, + -1, 187, -1, 184, 178, -1, 187, 184, 178, -1, + -1, 189, -1, 184, 191, -1, 184, 178, 190, -1, + 189, 184, 191, -1, 189, 184, 178, 190, -1, -1, + 191, -1, 56, -1, 56, 132, -1, 47, 109, 171, + 110, 173, -1, 46, 173, 47, 109, 171, 110, 132, + -1, 48, 109, 134, 193, 110, 173, -1, 172, 135, + 132, 172, 132, 172, -1, 214, 172, 132, 172, -1, + 51, 72, 132, -1, 51, 117, 171, 132, -1, 50, + 132, -1, 50, 72, 132, -1, 49, 132, -1, 49, + 72, 132, -1, 52, 172, 132, -1, 61, 167, 132, + -1, 62, 167, 132, -1, 62, 167, 63, 166, 132, + -1, 57, 175, 196, -1, 57, 175, 198, -1, 57, + 175, 196, 198, -1, 197, -1, 58, 109, 96, 110, + 175, -1, 197, 58, 109, 96, 110, 175, -1, 59, + 109, 96, 110, 175, -1, 197, 59, 109, 96, 110, + 175, -1, 58, 109, 134, 134, 199, 135, 110, 175, + 135, -1, 197, 58, 109, 134, 134, 199, 135, 110, + 175, 135, -1, 59, 109, 134, 134, 199, 135, 110, + 175, 135, -1, 197, 59, 109, 134, 134, 199, 135, + 110, 175, 135, -1, 60, 175, -1, 227, -1, 227, + 310, -1, 227, 358, -1, 367, 139, -1, 367, -1, + 64, 201, 109, 141, 110, 132, -1, 64, 201, 109, + 141, 130, 202, 110, 132, -1, 64, 201, 109, 141, + 130, 202, 130, 202, 110, 132, -1, 64, 201, 109, + 141, 130, 202, 130, 202, 130, 205, 110, 132, -1, + 64, 201, 51, 109, 141, 130, 130, 202, 130, 205, + 130, 206, 110, 132, -1, -1, 11, -1, -1, 203, + -1, 204, -1, 203, 116, 204, -1, 141, 109, 165, + 110, -1, 111, 165, 112, 141, 109, 165, 110, -1, + -1, 141, -1, 205, 116, 141, -1, 139, -1, 206, + 116, 139, -1, 135, -1, 208, -1, 214, -1, 208, + 134, 214, -1, 135, -1, 210, -1, 224, -1, 210, + 134, 224, -1, -1, 212, -1, 29, 213, 132, -1, + 212, 29, 213, 132, -1, 275, -1, 213, 116, 275, + -1, 215, -1, 224, -1, 216, 135, 132, -1, 221, + 135, 132, -1, 218, 135, 132, -1, 294, 135, 132, + -1, 297, 135, 132, -1, 217, 278, -1, 233, 217, + 278, -1, 216, 135, 116, 134, 273, 278, -1, 368, + 273, 312, -1, 371, 273, 312, -1, 229, 371, 273, + 312, -1, 219, -1, 229, 219, -1, 233, 219, -1, + 233, 229, 219, -1, 218, 135, 116, 134, 273, -1, + 111, 112, 273, 109, 134, 261, 135, 110, -1, 371, + 273, 109, 134, 261, 135, 110, -1, 220, 273, 109, + 134, 261, 135, 110, -1, 111, 134, 263, 135, 112, + -1, 111, 134, 263, 135, 116, 134, 264, 135, 112, + -1, 3, 217, -1, 3, 219, -1, 221, 135, 116, + 134, 139, -1, 3, 227, 310, -1, 222, 135, 116, + 134, 310, -1, 229, 3, 227, 310, -1, 227, 3, + 310, -1, 227, 3, 229, 310, -1, 3, 139, 131, + 166, -1, 223, 135, 116, 134, 139, 131, 166, -1, + 225, 135, 132, -1, 222, 135, 132, -1, 223, 135, + 132, -1, 241, 135, 132, -1, 226, 310, 312, 278, + -1, 225, 116, 313, 310, 312, 278, -1, 237, -1, + 241, -1, 243, -1, 284, -1, 238, -1, 242, -1, + 244, -1, 285, -1, -1, 229, -1, 230, -1, 229, + 230, -1, 231, -1, 315, -1, 10, -1, 12, -1, + 11, -1, 14, -1, 67, -1, -1, 13, 109, 232, + 287, 110, -1, 234, -1, 229, 234, -1, 233, 229, + 234, -1, 235, -1, 234, 235, -1, 5, -1, 7, + -1, 4, -1, 6, -1, 8, -1, 9, -1, 69, + -1, 71, -1, 16, -1, 21, -1, 20, -1, 18, + -1, 19, -1, 17, -1, 22, -1, 23, -1, 15, + -1, 25, -1, 26, -1, 27, -1, 24, -1, 238, + -1, 233, 238, -1, 237, 235, -1, 237, 235, 229, + -1, 237, 235, 238, -1, 239, -1, 228, 240, 228, + -1, 236, -1, 229, 236, -1, 239, 230, -1, 239, + 236, -1, 28, 109, 277, 110, -1, 28, 109, 171, + 110, -1, 78, 109, 277, 110, -1, 78, 109, 171, + 110, -1, 242, -1, 233, 242, -1, 241, 235, -1, + 241, 235, 229, -1, 245, -1, 229, 245, -1, 242, + 230, -1, 244, -1, 233, 244, -1, 243, 235, -1, + 243, 235, 229, -1, 74, -1, 229, 74, -1, 244, + 230, -1, 246, -1, 257, -1, 248, 114, 249, 115, + -1, 248, 275, -1, -1, 248, 275, 247, 114, 249, + 115, -1, 248, 109, 293, 110, 114, 249, 115, -1, + 248, 286, -1, 31, 313, -1, 32, 313, -1, -1, + 249, 250, -1, 251, 132, -1, 40, 251, 132, -1, + 252, 132, -1, 40, 252, 132, -1, 367, -1, 367, + 275, -1, 251, 116, 275, -1, 251, 116, -1, 227, + 253, -1, 252, 116, 313, 253, -1, -1, 255, -1, + 319, 254, -1, 332, 254, -1, 358, -1, -1, 255, + -1, 130, 165, -1, 30, 313, -1, 256, 114, 259, + 373, 115, -1, 256, 275, -1, -1, 256, 275, 258, + 114, 259, 373, 115, -1, 275, 260, -1, 259, 116, + 275, 260, -1, -1, 131, 165, -1, -1, 262, -1, + 264, -1, 263, -1, 263, 135, 116, 134, 264, -1, + 264, 135, 116, 134, 96, -1, 263, 135, 116, 134, + 96, -1, 268, -1, 264, 135, 116, 134, 268, -1, + 263, 135, 116, 134, 268, -1, 263, 135, 116, 134, + 264, 135, 116, 134, 268, -1, 269, -1, 264, 135, + 116, 134, 269, -1, -1, 266, -1, 267, -1, 267, + 135, 116, 134, 96, -1, 271, -1, 270, -1, 267, + 135, 116, 134, 271, -1, 267, 135, 116, 134, 270, + -1, 270, -1, 363, 273, 374, -1, 371, 273, 374, + -1, 229, 371, 273, 374, -1, 219, -1, 271, -1, + 363, -1, 371, -1, 229, 371, -1, 372, -1, 226, + 337, 374, -1, 226, 341, 374, -1, 226, -1, 226, + 352, -1, 139, -1, 272, 116, 139, -1, 137, -1, + 74, -1, 75, -1, 138, -1, 74, -1, 75, -1, + 139, -1, 74, -1, 75, -1, 367, -1, 227, -1, + 227, 358, -1, 367, -1, 372, -1, 227, -1, 227, + 346, -1, -1, 131, 279, -1, 107, 279, -1, 166, + -1, 114, 280, 373, 115, -1, -1, 279, -1, 281, + 279, -1, 280, 116, 279, -1, 280, 116, 281, 279, + -1, 282, 130, -1, 275, 130, -1, 283, -1, 282, + 283, -1, 113, 275, -1, 111, 134, 166, 135, 112, + -1, 111, 134, 311, 135, 112, -1, 111, 134, 165, + 96, 165, 135, 112, -1, 113, 111, 134, 147, 135, + 112, -1, 285, -1, 233, 285, -1, 284, 235, -1, + 284, 235, 229, -1, 286, -1, 229, 286, -1, 285, + 230, -1, 75, 109, 293, 110, -1, 288, 374, -1, + 287, 116, 288, 374, -1, -1, 290, 275, 289, 291, + -1, 227, 337, -1, 33, -1, 35, -1, 34, -1, + -1, 291, 292, -1, 128, 275, 109, 293, 110, -1, + 128, 114, 134, 299, 115, -1, 128, 109, 134, 287, + 135, 110, 114, 134, 299, 115, 109, 293, 110, -1, + 277, -1, 166, -1, 293, 116, 277, -1, 293, 116, + 166, -1, 33, 295, -1, 234, 33, 295, -1, 294, + 116, 295, -1, 296, 291, -1, 296, 291, 131, 277, + -1, 275, -1, 274, 109, 134, 287, 135, 110, -1, + 36, 275, 109, 134, 287, 135, 110, 114, 115, -1, + -1, 36, 275, 109, 134, 287, 135, 110, 114, 298, + 299, 115, -1, 300, -1, 299, 134, 300, -1, 301, + 135, 132, -1, 302, 135, 132, -1, 217, -1, 219, + -1, 301, 135, 116, 134, 273, -1, 227, 310, -1, + 302, 135, 116, 134, 310, -1, -1, 304, -1, 306, + -1, 304, 134, 306, -1, -1, 304, -1, 214, -1, + 308, -1, 200, -1, -1, 5, 82, 307, 114, 305, + 115, -1, 40, 306, -1, 309, -1, 324, 175, -1, + 328, 134, 209, 175, -1, 218, 175, -1, 226, 324, + 175, -1, 229, 324, 175, -1, 233, 324, 175, -1, + 233, 229, 324, 175, -1, 226, 328, 134, 209, 175, + -1, 229, 328, 134, 209, 175, -1, 233, 328, 134, + 209, 175, -1, 233, 229, 328, 134, 209, 175, -1, + 319, -1, 332, -1, 324, -1, 165, 122, 165, -1, + -1, 64, 109, 142, 110, 313, -1, -1, 314, -1, + 315, -1, 314, 315, -1, 39, 109, 109, 316, 110, + 110, -1, 317, -1, 316, 116, 317, -1, -1, 318, + -1, 318, 109, 172, 110, -1, 273, -1, 235, -1, + 236, -1, 230, -1, 320, 313, -1, 321, -1, 322, + 313, -1, 323, 313, -1, 137, -1, 109, 320, 110, + -1, 151, 319, -1, 151, 229, 319, -1, 109, 321, + 110, -1, 320, 350, -1, 109, 321, 110, 350, -1, + 109, 322, 110, 351, -1, 109, 322, 110, -1, 109, + 321, 110, 109, 134, 265, 135, 110, -1, 109, 323, + 110, -1, 325, 313, -1, 326, -1, 327, 313, -1, + 320, 109, 134, 265, 135, 110, -1, 109, 326, 110, + 109, 134, 265, 135, 110, -1, 109, 325, 110, -1, + 151, 324, -1, 151, 229, 324, -1, 109, 326, 110, + -1, 109, 326, 110, 350, -1, 109, 327, 110, 351, + -1, 109, 327, 110, -1, 329, -1, 330, -1, 331, + -1, 320, 109, 272, 110, -1, 109, 330, 110, 109, + 272, 110, -1, 109, 329, 110, -1, 151, 328, -1, + 151, 229, 328, -1, 109, 330, 110, -1, 109, 330, + 110, 350, -1, 109, 331, 110, 351, -1, 109, 331, + 110, -1, 333, 313, -1, 334, -1, 335, 313, -1, + 336, 313, -1, 342, -1, 109, 333, 110, -1, 151, + 332, -1, 151, 229, 332, -1, 109, 334, 110, -1, + 333, 350, -1, 109, 334, 110, 350, -1, 109, 335, + 110, 351, -1, 109, 335, 110, -1, 333, 109, 134, + 265, 135, 110, -1, 109, 334, 110, 109, 134, 265, + 135, 110, -1, 109, 336, 110, -1, 320, 313, -1, + 338, -1, 339, 313, -1, 340, 313, -1, 151, 337, + -1, 151, 229, 337, -1, 109, 338, 110, -1, 320, + 356, -1, 109, 338, 110, 350, -1, 109, 339, 110, + 351, -1, 109, 339, 110, -1, 320, 109, 134, 265, + 135, 110, -1, 109, 338, 110, 109, 134, 265, 135, + 110, -1, 109, 340, 110, -1, 342, 313, -1, 343, + -1, 344, 313, -1, 345, 313, -1, 74, -1, 75, + -1, 151, 341, -1, 151, 229, 341, -1, 109, 343, + 110, -1, 342, 356, -1, 109, 343, 110, 356, -1, + 342, 109, 134, 265, 135, 110, -1, 109, 343, 110, + 109, 134, 265, 135, 110, -1, 347, -1, 348, 313, + -1, 349, 313, -1, 151, -1, 151, 229, -1, 151, + 346, -1, 151, 229, 346, -1, 109, 347, 110, -1, + 350, -1, 109, 347, 110, 350, -1, 109, 348, 110, + 351, -1, 109, 348, 110, -1, 109, 134, 265, 135, + 110, -1, 109, 347, 110, 109, 134, 265, 135, 110, + -1, 109, 349, 110, -1, 111, 112, -1, 111, 112, + 351, -1, 351, -1, 111, 134, 166, 135, 112, -1, + 111, 134, 117, 135, 112, -1, 351, 111, 134, 166, + 135, 112, -1, 351, 111, 134, 117, 135, 112, -1, + 353, -1, 354, 313, -1, 355, 313, -1, 151, -1, + 151, 229, -1, 151, 352, -1, 151, 229, 352, -1, + 109, 353, 110, -1, 356, -1, 109, 353, 110, 356, + -1, 109, 354, 110, 351, -1, 109, 354, 110, -1, + 109, 134, 265, 135, 110, -1, 109, 353, 110, 109, + 134, 265, 135, 110, -1, 109, 355, 110, -1, 357, + -1, 357, 351, -1, 351, -1, 111, 112, -1, 111, + 134, 229, 117, 135, 112, -1, 111, 134, 229, 135, + 112, -1, 111, 134, 229, 166, 135, 112, -1, 111, + 134, 7, 228, 166, 135, 112, -1, 111, 134, 229, + 7, 166, 135, 112, -1, 359, -1, 360, 313, -1, + 361, 313, -1, 151, -1, 151, 229, -1, 151, 358, + -1, 151, 229, 358, -1, 109, 359, 110, -1, 350, + -1, 109, 359, 110, 350, -1, 109, 360, 110, 351, + -1, 109, 360, 110, -1, 109, 359, 110, 109, 134, + 265, 135, 110, -1, 109, 361, 110, -1, 363, -1, + 371, -1, 229, 371, -1, 364, -1, 365, -1, 151, + 227, -1, 229, 151, 227, -1, 151, 372, -1, 229, + 151, 372, -1, 151, 362, -1, 229, 151, 362, -1, + 111, 112, 227, -1, 366, 227, -1, 111, 112, 351, + 227, -1, 366, 351, 227, -1, 351, 227, -1, 111, + 112, 364, -1, 366, 364, -1, 111, 112, 351, 364, + -1, 366, 351, 364, -1, 351, 364, -1, 111, 134, + 229, 117, 135, 112, -1, 111, 134, 229, 166, 135, + 112, -1, 111, 134, 233, 166, 135, 112, -1, 111, + 134, 233, 229, 166, 135, 112, -1, 371, -1, 229, + 371, -1, 368, -1, 369, -1, 370, -1, 151, 227, + -1, 229, 151, 227, -1, 151, 372, -1, 229, 151, + 372, -1, 151, 367, -1, 229, 151, 367, -1, 111, + 112, 227, -1, 111, 112, 351, 227, -1, 351, 227, + -1, 111, 112, 369, -1, 111, 112, 351, 369, -1, + 351, 369, -1, 111, 134, 264, 135, 112, -1, 111, + 112, 109, 261, 110, -1, 371, 109, 134, 261, 135, + 110, -1, 220, 109, 134, 261, 135, 110, -1, -1, + 116, -1, -1, 131, 166, -1 }; @@ -1021,80 +1023,80 @@ static const yytype_uint16 yyrline[] = { - 0, 300, 300, 304, 311, 312, 313, 317, 318, 319, - 323, 324, 328, 329, 333, 334, 338, 342, 343, 354, - 356, 358, 360, 365, 366, 372, 376, 378, 380, 382, - 384, 386, 388, 390, 399, 400, 406, 407, 411, 412, - 416, 420, 422, 424, 426, 431, 434, 436, 438, 443, - 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, - 476, 483, 484, 490, 491, 492, 493, 497, 498, 500, - 505, 506, 508, 510, 515, 516, 518, 523, 524, 526, - 531, 532, 534, 536, 538, 543, 544, 546, 551, 552, - 557, 558, 563, 564, 569, 570, 575, 576, 581, 582, - 585, 587, 592, 597, 598, 600, 606, 607, 611, 612, - 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, - 628, 630, 632, 634, 639, 640, 645, 646, 652, 653, - 659, 660, 661, 662, 663, 664, 665, 666, 667, 677, - 684, 686, 696, 697, 702, 704, 710, 712, 716, 717, - 722, 727, 730, 732, 734, 744, 746, 757, 758, 760, - 764, 766, 770, 771, 776, 777, 781, 786, 787, 791, - 793, 799, 800, 804, 806, 808, 810, 816, 817, 821, - 823, 828, 830, 832, 837, 839, 844, 846, 850, 853, - 857, 860, 864, 866, 868, 870, 875, 877, 879, 884, - 886, 888, 890, 892, 897, 899, 901, 903, 908, 920, - 921, 926, 928, 933, 937, 939, 941, 943, 945, 951, - 952, 958, 959, 963, 964, 969, 971, 977, 978, 980, - 985, 990, 1000, 1002, 1006, 1007, 1012, 1014, 1018, 1019, - 1023, 1025, 1029, 1030, 1034, 1035, 1039, 1040, 1055, 1056, - 1057, 1058, 1059, 1063, 1068, 1075, 1085, 1090, 1095, 1103, - 1108, 1113, 1118, 1123, 1131, 1153, 1158, 1165, 1167, 1174, - 1179, 1184, 1195, 1200, 1205, 1210, 1215, 1224, 1229, 1237, - 1238, 1239, 1240, 1246, 1251, 1259, 1260, 1261, 1262, 1266, - 1267, 1268, 1269, 1274, 1275, 1284, 1285, 1290, 1291, 1296, - 1298, 1300, 1302, 1304, 1307, 1306, 1318, 1319, 1321, 1331, - 1332, 1337, 1339, 1341, 1343, 1345, 1348, 1350, 1353, 1358, - 1360, 1362, 1364, 1366, 1368, 1370, 1372, 1374, 1376, 1378, - 1380, 1382, 1388, 1389, 1391, 1393, 1395, 1400, 1401, 1407, - 1408, 1410, 1412, 1417, 1419, 1421, 1423, 1428, 1429, 1431, - 1433, 1438, 1439, 1441, 1446, 1447, 1449, 1451, 1456, 1458, - 1460, 1465, 1466, 1470, 1472, 1478, 1477, 1481, 1483, 1488, - 1490, 1496, 1497, 1502, 1503, 1505, 1506, 1515, 1516, 1518, - 1520, 1525, 1527, 1533, 1534, 1536, 1539, 1542, 1547, 1548, - 1553, 1558, 1562, 1564, 1570, 1569, 1576, 1578, 1584, 1585, - 1593, 1594, 1598, 1599, 1600, 1602, 1604, 1611, 1612, 1614, - 1616, 1621, 1622, 1628, 1629, 1633, 1634, 1639, 1640, 1641, - 1643, 1651, 1652, 1654, 1657, 1659, 1663, 1664, 1665, 1667, - 1669, 1673, 1678, 1686, 1687, 1696, 1698, 1703, 1704, 1705, - 1709, 1710, 1711, 1715, 1716, 1717, 1721, 1722, 1723, 1728, - 1729, 1730, 1731, 1737, 1738, 1740, 1745, 1746, 1751, 1752, - 1753, 1754, 1755, 1770, 1771, 1776, 1777, 1783, 1785, 1788, - 1790, 1792, 1815, 1816, 1818, 1820, 1825, 1826, 1828, 1833, - 1838, 1839, 1845, 1844, 1848, 1852, 1854, 1856, 1862, 1863, - 1868, 1873, 1875, 1880, 1882, 1883, 1885, 1890, 1892, 1894, - 1899, 1901, 1906, 1911, 1919, 1925, 1924, 1938, 1939, 1944, - 1945, 1949, 1954, 1959, 1967, 1972, 1983, 1984, 1989, 1990, - 1996, 1997, 2001, 2002, 2003, 2006, 2005, 2016, 2025, 2031, - 2037, 2046, 2052, 2058, 2064, 2070, 2078, 2084, 2092, 2098, - 2107, 2108, 2109, 2113, 2117, 2119, 2124, 2125, 2129, 2130, - 2135, 2141, 2142, 2145, 2147, 2148, 2152, 2153, 2154, 2155, - 2189, 2191, 2192, 2194, 2199, 2204, 2209, 2211, 2213, 2218, - 2220, 2222, 2224, 2229, 2231, 2240, 2242, 2243, 2248, 2250, - 2252, 2257, 2259, 2261, 2266, 2268, 2270, 2279, 2280, 2281, - 2285, 2287, 2289, 2294, 2296, 2298, 2303, 2305, 2307, 2322, - 2324, 2325, 2327, 2332, 2333, 2338, 2340, 2342, 2347, 2349, - 2351, 2353, 2358, 2360, 2362, 2372, 2374, 2375, 2377, 2382, - 2384, 2386, 2391, 2393, 2395, 2397, 2402, 2404, 2406, 2437, - 2439, 2440, 2442, 2447, 2452, 2460, 2462, 2464, 2469, 2471, - 2476, 2478, 2492, 2493, 2495, 2500, 2502, 2504, 2506, 2508, - 2513, 2514, 2516, 2518, 2523, 2525, 2527, 2533, 2535, 2537, - 2541, 2543, 2545, 2547, 2561, 2562, 2564, 2569, 2571, 2573, - 2575, 2577, 2582, 2583, 2585, 2587, 2592, 2594, 2596, 2602, - 2603, 2605, 2614, 2617, 2619, 2622, 2624, 2626, 2639, 2640, - 2642, 2647, 2649, 2651, 2653, 2655, 2660, 2661, 2663, 2665, - 2670, 2672, 2680, 2681, 2682, 2687, 2688, 2692, 2694, 2696, - 2698, 2700, 2702, 2709, 2711, 2713, 2715, 2717, 2719, 2721, - 2723, 2725, 2727, 2732, 2734, 2736, 2741, 2767, 2768, 2770, - 2774, 2775, 2779, 2781, 2783, 2785, 2787, 2789, 2796, 2798, - 2800, 2802, 2804, 2806, 2811, 2816, 2818, 2820, 2838, 2840, - 2845, 2846 + 0, 302, 302, 306, 313, 314, 315, 319, 320, 321, + 325, 326, 330, 331, 335, 336, 340, 344, 345, 356, + 358, 360, 362, 367, 368, 374, 378, 380, 382, 384, + 386, 388, 390, 392, 394, 403, 404, 410, 411, 415, + 416, 420, 424, 426, 428, 430, 435, 436, 440, 443, + 445, 447, 452, 465, 467, 469, 471, 473, 475, 477, + 479, 481, 483, 485, 492, 493, 499, 500, 501, 502, + 506, 507, 509, 514, 515, 517, 519, 524, 525, 527, + 532, 533, 535, 540, 541, 543, 545, 547, 552, 553, + 555, 560, 561, 566, 567, 572, 573, 578, 579, 584, + 585, 590, 591, 594, 596, 601, 606, 607, 609, 615, + 616, 620, 621, 622, 623, 624, 625, 626, 627, 628, + 629, 630, 631, 637, 639, 641, 643, 648, 649, 654, + 655, 661, 662, 668, 669, 670, 671, 672, 673, 674, + 675, 676, 686, 693, 695, 705, 706, 711, 713, 719, + 721, 725, 726, 731, 736, 739, 741, 743, 753, 755, + 766, 767, 769, 773, 775, 779, 780, 785, 786, 790, + 795, 796, 800, 802, 808, 809, 813, 815, 817, 819, + 825, 826, 830, 832, 837, 839, 841, 846, 848, 853, + 855, 859, 862, 866, 869, 873, 875, 877, 879, 884, + 886, 888, 893, 895, 897, 899, 901, 906, 908, 910, + 912, 917, 929, 930, 935, 937, 942, 946, 948, 950, + 952, 954, 960, 961, 967, 968, 972, 973, 978, 980, + 986, 987, 989, 994, 999, 1009, 1011, 1015, 1016, 1021, + 1023, 1027, 1028, 1032, 1034, 1038, 1039, 1043, 1044, 1048, + 1049, 1064, 1065, 1066, 1067, 1068, 1072, 1077, 1084, 1094, + 1099, 1104, 1112, 1117, 1122, 1127, 1132, 1140, 1162, 1167, + 1174, 1176, 1183, 1188, 1193, 1204, 1209, 1214, 1219, 1224, + 1233, 1238, 1246, 1247, 1248, 1249, 1255, 1260, 1268, 1269, + 1270, 1271, 1275, 1276, 1277, 1278, 1283, 1284, 1293, 1294, + 1299, 1300, 1305, 1307, 1309, 1311, 1313, 1316, 1315, 1327, + 1328, 1330, 1340, 1341, 1346, 1348, 1350, 1352, 1354, 1357, + 1359, 1362, 1367, 1369, 1371, 1373, 1375, 1377, 1379, 1381, + 1383, 1385, 1387, 1389, 1391, 1397, 1398, 1400, 1402, 1404, + 1409, 1410, 1416, 1417, 1419, 1421, 1426, 1428, 1430, 1432, + 1437, 1438, 1440, 1442, 1447, 1448, 1450, 1455, 1456, 1458, + 1460, 1465, 1467, 1469, 1474, 1475, 1479, 1481, 1487, 1486, + 1490, 1492, 1497, 1499, 1505, 1506, 1511, 1512, 1514, 1515, + 1524, 1525, 1527, 1529, 1534, 1536, 1542, 1543, 1545, 1548, + 1551, 1556, 1557, 1562, 1567, 1571, 1573, 1579, 1578, 1585, + 1587, 1593, 1594, 1602, 1603, 1607, 1608, 1609, 1611, 1613, + 1620, 1621, 1623, 1625, 1630, 1631, 1637, 1638, 1642, 1643, + 1648, 1649, 1650, 1652, 1660, 1661, 1663, 1666, 1668, 1672, + 1673, 1674, 1676, 1678, 1682, 1687, 1695, 1696, 1705, 1707, + 1712, 1713, 1714, 1718, 1719, 1720, 1724, 1725, 1726, 1730, + 1731, 1732, 1737, 1738, 1739, 1740, 1746, 1747, 1749, 1754, + 1755, 1760, 1761, 1762, 1763, 1764, 1779, 1780, 1785, 1786, + 1792, 1794, 1797, 1799, 1801, 1824, 1825, 1827, 1829, 1834, + 1835, 1837, 1842, 1847, 1848, 1854, 1853, 1857, 1861, 1863, + 1865, 1871, 1872, 1877, 1882, 1884, 1889, 1891, 1892, 1894, + 1899, 1901, 1903, 1908, 1910, 1915, 1920, 1928, 1934, 1933, + 1947, 1948, 1953, 1954, 1958, 1963, 1968, 1976, 1981, 1992, + 1993, 1998, 1999, 2005, 2006, 2010, 2011, 2012, 2015, 2014, + 2025, 2034, 2040, 2046, 2055, 2061, 2067, 2073, 2079, 2087, + 2093, 2101, 2107, 2116, 2117, 2118, 2122, 2126, 2128, 2133, + 2134, 2138, 2139, 2144, 2150, 2151, 2154, 2156, 2157, 2161, + 2162, 2163, 2164, 2198, 2200, 2201, 2203, 2208, 2213, 2218, + 2220, 2222, 2227, 2229, 2231, 2233, 2238, 2240, 2249, 2251, + 2252, 2257, 2259, 2261, 2266, 2268, 2270, 2275, 2277, 2279, + 2288, 2289, 2290, 2294, 2296, 2298, 2303, 2305, 2307, 2312, + 2314, 2316, 2331, 2333, 2334, 2336, 2341, 2342, 2347, 2349, + 2351, 2356, 2358, 2360, 2362, 2367, 2369, 2371, 2381, 2383, + 2384, 2386, 2391, 2393, 2395, 2400, 2402, 2404, 2406, 2411, + 2413, 2415, 2446, 2448, 2449, 2451, 2456, 2461, 2469, 2471, + 2473, 2478, 2480, 2485, 2487, 2501, 2502, 2504, 2509, 2511, + 2513, 2515, 2517, 2522, 2523, 2525, 2527, 2532, 2534, 2536, + 2542, 2544, 2546, 2550, 2552, 2554, 2556, 2570, 2571, 2573, + 2578, 2580, 2582, 2584, 2586, 2591, 2592, 2594, 2596, 2601, + 2603, 2605, 2611, 2612, 2614, 2623, 2626, 2628, 2631, 2633, + 2635, 2648, 2649, 2651, 2656, 2658, 2660, 2662, 2664, 2669, + 2670, 2672, 2674, 2679, 2681, 2689, 2690, 2691, 2696, 2697, + 2701, 2703, 2705, 2707, 2709, 2711, 2718, 2720, 2722, 2724, + 2726, 2728, 2730, 2732, 2734, 2736, 2741, 2743, 2745, 2750, + 2776, 2777, 2779, 2783, 2784, 2788, 2790, 2792, 2794, 2796, + 2798, 2805, 2807, 2809, 2811, 2813, 2815, 2820, 2825, 2827, + 2829, 2847, 2849, 2854, 2855 }; #endif @@ -1128,28 +1130,28 @@ "string_literal", "string_literal_list", "primary_expression", "postfix_expression", "argument_expression_list", "argument_expression", - "field_list", "field", "unary_expression", "ptrref_operator", - "unary_operator", "cast_expression", "multiplicative_expression", - "additive_expression", "shift_expression", "relational_expression", - "equality_expression", "AND_expression", "exclusive_OR_expression", - "inclusive_OR_expression", "logical_AND_expression", - "logical_OR_expression", "conditional_expression", "constant_expression", - "assignment_expression", "assignment_expression_opt", - "assignment_operator", "tuple", "tuple_expression_list", - "comma_expression", "comma_expression_opt", "statement", - "labeled_statement", "compound_statement", "block_item_list", - "block_item", "statement_list", "expression_statement", - "selection_statement", "case_value", "case_value_list", "case_label", - "case_label_list", "case_clause", "switch_clause_list_opt", - "switch_clause_list", "choose_clause_list_opt", "choose_clause_list", - "fall_through_opt", "fall_through", "iteration_statement", - "for_control_expression", "jump_statement", "exception_statement", - "handler_list", "handler_clause", "finally_clause", - "exception_declaration", "asm_statement", "asm_volatile_opt", - "asm_operands_opt", "asm_operands_list", "asm_operand", - "asm_clobbers_list_opt", "label_list", "declaration_list_opt", - "declaration_list", "old_declaration_list_opt", "old_declaration_list", - "local_label_declaration_opt", "local_label_declaration_list", - "local_label_list", "declaration", "new_declaration", - "new_variable_declaration", "new_variable_specifier", + "field_list", "field", "field_name", "unary_expression", + "ptrref_operator", "unary_operator", "cast_expression", + "multiplicative_expression", "additive_expression", "shift_expression", + "relational_expression", "equality_expression", "AND_expression", + "exclusive_OR_expression", "inclusive_OR_expression", + "logical_AND_expression", "logical_OR_expression", + "conditional_expression", "constant_expression", "assignment_expression", + "assignment_expression_opt", "assignment_operator", "tuple", + "tuple_expression_list", "comma_expression", "comma_expression_opt", + "statement", "labeled_statement", "compound_statement", + "block_item_list", "block_item", "statement_list", + "expression_statement", "selection_statement", "case_value", + "case_value_list", "case_label", "case_label_list", "case_clause", + "switch_clause_list_opt", "switch_clause_list", "choose_clause_list_opt", + "choose_clause_list", "fall_through_opt", "fall_through", + "iteration_statement", "for_control_expression", "jump_statement", + "exception_statement", "handler_list", "handler_clause", + "finally_clause", "exception_declaration", "asm_statement", + "asm_volatile_opt", "asm_operands_opt", "asm_operands_list", + "asm_operand", "asm_clobbers_list_opt", "label_list", + "declaration_list_opt", "declaration_list", "old_declaration_list_opt", + "old_declaration_list", "local_label_declaration_opt", + "local_label_declaration_list", "local_label_list", "declaration", + "new_declaration", "new_variable_declaration", "new_variable_specifier", "new_function_declaration", "new_function_specifier", "new_function_return", "new_typedef_declaration", "typedef_declaration", @@ -1241,77 +1243,77 @@ 138, 138, 139, 139, 140, 140, 141, 142, 142, 143, 143, 143, 143, 144, 144, 144, 144, 144, 144, 144, - 144, 144, 144, 144, 145, 145, 146, 146, 147, 147, - 148, 148, 148, 148, 148, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 150, 150, 151, 151, 151, 151, 152, 152, 152, - 153, 153, 153, 153, 154, 154, 154, 155, 155, 155, - 156, 156, 156, 156, 156, 157, 157, 157, 158, 158, - 159, 159, 160, 160, 161, 161, 162, 162, 163, 163, - 163, 163, 164, 165, 165, 165, 166, 166, 167, 167, - 167, 167, 167, 167, 167, 167, 167, 167, 167, 167, - 168, 168, 168, 168, 169, 169, 170, 170, 171, 171, - 172, 172, 172, 172, 172, 172, 172, 172, 172, 173, - 174, 174, 175, 175, 176, 176, 176, 176, 177, 177, - 178, 179, 179, 179, 179, 179, 179, 180, 180, 180, - 181, 181, 182, 182, 183, 183, 184, 185, 185, 186, - 186, 187, 187, 188, 188, 188, 188, 189, 189, 190, - 190, 191, 191, 191, 192, 192, 193, 193, 193, 193, - 193, 193, 193, 193, 193, 193, 194, 194, 194, 195, - 195, 195, 195, 195, 196, 196, 196, 196, 197, 198, - 198, 198, 198, 198, 199, 199, 199, 199, 199, 200, - 200, 201, 201, 202, 202, 203, 203, 204, 204, 204, - 205, 205, 206, 206, 207, 207, 208, 208, 209, 209, - 210, 210, 211, 211, 212, 212, 213, 213, 214, 214, - 214, 214, 214, 215, 215, 215, 216, 216, 216, 217, - 217, 217, 217, 217, 218, 218, 218, 219, 219, 220, - 220, 220, 221, 221, 221, 221, 221, 222, 222, 223, - 223, 223, 223, 224, 224, 225, 225, 225, 225, 226, - 226, 226, 226, 227, 227, 228, 228, 229, 229, 230, - 230, 230, 230, 230, 231, 230, 232, 232, 232, 233, - 233, 234, 234, 234, 234, 234, 234, 234, 234, 235, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 235, 235, 236, 236, 236, 236, 236, 237, 237, 238, - 238, 238, 238, 239, 239, 239, 239, 240, 240, 240, - 240, 241, 241, 241, 242, 242, 242, 242, 243, 243, - 243, 244, 244, 245, 245, 246, 245, 245, 245, 247, - 247, 248, 248, 249, 249, 249, 249, 250, 250, 250, - 250, 251, 251, 252, 252, 252, 252, 252, 253, 253, - 254, 255, 256, 256, 257, 256, 258, 258, 259, 259, - 260, 260, 261, 261, 261, 261, 261, 262, 262, 262, - 262, 263, 263, 264, 264, 265, 265, 266, 266, 266, - 266, 267, 267, 267, 267, 267, 268, 268, 268, 268, - 268, 269, 269, 270, 270, 271, 271, 272, 272, 272, + 144, 144, 144, 144, 144, 145, 145, 146, 146, 147, + 147, 148, 148, 148, 148, 148, 149, 149, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 151, 151, 152, 152, 152, 152, + 153, 153, 153, 154, 154, 154, 154, 155, 155, 155, + 156, 156, 156, 157, 157, 157, 157, 157, 158, 158, + 158, 159, 159, 160, 160, 161, 161, 162, 162, 163, + 163, 164, 164, 164, 164, 165, 166, 166, 166, 167, + 167, 168, 168, 168, 168, 168, 168, 168, 168, 168, + 168, 168, 168, 169, 169, 169, 169, 170, 170, 171, + 171, 172, 172, 173, 173, 173, 173, 173, 173, 173, + 173, 173, 174, 175, 175, 176, 176, 177, 177, 177, + 177, 178, 178, 179, 180, 180, 180, 180, 180, 180, + 181, 181, 181, 182, 182, 183, 183, 184, 184, 185, + 186, 186, 187, 187, 188, 188, 189, 189, 189, 189, + 190, 190, 191, 191, 192, 192, 192, 193, 193, 194, + 194, 194, 194, 194, 194, 194, 194, 194, 194, 195, + 195, 195, 196, 196, 196, 196, 196, 197, 197, 197, + 197, 198, 199, 199, 199, 199, 199, 200, 200, 200, + 200, 200, 201, 201, 202, 202, 203, 203, 204, 204, + 205, 205, 205, 206, 206, 207, 207, 208, 208, 209, + 209, 210, 210, 211, 211, 212, 212, 213, 213, 214, + 214, 215, 215, 215, 215, 215, 216, 216, 216, 217, + 217, 217, 218, 218, 218, 218, 218, 219, 219, 219, + 220, 220, 221, 221, 221, 222, 222, 222, 222, 222, + 223, 223, 224, 224, 224, 224, 225, 225, 226, 226, + 226, 226, 227, 227, 227, 227, 228, 228, 229, 229, + 230, 230, 231, 231, 231, 231, 231, 232, 231, 233, + 233, 233, 234, 234, 235, 235, 235, 235, 235, 235, + 235, 235, 236, 236, 236, 236, 236, 236, 236, 236, + 236, 236, 236, 236, 236, 237, 237, 237, 237, 237, + 238, 238, 239, 239, 239, 239, 240, 240, 240, 240, + 241, 241, 241, 241, 242, 242, 242, 243, 243, 243, + 243, 244, 244, 244, 245, 245, 246, 246, 247, 246, + 246, 246, 248, 248, 249, 249, 250, 250, 250, 250, + 251, 251, 251, 251, 252, 252, 253, 253, 253, 253, + 253, 254, 254, 255, 256, 257, 257, 258, 257, 259, + 259, 260, 260, 261, 261, 262, 262, 262, 262, 262, + 263, 263, 263, 263, 264, 264, 265, 265, 266, 266, + 267, 267, 267, 267, 268, 268, 268, 268, 268, 269, + 269, 269, 269, 269, 270, 270, 271, 271, 272, 272, 273, 273, 273, 274, 274, 274, 275, 275, 275, 276, - 276, 276, 276, 277, 277, 277, 278, 278, 279, 279, - 279, 279, 279, 280, 280, 281, 281, 282, 282, 282, - 282, 282, 283, 283, 283, 283, 284, 284, 284, 285, - 286, 286, 288, 287, 287, 289, 289, 289, 290, 290, - 291, 291, 291, 292, 292, 292, 292, 293, 293, 293, - 294, 294, 295, 295, 296, 297, 296, 298, 298, 299, - 299, 300, 300, 300, 301, 301, 302, 302, 303, 303, - 304, 304, 305, 305, 305, 306, 305, 305, 307, 307, - 307, 308, 308, 308, 308, 308, 308, 308, 308, 308, - 309, 309, 309, 310, 311, 311, 312, 312, 313, 313, - 314, 315, 315, 316, 316, 316, 317, 317, 317, 317, - 318, 318, 318, 318, 319, 319, 320, 320, 320, 321, - 321, 321, 321, 322, 322, 323, 323, 323, 324, 324, + 276, 276, 277, 277, 277, 277, 278, 278, 278, 279, + 279, 280, 280, 280, 280, 280, 281, 281, 282, 282, + 283, 283, 283, 283, 283, 284, 284, 284, 284, 285, + 285, 285, 286, 287, 287, 289, 288, 288, 290, 290, + 290, 291, 291, 292, 292, 292, 293, 293, 293, 293, + 294, 294, 294, 295, 295, 296, 296, 297, 298, 297, + 299, 299, 300, 300, 301, 301, 301, 302, 302, 303, + 303, 304, 304, 305, 305, 306, 306, 306, 307, 306, + 306, 308, 308, 308, 309, 309, 309, 309, 309, 309, + 309, 309, 309, 310, 310, 310, 311, 312, 312, 313, + 313, 314, 314, 315, 316, 316, 317, 317, 317, 318, + 318, 318, 318, 319, 319, 319, 319, 320, 320, 321, + 321, 321, 322, 322, 322, 322, 323, 323, 324, 324, 324, 325, 325, 325, 326, 326, 326, 327, 327, 327, 328, 328, 328, 329, 329, 329, 330, 330, 330, 331, - 331, 331, 331, 332, 332, 333, 333, 333, 334, 334, - 334, 334, 335, 335, 335, 336, 336, 336, 336, 337, - 337, 337, 338, 338, 338, 338, 339, 339, 339, 340, - 340, 340, 340, 341, 341, 342, 342, 342, 343, 343, - 344, 344, 345, 345, 345, 346, 346, 346, 346, 346, - 347, 347, 347, 347, 348, 348, 348, 349, 349, 349, - 350, 350, 350, 350, 351, 351, 351, 352, 352, 352, - 352, 352, 353, 353, 353, 353, 354, 354, 354, 355, - 355, 355, 356, 356, 356, 356, 356, 356, 357, 357, - 357, 358, 358, 358, 358, 358, 359, 359, 359, 359, - 360, 360, 361, 361, 361, 362, 362, 363, 363, 363, - 363, 363, 363, 364, 364, 364, 364, 364, 364, 364, - 364, 364, 364, 365, 365, 365, 365, 366, 366, 366, - 367, 367, 368, 368, 368, 368, 368, 368, 369, 369, - 369, 369, 369, 369, 370, 371, 371, 371, 372, 372, - 373, 373 + 331, 331, 332, 332, 332, 332, 333, 333, 334, 334, + 334, 335, 335, 335, 335, 336, 336, 336, 337, 337, + 337, 337, 338, 338, 338, 339, 339, 339, 339, 340, + 340, 340, 341, 341, 341, 341, 342, 342, 343, 343, + 343, 344, 344, 345, 345, 346, 346, 346, 347, 347, + 347, 347, 347, 348, 348, 348, 348, 349, 349, 349, + 350, 350, 350, 351, 351, 351, 351, 352, 352, 352, + 353, 353, 353, 353, 353, 354, 354, 354, 354, 355, + 355, 355, 356, 356, 356, 357, 357, 357, 357, 357, + 357, 358, 358, 358, 359, 359, 359, 359, 359, 360, + 360, 360, 360, 361, 361, 362, 362, 362, 363, 363, + 364, 364, 364, 364, 364, 364, 365, 365, 365, 365, + 365, 365, 365, 365, 365, 365, 366, 366, 366, 366, + 367, 367, 367, 368, 368, 369, 369, 369, 369, 369, + 369, 370, 370, 370, 370, 370, 370, 371, 372, 372, + 372, 373, 373, 374, 374 }; @@ -1321,78 +1323,78 @@ 0, 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, - 1, 3, 3, 1, 6, 4, 3, 7, 3, 7, - 2, 2, 7, 4, 1, 3, 0, 1, 1, 3, - 1, 3, 7, 3, 7, 1, 1, 1, 2, 2, - 2, 2, 2, 2, 4, 2, 4, 6, 1, 4, - 4, 1, 1, 1, 1, 1, 1, 1, 4, 4, - 1, 3, 3, 3, 1, 3, 3, 1, 3, 3, - 1, 3, 3, 3, 3, 1, 3, 3, 1, 3, - 1, 3, 1, 3, 1, 3, 1, 3, 1, 5, - 4, 5, 1, 1, 3, 2, 0, 1, 1, 1, + 1, 3, 3, 1, 6, 4, 3, 7, 3, 3, + 7, 2, 2, 7, 4, 1, 3, 0, 1, 1, + 3, 1, 3, 7, 3, 7, 1, 1, 1, 1, + 1, 2, 2, 2, 2, 2, 2, 4, 2, 4, + 6, 1, 4, 4, 1, 1, 1, 1, 1, 1, + 1, 4, 4, 1, 3, 3, 3, 1, 3, 3, + 1, 3, 3, 1, 3, 3, 3, 3, 1, 3, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, + 3, 1, 5, 4, 5, 1, 1, 3, 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 2, 5, 6, 7, 1, 3, 1, 3, 0, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 6, 4, - 2, 7, 1, 3, 1, 2, 1, 2, 1, 2, - 2, 5, 7, 5, 9, 5, 9, 1, 3, 1, - 1, 3, 3, 2, 1, 2, 2, 0, 1, 2, - 3, 0, 1, 2, 3, 3, 4, 0, 1, 1, - 2, 5, 7, 6, 6, 4, 3, 4, 2, 3, - 2, 3, 3, 3, 3, 5, 3, 3, 4, 1, - 5, 6, 5, 6, 9, 10, 9, 10, 2, 1, - 2, 2, 2, 1, 6, 8, 10, 12, 14, 0, - 1, 0, 1, 1, 3, 4, 7, 0, 1, 3, - 1, 3, 1, 1, 1, 3, 1, 1, 1, 3, - 0, 1, 3, 4, 1, 3, 1, 1, 3, 3, - 3, 3, 3, 2, 3, 6, 3, 3, 4, 1, - 2, 2, 3, 5, 8, 7, 7, 5, 9, 2, - 2, 5, 3, 5, 4, 3, 4, 4, 7, 3, - 3, 3, 3, 4, 6, 1, 1, 1, 1, 1, - 1, 1, 1, 0, 1, 1, 2, 1, 1, 1, - 1, 1, 1, 1, 0, 5, 1, 2, 3, 1, - 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 5, 6, 7, 1, 3, 1, + 3, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 6, 4, 2, 7, 1, 3, 1, 2, 1, + 2, 1, 2, 2, 5, 7, 5, 9, 5, 9, + 1, 3, 1, 1, 3, 3, 2, 1, 2, 2, + 0, 1, 2, 3, 0, 1, 2, 3, 3, 4, + 0, 1, 1, 2, 5, 7, 6, 6, 4, 3, + 4, 2, 3, 2, 3, 3, 3, 3, 5, 3, + 3, 4, 1, 5, 6, 5, 6, 9, 10, 9, + 10, 2, 1, 2, 2, 2, 1, 6, 8, 10, + 12, 14, 0, 1, 0, 1, 1, 3, 4, 7, + 0, 1, 3, 1, 3, 1, 1, 1, 3, 1, + 1, 1, 3, 0, 1, 3, 4, 1, 3, 1, + 1, 3, 3, 3, 3, 3, 2, 3, 6, 3, + 3, 4, 1, 2, 2, 3, 5, 8, 7, 7, + 5, 9, 2, 2, 5, 3, 5, 4, 3, 4, + 4, 7, 3, 3, 3, 3, 4, 6, 1, 1, + 1, 1, 1, 1, 1, 1, 0, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 0, 5, 1, + 2, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 2, 2, 3, 3, 1, 3, 1, - 2, 2, 2, 4, 4, 4, 4, 1, 2, 2, - 3, 1, 2, 2, 1, 2, 2, 3, 1, 2, - 2, 1, 1, 4, 2, 0, 6, 7, 2, 2, - 2, 0, 2, 2, 3, 2, 3, 1, 2, 3, - 2, 2, 4, 0, 1, 2, 2, 1, 0, 1, - 2, 2, 5, 2, 0, 7, 2, 4, 0, 2, - 0, 1, 1, 1, 5, 5, 5, 1, 5, 5, - 9, 1, 5, 0, 1, 1, 5, 1, 1, 5, - 5, 1, 3, 3, 4, 1, 1, 1, 1, 2, - 1, 3, 3, 1, 2, 1, 3, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, - 1, 1, 2, 0, 2, 2, 1, 4, 0, 1, - 2, 3, 4, 2, 2, 1, 2, 2, 5, 5, - 7, 6, 1, 2, 2, 3, 1, 2, 2, 4, - 2, 4, 0, 4, 2, 1, 1, 1, 0, 2, - 5, 5, 13, 1, 1, 3, 3, 2, 3, 3, - 2, 4, 1, 6, 9, 0, 11, 1, 3, 3, - 3, 1, 1, 5, 2, 5, 0, 1, 1, 3, - 0, 1, 1, 1, 1, 0, 6, 2, 1, 2, - 4, 2, 3, 3, 3, 4, 5, 5, 5, 6, - 1, 1, 1, 3, 0, 5, 0, 1, 1, 2, - 6, 1, 3, 0, 1, 4, 1, 1, 1, 1, - 2, 1, 2, 2, 1, 3, 2, 3, 3, 2, - 4, 4, 3, 8, 3, 2, 1, 2, 6, 8, - 3, 2, 3, 3, 4, 4, 3, 1, 1, 1, - 4, 6, 3, 2, 3, 3, 4, 4, 3, 2, - 1, 2, 2, 1, 3, 2, 3, 3, 2, 4, - 4, 3, 6, 8, 3, 2, 1, 2, 2, 2, - 3, 3, 2, 4, 4, 3, 6, 8, 3, 2, - 1, 2, 2, 1, 1, 2, 3, 3, 2, 4, - 6, 8, 1, 2, 2, 1, 2, 2, 3, 3, - 1, 4, 4, 3, 5, 8, 3, 2, 3, 1, - 5, 5, 6, 6, 1, 2, 2, 1, 2, 2, - 3, 3, 1, 4, 4, 3, 5, 8, 3, 1, - 2, 1, 2, 6, 5, 6, 7, 7, 1, 2, - 2, 1, 2, 2, 3, 3, 1, 4, 4, 3, - 8, 3, 1, 1, 2, 1, 1, 2, 3, 2, - 3, 2, 3, 3, 2, 4, 3, 2, 3, 2, - 4, 3, 2, 6, 6, 6, 7, 1, 2, 1, - 1, 1, 2, 3, 2, 3, 2, 3, 3, 4, - 2, 3, 4, 2, 5, 5, 6, 6, 0, 1, - 0, 2 + 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, + 1, 3, 1, 2, 2, 2, 4, 4, 4, 4, + 1, 2, 2, 3, 1, 2, 2, 1, 2, 2, + 3, 1, 2, 2, 1, 1, 4, 2, 0, 6, + 7, 2, 2, 2, 0, 2, 2, 3, 2, 3, + 1, 2, 3, 2, 2, 4, 0, 1, 2, 2, + 1, 0, 1, 2, 2, 5, 2, 0, 7, 2, + 4, 0, 2, 0, 1, 1, 1, 5, 5, 5, + 1, 5, 5, 9, 1, 5, 0, 1, 1, 5, + 1, 1, 5, 5, 1, 3, 3, 4, 1, 1, + 1, 1, 2, 1, 3, 3, 1, 2, 1, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 2, 0, 2, 2, 1, + 4, 0, 1, 2, 3, 4, 2, 2, 1, 2, + 2, 5, 5, 7, 6, 1, 2, 2, 3, 1, + 2, 2, 4, 2, 4, 0, 4, 2, 1, 1, + 1, 0, 2, 5, 5, 13, 1, 1, 3, 3, + 2, 3, 3, 2, 4, 1, 6, 9, 0, 11, + 1, 3, 3, 3, 1, 1, 5, 2, 5, 0, + 1, 1, 3, 0, 1, 1, 1, 1, 0, 6, + 2, 1, 2, 4, 2, 3, 3, 3, 4, 5, + 5, 5, 6, 1, 1, 1, 3, 0, 5, 0, + 1, 1, 2, 6, 1, 3, 0, 1, 4, 1, + 1, 1, 1, 2, 1, 2, 2, 1, 3, 2, + 3, 3, 2, 4, 4, 3, 8, 3, 2, 1, + 2, 6, 8, 3, 2, 3, 3, 4, 4, 3, + 1, 1, 1, 4, 6, 3, 2, 3, 3, 4, + 4, 3, 2, 1, 2, 2, 1, 3, 2, 3, + 3, 2, 4, 4, 3, 6, 8, 3, 2, 1, + 2, 2, 2, 3, 3, 2, 4, 4, 3, 6, + 8, 3, 2, 1, 2, 2, 1, 1, 2, 3, + 3, 2, 4, 6, 8, 1, 2, 2, 1, 2, + 2, 3, 3, 1, 4, 4, 3, 5, 8, 3, + 2, 3, 1, 5, 5, 6, 6, 1, 2, 2, + 1, 2, 2, 3, 3, 1, 4, 4, 3, 5, + 8, 3, 1, 2, 1, 2, 6, 5, 6, 7, + 7, 1, 2, 2, 1, 2, 2, 3, 3, 1, + 4, 4, 3, 8, 3, 1, 1, 2, 1, 1, + 2, 3, 2, 3, 2, 3, 3, 2, 4, 3, + 2, 3, 2, 4, 3, 2, 6, 6, 6, 7, + 1, 2, 1, 1, 1, 2, 3, 2, 3, 2, + 3, 3, 4, 2, 3, 4, 2, 5, 5, 6, + 6, 0, 1, 0, 2 }; @@ -1402,160 +1404,160 @@ static const yytype_uint16 yydefact[] = { - 293, 293, 313, 311, 314, 312, 315, 316, 299, 301, - 300, 0, 302, 327, 319, 324, 322, 323, 321, 320, - 325, 326, 331, 328, 329, 330, 546, 546, 546, 0, - 0, 0, 293, 219, 303, 317, 318, 7, 358, 0, - 8, 14, 15, 0, 2, 61, 62, 564, 9, 293, - 524, 522, 246, 3, 453, 3, 259, 0, 3, 3, - 3, 247, 3, 0, 0, 0, 294, 295, 297, 293, - 306, 309, 339, 285, 332, 337, 286, 347, 287, 354, - 351, 361, 0, 0, 362, 288, 472, 476, 3, 3, - 0, 2, 518, 523, 528, 298, 0, 0, 546, 576, - 546, 2, 587, 588, 589, 293, 0, 730, 731, 0, - 12, 0, 13, 293, 269, 270, 0, 294, 289, 290, - 291, 292, 525, 304, 391, 547, 548, 369, 370, 12, - 444, 445, 11, 440, 443, 0, 502, 497, 488, 444, - 445, 0, 0, 527, 220, 0, 293, 0, 0, 0, - 0, 0, 0, 0, 0, 293, 293, 2, 0, 732, - 294, 581, 593, 736, 729, 727, 734, 0, 0, 0, - 253, 2, 0, 531, 438, 439, 437, 0, 0, 0, - 0, 546, 0, 633, 634, 0, 0, 544, 540, 546, - 561, 546, 546, 542, 2, 541, 546, 600, 546, 546, - 603, 0, 0, 0, 293, 293, 311, 359, 2, 293, - 260, 296, 307, 340, 352, 477, 0, 2, 0, 453, - 261, 294, 333, 348, 355, 473, 0, 2, 0, 310, - 334, 341, 342, 0, 349, 353, 356, 360, 445, 293, - 371, 364, 368, 0, 393, 474, 478, 0, 0, 0, - 1, 293, 2, 529, 575, 577, 293, 2, 740, 294, - 743, 544, 544, 0, 294, 0, 0, 272, 546, 542, - 2, 293, 0, 0, 293, 549, 2, 500, 2, 553, - 0, 0, 0, 0, 0, 0, 19, 58, 4, 5, - 6, 17, 0, 0, 293, 2, 63, 64, 65, 66, - 46, 20, 47, 16, 23, 45, 67, 293, 0, 70, - 74, 77, 80, 85, 88, 90, 92, 94, 96, 98, - 103, 494, 750, 451, 493, 0, 449, 450, 0, 565, - 580, 583, 586, 592, 595, 598, 358, 0, 2, 738, - 0, 293, 741, 2, 61, 293, 3, 425, 0, 433, - 294, 293, 306, 332, 286, 347, 354, 3, 3, 407, - 411, 421, 426, 472, 293, 427, 705, 706, 293, 428, - 430, 293, 2, 582, 594, 728, 2, 2, 248, 2, - 458, 0, 456, 455, 454, 140, 2, 2, 250, 2, - 2, 249, 2, 280, 2, 281, 0, 279, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 566, 605, 0, - 453, 2, 560, 569, 659, 562, 563, 532, 293, 2, - 599, 608, 601, 602, 0, 275, 293, 293, 338, 294, - 0, 294, 0, 293, 733, 737, 735, 533, 293, 544, - 254, 262, 308, 0, 2, 534, 293, 498, 335, 336, - 282, 350, 357, 0, 293, 0, 748, 398, 0, 475, - 499, 251, 252, 519, 293, 435, 0, 293, 236, 0, - 2, 238, 0, 294, 0, 256, 2, 257, 277, 0, - 0, 2, 293, 544, 293, 485, 487, 486, 0, 0, - 750, 0, 293, 0, 293, 489, 293, 559, 557, 558, - 556, 0, 551, 554, 0, 0, 293, 53, 293, 67, - 48, 293, 55, 293, 293, 51, 52, 2, 126, 0, - 0, 447, 0, 446, 727, 120, 293, 18, 0, 30, - 31, 36, 2, 0, 36, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 109, 108, 0, 49, 50, + 296, 296, 316, 314, 317, 315, 318, 319, 302, 304, + 303, 0, 305, 330, 322, 327, 325, 326, 324, 323, + 328, 329, 334, 331, 332, 333, 549, 549, 549, 0, + 0, 0, 296, 222, 306, 320, 321, 7, 361, 0, + 8, 14, 15, 0, 2, 64, 65, 567, 9, 296, + 527, 525, 249, 3, 456, 3, 262, 0, 3, 3, + 3, 250, 3, 0, 0, 0, 297, 298, 300, 296, + 309, 312, 342, 288, 335, 340, 289, 350, 290, 357, + 354, 364, 0, 0, 365, 291, 475, 479, 3, 3, + 0, 2, 521, 526, 531, 301, 0, 0, 549, 579, + 549, 2, 590, 591, 592, 296, 0, 733, 734, 0, + 12, 0, 13, 296, 272, 273, 0, 297, 292, 293, + 294, 295, 528, 307, 394, 550, 551, 372, 373, 12, + 447, 448, 11, 443, 446, 0, 505, 500, 491, 447, + 448, 0, 0, 530, 223, 0, 296, 0, 0, 0, + 0, 0, 0, 0, 0, 296, 296, 2, 0, 735, + 297, 584, 596, 739, 732, 730, 737, 0, 0, 0, + 256, 2, 0, 534, 441, 442, 440, 0, 0, 0, + 0, 549, 0, 636, 637, 0, 0, 547, 543, 549, + 564, 549, 549, 545, 2, 544, 549, 603, 549, 549, + 606, 0, 0, 0, 296, 296, 314, 362, 2, 296, + 263, 299, 310, 343, 355, 480, 0, 2, 0, 456, + 264, 297, 336, 351, 358, 476, 0, 2, 0, 313, + 337, 344, 345, 0, 352, 356, 359, 363, 448, 296, + 374, 367, 371, 0, 396, 477, 481, 0, 0, 0, + 1, 296, 2, 532, 578, 580, 296, 2, 743, 297, + 746, 547, 547, 0, 297, 0, 0, 275, 549, 545, + 2, 296, 0, 0, 296, 552, 2, 503, 2, 556, + 0, 0, 0, 0, 0, 0, 19, 61, 4, 5, + 6, 17, 0, 0, 296, 2, 66, 67, 68, 69, + 49, 20, 50, 16, 23, 48, 70, 296, 0, 73, + 77, 80, 83, 88, 91, 93, 95, 97, 99, 101, + 106, 497, 753, 454, 496, 0, 452, 453, 0, 568, + 583, 586, 589, 595, 598, 601, 361, 0, 2, 741, + 0, 296, 744, 2, 64, 296, 3, 428, 0, 436, + 297, 296, 309, 335, 289, 350, 357, 3, 3, 410, + 414, 424, 429, 475, 296, 430, 708, 709, 296, 431, + 433, 296, 2, 585, 597, 731, 2, 2, 251, 2, + 461, 0, 459, 458, 457, 143, 2, 2, 253, 2, + 2, 252, 2, 283, 2, 284, 0, 282, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 569, 608, 0, + 456, 2, 563, 572, 662, 565, 566, 535, 296, 2, + 602, 611, 604, 605, 0, 278, 296, 296, 341, 297, + 0, 297, 0, 296, 736, 740, 738, 536, 296, 547, + 257, 265, 311, 0, 2, 537, 296, 501, 338, 339, + 285, 353, 360, 0, 296, 0, 751, 401, 0, 478, + 502, 254, 255, 522, 296, 438, 0, 296, 239, 0, + 2, 241, 0, 297, 0, 259, 2, 260, 280, 0, + 0, 2, 296, 547, 296, 488, 490, 489, 0, 0, + 753, 0, 296, 0, 296, 492, 296, 562, 560, 561, + 559, 0, 554, 557, 0, 0, 296, 56, 296, 70, + 51, 296, 58, 296, 296, 54, 55, 2, 129, 0, + 0, 450, 0, 449, 730, 123, 296, 18, 0, 31, + 32, 37, 2, 0, 37, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 112, 111, 0, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 105, 2, 645, 452, 642, 546, 546, 650, 479, 293, - 2, 584, 585, 0, 596, 597, 0, 2, 739, 742, - 120, 293, 0, 2, 707, 294, 711, 702, 703, 709, - 0, 2, 2, 667, 546, 750, 616, 546, 546, 750, - 546, 630, 546, 546, 681, 434, 664, 546, 546, 672, - 679, 293, 429, 294, 0, 0, 293, 717, 294, 722, - 750, 714, 293, 719, 750, 293, 293, 293, 0, 120, - 0, 19, 2, 0, 20, 0, 459, 748, 0, 0, - 465, 240, 0, 293, 0, 0, 0, 544, 568, 572, - 574, 604, 607, 611, 614, 567, 606, 0, 283, 657, - 0, 293, 276, 0, 0, 0, 0, 274, 2, 0, - 258, 535, 293, 0, 0, 293, 2, 363, 383, 372, - 0, 0, 377, 371, 749, 0, 0, 396, 0, 294, - 3, 414, 3, 418, 417, 590, 0, 530, 293, 61, - 3, 293, 433, 294, 3, 427, 428, 2, 0, 0, - 0, 484, 305, 293, 480, 482, 3, 2, 2, 0, - 501, 3, 0, 553, 128, 0, 0, 221, 0, 0, - 0, 0, 37, 0, 0, 120, 293, 21, 0, 22, - 0, 691, 696, 448, 688, 546, 546, 0, 106, 3, - 2, 28, 0, 34, 0, 2, 26, 0, 104, 71, - 72, 73, 75, 76, 78, 79, 83, 84, 81, 82, - 86, 87, 89, 91, 93, 95, 97, 0, 0, 751, - 293, 0, 0, 0, 646, 647, 643, 644, 496, 495, - 293, 0, 293, 713, 293, 718, 294, 293, 661, 293, - 293, 704, 660, 2, 293, 0, 0, 0, 0, 0, - 0, 0, 0, 682, 0, 668, 619, 635, 669, 2, - 615, 622, 431, 617, 618, 432, 2, 629, 638, 631, - 632, 665, 666, 680, 708, 712, 710, 750, 267, 2, - 744, 2, 422, 716, 721, 423, 0, 401, 3, 3, - 3, 3, 453, 3, 0, 2, 467, 464, 749, 0, - 460, 2, 463, 466, 0, 293, 241, 263, 3, 271, - 273, 0, 453, 2, 570, 571, 2, 609, 610, 0, - 658, 536, 3, 344, 343, 346, 345, 293, 537, 0, - 538, 371, 0, 0, 293, 293, 0, 0, 691, 381, - 384, 388, 546, 388, 387, 380, 373, 546, 375, 378, - 293, 398, 392, 102, 399, 748, 0, 0, 436, 239, - 0, 0, 3, 2, 667, 429, 0, 526, 0, 750, - 488, 0, 293, 293, 293, 0, 550, 552, 129, 0, - 0, 214, 0, 0, 0, 222, 223, 54, 0, 56, - 59, 60, 0, 2, 127, 0, 0, 0, 692, 693, - 689, 690, 458, 68, 69, 107, 124, 3, 106, 0, - 0, 25, 36, 3, 0, 33, 100, 0, 3, 649, - 653, 656, 648, 3, 591, 3, 715, 720, 2, 61, - 293, 3, 3, 294, 0, 3, 621, 625, 628, 637, - 671, 675, 678, 293, 3, 620, 636, 670, 293, 293, - 424, 293, 293, 745, 0, 0, 0, 0, 255, 0, - 102, 0, 3, 3, 0, 461, 0, 457, 0, 0, - 244, 293, 0, 0, 128, 0, 0, 0, 0, 0, - 128, 0, 0, 106, 106, 19, 2, 0, 0, 3, - 130, 131, 2, 142, 132, 133, 134, 135, 136, 137, - 144, 146, 0, 0, 0, 284, 293, 293, 546, 0, - 539, 293, 374, 376, 0, 390, 692, 385, 389, 386, - 379, 383, 366, 397, 0, 578, 2, 663, 662, 0, - 668, 2, 481, 483, 503, 3, 511, 512, 0, 2, - 507, 3, 3, 0, 0, 555, 221, 0, 0, 0, - 221, 0, 0, 120, 695, 699, 701, 694, 748, 106, - 0, 3, 660, 40, 3, 38, 35, 0, 3, 99, - 101, 0, 2, 651, 652, 0, 0, 293, 0, 0, - 0, 3, 637, 0, 2, 623, 624, 2, 639, 2, - 673, 674, 0, 0, 61, 0, 3, 3, 3, 3, - 409, 408, 412, 2, 2, 747, 746, 121, 0, 0, - 0, 0, 3, 462, 3, 0, 242, 145, 3, 294, - 293, 0, 0, 0, 0, 2, 0, 190, 0, 188, - 0, 0, 0, 0, 0, 0, 0, 546, 120, 0, - 150, 147, 293, 0, 0, 266, 278, 3, 3, 545, - 612, 367, 382, 395, 293, 265, 293, 0, 514, 491, - 293, 0, 0, 490, 505, 0, 0, 0, 215, 0, - 224, 57, 2, 697, 698, 0, 125, 122, 0, 0, - 0, 0, 0, 24, 0, 654, 293, 579, 264, 723, - 724, 725, 0, 676, 293, 293, 293, 3, 3, 0, - 684, 0, 0, 0, 0, 293, 293, 3, 543, 121, - 469, 0, 0, 245, 294, 0, 0, 0, 0, 293, - 191, 189, 186, 0, 192, 0, 0, 0, 0, 196, - 199, 197, 193, 0, 194, 128, 36, 143, 141, 243, - 0, 0, 416, 420, 419, 0, 508, 2, 509, 2, - 510, 504, 293, 227, 0, 225, 0, 227, 293, 32, - 123, 2, 43, 2, 41, 39, 29, 27, 3, 726, - 3, 3, 3, 0, 0, 683, 685, 626, 640, 268, - 2, 406, 3, 405, 0, 471, 468, 128, 0, 0, - 128, 3, 0, 128, 187, 0, 2, 2, 208, 198, - 0, 0, 0, 139, 0, 573, 613, 2, 0, 0, - 2, 228, 0, 0, 216, 0, 3, 0, 0, 0, - 0, 0, 0, 686, 687, 293, 0, 470, 151, 0, - 0, 2, 164, 128, 153, 0, 181, 0, 128, 0, - 2, 155, 0, 2, 0, 2, 2, 2, 195, 33, - 293, 513, 515, 506, 0, 0, 0, 0, 0, 3, - 3, 655, 627, 641, 677, 410, 128, 157, 160, 0, - 159, 163, 3, 166, 165, 0, 128, 183, 128, 3, - 0, 293, 0, 293, 0, 2, 0, 2, 138, 2, - 229, 230, 0, 226, 217, 700, 0, 0, 152, 0, - 0, 162, 232, 167, 2, 234, 182, 0, 185, 171, - 200, 3, 209, 213, 202, 3, 0, 293, 0, 293, - 0, 0, 0, 44, 42, 158, 161, 128, 0, 168, - 293, 128, 128, 0, 172, 0, 0, 691, 210, 211, - 212, 0, 201, 3, 203, 3, 293, 218, 231, 148, - 169, 154, 128, 235, 184, 179, 177, 173, 156, 128, - 0, 692, 0, 0, 0, 0, 149, 170, 180, 174, - 178, 177, 175, 3, 3, 0, 0, 492, 176, 204, - 206, 3, 3, 205, 207 + 108, 2, 648, 455, 645, 549, 549, 653, 482, 296, + 2, 587, 588, 0, 599, 600, 0, 2, 742, 745, + 123, 296, 0, 2, 710, 297, 714, 705, 706, 712, + 0, 2, 2, 670, 549, 753, 619, 549, 549, 753, + 549, 633, 549, 549, 684, 437, 667, 549, 549, 675, + 682, 296, 432, 297, 0, 0, 296, 720, 297, 725, + 753, 717, 296, 722, 753, 296, 296, 296, 0, 123, + 0, 19, 2, 0, 20, 0, 462, 751, 0, 0, + 468, 243, 0, 296, 0, 0, 0, 547, 571, 575, + 577, 607, 610, 614, 617, 570, 609, 0, 286, 660, + 0, 296, 279, 0, 0, 0, 0, 277, 2, 0, + 261, 538, 296, 0, 0, 296, 2, 366, 386, 375, + 0, 0, 380, 374, 752, 0, 0, 399, 0, 297, + 3, 417, 3, 421, 420, 593, 0, 533, 296, 64, + 3, 296, 436, 297, 3, 430, 431, 2, 0, 0, + 0, 487, 308, 296, 483, 485, 3, 2, 2, 0, + 504, 3, 0, 556, 131, 0, 0, 224, 0, 0, + 0, 0, 38, 0, 0, 123, 296, 21, 0, 22, + 0, 694, 699, 451, 691, 549, 549, 0, 109, 3, + 2, 29, 0, 35, 0, 28, 2, 26, 0, 107, + 74, 75, 76, 78, 79, 81, 82, 86, 87, 84, + 85, 89, 90, 92, 94, 96, 98, 100, 0, 0, + 754, 296, 0, 0, 0, 649, 650, 646, 647, 499, + 498, 296, 0, 296, 716, 296, 721, 297, 296, 664, + 296, 296, 707, 663, 2, 296, 0, 0, 0, 0, + 0, 0, 0, 0, 685, 0, 671, 622, 638, 672, + 2, 618, 625, 434, 620, 621, 435, 2, 632, 641, + 634, 635, 668, 669, 683, 711, 715, 713, 753, 270, + 2, 747, 2, 425, 719, 724, 426, 0, 404, 3, + 3, 3, 3, 456, 3, 0, 2, 470, 467, 752, + 0, 463, 2, 466, 469, 0, 296, 244, 266, 3, + 274, 276, 0, 456, 2, 573, 574, 2, 612, 613, + 0, 661, 539, 3, 347, 346, 349, 348, 296, 540, + 0, 541, 374, 0, 0, 296, 296, 0, 0, 694, + 384, 387, 391, 549, 391, 390, 383, 376, 549, 378, + 381, 296, 401, 395, 105, 402, 751, 0, 0, 439, + 242, 0, 0, 3, 2, 670, 432, 0, 529, 0, + 753, 491, 0, 296, 296, 296, 0, 553, 555, 132, + 0, 0, 217, 0, 0, 0, 225, 226, 57, 0, + 59, 62, 63, 0, 2, 130, 0, 0, 0, 695, + 696, 692, 693, 461, 71, 72, 110, 127, 3, 109, + 0, 0, 25, 37, 3, 0, 34, 103, 0, 3, + 652, 656, 659, 651, 3, 594, 3, 718, 723, 2, + 64, 296, 3, 3, 297, 0, 3, 624, 628, 631, + 640, 674, 678, 681, 296, 3, 623, 639, 673, 296, + 296, 427, 296, 296, 748, 0, 0, 0, 0, 258, + 0, 105, 0, 3, 3, 0, 464, 0, 460, 0, + 0, 247, 296, 0, 0, 131, 0, 0, 0, 0, + 0, 131, 0, 0, 109, 109, 19, 2, 0, 0, + 3, 133, 134, 2, 145, 135, 136, 137, 138, 139, + 140, 147, 149, 0, 0, 0, 287, 296, 296, 549, + 0, 542, 296, 377, 379, 0, 393, 695, 388, 392, + 389, 382, 386, 369, 400, 0, 581, 2, 666, 665, + 0, 671, 2, 484, 486, 506, 3, 514, 515, 0, + 2, 510, 3, 3, 0, 0, 558, 224, 0, 0, + 0, 224, 0, 0, 123, 698, 702, 704, 697, 751, + 109, 0, 3, 663, 47, 46, 3, 39, 41, 36, + 0, 3, 102, 104, 0, 2, 654, 655, 0, 0, + 296, 0, 0, 0, 3, 640, 0, 2, 626, 627, + 2, 642, 2, 676, 677, 0, 0, 64, 0, 3, + 3, 3, 3, 412, 411, 415, 2, 2, 750, 749, + 124, 0, 0, 0, 0, 3, 465, 3, 0, 245, + 148, 3, 297, 296, 0, 0, 0, 0, 2, 0, + 193, 0, 191, 0, 0, 0, 0, 0, 0, 0, + 549, 123, 0, 153, 150, 296, 0, 0, 269, 281, + 3, 3, 548, 615, 370, 385, 398, 296, 268, 296, + 0, 517, 494, 296, 0, 0, 493, 508, 0, 0, + 0, 218, 0, 227, 60, 2, 700, 701, 0, 128, + 125, 0, 0, 0, 0, 0, 24, 0, 657, 296, + 582, 267, 726, 727, 728, 0, 679, 296, 296, 296, + 3, 3, 0, 687, 0, 0, 0, 0, 296, 296, + 3, 546, 124, 472, 0, 0, 248, 297, 0, 0, + 0, 0, 296, 194, 192, 189, 0, 195, 0, 0, + 0, 0, 199, 202, 200, 196, 0, 197, 131, 37, + 146, 144, 246, 0, 0, 419, 423, 422, 0, 511, + 2, 512, 2, 513, 507, 296, 230, 0, 228, 0, + 230, 296, 33, 126, 40, 30, 2, 44, 2, 42, + 27, 3, 729, 3, 3, 3, 0, 0, 686, 688, + 629, 643, 271, 2, 409, 3, 408, 0, 474, 471, + 131, 0, 0, 131, 3, 0, 131, 190, 0, 2, + 2, 211, 201, 0, 0, 0, 142, 0, 576, 616, + 2, 0, 0, 2, 231, 0, 0, 219, 0, 3, + 0, 0, 0, 0, 0, 0, 689, 690, 296, 0, + 473, 154, 0, 0, 2, 167, 131, 156, 0, 184, + 0, 131, 0, 2, 158, 0, 2, 0, 2, 2, + 2, 198, 34, 296, 516, 518, 509, 0, 0, 0, + 0, 0, 3, 3, 658, 630, 644, 680, 413, 131, + 160, 163, 0, 162, 166, 3, 169, 168, 0, 131, + 186, 131, 3, 0, 296, 0, 296, 0, 2, 0, + 2, 141, 2, 232, 233, 0, 229, 220, 703, 0, + 0, 155, 0, 0, 165, 235, 170, 2, 237, 185, + 0, 188, 174, 203, 3, 212, 216, 205, 3, 0, + 296, 0, 296, 0, 0, 0, 45, 43, 161, 164, + 131, 0, 171, 296, 131, 131, 0, 175, 0, 0, + 694, 213, 214, 215, 0, 204, 3, 206, 3, 296, + 221, 234, 151, 172, 157, 131, 238, 187, 182, 180, + 176, 159, 131, 0, 695, 0, 0, 0, 0, 152, + 173, 183, 177, 181, 180, 178, 3, 3, 0, 0, + 495, 179, 207, 209, 3, 3, 208, 210 }; @@ -1563,192 +1565,192 @@ static const yytype_int16 yydefgoto[] = { - -1, 814, 468, 300, 47, 133, 134, 301, 302, 303, - 304, 305, 762, 763, 1134, 1135, 306, 381, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 1031, 518, 976, 547, 322, 977, 948, 1058, 1519, - 1060, 1061, 1062, 1063, 1520, 1064, 1065, 1438, 1439, 1402, - 1403, 1404, 1498, 1499, 1503, 1504, 1539, 1540, 1066, 1362, - 1067, 1068, 1299, 1300, 1301, 1481, 1069, 145, 954, 955, - 956, 1382, 1462, 1473, 1474, 469, 470, 875, 876, 1039, - 51, 52, 53, 54, 55, 347, 158, 58, 59, 60, - 61, 62, 349, 64, 65, 264, 67, 68, 274, 351, - 352, 71, 72, 73, 118, 75, 204, 354, 119, 78, - 120, 80, 81, 455, 82, 454, 689, 690, 691, 909, - 1087, 910, 83, 84, 458, 456, 697, 856, 857, 858, - 859, 700, 701, 702, 359, 360, 361, 362, 466, 340, - 135, 136, 522, 324, 170, 646, 647, 648, 649, 650, - 85, 121, 87, 489, 490, 940, 491, 277, 495, 325, - 88, 137, 138, 89, 1322, 1109, 1110, 1111, 1112, 90, - 91, 718, 92, 273, 93, 94, 187, 1033, 680, 412, - 125, 95, 501, 502, 503, 188, 268, 190, 191, 192, - 269, 98, 99, 100, 101, 102, 103, 104, 195, 196, - 197, 198, 199, 826, 606, 607, 608, 609, 200, 611, - 612, 613, 573, 574, 575, 576, 752, 105, 615, 616, - 617, 618, 619, 620, 969, 754, 755, 756, 596, 365, - 366, 367, 368, 326, 164, 107, 108, 109, 370, 695, - 570 + -1, 815, 468, 300, 47, 133, 134, 301, 302, 303, + 304, 305, 762, 763, 1136, 1137, 1138, 306, 381, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 1032, 518, 977, 547, 322, 978, 949, 1059, + 1522, 1061, 1062, 1063, 1064, 1523, 1065, 1066, 1441, 1442, + 1405, 1406, 1407, 1501, 1502, 1506, 1507, 1542, 1543, 1067, + 1365, 1068, 1069, 1302, 1303, 1304, 1484, 1070, 145, 955, + 956, 957, 1385, 1465, 1476, 1477, 469, 470, 876, 877, + 1040, 51, 52, 53, 54, 55, 347, 158, 58, 59, + 60, 61, 62, 349, 64, 65, 264, 67, 68, 274, + 351, 352, 71, 72, 73, 118, 75, 204, 354, 119, + 78, 120, 80, 81, 455, 82, 454, 689, 690, 691, + 910, 1088, 911, 83, 84, 458, 456, 697, 857, 858, + 859, 860, 700, 701, 702, 359, 360, 361, 362, 466, + 340, 135, 136, 522, 324, 170, 646, 647, 648, 649, + 650, 85, 121, 87, 489, 490, 941, 491, 277, 495, + 325, 88, 137, 138, 89, 1325, 1110, 1111, 1112, 1113, + 90, 91, 718, 92, 273, 93, 94, 187, 1034, 680, + 412, 125, 95, 501, 502, 503, 188, 268, 190, 191, + 192, 269, 98, 99, 100, 101, 102, 103, 104, 195, + 196, 197, 198, 199, 827, 606, 607, 608, 609, 200, + 611, 612, 613, 573, 574, 575, 576, 752, 105, 615, + 616, 617, 618, 619, 620, 970, 754, 755, 756, 596, + 365, 366, 367, 368, 326, 164, 107, 108, 109, 370, + 695, 570 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -1323 +#define YYPACT_NINF -1338 static const yytype_int16 yypact[] = { - 7329, 8828, -1323, 37, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, 109, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, 85, 85, 85, 873, - 733, 178, 7561, 370, -1323, -1323, -1323, -1323, -1323, 191, - -1323, -1323, -1323, 614, 225, -1323, -1323, -1323, -1323, 4615, - -1323, -1323, -1323, -1323, 229, 285, -1323, 934, -1323, -1323, - -1323, -1323, 435, 1196, 579, 110, 7677, -1323, -1323, 4858, - 1038, -1323, -1323, 580, 596, 6761, 1021, 875, 580, 1103, - -1323, -1323, 1317, 308, -1323, 580, 1224, -1323, 495, -1323, - 616, 623, -1323, -1323, -1323, -1323, 547, 285, 85, -1323, - 85, -1323, -1323, -1323, -1323, 9174, 934, -1323, -1323, 934, - -1323, 551, -1323, 9403, -1323, -1323, 1899, 9436, -1323, 844, - 844, 844, -1323, -1323, -1323, 85, -1323, -1323, -1323, 584, - 608, 632, -1323, -1323, -1323, 646, -1323, -1323, -1323, -1323, - -1323, 664, 687, -1323, -1323, -28, 8797, 2908, 117, 701, - 717, 726, 771, 786, 799, 8715, 6849, 731, 757, -1323, - 5600, -1323, -1323, -1323, -1323, 804, -1323, 223, 5225, 5225, - -1323, 802, 365, -1323, -1323, -1323, -1323, 816, 443, 480, - 534, 85, 827, -1323, -1323, 1196, 4341, 868, -1323, 50, - -1323, 85, 85, 285, -1323, -1323, 61, -1323, 85, 85, - -1323, 4647, 857, 864, 844, 6523, -1323, -1323, 869, 4615, - -1323, -1323, 580, -1323, -1323, -1323, 285, -1323, 934, 229, - -1323, 7868, -1323, 844, 844, 844, 285, -1323, 873, -1323, - 5676, -1323, -1323, 852, 844, -1323, 844, -1323, 191, 8797, - -1323, 884, -1323, 733, 890, 844, -1323, 873, 888, 892, - -1323, 7561, 631, -1323, -1323, -1323, 9256, -1323, -1323, 9621, - -1323, 868, 151, 10214, 9436, 1899, 4647, -1323, 88, -1323, - -1323, 9403, 934, 891, 7708, -1323, -1323, 347, -1323, 10561, - 922, 956, 10347, 945, 10366, 10423, -1323, 954, -1323, -1323, - -1323, -1323, 10442, 10442, 8571, 952, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, 988, -1323, 966, 1946, 8910, 10366, -1323, - 756, 338, 485, 411, 635, 955, 947, 957, 984, 237, - -1323, -1323, 962, 647, -1323, 302, -1323, -1323, 2908, -1323, - -1323, 235, 985, -1323, 312, 985, 989, 191, -1323, -1323, - 990, 9174, -1323, 999, 1006, 9023, -1323, -1323, 1335, 2030, - 8286, 6523, 580, -1323, 580, 844, 844, -1323, -1323, -1323, - -1323, -1323, -1323, 844, 9174, 934, -1323, -1323, 9474, 1575, - -1323, 8017, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 1008, - 5958, 10366, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, 1899, -1323, 973, 991, - 992, 1012, 978, 1017, 1018, 1020, 4341, -1323, -1323, 1029, - 229, 1031, -1323, -1323, 1033, -1323, -1323, -1323, 9256, -1323, - -1323, -1323, -1323, -1323, 4647, -1323, 8797, 8797, -1323, 844, - 1899, 6642, 934, 8359, -1323, -1323, -1323, -1323, 9256, 151, - -1323, -1323, 580, 285, -1323, -1323, 9256, -1323, 5770, -1323, - -1323, 844, 844, 337, 8204, 1032, 1036, 1023, 1042, 844, - -1323, -1323, -1323, -1323, 9660, -1323, 367, 6404, -1323, 285, - 1044, -1323, 1899, 10643, 10271, -1323, -1323, -1323, -1323, 1015, - 4647, -1323, 8432, 868, 7445, -1323, -1323, -1323, 843, 436, - 962, 733, 7708, 1341, 9403, -1323, 7708, -1323, -1323, -1323, - -1323, 508, -1323, 1051, 956, 248, 8571, -1323, 9512, -1323, - -1323, 8571, -1323, 8684, 8571, -1323, -1323, 1049, -1323, 606, - 1057, 682, 1059, -1323, -1323, 3527, 6492, -1323, 362, -1323, - -1323, 10214, -1323, 368, 10214, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, -1323, 10214, -1323, -1323, - 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, - 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 3593, 10214, - -1323, 647, 1677, -1323, -1323, 85, 85, -1323, -1323, 8797, - -1323, -1323, 1033, 631, -1323, 1033, 10290, -1323, -1323, -1323, - 5046, 6492, 1060, 1063, -1323, 9436, -1323, -1323, 804, -1323, - 1067, 750, 1068, 2627, 125, 962, -1323, 85, 85, 962, - 132, -1323, 85, 85, 1033, -1323, -1323, 85, 85, -1323, - 985, 9545, 934, 10788, 532, 656, 9545, -1323, 9621, -1323, - 962, -1323, 9174, -1323, 238, 7983, 7983, 7983, 934, -1323, - 5791, 1047, 1008, 493, 1058, 1061, -1323, 1076, 5225, 528, - -1323, 1165, 934, 7983, 631, 1899, 631, 868, 430, 985, - -1323, -1323, 536, 985, -1323, -1323, -1323, 956, -1323, 985, - 285, 9660, -1323, 619, 1086, 633, 1088, -1323, 1087, 285, - -1323, -1323, 9256, 285, 1089, 9512, 1092, -1323, 1065, -1323, - 538, 552, 733, -1323, 733, 1085, 10366, -1323, 733, 10788, - -1323, -1323, 1096, -1323, -1323, -1323, 631, -1323, 10716, 1006, - -1323, 7983, 703, 8286, -1323, -1323, 804, 1095, 1098, 843, - 5016, -1323, -1323, 7708, -1323, -1323, 1091, -1323, -1323, 1102, - -1323, 1091, 1104, 10561, 10214, 1090, 1093, 94, 1109, 1107, - 1111, 1114, -1323, 1118, 1129, 9365, 6611, -1323, 10214, -1323, - 682, 1717, -1323, -1323, -1323, 85, 85, 10157, 10214, 1125, - -1323, -1323, 653, -1323, 10214, -1323, -1323, 736, -1323, -1323, - -1323, -1323, 756, 756, 338, 338, 485, 485, 485, 485, - 411, 411, 635, 955, 947, 957, 984, 10366, 260, -1323, - 9660, 1132, 1136, 1137, 1677, -1323, -1323, -1323, -1323, -1323, - 9660, 708, 7983, -1323, 9174, -1323, 6968, 9136, -1323, 8017, - 6849, -1323, -1323, 750, 9660, 1022, 1140, 1141, 1142, 1143, - 1146, 1149, 1154, -1323, 3715, 2627, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, 1033, -1323, -1323, -1323, 962, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, 1155, -1323, 1157, 1159, - -1323, -1323, 229, 1125, 5791, -1323, -1323, -1323, 5958, 1158, - -1323, -1323, -1323, -1323, 733, 6174, 1248, -1323, -1323, -1323, - -1323, 1151, 229, -1323, -1323, 1033, -1323, -1323, 1033, 84, - 1033, -1323, -1323, -1323, -1323, -1323, -1323, 9327, -1323, 285, - -1323, -1323, 559, 562, 9474, 7087, 2137, 10366, 3114, -1323, - -1323, 1156, 51, 1156, -1323, 733, -1323, 85, -1323, -1323, - 8941, 1023, -1323, -1323, -1323, 1036, 1175, 1171, -1323, -1323, - 1178, 1181, -1323, 703, 1901, -1323, 672, -1323, 5016, 962, - -1323, 1184, 7708, 9583, 8797, 1185, -1323, -1323, 1180, 1187, - 1170, -1323, 10366, 1197, 326, 1194, -1323, 1202, 631, 1202, - -1323, -1323, 1202, 1199, -1323, 1208, 1210, 1211, 1717, -1323, - -1323, -1323, 5958, -1323, -1323, -1323, -1323, 1209, 10214, 1212, - 631, -1323, 10214, -1323, 631, -1323, -1323, 10214, -1323, 558, - 985, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 1008, 1006, - 9023, -1323, -1323, 7206, 1218, -1323, 674, 985, -1323, 813, - 861, 985, -1323, 844, 4029, -1323, -1323, -1323, 9660, 9660, - -1323, 8359, 8359, -1323, 1215, 1216, 1225, 1230, -1323, 1232, - 685, 82, 1125, -1323, 631, -1323, 5225, -1323, 10214, 564, - -1323, 6373, 1236, 1240, 10100, 1242, 1243, 70, 79, 96, - 10214, 1244, 285, 10214, 10214, 1227, 1249, 522, 1222, -1323, - -1323, -1323, 1250, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, 733, 1254, 10214, -1323, 9660, 9660, 85, 1257, - -1323, 9054, -1323, -1323, 752, -1323, 3114, -1323, -1323, -1323, - -1323, 1065, -1323, -1323, 1255, -1323, -1323, -1323, -1323, 1258, - 1901, -1323, -1323, 1245, -1323, 1091, -1323, -1323, 1899, 1260, - -1323, -1323, -1323, 713, 1264, -1323, 94, 1269, 10366, 1252, - 94, 94, 1262, 3527, 879, 985, -1323, -1323, 1076, 10214, - 1273, 1209, 358, 204, 1270, -1323, -1323, 1275, 1270, -1323, - -1323, 1278, -1323, -1323, 1033, 1280, 1284, 6730, 1285, 1290, - 1291, -1323, -1323, 1286, -1323, -1323, 1033, -1323, -1323, -1323, - -1323, 1033, 10214, 10214, 1006, 1294, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 10366, 10366, - 1300, 1302, 1270, -1323, -1323, 733, -1323, -1323, -1323, 5213, - 9583, 10214, 10214, 1374, 10214, -1323, 1295, -1323, 1296, -1323, - 1297, 10214, 1301, 10214, 1105, 1304, 12, 85, 9289, 1625, - -1323, -1323, 6174, 1322, 573, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, 9920, -1323, 8432, 1330, -1323, -1323, - 9583, 576, 602, -1323, 1331, 1315, 956, 1337, -1323, 329, - -1323, -1323, -1323, -1323, 1033, 1339, -1323, -1323, 1320, 486, - 509, 631, 1340, -1323, 1344, -1323, 9660, -1323, -1323, -1323, - -1323, -1323, 1347, -1323, 9660, 9660, 9660, -1323, -1323, 1348, - -1323, 1351, 1354, 1355, 716, 8056, 8171, -1323, -1323, 529, - -1323, 1357, 1362, -1323, 8505, 721, 730, 1358, 761, 3837, - -1323, -1323, -1323, 605, -1323, 766, 1366, 1367, 285, 1419, - 834, -1323, -1323, 10214, -1323, 10100, 10214, -1323, -1323, -1323, - 1370, 1375, -1323, -1323, -1323, 1372, -1323, -1323, -1323, -1323, - -1323, -1323, 9583, 956, 1379, -1323, 1352, 956, 9660, -1323, - -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, -1323, 1378, 1382, -1323, -1323, -1323, -1323, -1323, - -1323, -1323, 1387, -1323, 1386, -1323, -1323, 10100, 289, 10214, - 10100, -1323, 1389, 10214, -1323, 318, 1405, 1406, -1323, -1323, - 1399, 1400, 1380, -1323, 821, -1323, -1323, -1323, 934, 1899, - 1396, -1323, 402, 10366, -1323, 785, -1323, 631, 631, 1407, - 1408, 1413, 1415, -1323, -1323, 8359, 1414, -1323, 1490, 10366, - 1385, -1323, -1323, 10012, -1323, 800, -1323, 1402, 10100, 1403, - -1323, -1323, 1426, -1323, 1427, -1323, 1445, 1446, -1323, 1411, - 9583, -1323, -1323, -1323, 956, 631, 1434, 1417, 1435, 1270, - 1270, -1323, -1323, -1323, -1323, -1323, 10100, 107, -1323, 433, - -1323, -1323, 7793, -1323, -1323, 1418, 10214, -1323, 10214, 7793, - 285, 9512, 285, 9512, 1436, -1323, 1442, -1323, -1323, 1440, - -1323, -1323, 825, -1323, -1323, -1323, 1444, 1449, -1323, 10366, - 10366, -1323, -1323, 909, 211, -1323, -1323, 1425, -1323, 909, - -1323, -1323, 2166, 631, -1323, -1323, 285, 9512, 285, 9512, - 1453, 1431, 631, -1323, -1323, -1323, -1323, 10012, 1443, 909, - 6091, 10214, 9924, 1452, 909, 1454, 2166, 3344, -1323, -1323, - -1323, 1458, -1323, -1323, -1323, -1323, 8797, -1323, -1323, -1323, - 9791, -1323, 10012, -1323, -1323, 1438, 9703, -1323, -1323, 9924, - 285, 3344, 285, 1464, 1466, 853, -1323, 9791, -1323, -1323, - -1323, 9703, -1323, -1323, -1323, 285, 285, -1323, -1323, -1323, - -1323, -1323, -1323, -1323, -1323 + 4794, 8872, -1338, 118, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -32, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, 75, 75, 75, 889, + 761, 17, 6057, 231, -1338, -1338, -1338, -1338, -1338, 166, + -1338, -1338, -1338, 566, 192, -1338, -1338, -1338, -1338, 4939, + -1338, -1338, -1338, -1338, 195, 234, -1338, 1148, -1338, -1338, + -1338, -1338, 170, 2042, 352, 44, 7574, -1338, -1338, 9333, + 1157, -1338, -1338, 1542, 364, 3919, 608, 982, 1542, 1041, + -1338, -1338, 474, 402, -1338, 1542, 1242, -1338, 273, -1338, + 455, 478, -1338, -1338, -1338, -1338, 354, 234, 75, -1338, + 75, -1338, -1338, -1338, -1338, 9218, 1148, -1338, -1338, 1148, + -1338, 387, -1338, 9518, -1338, -1338, 2342, 9556, -1338, 992, + 992, 992, -1338, -1338, -1338, 75, -1338, -1338, -1338, 374, + 386, 471, -1338, -1338, -1338, 480, -1338, -1338, -1338, -1338, + -1338, 525, 539, -1338, -1338, 53, 8841, 1022, 54, 558, + 563, 587, 592, 605, 615, 8759, 7097, 644, 585, -1338, + 9371, -1338, -1338, -1338, -1338, 619, -1338, 349, 4637, 4637, + -1338, 657, 446, -1338, -1338, -1338, -1338, 651, 453, 454, + 476, 75, 659, -1338, -1338, 2042, 2592, 742, -1338, 57, + -1338, 75, 75, 234, -1338, -1338, 101, -1338, 75, 75, + -1338, 3079, 687, 706, 992, 6771, -1338, -1338, 707, 4939, + -1338, -1338, 1542, -1338, -1338, -1338, 234, -1338, 1148, 195, + -1338, 7912, -1338, 992, 992, 992, 234, -1338, 889, -1338, + 4555, -1338, -1338, 691, 992, -1338, 992, -1338, 166, 8841, + -1338, 713, -1338, 761, 725, 992, -1338, 889, 756, 768, + -1338, 6057, 675, -1338, -1338, -1338, 9300, -1338, -1338, 2361, + -1338, 742, 105, 10239, 9556, 2342, 3079, -1338, 194, -1338, + -1338, 9518, 1148, 743, 7605, -1338, -1338, 126, -1338, 10586, + 755, 847, 10372, 832, 10391, 10448, -1338, 839, -1338, -1338, + -1338, -1338, 10467, 10467, 8615, 824, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, 901, -1338, 679, 3121, 8954, 10391, -1338, + 507, 418, 680, 295, 694, 894, 852, 888, 930, 66, + -1338, -1338, 938, 665, -1338, 380, -1338, -1338, 1022, -1338, + -1338, 12, 949, -1338, 338, 949, 961, 166, -1338, -1338, + 968, 9218, -1338, 983, 984, 9067, -1338, -1338, 776, 1555, + 8330, 6771, 1542, -1338, 1542, 992, 992, -1338, -1338, -1338, + -1338, -1338, -1338, 992, 9218, 1148, -1338, -1338, 9594, 1098, + -1338, 8061, -1338, -1338, -1338, -1338, -1338, -1338, -1338, 995, + 5881, 10391, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, 2342, -1338, 489, 993, + 994, 1000, 732, 1004, 1007, 1008, 2592, -1338, -1338, 969, + 195, 1030, -1338, -1338, 1024, -1338, -1338, -1338, 9300, -1338, + -1338, -1338, -1338, -1338, 3079, -1338, 8841, 8841, -1338, 992, + 2342, 6890, 1148, 8403, -1338, -1338, -1338, -1338, 9300, 105, + -1338, -1338, 1542, 234, -1338, -1338, 9300, -1338, 6655, -1338, + -1338, 992, 992, 465, 8248, 1029, 1028, 1015, 1033, 992, + -1338, -1338, -1338, -1338, 9742, -1338, 591, 6518, -1338, 234, + 1044, -1338, 2342, 10668, 10296, -1338, -1338, -1338, -1338, 929, + 3079, -1338, 8476, 742, 5771, -1338, -1338, -1338, 1039, 645, + 938, 761, 7605, 809, 9518, -1338, 7605, -1338, -1338, -1338, + -1338, 688, -1338, 1046, 847, 251, 8615, -1338, 9627, -1338, + -1338, 8615, -1338, 8728, 8615, -1338, -1338, 1048, -1338, 751, + 1043, 711, 1057, -1338, -1338, 9447, 6740, -1338, 107, -1338, + -1338, 10239, -1338, 318, 10239, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, 10239, -1338, -1338, + 10391, 10391, 10391, 10391, 10391, 10391, 10391, 10391, 10391, 10391, + 10391, 10391, 10391, 10391, 10391, 10391, 10391, 10391, 4422, 10239, + -1338, 665, 1831, -1338, -1338, 75, 75, -1338, -1338, 8841, + -1338, -1338, 1024, 675, -1338, 1024, 10315, -1338, -1338, -1338, + 5500, 6740, 1056, 1064, -1338, 9556, -1338, -1338, 619, -1338, + 1065, 1323, 1067, 2196, 209, 938, -1338, 75, 75, 938, + 243, -1338, 75, 75, 1024, -1338, -1338, 75, 75, -1338, + 949, 9665, 1148, 10813, 217, 306, 9665, -1338, 2361, -1338, + 938, -1338, 9218, -1338, 212, 8027, 8027, 8027, 1148, -1338, + 6120, 1053, 995, 535, 1061, 1066, -1338, 1071, 4637, 421, + -1338, 1166, 1148, 8027, 675, 2342, 675, 742, 394, 949, + -1338, -1338, 788, 949, -1338, -1338, -1338, 847, -1338, 949, + 234, 9742, -1338, 764, 1087, 806, 1088, -1338, 1089, 234, + -1338, -1338, 9300, 234, 1090, 9627, 1096, -1338, 1729, -1338, + 527, 550, 761, -1338, 761, 1102, 10391, -1338, 761, 10813, + -1338, -1338, 1092, -1338, -1338, -1338, 675, -1338, 10741, 984, + -1338, 8027, 857, 8330, -1338, -1338, 619, 1103, 1112, 1039, + 3523, -1338, -1338, 7605, -1338, -1338, 1097, -1338, -1338, 1121, + -1338, 1097, 1124, 10586, 10239, 1105, 1104, 94, 1128, 1123, + 1132, 1133, -1338, 1136, 1138, 9485, 6859, -1338, 10239, -1338, + 711, 1914, -1338, -1338, -1338, 75, 75, 6186, 10239, 1134, + -1338, -1338, 822, -1338, 10239, -1338, -1338, -1338, 715, -1338, + -1338, -1338, -1338, 507, 507, 418, 418, 680, 680, 680, + 680, 295, 295, 694, 894, 852, 888, 930, 10391, 250, + -1338, 9742, 1151, 1153, 1158, 1831, -1338, -1338, -1338, -1338, + -1338, 9742, 827, 8027, -1338, 9218, -1338, 7216, 9180, -1338, + 8061, 7097, -1338, -1338, 1323, 9742, 936, 1159, 1162, 1164, + 1167, 1170, 1175, 1178, -1338, 3437, 2196, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, 1024, -1338, -1338, -1338, 938, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, 1179, -1338, 1180, + 1181, -1338, -1338, 195, 1134, 6120, -1338, -1338, -1338, 5881, + 1143, -1338, -1338, -1338, -1338, 761, 6348, 1247, -1338, -1338, + -1338, -1338, 1165, 195, -1338, -1338, 1024, -1338, -1338, 1024, + 230, 1024, -1338, -1338, -1338, -1338, -1338, -1338, 9409, -1338, + 234, -1338, -1338, 554, 555, 9594, 7335, 2114, 10391, 2586, + -1338, -1338, 1163, 40, 1163, -1338, 761, -1338, 75, -1338, + -1338, 8985, 1015, -1338, -1338, -1338, 1028, 1185, 1186, -1338, + -1338, 1189, 1191, -1338, 857, 1994, -1338, 444, -1338, 3523, + 938, -1338, 1195, 7605, 9703, 8841, 1196, -1338, -1338, 1192, + 1200, 1182, -1338, 10391, 1205, 298, 1203, -1338, 1206, 675, + 1206, -1338, -1338, 1206, 1209, -1338, 1214, 1216, 1217, 1914, + -1338, -1338, -1338, 5881, -1338, -1338, -1338, -1338, 1215, 10239, + 1220, 831, -1338, 10239, -1338, 831, -1338, -1338, 10239, -1338, + 972, 949, -1338, -1338, -1338, -1338, -1338, -1338, -1338, 995, + 984, 9067, -1338, -1338, 7454, 1229, -1338, 975, 949, -1338, + 979, 991, 949, -1338, 992, 3705, -1338, -1338, -1338, 9742, + 9742, -1338, 8403, 8403, -1338, 1226, 1232, 1235, 1240, -1338, + 1244, 564, 43, 1134, -1338, 831, -1338, 4637, -1338, 10239, + 582, -1338, 6621, 1243, 1245, 10182, 1248, 1251, 46, 70, + 103, 10239, 1252, 234, 10239, 10239, 1238, 1257, 333, 1239, + -1338, -1338, -1338, 1258, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, 761, 1268, 10239, -1338, 9742, 9742, 75, + 1269, -1338, 9098, -1338, -1338, 767, -1338, 2586, -1338, -1338, + -1338, -1338, 1729, -1338, -1338, 1270, -1338, -1338, -1338, -1338, + 1273, 1994, -1338, -1338, 1256, -1338, 1097, -1338, -1338, 2342, + 1271, -1338, -1338, -1338, 836, 1276, -1338, 94, 1279, 10391, + 1265, 94, 94, 1293, 9447, 1023, 949, -1338, -1338, 1071, + 10239, 1292, 1215, 513, -1338, -1338, 1296, -1338, -5, -1338, + 1297, 1296, -1338, -1338, 1304, -1338, -1338, 1024, 1306, 1309, + 6978, 1310, 1312, 1313, -1338, -1338, 1316, -1338, -1338, 1024, + -1338, -1338, -1338, -1338, 1024, 10239, 10239, 984, 1315, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, 10391, 10391, 1317, 1318, 1296, -1338, -1338, 761, -1338, + -1338, -1338, 7839, 9703, 10239, 10239, 1381, 10239, -1338, 1299, + -1338, 1303, -1338, 1305, 10239, 1311, 10239, 1014, 1314, 39, + 75, 5221, 1493, -1338, -1338, 6348, 1321, 584, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, 10002, -1338, 8476, + 1328, -1338, -1338, 9703, 589, 606, -1338, 1327, 1325, 847, + 1334, -1338, 331, -1338, -1338, -1338, -1338, 1024, 1332, -1338, + -1338, 1336, 831, 1339, 320, 457, -1338, 1341, -1338, 9742, + -1338, -1338, -1338, -1338, -1338, 1345, -1338, 9742, 9742, 9742, + -1338, -1338, 1351, -1338, 1355, 1358, 1360, 623, 8100, 8215, + -1338, -1338, 463, -1338, 1361, 1370, -1338, 8549, 841, 866, + 1374, 868, 6487, -1338, -1338, -1338, 616, -1338, 881, 1375, + 1379, 234, 1429, 861, -1338, -1338, 10239, -1338, 10182, 10239, + -1338, -1338, -1338, 1383, 1384, -1338, -1338, -1338, 1382, -1338, + -1338, -1338, -1338, -1338, -1338, 9703, 847, 1386, -1338, 1366, + 847, 9742, -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, -1338, 1389, 1390, -1338, -1338, + -1338, -1338, -1338, -1338, -1338, 1395, -1338, 1394, -1338, -1338, + 10182, 334, 10239, 10182, -1338, 1398, 10239, -1338, 339, 1415, + 1417, -1338, -1338, 1405, 1406, 1393, -1338, 840, -1338, -1338, + -1338, 1148, 2342, 1403, -1338, 329, 10391, -1338, 897, -1338, + 831, 831, 1411, 1412, 1416, 1421, -1338, -1338, 8403, 1423, + -1338, 1485, 10391, 1407, -1338, -1338, 10094, -1338, 898, -1338, + 1410, 10182, 1422, -1338, -1338, 1434, -1338, 1443, -1338, 1459, + 1461, -1338, 1428, 9703, -1338, -1338, -1338, 847, 675, 1452, + 1431, 1455, 1296, 1296, -1338, -1338, -1338, -1338, -1338, 10182, + 81, -1338, 447, -1338, -1338, 7690, -1338, -1338, 1435, 10239, + -1338, 10239, 7690, 234, 9627, 234, 9627, 1465, -1338, 1466, + -1338, -1338, 1456, -1338, -1338, 909, -1338, -1338, -1338, 1470, + 1471, -1338, 10391, 10391, -1338, -1338, 880, 254, -1338, -1338, + 1453, -1338, 880, -1338, -1338, 2645, 675, -1338, -1338, 234, + 9627, 234, 9627, 1480, 1458, 675, -1338, -1338, -1338, -1338, + 10094, 1476, 880, 7766, 10239, 10006, 1478, 880, 1486, 2645, + 2922, -1338, -1338, -1338, 1487, -1338, -1338, -1338, -1338, 8841, + -1338, -1338, -1338, 9873, -1338, 10094, -1338, -1338, 1467, 9785, + -1338, -1338, 10006, 234, 2922, 234, 1495, 1498, 927, -1338, + 9873, -1338, -1338, -1338, 9785, -1338, -1338, -1338, 234, 234, + -1338, -1338, -1338, -1338, -1338, -1338, -1338, -1338 }; @@ -1756,29 +1758,29 @@ static const yytype_int16 yypgoto[] = { - -1323, 4572, 3263, -1323, 197, -1323, 601, 950, -251, 910, - -1323, 521, -520, -467, -853, -64, 3183, 0, -1323, -150, - 423, 446, 477, 450, 1016, 1025, 1019, 1026, 1028, -1323, - -622, -408, 5012, -745, -1323, -735, 604, 472, -656, 413, - -1323, 1279, -1323, 374, -1058, -1323, -1323, 126, -1323, -823, - -1106, 222, -1323, -1323, -1323, -1323, 58, -1209, -1323, -1323, - -1323, -1323, -1323, -1323, 301, -1149, 35, -1323, -933, -1323, - 482, 274, -1323, 159, -1323, -303, -1323, -1323, -1323, 535, - -827, -1323, -1323, 15, -1007, 71, 28, -1323, -1323, -1323, - -21, -1323, 357, 1253, -198, 1636, 4113, -1323, -1323, 80, - 54, 422, 1473, -1323, 1886, -1323, -1323, 192, 2183, -1323, - 2495, 898, -1323, -1323, -1323, -638, -1323, 924, 925, 524, - 699, 83, -1323, -1323, -1323, 915, 695, -339, -1323, -106, - 34, 1281, -1323, -1323, -847, -986, 1046, 1127, 1039, 5, - -1323, 1536, 481, -165, -210, -124, 651, 758, -1323, 979, - -1323, 2789, 1548, -413, 904, -1323, -1323, 689, -1323, -235, - -1323, 158, -1323, -1323, -1323, -1257, 401, -1323, -1323, -1323, - 1148, -1323, 21, -1323, -1323, -858, -105, -1322, -129, 2267, - -1323, 2391, -1323, 906, -1323, -184, 59, -180, -173, -170, - 7, -40, -35, -33, 60, -6, 25, 93, -168, -164, - -158, -147, -144, -292, -471, -462, -452, -551, -302, -537, - -1323, -1323, -511, 1069, 1072, 1074, 2608, 4844, -578, -514, - -502, -495, -500, -1323, -508, -724, -717, -708, -590, -305, - -195, -1323, -1323, 246, 19, 36, -1323, 3865, 104, -623, - -397 + -1338, 4260, 2887, -1338, 1463, -1338, 1198, 661, -268, 942, + -1338, 552, -528, -471, -934, -784, -1338, 4910, 0, -1338, + -100, 434, 472, 506, 438, 1049, 1050, 1051, 1062, 1055, + -1338, 1094, -577, 5180, -896, -1338, -712, 636, -68, -593, + -654, -1338, 1469, -1338, 408, -1065, -1338, -1338, 159, -1338, + -1118, -880, 265, -1338, -1338, -1338, -1338, 92, -1253, -1338, + -1338, -1338, -1338, -1338, -1338, 341, -1303, 36, -1338, -904, + -1338, 518, 311, -1338, 196, -1338, -309, -1338, -1338, -1338, + 571, -749, -1338, -1338, 16, -930, 172, 1119, -1338, -1338, + -1338, -149, -1338, 71, 966, -196, 1532, 4034, -1338, -1338, + 83, 174, 287, 2700, -1338, 1836, -1338, -1338, 55, 2097, + -1338, 2401, 2181, -1338, -1338, -1338, -656, -1338, 962, 964, + 560, 736, -249, -1338, -1338, -1338, 955, 734, -456, -1338, + -116, -94, 869, -1338, -1338, -963, -979, -2, 913, 1074, + 29, -1338, 719, 357, -283, -191, -146, 681, 789, -1338, + 1010, -1338, 2818, 1589, -439, 940, -1338, -1338, 720, -1338, + -237, -1338, 109, -1338, -1338, -1338, -1275, 435, -1338, -1338, + -1338, 1183, -1338, 32, -1338, -1338, -845, -111, -1337, -112, + 3150, -1338, 3946, -1338, 941, -1338, -138, 1137, -181, -176, + -174, 7, -40, -33, -28, 1352, 38, 50, 77, -134, + -173, -171, -166, -165, -261, -504, -490, -476, -565, -319, + -523, -1338, -1338, -525, 1107, 1111, 1115, -135, 4740, -582, + -583, -534, -519, -480, -1338, -505, -725, -715, -709, -592, + -312, -258, -1338, -1338, 326, 26, -81, -1338, 3689, -15, + -601, -356 }; @@ -1786,680 +1788,681 @@ positive, shift that token. If negative, reduce the rule which number is the opposite. If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -522 +#define YYTABLE_NINF -525 static const yytype_int16 yytable[] = { - 49, 113, 407, 149, 453, 399, 428, 97, 150, 440, - 151, 267, 400, 753, 767, 401, 114, 1071, 408, 106, - 106, 402, 974, 280, 869, 828, 965, 403, 57, 57, - 505, 845, 49, 966, 1188, 50, 1172, 152, 404, 97, - 597, 405, 967, 147, 383, 384, 741, 610, 1070, 49, - 357, 106, 827, 143, 70, 920, 161, 605, 410, 96, - 57, 795, 177, 186, 819, 1380, 209, 50, 153, 49, - 193, 56, 115, 216, 923, 1303, 226, 1440, 949, 726, - 69, 281, 407, 731, 219, 399, 70, 820, 106, 31, - 31, 96, 400, 724, 57, 401, 425, 57, 408, 821, - 31, 402, 148, 56, 831, 113, 822, 403, 96, 162, - 838, 261, 69, 113, 262, 670, 266, 271, 404, 122, - 212, 405, 189, 194, 31, 96, 217, 31, 96, 227, - 816, 1138, 475, 477, 510, 679, 154, 210, 202, 817, - 220, 260, 1196, 683, 1304, 149, 307, 147, 1440, 818, - 150, 1198, 151, 166, 161, 113, 345, 548, 549, 252, - 209, 411, 411, 1459, 31, 986, 527, 373, 1200, 629, - 419, 31, 411, 633, 1170, 1171, 291, 715, 1178, 152, - 914, 1182, 965, 1235, 348, 186, 186, 1239, 203, 966, - 358, 342, 76, 161, 1078, 548, 721, 481, 967, 411, - 668, 266, 1197, 1469, 1179, 952, 96, 162, 832, 49, - 153, 1199, 835, 1201, 1187, 409, 161, 166, 123, 96, - 374, 209, 665, 439, 76, 149, 252, 329, 443, 1179, - 150, 548, 151, 852, 829, 471, 602, 855, 666, 307, - 1172, 836, 1030, 602, 398, 189, 162, 1017, 816, 57, - 327, 49, 1140, 735, 176, -233, -233, 817, 97, 271, - 476, 674, 676, 1081, 271, 266, 266, 818, 96, 162, - 106, 113, 463, 161, 1016, 442, 1004, 483, 154, 57, - 96, 444, 1188, 992, 500, 923, 50, 142, 924, 1249, - 1172, 657, 441, 1527, 307, 163, 665, 860, 861, 820, - 146, 610, 1094, 176, 1485, 70, 176, 307, 1205, 1206, - 96, 821, 666, 436, 878, 831, 597, 1250, 822, 672, - 1542, 597, 56, 572, 479, 677, -233, 357, 147, 730, - 923, 69, 567, 1399, 1400, 373, 168, 155, 1513, 377, - 1515, 113, 816, 327, 580, 345, 411, 476, 743, 603, - 621, 817, 176, 177, 1071, 378, 828, 63, 736, 163, - 169, 818, 1399, 1400, 626, 1139, 568, 1497, 626, 569, - 630, 113, 932, 1502, 634, 436, 748, 589, 737, 899, - 110, 144, 139, 140, 1246, 1070, 447, 96, 374, 63, - 987, 41, 42, 1522, 1202, 805, 266, 471, 1529, 171, - 769, 770, 771, 1401, 212, 460, 186, 342, 604, 1172, - 845, 166, 578, 373, 799, 176, 1030, 471, 579, 820, - 357, 583, 243, 411, 266, 471, 307, 307, 1170, 1171, - 266, 821, 1410, 626, 110, 1188, 1119, 854, 822, 1326, - 110, 715, 1188, 76, 1526, 41, 42, 684, 76, 599, - 1020, 41, 42, 579, 113, 435, 1120, 553, 554, 1327, - 1127, 348, 1363, 995, 1537, 189, 374, 358, -121, 176, - -121, 1541, 266, 760, -121, 493, 176, 705, 494, 765, - 266, 387, 626, 706, 49, 357, 953, 373, 720, -121, - -121, 97, 229, 1188, 113, 230, 923, 388, 234, 1085, - 236, 557, 558, 106, 911, 1245, 307, 245, 113, 1158, - 1160, 307, 57, 307, 307, 1136, 714, 435, 1424, 50, - 913, 751, 1017, 610, 870, 113, 345, 212, 882, 1105, - 327, 327, 1425, 1015, 1429, 1430, 559, 560, 70, 883, - 523, 411, 1102, 96, 1117, 176, 722, 604, 1435, 1470, - 880, 181, 723, 163, 348, 56, 923, 923, 110, 390, - 358, 342, 176, 1471, 69, 110, 176, 139, 140, 41, - 42, 572, 572, 555, 556, 391, 41, 42, 1127, 307, - 1444, 110, 201, 914, 2, 206, 4, 5, 6, 7, - 626, 345, 41, 42, 286, 621, 392, 1331, 327, -289, - 715, 603, 111, 603, 865, 41, 42, 973, 63, 997, - 76, 247, 393, 472, 805, 1475, 250, 327, 732, 348, - 1333, 626, 1475, -517, 733, 358, 626, 847, 621, 176, - 76, 514, 626, 1361, 229, 626, 626, 626, 76, 871, - -468, 643, -468, 862, 848, 886, 1015, 411, 849, 35, - 394, 36, 1028, 626, 915, 266, 252, 877, 872, -468, - 815, 471, 604, 348, 348, 348, 395, 1142, 917, 411, - 916, 807, 1075, 1523, 1444, 915, 76, 442, 917, 1444, - 1185, 348, 263, 327, 918, 113, 37, 929, 908, 1185, - 40, 1082, 1317, -10, 1083, 597, 1186, 41, 42, 1444, - 692, 498, 805, 110, 357, 1309, 1444, 1409, 1318, 1113, - 1237, 626, 934, 621, 41, 42, 747, -441, 1319, 720, - 720, 748, 748, 43, 407, 846, 399, 561, 562, 893, - 599, 45, 46, 400, 1320, 748, 401, 1364, 500, 348, - 408, -442, 402, 895, 1035, 113, 345, 912, 403, 748, - 751, 751, 523, 212, 523, 276, 571, 523, 411, 404, - 523, 923, 405, 981, 45, 46, 519, 212, 850, 982, - 1277, 1278, 851, 278, 229, 472, 234, 923, 815, 604, - 714, 342, 965, 1154, 850, 411, 1374, 176, 1101, 966, - 1477, 750, 1478, 411, 572, 472, 279, -103, 967, 45, - 46, -103, 626, 472, 626, 110, 1000, 139, 140, 626, - 345, 330, 933, 603, 602, 1162, 41, 42, 994, 176, - 45, 46, 37, 1233, 706, 603, 40, 331, 1349, 579, - 348, 1357, 1350, 41, 42, 176, 332, 748, 348, 712, - 1358, 63, 715, 371, 358, 1524, 748, 923, 923, 176, - 548, 985, 982, 465, 8, 9, 10, 11, 12, 813, - 212, 602, 329, 411, 229, 953, 372, 45, 46, 953, - 953, 1360, 815, 550, 76, 307, 1365, 748, -290, 551, - 552, 333, 748, 31, 604, 8, 9, 10, 11, 12, - 807, 510, 1370, 1371, 106, 1427, 334, 626, 673, 675, - 76, 1424, 665, 57, 113, 345, 908, 911, 908, 335, - 1445, 34, 1183, 376, 31, 37, 748, 385, 666, 40, - 113, 715, 1157, 913, 602, 389, 41, 42, 805, 70, - 176, 692, 409, 934, 934, 1491, 1419, 982, 720, 714, - 342, 1492, 34, 113, 307, 129, 56, 130, 131, 132, - 48, 112, 719, 1399, 1400, 69, 41, 42, 1106, 397, - 45, 46, 106, 1547, 214, 1084, 426, 912, 751, 579, - 1159, 57, 602, 427, 1509, 1426, 772, 773, 519, 112, - 112, 432, 48, 519, 450, 1324, 519, 738, 1242, 739, - 411, 1437, 740, 48, 1088, 744, 1088, 604, -365, 48, - 345, 774, 775, 1228, -394, 484, 37, 48, 174, 175, - 40, 780, 781, 48, 1107, 214, 48, 41, 42, 48, - 461, 626, 626, 1127, 462, 2, 206, 4, 5, 6, - 7, 504, 112, 112, 776, 777, 778, 779, 291, 472, - 788, 307, 2, 206, 4, 5, 6, 7, 327, 348, - 348, 528, 529, 530, 508, 1169, 48, 442, 214, 48, - 106, 1495, 1437, 513, 525, 472, 48, 76, 111, 57, - 527, 228, 1381, 563, 564, 531, 1381, 532, 566, 533, - 534, 113, 252, 329, 411, 565, 908, 419, 661, 411, - 35, 908, 36, 569, 176, 70, 338, 48, -438, 587, - 934, 658, 659, 712, 846, 48, -291, 35, 266, 36, - 48, 590, 56, 8, 9, 10, 11, 12, -3, 214, - 639, 1190, 660, 626, 481, 329, 411, 662, 663, 761, - 664, 829, 329, 602, 766, 48, 48, 37, 667, 183, - 184, 40, 31, 669, 257, 912, 693, 345, 41, 42, - 912, 48, 694, -3, 696, 498, 698, 214, -237, 48, - 734, 745, 214, 1296, 1297, 1298, 692, 749, 48, 757, - 34, 48, 808, 1460, 906, 809, 411, -12, 112, 812, - 823, 714, 45, 46, 465, 1332, 1334, 1335, -13, 271, - 113, 867, 868, 112, 874, 907, 894, 112, 896, 897, - 922, 48, 112, 901, 904, 219, -415, 723, 113, 106, - -521, 944, 307, 937, 946, 48, 48, 57, 57, 957, - 950, 959, 48, 958, 960, 951, 626, -292, 961, 48, - 113, 106, 63, 76, 8, 9, 10, 11, 12, 962, - 57, 978, 989, 212, 342, 1106, 990, 991, 214, 106, - 1006, 1007, 1008, 1009, 116, 879, 1010, 881, 57, 1011, - 210, 220, 712, 31, 1012, 1023, 70, -403, 37, -402, - 183, 184, 40, 1037, 1422, 626, 626, 1072, 48, 41, - 42, 1535, 1074, 56, 271, 1095, 907, 1096, 1059, 307, - 1097, 34, 69, 1098, 1104, 1114, 748, 1115, 48, 48, - 1116, 1107, 159, 348, 348, 185, 1118, 928, 106, 1352, - 1121, 1123, 57, 45, 46, 48, 972, 57, 1124, 48, - 1125, 1126, 113, 407, 1132, 1129, 399, 692, 1152, 214, - 644, 1173, 1174, 400, 173, 1175, 401, 1106, 442, 408, - 1176, 106, 402, 70, 1177, 1191, 48, 665, 403, 1192, - 57, 1194, 1195, 1203, 1210, 441, 48, 1207, 258, 404, - 56, 1208, 405, 666, 1215, -3, 159, 1220, 1225, 1190, - 1223, 214, 1241, 493, 48, 1229, 253, 1508, 1234, 266, - 48, 1236, 48, 1421, 1238, 1247, 1251, 1253, 1255, 110, - 1257, 139, 238, 1107, 1258, 626, 1263, 1259, 472, 323, - 41, 42, 1260, 1261, 76, 176, 1270, 37, 339, 174, - 175, 40, 1279, 110, 1280, 139, 140, 112, 41, 42, - 113, 1287, 48, 348, 41, 42, 239, 1290, 1291, 1292, - 48, 240, 1330, 1294, 48, 1106, 1302, 1308, 48, 106, - 1315, 112, 113, 112, 372, 1323, 1321, 1325, 57, 113, - 727, 113, 1336, 113, 1329, 728, 1337, 1193, 430, 1339, - 1345, 106, 434, 1346, 1347, 1348, 149, 1359, 106, 1355, - 57, 150, 417, 151, 1356, 1366, 1367, 57, 112, 1298, - 1375, 76, 1507, 112, 1384, 1376, 1377, 113, 1383, 113, - 1393, 1107, 323, 214, 1394, 437, 70, -404, 1397, 1408, - 113, 1412, 1414, 70, 712, 445, 1507, 1507, 1416, 1417, - 703, 1423, 1418, 56, 161, 1441, 307, 1431, 1432, 106, - 56, 214, 1190, 1433, 434, 1434, 214, 488, 57, 1190, - 1350, 1507, 1436, 112, 1446, 1448, 1450, 1452, 373, 213, - 48, 1454, 1456, 1458, 1463, 1465, 1486, 521, 232, 1464, - 1476, 48, 1488, 48, 70, 1490, 1493, 1501, 1521, 1122, - 159, 1494, 1516, 1517, 1530, 479, 141, 1528, 1532, 63, - 1538, 56, 48, 520, 1545, 176, 1546, 889, 1209, 782, - 1190, 1133, 1131, 712, 784, 1133, 1307, 1411, 48, 783, - 213, 704, 785, 112, 588, 786, 1496, 214, 594, 1548, - 1369, 1385, 48, 1240, 112, 48, 112, 1214, 1479, 902, - 903, 214, 1089, 925, 215, 1222, 1093, 627, 241, 244, - 327, 631, 801, 1128, 339, 1059, 1036, 939, 873, 1103, - 242, 1316, 717, 213, 76, 1133, 66, 117, 48, 947, - 791, 76, 112, 792, 112, 793, 472, 37, 112, 174, - 175, 40, 0, 0, 0, 0, 112, 0, 41, 42, - 0, 0, 0, 1285, 1286, 215, 1288, 0, 66, 48, - 48, 0, 0, 1293, 0, 1295, 0, 0, 0, 323, - 323, 0, 0, 48, 376, 160, 0, 8, 9, 10, - 11, 12, 76, 0, 213, 0, 0, 1483, 0, 1483, - 0, 0, 0, 0, 214, 221, 0, 688, 215, 0, - 528, 529, 530, 0, 0, 0, 31, 703, 1373, 0, - 116, 0, 681, 0, 0, 0, 0, 8, 9, 10, - 11, 12, 213, 1483, 531, 1483, 532, 213, 533, 1306, - 0, 259, 0, 0, 34, 488, 0, 323, 707, 488, - 0, 0, 499, 0, 0, 0, 31, 0, 0, 521, - 0, 521, 0, 48, 521, 0, 323, 521, 0, 215, - 1398, 0, 0, 1406, 0, 48, 0, 0, 339, 457, - 0, 0, 0, 328, 34, 520, 571, 0, 411, 0, - 520, 259, 350, 520, 45, 46, 0, 0, 704, 472, - 0, 0, 0, 0, 0, 0, 472, 215, 0, 0, - 0, 0, 215, 0, 0, 0, 1443, 0, 644, 0, - 0, 1447, 406, 213, 112, 0, 750, 0, 411, 0, - 0, 1405, 323, 0, 45, 46, 703, 424, 0, 0, - 429, 431, 0, 803, 0, 160, 703, 48, 0, 1468, - 1133, 1133, 1133, 0, 0, 0, 48, 472, 48, 0, - 703, 0, 0, 0, 0, 112, 448, 0, 0, 0, - 451, 0, 452, 0, 844, 0, 0, 0, 0, 594, - 0, 459, 0, 0, 0, 853, 74, 66, 48, 0, - 0, 0, 473, 0, 0, 0, 0, 0, 215, 0, - 0, 214, 480, 0, 213, 0, 0, 0, 112, 0, - 431, 8, 9, 10, 11, 12, 645, 704, 74, 0, - 0, 213, 644, 0, 0, 0, 0, 704, 0, 0, - 112, 0, 0, 1536, 112, 0, 0, 0, 688, 1536, - 31, 704, 0, 0, 0, 0, 213, 0, 0, 891, - 1536, 0, 892, 0, 1536, 222, 0, 0, 898, 0, - 0, 0, 900, 0, 0, 0, 0, 0, 34, 0, - 0, 37, 0, 183, 184, 40, 488, 259, 0, 215, - 0, 595, 41, 42, 112, 0, 0, 623, 1133, 1133, - 0, 0, 0, 0, 0, 0, 0, 0, 339, 0, - 628, 0, 0, 0, 628, 0, 0, 259, 265, 0, - 933, 0, 602, 0, 0, 0, 45, 46, 45, 46, - 0, 215, 112, 0, 0, 0, 1461, 725, 0, 729, - 0, 0, 0, 0, 0, 0, 48, 0, 0, 0, - 0, 48, 353, 535, 536, 537, 538, 539, 540, 541, - 542, 543, 544, 545, 473, 0, 0, 996, 48, 0, - 0, 0, 803, 0, 703, 703, 0, 0, 213, 350, - 0, 988, 0, 0, 473, 0, 0, 546, 0, 0, - 0, 993, 473, 0, 1510, 0, 0, 214, 0, 0, - 0, 0, 0, 1518, 0, 1005, 213, 0, 0, 0, - 699, 213, 37, 431, 183, 184, 40, 0, 0, 0, - 0, 0, 0, 41, 42, 0, 449, 0, 713, 0, - 66, 0, 703, 703, 0, 0, 0, 0, 431, 0, - 0, 0, 431, 0, 0, 112, 0, 74, 0, 601, - 0, 602, 74, 215, 0, 704, 704, 45, 46, 0, - 803, 0, 0, 0, 0, 0, 0, 339, 48, 0, - 0, 259, 350, 0, 0, 0, 0, 0, 0, 0, - 0, 215, 213, 688, 0, 0, 215, 0, 1080, 866, - 0, 0, 214, 77, 0, 0, 213, 0, 0, 0, - 0, 0, 0, 0, 0, 488, 1108, 323, 0, 112, - 112, 112, 0, 704, 704, 0, 499, 0, 794, 37, - 0, 183, 184, 40, 0, 77, 0, 0, 0, 0, - 41, 42, 0, 0, 0, 0, 628, 806, 919, 0, - 921, 0, 0, 0, 457, 0, 0, 222, 37, 825, - 183, 184, 40, 0, 0, 0, 906, 215, 411, 41, - 42, 0, 223, 844, 45, 46, 0, 595, 0, 0, - 0, 215, 595, 0, 0, 0, 0, 0, 628, 0, - 1313, 350, 350, 350, 0, 1506, 0, 411, 0, 213, - 0, 0, 0, 45, 46, 0, 0, 0, 0, 350, - 0, 0, 0, 124, 127, 128, 0, 0, 0, 1167, - 1168, 0, 703, 0, 74, 0, 0, 699, 0, 0, - 703, 703, 703, 0, 0, 0, 0, 0, 473, 353, - 0, 0, 0, 0, 74, 0, 0, 0, 48, 48, - 0, 1204, 74, 0, 688, 0, 0, 112, 112, 355, - 0, 0, 0, 0, 473, 0, 0, 350, 0, 0, - 353, 1314, 0, 0, 215, 0, 938, 1217, 1218, 431, - 0, 0, 0, 0, 0, 254, 0, 255, 353, 0, - 74, 0, 0, 0, 703, 112, 803, 0, 0, 0, - 0, 259, 713, 704, 0, 0, 0, 968, 0, 0, - 0, 704, 704, 704, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 645, 0, 0, 0, 0, 0, - 1040, 0, 353, 0, 0, 0, 0, 126, 126, 126, - 0, 0, 0, 0, 0, 0, 699, 0, 0, 0, - 0, 0, 48, 112, 77, 0, 699, 0, 350, 77, - 628, 0, 112, 1003, 0, 628, 806, 0, 396, 0, - 699, 1090, 0, 0, 0, 704, 48, 48, 415, 416, - 1014, 339, 0, 420, 0, 422, 423, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 213, 353, 0, 0, - 0, 48, 0, 1108, 0, 0, 0, 0, 0, 126, - 0, 126, 0, 0, 0, 79, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 645, 0, - 0, 66, 0, 0, 0, 0, 275, 0, 0, 0, - 0, 353, 353, 353, 0, 0, 0, 79, 0, 0, - 0, 0, 0, 628, 223, 0, 0, 1338, 0, 353, - 259, 713, 0, 0, 1086, 1340, 1341, 1342, 0, 0, - 0, 215, 0, 0, 0, 0, 0, 353, 0, 0, - 0, 0, 0, 0, 224, 0, 0, 0, 74, 0, - 1100, 0, 126, 0, 0, 1108, 0, 1368, 431, 117, - 126, 0, 126, 126, 0, 0, 0, 126, 0, 126, - 126, 0, 0, 0, 74, 0, 0, 353, 0, 0, - 0, 77, 0, 0, 0, 0, 0, 0, 1040, 1386, + 49, 113, 453, 149, 399, 267, 768, 97, 428, 400, + 150, 401, 402, 505, 403, 151, 753, 114, 821, 404, + 405, 829, 383, 384, 260, 966, 106, 106, 440, 846, + 610, 1072, 49, 597, 166, 967, 50, 921, 828, 97, + 357, 968, 741, 147, 1175, 975, 870, 796, 407, 49, + 1383, 1141, 408, 726, 413, 76, 161, 731, 106, 1173, + 1174, 421, 358, 186, 143, 1443, 209, 822, 50, 49, + 193, 63, 202, 216, 342, 410, 226, 123, 820, 31, + 1254, 152, 823, 69, 399, 219, 177, 76, 605, 400, + 425, 401, 402, 153, 403, 106, 31, 817, 166, 404, + 405, 1185, 1306, 63, 280, 113, 629, 471, 1255, 670, + 633, 818, 1191, 113, 31, 69, 266, 271, 1199, 925, + 154, 580, 203, 411, 832, 819, 142, 1071, 407, 679, + 839, 327, 408, 413, 724, 261, 1443, 683, 262, 1181, + 31, 950, 1201, 674, 676, 149, 307, 147, 1462, 475, + 477, 411, 150, 1488, 161, 113, 345, 151, 1208, 1209, + 209, 567, 281, 252, 329, 1182, 252, 373, 411, 409, + 715, 1307, 56, 115, 70, 1203, 291, 1472, 1200, 110, + 861, 862, 966, 915, 510, 186, 186, 1516, 577, 1518, + 41, 42, 967, 161, 436, 568, 581, 879, 968, 584, + 122, 266, 1202, 1182, 56, 953, 70, 548, 549, 49, + 419, 730, 411, 1238, 476, 817, 161, 1242, 760, 668, + 1204, 209, 1060, 152, 327, 149, 519, 721, 443, 818, + 743, 821, 150, 31, 1249, 153, 735, 151, 210, 307, + 212, 220, 144, 819, 1018, 548, 1082, 439, 31, 833, + 1175, 49, 1530, 836, 493, 933, 436, 494, 97, 271, + 589, 1017, 154, 413, 271, 266, 266, 421, 665, 471, + 993, 113, 666, 161, 853, 146, 1143, 106, 856, 1545, + 822, 548, 31, 463, 610, 657, 181, 50, 1447, 471, + 342, 1005, 166, 1190, 307, 823, 800, 471, -236, -236, + 1175, 483, 168, 481, 155, 411, 76, 307, 500, 597, + 817, 76, 527, 672, 597, 1173, 1174, 357, 830, 677, + 602, 476, 63, 572, 818, 1095, 169, 472, 147, 849, + 599, 1086, 806, 850, 69, 373, 832, 447, 819, 358, + 1079, 113, 665, 569, 413, 345, 666, 996, 171, 603, + 621, 821, 837, 829, 602, 201, 460, 229, 673, 675, + 230, 736, 1191, 234, 626, 236, 748, -292, 626, -236, + 1072, 113, 245, 900, 855, 163, 1118, 177, 1402, 1403, + 988, 737, 1447, 1402, 1403, 557, 558, 1447, 714, 247, + 110, 1196, 110, 441, 630, 442, 266, 765, 634, 1134, + 822, 41, 42, 41, 42, 286, 186, 1447, 1120, 846, + 357, 327, 327, 373, 1447, 823, 41, 42, 851, 1175, + 559, 560, 852, 56, 266, 70, 307, 307, 1121, 766, + 266, 1336, 358, 626, 715, 1438, 577, 577, 519, 163, + 1529, 1329, 514, 519, 342, 1427, 519, 583, 1404, 411, + 770, 771, 772, 1413, 113, 250, 1432, 1433, 1205, 1428, + 1540, 1330, 703, 252, 1128, 377, 1071, 1544, 1334, 954, + 1337, 1339, 266, 76, 110, 357, 139, 140, -520, 327, + 266, 378, 626, -10, 49, 41, 42, 373, 720, 472, + 578, 97, 1021, 76, 113, -444, 579, 358, 327, 229, + 789, 76, 871, 884, 1106, 411, 307, 610, 113, 472, + 106, 307, 1139, 307, 307, 1191, 243, 472, 263, 1018, + 50, 751, 1191, 885, 212, 113, 345, 888, 1248, 110, + 1161, 1163, 872, 471, 643, 435, 1134, 553, 554, 76, + 41, 42, 1240, 1366, 881, 883, 110, 998, 139, 238, + 912, 873, 806, 712, 914, 63, 851, 41, 42, 930, + 1102, 1060, 387, 1473, 327, 1016, 498, 69, 1338, 390, + 392, 572, 572, 1191, -471, 684, -471, 1474, 388, 307, + -445, 579, 1128, 239, 1103, 391, 393, 915, 240, 276, + 626, 345, 394, -471, 715, 621, 1500, 435, 252, 329, + 411, 603, 1505, 603, 1280, 1281, 847, 110, 395, 139, + 140, 599, 2, 206, 4, 5, 6, 7, 41, 42, + 523, 626, 1525, -124, 550, -124, 626, 1532, 621, -124, + 551, 552, 626, 163, 278, 626, 626, 626, 37, 229, + 806, 234, 40, 916, -124, -124, 866, 212, 279, 41, + 42, 848, 714, 626, 1376, 266, 56, 974, 70, 917, + 577, 48, 112, 1089, 342, 1089, 918, 863, 330, 703, + 916, 918, 1029, 331, 808, 43, -106, 35, 1016, 36, + -106, 878, 919, 45, 46, 113, 1083, 1084, 909, 597, + 112, 112, 1076, 48, 372, 357, 1478, 332, 1188, 1364, + 1188, 705, 333, 1478, 48, 1320, 1401, 706, 1114, 1409, + 48, 626, 935, 621, 1189, 334, 1312, 358, 48, 720, + 720, 1321, 1322, 1036, 48, 335, 399, 48, 376, 229, + 48, 400, 748, 401, 402, 1352, 403, 76, 1323, 1353, + -3, 404, 405, 112, 112, 113, 345, 110, 1367, 141, + 751, 751, 1446, 472, 1526, 722, 371, 1450, 41, 42, + 389, 723, 500, 76, 528, 529, 530, 48, 555, 556, + 48, 407, 385, 1412, 571, 408, 411, 48, 413, 472, + 692, 1377, 45, 46, 966, 1471, 561, 562, 531, 703, + 532, 397, 533, 534, 967, 572, 426, 442, 732, 703, + 968, 241, 244, 626, 733, 626, 409, 1001, 48, 1429, + 626, 345, 714, 703, 603, 427, 48, 712, 1165, 432, + 750, 48, 411, 450, 342, 1440, 603, -368, 45, 46, + 986, 983, 523, 110, 523, 139, 140, 523, 715, -397, + 523, 419, 661, 411, 41, 42, 48, 48, 37, 954, + 174, 175, 40, 954, 954, 1146, 1480, 484, 1481, 41, + 42, 747, 48, 738, 504, 739, 806, 748, 740, 1539, + 48, 744, 1158, 212, 894, 1539, 307, 329, 411, 48, + 748, 110, 48, 139, 140, 372, 1539, 212, 461, 112, + 1539, 1186, 41, 42, 808, 1498, 1440, 887, 626, 411, + 462, 548, 106, 110, 112, 113, 345, 909, 112, 909, + 1134, 1527, 48, 112, 41, 42, 896, 715, 727, 1373, + 1374, 113, 748, 728, 1402, 1403, 48, 48, 1172, 291, + 327, 76, 982, 48, 935, 935, 525, 995, 983, 720, + 48, 508, 510, 706, 113, 307, 1236, 63, 513, 665, + 413, 1360, 579, 666, 912, 1422, 983, 748, 914, 69, + 1107, 129, 457, 130, 131, 132, 934, 116, 602, 751, + 106, 1327, 41, 42, 45, 46, 1361, 712, 1363, 564, + 1512, 212, 748, 527, 748, -293, 847, 773, 774, 48, + 1246, 1368, 8, 9, 10, 11, 12, 748, 1231, 781, + 782, 345, 8, 9, 10, 11, 12, 1430, 1448, 48, + 48, 692, 563, 1427, 748, 159, 565, 703, 703, 1494, + 498, 31, 626, 626, 566, 1495, 48, 775, 776, 1128, + 48, 31, 8, 9, 10, 11, 12, 1550, 481, 329, + 411, 644, 307, 579, -294, 830, 329, 602, 56, 34, + 70, 8, 9, 10, 11, 12, 714, 48, 1384, 34, + 338, 31, 1384, 777, 778, 779, 780, 48, 106, 569, + -441, 258, 1299, 1300, 1301, 703, 703, 587, 667, 159, + 31, 1145, 113, 411, 1157, 48, 411, 909, 1160, 34, + 602, 48, 909, 48, 37, 590, -3, 76, 40, 645, + 1162, 935, 602, 658, 659, 41, 42, 639, 34, 266, + 660, 37, 323, 472, 662, 40, 1108, 663, 664, 57, + 57, 339, 41, 42, 626, 1193, 1288, 1289, 112, 1291, + 342, 43, 1245, 48, 411, 257, 1296, 96, 1298, 45, + 46, 48, 669, 693, 694, 48, 696, 698, 719, 48, + 345, 57, 112, 749, 112, 734, 45, 46, -240, 1463, + 745, 2, 206, 4, 5, 6, 7, 757, 809, 96, + 37, 430, 174, 175, 40, 434, 810, 813, 442, 824, + 148, 41, 42, -12, 1355, 57, 96, 869, 57, 112, + 228, -13, 271, 113, 112, 875, 868, 895, 897, 111, + 189, 898, -418, 96, 902, 323, 96, 376, 905, 219, + 725, 113, 729, 723, 56, 307, 70, 923, -524, 106, + 37, 712, 174, 175, 40, 1316, 35, 938, 36, 626, + 945, 41, 42, 113, 947, 951, 952, 434, 958, 959, + 488, 106, 960, 961, 112, -295, 962, 692, 963, 1107, + 979, 48, 8, 9, 10, 11, 12, 703, 1038, 106, + 521, 990, 48, 991, 48, 703, 703, 703, 992, 1007, + 76, 1425, 1008, 159, 1009, 348, 1073, 1010, 626, 626, + 1011, 31, 1538, 48, 96, 1012, 63, 271, 1013, 1024, + -406, -405, 307, 908, 1408, 1096, 1075, 96, 69, 48, + 712, 1098, 1097, 1099, 112, 1105, 1115, 588, 748, 34, + 1116, 594, 1117, 48, 1119, 112, 48, 112, 106, 1122, + 973, 1124, 398, 189, 1125, 113, 1126, 1127, 399, 703, + 627, 1130, 1133, 400, 631, 401, 402, 339, 403, 1155, + 57, 1107, 1176, 404, 405, 1178, 96, 76, 1177, 48, + 1179, 106, 1194, 112, 1195, 112, 1180, 1197, 96, 112, + 1198, 1206, 867, 472, 210, 220, 212, 112, 1210, 1211, + 57, 1213, 407, -3, 1511, 1193, 408, 704, 1218, 1223, + 48, 48, 266, 1228, 493, 1226, 1232, 56, 96, 70, + 1237, 1239, 323, 323, 48, 37, 665, 1241, 626, 40, + 666, 162, 479, 1244, 1250, 1108, 41, 42, 692, 1256, + 1424, 920, 1252, 922, 1258, 194, 1260, 457, 217, 1261, + 688, 227, 1262, 113, 1263, 1264, 1266, 1273, 1290, 1282, + 1283, 1293, 814, 116, 602, 1294, 1311, 1295, 1318, 1107, + 45, 46, 1324, 1297, 1328, 113, 1305, 1332, 1333, 106, + 465, 1335, 113, 1340, 113, 1326, 113, 1342, 488, 441, + 323, 442, 488, 1348, 56, 96, 70, 1349, 1350, 149, + 1351, 106, 521, 1358, 521, 48, 150, 521, 106, 323, + 521, 151, 1359, 1362, 1369, 1510, 604, 48, 1370, 1301, + 113, 339, 113, 1378, 1379, 1386, 1380, 1108, 1387, 162, + 76, 1396, 1397, 113, 327, -407, 1400, 76, 1411, 1510, + 1510, 1415, 374, 1417, 1419, 1420, 472, 161, 1426, 307, + 176, 1434, 1435, 472, 173, 1421, 1436, 1439, 1193, 106, + 644, 1437, 66, 117, 1510, 1193, 112, 1444, 162, 1353, + 893, 373, 1449, 189, 1453, 323, 2, 206, 4, 5, + 6, 7, 348, 1455, 1451, 1457, 804, 1459, 76, 48, + 1461, 162, 1466, 1467, 66, 1468, 253, 1479, 48, 176, + 48, 1493, 176, 444, 472, 1489, 1491, 112, 528, 529, + 530, 160, 1496, 1497, 704, 1504, 1193, 845, 645, 1519, + 1520, 1524, 594, 1531, 1041, 1108, 1533, 1535, 854, 1541, + 48, 221, 531, 57, 532, 1548, 533, 1309, 1549, 890, + 1212, 35, 783, 36, 784, 1132, 785, 56, 176, 70, + 112, 96, 787, 1310, 56, 604, 70, 37, 786, 183, + 184, 40, 1499, 1414, 644, 1091, 1551, 259, 41, 42, + 1243, 1388, 112, 1372, 1217, 348, 112, 903, 1482, 904, + 1090, 688, 1225, 926, 1129, 215, 1094, 802, 1037, 874, + 989, 1104, 417, 940, 601, 111, 602, 717, 1319, 0, + 994, 242, 45, 46, 948, 56, 0, 70, 792, 328, + 374, 176, 793, 0, 1006, 437, 794, 259, 350, 488, + 0, 0, 645, 0, 0, 445, 112, 0, 0, 0, + 0, 0, 0, 0, 704, 0, 215, 0, 0, 0, + 348, 339, 0, 0, 704, 0, 0, 0, 406, 0, + 0, 0, 0, 0, 0, 0, 761, 0, 704, 0, + 0, 767, 0, 424, 112, 176, 429, 431, 816, 0, + 604, 160, 176, 0, 0, 0, 0, 0, 48, 215, + 0, 0, 0, 48, 348, 348, 348, 0, 374, 0, + 0, 0, 448, 520, 0, 0, 451, 0, 452, 0, + 48, 997, 348, 0, 0, 0, 804, 459, 0, 0, + 1486, 465, 1486, 66, 0, 0, 0, 0, 473, 0, + 924, 0, 1041, 0, 0, 0, 0, 0, 480, 0, + 0, 37, 0, 183, 184, 40, 431, 0, 0, 0, + 215, 176, 41, 42, 0, 0, 1486, 0, 1486, 0, + 0, 0, 0, 0, 0, 913, 0, 0, 176, 0, + 348, 0, 176, 0, 0, 0, 74, 0, 907, 0, + 411, 8, 9, 10, 11, 12, 45, 46, 215, 112, + 0, 0, 880, 215, 882, 0, 816, 604, 0, 908, + 0, 0, 0, 0, 804, 0, 0, 0, 74, 0, + 31, 339, 48, 259, 0, 0, 0, 595, 0, 0, + 0, 0, 987, 623, 0, 0, 0, 688, 1170, 1171, + 0, 0, 0, 0, 0, 176, 628, 0, 34, 0, + 628, 0, 0, 259, 929, 222, 0, 1286, 0, 488, + 1109, 323, 681, 112, 0, 112, 112, 0, 0, 0, + 0, 0, 348, 0, 8, 9, 10, 11, 12, 0, + 348, 0, 704, 704, 0, 0, 0, 0, 707, 215, + 571, 0, 411, 0, 0, 0, 1220, 1221, 45, 46, + 473, 816, 0, 31, 0, 0, 0, 0, 0, 1031, + 0, 0, 0, 604, 0, 350, 0, 845, 0, 0, + 473, 0, 0, 0, 0, 520, 0, 0, 473, 0, + 520, 34, 0, 520, 0, 0, 0, 0, 0, 0, + 704, 704, 353, 0, 0, 57, 699, 0, 0, 431, + 0, 0, 924, 0, 8, 9, 10, 11, 12, 0, + 0, 0, 0, 0, 713, 0, 66, 0, 0, 0, + 215, 0, 0, 750, 431, 411, 0, 0, 431, 0, + 0, 45, 46, 31, 0, 0, 0, 0, 0, 0, + 0, 0, 48, 48, 1085, 0, 913, 924, 688, 0, + 0, 112, 112, 176, 0, 0, 0, 259, 350, 0, + 0, 34, 215, 57, 0, 0, 449, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 604, 0, 0, 0, + 0, 0, 1142, 0, 0, 176, 0, 74, 0, 112, + 804, 0, 74, 0, 0, 0, 0, 77, 0, 0, + 0, 176, 0, 934, 795, 602, 0, 0, 0, 0, + 0, 45, 46, 0, 37, 176, 183, 184, 40, 0, + 0, 0, 628, 807, 0, 41, 42, 0, 1341, 77, + 0, 0, 0, 1031, 0, 826, 1343, 1344, 1345, 892, + 1317, 348, 348, 0, 0, 0, 48, 112, 899, 0, + 0, 185, 901, 595, 0, 0, 112, 1123, 595, 45, + 46, 57, 0, 0, 628, 0, 223, 350, 350, 350, + 48, 48, 704, 0, 0, 0, 0, 339, 0, 1135, + 704, 704, 704, 1135, 215, 350, 37, 222, 183, 184, + 40, 0, 0, 0, 0, 48, 176, 41, 42, 1109, + 1389, 0, 0, 699, 0, 0, 8, 9, 10, 11, + 12, 0, 215, 924, 473, 0, 0, 215, 0, 0, + 0, 0, 0, 907, 913, 411, 0, 0, 0, 913, + 0, 45, 46, 1135, 0, 31, 0, 0, 0, 0, + 473, 0, 0, 350, 704, 0, 0, 214, 0, 0, + 0, 0, 939, 355, 74, 431, 0, 0, 0, 0, + 0, 0, 0, 34, 0, 0, 0, 0, 37, 353, + 183, 184, 40, 0, 74, 924, 924, 259, 713, 41, + 42, 0, 74, 969, 0, 0, 0, 0, 215, 0, + 0, 1109, 0, 0, 0, 0, 0, 0, 214, 0, + 353, 0, 215, 0, 0, 601, 0, 602, 0, 0, + 0, 57, 57, 45, 46, 0, 0, 0, 353, 0, + 74, 0, 0, 699, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 699, 57, 350, 0, 628, 0, 0, + 1004, 214, 628, 807, 0, 0, 0, 699, 77, 0, + 0, 0, 57, 77, 0, 0, 0, 1015, 0, 0, + 0, 176, 353, 0, 0, 0, 0, 0, 0, 1081, + 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 1109, + 0, 26, 27, 28, 0, 0, 215, 348, 348, 0, + 31, 79, 214, 0, 0, 0, 57, 0, 66, 0, + 0, 57, 0, 0, 37, 0, 183, 184, 40, 0, + 1485, 0, 1485, 0, 0, 41, 42, 353, 34, 0, + 628, 0, 0, 79, 0, 207, 39, 259, 713, 0, + 214, 1087, 0, 0, 57, 214, 0, 0, 223, 0, + 1135, 265, 1135, 1135, 0, 0, 1485, 0, 1485, 45, + 46, 0, 0, 0, 0, 0, 0, 1101, 0, 0, + 224, 353, 353, 353, 0, 431, 117, 0, 45, 46, + 924, 0, 0, 0, 0, 323, 0, 0, 0, 353, + 0, 0, 0, 0, 0, 0, 924, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 353, 0, 0, + 0, 0, 0, 0, 0, 77, 0, 348, 74, 0, + 0, 0, 1207, 0, 0, 0, 0, 0, 0, 0, + 355, 214, 0, 595, 0, 77, 0, 0, 0, 0, + 0, 0, 57, 77, 74, 0, 429, 353, 0, 0, + 0, 699, 699, 0, 350, 350, 0, 356, 0, 0, + 0, 355, 0, 0, 57, 0, 924, 924, 0, 0, + 0, 57, 0, 0, 1192, 0, 0, 0, 0, 355, + 0, 77, 353, 0, 0, 0, 0, 0, 1135, 1135, + 0, 0, 0, 215, 0, 0, 8, 9, 10, 11, + 12, 0, 8, 9, 10, 11, 12, 0, 0, 699, + 699, 0, 214, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 57, 355, 0, 31, 1464, 353, 0, 0, + 0, 31, 0, 0, 0, 0, 0, 353, 0, 353, + 0, 0, 0, 0, 222, 0, 479, 353, 0, 0, + 0, 353, 79, 34, 214, 0, 628, 79, 37, 34, + 183, 184, 40, 0, 37, 0, 183, 184, 40, 41, + 42, 0, 0, 0, 176, 41, 42, 0, 0, 0, + 0, 0, 713, 0, 1513, 0, 0, 0, 355, 0, + 0, 0, 0, 1521, 0, 907, 0, 411, 0, 0, + 0, 185, 0, 45, 46, 0, 0, 0, 0, 45, + 46, 0, 74, 0, 0, 0, 0, 37, 0, 183, + 184, 40, 0, 0, 0, 1287, 0, 0, 41, 42, + 0, 0, 355, 355, 355, 0, 0, 0, 0, 0, + 0, 0, 353, 259, 0, 0, 0, 66, 0, 0, + 355, 0, 224, 0, 1509, 0, 411, 0, 0, 699, + 0, 713, 45, 46, 0, 117, 213, 0, 355, 0, + 1371, 0, 0, 0, 0, 232, 214, 0, 0, 77, + 0, 215, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 699, 0, 0, 0, 0, 0, 0, 0, 699, + 699, 699, 0, 0, 214, 77, 0, 0, 355, 214, + 350, 350, 0, 0, 0, 0, 0, 213, 86, 79, + 0, 0, 0, 0, 1192, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 356, 0, 0, 0, 0, 79, + 0, 0, 0, 355, 176, 0, 0, 79, 0, 0, + 86, 0, 0, 0, 0, 353, 353, 117, 353, 353, + 213, 0, 0, 699, 0, 356, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 215, 0, 74, 0, + 214, 0, 0, 356, 0, 79, 0, 225, 355, 0, + 0, 0, 0, 0, 214, 0, 0, 0, 355, 0, + 355, 0, 0, 0, 0, 223, 0, 0, 355, 0, + 0, 0, 355, 353, 353, 0, 0, 0, 0, 0, + 0, 213, 1483, 0, 1487, 0, 0, 356, 0, 0, + 350, 0, 8, 9, 10, 11, 12, 0, 0, 0, + 167, 0, 172, 0, 0, 178, 179, 180, 0, 182, + 0, 0, 0, 0, 0, 117, 0, 0, 1515, 213, + 1517, 31, 0, 233, 213, 0, 0, 0, 0, 0, + 0, 0, 0, 77, 363, 248, 249, 1192, 0, 499, + 0, 0, 0, 0, 1192, 0, 353, 0, 214, 34, + 0, 0, 356, 0, 37, 0, 183, 184, 40, 0, + 0, 0, 1546, 355, 1547, 41, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1554, 1555, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 222, + 0, 1509, 0, 411, 0, 1192, 356, 356, 356, 45, + 46, 0, 1534, 0, 0, 0, 0, 0, 0, 0, + 213, 74, 0, 0, 356, 0, 0, 0, 0, 0, + 0, 0, 0, 353, 0, 353, 0, 0, 0, 86, + 0, 0, 356, 0, 86, 0, 0, 0, 0, 0, + 0, 0, 0, 79, 0, 0, 0, 0, 0, 8, + 9, 10, 11, 12, 0, 353, 0, 0, 0, 0, + 0, 0, 0, 353, 353, 353, 0, 0, 0, 79, + 0, 0, 356, 0, 353, 353, 355, 355, 31, 355, + 355, 0, 0, 0, 0, 0, 0, 0, 74, 0, + 0, 213, 0, 0, 0, 0, 0, 0, 0, 77, + 0, 0, 0, 0, 0, 0, 34, 356, 213, 0, + 0, 37, 0, 183, 184, 40, 0, 0, 0, 0, + 0, 0, 41, 42, 0, 0, 0, 353, 0, 225, + 0, 0, 0, 213, 355, 355, 124, 127, 128, 0, + 0, 0, 0, 0, 0, 214, 0, 0, 265, 0, + 0, 0, 356, 0, 0, 0, 45, 46, 0, 0, + 0, 0, 356, 0, 356, 0, 0, 0, 0, 224, + 0, 0, 356, 0, 0, 0, 356, 0, 535, 536, + 537, 538, 539, 540, 541, 542, 543, 544, 545, 0, + 0, 592, 0, 600, 353, 0, 86, 0, 0, 0, + 0, 0, 0, 0, 624, 625, 0, 355, 254, 0, + 255, 363, 546, 0, 0, 0, 86, 0, 0, 0, + 0, 0, 0, 0, 86, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 79, 0, 0, + 0, 74, 363, 0, 0, 0, 0, 0, 74, 0, + 223, 0, 0, 0, 0, 213, 0, 0, 0, 0, + 363, 0, 86, 0, 0, 0, 0, 356, 0, 0, + 0, 0, 77, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 213, 355, 0, 355, 0, 213, 0, + 0, 396, 0, 0, 0, 0, 0, 0, 0, 74, + 0, 415, 416, 0, 363, 0, 420, 0, 422, 423, 0, 0, 0, 0, 0, 0, 355, 0, 0, 0, - 0, 77, 0, 0, 0, 0, 0, 0, 0, 77, - 0, 0, 353, 0, 0, 0, 595, 8, 9, 10, - 11, 12, 0, 0, 0, 0, 0, 355, 0, 429, - 0, 356, 0, 0, 699, 699, 0, 350, 350, 126, - 0, 0, 213, 0, 0, 355, 31, 77, 0, 0, - 0, 0, 0, 1108, 0, 0, 353, 1189, 0, 0, - 0, 0, 0, 0, 0, 0, 353, 0, 353, 0, - 0, 0, 0, 222, 34, 0, 353, 0, 0, 37, - 353, 183, 184, 40, 1482, 0, 1482, 0, 0, 355, - 41, 42, 699, 699, 0, 0, 0, 0, 0, 0, - 0, 1283, 0, 0, 0, 0, 0, 0, 0, 1480, - 0, 1484, 0, 0, 0, 0, 601, 215, 602, 0, - 1482, 0, 1482, 0, 45, 46, 79, 0, 0, 0, - 0, 79, 0, 0, 0, 0, 0, 213, 0, 628, - 0, 74, 0, 0, 0, 1512, 0, 1514, 0, 323, - 0, 0, 0, 0, 355, 0, 0, 0, 0, 0, - 0, 0, 0, 713, 0, 0, 0, 0, 0, 86, - 0, 353, 0, 0, 0, 0, 0, 413, 0, 0, - 0, 0, 0, 0, 421, 0, 0, 0, 0, 1543, - 0, 1544, 0, 0, 0, 0, 0, 0, 355, 355, - 355, 86, 0, 0, 1551, 1552, 1284, 0, 0, 0, - 0, 0, 215, 0, 0, 0, 355, 0, 0, 0, - 0, 0, 796, 797, 259, 0, 224, 0, 66, 0, - 0, 0, 0, 0, 355, 0, 0, 0, 225, 0, - 699, 0, 713, 0, 0, 77, 117, 0, 0, 0, - 0, 830, 0, 0, 833, 834, 413, 837, 0, 839, - 840, 0, 0, 0, 841, 842, 0, 0, 0, 0, - 0, 77, 699, 0, 355, 0, 0, 0, 0, 0, - 699, 699, 699, 0, 353, 353, 0, 353, 353, 0, - 0, 350, 350, 79, 0, 0, 0, 0, 8, 9, - 10, 11, 12, 0, 0, 1189, 0, 74, 356, 355, - 0, 577, 0, 79, 0, 0, 0, 0, 0, 581, - 0, 79, 584, 0, 0, 363, 0, 31, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 117, 356, - 0, 0, 353, 353, 699, 0, 126, 126, 0, 0, - 0, 0, 0, 355, 0, 34, 0, 356, 0, 79, - 37, 0, 0, 355, 40, 355, 0, 0, 0, 0, - 223, 41, 42, 355, 0, 126, 0, 355, 126, 126, - 0, 126, 0, 126, 126, 0, 413, 0, 126, 126, - 421, 0, 0, 0, 0, 0, 0, 43, 0, 0, - 0, 356, 970, 971, 0, 45, 46, 0, 0, 0, - 0, 350, 0, 353, 0, 0, 0, 0, 0, 0, - 86, 0, 0, 0, 0, 86, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 117, 0, 77, 0, + 0, 0, 0, 0, 355, 355, 355, 0, 0, 0, + 0, 0, 0, 214, 0, 355, 355, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 213, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 363, + 0, 0, 0, 213, 0, 0, 0, 0, 0, 0, + 356, 356, 0, 356, 356, 0, 0, 0, 355, 0, + 0, 0, 0, 499, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 79, 1014, 0, 0, 8, 9, 10, + 11, 12, 0, 363, 363, 363, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 214, 0, + 0, 363, 0, 0, 282, 283, 31, 284, 356, 356, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 363, + 0, 0, 0, 0, 0, 355, 0, 0, 0, 0, + 86, 0, 0, 285, 34, 0, 0, 213, 0, 286, + 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, + 41, 42, 0, 292, 293, 0, 86, 0, 0, 363, + 0, 0, 0, 8, 9, 10, 11, 12, 0, 0, + 0, 0, 77, 0, 0, 0, 294, 0, 379, 77, + 0, 356, 0, 0, 344, 46, 296, 297, 298, 299, + 0, 0, 31, 0, 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 222, 0, 1189, 0, - 0, 0, 0, 0, 0, 1189, 356, 413, 355, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 74, 0, + 0, 0, 0, 0, 0, 0, 0, 927, 0, 928, + 34, 0, 0, 0, 224, 37, 931, 932, 0, 40, + 77, 937, 0, 0, 0, 0, 41, 42, 0, 363, + 0, 0, 0, 942, 0, 0, 79, 0, 946, 363, + 0, 363, 0, 0, 0, 0, 225, 0, 356, 363, + 356, 0, 719, 363, 0, 0, 0, 0, 0, 0, + 45, 46, 0, 0, 0, 0, 980, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 353, 0, 353, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 8, 9, 10, 11, 12, 0, - 356, 356, 356, 0, 0, 0, 1189, 0, 0, 0, - 225, 0, 353, 1531, 0, 0, 126, 126, 356, 0, - 353, 353, 353, 31, 0, 0, 0, 0, 0, 0, - 0, 353, 353, 0, 0, 0, 356, 0, 0, 0, - 0, 0, 0, 0, 0, 74, 0, 79, 0, 577, - 577, 34, 0, 0, 1091, 0, 37, 0, 183, 184, + 356, 0, 0, 0, 0, 0, 0, 0, 356, 356, + 356, 0, 0, 0, 0, 0, 0, 0, 0, 356, + 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 79, 86, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 213, 0, 0, 0, 0, 0, + 0, 0, 1166, 0, 0, 8, 9, 10, 11, 12, + 0, 0, 0, 0, 363, 797, 798, 0, 0, 0, + 0, 0, 356, 0, 0, 0, 0, 0, 165, 0, + 0, 0, 282, 283, 31, 284, 1025, 1026, 1027, 1028, + 0, 1030, 0, 0, 831, 218, 0, 834, 835, 0, + 838, 0, 840, 841, 0, 0, 1074, 842, 843, 0, + 0, 285, 34, 0, 0, 0, 0, 286, 0, 0, + 1080, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 0, 0, 0, 0, 356, + 0, 0, 165, 0, 0, 0, 272, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 379, 0, 0, 0, + 1100, 0, 1167, 46, 296, 297, 298, 299, 0, 0, + 0, 0, 0, 0, 0, 165, 0, 363, 363, 0, + 363, 363, 0, 0, 0, 369, 79, 0, 0, 375, + 0, 0, 0, 79, 0, 0, 0, 0, 0, 0, + 86, 0, 0, 0, 0, 1131, 0, 0, 0, 0, + 0, 1140, 0, 0, 0, 0, 1144, 0, 0, 0, + 0, 1148, 0, 1149, 0, 0, 0, 1151, 0, 1152, + 1153, 0, 213, 1156, 0, 363, 363, 0, 165, 0, + 0, 0, 1168, 0, 79, 971, 972, 0, 0, 0, + 218, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1183, 1184, 0, 0, 0, 0, 0, 0, 165, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 1214, 0, 0, + 1216, 0, 0, 375, 0, 0, 0, 0, 31, 0, + 165, 0, 0, 0, 0, 0, 0, 0, 363, 0, + 0, 0, 126, 126, 126, 0, 0, 0, 0, 0, + 0, 0, 0, 524, 0, 0, 34, 213, 0, 0, + 0, 0, 0, 1230, 0, 0, 165, 0, 0, 1234, + 1235, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 225, 0, 0, 0, 0, 0, 0, 0, 1251, + 0, 0, 0, 1253, 0, 0, 0, 0, 1257, 0, + 0, 0, 0, 86, 598, 0, 0, 0, 0, 622, + 0, 1265, 0, 0, 126, 363, 126, 363, 0, 0, + 0, 0, 0, 0, 1272, 0, 1274, 1275, 1276, 1277, + 0, 0, 0, 0, 0, 0, 0, 0, 1092, 0, + 0, 275, 1284, 0, 1285, 0, 0, 363, 172, 0, + 0, 0, 0, 0, 0, 363, 363, 363, 0, 0, + 0, 0, 0, 0, 0, 0, 363, 363, 0, 0, + 211, 0, 0, 0, 0, 0, 0, 1313, 1314, 231, + 86, 235, 0, 237, 0, 165, 165, 0, 0, 0, + 246, 0, 369, 0, 0, 0, 0, 126, 0, 0, + 0, 0, 0, 0, 0, 126, 0, 126, 126, 0, + 0, 0, 126, 524, 126, 126, 0, 0, 0, 363, + 0, 211, 0, 235, 237, 246, 0, 1346, 1347, 0, + 0, 0, 0, 0, 0, 0, 0, 1357, 0, 0, + 0, 716, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 165, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 211, 524, 0, 524, 0, 0, + 524, 0, 165, 524, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 126, 369, 363, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1392, 1222, + 1393, 1394, 1395, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1399, 0, 0, 0, 0, 0, 0, 0, + 0, 1410, 0, 0, 0, 211, 0, 235, 237, 246, + 0, 0, 0, 86, 0, 0, 0, 0, 165, 0, + 86, 0, 0, 0, 0, 0, 1431, 0, 0, 0, + 369, 0, 0, 0, 812, 0, 0, 0, 0, 0, + 0, 0, 0, 211, 0, 0, 0, 0, 211, 0, + 0, 0, 0, 0, 156, 0, 0, 0, 0, 0, + 598, 0, 0, 497, 0, 598, 0, 0, 0, 1469, + 1470, 86, 0, 0, 369, 369, 369, 0, 0, 0, + 0, 0, 1475, 0, 0, 0, 0, 0, 0, 1475, + 0, 0, 369, 0, 0, 0, 0, 0, 0, 0, + 0, 251, 0, 0, 0, 0, 0, 0, 0, 0, + 1308, 256, 211, 0, 0, 0, 0, 0, 0, 0, + 0, 1508, 0, 0, 524, 1514, 0, 0, 0, 0, + 0, 0, 0, 0, 211, 0, 0, 0, 0, 235, + 237, 0, 0, 0, 0, 0, 0, 246, 0, 0, + 369, 0, 936, 1536, 0, 1537, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 386, 0, 1552, 1553, 716, 0, 0, 0, 0, + 211, 1556, 1557, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 418, 0, 0, 0, 211, 282, + 283, 0, 284, 211, 0, 211, 0, 0, 433, 0, + 0, 0, 0, 0, 0, 0, 0, 438, 0, 0, + 0, 0, 211, 0, 0, 211, 211, 446, 285, 0, + 0, 0, 369, 211, 286, 0, 622, 0, 287, 0, + 369, 288, 289, 290, 291, 41, 42, 211, 292, 293, + 0, 0, 464, 0, 211, 0, 0, 474, 0, 0, + 0, 126, 126, 0, 0, 0, 0, 0, 0, 0, + 482, 294, 0, 379, 0, 0, 492, 0, 496, 45, + 46, 296, 297, 298, 299, 0, 0, 0, 0, 0, + 126, 0, 788, 126, 126, 526, 126, 0, 126, 126, + 0, 0, 0, 126, 126, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -296, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 31, 716, 0, 0, 586, 0, + 0, 0, 0, 591, 0, 0, 0, 0, 0, 0, + 524, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 211, + 0, 0, 636, -296, 165, 0, 637, 638, 0, 640, + 0, 0, 0, 0, 0, 0, 651, 652, 0, 653, + 654, 0, 655, 0, 656, 0, 0, 211, 0, 0, + 0, 0, 211, 0, 0, 0, 0, 0, 0, 0, + 0, 586, 0, 0, 282, 283, 0, 284, 0, 671, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 598, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 126, 126, 285, 682, 0, 0, 0, 0, 286, + 0, 369, 369, 287, 0, 0, 288, 289, 290, 291, + 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, + 708, 0, 0, 211, 0, 0, 711, 0, 0, 0, + 0, 464, 0, 0, 0, 0, 294, 211, 379, 0, + 0, 380, 0, 0, 45, 46, 296, 297, 298, 299, + 0, 0, 0, 0, 0, 0, 0, 497, 0, 0, + 0, 524, 0, 0, 0, 0, 0, 746, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 764, 0, -519, 0, 0, 1, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 0, 26, 27, 28, 29, 0, 211, + 30, 791, 0, 31, 32, 0, 0, 0, 0, 716, + 801, 211, 0, 0, 0, 0, 0, 803, 0, 0, + 0, 0, 0, 811, 0, 0, 0, 0, 33, 126, + 211, 34, 825, 35, 126, 36, 37, 0, 38, 39, 40, 0, 0, 0, 0, 0, 0, 41, 42, 0, - 0, 355, 355, 79, 355, 355, 356, 86, 0, 0, - 0, 0, 0, 0, 353, 0, 0, 0, 0, 0, - 0, 0, 363, 906, 77, 411, 0, 86, 0, 0, - 0, 45, 46, 0, 0, 86, 0, 0, 0, 0, - 0, 356, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 363, 0, 0, 0, 0, 0, 355, - 355, 0, 0, 0, 0, 0, 884, 0, 0, 0, - 887, 363, 0, 86, 0, 0, 0, 0, 0, 0, - 0, 353, 0, 0, 0, 356, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 356, 0, 356, 0, 0, - 0, 0, 224, 126, 0, 356, 0, 0, 126, 356, - 0, 0, 0, 0, 0, 363, 167, 0, 172, 0, - 0, 178, 179, 180, 0, 182, 0, 0, 74, 0, - 355, 0, 0, 0, 0, 74, 0, 0, 0, 233, - 0, 0, 0, 0, 0, 1219, 0, 0, 0, 0, - 0, 248, 249, 0, 8, 9, 10, 11, 12, 0, + 0, 218, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 341, 364, 0, 0, 0, + 0, 0, 865, 43, 0, 44, 0, 0, 0, 0, + 0, 45, 46, 0, 0, 0, 0, 0, 716, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 414, + 0, 0, 0, 0, 0, 0, 414, 0, 811, 0, + 0, 0, 0, 0, 0, 0, 906, 0, 0, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 369, 369, 26, + 27, 28, 0, 211, 0, 0, 218, 251, 31, 0, + 0, 0, 0, 0, 0, 0, 0, 943, 944, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 79, 0, 0, 223, 0, 0, 0, 0, 0, 0, - 363, 0, 0, 31, 0, 0, 74, 0, 0, 0, - 0, 0, 0, 0, 0, 77, 0, 0, 0, 0, - 356, 0, 577, 0, 0, 0, 0, 355, 0, 355, - 0, 34, 0, 0, 0, 0, 37, 0, 183, 184, - 40, 0, 0, 0, 363, 363, 363, 41, 42, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 355, - 0, 0, 363, 0, 0, 0, 0, 355, 355, 355, - 0, 0, 0, 1506, 0, 411, 0, 0, 355, 355, - 363, 45, 46, 0, 0, 507, 0, 509, 512, 126, - 0, 86, 77, 0, 1305, 515, 516, 0, 0, 0, + 0, 0, 0, 211, 0, 0, 34, 0, 414, 0, + 0, 37, 0, 38, 39, 40, 0, 0, 0, 0, + 981, 0, 41, 42, 0, 126, 985, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 211, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 43, 211, + 157, 0, 0, 0, 0, 0, 45, 46, 0, 0, + 0, 0, 0, 414, 0, 0, 0, 0, 0, 0, + 0, 414, 582, 0, 414, 585, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 364, 0, 369, 0, 614, + 1019, 0, 0, 0, 0, 0, 0, 1020, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 632, 0, + 1022, 341, 1023, 0, 0, 0, 0, 0, 0, 0, + 0, 211, 0, 0, 0, 0, 1035, 0, 0, 0, + 0, 0, 1039, 0, 0, 211, 0, 0, 414, 0, + 0, 0, 414, 524, 1077, 524, 0, 1078, 0, 0, + 0, 0, 0, 0, 0, 0, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 509, 509, 0, 0, 0, 0, 0, 86, 0, 0, - 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 355, 0, 356, 356, 0, 356, 356, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 509, 0, - 0, 0, 0, 0, 0, 363, 79, 8, 9, 10, + 0, 0, 0, 364, 0, 0, 0, 0, 0, 524, + 0, 524, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 507, 0, 509, 512, 0, 0, 0, 0, + 0, 0, 515, 516, 0, 0, 0, 0, 165, 0, + 0, 0, 0, 0, 0, 0, 0, 509, 509, 414, + 0, 0, 364, 0, 591, 0, 211, 0, 0, 0, + 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, -296, + 0, 26, 27, 28, 0, 509, 0, 0, 0, 1150, + 31, 414, 0, 0, 0, 341, 364, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, + 0, 509, 0, 37, 0, 336, 337, 40, 0, -296, + 0, 0, 0, 0, 41, 42, 0, 0, 0, 0, + 0, 414, 414, 0, 0, 0, 0, 526, 0, 0, + 0, 211, 0, 1215, 0, 0, 321, 0, 0, 0, + 805, 364, 338, 0, 0, 0, 346, 0, 45, 46, + 0, 614, 0, 614, 614, 0, 0, 0, 382, 382, + 614, 0, 0, 0, 0, 0, 0, 1227, 0, 0, + 844, 364, 1229, 0, 0, 0, 364, 0, 0, 0, + 1233, 0, 0, 0, 0, 364, 364, 364, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 364, 0, 0, 0, 0, 414, 886, + 0, 0, 414, 889, 0, 1259, 0, 0, 0, 891, + 0, 0, 0, 0, 0, 0, 0, 1267, 0, 321, + 1268, 0, 1269, 0, 0, 0, 0, 0, 414, 0, + 0, 0, 0, 0, 0, 0, 1278, 1279, 0, 0, + 0, 0, 0, 478, 0, 0, 0, 0, 0, 0, + 0, 364, 614, 0, 0, 0, 0, 0, 1292, 0, + 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, + 509, 509, 509, 509, 509, 509, 509, 509, 0, 0, + 0, 0, 0, 0, 0, 341, 364, 0, 0, 0, + 414, 414, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1331, 0, 0, 0, 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, -296, 0, + 26, 27, 28, 0, 0, 414, 0, 0, 0, 31, + 0, 0, 0, 364, 0, 0, 0, 0, 0, 0, + 805, 364, 0, 0, 614, 0, 614, 0, 0, 0, + 382, 0, 0, 0, 0, 0, 614, 34, 211, 0, + 0, 0, 37, 0, 336, 337, 40, 0, -296, 0, + 1381, 0, 1382, 41, 42, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1390, 0, 1391, 0, + 0, 0, 0, 0, 0, 0, 509, 0, 0, 635, + 0, 338, 0, 1398, 0, 0, 0, 45, 46, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1416, + 1418, 0, 0, 0, 0, 0, 0, 0, 805, 0, + 1423, 0, 0, 1233, 0, 341, 364, 414, 0, 414, + 0, 0, 0, 414, 710, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1445, 0, 0, 509, 0, 0, + 0, 0, 0, 1452, 614, 614, 1454, 0, 1456, 1458, + 1460, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 742, 0, 0, 0, 0, 509, 0, + 0, 0, 0, 0, 0, 0, 759, 0, 0, 414, + 0, 742, 0, 0, 742, 0, 0, 0, 1490, 0, + 1492, 0, 1233, 0, 0, 0, 0, 769, 0, 0, + 414, 1147, 0, 0, 0, 0, 0, 1503, 0, 0, + 0, 364, 0, 0, 0, 0, 0, 414, 1159, 790, + 614, 614, 1164, 0, 0, 0, 0, 0, 0, 799, + 0, 0, 364, 364, 0, 0, 346, 0, 0, 0, + 0, 759, 0, 0, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 29, 0, 0, 30, 0, 0, + 31, 32, 0, 0, 0, 0, 0, 0, 509, 0, + 864, 0, 0, 0, 0, 414, 0, 414, 382, 0, + 0, 0, 414, 0, 0, 33, 0, 0, 34, 0, + 35, 614, 36, 37, 0, 38, 39, 40, 0, 0, + 0, 0, 0, 0, 41, 42, 0, 0, 0, 0, + 0, 0, 0, 509, 805, 414, 1247, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 43, 0, 44, 0, 0, 0, -523, 0, 45, 46, + 364, 0, 0, 0, 0, 0, 0, 0, 509, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 509, 0, 0, 0, 0, 0, 0, 282, 283, + 0, 284, 0, 0, 0, 0, 759, 0, 965, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 976, 0, + 0, 0, 0, 0, 984, 0, 0, 285, 0, 0, + 0, 341, 509, 641, 0, 139, 140, 287, 0, 0, + 288, 289, 290, 291, 41, 42, 0, 292, 293, 364, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1002, 1003, 0, + 294, 346, 642, 0, 643, 380, 0, 0, 45, 46, + 296, 297, 298, 299, 0, 346, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 364, 364, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 509, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1033, 0, 0, 0, 382, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, -293, 0, 26, 27, 28, - 0, 0, 0, 0, 509, 0, 31, 0, 0, 0, - 0, 356, 356, 0, 0, 0, 0, 0, 355, 363, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 363, - 0, 363, 0, 0, 34, 0, 225, 1143, 126, 363, - 0, 38, 39, 363, 0, -293, 0, 592, 0, 600, - 0, 0, 0, 0, 1155, 0, 0, 0, 0, 0, - 624, 625, 0, 0, 0, 77, 0, 0, 0, 0, - 282, 283, 77, 284, 0, 0, 635, 0, 338, 0, - 0, 0, 356, 0, 45, 46, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 285, - 0, 0, 0, 0, 86, 286, 0, 0, 0, 287, - 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, - 293, 0, 0, 77, 0, 224, 0, 0, 0, 0, - 0, 0, 413, 0, 363, 0, 0, 0, 0, 0, - 0, 0, 294, 0, 379, 0, 0, 79, 0, 0, - 45, 46, 296, 297, 298, 299, 0, 0, 0, 356, - 0, 356, 1013, 787, 0, 8, 9, 10, 11, 12, - 0, 0, 1243, 509, 509, 509, 509, 509, 509, 509, - 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, - 509, 356, 282, 283, 31, 284, 0, 0, 0, 356, - 356, 356, 0, 0, 0, 0, 0, 0, 0, 0, - 356, 356, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 285, 34, 0, 79, 0, 0, 286, 0, 0, - 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, - 0, 292, 293, 0, 0, 0, 0, 363, 363, 0, - 363, 363, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 356, 294, 0, 379, 0, 0, 0, - 86, 0, 344, 46, 296, 297, 298, 299, 0, 0, + 21, 22, 23, 24, 25, 0, 346, 26, 27, 28, + 29, 509, 509, 30, 0, 0, 31, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 33, 0, 0, 34, 321, 35, 0, 36, 37, + 0, 38, 39, 40, 0, 0, 0, 0, 364, 0, + 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 382, 0, 0, 0, 282, 283, 976, + 284, 0, 0, 742, 0, 0, 43, 0, 44, 0, + 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, + 0, 0, 0, 0, 1154, 0, 285, 0, 0, 0, + 0, 0, 286, 0, 0, 1169, 287, 0, 0, 288, + 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 382, 0, 1187, + 0, 0, 0, 282, 283, 414, 284, 0, 0, 294, + 0, 379, 0, 0, 976, 976, 758, 45, 46, 296, + 297, 298, 299, 0, 0, 0, 0, 0, 0, 414, + 414, 0, 285, 0, 0, 1219, 0, 0, 286, 0, + 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, + 42, 0, 292, 293, 414, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 294, 509, 379, 0, 0, + 973, 0, 0, 45, 46, 296, 297, 298, 299, 0, + 976, 0, 509, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 864, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1270, 1271, 0, 0, 0, + 0, 1, 2, 206, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 29, 509, 509, 30, 282, 283, 31, 1042, 1043, + 0, 1044, 0, 0, 1045, 1046, 1047, 1048, 1049, 1050, + 1051, 1052, 0, 0, 0, 1053, 0, 0, 0, 1054, + 1055, 0, 33, 0, 285, 34, 0, 35, 0, 36, + 1056, 0, 38, 39, 287, 0, 0, 288, 289, 290, + 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 294, 0, 1057, + 0, 0, 171, 0, 0, 45, 46, 296, 297, 298, + 299, 0, 0, 0, 0, 1058, 0, 0, 0, 0, + -131, 0, 0, 0, 0, 0, 1375, 0, 0, 742, 1, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 363, 363, 26, 27, 28, - 29, 0, 0, 30, 282, 283, 31, 284, 0, 509, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 356, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 285, 34, 0, 35, 0, 36, 286, - 0, 38, 39, 287, 165, 0, 288, 289, 290, 291, + 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, + 29, 0, 0, 30, 282, 283, 31, 284, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 0, 285, 34, 0, 35, 31, 36, 286, + 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, - 0, 218, 0, 0, 0, 0, 363, 79, 0, 0, - 509, 0, 0, 0, 79, 0, 294, 0, 1056, 0, - 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, - 0, 0, 0, 926, 0, 927, 0, 0, 0, -128, - 509, 0, 930, 931, 0, 0, 0, 936, 165, 225, - 0, 0, 272, 0, 0, 0, 0, 0, 0, 941, - 0, 0, 0, 0, 945, 79, 0, 0, 0, 0, - 0, 86, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 165, 0, 363, 0, 363, 0, 0, 0, 0, - 0, 369, 979, 0, 0, 375, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1163, 0, 0, 8, - 9, 10, 11, 12, 0, 363, 0, 0, 0, 0, - 0, 0, 0, 363, 363, 363, 0, 0, 0, 0, - 0, 0, 0, 0, 363, 363, 282, 283, 31, 284, - 0, 0, 0, 0, 165, 0, 0, 0, 86, 0, - 0, 0, 0, 0, 0, 0, 218, 0, 0, 0, - 509, 0, 0, 0, 0, 285, 34, 0, 0, 0, - 0, 286, 0, 0, 165, 287, 0, 0, 288, 289, - 290, 291, 41, 42, 0, 292, 293, 363, 0, 0, - 0, 1024, 1025, 1026, 1027, 0, 1029, 0, 0, 375, - 0, 0, 0, 0, 0, 509, 165, 0, 294, 0, - 379, 1073, 0, 0, 0, 0, 1164, 46, 296, 297, - 298, 299, 0, 0, 0, 1079, 0, 0, 0, 524, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 509, 0, 165, 0, 0, 0, 0, 0, 0, 211, - 0, 0, 0, 509, 363, 0, 0, 0, 231, 0, - 235, 0, 237, 0, 0, 1099, 0, 0, 0, 246, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 598, 0, 0, 0, 0, 622, 0, 0, 0, 0, - 0, 0, 0, 0, 509, 0, 0, 0, 0, 0, - 211, 86, 235, 237, 246, 0, 0, 0, 86, 0, - 1130, 0, 0, 0, 0, 0, 1137, 0, 0, 0, - 0, 1141, 0, 0, 0, 0, 1145, 0, 1146, 0, - 0, 0, 1148, 0, 1149, 1150, 0, 0, 1153, 0, - 0, 0, 0, 211, 0, 0, 0, 1165, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 86, - 0, 165, 165, 0, 0, 1180, 1181, 0, 369, 0, - 0, 509, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 524, - 0, 0, 1211, 0, 0, 1213, 0, 0, 0, 0, - 0, 0, 0, 0, 211, 0, 235, 237, 246, 0, - 0, 0, 0, 0, 0, 0, 0, 716, 0, 0, - 0, 8, 9, 10, 11, 12, 0, 0, 0, 165, - 0, 509, 509, 0, 0, 0, 0, 0, 1227, 0, - 0, 524, 211, 524, 1231, 1232, 524, 211, 165, 524, - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 369, 497, 0, 1248, 0, 0, 1252, 0, 0, - 0, 1254, 0, 0, 0, 0, 0, 0, 34, 0, - 0, 0, 0, 37, 1262, 183, 184, 40, 0, 0, - 0, 0, 0, 0, 41, 42, 0, 1269, 0, 1271, - 1272, 1273, 1274, 0, 0, 0, 0, 0, 0, 0, - 0, 211, 0, 0, 165, 1281, 0, 1282, 0, 0, - 185, 172, 0, 0, 0, 0, 369, 0, 45, 46, - 811, 0, 0, 211, 0, 0, 0, 0, 235, 237, - 0, 0, 0, 0, 0, 0, 246, 0, 0, 0, - 1310, 1311, 0, 0, 0, 0, 598, 0, 0, 0, - 0, 598, 0, 0, 0, 0, 0, 0, 0, 0, - 369, 369, 369, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 369, 211, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1343, 1344, 0, 0, 0, 0, 0, 211, 0, 0, - 1354, 0, 211, 0, 211, 0, 0, 0, 0, 0, - 524, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 211, 0, 0, 211, 211, 509, 0, 0, 0, - 0, 0, 211, 0, 0, 0, 369, 0, 935, 0, - 0, 0, 509, 0, 0, 0, 211, 0, 0, 0, - 0, 0, 0, 211, 0, 0, 0, 0, 0, 0, - 0, 1389, 0, 1390, 1391, 1392, 0, 0, 0, 0, - 0, 716, 0, 0, 0, 1396, 156, 0, 0, 0, - 0, 0, 0, 0, 1407, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 0, 0, 26, 27, 28, 0, 1428, - 0, 0, 509, 509, 31, 0, 0, 8, 9, 10, - 11, 12, 0, 251, 0, 0, 0, 369, 0, 0, - 0, 622, 0, 256, 0, 369, 0, 0, 0, 0, - 0, 0, 34, 0, 0, 0, 31, 37, 0, 38, - 39, 40, 1466, 1467, 0, 0, 0, 0, 41, 42, - 0, 0, 0, 0, 0, 1472, 0, 0, 211, 0, - 0, 0, 1472, 0, 34, 0, 0, 0, 0, 37, - 0, 183, 184, 40, 43, 0, 157, 0, 0, 156, - 41, 42, 45, 46, 0, 0, 211, 0, 0, 0, - 0, 211, 0, 386, 1505, 0, 0, 0, 1511, 0, - 0, 0, 0, 0, 0, 0, 265, 0, 0, 0, - 0, 0, 0, 0, 45, 46, 418, 0, 0, 0, - 716, 0, 0, 0, 0, 0, 1533, 0, 1534, 0, - 433, 0, 0, 0, 0, 524, 0, 0, 0, 438, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 446, - 0, 0, 0, 0, 0, 0, 1549, 1550, 0, 165, - 0, 0, 211, 0, 1553, 1554, 0, 0, 0, 0, - 0, 0, 0, 0, 464, 0, 211, 0, 0, 474, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 482, 0, 0, 0, 497, 0, 492, 0, - 496, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 598, 0, 526, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 369, 369, 26, 27, - 28, 0, 0, 0, 0, 0, 0, 31, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 211, 0, 0, - 586, 0, 0, 0, 0, 591, 0, 0, 0, 211, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, - 37, 0, 38, 39, 40, 0, 0, 0, 211, 0, - 0, 41, 42, 0, 636, 0, 524, 0, 637, 638, - 0, 640, 0, 0, 0, 0, 0, 0, 651, 652, - 0, 653, 654, 0, 655, 0, 656, 43, 0, 44, - 0, 0, 0, 0, 0, 45, 46, 0, 0, 0, - 0, 0, 0, 586, 0, 0, 0, 0, 0, 0, - 0, 671, 0, 0, 0, 0, 0, 0, 0, 341, - 364, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 716, 0, 0, 0, 682, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 8, 9, 10, 11, - 12, 0, 0, 414, 0, 0, 0, 0, 0, 0, - 414, 0, 708, 0, 0, 0, 0, 0, 711, 0, - 0, 211, 0, 464, 218, 31, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, -293, 0, 26, 27, 28, 0, - 0, 211, 0, 34, 0, 31, 0, 0, 37, 746, - 0, 716, 40, 0, 0, 0, 0, 0, 0, 41, - 42, 0, 0, 0, 764, 0, 0, 0, 0, 0, - 0, 0, 414, 34, 0, 0, 211, 0, 37, 0, - 336, 337, 40, 0, -293, 719, 0, 211, 0, 41, - 42, 0, 0, 45, 46, 0, 0, 0, 0, 0, - 369, 369, 0, 790, 0, 0, 0, 0, 0, 218, - 0, 0, 800, 0, 0, 635, 0, 338, 321, 802, - 0, 0, 0, 45, 46, 810, 0, 414, 346, 0, - 0, 0, 0, 0, 824, 414, 582, 0, 414, 585, - 382, 382, 0, 0, 0, 0, 0, 0, 0, 364, - 0, 0, 0, 614, 0, 0, 0, 0, 0, 211, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 632, 211, 864, 341, 205, 2, 206, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 414, 26, 27, 28, 414, 0, 0, 0, - 810, 321, 31, 0, 0, 0, 0, 0, 905, 0, - 369, 0, 282, 283, 0, 284, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 478, 0, 364, 0, 0, - 34, 0, 35, 0, 36, 0, 0, 207, 39, 251, - 0, 285, 0, 0, 0, 0, 0, 286, 0, 942, - 943, 287, 211, 0, 288, 289, 290, 291, 41, 42, - 0, 292, 293, 0, 0, 0, 524, 0, 524, 0, - 0, 0, 0, 414, 208, 0, 364, 0, 0, 0, - 45, 46, 980, 0, 294, 0, 379, 984, 0, 380, - 0, 0, 45, 46, 296, 297, 298, 299, 0, 0, - 0, 0, 524, 0, 524, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 414, 0, 0, 0, 341, - 364, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 165, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 382, 0, 0, 0, 0, 211, 0, 0, - 0, 1018, 0, 0, 0, 0, 0, 0, 1019, 0, - 0, 0, 0, 0, 0, 414, 414, 0, 0, 0, - 0, 1021, 0, 1022, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 804, 364, 0, 1034, 0, 0, - 0, 0, 0, 1038, 0, 614, 0, 614, 614, 0, - 0, 0, 0, 0, 614, 1076, 0, 0, 1077, 0, - 0, 0, 0, 0, 843, 364, 0, 0, 0, 0, - 364, 0, 0, 0, 0, 0, 0, 0, 0, 364, - 364, 364, 0, 0, 0, 0, 710, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 364, 0, 0, - 0, 0, 414, 885, 0, 0, 414, 888, 0, 0, - 0, 0, 0, 890, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 742, 0, 0, 0, 0, - 0, 0, 414, 0, 0, 591, 0, 0, 759, 0, - 0, 0, 0, 742, 0, 0, 742, 0, 0, 0, - 0, 0, 0, 0, 0, 364, 614, 0, 0, 768, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1147, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 789, 0, 0, 0, 0, 0, 0, 0, 341, - 364, 798, 0, 0, 414, 414, 0, 0, 346, 0, - 0, 0, 0, 759, 0, 0, 0, 0, 0, 0, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 526, 0, - 26, 27, 28, 0, 1212, 0, 0, 0, 414, 31, - 0, 0, 0, 0, 211, 0, 364, 0, 0, 0, - 0, 0, 863, 804, 364, 0, 0, 614, 0, 614, - 382, 0, 0, 0, 0, 0, 0, 34, 1224, 614, - 0, 0, 37, 1226, 207, 39, 40, 0, 0, 0, - 0, 1230, 0, 41, 42, 0, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, -293, 0, 0, 0, 0, 43, - 0, 270, 0, 0, 1256, 31, 0, 45, 46, 0, - 0, 0, 0, 0, 0, 0, 1264, 0, 0, 1265, - 0, 1266, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 804, 0, 34, 0, 1275, 1276, 0, 341, 364, - 414, 0, 414, 0, -293, 0, 414, 0, 759, 0, - 964, 0, 0, 0, 0, 0, 0, 1289, 0, 0, - 975, 0, 0, 0, 0, 0, 983, 614, 614, 0, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, -294, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, - 0, 0, 414, 0, 1328, 0, 0, 0, 1001, 1002, - 0, 0, 346, 0, 0, 0, 0, 0, 282, 283, - 0, 284, 0, 414, 1144, 0, 346, 34, 0, 0, - 0, 0, 0, 0, 364, 0, 0, 0, -294, 0, - 414, 1156, 0, 614, 614, 1161, 0, 285, 0, 0, - 0, 0, 0, 286, 0, 364, 364, 287, 0, 0, - 288, 289, 290, 291, 41, 42, 1032, 292, 293, 0, - 382, 0, 0, 0, 0, 0, 0, 0, 0, 1378, - 0, 1379, 0, 0, 0, 0, 0, 0, 0, 0, - 294, 0, 379, 1387, 0, 1388, 0, 758, 45, 46, - 296, 297, 298, 299, 0, 0, 0, 346, 0, 0, - 0, 0, 1395, 0, 0, 0, 0, 0, 414, 0, - 414, 0, 0, 0, 0, 414, 0, 0, 1413, 1415, - 0, 0, 0, 0, 614, 0, 0, 0, 0, 1420, - 0, 0, 1230, 0, 0, 0, 321, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 804, 414, 1244, - 0, 0, 0, 1442, 0, 0, 0, 0, 0, 0, - 0, 0, 1449, 0, 382, 1451, 0, 1453, 1455, 1457, - 975, 364, 0, 0, 742, 282, 283, 0, 284, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1151, 0, 0, 0, 0, - 0, 0, 0, 0, 285, 0, 1166, 1487, 0, 1489, - 641, 1230, 139, 140, 287, 0, 0, 288, 289, 290, - 291, 41, 42, 0, 292, 293, 1500, 0, 382, 0, - 1184, 0, 341, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 975, 975, 294, 0, 642, - 364, 643, 380, 0, 0, 45, 46, 296, 297, 298, - 299, 0, 0, 0, 0, 0, 1216, 0, 0, 0, + 110, 0, 38, 39, 0, 0, 294, 0, 1057, 0, + 0, 41, 42, 0, 45, 46, 296, 297, 298, 299, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -131, 0, 0, 0, 0, 1, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 364, - 364, 26, 27, 28, 29, 0, 0, 30, 0, 0, - 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 975, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 34, 863, - 35, 0, 36, 0, 0, 38, 39, 0, 0, 0, - 0, 0, 0, 0, 1267, 1268, 0, 1, 2, 206, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 44, 0, 26, 27, 28, 29, 45, 46, - 30, 282, 283, 31, 1041, 1042, 0, 1043, 0, 0, - 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 0, 0, - 0, 1052, 0, 0, 0, 1053, 1054, 0, 33, 364, - 285, 34, 0, 35, 0, 36, 1055, 0, 38, 39, - 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, - 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 29, 0, 0, 30, 282, 283, + 31, 284, 0, 0, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -297, 0, 0, 0, 285, 34, 0, + 35, 0, 36, 286, 31, 38, 39, 287, 0, 321, + 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 294, 0, 1056, 0, 0, 171, 0, - 0, 45, 46, 296, 297, 298, 299, 0, 0, 0, - 0, 1057, 0, 0, 0, 0, -128, 0, 0, 0, - 0, 0, 0, 0, 0, 1372, 0, 0, 742, 0, - 0, 0, 0, 0, 0, 0, 414, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 414, 414, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 414, 1, 2, 206, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 0, 26, 27, 28, 29, 0, 0, 30, - 282, 283, 31, 284, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 0, 26, 27, 28, 0, 0, 285, - 34, 0, 35, 31, 36, 286, 0, 38, 39, 287, - 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, - 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 34, 0, 0, 0, 0, 110, 0, 38, 39, - 0, 0, 294, 0, 44, 0, 0, 41, 42, 0, - 45, 46, 296, 297, 298, 299, 2, 206, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 0, 0, 26, 27, 28, 0, 0, 0, 321, 282, - 283, 31, 284, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 0, 26, 27, 28, 0, 0, 285, 34, - 0, 35, 31, 36, 286, 0, 38, 39, 287, 0, - 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 34, 0, 0, 0, 0, 0, 0, 38, 39, 0, - 0, 294, 0, 343, 0, 0, 0, 0, 758, 344, - 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 0, 0, 0, 0, 282, 283, - 31, 284, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 0, 0, 26, 27, 28, 0, 0, 285, 34, 0, - 35, 31, 36, 286, 0, 38, 39, 287, 0, 0, - 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, - 0, 0, 0, 0, 0, 0, 207, 39, 0, 0, - 294, 0, 963, 0, 0, 0, 0, 758, 344, 46, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, + 294, 0, 44, -297, 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, @@ -2468,22 +2471,22 @@ 284, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 0, 0, 0, 0, 0, 285, 34, 0, 35, + 0, 26, 27, 28, 0, 0, 285, 34, 0, 35, 31, 36, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, - 0, 963, 0, 0, 0, 0, 758, 45, 46, 296, + 0, 0, 0, 0, 0, 38, 39, 0, 0, 294, + 0, 343, 0, 0, 0, 0, 758, 344, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, 282, 283, 31, 284, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 285, 34, 0, 35, 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, + 26, 27, 28, 0, 0, 285, 34, 0, 35, 31, 36, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 294, 0, - 343, 0, 0, 0, 0, 0, 344, 46, 296, 297, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, + 0, 0, 0, 0, 207, 39, 0, 0, 294, 0, + 964, 0, 0, 0, 0, 758, 344, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, @@ -2493,9 +2496,9 @@ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 285, 34, 0, 35, 0, 36, - 286, 0, 207, 39, 287, 0, 0, 288, 289, 290, + 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 294, 0, 998, - 0, 0, 0, 0, 0, 999, 46, 296, 297, 298, + 0, 0, 0, 0, 0, 0, 0, 294, 0, 964, + 0, 0, 0, 0, 758, 45, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, @@ -2508,5 +2511,5 @@ 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 294, 0, 963, 0, + 0, 0, 0, 0, 0, 0, 294, 0, 343, 0, 0, 0, 0, 0, 344, 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, @@ -2520,338 +2523,354 @@ 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 294, 0, 379, 0, 0, - 0, 0, 0, 45, 46, 296, 297, 298, 299, -516, - 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, + 0, 0, 0, 0, 0, 294, 0, 999, 0, 0, + 0, 0, 0, 1000, 46, 296, 297, 298, 299, 2, + 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, + 0, 0, 282, 283, 31, 284, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 285, 34, 0, 35, 0, 36, 286, 0, 38, + 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 964, 0, 0, 0, + 0, 0, 344, 46, 296, 297, 298, 299, 2, 206, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 0, 26, 27, 28, 0, 0, 0, + 0, 282, 283, 31, 284, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 285, 34, 0, 35, 0, 36, 286, 0, 207, 39, + 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, + 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 294, 0, 379, 0, 0, 0, 0, + 0, 45, 46, 296, 297, 298, 299, 205, 2, 206, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 0, 0, 26, 27, 28, 0, 0, 0, + 0, 0, 0, 31, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 0, 0, 26, 27, 28, 485, 486, + 487, 34, 0, 35, 31, 36, 37, 0, 207, 39, + 40, 0, 0, 0, 0, 0, 0, 41, 42, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 38, + 39, 0, 0, 43, 0, 208, 0, 0, 0, 0, + 0, 45, 46, 1, 2, 206, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, -296, 0, + 26, 27, 28, 29, 0, 0, 30, 0, 0, 31, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, + 0, 36, 0, 0, 38, 39, 0, 0, -296, 1, + 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 29, + 0, 44, 30, 0, 0, 31, 0, 45, 46, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 34, 0, 35, 0, 36, 0, 0, + 38, 39, 205, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, - 27, 28, 29, 0, 0, 30, 0, 0, 31, 32, + 27, 28, 0, 0, 0, 0, 0, 44, 31, 0, + 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 34, 0, 35, 0, + 36, 0, 0, 207, 39, 0, 2, 206, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 0, + 208, 31, 0, 0, 0, 0, 45, 46, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, + 0, 35, 0, 36, 37, 0, 207, 39, 40, 0, + 0, 0, 0, 0, 0, 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 33, 0, 0, 34, 0, 35, 0, - 36, 37, 0, 38, 39, 40, 0, 0, 0, 0, - 0, 0, 41, 42, 0, 0, 0, 0, 0, 0, + 0, 43, 0, 208, 0, 0, 0, 0, 0, 45, + 46, 2, 206, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, + 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, + 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 27, 28, 34, 0, 35, 0, 36, 0, + 31, 38, 39, 0, 2, 206, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 34, 0, + 26, 27, 28, 0, 0, 38, 39, -403, 678, 31, + 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 43, 0, - 44, 0, 0, 0, 0, 0, 45, 46, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, + 635, 36, 338, 0, 38, 39, 0, 0, 45, 46, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1354, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 678, 0, 0, 0, 0, 0, 45, 46, 2, + 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 0, 0, 26, 27, 28, 29, 0, - 0, 30, 0, 0, 31, 32, 0, 0, 0, 0, + 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, + 0, 0, 0, 0, 31, 0, 0, 0, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 34, 0, 35, 0, 36, 31, 685, 38, + 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, - 0, 0, 34, 0, 35, 0, 36, 37, 0, 38, - 39, 40, 0, 0, 0, 0, 0, 0, 41, 42, + 0, 1356, 0, 0, 0, 34, 0, 0, 0, 0, + 0, 0, 38, 39, 0, 0, 678, 0, 0, 0, + 0, 0, 45, 46, 2, 206, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 686, + 26, 27, 28, 687, 0, 45, 46, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 43, 0, 44, 0, 0, 0, - -520, 0, 45, 46, 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 29, 0, 0, 30, 0, 0, - 31, 32, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 33, 0, 0, 34, 0, - 35, 0, 36, 37, 0, 38, 39, 40, 0, 0, - 0, 0, 0, 0, 41, 42, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 43, 0, 44, 0, 0, 0, 0, 0, 45, 46, - 205, 2, 206, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, - 0, 0, 0, 0, 0, 0, 31, 0, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, - 28, 485, 486, 487, 34, 0, 35, 31, 36, 37, - 0, 207, 39, 40, 0, 0, 0, 0, 0, 0, - 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, - 0, 0, 38, 39, 0, 0, 43, 0, 208, 0, - 0, 0, 0, 0, 45, 46, 1, 2, 206, 4, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, + 0, 36, 0, 0, 207, 39, 0, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, -293, 0, 26, 27, 28, 29, 0, 0, 30, - 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, + 0, 270, 31, 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, 0, 0, 38, 39, 0, - 0, -293, 2, 206, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, - 28, 0, 0, 0, 44, 0, 0, 31, 0, 0, + 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, + 0, 0, 0, 0, 678, 31, 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, - 37, 0, 207, 39, 40, 0, 0, 0, 0, 0, - 0, 41, 42, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 43, 0, 208, - 0, 0, 0, 0, 0, 45, 46, 2, 206, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 0, 26, 27, 28, 0, 0, 0, 0, - 0, 0, 31, 0, 0, 0, 0, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, - 34, 0, 35, 0, 36, 0, 31, 38, 39, 0, - 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 34, 0, 26, 27, 28, 0, - 0, 38, 39, -400, 678, 31, 0, 0, 0, 0, - 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 34, 0, 35, 635, 36, 338, 0, - 38, 39, 0, 0, 45, 46, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1351, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 678, 0, 0, - 0, 0, 0, 45, 46, 2, 206, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 0, 0, 0, 0, 0, 0, - 31, 0, 0, 0, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 0, 26, 27, 28, 0, 34, 0, - 35, 0, 36, 31, 685, 38, 39, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1353, 0, 0, - 0, 34, 0, 0, 0, 0, 0, 0, 38, 39, - 0, 0, 678, 0, 0, 0, 0, 0, 45, 46, - 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 686, 26, 27, 28, 687, - 0, 45, 46, 0, 0, 31, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, 0, 0, - 207, 39, 0, 2, 206, 4, 5, 6, 7, 8, + 38, 39, 0, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, - 27, 28, 0, 0, 0, 0, 0, 270, 31, 0, + 27, 28, 0, 0, 0, 0, 0, 593, 31, 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, 0, - 36, 0, 0, 38, 39, 0, 2, 206, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 0, 0, 26, 27, 28, 0, 0, 0, 0, 0, - 678, 31, 0, 0, 0, 0, 45, 46, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, - 0, 35, 0, 36, 0, 0, 38, 39, 0, 2, - 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 36, 0, 0, 207, 39, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, - 0, 0, 0, 593, 31, 0, 0, 0, 0, 45, - 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 282, 283, 31, 284, 0, 0, 0, 0, + 208, 0, 0, 0, 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 34, 0, 35, 0, 36, 0, 0, 207, - 39, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 0, 285, 34, 0, 0, 0, 0, 286, 0, 38, + 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 517, 0, 0, 171, + 0, 0, 45, 46, 296, 297, 298, 299, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 0, 0, 0, 282, 283, 31, 284, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, + 27, 28, 0, 0, 285, 34, 0, 0, 31, 0, + 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, + 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, + 0, 37, 0, 336, 337, 40, 0, 294, -37, 295, + 0, 0, 41, 42, 0, 45, 46, 296, 297, 298, + 299, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 0, 0, 0, 0, 282, 283, - 31, 284, 0, 0, 0, 0, 208, 0, 0, 0, - 0, 0, 45, 46, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 285, 34, 0, - 0, 0, 0, 286, 0, 38, 39, 287, 0, 0, + 338, 26, 27, 28, 0, 0, 45, 46, 282, 283, + 31, 284, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 285, 34, 0, + 0, 31, 0, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 294, 0, 517, 0, 0, 171, 0, 0, 45, 46, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, + 0, 0, 0, 0, 110, 0, 38, 39, 0, 0, + 294, 0, 295, 0, 0, 41, 42, 0, 45, 46, 296, 297, 298, 299, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 0, 26, 27, 28, 0, 0, 0, - 0, 282, 283, 31, 284, 8, 9, 10, 11, 12, + 24, 25, 0, 44, 26, 27, 28, 0, 0, 45, + 46, 282, 283, 31, 284, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, 0, - 285, 34, 0, 0, 31, 0, 286, 0, 38, 39, + 285, 34, 0, 0, 31, 685, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 34, 0, 0, 0, 0, 37, 0, 336, - 337, 40, 0, 294, -36, 295, 0, 0, 41, 42, + 0, 0, 34, 0, 0, 0, 0, 0, 0, 38, + 39, 0, 0, 294, 0, 157, 0, 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 0, 338, 26, 27, 28, - 0, 0, 45, 46, 282, 283, 31, 284, 8, 9, + 21, 22, 23, 24, 25, 0, 686, 26, 27, 28, + 1093, 0, 45, 46, 282, 283, 31, 284, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, - 28, 0, 0, 285, 34, 0, 0, 31, 0, 286, + 28, 0, 0, 285, 34, 0, 0, 31, 685, 286, 0, 38, 39, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, - 110, 0, 38, 39, 0, 0, 294, 0, 295, 0, - 0, 41, 42, 0, 45, 46, 296, 297, 298, 299, + 0, 0, 38, 39, 0, 0, 294, 0, 593, 0, + 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 0, 44, - 26, 27, 28, 0, 0, 45, 46, 282, 283, 31, - 284, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 686, + 26, 27, 28, 1224, 0, 45, 46, 282, 283, 31, + 284, 0, 0, 0, 0, 0, 0, 0, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 285, 34, 26, 27, + 28, 0, 286, 0, 38, 39, 287, 31, 0, 288, + 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 34, 0, 0, 0, 294, + 0, 379, 38, 39, 0, 0, 0, 45, 46, 296, + 297, 298, 299, 467, 2, 206, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 0, 257, + 26, 27, 28, 0, 0, 45, 46, 0, 0, 31, + 0, 0, 0, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 0, 0, 26, 27, 28, 0, 34, 0, 35, + 0, 36, 31, 0, 38, 39, 0, 0, 0, 0, + 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 26, 27, 28, 0, 0, 285, 34, 0, 0, - 31, 685, 286, 0, 38, 39, 287, 0, 0, 288, - 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, - 0, 0, 0, 0, 0, 38, 39, 0, 0, 294, - 0, 157, 0, 0, 0, 0, 0, 45, 46, 296, - 297, 298, 299, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 686, 26, 27, 28, 1092, 0, 45, 46, - 282, 283, 31, 284, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 0, 26, 27, 28, 0, 0, 285, - 34, 0, 0, 31, 685, 286, 0, 38, 39, 287, - 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, - 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 34, 0, 0, 0, 0, 0, 0, 38, 39, - 0, 0, 294, 0, 593, 0, 0, 0, 0, 0, - 45, 46, 296, 297, 298, 299, 8, 9, 10, 11, + 34, 26, 27, 28, 0, 37, 0, 38, 39, 40, + 31, 0, 0, 0, -3, 0, 41, 42, 0, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 0, 34, 26, + 27, 28, 43, 37, 44, 207, 39, 40, 31, 0, + 45, 46, 0, 0, 41, 42, 0, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, -296, 34, 26, 27, 28, + 43, 37, 270, 336, 337, 40, 31, 0, 45, 46, + 0, 0, 41, 42, 0, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -296, 34, 26, 27, 28, 635, 0, + 338, 38, 39, 0, 31, -296, 45, 46, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 34, 0, 0, 0, 635, 31, 338, 38, + 39, 0, 0, -296, 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 686, 26, 27, 28, 1221, - 0, 45, 46, 282, 283, 31, 284, 0, 0, 0, - 0, 0, 0, 0, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 285, 34, 26, 27, 28, 0, 286, 0, - 38, 39, 287, 31, 0, 288, 289, 290, 291, 41, - 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 34, 0, 0, 0, 294, 0, 379, 38, 39, - 0, 0, 0, 45, 46, 296, 297, 298, 299, 467, - 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 257, 26, 27, 28, 0, - 0, 45, 46, 0, 0, 31, 0, 0, 0, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, -293, 0, 26, - 27, 28, 0, 34, 0, 35, 0, 36, 31, 0, - 38, 39, 0, 0, 0, 0, 0, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 0, 34, 26, 27, 28, - 0, 37, 0, 336, 337, 40, 31, -293, 0, 0, - -3, 0, 41, 42, 0, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, -293, 34, 26, 27, 28, 0, 37, - 338, 336, 337, 40, 31, 0, 45, 46, 0, 0, - 41, 42, 0, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 34, 26, 27, 28, 635, 0, 338, 38, - 39, 0, 31, -293, 45, 46, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, - 34, 0, 0, 0, 0, 31, 338, 38, 39, 0, + 22, 23, 24, 25, 0, 34, 26, 27, 28, 0, + 0, 0, 38, 39, 0, 31, 338, 0, 0, 0, 0, 0, 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 0, 34, 26, 27, 28, 0, 0, 0, - 207, 39, 0, 31, 157, 0, 0, 0, 0, 0, - 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 0, 34, 26, 27, 28, 0, 0, 270, 38, 39, - 0, 31, 0, 45, 46, 8, 9, 10, 11, 12, + 24, 25, 0, 34, 26, 27, 28, 0, 0, 157, + 207, 39, 0, 31, 0, 45, 46, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 0, 0, 26, 27, 28, + 0, 34, 0, 0, 0, 0, 31, 270, 38, 39, + 0, 0, 0, 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 0, 0, 26, 27, 28, 0, 34, - 0, 0, 0, 0, 31, 338, 38, 39, 0, 0, + 23, 24, 25, 0, 34, 26, 27, 28, 0, 0, + 0, 38, 39, 0, 31, 338, 0, 0, 0, 0, 0, 45, 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 0, 34, 26, 27, 28, 0, 0, 0, 38, - 39, 0, 31, 686, 0, 0, 0, 0, 0, 45, - 46, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 34, 26, 27, 28, 0, 0, 593, 38, 39, 0, - 31, 0, 45, 46, 2, 206, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 34, 0, - 26, 27, 28, 0, 44, 207, 39, 0, 0, 31, - 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 34, 26, 27, 28, 0, 0, 686, 38, + 39, 0, 31, 0, 45, 46, 2, 206, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 34, 0, 26, 27, 28, 0, 593, 38, 39, 0, + 0, 31, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 34, 0, 35, - 0, 36, 0, 0, 38, 39, 0, 0, 45, 46, - 282, 283, 0, 284, 1042, 0, 1043, 0, 0, 1044, - 1045, 1046, 1047, 1048, 1049, 1050, 1051, 0, 0, 1525, - 1052, 0, 0, 0, 1053, 1054, 0, 33, 0, 285, - -413, 0, 0, 0, 0, 1055, 0, 0, 0, 287, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, + 0, 35, 0, 36, 44, 0, 38, 39, 0, 0, + 45, 46, 282, 283, 0, 284, 1043, 0, 1044, 0, + 0, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 0, + 0, 1528, 1053, 0, 0, 0, 1054, 1055, 0, 33, + 0, 285, -416, 0, 0, 0, 0, 1056, 0, 0, + 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 294, 0, 379, 0, 0, 171, + 0, 0, 45, 46, 296, 297, 298, 299, 0, 0, + 282, 283, 1058, 284, 1043, 0, 1044, -131, 0, 1045, + 1046, 1047, 1048, 1049, 1050, 1051, 1052, 0, 0, 0, + 1053, 0, 0, 0, 1054, 1055, 0, 33, 0, 285, + 0, 0, 0, 0, 0, 1056, 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, 0, 379, 0, 0, 171, 0, 0, - 45, 46, 296, 297, 298, 299, 0, 0, 282, 283, - 1057, 284, 1042, 0, 1043, -128, 0, 1044, 1045, 1046, - 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 1052, 0, - 0, 0, 1053, 1054, 0, 33, 0, 285, 0, 0, - 0, 0, 0, 1055, 0, 0, 0, 287, 0, 0, - 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, + 45, 46, 296, 297, 298, 299, 0, 0, 0, 0, + 1058, 0, 0, 0, 0, -131, 2, 206, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 27, 28, 0, 0, 0, 0, 0, + 0, 31, 0, 282, 283, 0, 284, 1043, 0, 1044, + 1402, 1403, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, + 0, 0, 1528, 1053, 0, 0, 0, 1054, 1055, 34, + 33, 35, 285, 36, 0, 0, 38, 39, 1056, 0, + 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, + 42, 0, 292, 293, 0, 0, 0, 0, 1315, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 294, 0, 379, 0, 0, 171, 0, 0, 45, 46, - 296, 297, 298, 299, 0, 0, 0, 0, 1057, 0, - 0, 0, 0, -128, 2, 206, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, - 26, 27, 28, 0, 0, 0, 0, 0, 0, 31, - 0, 282, 283, 0, 284, 1042, 0, 1043, 1399, 1400, - 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 0, 0, - 1525, 1052, 0, 0, 0, 1053, 1054, 34, 33, 35, - 285, 36, 0, 0, 38, 39, 1055, 0, 0, 0, + 0, 0, 0, 0, 0, 294, 0, 379, 0, 0, + 171, 0, 0, 45, 46, 296, 297, 298, 299, 0, + 0, 282, 283, 1058, 284, 1043, 0, 1044, 1402, 1403, + 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 0, 0, + 0, 1053, 0, 0, 0, 1054, 1055, 0, 33, 0, + 285, 0, 0, 0, 0, 0, 1056, 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, - 292, 293, 0, 0, 0, 0, 1312, 0, 0, 0, + 292, 293, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, 0, 379, 0, 0, 171, 0, 0, 45, 46, 296, 297, 298, 299, 0, 0, 282, - 283, 1057, 284, 1042, 0, 1043, 1399, 1400, 1044, 1045, - 1046, 1047, 1048, 1049, 1050, 1051, 0, 0, 0, 1052, - 0, 0, 0, 1053, 1054, 0, 33, 0, 285, 0, - 0, 0, 0, 0, 1055, 0, 0, 0, 287, 0, + 283, 1058, 284, 1043, 0, 1044, 0, 0, 1045, 1046, + 1047, 1048, 1049, 1050, 1051, 1052, 0, 0, 0, 1053, + 0, 0, 0, 1054, 1055, 0, 33, 0, 285, 0, + 0, 0, 0, 0, 1056, 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, + 0, 0, 0, 0, 0, 0, 282, 283, 0, 284, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 294, 0, 379, 0, 0, 171, 0, 0, 45, + 46, 296, 297, 298, 299, 285, 0, 0, 0, 1058, + 0, 286, 0, 0, 0, 287, 0, 0, 288, 289, + 290, 291, 41, 42, 0, 292, 293, 0, 0, 0, + 0, 0, 0, 282, 283, 0, 284, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 294, 0, + 379, 0, 282, 283, 0, 284, 45, 46, 296, 297, + 298, 299, 285, 0, 0, 0, 0, 0, 286, 0, + 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, + 42, 285, 292, 293, 0, 0, 0, 286, 0, 0, + 0, 287, 0, 0, 288, 289, 290, 291, 41, 42, + 0, 292, 293, 0, 0, 294, 0, 379, 0, 282, + 283, 0, 284, 709, 46, 296, 297, 298, 299, 0, + 0, 0, 0, 0, 294, 0, 379, 0, 282, 283, + 0, 284, 344, 46, 296, 297, 298, 299, 285, 0, + 0, 0, 0, 0, 286, 0, 0, 0, 287, 0, + 0, 288, 289, 290, 291, 41, 42, 285, 292, 293, + 0, 0, 0, 286, 0, 0, 0, 287, 0, 0, + 288, 289, 290, 291, 41, 42, 0, 292, 293, 0, + 0, 506, 0, 0, 0, 282, 283, 0, 284, 45, + 46, 296, 297, 298, 299, 0, 0, 0, 0, 0, + 294, 0, 0, 0, 282, 283, 0, 284, 45, 46, + 296, 297, 298, 299, 285, 0, 0, 0, 0, 0, + 286, 0, 0, 0, 287, 0, 0, 288, 289, 290, + 291, 41, 42, 285, 292, 293, 0, 0, 0, 286, + 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, + 41, 42, 0, 292, 293, 0, 0, 511, 0, 0, + 0, 0, 0, 0, 0, 45, 46, 296, 297, 298, + 299, 0, 0, 0, 0, 0, 514, 0, 0, 0, + 0, 0, 0, 0, 45, 46, 296, 297, 298, 299, + 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 294, 0, 379, 0, 0, 171, 0, 0, 45, - 46, 296, 297, 298, 299, 0, 0, 282, 283, 1057, - 284, 1042, 0, 1043, 0, 0, 1044, 1045, 1046, 1047, - 1048, 1049, 1050, 1051, 0, 0, 0, 1052, 0, 0, - 0, 1053, 1054, 0, 33, 0, 285, 0, 0, 0, - 0, 0, 1055, 0, 0, 0, 287, 0, 0, 288, - 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, - 0, 0, 0, 0, 282, 283, 0, 284, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 294, - 0, 379, 0, 0, 171, 0, 0, 45, 46, 296, - 297, 298, 299, 285, 0, 0, 0, 1057, 0, 286, - 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, - 41, 42, 0, 292, 293, 0, 0, 0, 0, 0, - 0, 282, 283, 0, 284, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 294, 0, 379, 0, - 0, 972, 0, 0, 45, 46, 296, 297, 298, 299, - 285, 0, 0, 0, 0, 0, 286, 0, 0, 0, - 287, 0, 0, 288, 289, 290, 291, 41, 42, 0, - 292, 293, 0, 0, 0, 0, 0, 0, 282, 283, - 0, 284, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 294, 0, 379, 0, 282, 283, 0, - 284, 45, 46, 296, 297, 298, 299, 285, 0, 0, - 0, 0, 0, 286, 0, 0, 0, 287, 0, 0, - 288, 289, 290, 291, 41, 42, 285, 292, 293, 0, - 0, 0, 286, 0, 0, 0, 287, 0, 0, 288, - 289, 290, 291, 41, 42, 0, 292, 293, 0, 0, - 294, 0, 379, 0, 282, 283, 0, 284, 709, 46, - 296, 297, 298, 299, 0, 0, 0, 0, 0, 294, - 0, 379, 0, 282, 283, 0, 284, 344, 46, 296, - 297, 298, 299, 285, 0, 0, 0, 0, 0, 286, - 0, 0, 0, 287, 0, 0, 288, 289, 290, 291, - 41, 42, 285, 292, 293, 0, 0, 0, 286, 0, - 0, 0, 287, 0, 0, 288, 289, 290, 291, 41, - 42, 0, 292, 293, 0, 0, 506, 0, 0, 0, - 282, 283, 0, 284, 45, 46, 296, 297, 298, 299, - 0, 0, 0, 0, 0, 294, 0, 0, 0, 282, - 283, 0, 284, 45, 46, 296, 297, 298, 299, 285, - 0, 0, 0, 0, 0, 286, 0, 0, 0, 287, - 0, 0, 288, 289, 290, 291, 41, 42, 285, 292, - 293, 0, 0, 0, 286, 0, 0, 0, 287, 0, - 0, 288, 289, 290, 291, 41, 42, 0, 292, 293, - 0, 0, 511, 0, 0, 0, 0, 0, 0, 0, - 45, 46, 296, 297, 298, 299, 0, 0, 0, 0, - 0, 514, 0, 0, 0, 0, 0, 0, 0, 45, - 46, 296, 297, 298, 299, 2, 206, 4, 5, 6, + 0, 0, 0, 34, 0, 35, 0, 36, 37, 0, + 174, 175, 40, 0, 0, 0, 0, 0, 0, 41, + 42, 205, 2, 206, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, + 28, 0, 0, 0, 0, 0, 0, 31, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, + 0, 0, 207, 39, 467, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 26, 27, 28, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, - 35, 0, 36, 37, 0, 174, 175, 40, 0, 0, - 0, 0, 0, 0, 41, 42, 205, 2, 206, 4, + 35, 0, 36, 0, 0, 38, 39, 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, @@ -2860,24 +2879,9 @@ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 34, 0, 35, 0, 36, 0, 0, 207, 39, 467, - 2, 206, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 0, 0, 26, 27, 28, 0, - 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 34, 0, 35, 0, 36, 0, 0, - 38, 39, 2, 206, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 0, 0, 26, 27, - 28, 0, 0, 0, 0, 0, 0, 31, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 34, 0, 35, 0, 36, - 0, 0, 207, 39 + 34, 0, 35, 0, 36, 0, 0, 207, 39 }; #define yypact_value_is_default(yystate) \ - ((yystate) == (-1323)) + ((yystate) == (-1338)) #define yytable_value_is_error(yytable_value) \ @@ -2886,677 +2890,678 @@ static const yytype_int16 yycheck[] = { - 0, 1, 186, 43, 239, 185, 204, 0, 43, 219, - 43, 116, 185, 521, 534, 185, 1, 875, 186, 0, - 1, 185, 757, 51, 647, 603, 750, 185, 0, 1, - 281, 621, 32, 750, 1041, 0, 1022, 43, 185, 32, - 345, 185, 750, 43, 168, 169, 513, 349, 875, 49, - 156, 32, 603, 32, 0, 693, 49, 349, 187, 0, - 32, 572, 57, 63, 601, 1322, 66, 32, 43, 69, - 63, 0, 1, 66, 696, 63, 69, 1399, 734, 492, - 0, 109, 266, 496, 69, 265, 32, 601, 69, 39, - 39, 32, 265, 490, 66, 265, 201, 69, 266, 601, - 39, 265, 43, 32, 604, 105, 601, 265, 49, 49, - 610, 106, 32, 113, 109, 418, 116, 117, 265, 82, - 66, 265, 63, 63, 39, 66, 66, 39, 69, 69, - 601, 984, 261, 262, 284, 438, 43, 66, 28, 601, - 69, 105, 72, 446, 132, 185, 146, 147, 1470, 601, - 185, 72, 185, 49, 147, 155, 156, 307, 308, 109, - 160, 111, 111, 1420, 39, 787, 82, 160, 72, 364, - 109, 39, 111, 368, 1021, 1022, 82, 482, 96, 185, - 688, 1034, 906, 1116, 156, 185, 186, 1120, 78, 906, - 156, 155, 0, 186, 110, 345, 488, 109, 906, 111, - 410, 201, 132, 96, 122, 111, 147, 147, 605, 209, - 185, 132, 609, 117, 1041, 64, 209, 113, 109, 160, - 160, 221, 406, 218, 32, 265, 109, 110, 221, 122, - 265, 381, 265, 630, 109, 256, 111, 634, 406, 239, - 1226, 109, 864, 111, 185, 186, 186, 825, 719, 221, - 146, 251, 987, 504, 57, 44, 45, 719, 251, 259, - 109, 426, 427, 901, 264, 265, 266, 719, 209, 209, - 251, 271, 251, 266, 825, 221, 813, 272, 185, 251, - 221, 221, 1289, 794, 279, 907, 251, 109, 696, 85, - 1276, 396, 221, 1502, 294, 49, 480, 636, 637, 813, - 109, 603, 925, 106, 1453, 251, 109, 307, 1053, 1054, - 251, 813, 480, 209, 653, 815, 621, 113, 813, 424, - 1529, 626, 251, 323, 265, 430, 115, 433, 328, 494, - 952, 251, 95, 44, 45, 328, 107, 112, 1487, 116, - 1489, 341, 813, 239, 109, 345, 111, 109, 513, 349, - 350, 813, 155, 348, 1212, 132, 934, 0, 110, 113, - 131, 813, 44, 45, 364, 987, 129, 1473, 368, 131, - 365, 371, 711, 1479, 369, 271, 116, 341, 130, 682, - 72, 11, 74, 75, 1129, 1212, 228, 328, 328, 32, - 130, 83, 84, 1499, 1050, 590, 396, 418, 1504, 114, - 550, 551, 552, 114, 350, 247, 406, 371, 349, 1395, - 1000, 307, 110, 406, 579, 218, 1038, 438, 116, 933, - 526, 109, 114, 111, 424, 446, 426, 427, 1275, 1276, - 430, 933, 114, 433, 72, 1442, 110, 632, 933, 110, - 72, 746, 1449, 251, 1502, 83, 84, 110, 256, 345, - 847, 83, 84, 116, 454, 209, 130, 119, 120, 130, - 968, 433, 1289, 802, 1522, 406, 406, 433, 110, 272, - 112, 1529, 472, 111, 116, 128, 279, 110, 131, 111, - 480, 116, 482, 116, 484, 591, 737, 480, 488, 131, - 132, 484, 70, 1500, 494, 73, 1118, 132, 76, 907, - 78, 90, 91, 484, 688, 1128, 506, 85, 508, 1009, - 1010, 511, 484, 513, 514, 982, 482, 271, 116, 484, - 688, 521, 1100, 825, 648, 525, 526, 473, 657, 942, - 426, 427, 130, 825, 1387, 1388, 125, 126, 484, 109, - 294, 111, 939, 484, 952, 348, 110, 488, 1395, 116, - 655, 116, 116, 307, 526, 484, 1178, 1179, 72, 116, - 526, 525, 365, 130, 484, 72, 369, 74, 75, 83, - 84, 571, 572, 88, 89, 132, 83, 84, 1086, 579, - 1403, 72, 3, 1091, 4, 5, 6, 7, 8, 9, - 590, 591, 83, 84, 72, 595, 116, 111, 494, 3, - 905, 601, 1, 603, 111, 83, 84, 757, 251, 804, - 418, 116, 132, 256, 809, 1442, 0, 513, 110, 591, - 111, 621, 1449, 0, 116, 591, 626, 622, 628, 432, - 438, 109, 632, 1289, 212, 635, 636, 637, 446, 111, - 111, 113, 113, 638, 112, 109, 938, 111, 116, 69, - 116, 71, 862, 653, 116, 655, 109, 652, 130, 130, - 601, 682, 603, 635, 636, 637, 132, 109, 116, 111, - 132, 591, 882, 1500, 1497, 116, 484, 623, 116, 1502, - 116, 653, 131, 579, 132, 685, 72, 708, 688, 116, - 76, 132, 116, 109, 132, 1000, 132, 83, 84, 1522, - 454, 279, 897, 72, 810, 132, 1529, 1363, 132, 944, - 1118, 711, 712, 713, 83, 84, 110, 109, 116, 719, - 720, 116, 116, 109, 908, 621, 906, 92, 93, 110, - 626, 117, 118, 906, 132, 116, 906, 132, 733, 711, - 908, 109, 906, 110, 868, 745, 746, 688, 906, 116, - 750, 751, 506, 699, 508, 109, 109, 511, 111, 906, - 514, 1383, 906, 110, 117, 118, 294, 713, 112, 116, - 1178, 1179, 116, 109, 352, 418, 354, 1399, 719, 720, - 746, 745, 1506, 109, 112, 111, 1306, 590, 116, 1506, - 1446, 109, 1448, 111, 794, 438, 109, 112, 1506, 117, - 118, 116, 802, 446, 804, 72, 806, 74, 75, 809, - 810, 110, 109, 813, 111, 1013, 83, 84, 110, 622, - 117, 118, 72, 110, 116, 825, 76, 110, 112, 116, - 802, 110, 116, 83, 84, 638, 110, 116, 810, 482, - 110, 484, 1147, 112, 810, 1501, 116, 1469, 1470, 652, - 1000, 115, 116, 252, 10, 11, 12, 13, 14, 109, - 806, 111, 110, 111, 442, 1116, 109, 117, 118, 1120, - 1121, 110, 813, 117, 682, 875, 110, 116, 3, 123, - 124, 110, 116, 39, 825, 10, 11, 12, 13, 14, - 810, 1041, 58, 59, 875, 110, 110, 897, 426, 427, - 708, 116, 1086, 875, 904, 905, 906, 1091, 908, 110, - 110, 67, 1036, 109, 39, 72, 116, 115, 1086, 76, - 920, 1226, 109, 1091, 111, 109, 83, 84, 1123, 875, - 733, 685, 64, 933, 934, 110, 115, 116, 938, 905, - 904, 116, 67, 943, 944, 72, 875, 74, 75, 76, - 0, 1, 109, 44, 45, 875, 83, 84, 943, 132, - 117, 118, 943, 110, 66, 906, 109, 908, 968, 116, - 109, 943, 111, 109, 1482, 1383, 553, 554, 506, 29, - 30, 112, 32, 511, 132, 1236, 514, 506, 109, 508, - 111, 1399, 511, 43, 911, 514, 913, 938, 114, 49, - 1000, 555, 556, 1108, 114, 114, 72, 57, 74, 75, - 76, 561, 562, 63, 943, 117, 66, 83, 84, 69, - 132, 1021, 1022, 1531, 132, 4, 5, 6, 7, 8, - 9, 109, 82, 83, 557, 558, 559, 560, 82, 682, - 568, 1041, 4, 5, 6, 7, 8, 9, 944, 1021, - 1022, 85, 86, 87, 109, 1021, 106, 1003, 160, 109, - 1041, 1469, 1470, 109, 112, 708, 116, 875, 467, 1041, - 82, 33, 1323, 118, 127, 109, 1327, 111, 94, 113, - 114, 1081, 109, 110, 111, 128, 1086, 109, 110, 111, - 69, 1091, 71, 131, 897, 1041, 111, 147, 109, 109, - 1100, 110, 110, 746, 1000, 155, 3, 69, 1108, 71, - 160, 112, 1041, 10, 11, 12, 13, 14, 112, 221, - 112, 1041, 110, 1123, 109, 110, 111, 110, 110, 528, - 110, 109, 110, 111, 533, 185, 186, 72, 109, 74, - 75, 76, 39, 112, 111, 1086, 114, 1147, 83, 84, - 1091, 201, 116, 132, 131, 733, 114, 259, 114, 209, - 109, 112, 264, 58, 59, 60, 920, 110, 218, 110, - 67, 221, 112, 1424, 109, 112, 111, 130, 228, 112, - 112, 1147, 117, 118, 583, 1249, 1250, 1251, 130, 1189, - 1190, 130, 116, 243, 29, 130, 110, 247, 110, 112, - 115, 251, 252, 114, 112, 1190, 110, 116, 1208, 1190, - 115, 109, 1212, 115, 110, 265, 266, 1189, 1190, 110, - 130, 110, 272, 116, 110, 132, 1226, 3, 110, 279, - 1230, 1212, 875, 1041, 10, 11, 12, 13, 14, 110, - 1212, 116, 110, 1189, 1208, 1230, 110, 110, 350, 1230, - 110, 110, 110, 110, 1, 654, 110, 656, 1230, 110, - 1189, 1190, 905, 39, 110, 110, 1212, 110, 72, 110, - 74, 75, 76, 115, 1379, 1275, 1276, 29, 328, 83, - 84, 1516, 131, 1212, 1284, 110, 130, 116, 875, 1289, - 112, 67, 1212, 112, 110, 110, 116, 110, 348, 349, - 130, 1230, 49, 1275, 1276, 109, 109, 706, 1289, 1275, - 116, 112, 1284, 117, 118, 365, 114, 1289, 110, 369, - 110, 110, 1322, 1507, 112, 116, 1506, 1081, 110, 431, - 380, 116, 116, 1506, 55, 110, 1506, 1322, 1284, 1507, - 110, 1322, 1506, 1289, 112, 109, 396, 1531, 1506, 109, - 1322, 109, 109, 109, 132, 1284, 406, 130, 105, 1506, - 1289, 112, 1506, 1531, 110, 115, 113, 110, 110, 1289, - 115, 473, 110, 128, 424, 115, 97, 1482, 114, 1379, - 430, 112, 432, 1378, 132, 112, 116, 112, 110, 72, - 110, 74, 75, 1322, 110, 1395, 110, 112, 1041, 146, - 83, 84, 112, 112, 1212, 1208, 112, 72, 155, 74, - 75, 76, 112, 72, 112, 74, 75, 467, 83, 84, - 1420, 47, 472, 1395, 83, 84, 109, 132, 132, 132, - 480, 114, 112, 132, 484, 1420, 132, 115, 488, 1420, - 110, 491, 1442, 493, 109, 130, 115, 110, 1420, 1449, - 109, 1451, 112, 1453, 115, 114, 112, 1044, 205, 112, - 112, 1442, 209, 112, 110, 110, 1506, 109, 1449, 112, - 1442, 1506, 193, 1506, 112, 109, 109, 1449, 528, 60, - 110, 1289, 1482, 533, 132, 110, 114, 1487, 109, 1489, - 112, 1420, 239, 595, 112, 216, 1442, 110, 112, 110, - 1500, 96, 96, 1449, 1147, 226, 1506, 1507, 109, 109, - 464, 115, 132, 1442, 1507, 130, 1516, 110, 110, 1500, - 1449, 623, 1442, 110, 271, 110, 628, 274, 1500, 1449, - 116, 1531, 42, 583, 132, 132, 110, 110, 1531, 66, - 590, 96, 96, 132, 110, 110, 110, 294, 75, 132, - 132, 601, 110, 603, 1500, 115, 112, 132, 115, 958, - 307, 112, 109, 132, 110, 1506, 30, 115, 110, 1212, - 132, 1500, 622, 294, 110, 1378, 110, 667, 1057, 563, - 1500, 980, 978, 1226, 565, 984, 1212, 1365, 638, 564, - 117, 464, 566, 643, 341, 567, 1470, 699, 345, 1541, - 1299, 1327, 652, 1121, 654, 655, 656, 1072, 1449, 685, - 685, 713, 913, 698, 66, 1091, 921, 364, 82, 83, - 1516, 368, 583, 972, 371, 1212, 868, 723, 649, 940, - 82, 1230, 484, 160, 1442, 1034, 0, 1, 688, 733, - 571, 1449, 692, 571, 694, 571, 1289, 72, 698, 74, - 75, 76, -1, -1, -1, -1, 706, -1, 83, 84, - -1, -1, -1, 1191, 1192, 117, 1194, -1, 32, 719, - 720, -1, -1, 1201, -1, 1203, -1, -1, -1, 426, - 427, -1, -1, 733, 109, 49, -1, 10, 11, 12, - 13, 14, 1500, -1, 221, -1, -1, 1451, -1, 1453, - -1, -1, -1, -1, 806, 69, -1, 454, 160, -1, - 85, 86, 87, -1, -1, -1, 39, 671, 1305, -1, - 467, -1, 443, -1, -1, -1, -1, 10, 11, 12, - 13, 14, 259, 1487, 109, 1489, 111, 264, 113, 114, - -1, 105, -1, -1, 67, 492, -1, 494, 469, 496, - -1, -1, 279, -1, -1, -1, 39, -1, -1, 506, - -1, 508, -1, 813, 511, -1, 513, 514, -1, 221, - 1357, -1, -1, 1360, -1, 825, -1, -1, 525, 243, - -1, -1, -1, 147, 67, 506, 109, -1, 111, -1, - 511, 155, 156, 514, 117, 118, -1, -1, 671, 1442, - -1, -1, -1, -1, -1, -1, 1449, 259, -1, -1, - -1, -1, 264, -1, -1, -1, 1403, -1, 868, -1, - -1, 1408, 186, 350, 874, -1, 109, -1, 111, -1, - -1, 1359, 579, -1, 117, 118, 790, 201, -1, -1, - 204, 205, -1, 590, -1, 209, 800, 897, -1, 1436, - 1249, 1250, 1251, -1, -1, -1, 906, 1500, 908, -1, - 814, -1, -1, -1, -1, 915, 230, -1, -1, -1, - 234, -1, 236, -1, 621, -1, -1, -1, -1, 626, - -1, 245, -1, -1, -1, 632, 0, 251, 938, -1, - -1, -1, 256, -1, -1, -1, -1, -1, 350, -1, - -1, 1003, 266, -1, 431, -1, -1, -1, 958, -1, - 274, 10, 11, 12, 13, 14, 380, 790, 32, -1, - -1, 448, 972, -1, -1, -1, -1, 800, -1, -1, - 980, -1, -1, 1520, 984, -1, -1, -1, 685, 1526, - 39, 814, -1, -1, -1, -1, 473, -1, -1, 670, - 1537, -1, 671, -1, 1541, 69, -1, -1, 679, -1, - -1, -1, 683, -1, -1, -1, -1, -1, 67, -1, - -1, 72, -1, 74, 75, 76, 723, 341, -1, 431, - -1, 345, 83, 84, 1034, -1, -1, 351, 1387, 1388, - -1, -1, -1, -1, -1, -1, -1, -1, 745, -1, - 364, -1, -1, -1, 368, -1, -1, 371, 109, -1, - 109, -1, 111, -1, -1, -1, 117, 118, 117, 118, - -1, 473, 1072, -1, -1, -1, 1425, 491, -1, 493, - -1, -1, -1, -1, -1, -1, 1086, -1, -1, -1, - -1, 1091, 156, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 418, -1, -1, 804, 1108, -1, - -1, -1, 809, -1, 1018, 1019, -1, -1, 595, 433, - -1, 790, -1, -1, 438, -1, -1, 131, -1, -1, - -1, 800, 446, -1, 1483, -1, -1, 1189, -1, -1, - -1, -1, -1, 1492, -1, 814, 623, -1, -1, -1, - 464, 628, 72, 467, 74, 75, 76, -1, -1, -1, - -1, -1, -1, 83, 84, -1, 230, -1, 482, -1, - 484, -1, 1076, 1077, -1, -1, -1, -1, 492, -1, - -1, -1, 496, -1, -1, 1185, -1, 251, -1, 109, - -1, 111, 256, 595, -1, 1018, 1019, 117, 118, -1, - 897, -1, -1, -1, -1, -1, -1, 904, 1208, -1, - -1, 525, 526, -1, -1, -1, -1, -1, -1, -1, - -1, 623, 699, 920, -1, -1, 628, -1, 899, 643, - -1, -1, 1284, 0, -1, -1, 713, -1, -1, -1, - -1, -1, -1, -1, -1, 942, 943, 944, -1, 1249, - 1250, 1251, -1, 1076, 1077, -1, 733, -1, 572, 72, - -1, 74, 75, 76, -1, 32, -1, -1, -1, -1, - 83, 84, -1, -1, -1, -1, 590, 591, 692, -1, - 694, -1, -1, -1, 698, -1, -1, 351, 72, 603, - 74, 75, 76, -1, -1, -1, 109, 699, 111, 83, - 84, -1, 69, 1000, 117, 118, -1, 621, -1, -1, - -1, 713, 626, -1, -1, -1, -1, -1, 632, -1, - 1224, 635, 636, 637, -1, 109, -1, 111, -1, 806, - -1, -1, -1, 117, 118, -1, -1, -1, -1, 653, - -1, -1, -1, 26, 27, 28, -1, -1, -1, 1018, - 1019, -1, 1256, -1, 418, -1, -1, 671, -1, -1, - 1264, 1265, 1266, -1, -1, -1, -1, -1, 682, 433, - -1, -1, -1, -1, 438, -1, -1, -1, 1378, 1379, - -1, 1052, 446, -1, 1081, -1, -1, 1387, 1388, 156, - -1, -1, -1, -1, 708, -1, -1, 711, -1, -1, - 464, 1224, -1, -1, 806, -1, 720, 1076, 1077, 723, - -1, -1, -1, -1, -1, 98, -1, 100, 482, -1, - 484, -1, -1, -1, 1328, 1425, 1123, -1, -1, -1, - -1, 745, 746, 1256, -1, -1, -1, 751, -1, -1, - -1, 1264, 1265, 1266, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 868, -1, -1, -1, -1, -1, - 874, -1, 526, -1, -1, -1, -1, 26, 27, 28, - -1, -1, -1, -1, -1, -1, 790, -1, -1, -1, - -1, -1, 1482, 1483, 251, -1, 800, -1, 802, 256, - 804, -1, 1492, 807, -1, 809, 810, -1, 181, -1, - 814, 915, -1, -1, -1, 1328, 1506, 1507, 191, 192, - 824, 1208, -1, 196, -1, 198, 199, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1003, 591, -1, -1, - -1, 1531, -1, 1230, -1, -1, -1, -1, -1, 98, - -1, 100, -1, -1, -1, 0, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 972, -1, - -1, 875, -1, -1, -1, -1, 125, -1, -1, -1, - -1, 635, 636, 637, -1, -1, -1, 32, -1, -1, - -1, -1, -1, 897, 351, -1, -1, 1256, -1, 653, - 904, 905, -1, -1, 908, 1264, 1265, 1266, -1, -1, - -1, 1003, -1, -1, -1, -1, -1, 671, -1, -1, - -1, -1, -1, -1, 69, -1, -1, -1, 682, -1, - 934, -1, 181, -1, -1, 1322, -1, 1298, 942, 943, - 189, -1, 191, 192, -1, -1, -1, 196, -1, 198, - 199, -1, -1, -1, 708, -1, -1, 711, -1, -1, - -1, 418, -1, -1, -1, -1, -1, -1, 1072, 1328, - -1, -1, -1, -1, -1, -1, 433, -1, -1, -1, - -1, 438, -1, -1, -1, -1, -1, -1, -1, 446, - -1, -1, 746, -1, -1, -1, 1000, 10, 11, 12, - 13, 14, -1, -1, -1, -1, -1, 464, -1, 1013, - -1, 156, -1, -1, 1018, 1019, -1, 1021, 1022, 268, - -1, -1, 1189, -1, -1, 482, 39, 484, -1, -1, - -1, -1, -1, 1420, -1, -1, 790, 1041, -1, -1, - -1, -1, -1, -1, -1, -1, 800, -1, 802, -1, - -1, -1, -1, 807, 67, -1, 810, -1, -1, 72, - 814, 74, 75, 76, 1451, -1, 1453, -1, -1, 526, - 83, 84, 1076, 1077, -1, -1, -1, -1, -1, -1, - -1, 1185, -1, -1, -1, -1, -1, -1, -1, 1450, - -1, 1452, -1, -1, -1, -1, 109, 1189, 111, -1, - 1487, -1, 1489, -1, 117, 118, 251, -1, -1, -1, - -1, 256, -1, -1, -1, -1, -1, 1284, -1, 1123, - -1, 875, -1, -1, -1, 1486, -1, 1488, -1, 1516, - -1, -1, -1, -1, 591, -1, -1, -1, -1, -1, - -1, -1, -1, 1147, -1, -1, -1, -1, -1, 0, - -1, 905, -1, -1, -1, -1, -1, 189, -1, -1, - -1, -1, -1, -1, 196, -1, -1, -1, -1, 1530, - -1, 1532, -1, -1, -1, -1, -1, -1, 635, 636, - 637, 32, -1, -1, 1545, 1546, 1190, -1, -1, -1, - -1, -1, 1284, -1, -1, -1, 653, -1, -1, -1, - -1, -1, 575, 576, 1208, -1, 351, -1, 1212, -1, - -1, -1, -1, -1, 671, -1, -1, -1, 69, -1, - 1224, -1, 1226, -1, -1, 682, 1230, -1, -1, -1, - -1, 604, -1, -1, 607, 608, 268, 610, -1, 612, - 613, -1, -1, -1, 617, 618, -1, -1, -1, -1, - -1, 708, 1256, -1, 711, -1, -1, -1, -1, -1, - 1264, 1265, 1266, -1, 1018, 1019, -1, 1021, 1022, -1, - -1, 1275, 1276, 418, -1, -1, -1, -1, 10, 11, - 12, 13, 14, -1, -1, 1289, -1, 1041, 433, 746, - -1, 323, -1, 438, -1, -1, -1, -1, -1, 331, - -1, 446, 334, -1, -1, 156, -1, 39, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 1322, 464, - -1, -1, 1076, 1077, 1328, -1, 575, 576, -1, -1, - -1, -1, -1, 790, -1, 67, -1, 482, -1, 484, - 72, -1, -1, 800, 76, 802, -1, -1, -1, -1, - 807, 83, 84, 810, -1, 604, -1, 814, 607, 608, - -1, 610, -1, 612, 613, -1, 398, -1, 617, 618, - 402, -1, -1, -1, -1, -1, -1, 109, -1, -1, - -1, 526, 755, 756, -1, 117, 118, -1, -1, -1, - -1, 1395, -1, 1147, -1, -1, -1, -1, -1, -1, - 251, -1, -1, -1, -1, 256, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1420, -1, 875, -1, + 0, 1, 239, 43, 185, 116, 534, 0, 204, 185, + 43, 185, 185, 281, 185, 43, 521, 1, 601, 185, + 185, 603, 168, 169, 105, 750, 0, 1, 219, 621, + 349, 876, 32, 345, 49, 750, 0, 693, 603, 32, + 156, 750, 513, 43, 1023, 757, 647, 572, 186, 49, + 1325, 985, 186, 492, 189, 0, 49, 496, 32, 1022, + 1023, 196, 156, 63, 32, 1402, 66, 601, 32, 69, + 63, 0, 28, 66, 155, 187, 69, 109, 601, 39, + 85, 43, 601, 0, 265, 69, 57, 32, 349, 265, + 201, 265, 265, 43, 265, 69, 39, 601, 113, 265, + 265, 1035, 63, 32, 51, 105, 364, 256, 113, 418, + 368, 601, 1042, 113, 39, 32, 116, 117, 72, 696, + 43, 109, 78, 111, 604, 601, 109, 876, 266, 438, + 610, 146, 266, 268, 490, 106, 1473, 446, 109, 96, + 39, 734, 72, 426, 427, 185, 146, 147, 1423, 261, + 262, 111, 185, 1456, 147, 155, 156, 185, 1054, 1055, + 160, 95, 109, 109, 110, 122, 109, 160, 111, 64, + 482, 132, 0, 1, 0, 72, 82, 96, 132, 72, + 636, 637, 907, 688, 284, 185, 186, 1490, 323, 1492, + 83, 84, 907, 186, 209, 129, 331, 653, 907, 334, + 82, 201, 132, 122, 32, 111, 32, 307, 308, 209, + 109, 494, 111, 1117, 109, 719, 209, 1121, 111, 410, + 117, 221, 876, 185, 239, 265, 294, 488, 221, 719, + 513, 814, 265, 39, 1130, 185, 504, 265, 66, 239, + 66, 69, 11, 719, 826, 345, 902, 218, 39, 605, + 1229, 251, 1505, 609, 128, 711, 271, 131, 251, 259, + 341, 826, 185, 398, 264, 265, 266, 402, 406, 418, + 795, 271, 406, 266, 630, 109, 988, 251, 634, 1532, + 814, 381, 39, 251, 603, 396, 116, 251, 1406, 438, + 371, 814, 307, 1042, 294, 814, 579, 446, 44, 45, + 1279, 272, 107, 109, 112, 111, 251, 307, 279, 621, + 814, 256, 82, 424, 626, 1278, 1279, 433, 109, 430, + 111, 109, 251, 323, 814, 926, 131, 256, 328, 112, + 345, 908, 590, 116, 251, 328, 816, 228, 814, 433, + 110, 341, 480, 131, 479, 345, 480, 803, 114, 349, + 350, 934, 109, 935, 111, 3, 247, 70, 426, 427, + 73, 110, 1292, 76, 364, 78, 116, 3, 368, 115, + 1215, 371, 85, 682, 632, 49, 953, 348, 44, 45, + 130, 130, 1500, 44, 45, 90, 91, 1505, 482, 116, + 72, 1045, 72, 221, 365, 221, 396, 79, 369, 79, + 934, 83, 84, 83, 84, 72, 406, 1525, 110, 1001, + 526, 426, 427, 406, 1532, 934, 83, 84, 112, 1398, + 125, 126, 116, 251, 424, 251, 426, 427, 130, 111, + 430, 111, 526, 433, 746, 1398, 571, 572, 506, 113, + 1505, 110, 109, 511, 525, 116, 514, 109, 114, 111, + 550, 551, 552, 114, 454, 0, 1390, 1391, 1051, 130, + 1525, 130, 464, 109, 969, 116, 1215, 1532, 1252, 737, + 1254, 1255, 472, 418, 72, 591, 74, 75, 0, 494, + 480, 132, 482, 109, 484, 83, 84, 480, 488, 418, + 110, 484, 848, 438, 494, 109, 116, 591, 513, 212, + 568, 446, 648, 109, 943, 111, 506, 826, 508, 438, + 484, 511, 983, 513, 514, 1445, 114, 446, 131, 1101, + 484, 521, 1452, 658, 350, 525, 526, 662, 1129, 72, + 1010, 1011, 111, 682, 113, 209, 79, 119, 120, 484, + 83, 84, 1119, 1292, 655, 657, 72, 805, 74, 75, + 688, 130, 810, 482, 688, 484, 112, 83, 84, 708, + 116, 1215, 116, 116, 579, 826, 279, 484, 111, 116, + 116, 571, 572, 1503, 111, 110, 113, 130, 132, 579, + 109, 116, 1087, 109, 940, 132, 132, 1092, 114, 109, + 590, 591, 116, 130, 906, 595, 1476, 271, 109, 110, + 111, 601, 1482, 603, 1181, 1182, 621, 72, 132, 74, + 75, 626, 4, 5, 6, 7, 8, 9, 83, 84, + 294, 621, 1502, 110, 117, 112, 626, 1507, 628, 116, + 123, 124, 632, 307, 109, 635, 636, 637, 72, 352, + 898, 354, 76, 116, 131, 132, 111, 473, 109, 83, + 84, 622, 746, 653, 1308, 655, 484, 757, 484, 132, + 795, 0, 1, 912, 745, 914, 116, 638, 110, 671, + 116, 116, 863, 110, 591, 109, 112, 69, 939, 71, + 116, 652, 132, 117, 118, 685, 132, 132, 688, 1001, + 29, 30, 883, 32, 109, 811, 1445, 110, 116, 1292, + 116, 110, 110, 1452, 43, 116, 1360, 116, 945, 1363, + 49, 711, 712, 713, 132, 110, 132, 811, 57, 719, + 720, 132, 116, 869, 63, 110, 907, 66, 109, 442, + 69, 907, 116, 907, 907, 112, 907, 682, 132, 116, + 132, 907, 907, 82, 83, 745, 746, 72, 132, 30, + 750, 751, 1406, 682, 1503, 110, 112, 1411, 83, 84, + 109, 116, 733, 708, 85, 86, 87, 106, 88, 89, + 109, 909, 115, 1366, 109, 909, 111, 116, 913, 708, + 454, 1309, 117, 118, 1509, 1439, 92, 93, 109, 791, + 111, 132, 113, 114, 1509, 795, 109, 623, 110, 801, + 1509, 82, 83, 803, 116, 805, 64, 807, 147, 1386, + 810, 811, 906, 815, 814, 109, 155, 746, 1014, 112, + 109, 160, 111, 132, 905, 1402, 826, 114, 117, 118, + 115, 116, 506, 72, 508, 74, 75, 511, 1150, 114, + 514, 109, 110, 111, 83, 84, 185, 186, 72, 1117, + 74, 75, 76, 1121, 1122, 990, 1449, 114, 1451, 83, + 84, 110, 201, 506, 109, 508, 1124, 116, 511, 1523, + 209, 514, 1007, 699, 110, 1529, 876, 110, 111, 218, + 116, 72, 221, 74, 75, 109, 1540, 713, 132, 228, + 1544, 1037, 83, 84, 811, 1472, 1473, 109, 898, 111, + 132, 1001, 876, 72, 243, 905, 906, 907, 247, 909, + 79, 1504, 251, 252, 83, 84, 110, 1229, 109, 58, + 59, 921, 116, 114, 44, 45, 265, 266, 1022, 82, + 945, 876, 110, 272, 934, 935, 112, 110, 116, 939, + 279, 109, 1042, 116, 944, 945, 110, 876, 109, 1087, + 1085, 110, 116, 1087, 1092, 115, 116, 116, 1092, 876, + 944, 72, 243, 74, 75, 76, 109, 1, 111, 969, + 944, 1239, 83, 84, 117, 118, 110, 906, 110, 127, + 1485, 807, 116, 82, 116, 3, 1001, 553, 554, 328, + 1125, 110, 10, 11, 12, 13, 14, 116, 1109, 561, + 562, 1001, 10, 11, 12, 13, 14, 110, 110, 348, + 349, 685, 118, 116, 116, 49, 128, 1019, 1020, 110, + 733, 39, 1022, 1023, 94, 116, 365, 555, 556, 1534, + 369, 39, 10, 11, 12, 13, 14, 110, 109, 110, + 111, 380, 1042, 116, 3, 109, 110, 111, 876, 67, + 876, 10, 11, 12, 13, 14, 1150, 396, 1326, 67, + 111, 39, 1330, 557, 558, 559, 560, 406, 1042, 131, + 109, 105, 58, 59, 60, 1077, 1078, 109, 109, 113, + 39, 109, 1082, 111, 109, 424, 111, 1087, 109, 67, + 111, 430, 1092, 432, 72, 112, 112, 1042, 76, 380, + 109, 1101, 111, 110, 110, 83, 84, 112, 67, 1109, + 110, 72, 146, 1042, 110, 76, 944, 110, 110, 0, + 1, 155, 83, 84, 1124, 1042, 1194, 1195, 467, 1197, + 1211, 109, 109, 472, 111, 111, 1204, 0, 1206, 117, + 118, 480, 112, 114, 116, 484, 131, 114, 109, 488, + 1150, 32, 491, 110, 493, 109, 117, 118, 114, 1427, + 112, 4, 5, 6, 7, 8, 9, 110, 112, 32, + 72, 205, 74, 75, 76, 209, 112, 112, 1004, 112, + 43, 83, 84, 130, 1278, 66, 49, 116, 69, 528, + 33, 130, 1192, 1193, 533, 29, 130, 110, 110, 1, + 63, 112, 110, 66, 114, 239, 69, 109, 112, 1193, + 491, 1211, 493, 116, 1042, 1215, 1042, 115, 115, 1193, + 72, 1150, 74, 75, 76, 1227, 69, 115, 71, 1229, + 109, 83, 84, 1233, 110, 130, 132, 271, 110, 116, + 274, 1215, 110, 110, 583, 3, 110, 921, 110, 1233, + 116, 590, 10, 11, 12, 13, 14, 1259, 115, 1233, + 294, 110, 601, 110, 603, 1267, 1268, 1269, 110, 110, + 1215, 1382, 110, 307, 110, 156, 29, 110, 1278, 1279, + 110, 39, 1519, 622, 147, 110, 1215, 1287, 110, 110, + 110, 110, 1292, 130, 1362, 110, 131, 160, 1215, 638, + 1229, 112, 116, 112, 643, 110, 110, 341, 116, 67, + 110, 345, 130, 652, 109, 654, 655, 656, 1292, 116, + 114, 112, 185, 186, 110, 1325, 110, 110, 1509, 1331, + 364, 116, 112, 1509, 368, 1509, 1509, 371, 1509, 110, + 221, 1325, 116, 1509, 1509, 110, 209, 1292, 116, 688, + 110, 1325, 109, 692, 109, 694, 112, 109, 221, 698, + 109, 109, 643, 1292, 1192, 1193, 1192, 706, 130, 112, + 251, 132, 1510, 115, 1485, 1292, 1510, 464, 110, 110, + 719, 720, 1382, 110, 128, 115, 115, 1215, 251, 1215, + 114, 112, 426, 427, 733, 72, 1534, 132, 1398, 76, + 1534, 49, 265, 110, 112, 1233, 83, 84, 1082, 112, + 1381, 692, 116, 694, 110, 63, 110, 698, 66, 110, + 454, 69, 112, 1423, 112, 112, 110, 112, 47, 112, + 112, 132, 109, 467, 111, 132, 115, 132, 110, 1423, + 117, 118, 115, 132, 110, 1445, 132, 115, 112, 1423, + 252, 112, 1452, 112, 1454, 130, 1456, 112, 492, 1287, + 494, 1287, 496, 112, 1292, 328, 1292, 112, 110, 1509, + 110, 1445, 506, 112, 508, 814, 1509, 511, 1452, 513, + 514, 1509, 112, 109, 109, 1485, 349, 826, 109, 60, + 1490, 525, 1492, 110, 110, 109, 114, 1325, 132, 147, + 1445, 112, 112, 1503, 1519, 110, 112, 1452, 110, 1509, + 1510, 96, 160, 96, 109, 109, 1445, 1510, 115, 1519, + 57, 110, 110, 1452, 55, 132, 110, 42, 1445, 1503, + 869, 110, 0, 1, 1534, 1452, 875, 130, 186, 116, + 671, 1534, 132, 406, 110, 579, 4, 5, 6, 7, + 8, 9, 433, 110, 132, 96, 590, 96, 1503, 898, + 132, 209, 110, 132, 32, 110, 97, 132, 907, 106, + 909, 115, 109, 221, 1503, 110, 110, 916, 85, 86, + 87, 49, 112, 112, 671, 132, 1503, 621, 869, 109, + 132, 115, 626, 115, 875, 1423, 110, 110, 632, 132, + 939, 69, 109, 484, 111, 110, 113, 114, 110, 667, + 1058, 69, 563, 71, 564, 979, 565, 1445, 155, 1445, + 959, 484, 567, 1215, 1452, 488, 1452, 72, 566, 74, + 75, 76, 1473, 1368, 973, 916, 1544, 105, 83, 84, + 1122, 1330, 981, 1302, 1073, 526, 985, 685, 1452, 685, + 914, 685, 1092, 698, 973, 66, 922, 583, 869, 649, + 791, 941, 193, 723, 109, 467, 111, 484, 1233, -1, + 801, 82, 117, 118, 733, 1503, -1, 1503, 571, 147, + 328, 218, 571, -1, 815, 216, 571, 155, 156, 723, + -1, -1, 973, -1, -1, 226, 1035, -1, -1, -1, + -1, -1, -1, -1, 791, -1, 117, -1, -1, -1, + 591, 745, -1, -1, 801, -1, -1, -1, 186, -1, + -1, -1, -1, -1, -1, -1, 528, -1, 815, -1, + -1, 533, -1, 201, 1073, 272, 204, 205, 601, -1, + 603, 209, 279, -1, -1, -1, -1, -1, 1087, 160, + -1, -1, -1, 1092, 635, 636, 637, -1, 406, -1, + -1, -1, 230, 294, -1, -1, 234, -1, 236, -1, + 1109, 805, 653, -1, -1, -1, 810, 245, -1, -1, + 1454, 583, 1456, 251, -1, -1, -1, -1, 256, -1, + 696, -1, 1073, -1, -1, -1, -1, -1, 266, -1, + -1, 72, -1, 74, 75, 76, 274, -1, -1, -1, + 221, 348, 83, 84, -1, -1, 1490, -1, 1492, -1, + -1, -1, -1, -1, -1, 688, -1, -1, 365, -1, + 711, -1, 369, -1, -1, -1, 0, -1, 109, -1, + 111, 10, 11, 12, 13, 14, 117, 118, 259, 1188, + -1, -1, 654, 264, 656, -1, 719, 720, -1, 130, + -1, -1, -1, -1, 898, -1, -1, -1, 32, -1, + 39, 905, 1211, 341, -1, -1, -1, 345, -1, -1, + -1, -1, 788, 351, -1, -1, -1, 921, 1019, 1020, + -1, -1, -1, -1, -1, 432, 364, -1, 67, -1, + 368, -1, -1, 371, 706, 69, -1, 1188, -1, 943, + 944, 945, 443, 1252, -1, 1254, 1255, -1, -1, -1, + -1, -1, 803, -1, 10, 11, 12, 13, 14, -1, + 811, -1, 1019, 1020, -1, -1, -1, -1, 469, 350, + 109, -1, 111, -1, -1, -1, 1077, 1078, 117, 118, + 418, 814, -1, 39, -1, -1, -1, -1, -1, 865, + -1, -1, -1, 826, -1, 433, -1, 1001, -1, -1, + 438, -1, -1, -1, -1, 506, -1, -1, 446, -1, + 511, 67, -1, 514, -1, -1, -1, -1, -1, -1, + 1077, 1078, 156, -1, -1, 876, 464, -1, -1, 467, + -1, -1, 908, -1, 10, 11, 12, 13, 14, -1, + -1, -1, -1, -1, 482, -1, 484, -1, -1, -1, + 431, -1, -1, 109, 492, 111, -1, -1, 496, -1, + -1, 117, 118, 39, -1, -1, -1, -1, -1, -1, + -1, -1, 1381, 1382, 907, -1, 909, 953, 1082, -1, + -1, 1390, 1391, 590, -1, -1, -1, 525, 526, -1, + -1, 67, 473, 944, -1, -1, 230, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 939, -1, -1, -1, + -1, -1, 988, -1, -1, 622, -1, 251, -1, 1428, + 1124, -1, 256, -1, -1, -1, -1, 0, -1, -1, + -1, 638, -1, 109, 572, 111, -1, -1, -1, -1, + -1, 117, 118, -1, 72, 652, 74, 75, 76, -1, + -1, -1, 590, 591, -1, 83, 84, -1, 1259, 32, + -1, -1, -1, 1039, -1, 603, 1267, 1268, 1269, 670, + 1227, 1022, 1023, -1, -1, -1, 1485, 1486, 679, -1, + -1, 109, 683, 621, -1, -1, 1495, 959, 626, 117, + 118, 1042, -1, -1, 632, -1, 69, 635, 636, 637, + 1509, 1510, 1259, -1, -1, -1, -1, 1211, -1, 981, + 1267, 1268, 1269, 985, 595, 653, 72, 351, 74, 75, + 76, -1, -1, -1, -1, 1534, 733, 83, 84, 1233, + 1331, -1, -1, 671, -1, -1, 10, 11, 12, 13, + 14, -1, 623, 1119, 682, -1, -1, 628, -1, -1, + -1, -1, -1, 109, 1087, 111, -1, -1, -1, 1092, + -1, 117, 118, 1035, -1, 39, -1, -1, -1, -1, + 708, -1, -1, 711, 1331, -1, -1, 66, -1, -1, + -1, -1, 720, 156, 418, 723, -1, -1, -1, -1, + -1, -1, -1, 67, -1, -1, -1, -1, 72, 433, + 74, 75, 76, -1, 438, 1181, 1182, 745, 746, 83, + 84, -1, 446, 751, -1, -1, -1, -1, 699, -1, + -1, 1325, -1, -1, -1, -1, -1, -1, 117, -1, + 464, -1, 713, -1, -1, 109, -1, 111, -1, -1, + -1, 1192, 1193, 117, 118, -1, -1, -1, 482, -1, + 484, -1, -1, 791, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 801, 1215, 803, -1, 805, -1, -1, + 808, 160, 810, 811, -1, -1, -1, 815, 251, -1, + -1, -1, 1233, 256, -1, -1, -1, 825, -1, -1, + -1, 898, 526, -1, -1, -1, -1, -1, -1, 900, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 1423, + -1, 30, 31, 32, -1, -1, 807, 1278, 1279, -1, + 39, 0, 221, -1, -1, -1, 1287, -1, 876, -1, + -1, 1292, -1, -1, 72, -1, 74, 75, 76, -1, + 1454, -1, 1456, -1, -1, 83, 84, 591, 67, -1, + 898, -1, -1, 32, -1, 74, 75, 905, 906, -1, + 259, 909, -1, -1, 1325, 264, -1, -1, 351, -1, + 1252, 109, 1254, 1255, -1, -1, 1490, -1, 1492, 117, + 118, -1, -1, -1, -1, -1, -1, 935, -1, -1, + 69, 635, 636, 637, -1, 943, 944, -1, 117, 118, + 1386, -1, -1, -1, -1, 1519, -1, -1, -1, 653, + -1, -1, -1, -1, -1, -1, 1402, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 671, -1, -1, + -1, -1, -1, -1, -1, 418, -1, 1398, 682, -1, + -1, -1, 1053, -1, -1, -1, -1, -1, -1, -1, + 433, 350, -1, 1001, -1, 438, -1, -1, -1, -1, + -1, -1, 1423, 446, 708, -1, 1014, 711, -1, -1, + -1, 1019, 1020, -1, 1022, 1023, -1, 156, -1, -1, + -1, 464, -1, -1, 1445, -1, 1472, 1473, -1, -1, + -1, 1452, -1, -1, 1042, -1, -1, -1, -1, 482, + -1, 484, 746, -1, -1, -1, -1, -1, 1390, 1391, + -1, -1, -1, 1004, -1, -1, 10, 11, 12, 13, + 14, -1, 10, 11, 12, 13, 14, -1, -1, 1077, + 1078, -1, 431, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1503, 526, -1, 39, 1428, 791, -1, -1, + -1, 39, -1, -1, -1, -1, -1, 801, -1, 803, + -1, -1, -1, -1, 808, -1, 1509, 811, -1, -1, + -1, 815, 251, 67, 473, -1, 1124, 256, 72, 67, + 74, 75, 76, -1, 72, -1, 74, 75, 76, 83, + 84, -1, -1, -1, 1211, 83, 84, -1, -1, -1, + -1, -1, 1150, -1, 1486, -1, -1, -1, 591, -1, + -1, -1, -1, 1495, -1, 109, -1, 111, -1, -1, + -1, 109, -1, 117, 118, -1, -1, -1, -1, 117, + 118, -1, 876, -1, -1, -1, -1, 72, -1, 74, + 75, 76, -1, -1, -1, 1193, -1, -1, 83, 84, + -1, -1, 635, 636, 637, -1, -1, -1, -1, -1, + -1, -1, 906, 1211, -1, -1, -1, 1215, -1, -1, + 653, -1, 351, -1, 109, -1, 111, -1, -1, 1227, + -1, 1229, 117, 118, -1, 1233, 66, -1, 671, -1, + 1301, -1, -1, -1, -1, 75, 595, -1, -1, 682, + -1, 1192, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1259, -1, -1, -1, -1, -1, -1, -1, 1267, + 1268, 1269, -1, -1, 623, 708, -1, -1, 711, 628, + 1278, 1279, -1, -1, -1, -1, -1, 117, 0, 418, + -1, -1, -1, -1, 1292, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 433, -1, -1, -1, -1, 438, + -1, -1, -1, 746, 1381, -1, -1, 446, -1, -1, + 32, -1, -1, -1, -1, 1019, 1020, 1325, 1022, 1023, + 160, -1, -1, 1331, -1, 464, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1287, -1, 1042, -1, + 699, -1, -1, 482, -1, 484, -1, 69, 791, -1, + -1, -1, -1, -1, 713, -1, -1, -1, 801, -1, + 803, -1, -1, -1, -1, 808, -1, -1, 811, -1, + -1, -1, 815, 1077, 1078, -1, -1, -1, -1, -1, + -1, 221, 1453, -1, 1455, -1, -1, 526, -1, -1, + 1398, -1, 10, 11, 12, 13, 14, -1, -1, -1, + 53, -1, 55, -1, -1, 58, 59, 60, -1, 62, + -1, -1, -1, -1, -1, 1423, -1, -1, 1489, 259, + 1491, 39, -1, 76, 264, -1, -1, -1, -1, -1, + -1, -1, -1, 876, 156, 88, 89, 1445, -1, 279, + -1, -1, -1, -1, 1452, -1, 1150, -1, 807, 67, + -1, -1, 591, -1, 72, -1, 74, 75, 76, -1, + -1, -1, 1533, 906, 1535, 83, 84, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1548, 1549, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1193, + -1, 109, -1, 111, -1, 1503, 635, 636, 637, 117, + 118, -1, 1510, -1, -1, -1, -1, -1, -1, -1, + 350, 1215, -1, -1, 653, -1, -1, -1, -1, -1, + -1, -1, -1, 1227, -1, 1229, -1, -1, -1, 251, + -1, -1, 671, -1, 256, -1, -1, -1, -1, -1, + -1, -1, -1, 682, -1, -1, -1, -1, -1, 10, + 11, 12, 13, 14, -1, 1259, -1, -1, -1, -1, + -1, -1, -1, 1267, 1268, 1269, -1, -1, -1, 708, + -1, -1, 711, -1, 1278, 1279, 1019, 1020, 39, 1022, + 1023, -1, -1, -1, -1, -1, -1, -1, 1292, -1, + -1, 431, -1, -1, -1, -1, -1, -1, -1, 1042, + -1, -1, -1, -1, -1, -1, 67, 746, 448, -1, + -1, 72, -1, 74, 75, 76, -1, -1, -1, -1, + -1, -1, 83, 84, -1, -1, -1, 1331, -1, 351, + -1, -1, -1, 473, 1077, 1078, 26, 27, 28, -1, + -1, -1, -1, -1, -1, 1004, -1, -1, 109, -1, + -1, -1, 791, -1, -1, -1, 117, 118, -1, -1, + -1, -1, 801, -1, 803, -1, -1, -1, -1, 808, + -1, -1, 811, -1, -1, -1, 815, -1, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, -1, + -1, 344, -1, 346, 1398, -1, 418, -1, -1, -1, + -1, -1, -1, -1, 357, 358, -1, 1150, 98, -1, + 100, 433, 131, -1, -1, -1, 438, -1, -1, -1, + -1, -1, -1, -1, 446, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 876, -1, -1, + -1, 1445, 464, -1, -1, -1, -1, -1, 1452, -1, + 1193, -1, -1, -1, -1, 595, -1, -1, -1, -1, + 482, -1, 484, -1, -1, -1, -1, 906, -1, -1, + -1, -1, 1215, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 623, 1227, -1, 1229, -1, 628, -1, + -1, 181, -1, -1, -1, -1, -1, -1, -1, 1503, + -1, 191, 192, -1, 526, -1, 196, -1, 198, 199, + -1, -1, -1, -1, -1, -1, 1259, -1, -1, -1, + -1, -1, -1, -1, 1267, 1268, 1269, -1, -1, -1, + -1, -1, -1, 1192, -1, 1278, 1279, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1292, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 699, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 591, + -1, -1, -1, 713, -1, -1, -1, -1, -1, -1, + 1019, 1020, -1, 1022, 1023, -1, -1, -1, 1331, -1, + -1, -1, -1, 733, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1042, 7, -1, -1, 10, 11, 12, + 13, 14, -1, 635, 636, 637, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1287, -1, + -1, 653, -1, -1, 37, 38, 39, 40, 1077, 1078, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 671, + -1, -1, -1, -1, -1, 1398, -1, -1, -1, -1, + 682, -1, -1, 66, 67, -1, -1, 807, -1, 72, + -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, + 83, 84, -1, 86, 87, -1, 708, -1, -1, 711, + -1, -1, -1, 10, 11, 12, 13, 14, -1, -1, + -1, -1, 1445, -1, -1, -1, 109, -1, 111, 1452, + -1, 1150, -1, -1, 117, 118, 119, 120, 121, 122, + -1, -1, 39, -1, 746, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 1190, -1, 1442, -1, - -1, -1, -1, -1, -1, 1449, 591, 479, 905, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 1212, -1, + -1, -1, -1, -1, -1, -1, -1, 700, -1, 702, + 67, -1, -1, -1, 1193, 72, 709, 710, -1, 76, + 1503, 714, -1, -1, -1, -1, 83, 84, -1, 791, + -1, -1, -1, 726, -1, -1, 1215, -1, 731, 801, + -1, 803, -1, -1, -1, -1, 808, -1, 1227, 811, + 1229, -1, 109, 815, -1, -1, -1, -1, -1, -1, + 117, 118, -1, -1, -1, -1, 759, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1224, -1, 1226, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 10, 11, 12, 13, 14, -1, - 635, 636, 637, -1, -1, -1, 1500, -1, -1, -1, - 351, -1, 1256, 1507, -1, -1, 755, 756, 653, -1, - 1264, 1265, 1266, 39, -1, -1, -1, -1, -1, -1, - -1, 1275, 1276, -1, -1, -1, 671, -1, -1, -1, - -1, -1, -1, -1, -1, 1289, -1, 682, -1, 571, - 572, 67, -1, -1, 917, -1, 72, -1, 74, 75, + 1259, -1, -1, -1, -1, -1, -1, -1, 1267, 1268, + 1269, -1, -1, -1, -1, -1, -1, -1, -1, 1278, + 1279, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1292, 876, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1004, -1, -1, -1, -1, -1, + -1, -1, 7, -1, -1, 10, 11, 12, 13, 14, + -1, -1, -1, -1, 906, 575, 576, -1, -1, -1, + -1, -1, 1331, -1, -1, -1, -1, -1, 49, -1, + -1, -1, 37, 38, 39, 40, 859, 860, 861, 862, + -1, 864, -1, -1, 604, 66, -1, 607, 608, -1, + 610, -1, 612, 613, -1, -1, 879, 617, 618, -1, + -1, 66, 67, -1, -1, -1, -1, 72, -1, -1, + 893, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, -1, 1398, + -1, -1, 113, -1, -1, -1, 117, -1, -1, -1, + -1, -1, -1, -1, 109, -1, 111, -1, -1, -1, + 933, -1, 117, 118, 119, 120, 121, 122, -1, -1, + -1, -1, -1, -1, -1, 146, -1, 1019, 1020, -1, + 1022, 1023, -1, -1, -1, 156, 1445, -1, -1, 160, + -1, -1, -1, 1452, -1, -1, -1, -1, -1, -1, + 1042, -1, -1, -1, -1, 978, -1, -1, -1, -1, + -1, 984, -1, -1, -1, -1, 989, -1, -1, -1, + -1, 994, -1, 996, -1, -1, -1, 1000, -1, 1002, + 1003, -1, 1192, 1006, -1, 1077, 1078, -1, 209, -1, + -1, -1, 1015, -1, 1503, 755, 756, -1, -1, -1, + 221, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1033, 1034, -1, -1, -1, -1, -1, -1, 239, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 1060, -1, -1, + 1063, -1, -1, 264, -1, -1, -1, -1, 39, -1, + 271, -1, -1, -1, -1, -1, -1, -1, 1150, -1, + -1, -1, 26, 27, 28, -1, -1, -1, -1, -1, + -1, -1, -1, 294, -1, -1, 67, 1287, -1, -1, + -1, -1, -1, 1106, -1, -1, 307, -1, -1, 1112, + 1113, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1193, -1, -1, -1, -1, -1, -1, -1, 1132, + -1, -1, -1, 1136, -1, -1, -1, -1, 1141, -1, + -1, -1, -1, 1215, 345, -1, -1, -1, -1, 350, + -1, 1154, -1, -1, 98, 1227, 100, 1229, -1, -1, + -1, -1, -1, -1, 1167, -1, 1169, 1170, 1171, 1172, + -1, -1, -1, -1, -1, -1, -1, -1, 918, -1, + -1, 125, 1185, -1, 1187, -1, -1, 1259, 1191, -1, + -1, -1, -1, -1, -1, 1267, 1268, 1269, -1, -1, + -1, -1, -1, -1, -1, -1, 1278, 1279, -1, -1, + 66, -1, -1, -1, -1, -1, -1, 1220, 1221, 75, + 1292, 77, -1, 79, -1, 426, 427, -1, -1, -1, + 86, -1, 433, -1, -1, -1, -1, 181, -1, -1, + -1, -1, -1, -1, -1, 189, -1, 191, 192, -1, + -1, -1, 196, 454, 198, 199, -1, -1, -1, 1331, + -1, 117, -1, 119, 120, 121, -1, 1270, 1271, -1, + -1, -1, -1, -1, -1, -1, -1, 1280, -1, -1, + -1, 482, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 494, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 160, 506, -1, 508, -1, -1, + 511, -1, 513, 514, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 268, 526, 1398, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1341, 1079, + 1343, 1344, 1345, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1355, -1, -1, -1, -1, -1, -1, -1, + -1, 1364, -1, -1, -1, 221, -1, 223, 224, 225, + -1, -1, -1, 1445, -1, -1, -1, -1, 579, -1, + 1452, -1, -1, -1, -1, -1, 1389, -1, -1, -1, + 591, -1, -1, -1, 595, -1, -1, -1, -1, -1, + -1, -1, -1, 259, -1, -1, -1, -1, 264, -1, + -1, -1, -1, -1, 44, -1, -1, -1, -1, -1, + 621, -1, -1, 279, -1, 626, -1, -1, -1, 1432, + 1433, 1503, -1, -1, 635, 636, 637, -1, -1, -1, + -1, -1, 1445, -1, -1, -1, -1, -1, -1, 1452, + -1, -1, 653, -1, -1, -1, -1, -1, -1, -1, + -1, 91, -1, -1, -1, -1, -1, -1, -1, -1, + 1210, 101, 328, -1, -1, -1, -1, -1, -1, -1, + -1, 1484, -1, -1, 685, 1488, -1, -1, -1, -1, + -1, -1, -1, -1, 350, -1, -1, -1, -1, 355, + 356, -1, -1, -1, -1, -1, -1, 363, -1, -1, + 711, -1, 713, 1516, -1, 1518, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 157, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 171, -1, 1546, 1547, 746, -1, -1, -1, -1, + 406, 1554, 1555, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 194, -1, -1, -1, 424, 37, + 38, -1, 40, 429, -1, 431, -1, -1, 208, -1, + -1, -1, -1, -1, -1, -1, -1, 217, -1, -1, + -1, -1, 448, -1, -1, 451, 452, 227, 66, -1, + -1, -1, 803, 459, 72, -1, 807, -1, 76, -1, + 811, 79, 80, 81, 82, 83, 84, 473, 86, 87, + -1, -1, 252, -1, 480, -1, -1, 257, -1, -1, + -1, 575, 576, -1, -1, -1, -1, -1, -1, -1, + 270, 109, -1, 111, -1, -1, 276, -1, 278, 117, + 118, 119, 120, 121, 122, -1, -1, -1, -1, -1, + 604, -1, 130, 607, 608, 295, 610, -1, 612, 613, + -1, -1, -1, 617, 618, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 39, 906, -1, -1, 338, -1, + -1, -1, -1, 343, -1, -1, -1, -1, -1, -1, + 921, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 67, -1, -1, -1, -1, -1, -1, 595, + -1, -1, 372, 78, 945, -1, 376, 377, -1, 379, + -1, -1, -1, -1, -1, -1, 386, 387, -1, 389, + 390, -1, 392, -1, 394, -1, -1, 623, -1, -1, + -1, -1, 628, -1, -1, -1, -1, -1, -1, -1, + -1, 411, -1, -1, 37, 38, -1, 40, -1, 419, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1001, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 755, 756, 66, 444, -1, -1, -1, -1, 72, + -1, 1022, 1023, 76, -1, -1, 79, 80, 81, 82, + 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, + 470, -1, -1, 699, -1, -1, 476, -1, -1, -1, + -1, 481, -1, -1, -1, -1, 109, 713, 111, -1, + -1, 114, -1, -1, 117, 118, 119, 120, 121, 122, + -1, -1, -1, -1, -1, -1, -1, 733, -1, -1, + -1, 1082, -1, -1, -1, -1, -1, 517, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 532, -1, 0, -1, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, -1, 30, 31, 32, 33, -1, 795, + 36, 571, -1, 39, 40, -1, -1, -1, -1, 1150, + 580, 807, -1, -1, -1, -1, -1, 587, -1, -1, + -1, -1, -1, 593, -1, -1, -1, -1, 64, 913, + 826, 67, 602, 69, 918, 71, 72, -1, 74, 75, 76, -1, -1, -1, -1, -1, -1, 83, 84, -1, - -1, 1018, 1019, 708, 1021, 1022, 711, 418, -1, -1, - -1, -1, -1, -1, 1328, -1, -1, -1, -1, -1, - -1, -1, 433, 109, 1041, 111, -1, 438, -1, -1, - -1, 117, 118, -1, -1, 446, -1, -1, -1, -1, - -1, 746, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 464, -1, -1, -1, -1, -1, 1076, - 1077, -1, -1, -1, -1, -1, 658, -1, -1, -1, - 662, 482, -1, 484, -1, -1, -1, -1, -1, -1, - -1, 1395, -1, -1, -1, 790, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 800, -1, 802, -1, -1, - -1, -1, 807, 912, -1, 810, -1, -1, 917, 814, - -1, -1, -1, -1, -1, 526, 53, -1, 55, -1, - -1, 58, 59, 60, -1, 62, -1, -1, 1442, -1, - 1147, -1, -1, -1, -1, 1449, -1, -1, -1, 76, - -1, -1, -1, -1, -1, 1078, -1, -1, -1, -1, - -1, 88, 89, -1, 10, 11, 12, 13, 14, -1, + -1, 1192, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 155, 156, -1, -1, -1, + -1, -1, 642, 109, -1, 111, -1, -1, -1, -1, + -1, 117, 118, -1, -1, -1, -1, -1, 1229, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 189, + -1, -1, -1, -1, -1, -1, 196, -1, 678, -1, + -1, -1, -1, -1, -1, -1, 686, -1, -1, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 1278, 1279, 30, + 31, 32, -1, 939, -1, -1, 1287, 717, 39, -1, + -1, -1, -1, -1, -1, -1, -1, 727, 728, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 875, -1, -1, 1190, -1, -1, -1, -1, -1, -1, - 591, -1, -1, 39, -1, -1, 1500, -1, -1, -1, - -1, -1, -1, -1, -1, 1212, -1, -1, -1, -1, - 905, -1, 794, -1, -1, -1, -1, 1224, -1, 1226, - -1, 67, -1, -1, -1, -1, 72, -1, 74, 75, - 76, -1, -1, -1, 635, 636, 637, 83, 84, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1256, - -1, -1, 653, -1, -1, -1, -1, 1264, 1265, 1266, - -1, -1, -1, 109, -1, 111, -1, -1, 1275, 1276, - 671, 117, 118, -1, -1, 282, -1, 284, 285, 1078, - -1, 682, 1289, -1, 1207, 292, 293, -1, -1, -1, + -1, -1, -1, 969, -1, -1, 67, -1, 268, -1, + -1, 72, -1, 74, 75, 76, -1, -1, -1, -1, + 760, -1, 83, 84, -1, 1079, 766, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1004, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 109, 1015, + 111, -1, -1, -1, -1, -1, 117, 118, -1, -1, + -1, -1, -1, 323, -1, -1, -1, -1, -1, -1, + -1, 331, 332, -1, 334, 335, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 345, -1, 1398, -1, 349, + 830, -1, -1, -1, -1, -1, -1, 837, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 368, -1, + 850, 371, 852, -1, -1, -1, -1, -1, -1, -1, + -1, 1087, -1, -1, -1, -1, 866, -1, -1, -1, + -1, -1, 872, -1, -1, 1101, -1, -1, 398, -1, + -1, -1, 402, 1454, 884, 1456, -1, 887, -1, -1, + -1, -1, -1, -1, -1, -1, 1210, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 307, 308, -1, -1, -1, -1, -1, 708, -1, -1, - 711, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1328, -1, 1018, 1019, -1, 1021, 1022, -1, -1, - 912, -1, -1, -1, -1, -1, -1, -1, 345, -1, - -1, -1, -1, -1, -1, 746, 1041, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, -1, 30, 31, 32, - -1, -1, -1, -1, 381, -1, 39, -1, -1, -1, - -1, 1076, 1077, -1, -1, -1, -1, -1, 1395, 790, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 800, - -1, 802, -1, -1, 67, -1, 807, 989, 1207, 810, - -1, 74, 75, 814, -1, 78, -1, 344, -1, 346, - -1, -1, -1, -1, 1006, -1, -1, -1, -1, -1, - 357, 358, -1, -1, -1, 1442, -1, -1, -1, -1, - 37, 38, 1449, 40, -1, -1, 109, -1, 111, -1, - -1, -1, 1147, -1, 117, 118, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 66, - -1, -1, -1, -1, 875, 72, -1, -1, -1, 76, - -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, - 87, -1, -1, 1500, -1, 1190, -1, -1, -1, -1, - -1, -1, 1084, -1, 905, -1, -1, -1, -1, -1, - -1, -1, 109, -1, 111, -1, -1, 1212, -1, -1, - 117, 118, 119, 120, 121, 122, -1, -1, -1, 1224, - -1, 1226, 7, 130, -1, 10, 11, 12, 13, 14, - -1, -1, 1124, 550, 551, 552, 553, 554, 555, 556, - 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, - 567, 1256, 37, 38, 39, 40, -1, -1, -1, 1264, - 1265, 1266, -1, -1, -1, -1, -1, -1, -1, -1, - 1275, 1276, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 66, 67, -1, 1289, -1, -1, 72, -1, -1, - -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, - -1, 86, 87, -1, -1, -1, -1, 1018, 1019, -1, - 1021, 1022, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 1328, 109, -1, 111, -1, -1, -1, - 1041, -1, 117, 118, 119, 120, 121, 122, -1, -1, + -1, -1, -1, 433, -1, -1, -1, -1, -1, 1490, + -1, 1492, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 282, -1, 284, 285, -1, -1, -1, -1, + -1, -1, 292, 293, -1, -1, -1, -1, 1519, -1, + -1, -1, -1, -1, -1, -1, -1, 307, 308, 479, + -1, -1, 482, -1, 964, -1, 1192, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + -1, 30, 31, 32, -1, 345, -1, -1, -1, 999, + 39, 521, -1, -1, -1, 525, 526, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, + -1, 381, -1, 72, -1, 74, 75, 76, -1, 78, + -1, -1, -1, -1, 83, 84, -1, -1, -1, -1, + -1, 571, 572, -1, -1, -1, -1, 1057, -1, -1, + -1, 1287, -1, 1063, -1, -1, 146, -1, -1, -1, + 590, 591, 111, -1, -1, -1, 156, -1, 117, 118, + -1, 601, -1, 603, 604, -1, -1, -1, 168, 169, + 610, -1, -1, -1, -1, -1, -1, 1097, -1, -1, + 620, 621, 1102, -1, -1, -1, 626, -1, -1, -1, + 1110, -1, -1, -1, -1, 635, 636, 637, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 653, -1, -1, -1, -1, 658, 659, + -1, -1, 662, 663, -1, 1145, -1, -1, -1, 669, + -1, -1, -1, -1, -1, -1, -1, 1157, -1, 239, + 1160, -1, 1162, -1, -1, -1, -1, -1, 688, -1, + -1, -1, -1, -1, -1, -1, 1176, 1177, -1, -1, + -1, -1, -1, 263, -1, -1, -1, -1, -1, -1, + -1, 711, 712, -1, -1, -1, -1, -1, 1198, -1, + 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, + 560, 561, 562, 563, 564, 565, 566, 567, -1, -1, + -1, -1, -1, -1, -1, 745, 746, -1, -1, -1, + 750, 751, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1245, -1, -1, -1, -1, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, -1, + 30, 31, 32, -1, -1, 795, -1, -1, -1, 39, + -1, -1, -1, 803, -1, -1, -1, -1, -1, -1, + 810, 811, -1, -1, 814, -1, 816, -1, -1, -1, + 380, -1, -1, -1, -1, -1, 826, 67, 1534, -1, + -1, -1, 72, -1, 74, 75, 76, -1, 78, -1, + 1320, -1, 1322, 83, 84, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1336, -1, 1338, -1, + -1, -1, -1, -1, -1, -1, 696, -1, -1, 109, + -1, 111, -1, 1353, -1, -1, -1, 117, 118, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1369, + 1370, -1, -1, -1, -1, -1, -1, -1, 898, -1, + 1380, -1, -1, 1383, -1, 905, 906, 907, -1, 909, + -1, -1, -1, 913, 474, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1404, -1, -1, 757, -1, -1, + -1, -1, -1, 1413, 934, 935, 1416, -1, 1418, 1419, + 1420, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 513, -1, -1, -1, -1, 788, -1, + -1, -1, -1, -1, -1, -1, 526, -1, -1, 969, + -1, 531, -1, -1, 534, -1, -1, -1, 1458, -1, + 1460, -1, 1462, -1, -1, -1, -1, 547, -1, -1, + 990, 991, -1, -1, -1, -1, -1, 1477, -1, -1, + -1, 1001, -1, -1, -1, -1, -1, 1007, 1008, 569, + 1010, 1011, 1012, -1, -1, -1, -1, -1, -1, 579, + -1, -1, 1022, 1023, -1, -1, 586, -1, -1, -1, + -1, 591, -1, -1, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, 33, -1, -1, 36, -1, -1, + 39, 40, -1, -1, -1, -1, -1, -1, 908, -1, + 640, -1, -1, -1, -1, 1085, -1, 1087, 648, -1, + -1, -1, 1092, -1, -1, 64, -1, -1, 67, -1, + 69, 1101, 71, 72, -1, 74, 75, 76, -1, -1, + -1, -1, -1, -1, 83, 84, -1, -1, -1, -1, + -1, -1, -1, 953, 1124, 1125, 1126, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 109, -1, 111, -1, -1, -1, 115, -1, 117, 118, + 1150, -1, -1, -1, -1, -1, -1, -1, 988, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1001, -1, -1, -1, -1, -1, -1, 37, 38, + -1, 40, -1, -1, -1, -1, 746, -1, 748, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 758, -1, + -1, -1, -1, -1, 764, -1, -1, 66, -1, -1, + -1, 1211, 1042, 72, -1, 74, 75, 76, -1, -1, + 79, 80, 81, 82, 83, 84, -1, 86, 87, 1229, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 807, 808, -1, + 109, 811, 111, -1, 113, 114, -1, -1, 117, 118, + 119, 120, 121, 122, -1, 825, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1278, 1279, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1119, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 865, -1, -1, -1, 869, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 1076, 1077, 30, 31, 32, - 33, -1, -1, 36, 37, 38, 39, 40, -1, 696, + 23, 24, 25, 26, 27, -1, 906, 30, 31, 32, + 33, 1181, 1182, 36, -1, -1, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1395, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 66, 67, -1, 69, -1, 71, 72, - -1, 74, 75, 76, 49, -1, 79, 80, 81, 82, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 64, -1, -1, 67, 945, 69, -1, 71, 72, + -1, 74, 75, 76, -1, -1, -1, -1, 1398, -1, + 83, 84, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 973, -1, -1, -1, 37, 38, 979, + 40, -1, -1, 983, -1, -1, 109, -1, 111, -1, + -1, -1, -1, -1, 117, 118, -1, -1, -1, -1, + -1, -1, -1, -1, 1004, -1, 66, -1, -1, -1, + -1, -1, 72, -1, -1, 1015, 76, -1, -1, 79, + 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1037, -1, 1039, + -1, -1, -1, 37, 38, 1485, 40, -1, -1, 109, + -1, 111, -1, -1, 1054, 1055, 116, 117, 118, 119, + 120, 121, 122, -1, -1, -1, -1, -1, -1, 1509, + 1510, -1, 66, -1, -1, 1075, -1, -1, 72, -1, + -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, + 84, -1, 86, 87, 1534, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 109, 1386, 111, -1, -1, + 114, -1, -1, 117, 118, 119, 120, 121, 122, -1, + 1130, -1, 1402, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1150, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1165, 1166, -1, -1, -1, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, 33, 1472, 1473, 36, 37, 38, 39, 40, 41, + -1, 43, -1, -1, 46, 47, 48, 49, 50, 51, + 52, 53, -1, -1, -1, 57, -1, -1, -1, 61, + 62, -1, 64, -1, 66, 67, -1, 69, -1, 71, + 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, + 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, + -1, -1, 114, -1, -1, 117, 118, 119, 120, 121, + 122, -1, -1, -1, -1, 127, -1, -1, -1, -1, + 132, -1, -1, -1, -1, -1, 1306, -1, -1, 1309, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, + 33, -1, -1, 36, 37, 38, 39, 40, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, -1, 66, 67, -1, 69, 39, 71, 72, + -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, - -1, 66, -1, -1, -1, -1, 1147, 1442, -1, -1, - 757, -1, -1, -1, 1449, -1, 109, -1, 111, -1, - -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, - -1, -1, -1, 700, -1, 702, -1, -1, -1, 132, - 787, -1, 709, 710, -1, -1, -1, 714, 113, 1190, - -1, -1, 117, -1, -1, -1, -1, -1, -1, 726, - -1, -1, -1, -1, 731, 1500, -1, -1, -1, -1, - -1, 1212, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 146, -1, 1224, -1, 1226, -1, -1, -1, -1, - -1, 156, 759, -1, -1, 160, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 7, -1, -1, 10, - 11, 12, 13, 14, -1, 1256, -1, -1, -1, -1, - -1, -1, -1, 1264, 1265, 1266, -1, -1, -1, -1, - -1, -1, -1, -1, 1275, 1276, 37, 38, 39, 40, - -1, -1, -1, -1, 209, -1, -1, -1, 1289, -1, - -1, -1, -1, -1, -1, -1, 221, -1, -1, -1, - 907, -1, -1, -1, -1, 66, 67, -1, -1, -1, - -1, 72, -1, -1, 239, 76, -1, -1, 79, 80, - 81, 82, 83, 84, -1, 86, 87, 1328, -1, -1, - -1, 858, 859, 860, 861, -1, 863, -1, -1, 264, - -1, -1, -1, -1, -1, 952, 271, -1, 109, -1, - 111, 878, -1, -1, -1, -1, 117, 118, 119, 120, - 121, 122, -1, -1, -1, 892, -1, -1, -1, 294, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 987, -1, 307, -1, -1, -1, -1, -1, -1, 66, - -1, -1, -1, 1000, 1395, -1, -1, -1, 75, -1, - 77, -1, 79, -1, -1, 932, -1, -1, -1, 86, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 345, -1, -1, -1, -1, 350, -1, -1, -1, -1, - -1, -1, -1, -1, 1041, -1, -1, -1, -1, -1, - 117, 1442, 119, 120, 121, -1, -1, -1, 1449, -1, - 977, -1, -1, -1, -1, -1, 983, -1, -1, -1, - -1, 988, -1, -1, -1, -1, 993, -1, 995, -1, - -1, -1, 999, -1, 1001, 1002, -1, -1, 1005, -1, - -1, -1, -1, 160, -1, -1, -1, 1014, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1500, - -1, 426, 427, -1, -1, 1032, 1033, -1, 433, -1, - -1, 1118, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 454, - -1, -1, 1059, -1, -1, 1062, -1, -1, -1, -1, - -1, -1, -1, -1, 221, -1, 223, 224, 225, -1, - -1, -1, -1, -1, -1, -1, -1, 482, -1, -1, - -1, 10, 11, 12, 13, 14, -1, -1, -1, 494, - -1, 1178, 1179, -1, -1, -1, -1, -1, 1105, -1, - -1, 506, 259, 508, 1111, 1112, 511, 264, 513, 514, - 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 526, 279, -1, 1131, -1, -1, 1134, -1, -1, - -1, 1138, -1, -1, -1, -1, -1, -1, 67, -1, - -1, -1, -1, 72, 1151, 74, 75, 76, -1, -1, - -1, -1, -1, -1, 83, 84, -1, 1164, -1, 1166, - 1167, 1168, 1169, -1, -1, -1, -1, -1, -1, -1, - -1, 328, -1, -1, 579, 1182, -1, 1184, -1, -1, - 109, 1188, -1, -1, -1, -1, 591, -1, 117, 118, - 595, -1, -1, 350, -1, -1, -1, -1, 355, 356, - -1, -1, -1, -1, -1, -1, 363, -1, -1, -1, - 1217, 1218, -1, -1, -1, -1, 621, -1, -1, -1, - -1, 626, -1, -1, -1, -1, -1, -1, -1, -1, - 635, 636, 637, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 653, 406, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1267, 1268, -1, -1, -1, -1, -1, 424, -1, -1, - 1277, -1, 429, -1, 431, -1, -1, -1, -1, -1, - 685, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 448, -1, -1, 451, 452, 1383, -1, -1, -1, - -1, -1, 459, -1, -1, -1, 711, -1, 713, -1, - -1, -1, 1399, -1, -1, -1, 473, -1, -1, -1, - -1, -1, -1, 480, -1, -1, -1, -1, -1, -1, - -1, 1338, -1, 1340, 1341, 1342, -1, -1, -1, -1, - -1, 746, -1, -1, -1, 1352, 44, -1, -1, -1, - -1, -1, -1, -1, 1361, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, -1, -1, 30, 31, 32, -1, 1386, - -1, -1, 1469, 1470, 39, -1, -1, 10, 11, 12, - 13, 14, -1, 91, -1, -1, -1, 802, -1, -1, - -1, 806, -1, 101, -1, 810, -1, -1, -1, -1, - -1, -1, 67, -1, -1, -1, 39, 72, -1, 74, - 75, 76, 1429, 1430, -1, -1, -1, -1, 83, 84, - -1, -1, -1, -1, -1, 1442, -1, -1, 595, -1, - -1, -1, 1449, -1, 67, -1, -1, -1, -1, 72, - -1, 74, 75, 76, 109, -1, 111, -1, -1, 157, - 83, 84, 117, 118, -1, -1, 623, -1, -1, -1, - -1, 628, -1, 171, 1481, -1, -1, -1, 1485, -1, - -1, -1, -1, -1, -1, -1, 109, -1, -1, -1, - -1, -1, -1, -1, 117, 118, 194, -1, -1, -1, - 905, -1, -1, -1, -1, -1, 1513, -1, 1515, -1, - 208, -1, -1, -1, -1, 920, -1, -1, -1, 217, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 227, - -1, -1, -1, -1, -1, -1, 1543, 1544, -1, 944, - -1, -1, 699, -1, 1551, 1552, -1, -1, -1, -1, - -1, -1, -1, -1, 252, -1, 713, -1, -1, 257, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 270, -1, -1, -1, 733, -1, 276, -1, - 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1000, -1, 295, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 1021, 1022, 30, 31, - 32, -1, -1, -1, -1, -1, -1, 39, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 794, -1, -1, - 338, -1, -1, -1, -1, 343, -1, -1, -1, 806, -1, -1, -1, -1, -1, 67, -1, -1, -1, -1, - 72, -1, 74, 75, 76, -1, -1, -1, 825, -1, - -1, 83, 84, -1, 372, -1, 1081, -1, 376, 377, - -1, 379, -1, -1, -1, -1, -1, -1, 386, 387, - -1, 389, 390, -1, 392, -1, 394, 109, -1, 111, - -1, -1, -1, -1, -1, 117, 118, -1, -1, -1, - -1, -1, -1, 411, -1, -1, -1, -1, -1, -1, - -1, 419, -1, -1, -1, -1, -1, -1, -1, 155, - 156, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1147, -1, -1, -1, 444, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, - 14, -1, -1, 189, -1, -1, -1, -1, -1, -1, - 196, -1, 470, -1, -1, -1, -1, -1, 476, -1, - -1, 938, -1, 481, 1189, 39, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, -1, 30, 31, 32, -1, - -1, 968, -1, 67, -1, 39, -1, -1, 72, 517, - -1, 1226, 76, -1, -1, -1, -1, -1, -1, 83, - 84, -1, -1, -1, 532, -1, -1, -1, -1, -1, - -1, -1, 268, 67, -1, -1, 1003, -1, 72, -1, - 74, 75, 76, -1, 78, 109, -1, 1014, -1, 83, - 84, -1, -1, 117, 118, -1, -1, -1, -1, -1, - 1275, 1276, -1, 571, -1, -1, -1, -1, -1, 1284, - -1, -1, 580, -1, -1, 109, -1, 111, 146, 587, - -1, -1, -1, 117, 118, 593, -1, 323, 156, -1, - -1, -1, -1, -1, 602, 331, 332, -1, 334, 335, - 168, 169, -1, -1, -1, -1, -1, -1, -1, 345, - -1, -1, -1, 349, -1, -1, -1, -1, -1, 1086, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 368, 1100, 642, 371, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, 398, 30, 31, 32, 402, -1, -1, -1, - 678, 239, 39, -1, -1, -1, -1, -1, 686, -1, - 1395, -1, 37, 38, -1, 40, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 263, -1, 433, -1, -1, - 67, -1, 69, -1, 71, -1, -1, 74, 75, 717, - -1, 66, -1, -1, -1, -1, -1, 72, -1, 727, - 728, 76, 1189, -1, 79, 80, 81, 82, 83, 84, - -1, 86, 87, -1, -1, -1, 1451, -1, 1453, -1, - -1, -1, -1, 479, 111, -1, 482, -1, -1, -1, - 117, 118, 760, -1, 109, -1, 111, 765, -1, 114, - -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, - -1, -1, 1487, -1, 1489, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 521, -1, -1, -1, 525, - 526, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1516, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 380, -1, -1, -1, -1, 1284, -1, -1, - -1, 829, -1, -1, -1, -1, -1, -1, 836, -1, - -1, -1, -1, -1, -1, 571, 572, -1, -1, -1, - -1, 849, -1, 851, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 590, 591, -1, 865, -1, -1, - -1, -1, -1, 871, -1, 601, -1, 603, 604, -1, - -1, -1, -1, -1, 610, 883, -1, -1, 886, -1, - -1, -1, -1, -1, 620, 621, -1, -1, -1, -1, - 626, -1, -1, -1, -1, -1, -1, -1, -1, 635, - 636, 637, -1, -1, -1, -1, 474, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 653, -1, -1, - -1, -1, 658, 659, -1, -1, 662, 663, -1, -1, - -1, -1, -1, 669, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 513, -1, -1, -1, -1, - -1, -1, 688, -1, -1, 963, -1, -1, 526, -1, - -1, -1, -1, 531, -1, -1, 534, -1, -1, -1, - -1, -1, -1, -1, -1, 711, 712, -1, -1, 547, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 998, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 569, -1, -1, -1, -1, -1, -1, -1, 745, - 746, 579, -1, -1, 750, 751, -1, -1, 586, -1, - -1, -1, -1, 591, -1, -1, -1, -1, -1, -1, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 1056, -1, - 30, 31, 32, -1, 1062, -1, -1, -1, 794, 39, - -1, -1, -1, -1, 1531, -1, 802, -1, -1, -1, - -1, -1, 640, 809, 810, -1, -1, 813, -1, 815, - 648, -1, -1, -1, -1, -1, -1, 67, 1096, 825, - -1, -1, 72, 1101, 74, 75, 76, -1, -1, -1, - -1, 1109, -1, 83, 84, -1, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, -1, -1, -1, -1, 109, - -1, 111, -1, -1, 1142, 39, -1, 117, 118, -1, - -1, -1, -1, -1, -1, -1, 1154, -1, -1, 1157, - -1, 1159, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 897, -1, 67, -1, 1173, 1174, -1, 904, 905, - 906, -1, 908, -1, 78, -1, 912, -1, 746, -1, - 748, -1, -1, -1, -1, -1, -1, 1195, -1, -1, - 758, -1, -1, -1, -1, -1, 764, 933, 934, -1, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 39, - -1, -1, 968, -1, 1242, -1, -1, -1, 806, 807, - -1, -1, 810, -1, -1, -1, -1, -1, 37, 38, - -1, 40, -1, 989, 990, -1, 824, 67, -1, -1, - -1, -1, -1, -1, 1000, -1, -1, -1, 78, -1, - 1006, 1007, -1, 1009, 1010, 1011, -1, 66, -1, -1, - -1, -1, -1, 72, -1, 1021, 1022, 76, -1, -1, - 79, 80, 81, 82, 83, 84, 864, 86, 87, -1, - 868, -1, -1, -1, -1, -1, -1, -1, -1, 1317, - -1, 1319, -1, -1, -1, -1, -1, -1, -1, -1, - 109, -1, 111, 1331, -1, 1333, -1, 116, 117, 118, - 119, 120, 121, 122, -1, -1, -1, 905, -1, -1, - -1, -1, 1350, -1, -1, -1, -1, -1, 1084, -1, - 1086, -1, -1, -1, -1, 1091, -1, -1, 1366, 1367, - -1, -1, -1, -1, 1100, -1, -1, -1, -1, 1377, - -1, -1, 1380, -1, -1, -1, 944, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1123, 1124, 1125, - -1, -1, -1, 1401, -1, -1, -1, -1, -1, -1, - -1, -1, 1410, -1, 972, 1413, -1, 1415, 1416, 1417, - 978, 1147, -1, -1, 982, 37, 38, -1, 40, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1003, -1, -1, -1, -1, - -1, -1, -1, -1, 66, -1, 1014, 1455, -1, 1457, - 72, 1459, 74, 75, 76, -1, -1, 79, 80, 81, - 82, 83, 84, -1, 86, 87, 1474, -1, 1036, -1, - 1038, -1, 1208, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1053, 1054, 109, -1, 111, - 1226, 113, 114, -1, -1, 117, 118, 119, 120, 121, - 122, -1, -1, -1, -1, -1, 1074, -1, -1, -1, + 72, -1, 74, 75, -1, -1, 109, -1, 111, -1, + -1, 83, 84, -1, 117, 118, 119, 120, 121, 122, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 132, -1, -1, -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 1275, - 1276, 30, 31, 32, 33, -1, -1, 36, -1, -1, - 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1129, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 67, 1147, - 69, -1, 71, -1, -1, 74, 75, -1, -1, -1, - -1, -1, -1, -1, 1162, 1163, -1, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 111, -1, 30, 31, 32, 33, 117, 118, - 36, 37, 38, 39, 40, 41, -1, 43, -1, -1, - 46, 47, 48, 49, 50, 51, 52, 53, -1, -1, - -1, 57, -1, -1, -1, 61, 62, -1, 64, 1395, - 66, 67, -1, 69, -1, 71, 72, -1, 74, 75, - 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, - 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, 33, -1, -1, 36, 37, 38, + 39, 40, -1, -1, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, -1, -1, -1, 66, 67, -1, + 69, -1, 71, 72, 39, 74, 75, 76, -1, 1519, + 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 109, -1, 111, -1, -1, 114, -1, - -1, 117, 118, 119, 120, 121, 122, -1, -1, -1, - -1, 127, -1, -1, -1, -1, 132, -1, -1, -1, - -1, -1, -1, -1, -1, 1303, -1, -1, 1306, -1, - -1, -1, -1, -1, -1, -1, 1482, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1506, 1507, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1531, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, -1, 30, 31, 32, 33, -1, -1, 36, - 37, 38, 39, 40, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, -1, 30, 31, 32, -1, -1, 66, - 67, -1, 69, 39, 71, 72, -1, 74, 75, 76, - -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, - 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 67, -1, -1, -1, -1, 72, -1, 74, 75, - -1, -1, 109, -1, 111, -1, -1, 83, 84, -1, - 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - -1, -1, 30, 31, 32, -1, -1, -1, 1516, 37, - 38, 39, 40, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, -1, 30, 31, 32, -1, -1, 66, 67, - -1, 69, 39, 71, 72, -1, 74, 75, 76, -1, - -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 67, -1, -1, -1, -1, -1, -1, 74, 75, -1, - -1, 109, -1, 111, -1, -1, -1, -1, 116, 117, - 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, -1, -1, -1, -1, 37, 38, - 39, 40, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - -1, -1, 30, 31, 32, -1, -1, 66, 67, -1, - 69, 39, 71, 72, -1, 74, 75, 76, -1, -1, - 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, - -1, -1, -1, -1, -1, -1, 74, 75, -1, -1, - 109, -1, 111, -1, -1, -1, -1, 116, 117, 118, + -1, -1, 67, -1, -1, -1, -1, -1, -1, -1, + 109, -1, 111, 78, -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, @@ -3565,9 +3570,9 @@ 40, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, -1, -1, -1, -1, -1, 66, 67, -1, 69, + -1, 30, 31, 32, -1, -1, 66, 67, -1, 69, 39, 71, 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, + -1, -1, -1, -1, -1, 74, 75, -1, -1, 109, -1, 111, -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, 9, 10, @@ -3575,12 +3580,12 @@ 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, 37, 38, 39, 40, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 66, 67, -1, 69, -1, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, + 30, 31, 32, -1, -1, 66, 67, -1, 69, 39, 71, 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, - 111, -1, -1, -1, -1, -1, 117, 118, 119, 120, + -1, -1, -1, -1, -1, -1, -1, 67, -1, -1, + -1, -1, -1, -1, 74, 75, -1, -1, 109, -1, + 111, -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, @@ -3594,5 +3599,5 @@ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, - -1, -1, -1, -1, -1, 117, 118, 119, 120, 121, + -1, -1, -1, -1, 116, 117, 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, @@ -3618,109 +3623,56 @@ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, - -1, -1, -1, 117, 118, 119, 120, 121, 122, 0, - -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, - 31, 32, 33, -1, -1, 36, -1, -1, 39, 40, + -1, -1, -1, 117, 118, 119, 120, 121, 122, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, + -1, -1, 37, 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 64, -1, -1, 67, -1, 69, -1, - 71, 72, -1, 74, 75, 76, -1, -1, -1, -1, - -1, -1, 83, 84, -1, -1, -1, -1, -1, -1, + -1, 66, 67, -1, 69, -1, 71, 72, -1, 74, + 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, - 111, -1, -1, -1, -1, -1, 117, 118, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, -1, -1, 30, 31, 32, 33, -1, - -1, 36, -1, -1, 39, 40, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 64, - -1, -1, 67, -1, 69, -1, 71, 72, -1, 74, - 75, 76, -1, -1, -1, -1, -1, -1, 83, 84, + -1, -1, -1, -1, 109, -1, 111, -1, -1, -1, + -1, -1, 117, 118, 119, 120, 121, 122, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, -1, 30, 31, 32, -1, -1, -1, + -1, 37, 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 109, -1, 111, -1, -1, -1, - 115, -1, 117, 118, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, 33, -1, -1, 36, -1, -1, - 39, 40, -1, -1, -1, -1, -1, -1, -1, -1, + 66, 67, -1, 69, -1, 71, 72, -1, 74, 75, + 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, + 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 64, -1, -1, 67, -1, - 69, -1, 71, 72, -1, 74, 75, 76, -1, -1, - -1, -1, -1, -1, 83, 84, -1, -1, -1, -1, + -1, -1, -1, 109, -1, 111, -1, -1, -1, -1, + -1, 117, 118, 119, 120, 121, 122, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, -1, -1, 30, 31, 32, -1, -1, -1, + -1, -1, -1, 39, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, 30, 31, 32, 33, 34, + 35, 67, -1, 69, 39, 71, 72, -1, 74, 75, + 76, -1, -1, -1, -1, -1, -1, 83, 84, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 67, -1, -1, -1, -1, -1, -1, 74, + 75, -1, -1, 109, -1, 111, -1, -1, -1, -1, + -1, 117, 118, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, -1, + 30, 31, 32, 33, -1, -1, 36, -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 109, -1, 111, -1, -1, -1, -1, -1, 117, 118, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, - -1, -1, -1, -1, -1, -1, 39, -1, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, - 32, 33, 34, 35, 67, -1, 69, 39, 71, 72, - -1, 74, 75, 76, -1, -1, -1, -1, -1, -1, - 83, 84, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 67, -1, -1, -1, -1, - -1, -1, 74, 75, -1, -1, 109, -1, 111, -1, - -1, -1, -1, -1, 117, 118, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, -1, 30, 31, 32, 33, -1, -1, 36, - -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 67, -1, 69, -1, 71, -1, -1, 74, 75, -1, - -1, 78, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, - 32, -1, -1, -1, 111, -1, -1, 39, -1, -1, - 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 67, -1, 69, -1, 71, - 72, -1, 74, 75, 76, -1, -1, -1, -1, -1, - -1, 83, 84, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, - -1, -1, -1, -1, -1, 117, 118, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, - -1, -1, 39, -1, -1, -1, -1, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, - 67, -1, 69, -1, 71, -1, 39, 74, 75, -1, + -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, + -1, 71, -1, -1, 74, 75, -1, -1, 78, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 67, -1, 30, 31, 32, -1, - -1, 74, 75, 110, 111, 39, -1, -1, -1, -1, - 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 67, -1, 69, 109, 71, 111, -1, - 74, 75, -1, -1, 117, 118, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 96, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 111, -1, -1, - -1, -1, -1, 117, 118, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, -1, -1, -1, -1, -1, -1, - 39, -1, -1, -1, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, -1, 30, 31, 32, -1, 67, -1, - 69, -1, 71, 39, 40, 74, 75, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 96, -1, -1, - -1, 67, -1, -1, -1, -1, -1, -1, 74, 75, - -1, -1, 111, -1, -1, -1, -1, -1, 117, 118, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, 111, 30, 31, 32, 115, - -1, 117, 118, -1, -1, 39, -1, -1, -1, -1, + 24, 25, 26, 27, -1, -1, 30, 31, 32, 33, + -1, 111, 36, -1, -1, 39, -1, 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, -1, 71, -1, -1, - 74, 75, -1, 4, 5, 6, 7, 8, 9, 10, + 74, 75, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, @@ -3736,219 +3688,288 @@ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, - -1, 69, -1, 71, -1, -1, 74, 75, -1, 4, + -1, 69, -1, 71, 72, -1, 74, 75, 76, -1, + -1, -1, -1, -1, -1, 83, 84, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, -1, -1, -1, 117, + 118, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, + -1, -1, -1, -1, -1, -1, 39, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + -1, 30, 31, 32, 67, -1, 69, -1, 71, -1, + 39, 74, 75, -1, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 67, -1, + 30, 31, 32, -1, -1, 74, 75, 110, 111, 39, + -1, -1, -1, -1, 117, 118, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, + 109, 71, 111, -1, 74, 75, -1, -1, 117, 118, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 96, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 111, -1, -1, -1, -1, -1, 117, 118, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, - -1, -1, -1, 111, 39, -1, -1, -1, -1, 117, - 118, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 39, -1, -1, -1, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, 67, -1, 69, -1, 71, 39, 40, 74, + 75, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, -1, 69, -1, 71, -1, -1, 74, - 75, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, -1, -1, -1, -1, 37, 38, - 39, 40, -1, -1, -1, -1, 111, -1, -1, -1, - -1, -1, 117, 118, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 66, 67, -1, - -1, -1, -1, 72, -1, 74, 75, 76, -1, -1, - 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + -1, 96, -1, -1, -1, 67, -1, -1, -1, -1, + -1, -1, 74, 75, -1, -1, 111, -1, -1, -1, + -1, -1, 117, 118, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, -1, 111, + 30, 31, 32, 115, -1, 117, 118, -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 109, -1, 111, -1, -1, 114, -1, -1, 117, 118, + -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, + -1, 71, -1, -1, 74, 75, -1, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, -1, -1, -1, -1, + -1, 111, 39, -1, -1, -1, -1, 117, 118, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 67, -1, 69, -1, 71, -1, -1, 74, 75, -1, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, + -1, -1, -1, -1, 111, 39, -1, -1, -1, -1, + 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 67, -1, 69, -1, 71, -1, -1, + 74, 75, -1, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, + 31, 32, -1, -1, -1, -1, -1, 111, 39, -1, + -1, -1, -1, 117, 118, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 67, -1, 69, -1, + 71, -1, -1, 74, 75, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, + -1, -1, 37, 38, 39, 40, -1, -1, -1, -1, + 111, -1, -1, -1, -1, -1, 117, 118, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 66, 67, -1, -1, -1, -1, 72, -1, 74, + 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 109, -1, 111, -1, -1, 114, + -1, -1, 117, 118, 119, 120, 121, 122, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, -1, -1, -1, 37, 38, 39, 40, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, + 31, 32, -1, -1, 66, 67, -1, -1, 39, -1, + 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, + 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 67, -1, -1, -1, + -1, 72, -1, 74, 75, 76, -1, 109, 110, 111, + -1, -1, 83, 84, -1, 117, 118, 119, 120, 121, + 122, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, + 111, 30, 31, 32, -1, -1, 117, 118, 37, 38, + 39, 40, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, 66, 67, -1, + -1, 39, -1, 72, -1, 74, 75, 76, -1, -1, + 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, + -1, -1, -1, -1, 72, -1, 74, 75, -1, -1, + 109, -1, 111, -1, -1, 83, 84, -1, 117, 118, 119, 120, 121, 122, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, -1, 30, 31, 32, -1, -1, -1, - -1, 37, 38, 39, 40, 10, 11, 12, 13, 14, + 26, 27, -1, 111, 30, 31, 32, -1, -1, 117, + 118, 37, 38, 39, 40, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, -1, - 66, 67, -1, -1, 39, -1, 72, -1, 74, 75, + 66, 67, -1, -1, 39, 40, 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, -1, -1, -1, -1, 72, -1, 74, - 75, 76, -1, 109, 110, 111, -1, -1, 83, 84, + -1, -1, 67, -1, -1, -1, -1, -1, -1, 74, + 75, -1, -1, 109, -1, 111, -1, -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, 111, 30, 31, 32, - -1, -1, 117, 118, 37, 38, 39, 40, 10, 11, + 115, -1, 117, 118, 37, 38, 39, 40, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, - 32, -1, -1, 66, 67, -1, -1, 39, -1, 72, + 32, -1, -1, 66, 67, -1, -1, 39, 40, 72, -1, 74, 75, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, -1, -1, -1, - 72, -1, 74, 75, -1, -1, 109, -1, 111, -1, - -1, 83, 84, -1, 117, 118, 119, 120, 121, 122, + -1, -1, 74, 75, -1, -1, 109, -1, 111, -1, + -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, 111, - 30, 31, 32, -1, -1, 117, 118, 37, 38, 39, - 40, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 30, 31, 32, 115, -1, 117, 118, 37, 38, 39, + 40, -1, -1, -1, -1, -1, -1, -1, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 66, 67, 30, 31, + 32, -1, 72, -1, 74, 75, 76, 39, -1, 79, + 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 67, -1, -1, -1, 109, + -1, 111, 74, 75, -1, -1, -1, 117, 118, 119, + 120, 121, 122, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, -1, 111, + 30, 31, 32, -1, -1, 117, 118, -1, -1, 39, + -1, -1, -1, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, -1, -1, 30, 31, 32, -1, 67, -1, 69, + -1, 71, 39, -1, 74, 75, -1, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, 30, 31, 32, -1, -1, 66, 67, -1, -1, - 39, 40, 72, -1, 74, 75, 76, -1, -1, 79, - 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, - -1, -1, -1, -1, -1, 74, 75, -1, -1, 109, - -1, 111, -1, -1, -1, -1, -1, 117, 118, 119, - 120, 121, 122, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, 111, 30, 31, 32, 115, -1, 117, 118, - 37, 38, 39, 40, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, -1, 30, 31, 32, -1, -1, 66, - 67, -1, -1, 39, 40, 72, -1, 74, 75, 76, - -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, - 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 67, -1, -1, -1, -1, -1, -1, 74, 75, - -1, -1, 109, -1, 111, -1, -1, -1, -1, -1, - 117, 118, 119, 120, 121, 122, 10, 11, 12, 13, + 67, 30, 31, 32, -1, 72, -1, 74, 75, 76, + 39, -1, -1, -1, 114, -1, 83, 84, -1, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, -1, 67, 30, + 31, 32, 109, 72, 111, 74, 75, 76, 39, -1, + 117, 118, -1, -1, 83, 84, -1, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 67, 30, 31, 32, + 109, 72, 111, 74, 75, 76, 39, -1, 117, 118, + -1, -1, 83, 84, -1, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 67, 30, 31, 32, 109, -1, + 111, 74, 75, -1, 39, 78, 117, 118, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, 67, -1, -1, -1, 109, 39, 111, 74, + 75, -1, -1, 78, 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, 111, 30, 31, 32, 115, - -1, 117, 118, 37, 38, 39, 40, -1, -1, -1, - -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 66, 67, 30, 31, 32, -1, 72, -1, - 74, 75, 76, 39, -1, 79, 80, 81, 82, 83, - 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 67, -1, -1, -1, 109, -1, 111, 74, 75, - -1, -1, -1, 117, 118, 119, 120, 121, 122, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, 111, 30, 31, 32, -1, - -1, 117, 118, -1, -1, 39, -1, -1, -1, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, -1, 30, - 31, 32, -1, 67, -1, 69, -1, 71, 39, -1, - 74, 75, -1, -1, -1, -1, -1, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, -1, 67, 30, 31, 32, - -1, 72, -1, 74, 75, 76, 39, 78, -1, -1, - 114, -1, 83, 84, -1, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 67, 30, 31, 32, -1, 72, - 111, 74, 75, 76, 39, -1, 117, 118, -1, -1, - 83, 84, -1, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, 67, 30, 31, 32, 109, -1, 111, 74, - 75, -1, 39, 78, 117, 118, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, - 67, -1, -1, -1, -1, 39, 111, 74, 75, -1, + 24, 25, 26, 27, -1, 67, 30, 31, 32, -1, + -1, -1, 74, 75, -1, 39, 111, -1, -1, -1, -1, -1, 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, -1, 67, 30, 31, 32, -1, -1, -1, - 74, 75, -1, 39, 111, -1, -1, -1, -1, -1, - 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - -1, 67, 30, 31, 32, -1, -1, 111, 74, 75, - -1, 39, -1, 117, 118, 10, 11, 12, 13, 14, + 26, 27, -1, 67, 30, 31, 32, -1, -1, 111, + 74, 75, -1, 39, -1, 117, 118, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, -1, -1, 30, 31, 32, + -1, 67, -1, -1, -1, -1, 39, 111, 74, 75, + -1, -1, -1, 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, -1, -1, 30, 31, 32, -1, 67, - -1, -1, -1, -1, 39, 111, 74, 75, -1, -1, + 25, 26, 27, -1, 67, 30, 31, 32, -1, -1, + -1, 74, 75, -1, 39, 111, -1, -1, -1, -1, -1, 117, 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, -1, 67, 30, 31, 32, -1, -1, -1, 74, - 75, -1, 39, 111, -1, -1, -1, -1, -1, 117, - 118, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - 67, 30, 31, 32, -1, -1, 111, 74, 75, -1, - 39, -1, 117, 118, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 67, -1, - 30, 31, 32, -1, 111, 74, 75, -1, -1, 39, - 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, + 27, -1, 67, 30, 31, 32, -1, -1, 111, 74, + 75, -1, 39, -1, 117, 118, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 67, -1, 30, 31, 32, -1, 111, 74, 75, -1, + -1, 39, 117, 118, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 67, -1, 69, - -1, 71, -1, -1, 74, 75, -1, -1, 117, 118, - 37, 38, -1, 40, 41, -1, 43, -1, -1, 46, - 47, 48, 49, 50, 51, 52, 53, -1, -1, 56, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, + -1, 69, -1, 71, 111, -1, 74, 75, -1, -1, + 117, 118, 37, 38, -1, 40, 41, -1, 43, -1, + -1, 46, 47, 48, 49, 50, 51, 52, 53, -1, + -1, 56, 57, -1, -1, -1, 61, 62, -1, 64, + -1, 66, 110, -1, -1, -1, -1, 72, -1, -1, + -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 109, -1, 111, -1, -1, 114, + -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, + 37, 38, 127, 40, 41, -1, 43, 132, -1, 46, + 47, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, -1, -1, -1, 61, 62, -1, 64, -1, 66, - 110, -1, -1, -1, -1, 72, -1, -1, -1, 76, + -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, 114, -1, -1, - 117, 118, 119, 120, 121, 122, -1, -1, 37, 38, - 127, 40, 41, -1, 43, 132, -1, 46, 47, 48, - 49, 50, 51, 52, 53, -1, -1, -1, 57, -1, - -1, -1, 61, 62, -1, 64, -1, 66, -1, -1, - -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, - 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + 117, 118, 119, 120, 121, 122, -1, -1, -1, -1, + 127, -1, -1, -1, -1, 132, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + -1, -1, 30, 31, 32, -1, -1, -1, -1, -1, + -1, 39, -1, 37, 38, -1, 40, 41, -1, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + -1, -1, 56, 57, -1, -1, -1, 61, 62, 67, + 64, 69, 66, 71, -1, -1, 74, 75, 72, -1, + -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, + 84, -1, 86, 87, -1, -1, -1, -1, 96, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 109, -1, 111, -1, -1, 114, -1, -1, 117, 118, - 119, 120, 121, 122, -1, -1, -1, -1, 127, -1, - -1, -1, -1, 132, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, - 30, 31, 32, -1, -1, -1, -1, -1, -1, 39, - -1, 37, 38, -1, 40, 41, -1, 43, 44, 45, + -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, + 114, -1, -1, 117, 118, 119, 120, 121, 122, -1, + -1, 37, 38, 127, 40, 41, -1, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, -1, -1, - 56, 57, -1, -1, -1, 61, 62, 67, 64, 69, - 66, 71, -1, -1, 74, 75, 72, -1, -1, -1, + -1, 57, -1, -1, -1, 61, 62, -1, 64, -1, + 66, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, - 86, 87, -1, -1, -1, -1, 96, -1, -1, -1, + 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, 111, -1, -1, 114, -1, -1, 117, 118, 119, 120, 121, 122, -1, -1, 37, - 38, 127, 40, 41, -1, 43, 44, 45, 46, 47, + 38, 127, 40, 41, -1, 43, -1, -1, 46, 47, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, -1, -1, -1, 61, 62, -1, 64, -1, 66, -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, + -1, -1, -1, -1, -1, -1, 37, 38, -1, 40, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 109, -1, 111, -1, -1, 114, -1, -1, 117, + 118, 119, 120, 121, 122, 66, -1, -1, -1, 127, + -1, 72, -1, -1, -1, 76, -1, -1, 79, 80, + 81, 82, 83, 84, -1, 86, 87, -1, -1, -1, + -1, -1, -1, 37, 38, -1, 40, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 109, -1, + 111, -1, 37, 38, -1, 40, 117, 118, 119, 120, + 121, 122, 66, -1, -1, -1, -1, -1, 72, -1, + -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, + 84, 66, 86, 87, -1, -1, -1, 72, -1, -1, + -1, 76, -1, -1, 79, 80, 81, 82, 83, 84, + -1, 86, 87, -1, -1, 109, -1, 111, -1, 37, + 38, -1, 40, 117, 118, 119, 120, 121, 122, -1, + -1, -1, -1, -1, 109, -1, 111, -1, 37, 38, + -1, 40, 117, 118, 119, 120, 121, 122, 66, -1, + -1, -1, -1, -1, 72, -1, -1, -1, 76, -1, + -1, 79, 80, 81, 82, 83, 84, 66, 86, 87, + -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, + 79, 80, 81, 82, 83, 84, -1, 86, 87, -1, + -1, 109, -1, -1, -1, 37, 38, -1, 40, 117, + 118, 119, 120, 121, 122, -1, -1, -1, -1, -1, + 109, -1, -1, -1, 37, 38, -1, 40, 117, 118, + 119, 120, 121, 122, 66, -1, -1, -1, -1, -1, + 72, -1, -1, -1, 76, -1, -1, 79, 80, 81, + 82, 83, 84, 66, 86, 87, -1, -1, -1, 72, + -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, + 83, 84, -1, 86, 87, -1, -1, 109, -1, -1, + -1, -1, -1, -1, -1, 117, 118, 119, 120, 121, + 122, -1, -1, -1, -1, -1, 109, -1, -1, -1, + -1, -1, -1, -1, 117, 118, 119, 120, 121, 122, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 109, -1, 111, -1, -1, 114, -1, -1, 117, - 118, 119, 120, 121, 122, -1, -1, 37, 38, 127, - 40, 41, -1, 43, -1, -1, 46, 47, 48, 49, - 50, 51, 52, 53, -1, -1, -1, 57, -1, -1, - -1, 61, 62, -1, 64, -1, 66, -1, -1, -1, - -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, - 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, - -1, -1, -1, -1, 37, 38, -1, 40, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 109, - -1, 111, -1, -1, 114, -1, -1, 117, 118, 119, - 120, 121, 122, 66, -1, -1, -1, 127, -1, 72, - -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, - 83, 84, -1, 86, 87, -1, -1, -1, -1, -1, - -1, 37, 38, -1, 40, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 109, -1, 111, -1, - -1, 114, -1, -1, 117, 118, 119, 120, 121, 122, - 66, -1, -1, -1, -1, -1, 72, -1, -1, -1, - 76, -1, -1, 79, 80, 81, 82, 83, 84, -1, - 86, 87, -1, -1, -1, -1, -1, -1, 37, 38, - -1, 40, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 109, -1, 111, -1, 37, 38, -1, - 40, 117, 118, 119, 120, 121, 122, 66, -1, -1, - -1, -1, -1, 72, -1, -1, -1, 76, -1, -1, - 79, 80, 81, 82, 83, 84, 66, 86, 87, -1, - -1, -1, 72, -1, -1, -1, 76, -1, -1, 79, - 80, 81, 82, 83, 84, -1, 86, 87, -1, -1, - 109, -1, 111, -1, 37, 38, -1, 40, 117, 118, - 119, 120, 121, 122, -1, -1, -1, -1, -1, 109, - -1, 111, -1, 37, 38, -1, 40, 117, 118, 119, - 120, 121, 122, 66, -1, -1, -1, -1, -1, 72, - -1, -1, -1, 76, -1, -1, 79, 80, 81, 82, - 83, 84, 66, 86, 87, -1, -1, -1, 72, -1, - -1, -1, 76, -1, -1, 79, 80, 81, 82, 83, - 84, -1, 86, 87, -1, -1, 109, -1, -1, -1, - 37, 38, -1, 40, 117, 118, 119, 120, 121, 122, - -1, -1, -1, -1, -1, 109, -1, -1, -1, 37, - 38, -1, 40, 117, 118, 119, 120, 121, 122, 66, - -1, -1, -1, -1, -1, 72, -1, -1, -1, 76, - -1, -1, 79, 80, 81, 82, 83, 84, 66, 86, - 87, -1, -1, -1, 72, -1, -1, -1, 76, -1, - -1, 79, 80, 81, 82, 83, 84, -1, 86, 87, - -1, -1, 109, -1, -1, -1, -1, -1, -1, -1, - 117, 118, 119, 120, 121, 122, -1, -1, -1, -1, - -1, 109, -1, -1, -1, -1, -1, -1, -1, 117, - 118, 119, 120, 121, 122, 4, 5, 6, 7, 8, + -1, -1, -1, 67, -1, 69, -1, 71, 72, -1, + 74, 75, 76, -1, -1, -1, -1, -1, -1, 83, + 84, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, + 32, -1, -1, -1, -1, -1, -1, 39, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 67, -1, 69, -1, 71, + -1, -1, 74, 75, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 30, 31, 32, -1, -1, -1, -1, -1, -1, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, -1, - 69, -1, 71, 72, -1, 74, 75, 76, -1, -1, - -1, -1, -1, -1, 83, 84, 3, 4, 5, 6, + 69, -1, 71, -1, -1, 74, 75, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, @@ -3957,20 +3978,5 @@ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 67, -1, 69, -1, 71, -1, -1, 74, 75, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, -1, -1, 30, 31, 32, -1, - -1, -1, -1, -1, -1, 39, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 67, -1, 69, -1, 71, -1, -1, - 74, 75, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 30, 31, - 32, -1, -1, -1, -1, -1, -1, 39, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 67, -1, 69, -1, 71, - -1, -1, 74, 75 + 67, -1, 69, -1, 71, -1, -1, 74, 75 }; @@ -3983,156 +3989,156 @@ 22, 23, 24, 25, 26, 27, 30, 31, 32, 33, 36, 39, 40, 64, 67, 69, 71, 72, 74, 75, - 76, 83, 84, 109, 111, 117, 118, 137, 140, 150, - 199, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 232, - 233, 234, 235, 236, 237, 238, 240, 241, 242, 243, - 244, 245, 247, 255, 256, 283, 284, 285, 293, 296, - 302, 303, 305, 307, 308, 314, 319, 323, 324, 325, - 326, 327, 328, 329, 330, 350, 367, 368, 369, 370, - 72, 139, 140, 150, 216, 218, 226, 228, 237, 241, - 243, 284, 82, 109, 312, 313, 314, 312, 312, 72, - 74, 75, 76, 138, 139, 273, 274, 294, 295, 74, - 75, 274, 109, 305, 11, 200, 109, 150, 319, 324, - 325, 326, 328, 329, 330, 112, 134, 111, 219, 226, - 228, 323, 327, 366, 367, 370, 371, 135, 107, 131, - 277, 114, 135, 174, 74, 75, 137, 272, 135, 135, - 135, 116, 135, 74, 75, 109, 150, 309, 318, 319, - 320, 321, 322, 323, 327, 331, 332, 333, 334, 335, - 341, 3, 28, 78, 239, 3, 5, 74, 111, 150, - 218, 229, 233, 235, 244, 285, 323, 327, 370, 216, - 218, 228, 237, 241, 243, 284, 323, 327, 33, 234, - 234, 229, 235, 135, 234, 229, 234, 229, 75, 109, - 114, 274, 285, 114, 274, 234, 229, 116, 135, 135, - 0, 134, 109, 174, 312, 312, 134, 111, 226, 228, - 368, 272, 272, 131, 228, 109, 150, 309, 319, 323, - 111, 150, 370, 306, 231, 314, 109, 290, 109, 109, + 76, 83, 84, 109, 111, 117, 118, 137, 140, 151, + 200, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 233, + 234, 235, 236, 237, 238, 239, 241, 242, 243, 244, + 245, 246, 248, 256, 257, 284, 285, 286, 294, 297, + 303, 304, 306, 308, 309, 315, 320, 324, 325, 326, + 327, 328, 329, 330, 331, 351, 368, 369, 370, 371, + 72, 139, 140, 151, 217, 219, 227, 229, 238, 242, + 244, 285, 82, 109, 313, 314, 315, 313, 313, 72, + 74, 75, 76, 138, 139, 274, 275, 295, 296, 74, + 75, 275, 109, 306, 11, 201, 109, 151, 320, 325, + 326, 327, 329, 330, 331, 112, 134, 111, 220, 227, + 229, 324, 328, 367, 368, 371, 372, 135, 107, 131, + 278, 114, 135, 175, 74, 75, 137, 273, 135, 135, + 135, 116, 135, 74, 75, 109, 151, 310, 319, 320, + 321, 322, 323, 324, 328, 332, 333, 334, 335, 336, + 342, 3, 28, 78, 240, 3, 5, 74, 111, 151, + 219, 230, 234, 236, 245, 286, 324, 328, 371, 217, + 219, 229, 238, 242, 244, 285, 324, 328, 33, 235, + 235, 230, 236, 135, 235, 230, 235, 230, 75, 109, + 114, 275, 286, 114, 275, 235, 230, 116, 135, 135, + 0, 134, 109, 175, 313, 313, 134, 111, 227, 229, + 369, 273, 273, 131, 229, 109, 151, 310, 320, 324, + 111, 151, 371, 307, 232, 315, 109, 291, 109, 109, 51, 109, 37, 38, 40, 66, 72, 76, 79, 80, 81, 82, 86, 87, 109, 111, 119, 120, 121, 122, - 136, 140, 141, 142, 143, 144, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 165, 168, 226, 276, 292, 366, 371, 228, 110, - 110, 110, 110, 110, 110, 110, 74, 75, 111, 226, - 272, 350, 368, 111, 117, 150, 165, 218, 219, 225, - 228, 232, 233, 237, 240, 241, 243, 262, 263, 267, - 268, 269, 270, 284, 350, 362, 363, 364, 365, 370, - 371, 112, 109, 323, 327, 370, 109, 116, 132, 111, - 114, 150, 165, 278, 278, 115, 134, 116, 132, 109, - 116, 132, 116, 132, 116, 132, 312, 132, 319, 320, - 321, 322, 332, 333, 334, 335, 228, 318, 331, 64, - 311, 111, 312, 349, 350, 312, 312, 174, 134, 109, - 312, 349, 312, 312, 228, 309, 109, 109, 227, 228, - 226, 228, 112, 134, 226, 366, 371, 174, 134, 272, - 277, 218, 233, 323, 327, 174, 134, 294, 228, 237, - 132, 228, 228, 292, 248, 246, 258, 274, 257, 228, - 294, 132, 132, 305, 134, 139, 271, 3, 135, 208, - 209, 223, 225, 228, 134, 311, 109, 311, 165, 319, - 228, 109, 134, 272, 114, 33, 34, 35, 226, 286, - 287, 289, 134, 128, 131, 291, 134, 229, 234, 235, - 272, 315, 316, 317, 109, 141, 109, 149, 109, 149, - 152, 109, 149, 109, 109, 149, 149, 111, 165, 170, - 174, 226, 275, 366, 370, 112, 134, 82, 85, 86, + 136, 140, 141, 142, 143, 144, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 166, 169, 227, 277, 293, 367, 372, 229, 110, + 110, 110, 110, 110, 110, 110, 74, 75, 111, 227, + 273, 351, 369, 111, 117, 151, 166, 219, 220, 226, + 229, 233, 234, 238, 241, 242, 244, 263, 264, 268, + 269, 270, 271, 285, 351, 363, 364, 365, 366, 371, + 372, 112, 109, 324, 328, 371, 109, 116, 132, 111, + 114, 151, 166, 279, 279, 115, 134, 116, 132, 109, + 116, 132, 116, 132, 116, 132, 313, 132, 320, 321, + 322, 323, 333, 334, 335, 336, 229, 319, 332, 64, + 312, 111, 313, 350, 351, 313, 313, 175, 134, 109, + 313, 350, 313, 313, 229, 310, 109, 109, 228, 229, + 227, 229, 112, 134, 227, 367, 372, 175, 134, 273, + 278, 219, 234, 324, 328, 175, 134, 295, 229, 238, + 132, 229, 229, 293, 249, 247, 259, 275, 258, 229, + 295, 132, 132, 306, 134, 139, 272, 3, 135, 209, + 210, 224, 226, 229, 134, 312, 109, 312, 166, 320, + 229, 109, 134, 273, 114, 33, 34, 35, 227, 287, + 288, 290, 134, 128, 131, 292, 134, 230, 235, 236, + 273, 316, 317, 318, 109, 141, 109, 150, 109, 150, + 153, 109, 150, 109, 109, 150, 150, 111, 166, 171, + 175, 227, 276, 367, 371, 112, 134, 82, 85, 86, 87, 109, 111, 113, 114, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 131, 167, 152, 152, + 102, 103, 104, 105, 106, 107, 131, 168, 153, 153, 117, 123, 124, 119, 120, 88, 89, 90, 91, 125, 126, 92, 93, 118, 127, 128, 94, 95, 129, 131, - 373, 109, 150, 345, 346, 347, 348, 349, 110, 116, - 109, 349, 350, 109, 349, 350, 134, 109, 226, 368, - 112, 134, 135, 111, 226, 228, 361, 362, 370, 371, - 135, 109, 111, 150, 319, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 350, 351, 352, 353, 354, 355, - 356, 150, 370, 228, 135, 135, 150, 226, 228, 363, - 272, 226, 350, 363, 272, 109, 134, 134, 134, 112, - 134, 72, 111, 113, 140, 274, 278, 279, 280, 281, - 282, 134, 134, 134, 134, 134, 134, 309, 110, 110, - 110, 110, 110, 110, 110, 318, 331, 109, 277, 112, - 208, 134, 309, 170, 276, 170, 276, 309, 111, 208, - 311, 174, 134, 208, 110, 40, 111, 115, 226, 249, - 250, 251, 366, 114, 116, 372, 131, 259, 114, 228, - 264, 265, 266, 269, 270, 110, 116, 174, 134, 117, - 165, 134, 225, 228, 263, 362, 370, 303, 304, 109, - 150, 336, 110, 116, 373, 274, 286, 109, 114, 274, - 276, 286, 110, 116, 109, 141, 110, 130, 275, 275, - 275, 146, 165, 276, 275, 112, 134, 110, 116, 110, - 109, 150, 349, 357, 358, 359, 360, 110, 116, 165, - 111, 139, 145, 146, 134, 111, 139, 145, 165, 152, - 152, 152, 153, 153, 154, 154, 155, 155, 155, 155, - 156, 156, 157, 158, 159, 160, 161, 130, 170, 165, - 134, 346, 347, 348, 228, 345, 312, 312, 165, 276, - 134, 271, 134, 226, 350, 363, 228, 232, 112, 112, - 134, 370, 112, 109, 134, 319, 337, 338, 339, 342, - 352, 353, 354, 112, 134, 228, 336, 340, 351, 109, - 312, 355, 373, 312, 312, 373, 109, 312, 355, 312, - 312, 312, 312, 350, 226, 361, 371, 272, 112, 116, - 112, 116, 373, 226, 363, 373, 260, 261, 262, 263, - 260, 260, 272, 165, 134, 111, 274, 130, 116, 372, - 278, 111, 130, 282, 29, 210, 211, 272, 260, 139, - 309, 139, 311, 109, 349, 350, 109, 349, 350, 142, - 350, 174, 264, 110, 110, 110, 110, 112, 174, 208, - 174, 114, 250, 251, 112, 134, 109, 130, 150, 252, - 254, 318, 319, 331, 357, 116, 132, 116, 132, 274, - 248, 274, 115, 163, 164, 258, 135, 135, 139, 223, - 135, 135, 260, 109, 150, 370, 135, 115, 228, 287, - 288, 135, 134, 134, 109, 135, 110, 316, 170, 171, - 130, 132, 111, 141, 201, 202, 203, 110, 116, 110, - 110, 110, 110, 111, 165, 358, 359, 360, 228, 357, - 312, 312, 114, 152, 168, 165, 166, 169, 116, 135, - 134, 110, 116, 165, 134, 115, 163, 130, 264, 110, - 110, 110, 345, 264, 110, 260, 226, 363, 111, 117, - 150, 165, 165, 228, 342, 264, 110, 110, 110, 110, - 110, 110, 110, 7, 228, 336, 340, 351, 134, 134, - 373, 134, 134, 110, 135, 135, 135, 135, 277, 135, - 163, 164, 165, 310, 134, 278, 280, 115, 134, 212, - 274, 40, 41, 43, 46, 47, 48, 49, 50, 51, - 52, 53, 57, 61, 62, 72, 111, 127, 171, 172, - 173, 174, 175, 176, 178, 179, 191, 193, 194, 199, - 213, 308, 29, 135, 131, 277, 134, 134, 110, 135, - 174, 248, 132, 132, 319, 164, 228, 253, 254, 253, - 274, 312, 115, 259, 372, 110, 116, 112, 112, 135, - 228, 116, 373, 290, 110, 286, 216, 218, 226, 298, - 299, 300, 301, 292, 110, 110, 130, 164, 109, 110, - 130, 116, 139, 112, 110, 110, 110, 357, 279, 116, - 135, 169, 112, 139, 147, 148, 146, 135, 147, 163, - 168, 135, 109, 349, 350, 135, 135, 134, 135, 135, - 135, 165, 110, 135, 109, 349, 350, 109, 355, 109, - 355, 350, 227, 7, 117, 135, 165, 264, 264, 263, - 267, 267, 268, 116, 116, 110, 110, 112, 96, 122, - 135, 135, 147, 278, 165, 116, 132, 213, 217, 228, - 232, 109, 109, 172, 109, 109, 72, 132, 72, 132, - 72, 117, 171, 109, 174, 166, 166, 130, 112, 144, - 132, 135, 134, 135, 212, 110, 165, 264, 264, 312, - 110, 115, 252, 115, 134, 110, 134, 135, 309, 115, - 134, 135, 135, 110, 114, 201, 112, 164, 132, 201, - 203, 110, 109, 349, 350, 372, 166, 112, 135, 85, - 113, 116, 135, 112, 135, 110, 134, 110, 110, 112, - 112, 112, 135, 110, 134, 134, 134, 165, 165, 135, - 112, 135, 135, 135, 135, 134, 134, 164, 164, 112, - 112, 135, 135, 274, 228, 170, 170, 47, 170, 134, - 132, 132, 132, 170, 132, 170, 58, 59, 60, 195, - 196, 197, 132, 63, 132, 312, 114, 176, 115, 132, - 135, 135, 96, 269, 270, 110, 299, 116, 132, 116, - 132, 115, 297, 130, 141, 110, 110, 130, 134, 115, - 112, 111, 148, 111, 148, 148, 112, 112, 264, 112, - 264, 264, 264, 135, 135, 112, 112, 110, 110, 112, - 116, 96, 263, 96, 135, 112, 112, 110, 110, 109, - 110, 171, 192, 213, 132, 110, 109, 109, 174, 197, - 58, 59, 165, 172, 145, 110, 110, 114, 134, 134, - 298, 141, 204, 109, 132, 204, 264, 134, 134, 135, - 135, 135, 135, 112, 112, 134, 135, 112, 172, 44, - 45, 114, 182, 183, 184, 170, 172, 135, 110, 171, - 114, 184, 96, 134, 96, 134, 109, 109, 132, 115, - 134, 272, 309, 115, 116, 130, 164, 110, 135, 147, - 147, 110, 110, 110, 110, 267, 42, 164, 180, 181, - 310, 130, 134, 172, 182, 110, 132, 172, 132, 134, - 110, 134, 110, 134, 96, 134, 96, 134, 132, 298, - 141, 139, 205, 110, 132, 110, 135, 135, 172, 96, - 116, 130, 135, 206, 207, 213, 132, 171, 171, 206, - 174, 198, 226, 366, 174, 198, 110, 134, 110, 134, - 115, 110, 116, 112, 112, 164, 180, 183, 185, 186, - 134, 132, 183, 187, 188, 135, 109, 150, 309, 357, - 139, 135, 174, 198, 174, 198, 109, 132, 139, 172, - 177, 115, 183, 213, 171, 56, 177, 190, 115, 183, - 110, 228, 110, 135, 135, 292, 172, 177, 132, 189, - 190, 177, 190, 174, 174, 110, 110, 110, 189, 135, - 135, 174, 174, 135, 135 + 374, 109, 151, 346, 347, 348, 349, 350, 110, 116, + 109, 350, 351, 109, 350, 351, 134, 109, 227, 369, + 112, 134, 135, 111, 227, 229, 362, 363, 371, 372, + 135, 109, 111, 151, 320, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 351, 352, 353, 354, 355, 356, + 357, 151, 371, 229, 135, 135, 151, 227, 229, 364, + 273, 227, 351, 364, 273, 109, 134, 134, 134, 112, + 134, 72, 111, 113, 140, 275, 279, 280, 281, 282, + 283, 134, 134, 134, 134, 134, 134, 310, 110, 110, + 110, 110, 110, 110, 110, 319, 332, 109, 278, 112, + 209, 134, 310, 171, 277, 171, 277, 310, 111, 209, + 312, 175, 134, 209, 110, 40, 111, 115, 227, 250, + 251, 252, 367, 114, 116, 373, 131, 260, 114, 229, + 265, 266, 267, 270, 271, 110, 116, 175, 134, 117, + 166, 134, 226, 229, 264, 363, 371, 304, 305, 109, + 151, 337, 110, 116, 374, 275, 287, 109, 114, 275, + 277, 287, 110, 116, 109, 141, 110, 130, 276, 276, + 276, 146, 166, 277, 276, 112, 134, 110, 116, 110, + 109, 151, 350, 358, 359, 360, 361, 110, 116, 166, + 111, 139, 145, 146, 134, 79, 111, 139, 145, 166, + 153, 153, 153, 154, 154, 155, 155, 156, 156, 156, + 156, 157, 157, 158, 159, 160, 161, 162, 130, 171, + 166, 134, 347, 348, 349, 229, 346, 313, 313, 166, + 277, 134, 272, 134, 227, 351, 364, 229, 233, 112, + 112, 134, 371, 112, 109, 134, 320, 338, 339, 340, + 343, 353, 354, 355, 112, 134, 229, 337, 341, 352, + 109, 313, 356, 374, 313, 313, 374, 109, 313, 356, + 313, 313, 313, 313, 351, 227, 362, 372, 273, 112, + 116, 112, 116, 374, 227, 364, 374, 261, 262, 263, + 264, 261, 261, 273, 166, 134, 111, 275, 130, 116, + 373, 279, 111, 130, 283, 29, 211, 212, 273, 261, + 139, 310, 139, 312, 109, 350, 351, 109, 350, 351, + 142, 351, 175, 265, 110, 110, 110, 110, 112, 175, + 209, 175, 114, 251, 252, 112, 134, 109, 130, 151, + 253, 255, 319, 320, 332, 358, 116, 132, 116, 132, + 275, 249, 275, 115, 164, 165, 259, 135, 135, 139, + 224, 135, 135, 261, 109, 151, 371, 135, 115, 229, + 288, 289, 135, 134, 134, 109, 135, 110, 317, 171, + 172, 130, 132, 111, 141, 202, 203, 204, 110, 116, + 110, 110, 110, 110, 111, 166, 359, 360, 361, 229, + 358, 313, 313, 114, 153, 169, 166, 167, 170, 116, + 135, 134, 110, 116, 166, 134, 115, 164, 130, 265, + 110, 110, 110, 346, 265, 110, 261, 227, 364, 111, + 117, 151, 166, 166, 229, 343, 265, 110, 110, 110, + 110, 110, 110, 110, 7, 229, 337, 341, 352, 134, + 134, 374, 134, 134, 110, 135, 135, 135, 135, 278, + 135, 164, 165, 166, 311, 134, 279, 281, 115, 134, + 213, 275, 40, 41, 43, 46, 47, 48, 49, 50, + 51, 52, 53, 57, 61, 62, 72, 111, 127, 172, + 173, 174, 175, 176, 177, 179, 180, 192, 194, 195, + 200, 214, 309, 29, 135, 131, 278, 134, 134, 110, + 135, 175, 249, 132, 132, 320, 165, 229, 254, 255, + 254, 275, 313, 115, 260, 373, 110, 116, 112, 112, + 135, 229, 116, 374, 291, 110, 287, 217, 219, 227, + 299, 300, 301, 302, 293, 110, 110, 130, 165, 109, + 110, 130, 116, 139, 112, 110, 110, 110, 358, 280, + 116, 135, 170, 112, 79, 139, 147, 148, 149, 146, + 135, 147, 164, 169, 135, 109, 350, 351, 135, 135, + 134, 135, 135, 135, 166, 110, 135, 109, 350, 351, + 109, 356, 109, 356, 351, 228, 7, 117, 135, 166, + 265, 265, 264, 268, 268, 269, 116, 116, 110, 110, + 112, 96, 122, 135, 135, 147, 279, 166, 116, 132, + 214, 218, 229, 233, 109, 109, 173, 109, 109, 72, + 132, 72, 132, 72, 117, 172, 109, 175, 167, 167, + 130, 112, 144, 132, 135, 134, 135, 213, 110, 166, + 265, 265, 313, 110, 115, 253, 115, 134, 110, 134, + 135, 310, 115, 134, 135, 135, 110, 114, 202, 112, + 165, 132, 202, 204, 110, 109, 350, 351, 373, 167, + 112, 135, 116, 135, 85, 113, 112, 135, 110, 134, + 110, 110, 112, 112, 112, 135, 110, 134, 134, 134, + 166, 166, 135, 112, 135, 135, 135, 135, 134, 134, + 165, 165, 112, 112, 135, 135, 275, 229, 171, 171, + 47, 171, 134, 132, 132, 132, 171, 132, 171, 58, + 59, 60, 196, 197, 198, 132, 63, 132, 313, 114, + 177, 115, 132, 135, 135, 96, 270, 271, 110, 300, + 116, 132, 116, 132, 115, 298, 130, 141, 110, 110, + 130, 134, 115, 112, 148, 112, 111, 148, 111, 148, + 112, 265, 112, 265, 265, 265, 135, 135, 112, 112, + 110, 110, 112, 116, 96, 264, 96, 135, 112, 112, + 110, 110, 109, 110, 172, 193, 214, 132, 110, 109, + 109, 175, 198, 58, 59, 166, 173, 145, 110, 110, + 114, 134, 134, 299, 141, 205, 109, 132, 205, 265, + 134, 134, 135, 135, 135, 135, 112, 112, 134, 135, + 112, 173, 44, 45, 114, 183, 184, 185, 171, 173, + 135, 110, 172, 114, 185, 96, 134, 96, 134, 109, + 109, 132, 115, 134, 273, 310, 115, 116, 130, 165, + 110, 135, 147, 147, 110, 110, 110, 110, 268, 42, + 165, 181, 182, 311, 130, 134, 173, 183, 110, 132, + 173, 132, 134, 110, 134, 110, 134, 96, 134, 96, + 134, 132, 299, 141, 139, 206, 110, 132, 110, 135, + 135, 173, 96, 116, 130, 135, 207, 208, 214, 132, + 172, 172, 207, 175, 199, 227, 367, 175, 199, 110, + 134, 110, 134, 115, 110, 116, 112, 112, 165, 181, + 184, 186, 187, 134, 132, 184, 188, 189, 135, 109, + 151, 310, 358, 139, 135, 175, 199, 175, 199, 109, + 132, 139, 173, 178, 115, 184, 214, 172, 56, 178, + 191, 115, 184, 110, 229, 110, 135, 135, 293, 173, + 178, 132, 190, 191, 178, 191, 175, 175, 110, 110, + 110, 190, 135, 135, 175, 175, 135, 135 }; @@ -4971,5 +4977,5 @@ /* Line 1806 of yacc.c */ -#line 300 "parser.yy" +#line 302 "parser.yy" { typedefTable.enterScope(); } break; @@ -4978,5 +4984,5 @@ /* Line 1806 of yacc.c */ -#line 304 "parser.yy" +#line 306 "parser.yy" { typedefTable.leaveScope(); } break; @@ -4985,5 +4991,5 @@ /* Line 1806 of yacc.c */ -#line 311 "parser.yy" +#line 313 "parser.yy" { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); } break; @@ -4992,5 +4998,5 @@ /* Line 1806 of yacc.c */ -#line 312 "parser.yy" +#line 314 "parser.yy" { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); } break; @@ -4999,5 +5005,5 @@ /* Line 1806 of yacc.c */ -#line 313 "parser.yy" +#line 315 "parser.yy" { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); } break; @@ -5006,5 +5012,5 @@ /* Line 1806 of yacc.c */ -#line 338 "parser.yy" +#line 340 "parser.yy" { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].str) ); } break; @@ -5013,5 +5019,5 @@ /* Line 1806 of yacc.c */ -#line 342 "parser.yy" +#line 344 "parser.yy" { (yyval.str) = (yyvsp[(1) - (1)].tok); } break; @@ -5020,5 +5026,5 @@ /* Line 1806 of yacc.c */ -#line 344 "parser.yy" +#line 346 "parser.yy" { appendStr( (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].tok) ); // append 2nd juxtaposed string to 1st @@ -5031,19 +5037,19 @@ /* Line 1806 of yacc.c */ -#line 355 "parser.yy" - { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); } - break; - - case 20: - -/* Line 1806 of yacc.c */ #line 357 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); } break; + case 20: + +/* Line 1806 of yacc.c */ +#line 359 "parser.yy" + { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); } + break; + case 21: /* Line 1806 of yacc.c */ -#line 359 "parser.yy" +#line 361 "parser.yy" { (yyval.en) = (yyvsp[(2) - (3)].en); } break; @@ -5052,5 +5058,5 @@ /* Line 1806 of yacc.c */ -#line 361 "parser.yy" +#line 363 "parser.yy" { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); } break; @@ -5059,5 +5065,5 @@ /* Line 1806 of yacc.c */ -#line 371 "parser.yy" +#line 373 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); } break; @@ -5066,5 +5072,5 @@ /* Line 1806 of yacc.c */ -#line 373 "parser.yy" +#line 375 "parser.yy" { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); } break; @@ -5073,5 +5079,5 @@ /* Line 1806 of yacc.c */ -#line 377 "parser.yy" +#line 379 "parser.yy" { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); } break; @@ -5080,5 +5086,5 @@ /* Line 1806 of yacc.c */ -#line 379 "parser.yy" +#line 381 "parser.yy" { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); } break; @@ -5087,128 +5093,135 @@ /* Line 1806 of yacc.c */ -#line 381 "parser.yy" +#line 383 "parser.yy" + { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_constantInteger( *(yyvsp[(3) - (3)].tok) ) ) ); } + break; + + case 29: + +/* Line 1806 of yacc.c */ +#line 385 "parser.yy" { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); } break; - case 29: - -/* Line 1806 of yacc.c */ -#line 383 "parser.yy" + case 30: + +/* Line 1806 of yacc.c */ +#line 387 "parser.yy" { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); } break; - case 30: - -/* Line 1806 of yacc.c */ -#line 385 "parser.yy" + case 31: + +/* Line 1806 of yacc.c */ +#line 389 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); } break; - case 31: - -/* Line 1806 of yacc.c */ -#line 387 "parser.yy" + case 32: + +/* Line 1806 of yacc.c */ +#line 391 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); } break; - case 32: - -/* Line 1806 of yacc.c */ -#line 389 "parser.yy" + case 33: + +/* Line 1806 of yacc.c */ +#line 393 "parser.yy" { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); } break; - case 33: - -/* Line 1806 of yacc.c */ -#line 391 "parser.yy" + case 34: + +/* Line 1806 of yacc.c */ +#line 395 "parser.yy" { Token fn; - fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? + fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? (yyval.en) = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) ) ); } break; - case 35: - -/* Line 1806 of yacc.c */ -#line 401 "parser.yy" + case 36: + +/* Line 1806 of yacc.c */ +#line 405 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); } break; - case 36: - -/* Line 1806 of yacc.c */ -#line 406 "parser.yy" + case 37: + +/* Line 1806 of yacc.c */ +#line 410 "parser.yy" { (yyval.en) = 0; } break; - case 39: - -/* Line 1806 of yacc.c */ -#line 412 "parser.yy" + case 40: + +/* Line 1806 of yacc.c */ +#line 416 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } break; - case 40: - -/* Line 1806 of yacc.c */ -#line 417 "parser.yy" + case 41: + +/* Line 1806 of yacc.c */ +#line 423 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); } break; - case 41: - -/* Line 1806 of yacc.c */ -#line 421 "parser.yy" + case 42: + +/* Line 1806 of yacc.c */ +#line 425 "parser.yy" { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); } break; - case 42: - -/* Line 1806 of yacc.c */ -#line 423 "parser.yy" + case 43: + +/* Line 1806 of yacc.c */ +#line 427 "parser.yy" { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); } break; - case 43: - -/* Line 1806 of yacc.c */ -#line 425 "parser.yy" + case 44: + +/* Line 1806 of yacc.c */ +#line 429 "parser.yy" { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); } break; - case 44: - -/* Line 1806 of yacc.c */ -#line 427 "parser.yy" + case 45: + +/* Line 1806 of yacc.c */ +#line 431 "parser.yy" { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); } break; - case 46: - -/* Line 1806 of yacc.c */ -#line 435 "parser.yy" + case 49: + +/* Line 1806 of yacc.c */ +#line 444 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; - case 47: - -/* Line 1806 of yacc.c */ -#line 437 "parser.yy" + case 50: + +/* Line 1806 of yacc.c */ +#line 446 "parser.yy" { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); } break; - case 48: - -/* Line 1806 of yacc.c */ -#line 439 "parser.yy" + case 51: + +/* Line 1806 of yacc.c */ +#line 448 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); } break; - case 49: - -/* Line 1806 of yacc.c */ -#line 444 "parser.yy" + case 52: + +/* Line 1806 of yacc.c */ +#line 453 "parser.yy" { switch ( (yyvsp[(1) - (2)].op) ) { @@ -5225,460 +5238,460 @@ break; - case 50: - -/* Line 1806 of yacc.c */ -#line 457 "parser.yy" + case 53: + +/* Line 1806 of yacc.c */ +#line 466 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); } break; - case 51: - -/* Line 1806 of yacc.c */ -#line 459 "parser.yy" + case 54: + +/* Line 1806 of yacc.c */ +#line 468 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); } break; - case 52: - -/* Line 1806 of yacc.c */ -#line 461 "parser.yy" + case 55: + +/* Line 1806 of yacc.c */ +#line 470 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); } break; - case 53: - -/* Line 1806 of yacc.c */ -#line 463 "parser.yy" + case 56: + +/* Line 1806 of yacc.c */ +#line 472 "parser.yy" { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); } break; - case 54: - -/* Line 1806 of yacc.c */ -#line 465 "parser.yy" + case 57: + +/* Line 1806 of yacc.c */ +#line 474 "parser.yy" { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); } break; - case 55: - -/* Line 1806 of yacc.c */ -#line 467 "parser.yy" + case 58: + +/* Line 1806 of yacc.c */ +#line 476 "parser.yy" { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); } break; - case 56: - -/* Line 1806 of yacc.c */ -#line 469 "parser.yy" + case 59: + +/* Line 1806 of yacc.c */ +#line 478 "parser.yy" { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); } break; - case 57: - -/* Line 1806 of yacc.c */ -#line 471 "parser.yy" + case 60: + +/* Line 1806 of yacc.c */ +#line 480 "parser.yy" { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); } break; - case 58: - -/* Line 1806 of yacc.c */ -#line 473 "parser.yy" + case 61: + +/* Line 1806 of yacc.c */ +#line 482 "parser.yy" { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); } break; - case 59: - -/* Line 1806 of yacc.c */ -#line 475 "parser.yy" + case 62: + +/* Line 1806 of yacc.c */ +#line 484 "parser.yy" { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); } break; - case 60: - -/* Line 1806 of yacc.c */ -#line 477 "parser.yy" + case 63: + +/* Line 1806 of yacc.c */ +#line 486 "parser.yy" { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); } break; - case 61: - -/* Line 1806 of yacc.c */ -#line 483 "parser.yy" + case 64: + +/* Line 1806 of yacc.c */ +#line 492 "parser.yy" { (yyval.op) = OperKinds::PointTo; } break; - case 62: - -/* Line 1806 of yacc.c */ -#line 484 "parser.yy" + case 65: + +/* Line 1806 of yacc.c */ +#line 493 "parser.yy" { (yyval.op) = OperKinds::AddressOf; } break; - case 63: - -/* Line 1806 of yacc.c */ -#line 490 "parser.yy" + case 66: + +/* Line 1806 of yacc.c */ +#line 499 "parser.yy" { (yyval.op) = OperKinds::UnPlus; } break; - case 64: - -/* Line 1806 of yacc.c */ -#line 491 "parser.yy" + case 67: + +/* Line 1806 of yacc.c */ +#line 500 "parser.yy" { (yyval.op) = OperKinds::UnMinus; } break; - case 65: - -/* Line 1806 of yacc.c */ -#line 492 "parser.yy" + case 68: + +/* Line 1806 of yacc.c */ +#line 501 "parser.yy" { (yyval.op) = OperKinds::Neg; } break; - case 66: - -/* Line 1806 of yacc.c */ -#line 493 "parser.yy" + case 69: + +/* Line 1806 of yacc.c */ +#line 502 "parser.yy" { (yyval.op) = OperKinds::BitNeg; } break; - case 68: - -/* Line 1806 of yacc.c */ -#line 499 "parser.yy" + case 71: + +/* Line 1806 of yacc.c */ +#line 508 "parser.yy" { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); } break; - case 69: - -/* Line 1806 of yacc.c */ -#line 501 "parser.yy" + case 72: + +/* Line 1806 of yacc.c */ +#line 510 "parser.yy" { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); } break; - case 71: - -/* Line 1806 of yacc.c */ -#line 507 "parser.yy" + case 74: + +/* Line 1806 of yacc.c */ +#line 516 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 72: - -/* Line 1806 of yacc.c */ -#line 509 "parser.yy" + case 75: + +/* Line 1806 of yacc.c */ +#line 518 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 73: - -/* Line 1806 of yacc.c */ -#line 511 "parser.yy" + case 76: + +/* Line 1806 of yacc.c */ +#line 520 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 75: - -/* Line 1806 of yacc.c */ -#line 517 "parser.yy" + case 78: + +/* Line 1806 of yacc.c */ +#line 526 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 76: - -/* Line 1806 of yacc.c */ -#line 519 "parser.yy" + case 79: + +/* Line 1806 of yacc.c */ +#line 528 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 78: - -/* Line 1806 of yacc.c */ -#line 525 "parser.yy" + case 81: + +/* Line 1806 of yacc.c */ +#line 534 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 79: - -/* Line 1806 of yacc.c */ -#line 527 "parser.yy" + case 82: + +/* Line 1806 of yacc.c */ +#line 536 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 81: - -/* Line 1806 of yacc.c */ -#line 533 "parser.yy" + case 84: + +/* Line 1806 of yacc.c */ +#line 542 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 82: - -/* Line 1806 of yacc.c */ -#line 535 "parser.yy" + case 85: + +/* Line 1806 of yacc.c */ +#line 544 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 83: - -/* Line 1806 of yacc.c */ -#line 537 "parser.yy" + case 86: + +/* Line 1806 of yacc.c */ +#line 546 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 84: - -/* Line 1806 of yacc.c */ -#line 539 "parser.yy" + case 87: + +/* Line 1806 of yacc.c */ +#line 548 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 86: - -/* Line 1806 of yacc.c */ -#line 545 "parser.yy" + case 89: + +/* Line 1806 of yacc.c */ +#line 554 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 87: - -/* Line 1806 of yacc.c */ -#line 547 "parser.yy" + case 90: + +/* Line 1806 of yacc.c */ +#line 556 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 89: - -/* Line 1806 of yacc.c */ -#line 553 "parser.yy" + case 92: + +/* Line 1806 of yacc.c */ +#line 562 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 91: - -/* Line 1806 of yacc.c */ -#line 559 "parser.yy" + case 94: + +/* Line 1806 of yacc.c */ +#line 568 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 93: - -/* Line 1806 of yacc.c */ -#line 565 "parser.yy" + case 96: + +/* Line 1806 of yacc.c */ +#line 574 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 95: - -/* Line 1806 of yacc.c */ -#line 571 "parser.yy" + case 98: + +/* Line 1806 of yacc.c */ +#line 580 "parser.yy" { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); } break; - case 97: - -/* Line 1806 of yacc.c */ -#line 577 "parser.yy" + case 100: + +/* Line 1806 of yacc.c */ +#line 586 "parser.yy" { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); } break; - case 99: - -/* Line 1806 of yacc.c */ -#line 583 "parser.yy" + case 102: + +/* Line 1806 of yacc.c */ +#line 592 "parser.yy" { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); } break; - case 100: - -/* Line 1806 of yacc.c */ -#line 586 "parser.yy" + case 103: + +/* Line 1806 of yacc.c */ +#line 595 "parser.yy" { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); } break; - case 101: - -/* Line 1806 of yacc.c */ -#line 588 "parser.yy" + case 104: + +/* Line 1806 of yacc.c */ +#line 597 "parser.yy" { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); } break; - case 104: - -/* Line 1806 of yacc.c */ -#line 599 "parser.yy" + case 107: + +/* Line 1806 of yacc.c */ +#line 608 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 105: - -/* Line 1806 of yacc.c */ -#line 601 "parser.yy" + case 108: + +/* Line 1806 of yacc.c */ +#line 610 "parser.yy" { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new ExpressionNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); } break; - case 106: - -/* Line 1806 of yacc.c */ -#line 606 "parser.yy" + case 109: + +/* Line 1806 of yacc.c */ +#line 615 "parser.yy" { (yyval.en) = nullptr; } break; - case 108: - -/* Line 1806 of yacc.c */ -#line 611 "parser.yy" + case 111: + +/* Line 1806 of yacc.c */ +#line 620 "parser.yy" { (yyval.op) = OperKinds::Assign; } break; - case 109: - -/* Line 1806 of yacc.c */ -#line 612 "parser.yy" + case 112: + +/* Line 1806 of yacc.c */ +#line 621 "parser.yy" { (yyval.op) = OperKinds::AtAssn; } break; - case 110: - -/* Line 1806 of yacc.c */ -#line 613 "parser.yy" + case 113: + +/* Line 1806 of yacc.c */ +#line 622 "parser.yy" { (yyval.op) = OperKinds::MulAssn; } break; - case 111: - -/* Line 1806 of yacc.c */ -#line 614 "parser.yy" + case 114: + +/* Line 1806 of yacc.c */ +#line 623 "parser.yy" { (yyval.op) = OperKinds::DivAssn; } break; - case 112: - -/* Line 1806 of yacc.c */ -#line 615 "parser.yy" + case 115: + +/* Line 1806 of yacc.c */ +#line 624 "parser.yy" { (yyval.op) = OperKinds::ModAssn; } break; - case 113: - -/* Line 1806 of yacc.c */ -#line 616 "parser.yy" + case 116: + +/* Line 1806 of yacc.c */ +#line 625 "parser.yy" { (yyval.op) = OperKinds::PlusAssn; } break; - case 114: - -/* Line 1806 of yacc.c */ -#line 617 "parser.yy" + case 117: + +/* Line 1806 of yacc.c */ +#line 626 "parser.yy" { (yyval.op) = OperKinds::MinusAssn; } break; - case 115: - -/* Line 1806 of yacc.c */ -#line 618 "parser.yy" + case 118: + +/* Line 1806 of yacc.c */ +#line 627 "parser.yy" { (yyval.op) = OperKinds::LSAssn; } break; - case 116: - -/* Line 1806 of yacc.c */ -#line 619 "parser.yy" + case 119: + +/* Line 1806 of yacc.c */ +#line 628 "parser.yy" { (yyval.op) = OperKinds::RSAssn; } break; - case 117: - -/* Line 1806 of yacc.c */ -#line 620 "parser.yy" + case 120: + +/* Line 1806 of yacc.c */ +#line 629 "parser.yy" { (yyval.op) = OperKinds::AndAssn; } break; - case 118: - -/* Line 1806 of yacc.c */ -#line 621 "parser.yy" + case 121: + +/* Line 1806 of yacc.c */ +#line 630 "parser.yy" { (yyval.op) = OperKinds::ERAssn; } break; - case 119: - -/* Line 1806 of yacc.c */ -#line 622 "parser.yy" + case 122: + +/* Line 1806 of yacc.c */ +#line 631 "parser.yy" { (yyval.op) = OperKinds::OrAssn; } break; - case 120: - -/* Line 1806 of yacc.c */ -#line 629 "parser.yy" + case 123: + +/* Line 1806 of yacc.c */ +#line 638 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple() ); } break; - case 121: - -/* Line 1806 of yacc.c */ -#line 631 "parser.yy" + case 124: + +/* Line 1806 of yacc.c */ +#line 640 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); } break; - case 122: - -/* Line 1806 of yacc.c */ -#line 633 "parser.yy" + case 125: + +/* Line 1806 of yacc.c */ +#line 642 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); } break; - case 123: - -/* Line 1806 of yacc.c */ -#line 635 "parser.yy" + case 126: + +/* Line 1806 of yacc.c */ +#line 644 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); } break; - case 125: - -/* Line 1806 of yacc.c */ -#line 641 "parser.yy" + case 128: + +/* Line 1806 of yacc.c */ +#line 650 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } break; - case 127: - -/* Line 1806 of yacc.c */ -#line 647 "parser.yy" + case 130: + +/* Line 1806 of yacc.c */ +#line 656 "parser.yy" { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 128: - -/* Line 1806 of yacc.c */ -#line 652 "parser.yy" + case 131: + +/* Line 1806 of yacc.c */ +#line 661 "parser.yy" { (yyval.en) = 0; } break; - case 132: - -/* Line 1806 of yacc.c */ -#line 661 "parser.yy" + case 135: + +/* Line 1806 of yacc.c */ +#line 670 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (1)].sn); } break; - case 138: - -/* Line 1806 of yacc.c */ -#line 668 "parser.yy" + case 141: + +/* Line 1806 of yacc.c */ +#line 677 "parser.yy" { Token fn; - fn.str = new std::string( "^?{}" ); // location undefined + fn.str = new string( "^?{}" ); // location undefined (yyval.sn) = new StatementNode( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_last( (yyvsp[(4) - (6)].en) ) ) ) ) ); } break; - case 139: - -/* Line 1806 of yacc.c */ -#line 678 "parser.yy" + case 142: + +/* Line 1806 of yacc.c */ +#line 687 "parser.yy" { (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) ); @@ -5686,36 +5699,36 @@ break; - case 140: - -/* Line 1806 of yacc.c */ -#line 685 "parser.yy" + case 143: + +/* Line 1806 of yacc.c */ +#line 694 "parser.yy" { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); } break; - case 141: - -/* Line 1806 of yacc.c */ -#line 692 "parser.yy" + case 144: + +/* Line 1806 of yacc.c */ +#line 701 "parser.yy" { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); } break; - case 143: - -/* Line 1806 of yacc.c */ -#line 698 "parser.yy" + case 146: + +/* Line 1806 of yacc.c */ +#line 707 "parser.yy" { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } } break; - case 144: - -/* Line 1806 of yacc.c */ -#line 703 "parser.yy" + case 147: + +/* Line 1806 of yacc.c */ +#line 712 "parser.yy" { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } break; - case 145: - -/* Line 1806 of yacc.c */ -#line 705 "parser.yy" + case 148: + +/* Line 1806 of yacc.c */ +#line 714 "parser.yy" { // mark all fields in list for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) @@ -5725,50 +5738,50 @@ break; - case 146: - -/* Line 1806 of yacc.c */ -#line 711 "parser.yy" + case 149: + +/* Line 1806 of yacc.c */ +#line 720 "parser.yy" { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } break; - case 149: - -/* Line 1806 of yacc.c */ -#line 718 "parser.yy" + case 152: + +/* Line 1806 of yacc.c */ +#line 727 "parser.yy" { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } } break; - case 150: - -/* Line 1806 of yacc.c */ -#line 723 "parser.yy" + case 153: + +/* Line 1806 of yacc.c */ +#line 732 "parser.yy" { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); } break; - case 151: - -/* Line 1806 of yacc.c */ -#line 729 "parser.yy" + case 154: + +/* Line 1806 of yacc.c */ +#line 738 "parser.yy" { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); } break; - case 152: - -/* Line 1806 of yacc.c */ -#line 731 "parser.yy" + case 155: + +/* Line 1806 of yacc.c */ +#line 740 "parser.yy" { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); } break; - case 153: - -/* Line 1806 of yacc.c */ -#line 733 "parser.yy" + case 156: + +/* Line 1806 of yacc.c */ +#line 742 "parser.yy" { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } break; - case 154: - -/* Line 1806 of yacc.c */ -#line 735 "parser.yy" + case 157: + +/* Line 1806 of yacc.c */ +#line 744 "parser.yy" { StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) ); @@ -5782,15 +5795,15 @@ break; - case 155: - -/* Line 1806 of yacc.c */ -#line 745 "parser.yy" + case 158: + +/* Line 1806 of yacc.c */ +#line 754 "parser.yy" { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } break; - case 156: - -/* Line 1806 of yacc.c */ -#line 747 "parser.yy" + case 159: + +/* Line 1806 of yacc.c */ +#line 756 "parser.yy" { StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) ); @@ -5799,323 +5812,323 @@ break; - case 157: - -/* Line 1806 of yacc.c */ -#line 757 "parser.yy" + case 160: + +/* Line 1806 of yacc.c */ +#line 766 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; - case 158: - -/* Line 1806 of yacc.c */ -#line 759 "parser.yy" + case 161: + +/* Line 1806 of yacc.c */ +#line 768 "parser.yy" { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 160: - -/* Line 1806 of yacc.c */ -#line 764 "parser.yy" + case 163: + +/* Line 1806 of yacc.c */ +#line 773 "parser.yy" { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); } break; - case 161: - -/* Line 1806 of yacc.c */ -#line 766 "parser.yy" + case 164: + +/* Line 1806 of yacc.c */ +#line 775 "parser.yy" { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); } break; - case 162: - -/* Line 1806 of yacc.c */ -#line 770 "parser.yy" + case 165: + +/* Line 1806 of yacc.c */ +#line 779 "parser.yy" { (yyval.sn) = (yyvsp[(2) - (3)].sn); } break; - case 163: - -/* Line 1806 of yacc.c */ -#line 771 "parser.yy" + case 166: + +/* Line 1806 of yacc.c */ +#line 780 "parser.yy" { (yyval.sn) = new StatementNode( build_default() ); } break; - case 165: - -/* Line 1806 of yacc.c */ -#line 777 "parser.yy" + case 168: + +/* Line 1806 of yacc.c */ +#line 786 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); } break; - case 166: - -/* Line 1806 of yacc.c */ -#line 781 "parser.yy" + case 169: + +/* Line 1806 of yacc.c */ +#line 790 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); } break; - case 167: - -/* Line 1806 of yacc.c */ -#line 786 "parser.yy" + case 170: + +/* Line 1806 of yacc.c */ +#line 795 "parser.yy" { (yyval.sn) = 0; } break; - case 169: - -/* Line 1806 of yacc.c */ -#line 792 "parser.yy" + case 172: + +/* Line 1806 of yacc.c */ +#line 801 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); } break; - case 170: - -/* Line 1806 of yacc.c */ -#line 794 "parser.yy" + case 173: + +/* Line 1806 of yacc.c */ +#line 803 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); } break; - case 171: - -/* Line 1806 of yacc.c */ -#line 799 "parser.yy" + case 174: + +/* Line 1806 of yacc.c */ +#line 808 "parser.yy" { (yyval.sn) = 0; } break; - case 173: - -/* Line 1806 of yacc.c */ -#line 805 "parser.yy" + case 176: + +/* Line 1806 of yacc.c */ +#line 814 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); } break; - case 174: - -/* Line 1806 of yacc.c */ -#line 807 "parser.yy" + case 177: + +/* Line 1806 of yacc.c */ +#line 816 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); } break; - case 175: - -/* Line 1806 of yacc.c */ -#line 809 "parser.yy" + case 178: + +/* Line 1806 of yacc.c */ +#line 818 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); } break; - case 176: - -/* Line 1806 of yacc.c */ -#line 811 "parser.yy" + case 179: + +/* Line 1806 of yacc.c */ +#line 820 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); } break; - case 177: - -/* Line 1806 of yacc.c */ -#line 816 "parser.yy" + case 180: + +/* Line 1806 of yacc.c */ +#line 825 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); } break; - case 179: - -/* Line 1806 of yacc.c */ -#line 822 "parser.yy" + case 182: + +/* Line 1806 of yacc.c */ +#line 831 "parser.yy" { (yyval.sn) = 0; } break; - case 180: - -/* Line 1806 of yacc.c */ -#line 824 "parser.yy" + case 183: + +/* Line 1806 of yacc.c */ +#line 833 "parser.yy" { (yyval.sn) = 0; } break; - case 181: - -/* Line 1806 of yacc.c */ -#line 829 "parser.yy" + case 184: + +/* Line 1806 of yacc.c */ +#line 838 "parser.yy" { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } break; - case 182: - -/* Line 1806 of yacc.c */ -#line 831 "parser.yy" + case 185: + +/* Line 1806 of yacc.c */ +#line 840 "parser.yy" { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); } break; - case 183: - -/* Line 1806 of yacc.c */ -#line 833 "parser.yy" + case 186: + +/* Line 1806 of yacc.c */ +#line 842 "parser.yy" { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); } break; - case 184: - -/* Line 1806 of yacc.c */ -#line 838 "parser.yy" + case 187: + +/* Line 1806 of yacc.c */ +#line 847 "parser.yy" { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); } break; - case 185: - -/* Line 1806 of yacc.c */ -#line 840 "parser.yy" + case 188: + +/* Line 1806 of yacc.c */ +#line 849 "parser.yy" { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); } break; - case 186: - -/* Line 1806 of yacc.c */ -#line 845 "parser.yy" + case 189: + +/* Line 1806 of yacc.c */ +#line 854 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); } break; - case 187: - -/* Line 1806 of yacc.c */ -#line 849 "parser.yy" + case 190: + +/* Line 1806 of yacc.c */ +#line 858 "parser.yy" { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); } break; - case 188: - -/* Line 1806 of yacc.c */ -#line 852 "parser.yy" + case 191: + +/* Line 1806 of yacc.c */ +#line 861 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); } break; - case 189: - -/* Line 1806 of yacc.c */ -#line 856 "parser.yy" + case 192: + +/* Line 1806 of yacc.c */ +#line 865 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); } break; - case 190: - -/* Line 1806 of yacc.c */ -#line 859 "parser.yy" + case 193: + +/* Line 1806 of yacc.c */ +#line 868 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); } break; - case 191: - -/* Line 1806 of yacc.c */ -#line 863 "parser.yy" + case 194: + +/* Line 1806 of yacc.c */ +#line 872 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); } break; - case 192: - -/* Line 1806 of yacc.c */ -#line 865 "parser.yy" + case 195: + +/* Line 1806 of yacc.c */ +#line 874 "parser.yy" { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); } break; - case 193: - -/* Line 1806 of yacc.c */ -#line 867 "parser.yy" + case 196: + +/* Line 1806 of yacc.c */ +#line 876 "parser.yy" { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); } break; - case 194: - -/* Line 1806 of yacc.c */ -#line 869 "parser.yy" + case 197: + +/* Line 1806 of yacc.c */ +#line 878 "parser.yy" { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); } break; - case 195: - -/* Line 1806 of yacc.c */ -#line 871 "parser.yy" + case 198: + +/* Line 1806 of yacc.c */ +#line 880 "parser.yy" { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); } break; - case 196: - -/* Line 1806 of yacc.c */ -#line 876 "parser.yy" + case 199: + +/* Line 1806 of yacc.c */ +#line 885 "parser.yy" { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); } break; - case 197: - -/* Line 1806 of yacc.c */ -#line 878 "parser.yy" + case 200: + +/* Line 1806 of yacc.c */ +#line 887 "parser.yy" { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); } break; - case 198: - -/* Line 1806 of yacc.c */ -#line 880 "parser.yy" + case 201: + +/* Line 1806 of yacc.c */ +#line 889 "parser.yy" { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); } break; - case 200: - -/* Line 1806 of yacc.c */ -#line 887 "parser.yy" + case 203: + +/* Line 1806 of yacc.c */ +#line 896 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); } break; - case 201: - -/* Line 1806 of yacc.c */ -#line 889 "parser.yy" + case 204: + +/* Line 1806 of yacc.c */ +#line 898 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); } break; - case 202: - -/* Line 1806 of yacc.c */ -#line 891 "parser.yy" + case 205: + +/* Line 1806 of yacc.c */ +#line 900 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); } break; - case 203: - -/* Line 1806 of yacc.c */ -#line 893 "parser.yy" + case 206: + +/* Line 1806 of yacc.c */ +#line 902 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); } break; - case 204: - -/* Line 1806 of yacc.c */ -#line 898 "parser.yy" + case 207: + +/* Line 1806 of yacc.c */ +#line 907 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); } break; - case 205: - -/* Line 1806 of yacc.c */ -#line 900 "parser.yy" + case 208: + +/* Line 1806 of yacc.c */ +#line 909 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); } break; - case 206: - -/* Line 1806 of yacc.c */ -#line 902 "parser.yy" + case 209: + +/* Line 1806 of yacc.c */ +#line 911 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); } break; - case 207: - -/* Line 1806 of yacc.c */ -#line 904 "parser.yy" + case 210: + +/* Line 1806 of yacc.c */ +#line 913 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); } break; - case 208: - -/* Line 1806 of yacc.c */ -#line 909 "parser.yy" + case 211: + +/* Line 1806 of yacc.c */ +#line 918 "parser.yy" { (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) ); @@ -6123,8 +6136,8 @@ break; - case 210: - -/* Line 1806 of yacc.c */ -#line 922 "parser.yy" + case 213: + +/* Line 1806 of yacc.c */ +#line 931 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6133,15 +6146,15 @@ break; - case 211: - -/* Line 1806 of yacc.c */ -#line 927 "parser.yy" + case 214: + +/* Line 1806 of yacc.c */ +#line 936 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 212: - -/* Line 1806 of yacc.c */ -#line 929 "parser.yy" + case 215: + +/* Line 1806 of yacc.c */ +#line 938 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6150,106 +6163,106 @@ break; - case 214: - -/* Line 1806 of yacc.c */ -#line 938 "parser.yy" + case 217: + +/* Line 1806 of yacc.c */ +#line 947 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); } break; - case 215: - -/* Line 1806 of yacc.c */ -#line 940 "parser.yy" + case 218: + +/* Line 1806 of yacc.c */ +#line 949 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); } break; - case 216: - -/* Line 1806 of yacc.c */ -#line 942 "parser.yy" + case 219: + +/* Line 1806 of yacc.c */ +#line 951 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); } break; - case 217: - -/* Line 1806 of yacc.c */ -#line 944 "parser.yy" + case 220: + +/* Line 1806 of yacc.c */ +#line 953 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); } break; - case 218: - -/* Line 1806 of yacc.c */ -#line 946 "parser.yy" + case 221: + +/* Line 1806 of yacc.c */ +#line 955 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ) ); } break; - case 219: - -/* Line 1806 of yacc.c */ -#line 951 "parser.yy" + case 222: + +/* Line 1806 of yacc.c */ +#line 960 "parser.yy" { (yyval.flag) = false; } break; - case 220: - -/* Line 1806 of yacc.c */ -#line 953 "parser.yy" + case 223: + +/* Line 1806 of yacc.c */ +#line 962 "parser.yy" { (yyval.flag) = true; } break; - case 221: - -/* Line 1806 of yacc.c */ -#line 958 "parser.yy" + case 224: + +/* Line 1806 of yacc.c */ +#line 967 "parser.yy" { (yyval.en) = 0; } break; - case 224: - -/* Line 1806 of yacc.c */ -#line 965 "parser.yy" + case 227: + +/* Line 1806 of yacc.c */ +#line 974 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } break; - case 225: - -/* Line 1806 of yacc.c */ -#line 970 "parser.yy" + case 228: + +/* Line 1806 of yacc.c */ +#line 979 "parser.yy" { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); } break; - case 226: - -/* Line 1806 of yacc.c */ -#line 972 "parser.yy" + case 229: + +/* Line 1806 of yacc.c */ +#line 981 "parser.yy" { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); } break; - case 227: - -/* Line 1806 of yacc.c */ -#line 977 "parser.yy" + case 230: + +/* Line 1806 of yacc.c */ +#line 986 "parser.yy" { (yyval.en) = 0; } break; - case 228: - -/* Line 1806 of yacc.c */ -#line 979 "parser.yy" + case 231: + +/* Line 1806 of yacc.c */ +#line 988 "parser.yy" { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); } break; - case 229: - -/* Line 1806 of yacc.c */ -#line 981 "parser.yy" + case 232: + +/* Line 1806 of yacc.c */ +#line 990 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); } break; - case 230: - -/* Line 1806 of yacc.c */ -#line 986 "parser.yy" + case 233: + +/* Line 1806 of yacc.c */ +#line 995 "parser.yy" { (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) ); @@ -6258,8 +6271,8 @@ break; - case 231: - -/* Line 1806 of yacc.c */ -#line 991 "parser.yy" + case 234: + +/* Line 1806 of yacc.c */ +#line 1000 "parser.yy" { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) ); @@ -6268,50 +6281,50 @@ break; - case 232: - -/* Line 1806 of yacc.c */ -#line 1001 "parser.yy" + case 235: + +/* Line 1806 of yacc.c */ +#line 1010 "parser.yy" { (yyval.decl) = 0; } break; - case 235: - -/* Line 1806 of yacc.c */ -#line 1008 "parser.yy" + case 238: + +/* Line 1806 of yacc.c */ +#line 1017 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; - case 236: - -/* Line 1806 of yacc.c */ -#line 1013 "parser.yy" + case 239: + +/* Line 1806 of yacc.c */ +#line 1022 "parser.yy" { (yyval.decl) = 0; } break; - case 239: - -/* Line 1806 of yacc.c */ -#line 1020 "parser.yy" + case 242: + +/* Line 1806 of yacc.c */ +#line 1029 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; - case 244: - -/* Line 1806 of yacc.c */ -#line 1034 "parser.yy" + case 247: + +/* Line 1806 of yacc.c */ +#line 1043 "parser.yy" {} break; - case 245: - -/* Line 1806 of yacc.c */ -#line 1035 "parser.yy" + case 248: + +/* Line 1806 of yacc.c */ +#line 1044 "parser.yy" {} break; - case 253: - -/* Line 1806 of yacc.c */ -#line 1064 "parser.yy" + case 256: + +/* Line 1806 of yacc.c */ +#line 1073 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6320,8 +6333,8 @@ break; - case 254: - -/* Line 1806 of yacc.c */ -#line 1071 "parser.yy" + case 257: + +/* Line 1806 of yacc.c */ +#line 1080 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6330,8 +6343,8 @@ break; - case 255: - -/* Line 1806 of yacc.c */ -#line 1076 "parser.yy" + case 258: + +/* Line 1806 of yacc.c */ +#line 1085 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID ); @@ -6340,8 +6353,8 @@ break; - case 256: - -/* Line 1806 of yacc.c */ -#line 1086 "parser.yy" + case 259: + +/* Line 1806 of yacc.c */ +#line 1095 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); @@ -6350,8 +6363,8 @@ break; - case 257: - -/* Line 1806 of yacc.c */ -#line 1091 "parser.yy" + case 260: + +/* Line 1806 of yacc.c */ +#line 1100 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); @@ -6360,8 +6373,8 @@ break; - case 258: - -/* Line 1806 of yacc.c */ -#line 1096 "parser.yy" + case 261: + +/* Line 1806 of yacc.c */ +#line 1105 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) ); @@ -6370,8 +6383,8 @@ break; - case 259: - -/* Line 1806 of yacc.c */ -#line 1104 "parser.yy" + case 262: + +/* Line 1806 of yacc.c */ +#line 1113 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6380,8 +6393,8 @@ break; - case 260: - -/* Line 1806 of yacc.c */ -#line 1109 "parser.yy" + case 263: + +/* Line 1806 of yacc.c */ +#line 1118 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6390,8 +6403,8 @@ break; - case 261: - -/* Line 1806 of yacc.c */ -#line 1114 "parser.yy" + case 264: + +/* Line 1806 of yacc.c */ +#line 1123 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6400,8 +6413,8 @@ break; - case 262: - -/* Line 1806 of yacc.c */ -#line 1119 "parser.yy" + case 265: + +/* Line 1806 of yacc.c */ +#line 1128 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6410,8 +6423,8 @@ break; - case 263: - -/* Line 1806 of yacc.c */ -#line 1124 "parser.yy" + case 266: + +/* Line 1806 of yacc.c */ +#line 1133 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID ); @@ -6420,8 +6433,8 @@ break; - case 264: - -/* Line 1806 of yacc.c */ -#line 1132 "parser.yy" + case 267: + +/* Line 1806 of yacc.c */ +#line 1141 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true ); @@ -6429,8 +6442,8 @@ break; - case 265: - -/* Line 1806 of yacc.c */ -#line 1155 "parser.yy" + case 268: + +/* Line 1806 of yacc.c */ +#line 1164 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); @@ -6438,8 +6451,8 @@ break; - case 266: - -/* Line 1806 of yacc.c */ -#line 1159 "parser.yy" + case 269: + +/* Line 1806 of yacc.c */ +#line 1168 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); @@ -6447,22 +6460,22 @@ break; - case 267: - -/* Line 1806 of yacc.c */ -#line 1166 "parser.yy" + case 270: + +/* Line 1806 of yacc.c */ +#line 1175 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } break; - case 268: - -/* Line 1806 of yacc.c */ -#line 1170 "parser.yy" + case 271: + +/* Line 1806 of yacc.c */ +#line 1179 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); } break; - case 269: - -/* Line 1806 of yacc.c */ -#line 1175 "parser.yy" + case 272: + +/* Line 1806 of yacc.c */ +#line 1184 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6471,8 +6484,8 @@ break; - case 270: - -/* Line 1806 of yacc.c */ -#line 1180 "parser.yy" + case 273: + +/* Line 1806 of yacc.c */ +#line 1189 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6481,8 +6494,8 @@ break; - case 271: - -/* Line 1806 of yacc.c */ -#line 1185 "parser.yy" + case 274: + +/* Line 1806 of yacc.c */ +#line 1194 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD ); @@ -6491,8 +6504,8 @@ break; - case 272: - -/* Line 1806 of yacc.c */ -#line 1196 "parser.yy" + case 275: + +/* Line 1806 of yacc.c */ +#line 1205 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6501,8 +6514,8 @@ break; - case 273: - -/* Line 1806 of yacc.c */ -#line 1201 "parser.yy" + case 276: + +/* Line 1806 of yacc.c */ +#line 1210 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6511,8 +6524,8 @@ break; - case 274: - -/* Line 1806 of yacc.c */ -#line 1206 "parser.yy" + case 277: + +/* Line 1806 of yacc.c */ +#line 1215 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6521,8 +6534,8 @@ break; - case 275: - -/* Line 1806 of yacc.c */ -#line 1211 "parser.yy" + case 278: + +/* Line 1806 of yacc.c */ +#line 1220 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6531,8 +6544,8 @@ break; - case 276: - -/* Line 1806 of yacc.c */ -#line 1216 "parser.yy" + case 279: + +/* Line 1806 of yacc.c */ +#line 1225 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6541,8 +6554,8 @@ break; - case 277: - -/* Line 1806 of yacc.c */ -#line 1225 "parser.yy" + case 280: + +/* Line 1806 of yacc.c */ +#line 1234 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD ); @@ -6551,8 +6564,8 @@ break; - case 278: - -/* Line 1806 of yacc.c */ -#line 1230 "parser.yy" + case 281: + +/* Line 1806 of yacc.c */ +#line 1239 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD ); @@ -6561,8 +6574,8 @@ break; - case 283: - -/* Line 1806 of yacc.c */ -#line 1247 "parser.yy" + case 286: + +/* Line 1806 of yacc.c */ +#line 1256 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6571,8 +6584,8 @@ break; - case 284: - -/* Line 1806 of yacc.c */ -#line 1252 "parser.yy" + case 287: + +/* Line 1806 of yacc.c */ +#line 1261 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6581,57 +6594,57 @@ break; - case 293: - -/* Line 1806 of yacc.c */ -#line 1274 "parser.yy" + case 296: + +/* Line 1806 of yacc.c */ +#line 1283 "parser.yy" { (yyval.decl) = 0; } break; - case 296: - -/* Line 1806 of yacc.c */ -#line 1286 "parser.yy" + case 299: + +/* Line 1806 of yacc.c */ +#line 1295 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 299: - -/* Line 1806 of yacc.c */ -#line 1297 "parser.yy" + case 302: + +/* Line 1806 of yacc.c */ +#line 1306 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); } break; - case 300: - -/* Line 1806 of yacc.c */ -#line 1299 "parser.yy" + case 303: + +/* Line 1806 of yacc.c */ +#line 1308 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); } break; - case 301: - -/* Line 1806 of yacc.c */ -#line 1301 "parser.yy" + case 304: + +/* Line 1806 of yacc.c */ +#line 1310 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } break; - case 302: - -/* Line 1806 of yacc.c */ -#line 1303 "parser.yy" + case 305: + +/* Line 1806 of yacc.c */ +#line 1312 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } break; - case 303: - -/* Line 1806 of yacc.c */ -#line 1305 "parser.yy" + case 306: + +/* Line 1806 of yacc.c */ +#line 1314 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } break; - case 304: - -/* Line 1806 of yacc.c */ -#line 1307 "parser.yy" + case 307: + +/* Line 1806 of yacc.c */ +#line 1316 "parser.yy" { typedefTable.enterScope(); @@ -6639,8 +6652,8 @@ break; - case 305: - -/* Line 1806 of yacc.c */ -#line 1311 "parser.yy" + case 308: + +/* Line 1806 of yacc.c */ +#line 1320 "parser.yy" { typedefTable.leaveScope(); @@ -6649,417 +6662,417 @@ break; - case 307: - -/* Line 1806 of yacc.c */ -#line 1320 "parser.yy" + case 310: + +/* Line 1806 of yacc.c */ +#line 1329 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 308: - -/* Line 1806 of yacc.c */ -#line 1322 "parser.yy" + case 311: + +/* Line 1806 of yacc.c */ +#line 1331 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 310: - -/* Line 1806 of yacc.c */ -#line 1333 "parser.yy" + case 313: + +/* Line 1806 of yacc.c */ +#line 1342 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 311: - -/* Line 1806 of yacc.c */ -#line 1338 "parser.yy" + case 314: + +/* Line 1806 of yacc.c */ +#line 1347 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } break; - case 312: - -/* Line 1806 of yacc.c */ -#line 1340 "parser.yy" + case 315: + +/* Line 1806 of yacc.c */ +#line 1349 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); } break; - case 313: - -/* Line 1806 of yacc.c */ -#line 1342 "parser.yy" + case 316: + +/* Line 1806 of yacc.c */ +#line 1351 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); } break; - case 314: - -/* Line 1806 of yacc.c */ -#line 1344 "parser.yy" + case 317: + +/* Line 1806 of yacc.c */ +#line 1353 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); } break; - case 315: - -/* Line 1806 of yacc.c */ -#line 1347 "parser.yy" + case 318: + +/* Line 1806 of yacc.c */ +#line 1356 "parser.yy" { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; } break; - case 316: - -/* Line 1806 of yacc.c */ -#line 1349 "parser.yy" + case 319: + +/* Line 1806 of yacc.c */ +#line 1358 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } break; - case 317: - -/* Line 1806 of yacc.c */ -#line 1352 "parser.yy" + case 320: + +/* Line 1806 of yacc.c */ +#line 1361 "parser.yy" { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; } break; - case 318: - -/* Line 1806 of yacc.c */ -#line 1354 "parser.yy" + case 321: + +/* Line 1806 of yacc.c */ +#line 1363 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); } break; - case 319: - -/* Line 1806 of yacc.c */ -#line 1359 "parser.yy" + case 322: + +/* Line 1806 of yacc.c */ +#line 1368 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); } break; - case 320: - -/* Line 1806 of yacc.c */ -#line 1361 "parser.yy" + case 323: + +/* Line 1806 of yacc.c */ +#line 1370 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); } break; - case 321: - -/* Line 1806 of yacc.c */ -#line 1363 "parser.yy" + case 324: + +/* Line 1806 of yacc.c */ +#line 1372 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); } break; - case 322: - -/* Line 1806 of yacc.c */ -#line 1365 "parser.yy" + case 325: + +/* Line 1806 of yacc.c */ +#line 1374 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); } break; - case 323: - -/* Line 1806 of yacc.c */ -#line 1367 "parser.yy" + case 326: + +/* Line 1806 of yacc.c */ +#line 1376 "parser.yy" { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); } break; - case 324: - -/* Line 1806 of yacc.c */ -#line 1369 "parser.yy" + case 327: + +/* Line 1806 of yacc.c */ +#line 1378 "parser.yy" { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); } break; - case 325: - -/* Line 1806 of yacc.c */ -#line 1371 "parser.yy" + case 328: + +/* Line 1806 of yacc.c */ +#line 1380 "parser.yy" { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); } break; - case 326: - -/* Line 1806 of yacc.c */ -#line 1373 "parser.yy" + case 329: + +/* Line 1806 of yacc.c */ +#line 1382 "parser.yy" { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); } break; - case 327: - -/* Line 1806 of yacc.c */ -#line 1375 "parser.yy" + case 330: + +/* Line 1806 of yacc.c */ +#line 1384 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); } break; - case 328: - -/* Line 1806 of yacc.c */ -#line 1377 "parser.yy" + case 331: + +/* Line 1806 of yacc.c */ +#line 1386 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); } break; - case 329: - -/* Line 1806 of yacc.c */ -#line 1379 "parser.yy" + case 332: + +/* Line 1806 of yacc.c */ +#line 1388 "parser.yy" { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); } break; - case 330: - -/* Line 1806 of yacc.c */ -#line 1381 "parser.yy" + case 333: + +/* Line 1806 of yacc.c */ +#line 1390 "parser.yy" { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } break; - case 331: - -/* Line 1806 of yacc.c */ -#line 1383 "parser.yy" + case 334: + +/* Line 1806 of yacc.c */ +#line 1392 "parser.yy" { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); } break; - case 333: - -/* Line 1806 of yacc.c */ -#line 1390 "parser.yy" + case 336: + +/* Line 1806 of yacc.c */ +#line 1399 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 334: - -/* Line 1806 of yacc.c */ -#line 1392 "parser.yy" + case 337: + +/* Line 1806 of yacc.c */ +#line 1401 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 335: - -/* Line 1806 of yacc.c */ -#line 1394 "parser.yy" + case 338: + +/* Line 1806 of yacc.c */ +#line 1403 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 336: - -/* Line 1806 of yacc.c */ -#line 1396 "parser.yy" + case 339: + +/* Line 1806 of yacc.c */ +#line 1405 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); } break; - case 338: - -/* Line 1806 of yacc.c */ -#line 1402 "parser.yy" + case 341: + +/* Line 1806 of yacc.c */ +#line 1411 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 340: - -/* Line 1806 of yacc.c */ -#line 1409 "parser.yy" + case 343: + +/* Line 1806 of yacc.c */ +#line 1418 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 341: - -/* Line 1806 of yacc.c */ -#line 1411 "parser.yy" + case 344: + +/* Line 1806 of yacc.c */ +#line 1420 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 342: - -/* Line 1806 of yacc.c */ -#line 1413 "parser.yy" + case 345: + +/* Line 1806 of yacc.c */ +#line 1422 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); } break; - case 343: - -/* Line 1806 of yacc.c */ -#line 1418 "parser.yy" + case 346: + +/* Line 1806 of yacc.c */ +#line 1427 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (4)].decl); } break; - case 344: - -/* Line 1806 of yacc.c */ -#line 1420 "parser.yy" + case 347: + +/* Line 1806 of yacc.c */ +#line 1429 "parser.yy" { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); } break; - case 345: - -/* Line 1806 of yacc.c */ -#line 1422 "parser.yy" + case 348: + +/* Line 1806 of yacc.c */ +#line 1431 "parser.yy" { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); } break; - case 346: - -/* Line 1806 of yacc.c */ -#line 1424 "parser.yy" + case 349: + +/* Line 1806 of yacc.c */ +#line 1433 "parser.yy" { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } break; - case 348: - -/* Line 1806 of yacc.c */ -#line 1430 "parser.yy" + case 351: + +/* Line 1806 of yacc.c */ +#line 1439 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 349: - -/* Line 1806 of yacc.c */ -#line 1432 "parser.yy" + case 352: + +/* Line 1806 of yacc.c */ +#line 1441 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 350: - -/* Line 1806 of yacc.c */ -#line 1434 "parser.yy" + case 353: + +/* Line 1806 of yacc.c */ +#line 1443 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 352: - -/* Line 1806 of yacc.c */ -#line 1440 "parser.yy" + case 355: + +/* Line 1806 of yacc.c */ +#line 1449 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 353: - -/* Line 1806 of yacc.c */ -#line 1442 "parser.yy" + case 356: + +/* Line 1806 of yacc.c */ +#line 1451 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 355: - -/* Line 1806 of yacc.c */ -#line 1448 "parser.yy" + case 358: + +/* Line 1806 of yacc.c */ +#line 1457 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 356: - -/* Line 1806 of yacc.c */ -#line 1450 "parser.yy" + case 359: + +/* Line 1806 of yacc.c */ +#line 1459 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 357: - -/* Line 1806 of yacc.c */ -#line 1452 "parser.yy" + case 360: + +/* Line 1806 of yacc.c */ +#line 1461 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 358: - -/* Line 1806 of yacc.c */ -#line 1457 "parser.yy" + case 361: + +/* Line 1806 of yacc.c */ +#line 1466 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); } break; - case 359: - -/* Line 1806 of yacc.c */ -#line 1459 "parser.yy" + case 362: + +/* Line 1806 of yacc.c */ +#line 1468 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 360: - -/* Line 1806 of yacc.c */ -#line 1461 "parser.yy" + case 363: + +/* Line 1806 of yacc.c */ +#line 1470 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 363: - -/* Line 1806 of yacc.c */ -#line 1471 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); } - break; - - case 364: - -/* Line 1806 of yacc.c */ -#line 1473 "parser.yy" + case 366: + +/* Line 1806 of yacc.c */ +#line 1480 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), nullptr, nullptr, (yyvsp[(3) - (4)].decl), true ); } + break; + + case 367: + +/* Line 1806 of yacc.c */ +#line 1482 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); - (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), 0, 0, false ); + (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), nullptr, nullptr, false ); } break; - case 365: - -/* Line 1806 of yacc.c */ -#line 1478 "parser.yy" + case 368: + +/* Line 1806 of yacc.c */ +#line 1487 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); } break; - case 366: - -/* Line 1806 of yacc.c */ -#line 1480 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); } - break; - - case 367: - -/* Line 1806 of yacc.c */ -#line 1482 "parser.yy" - { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); } - break; - - case 368: - -/* Line 1806 of yacc.c */ -#line 1484 "parser.yy" + case 369: + +/* Line 1806 of yacc.c */ +#line 1489 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); } + break; + + case 370: + +/* Line 1806 of yacc.c */ +#line 1491 "parser.yy" + { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); } + break; + + case 371: + +/* Line 1806 of yacc.c */ +#line 1493 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl); } break; - case 369: - -/* Line 1806 of yacc.c */ -#line 1489 "parser.yy" + case 372: + +/* Line 1806 of yacc.c */ +#line 1498 "parser.yy" { (yyval.aggKey) = DeclarationNode::Struct; } break; - case 370: - -/* Line 1806 of yacc.c */ -#line 1491 "parser.yy" + case 373: + +/* Line 1806 of yacc.c */ +#line 1500 "parser.yy" { (yyval.aggKey) = DeclarationNode::Union; } break; - case 371: - -/* Line 1806 of yacc.c */ -#line 1496 "parser.yy" + case 374: + +/* Line 1806 of yacc.c */ +#line 1505 "parser.yy" { (yyval.decl) = 0; } break; - case 372: - -/* Line 1806 of yacc.c */ -#line 1498 "parser.yy" + case 375: + +/* Line 1806 of yacc.c */ +#line 1507 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); } break; - case 374: - -/* Line 1806 of yacc.c */ -#line 1504 "parser.yy" + case 377: + +/* Line 1806 of yacc.c */ +#line 1513 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); } break; - case 376: - -/* Line 1806 of yacc.c */ -#line 1507 "parser.yy" + case 379: + +/* Line 1806 of yacc.c */ +#line 1516 "parser.yy" { // mark all fields in list for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) @@ -7069,99 +7082,99 @@ break; - case 378: - -/* Line 1806 of yacc.c */ -#line 1517 "parser.yy" + case 381: + +/* Line 1806 of yacc.c */ +#line 1526 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); } break; - case 379: - -/* Line 1806 of yacc.c */ -#line 1519 "parser.yy" + case 382: + +/* Line 1806 of yacc.c */ +#line 1528 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); } break; - case 380: - -/* Line 1806 of yacc.c */ -#line 1521 "parser.yy" + case 383: + +/* Line 1806 of yacc.c */ +#line 1530 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); } break; - case 381: - -/* Line 1806 of yacc.c */ -#line 1526 "parser.yy" + case 384: + +/* Line 1806 of yacc.c */ +#line 1535 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 382: - -/* Line 1806 of yacc.c */ -#line 1528 "parser.yy" + case 385: + +/* Line 1806 of yacc.c */ +#line 1537 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); } break; - case 383: - -/* Line 1806 of yacc.c */ -#line 1533 "parser.yy" + case 386: + +/* Line 1806 of yacc.c */ +#line 1542 "parser.yy" { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ } break; - case 384: - -/* Line 1806 of yacc.c */ -#line 1535 "parser.yy" + case 387: + +/* Line 1806 of yacc.c */ +#line 1544 "parser.yy" { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); } break; - case 385: - -/* Line 1806 of yacc.c */ -#line 1538 "parser.yy" + case 388: + +/* Line 1806 of yacc.c */ +#line 1547 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } break; - case 386: - -/* Line 1806 of yacc.c */ -#line 1541 "parser.yy" + case 389: + +/* Line 1806 of yacc.c */ +#line 1550 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } break; - case 388: - -/* Line 1806 of yacc.c */ -#line 1547 "parser.yy" + case 391: + +/* Line 1806 of yacc.c */ +#line 1556 "parser.yy" { (yyval.en) = 0; } break; - case 389: - -/* Line 1806 of yacc.c */ -#line 1549 "parser.yy" + case 392: + +/* Line 1806 of yacc.c */ +#line 1558 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; - case 390: - -/* Line 1806 of yacc.c */ -#line 1554 "parser.yy" + case 393: + +/* Line 1806 of yacc.c */ +#line 1563 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; - case 392: - -/* Line 1806 of yacc.c */ -#line 1563 "parser.yy" - { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); } - break; - - case 393: - -/* Line 1806 of yacc.c */ -#line 1565 "parser.yy" + case 395: + +/* Line 1806 of yacc.c */ +#line 1572 "parser.yy" + { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); } + break; + + case 396: + +/* Line 1806 of yacc.c */ +#line 1574 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); @@ -7170,162 +7183,162 @@ break; - case 394: - -/* Line 1806 of yacc.c */ -#line 1570 "parser.yy" + case 397: + +/* Line 1806 of yacc.c */ +#line 1579 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); } break; - case 395: - -/* Line 1806 of yacc.c */ -#line 1572 "parser.yy" + case 398: + +/* Line 1806 of yacc.c */ +#line 1581 "parser.yy" { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); } break; - case 396: - -/* Line 1806 of yacc.c */ -#line 1577 "parser.yy" + case 399: + +/* Line 1806 of yacc.c */ +#line 1586 "parser.yy" { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); } break; - case 397: - -/* Line 1806 of yacc.c */ -#line 1579 "parser.yy" + case 400: + +/* Line 1806 of yacc.c */ +#line 1588 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); } break; - case 398: - -/* Line 1806 of yacc.c */ -#line 1584 "parser.yy" + case 401: + +/* Line 1806 of yacc.c */ +#line 1593 "parser.yy" { (yyval.en) = 0; } break; - case 399: - -/* Line 1806 of yacc.c */ -#line 1586 "parser.yy" + case 402: + +/* Line 1806 of yacc.c */ +#line 1595 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; - case 400: - -/* Line 1806 of yacc.c */ -#line 1593 "parser.yy" + case 403: + +/* Line 1806 of yacc.c */ +#line 1602 "parser.yy" { (yyval.decl) = 0; } break; - case 404: - -/* Line 1806 of yacc.c */ -#line 1601 "parser.yy" + case 407: + +/* Line 1806 of yacc.c */ +#line 1610 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 405: - -/* Line 1806 of yacc.c */ -#line 1603 "parser.yy" + case 408: + +/* Line 1806 of yacc.c */ +#line 1612 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; - case 406: - -/* Line 1806 of yacc.c */ -#line 1605 "parser.yy" + case 409: + +/* Line 1806 of yacc.c */ +#line 1614 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; - case 408: - -/* Line 1806 of yacc.c */ -#line 1613 "parser.yy" + case 411: + +/* Line 1806 of yacc.c */ +#line 1622 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 409: - -/* Line 1806 of yacc.c */ -#line 1615 "parser.yy" + case 412: + +/* Line 1806 of yacc.c */ +#line 1624 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 410: - -/* Line 1806 of yacc.c */ -#line 1617 "parser.yy" + case 413: + +/* Line 1806 of yacc.c */ +#line 1626 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); } break; - case 412: - -/* Line 1806 of yacc.c */ -#line 1623 "parser.yy" + case 415: + +/* Line 1806 of yacc.c */ +#line 1632 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 413: - -/* Line 1806 of yacc.c */ -#line 1628 "parser.yy" + case 416: + +/* Line 1806 of yacc.c */ +#line 1637 "parser.yy" { (yyval.decl) = 0; } break; - case 416: - -/* Line 1806 of yacc.c */ -#line 1635 "parser.yy" + case 419: + +/* Line 1806 of yacc.c */ +#line 1644 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; - case 419: - -/* Line 1806 of yacc.c */ -#line 1642 "parser.yy" + case 422: + +/* Line 1806 of yacc.c */ +#line 1651 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 420: - -/* Line 1806 of yacc.c */ -#line 1644 "parser.yy" + case 423: + +/* Line 1806 of yacc.c */ +#line 1653 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; - case 422: - -/* Line 1806 of yacc.c */ -#line 1653 "parser.yy" + case 425: + +/* Line 1806 of yacc.c */ +#line 1662 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } break; - case 423: - -/* Line 1806 of yacc.c */ -#line 1656 "parser.yy" + case 426: + +/* Line 1806 of yacc.c */ +#line 1665 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } break; - case 424: - -/* Line 1806 of yacc.c */ -#line 1658 "parser.yy" + case 427: + +/* Line 1806 of yacc.c */ +#line 1667 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); } break; - case 429: - -/* Line 1806 of yacc.c */ -#line 1668 "parser.yy" + case 432: + +/* Line 1806 of yacc.c */ +#line 1677 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 431: - -/* Line 1806 of yacc.c */ -#line 1674 "parser.yy" + case 434: + +/* Line 1806 of yacc.c */ +#line 1683 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7334,8 +7347,8 @@ break; - case 432: - -/* Line 1806 of yacc.c */ -#line 1679 "parser.yy" + case 435: + +/* Line 1806 of yacc.c */ +#line 1688 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7344,253 +7357,253 @@ break; - case 434: - -/* Line 1806 of yacc.c */ -#line 1688 "parser.yy" + case 437: + +/* Line 1806 of yacc.c */ +#line 1697 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 435: - -/* Line 1806 of yacc.c */ -#line 1697 "parser.yy" + case 438: + +/* Line 1806 of yacc.c */ +#line 1706 "parser.yy" { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); } break; - case 436: - -/* Line 1806 of yacc.c */ -#line 1699 "parser.yy" + case 439: + +/* Line 1806 of yacc.c */ +#line 1708 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); } break; - case 448: - -/* Line 1806 of yacc.c */ -#line 1724 "parser.yy" + case 451: + +/* Line 1806 of yacc.c */ +#line 1733 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 452: - -/* Line 1806 of yacc.c */ -#line 1732 "parser.yy" + case 455: + +/* Line 1806 of yacc.c */ +#line 1741 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; - case 453: - -/* Line 1806 of yacc.c */ -#line 1737 "parser.yy" + case 456: + +/* Line 1806 of yacc.c */ +#line 1746 "parser.yy" { (yyval.in) = 0; } break; - case 454: - -/* Line 1806 of yacc.c */ -#line 1739 "parser.yy" + case 457: + +/* Line 1806 of yacc.c */ +#line 1748 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in); } break; - case 455: - -/* Line 1806 of yacc.c */ -#line 1741 "parser.yy" + case 458: + +/* Line 1806 of yacc.c */ +#line 1750 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); } break; - case 456: - -/* Line 1806 of yacc.c */ -#line 1745 "parser.yy" + case 459: + +/* Line 1806 of yacc.c */ +#line 1754 "parser.yy" { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); } break; - case 457: - -/* Line 1806 of yacc.c */ -#line 1746 "parser.yy" + case 460: + +/* Line 1806 of yacc.c */ +#line 1755 "parser.yy" { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); } break; - case 458: - -/* Line 1806 of yacc.c */ -#line 1751 "parser.yy" + case 461: + +/* Line 1806 of yacc.c */ +#line 1760 "parser.yy" { (yyval.in) = 0; } break; - case 460: - -/* Line 1806 of yacc.c */ -#line 1753 "parser.yy" + case 463: + +/* Line 1806 of yacc.c */ +#line 1762 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); } break; - case 461: - -/* Line 1806 of yacc.c */ -#line 1754 "parser.yy" + case 464: + +/* Line 1806 of yacc.c */ +#line 1763 "parser.yy" { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); } break; - case 462: - -/* Line 1806 of yacc.c */ -#line 1756 "parser.yy" + case 465: + +/* Line 1806 of yacc.c */ +#line 1765 "parser.yy" { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); } break; - case 464: - -/* Line 1806 of yacc.c */ -#line 1772 "parser.yy" + case 467: + +/* Line 1806 of yacc.c */ +#line 1781 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); } break; - case 466: - -/* Line 1806 of yacc.c */ -#line 1778 "parser.yy" + case 469: + +/* Line 1806 of yacc.c */ +#line 1787 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); } break; - case 467: - -/* Line 1806 of yacc.c */ -#line 1784 "parser.yy" + case 470: + +/* Line 1806 of yacc.c */ +#line 1793 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); } break; - case 468: - -/* Line 1806 of yacc.c */ -#line 1787 "parser.yy" + case 471: + +/* Line 1806 of yacc.c */ +#line 1796 "parser.yy" { (yyval.en) = (yyvsp[(3) - (5)].en); } break; - case 469: - -/* Line 1806 of yacc.c */ -#line 1789 "parser.yy" + case 472: + +/* Line 1806 of yacc.c */ +#line 1798 "parser.yy" { (yyval.en) = (yyvsp[(3) - (5)].en); } break; - case 470: - -/* Line 1806 of yacc.c */ -#line 1791 "parser.yy" + case 473: + +/* Line 1806 of yacc.c */ +#line 1800 "parser.yy" { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); } break; - case 471: - -/* Line 1806 of yacc.c */ -#line 1793 "parser.yy" + case 474: + +/* Line 1806 of yacc.c */ +#line 1802 "parser.yy" { (yyval.en) = (yyvsp[(4) - (6)].en); } break; - case 473: - -/* Line 1806 of yacc.c */ -#line 1817 "parser.yy" + case 476: + +/* Line 1806 of yacc.c */ +#line 1826 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 474: - -/* Line 1806 of yacc.c */ -#line 1819 "parser.yy" + case 477: + +/* Line 1806 of yacc.c */ +#line 1828 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 475: - -/* Line 1806 of yacc.c */ -#line 1821 "parser.yy" + case 478: + +/* Line 1806 of yacc.c */ +#line 1830 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; - case 477: - -/* Line 1806 of yacc.c */ -#line 1827 "parser.yy" + case 480: + +/* Line 1806 of yacc.c */ +#line 1836 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 478: - -/* Line 1806 of yacc.c */ -#line 1829 "parser.yy" + case 481: + +/* Line 1806 of yacc.c */ +#line 1838 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 479: - -/* Line 1806 of yacc.c */ -#line 1834 "parser.yy" + case 482: + +/* Line 1806 of yacc.c */ +#line 1843 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } break; - case 481: - -/* Line 1806 of yacc.c */ -#line 1840 "parser.yy" + case 484: + +/* Line 1806 of yacc.c */ +#line 1849 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); } break; - case 482: - -/* Line 1806 of yacc.c */ -#line 1845 "parser.yy" + case 485: + +/* Line 1806 of yacc.c */ +#line 1854 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); } break; - case 483: - -/* Line 1806 of yacc.c */ -#line 1847 "parser.yy" + case 486: + +/* Line 1806 of yacc.c */ +#line 1856 "parser.yy" { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); } break; - case 485: - -/* Line 1806 of yacc.c */ -#line 1853 "parser.yy" + case 488: + +/* Line 1806 of yacc.c */ +#line 1862 "parser.yy" { (yyval.tclass) = DeclarationNode::Otype; } break; - case 486: - -/* Line 1806 of yacc.c */ -#line 1855 "parser.yy" + case 489: + +/* Line 1806 of yacc.c */ +#line 1864 "parser.yy" { (yyval.tclass) = DeclarationNode::Ftype; } break; - case 487: - -/* Line 1806 of yacc.c */ -#line 1857 "parser.yy" + case 490: + +/* Line 1806 of yacc.c */ +#line 1866 "parser.yy" { (yyval.tclass) = DeclarationNode::Dtype; } break; - case 488: - -/* Line 1806 of yacc.c */ -#line 1862 "parser.yy" + case 491: + +/* Line 1806 of yacc.c */ +#line 1871 "parser.yy" { (yyval.decl) = 0; } break; - case 489: - -/* Line 1806 of yacc.c */ -#line 1864 "parser.yy" + case 492: + +/* Line 1806 of yacc.c */ +#line 1873 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); } break; - case 490: - -/* Line 1806 of yacc.c */ -#line 1869 "parser.yy" + case 493: + +/* Line 1806 of yacc.c */ +#line 1878 "parser.yy" { typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) ); @@ -7599,78 +7612,78 @@ break; - case 491: - -/* Line 1806 of yacc.c */ -#line 1874 "parser.yy" + case 494: + +/* Line 1806 of yacc.c */ +#line 1883 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (5)].decl); } break; - case 492: - -/* Line 1806 of yacc.c */ -#line 1876 "parser.yy" + case 495: + +/* Line 1806 of yacc.c */ +#line 1885 "parser.yy" { (yyval.decl) = 0; } break; - case 493: - -/* Line 1806 of yacc.c */ -#line 1881 "parser.yy" + case 496: + +/* Line 1806 of yacc.c */ +#line 1890 "parser.yy" { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); } break; - case 495: - -/* Line 1806 of yacc.c */ -#line 1884 "parser.yy" + case 498: + +/* Line 1806 of yacc.c */ +#line 1893 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); } break; - case 496: - -/* Line 1806 of yacc.c */ -#line 1886 "parser.yy" + case 499: + +/* Line 1806 of yacc.c */ +#line 1895 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); } break; - case 497: - -/* Line 1806 of yacc.c */ -#line 1891 "parser.yy" + case 500: + +/* Line 1806 of yacc.c */ +#line 1900 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl); } break; - case 498: - -/* Line 1806 of yacc.c */ -#line 1893 "parser.yy" + case 501: + +/* Line 1806 of yacc.c */ +#line 1902 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); } break; - case 499: - -/* Line 1806 of yacc.c */ -#line 1895 "parser.yy" + case 502: + +/* Line 1806 of yacc.c */ +#line 1904 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); } break; - case 500: - -/* Line 1806 of yacc.c */ -#line 1900 "parser.yy" + case 503: + +/* Line 1806 of yacc.c */ +#line 1909 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); } break; - case 501: - -/* Line 1806 of yacc.c */ -#line 1902 "parser.yy" + case 504: + +/* Line 1806 of yacc.c */ +#line 1911 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); } break; - case 502: - -/* Line 1806 of yacc.c */ -#line 1907 "parser.yy" + case 505: + +/* Line 1806 of yacc.c */ +#line 1916 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD ); @@ -7679,8 +7692,8 @@ break; - case 503: - -/* Line 1806 of yacc.c */ -#line 1912 "parser.yy" + case 506: + +/* Line 1806 of yacc.c */ +#line 1921 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG ); @@ -7689,8 +7702,8 @@ break; - case 504: - -/* Line 1806 of yacc.c */ -#line 1920 "parser.yy" + case 507: + +/* Line 1806 of yacc.c */ +#line 1929 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID ); @@ -7699,8 +7712,8 @@ break; - case 505: - -/* Line 1806 of yacc.c */ -#line 1925 "parser.yy" + case 508: + +/* Line 1806 of yacc.c */ +#line 1934 "parser.yy" { typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) ); @@ -7709,8 +7722,8 @@ break; - case 506: - -/* Line 1806 of yacc.c */ -#line 1930 "parser.yy" + case 509: + +/* Line 1806 of yacc.c */ +#line 1939 "parser.yy" { typedefTable.leaveTrait(); @@ -7720,15 +7733,15 @@ break; - case 508: - -/* Line 1806 of yacc.c */ -#line 1940 "parser.yy" + case 511: + +/* Line 1806 of yacc.c */ +#line 1949 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; - case 511: - -/* Line 1806 of yacc.c */ -#line 1950 "parser.yy" + case 514: + +/* Line 1806 of yacc.c */ +#line 1959 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7737,8 +7750,8 @@ break; - case 512: - -/* Line 1806 of yacc.c */ -#line 1955 "parser.yy" + case 515: + +/* Line 1806 of yacc.c */ +#line 1964 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7747,8 +7760,8 @@ break; - case 513: - -/* Line 1806 of yacc.c */ -#line 1960 "parser.yy" + case 516: + +/* Line 1806 of yacc.c */ +#line 1969 "parser.yy" { typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID ); @@ -7757,8 +7770,8 @@ break; - case 514: - -/* Line 1806 of yacc.c */ -#line 1968 "parser.yy" + case 517: + +/* Line 1806 of yacc.c */ +#line 1977 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7767,8 +7780,8 @@ break; - case 515: - -/* Line 1806 of yacc.c */ -#line 1973 "parser.yy" + case 518: + +/* Line 1806 of yacc.c */ +#line 1982 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7777,53 +7790,53 @@ break; - case 516: - -/* Line 1806 of yacc.c */ -#line 1983 "parser.yy" + case 519: + +/* Line 1806 of yacc.c */ +#line 1992 "parser.yy" {} break; - case 517: - -/* Line 1806 of yacc.c */ -#line 1985 "parser.yy" + case 520: + +/* Line 1806 of yacc.c */ +#line 1994 "parser.yy" { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl); } break; - case 519: - -/* Line 1806 of yacc.c */ -#line 1991 "parser.yy" + case 522: + +/* Line 1806 of yacc.c */ +#line 2000 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl) != nullptr ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); } break; - case 520: - -/* Line 1806 of yacc.c */ -#line 1996 "parser.yy" + case 523: + +/* Line 1806 of yacc.c */ +#line 2005 "parser.yy" { (yyval.decl) = 0; } break; - case 524: - -/* Line 1806 of yacc.c */ -#line 2004 "parser.yy" + case 527: + +/* Line 1806 of yacc.c */ +#line 2013 "parser.yy" {} break; - case 525: - -/* Line 1806 of yacc.c */ -#line 2006 "parser.yy" + case 528: + +/* Line 1806 of yacc.c */ +#line 2015 "parser.yy" { linkageStack.push( linkage ); // handle nested extern "C"/"Cforall" - linkage = LinkageSpec::fromString( *(yyvsp[(2) - (2)].tok) ); + linkage = LinkageSpec::linkageCheck( (yyvsp[(2) - (2)].tok) ); } break; - case 526: - -/* Line 1806 of yacc.c */ -#line 2011 "parser.yy" + case 529: + +/* Line 1806 of yacc.c */ +#line 2020 "parser.yy" { linkage = linkageStack.top(); @@ -7833,8 +7846,8 @@ break; - case 527: - -/* Line 1806 of yacc.c */ -#line 2017 "parser.yy" + case 530: + +/* Line 1806 of yacc.c */ +#line 2026 "parser.yy" { // mark all fields in list for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) @@ -7844,8 +7857,8 @@ break; - case 529: - -/* Line 1806 of yacc.c */ -#line 2032 "parser.yy" + case 532: + +/* Line 1806 of yacc.c */ +#line 2041 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7855,8 +7868,8 @@ break; - case 530: - -/* Line 1806 of yacc.c */ -#line 2038 "parser.yy" + case 533: + +/* Line 1806 of yacc.c */ +#line 2047 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7866,8 +7879,8 @@ break; - case 531: - -/* Line 1806 of yacc.c */ -#line 2047 "parser.yy" + case 534: + +/* Line 1806 of yacc.c */ +#line 2056 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7877,8 +7890,8 @@ break; - case 532: - -/* Line 1806 of yacc.c */ -#line 2053 "parser.yy" + case 535: + +/* Line 1806 of yacc.c */ +#line 2062 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7888,8 +7901,8 @@ break; - case 533: - -/* Line 1806 of yacc.c */ -#line 2059 "parser.yy" + case 536: + +/* Line 1806 of yacc.c */ +#line 2068 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7899,8 +7912,8 @@ break; - case 534: - -/* Line 1806 of yacc.c */ -#line 2065 "parser.yy" + case 537: + +/* Line 1806 of yacc.c */ +#line 2074 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7910,8 +7923,8 @@ break; - case 535: - -/* Line 1806 of yacc.c */ -#line 2071 "parser.yy" + case 538: + +/* Line 1806 of yacc.c */ +#line 2080 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7921,8 +7934,8 @@ break; - case 536: - -/* Line 1806 of yacc.c */ -#line 2079 "parser.yy" + case 539: + +/* Line 1806 of yacc.c */ +#line 2088 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7932,8 +7945,8 @@ break; - case 537: - -/* Line 1806 of yacc.c */ -#line 2085 "parser.yy" + case 540: + +/* Line 1806 of yacc.c */ +#line 2094 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7943,8 +7956,8 @@ break; - case 538: - -/* Line 1806 of yacc.c */ -#line 2093 "parser.yy" + case 541: + +/* Line 1806 of yacc.c */ +#line 2102 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7954,8 +7967,8 @@ break; - case 539: - -/* Line 1806 of yacc.c */ -#line 2099 "parser.yy" + case 542: + +/* Line 1806 of yacc.c */ +#line 2108 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7965,99 +7978,99 @@ break; - case 543: - -/* Line 1806 of yacc.c */ -#line 2114 "parser.yy" + case 546: + +/* Line 1806 of yacc.c */ +#line 2123 "parser.yy" { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; - case 545: - -/* Line 1806 of yacc.c */ -#line 2119 "parser.yy" + case 548: + +/* Line 1806 of yacc.c */ +#line 2128 "parser.yy" { delete (yyvsp[(3) - (5)].str); } break; - case 546: - -/* Line 1806 of yacc.c */ -#line 2124 "parser.yy" + case 549: + +/* Line 1806 of yacc.c */ +#line 2133 "parser.yy" { (yyval.decl) = 0; } break; - case 549: - -/* Line 1806 of yacc.c */ -#line 2131 "parser.yy" + case 552: + +/* Line 1806 of yacc.c */ +#line 2140 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 550: - -/* Line 1806 of yacc.c */ -#line 2137 "parser.yy" + case 553: + +/* Line 1806 of yacc.c */ +#line 2146 "parser.yy" { (yyval.decl) = 0; } break; - case 555: - -/* Line 1806 of yacc.c */ -#line 2148 "parser.yy" + case 558: + +/* Line 1806 of yacc.c */ +#line 2157 "parser.yy" { delete (yyvsp[(3) - (4)].en); } break; - case 556: - -/* Line 1806 of yacc.c */ -#line 2152 "parser.yy" + case 559: + +/* Line 1806 of yacc.c */ +#line 2161 "parser.yy" { delete (yyvsp[(1) - (1)].tok); } break; - case 557: - -/* Line 1806 of yacc.c */ -#line 2153 "parser.yy" + case 560: + +/* Line 1806 of yacc.c */ +#line 2162 "parser.yy" { delete (yyvsp[(1) - (1)].decl); } break; - case 558: - -/* Line 1806 of yacc.c */ -#line 2154 "parser.yy" + case 561: + +/* Line 1806 of yacc.c */ +#line 2163 "parser.yy" { delete (yyvsp[(1) - (1)].decl); } break; - case 559: - -/* Line 1806 of yacc.c */ -#line 2155 "parser.yy" + case 562: + +/* Line 1806 of yacc.c */ +#line 2164 "parser.yy" { delete (yyvsp[(1) - (1)].decl); } break; - case 560: - -/* Line 1806 of yacc.c */ -#line 2190 "parser.yy" + case 563: + +/* Line 1806 of yacc.c */ +#line 2199 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 562: - -/* Line 1806 of yacc.c */ -#line 2193 "parser.yy" + case 565: + +/* Line 1806 of yacc.c */ +#line 2202 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 563: - -/* Line 1806 of yacc.c */ -#line 2195 "parser.yy" + case 566: + +/* Line 1806 of yacc.c */ +#line 2204 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 564: - -/* Line 1806 of yacc.c */ -#line 2200 "parser.yy" + case 567: + +/* Line 1806 of yacc.c */ +#line 2209 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8066,25 +8079,4 @@ break; - case 565: - -/* Line 1806 of yacc.c */ -#line 2205 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 566: - -/* Line 1806 of yacc.c */ -#line 2210 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 567: - -/* Line 1806 of yacc.c */ -#line 2212 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } - break; - case 568: @@ -8098,89 +8090,89 @@ /* Line 1806 of yacc.c */ #line 2219 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 570: + +/* Line 1806 of yacc.c */ +#line 2221 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 571: + +/* Line 1806 of yacc.c */ +#line 2223 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 572: + +/* Line 1806 of yacc.c */ +#line 2228 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 570: - -/* Line 1806 of yacc.c */ -#line 2221 "parser.yy" + case 573: + +/* Line 1806 of yacc.c */ +#line 2230 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 571: - -/* Line 1806 of yacc.c */ -#line 2223 "parser.yy" + case 574: + +/* Line 1806 of yacc.c */ +#line 2232 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 572: - -/* Line 1806 of yacc.c */ -#line 2225 "parser.yy" + case 575: + +/* Line 1806 of yacc.c */ +#line 2234 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 573: - -/* Line 1806 of yacc.c */ -#line 2230 "parser.yy" + case 576: + +/* Line 1806 of yacc.c */ +#line 2239 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 574: - -/* Line 1806 of yacc.c */ -#line 2232 "parser.yy" + case 577: + +/* Line 1806 of yacc.c */ +#line 2241 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 575: - -/* Line 1806 of yacc.c */ -#line 2241 "parser.yy" + case 578: + +/* Line 1806 of yacc.c */ +#line 2250 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 577: - -/* Line 1806 of yacc.c */ -#line 2244 "parser.yy" + case 580: + +/* Line 1806 of yacc.c */ +#line 2253 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 578: - -/* Line 1806 of yacc.c */ -#line 2249 "parser.yy" + case 581: + +/* Line 1806 of yacc.c */ +#line 2258 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; - case 579: - -/* Line 1806 of yacc.c */ -#line 2251 "parser.yy" + case 582: + +/* Line 1806 of yacc.c */ +#line 2260 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } - break; - - case 580: - -/* Line 1806 of yacc.c */ -#line 2253 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 581: - -/* Line 1806 of yacc.c */ -#line 2258 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 582: - -/* Line 1806 of yacc.c */ -#line 2260 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8196,5 +8188,5 @@ /* Line 1806 of yacc.c */ #line 2267 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8203,5 +8195,5 @@ /* Line 1806 of yacc.c */ #line 2269 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8213,37 +8205,37 @@ break; - case 590: - -/* Line 1806 of yacc.c */ -#line 2286 "parser.yy" + case 587: + +/* Line 1806 of yacc.c */ +#line 2276 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 588: + +/* Line 1806 of yacc.c */ +#line 2278 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 589: + +/* Line 1806 of yacc.c */ +#line 2280 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 593: + +/* Line 1806 of yacc.c */ +#line 2295 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); } break; - case 591: - -/* Line 1806 of yacc.c */ -#line 2288 "parser.yy" + case 594: + +/* Line 1806 of yacc.c */ +#line 2297 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); } - break; - - case 592: - -/* Line 1806 of yacc.c */ -#line 2290 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 593: - -/* Line 1806 of yacc.c */ -#line 2295 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 594: - -/* Line 1806 of yacc.c */ -#line 2297 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8259,5 +8251,5 @@ /* Line 1806 of yacc.c */ #line 2304 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8266,5 +8258,5 @@ /* Line 1806 of yacc.c */ #line 2306 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8279,41 +8271,41 @@ /* Line 1806 of yacc.c */ -#line 2323 "parser.yy" +#line 2313 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 600: + +/* Line 1806 of yacc.c */ +#line 2315 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } + break; + + case 601: + +/* Line 1806 of yacc.c */ +#line 2317 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 602: + +/* Line 1806 of yacc.c */ +#line 2332 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 601: - -/* Line 1806 of yacc.c */ -#line 2326 "parser.yy" + case 604: + +/* Line 1806 of yacc.c */ +#line 2335 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 602: - -/* Line 1806 of yacc.c */ -#line 2328 "parser.yy" + case 605: + +/* Line 1806 of yacc.c */ +#line 2337 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } - break; - - case 604: - -/* Line 1806 of yacc.c */ -#line 2334 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 605: - -/* Line 1806 of yacc.c */ -#line 2339 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } - break; - - case 606: - -/* Line 1806 of yacc.c */ -#line 2341 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8329,40 +8321,40 @@ /* Line 1806 of yacc.c */ #line 2348 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } + break; + + case 609: + +/* Line 1806 of yacc.c */ +#line 2350 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } + break; + + case 610: + +/* Line 1806 of yacc.c */ +#line 2352 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 611: + +/* Line 1806 of yacc.c */ +#line 2357 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 609: - -/* Line 1806 of yacc.c */ -#line 2350 "parser.yy" + case 612: + +/* Line 1806 of yacc.c */ +#line 2359 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 610: - -/* Line 1806 of yacc.c */ -#line 2352 "parser.yy" + case 613: + +/* Line 1806 of yacc.c */ +#line 2361 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 611: - -/* Line 1806 of yacc.c */ -#line 2354 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 612: - -/* Line 1806 of yacc.c */ -#line 2359 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } - break; - - case 613: - -/* Line 1806 of yacc.c */ -#line 2361 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8377,83 +8369,83 @@ /* Line 1806 of yacc.c */ -#line 2373 "parser.yy" +#line 2368 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } + break; + + case 616: + +/* Line 1806 of yacc.c */ +#line 2370 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 617: + +/* Line 1806 of yacc.c */ +#line 2372 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 618: + +/* Line 1806 of yacc.c */ +#line 2382 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 617: - -/* Line 1806 of yacc.c */ -#line 2376 "parser.yy" + case 620: + +/* Line 1806 of yacc.c */ +#line 2385 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 618: - -/* Line 1806 of yacc.c */ -#line 2378 "parser.yy" + case 621: + +/* Line 1806 of yacc.c */ +#line 2387 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 619: - -/* Line 1806 of yacc.c */ -#line 2383 "parser.yy" + case 622: + +/* Line 1806 of yacc.c */ +#line 2392 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 620: - -/* Line 1806 of yacc.c */ -#line 2385 "parser.yy" + case 623: + +/* Line 1806 of yacc.c */ +#line 2394 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 621: - -/* Line 1806 of yacc.c */ -#line 2387 "parser.yy" + case 624: + +/* Line 1806 of yacc.c */ +#line 2396 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 622: - -/* Line 1806 of yacc.c */ -#line 2392 "parser.yy" + case 625: + +/* Line 1806 of yacc.c */ +#line 2401 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 623: - -/* Line 1806 of yacc.c */ -#line 2394 "parser.yy" + case 626: + +/* Line 1806 of yacc.c */ +#line 2403 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 624: - -/* Line 1806 of yacc.c */ -#line 2396 "parser.yy" + case 627: + +/* Line 1806 of yacc.c */ +#line 2405 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 625: - -/* Line 1806 of yacc.c */ -#line 2398 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 626: - -/* Line 1806 of yacc.c */ -#line 2403 "parser.yy" - { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } - break; - - case 627: - -/* Line 1806 of yacc.c */ -#line 2405 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8468,26 +8460,47 @@ /* Line 1806 of yacc.c */ -#line 2438 "parser.yy" +#line 2412 "parser.yy" + { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } + break; + + case 630: + +/* Line 1806 of yacc.c */ +#line 2414 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 631: + +/* Line 1806 of yacc.c */ +#line 2416 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 632: + +/* Line 1806 of yacc.c */ +#line 2447 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 631: - -/* Line 1806 of yacc.c */ -#line 2441 "parser.yy" + case 634: + +/* Line 1806 of yacc.c */ +#line 2450 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 632: - -/* Line 1806 of yacc.c */ -#line 2443 "parser.yy" + case 635: + +/* Line 1806 of yacc.c */ +#line 2452 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 633: - -/* Line 1806 of yacc.c */ -#line 2448 "parser.yy" + case 636: + +/* Line 1806 of yacc.c */ +#line 2457 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8496,8 +8509,8 @@ break; - case 634: - -/* Line 1806 of yacc.c */ -#line 2453 "parser.yy" + case 637: + +/* Line 1806 of yacc.c */ +#line 2462 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8506,135 +8519,114 @@ break; - case 635: - -/* Line 1806 of yacc.c */ -#line 2461 "parser.yy" + case 638: + +/* Line 1806 of yacc.c */ +#line 2470 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 636: - -/* Line 1806 of yacc.c */ -#line 2463 "parser.yy" + case 639: + +/* Line 1806 of yacc.c */ +#line 2472 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 637: - -/* Line 1806 of yacc.c */ -#line 2465 "parser.yy" + case 640: + +/* Line 1806 of yacc.c */ +#line 2474 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 638: - -/* Line 1806 of yacc.c */ -#line 2470 "parser.yy" + case 641: + +/* Line 1806 of yacc.c */ +#line 2479 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 639: - -/* Line 1806 of yacc.c */ -#line 2472 "parser.yy" + case 642: + +/* Line 1806 of yacc.c */ +#line 2481 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 640: - -/* Line 1806 of yacc.c */ -#line 2477 "parser.yy" + case 643: + +/* Line 1806 of yacc.c */ +#line 2486 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; - case 641: - -/* Line 1806 of yacc.c */ -#line 2479 "parser.yy" + case 644: + +/* Line 1806 of yacc.c */ +#line 2488 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 643: - -/* Line 1806 of yacc.c */ -#line 2494 "parser.yy" + case 646: + +/* Line 1806 of yacc.c */ +#line 2503 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 644: - -/* Line 1806 of yacc.c */ -#line 2496 "parser.yy" + case 647: + +/* Line 1806 of yacc.c */ +#line 2505 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 645: - -/* Line 1806 of yacc.c */ -#line 2501 "parser.yy" + case 648: + +/* Line 1806 of yacc.c */ +#line 2510 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; - case 646: - -/* Line 1806 of yacc.c */ -#line 2503 "parser.yy" + case 649: + +/* Line 1806 of yacc.c */ +#line 2512 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; - case 647: - -/* Line 1806 of yacc.c */ -#line 2505 "parser.yy" + case 650: + +/* Line 1806 of yacc.c */ +#line 2514 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 648: - -/* Line 1806 of yacc.c */ -#line 2507 "parser.yy" + case 651: + +/* Line 1806 of yacc.c */ +#line 2516 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 649: - -/* Line 1806 of yacc.c */ -#line 2509 "parser.yy" + case 652: + +/* Line 1806 of yacc.c */ +#line 2518 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 651: - -/* Line 1806 of yacc.c */ -#line 2515 "parser.yy" + case 654: + +/* Line 1806 of yacc.c */ +#line 2524 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 652: - -/* Line 1806 of yacc.c */ -#line 2517 "parser.yy" + case 655: + +/* Line 1806 of yacc.c */ +#line 2526 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 653: - -/* Line 1806 of yacc.c */ -#line 2519 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 654: - -/* Line 1806 of yacc.c */ -#line 2524 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); } - break; - - case 655: - -/* Line 1806 of yacc.c */ -#line 2526 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8649,125 +8641,125 @@ /* Line 1806 of yacc.c */ -#line 2534 "parser.yy" +#line 2533 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); } + break; + + case 658: + +/* Line 1806 of yacc.c */ +#line 2535 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 659: + +/* Line 1806 of yacc.c */ +#line 2537 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 660: + +/* Line 1806 of yacc.c */ +#line 2543 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } break; - case 658: - -/* Line 1806 of yacc.c */ -#line 2536 "parser.yy" + case 661: + +/* Line 1806 of yacc.c */ +#line 2545 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); } break; - case 660: - -/* Line 1806 of yacc.c */ -#line 2542 "parser.yy" + case 663: + +/* Line 1806 of yacc.c */ +#line 2551 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); } break; - case 661: - -/* Line 1806 of yacc.c */ -#line 2544 "parser.yy" + case 664: + +/* Line 1806 of yacc.c */ +#line 2553 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( 0 ); } break; - case 662: - -/* Line 1806 of yacc.c */ -#line 2546 "parser.yy" + case 665: + +/* Line 1806 of yacc.c */ +#line 2555 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); } break; - case 663: - -/* Line 1806 of yacc.c */ -#line 2548 "parser.yy" + case 666: + +/* Line 1806 of yacc.c */ +#line 2557 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); } break; - case 665: - -/* Line 1806 of yacc.c */ -#line 2563 "parser.yy" + case 668: + +/* Line 1806 of yacc.c */ +#line 2572 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 666: - -/* Line 1806 of yacc.c */ -#line 2565 "parser.yy" + case 669: + +/* Line 1806 of yacc.c */ +#line 2574 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 667: - -/* Line 1806 of yacc.c */ -#line 2570 "parser.yy" + case 670: + +/* Line 1806 of yacc.c */ +#line 2579 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; - case 668: - -/* Line 1806 of yacc.c */ -#line 2572 "parser.yy" + case 671: + +/* Line 1806 of yacc.c */ +#line 2581 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; - case 669: - -/* Line 1806 of yacc.c */ -#line 2574 "parser.yy" + case 672: + +/* Line 1806 of yacc.c */ +#line 2583 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 670: - -/* Line 1806 of yacc.c */ -#line 2576 "parser.yy" + case 673: + +/* Line 1806 of yacc.c */ +#line 2585 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 671: - -/* Line 1806 of yacc.c */ -#line 2578 "parser.yy" + case 674: + +/* Line 1806 of yacc.c */ +#line 2587 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 673: - -/* Line 1806 of yacc.c */ -#line 2584 "parser.yy" + case 676: + +/* Line 1806 of yacc.c */ +#line 2593 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 674: - -/* Line 1806 of yacc.c */ -#line 2586 "parser.yy" + case 677: + +/* Line 1806 of yacc.c */ +#line 2595 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } - break; - - case 675: - -/* Line 1806 of yacc.c */ -#line 2588 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (3)].decl); } - break; - - case 676: - -/* Line 1806 of yacc.c */ -#line 2593 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); } - break; - - case 677: - -/* Line 1806 of yacc.c */ -#line 2595 "parser.yy" - { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8779,401 +8771,415 @@ break; + case 679: + +/* Line 1806 of yacc.c */ +#line 2602 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); } + break; + case 680: /* Line 1806 of yacc.c */ #line 2604 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } + break; + + case 681: + +/* Line 1806 of yacc.c */ +#line 2606 "parser.yy" + { (yyval.decl) = (yyvsp[(2) - (3)].decl); } + break; + + case 683: + +/* Line 1806 of yacc.c */ +#line 2613 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; - case 682: - -/* Line 1806 of yacc.c */ -#line 2615 "parser.yy" + case 685: + +/* Line 1806 of yacc.c */ +#line 2624 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } break; - case 683: - -/* Line 1806 of yacc.c */ -#line 2618 "parser.yy" + case 686: + +/* Line 1806 of yacc.c */ +#line 2627 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } break; - case 684: - -/* Line 1806 of yacc.c */ -#line 2620 "parser.yy" + case 687: + +/* Line 1806 of yacc.c */ +#line 2629 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); } break; - case 685: - -/* Line 1806 of yacc.c */ -#line 2623 "parser.yy" + case 688: + +/* Line 1806 of yacc.c */ +#line 2632 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } break; - case 686: - -/* Line 1806 of yacc.c */ -#line 2625 "parser.yy" + case 689: + +/* Line 1806 of yacc.c */ +#line 2634 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); } break; - case 687: - -/* Line 1806 of yacc.c */ -#line 2627 "parser.yy" + case 690: + +/* Line 1806 of yacc.c */ +#line 2636 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); } break; - case 689: - -/* Line 1806 of yacc.c */ -#line 2641 "parser.yy" + case 692: + +/* Line 1806 of yacc.c */ +#line 2650 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 690: - -/* Line 1806 of yacc.c */ -#line 2643 "parser.yy" + case 693: + +/* Line 1806 of yacc.c */ +#line 2652 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; - case 691: - -/* Line 1806 of yacc.c */ -#line 2648 "parser.yy" + case 694: + +/* Line 1806 of yacc.c */ +#line 2657 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; - case 692: - -/* Line 1806 of yacc.c */ -#line 2650 "parser.yy" + case 695: + +/* Line 1806 of yacc.c */ +#line 2659 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; - case 693: - -/* Line 1806 of yacc.c */ -#line 2652 "parser.yy" + case 696: + +/* Line 1806 of yacc.c */ +#line 2661 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 694: - -/* Line 1806 of yacc.c */ -#line 2654 "parser.yy" + case 697: + +/* Line 1806 of yacc.c */ +#line 2663 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; - case 695: - -/* Line 1806 of yacc.c */ -#line 2656 "parser.yy" + case 698: + +/* Line 1806 of yacc.c */ +#line 2665 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 697: - -/* Line 1806 of yacc.c */ -#line 2662 "parser.yy" + case 700: + +/* Line 1806 of yacc.c */ +#line 2671 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 698: - -/* Line 1806 of yacc.c */ -#line 2664 "parser.yy" + case 701: + +/* Line 1806 of yacc.c */ +#line 2673 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; - case 699: - -/* Line 1806 of yacc.c */ -#line 2666 "parser.yy" + case 702: + +/* Line 1806 of yacc.c */ +#line 2675 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 700: - -/* Line 1806 of yacc.c */ -#line 2671 "parser.yy" + case 703: + +/* Line 1806 of yacc.c */ +#line 2680 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; - case 701: - -/* Line 1806 of yacc.c */ -#line 2673 "parser.yy" + case 704: + +/* Line 1806 of yacc.c */ +#line 2682 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; - case 704: - -/* Line 1806 of yacc.c */ -#line 2683 "parser.yy" + case 707: + +/* Line 1806 of yacc.c */ +#line 2692 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 707: - -/* Line 1806 of yacc.c */ -#line 2693 "parser.yy" + case 710: + +/* Line 1806 of yacc.c */ +#line 2702 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 708: - -/* Line 1806 of yacc.c */ -#line 2695 "parser.yy" + case 711: + +/* Line 1806 of yacc.c */ +#line 2704 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 709: - -/* Line 1806 of yacc.c */ -#line 2697 "parser.yy" + case 712: + +/* Line 1806 of yacc.c */ +#line 2706 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 710: - -/* Line 1806 of yacc.c */ -#line 2699 "parser.yy" + case 713: + +/* Line 1806 of yacc.c */ +#line 2708 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 711: - -/* Line 1806 of yacc.c */ -#line 2701 "parser.yy" + case 714: + +/* Line 1806 of yacc.c */ +#line 2710 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 712: - -/* Line 1806 of yacc.c */ -#line 2703 "parser.yy" + case 715: + +/* Line 1806 of yacc.c */ +#line 2712 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 713: - -/* Line 1806 of yacc.c */ -#line 2710 "parser.yy" + case 716: + +/* Line 1806 of yacc.c */ +#line 2719 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 714: - -/* Line 1806 of yacc.c */ -#line 2712 "parser.yy" + case 717: + +/* Line 1806 of yacc.c */ +#line 2721 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 715: - -/* Line 1806 of yacc.c */ -#line 2714 "parser.yy" + case 718: + +/* Line 1806 of yacc.c */ +#line 2723 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 716: - -/* Line 1806 of yacc.c */ -#line 2716 "parser.yy" + case 719: + +/* Line 1806 of yacc.c */ +#line 2725 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } break; - case 717: - -/* Line 1806 of yacc.c */ -#line 2718 "parser.yy" + case 720: + +/* Line 1806 of yacc.c */ +#line 2727 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 718: - -/* Line 1806 of yacc.c */ -#line 2720 "parser.yy" + case 721: + +/* Line 1806 of yacc.c */ +#line 2729 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 719: - -/* Line 1806 of yacc.c */ -#line 2722 "parser.yy" + case 722: + +/* Line 1806 of yacc.c */ +#line 2731 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 720: - -/* Line 1806 of yacc.c */ -#line 2724 "parser.yy" + case 723: + +/* Line 1806 of yacc.c */ +#line 2733 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; - case 721: - -/* Line 1806 of yacc.c */ -#line 2726 "parser.yy" + case 724: + +/* Line 1806 of yacc.c */ +#line 2735 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } break; - case 722: - -/* Line 1806 of yacc.c */ -#line 2728 "parser.yy" + case 725: + +/* Line 1806 of yacc.c */ +#line 2737 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 723: - -/* Line 1806 of yacc.c */ -#line 2733 "parser.yy" + case 726: + +/* Line 1806 of yacc.c */ +#line 2742 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } break; - case 724: - -/* Line 1806 of yacc.c */ -#line 2735 "parser.yy" + case 727: + +/* Line 1806 of yacc.c */ +#line 2744 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } break; - case 725: - -/* Line 1806 of yacc.c */ -#line 2740 "parser.yy" + case 728: + +/* Line 1806 of yacc.c */ +#line 2749 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); } break; - case 726: - -/* Line 1806 of yacc.c */ -#line 2742 "parser.yy" + case 729: + +/* Line 1806 of yacc.c */ +#line 2751 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); } break; - case 728: - -/* Line 1806 of yacc.c */ -#line 2769 "parser.yy" + case 731: + +/* Line 1806 of yacc.c */ +#line 2778 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; - case 732: - -/* Line 1806 of yacc.c */ -#line 2780 "parser.yy" + case 735: + +/* Line 1806 of yacc.c */ +#line 2789 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 733: - -/* Line 1806 of yacc.c */ -#line 2782 "parser.yy" + case 736: + +/* Line 1806 of yacc.c */ +#line 2791 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 734: - -/* Line 1806 of yacc.c */ -#line 2784 "parser.yy" + case 737: + +/* Line 1806 of yacc.c */ +#line 2793 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 735: - -/* Line 1806 of yacc.c */ -#line 2786 "parser.yy" + case 738: + +/* Line 1806 of yacc.c */ +#line 2795 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 736: - -/* Line 1806 of yacc.c */ -#line 2788 "parser.yy" + case 739: + +/* Line 1806 of yacc.c */ +#line 2797 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; - case 737: - -/* Line 1806 of yacc.c */ -#line 2790 "parser.yy" + case 740: + +/* Line 1806 of yacc.c */ +#line 2799 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; - case 738: - -/* Line 1806 of yacc.c */ -#line 2797 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 739: - -/* Line 1806 of yacc.c */ -#line 2799 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 740: - -/* Line 1806 of yacc.c */ -#line 2801 "parser.yy" + case 741: + +/* Line 1806 of yacc.c */ +#line 2806 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } + break; + + case 742: + +/* Line 1806 of yacc.c */ +#line 2808 "parser.yy" + { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } + break; + + case 743: + +/* Line 1806 of yacc.c */ +#line 2810 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 741: - -/* Line 1806 of yacc.c */ -#line 2803 "parser.yy" - { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 742: - -/* Line 1806 of yacc.c */ -#line 2805 "parser.yy" - { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } - break; - - case 743: - -/* Line 1806 of yacc.c */ -#line 2807 "parser.yy" + case 744: + +/* Line 1806 of yacc.c */ +#line 2812 "parser.yy" + { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } + break; + + case 745: + +/* Line 1806 of yacc.c */ +#line 2814 "parser.yy" + { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } + break; + + case 746: + +/* Line 1806 of yacc.c */ +#line 2816 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; - case 744: - -/* Line 1806 of yacc.c */ -#line 2812 "parser.yy" + case 747: + +/* Line 1806 of yacc.c */ +#line 2821 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } break; - case 745: - -/* Line 1806 of yacc.c */ -#line 2817 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); } - break; - - case 746: - -/* Line 1806 of yacc.c */ -#line 2819 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); } - break; - - case 747: - -/* Line 1806 of yacc.c */ -#line 2821 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); } + case 748: + +/* Line 1806 of yacc.c */ +#line 2826 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), (yyvsp[(4) - (5)].decl), nullptr ); } + break; + + case 749: + +/* Line 1806 of yacc.c */ +#line 2828 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); } break; @@ -9181,12 +9187,19 @@ /* Line 1806 of yacc.c */ -#line 2845 "parser.yy" +#line 2830 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); } + break; + + case 753: + +/* Line 1806 of yacc.c */ +#line 2854 "parser.yy" { (yyval.en) = 0; } break; - case 751: - -/* Line 1806 of yacc.c */ -#line 2847 "parser.yy" + case 754: + +/* Line 1806 of yacc.c */ +#line 2856 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; @@ -9195,5 +9208,5 @@ /* Line 1806 of yacc.c */ -#line 9198 "Parser/parser.cc" +#line 9211 "Parser/parser.cc" default: break; } @@ -9426,5 +9439,5 @@ /* Line 2067 of yacc.c */ -#line 2850 "parser.yy" +#line 2859 "parser.yy" // ----end of grammar---- @@ -9433,9 +9446,9 @@ void yyerror( const char * ) { - std::cout << "Error "; + cout << "Error "; if ( yyfilename ) { - std::cout << "in file " << yyfilename << " "; + cout << "in file " << yyfilename << " "; } // if - std::cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << std::endl; + cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << endl; } Index: src/Parser/parser.h =================================================================== --- src/Parser/parser.h (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/parser.h (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -262,5 +262,5 @@ /* Line 2068 of yacc.c */ -#line 115 "parser.yy" +#line 116 "parser.yy" Token tok; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/Parser/parser.yy (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 12 17:29:45 2016 -// Update Count : 1969 +// Last Modified On : Wed Oct 5 14:10:46 2016 +// Update Count : 2002 // @@ -54,4 +54,5 @@ #include "TypeData.h" #include "LinkageSpec.h" +using namespace std; extern DeclarationNode * parseTree; @@ -59,7 +60,7 @@ extern TypedefTable typedefTable; -std::stack< LinkageSpec::Spec > linkageStack; - -void appendStr( std::string *to, std::string *from ) { +stack< LinkageSpec::Spec > linkageStack; + +void appendStr( string *to, string *from ) { // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string. to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) ); @@ -195,4 +196,5 @@ %type field_declaration field_declaration_list field_declarator field_declaring_list %type field field_list +%type field_name %type external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr @@ -359,5 +361,5 @@ { $$ = $2; } | '(' compound_statement ')' // GCC, lambda expression - { $$ = new ExpressionNode( build_valexpr( $2 ) ); } + { $$ = new ExpressionNode( build_valexpr( $2 ) ); } ; @@ -378,4 +380,6 @@ | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); } + | postfix_expression '.' INTEGERconstant + { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); } | postfix_expression ARROW no_attr_identifier { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); } @@ -391,5 +395,5 @@ { Token fn; - fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? + fn.str = new std::string( "?{}" ); // location undefined - use location of '{'? $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) ); } @@ -414,16 +418,21 @@ field: // CFA, tuple field selector - no_attr_identifier - { $$ = new ExpressionNode( build_varref( $1 ) ); } + field_name // ambiguity with .0 so space required after field-selection, e.g. // struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1; - | no_attr_identifier '.' field + { $$ = new ExpressionNode( build_varref( $1 ) ); } + | field_name '.' field { $$ = new ExpressionNode( build_fieldSel( $3, build_varref( $1 ) ) ); } - | no_attr_identifier '.' '[' push field_list pop ']' + | field_name '.' '[' push field_list pop ']' { $$ = new ExpressionNode( build_fieldSel( $5, build_varref( $1 ) ) ); } - | no_attr_identifier ARROW field + | field_name ARROW field { $$ = new ExpressionNode( build_pfieldSel( $3, build_varref( $1 ) ) ); } - | no_attr_identifier ARROW '[' push field_list pop ']' + | field_name ARROW '[' push field_list pop ']' { $$ = new ExpressionNode( build_pfieldSel( $5, build_varref( $1 ) ) ); } + ; + +field_name: + no_attr_identifier + | INTEGERconstant ; @@ -668,5 +677,5 @@ { Token fn; - fn.str = new std::string( "^?{}" ); // location undefined + fn.str = new string( "^?{}" ); // location undefined $$ = new StatementNode( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) ) ) ); } @@ -898,5 +907,5 @@ { $$ = new StatementNode( build_catch( $5, $8 ) ); } | handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop - { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $6, $9 ) ) ); } + { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $6, $9 ) ) ); } | CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop { $$ = new StatementNode( build_catch( $5, $8 ) ); } @@ -970,5 +979,5 @@ { $$ = new ExpressionNode( build_asmexpr( 0, $1, $3 ) ); } | '[' constant_expression ']' string_literal '(' constant_expression ')' - { $$ = new ExpressionNode( build_asmexpr( $2, $4, $6 ) ); } + { $$ = new ExpressionNode( build_asmexpr( $2, $4, $6 ) ); } ; @@ -1469,16 +1478,16 @@ aggregate_name: aggregate_key '{' field_declaration_list '}' - { $$ = DeclarationNode::newAggregate( $1, 0, 0, $3, true ); } + { $$ = DeclarationNode::newAggregate( $1, nullptr, nullptr, $3, true ); } | aggregate_key no_attr_identifier_or_type_name { typedefTable.makeTypedef( *$2 ); - $$ = DeclarationNode::newAggregate( $1, $2, 0, 0, false ); + $$ = DeclarationNode::newAggregate( $1, $2, nullptr, nullptr, false ); } | aggregate_key no_attr_identifier_or_type_name { typedefTable.makeTypedef( *$2 ); } '{' field_declaration_list '}' - { $$ = DeclarationNode::newAggregate( $1, $2, 0, $5, true ); } + { $$ = DeclarationNode::newAggregate( $1, $2, nullptr, $5, true ); } | aggregate_key '(' type_name_list ')' '{' field_declaration_list '}' // CFA - { $$ = DeclarationNode::newAggregate( $1, 0, $3, $6, false ); } + { $$ = DeclarationNode::newAggregate( $1, nullptr, $3, $6, false ); } | aggregate_key typegen_name // CFA, S/R conflict { $$ = $2; } @@ -1561,5 +1570,5 @@ enum_name: enum_key '{' enumerator_list comma_opt '}' - { $$ = DeclarationNode::newEnum( 0, $3 ); } + { $$ = DeclarationNode::newEnum( nullptr, $3 ); } | enum_key no_attr_identifier_or_type_name { @@ -2006,5 +2015,5 @@ { linkageStack.push( linkage ); // handle nested extern "C"/"Cforall" - linkage = LinkageSpec::fromString( *$2 ); + linkage = LinkageSpec::linkageCheck( $2 ); } '{' external_definition_list_opt '}' // C++-style linkage specifier @@ -2522,5 +2531,5 @@ abstract_function: '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); } | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } @@ -2591,5 +2600,5 @@ abstract_parameter_function: '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = DeclarationNode::newFunction( 0, 0, $3, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); } | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) { $$ = $2->addParamList( $6 ); } @@ -2795,13 +2804,13 @@ // empty (void) function return type. '[' ']' type_specifier - { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } | '[' ']' multi_array_dimension type_specifier - { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } | multi_array_dimension type_specifier { $$ = $2->addNewArray( $1 ); } | '[' ']' new_abstract_ptr - { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } | '[' ']' multi_array_dimension new_abstract_ptr - { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } + { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } | multi_array_dimension new_abstract_ptr { $$ = $2->addNewArray( $1 ); } @@ -2815,9 +2824,9 @@ new_abstract_function: // CFA '[' ']' '(' new_parameter_type_list_opt ')' - { $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $4, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, nullptr ); } | new_abstract_tuple '(' push new_parameter_type_list_opt pop ')' - { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); } | new_function_return '(' push new_parameter_type_list_opt pop ')' - { $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); } + { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); } ; @@ -2854,9 +2863,9 @@ void yyerror( const char * ) { - std::cout << "Error "; + cout << "Error "; if ( yyfilename ) { - std::cout << "in file " << yyfilename << " "; + cout << "in file " << yyfilename << " "; } // if - std::cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << std::endl; + cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << endl; } Index: src/SynTree/FunctionDecl.cc =================================================================== --- src/SynTree/FunctionDecl.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/SynTree/FunctionDecl.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 18 23:50:14 2016 -// Update Count : 20 +// Last Modified On : Sat Oct 1 23:06:32 2016 +// Update Count : 21 // @@ -60,5 +60,5 @@ } // if if ( get_linkage() != LinkageSpec::Cforall ) { - os << LinkageSpec::toString( get_linkage() ) << " "; + os << LinkageSpec::linkageName( get_linkage() ) << " "; } // if if ( get_isInline() ) { Index: src/SynTree/ObjectDecl.cc =================================================================== --- src/SynTree/ObjectDecl.cc (revision ac9ca967fc4b0004f809382a113690d4c01cae00) +++ src/SynTree/ObjectDecl.cc (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 18 23:50:33 2016 -// Update Count : 31 +// Last Modified On : Sat Oct 1 23:05:56 2016 +// Update Count : 32 // @@ -44,5 +44,5 @@ if ( get_linkage() != LinkageSpec::Cforall ) { - os << LinkageSpec::toString( get_linkage() ) << " "; + os << LinkageSpec::linkageName( get_linkage() ) << " "; } // if Index: src/libcfa/memcheck.awk =================================================================== --- src/libcfa/memcheck.awk (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) +++ src/libcfa/memcheck.awk (revision 7756647eaf7d18e5f8c8c4841b9279a5f4e4f8dc) @@ -0,0 +1,26 @@ +#!/usr/bin/nawk -f + +BEGIN { + print "Freed but not allocated:" +} + +/malloc/ { + alloc[ $2 ] = $3; +} + +/free/ { + if ( $2 in alloc ) { + delete alloc[ $2 ]; + } else { + print $2; + } # if +} + +END { + print "Allocated but not freed:" + for ( i in alloc ) { + print i, alloc[ i ]; + total += alloc[ i ] + } # for + print "total", total; +}