Changeset b3f9a0cb


Ignore:
Timestamp:
Apr 4, 2016, 1:18:17 PM (6 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, string, with_gc
Children:
afc1045
Parents:
89173242 (diff), 3cfe27f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
4 added
11 deleted
40 edited

Legend:

Unmodified
Added
Removed
  • .gitignore

    r89173242 rb3f9a0cb  
    3030
    3131# generated by latex
    32 doc/refrat/refrat.aux
    33 doc/refrat/refrat.bbl
    34 doc/refrat/refrat.blg
    35 doc/refrat/refrat.brf
    36 doc/refrat/refrat.dvi
    37 doc/refrat/refrat.idx
    38 doc/refrat/refrat.ilg
    39 doc/refrat/refrat.ind
    40 doc/refrat/refrat.log
    41 doc/refrat/refrat.out
    42 doc/refrat/refrat.pdf
    43 doc/refrat/refrat.ps
    44 doc/refrat/refrat.toc
     32*.aux
     33*.bbl
     34*.blg
     35*.brf
     36*.dvi
     37*.idx
     38*.ilg
     39*.ind
     40*.log
     41*.out
     42*.pdf
     43*.ps
     44*.toc
  • doc/refrat/refrat.tex

    r89173242 rb3f9a0cb  
    1717\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
    1818\usepackage{breakurl}
    19 \urlstyle{sf}
     19\renewcommand{\UrlFont}{\small\sf}
    2020
    2121%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     
    2323% Names used in the document.
    2424
    25 \newcommand{\CFA}{Cforall\xspace}               % set language text name
    26 \newcommand{\CFAA}{C$\forall$\xspace}   % set language symbolic name
     25\newcommand{\CFA}{C$\forall$\xspace}    % set language symbolic name
     26\newcommand{\CFL}{Cforall\xspace}               % set language text name
    2727\newcommand{\CC}{C\kern-.1em\hbox{+\kern-.25em+}\xspace} % CC symbolic name
    2828\def\c11{ISO/IEC C} % C11 name (cannot have numbers in latex command name)
     
    3333
    3434\makeatletter
     35% allow escape sequence in lstinline
     36%\usepackage{etoolbox}
     37%\patchcmd{\lsthk@TextStyle}{\let\lst@DefEsc\@empty}{}{}{\errmessage{failed to patch}}
     38
     39\renewcommand\small{%
     40   \@setfontsize\small{8.5}{11}%
     41   \abovedisplayskip 8.5pt \@plus 3pt \@minus 4pt
     42   \abovedisplayshortskip \z@ \@plus 2pt
     43   \belowdisplayshortskip 4pt \@plus 2pt \@minus 2pt
     44   \def\@listi{\leftmargin\leftmargini
     45               \topsep 4pt \@plus 2pt \@minus 2pt
     46               \parsep 2pt \@pluspt \@minuspt
     47               \itemsep \parsep}%
     48   \belowdisplayskip \abovedisplayskip
     49}
     50\usepackage{relsize}            % must be after change to small
     51
    3552\renewcommand{\labelitemi}{{\raisebox{0.25ex}{\footnotesize$\bullet$}}}
    3653\renewenvironment{itemize}{\begin{list}{\labelitemi}{\topsep=5pt\itemsep=5pt\parsep=0pt}}{\end{list}}
     
    5976\renewcommand\section{\@startsection{section}{1}{\z@}{-3.0ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\large\bfseries}}
    6077\renewcommand\subsection{\@startsection{subsection}{2}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
    61 \renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}{-2.0ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
     78\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
    6279\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}{-2.0ex \@plus -1ex \@minus -.2ex}{-1em}{\normalfont\normalsize\bfseries}}
    6380
     81% index macros
    6482\newcommand{\italic}[1]{\emph{\hyperpage{#1}}}
    6583\newcommand{\definition}[1]{\textbf{\hyperpage{#1}}}
     
    97115
    98116% blocks and titles
    99 \newcommand{\define}[1]{\emph{#1\/}\index{#1}}
    100117\newenvironment{rationale}{%
    101118  \begin{quotation}\noindent$\Box$\enspace
     
    103120  \hfill\enspace$\Box$\end{quotation}
    104121}%
     122\newcommand{\define}[1]{\emph{#1\/}\index{#1}}
    105123\newcommand{\rewrite}{\(\Rightarrow\)}
    106124\newcommand{\rewriterules}{\paragraph{Rewrite Rules}~\par\noindent}
     
    131149\newcommand{\VPageref}[2][page]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}}
    132150
    133 % adjust listings macros
     151% CFA based on ANSI C
    134152\lstdefinelanguage{CFA}[ANSI]{C}%
    135 {morekeywords={asm,_Alignas,_Alignof,_At,_Atomic,_Bool,catch,catchResume,choose,_Complex,context,disable,dtype,enable,
    136         fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,lvalue,_Noreturn,restrict,_Static_assert,
    137         _Thread_local,throw,throwResume,try,type,},
     153{morekeywords={asm,_Alignas,_Alignof,_At,_Atomic,_Bool,catch,catchResume,choose,_Complex,trait,disable,dtype,enable,
     154        fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,lvalue,_Noreturn,otype,restrict,_Static_assert,
     155        _Thread_local,throw,throwResume,try,},
    138156}%
    139157
     
    141159language=CFA,
    142160columns=flexible,
    143 basicstyle=\sf\small,
     161basicstyle=\sf\relsize{-1},
    144162tabsize=4,
    145163xleftmargin=\parindent,
    146164escapechar=@,
    147165keepspaces=true,
    148 %showtabs=true,
    149 %tab=\rightarrowfill,
     166showstringspaces=false,
     167showlines=true,
    150168}%
    151169
     
    174192
    175193\title{\Huge
    176 \CFA (\CFAA) Reference Manual and Rationale
     194\CFA (\CFL) Reference Manual and Rationale
    177195}% title
    178196\author{\huge
     
    280298An instantiation of the generic type is written by specifying the type parameters in parentheses after the name of the generic type generator:
    281299\begin{lstlisting}
    282 forall( type T | sumable( T ) ) struct pair {
     300forall( otype T | sumable( T ) ) struct pair {
    283301        T x;
    284302        T y;
     
    292310Polymorphic functions may have generic types as parameters, and those generic types may use type parameters of the polymorphic function as type parameters of the generic type:
    293311\begin{lstlisting}
    294 forall( type T ) void swap( pair(T) *p ) {
     312forall( otype T ) void swap( pair(T) *p ) {
    295313        T z = p->x;
    296314        p->x = p->y;
     
    302320\subsubsection{Constraints}
    303321
    304 To avoid unduly constraining implementors, the generic type generator definition must be visible at any point where it is instantiated.  Forward declarations of generic type generators are not forbidden, but the definition must be visible to instantiate the generic type.  Equivalently, instantiations of generic types are not allowed to be incomplete types.
     322To avoid unduly constraining implementors, the generic type generator definition must be visible at any point where it is instantiated.
     323Forward declarations of generic type generators are not forbidden, but the definition must be visible to instantiate the generic type.  Equivalently, instantiations of generic types are not allowed to be incomplete types.
    305324
    306325\examples
    307326\begin{lstlisting}
    308 forall( type T ) struct A;
    309 
    310 forall( type T ) struct B {
     327forall( otype T ) struct A;
     328
     329forall( otype T ) struct B {
    311330        A(T) *a;                        // legal, but cannot instantiate B(T)
    312331};
     
    314333B(T) x;                                 // illegal, *x.a is of an incomplete generic type
    315334 
    316 forall( type T ) struct A {
     335forall( otype T ) struct A {
    317336        B( T ) *b;
    318337};
     
    321340
    322341// box.h:
    323         forall( type T ) struct box;
    324         forall( type T ) box( T ) *make_box( T );
    325         forall( type T ) void use_box( box( T ) *b );
     342        forall( otype T ) struct box;
     343        forall( otype T ) box( T ) *make_box( T );
     344        forall( otype T ) void use_box( box( T ) *b );
    326345       
    327346// main.c:
     
    410429
    411430\subsubsection{Specialization}
    412 A function or value whose type is polymorphic may be implicitly converted to one whose type is
    413 \Index{less polymorphic} by binding values to one or more of its \Index{inferred parameter}.
     431A function or value whose type is polymorphic may be implicitly converted to one whose type is \Index{less polymorphic} by binding values to one or more of its \Index{inferred parameter}.
    414432Any value that is legal for the inferred parameter may be used, including other inferred parameters.
    415433
    416 If, after the inferred parameter binding, an \Index{assertion parameter} has no inferred parameters in its type, then an object or function must be visible at the point of the specialization that has the same identifier as the assertion parameter and has a type that is compatible\index{compatible
    417   type} with or can be specialized to the type of the assertion parameter.  The assertion parameter is bound to that object or function.
     434If, after the inferred parameter binding, an \Index{assertion parameter} has no inferred parameters in its type, then an object or function must be visible at the point of the specialization that has the same identifier as the assertion parameter and has a type that is compatible\index{compatible type} with or can be specialized to the type of the assertion parameter.
     435The assertion parameter is bound to that object or function.
    418436
    419437The type of the specialization is the type of the original with the bound inferred parameters and the bound assertion parameters replaced by their bound values.
     
    422440The type
    423441\begin{lstlisting}
    424 forall( type T, type U ) void (*)( T, U );
     442forall( otype T, otype U ) void (*)( T, U );
    425443\end{lstlisting}
    426444can be specialized to (among other things)
    427445\begin{lstlisting}
    428 forall( type T ) void (*)( T, T );              // U bound to T
    429 forall( type T ) void (*)( T, real );   // U bound to real
    430 forall( type U ) void (*)( real, U );   // T bound to real
     446forall( otype T ) void (*)( T, T );             // U bound to T
     447forall( otype T ) void (*)( T, real );  // U bound to real
     448forall( otype U ) void (*)( real, U );  // T bound to real
    431449void f( real, real );                                   // both bound to real
    432450\end{lstlisting}
     
    434452The type
    435453\begin{lstlisting}
    436 forall( type T | T ?+?( T, T ) ) T (*)( T );
     454forall( otype T | T ?+?( T, T ) ) T (*)( T );
    437455\end{lstlisting}
    438456can be specialized to (among other things)
     
    494512If \lstinline$int$ can represent all the values of \lstinline$unsigned short$, then the cost of an implicit conversion from \lstinline$unsigned short$ to \lstinline$unsigned$ is 2:
    495513\lstinline$unsigned short$ to \lstinline$int$ to \lstinline$unsigned$.
    496 Otherwise,
    497 \lstinline$unsigned short$ is converted directly to \lstinline$unsigned$, and the cost is 1.
     514Otherwise, \lstinline$unsigned short$ is converted directly to \lstinline$unsigned$, and the cost is 1.
    498515
    499516\item
     
    508525        \rhs \lstinline$forall$
    509526        \rhs \lstinline$lvalue$
    510         \rhs \lstinline$context$
     527        \rhs \lstinline$trait$
    511528        \rhs \lstinline$dtype$
    512529        \rhs \lstinline$ftype$
     
    539556A \nonterm{constant-expression} that evaluates to 0 is effectively compatible with every pointer type.
    540557
    541 In C, the integer constants 0 and 1 suffice because the integer promotion rules can convert them to any arithmetic type, and the rules for pointer expressions treat constant expressions evaluating to
    542 0 as a special case.
     558In C, the integer constants 0 and 1 suffice because the integer promotion rules can convert them to any arithmetic type, and the rules for pointer expressions treat constant expressions evaluating to 0 as a special case.
    543559However, user-defined arithmetic types often need the equivalent of a 1 or 0 for their functions or operators, polymorphic functions often need 0 and 1 constants of a type matching their polymorphic parameters, and user-defined pointer-like types may need a null value.
    544560Defining special constants for a user-defined type is more efficient than defining a conversion to the type from \lstinline$_Bool$.
     
    836852\predefined
    837853\begin{lstlisting}
    838 forall( type T ) lvalue T ?[?]( T *, ptrdiff_t );@\use{ptrdiff_t}@
    839 forall( type T ) lvalue _Atomic T ?[?]( _Atomic T *, ptrdiff_t );
    840 forall( type T ) lvalue const T ?[?]( const T *, ptrdiff_t );
    841 forall( type T ) lvalue restrict T ?[?]( restrict T *, ptrdiff_t );
    842 forall( type T ) lvalue volatile T ?[?]( volatile T *, ptrdiff_t );
    843 forall( type T ) lvalue _Atomic const T ?[?]( _Atomic const T *, ptrdiff_t );
    844 forall( type T ) lvalue _Atomic restrict T ?[?]( _Atomic restrict T *, ptrdiff_t );
    845 forall( type T ) lvalue _Atomic volatile T ?[?]( _Atomic volatile T *, ptrdiff_t );
    846 forall( type T ) lvalue const restrict T ?[?]( const restrict T *, ptrdiff_t );
    847 forall( type T ) lvalue const volatile T ?[?]( const volatile T *, ptrdiff_t );
    848 forall( type T ) lvalue restrict volatile T ?[?]( restrict volatile T *, ptrdiff_t );
    849 forall( type T ) lvalue _Atomic const restrict T ?[?]( _Atomic const restrict T *, ptrdiff_t );
    850 forall( type T ) lvalue _Atomic const volatile T ?[?]( _Atomic const volatile T *, ptrdiff_t );
    851 forall( type T ) lvalue _Atomic restrict volatile T ?[?]( _Atomic restrict volatile T *, ptrdiff_t );
    852 forall( type T ) lvalue const restrict volatile T ?[?]( const restrict volatile T *, ptrdiff_t );
    853 forall( type T ) lvalue _Atomic const restrict volatile T ?[?]( _Atomic const restrict volatile T *, ptrdiff_t );
     854forall( otype T ) lvalue T ?[?]( T *, ptrdiff_t );@\use{ptrdiff_t}@
     855forall( otype T ) lvalue _Atomic T ?[?]( _Atomic T *, ptrdiff_t );
     856forall( otype T ) lvalue const T ?[?]( const T *, ptrdiff_t );
     857forall( otype T ) lvalue restrict T ?[?]( restrict T *, ptrdiff_t );
     858forall( otype T ) lvalue volatile T ?[?]( volatile T *, ptrdiff_t );
     859forall( otype T ) lvalue _Atomic const T ?[?]( _Atomic const T *, ptrdiff_t );
     860forall( otype T ) lvalue _Atomic restrict T ?[?]( _Atomic restrict T *, ptrdiff_t );
     861forall( otype T ) lvalue _Atomic volatile T ?[?]( _Atomic volatile T *, ptrdiff_t );
     862forall( otype T ) lvalue const restrict T ?[?]( const restrict T *, ptrdiff_t );
     863forall( otype T ) lvalue const volatile T ?[?]( const volatile T *, ptrdiff_t );
     864forall( otype T ) lvalue restrict volatile T ?[?]( restrict volatile T *, ptrdiff_t );
     865forall( otype T ) lvalue _Atomic const restrict T ?[?]( _Atomic const restrict T *, ptrdiff_t );
     866forall( otype T ) lvalue _Atomic const volatile T ?[?]( _Atomic const volatile T *, ptrdiff_t );
     867forall( otype T ) lvalue _Atomic restrict volatile T ?[?]( _Atomic restrict volatile T *, ptrdiff_t );
     868forall( otype T ) lvalue const restrict volatile T ?[?]( const restrict volatile T *, ptrdiff_t );
     869forall( otype T ) lvalue _Atomic const restrict volatile T ?[?]( _Atomic const restrict volatile T *, ptrdiff_t );
    854870\end{lstlisting}
    855871\semantics
     
    914930\begin{rationale}
    915931One desirable property of a polymorphic programming language is \define{generalizability}: the ability to replace an abstraction with a more general but equivalent abstraction without requiring changes in any of the uses of the original\cite{Cormack90}.
    916 For instance, it should be possible to replace a function ``\lstinline$int f( int );$'' with ``\lstinline$forall( type T ) T f( T );$'' without affecting any calls of \lstinline$f$.
     932For instance, it should be possible to replace a function ``\lstinline$int f( int );$'' with ``\lstinline$forall( otype T ) T f( T );$'' without affecting any calls of \lstinline$f$.
    917933
    918934\CFA\index{deficiencies!generalizability} does not fully possess this property, because
     
    928944f = g( d, f );          // (3) (unsafe conversion to float)
    929945\end{lstlisting}
    930 If \lstinline$g$ was replaced by ``\lstinline$forall( type T ) T g( T, T );$'', the first and second calls would be unaffected, but the third would change: \lstinline$f$ would be converted to
     946If \lstinline$g$ was replaced by ``\lstinline$forall( otype T ) T g( T, T );$'', the first and second calls would be unaffected, but the third would change: \lstinline$f$ would be converted to
    931947\lstinline$double$, and the result would be a \lstinline$double$.
    932948
    933949Another example is the function ``\lstinline$void h( int *);$''.
    934950This function can be passed a
    935 \lstinline$void *$ argument, but the generalization ``\lstinline$forall( type T ) void h( T *);$'' can not.
     951\lstinline$void *$ argument, but the generalization ``\lstinline$forall( otype T ) void h( T *);$'' can not.
    936952In this case, \lstinline$void$ is not a valid value for \lstinline$T$ because it is not an object type.
    937953If unsafe conversions were allowed, \lstinline$T$ could be inferred to be \emph{any} object type, which is undesirable.
     
    941957A function called ``\lstinline$?()$'' might be part of a numerical differentiation package.
    942958\begin{lstlisting}
    943 extern type Derivative;
     959extern otype Derivative;
    944960extern double ?()( Derivative, double );
    945961extern Derivative derivative_of( double (*f)( double ) );
     
    962978
    963979\begin{lstlisting}
    964 forall( type T ) T h( T );
     980forall( otype T ) T h( T );
    965981double d = h( 1.5 );
    966982\end{lstlisting}
     
    969985
    970986\begin{lstlisting}
    971 forall( type T, type U ) void g( T, U );        // (4)
    972 forall( type T ) void g( T, T );                        // (5)
    973 forall( type T ) void g( T, long );                     // (6)
     987forall( otype T, otype U ) void g( T, U );      // (4)
     988forall( otype T ) void g( T, T );                       // (5)
     989forall( otype T ) void g( T, long );                    // (6)
    974990void g( long, long );                                           // (7)
    975991double d;
     
    9911007The fourth call has no interpretation for (5), because its arguments must have compatible type. (4) is chosen because it does not involve unsafe conversions.
    9921008\begin{lstlisting}
    993 forall( type T ) T min( T, T );
     1009forall( otype T ) T min( T, T );
    9941010double max( double, double );
    995 context min_max( T ) {@\impl{min_max}@
     1011trait min_max( T ) {@\impl{min_max}@
    9961012        T min( T, T );
    9971013        T max( T, T );
    9981014}
    999 forall( type U | min_max( U ) ) void shuffle( U, U );
     1015forall( otype U | min_max( U ) ) void shuffle( U, U );
    10001016shuffle( 9, 10 );
    10011017\end{lstlisting}
     
    10471063long double ?++( volatile long double * ), ?++( _Atomic volatile long double * );
    10481064
    1049 forall( type T ) T * ?++( T * restrict volatile * ), * ?++( T * _Atomic restrict volatile * );
    1050 forall( type T ) _Atomic T * ?++( _Atomic T * restrict volatile * ), * ?++( _Atomic T * _Atomic restrict volatile * );
    1051 forall( type T ) const T * ?++( const T * restrict volatile * ), * ?++( const T * _Atomic restrict volatile * );
    1052 forall( type T ) volatile T * ?++( volatile T * restrict volatile * ), * ?++( volatile T * _Atomic restrict volatile * );
    1053 forall( type T ) restrict T * ?++( restrict T * restrict volatile * ), * ?++( restrict T * _Atomic restrict volatile * );
    1054 forall( type T ) _Atomic const T * ?++( _Atomic const T * restrict volatile * ),
     1065forall( otype T ) T * ?++( T * restrict volatile * ), * ?++( T * _Atomic restrict volatile * );
     1066forall( otype T ) _Atomic T * ?++( _Atomic T * restrict volatile * ), * ?++( _Atomic T * _Atomic restrict volatile * );
     1067forall( otype T ) const T * ?++( const T * restrict volatile * ), * ?++( const T * _Atomic restrict volatile * );
     1068forall( otype T ) volatile T * ?++( volatile T * restrict volatile * ), * ?++( volatile T * _Atomic restrict volatile * );
     1069forall( otype T ) restrict T * ?++( restrict T * restrict volatile * ), * ?++( restrict T * _Atomic restrict volatile * );
     1070forall( otype T ) _Atomic const T * ?++( _Atomic const T * restrict volatile * ),
    10551071        * ?++( _Atomic const T * _Atomic restrict volatile * );
    1056 forall( type T ) _Atomic restrict T * ?++( _Atomic restrict T * restrict volatile * ),
     1072forall( otype T ) _Atomic restrict T * ?++( _Atomic restrict T * restrict volatile * ),
    10571073        * ?++( _Atomic restrict T * _Atomic restrict volatile * );
    1058 forall( type T ) _Atomic volatile T * ?++( _Atomic volatile T * restrict volatile * ),
     1074forall( otype T ) _Atomic volatile T * ?++( _Atomic volatile T * restrict volatile * ),
    10591075        * ?++( _Atomic volatile T * _Atomic restrict volatile * );
    1060 forall( type T ) const restrict T * ?++( const restrict T * restrict volatile * ),
     1076forall( otype T ) const restrict T * ?++( const restrict T * restrict volatile * ),
    10611077        * ?++( const restrict T * _Atomic restrict volatile * );
    1062 forall( type T ) const volatile T * ?++( const volatile T * restrict volatile * ),
     1078forall( otype T ) const volatile T * ?++( const volatile T * restrict volatile * ),
    10631079        * ?++( const volatile T * _Atomic restrict volatile * );
    1064 forall( type T ) restrict volatile T * ?++( restrict volatile T * restrict volatile * ),
     1080forall( otype T ) restrict volatile T * ?++( restrict volatile T * restrict volatile * ),
    10651081        * ?++( restrict volatile T * _Atomic restrict volatile * );
    1066 forall( type T ) _Atomic const restrict T * ?++( _Atomic const restrict T * restrict volatile * ),
     1082forall( otype T ) _Atomic const restrict T * ?++( _Atomic const restrict T * restrict volatile * ),
    10671083        * ?++( _Atomic const restrict T * _Atomic restrict volatile * );
    1068 forall( type T ) _Atomic const volatile T * ?++( _Atomic const volatile T * restrict volatile * ),
     1084forall( otype T ) _Atomic const volatile T * ?++( _Atomic const volatile T * restrict volatile * ),
    10691085        * ?++( _Atomic const volatile T * _Atomic restrict volatile * );
    1070 forall( type T ) _Atomic restrict volatile T * ?++( _Atomic restrict volatile T * restrict volatile * ),
     1086forall( otype T ) _Atomic restrict volatile T * ?++( _Atomic restrict volatile T * restrict volatile * ),
    10711087        * ?++( _Atomic restrict volatile T * _Atomic restrict volatile * );
    1072 forall( type T ) const restrict volatile T * ?++( const restrict volatile T * restrict volatile * ),
     1088forall( otype T ) const restrict volatile T * ?++( const restrict volatile T * restrict volatile * ),
    10731089        * ?++( const restrict volatile T * _Atomic restrict volatile * );
    1074 forall( type T ) _Atomic const restrict volatile T * ?++( _Atomic const restrict volatile T * restrict volatile * ),
     1090forall( otype T ) _Atomic const restrict volatile T * ?++( _Atomic const restrict volatile T * restrict volatile * ),
    10751091        * ?++( _Atomic const restrict volatile T * _Atomic restrict volatile * );
    10761092
     
    10911107long double ?--( volatile long double * ), ?--( _Atomic volatile long double * );
    10921108
    1093 forall( type T ) T * ?--( T * restrict volatile * ), * ?--( T * _Atomic restrict volatile * );
    1094 forall( type T ) _Atomic T * ?--( _Atomic T * restrict volatile * ), * ?--( _Atomic T * _Atomic restrict volatile * );
    1095 forall( type T ) const T * ?--( const T * restrict volatile * ), * ?--( const T * _Atomic restrict volatile * );
    1096 forall( type T ) volatile T * ?--( volatile T * restrict volatile * ), * ?--( volatile T * _Atomic restrict volatile * );
    1097 forall( type T ) restrict T * ?--( restrict T * restrict volatile * ), * ?--( restrict T * _Atomic restrict volatile * );
    1098 forall( type T ) _Atomic const T * ?--( _Atomic const T * restrict volatile * ),
     1109forall( otype T ) T * ?--( T * restrict volatile * ), * ?--( T * _Atomic restrict volatile * );
     1110forall( otype T ) _Atomic T * ?--( _Atomic T * restrict volatile * ), * ?--( _Atomic T * _Atomic restrict volatile * );
     1111forall( otype T ) const T * ?--( const T * restrict volatile * ), * ?--( const T * _Atomic restrict volatile * );
     1112forall( otype T ) volatile T * ?--( volatile T * restrict volatile * ), * ?--( volatile T * _Atomic restrict volatile * );
     1113forall( otype T ) restrict T * ?--( restrict T * restrict volatile * ), * ?--( restrict T * _Atomic restrict volatile * );
     1114forall( otype T ) _Atomic const T * ?--( _Atomic const T * restrict volatile * ),
    10991115        * ?--( _Atomic const T * _Atomic restrict volatile * );
    1100 forall( type T ) _Atomic restrict T * ?--( _Atomic restrict T * restrict volatile * ),
     1116forall( otype T ) _Atomic restrict T * ?--( _Atomic restrict T * restrict volatile * ),
    11011117        * ?--( _Atomic restrict T * _Atomic restrict volatile * );
    1102 forall( type T ) _Atomic volatile T * ?--( _Atomic volatile T * restrict volatile * ),
     1118forall( otype T ) _Atomic volatile T * ?--( _Atomic volatile T * restrict volatile * ),
    11031119        * ?--( _Atomic volatile T * _Atomic restrict volatile * );
    1104 forall( type T ) const restrict T * ?--( const restrict T * restrict volatile * ),
     1120forall( otype T ) const restrict T * ?--( const restrict T * restrict volatile * ),
    11051121        * ?--( const restrict T * _Atomic restrict volatile * );
    1106 forall( type T ) const volatile T * ?--( const volatile T * restrict volatile * ),
     1122forall( otype T ) const volatile T * ?--( const volatile T * restrict volatile * ),
    11071123        * ?--( const volatile T * _Atomic restrict volatile * );
    1108 forall( type T ) restrict volatile T * ?--( restrict volatile T * restrict volatile * ),
     1124forall( otype T ) restrict volatile T * ?--( restrict volatile T * restrict volatile * ),
    11091125        * ?--( restrict volatile T * _Atomic restrict volatile * );
    1110 forall( type T ) _Atomic const restrict T * ?--( _Atomic const restrict T * restrict volatile * ),
     1126forall( otype T ) _Atomic const restrict T * ?--( _Atomic const restrict T * restrict volatile * ),
    11111127        * ?--( _Atomic const restrict T * _Atomic restrict volatile * );
    1112 forall( type T ) _Atomic const volatile T * ?--( _Atomic const volatile T * restrict volatile * ),
     1128forall( otype T ) _Atomic const volatile T * ?--( _Atomic const volatile T * restrict volatile * ),
    11131129        * ?--( _Atomic const volatile T * _Atomic restrict volatile * );
    1114 forall( type T ) _Atomic restrict volatile T * ?--( _Atomic restrict volatile T * restrict volatile * ),
     1130forall( otype T ) _Atomic restrict volatile T * ?--( _Atomic restrict volatile T * restrict volatile * ),
    11151131        * ?--( _Atomic restrict volatile T * _Atomic restrict volatile * );
    1116 forall( type T ) const restrict volatile T * ?--( const restrict volatile T * restrict volatile * ),
     1132forall( otype T ) const restrict volatile T * ?--( const restrict volatile T * restrict volatile * ),
    11171133        * ?--( const restrict volatile T * _Atomic restrict volatile * );
    1118 forall( type T ) _Atomic const restrict volatile T * ?--( _Atomic const restrict volatile T * restrict volatile * ),
     1134forall( otype T ) _Atomic const restrict volatile T * ?--( _Atomic const restrict volatile T * restrict volatile * ),
    11191135        * ?--( _Atomic const restrict volatile T * _Atomic restrict volatile * );
    11201136\end{lstlisting}
     
    11951211The expression would be valid if \lstinline$?++$ were declared by
    11961212\begin{lstlisting}
    1197 forall( type T ) T * ?++( T * * );
     1213forall( otype T ) T * ?++( T * * );
    11981214\end{lstlisting} with \lstinline$T$ inferred to be \lstinline$char$.
    11991215
     
    12031219Hence the actual predefined function is
    12041220\begin{lstlisting}
    1205 forall( type T ) T * ?++( T * restrict volatile * );
     1221forall( otype T ) T * ?++( T * restrict volatile * );
    12061222\end{lstlisting} which also accepts a \lstinline$char * *$ argument, because of the safe conversions that add
    12071223\lstinline$volatile$ and \lstinline$restrict$ qualifiers. (The parameter is not const-qualified, so constant pointers cannot be incremented.)
     
    12171233\lstinline$char const volatile *$, so a new overloading is needed:
    12181234\begin{lstlisting}
    1219 forall( type T ) T const volatile * ?++( T const volatile *restrict volatile * );
     1235forall( otype T ) T const volatile * ?++( T const volatile *restrict volatile * );
    12201236\end{lstlisting}
    12211237One overloading is needed for each combination of qualifiers in the pointed-at type\index{deficiencies!pointers to qualified types}.
     
    12251241The \lstinline$restrict$ qualifier is handled just like \lstinline$const$ and \lstinline$volatile$ in the previous case:
    12261242\begin{lstlisting}
    1227 forall( type T ) T restrict * ?++( T restrict *restrict volatile * );
     1243forall( otype T ) T restrict * ?++( T restrict *restrict volatile * );
    12281244\end{lstlisting} with \lstinline$T$ inferred to be \lstinline$float *$.
    12291245This looks odd, because {\c11} contains a constraint that requires restrict-qualified types to be pointer-to-object types, and \lstinline$T$ is not syntactically a pointer type. \CFA loosens the constraint.
     
    12831299long double ++?( volatile long double * ), ++?( _Atomic volatile long double * );
    12841300
    1285 forall( type T ) T * ++?( T * restrict volatile * ), * ++?( T * _Atomic restrict volatile * );
    1286 forall( type T ) _Atomic T * ++?( _Atomic T * restrict volatile * ), * ++?( _Atomic T * _Atomic restrict volatile * );
    1287 forall( type T ) const T * ++?( const T * restrict volatile * ), * ++?( const T * _Atomic restrict volatile * );
    1288 forall( type T ) volatile T * ++?( volatile T * restrict volatile * ), * ++?( volatile T * _Atomic restrict volatile * );
    1289 forall( type T ) restrict T * ++?( restrict T * restrict volatile * ), * ++?( restrict T * _Atomic restrict volatile * );
    1290 forall( type T ) _Atomic const T * ++?( _Atomic const T * restrict volatile * ),
     1301forall( otype T ) T * ++?( T * restrict volatile * ), * ++?( T * _Atomic restrict volatile * );
     1302forall( otype T ) _Atomic T * ++?( _Atomic T * restrict volatile * ), * ++?( _Atomic T * _Atomic restrict volatile * );
     1303forall( otype T ) const T * ++?( const T * restrict volatile * ), * ++?( const T * _Atomic restrict volatile * );
     1304forall( otype T ) volatile T * ++?( volatile T * restrict volatile * ), * ++?( volatile T * _Atomic restrict volatile * );
     1305forall( otype T ) restrict T * ++?( restrict T * restrict volatile * ), * ++?( restrict T * _Atomic restrict volatile * );
     1306forall( otype T ) _Atomic const T * ++?( _Atomic const T * restrict volatile * ),
    12911307        * ++?( _Atomic const T * _Atomic restrict volatile * );
    1292 forall( type T ) _Atomic volatile T * ++?( _Atomic volatile T * restrict volatile * ),
     1308forall( otype T ) _Atomic volatile T * ++?( _Atomic volatile T * restrict volatile * ),
    12931309        * ++?( _Atomic volatile T * _Atomic restrict volatile * );
    1294 forall( type T ) _Atomic restrict T * ++?( _Atomic restrict T * restrict volatile * ),
     1310forall( otype T ) _Atomic restrict T * ++?( _Atomic restrict T * restrict volatile * ),
    12951311        * ++?( _Atomic restrict T * _Atomic restrict volatile * );
    1296 forall( type T ) const volatile T * ++?( const volatile T * restrict volatile * ),
     1312forall( otype T ) const volatile T * ++?( const volatile T * restrict volatile * ),
    12971313        * ++?( const volatile T * _Atomic restrict volatile * );
    1298 forall( type T ) const restrict T * ++?( const restrict T * restrict volatile * ),
     1314forall( otype T ) const restrict T * ++?( const restrict T * restrict volatile * ),
    12991315        * ++?( const restrict T * _Atomic restrict volatile * );
    1300 forall( type T ) restrict volatile T * ++?( restrict volatile T * restrict volatile * ),
     1316forall( otype T ) restrict volatile T * ++?( restrict volatile T * restrict volatile * ),
    13011317        * ++?( restrict volatile T * _Atomic restrict volatile * );
    1302 forall( type T ) _Atomic const volatile T * ++?( _Atomic const volatile T * restrict volatile * ),
     1318forall( otype T ) _Atomic const volatile T * ++?( _Atomic const volatile T * restrict volatile * ),
    13031319        * ++?( _Atomic const volatile T * _Atomic restrict volatile * );
    1304 forall( type T ) _Atomic const restrict T * ++?( _Atomic const restrict T * restrict volatile * ),
     1320forall( otype T ) _Atomic const restrict T * ++?( _Atomic const restrict T * restrict volatile * ),
    13051321        * ++?( _Atomic const restrict T * _Atomic restrict volatile * );
    1306 forall( type T ) _Atomic restrict volatile T * ++?( _Atomic restrict volatile T * restrict volatile * ),
     1322forall( otype T ) _Atomic restrict volatile T * ++?( _Atomic restrict volatile T * restrict volatile * ),
    13071323        * ++?( _Atomic restrict volatile T * _Atomic restrict volatile * );
    1308 forall( type T ) const restrict volatile T * ++?( const restrict volatile T * restrict volatile * ),
     1324forall( otype T ) const restrict volatile T * ++?( const restrict volatile T * restrict volatile * ),
    13091325        * ++?( const restrict volatile T * _Atomic restrict volatile * );
    1310 forall( type T ) _Atomic const restrict volatile T * ++?( _Atomic const restrict volatile T * restrict volatile * ),
     1326forall( otype T ) _Atomic const restrict volatile T * ++?( _Atomic const restrict volatile T * restrict volatile * ),
    13111327        * ++?( _Atomic const restrict volatile T * _Atomic restrict volatile * );
    13121328
     
    13271343long double --?( volatile long double * ), --?( _Atomic volatile long double * );
    13281344
    1329 forall( type T ) T * --?( T * restrict volatile * ), * --?( T * _Atomic restrict volatile * );
    1330 forall( type T ) _Atomic T * --?( _Atomic T * restrict volatile * ), * --?( _Atomic T * _Atomic restrict volatile * );
    1331 forall( type T ) const T * --?( const T * restrict volatile * ), * --?( const T * _Atomic restrict volatile * );
    1332 forall( type T ) volatile T * --?( volatile T * restrict volatile * ), * --?( volatile T * _Atomic restrict volatile * );
    1333 forall( type T ) restrict T * --?( restrict T * restrict volatile * ), * --?( restrict T * _Atomic restrict volatile * );
    1334 forall( type T ) _Atomic const T * --?( _Atomic const T * restrict volatile * ),
     1345forall( otype T ) T * --?( T * restrict volatile * ), * --?( T * _Atomic restrict volatile * );
     1346forall( otype T ) _Atomic T * --?( _Atomic T * restrict volatile * ), * --?( _Atomic T * _Atomic restrict volatile * );
     1347forall( otype T ) const T * --?( const T * restrict volatile * ), * --?( const T * _Atomic restrict volatile * );
     1348forall( otype T ) volatile T * --?( volatile T * restrict volatile * ), * --?( volatile T * _Atomic restrict volatile * );
     1349forall( otype T ) restrict T * --?( restrict T * restrict volatile * ), * --?( restrict T * _Atomic restrict volatile * );
     1350forall( otype T ) _Atomic const T * --?( _Atomic const T * restrict volatile * ),
    13351351        * --?( _Atomic const T * _Atomic restrict volatile * );
    1336 forall( type T ) _Atomic volatile T * --?( _Atomic volatile T * restrict volatile * ),
     1352forall( otype T ) _Atomic volatile T * --?( _Atomic volatile T * restrict volatile * ),
    13371353        * --?( _Atomic volatile T * _Atomic restrict volatile * );
    1338 forall( type T ) _Atomic restrict T * --?( _Atomic restrict T * restrict volatile * ),
     1354forall( otype T ) _Atomic restrict T * --?( _Atomic restrict T * restrict volatile * ),
    13391355        * --?( _Atomic restrict T * _Atomic restrict volatile * );
    1340 forall( type T ) const volatile T * --?( const volatile T * restrict volatile * ),
     1356forall( otype T ) const volatile T * --?( const volatile T * restrict volatile * ),
    13411357        * --?( const volatile T * _Atomic restrict volatile * );
    1342 forall( type T ) const restrict T * --?( const restrict T * restrict volatile * ),
     1358forall( otype T ) const restrict T * --?( const restrict T * restrict volatile * ),
    13431359        * --?( const restrict T * _Atomic restrict volatile * );
    1344 forall( type T ) restrict volatile T * --?( restrict volatile T * restrict volatile * ),
     1360forall( otype T ) restrict volatile T * --?( restrict volatile T * restrict volatile * ),
    13451361        * --?( restrict volatile T * _Atomic restrict volatile * );
    1346 forall( type T ) _Atomic const volatile T * --?( _Atomic const volatile T * restrict volatile * ),
     1362forall( otype T ) _Atomic const volatile T * --?( _Atomic const volatile T * restrict volatile * ),
    13471363        * --?( _Atomic const volatile T * _Atomic restrict volatile * );
    1348 forall( type T ) _Atomic const restrict T * --?( _Atomic const restrict T * restrict volatile * ),
     1364forall( otype T ) _Atomic const restrict T * --?( _Atomic const restrict T * restrict volatile * ),
    13491365        * --?( _Atomic const restrict T * _Atomic restrict volatile * );
    1350 forall( type T ) _Atomic restrict volatile T * --?( _Atomic restrict volatile T * restrict volatile * ),
     1366forall( otype T ) _Atomic restrict volatile T * --?( _Atomic restrict volatile T * restrict volatile * ),
    13511367        * --?( _Atomic restrict volatile T * _Atomic restrict volatile * );
    1352 forall( type T ) const restrict volatile T * --?( const restrict volatile T * restrict volatile * ),
     1368forall( otype T ) const restrict volatile T * --?( const restrict volatile T * restrict volatile * ),
    13531369        * --?( const restrict volatile T * _Atomic restrict volatile * );
    1354 forall( type T ) _Atomic const restrict volatile T * --?( _Atomic const restrict volatile T * restrict volatile * ),
     1370forall( otype T ) _Atomic const restrict volatile T * --?( _Atomic const restrict volatile T * restrict volatile * ),
    13551371        * --?( _Atomic const restrict volatile T * _Atomic restrict volatile * );
    13561372\end{lstlisting}
     
    13801396\predefined
    13811397\begin{lstlisting}
    1382 forall( type T ) lvalue T *?( T * );
    1383 forall( type T ) _Atomic lvalue T *?( _Atomic T * );
    1384 forall( type T ) const lvalue T *?( const T * );
    1385 forall( type T ) volatile lvalue T *?( volatile T * );
    1386 forall( type T ) restrict lvalue T *?( restrict T * );
    1387 forall( type T ) _Atomic const lvalue T *?( _Atomic const T * );
    1388 forall( type T ) _Atomic volatile lvalue T *?( _Atomic volatile T * );
    1389 forall( type T ) _Atomic restrict lvalue T *?( _Atomic restrict T * );
    1390 forall( type T ) const volatile lvalue T *?( const volatile T * );
    1391 forall( type T ) const restrict lvalue T *?( const restrict T * );
    1392 forall( type T ) restrict volatile lvalue T *?( restrict volatile T * );
    1393 forall( type T ) _Atomic const volatile lvalue T *?( _Atomic const volatile T * );
    1394 forall( type T ) _Atomic const restrict lvalue T *?( _Atomic const restrict T * );
    1395 forall( type T ) _Atomic restrict volatile lvalue T *?( _Atomic restrict volatile T * );
    1396 forall( type T ) const restrict volatile lvalue T *?( const restrict volatile T * );
    1397 forall( type T ) _Atomic const restrict volatile lvalue T *?( _Atomic const restrict volatile T * );
     1398forall( otype T ) lvalue T *?( T * );
     1399forall( otype T ) _Atomic lvalue T *?( _Atomic T * );
     1400forall( otype T ) const lvalue T *?( const T * );
     1401forall( otype T ) volatile lvalue T *?( volatile T * );
     1402forall( otype T ) restrict lvalue T *?( restrict T * );
     1403forall( otype T ) _Atomic const lvalue T *?( _Atomic const T * );
     1404forall( otype T ) _Atomic volatile lvalue T *?( _Atomic volatile T * );
     1405forall( otype T ) _Atomic restrict lvalue T *?( _Atomic restrict T * );
     1406forall( otype T ) const volatile lvalue T *?( const volatile T * );
     1407forall( otype T ) const restrict lvalue T *?( const restrict T * );
     1408forall( otype T ) restrict volatile lvalue T *?( restrict volatile T * );
     1409forall( otype T ) _Atomic const volatile lvalue T *?( _Atomic const volatile T * );
     1410forall( otype T ) _Atomic const restrict lvalue T *?( _Atomic const restrict T * );
     1411forall( otype T ) _Atomic restrict volatile lvalue T *?( _Atomic restrict volatile T * );
     1412forall( otype T ) const restrict volatile lvalue T *?( const restrict volatile T * );
     1413forall( otype T ) _Atomic const restrict volatile lvalue T *?( _Atomic const restrict volatile T * );
    13981414forall( ftype FT ) FT *?( FT * );
    13991415\end{lstlisting}
     
    15101526\begin{rationale}
    15111527\begin{lstlisting}
    1512 type Pair = struct { int first, second; };
     1528otype Pair = struct { int first, second; };
    15131529size_t p_size = sizeof(Pair);           // constant expression
    1514 extern type Rational;@\use{Rational}@
     1530extern otype Rational;@\use{Rational}@
    15151531size_t c_size = sizeof(Rational);       // non-constant expression
    15161532forall(type T) T f(T p1, T p2) {
     
    16361652Consider
    16371653\begin{lstlisting}
    1638 forall( type T | T ?*?( T, T ) ) T square( T );
     1654forall( otype T | T ?*?( T, T ) ) T square( T );
    16391655short s;
    16401656square( s );
     
    16471663A more troubling example is
    16481664\begin{lstlisting}
    1649 forall( type T | ?*?( T, T ) ) T product( T[], int n );
     1665forall( otype T | ?*?( T, T ) ) T product( T[], int n );
    16501666short sa[5];
    16511667product( sa, 5);
     
    17041720        ?+?( _Complex long double, _Complex long double ), ?-?( _Complex long double, _Complex long double );
    17051721
    1706 forall( type T ) T * ?+?( T *, ptrdiff_t ), * ?+?( ptrdiff_t, T * ), * ?-?( T *, ptrdiff_t );
    1707 forall( type T ) _Atomic T * ?+?( _Atomic T *, ptrdiff_t ), * ?+?( ptrdiff_t, _Atomic T * ),
     1722forall( otype T ) T * ?+?( T *, ptrdiff_t ), * ?+?( ptrdiff_t, T * ), * ?-?( T *, ptrdiff_t );
     1723forall( otype T ) _Atomic T * ?+?( _Atomic T *, ptrdiff_t ), * ?+?( ptrdiff_t, _Atomic T * ),
    17081724        * ?-?( _Atomic T *, ptrdiff_t );
    1709 forall( type T ) const T * ?+?( const T *, ptrdiff_t ), * ?+?( ptrdiff_t, const T * ),
     1725forall( otype T ) const T * ?+?( const T *, ptrdiff_t ), * ?+?( ptrdiff_t, const T * ),
    17101726        * ?-?( const T *, ptrdiff_t );
    1711 forall( type T ) restrict T * ?+?( restrict T *, ptrdiff_t ), * ?+?( ptrdiff_t, restrict T * ),
     1727forall( otype T ) restrict T * ?+?( restrict T *, ptrdiff_t ), * ?+?( ptrdiff_t, restrict T * ),
    17121728        * ?-?( restrict T *, ptrdiff_t );
    1713 forall( type T ) volatile T * ?+?( volatile T *, ptrdiff_t ), * ?+?( ptrdiff_t, volatile T * ),
     1729forall( otype T ) volatile T * ?+?( volatile T *, ptrdiff_t ), * ?+?( ptrdiff_t, volatile T * ),
    17141730        * ?-?( volatile T *, ptrdiff_t );
    1715 forall( type T ) _Atomic const T * ?+?( _Atomic const T *, ptrdiff_t ), * ?+?( ptrdiff_t, _Atomic const T * ),
     1731forall( otype T ) _Atomic const T * ?+?( _Atomic const T *, ptrdiff_t ), * ?+?( ptrdiff_t, _Atomic const T * ),
    17161732        * ?-?( _Atomic const T *, ptrdiff_t );
    1717 forall( type T ) _Atomic restrict T * ?+?( _Atomic restrict T *, ptrdiff_t ), * ?+?( ptrdiff_t, _Atomic restrict T * ),
     1733forall( otype T ) _Atomic restrict T * ?+?( _Atomic restrict T *, ptrdiff_t ), * ?+?( ptrdiff_t, _Atomic restrict T * ),
    17181734        * ?-?( _Atomic restrict T *, ptrdiff_t );
    1719 forall( type T ) _Atomic volatile T * ?+?( _Atomic volatile T *, ptrdiff_t ), * ?+?( ptrdiff_t, _Atomic volatile T * ),
     1735forall( otype T ) _Atomic volatile T * ?+?( _Atomic volatile T *, ptrdiff_t ), * ?+?( ptrdiff_t, _Atomic volatile T * ),
    17201736        * ?-?( _Atomic volatile T *, ptrdiff_t );
    1721 forall( type T ) const restrict T * ?+?( const restrict T *, ptrdiff_t ), * ?+?( ptrdiff_t, const restrict T * ),
     1737forall( otype T ) const restrict T * ?+?( const restrict T *, ptrdiff_t ), * ?+?( ptrdiff_t, const restrict T * ),
    17221738        * ?-?( const restrict T *, ptrdiff_t );
    1723 forall( type T ) const volatile T * ?+?( const volatile T *, ptrdiff_t ), * ?+?( ptrdiff_t, const volatile T * ),
     1739forall( otype T ) const volatile T * ?+?( const volatile T *, ptrdiff_t ), * ?+?( ptrdiff_t, const volatile T * ),
    17241740        * ?-?( const volatile T *, ptrdiff_t );
    1725 forall( type T ) restrict volatile T * ?+?( restrict volatile T *, ptrdiff_t ), * ?+?( ptrdiff_t, restrict volatile T * ),
     1741forall( otype T ) restrict volatile T * ?+?( restrict volatile T *, ptrdiff_t ), * ?+?( ptrdiff_t, restrict volatile T * ),
    17261742        * ?-?( restrict volatile T *, ptrdiff_t );
    1727 forall( type T ) _Atomic const restrict T * ?+?( _Atomic const restrict T *, ptrdiff_t ),
     1743forall( otype T ) _Atomic const restrict T * ?+?( _Atomic const restrict T *, ptrdiff_t ),
    17281744        * ?+?( ptrdiff_t, _Atomic const restrict T * ),
    17291745        * ?-?( _Atomic const restrict T *, ptrdiff_t );
    1730 forall( type T ) ptrdiff_t
     1746forall( otype T ) ptrdiff_t
    17311747        * ?-?( const restrict volatile T *, const restrict volatile T * ),
    17321748        * ?-?( _Atomic const restrict volatile T *, _Atomic const restrict volatile T * );
     
    20522068
    20532069\begin{lstlisting}
    2054 extern type Rational;@\use{Rational}@
     2070extern otype Rational;@\use{Rational}@
    20552071extern const Rational 0;@\use{0}@
    20562072extern int ?!=?( Rational, Rational );
     
    20952111If the second and third operands both have interpretations with non-\lstinline$void$ types, the expression is treated as if it were the call ``\lstinline$cond((a)!=0, b, c)$'', with \lstinline$cond$ declared as
    20962112\begin{lstlisting}
    2097 forall( type T ) T cond( int, T, T );
     2113forall( otype T ) T cond( int, T, T );
    20982114forall( dtype D ) void * cond( int, D *, void * ), * cond( int, void *, D * );
    20992115forall( dtype D ) _atomic void * cond(
     
    24552471\predefined
    24562472\begin{lstlisting}
    2457 forall( type T ) T
     2473forall( otype T ) T
    24582474        * ?+=?( T * restrict volatile *, ptrdiff_t ),
    24592475        * ?-=?( T * restrict volatile *, ptrdiff_t ),
    24602476        * ?+=?( T * _Atomic restrict volatile *, ptrdiff_t ),
    24612477        * ?-=?( T * _Atomic restrict volatile *, ptrdiff_t );
    2462 forall( type T ) T _Atomic
     2478forall( otype T ) T _Atomic
    24632479        * ?+=?( T _Atomic * restrict volatile *, ptrdiff_t ),
    24642480        * ?-=?( T _Atomic * restrict volatile *, ptrdiff_t ),
    24652481        * ?+=?( T _Atomic * _Atomic restrict volatile *, ptrdiff_t ),
    24662482        * ?-=?( T _Atomic * _Atomic restrict volatile *, ptrdiff_t );
    2467 forall( type T ) T const
     2483forall( otype T ) T const
    24682484        * ?+=?( T const * restrict volatile *, ptrdiff_t ),
    24692485        * ?-=?( T const * restrict volatile *, ptrdiff_t ),
    24702486        * ?+=?( T const * _Atomic restrict volatile *, ptrdiff_t ),
    24712487        * ?-=?( T const * _Atomic restrict volatile *, ptrdiff_t );
    2472 forall( type T ) T restrict
     2488forall( otype T ) T restrict
    24732489        * ?+=?( T restrict * restrict volatile *, ptrdiff_t ),
    24742490        * ?-=?( T restrict * restrict volatile *, ptrdiff_t ),
    24752491        * ?+=?( T restrict * _Atomic restrict volatile *, ptrdiff_t ),
    24762492        * ?-=?( T restrict * _Atomic restrict volatile *, ptrdiff_t );
    2477 forall( type T ) T volatile
     2493forall( otype T ) T volatile
    24782494        * ?+=?( T volatile * restrict volatile *, ptrdiff_t ),
    24792495        * ?-=?( T volatile * restrict volatile *, ptrdiff_t ),
    24802496        * ?+=?( T volatile * _Atomic restrict volatile *, ptrdiff_t ),
    24812497        * ?-=?( T volatile * _Atomic restrict volatile *, ptrdiff_t );
    2482 forall( type T ) T _Atomic const
     2498forall( otype T ) T _Atomic const
    24832499        * ?+=?( T _Atomic const restrict volatile *, ptrdiff_t ),
    24842500        * ?-=?( T _Atomic const restrict volatile *, ptrdiff_t ),
    24852501        * ?+=?( T _Atomic const _Atomic restrict volatile *, ptrdiff_t ),
    24862502        * ?-=?( T _Atomic const _Atomic restrict volatile *, ptrdiff_t );
    2487 forall( type T ) T _Atomic restrict
     2503forall( otype T ) T _Atomic restrict
    24882504        * ?+=?( T _Atomic restrict * restrict volatile *, ptrdiff_t ),
    24892505        * ?-=?( T _Atomic restrict * restrict volatile *, ptrdiff_t ),
    24902506        * ?+=?( T _Atomic restrict * _Atomic restrict volatile *, ptrdiff_t ),
    24912507        * ?-=?( T _Atomic restrict * _Atomic restrict volatile *, ptrdiff_t );
    2492 forall( type T ) T _Atomic volatile
     2508forall( otype T ) T _Atomic volatile
    24932509        * ?+=?( T _Atomic volatile * restrict volatile *, ptrdiff_t ),
    24942510        * ?-=?( T _Atomic volatile * restrict volatile *, ptrdiff_t ),
    24952511        * ?+=?( T _Atomic volatile * _Atomic restrict volatile *, ptrdiff_t ),
    24962512        * ?-=?( T _Atomic volatile * _Atomic restrict volatile *, ptrdiff_t );
    2497 forall( type T ) T const restrict
     2513forall( otype T ) T const restrict
    24982514        * ?+=?( T const restrict * restrict volatile *, ptrdiff_t ),
    24992515        * ?-=?( T const restrict * restrict volatile *, ptrdiff_t ),
    25002516        * ?+=?( T const restrict * _Atomic restrict volatile *, ptrdiff_t ),
    25012517        * ?-=?( T const restrict * _Atomic restrict volatile *, ptrdiff_t );
    2502 forall( type T ) T const volatile
     2518forall( otype T ) T const volatile
    25032519        * ?+=?( T const volatile * restrict volatile *, ptrdiff_t ),
    25042520        * ?-=?( T const volatile * restrict volatile *, ptrdiff_t ),
    25052521        * ?+=?( T const volatile * _Atomic restrict volatile *, ptrdiff_t ),
    25062522        * ?-=?( T const volatile * _Atomic restrict volatile *, ptrdiff_t );
    2507 forall( type T ) T restrict volatile
     2523forall( otype T ) T restrict volatile
    25082524        * ?+=?( T restrict volatile * restrict volatile *, ptrdiff_t ),
    25092525        * ?-=?( T restrict volatile * restrict volatile *, ptrdiff_t ),
    25102526        * ?+=?( T restrict volatile * _Atomic restrict volatile *, ptrdiff_t ),
    25112527        * ?-=?( T restrict volatile * _Atomic restrict volatile *, ptrdiff_t );
    2512 forall( type T ) T _Atomic const restrict
     2528forall( otype T ) T _Atomic const restrict
    25132529        * ?+=?( T _Atomic const restrict * restrict volatile *, ptrdiff_t ),
    25142530        * ?-=?( T _Atomic const restrict * restrict volatile *, ptrdiff_t ),
    25152531        * ?+=?( T _Atomic const restrict * _Atomic restrict volatile *, ptrdiff_t ),
    25162532        * ?-=?( T _Atomic const restrict * _Atomic restrict volatile *, ptrdiff_t );
    2517 forall( type T ) T _Atomic const volatile
     2533forall( otype T ) T _Atomic const volatile
    25182534        * ?+=?( T _Atomic const volatile * restrict volatile *, ptrdiff_t ),
    25192535        * ?-=?( T _Atomic const volatile * restrict volatile *, ptrdiff_t ),
    25202536        * ?+=?( T _Atomic const volatile * _Atomic restrict volatile *, ptrdiff_t ),
    25212537        * ?-=?( T _Atomic const volatile * _Atomic restrict volatile *, ptrdiff_t );
    2522 forall( type T ) T _Atomic restrict volatile
     2538forall( otype T ) T _Atomic restrict volatile
    25232539        * ?+=?( T _Atomic restrict volatile * restrict volatile *, ptrdiff_t ),
    25242540        * ?-=?( T _Atomic restrict volatile * restrict volatile *, ptrdiff_t ),
    25252541        * ?+=?( T _Atomic restrict volatile * _Atomic restrict volatile *, ptrdiff_t ),
    25262542        * ?-=?( T _Atomic restrict volatile * _Atomic restrict volatile *, ptrdiff_t );
    2527 forall( type T ) T const restrict volatile
     2543forall( otype T ) T const restrict volatile
    25282544        * ?+=?( T const restrict volatile * restrict volatile *, ptrdiff_t ),
    25292545        * ?-=?( T const restrict volatile * restrict volatile *, ptrdiff_t ),
    25302546        * ?+=?( T const restrict volatile * _Atomic restrict volatile *, ptrdiff_t ),
    25312547        * ?-=?( T const restrict volatile * _Atomic restrict volatile *, ptrdiff_t );
    2532 forall( type T ) T _Atomic const restrict volatile
     2548forall( otype T ) T _Atomic const restrict volatile
    25332549        * ?+=?( T _Atomic const restrict volatile * restrict volatile *, ptrdiff_t ),
    25342550        * ?-=?( T _Atomic const restrict volatile * restrict volatile *, ptrdiff_t ),
     
    28422858This sort of declaration is illegal because the scope of the type identifiers ends at the end of the declaration, but the scope of the structure tag does not.
    28432859\begin{lstlisting}
    2844 forall( type T ) struct Pair { T a, b;
     2860forall( otype T ) struct Pair { T a, b;
    28452861} mkPair( T, T ); // illegal
    28462862\end{lstlisting}
     
    28672883If this restriction were lifted, it would be possible to write
    28682884\begin{lstlisting}
    2869 forall( type T ) T * alloc( void );@\use{alloc}@ int *p = alloc();
     2885forall( otype T ) T * alloc( void );@\use{alloc}@ int *p = alloc();
    28702886\end{lstlisting}
    28712887Here \lstinline$alloc()$ would receive \lstinline$int$ as an inferred argument, and return an
     
    28762892\lstinline$T$:
    28772893\begin{lstlisting}
    2878 forall( type T ) T * alloc( T initial_value );@\use{alloc}@
     2894forall( otype T ) T * alloc( T initial_value );@\use{alloc}@
    28792895\end{lstlisting}
    28802896\end{rationale}
     
    28992915\begin{lstlisting}
    29002916int fi( int );
    2901 forall( type T ) T fT( T );
     2917forall( otype T ) T fT( T );
    29022918\end{lstlisting}
    29032919\lstinline$fi()$ takes an \lstinline$int$ and returns an \lstinline$int$. \lstinline$fT()$ takes a
     
    29052921\begin{lstlisting}
    29062922int (*pfi )( int ) = fi;
    2907 forall( type T ) T (*pfT )( T ) = fT;
     2923forall( otype T ) T (*pfT )( T ) = fT;
    29082924\end{lstlisting}
    29092925\lstinline$pfi$ and \lstinline$pfT$ are pointers to functions. \lstinline$pfT$ is not polymorphic, but the function it points at is.
     
    29122928        return pfi;
    29132929}
    2914 forall( type T ) T (*fvpfT( void ))( T ) {
     2930forall( otype T ) T (*fvpfT( void ))( T ) {
    29152931        return pfT;
    29162932}
     
    29182934\lstinline$fvpfi()$ and \lstinline$fvpfT()$ are functions taking no arguments and returning pointers to functions. \lstinline$fvpfT()$ is monomorphic, but the function that its return value points at is polymorphic.
    29192935\begin{lstlisting}
    2920 forall( type T ) int ( *fTpfi( T ) )( int );
    2921 forall( type T ) T ( *fTpfT( T ) )( T );
    2922 forall( type T, type U ) U ( *fTpfU( T ) )( U );
     2936forall( otype T ) int ( *fTpfi( T ) )( int );
     2937forall( otype T ) T ( *fTpfT( T ) )( T );
     2938forall( otype T, otype U ) U ( *fTpfU( T ) )( U );
    29232939\end{lstlisting}
    29242940\lstinline$fTpfi()$ is a polymorphic function that returns a pointer to a monomorphic function taking an integer and returning an integer.
     
    29302946\lstinline$char *$.
    29312947\begin{lstlisting}
    2932 forall( type T, type U, type V ) U * f( T *, U, V * const );
    2933 forall( type U, type V, type W ) U * g( V *, U, W * const );
     2948forall( otype T, otype U, otype V ) U * f( T *, U, V * const );
     2949forall( otype U, otype V, otype W ) U * g( V *, U, W * const );
    29342950\end{lstlisting}
    29352951The functions \lstinline$f()$ and \lstinline$g()$ have compatible types.
     
    29392955Replacing every \(f_i\) by \(g_i\) in \(f\) gives
    29402956\begin{lstlisting}
    2941 forall( type V, type U, type W ) U * f( V *, U, W * const );
     2957forall( otype V, otype U, otype W ) U * f( V *, U, W * const );
    29422958\end{lstlisting} which has a return type and parameter list that is compatible with \(g\).
    29432959\begin{rationale}
     
    31273143\examples
    31283144\begin{lstlisting}
    3129 forall( type T | T ?*?( T, T ))@\use{?*?}@
     3145forall( otype T | T ?*?( T, T ))@\use{?*?}@
    31303146T square( T val ) {@\impl{square}@
    31313147        return val + val;
    31323148}
    3133 context summable( type T ) {@\impl{summable}@
     3149trait summable( otype T ) {@\impl{summable}@
    31343150        T ?+=?( T *, T );@\use{?+=?}@
    31353151        const T 0;@\use{0}@
    31363152};
    3137 context list_of( type List, type Element ) {@\impl{list_of}@
     3153trait list_of( otype List, otype Element ) {@\impl{list_of}@
    31383154        Element car( List );
    31393155        List cdr( List );
     
    31423158        int is_nil( List );
    31433159};
    3144 context sum_list( type List, type Element | summable( Element ) | list_of( List, Element ) ) {};
     3160trait sum_list( otype List, otype Element | summable( Element ) | list_of( List, Element ) ) {};
    31453161\end{lstlisting}
    31463162\lstinline$sum_list$ contains seven declarations, which describe a list whose elements can be added up.
     
    32043220Incomplete type declarations allow compact mutually-recursive types.
    32053221\begin{lstlisting}
    3206 type t1; // incomplete type declaration
    3207 type t2 = struct { t1 * p; ... };
    3208 type t1 = struct { t2 * p; ... };
     3222otype t1; // incomplete type declaration
     3223otype t2 = struct { t1 * p; ... };
     3224otype t1 = struct { t2 * p; ... };
    32093225\end{lstlisting}
    32103226Without them, mutual recursion could be handled by declaring mutually recursive structures, then initializing the types to those structures.
    32113227\begin{lstlisting}
    32123228struct s1;
    3213 type t2 = struct s2 { struct s1 * p; ... };
    3214 type t1 = struct s1 { struct s2 * p; ... };
     3229otype t2 = struct s2 { struct s1 * p; ... };
     3230otype t1 = struct s1 { struct s2 * p; ... };
    32153231\end{lstlisting}
    32163232This introduces extra names, and may force the programmer to cast between the types and their implementations.
     
    32673283This prevents the declaration of types that contain each other.
    32683284\begin{lstlisting}
    3269 type t1;
    3270 type t2 = t1; // illegal: incomplete type t1
    3271 type t1 = t2;
     3285otype t1;
     3286otype t2 = t1; // illegal: incomplete type t1
     3287otype t1 = t2;
    32723288\end{lstlisting}
    32733289
     
    32763292 types}.
    32773293\begin{lstlisting}
    3278 extern type Huge; // extended-precision integer type
    3279 type Rational = struct {
     3294extern otype Huge; // extended-precision integer type
     3295otype Rational = struct {
    32803296        Huge numerator, denominator;    // illegal
    32813297};
     
    33163332\begin{lstlisting}
    33173333#include <stdlib.h>
    3318 T * new( type T ) { return ( T * )malloc( sizeof( T) ); };
     3334T * new( otype T ) { return ( T * )malloc( sizeof( T) ); };
    33193335@\ldots@ int * ip = new( int );
    33203336\end{lstlisting}
     
    33273343Since type declarations create new types, instances of types are always passed by value.
    33283344\begin{lstlisting}
    3329 type A1 = int[2];
     3345otype A1 = int[2];
    33303346void f1( A1 a ) { a[0] = 0; };
    3331 typedef int A2[2];
     3347otypedef int A2[2];
    33323348void f2( A2 a ) { a[0] = 0; };
    33333349A1 v1;
     
    33463362That unit might contain the declarations
    33473363\begin{lstlisting}
    3348 type Complex = struct { float re, im; };@\impl{Complex}@
     3364otype Complex = struct { float re, im; };@\impl{Complex}@
    33493365Complex cplx_i = { 0.0, 1.0 };@\impl{cplx_i}@
    33503366float abs( Complex c ) {@\impl{abs( Complex )}@
     
    33553371
    33563372\begin{lstlisting}
    3357 type Time_of_day = int;@\impl{Time_of_day}@ // seconds since midnight.
     3373otype Time_of_day = int;@\impl{Time_of_day}@ // seconds since midnight.
    33583374Time_of_day ?+?( Time_of_day t1, int seconds ) {@\impl{?+?}@
    33593375        return (( int)t1 + seconds ) % 86400;
     
    34293445\examples
    34303446\begin{lstlisting}
    3431 context s( type T ) {
     3447trait s( otype T ) {
    34323448        T a, b;
    34333449} struct impl { int left, right; } a = { 0, 0 };
    3434 type Pair | s( Pair ) = struct impl;
     3450otype Pair | s( Pair ) = struct impl;
    34353451Pair b = { 1, 1 };
    34363452\end{lstlisting}
     
    34403456\lstinline$Pair b$ is compulsory because there is no \lstinline$struct impl b$ to construct a value from.
    34413457\begin{lstlisting}
    3442 context ss( type T ) {
     3458trait ss( otype T ) {
    34433459        T clone( T );
    34443460        void munge( T * );
    34453461}
    3446 type Whatsit | ss( Whatsit );@\use{Whatsit}@
    3447 type Doodad | ss( Doodad ) = struct doodad {@\use{Doodad}@
     3462otype Whatsit | ss( Whatsit );@\use{Whatsit}@
     3463otype Doodad | ss( Doodad ) = struct doodad {@\use{Doodad}@
    34483464        Whatsit; // anonymous member
    34493465        int extra;
     
    34663482Default functions and objects are subject to the normal scope rules.
    34673483\begin{lstlisting}
    3468 type T = @\ldots@;
     3484otype T = @\ldots@;
    34693485T a_T = @\ldots@;               // Default assignment used.
    34703486T ?=?( T *, T );
     
    37353751The assertion ``\lstinline$scalar( Complex )$'' should be read as ``type \lstinline$Complex$ is scalar''.
    37363752\begin{lstlisting}
    3737 context scalar( type T ) {@\impl{scalar}@
     3753trait scalar( otype T ) {@\impl{scalar}@
    37383754        int !?( T );
    37393755        int ?<?( T, T ), ?<=?( T, T ), ?==?( T, T ), ?>=?( T, T ), ?>?( T, T ), ?!=?( T, T );
     
    37453761This is equivalent to inheritance of specifications.
    37463762\begin{lstlisting}
    3747 context arithmetic( type T | scalar( T ) ) {@\impl{arithmetic}@@\use{scalar}@
     3763trait arithmetic( otype T | scalar( T ) ) {@\impl{arithmetic}@@\use{scalar}@
    37483764        T +?( T ), -?( T );
    37493765        T ?*?( T, T ), ?/?( T, T ), ?+?( T, T ), ?-?( T, T );
     
    37543770\define{integral types}.
    37553771\begin{lstlisting}
    3756 context integral( type T | arithmetic( T ) ) {@\impl{integral}@@\use{arithmetic}@
     3772trait integral( otype T | arithmetic( T ) ) {@\impl{integral}@@\use{arithmetic}@
    37573773        T ~?( T );
    37583774        T ?&?( T, T ), ?|?( T, T ), ?^?( T, T );
     
    37683784The only operation that can be applied to all modifiable lvalues is simple assignment.
    37693785\begin{lstlisting}
    3770 context m_lvalue( type T ) {@\impl{m_lvalue}@
     3786trait m_lvalue( otype T ) {@\impl{m_lvalue}@
    37713787        T ?=?( T *, T );
    37723788};
     
    37783794Scalars can also be incremented and decremented.
    37793795\begin{lstlisting}
    3780 context m_l_scalar( type T | scalar( T ) | m_lvalue( T ) ) {@\impl{m_l_scalar}@
     3796trait m_l_scalar( otype T | scalar( T ) | m_lvalue( T ) ) {@\impl{m_l_scalar}@
    37813797        T ?++( T * ), ?--( T * );@\use{scalar}@@\use{m_lvalue}@
    37823798        T ++?( T * ), --?( T * );
     
    37873803Note that this results in the ``inheritance'' of \lstinline$scalar$ along both paths.
    37883804\begin{lstlisting}
    3789 context m_l_arithmetic( type T | m_l_scalar( T ) | arithmetic( T ) ) {@\impl{m_l_arithmetic}@
     3805trait m_l_arithmetic( otype T | m_l_scalar( T ) | arithmetic( T ) ) {@\impl{m_l_arithmetic}@
    37903806        T ?/=?( T *, T ), ?*=?( T *, T );@\use{m_l_scalar}@@\use{arithmetic}@
    37913807        T ?+=?( T *, T ), ?-=?( T *, T );
    37923808};
    3793 context m_l_integral( type T | m_l_arithmetic( T ) | integral( T ) ) {@\impl{m_l_integral}@
     3809trait m_l_integral( otype T | m_l_arithmetic( T ) | integral( T ) ) {@\impl{m_l_integral}@
    37943810        T ?&=?( T *, T ), ?|=?( T *, T ), ?^=?( T *, T );@\use{m_l_arithmetic}@
    37953811        T ?%=?( T *, T ), ?<<=?( T *, T ), ?>>=?( T *, T );@\use{integral}@
     
    38113827\lstinline$arithmetic$, so these operators cannot be consolidated in \lstinline$scalar$.
    38123828\begin{lstlisting}
    3813 context pointer( type P | scalar( P ) ) {@\impl{pointer}@@\use{scalar}@
     3829trait pointer( type P | scalar( P ) ) {@\impl{pointer}@@\use{scalar}@
    38143830        P ?+?( P, long int ), ?+?( long int, P ), ?-?( P, long int );
    38153831        ptrdiff_t ?-?( P, P );
    38163832};
    3817 context m_l_pointer( type P | pointer( P ) | m_l_scalar( P ) ) {@\impl{m_l_pointer}@
     3833trait m_l_pointer( type P | pointer( P ) | m_l_scalar( P ) ) {@\impl{m_l_pointer}@
    38183834        P ?+=?( P *, long int ), ?-=?( P *, long int );
    38193835        P ?=?( P *, void * );
     
    38273843``\lstinline$Safe_pointer$ acts like a pointer to \lstinline$int$''.
    38283844\begin{lstlisting}
    3829 context ptr_to( type P | pointer( P ), type T ) {@\impl{ptr_to}@@\use{pointer}@
     3845trait ptr_to( type P | pointer( P ), otype T ) {@\impl{ptr_to}@@\use{pointer}@
    38303846        lvalue T *?( P );
    38313847        lvalue T ?[?]( P, long int );
    38323848};
    3833 context ptr_to_const( type P | pointer( P ), type T ) {@\impl{ptr_to_const}@
     3849trait ptr_to_const( type P | pointer( P ), otype T ) {@\impl{ptr_to_const}@
    38343850        const lvalue T *?( P );
    38353851        const lvalue T ?[?]( P, long int );@\use{pointer}@
    38363852};
    3837 context ptr_to_volatile( type P | pointer( P ), type T ) }@\impl{ptr_to_volatile}@
     3853trait ptr_to_volatile( type P | pointer( P ), otype T ) }@\impl{ptr_to_volatile}@
    38383854        volatile lvalue T *?( P );
    38393855        volatile lvalue T ?[?]( P, long int );@\use{pointer}@
    38403856};
    3841 context ptr_to_const_volatile( type P | pointer( P ), type T ) }@\impl{ptr_to_const_volatile}@
     3857trait ptr_to_const_volatile( type P | pointer( P ), otype T ) }@\impl{ptr_to_const_volatile}@
    38423858        const volatile lvalue T *?( P );@\use{pointer}@
    38433859        const volatile lvalue T ?[?]( P, long int );
     
    38493865``\lstinline$ptr_to$'' specifications.
    38503866\begin{lstlisting}
    3851 context m_l_ptr_to( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to}@ type T | ptr_to( P, T )@\use{ptr_to}@ {
     3867trait m_l_ptr_to( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to}@ otype T | ptr_to( P, T )@\use{ptr_to}@ {
    38523868        P ?=?( P *, T * );
    38533869        T * ?=?( T **, P );
    38543870};
    3855 context m_l_ptr_to_const( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_const}@ type T | ptr_to_const( P, T )@\use{ptr_to_const}@) {
     3871trait m_l_ptr_to_const( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_const}@ otype T | ptr_to_const( P, T )@\use{ptr_to_const}@) {
    38563872        P ?=?( P *, const T * );
    38573873        const T * ?=?( const T **, P );
    38583874};
    3859 context m_l_ptr_to_volatile( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_volatile}@ type T | ptr_to_volatile( P, T )) {@\use{ptr_to_volatile}@
     3875trait m_l_ptr_to_volatile( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_volatile}@ otype T | ptr_to_volatile( P, T )) {@\use{ptr_to_volatile}@
    38603876        P ?=?( P *, volatile T * );
    38613877        volatile T * ?=?( volatile T **, P );
    38623878};
    3863 context m_l_ptr_to_const_volatile( type P | ptr_to_const_volatile( P ),@\use{ptr_to_const_volatile}@@\impl{m_l_ptr_to_const_volatile}@
     3879trait m_l_ptr_to_const_volatile( type P | ptr_to_const_volatile( P ),@\use{ptr_to_const_volatile}@@\impl{m_l_ptr_to_const_volatile}@
    38643880                type T | m_l_ptr_to_volatile( P, T ) | m_l_ptr_to_const( P )) {@\use{m_l_ptr_to_const}@@\use{m_l_ptr_to_volatile}@
    38653881        P ?=?( P *, const volatile T * );
     
    38713887An alternative specification can make use of the fact that qualification of the pointed-at type is part of a pointer type to capture that regularity.
    38723888\begin{lstlisting}
    3873 context m_l_ptr_like( type MyP | m_l_pointer( MyP ),@\use{m_l_pointer}@@\impl{m_l_ptr_like}@ type CP | m_l_pointer( CP ) ) {
     3889trait m_l_ptr_like( type MyP | m_l_pointer( MyP ),@\use{m_l_pointer}@@\impl{m_l_ptr_like}@ type CP | m_l_pointer( CP ) ) {
    38743890        MyP ?=?( MyP *, CP );
    38753891        CP ?=?( CP *, MyP );
     
    39043920C and \CFA have an extra, non-obvious comparison operator: ``\lstinline$!$'', logical negation, returns 1 if its operand compares equal to 0, and 0 otherwise.
    39053921\begin{lstlisting}
    3906 context comparable( type T ) {
     3922trait comparable( otype T ) {
    39073923        const T 0;
    39083924        int compare( T, T );
    39093925}
    3910 forall( type T | comparable( T ) ) int ?<?( T l, T r ) {
     3926forall( otype T | comparable( T ) ) int ?<?( T l, T r ) {
    39113927        return compare( l, r ) < 0;
    39123928}
    39133929// ... similarly for <=, ==, >=, >, and !=.
    3914 forall( type T | comparable( T ) ) int !?( T operand ) {
     3930forall( otype T | comparable( T ) ) int !?( T operand ) {
    39153931        return !compare( operand, 0 );
    39163932}
     
    39243940Similarly, a complete integral type would provide integral operations based on integral assignment operations.
    39253941\begin{lstlisting}
    3926 context arith_base( type T ) {
     3942trait arith_base( otype T ) {
    39273943        const T 1;
    39283944        T ?+=?( T *, T ), ?-=?( T *, T ), ?*=?( T *, T ), ?/=?( T *, T );
    39293945}
    3930 forall( type T | arith_base( T ) ) T ?+?( T l, T r ) {
     3946forall( otype T | arith_base( T ) ) T ?+?( T l, T r ) {
    39313947        return l += r;
    39323948}
    3933 forall( type T | arith_base( T ) ) T ?++( T * operand ) {
     3949forall( otype T | arith_base( T ) ) T ?++( T * operand ) {
    39343950        T temporary = *operand;
    39353951        *operand += 1;
    39363952        return temporary;
    39373953}
    3938 forall( type T | arith_base( T ) ) T ++?( T * operand ) {
     3954forall( otype T | arith_base( T ) ) T ++?( T * operand ) {
    39393955        return *operand += 1;
    39403956}
    39413957// ... similarly for -, --, *, and /.
    3942 context int_base( type T ) {
     3958trait int_base( otype T ) {
    39433959        T ?&=?( T *, T ), ?|=?( T *, T ), ?^=?( T *, T );
    39443960        T ?%=?( T *, T ), ?<<=?( T *, T ), ?>>=?( T *, T );
    39453961}
    3946 forall( type T | int_base( T ) ) T ?&?( T l, T r ) {
     3962forall( otype T | int_base( T ) ) T ?&?( T l, T r ) {
    39473963        return l &= r;
    39483964}
  • src/Parser/DeclarationNode.cc

    r89173242 rb3f9a0cb  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:26:24 2016
    13 // Update Count     : 134
     12// Last Modified On : Mon Mar 21 21:04:23 2016
     13// Update Count     : 142
    1414//
    1515
     
    4242UniqueName DeclarationNode::anonymous( "__anonymous" );
    4343
    44 extern LinkageSpec::Type linkage;               /* defined in cfa.y */
     44extern LinkageSpec::Type linkage;                                               // defined in parser.yy
    4545
    4646DeclarationNode *DeclarationNode::clone() const {
     
    5555        newnode->linkage = linkage;
    5656        return newnode;
    57 }
     57} // DeclarationNode::clone
    5858
    5959DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) {
     
    117117        newnode->type->function->newStyle = newStyle;
    118118        newnode->type->function->body = body;
     119        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
    119120
    120121        if ( body ) {
     
    129130
    130131        return newnode;
    131 }
     132} // DeclarationNode::newFunction
    132133
    133134DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) {
     
    136137        newnode->type->qualifiers.push_back( q );
    137138        return newnode;
    138 }
     139} // DeclarationNode::newQualifier
    139140
    140141DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
     
    142143        newnode->storageClasses.push_back( sc );
    143144        return newnode;
    144 }
     145} // DeclarationNode::newStorageClass
    145146
    146147DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) {
     
    149150        newnode->type->basic->typeSpec.push_back( bt );
    150151        return newnode;
    151 }
     152} // DeclarationNode::newBasicType
    152153
    153154DeclarationNode *DeclarationNode::newBuiltinType( BuiltinType bt ) {
     
    156157        newnode->type->builtin->type = bt;
    157158        return newnode;
    158 }
     159} // DeclarationNode::newBuiltinType
    159160
    160161DeclarationNode *DeclarationNode::newModifier( Modifier mod ) {
     
    163164        newnode->type->basic->modifiers.push_back( mod );
    164165        return newnode;
    165 }
     166} // DeclarationNode::newModifier
    166167
    167168DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) {
     
    170171        newnode->type->forall = forall;
    171172        return newnode;
    172 }
     173} // DeclarationNode::newForall
    173174
    174175DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) {
     
    179180        newnode->type->symbolic->params = 0;
    180181        return newnode;
    181 }
     182} // DeclarationNode::newFromTypedef
    182183
    183184DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields ) {
     
    188189        if ( newnode->type->aggregate->name == "" ) {           // anonymous aggregate ?
    189190                newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
    190         } else {
    191                 // SKULLDUGGERY: generate a typedef for the aggregate name so that the aggregate does not have to be qualified
    192                 // by "struct"
     191        } else if ( ! typedefTable.exists( newnode->type->aggregate->name ) ) {
     192                // SKULLDUGGERY: Generate a typedef for the aggregate name so the aggregate does not have to be qualified by
     193                // "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed
     194                // if the name is explicitly used.
    193195                typedefTable.addToEnclosingScope( newnode->type->aggregate->name, TypedefTable::TD );
    194196                DeclarationNode *typedf = new DeclarationNode;
     
    199201        newnode->type->aggregate->fields = fields;
    200202        return newnode;
    201 }
     203} // DeclarationNode::newAggregate
    202204
    203205DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
     
    208210        if ( newnode->type->enumeration->name == "" ) {         // anonymous enumeration ?
    209211                newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
    210         } else {
    211                 // SKULLDUGGERY: generate a typedef for the enumeration name so that the enumeration does not have to be
    212                 // qualified by "enum"
     212        } else if ( ! typedefTable.exists( newnode->type->enumeration->name ) ) {
     213                // SKULLDUGGERY: Generate a typedef for the enumeration name so the enumeration does not have to be qualified by
     214                // "enum". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed if
     215                // the name is explicitly used.
    213216                typedefTable.addToEnclosingScope( newnode->type->enumeration->name, TypedefTable::TD );
    214217                DeclarationNode *typedf = new DeclarationNode;
     
    218221        newnode->type->enumeration->constants = constants;
    219222        return newnode;
    220 }
     223} // DeclarationNode::newEnum
    221224
    222225DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) {
     
    224227        newnode->name = assign_strptr( name );
    225228        newnode->enumeratorValue = constant;
    226         return newnode;
    227 }
     229        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
     230        return newnode;
     231} // DeclarationNode::newEnumConstant
    228232
    229233DeclarationNode *DeclarationNode::newName( std::string *name ) {
     
    231235        newnode->name = assign_strptr( name );
    232236        return newnode;
    233 }
     237} // DeclarationNode::newName
    234238
    235239DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
     
    240244        newnode->type->symbolic->actuals = params;
    241245        return newnode;
    242 }
     246} // DeclarationNode::newFromTypeGen
    243247
    244248DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
     
    249253        newnode->type->variable->name = newnode->name;
    250254        return newnode;
    251 }
     255} // DeclarationNode::newTypeParam
    252256
    253257DeclarationNode *DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
     
    259263        newnode->type->aggregate->name = assign_strptr( name );
    260264        return newnode;
    261 }
     265} // DeclarationNode::newTrait
    262266
    263267DeclarationNode *DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) {
     
    269273        newnode->type->aggInst->params = params;
    270274        return newnode;
    271 }
     275} // DeclarationNode::newTraitUse
    272276
    273277DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) {
     
    279283        newnode->type->symbolic->name = newnode->name;
    280284        return newnode;
    281 }
     285} // DeclarationNode::newTypeDecl
    282286
    283287DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
     
    285289        newnode->type = new TypeData( TypeData::Pointer );
    286290        return newnode->addQualifiers( qualifiers );
    287 }
     291} // DeclarationNode::newPointer
    288292
    289293DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
     
    298302        } // if
    299303        return newnode->addQualifiers( qualifiers );
    300 }
     304} // DeclarationNode::newArray
    301305
    302306DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
  • src/Parser/ExpressionNode.cc

    r89173242 rb3f9a0cb  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Feb  1 13:32:30 2016
    13 // Update Count     : 271
     12// Last Modified On : Sun Mar 13 12:34:38 2016
     13// Update Count     : 272
    1414//
    1515
     
    487487                args.front() = new AddressExpr( args.front() );
    488488                break;
    489           default:
    490                 /* do nothing */
     489          default:              // do nothing
    491490                ;
    492         }
     491        } // switch
    493492
    494493        switch ( op->get_type() ) {
  • src/Parser/Parser.cc

    r89173242 rb3f9a0cb  
    1010// Created On       : Sat May 16 14:54:28 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun May 31 23:45:19 2015
    13 // Update Count     : 4
     12// Last Modified On : Mon Mar 21 18:04:47 2016
     13// Update Count     : 5
    1414//
    1515
    1616#include "Parser.h"
    17 #include "TypedefTable.h"
    1817#include "lex.h"
    1918#include "parser.h"
     19#include "TypedefTable.h"
    2020
    2121// global variables in cfa.y
  • src/Parser/TypedefTable.cc

    r89173242 rb3f9a0cb  
    1010// Created On       : Sat May 16 15:20:13 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:25:55 2016
    13 // Update Count     : 20
     12// Last Modified On : Mon Mar 21 18:18:58 2016
     13// Update Count     : 23
    1414//
    1515
    1616#include <map>
    1717#include <list>
     18#include <cassert>
    1819#include "TypedefTable.h"
    19 #include <cassert>
    2020using namespace std;
    2121
     
    2929TypedefTable::TypedefTable() : currentScope( 0 ) {}
    3030
     31bool TypedefTable::exists( const string &identifier ) {
     32        return table.count( identifier ) > 0;
     33}
     34
    3135void TypedefTable::changeKind( const string &identifier, kind_t kind ) {
    3236        tableType::iterator id_pos = table.find( identifier );
    33         if ( id_pos == table.end() ) {
    34                 return;
    35         } else {
    36                 (*((*id_pos ).second.begin())).kind = kind;
    37                 return;
    38         } // if
     37        if ( id_pos == table.end() ) return;
     38        id_pos->second.begin()->kind = kind;
    3939}
    4040
    41 bool TypedefTable::isKind( const string &identifier, kind_t kind ) const {
     41int TypedefTable::isKind( const string &identifier ) const {
    4242        tableType::const_iterator id_pos = table.find( identifier );
    43         if ( id_pos == table.end() ) {
    44                 return true;
    45         } else {
    46                 return (*((*id_pos ).second.begin())).kind == kind;
    47         } // if
    48 }
    49 
    50 bool TypedefTable::isIdentifier( const string &identifier ) const {
    51         return isKind( identifier, ID );
    52 }
    53 
    54 bool TypedefTable::isTypedef( const string &identifier ) const {
    55         return isKind( identifier, TD );
    56 }
    57 
    58 bool TypedefTable::isTypegen( const string &identifier ) const {
    59         return isKind( identifier, TG );
     43        // Name lookup defaults to identifier, and then the identifier's kind is set by the parser.
     44        if ( id_pos == table.end() ) return IDENTIFIER;
     45        return id_pos->second.begin()->kind;
    6046}
    6147
  • src/Parser/TypedefTable.h

    r89173242 rb3f9a0cb  
    1010// Created On       : Sat May 16 15:24:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:26:54 2016
    13 // Update Count     : 12
     12// Last Modified On : Mon Mar 21 18:17:36 2016
     13// Update Count     : 24
    1414//
    1515
     
    2222#include <stack>
    2323
     24#include "lex.h"
     25#include "parser.h"
     26
    2427class TypedefTable {
    2528  public:
    26         enum kind_t { ID, TD, TG };
     29        enum kind_t { ID = IDENTIFIER, TD = TYPEDEFname, TG = TYPEGENname };
    2730  private:
    2831        struct Entry {
     
    4952        std::stack< std::string > nextIdentifiers;
    5053
    51         bool isKind( const std::string &identifier, kind_t kind ) const;
    5254        void addToScope( const std::string &identifier, kind_t kind, int scope );
    5355  public:
    5456        TypedefTable();
    5557
    56         bool isIdentifier( const std::string &identifier ) const;
    57         bool isTypedef( const std::string &identifier ) const;
    58         bool isTypegen( const std::string &identifier ) const;
    59 
     58        bool exists( const std::string &identifier );
     59        int isKind( const std::string &identifier ) const;
    6060        void changeKind( const std::string &identifier, kind_t kind );
    6161       
  • src/Parser/lex.cc

    r89173242 rb3f9a0cb  
    418418      120,  120,    0,    0,    0,  118,    0,    0,    0,    0,
    419419        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    420         0,  133,  112,  112,    0,  112,  112,  112,    0,    6,
    421       112,  110,    0,    0,    0,  112,    0,  110,  110,  110,
     420        0,  133,  112,  112,    0,  112,  112,    0,    0,    6,
     421        0,  110,    0,    0,    0,  112,    0,  110,  110,  110,
    422422      110,    0,  111,    0,    0,  109,  109,  109,  109,    0,
    423423      171,  172,    0,  177,  175,    0,    0,    0,  103,    0,
     
    433433        0,  120,    0,    0,    0,    0,    0,  120,    0,    0,
    434434      178,    0,    0,    0,    0,    0,    0,    0,  112,    0,
    435       112,    0,  112,    0,    0,  112,  112,  110,  110,    0,
     435      112,    0,  112,    0,    0,  112,    0,  110,  110,    0,
    436436        0,  111,  111,    0,  111,    0,  111,  109,  109,    0,
    437437        0,    0,    0,    0,    0,    0,    0,    0,    0,  176,
     
    445445      102,  102,  102,  102,   97,  102,  102,    0,    0,    0,
    446446        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    447         0,  120,    0,    0,    0,    0,    0,  112,  112,    0,
     447        0,  120,    0,    0,    0,    0,    0,  112,    0,    0,
    448448        0,    0,    0,    0,  111,  111,    0,  113,    0,  111,
    449449
     
    459459        0,    0,    0,    0,    0,  113,    0,    0,  111,  113,
    460460
    461       113,  113,  113,  113,  111,    0,    0,    0,    0,    0,
     461      113,  113,  113,    0,  111,    0,    0,    0,    0,    0,
    462462        0,    0,    0,    0,    0,  102,    0,  102,  102,  102,
    463463      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
     
    467467       81,   83,   84,  102,  102,   91,  102,  102,    0,    1,
    468468        0,    0,    0,    0,    0,    0,  105,    0,    0,    0,
    469       120,    0,    0,    0,    0,  113,  113,  113,  113,    0,
     469      120,    0,    0,    0,    0,  113,    0,  113,  113,    0,
    470470        0,    0,    0,    0,    0,    0,    0,    0,  102,  102,
    471471
     
    500500       16,   17,   18,   19,   20,   21,   22,   23,   24,   25,
    501501       26,   26,   26,   26,   26,   27,   28,   29,   30,   31,
    502        32,   33,   34,   35,   36,   37,   38,   39,   40,   39,
    503        41,   11,   42,   11,   11,   43,   11,   44,   11,   45,
    504        11,   46,   47,   48,   49,   11,   11,   50,   11,   11,
    505        51,   52,   53,   54,   55,   56,   57,   58,   59,   60,
    506 
    507        61,   62,   63,   64,   65,   11,   66,   67,   68,   69,
    508        70,   71,   11,   72,   73,   74,   75,   76,   77,   78,
    509        79,   80,   81,   82,   83,   84,    1,    1,    1,    1,
     502       32,   33,   34,   35,   36,   37,   38,   39,   40,   41,
     503       42,   11,   43,   11,   11,   44,   11,   45,   11,   46,
     504       11,   47,   48,   49,   50,   11,   11,   51,   11,   11,
     505       52,   53,   54,   55,   56,   57,   58,   59,   60,   61,
     506
     507       62,   63,   64,   65,   66,   11,   67,   68,   69,   70,
     508       71,   72,   11,   73,   74,   75,   76,   77,   78,   79,
     509       80,   81,   82,   83,   84,   85,    1,    1,    1,    1,
    510510        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    511511        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     
    524524    } ;
    525525
    526 static yyconst flex_int32_t yy_meta[85] =
     526static yyconst flex_int32_t yy_meta[86] =
    527527    {   0,
    528528        1,    1,    2,    1,    1,    1,    1,    1,    3,    1,
     
    530530        6,    1,    7,    7,    7,    7,    7,    7,    1,    1,
    531531        1,    8,    1,    1,    1,    9,    9,    9,    9,    9,
    532         4,    4,   10,    4,   11,    4,    4,    4,   10,    4,
    533         1,   12,    1,    1,   13,    1,    9,    9,    9,    9,
    534         9,    9,    4,    4,    4,    4,   10,    4,    4,    4,
    535        11,    4,    4,    4,   10,    4,    4,    4,    4,    4,
    536         1,    1,    1,    1
     532        9,    4,    4,   10,    4,   11,    4,    4,    4,   10,
     533        4,    1,   12,    1,    1,   13,    1,    9,    9,    9,
     534        9,    9,    9,    4,    4,    4,    4,   10,    4,    4,
     535        4,   11,    4,    4,    4,   10,    4,    4,    4,    4,
     536        4,    1,    1,    1,    1
    537537    } ;
    538538
    539539static yyconst flex_int16_t yy_base[1062] =
    540540    {   0,
    541         0,   83, 2268, 2265,   93,    0,  175,  176,  177,  178,
    542      2279, 2798,  189, 2798,  195,   54, 2798, 2226,   59,  171,
    543      2798, 2798, 2798,   55,  186, 2798,  189,  187,  202,  214,
    544       272,    0, 2244, 2798,  214, 2243,  150,  340,  153,  222,
    545      2798,  157, 2798,  215,  224, 2798,  207,  181,  221,  249,
    546       235,  289,  155,  255,  218,  231,  206,  266,  256,  323,
    547       259,  192, 2798,  252, 2798, 2238,  377,  342, 2798, 2249,
    548      2798, 2218,  241, 2798,    0, 2798,  421,    0, 2798,  393,
    549      2798,  399,  405, 2798,  492, 2216,  276, 2798, 2798, 2798,
    550      2798, 2798, 2231, 2798, 2228, 2798, 2798, 2240,  552, 2798,
    551 
    552      2257, 2798,  413,  393,  437,  493,  377,  318,  195,  430,
    553       382,    0,  384,  321,  196,  427, 2798, 2798, 2798, 2226,
    554      2798, 2798, 2798, 2223, 2220,  304,  342, 2235,  381,  435,
    555       422,  400,  455,  440,  494, 2216,  469, 2165,  497, 2193,
    556      2798,  432, 2798, 2798,  521, 2187, 2186, 2798, 2159,  470,
    557       414,  436,  325,  254,  463,  480,  486,  563,  274,  482,
    558       484,  487,  495,  234,  489,  341,  488,  490,  377,  507,
    559       497,  501,  503,  514,  515,  506,  529, 2186,  531,  537,
    560       505,  518,  536,  534,  538,  559,  575,  571,  577,  574,
    561       599,  590,  581,  592, 2798, 2798,  662,  668, 2232,  674,
    562 
    563      2798,  680, 2798, 2180,  583, 2176, 2175,    0,  671, 2798,
    564      2798,  686, 2173, 2170, 2167,    0, 2189,  568,  615,  618,
    565       695,  694,  627,  654,  628,  683, 2186,  686,  687, 2163,
    566      2160, 2798,    0,  680,  712,  703,  682, 2157, 2208, 2798,
    567       711,    0,  702,  756,  762,  795,  774,  604, 2798, 2167,
    568      2141,    0,  803, 2167,  780,  684, 2798, 2143, 2118,  804,
    569      2798, 2798, 2148, 2798, 2798,  724,  728, 2126, 2126,  694,
    570      2122, 2120, 2117,    0, 2114,    0, 2085,  679,  682,  696,
    571       423,  722,  757,  703,  758,  741,  799,  764,  725,  789,
    572       697,  774,  788,  792,  760,  784,  795, 2115,  809,  797,
    573 
    574       816,  196,  804,  812,  817,  823,  829,  632,  831,  832,
    575       836,  819,  837,  833,  840,  844,  847,  843,  853,  851,
    576      2113,  854,  855,  856,  859,  857,  858,  860,  861,  867,
    577       863,  866,  868,  873,  874, 2110,  877,  716,  882,  883,
    578       884,  888,  894,  947,  944, 2104, 2103, 2102,    0, 2100,
    579         0,  934,  939, 2097,    0, 2094,    0, 2093,    0, 2113,
    580      2798,  934,  935, 2092, 2087,    0, 2086,    0, 2798,  947,
    581       967,  958, 2798,  973,  988, 1012, 2085, 2798, 2798,  932,
    582       962,  999,  975, 1033,  912, 1020,  956, 2798, 2798, 2083,
    583      2080, 2079,    0, 2078,    0, 2076,    0, 2073,    0, 2798,
    584 
    585       956,  936,  978,  950,  994, 1010, 1016,  973, 1019, 1020,
    586      1024, 1012, 1029, 1030, 1026, 1027, 1032, 1038, 1044, 1031,
    587      1051, 1049, 1041, 2072, 1055, 2068, 1054, 2066, 1057, 1058,
    588      1059,  974, 1061, 1064, 1065, 2064, 1070, 2061, 1063, 1071,
    589      1073, 1075, 1076, 1081, 1077, 2059, 1082, 2057, 1084, 1087,
    590      1089, 1092, 1094, 1095, 1100, 1090, 1098, 1106, 1115, 1102,
    591      1103, 1116, 1104, 1118, 2054, 1119, 1123, 1169, 2048,    0,
    592      2047,    0, 2046,    0, 2044,    0, 1164, 2041,    0, 2038,
    593         0, 2037, 2036, 2034,    0, 2031,    0, 1171, 2028, 1177,
    594      1137, 1197, 1164, 1112, 1131, 2798, 1216, 1230, 1256, 2039,
    595 
    596      2014, 2024, 2021,    0, 2018,    0, 2017,    0, 2016,    0,
    597      2014,    0, 2011,    0, 1159, 1164, 2011, 1160, 1178, 1182,
    598      1133, 1194, 1208, 1185,  541, 1199, 1197, 1215, 1193, 1209,
    599      1211, 1225, 1210, 1254, 1235, 1237, 1239, 1241, 1242, 2010,
    600      1252, 1248, 2009, 1249, 1253, 1255, 1251, 2007, 1258, 1261,
    601      1262, 1264, 2004, 1265, 1271, 2001, 1263, 1273, 2000, 1269,
    602      1275, 1277, 1999, 1281, 1283, 1285, 1284, 1286, 1296, 1997,
    603      1295, 1287, 1994, 1299, 1300, 1991, 2039, 1986,    0, 1984,
    604         0, 1981,    0, 1980,    0, 1979,    0, 1977,    0, 1974,
    605         0, 1973,    0, 1336, 1346, 1369, 1357, 1972, 2798, 1375,
    606 
    607      1311, 1347, 1313, 1970, 2798, 1937,    0, 1935,    0, 1934,
    608         0, 1931,    0,    0,    0, 1931,    0, 1353, 1354, 1305,
    609      1302, 1335, 1363, 1366, 1367, 1364,  586, 1370, 1365, 1374,
    610      1368, 1376, 1369, 1385, 1380, 1166, 1392, 1394, 1327, 1395,
    611      1396, 1399, 1930, 1398, 1400, 1401, 1929, 1927, 1924, 1403,
    612      1402, 1921, 1409, 1920, 1919, 1406, 1404, 1917, 1914, 1913,
    613      1912, 1910, 1907, 1416, 1417, 1906, 1419, 1405, 1954, 2798,
    614      1900,    0, 1897,    0,    0,    0, 1896,    0,    0,    0,
    615      2798,    0,    0,    0,    0, 1459, 1889, 2798, 2798, 1465,
    616      1885,    0, 1869,    0,    0,    0,    0, 1868, 1424, 1442,
    617 
    618      1870, 1444, 1447, 1443, 1451, 1453, 1455, 1457, 1868, 1459,
    619      1460, 1476, 1461, 1463, 1494, 1477, 1478, 1504, 1483, 1482,
    620      1481, 1488, 1490, 1491, 1492, 1865, 1864, 1493, 1863, 1861,
    621      1497, 1496, 1499, 1858, 1500, 1502,    0,    0,    0, 1854,
    622      1853, 1851, 1550,    0, 1848, 1847, 1846, 1844, 1841, 1843,
    623      1842, 1840, 1837, 1507, 1513, 1505, 1514, 1509, 1515, 1528,
    624      1506, 1531, 1533, 1562, 1836, 1536, 1835, 1537, 1541, 1544,
    625      1549, 1542, 1543, 1833, 1830, 1829, 1828, 1550, 1826, 1823,
    626      1819, 1818, 1816, 1813, 1812, 1811, 1809, 1802, 1800, 1799,
    627      1796, 1795, 1551, 1797, 1554, 1556, 1555, 1559, 1560, 1561,
    628 
    629      1795, 1565, 1592, 1568, 1778, 1569, 1576, 1577, 1584, 1570,
    630      1572, 1766, 1765, 1762, 1755, 1752, 1745, 1743, 1742, 1721,
    631      1720, 1719, 1712, 1710, 1712, 1582, 1587, 1595, 1590, 1589,
    632      1597, 1585, 1670, 1669, 1601, 1666, 1665, 1605, 1606, 1609,
    633      1660, 1659, 1655, 1654, 1651, 1650, 1649, 1593, 1610, 1611,
    634      1412, 1614, 1612, 1620, 1337, 1621, 1623, 1627, 1000,  928,
    635       896,  778, 1628, 1629, 1631, 1632, 1633, 1635,  709,  628,
    636      1637,  373,  338, 1639, 1640,  337,  257, 1641, 1643, 1645,
    637      1647, 1646, 1649, 1651,  200,  136, 2798, 1723, 1736, 1749,
    638      1759, 1769, 1782, 1792, 1805, 1818, 1831, 1839, 1849, 1856,
    639 
    640      1863, 1870, 1877, 1884, 1891, 1898, 1905, 1912, 1925, 1932,
    641      1936, 1944, 1947, 1954, 1961, 1968, 1971, 1978, 1984, 1997,
    642      2010, 2017, 2024, 2031, 2038, 2041, 2048, 2051, 2058, 2061,
    643      2068, 2071, 2078, 2081, 2088, 2091, 2098, 2101, 2108, 2116,
    644      2123, 2130, 2137, 2144, 2147, 2154, 2157, 2164, 2167, 2174,
    645      2180, 2193, 2200, 2207, 2210, 2217, 2220, 2227, 2230, 2237,
    646      2240, 2247, 2250, 2257, 2260, 2267, 2274, 2277, 2284, 2287,
    647      2294, 2301, 2308, 2311, 2318, 2321, 2328, 2331, 2338, 2341,
    648      2348, 2351, 2358, 2364, 2377, 2384, 2391, 2394, 2401, 2404,
    649      2411, 2414, 2421, 2424, 2431, 2434, 2441, 2444, 2451, 2454,
    650 
    651      2461, 2464, 2471, 2478, 2481, 2488, 2491, 2498, 2501, 2508,
    652      2511, 2514, 2520, 2527, 2536, 2543, 2550, 2553, 2560, 2563,
    653      2566, 2572, 2579, 2582, 2585, 2588, 2591, 2594, 2597, 2600,
    654      2607, 2610, 2617, 2620, 2623, 2626, 2629, 2639, 2646, 2649,
    655      2652, 2655, 2662, 2669, 2676, 2679, 2686, 2693, 2700, 2707,
    656      2714, 2721, 2728, 2735, 2742, 2749, 2756, 2763, 2770, 2777,
    657      2784
     541        0,   84, 2272, 2269,   94,    0,  177,  178,  179,  180,
     542     2285, 2822,  191, 2822,  197,   55, 2822, 2231,   60,  173,
     543     2822, 2822, 2822,   56,  188, 2822,  191,  189,  204,  216,
     544      275,    0, 2249, 2822,  216, 2247,  152,  344,  155,  220,
     545     2822,  159, 2822,  217,  226, 2822,  185,  154,  212,  251,
     546      237,  270,  235,  257,  241,  205,  193,  305,  314,  333,
     547      238,  228, 2822,  225, 2822, 2242,  402,  390, 2822, 2253,
     548     2822, 2221,  235, 2822,    0, 2822,  426,    0, 2822,  417,
     549     2822,  439,  451, 2822,  498, 2219,  264, 2822, 2822, 2822,
     550     2822, 2822, 2235, 2822, 2232, 2822, 2822, 2244,  559, 2822,
     551
     552     2261, 2822,  438,  444,  511,  534,  289,  253,  197,  380,
     553      305,    0,  319,  280,  198,  322, 2822, 2822, 2822, 2230,
     554     2822, 2822, 2822, 2227, 2224,  218,  255, 2239,  298,  350,
     555      368,  312,  440,  398,  405, 2220,  441, 2168,  446, 2196,
     556     2822,  335, 2822, 2822,  468, 2190, 2189, 2822, 2162,  439,
     557      282,  433,  372,  281,  437,  434,  428,  570,  444,  466,
     558      464,  469,  475,  321,  492,  438,  471,  445,  474,  512,
     559      489,  503,  496,  521,  276,  515,  516, 2189,  526,  510,
     560      519,  525,  543,  522,  560,  553,  523,  561,  551,  544,
     561      599,  582,  593,  584, 2822, 2822,  660,  651, 2236,  666,
     562
     563     2822,  678, 2822, 2183,  607, 2179, 2178,    0,  693, 2822,
     564     2822,  684, 2176, 2156, 2154,    0, 2177,  578,  608,  617,
     565      654,  679,  650,  683,  684,  687, 2172,  690,  691, 2147,
     566     2146, 2822,    0,  683,  710,  686,  700, 2145, 2196, 2822,
     567      714,    0,  427,  746,  764,  786,  808,  621, 2822, 2152,
     568     2125,    0,  794, 2171,  795,  709, 2822, 2147, 2121,  832,
     569     2822, 2822, 2152, 2822, 2822,  711,  714, 2129, 2129,  717,
     570     2125, 2123, 2120,    0, 2117,    0, 2088,  694,  679,  712,
     571      709,  711,  698,  566,  726,  743,  771,  741,  790,  784,
     572      800,  795,  742,  744,  814,  816,  818, 2118,  819,  745,
     573
     574      820,  821,  822,  823,  824,  746,  825,  748,  659,  831,
     575      826,  833,  838,  839,  848,  850,  851,  844,  834,  857,
     576     2116,  858,  859,  860,  862,  861,  864,  865,  867,  868,
     577      866,  871,  876,  872,  878, 2113,  880,  689,  881,  882,
     578      892,  896,  893,  953,  954, 2109, 2108, 2106,    0, 2103,
     579        0,  941,  945, 2102,    0, 2101,    0, 2099,    0, 2118,
     580     2822,  940,  941, 2094, 2088,    0, 2086,    0, 2822,  953,
     581      975,  964, 2822,  981,  997, 1021, 2084, 2822, 2822,  939,
     582      940, 1006,  982, 1041,  310, 1039, 1004, 2822, 2822, 2081,
     583     2079, 2077,    0, 2074,    0, 2071,    0, 2070,    0, 2822,
     584
     585      886,  941,  960,  962,  977,  976,  980,  982, 1017, 1010,
     586     1002,  998, 1022, 1031, 1028, 1033, 1034, 1037, 1040, 1043,
     587     1038, 1041, 1053, 2072, 1055, 2070, 1045, 2067, 1056, 1061,
     588     1063, 1065, 1066, 1067, 1070, 2064, 1071, 2063, 1073, 1074,
     589     1075, 1078, 1080, 1081, 1085, 2062, 1087, 2060, 1084, 1089,
     590     1091, 1097, 1099, 1092, 1102, 1103, 1105, 1106, 1108,  905,
     591     1109, 1116, 1110, 1122, 2057, 1120, 1123, 1179, 2051,    0,
     592     2050,    0, 2049,    0, 2047,    0, 1166, 2044,    0, 2041,
     593        0, 2040, 2039, 2037,    0, 2034,    0, 1173, 2031, 1179,
     594     1137, 1195, 1181, 1178, 1176, 2822, 1219, 1231, 1253, 2042,
     595
     596     2017, 2027, 2024,    0, 2021,    0, 2020,    0, 2019,    0,
     597     2017,    0, 2014,    0, 1141, 1172, 2014, 1180, 1155, 1196,
     598     1157, 1216, 1207, 1231, 1125, 1210, 1232, 1214, 1187, 1236,
     599     1235, 1237, 1238, 1272, 1249, 1252, 1250, 1253, 1254, 2013,
     600     1261, 1256, 2012, 1260, 1263, 1264, 1257, 2010, 1271, 1268,
     601     1269, 1273, 2007, 1275, 1282, 2006, 1283, 1284, 2005, 1276,
     602     1286, 1289, 2003, 1294, 1291, 1296, 1295, 1297, 1310, 2000,
     603     1305, 1308, 1999, 1307, 1300, 1998, 2046, 1960,    0, 1958,
     604        0, 1957,    0, 1954,    0, 1951,    0, 1950,    0, 1949,
     605        0, 1947,    0, 1355, 1361, 1389, 1372, 1944, 2822, 1378,
     606
     607     1325, 1365, 1379, 1941, 2822, 1940,    0, 1939,    0, 1937,
     608        0, 1934,    0,    0,    0, 1936,    0, 1366, 1312, 1311,
     609     1341, 1323, 1368, 1369, 1374, 1356, 1383, 1372, 1388, 1390,
     610     1393, 1395, 1396, 1398, 1400, 1431, 1406, 1407, 1411, 1408,
     611     1413, 1414, 1935, 1409, 1416, 1419, 1933, 1930, 1929, 1422,
     612     1424, 1928, 1429, 1926, 1923, 1425, 1430, 1919, 1915, 1911,
     613     1895, 1894, 1893, 1436, 1433, 1891, 1439, 1440, 1938, 2822,
     614     1884,    0, 1883,    0,    0,    0, 1884,    0,    0,    0,
     615     2822,    0,    0,    0,    0, 1486, 1878, 2822, 2822, 1492,
     616     1877,    0, 1876,    0,    0,    0,    0, 1874, 1447, 1444,
     617
     618     1874, 1449, 1471, 1479, 1450, 1480, 1482, 1469, 1873, 1486,
     619     1490, 1488, 1502, 1452, 1510, 1504, 1491, 1519, 1506, 1498,
     620     1508, 1512, 1513, 1514, 1515, 1872, 1870, 1517, 1867, 1866,
     621     1518, 1520, 1523, 1865, 1521, 1525,    0,    0,    0, 1860,
     622     1857, 1856, 1575,    0, 1855, 1853, 1850, 1849, 1848, 1849,
     623     1846, 1845, 1844, 1531, 1536, 1527, 1528, 1552, 1533, 1537,
     624     1539, 1555, 1557, 1569, 1842, 1560, 1839, 1561, 1559, 1568,
     625     1572, 1567, 1573, 1838, 1837, 1835, 1828, 1574, 1826, 1825,
     626     1819, 1818, 1817, 1815, 1798, 1789, 1788, 1785, 1778, 1775,
     627     1768, 1766, 1576, 1768, 1577, 1581, 1580, 1579, 1584, 1585,
     628
     629     1747, 1586, 1615, 1590, 1746, 1591, 1592, 1602, 1600, 1594,
     630     1606, 1742, 1735, 1733, 1732, 1690, 1689, 1686, 1685, 1683,
     631     1682, 1678, 1677, 1674, 1676, 1607, 1611, 1614, 1612, 1608,
     632     1616, 1620, 1675, 1623, 1624, 1530, 1453, 1630, 1625, 1629,
     633     1438, 1354, 1319, 1318, 1267, 1212, 1210, 1208, 1631, 1636,
     634     1178, 1639, 1635, 1643, 1177, 1644, 1646, 1650, 1126,  964,
     635      937,  903, 1651, 1652, 1654, 1655, 1656, 1658,  788,  752,
     636     1660,  607,  487, 1662, 1663,  394,  357, 1664, 1666, 1668,
     637     1670, 1669, 1672, 1674,  233,  137, 2822, 1747, 1760, 1773,
     638     1783, 1793, 1806, 1816, 1829, 1842, 1855, 1863, 1873, 1880,
     639
     640     1887, 1894, 1901, 1908, 1915, 1922, 1929, 1936, 1949, 1956,
     641     1960, 1968, 1971, 1978, 1985, 1992, 1995, 2002, 2008, 2021,
     642     2034, 2041, 2048, 2055, 2062, 2065, 2072, 2075, 2082, 2085,
     643     2092, 2095, 2102, 2105, 2112, 2115, 2122, 2125, 2132, 2140,
     644     2147, 2154, 2161, 2168, 2171, 2178, 2181, 2188, 2191, 2198,
     645     2204, 2217, 2224, 2231, 2234, 2241, 2244, 2251, 2254, 2261,
     646     2264, 2271, 2274, 2281, 2284, 2291, 2298, 2301, 2308, 2311,
     647     2318, 2325, 2332, 2335, 2342, 2345, 2352, 2355, 2362, 2365,
     648     2372, 2375, 2382, 2388, 2401, 2408, 2415, 2418, 2425, 2428,
     649     2435, 2438, 2445, 2448, 2455, 2458, 2465, 2468, 2475, 2478,
     650
     651     2485, 2488, 2495, 2502, 2505, 2512, 2515, 2522, 2525, 2532,
     652     2535, 2538, 2544, 2551, 2560, 2567, 2574, 2577, 2584, 2587,
     653     2590, 2596, 2603, 2606, 2609, 2612, 2615, 2618, 2621, 2624,
     654     2631, 2634, 2641, 2644, 2647, 2650, 2653, 2663, 2670, 2673,
     655     2676, 2679, 2686, 2693, 2700, 2703, 2710, 2717, 2724, 2731,
     656     2738, 2745, 2752, 2759, 2766, 2773, 2780, 2787, 2794, 2801,
     657     2808
    658658    } ;
    659659
     
    779779    } ;
    780780
    781 static yyconst flex_int16_t yy_nxt[2883] =
     781static yyconst flex_int16_t yy_nxt[2908] =
    782782    {   0,
    783783       12,   13,   14,   15,   15,   15,   13,   16,   17,   12,
     
    785785       28,   29,   30,   31,   32,   32,   32,   32,   33,   34,
    786786       35,   36,   37,   38,   39,   18,   18,   18,   18,   18,
    787        18,   18,   40,   18,   18,   18,   18,   18,   40,   18,
    788        41,   42,   43,   44,   45,   46,   47,   48,   49,   50,
    789        51,   52,   53,   18,   54,   18,   55,   18,   18,   56,
    790        18,   57,   58,   59,   60,   61,   62,   18,   18,   18,
    791        63,   64,   65,   66,   67,   84,   92,   85,   85,   67,
    792        88,   89,   68,   71,   71,   71,   71,   71,   71,   71,
    793 
    794        71,   71,   71,   72,   71,   71,   71,   71,   71,   71,
     787       18,   18,   18,   40,   18,   18,   18,   18,   18,   40,
     788       18,   41,   42,   43,   44,   45,   46,   47,   48,   49,
     789       50,   51,   52,   53,   18,   54,   18,   55,   18,   18,
     790       56,   18,   57,   58,   59,   60,   61,   62,   18,   18,
     791       18,   63,   64,   65,   66,   67,   84,   92,   85,   85,
     792       67,   88,   89,   68,   71,   71,   71,   71,   71,   71,
     793
     794       71,   71,   71,   71,   72,   71,   71,   71,   71,   71,
    795795       71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
    796        71,   71,   71,   71,   71,   71,   71,   71,   72,   72,
     796       71,   71,   71,   71,   71,   71,   71,   71,   71,   72,
    797797       72,   72,   72,   72,   72,   72,   72,   72,   72,   72,
    798        72,   72,   72,   71,   73,   71,   71,   72,   74,   72,
     798       72,   72,   72,   72,   72,   71,   73,   71,   71,   72,
     799       74,   72,   72,   72,   72,   72,   72,   72,   72,   72,
    799800       72,   72,   72,   72,   72,   72,   72,   72,   72,   72,
    800        72,   72,   72,   72,   72,   72,   72,   72,   72,   72,
    801        72,   72,   72,   71,   71,   71,   71,   76,   76,   79,
    802        79,  123,  124,   90,  141,   79,   79,   87,   76,   76,
    803        80,   81,   82,   82,   82,   80,   82,   81,   83,   83,
    804 
    805        83,   82,   91,   93,  142,  146,   87,   98,   95,   99,
    806        99,   99,   99,   99,   99,  252,  887,   94,  100,   85,
    807        96,   97,   85,  101,  177,  118,   77,   77,   77,   77,
    808       143,  147,   87,  102,  103,  144,  104,  104,  104,  104,
    809       105,  105,  119,   87,  120,  121,  148,   87,  149,  254,
    810       260,   87,  161,  106,  427,  194,  107,   87,   87,  150,
    811       151,  152,  108,  109,  153,  154,  183,  155,  110,   87,
    812       156,  157,   87,   87,  106,   87,  145,  162,  158,  159,
    813       111,  160,   87,  195,  163,   87,   87,  180,  108,  206,
    814       164,  109,  103,  181,  112,  112,  112,  112,  112,  112,
    815 
    816        87,  169,  305,  170,  182,   87,   87,   87,   87,  165,
    817        87,  106,  171,  166,  113,  207,  178,   87,  167,  188,
    818       114,  283,  168,  179,  230,   87,  115,  189,  193,  184,
    819       185,  143,  106,  196,  190,  263,  144,  264,  116,  186,
    820        87,  298,  187,  200,  201,  172,  114,  125,  200,  191,
    821       231,  126,  127,  173,  128,  174,  129,  130,  175,  131,
    822       250,  132,  176,  258,  202,  202,  202,  202,  202,  202,
    823       133,  134,  135,  263,   87,  264,   87,  145,  197,   81,
    824        82,   82,   82,  197,  251,  282,  198,  259,   87,   87,
    825       136,  192,   87,  137,   80,   81,   82,   82,   82,   80,
    826 
    827        82,   81,   82,   82,   82,   82,   82,   81,   83,   83,
    828        83,   82,  263,  307,  264,  242,  242,  242,  242,  248,
    829       138,  139,  209,  210,   87,  249,  256,  209,   87,  211,
    830       249,  263,  257,  264,  211,   99,   99,   99,   99,   99,
    831        99,  265,  887,  212,  212,  212,  212,  243,  248,  310,
    832       887,  249,  265,  263,  211,  264,  249,  103,  257,  105,
    833       105,  105,  105,  105,  105,   87,  263,  241,  264,  213,
    834       887,  263,  211,  264,   87,  257,  106,  211,  211,  887,
    835       271,  211,  211,  280,  255,  266,  263,   87,  264,  211,
    836       404,  244,  211,  256,  211,  214,  211,  106,  215,  217,
    837 
    838       263,  257,  264,  218,  219,  281,  272,  887,  220,  221,
    839       245,  222,  245,  223,   87,  246,  246,  246,  246,  246,
    840       246,   87,  224,  225,  226,  263,  267,  264,  263,  143,
    841       264,   87,  284,   87,  144,   87,  278,   87,   87,   87,
    842        87,   87,  227,  279,  300,  228,   87,  247,   87,  286,
    843       306,  303,   87,  285,   87,  299,   87,   87,   87,  301,
    844       302,  323,  308,  311,  304,   87,   87,  314,  309,   87,
    845       313,  315,   87,  229,  233,  233,  233,  233,  233,  233,
    846        87,  312,   87,  316,  318,   87,  317,   87,   87,   87,
    847       234,  235,   87,  236,  237,  627,  324,  320,  325,  360,
    848 
    849       329,  361,  319,  328,  321,  322,  238,  143,  326,  327,
    850        87,  234,  235,  234,   87,  331,  236,  330,  237,  287,
    851       288,  289,   87,  290,  291,   87,   87,  292,   87,  293,
    852       332,  346,   87,  335,  294,  295,  296,   87,  297,  333,
    853       709,   87,  334,   87,  337,  341,  360,  342,  361,  360,
    854        87,  361,  378,  338,  339,  336,  343,  347,  360,  360,
    855       361,  361,  340,  197,   81,   82,   82,   82,  197,  200,
    856       201,  198,  209,  210,  200,  200,  201,  209,  378,   87,
    857       200,  344,  201,   87,  362,  360,  344,  361,  345,  434,
    858       202,  202,  202,  202,  202,  202,  202,  202,  202,  202,
    859 
    860       202,  202,  202,  202,  202,  202,  202,  202,  352,  352,
    861       352,  352,  361,  361,  360,  363,  361,  360,  360,  361,
    862       361,  369,  887,  369,  143,  360,  360,  361,  361,  370,
    863        87,  370,  388,   87,  371,  371,  371,  371,  371,  371,
    864       353,  373,  390,  401,  369,  373,  369,   87,   87,  234,
    865       235,  402,  236,  237,   87,  263,  375,  264,  388,  263,
    866        87,  264,  373,  416,  373,  403,  372,   87,  391,  373,
    867       234,  235,  234,   87,  407,  236,   87,  237,  105,  105,
    868       105,  105,  105,  105,  246,  246,  246,  246,  246,  246,
    869       405,  245,   87,  245,  414,  106,  246,  246,  246,  246,
    870 
    871       246,  246,  105,  105,  105,  105,  105,  105,   87,   87,
    872       255,   87,  409,  406,  408,   87,  106,  376,  376,  376,
    873       376,  376,  376,  381,  421,   87,  112,  112,  112,  112,
    874       112,  112,  887,  234,  255,   87,  236,  237,  413,   87,
    875        87,  417,  418,   87,  419,  383,   87,  384,   87,  377,
    876        87,  385,  420,  425,  234,   87,  234,  386,  260,  236,
    877        87,  237,  422,   87,  423,  410,  415,   87,   87,  387,
    878        87,  411,  412,  384,   87,  428,  426,  385,  424,  432,
    879        87,  429,   87,   87,   87,  433,  438,   87,   87,  430,
    880       431,   87,  436,  437,   87,   87,  441,  439,   87,  440,
    881 
    882       442,  435,   87,  443,   87,   87,   87,   87,   87,   87,
    883        87,   87,   87,  445,   87,  447,  448,   87,   87,   87,
    884       444,  449,  446,  451,   87,   87,  450,  456,   87,  455,
    885       452,  454,  453,   87,   87,   87,  457,  462,  461,   87,
    886       458,  459,  460,  465,  466,   87,  201,  464,  344,  201,
    887       887,  463,  199,  344,  500,  345,  211,  211,  211,  211,
    888       467,  352,  352,  352,  352,  360,  360,  361,  361,  371,
    889       371,  371,  371,  371,  371,  370,  492,  370,  501,   87,
    890       371,  371,  371,  371,  371,  371,  493,   87,  477,  488,
    891       488,  488,  488,  488,  488,  233,  233,  233,  233,  233,
    892 
    893       233,   87,  492,  516,  496,  234,  492,   87,  236,  237,
    894       242,  242,  242,  242,  105,  105,  494,  495,  515,  381,
    895       518,  489,  495,  496,   87,   87,  234,  374,  234,   87,
    896       496,  236,  492,  237,  376,  376,  376,  376,  376,  376,
    897       887,  383,  375,  384,  517,   87,  522,  385,  545,  496,
    898       497,   87,  497,  386,  519,  498,  498,  498,  498,  498,
    899       498,   87,  383,   87,  384,  387,  377,   87,  385,  384,
    900        87,   87,  520,  385,  502,   87,  521,   87,   87,  523,
    901        87,   87,   87,   87,  524,  526,  387,  499,  532,   87,
    902       384,  525,   87,  527,  385,   87,  531,  528,  529,  530,
    903 
    904        87,  535,   87,  536,  533,   87,   87,  539,   87,   87,
    905        87,  534,   87,  537,   87,   87,   87,  541,  546,  538,
    906       540,   87,   87,  544,   87,  548,   87,   87,   87,  542,
    907       547,  543,   87,   87,  550,   87,  549,  556,   87,  552,
    908        87,   87,  554,   87,  551,   87,   87,  559,  553,   87,
    909       557,   87,  555,   87,   87,   87,  492,   87,  558,  565,
    910       564,  560,  566,  561,  567,  562,   87,   87,  563,   87,
    911        87,  201,  573,  568,   87,  571,  570,  577,  569,  599,
    912       574,  492,  492,  576,   87,  572,  211,  211,  211,  211,
    913       718,  493,  575,  488,  488,  488,  488,  488,  488,  376,
    914 
    915       376,  376,  376,  376,  376,  599,  623,  492,  492,  234,
    916        87,   87,  236,  237,  595,   87,  595,   87,  598,  596,
    917       596,  596,  596,  596,  596,  489,  620,  618,  619,   87,
    918       234,  490,  234,   87,  492,  236,   87,  237,  498,  498,
    919       498,  498,  498,  498,   87,   87,  622,  626,   87,  621,
    920        87,  597,  600,  600,  600,  600,  600,  600,  624,   87,
    921        87,   87,   87,  629,  625,  631,   87,  633,  601,  632,
    922       628,  602,  603,  497,  635,  497,   87,  636,  498,  498,
    923       498,  498,  498,  498,  604,  630,   87,  634,   87,  601,
    924        87,  601,   87,   87,  602,  637,  603,  642,  641,   87,
    925 
    926        87,  640,   87,   87,   87,   87,   87,  639,  643,   87,
    927       638,  647,   87,   87,   87,   87,   87,  644,  648,  645,
    928        87,  646,   87,  654,   87,  650,   87,  653,   87,  649,
    929       651,  652,   87,  655,   87,   87,   87,   87,   87,  657,
    930       659,  664,  656,  661,  660,  658,   87,   87,  666,  663,
    931        87,   87,  688,   87,  688,  665,   87,  662,  488,  488,
    932       488,  488,  488,  488,  668,  702,  703,  667,  596,  596,
    933       596,  596,  596,  596,  595,  688,  595,  688,   87,  596,
    934       596,  596,  596,  596,  596,  689,   87,  721,   87,  689,
    935       594,  686,  686,  686,  686,  686,  686,  600,  600,  600,
    936 
    937       600,  600,  600,  704,   87,   87,  689,  601,  689,  699,
    938       602,  603,  701,  689,   87,   87,   87,   87,   87,   87,
    939        87,   87,  700,  687,  706,   87,  707,   87,  601,  604,
    940       601,   87,  708,  602,  710,  603,   87,  705,  711,  716,
    941       712,  713,  715,   87,  714,   87,   87,   87,  717,   87,
    942        87,   87,   87,   87,   87,   87,   87,   87,  719,  724,
    943        87,  727,  732,   87,  722,  720,  731,   87,   87,  723,
    944        87,  736,  725,  726,  728,   87,  733,  730,  734,  735,
    945       729,  686,  686,  686,  686,  686,  686,  600,  600,  600,
    946       600,  600,  600,   87,   87,   87,  750,  601,   87,  754,
    947 
    948       602,  603,   87,  751,   87,  753,   87,  756,   87,  757,
    949        87,   87,   87,  687,   87,  762,  759,  764,  601,  690,
    950       601,  752,  755,  602,  760,  603,  758,   87,   87,   87,
    951       767,  765,   87,   87,   87,  763,  761,  768,  766,   87,
    952       770,   87,   87,   87,   87,   87,  769,   87,   87,  771,
    953        87,   87,  774,   87,  772,   87,   87,   87,   87,  779,
    954        87,  795,  780,  773,   87,   87,   87,  775,  776,  777,
    955       797,  778,  686,  686,  686,  686,  686,  686,  793,   87,
    956       796,  794,   87,  800,   87,  801,  803,   87,   87,  798,
    957       804,  805,   87,   87,   87,   87,  799,  802,  807,  806,
    958 
    959        87,   87,   87,  808,  743,   87,   87,   87,  809,  828,
    960        87,   87,   87,   87,  830,  831,   87,  810,  833,   87,
    961        87,   87,  834,   87,  811,  827,  826,   87,   87,  825,
    962       836,  837,  829,   87,  832,   87,   87,  839,   87,  840,
    963        87,   87,  835,   87,  838,  850,   87,  887,   87,  851,
    964       852,  855,   87,  856,  849,  857,   87,   87,  853,  858,
    965        87,   87,   87,   87,  854,   87,  859,  864,  865,  860,
    966       863,   87,   87,  866,   87,  868,  867,  869,   87,   87,
    967        87,  870,   87,   87,   87,  873,   87,  875,   87,  876,
    968        87,   87,   87,  874,   87,  872,   87,   87,   87,  871,
    969 
    970        87,  880,   87,  887,  862,  887,  879,  881,  887,  887,
    971       877,  878,  886,  887,  861,  884,   87,   87,  882,  883,
    972        87,   87,  885,   69,   69,   69,   69,   69,   69,   69,
    973        69,   69,   69,   69,   69,   69,   75,   75,   75,   75,
    974        75,   75,   75,   75,   75,   75,   75,   75,   75,   78,
    975        78,   78,   78,   78,   78,   78,   78,   78,   78,   78,
    976        78,   78,   86,   87,  887,   86,  887,   86,   86,   86,
    977        86,   86,  140,  848,  887,  847,  140,  140,  140,  140,
    978       140,  140,  199,  199,  199,  199,  199,  199,  199,  199,
    979       199,  199,  199,  199,  199,  204,  887,  845,  204,  887,
    980 
    981       204,  204,  204,  204,  204,  208,  844,  208,  208,  887,
    982       208,  208,  208,  208,  208,  208,  843,  208,  216,  887,
    983       842,  216,  216,  216,  216,  216,  216,  216,  216,   87,
    984       216,  239,  239,  239,  239,  239,  239,  239,  239,  239,
    985       239,  239,  239,  239,  253,  253,   87,  253,   87,  887,
    986       824,  253,  269,  887,  823,  269,  821,  269,  269,  269,
    987       269,  269,  273,  887,  273,  819,  887,  817,  273,  275,
    988       887,  275,  815,  813,   87,  275,  348,   87,  348,   87,
    989        87,   87,  348,  350,   87,  350,   87,   87,   87,  350,
    990       354,   87,  354,   87,   87,  887,  354,  356,  792,  356,
    991 
    992       790,  887,  887,  356,  358,  787,  358,  785,  783,   87,
    993       358,  365,   87,  365,   87,   87,   87,  365,  367,   87,
    994       367,   87,  749,  746,  367,  239,  239,  239,  239,  239,
    995       239,  239,  239,  239,  239,  239,  239,  239,  380,  745,
    996       380,  382,  382,  743,  382,  382,  382,  205,  382,  253,
    997       253,  739,  253,  392,  738,  392,  670,   87,   87,  392,
    998       394,   87,  394,   87,   87,   87,  394,  396,   87,  396,
    999        87,   87,   87,  396,  273,   87,  273,  398,   87,  398,
    1000        87,   87,   87,  398,  275,  697,  275,   86,  696,  694,
    1001        86,  692,   86,   86,   86,   86,   86,  199,  199,  199,
    1002 
    1003       199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
     801       72,   72,   72,   72,   72,   71,   71,   71,   71,   76,
     802       76,   79,   79,  123,  124,   90,  141,   79,   79,   87,
     803       76,   76,   80,   81,   82,   82,   82,   80,   82,   81,
     804
     805       83,   83,   83,   82,   91,   93,   87,  142,  146,   98,
     806       95,   99,   99,   99,   99,   99,   99,  252,  887,   94,
     807      100,   85,   96,   97,   85,  101,  161,  118,  143,   77,
     808       77,   77,   77,  144,  147,  102,  103,   87,  104,  104,
     809      104,  104,  105,  105,  119,   87,  120,  121,  148,  263,
     810      149,  264,  254,  260,  183,  106,  195,   87,  159,  107,
     811      160,  150,  151,  152,   87,  108,  109,  153,  154,  162,
     812      155,  110,   87,  156,  157,  145,  163,  106,   87,  182,
     813       87,  158,  164,  111,  206,   87,  263,   87,  264,   87,
     814       87,  108,  194,   87,  109,  103,  250,  112,  112,  112,
     815
     816      112,  112,  112,   87,  169,  177,  170,  196,  193,   87,
     817      207,  180,  165,  230,  106,  171,  166,  181,  113,  178,
     818      251,  167,   87,  258,  114,  168,  179,  172,   87,  263,
     819      115,  264,  248,   87,   87,  173,  106,  174,  249,  231,
     820      175,  143,  116,  263,  176,  264,  144,  259,  317,  283,
     821      114,  125,  280,  500,  249,  126,  127,   87,  128,  191,
     822      129,  130,  256,  131,  249,  132,   87,  265,  257,  184,
     823      185,  257,  248,   87,  133,  134,  135,  501,  188,  186,
     824      249,  263,  187,  264,  271,   87,  189,  265,  145,  256,
     825      305,  200,  201,  190,  257,  136,  200,  257,  137,  263,
     826
     827      887,  264,  192,  197,   81,   82,   82,   82,  197,   87,
     828      272,  198,  202,  202,  202,  202,  202,  202,   80,   81,
     829       82,   82,   82,   80,   87,  138,  139,  209,  210,  263,
     830      887,  264,  209,  282,  211,  255,  263,  267,  264,  211,
     831       82,   81,   82,   82,   82,   82,   87,  887,  212,  212,
     832      212,  212,   82,   81,   83,   83,   83,   82,  887,  211,
     833       99,   99,   99,   99,   99,   99,  242,  242,  242,  242,
     834      266,  263,  263,  264,  264,  213,  143,  263,  211,  264,
     835       87,  144,  375,  211,  211,   87,   87,  211,  211,   87,
     836       87,   87,  286,  241,  887,  211,   87,   87,  211,  243,
     837
     838      211,  214,  211,  281,  215,  217,  278,  284,  285,  218,
     839      219,  307,  298,  279,  220,  221,   87,  222,   87,  223,
     840       87,   87,  887,   87,  309,  300,   87,   87,  224,  225,
     841      226,  103,  303,  105,  105,  105,  105,  105,  105,   87,
     842      299,   87,  301,  302,   87,  304,  308,  310,   87,  227,
     843      106,  245,  228,  245,  306,   87,  246,  246,  246,  246,
     844      246,  246,   87,  313,   87,  315,  244,   87,   87,  311,
     845      314,   87,  106,   87,   87,   87,  323,   87,   87,  322,
     846      229,  233,  233,  233,  233,  233,  233,  312,  333,  247,
     847      319,  316,  328,  320,  318,   87,   87,  234,  235,  236,
     848
     849      321,  237,  236,   87,  324,   87,  325,  143,  335,  360,
     850      331,  361,   87,   87,  238,  337,  326,  327,   87,  236,
     851      235,  236,   87,  329,  237,  332,  236,  287,  288,  289,
     852      336,  290,  291,  334,   87,  292,   87,  293,  407,  360,
     853      330,  361,  294,  295,  296,   87,  297,  339,  360,  343,
     854      361,   87,  200,  201,  338,  340,  346,  200,  341,   87,
     855      342,  197,   81,   82,   82,   82,  197,  200,  201,  198,
     856      378,  361,  200,  202,  202,  202,  202,  202,  202,  344,
     857      201,  360,  347,  361,  344,  360,  345,  361,  202,  202,
     858      202,  202,  202,  202,  209,  210,  378,  143,  361,  209,
     859
     860      202,  202,  202,  202,  202,  202,  352,  352,  352,  352,
     861      360,   87,  361,  362,  360,  360,  361,  361,  360,  363,
     862      361,  360,  360,  361,  361,  369,  369,  370,  369,  370,
     863      435,   87,  371,  371,  371,  371,  371,  371,  373,  353,
     864      373,   87,  263,  373,  264,  263,   87,  264,  369,  402,
     865       87,  369,  234,  235,  236,  406,  237,  236,  388,  401,
     866      373,   87,  373,   87,   87,  372,  390,  373,  105,  105,
     867      105,  105,  105,  105,  236,  235,  236,  404,   87,  237,
     868      405,  236,  403,  408,  388,  106,  246,  246,  246,  246,
     869      246,  246,  391,   87,   87,   87,   87,   87,   87,  419,
     870
     871       87,  255,  425,  432,   87,  420,  434,  106,  376,  376,
     872      376,  376,  376,  376,  381,  409,  413,  105,  105,  105,
     873      105,  105,  105,   87,  234,  245,  236,  245,  237,  236,
     874      246,  246,  246,  246,  246,  246,   87,  383,  410,  384,
     875       87,  377,   87,  385,  411,  412,  236,   87,  236,  386,
     876      255,  237,   87,  236,  112,  112,  112,  112,  112,  112,
     877      414,  387,  415,  417,  418,  384,   87,  416,   87,  385,
     878       87,   87,   87,   87,   87,   87,   87,   87,   87,  421,
     879      427,  426,  433,   87,  437,   87,   87,  260,  423,  424,
     880       87,   87,  436,  429,  428,  422,   87,  430,  431,  439,
     881
     882       87,  438,   87,   87,  446,  441,  440,  442,  443,   87,
     883       87,   87,   87,   87,   87,  445,   87,   87,   87,   87,
     884       87,  448,  447,   87,   87,  444,  449,  451,   87,  456,
     885       87,  450,   87,   87,   87,  452,  455,  454,   87,  453,
     886      457,  462,  460,  461,   87,   87,  458,  464,   87,  515,
     887      459,  463,  465,  466,  344,  201,  201,   87,  887,  344,
     888      467,  345,  199,  211,  211,  211,  211,  352,  352,  352,
     889      352,  360,  360,  361,  361,  371,  371,  371,  371,  371,
     890      371,  370,  569,  370,  492,  492,  371,  371,  371,  371,
     891      371,  371,  887,   87,  493,  494,  477,  488,  488,  488,
     892
     893      488,  488,  488,  233,  233,  233,  233,  233,  233,  516,
     894      492,  492,   87,  234,   87,  236,   87,  237,  236,  242,
     895      242,  242,  242,  105,  105,  495,  381,  517,   87,   87,
     896      489,  496,   87,  518,   87,  236,  374,  236,  519,  520,
     897      237,  521,  236,  376,  376,  376,  376,  376,  376,  383,
     898       87,  384,  375,  496,   87,  385,  522,  496,  497,  887,
     899      497,  386,   87,  498,  498,  498,  498,  498,  498,   87,
     900      525,  495,  526,  387,   87,  524,  377,  384,  523,  496,
     901       87,  385,  383,   87,  384,   87,   87,  527,  385,   87,
     902       87,  532,   87,   87,  502,   87,  499,   87,  535,  528,
     903
     904      529,  537,  530,  531,  533,   87,  387,   87,   87,  541,
     905      384,  534,  538,   87,  385,   87,  536,   87,   87,   87,
     906      539,  540,   87,   87,  546,   87,   87,   87,  544,  542,
     907       87,  548,   87,   87,  547,  543,   87,   87,  549,   87,
     908      545,   87,  552,   87,   87,  550,  556,  554,  551,   87,
     909      559,   87,  553,  555,   87,   87,  557,   87,   87,  558,
     910       87,   87,   87,  564,  560,  567,  563,  568,   87,  561,
     911      566,  562,   87,  565,   87,   87,  571,   87,   87,  573,
     912      627,  201,  492,  570,  576,  574,  572,  577,  211,  211,
     913      211,  211,  493,   87,  575,  488,  488,  488,  488,  488,
     914
     915      488,  376,  376,  376,  376,  376,  376,   87,  492,   87,
     916      618,  234,  595,  236,  595,  237,  236,  596,  596,  596,
     917      596,  596,  596,  492,   87,  599,  492,  621,  489,   87,
     918       87,  623,   87,  236,  490,  236,  598,  619,  237,   87,
     919      236,  498,  498,  498,  498,  498,  498,  620,   87,  492,
     920      597,  599,  492,  600,  600,  600,  600,  600,  600,   87,
     921      631,  622,   87,  887,  625,  887,   87,  862,   87,  601,
     922      497,  602,  497,  603,  602,  498,  498,  498,  498,  498,
     923      498,  624,  628,   87,   87,  630,  604,   87,   87,   87,
     924       87,  602,  633,  602,  626,  636,  603,  632,  602,  629,
     925
     926      634,   87,   87,  635,   87,   87,   87,  642,   87,   87,
     927      637,  641,   87,   87,  640,   87,   87,  643,  647,  639,
     928       87,   87,  887,   87,   87,   87,  638,   87,   87,  644,
     929      645,  646,  648,  650,   87,   87,   87,  649,   87,  653,
     930      651,   87,  652,   87,  654,  655,   87,   87,   87,   87,
     931      656,  657,   87,  660,  659,  661,  664,   87,  658,   87,
     932       87,  663,   87,   87,   87,  668,  665,  688,  688,  662,
     933      666,  701,  702,  887,  887,   87,  667,  488,  488,  488,
     934      488,  488,  488,  596,  596,  596,  596,  596,  596,  595,
     935      688,  595,  704,   87,  596,  596,  596,  596,  596,  596,
     936
     937      600,  600,  600,  600,  600,  600,  703,  688,   87,  887,
     938      594,  686,  686,  686,  686,  686,  686,  689,   87,  689,
     939       87,   87,  689,  699,   87,  708,   87,  601,  706,  602,
     940      688,  603,  602,  604,  707,   87,  700,  710,  709,  689,
     941       87,  689,   87,  705,  687,   87,  689,   87,   87,  602,
     942       87,  602,   87,  716,  603,  718,  602,  712,   87,   87,
     943       87,   87,  711,   87,  714,   87,   87,  713,   87,  717,
     944      715,   87,  721,  719,   87,  724,   87,   87,  722,  720,
     945      727,   87,   87,   87,  725,   87,  731,  723,   87,  732,
     946      726,   87,   87,  861,  728,  734,   87,  733,  730,   87,
     947
     948      735,   87,   87,  729,   87,   87,  751,  736,  686,  686,
     949      686,  686,  686,  686,  600,  600,  600,  600,  600,  600,
     950      750,   87,  755,   87,  601,  763,  602,  752,  603,  602,
     951      753,   87,   87,  764,   87,  756,  754,  757,   87,  758,
     952       87,  687,   87,   87,  759,  767,  602,  690,  602,  761,
     953       87,  603,  766,  602,   87,  760,   87,  762,   87,  765,
     954       87,  768,   87,  769,   87,   87,   87,   87,  770,   87,
     955       87,   87,   87,   87,  771,   87,  774,   87,  772,   87,
     956       87,  779,   87,   87,  795,   87,  780,  773,   87,   87,
     957      776,   87,  775,  803,  777,  796,  778,  686,  686,  686,
     958
     959      686,  686,  686,  793,   87,  794,  799,   87,  798,   87,
     960      801,   87,   87,   87,  797,  804,  805,  800,  806,   87,
     961       87,   87,  802,  807,   87,   87,   87,  808,   87,   87,
     962      743,   87,   87,   87,  809,  828,   87,   87,   87,  830,
     963      831,  833,   87,   87,   87,  834,   87,  836,  810,  811,
     964      826,  827,   87,  829,   87,  825,  832,  837,   87,   87,
     965       87,  838,  839,   87,   87,  835,   87,   87,   87,  851,
     966      850,  855,   87,  852,  840,   87,   87,   87,  853,  857,
     967      849,   87,   87,   87,  854,  858,  859,   87,   87,  856,
     968      860,   87,  863,  864,  865,   87,   87,  866,   87,  868,
     969
     970      867,  869,   87,   87,   87,  870,   87,   87,   87,  873,
     971       87,  875,   87,  876,   87,   87,   87,  874,   87,  872,
     972       87,   87,   87,  871,   87,  880,   87,   87,   87,  887,
     973      879,  881,  887,  848,  877,  878,  886,  887,  847,  884,
     974      887,  845,  882,  883,  887,  844,  885,   69,   69,   69,
     975       69,   69,   69,   69,   69,   69,   69,   69,   69,   69,
     976       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
     977       75,   75,   75,   78,   78,   78,   78,   78,   78,   78,
     978       78,   78,   78,   78,   78,   78,   86,  887,  843,   86,
     979      887,   86,   86,   86,   86,   86,  140,  842,   87,   87,
     980
     981      140,  140,  140,  140,  140,  140,  199,  199,  199,  199,
     982      199,  199,  199,  199,  199,  199,  199,  199,  199,  204,
     983       87,  887,  204,  824,  204,  204,  204,  204,  204,  208,
     984      887,  208,  208,  823,  208,  208,  208,  208,  208,  208,
     985      821,  208,  216,  887,  819,  216,  216,  216,  216,  216,
     986      216,  216,  216,  887,  216,  239,  239,  239,  239,  239,
     987      239,  239,  239,  239,  239,  239,  239,  239,  253,  253,
     988      817,  253,  887,  815,  813,  253,  269,   87,   87,  269,
     989       87,  269,  269,  269,  269,  269,  273,   87,  273,   87,
     990       87,   87,  273,  275,   87,  275,   87,   87,   87,  275,
     991
     992      348,   87,  348,  887,  792,  790,  348,  350,  887,  350,
     993      887,  787,  785,  350,  354,  783,  354,   87,   87,   87,
     994      354,  356,   87,  356,   87,   87,   87,  356,  358,  749,
     995      358,  746,  745,  743,  358,  365,  205,  365,  739,  738,
     996      670,  365,  367,   87,  367,   87,   87,   87,  367,  239,
     997      239,  239,  239,  239,  239,  239,  239,  239,  239,  239,
     998      239,  239,  380,   87,  380,  382,  382,   87,  382,  382,
     999      382,   87,  382,  253,  253,   87,  253,  392,   87,  392,
     1000       87,   87,   87,  392,  394,   87,  394,   87,   87,  697,
     1001      394,  396,  696,  396,  694,  692,  690,  396,  273,  598,
     1002
     1003      273,  398,  685,  398,  684,  682,  680,  398,  275,  678,
     1004      275,   86,  676,  674,   86,  672,   86,   86,   86,   86,
     1005       86,  199,  199,  199,  199,  199,  199,  199,  199,  199,
     1006      199,  199,  199,  199,  468,  468,  468,  468,  468,  468,
     1007      468,  468,  468,  468,  468,  468,  468,  469,  670,  469,
     1008       87,   87,   87,  469,  471,   87,  471,   87,   87,   87,
     1009      471,  473,   87,  473,   87,   87,   87,  473,  348,  617,
     1010      348,  475,  615,  475,  613,  611,  609,  475,  350,  607,
     1011      350,  478,  502,  478,  605,  605,  594,  478,  354,  593,
     1012      354,  480,  591,  480,  483,  483,  589,  480,  356,  587,
     1013
     1014      356,  482,  585,  482,  583,  581,  579,  482,  358,   87,
     1015      358,  484,   87,  484,   87,   87,   87,  484,  365,   87,
     1016      365,  486,   87,  486,   87,  514,  512,  486,  367,  510,
     1017      367,  491,  508,  491,  506,  491,  504,  491,  380,  490,
     1018      380,  487,  380,  485,  380,  382,  382,  361,  382,  382,
     1019      382,  361,  382,  503,  483,  503,  481,  479,  476,  503,
     1020      505,  474,  505,  472,  470,   87,  505,  507,   87,  507,
     1021       87,  400,  399,  507,  392,  397,  392,  509,  395,  509,
     1022      393,  270,  265,  509,  394,  264,  394,  511,  389,  511,
     1023      389,  252,  379,  511,  396,  379,  396,  513,  240,  513,
     1024
     1025      374,  368,  366,  513,  398,  364,  398,   86,  360,  359,
     1026       86,  357,   86,   86,   86,   86,   86,  468,  468,  468,
    10041027      468,  468,  468,  468,  468,  468,  468,  468,  468,  468,
    1005       468,  468,  468,  469,  690,  469,  598,  685,  684,  469,
    1006       471,  682,  471,  680,  678,  676,  471,  473,  674,  473,
    1007       672,  670,   87,  473,  348,   87,  348,  475,   87,  475,
    1008        87,   87,   87,  475,  350,   87,  350,  478,   87,  478,
    1009        87,   87,   87,  478,  354,  617,  354,  480,  615,  480,
    1010       613,  611,  609,  480,  356,  607,  356,  482,  502,  482,
    1011       605,  605,  594,  482,  358,  593,  358,  484,  591,  484,
    1012       483,  483,  589,  484,  365,  587,  365,  486,  585,  486,
    1013 
    1014       583,  581,  579,  486,  367,   87,  367,  491,   87,  491,
    1015        87,  491,   87,  491,  380,   87,  380,   87,  380,   87,
    1016       380,  382,  382,   87,  382,  382,  382,  514,  382,  503,
    1017       512,  503,  510,  508,  506,  503,  505,  504,  505,  490,
    1018       487,  485,  505,  507,  361,  507,  361,  483,  481,  507,
    1019       392,  479,  392,  509,  476,  509,  474,  472,  470,  509,
    1020       394,   87,  394,  511,   87,  511,   87,  400,  399,  511,
    1021       396,  397,  396,  513,  395,  513,  393,  270,  265,  513,
    1022       398,  264,  398,   86,  389,  389,   86,  252,   86,   86,
    1023        86,   86,   86,  468,  468,  468,  468,  468,  468,  468,
    1024 
    1025       468,  468,  468,  468,  468,  468,  578,  379,  578,  379,
    1026       240,  374,  578,  469,  368,  469,  580,  366,  580,  364,
    1027       360,  359,  580,  471,  357,  471,  582,  355,  582,  351,
    1028       349,  205,  582,  473,  201,  473,  584,   87,  584,  277,
    1029       276,  274,  584,  475,  270,  475,  586,  265,  586,  268,
    1030       265,  263,  586,  478,  262,  478,  588,  261,  588,  240,
    1031       232,   85,  588,  480,   85,  480,  482,   87,  482,  205,
    1032       203,   85,  482,  590,  122,  590,  117,   87,  887,  590,
    1033       484,   70,  484,  592,   70,  592,  887,  887,  887,  592,
    1034       486,  887,  486,  491,  887,  491,  887,  491,  887,  491,
    1035 
    1036       382,  887,  382,  887,  887,  887,  382,  606,  887,  606,
    1037       887,  887,  887,  606,  503,  887,  503,  608,  887,  608,
    1038       887,  887,  887,  608,  505,  887,  505,  610,  887,  610,
    1039       887,  887,  887,  610,  507,  887,  507,  612,  887,  612,
    1040       887,  887,  887,  612,  509,  887,  509,  614,  887,  614,
    1041       887,  887,  887,  614,  511,  887,  511,  616,  887,  616,
    1042       887,  887,  887,  616,  513,  887,  513,   86,  887,  887,
    1043        86,  887,   86,   86,   86,   86,   86,  669,  669,  669,
     1028      578,  355,  578,  351,  349,  205,  578,  469,  201,  469,
     1029      580,   87,  580,  277,  276,  274,  580,  471,  270,  471,
     1030      582,  265,  582,  268,  265,  263,  582,  473,  262,  473,
     1031      584,  261,  584,  240,  232,   85,  584,  475,   85,  475,
     1032      586,   87,  586,  205,  203,   85,  586,  478,  122,  478,
     1033      588,  117,  588,   87,  887,   70,  588,  480,   70,  480,
     1034      482,  887,  482,  887,  887,  887,  482,  590,  887,  590,
     1035
     1036      887,  887,  887,  590,  484,  887,  484,  592,  887,  592,
     1037      887,  887,  887,  592,  486,  887,  486,  491,  887,  491,
     1038      887,  491,  887,  491,  382,  887,  382,  887,  887,  887,
     1039      382,  606,  887,  606,  887,  887,  887,  606,  503,  887,
     1040      503,  608,  887,  608,  887,  887,  887,  608,  505,  887,
     1041      505,  610,  887,  610,  887,  887,  887,  610,  507,  887,
     1042      507,  612,  887,  612,  887,  887,  887,  612,  509,  887,
     1043      509,  614,  887,  614,  887,  887,  887,  614,  511,  887,
     1044      511,  616,  887,  616,  887,  887,  887,  616,  513,  887,
     1045      513,   86,  887,  887,   86,  887,   86,   86,   86,   86,
     1046
     1047       86,  669,  669,  669,  669,  669,  669,  669,  669,  669,
     1048      669,  669,  669,  669,  671,  887,  671,  887,  887,  887,
     1049      671,  578,  887,  578,  673,  887,  673,  887,  887,  887,
     1050      673,  580,  887,  580,  675,  887,  675,  887,  887,  887,
     1051      675,  582,  887,  582,  677,  887,  677,  887,  887,  887,
     1052      677,  584,  887,  584,  679,  887,  679,  887,  887,  887,
     1053      679,  586,  887,  586,  681,  887,  681,  887,  887,  887,
     1054      681,  588,  887,  588,  683,  887,  683,  887,  887,  887,
     1055      683,  590,  887,  590,   86,  887,   86,  887,  887,  887,
     1056       86,  592,  887,  592,  491,  887,  491,  887,  887,  887,
     1057
     1058      491,  691,  887,  691,  887,  887,  887,  691,  606,  887,
     1059      606,  693,  887,  693,  887,  887,  887,  693,  608,  887,
     1060      608,  695,  887,  695,  887,  887,  887,  695,  610,  887,
     1061      610,  140,  887,  140,  887,  887,  887,  140,  612,  887,
     1062      612,  698,  887,  698,  614,  887,  614,   86,  887,  887,
     1063       86,  887,   86,   86,   86,   86,   86,  616,  887,  616,
    10441064      669,  669,  669,  669,  669,  669,  669,  669,  669,  669,
    1045       671,  887,  671,  887,  887,  887,  671,  578,  887,  578,
    1046 
    1047       673,  887,  673,  887,  887,  887,  673,  580,  887,  580,
    1048       675,  887,  675,  887,  887,  887,  675,  582,  887,  582,
    1049       677,  887,  677,  887,  887,  887,  677,  584,  887,  584,
    1050       679,  887,  679,  887,  887,  887,  679,  586,  887,  586,
    1051       681,  887,  681,  887,  887,  887,  681,  588,  887,  588,
    1052       683,  887,  683,  887,  887,  887,  683,  590,  887,  590,
    1053        86,  887,   86,  887,  887,  887,   86,  592,  887,  592,
    1054       491,  887,  491,  887,  887,  887,  491,  691,  887,  691,
    1055       887,  887,  887,  691,  606,  887,  606,  693,  887,  693,
    1056       887,  887,  887,  693,  608,  887,  608,  695,  887,  695,
    1057 
    1058       887,  887,  887,  695,  610,  887,  610,  140,  887,  140,
    1059       887,  887,  887,  140,  612,  887,  612,  698,  887,  698,
    1060       614,  887,  614,   86,  887,  887,   86,  887,   86,   86,
    1061        86,   86,   86,  616,  887,  616,  669,  669,  669,  669,
    1062       669,  669,  669,  669,  669,  669,  669,  669,  669,  737,
    1063       887,  737,  887,  887,  887,  737,  671,  887,  671,  204,
    1064       887,  204,  887,  887,  887,  204,  673,  887,  673,  740,
    1065       887,  740,  675,  887,  675,  204,  887,  887,  204,  887,
    1066       204,  204,  204,  204,  204,  677,  887,  677,  741,  887,
    1067       741,  679,  887,  679,  681,  887,  681,  742,  887,  742,
    1068 
    1069       683,  887,  683,   86,  887,   86,  744,  887,  744,  887,
    1070       887,  887,  744,  691,  887,  691,  269,  887,  269,  887,
    1071       887,  887,  269,  693,  887,  693,  747,  887,  747,  695,
    1072       887,  695,  140,  887,  140,  748,  887,  748,  887,  887,
    1073       887,  748,   86,  887,  887,   86,  887,   86,   86,   86,
    1074        86,   86,  781,  887,  781,  737,  887,  737,  204,  887,
    1075       204,  782,  887,  782,  887,  887,  887,  782,  784,  887,
    1076       784,  887,  887,  887,  784,  786,  887,  786,  887,  887,
    1077       887,  786,  788,  887,  788,  789,  887,  789,  887,  887,
    1078       887,  789,  791,  887,  791,  887,  887,  887,  791,  812,
    1079 
    1080       887,  812,  887,  887,  887,  812,  814,  887,  814,  887,
    1081       887,  887,  814,  816,  887,  816,  887,  887,  887,  816,
    1082       818,  887,  818,  887,  887,  887,  818,  820,  887,  820,
    1083       887,  887,  887,  820,  822,  887,  822,  887,  887,  887,
    1084       822,  616,  887,  616,  887,  887,  887,  616,  841,  887,
    1085       841,  887,  887,  887,  841,  677,  887,  677,  887,  887,
    1086       887,  677,  681,  887,  681,  887,  887,  887,  681,   86,
    1087       887,   86,  887,  887,  887,   86,  846,  887,  846,  887,
    1088       887,  887,  846,  140,  887,  140,  887,  887,  887,  140,
    1089       204,  887,  204,  887,  887,  887,  204,   11,  887,  887,
    1090 
     1065      669,  669,  669,  737,  887,  737,  887,  887,  887,  737,
     1066      671,  887,  671,  204,  887,  204,  887,  887,  887,  204,
     1067      673,  887,  673,  740,  887,  740,  675,  887,  675,  204,
     1068
     1069      887,  887,  204,  887,  204,  204,  204,  204,  204,  677,
     1070      887,  677,  741,  887,  741,  679,  887,  679,  681,  887,
     1071      681,  742,  887,  742,  683,  887,  683,   86,  887,   86,
     1072      744,  887,  744,  887,  887,  887,  744,  691,  887,  691,
     1073      269,  887,  269,  887,  887,  887,  269,  693,  887,  693,
     1074      747,  887,  747,  695,  887,  695,  140,  887,  140,  748,
     1075      887,  748,  887,  887,  887,  748,   86,  887,  887,   86,
     1076      887,   86,   86,   86,   86,   86,  781,  887,  781,  737,
     1077      887,  737,  204,  887,  204,  782,  887,  782,  887,  887,
     1078      887,  782,  784,  887,  784,  887,  887,  887,  784,  786,
     1079
     1080      887,  786,  887,  887,  887,  786,  788,  887,  788,  789,
     1081      887,  789,  887,  887,  887,  789,  791,  887,  791,  887,
     1082      887,  887,  791,  812,  887,  812,  887,  887,  887,  812,
     1083      814,  887,  814,  887,  887,  887,  814,  816,  887,  816,
     1084      887,  887,  887,  816,  818,  887,  818,  887,  887,  887,
     1085      818,  820,  887,  820,  887,  887,  887,  820,  822,  887,
     1086      822,  887,  887,  887,  822,  616,  887,  616,  887,  887,
     1087      887,  616,  841,  887,  841,  887,  887,  887,  841,  677,
     1088      887,  677,  887,  887,  887,  677,  681,  887,  681,  887,
     1089      887,  887,  681,   86,  887,   86,  887,  887,  887,   86,
     1090
     1091      846,  887,  846,  887,  887,  887,  846,  140,  887,  140,
     1092      887,  887,  887,  140,  204,  887,  204,  887,  887,  887,
     1093      204,   11,  887,  887,  887,  887,  887,  887,  887,  887,
    10911094      887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    10921095      887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
     
    10961099      887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    10971100      887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1098       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1099       887,  887
     1101
     1102      887,  887,  887,  887,  887,  887,  887
    11001103    } ;
    11011104
    1102 static yyconst flex_int16_t yy_chk[2883] =
     1105static yyconst flex_int16_t yy_chk[2908] =
    11031106    {   0,
    11041107        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     
    11101113        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    11111114        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1112         1,    1,    1,    1,    2,   16,   24,   16,   24,    2,
    1113        19,   19,    2,    5,    5,    5,    5,    5,    5,    5,
     1115        1,    1,    1,    1,    1,    2,   16,   24,   16,   24,
     1116        2,   19,   19,    2,    5,    5,    5,    5,    5,    5,
    11141117
    11151118        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
     
    11201123        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
    11211124        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
    1122         5,    5,    5,    5,    5,    5,    5,    7,    8,    9,
    1123        10,   37,   37,   20,   39,    9,   10,  886,    7,    8,
    1124        13,   13,   13,   13,   13,   13,   15,   15,   15,   15,
    1125 
    1126        15,   15,   20,   25,   39,   42,   53,   28,   27,   28,
    1127        28,   28,   28,   28,   28,  109,  115,   25,   29,   25,
    1128        27,   27,   27,   29,   53,   35,    7,    8,    9,   10,
    1129        40,   42,   48,   29,   30,   40,   30,   30,   30,   30,
    1130        30,   30,   35,   62,   35,   35,   44,  302,   44,  109,
    1131       115,  885,   48,   30,  302,   62,   30,   57,   47,   45,
    1132        45,   45,   30,   30,   45,   45,   57,   45,   30,   55,
    1133        45,   45,   49,   40,   30,   45,   40,   49,   45,   47,
    1134        30,   47,   56,   64,   49,  164,   51,   55,   30,   73,
    1135        49,   30,   31,   55,   31,   31,   31,   31,   31,   31,
    1136 
    1137        50,   51,  164,   51,   56,  154,   54,   59,  877,   50,
    1138        61,   31,   51,   50,   31,   73,   54,   58,   50,   59,
    1139        31,  154,   50,   54,   87,  159,   31,   59,   61,   58,
    1140        58,   60,   31,   64,   59,  126,   60,  126,   31,   58,
    1141        52,  159,   58,   68,   68,   52,   31,   38,   68,   60,
    1142        87,   38,   38,   52,   38,   52,   38,   38,   52,   38,
    1143       108,   38,   52,  114,   68,   68,   68,   68,   68,   68,
    1144        38,   38,   38,  127,   60,  127,  153,   60,   67,   67,
    1145        67,   67,   67,   67,  108,  153,   67,  114,  876,  873,
    1146        38,   60,  166,   38,   80,   80,   80,   80,   80,   80,
    1147 
    1148        82,   82,   82,   82,   82,   82,   83,   83,   83,   83,
    1149        83,   83,  129,  166,  129,  104,  104,  104,  104,  107,
    1150        38,   38,   77,   77,  872,  107,  113,   77,  169,   77,
    1151       111,  132,  113,  132,   77,  103,  103,  103,  103,  103,
    1152       103,  131,  104,   77,   77,   77,   77,  104,  111,  169,
    1153       110,  107,  130,  131,   77,  131,  111,  105,  113,  105,
    1154       105,  105,  105,  105,  105,  151,  130,  103,  130,   77,
    1155       104,  134,   77,  134,  281,  116,  105,   77,   77,  110,
    1156       142,   77,   77,  151,  110,  133,  133,  152,  133,   77,
    1157       281,  105,   77,  116,   77,   77,   77,  105,   77,   85,
    1158 
    1159       137,  116,  137,   85,   85,  152,  142,  110,   85,   85,
    1160       106,   85,  106,   85,  155,  106,  106,  106,  106,  106,
    1161       106,  150,   85,   85,   85,  135,  135,  135,  139,  145,
    1162       139,  156,  155,  160,  145,  161,  150,  157,  162,  167,
    1163       165,  168,   85,  150,  161,   85,  163,  106,  171,  157,
    1164       165,  163,  172,  156,  173,  160,  181,  176,  170,  162,
    1165       162,  181,  167,  170,  163,  174,  175,  172,  168,  182,
    1166       171,  173,  145,   85,   99,   99,   99,   99,   99,   99,
    1167       177,  170,  179,  174,  176,  184,  175,  183,  180,  185,
    1168        99,   99,  525,   99,   99,  525,  182,  179,  183,  218,
    1169 
    1170       185,  218,  177,  184,  179,  180,   99,  191,  183,  183,
    1171       186,   99,   99,   99,  158,  186,   99,  185,   99,  158,
    1172       158,  158,  188,  158,  158,  190,  187,  158,  189,  158,
    1173       186,  205,  193,  189,  158,  158,  158,  627,  158,  187,
    1174       627,  192,  188,  194,  190,  193,  219,  193,  219,  220,
    1175       191,  220,  248,  191,  192,  189,  194,  205,  223,  225,
    1176       223,  225,  192,  197,  197,  197,  197,  197,  197,  198,
    1177       198,  197,  209,  209,  198,  200,  200,  209,  248,  870,
    1178       200,  202,  202,  308,  224,  224,  202,  224,  202,  308,
    1179       198,  198,  198,  198,  198,  198,  200,  200,  200,  200,
    1180 
    1181       200,  200,  202,  202,  202,  202,  202,  202,  212,  212,
    1182       212,  212,  221,  222,  226,  226,  226,  228,  229,  228,
    1183       229,  234,  243,  237,  338,  222,  221,  222,  221,  235,
    1184       278,  235,  256,  279,  235,  235,  235,  235,  235,  235,
    1185       212,  236,  270,  278,  234,  236,  237,  280,  291,  241,
    1186       241,  279,  241,  241,  284,  266,  243,  266,  256,  267,
    1187       869,  267,  236,  291,  236,  280,  235,  338,  270,  236,
    1188       241,  241,  241,  282,  284,  241,  289,  241,  244,  244,
    1189       244,  244,  244,  244,  245,  245,  245,  245,  245,  245,
    1190       282,  247,  286,  247,  289,  244,  247,  247,  247,  247,
    1191 
    1192       247,  247,  255,  255,  255,  255,  255,  255,  283,  285,
    1193       244,  295,  286,  283,  285,  288,  244,  246,  246,  246,
    1194       246,  246,  246,  253,  295,  292,  260,  260,  260,  260,
    1195       260,  260,  862,  246,  255,  296,  246,  246,  288,  293,
    1196       290,  292,  292,  294,  293,  253,  297,  253,  300,  246,
    1197       287,  253,  294,  300,  246,  303,  246,  253,  260,  246,
    1198       299,  246,  296,  304,  297,  287,  290,  301,  305,  253,
    1199       312,  287,  287,  253,  306,  303,  301,  253,  299,  306,
    1200       307,  304,  309,  310,  314,  307,  312,  311,  313,  305,
    1201       305,  315,  310,  311,  318,  316,  315,  313,  317,  314,
    1202 
    1203       316,  309,  320,  317,  319,  322,  323,  324,  326,  327,
    1204       325,  328,  329,  318,  331,  320,  322,  332,  330,  333,
    1205       317,  323,  319,  325,  334,  335,  324,  330,  337,  329,
    1206       326,  328,  327,  339,  340,  341,  331,  337,  335,  342,
    1207       332,  333,  334,  341,  342,  343,  345,  340,  344,  344,
    1208       861,  339,  345,  344,  385,  344,  352,  352,  352,  352,
    1209       343,  353,  353,  353,  353,  362,  363,  362,  363,  370,
    1210       370,  370,  370,  370,  370,  372,  380,  372,  385,  860,
    1211       372,  372,  372,  372,  372,  372,  380,  402,  352,  371,
    1212       371,  371,  371,  371,  371,  374,  374,  374,  374,  374,
    1213 
    1214       374,  404,  380,  402,  387,  371,  381,  401,  371,  371,
    1215       375,  375,  375,  375,  375,  375,  381,  383,  401,  382,
    1216       404,  371,  387,  383,  408,  432,  371,  374,  371,  403,
    1217       387,  371,  381,  371,  376,  376,  376,  376,  376,  376,
    1218       386,  382,  375,  382,  403,  405,  408,  382,  432,  383,
    1219       384,  859,  384,  382,  405,  384,  384,  384,  384,  384,
    1220       384,  406,  386,  412,  386,  382,  376,  407,  386,  382,
    1221       409,  410,  406,  382,  386,  411,  407,  415,  416,  409,
    1222       413,  414,  420,  417,  410,  412,  386,  384,  417,  418,
    1223       386,  411,  423,  413,  386,  419,  416,  414,  414,  415,
    1224 
    1225       422,  419,  421,  420,  418,  427,  425,  423,  429,  430,
    1226       431,  418,  433,  421,  439,  434,  435,  427,  433,  422,
    1227       425,  437,  440,  431,  441,  435,  442,  443,  445,  429,
    1228       434,  430,  444,  447,  439,  449,  437,  445,  450,  441,
    1229       451,  456,  443,  452,  440,  453,  454,  450,  442,  457,
    1230       447,  455,  444,  460,  461,  463,  494,  458,  449,  456,
    1231       455,  451,  457,  452,  458,  453,  459,  462,  454,  464,
    1232       466,  468,  463,  459,  467,  462,  461,  468,  460,  495,
    1233       464,  491,  494,  467,  521,  462,  477,  477,  477,  477,
    1234       636,  491,  466,  488,  488,  488,  488,  488,  488,  490,
    1235 
    1236       490,  490,  490,  490,  490,  495,  521,  491,  493,  488,
    1237       515,  518,  488,  488,  492,  516,  492,  636,  493,  492,
    1238       492,  492,  492,  492,  492,  488,  518,  515,  516,  519,
    1239       488,  490,  488,  520,  493,  488,  524,  488,  497,  497,
    1240       497,  497,  497,  497,  529,  522,  520,  524,  527,  519,
    1241       526,  492,  498,  498,  498,  498,  498,  498,  522,  523,
    1242       530,  533,  531,  527,  523,  529,  528,  531,  498,  530,
    1243       526,  498,  498,  499,  533,  499,  532,  534,  499,  499,
    1244       499,  499,  499,  499,  498,  528,  535,  532,  536,  498,
    1245       537,  498,  538,  539,  498,  535,  498,  541,  539,  542,
    1246 
    1247       544,  538,  547,  541,  545,  534,  546,  537,  542,  549,
    1248       536,  547,  550,  551,  557,  552,  554,  544,  549,  545,
    1249       560,  546,  555,  557,  558,  551,  561,  555,  562,  550,
    1250       552,  554,  564,  558,  565,  567,  566,  568,  572,  561,
    1251       564,  569,  560,  566,  565,  562,  571,  569,  572,  568,
    1252       574,  575,  601,  621,  603,  571,  620,  567,  594,  594,
    1253       594,  594,  594,  594,  575,  620,  621,  574,  595,  595,
    1254       595,  595,  595,  595,  597,  601,  597,  603,  639,  597,
    1255       597,  597,  597,  597,  597,  602,  622,  639,  855,  602,
    1256       594,  596,  596,  596,  596,  596,  596,  600,  600,  600,
    1257 
    1258       600,  600,  600,  622,  618,  619,  602,  596,  602,  618,
    1259       596,  596,  619,  602,  623,  626,  629,  624,  625,  631,
    1260       633,  628,  618,  596,  624,  630,  625,  632,  596,  600,
    1261       596,  635,  626,  596,  628,  596,  634,  623,  629,  634,
    1262       630,  631,  633,  637,  632,  638,  640,  641,  635,  644,
    1263       642,  645,  646,  651,  650,  657,  668,  656,  637,  642,
    1264       653,  646,  657,  851,  640,  638,  656,  664,  665,  641,
    1265       667,  668,  644,  645,  650,  699,  664,  653,  665,  667,
    1266       651,  686,  686,  686,  686,  686,  686,  690,  690,  690,
    1267       690,  690,  690,  700,  704,  702,  699,  686,  703,  704,
    1268 
    1269       686,  686,  705,  700,  706,  703,  707,  706,  708,  707,
    1270       710,  711,  713,  686,  714,  713,  710,  715,  686,  690,
    1271       686,  702,  705,  686,  711,  686,  708,  712,  716,  717,
    1272       718,  716,  721,  720,  719,  714,  712,  719,  717,  722,
    1273       721,  723,  724,  725,  728,  715,  720,  732,  731,  722,
    1274       733,  735,  725,  736,  723,  718,  756,  761,  754,  735,
    1275       758,  756,  736,  724,  755,  757,  759,  728,  731,  732,
    1276       758,  733,  743,  743,  743,  743,  743,  743,  754,  760,
    1277       757,  755,  762,  761,  763,  762,  764,  766,  768,  759,
    1278       766,  768,  769,  772,  773,  770,  760,  763,  770,  769,
    1279 
    1280       771,  778,  793,  771,  743,  795,  797,  796,  772,  797,
    1281       798,  799,  800,  764,  799,  800,  802,  773,  803,  804,
    1282       806,  810,  804,  811,  778,  796,  795,  807,  808,  793,
    1283       807,  808,  798,  826,  802,  809,  832,  810,  827,  811,
    1284       830,  829,  806,  803,  809,  827,  828,  848,  831,  828,
    1285       829,  831,  835,  832,  826,  835,  838,  839,  830,  838,
    1286       840,  849,  850,  853,  830,  852,  839,  850,  852,  840,
    1287       849,  854,  856,  853,  857,  856,  854,  857,  858,  863,
    1288       864,  858,  865,  866,  867,  865,  868,  867,  871,  868,
    1289       874,  875,  878,  866,  879,  864,  880,  882,  881,  863,
    1290 
    1291       883,  878,  884,  847,  846,  845,  875,  879,  844,  843,
    1292       871,  874,  884,  842,  841,  882,  837,  836,  880,  881,
    1293       834,  833,  883,  888,  888,  888,  888,  888,  888,  888,
    1294       888,  888,  888,  888,  888,  888,  889,  889,  889,  889,
    1295       889,  889,  889,  889,  889,  889,  889,  889,  889,  890,
    1296       890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
    1297       890,  890,  891,  825,  824,  891,  823,  891,  891,  891,
    1298       891,  891,  892,  822,  821,  820,  892,  892,  892,  892,
    1299       892,  892,  893,  893,  893,  893,  893,  893,  893,  893,
    1300       893,  893,  893,  893,  893,  894,  819,  818,  894,  817,
    1301 
    1302       894,  894,  894,  894,  894,  895,  816,  895,  895,  815,
    1303       895,  895,  895,  895,  895,  895,  814,  895,  896,  813,
    1304       812,  896,  896,  896,  896,  896,  896,  896,  896,  805,
    1305       896,  897,  897,  897,  897,  897,  897,  897,  897,  897,
    1306       897,  897,  897,  897,  898,  898,  801,  898,  794,  792,
    1307       791,  898,  899,  790,  789,  899,  788,  899,  899,  899,
    1308       899,  899,  900,  787,  900,  786,  785,  784,  900,  901,
    1309       783,  901,  782,  781,  780,  901,  902,  779,  902,  777,
    1310       776,  775,  902,  903,  774,  903,  767,  765,  753,  903,
    1311       904,  752,  904,  751,  750,  749,  904,  905,  748,  905,
    1312 
    1313       747,  746,  745,  905,  906,  742,  906,  741,  740,  734,
    1314       906,  907,  730,  907,  729,  727,  726,  907,  908,  709,
    1315       908,  701,  698,  693,  908,  909,  909,  909,  909,  909,
    1316       909,  909,  909,  909,  909,  909,  909,  909,  910,  691,
    1317       910,  911,  911,  687,  911,  911,  911,  677,  911,  912,
    1318       912,  673,  912,  913,  671,  913,  669,  666,  663,  913,
    1319       914,  662,  914,  661,  660,  659,  914,  915,  658,  915,
    1320       655,  654,  652,  915,  916,  649,  916,  917,  648,  917,
    1321       647,  643,  616,  917,  918,  612,  918,  919,  610,  608,
    1322       919,  606,  919,  919,  919,  919,  919,  920,  920,  920,
    1323 
    1324       920,  920,  920,  920,  920,  920,  920,  920,  920,  920,
    1325       921,  921,  921,  921,  921,  921,  921,  921,  921,  921,
    1326       921,  921,  921,  922,  604,  922,  598,  592,  590,  922,
    1327       923,  588,  923,  586,  584,  582,  923,  924,  580,  924,
    1328       578,  577,  576,  924,  925,  573,  925,  926,  570,  926,
    1329       563,  559,  556,  926,  927,  553,  927,  928,  548,  928,
    1330       543,  540,  517,  928,  929,  513,  929,  930,  511,  930,
    1331       509,  507,  505,  930,  931,  503,  931,  932,  502,  932,
    1332       501,  500,  489,  932,  933,  486,  933,  934,  484,  934,
    1333       483,  482,  480,  934,  935,  478,  935,  936,  475,  936,
    1334 
    1335       473,  471,  469,  936,  937,  465,  937,  938,  448,  938,
    1336       446,  938,  438,  938,  939,  436,  939,  428,  939,  426,
    1337       939,  940,  940,  424,  940,  940,  940,  398,  940,  941,
    1338       396,  941,  394,  392,  391,  941,  942,  390,  942,  377,
    1339       367,  365,  942,  943,  364,  943,  360,  358,  356,  943,
    1340       944,  354,  944,  945,  350,  945,  348,  347,  346,  945,
    1341       946,  336,  946,  947,  321,  947,  298,  277,  275,  947,
    1342       948,  273,  948,  949,  272,  949,  271,  269,  268,  949,
    1343       950,  263,  950,  951,  259,  258,  951,  254,  951,  951,
    1344       951,  951,  951,  952,  952,  952,  952,  952,  952,  952,
    1345 
    1346       952,  952,  952,  952,  952,  952,  953,  251,  953,  250,
    1347       239,  238,  953,  954,  231,  954,  955,  230,  955,  227,
    1348       217,  215,  955,  956,  214,  956,  957,  213,  957,  207,
    1349       206,  204,  957,  958,  199,  958,  959,  178,  959,  149,
    1350       147,  146,  959,  960,  140,  960,  961,  138,  961,  136,
    1351       128,  125,  961,  962,  124,  962,  963,  120,  963,  101,
    1352        98,   95,  963,  964,   93,  964,  965,   86,  965,   72,
    1353        70,   66,  965,  966,   36,  966,   33,   18,   11,  966,
    1354       967,    4,  967,  968,    3,  968,    0,    0,    0,  968,
    1355       969,    0,  969,  970,    0,  970,    0,  970,    0,  970,
    1356 
    1357       971,    0,  971,    0,    0,    0,  971,  972,    0,  972,
    1358         0,    0,    0,  972,  973,    0,  973,  974,    0,  974,
    1359         0,    0,    0,  974,  975,    0,  975,  976,    0,  976,
    1360         0,    0,    0,  976,  977,    0,  977,  978,    0,  978,
    1361         0,    0,    0,  978,  979,    0,  979,  980,    0,  980,
    1362         0,    0,    0,  980,  981,    0,  981,  982,    0,  982,
    1363         0,    0,    0,  982,  983,    0,  983,  984,    0,    0,
    1364       984,    0,  984,  984,  984,  984,  984,  985,  985,  985,
    1365       985,  985,  985,  985,  985,  985,  985,  985,  985,  985,
    1366       986,    0,  986,    0,    0,    0,  986,  987,    0,  987,
    1367 
    1368       988,    0,  988,    0,    0,    0,  988,  989,    0,  989,
    1369       990,    0,  990,    0,    0,    0,  990,  991,    0,  991,
    1370       992,    0,  992,    0,    0,    0,  992,  993,    0,  993,
    1371       994,    0,  994,    0,    0,    0,  994,  995,    0,  995,
    1372       996,    0,  996,    0,    0,    0,  996,  997,    0,  997,
    1373       998,    0,  998,    0,    0,    0,  998,  999,    0,  999,
    1374      1000,    0, 1000,    0,    0,    0, 1000, 1001,    0, 1001,
    1375      1002,    0, 1002,    0,    0,    0, 1002, 1003,    0, 1003,
    1376         0,    0,    0, 1003, 1004,    0, 1004, 1005,    0, 1005,
    1377         0,    0,    0, 1005, 1006,    0, 1006, 1007,    0, 1007,
    1378 
    1379         0,    0,    0, 1007, 1008,    0, 1008, 1009,    0, 1009,
    1380         0,    0,    0, 1009, 1010,    0, 1010, 1011,    0, 1011,
    1381      1012,    0, 1012, 1013,    0,    0, 1013,    0, 1013, 1013,
    1382      1013, 1013, 1013, 1014,    0, 1014, 1015, 1015, 1015, 1015,
    1383      1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1016,
    1384         0, 1016,    0,    0,    0, 1016, 1017,    0, 1017, 1018,
    1385         0, 1018,    0,    0,    0, 1018, 1019,    0, 1019, 1020,
    1386         0, 1020, 1021,    0, 1021, 1022,    0,    0, 1022,    0,
    1387      1022, 1022, 1022, 1022, 1022, 1023,    0, 1023, 1024,    0,
    1388      1024, 1025,    0, 1025, 1026,    0, 1026, 1027,    0, 1027,
    1389 
    1390      1028,    0, 1028, 1029,    0, 1029, 1030,    0, 1030,    0,
    1391         0,    0, 1030, 1031,    0, 1031, 1032,    0, 1032,    0,
    1392         0,    0, 1032, 1033,    0, 1033, 1034,    0, 1034, 1035,
    1393         0, 1035, 1036,    0, 1036, 1037,    0, 1037,    0,    0,
    1394         0, 1037, 1038,    0,    0, 1038,    0, 1038, 1038, 1038,
    1395      1038, 1038, 1039,    0, 1039, 1040,    0, 1040, 1041,    0,
    1396      1041, 1042,    0, 1042,    0,    0,    0, 1042, 1043,    0,
    1397      1043,    0,    0,    0, 1043, 1044,    0, 1044,    0,    0,
    1398         0, 1044, 1045,    0, 1045, 1046,    0, 1046,    0,    0,
    1399         0, 1046, 1047,    0, 1047,    0,    0,    0, 1047, 1048,
    1400 
    1401         0, 1048,    0,    0,    0, 1048, 1049,    0, 1049,    0,
    1402         0,    0, 1049, 1050,    0, 1050,    0,    0,    0, 1050,
    1403      1051,    0, 1051,    0,    0,    0, 1051, 1052,    0, 1052,
    1404         0,    0,    0, 1052, 1053,    0, 1053,    0,    0,    0,
    1405      1053, 1054,    0, 1054,    0,    0,    0, 1054, 1055,    0,
    1406      1055,    0,    0,    0, 1055, 1056,    0, 1056,    0,    0,
    1407         0, 1056, 1057,    0, 1057,    0,    0,    0, 1057, 1058,
    1408         0, 1058,    0,    0,    0, 1058, 1059,    0, 1059,    0,
    1409         0,    0, 1059, 1060,    0, 1060,    0,    0,    0, 1060,
    1410      1061,    0, 1061,    0,    0,    0, 1061,  887,  887,  887,
    1411 
     1125        5,    5,    5,    5,    5,    5,    5,    5,    5,    7,
     1126        8,    9,   10,   37,   37,   20,   39,    9,   10,  886,
     1127        7,    8,   13,   13,   13,   13,   13,   13,   15,   15,
     1128
     1129       15,   15,   15,   15,   20,   25,   48,   39,   42,   28,
     1130       27,   28,   28,   28,   28,   28,   28,  109,  115,   25,
     1131       29,   25,   27,   27,   27,   29,   48,   35,   40,    7,
     1132        8,    9,   10,   40,   42,   29,   30,   47,   30,   30,
     1133       30,   30,   30,   30,   35,   57,   35,   35,   44,  126,
     1134       44,  126,  109,  115,   57,   30,   64,   56,   47,   30,
     1135       47,   45,   45,   45,   49,   30,   30,   45,   45,   49,
     1136       45,   30,   40,   45,   45,   40,   49,   30,   45,   56,
     1137       62,   45,   49,   30,   73,  885,  127,   53,  127,   51,
     1138       61,   30,   62,   55,   30,   31,  108,   31,   31,   31,
     1139
     1140       31,   31,   31,   50,   51,   53,   51,   64,   61,   54,
     1141       73,   55,   50,   87,   31,   51,   50,   55,   31,   54,
     1142      108,   50,   52,  114,   31,   50,   54,   52,  175,  129,
     1143       31,  129,  107,  154,  151,   52,   31,   52,  107,   87,
     1144       52,   60,   31,  132,   52,  132,   60,  114,  175,  154,
     1145       31,   38,  151,  385,  111,   38,   38,   58,   38,   60,
     1146       38,   38,  113,   38,  107,   38,   59,  130,  113,   58,
     1147       58,  116,  111,  164,   38,   38,   38,  385,   59,   58,
     1148      111,  130,   58,  130,  142,   60,   59,  131,   60,  116,
     1149      164,   68,   68,   59,  113,   38,   68,  116,   38,  131,
     1150
     1151      110,  131,   60,   67,   67,   67,   67,   67,   67,  877,
     1152      142,   67,   68,   68,   68,   68,   68,   68,   80,   80,
     1153       80,   80,   80,   80,  153,   38,   38,   77,   77,  134,
     1154      110,  134,   77,  153,   77,  110,  135,  135,  135,   77,
     1155       82,   82,   82,   82,   82,   82,  876,  243,   77,   77,
     1156       77,   77,   83,   83,   83,   83,   83,   83,  110,   77,
     1157      103,  103,  103,  103,  103,  103,  104,  104,  104,  104,
     1158      133,  133,  137,  133,  137,   77,  145,  139,   77,  139,
     1159      157,  145,  243,   77,   77,  152,  156,   77,   77,  155,
     1160      166,  150,  157,  103,  104,   77,  159,  168,   77,  104,
     1161
     1162       77,   77,   77,  152,   77,   85,  150,  155,  156,   85,
     1163       85,  166,  159,  150,   85,   85,  161,   85,  160,   85,
     1164      145,  162,  104,  167,  168,  161,  169,  163,   85,   85,
     1165       85,  105,  163,  105,  105,  105,  105,  105,  105,  873,
     1166      160,  171,  162,  162,  165,  163,  167,  169,  173,   85,
     1167      105,  106,   85,  106,  165,  172,  106,  106,  106,  106,
     1168      106,  106,  180,  171,  170,  173,  105,  176,  177,  170,
     1169      172,  181,  105,  174,  184,  187,  181,  182,  179,  180,
     1170       85,   99,   99,   99,   99,   99,   99,  170,  187,  106,
     1171      177,  174,  184,  179,  176,  183,  190,   99,   99,   99,
     1172
     1173      179,   99,   99,  189,  182,  186,  183,  191,  189,  218,
     1174      186,  218,  185,  188,   99,  190,  183,  183,  284,   99,
     1175       99,   99,  158,  185,   99,  186,   99,  158,  158,  158,
     1176      189,  158,  158,  188,  192,  158,  194,  158,  284,  219,
     1177      185,  219,  158,  158,  158,  193,  158,  192,  220,  194,
     1178      220,  191,  198,  198,  191,  192,  205,  198,  193,  872,
     1179      193,  197,  197,  197,  197,  197,  197,  200,  200,  197,
     1180      248,  221,  200,  198,  198,  198,  198,  198,  198,  202,
     1181      202,  223,  205,  223,  202,  221,  202,  221,  200,  200,
     1182      200,  200,  200,  200,  209,  209,  248,  338,  222,  209,
     1183
     1184      202,  202,  202,  202,  202,  202,  212,  212,  212,  212,
     1185      222,  309,  222,  224,  224,  225,  224,  225,  226,  226,
     1186      226,  228,  229,  228,  229,  234,  234,  235,  236,  235,
     1187      309,  279,  235,  235,  235,  235,  235,  235,  237,  212,
     1188      237,  338,  266,  237,  266,  267,  278,  267,  234,  279,
     1189      283,  236,  241,  241,  241,  283,  241,  241,  256,  278,
     1190      237,  281,  237,  282,  280,  235,  270,  237,  244,  244,
     1191      244,  244,  244,  244,  241,  241,  241,  281,  285,  241,
     1192      282,  241,  280,  285,  256,  244,  245,  245,  245,  245,
     1193      245,  245,  270,  288,  293,  286,  294,  300,  306,  293,
     1194
     1195      308,  244,  300,  306,  870,  294,  308,  244,  246,  246,
     1196      246,  246,  246,  246,  253,  286,  288,  255,  255,  255,
     1197      255,  255,  255,  287,  246,  247,  246,  247,  246,  246,
     1198      247,  247,  247,  247,  247,  247,  290,  253,  287,  253,
     1199      869,  246,  289,  253,  287,  287,  246,  292,  246,  253,
     1200      255,  246,  291,  246,  260,  260,  260,  260,  260,  260,
     1201      289,  253,  290,  292,  292,  253,  295,  291,  296,  253,
     1202      297,  299,  301,  302,  303,  304,  305,  307,  311,  295,
     1203      302,  301,  307,  310,  311,  312,  319,  260,  297,  299,
     1204      313,  314,  310,  304,  303,  296,  318,  305,  305,  313,
     1205
     1206      315,  312,  316,  317,  319,  315,  314,  316,  317,  320,
     1207      322,  323,  324,  326,  325,  318,  327,  328,  331,  329,
     1208      330,  322,  320,  332,  334,  317,  323,  325,  333,  330,
     1209      335,  324,  337,  339,  340,  326,  329,  328,  401,  327,
     1210      331,  337,  334,  335,  341,  343,  332,  340,  342,  401,
     1211      333,  339,  341,  342,  344,  344,  345,  460,  862,  344,
     1212      343,  344,  345,  352,  352,  352,  352,  353,  353,  353,
     1213      353,  362,  363,  362,  363,  370,  370,  370,  370,  370,
     1214      370,  372,  460,  372,  380,  381,  372,  372,  372,  372,
     1215      372,  372,  861,  402,  380,  381,  352,  371,  371,  371,
     1216
     1217      371,  371,  371,  374,  374,  374,  374,  374,  374,  402,
     1218      380,  381,  403,  371,  404,  371,  860,  371,  371,  375,
     1219      375,  375,  375,  375,  375,  383,  382,  403,  406,  405,
     1220      371,  383,  407,  404,  408,  371,  374,  371,  405,  406,
     1221      371,  407,  371,  376,  376,  376,  376,  376,  376,  382,
     1222      412,  382,  375,  387,  411,  382,  408,  383,  384,  386,
     1223      384,  382,  410,  384,  384,  384,  384,  384,  384,  409,
     1224      411,  387,  412,  382,  413,  410,  376,  382,  409,  387,
     1225      415,  382,  386,  414,  386,  416,  417,  413,  386,  418,
     1226      421,  417,  419,  422,  386,  420,  384,  427,  419,  414,
     1227
     1228      414,  421,  415,  416,  418,  423,  386,  425,  429,  427,
     1229      386,  418,  422,  430,  386,  431,  420,  432,  433,  434,
     1230      423,  425,  435,  437,  433,  439,  440,  441,  431,  429,
     1231      442,  435,  443,  444,  434,  430,  449,  445,  437,  447,
     1232      432,  450,  441,  451,  454,  439,  445,  443,  440,  452,
     1233      450,  453,  442,  444,  455,  456,  447,  457,  458,  449,
     1234      459,  461,  463,  455,  451,  458,  454,  459,  462,  452,
     1235      457,  453,  466,  456,  464,  467,  462,  525,  859,  463,
     1236      525,  468,  491,  461,  467,  464,  462,  468,  477,  477,
     1237      477,  477,  491,  515,  466,  488,  488,  488,  488,  488,
     1238
     1239      488,  490,  490,  490,  490,  490,  490,  519,  491,  521,
     1240      515,  488,  492,  488,  492,  488,  488,  492,  492,  492,
     1241      492,  492,  492,  494,  516,  495,  493,  519,  488,  855,
     1242      851,  521,  518,  488,  490,  488,  493,  516,  488,  529,
     1243      488,  497,  497,  497,  497,  497,  497,  518,  520,  494,
     1244      492,  495,  493,  498,  498,  498,  498,  498,  498,  523,
     1245      529,  520,  526,  848,  523,  847,  528,  846,  522,  498,
     1246      499,  498,  499,  498,  498,  499,  499,  499,  499,  499,
     1247      499,  522,  526,  524,  527,  528,  498,  531,  530,  532,
     1248      533,  498,  531,  498,  524,  534,  498,  530,  498,  527,
     1249
     1250      532,  535,  537,  533,  536,  538,  539,  541,  542,  547,
     1251      535,  539,  544,  541,  538,  545,  546,  542,  547,  537,
     1252      550,  551,  845,  549,  534,  552,  536,  554,  560,  544,
     1253      545,  546,  549,  551,  555,  557,  558,  550,  561,  555,
     1254      552,  562,  554,  565,  557,  558,  564,  567,  566,  568,
     1255      560,  561,  575,  565,  564,  566,  569,  571,  562,  574,
     1256      572,  568,  569,  620,  619,  575,  571,  601,  601,  567,
     1257      572,  619,  620,  844,  843,  622,  574,  594,  594,  594,
     1258      594,  594,  594,  595,  595,  595,  595,  595,  595,  597,
     1259      601,  597,  622,  621,  597,  597,  597,  597,  597,  597,
     1260
     1261      600,  600,  600,  600,  600,  600,  621,  602,  626,  842,
     1262      594,  596,  596,  596,  596,  596,  596,  603,  618,  603,
     1263      623,  624,  603,  618,  628,  626,  625,  596,  624,  596,
     1264      602,  596,  596,  600,  625,  627,  618,  628,  627,  603,
     1265      629,  603,  630,  623,  596,  631,  603,  632,  633,  596,
     1266      634,  596,  635,  634,  596,  636,  596,  630,  637,  638,
     1267      640,  644,  629,  639,  632,  641,  642,  631,  645,  635,
     1268      633,  646,  639,  637,  650,  642,  651,  656,  640,  638,
     1269      646,  653,  657,  636,  644,  665,  656,  641,  664,  657,
     1270      645,  667,  668,  841,  650,  665,  700,  664,  653,  699,
     1271
     1272      667,  702,  705,  651,  714,  837,  700,  668,  686,  686,
     1273      686,  686,  686,  686,  690,  690,  690,  690,  690,  690,
     1274      699,  708,  705,  703,  686,  714,  686,  702,  686,  686,
     1275      703,  704,  706,  715,  707,  706,  704,  707,  710,  708,
     1276      712,  686,  711,  717,  710,  718,  686,  690,  686,  712,
     1277      720,  686,  717,  686,  713,  711,  716,  713,  719,  716,
     1278      721,  719,  715,  720,  722,  723,  724,  725,  721,  728,
     1279      731,  718,  732,  735,  722,  733,  725,  736,  723,  756,
     1280      757,  735,  836,  754,  756,  759,  736,  724,  755,  760,
     1281      731,  761,  728,  764,  732,  757,  733,  743,  743,  743,
     1282
     1283      743,  743,  743,  754,  758,  755,  760,  762,  759,  763,
     1284      762,  769,  766,  768,  758,  766,  768,  761,  769,  772,
     1285      770,  764,  763,  770,  771,  773,  778,  771,  793,  795,
     1286      743,  798,  797,  796,  772,  797,  799,  800,  802,  799,
     1287      800,  803,  804,  806,  807,  804,  810,  807,  773,  778,
     1288      795,  796,  809,  798,  808,  793,  802,  808,  811,  826,
     1289      830,  809,  810,  827,  829,  806,  828,  803,  831,  828,
     1290      827,  831,  832,  829,  811,  834,  835,  839,  830,  835,
     1291      826,  840,  838,  849,  830,  838,  839,  853,  850,  832,
     1292      840,  852,  849,  850,  852,  854,  856,  853,  857,  856,
     1293
     1294      854,  857,  858,  863,  864,  858,  865,  866,  867,  865,
     1295      868,  867,  871,  868,  874,  875,  878,  866,  879,  864,
     1296      880,  882,  881,  863,  883,  878,  884,  833,  825,  824,
     1297      875,  879,  823,  822,  871,  874,  884,  821,  820,  882,
     1298      819,  818,  880,  881,  817,  816,  883,  888,  888,  888,
     1299      888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
     1300      889,  889,  889,  889,  889,  889,  889,  889,  889,  889,
     1301      889,  889,  889,  890,  890,  890,  890,  890,  890,  890,
     1302      890,  890,  890,  890,  890,  890,  891,  815,  814,  891,
     1303      813,  891,  891,  891,  891,  891,  892,  812,  805,  801,
     1304
     1305      892,  892,  892,  892,  892,  892,  893,  893,  893,  893,
     1306      893,  893,  893,  893,  893,  893,  893,  893,  893,  894,
     1307      794,  792,  894,  791,  894,  894,  894,  894,  894,  895,
     1308      790,  895,  895,  789,  895,  895,  895,  895,  895,  895,
     1309      788,  895,  896,  787,  786,  896,  896,  896,  896,  896,
     1310      896,  896,  896,  785,  896,  897,  897,  897,  897,  897,
     1311      897,  897,  897,  897,  897,  897,  897,  897,  898,  898,
     1312      784,  898,  783,  782,  781,  898,  899,  780,  779,  899,
     1313      777,  899,  899,  899,  899,  899,  900,  776,  900,  775,
     1314      774,  767,  900,  901,  765,  901,  753,  752,  751,  901,
     1315
     1316      902,  750,  902,  749,  748,  747,  902,  903,  746,  903,
     1317      745,  742,  741,  903,  904,  740,  904,  734,  730,  729,
     1318      904,  905,  727,  905,  726,  709,  701,  905,  906,  698,
     1319      906,  693,  691,  687,  906,  907,  677,  907,  673,  671,
     1320      669,  907,  908,  666,  908,  663,  662,  661,  908,  909,
     1321      909,  909,  909,  909,  909,  909,  909,  909,  909,  909,
     1322      909,  909,  910,  660,  910,  911,  911,  659,  911,  911,
     1323      911,  658,  911,  912,  912,  655,  912,  913,  654,  913,
     1324      652,  649,  648,  913,  914,  647,  914,  643,  616,  612,
     1325      914,  915,  610,  915,  608,  606,  604,  915,  916,  598,
     1326
     1327      916,  917,  592,  917,  590,  588,  586,  917,  918,  584,
     1328      918,  919,  582,  580,  919,  578,  919,  919,  919,  919,
     1329      919,  920,  920,  920,  920,  920,  920,  920,  920,  920,
     1330      920,  920,  920,  920,  921,  921,  921,  921,  921,  921,
     1331      921,  921,  921,  921,  921,  921,  921,  922,  577,  922,
     1332      576,  573,  570,  922,  923,  563,  923,  559,  556,  553,
     1333      923,  924,  548,  924,  543,  540,  517,  924,  925,  513,
     1334      925,  926,  511,  926,  509,  507,  505,  926,  927,  503,
     1335      927,  928,  502,  928,  501,  500,  489,  928,  929,  486,
     1336      929,  930,  484,  930,  483,  482,  480,  930,  931,  478,
     1337
     1338      931,  932,  475,  932,  473,  471,  469,  932,  933,  465,
     1339      933,  934,  448,  934,  446,  438,  436,  934,  935,  428,
     1340      935,  936,  426,  936,  424,  398,  396,  936,  937,  394,
     1341      937,  938,  392,  938,  391,  938,  390,  938,  939,  377,
     1342      939,  367,  939,  365,  939,  940,  940,  364,  940,  940,
     1343      940,  360,  940,  941,  358,  941,  356,  354,  350,  941,
     1344      942,  348,  942,  347,  346,  336,  942,  943,  321,  943,
     1345      298,  277,  275,  943,  944,  273,  944,  945,  272,  945,
     1346      271,  269,  268,  945,  946,  263,  946,  947,  259,  947,
     1347      258,  254,  251,  947,  948,  250,  948,  949,  239,  949,
     1348
     1349      238,  231,  230,  949,  950,  227,  950,  951,  217,  215,
     1350      951,  214,  951,  951,  951,  951,  951,  952,  952,  952,
     1351      952,  952,  952,  952,  952,  952,  952,  952,  952,  952,
     1352      953,  213,  953,  207,  206,  204,  953,  954,  199,  954,
     1353      955,  178,  955,  149,  147,  146,  955,  956,  140,  956,
     1354      957,  138,  957,  136,  128,  125,  957,  958,  124,  958,
     1355      959,  120,  959,  101,   98,   95,  959,  960,   93,  960,
     1356      961,   86,  961,   72,   70,   66,  961,  962,   36,  962,
     1357      963,   33,  963,   18,   11,    4,  963,  964,    3,  964,
     1358      965,    0,  965,    0,    0,    0,  965,  966,    0,  966,
     1359
     1360        0,    0,    0,  966,  967,    0,  967,  968,    0,  968,
     1361        0,    0,    0,  968,  969,    0,  969,  970,    0,  970,
     1362        0,  970,    0,  970,  971,    0,  971,    0,    0,    0,
     1363      971,  972,    0,  972,    0,    0,    0,  972,  973,    0,
     1364      973,  974,    0,  974,    0,    0,    0,  974,  975,    0,
     1365      975,  976,    0,  976,    0,    0,    0,  976,  977,    0,
     1366      977,  978,    0,  978,    0,    0,    0,  978,  979,    0,
     1367      979,  980,    0,  980,    0,    0,    0,  980,  981,    0,
     1368      981,  982,    0,  982,    0,    0,    0,  982,  983,    0,
     1369      983,  984,    0,    0,  984,    0,  984,  984,  984,  984,
     1370
     1371      984,  985,  985,  985,  985,  985,  985,  985,  985,  985,
     1372      985,  985,  985,  985,  986,    0,  986,    0,    0,    0,
     1373      986,  987,    0,  987,  988,    0,  988,    0,    0,    0,
     1374      988,  989,    0,  989,  990,    0,  990,    0,    0,    0,
     1375      990,  991,    0,  991,  992,    0,  992,    0,    0,    0,
     1376      992,  993,    0,  993,  994,    0,  994,    0,    0,    0,
     1377      994,  995,    0,  995,  996,    0,  996,    0,    0,    0,
     1378      996,  997,    0,  997,  998,    0,  998,    0,    0,    0,
     1379      998,  999,    0,  999, 1000,    0, 1000,    0,    0,    0,
     1380     1000, 1001,    0, 1001, 1002,    0, 1002,    0,    0,    0,
     1381
     1382     1002, 1003,    0, 1003,    0,    0,    0, 1003, 1004,    0,
     1383     1004, 1005,    0, 1005,    0,    0,    0, 1005, 1006,    0,
     1384     1006, 1007,    0, 1007,    0,    0,    0, 1007, 1008,    0,
     1385     1008, 1009,    0, 1009,    0,    0,    0, 1009, 1010,    0,
     1386     1010, 1011,    0, 1011, 1012,    0, 1012, 1013,    0,    0,
     1387     1013,    0, 1013, 1013, 1013, 1013, 1013, 1014,    0, 1014,
     1388     1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015,
     1389     1015, 1015, 1015, 1016,    0, 1016,    0,    0,    0, 1016,
     1390     1017,    0, 1017, 1018,    0, 1018,    0,    0,    0, 1018,
     1391     1019,    0, 1019, 1020,    0, 1020, 1021,    0, 1021, 1022,
     1392
     1393        0,    0, 1022,    0, 1022, 1022, 1022, 1022, 1022, 1023,
     1394        0, 1023, 1024,    0, 1024, 1025,    0, 1025, 1026,    0,
     1395     1026, 1027,    0, 1027, 1028,    0, 1028, 1029,    0, 1029,
     1396     1030,    0, 1030,    0,    0,    0, 1030, 1031,    0, 1031,
     1397     1032,    0, 1032,    0,    0,    0, 1032, 1033,    0, 1033,
     1398     1034,    0, 1034, 1035,    0, 1035, 1036,    0, 1036, 1037,
     1399        0, 1037,    0,    0,    0, 1037, 1038,    0,    0, 1038,
     1400        0, 1038, 1038, 1038, 1038, 1038, 1039,    0, 1039, 1040,
     1401        0, 1040, 1041,    0, 1041, 1042,    0, 1042,    0,    0,
     1402        0, 1042, 1043,    0, 1043,    0,    0,    0, 1043, 1044,
     1403
     1404        0, 1044,    0,    0,    0, 1044, 1045,    0, 1045, 1046,
     1405        0, 1046,    0,    0,    0, 1046, 1047,    0, 1047,    0,
     1406        0,    0, 1047, 1048,    0, 1048,    0,    0,    0, 1048,
     1407     1049,    0, 1049,    0,    0,    0, 1049, 1050,    0, 1050,
     1408        0,    0,    0, 1050, 1051,    0, 1051,    0,    0,    0,
     1409     1051, 1052,    0, 1052,    0,    0,    0, 1052, 1053,    0,
     1410     1053,    0,    0,    0, 1053, 1054,    0, 1054,    0,    0,
     1411        0, 1054, 1055,    0, 1055,    0,    0,    0, 1055, 1056,
     1412        0, 1056,    0,    0,    0, 1056, 1057,    0, 1057,    0,
     1413        0,    0, 1057, 1058,    0, 1058,    0,    0,    0, 1058,
     1414
     1415     1059,    0, 1059,    0,    0,    0, 1059, 1060,    0, 1060,
     1416        0,    0,    0, 1060, 1061,    0, 1061,    0,    0,    0,
     1417     1061,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    14121418      887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    14131419      887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
     
    14171423      887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    14181424      887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1419       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1420       887,  887
     1425
     1426      887,  887,  887,  887,  887,  887,  887
    14211427    } ;
    14221428
     
    14611467 * Created On       : Sat Sep 22 08:58:10 2001
    14621468 * Last Modified By : Peter A. Buhr
    1463  * Last Modified On : Wed Mar  2 18:07:20 2016
    1464  * Update Count     : 434
     1469 * Last Modified On : Mon Mar 21 23:33:46 2016
     1470 * Update Count     : 450
    14651471 */
    14661472#line 20 "lex.ll"
     
    14741480
    14751481#include "lex.h"
     1482#include "parser.h"                                                                             // YACC generated definitions based on C++ grammar
    14761483#include "ParseNode.h"
    1477 #include "parser.h"                                                                             // YACC generated definitions based on C++ grammar
     1484#include "TypedefTable.h"
    14781485
    14791486char *yyfilename;
     
    14911498#define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL( x ) // numeric constant
    14921499#define KEYWORD_RETURN(x)       RETURN_CHAR( x )                        // keyword
    1493 #define IDENTIFIER_RETURN()     RETURN_VAL( (typedefTable.isIdentifier( yytext ) ? IDENTIFIER : typedefTable.isTypedef( yytext ) ? TYPEDEFname : TYPEGENname ) )
     1500#define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
    14941501#define ATTRIBUTE_RETURN()      RETURN_VAL( ATTR_IDENTIFIER )
    14951502
     
    15111518// attribute identifier, GCC: $ in identifier
    15121519// numeric constants, CFA: '_' in constant
    1513 // GCC: D (double), LD (long double) and iI (imaginary) suffixes
     1520// GCC: D (double), DL (long double) and iI (imaginary) suffixes
     1521//floating_suffix "_"?([fFdD]|[lL]|[D][L])|([iI][lLfFdD])|([lLfFdD][iI]))
    15141522// character escape sequence, GCC: \e => esc character
    15151523// ' stop highlighting
     
    15201528
    15211529
    1522 #line 1523 "Parser/lex.cc"
     1530#line 1531 "Parser/lex.cc"
    15231531
    15241532#define INITIAL 0
     
    17121720        register int yy_act;
    17131721   
    1714 #line 137 "lex.ll"
     1722#line 139 "lex.ll"
    17151723
    17161724                                   /* line directives */
    1717 #line 1718 "Parser/lex.cc"
     1725#line 1726 "Parser/lex.cc"
    17181726
    17191727        if ( !(yy_init) )
     
    17751783                        ++yy_cp;
    17761784                        }
    1777                 while ( yy_base[yy_current_state] != 2798 );
     1785                while ( yy_base[yy_current_state] != 2822 );
    17781786
    17791787yy_find_action:
     
    18121820/* rule 1 can match eol */
    18131821YY_RULE_SETUP
    1814 #line 139 "lex.ll"
     1822#line 141 "lex.ll"
    18151823{
    18161824        /* " stop highlighting */
     
    18391847/* rule 2 can match eol */
    18401848YY_RULE_SETUP
    1841 #line 162 "lex.ll"
     1849#line 164 "lex.ll"
    18421850;
    18431851        YY_BREAK
     
    18451853case 3:
    18461854YY_RULE_SETUP
    1847 #line 165 "lex.ll"
     1855#line 167 "lex.ll"
    18481856{ BEGIN COMMENT; }
    18491857        YY_BREAK
     
    18511859/* rule 4 can match eol */
    18521860YY_RULE_SETUP
    1853 #line 166 "lex.ll"
     1861#line 168 "lex.ll"
    18541862;
    18551863        YY_BREAK
    18561864case 5:
    18571865YY_RULE_SETUP
    1858 #line 167 "lex.ll"
     1866#line 169 "lex.ll"
    18591867{ BEGIN 0; }
    18601868        YY_BREAK
     
    18631871/* rule 6 can match eol */
    18641872YY_RULE_SETUP
    1865 #line 170 "lex.ll"
     1873#line 172 "lex.ll"
    18661874;
    18671875        YY_BREAK
     
    18691877case 7:
    18701878YY_RULE_SETUP
    1871 #line 173 "lex.ll"
     1879#line 175 "lex.ll"
    18721880{ WHITE_RETURN(' '); }
    18731881        YY_BREAK
    18741882case 8:
    18751883YY_RULE_SETUP
    1876 #line 174 "lex.ll"
     1884#line 176 "lex.ll"
    18771885{ WHITE_RETURN(' '); }
    18781886        YY_BREAK
     
    18801888/* rule 9 can match eol */
    18811889YY_RULE_SETUP
    1882 #line 175 "lex.ll"
     1890#line 177 "lex.ll"
    18831891{ NEWLINE_RETURN(); }
    18841892        YY_BREAK
     
    18861894case 10:
    18871895YY_RULE_SETUP
    1888 #line 178 "lex.ll"
     1896#line 180 "lex.ll"
    18891897{ KEYWORD_RETURN(ALIGNAS); }                    // C11
    18901898        YY_BREAK
    18911899case 11:
    18921900YY_RULE_SETUP
    1893 #line 179 "lex.ll"
     1901#line 181 "lex.ll"
    18941902{ KEYWORD_RETURN(ALIGNOF); }                    // C11
    18951903        YY_BREAK
    18961904case 12:
    18971905YY_RULE_SETUP
    1898 #line 180 "lex.ll"
     1906#line 182 "lex.ll"
    18991907{ KEYWORD_RETURN(ALIGNOF); }                    // GCC
    19001908        YY_BREAK
    19011909case 13:
    19021910YY_RULE_SETUP
    1903 #line 181 "lex.ll"
     1911#line 183 "lex.ll"
    19041912{ KEYWORD_RETURN(ALIGNOF); }                    // GCC
    19051913        YY_BREAK
    19061914case 14:
    19071915YY_RULE_SETUP
    1908 #line 182 "lex.ll"
     1916#line 184 "lex.ll"
    19091917{ KEYWORD_RETURN(ASM); }
    19101918        YY_BREAK
    19111919case 15:
    19121920YY_RULE_SETUP
    1913 #line 183 "lex.ll"
     1921#line 185 "lex.ll"
    19141922{ KEYWORD_RETURN(ASM); }                                // GCC
    19151923        YY_BREAK
    19161924case 16:
    19171925YY_RULE_SETUP
    1918 #line 184 "lex.ll"
     1926#line 186 "lex.ll"
    19191927{ KEYWORD_RETURN(ASM); }                                // GCC
    19201928        YY_BREAK
    19211929case 17:
    19221930YY_RULE_SETUP
    1923 #line 185 "lex.ll"
     1931#line 187 "lex.ll"
    19241932{ KEYWORD_RETURN(AT); }                                 // CFA
    19251933        YY_BREAK
    19261934case 18:
    19271935YY_RULE_SETUP
    1928 #line 186 "lex.ll"
     1936#line 188 "lex.ll"
    19291937{ KEYWORD_RETURN(ATOMIC); }                             // C11
    19301938        YY_BREAK
    19311939case 19:
    19321940YY_RULE_SETUP
    1933 #line 187 "lex.ll"
     1941#line 189 "lex.ll"
    19341942{ KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    19351943        YY_BREAK
    19361944case 20:
    19371945YY_RULE_SETUP
    1938 #line 188 "lex.ll"
     1946#line 190 "lex.ll"
    19391947{ KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    19401948        YY_BREAK
    19411949case 21:
    19421950YY_RULE_SETUP
    1943 #line 189 "lex.ll"
     1951#line 191 "lex.ll"
    19441952{ KEYWORD_RETURN(AUTO); }
    19451953        YY_BREAK
    19461954case 22:
    19471955YY_RULE_SETUP
    1948 #line 190 "lex.ll"
     1956#line 192 "lex.ll"
    19491957{ KEYWORD_RETURN(BOOL); }                               // C99
    19501958        YY_BREAK
    19511959case 23:
    19521960YY_RULE_SETUP
    1953 #line 191 "lex.ll"
     1961#line 193 "lex.ll"
    19541962{ KEYWORD_RETURN(BREAK); }
    19551963        YY_BREAK
    19561964case 24:
    19571965YY_RULE_SETUP
    1958 #line 192 "lex.ll"
     1966#line 194 "lex.ll"
    19591967{ KEYWORD_RETURN(CASE); }
    19601968        YY_BREAK
    19611969case 25:
    19621970YY_RULE_SETUP
    1963 #line 193 "lex.ll"
     1971#line 195 "lex.ll"
    19641972{ KEYWORD_RETURN(CATCH); }                              // CFA
    19651973        YY_BREAK
    19661974case 26:
    19671975YY_RULE_SETUP
    1968 #line 194 "lex.ll"
     1976#line 196 "lex.ll"
    19691977{ KEYWORD_RETURN(CATCHRESUME); }                // CFA
    19701978        YY_BREAK
    19711979case 27:
    19721980YY_RULE_SETUP
    1973 #line 195 "lex.ll"
     1981#line 197 "lex.ll"
    19741982{ KEYWORD_RETURN(CHAR); }
    19751983        YY_BREAK
    19761984case 28:
    19771985YY_RULE_SETUP
    1978 #line 196 "lex.ll"
     1986#line 198 "lex.ll"
    19791987{ KEYWORD_RETURN(CHOOSE); }                             // CFA
    19801988        YY_BREAK
    19811989case 29:
    19821990YY_RULE_SETUP
    1983 #line 197 "lex.ll"
     1991#line 199 "lex.ll"
    19841992{ KEYWORD_RETURN(COMPLEX); }                    // C99
    19851993        YY_BREAK
    19861994case 30:
    19871995YY_RULE_SETUP
    1988 #line 198 "lex.ll"
     1996#line 200 "lex.ll"
    19891997{ KEYWORD_RETURN(COMPLEX); }                    // GCC
    19901998        YY_BREAK
    19911999case 31:
    19922000YY_RULE_SETUP
    1993 #line 199 "lex.ll"
     2001#line 201 "lex.ll"
    19942002{ KEYWORD_RETURN(COMPLEX); }                    // GCC
    19952003        YY_BREAK
    19962004case 32:
    19972005YY_RULE_SETUP
    1998 #line 200 "lex.ll"
     2006#line 202 "lex.ll"
    19992007{ KEYWORD_RETURN(CONST); }
    20002008        YY_BREAK
    20012009case 33:
    20022010YY_RULE_SETUP
    2003 #line 201 "lex.ll"
     2011#line 203 "lex.ll"
    20042012{ KEYWORD_RETURN(CONST); }                              // GCC
    20052013        YY_BREAK
    20062014case 34:
    20072015YY_RULE_SETUP
    2008 #line 202 "lex.ll"
     2016#line 204 "lex.ll"
    20092017{ KEYWORD_RETURN(CONST); }                              // GCC
    20102018        YY_BREAK
    20112019case 35:
    20122020YY_RULE_SETUP
    2013 #line 203 "lex.ll"
     2021#line 205 "lex.ll"
    20142022{ KEYWORD_RETURN(CONTINUE); }
    20152023        YY_BREAK
    20162024case 36:
    20172025YY_RULE_SETUP
    2018 #line 204 "lex.ll"
     2026#line 206 "lex.ll"
    20192027{ KEYWORD_RETURN(DEFAULT); }
    20202028        YY_BREAK
    20212029case 37:
    20222030YY_RULE_SETUP
    2023 #line 205 "lex.ll"
     2031#line 207 "lex.ll"
    20242032{ KEYWORD_RETURN(DISABLE); }                    // CFA
    20252033        YY_BREAK
    20262034case 38:
    20272035YY_RULE_SETUP
    2028 #line 206 "lex.ll"
     2036#line 208 "lex.ll"
    20292037{ KEYWORD_RETURN(DO); }
    20302038        YY_BREAK
    20312039case 39:
    20322040YY_RULE_SETUP
    2033 #line 207 "lex.ll"
     2041#line 209 "lex.ll"
    20342042{ KEYWORD_RETURN(DOUBLE); }
    20352043        YY_BREAK
    20362044case 40:
    20372045YY_RULE_SETUP
    2038 #line 208 "lex.ll"
     2046#line 210 "lex.ll"
    20392047{ KEYWORD_RETURN(DTYPE); }                              // CFA
    20402048        YY_BREAK
    20412049case 41:
    20422050YY_RULE_SETUP
    2043 #line 209 "lex.ll"
     2051#line 211 "lex.ll"
    20442052{ KEYWORD_RETURN(ELSE); }
    20452053        YY_BREAK
    20462054case 42:
    20472055YY_RULE_SETUP
    2048 #line 210 "lex.ll"
     2056#line 212 "lex.ll"
    20492057{ KEYWORD_RETURN(ENABLE); }                             // CFA
    20502058        YY_BREAK
    20512059case 43:
    20522060YY_RULE_SETUP
    2053 #line 211 "lex.ll"
     2061#line 213 "lex.ll"
    20542062{ KEYWORD_RETURN(ENUM); }
    20552063        YY_BREAK
    20562064case 44:
    20572065YY_RULE_SETUP
    2058 #line 212 "lex.ll"
     2066#line 214 "lex.ll"
    20592067{ KEYWORD_RETURN(EXTENSION); }                  // GCC
    20602068        YY_BREAK
    20612069case 45:
    20622070YY_RULE_SETUP
    2063 #line 213 "lex.ll"
     2071#line 215 "lex.ll"
    20642072{ KEYWORD_RETURN(EXTERN); }
    20652073        YY_BREAK
    20662074case 46:
    20672075YY_RULE_SETUP
    2068 #line 214 "lex.ll"
     2076#line 216 "lex.ll"
    20692077{ KEYWORD_RETURN(FALLTHRU); }                   // CFA
    20702078        YY_BREAK
    20712079case 47:
    20722080YY_RULE_SETUP
    2073 #line 215 "lex.ll"
     2081#line 217 "lex.ll"
    20742082{ KEYWORD_RETURN(FINALLY); }                    // CFA
    20752083        YY_BREAK
    20762084case 48:
    20772085YY_RULE_SETUP
    2078 #line 216 "lex.ll"
     2086#line 218 "lex.ll"
    20792087{ KEYWORD_RETURN(FLOAT); }
    20802088        YY_BREAK
    20812089case 49:
    20822090YY_RULE_SETUP
    2083 #line 217 "lex.ll"
     2091#line 219 "lex.ll"
    20842092{ KEYWORD_RETURN(FLOAT); }                              // GCC
    20852093        YY_BREAK
    20862094case 50:
    20872095YY_RULE_SETUP
    2088 #line 218 "lex.ll"
     2096#line 220 "lex.ll"
    20892097{ KEYWORD_RETURN(FOR); }
    20902098        YY_BREAK
    20912099case 51:
    20922100YY_RULE_SETUP
    2093 #line 219 "lex.ll"
     2101#line 221 "lex.ll"
    20942102{ KEYWORD_RETURN(FORALL); }                             // CFA
    20952103        YY_BREAK
    20962104case 52:
    20972105YY_RULE_SETUP
    2098 #line 220 "lex.ll"
     2106#line 222 "lex.ll"
    20992107{ KEYWORD_RETURN(FORTRAN); }
    21002108        YY_BREAK
    21012109case 53:
    21022110YY_RULE_SETUP
    2103 #line 221 "lex.ll"
     2111#line 223 "lex.ll"
    21042112{ KEYWORD_RETURN(FTYPE); }                              // CFA
    21052113        YY_BREAK
    21062114case 54:
    21072115YY_RULE_SETUP
    2108 #line 222 "lex.ll"
     2116#line 224 "lex.ll"
    21092117{ KEYWORD_RETURN(GENERIC); }                    // C11
    21102118        YY_BREAK
    21112119case 55:
    21122120YY_RULE_SETUP
    2113 #line 223 "lex.ll"
     2121#line 225 "lex.ll"
    21142122{ KEYWORD_RETURN(GOTO); }
    21152123        YY_BREAK
    21162124case 56:
    21172125YY_RULE_SETUP
    2118 #line 224 "lex.ll"
     2126#line 226 "lex.ll"
    21192127{ KEYWORD_RETURN(IF); }
    21202128        YY_BREAK
    21212129case 57:
    21222130YY_RULE_SETUP
    2123 #line 225 "lex.ll"
     2131#line 227 "lex.ll"
    21242132{ KEYWORD_RETURN(IMAGINARY); }                  // C99
    21252133        YY_BREAK
    21262134case 58:
    21272135YY_RULE_SETUP
    2128 #line 226 "lex.ll"
     2136#line 228 "lex.ll"
    21292137{ KEYWORD_RETURN(IMAGINARY); }                  // GCC
    21302138        YY_BREAK
    21312139case 59:
    21322140YY_RULE_SETUP
    2133 #line 227 "lex.ll"
     2141#line 229 "lex.ll"
    21342142{ KEYWORD_RETURN(IMAGINARY); }                  // GCC
    21352143        YY_BREAK
    21362144case 60:
    21372145YY_RULE_SETUP
    2138 #line 228 "lex.ll"
     2146#line 230 "lex.ll"
    21392147{ KEYWORD_RETURN(INLINE); }                             // C99
    21402148        YY_BREAK
    21412149case 61:
    21422150YY_RULE_SETUP
    2143 #line 229 "lex.ll"
     2151#line 231 "lex.ll"
    21442152{ KEYWORD_RETURN(INLINE); }                             // GCC
    21452153        YY_BREAK
    21462154case 62:
    21472155YY_RULE_SETUP
    2148 #line 230 "lex.ll"
     2156#line 232 "lex.ll"
    21492157{ KEYWORD_RETURN(INLINE); }                             // GCC
    21502158        YY_BREAK
    21512159case 63:
    21522160YY_RULE_SETUP
    2153 #line 231 "lex.ll"
     2161#line 233 "lex.ll"
    21542162{ KEYWORD_RETURN(INT); }
    21552163        YY_BREAK
    21562164case 64:
    21572165YY_RULE_SETUP
    2158 #line 232 "lex.ll"
     2166#line 234 "lex.ll"
    21592167{ KEYWORD_RETURN(INT); }                                // GCC
    21602168        YY_BREAK
    21612169case 65:
    21622170YY_RULE_SETUP
    2163 #line 233 "lex.ll"
     2171#line 235 "lex.ll"
    21642172{ KEYWORD_RETURN(LABEL); }                              // GCC
    21652173        YY_BREAK
    21662174case 66:
    21672175YY_RULE_SETUP
    2168 #line 234 "lex.ll"
     2176#line 236 "lex.ll"
    21692177{ KEYWORD_RETURN(LONG); }
    21702178        YY_BREAK
    21712179case 67:
    21722180YY_RULE_SETUP
    2173 #line 235 "lex.ll"
     2181#line 237 "lex.ll"
    21742182{ KEYWORD_RETURN(LVALUE); }                             // CFA
    21752183        YY_BREAK
    21762184case 68:
    21772185YY_RULE_SETUP
    2178 #line 236 "lex.ll"
     2186#line 238 "lex.ll"
    21792187{ KEYWORD_RETURN(NORETURN); }                   // C11
    21802188        YY_BREAK
    21812189case 69:
    21822190YY_RULE_SETUP
    2183 #line 237 "lex.ll"
     2191#line 239 "lex.ll"
    21842192{ KEYWORD_RETURN(OFFSETOF); }           // GCC
    21852193        YY_BREAK
    21862194case 70:
    21872195YY_RULE_SETUP
    2188 #line 238 "lex.ll"
     2196#line 240 "lex.ll"
    21892197{ KEYWORD_RETURN(OTYPE); }                              // CFA
    21902198        YY_BREAK
    21912199case 71:
    21922200YY_RULE_SETUP
    2193 #line 239 "lex.ll"
     2201#line 241 "lex.ll"
    21942202{ KEYWORD_RETURN(REGISTER); }
    21952203        YY_BREAK
    21962204case 72:
    21972205YY_RULE_SETUP
    2198 #line 240 "lex.ll"
     2206#line 242 "lex.ll"
    21992207{ KEYWORD_RETURN(RESTRICT); }                   // C99
    22002208        YY_BREAK
    22012209case 73:
    22022210YY_RULE_SETUP
    2203 #line 241 "lex.ll"
     2211#line 243 "lex.ll"
    22042212{ KEYWORD_RETURN(RESTRICT); }                   // GCC
    22052213        YY_BREAK
    22062214case 74:
    22072215YY_RULE_SETUP
    2208 #line 242 "lex.ll"
     2216#line 244 "lex.ll"
    22092217{ KEYWORD_RETURN(RESTRICT); }                   // GCC
    22102218        YY_BREAK
    22112219case 75:
    22122220YY_RULE_SETUP
    2213 #line 243 "lex.ll"
     2221#line 245 "lex.ll"
    22142222{ KEYWORD_RETURN(RETURN); }
    22152223        YY_BREAK
    22162224case 76:
    22172225YY_RULE_SETUP
    2218 #line 244 "lex.ll"
     2226#line 246 "lex.ll"
    22192227{ KEYWORD_RETURN(SHORT); }
    22202228        YY_BREAK
    22212229case 77:
    22222230YY_RULE_SETUP
    2223 #line 245 "lex.ll"
     2231#line 247 "lex.ll"
    22242232{ KEYWORD_RETURN(SIGNED); }
    22252233        YY_BREAK
    22262234case 78:
    22272235YY_RULE_SETUP
    2228 #line 246 "lex.ll"
     2236#line 248 "lex.ll"
    22292237{ KEYWORD_RETURN(SIGNED); }                             // GCC
    22302238        YY_BREAK
    22312239case 79:
    22322240YY_RULE_SETUP
    2233 #line 247 "lex.ll"
     2241#line 249 "lex.ll"
    22342242{ KEYWORD_RETURN(SIGNED); }                             // GCC
    22352243        YY_BREAK
    22362244case 80:
    22372245YY_RULE_SETUP
    2238 #line 248 "lex.ll"
     2246#line 250 "lex.ll"
    22392247{ KEYWORD_RETURN(SIZEOF); }
    22402248        YY_BREAK
    22412249case 81:
    22422250YY_RULE_SETUP
    2243 #line 249 "lex.ll"
     2251#line 251 "lex.ll"
    22442252{ KEYWORD_RETURN(STATIC); }
    22452253        YY_BREAK
    22462254case 82:
    22472255YY_RULE_SETUP
    2248 #line 250 "lex.ll"
     2256#line 252 "lex.ll"
    22492257{ KEYWORD_RETURN(STATICASSERT); }               // C11
    22502258        YY_BREAK
    22512259case 83:
    22522260YY_RULE_SETUP
    2253 #line 251 "lex.ll"
     2261#line 253 "lex.ll"
    22542262{ KEYWORD_RETURN(STRUCT); }
    22552263        YY_BREAK
    22562264case 84:
    22572265YY_RULE_SETUP
    2258 #line 252 "lex.ll"
     2266#line 254 "lex.ll"
    22592267{ KEYWORD_RETURN(SWITCH); }
    22602268        YY_BREAK
    22612269case 85:
    22622270YY_RULE_SETUP
    2263 #line 253 "lex.ll"
     2271#line 255 "lex.ll"
    22642272{ KEYWORD_RETURN(THREADLOCAL); }                // C11
    22652273        YY_BREAK
    22662274case 86:
    22672275YY_RULE_SETUP
    2268 #line 254 "lex.ll"
     2276#line 256 "lex.ll"
    22692277{ KEYWORD_RETURN(THROW); }                              // CFA
    22702278        YY_BREAK
    22712279case 87:
    22722280YY_RULE_SETUP
    2273 #line 255 "lex.ll"
     2281#line 257 "lex.ll"
    22742282{ KEYWORD_RETURN(THROWRESUME); }                // CFA
    22752283        YY_BREAK
    22762284case 88:
    22772285YY_RULE_SETUP
    2278 #line 256 "lex.ll"
     2286#line 258 "lex.ll"
    22792287{ KEYWORD_RETURN(TRAIT); }                              // CFA
    22802288        YY_BREAK
    22812289case 89:
    22822290YY_RULE_SETUP
    2283 #line 257 "lex.ll"
     2291#line 259 "lex.ll"
    22842292{ KEYWORD_RETURN(TRY); }                                // CFA
    22852293        YY_BREAK
    22862294case 90:
    22872295YY_RULE_SETUP
    2288 #line 258 "lex.ll"
     2296#line 260 "lex.ll"
    22892297{ KEYWORD_RETURN(TYPEDEF); }
    22902298        YY_BREAK
    22912299case 91:
    2292 YY_RULE_SETUP
    2293 #line 259 "lex.ll"
    2294 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    2295         YY_BREAK
    2296 case 92:
    2297 YY_RULE_SETUP
    2298 #line 260 "lex.ll"
    2299 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    2300         YY_BREAK
    2301 case 93:
    23022300YY_RULE_SETUP
    23032301#line 261 "lex.ll"
    23042302{ KEYWORD_RETURN(TYPEOF); }                             // GCC
    23052303        YY_BREAK
     2304case 92:
     2305YY_RULE_SETUP
     2306#line 262 "lex.ll"
     2307{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2308        YY_BREAK
     2309case 93:
     2310YY_RULE_SETUP
     2311#line 263 "lex.ll"
     2312{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2313        YY_BREAK
    23062314case 94:
    23072315YY_RULE_SETUP
    2308 #line 262 "lex.ll"
     2316#line 264 "lex.ll"
    23092317{ KEYWORD_RETURN(UNION); }
    23102318        YY_BREAK
    23112319case 95:
    23122320YY_RULE_SETUP
    2313 #line 263 "lex.ll"
     2321#line 265 "lex.ll"
    23142322{ KEYWORD_RETURN(UNSIGNED); }
    23152323        YY_BREAK
    23162324case 96:
    23172325YY_RULE_SETUP
    2318 #line 264 "lex.ll"
     2326#line 266 "lex.ll"
    23192327{ KEYWORD_RETURN(VALIST); }                     // GCC
    23202328        YY_BREAK
    23212329case 97:
    23222330YY_RULE_SETUP
    2323 #line 265 "lex.ll"
     2331#line 267 "lex.ll"
    23242332{ KEYWORD_RETURN(VOID); }
    23252333        YY_BREAK
    23262334case 98:
    23272335YY_RULE_SETUP
    2328 #line 266 "lex.ll"
     2336#line 268 "lex.ll"
    23292337{ KEYWORD_RETURN(VOLATILE); }
    23302338        YY_BREAK
    23312339case 99:
    23322340YY_RULE_SETUP
    2333 #line 267 "lex.ll"
     2341#line 269 "lex.ll"
    23342342{ KEYWORD_RETURN(VOLATILE); }                   // GCC
    23352343        YY_BREAK
    23362344case 100:
    23372345YY_RULE_SETUP
    2338 #line 268 "lex.ll"
     2346#line 270 "lex.ll"
    23392347{ KEYWORD_RETURN(VOLATILE); }                   // GCC
    23402348        YY_BREAK
    23412349case 101:
    23422350YY_RULE_SETUP
    2343 #line 269 "lex.ll"
     2351#line 271 "lex.ll"
    23442352{ KEYWORD_RETURN(WHILE); }
    23452353        YY_BREAK
     
    23472355case 102:
    23482356YY_RULE_SETUP
    2349 #line 272 "lex.ll"
     2357#line 274 "lex.ll"
    23502358{ IDENTIFIER_RETURN(); }
    23512359        YY_BREAK
    23522360case 103:
    23532361YY_RULE_SETUP
    2354 #line 273 "lex.ll"
     2362#line 275 "lex.ll"
    23552363{ ATTRIBUTE_RETURN(); }
    23562364        YY_BREAK
    23572365case 104:
    23582366YY_RULE_SETUP
    2359 #line 274 "lex.ll"
     2367#line 276 "lex.ll"
    23602368{ BEGIN BKQUOTE; }
    23612369        YY_BREAK
    23622370case 105:
    23632371YY_RULE_SETUP
    2364 #line 275 "lex.ll"
     2372#line 277 "lex.ll"
    23652373{ IDENTIFIER_RETURN(); }
    23662374        YY_BREAK
    23672375case 106:
    23682376YY_RULE_SETUP
    2369 #line 276 "lex.ll"
     2377#line 278 "lex.ll"
    23702378{ BEGIN 0; }
    23712379        YY_BREAK
     
    23732381case 107:
    23742382YY_RULE_SETUP
    2375 #line 279 "lex.ll"
     2383#line 281 "lex.ll"
    23762384{ NUMERIC_RETURN(ZERO); }                               // CFA
    23772385        YY_BREAK
    23782386case 108:
    23792387YY_RULE_SETUP
    2380 #line 280 "lex.ll"
     2388#line 282 "lex.ll"
    23812389{ NUMERIC_RETURN(ONE); }                                // CFA
    23822390        YY_BREAK
    23832391case 109:
    2384 YY_RULE_SETUP
    2385 #line 281 "lex.ll"
    2386 { NUMERIC_RETURN(INTEGERconstant); }
    2387         YY_BREAK
    2388 case 110:
    2389 YY_RULE_SETUP
    2390 #line 282 "lex.ll"
    2391 { NUMERIC_RETURN(INTEGERconstant); }
    2392         YY_BREAK
    2393 case 111:
    23942392YY_RULE_SETUP
    23952393#line 283 "lex.ll"
    23962394{ NUMERIC_RETURN(INTEGERconstant); }
    23972395        YY_BREAK
     2396case 110:
     2397YY_RULE_SETUP
     2398#line 284 "lex.ll"
     2399{ NUMERIC_RETURN(INTEGERconstant); }
     2400        YY_BREAK
     2401case 111:
     2402YY_RULE_SETUP
     2403#line 285 "lex.ll"
     2404{ NUMERIC_RETURN(INTEGERconstant); }
     2405        YY_BREAK
    23982406case 112:
    23992407YY_RULE_SETUP
    2400 #line 284 "lex.ll"
     2408#line 286 "lex.ll"
    24012409{ NUMERIC_RETURN(FLOATINGconstant); }
    24022410        YY_BREAK
    24032411case 113:
    24042412YY_RULE_SETUP
    2405 #line 285 "lex.ll"
     2413#line 287 "lex.ll"
    24062414{ NUMERIC_RETURN(FLOATINGconstant); }
    24072415        YY_BREAK
     
    24092417case 114:
    24102418YY_RULE_SETUP
    2411 #line 288 "lex.ll"
     2419#line 290 "lex.ll"
    24122420{ BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
    24132421        YY_BREAK
    24142422case 115:
    24152423YY_RULE_SETUP
    2416 #line 289 "lex.ll"
     2424#line 291 "lex.ll"
    24172425{ *strtext += std::string( yytext ); }
    24182426        YY_BREAK
     
    24202428/* rule 116 can match eol */
    24212429YY_RULE_SETUP
    2422 #line 290 "lex.ll"
     2430#line 292 "lex.ll"
    24232431{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
    24242432        YY_BREAK
     
    24272435case 117:
    24282436YY_RULE_SETUP
    2429 #line 294 "lex.ll"
     2437#line 296 "lex.ll"
    24302438{ BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
    24312439        YY_BREAK
    24322440case 118:
    24332441YY_RULE_SETUP
    2434 #line 295 "lex.ll"
     2442#line 297 "lex.ll"
    24352443{ *strtext += std::string( yytext ); }
    24362444        YY_BREAK
     
    24382446/* rule 119 can match eol */
    24392447YY_RULE_SETUP
    2440 #line 296 "lex.ll"
     2448#line 298 "lex.ll"
    24412449{ BEGIN 0; *strtext += std::string( yytext ); RETURN_STR(STRINGliteral); }
    24422450        YY_BREAK
     
    24452453case 120:
    24462454YY_RULE_SETUP
    2447 #line 300 "lex.ll"
     2455#line 302 "lex.ll"
    24482456{ rm_underscore(); *strtext += std::string( yytext ); }
    24492457        YY_BREAK
     
    24512459/* rule 121 can match eol */
    24522460YY_RULE_SETUP
    2453 #line 301 "lex.ll"
     2461#line 303 "lex.ll"
    24542462{}                                              // continuation (ALSO HANDLED BY CPP)
    24552463        YY_BREAK
    24562464case 122:
    24572465YY_RULE_SETUP
    2458 #line 302 "lex.ll"
     2466#line 304 "lex.ll"
    24592467{ *strtext += std::string( yytext ); } // unknown escape character
    24602468        YY_BREAK
     
    24622470case 123:
    24632471YY_RULE_SETUP
    2464 #line 305 "lex.ll"
    2465 { ASCIIOP_RETURN(); }
    2466         YY_BREAK
    2467 case 124:
    2468 YY_RULE_SETUP
    2469 #line 306 "lex.ll"
    2470 { ASCIIOP_RETURN(); }
    2471         YY_BREAK
    2472 case 125:
    2473 YY_RULE_SETUP
    24742472#line 307 "lex.ll"
    24752473{ ASCIIOP_RETURN(); }
    24762474        YY_BREAK
    2477 case 126:
     2475case 124:
    24782476YY_RULE_SETUP
    24792477#line 308 "lex.ll"
    24802478{ ASCIIOP_RETURN(); }
    24812479        YY_BREAK
    2482 case 127:
     2480case 125:
    24832481YY_RULE_SETUP
    24842482#line 309 "lex.ll"
    24852483{ ASCIIOP_RETURN(); }
    24862484        YY_BREAK
    2487 case 128:
     2485case 126:
    24882486YY_RULE_SETUP
    24892487#line 310 "lex.ll"
    24902488{ ASCIIOP_RETURN(); }
    24912489        YY_BREAK
    2492 case 129:
     2490case 127:
    24932491YY_RULE_SETUP
    24942492#line 311 "lex.ll"
    2495 { ASCIIOP_RETURN(); }                                   // also operator
    2496         YY_BREAK
    2497 case 130:
     2493{ ASCIIOP_RETURN(); }
     2494        YY_BREAK
     2495case 128:
    24982496YY_RULE_SETUP
    24992497#line 312 "lex.ll"
    25002498{ ASCIIOP_RETURN(); }
    25012499        YY_BREAK
     2500case 129:
     2501YY_RULE_SETUP
     2502#line 313 "lex.ll"
     2503{ ASCIIOP_RETURN(); }                                   // also operator
     2504        YY_BREAK
     2505case 130:
     2506YY_RULE_SETUP
     2507#line 314 "lex.ll"
     2508{ ASCIIOP_RETURN(); }
     2509        YY_BREAK
    25022510case 131:
    25032511YY_RULE_SETUP
    2504 #line 313 "lex.ll"
     2512#line 315 "lex.ll"
    25052513{ ASCIIOP_RETURN(); }
    25062514        YY_BREAK
    25072515case 132:
    25082516YY_RULE_SETUP
    2509 #line 314 "lex.ll"
     2517#line 316 "lex.ll"
    25102518{ ASCIIOP_RETURN(); }                                   // also operator
    25112519        YY_BREAK
    25122520case 133:
    25132521YY_RULE_SETUP
    2514 #line 315 "lex.ll"
     2522#line 317 "lex.ll"
    25152523{ NAMEDOP_RETURN(ELLIPSIS); }
    25162524        YY_BREAK
     
    25182526case 134:
    25192527YY_RULE_SETUP
    2520 #line 318 "lex.ll"
     2528#line 320 "lex.ll"
    25212529{ RETURN_VAL('['); }
    25222530        YY_BREAK
    25232531case 135:
    25242532YY_RULE_SETUP
    2525 #line 319 "lex.ll"
     2533#line 321 "lex.ll"
    25262534{ RETURN_VAL(']'); }
    25272535        YY_BREAK
    25282536case 136:
    25292537YY_RULE_SETUP
    2530 #line 320 "lex.ll"
     2538#line 322 "lex.ll"
    25312539{ RETURN_VAL('{'); }
    25322540        YY_BREAK
    25332541case 137:
    25342542YY_RULE_SETUP
    2535 #line 321 "lex.ll"
     2543#line 323 "lex.ll"
    25362544{ RETURN_VAL('}'); }
    25372545        YY_BREAK
     
    25392547case 138:
    25402548YY_RULE_SETUP
    2541 #line 324 "lex.ll"
    2542 { ASCIIOP_RETURN(); }
    2543         YY_BREAK
    2544 case 139:
    2545 YY_RULE_SETUP
    2546 #line 325 "lex.ll"
    2547 { ASCIIOP_RETURN(); }
    2548         YY_BREAK
    2549 case 140:
    2550 YY_RULE_SETUP
    25512549#line 326 "lex.ll"
    25522550{ ASCIIOP_RETURN(); }
    25532551        YY_BREAK
    2554 case 141:
     2552case 139:
    25552553YY_RULE_SETUP
    25562554#line 327 "lex.ll"
    25572555{ ASCIIOP_RETURN(); }
    25582556        YY_BREAK
    2559 case 142:
     2557case 140:
    25602558YY_RULE_SETUP
    25612559#line 328 "lex.ll"
    25622560{ ASCIIOP_RETURN(); }
    25632561        YY_BREAK
    2564 case 143:
     2562case 141:
    25652563YY_RULE_SETUP
    25662564#line 329 "lex.ll"
    25672565{ ASCIIOP_RETURN(); }
    25682566        YY_BREAK
    2569 case 144:
     2567case 142:
    25702568YY_RULE_SETUP
    25712569#line 330 "lex.ll"
    25722570{ ASCIIOP_RETURN(); }
    25732571        YY_BREAK
    2574 case 145:
     2572case 143:
    25752573YY_RULE_SETUP
    25762574#line 331 "lex.ll"
    25772575{ ASCIIOP_RETURN(); }
    25782576        YY_BREAK
    2579 case 146:
     2577case 144:
    25802578YY_RULE_SETUP
    25812579#line 332 "lex.ll"
    25822580{ ASCIIOP_RETURN(); }
    25832581        YY_BREAK
    2584 case 147:
     2582case 145:
    25852583YY_RULE_SETUP
    25862584#line 333 "lex.ll"
    25872585{ ASCIIOP_RETURN(); }
    25882586        YY_BREAK
    2589 case 148:
     2587case 146:
    25902588YY_RULE_SETUP
    25912589#line 334 "lex.ll"
    25922590{ ASCIIOP_RETURN(); }
    25932591        YY_BREAK
    2594 case 149:
     2592case 147:
    25952593YY_RULE_SETUP
    25962594#line 335 "lex.ll"
    25972595{ ASCIIOP_RETURN(); }
    25982596        YY_BREAK
    2599 case 150:
     2597case 148:
    26002598YY_RULE_SETUP
    26012599#line 336 "lex.ll"
    26022600{ ASCIIOP_RETURN(); }
    26032601        YY_BREAK
    2604 case 151:
     2602case 149:
    26052603YY_RULE_SETUP
    26062604#line 337 "lex.ll"
    26072605{ ASCIIOP_RETURN(); }
    26082606        YY_BREAK
     2607case 150:
     2608YY_RULE_SETUP
     2609#line 338 "lex.ll"
     2610{ ASCIIOP_RETURN(); }
     2611        YY_BREAK
     2612case 151:
     2613YY_RULE_SETUP
     2614#line 339 "lex.ll"
     2615{ ASCIIOP_RETURN(); }
     2616        YY_BREAK
    26092617case 152:
    26102618YY_RULE_SETUP
    2611 #line 339 "lex.ll"
     2619#line 341 "lex.ll"
    26122620{ NAMEDOP_RETURN(ICR); }
    26132621        YY_BREAK
    26142622case 153:
    26152623YY_RULE_SETUP
    2616 #line 340 "lex.ll"
     2624#line 342 "lex.ll"
    26172625{ NAMEDOP_RETURN(DECR); }
    26182626        YY_BREAK
    26192627case 154:
    26202628YY_RULE_SETUP
    2621 #line 341 "lex.ll"
     2629#line 343 "lex.ll"
    26222630{ NAMEDOP_RETURN(EQ); }
    26232631        YY_BREAK
    26242632case 155:
    26252633YY_RULE_SETUP
    2626 #line 342 "lex.ll"
     2634#line 344 "lex.ll"
    26272635{ NAMEDOP_RETURN(NE); }
    26282636        YY_BREAK
    26292637case 156:
    26302638YY_RULE_SETUP
    2631 #line 343 "lex.ll"
     2639#line 345 "lex.ll"
    26322640{ NAMEDOP_RETURN(LS); }
    26332641        YY_BREAK
    26342642case 157:
    26352643YY_RULE_SETUP
    2636 #line 344 "lex.ll"
     2644#line 346 "lex.ll"
    26372645{ NAMEDOP_RETURN(RS); }
    26382646        YY_BREAK
    26392647case 158:
    26402648YY_RULE_SETUP
    2641 #line 345 "lex.ll"
     2649#line 347 "lex.ll"
    26422650{ NAMEDOP_RETURN(LE); }
    26432651        YY_BREAK
    26442652case 159:
    26452653YY_RULE_SETUP
    2646 #line 346 "lex.ll"
     2654#line 348 "lex.ll"
    26472655{ NAMEDOP_RETURN(GE); }
    26482656        YY_BREAK
    26492657case 160:
    26502658YY_RULE_SETUP
    2651 #line 347 "lex.ll"
     2659#line 349 "lex.ll"
    26522660{ NAMEDOP_RETURN(ANDAND); }
    26532661        YY_BREAK
    26542662case 161:
    26552663YY_RULE_SETUP
    2656 #line 348 "lex.ll"
     2664#line 350 "lex.ll"
    26572665{ NAMEDOP_RETURN(OROR); }
    26582666        YY_BREAK
    26592667case 162:
    26602668YY_RULE_SETUP
    2661 #line 349 "lex.ll"
     2669#line 351 "lex.ll"
    26622670{ NAMEDOP_RETURN(ARROW); }
    26632671        YY_BREAK
    26642672case 163:
    26652673YY_RULE_SETUP
    2666 #line 350 "lex.ll"
     2674#line 352 "lex.ll"
    26672675{ NAMEDOP_RETURN(PLUSassign); }
    26682676        YY_BREAK
    26692677case 164:
    26702678YY_RULE_SETUP
    2671 #line 351 "lex.ll"
     2679#line 353 "lex.ll"
    26722680{ NAMEDOP_RETURN(MINUSassign); }
    26732681        YY_BREAK
    26742682case 165:
    26752683YY_RULE_SETUP
    2676 #line 352 "lex.ll"
     2684#line 354 "lex.ll"
    26772685{ NAMEDOP_RETURN(MULTassign); }
    26782686        YY_BREAK
    26792687case 166:
    26802688YY_RULE_SETUP
    2681 #line 353 "lex.ll"
     2689#line 355 "lex.ll"
    26822690{ NAMEDOP_RETURN(DIVassign); }
    26832691        YY_BREAK
    26842692case 167:
    26852693YY_RULE_SETUP
    2686 #line 354 "lex.ll"
     2694#line 356 "lex.ll"
    26872695{ NAMEDOP_RETURN(MODassign); }
    26882696        YY_BREAK
    26892697case 168:
    26902698YY_RULE_SETUP
    2691 #line 355 "lex.ll"
     2699#line 357 "lex.ll"
    26922700{ NAMEDOP_RETURN(ANDassign); }
    26932701        YY_BREAK
    26942702case 169:
    26952703YY_RULE_SETUP
    2696 #line 356 "lex.ll"
     2704#line 358 "lex.ll"
    26972705{ NAMEDOP_RETURN(ORassign); }
    26982706        YY_BREAK
    26992707case 170:
    27002708YY_RULE_SETUP
    2701 #line 357 "lex.ll"
     2709#line 359 "lex.ll"
    27022710{ NAMEDOP_RETURN(ERassign); }
    27032711        YY_BREAK
    27042712case 171:
    27052713YY_RULE_SETUP
    2706 #line 358 "lex.ll"
     2714#line 360 "lex.ll"
    27072715{ NAMEDOP_RETURN(LSassign); }
    27082716        YY_BREAK
    27092717case 172:
    27102718YY_RULE_SETUP
    2711 #line 359 "lex.ll"
     2719#line 361 "lex.ll"
    27122720{ NAMEDOP_RETURN(RSassign); }
    27132721        YY_BREAK
    27142722case 173:
    27152723YY_RULE_SETUP
    2716 #line 361 "lex.ll"
     2724#line 363 "lex.ll"
    27172725{ NAMEDOP_RETURN(ATassign); }
    27182726        YY_BREAK
     
    27202728case 174:
    27212729YY_RULE_SETUP
    2722 #line 364 "lex.ll"
     2730#line 366 "lex.ll"
    27232731{ IDENTIFIER_RETURN(); }                                // unary
    27242732        YY_BREAK
    27252733case 175:
    27262734YY_RULE_SETUP
    2727 #line 365 "lex.ll"
     2735#line 367 "lex.ll"
    27282736{ IDENTIFIER_RETURN(); }
    27292737        YY_BREAK
    27302738case 176:
    27312739YY_RULE_SETUP
    2732 #line 366 "lex.ll"
     2740#line 368 "lex.ll"
    27332741{ IDENTIFIER_RETURN(); }
    27342742        YY_BREAK
    27352743case 177:
    27362744YY_RULE_SETUP
    2737 #line 367 "lex.ll"
     2745#line 369 "lex.ll"
    27382746{ IDENTIFIER_RETURN(); }                // binary
    27392747        YY_BREAK
     
    27662774case 178:
    27672775YY_RULE_SETUP
    2768 #line 394 "lex.ll"
     2776#line 396 "lex.ll"
    27692777{
    27702778        // 1 or 2 character unary operator ?
     
    27812789case 179:
    27822790YY_RULE_SETUP
    2783 #line 406 "lex.ll"
     2791#line 408 "lex.ll"
    27842792{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
    27852793        YY_BREAK
    27862794case 180:
    27872795YY_RULE_SETUP
    2788 #line 408 "lex.ll"
     2796#line 410 "lex.ll"
    27892797ECHO;
    27902798        YY_BREAK
    2791 #line 2792 "Parser/lex.cc"
     2799#line 2800 "Parser/lex.cc"
    27922800case YY_STATE_EOF(INITIAL):
    27932801case YY_STATE_EOF(COMMENT):
     
    37643772#define YYTABLES_NAME "yytables"
    37653773
    3766 #line 408 "lex.ll"
     3774#line 410 "lex.ll"
    37673775
    37683776
  • src/Parser/lex.h

    r89173242 rb3f9a0cb  
    1010// Created On       : Sat Sep 22 08:58:10 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun  8 20:28:48 2015
    13 // Update Count     : 341
     12// Last Modified On : Mon Mar 21 18:18:06 2016
     13// Update Count     : 346
    1414//
    1515
     
    2020void yyerror( const char * );
    2121
     22#include <string>
     23#include "ParseNode.h"
    2224// External declarations for information sharing between lexer and scanner
    23 #include "TypedefTable.h"
     25class TypedefTable;
    2426extern TypedefTable typedefTable;
    2527
  • src/Parser/lex.ll

    r89173242 rb3f9a0cb  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Wed Mar  2 18:07:20 2016
    13  * Update Count     : 434
     12 * Last Modified On : Mon Mar 21 23:33:46 2016
     13 * Update Count     : 450
    1414 */
    1515
     
    2727
    2828#include "lex.h"
     29#include "parser.h"                                                                             // YACC generated definitions based on C++ grammar
    2930#include "ParseNode.h"
    30 #include "parser.h"                                                                             // YACC generated definitions based on C++ grammar
     31#include "TypedefTable.h"
    3132
    3233char *yyfilename;
     
    4445#define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL( x ) // numeric constant
    4546#define KEYWORD_RETURN(x)       RETURN_CHAR( x )                        // keyword
    46 #define IDENTIFIER_RETURN()     RETURN_VAL( (typedefTable.isIdentifier( yytext ) ? IDENTIFIER : typedefTable.isTypedef( yytext ) ? TYPEDEFname : TYPEGENname ) )
     47#define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
    4748#define ATTRIBUTE_RETURN()      RETURN_VAL( ATTR_IDENTIFIER )
    4849
     
    9596fractional_constant ({decimal_digits}?"."{decimal_digits})|({decimal_digits}".")
    9697exponent "_"?[eE]"_"?[+-]?{decimal_digits}
    97                                 // GCC: D (double), LD (long double) and iI (imaginary) suffixes
    98 floating_suffix "_"?([fFdD]?|([lL]?)|([iI][lLfFdD]?)|([lLfFdD][iI]))
     98                                // GCC: D (double), DL (long double) and iI (imaginary) suffixes
     99floating_suffix "_"?([fFdDlL][iI]?|"DL"|[iI][lLfFdD]?)
     100                                //floating_suffix "_"?([fFdD]|[lL]|[D][L])|([iI][lLfFdD])|([lLfFdD][iI]))
    99101floating_constant (({fractional_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix}?
    100102
  • src/Parser/parser.cc

    <
    r89173242 rb3f9a0cb  
    7777#include <cstdio>
    7878#include <stack>
     79#include "lex.h"
     80#include "parser.h"
     81#include "ParseNode.h"
    7982#include "TypedefTable.h"
    80 #include "lex.h"
    81 #include "ParseNode.h"
    8283#include "TypeData.h"
    8384#include "LinkageSpec.h"
     
    9091
    9192/* Line 268 of yacc.c  */
    92 #line 93 "Parser/parser.cc"
     93#line 94 "Parser/parser.cc"
    9394
    9495/* Enabling traces.  */
     
    341342
    342343/* Line 293 of yacc.c  */
    343 #line 111 "parser.yy"
     344#line 112 "parser.yy"
    344345
    345346        Token tok;
     
    358359
    359360/* Line 293 of yacc.c  */
    360 #line 361 "Parser/parser.cc"
     361#line 362 "Parser/parser.cc"
    361362} YYSTYPE;
    362363# define YYSTYPE_IS_TRIVIAL 1
     
    370371
    371372/* Line 343 of yacc.c  */
    372 #line 373 "Parser/parser.cc"
     373#line 374 "Parser/parser.cc"
    373374
    374375#ifdef short
     
    10151016static const yytype_uint16 yyrline[] =
    10161017{
    1017        0,   291,   291,   297,   306,   307,   308,   312,   313,   314,
    1018      318,   319,   323,   324,   328,   329,   333,   334,   340,   342,
    1019      344,   346,   351,   352,   358,   362,   364,   365,   367,   368,
    1020      370,   372,   374,   382,   383,   389,   390,   391,   396,   398,
    1021      403,   404,   408,   412,   414,   416,   418,   423,   426,   428,
    1022      430,   432,   434,   436,   438,   440,   446,   448,   450,   452,
    1023      454,   456,   458,   460,   462,   467,   468,   469,   470,   474,
    1024      475,   477,   482,   483,   485,   487,   492,   493,   495,   500,
    1025      501,   503,   508,   509,   511,   513,   515,   520,   521,   523,
    1026      528,   529,   534,   535,   540,   541,   546,   547,   552,   553,
    1027      558,   559,   561,   563,   568,   573,   574,   576,   578,   584,
    1028      585,   591,   593,   595,   597,   602,   603,   608,   609,   610,
    1029      611,   612,   613,   614,   615,   616,   617,   621,   622,   628,
    1030      629,   635,   636,   637,   638,   639,   640,   641,   642,   643,
    1031      652,   659,   661,   671,   672,   677,   679,   681,   683,   687,
    1032      688,   693,   698,   701,   703,   705,   710,   712,   720,   721,
    1033      723,   727,   728,   733,   734,   739,   740,   744,   749,   750,
    1034      754,   756,   762,   763,   767,   769,   771,   773,   779,   780,
    1035      784,   785,   789,   791,   793,   798,   800,   805,   807,   811,
    1036      814,   818,   821,   825,   827,   831,   833,   840,   842,   844,
    1037      853,   855,   857,   859,   861,   866,   868,   870,   872,   877,
    1038      890,   891,   896,   898,   903,   907,   909,   911,   913,   915,
    1039      921,   922,   928,   929,   933,   934,   939,   941,   947,   948,
    1040      950,   955,   957,   964,   966,   970,   971,   976,   978,   982,
    1041      983,   987,   989,   993,   994,   998,   999,  1003,  1004,  1019,
    1042     1020,  1021,  1022,  1023,  1027,  1032,  1039,  1049,  1054,  1059,
    1043     1067,  1072,  1077,  1082,  1087,  1095,  1117,  1122,  1129,  1131,
    1044     1138,  1143,  1148,  1159,  1164,  1169,  1174,  1179,  1188,  1193,
    1045     1201,  1202,  1203,  1204,  1210,  1215,  1223,  1224,  1225,  1226,
    1046     1230,  1231,  1232,  1233,  1238,  1239,  1248,  1249,  1254,  1255,
    1047     1260,  1262,  1264,  1266,  1268,  1271,  1270,  1282,  1283,  1285,
    1048     1295,  1296,  1301,  1305,  1307,  1309,  1311,  1313,  1315,  1317,
    1049     1319,  1324,  1326,  1328,  1330,  1332,  1334,  1336,  1338,  1340,
    1050     1342,  1344,  1346,  1348,  1354,  1355,  1357,  1359,  1361,  1366,
    1051     1367,  1373,  1374,  1376,  1378,  1383,  1385,  1387,  1389,  1394,
    1052     1395,  1397,  1399,  1404,  1405,  1407,  1412,  1413,  1415,  1417,
    1053     1422,  1424,  1426,  1431,  1432,  1436,  1438,  1440,  1442,  1444,
    1054     1449,  1451,  1456,  1458,  1463,  1464,  1466,  1467,  1472,  1473,
    1055     1475,  1477,  1482,  1484,  1490,  1491,  1493,  1496,  1499,  1504,
    1056     1505,  1510,  1515,  1519,  1521,  1523,  1528,  1530,  1536,  1537,
    1057     1545,  1546,  1550,  1551,  1552,  1554,  1556,  1563,  1564,  1566,
    1058     1568,  1573,  1574,  1580,  1581,  1585,  1586,  1591,  1592,  1593,
    1059     1595,  1603,  1604,  1606,  1609,  1611,  1615,  1616,  1617,  1619,
    1060     1621,  1625,  1630,  1638,  1639,  1648,  1650,  1655,  1656,  1657,
    1061     1661,  1662,  1663,  1667,  1668,  1669,  1673,  1674,  1675,  1680,
    1062     1681,  1682,  1683,  1689,  1690,  1692,  1697,  1698,  1703,  1704,
    1063     1705,  1706,  1707,  1722,  1723,  1728,  1729,  1737,  1739,  1741,
    1064     1744,  1746,  1748,  1771,  1772,  1774,  1776,  1781,  1782,  1784,
    1065     1789,  1794,  1795,  1801,  1800,  1804,  1808,  1810,  1812,  1818,
    1066     1819,  1824,  1829,  1831,  1836,  1838,  1839,  1841,  1846,  1848,
    1067     1850,  1855,  1857,  1862,  1867,  1875,  1881,  1880,  1894,  1895,
    1068     1900,  1901,  1905,  1910,  1915,  1923,  1928,  1939,  1940,  1951,
    1069     1952,  1958,  1959,  1963,  1964,  1965,  1968,  1967,  1978,  1983,
    1070     1988,  1994,  2003,  2009,  2015,  2021,  2027,  2035,  2041,  2049,
    1071     2055,  2064,  2065,  2066,  2070,  2074,  2076,  2081,  2082,  2086,
    1072     2087,  2092,  2098,  2099,  2102,  2104,  2105,  2109,  2110,  2111,
    1073     2112,  2146,  2148,  2149,  2151,  2156,  2161,  2166,  2168,  2170,
    1074     2175,  2177,  2179,  2181,  2186,  2188,  2198,  2200,  2201,  2206,
    1075     2208,  2210,  2215,  2217,  2219,  2224,  2226,  2228,  2237,  2238,
    1076     2239,  2243,  2245,  2247,  2252,  2254,  2256,  2261,  2263,  2265,
    1077     2280,  2282,  2283,  2285,  2290,  2291,  2296,  2298,  2300,  2305,
    1078     2307,  2309,  2311,  2316,  2318,  2320,  2330,  2332,  2333,  2335,
    1079     2340,  2342,  2344,  2349,  2351,  2353,  2355,  2360,  2362,  2364,
    1080     2395,  2397,  2398,  2400,  2405,  2410,  2418,  2420,  2422,  2427,
    1081     2429,  2434,  2436,  2450,  2451,  2453,  2458,  2460,  2462,  2464,
    1082     2466,  2471,  2472,  2474,  2476,  2481,  2483,  2485,  2491,  2493,
    1083     2495,  2499,  2501,  2503,  2505,  2519,  2520,  2522,  2527,  2529,
    1084     2531,  2533,  2535,  2540,  2541,  2543,  2545,  2550,  2552,  2554,
    1085     2560,  2561,  2563,  2572,  2575,  2577,  2580,  2582,  2584,  2597,
    1086     2598,  2600,  2605,  2607,  2609,  2611,  2613,  2618,  2619,  2621,
    1087     2623,  2628,  2630,  2638,  2639,  2640,  2645,  2646,  2650,  2652,
    1088     2654,  2656,  2658,  2660,  2667,  2669,  2671,  2673,  2675,  2677,
    1089     2679,  2681,  2683,  2685,  2690,  2692,  2694,  2699,  2725,  2726,
    1090     2728,  2732,  2733,  2737,  2739,  2741,  2743,  2745,  2747,  2754,
    1091     2756,  2758,  2760,  2762,  2764,  2769,  2774,  2776,  2778,  2796,
    1092     2798,  2803,  2804
     1018       0,   292,   292,   298,   307,   308,   309,   313,   314,   315,
     1019     319,   320,   324,   325,   329,   330,   334,   335,   341,   343,
     1020     345,   347,   352,   353,   359,   363,   365,   366,   368,   369,
     1021     371,   373,   375,   383,   384,   390,   391,   392,   397,   399,
     1022     404,   405,   409,   413,   415,   417,   419,   424,   427,   429,
     1023     431,   433,   435,   437,   439,   441,   447,   449,   451,   453,
     1024     455,   457,   459,   461,   463,   468,   469,   470,   471,   475,
     1025     476,   478,   483,   484,   486,   488,   493,   494,   496,   501,
     1026     502,   504,   509,   510,   512,   514,   516,   521,   522,   524,
     1027     529,   530,   535,   536,   541,   542,   547,   548,   553,   554,
     1028     559,   560,   562,   564,   569,   574,   575,   577,   579,   585,
     1029     586,   592,   594,   596,   598,   603,   604,   609,   610,   611,
     1030     612,   613,   614,   615,   616,   617,   618,   622,   623,   629,
     1031     630,   636,   637,   638,   639,   640,   641,   642,   643,   644,
     1032     653,   660,   662,   672,   673,   678,   680,   682,   684,   688,
     1033     689,   694,   699,   702,   704,   706,   711,   713,   721,   722,
     1034     724,   728,   729,   734,   735,   740,   741,   745,   750,   751,
     1035     755,   757,   763,   764,   768,   770,   772,   774,   780,   781,
     1036     785,   786,   790,   792,   794,   799,   801,   806,   808,   812,
     1037     815,   819,   822,   826,   828,   832,   834,   841,   843,   845,
     1038     854,   856,   858,   860,   862,   867,   869,   871,   873,   878,
     1039     891,   892,   897,   899,   904,   908,   910,   912,   914,   916,
     1040     922,   923,   929,   930,   934,   935,   940,   942,   948,   949,
     1041     951,   956,   958,   965,   967,   971,   972,   977,   979,   983,
     1042     984,   988,   990,   994,   995,   999,  1000,  1004,  1005,  1020,
     1043    1021,  1022,  1023,  1024,  1028,  1033,  1040,  1050,  1055,  1060,
     1044    1068,  1073,  1078,  1083,  1088,  1096,  1118,  1123,  1130,  1132,
     1045    1139,  1144,  1149,  1160,  1165,  1170,  1175,  1180,  1189,  1194,
     1046    1202,  1203,  1204,  1205,  1211,  1216,  1224,  1225,  1226,  1227,
     1047    1231,  1232,  1233,  1234,  1239,  1240,  1249,  1250,  1255,  1256,
     1048    1261,  1263,  1265,  1267,  1269,  1272,  1271,  1283,  1284,  1286,
     1049    1296,  1297,  1302,  1306,  1308,  1310,  1312,  1314,  1316,  1318,
     1050    1320,  1325,  1327,  1329,  1331,  1333,  1335,  1337,  1339,  1341,
     1051    1343,  1345,  1347,  1349,  1355,  1356,  1358,  1360,  1362,  1367,
     1052    1368,  1374,  1375,  1377,  1379,  1384,  1386,  1388,  1390,  1395,
     1053    1396,  1398,  1400,  1405,  1406,  1408,  1413,  1414,  1416,  1418,
     1054    1423,  1425,  1427,  1432,  1433,  1437,  1439,  1441,  1443,  1445,
     1055    1450,  1452,  1457,  1459,  1464,  1465,  1467,  1468,  1473,  1474,
     1056    1476,  1478,  1483,  1485,  1491,  1492,  1494,  1497,  1500,  1505,
     1057    1506,  1511,  1516,  1520,  1522,  1524,  1529,  1531,  1537,  1538,
     1058    1546,  1547,  1551,  1552,  1553,  1555,  1557,  1564,  1565,  1567,
     1059    1569,  1574,  1575,  1581,  1582,  1586,  1587,  1592,  1593,  1594,
     1060    1596,  1604,  1605,  1607,  1610,  1612,  1616,  1617,  1618,  1620,
     1061    1622,  1626,  1631,  1639,  1640,  1649,  1651,  1656,  1657,  1658,
     1062    1662,  1663,  1664,  1668,  1669,  1670,  1674,  1675,  1676,  1681,
     1063    1682,  1683,  1684,  1690,  1691,  1693,  1698,  1699,  1704,  1705,
     1064    1706,  1707,  1708,  1723,  1724,  1729,  1730,  1738,  1740,  1742,
     1065    1745,  1747,  1749,  1772,  1773,  1775,  1777,  1782,  1783,  1785,
     1066    1790,  1795,  1796,  1802,  1801,  1805,  1809,  1811,  1813,  1819,
     1067    1820,  1825,  1830,  1832,  1837,  1839,  1840,  1842,  1847,  1849,
     1068    1851,  1856,  1858,  1863,  1868,  1876,  1882,  1881,  1895,  1896,
     1069    1901,  1902,  1906,  1911,  1916,  1924,  1929,  1940,  1941,  1952,
     1070    1953,  1959,  1960,  1964,  1965,  1966,  1969,  1968,  1979,  1984,
     1071    1989,  1995,  2004,  2010,  2016,  2022,  2028,  2036,  2042,  2050,
     1072    2056,  2065,  2066,  2067,  2071,  2075,  2077,  2082,  2083,  2087,
     1073    2088,  2093,  2099,  2100,  2103,  2105,  2106,  2110,  2111,  2112,
     1074    2113,  2147,  2149,  2150,  2152,  2157,  2162,  2167,  2169,  2171,
     1075    2176,  2178,  2180,  2182,  2187,  2189,  2199,  2201,  2202,  2207,
     1076    2209,  2211,  2216,  2218,  2220,  2225,  2227,  2229,  2238,  2239,
     1077    2240,  2244,  2246,  2248,  2253,  2255,  2257,  2262,  2264,  2266,
     1078    2281,  2283,  2284,  2286,  2291,  2292,  2297,  2299,  2301,  2306,
     1079    2308,  2310,  2312,  2317,  2319,  2321,  2331,  2333,  2334,  2336,
     1080    2341,  2343,  2345,  2350,  2352,  2354,  2356,  2361,  2363,  2365,
     1081    2396,  2398,  2399,  2401,  2406,  2411,  2419,  2421,  2423,  2428,
     1082    2430,  2435,  2437,  2451,  2452,  2454,  2459,  2461,  2463,  2465,
     1083    2467,  2472,  2473,  2475,  2477,  2482,  2484,  2486,  2492,  2494,
     1084    2496,  2500,  2502,  2504,  2506,  2520,  2521,  2523,  2528,  2530,
     1085    2532,  2534,  2536,  2541,  2542,  2544,  2546,  2551,  2553,  2555,
     1086    2561,  2562,  2564,  2573,  2576,  2578,  2581,  2583,  2585,  2598,
     1087    2599,  2601,  2606,  2608,  2610,  2612,  2614,  2619,  2620,  2622,
     1088    2624,  2629,  2631,  2639,  2640,  2641,  2646,  2647,  2651,  2653,
     1089    2655,  2657,  2659,  2661,  2668,  2670,  2672,  2674,  2676,  2678,
     1090    2680,  2682,  2684,  2686,  2691,  2693,  2695,  2700,  2726,  2727,
     1091    2729,  2733,  2734,  2738,  2740,  2742,  2744,  2746,  2748,  2755,
     1092    2757,  2759,  2761,  2763,  2765,  2770,  2775,  2777,  2779,  2797,
     1093    2799,  2804,  2805
    10931094};
    10941095#endif
     
    50555056
    50565057/* Line 1806 of yacc.c  */
    5057 #line 291 "parser.yy"
     5058#line 292 "parser.yy"
    50585059    {
    50595060                        typedefTable.enterScope();
     
    50645065
    50655066/* Line 1806 of yacc.c  */
    5066 #line 297 "parser.yy"
     5067#line 298 "parser.yy"
    50675068    {
    50685069                        typedefTable.leaveScope();
     
    50735074
    50745075/* Line 1806 of yacc.c  */
    5075 #line 306 "parser.yy"
     5076#line 307 "parser.yy"
    50765077    { (yyval.constant) = new ConstantNode( ConstantNode::Integer, (yyvsp[(1) - (1)].tok) ); }
    50775078    break;
     
    50805081
    50815082/* Line 1806 of yacc.c  */
    5082 #line 307 "parser.yy"
     5083#line 308 "parser.yy"
    50835084    { (yyval.constant) = new ConstantNode( ConstantNode::Float, (yyvsp[(1) - (1)].tok) ); }
    50845085    break;
     
    50875088
    50885089/* Line 1806 of yacc.c  */
    5089 #line 308 "parser.yy"
     5090#line 309 "parser.yy"
    50905091    { (yyval.constant) = new ConstantNode( ConstantNode::Character, (yyvsp[(1) - (1)].tok) ); }
    50915092    break;
     
    50945095
    50955096/* Line 1806 of yacc.c  */
    5096 #line 333 "parser.yy"
     5097#line 334 "parser.yy"
    50975098    { (yyval.constant) = new ConstantNode( ConstantNode::String, (yyvsp[(1) - (1)].tok) ); }
    50985099    break;
     
    51015102
    51025103/* Line 1806 of yacc.c  */
    5103 #line 334 "parser.yy"
     5104#line 335 "parser.yy"
    51045105    { (yyval.constant) = (yyvsp[(1) - (2)].constant)->appendstr( (yyvsp[(2) - (2)].tok) ); }
    51055106    break;
     
    51085109
    51095110/* Line 1806 of yacc.c  */
    5110 #line 341 "parser.yy"
     5111#line 342 "parser.yy"
    51115112    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    51125113    break;
     
    51155116
    51165117/* Line 1806 of yacc.c  */
    5117 #line 343 "parser.yy"
     5118#line 344 "parser.yy"
    51185119    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    51195120    break;
     
    51225123
    51235124/* Line 1806 of yacc.c  */
    5124 #line 345 "parser.yy"
     5125#line 346 "parser.yy"
    51255126    { (yyval.en) = (yyvsp[(2) - (3)].en); }
    51265127    break;
     
    51295130
    51305131/* Line 1806 of yacc.c  */
    5131 #line 347 "parser.yy"
     5132#line 348 "parser.yy"
    51325133    { (yyval.en) = new ValofExprNode( (yyvsp[(2) - (3)].sn) ); }
    51335134    break;
     
    51365137
    51375138/* Line 1806 of yacc.c  */
    5138 #line 357 "parser.yy"
     5139#line 358 "parser.yy"
    51395140    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Index ), (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ); }
    51405141    break;
     
    51435144
    51445145/* Line 1806 of yacc.c  */
    5145 #line 359 "parser.yy"
     5146#line 360 "parser.yy"
    51465147    { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ); }
    51475148    break;
     
    51505151
    51515152/* Line 1806 of yacc.c  */
    5152 #line 363 "parser.yy"
     5153#line 364 "parser.yy"
    51535154    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); }
    51545155    break;
     
    51575158
    51585159/* Line 1806 of yacc.c  */
    5159 #line 366 "parser.yy"
     5160#line 367 "parser.yy"
    51605161    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); }
    51615162    break;
     
    51645165
    51655166/* Line 1806 of yacc.c  */
    5166 #line 369 "parser.yy"
     5167#line 370 "parser.yy"
    51675168    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::IncrPost ), (yyvsp[(1) - (2)].en) ); }
    51685169    break;
     
    51715172
    51725173/* Line 1806 of yacc.c  */
    5173 #line 371 "parser.yy"
     5174#line 372 "parser.yy"
    51745175    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), (yyvsp[(1) - (2)].en) ); }
    51755176    break;
     
    51785179
    51795180/* Line 1806 of yacc.c  */
    5180 #line 373 "parser.yy"
     5181#line 374 "parser.yy"
    51815182    { (yyval.en) = 0; }
    51825183    break;
     
    51855186
    51865187/* Line 1806 of yacc.c  */
    5187 #line 375 "parser.yy"
     5188#line 376 "parser.yy"
    51885189    {
    51895190                        Token fn; fn.str = new std::string( "?{}" ); // location undefined
     
    51955196
    51965197/* Line 1806 of yacc.c  */
    5197 #line 384 "parser.yy"
     5198#line 385 "parser.yy"
    51985199    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    51995200    break;
     
    52025203
    52035204/* Line 1806 of yacc.c  */
    5204 #line 389 "parser.yy"
     5205#line 390 "parser.yy"
    52055206    { (yyval.en) = 0; }
    52065207    break;
     
    52095210
    52105211/* Line 1806 of yacc.c  */
    5211 #line 392 "parser.yy"
     5212#line 393 "parser.yy"
    52125213    { (yyval.en) = (yyvsp[(3) - (3)].en)->set_argName( (yyvsp[(1) - (3)].tok) ); }
    52135214    break;
     
    52165217
    52175218/* Line 1806 of yacc.c  */
    5218 #line 397 "parser.yy"
     5219#line 398 "parser.yy"
    52195220    { (yyval.en) = (yyvsp[(7) - (7)].en)->set_argName( (yyvsp[(3) - (7)].en) ); }
    52205221    break;
     
    52235224
    52245225/* Line 1806 of yacc.c  */
    5225 #line 399 "parser.yy"
     5226#line 400 "parser.yy"
    52265227    { (yyval.en) = (yyvsp[(9) - (9)].en)->set_argName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (9)].en)->set_link( flattenCommas( (yyvsp[(5) - (9)].en) )))); }
    52275228    break;
     
    52305231
    52315232/* Line 1806 of yacc.c  */
    5232 #line 404 "parser.yy"
     5233#line 405 "parser.yy"
    52335234    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    52345235    break;
     
    52375238
    52385239/* Line 1806 of yacc.c  */
    5239 #line 409 "parser.yy"
     5240#line 410 "parser.yy"
    52405241    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    52415242    break;
     
    52445245
    52455246/* Line 1806 of yacc.c  */
    5246 #line 413 "parser.yy"