/************************************************************************/
/*                                                                      */
/*                         Applied Type System                          */
/*                                                                      */
/*                              Hongwei Xi                              */
/*                                                                      */
/************************************************************************/

/*
** ATS/Anairiats - Unleashing the Potential of Types!
**
** Copyright (C) 2002-2008 Hongwei Xi.
**
** All rights reserved
**
** ATS is free software;  you can  redistribute it and/or modify it under
** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the
** Free Software Foundation; either version 3, or (at  your  option)  any
** later version.
** 
** ATS is distributed in the hope that it will be useful, but WITHOUT ANY
** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or
** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
** for more details.
** 
** You  should  have  received  a  copy of the GNU General Public License
** along  with  ATS;  see the  file COPYING.  If not, please write to the
** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA
** 02110-1301, USA.
*/

/* ****** ****** */
//
// Author: Hongwei Xi (hwxi AT cs DOT bu DOT edu)
// Start time: July 2007
//
/* ****** ****** */

/*
** Grammar for ATS/Anairiats
*/

/* ****** ****** */

/*
** Time of Generation: Thu Sep 15 18:56:45 2011
*/

/* ****** ****** */

/*
** terminals
*/

%token YYBEG_i0de
%token YYBEG_s0rtid
%token YYBEG_si0de
%token YYBEG_di0de
%token YYBEG_s0exp
%token YYBEG_d0exp
%token YYBEG_d0ecseq_sta
%token YYBEG_d0ecseq_dyn
%token TOKEN_eof
%token <c0har> LITERAL_char
%token <e0xtcode> LITERAL_extcode
%token <f0loat> LITERAL_float
%token <f0loatsp> LITERAL_floatsp
%token <i0nt> LITERAL_int
%token <i0ntsp> LITERAL_intsp
%token <s0tring> LITERAL_string
%token <i0de> IDENTIFIER_alp
%token <i0de> IDENTIFIER_sym
%token <i0de> IDENTIFIER_arr
%token <i0de> IDENTIFIER_tmp
%token <i0de> IDENTIFIER_ext
%token <i0de> IDENTIFIER_dlr
%token <i0de> IDENTIFIER_srp
%token <t0kn> ABSPROP
%token <t0kn> ABSTYPE
%token <t0kn> ABST0YPE
%token <t0kn> ABSVIEW
%token <t0kn> ABSVIEWTYPE
%token <t0kn> ABSVIEWT0YPE
%token <t0kn> AND
%token <t0kn> AS
%token <t0kn> ASSUME
%token <t0kn> ATLAM
%token <t0kn> ATLLAM
%token <t0kn> ATFIX
%token <t0kn> BEGIN
%token <t0kn> BREAK
%token <t0kn> CASE
%token <t0kn> CASEMINUS
%token <t0kn> CASEPLUS
%token <t0kn> CASTFN
%token <t0kn> CLASSDEC
%token <t0kn> CONTINUE
%token <t0kn> DATASORT
%token <t0kn> DATAPARASORT
%token <t0kn> DATAPROP
%token <t0kn> DATATYPE
%token <t0kn> DATAVIEW
%token <t0kn> DATAVIEWTYPE
%token <t0kn> DO
%token <t0kn> DYN
%token <t0kn> DYNLOAD
%token <t0kn> ELSE
%token <t0kn> END
%token <t0kn> EXCEPTION
%token <t0kn> EXTERN
%token <t0kn> FIX
%token <t0kn> FN
%token <t0kn> FNSTAR
%token <t0kn> FOR
%token <t0kn> FORSTAR
%token <t0kn> FUN
%token <t0kn> IF
%token <t0kn> IMPLEMENT
%token <t0kn> IN
%token <t0kn> INFIX
%token <t0kn> INFIXL
%token <t0kn> INFIXR
%token <t0kn> LAM
%token <t0kn> LET
%token <t0kn> LLAM
%token <t0kn> LOCAL
%token <t0kn> MACDEF
%token <t0kn> MACRODEF
%token <t0kn> NONFIX
%token <t0kn> OF
%token <t0kn> OP
%token <t0kn> OVERLOAD
%token <t0kn> PAR
%token <t0kn> POSTFIX
%token <t0kn> PRAXI
%token <t0kn> PREFIX
%token <t0kn> PRFN
%token <t0kn> PRFUN
%token <t0kn> PROPDEF
%token <t0kn> PROPMINUS
%token <t0kn> PROPPLUS
%token <t0kn> PRVAL
%token <t0kn> REC
%token <t0kn> R0EAD
%token <t0kn> SCASE
%token <t0kn> SIF
%token <t0kn> SORTDEF
%token <t0kn> STACST
%token <t0kn> STADEF
%token <t0kn> STAIF
%token <t0kn> STALOAD
%token <t0kn> STAVAR
%token <t0kn> SYMELIM
%token <t0kn> SYMINTR
%token <t0kn> THEN
%token <t0kn> TRY
%token <t0kn> TYPEDEF
%token <t0kn> TYPEMINUS
%token <t0kn> TYPEPLUS
%token <t0kn> T0YPE
%token <t0kn> T0YPEMINUS
%token <t0kn> T0YPEPLUS
%token <t0kn> VAL
%token <t0kn> VALMINUS
%token <t0kn> VALPLUS
%token <t0kn> VAR
%token <t0kn> VIEWDEF
%token <t0kn> VIEWMINUS
%token <t0kn> VIEWPLUS
%token <t0kn> VIEWTYPEDEF
%token <t0kn> VIEWTYPEMINUS
%token <t0kn> VIEWTYPEPLUS
%token <t0kn> VIEWT0YPE
%token <t0kn> VIEWT0YPEMINUS
%token <t0kn> VIEWT0YPEPLUS
%token <t0kn> WHEN
%token <t0kn> WHERE
%token <t0kn> WHILE
%token <t0kn> WHILESTAR
%token <t0kn> WITH
%token <t0kn> WITHPROP
%token <t0kn> WITHTYPE
%token <t0kn> WITHVIEW
%token <t0kn> WITHVIEWTYPE
%token <t0kn> AMPERSAND
%token <t0kn> BACKQUOTE
%token <t0kn> BACKSLASH
%token <t0kn> BANG
%token <t0kn> BAR
%token <t0kn> COMMA
%token <t0kn> COLON
%token <t0kn> SEMICOLON
%token <t0kn> DOT
%token <t0kn> EQ
%token <t0kn> LT
%token <t0kn> GT
%token <t0kn> DOLLAR
%token <t0kn> HASH
%token <t0kn> TILDE
%token <t0kn> DOTDOT
%token <t0kn> DOTDOTDOT
%token <t0kn> EQLT
%token <t0kn> EQGT
%token <t0kn> EQLTGT
%token <t0kn> EQGTGT
%token <t0kn> EQSLASHEQGT
%token <t0kn> EQSLASHEQGTGT
%token <t0kn> GTLT
%token <t0kn> DOTLT
%token <t0kn> GTDOT
%token <t0kn> DOTLTGTDOT
%token <t0kn> MINUSLT
%token <t0kn> MINUSGT
%token <t0kn> MINUSLTGT
%token <t0kn> COLONLT
%token <t0kn> COLONLTGT
%token <t0kn> BACKQUOTELPAREN
%token <t0kn> COMMALPAREN
%token <t0kn> PERCENTLPAREN
%token <t0kn> DLRARRSZ
%token <t0kn> DLRLST_T
%token <t0kn> DLRLST_VT
%token <t0kn> DLRREC_T
%token <t0kn> DLRREC_VT
%token <t0kn> DLRTUP_T
%token <t0kn> DLRTUP_VT
%token <t0kn> DLRDELAY
%token <t0kn> DLRLDELAY
%token <t0kn> DLRDYNLOAD
%token <t0kn> DLREFFMASK_ALL
%token <t0kn> DLREFFMASK_EXN
%token <t0kn> DLREFFMASK_NTM
%token <t0kn> DLREFFMASK_REF
%token <t0kn> DLRDECRYPT
%token <t0kn> DLRENCRYPT
%token <t0kn> DLREXTERN
%token <t0kn> DLREXTVAL
%token <t0kn> DLREXTYPE
%token <t0kn> DLREXTYPE_STRUCT
%token <t0kn> DLRFOLD
%token <t0kn> DLRUNFOLD
%token <t0kn> DLRRAISE
%token <t0kn> DLRTYPEOF
%token <t0kn> SRPFILENAME
%token <t0kn> SRPLOCATION
%token <t0kn> SRPCHARCOUNT
%token <t0kn> SRPLINECOUNT
%token <t0kn> SRPASSERT
%token <t0kn> SRPDEFINE
%token <t0kn> SRPELSE
%token <t0kn> SRPELIF
%token <t0kn> SRPELIFDEF
%token <t0kn> SRPELIFNDEF
%token <t0kn> SRPENDIF
%token <t0kn> SRPERROR
%token <t0kn> SRPIF
%token <t0kn> SRPIFDEF
%token <t0kn> SRPIFNDEF
%token <t0kn> SRPINCLUDE
%token <t0kn> SRPPRINT
%token <t0kn> SRPTHEN
%token <t0kn> SRPUNDEF
%token <t0kn> FOLDAT
%token <t0kn> FREEAT
%token <t0kn> VIEWAT
%token <t0kn> LPAREN
%token <t0kn> RPAREN
%token <t0kn> LBRACKET
%token <t0kn> RBRACKET
%token <t0kn> LBRACE
%token <t0kn> RBRACE
%token <t0kn> ATLPAREN
%token <t0kn> ATLBRACKET
%token <t0kn> ATLBRACE
%token <t0kn> QUOTELPAREN
%token <t0kn> QUOTELBRACKET
%token <t0kn> QUOTELBRACE
%token <t0kn> HASHLPAREN
%token <t0kn> HASHLBRACKET
%token <t0kn> HASHLBRACE

/* ****** ****** */

/*
** precedence
*/

%nonassoc PATAS
%nonassoc PATFREE

%nonassoc SEXPLAM
%nonassoc DEXPLAM
%nonassoc DEXPFIX

%nonassoc CLAUS
%nonassoc DEXPCASE
%nonassoc DEXPIF

%nonassoc DEXPRAISE
%nonassoc DEXPTRY

%nonassoc DEXPFOR
%nonassoc DEXPWHILE

%nonassoc ELSE
%nonassoc WHERE

%right COLON /*  :  :  */

%nonassoc BARCLAUSSEQNONE
%nonassoc BAR

%nonassoc GT
%nonassoc TMPSEXP
%nonassoc TMPSARG

%nonassoc SARRIND
%nonassoc LBRACKET

%nonassoc SEXPDARGSEQEMPTY
%nonassoc LBRACE

/* ****** ****** */

/*
** nonterminals
*/

%type <d0eclst> theStartEntry
%type <abskind> abskind
%type <dcstkind> dcstkind
%type <datakind> datakind
%type <stadefkind> stadefkind
%type <valkind> valkind
%type <funkind> funkind
%type <lamkind> lamkind
%type <fixkind> fixkind
%type <srpifkindtok> srpifkind
%type <srpifkindtok> srpelifkind
%type srpthenopt
%type <i0de> i0de
%type <i0de> i0de_dlr
%type <i0delst> i0deseq
%type <i0de> i0dext
%type <l0ab> l0ab
%type <i0de> stai0de
%type <p0rec> p0rec
%type <e0xp> e0xp
%type <e0xp> atme0xp
%type <e0xplst> e0xpseq
%type <e0xplst> commae0xpseq
%type <e0xpopt> e0xpopt
%type <i0de> e0ffid
%type <e0fftag> e0fftag
%type <e0fftaglst> e0fftagseq
%type <e0fftaglst> commae0fftagseq
%type <e0fftaglstopt> colonwith
%type <s0rt> s0rt
%type <s0rtq> s0rtq
%type <i0de> s0rtid
%type <s0rt> atms0rt
%type <s0rtlst> s0rtseq
%type <s0rtlst> commas0rtseq
%type <s0rtpol> s0rtpol
%type <d0atsrtcon> d0atsrtcon
%type <d0atsrtconlst> d0atsrtconseq
%type <d0atsrtconlst> bard0atsrtconseq
%type <d0atsrtdec> d0atsrtdec
%type <d0atsrtdeclst> andd0atsrtdecseq
%type <s0taq> s0taq
%type <d0ynq> d0ynq
%type <i0de> si0de
%type <sqi0de> sqi0de
%type <i0delst> commasi0deseq
%type <i0de> di0de
%type <dqi0de> dqi0de
%type <i0de> pi0de
%type <i0de> fi0de
%type <i0de> arri0de
%type <arrqi0de> arrqi0de
%type <i0de> tmpi0de
%type <tmpqi0de> tmpqi0de
%type <s0rtopt> colons0rtopt
%type <s0arg> s0arg
%type <s0arglst> s0argseq
%type <s0arglst> commas0argseq
%type <s0arglstlst> s0argseqseq
%type <s0arglst> decs0argseq
%type <s0arglst> commadecs0argseq
%type <s0arglstlst> decs0argseqseq
%type <sp0at> sp0at
%type <s0exp> s0exp
%type <s0exp> atms0exp
%type <s0exp> apps0exp
%type <s0expext> exts0exp
%type <s0expopt> s0expelt
%type <s0arrind> s0arrind
%type <s0qua> s0qua
%type <s0qualst> s0quaseq
%type <s0qualst> barsemis0quaseq
%type <s0rtext> s0rtext
%type <s0explst> s0expseq
%type <s0explst> barsemis0expseq
%type <s0explst> commas0expseq
%type <s0explst> s0expseq1
%type <labs0explst> labs0expseq
%type <labs0explst> commalabs0expseq
%type <s0exp> t0mps0exp
%type <s0exp> t1mps0exp
%type <s0explst> t1mps0expseq
%type <s0explst> commat1mps0expseq
%type <t1mps0explstlst> gtlt_t1mps0expseqseq
%type <impqi0de> impqi0de
%type <s0rtdef> s0rtdef
%type <s0rtdeflst> ands0rtdefseq
%type <d0atarg> d0atarg
%type <d0atarglst> d0atargseq
%type <d0atarglst> commad0atargseq
%type <s0tacon> s0tacon
%type <s0taconlst> ands0taconseq
%type <s0tacst> s0tacst
%type <s0tacstlst> ands0tacstseq
%type <s0tavar> s0tavar
%type <s0tavarlst> ands0tavarseq
%type <s0expdef> s0expdef
%type <s0expdeflst> ands0expdefseq
%type <s0aspdec> s0aspdec
%type <s0qualstlst> conq0uaseq
%type <s0expopt> coni0ndopt
%type <s0expopt> cona0rgopt
%type <d0atcon> d0atcon
%type <d0atconlst> d0atconseq
%type <d0atconlst> bard0atconseq
%type <d0atdec> d0atdec
%type <d0atdeclst> andd0atdecseq
%type <s0expdeflst> s0expdefseqopt
%type <e0xndec> e0xndec
%type <e0xndeclst> ande0xndecseq
%type <p0arg> p0arg
%type <p0arglst> p0argseq
%type <p0arglst> commap0argseq
%type <d0arg> d0arg
%type <d0arglst> d0argseq
%type <extnamopt> extnamopt
%type <d0cstdec> d0cstdec
%type <d0cstdeclst> andd0cstdecseq
%type <s0vararg> s0vararg
%type <s0exparg> s0exparg
%type <s0elop> s0elop
%type <witht0ype> witht0ype
%type <p0at> p0at
%type <p0at> atmp0at
%type <p0at> argp0at
%type <p0atlst> argp0atseq
%type <p0atlst> p0atseq
%type <p0atlst> commap0atseq
%type <labp0atlst> labp0atseq
%type <labp0atlst> commalabp0atseq
%type <f0arg> f0arg1
%type <f0arglst> f0arg1seq
%type <f0arg> f0arg2
%type <f0arglst> f0arg2seq
%type <d0exp> d0exp
%type <d0exp> atmd0exp
%type <d0exp> s0expdarg
%type <d0explst> s0expdargseq
%type <d0exp> argd0exp
%type <d0explst> argd0expseq
%type <d0arrind> d0arrind
%type <s0expopt> colons0expopt
%type <e0fftaglstopt> funarrow
%type <i0nvresstate> caseinv
%type <ifhead> ifhead
%type <ifhead> sifhead
%type <casehead> casehead
%type <casehead> scasehead
%type <loophead> forhead
%type <loophead> whilehead
%type <tryhead> tryhead
%type <d0explst> d0expcommaseq
%type <d0explst> commad0expseq
%type <d0explst> d0expsemiseq0
%type <d0explst> d0expsemiseq1
%type <labd0explst> labd0expseq
%type <labd0explst> commalabd0expseq
%type <m0atch> m0atch
%type <m0atchlst> m0atchseq
%type <m0atchlst> andm0atchseq
%type <guap0at> guap0at
%type <c0lau> c0lau
%type <c0laulst> c0lauseq
%type <c0laulst> barc0lauseq
%type <sc0lau> sc0lau
%type <sc0laulst> sc0lauseq
%type <sc0laulst> barsc0lauseq
%type <s0qualstopt> i0nvqua
%type <s0qualstopt> i0nvmet
%type <i0nvarg> i0nvarg
%type <i0nvarglst> i0nvargseq
%type <i0nvarglst> commai0nvargseq
%type <i0nvarglst> i0nvargstate
%type <s0qualstopt> i0nvresqua
%type <i0nvresstate> i0nvresstate
%type <loopi0nv> loopi0nv
%type <initestpost> initestpost
%type <i0de> m0arg
%type <i0delst> m0argseq
%type <i0delst> commam0argseq
%type <m0acarg> m0acarg
%type <m0acarglst> m0acargseq
%type <m0acdef> m0acdef
%type <m0acdeflst> andm0acdefseq
%type <v0aldec> v0aldec
%type <v0aldeclst> andv0aldecseq
%type <f0undec> f0undec
%type <f0undeclst> andf0undecseq
%type <v0arwth> v0arwth
%type <v0ardec> v0ardec
%type <v0ardeclst> andv0ardecseq
%type <i0mpdec> i0mpdec
%type <d0ec> d0ec
%type <s0qualst> d0ecarg
%type <s0qualstlst> d0ecargseq
%type semicolonseq
%type <d0ec> d0ec_sta
%type <d0eclst> guad0ec_sta
%type <d0eclst> d0ecseq_sta
%type <d0eclst> d0ecseq_sta_rev
%type <d0ec> d0ec_dyn
%type <d0eclst> guad0ec_dyn
%type <d0eclst> d0ecseq_dyn
%type <d0eclst> d0ecseq_dyn_rev

/* ****** ****** */

/*
** production rules
*/

theStartEntry
  : YYBEG_d0ecseq_sta d0ecseq_sta TOKEN_eof { theYYVALyyres = atsopt_yyres_d0eclst($2) ; return 0 ; }
  | YYBEG_d0ecseq_dyn d0ecseq_dyn TOKEN_eof { theYYVALyyres = atsopt_yyres_d0eclst($2) ; return 0 ; }
  | YYBEG_i0de i0de TOKEN_eof { theYYVALyyres = atsopt_yyres_i0de($2) ; return 0 ; }
  | YYBEG_s0rtid s0rtid TOKEN_eof { theYYVALyyres = atsopt_yyres_i0de($2) ; return 0 ; }
  | YYBEG_si0de si0de TOKEN_eof { theYYVALyyres = atsopt_yyres_i0de($2) ; return 0 ; }
  | YYBEG_di0de di0de TOKEN_eof { theYYVALyyres = atsopt_yyres_i0de($2) ; return 0 ; }
  | YYBEG_s0exp s0exp TOKEN_eof { theYYVALyyres = atsopt_yyres_s0exp($2) ; return 0 ; }
  | YYBEG_d0exp d0exp TOKEN_eof { theYYVALyyres = atsopt_yyres_d0exp($2) ; return 0 ; }
; /* theStartEntry */

abskind
  : ABSPROP { $$ = abskind_prop () ; }
  | ABSTYPE { $$ = abskind_type () ; }
  | ABST0YPE { $$ = abskind_t0ype () ; }
  | ABSVIEW { $$ = abskind_view () ; }
  | ABSVIEWTYPE { $$ = abskind_viewtype () ; }
  | ABSVIEWT0YPE { $$ = abskind_viewt0ype () ; }
; /* abskind */

dcstkind
  : FUN { $$ = dcstkind_fun () ; }
  | VAL { $$ = dcstkind_val () ; }
  | CASTFN { $$ = dcstkind_castfn () ; }
  | PRAXI { $$ = dcstkind_praxi () ; }
  | PRFUN { $$ = dcstkind_prfun () ; }
  | PRVAL { $$ = dcstkind_prval () ; }
; /* dcstkind */

datakind
  : DATAPROP { $$ = datakind_prop () ; }
  | DATATYPE { $$ = datakind_type () ; }
  | DATAVIEW { $$ = datakind_view () ; }
  | DATAVIEWTYPE { $$ = datakind_viewtype () ; }
; /* datakind */

stadefkind
  : STADEF { $$ = stadefkind_generic () ; }
  | PROPDEF { $$ = stadefkind_prop ($1) ; }
  | TYPEDEF { $$ = stadefkind_type ($1) ; }
  | VIEWDEF { $$ = stadefkind_view ($1) ; }
  | VIEWTYPEDEF { $$ = stadefkind_viewtype ($1) ; }
; /* stadefkind */

valkind
  : VAL { $$ = valkind_val () ; }
  | VALMINUS { $$ = valkind_valminus () ; }
  | VALPLUS { $$ = valkind_valplus () ; }
  | PRVAL { $$ = valkind_prval () ; }
; /* valkind */

funkind
  : FN { $$ = funkind_fn () ; }
  | FNSTAR { $$ = funkind_fnstar () ; }
  | FUN { $$ = funkind_fun () ; }
  | CASTFN { $$ = funkind_castfn () ; }
  | PRFN { $$ = funkind_prfn () ; }
  | PRFUN { $$ = funkind_prfun () ; }
; /* funkind */

lamkind
  : LAM { $$ = lamkind_lam ($1) ; }
  | ATLAM { $$ = lamkind_atlam ($1) ; }
  | LLAM { $$ = lamkind_llam ($1) ; }
  | ATLLAM { $$ = lamkind_atllam ($1) ; }
; /* lamkind */

fixkind
  : FIX { $$ = fixkind_fix ($1) ; }
  | ATFIX { $$ = fixkind_atfix ($1) ; }
; /* fixkind */

srpifkind
  : SRPIF { $$ = srpifkindtok_if ($1) ; }
  | SRPIFDEF { $$ = srpifkindtok_ifdef ($1) ; }
  | SRPIFNDEF { $$ = srpifkindtok_ifndef ($1) ; }
; /* srpifkind */

srpelifkind
  : SRPELIF { $$ = srpifkindtok_if ($1) ; }
  | SRPELIFDEF { $$ = srpifkindtok_ifdef ($1) ; }
  | SRPELIFNDEF { $$ = srpifkindtok_ifndef ($1) ; }
; /* srpelifkind */

srpthenopt
  : /*(empty)*/ { ; }
  | SRPTHEN { ; }
; /* srpthenopt */

i0de
  : IDENTIFIER_alp { $$ = $1 ; }
  | IDENTIFIER_sym { $$ = $1 ; }
  | AMPERSAND { $$ = i0de_make_ampersand($1) ; }
  | BACKSLASH { $$ = i0de_make_backslash($1) ; }
  | BANG { $$ = i0de_make_bang($1) ; }
  | EQ { $$ = i0de_make_eq($1) ; }
  | GT { $$ = i0de_make_gt($1) ; }
  | GTLT { $$ = i0de_make_gtlt($1) ; }
  | LT { $$ = i0de_make_lt($1) ; }
  | MINUSGT { $$ = i0de_make_minusgt($1) ; }
  | MINUSLTGT { $$ = i0de_make_minusltgt($1) ; }
  | TILDE { $$ = i0de_make_tilde($1) ; }
; /* i0de */

i0de_dlr
  : IDENTIFIER_dlr { $$ = $1 ; }
; /* i0de_dlr */

i0deseq
  : /*(empty)*/ { $$ = i0delst_nil() ; }
  | i0de i0deseq { $$ = i0delst_cons($1, $2) ; }
; /* i0deseq */

i0dext
  : IDENTIFIER_ext { $$ = $1 ; }
  | DO { $$ = i0de_make_DO($1) ; }
  | WHILE { $$ = i0de_make_WHILE($1) ; }
; /* i0dext */

l0ab
  : i0de { $$ = l0ab_ide($1) ; }
  | LITERAL_int { $$ = l0ab_int($1) ; }
  | LPAREN l0ab RPAREN { $$ = $2 ; }
; /* l0ab */

stai0de
  : IDENTIFIER_alp { $$ = stai0de_make($1) ; }
; /* stai0de */

p0rec
  : /*(empty)*/ { $$ = p0rec_emp() ; }
  | LITERAL_int { $$ = p0rec_int($1) ; }
  | LPAREN i0de RPAREN { $$ = p0rec_ide($2) ; }
  | LPAREN i0de IDENTIFIER_sym LITERAL_int RPAREN { $$ = p0rec_opr($2, $3, $4) ; }
; /* p0rec */

e0xp
  : e0xp atme0xp { $$ = e0xp_app($1, $2) ; }
  | atme0xp { $$ = $1 ; }
; /* e0xp */

atme0xp
  : LITERAL_char { $$ = e0xp_char($1) ; }
  | LITERAL_float { $$ = e0xp_float($1) ; }
  | LITERAL_int { $$ = e0xp_int($1) ; }
  | LITERAL_string { $$ = e0xp_string($1) ; }
  | SRPFILENAME { $$ = e0xp_FILENAME($1) ; }
  | SRPLOCATION { $$ = e0xp_LOCATION($1) ; }
  | i0de { $$ = e0xp_ide($1) ; }
  | LPAREN e0xpseq RPAREN { $$ = e0xp_list($1, $2, $3) ; }
  | PERCENTLPAREN e0xp RPAREN { $$ = e0xp_eval($1, $2, $3) ; }
; /* atme0xp */

e0xpseq
  : /*(empty)*/ { $$ = e0xplst_nil() ; }
  | e0xp commae0xpseq { $$ = e0xplst_cons($1, $2) ; }
; /* e0xpseq */

commae0xpseq
  : /*(empty)*/ { $$ = e0xplst_nil() ; }
  | COMMA e0xp commae0xpseq { $$ = e0xplst_cons($2, $3) ; }
; /* commae0xpseq */

e0xpopt
  : /*(empty)*/ { $$ = e0xpopt_none() ; }
  | e0xp { $$ = e0xpopt_some($1) ; }
; /* e0xpopt */

e0ffid
  : IDENTIFIER_alp { $$ = $1 ; }
; /* e0ffid */

e0fftag
  : BANG e0ffid { $$ = e0fftag_cst (0, $2) ; }
  | TILDE e0ffid { $$ = e0fftag_cst (1, $2) ; }
  | e0ffid { $$ = e0fftag_var($1) ; }
  | FUN { $$ = e0fftag_var_fun($1) ; }
  | LITERAL_int { $$ = e0fftag_int($1) ; }
; /* e0fftag */

e0fftagseq
  : /*(empty)*/ { $$ = e0fftaglst_nil() ; }
  | e0fftag commae0fftagseq { $$ = e0fftaglst_cons($1, $2) ; }
; /* e0fftagseq */

commae0fftagseq
  : /*(empty)*/ { $$ = e0fftaglst_nil() ; }
  | COMMA e0fftag commae0fftagseq { $$ = e0fftaglst_cons($2, $3) ; }
; /* commae0fftagseq */

colonwith
  : COLON { $$ = e0fftaglstopt_none() ; }
  | COLONLTGT { $$ = e0fftaglstopt_some(e0fftaglst_nil()) ; }
  | COLONLT e0fftagseq GT { $$ = e0fftaglstopt_some($2) ; }
; /* colonwith */

s0rt
  : s0rt atms0rt { $$ = s0rt_app($1, $2) ; }
  | atms0rt { $$ = $1 ; }
; /* s0rt */

s0rtq
  : i0de_dlr DOT { $$ = s0rtq_sym($1) ; }
  | DOLLAR LITERAL_string DOT { $$ = s0rtq_str($2) ; }
; /* s0rtq */

s0rtid
  : IDENTIFIER_alp { $$ = $1 ; }
  | IDENTIFIER_sym { $$ = $1 ; }
  | T0YPE { $$ = i0de_make_t0ype($1) ; }
  | VIEWT0YPE { $$ = i0de_make_viewt0ype($1) ; }
  | BACKSLASH { $$ = i0de_make_backslash($1) ; }
  | MINUSGT { $$ = i0de_make_minusgt($1) ; }
  | MINUSLTGT { $$ = i0de_make_minusltgt($1) ; }
; /* s0rtid */

atms0rt
  : s0rtid { $$ = s0rt_ide($1) ; }
  | s0rtq s0rtid { $$ = s0rt_qid($1, $2) ; }
  | LPAREN s0rtseq RPAREN { $$ = s0rt_list($1, $2, $3) ; }
  | ATLPAREN s0rtseq RPAREN { $$ = s0rt_tup($1, $2, $3) ; }
; /* atms0rt */

s0rtseq
  : /*(empty)*/ { $$ = s0rtlst_nil() ; }
  | s0rt commas0rtseq { $$ = s0rtlst_cons($1, $2) ; }
; /* s0rtseq */

commas0rtseq
  : /*(empty)*/ { $$ = s0rtlst_nil() ; }
  | COMMA s0rt commas0rtseq { $$ = s0rtlst_cons($2, $3) ; }
; /* commas0rtseq */

s0rtpol
  : s0rt { $$ = s0rtpol_make($1, 0) ; }
  | PROPMINUS { $$ = s0rtpol_make(s0rt_prop($1), -1) ; }
  | PROPPLUS { $$ = s0rtpol_make(s0rt_prop($1),  1) ; }
  | TYPEMINUS { $$ = s0rtpol_make(s0rt_type($1), -1) ; }
  | TYPEPLUS { $$ = s0rtpol_make(s0rt_type($1),  1) ; }
  | T0YPEMINUS { $$ = s0rtpol_make(s0rt_t0ype($1), -1) ; }
  | T0YPEPLUS { $$ = s0rtpol_make(s0rt_t0ype($1),  1) ; }
  | VIEWMINUS { $$ = s0rtpol_make(s0rt_view($1), -1) ; }
  | VIEWPLUS { $$ = s0rtpol_make(s0rt_view($1),  1) ; }
  | VIEWTYPEMINUS { $$ = s0rtpol_make(s0rt_viewtype($1), -1) ; }
  | VIEWTYPEPLUS { $$ = s0rtpol_make(s0rt_viewtype($1),  1) ; }
  | VIEWT0YPEMINUS { $$ = s0rtpol_make(s0rt_viewt0ype($1), -1) ; }
  | VIEWT0YPEPLUS { $$ = s0rtpol_make(s0rt_viewt0ype($1),  1) ; }
; /* s0rtpol */

d0atsrtcon
  : i0de { $$ = d0atsrtcon_make_none($1) ; }
  | i0de OF s0rt { $$ = d0atsrtcon_make_some($1, $3) ; }
; /* d0atsrtcon */

d0atsrtconseq
  : bard0atsrtconseq { $$ = $1 ; }
  | d0atsrtcon bard0atsrtconseq { $$ = d0atsrtconlst_cons($1, $2) ; }
; /* d0atsrtconseq */

bard0atsrtconseq
  : /*(empty)*/ { $$ = d0atsrtconlst_nil() ; }
  | BAR d0atsrtcon bard0atsrtconseq { $$ = d0atsrtconlst_cons($2, $3) ; }
; /* bard0atsrtconseq */

d0atsrtdec
  : i0de EQ d0atsrtconseq { $$ = d0atsrtdec_make($1, $3) ; }
; /* d0atsrtdec */

andd0atsrtdecseq
  : /*(empty)*/ { $$ = d0atsrtdeclst_nil() ; }
  | AND d0atsrtdec andd0atsrtdecseq { $$ = d0atsrtdeclst_cons($2, $3) ; }
; /* andd0atsrtdecseq */

s0taq
  : i0de_dlr DOT { $$ = s0taq_symdot($1) ; }
  | i0de_dlr COLON { $$ = s0taq_symcolon($1) ; }
  | DOLLAR LITERAL_string DOT { $$ = s0taq_fildot($2) ; }
; /* s0taq */

d0ynq
  : i0de_dlr DOT { $$ = d0ynq_symdot($1) ; }
  | i0de_dlr COLON { $$ = d0ynq_symcolon($1) ; }
  | i0de_dlr i0de_dlr COLON { $$ = d0ynq_symdot_symcolon ($1, $2) ; }
  | DOLLAR LITERAL_string DOT { $$ = d0ynq_fildot($2) ; }
  | DOLLAR LITERAL_string i0de_dlr COLON { $$ = d0ynq_fildot_symcolon($2, $3) ; }
; /* d0ynq */

si0de
  : IDENTIFIER_alp { $$ = $1 ; }
  | IDENTIFIER_sym { $$ = $1 ; }
  | R0EAD { $$ = i0de_make_r0ead($1) ; }
  | AMPERSAND { $$ = i0de_make_ampersand($1) ; }
  | BACKSLASH { $$ = i0de_make_backslash($1) ; }
  | BANG { $$ = i0de_make_bang($1) ; }
  | GT { $$ = i0de_make_gt($1) ; }
  | LT { $$ = i0de_make_lt($1) ; }
  | MINUSGT { $$ = i0de_make_minusgt($1) ; }
  | TILDE { $$ = i0de_make_tilde($1) ; }
; /* si0de */

sqi0de
  : si0de { $$ = sqi0de_make_none($1) ; }
  | s0taq si0de { $$ = sqi0de_make_some($1, $2) ; }
; /* sqi0de */

commasi0deseq
  : /*(empty)*/ { $$ = i0delst_nil() ; }
  | COMMA si0de commasi0deseq { $$ = i0delst_cons($2, $3) ; }
; /* commasi0deseq */

di0de
  : IDENTIFIER_alp { $$ = $1 ; }
  | IDENTIFIER_sym { $$ = $1 ; }
  | BACKSLASH { $$ = i0de_make_backslash($1) ; }
  | BANG { $$ = i0de_make_bang($1) ; }
  | EQ { $$ = i0de_make_eq($1) ; }
  | GT { $$ = i0de_make_gt($1) ; }
  | GTLT { $$ = i0de_make_gtlt($1) ; }
  | LT { $$ = i0de_make_lt($1) ; }
  | TILDE { $$ = i0de_make_tilde($1) ; }
; /* di0de */

dqi0de
  : di0de { $$ = dqi0de_make_none($1) ; }
  | d0ynq di0de { $$ = dqi0de_make_some($1, $2) ; }
; /* dqi0de */

pi0de
  : IDENTIFIER_alp { $$ = $1 ; }
  | IDENTIFIER_sym { $$ = $1 ; }
; /* pi0de */

fi0de
  : di0de { $$ = $1 ; }
  | OP di0de { $$ = $2 ; }
; /* fi0de */

arri0de
  : IDENTIFIER_arr { $$ = $1 ; }
; /* arri0de */

arrqi0de
  : arri0de { $$ = arrqi0de_make_none($1) ; }
  | d0ynq arri0de { $$ = arrqi0de_make_some($1, $2) ; }
; /* arrqi0de */

tmpi0de
  : IDENTIFIER_tmp { $$ = $1 ; }
; /* tmpi0de */

tmpqi0de
  : tmpi0de { $$ = tmpqi0de_make_none($1) ; }
  | d0ynq tmpi0de { $$ = tmpqi0de_make_some($1, $2) ; }
; /* tmpqi0de */

colons0rtopt
  : /*(empty)*/ { $$ = s0rtopt_none() ; }
  | COLON s0rt { $$ = s0rtopt_some($2) ; }
; /* colons0rtopt */

s0arg
  : si0de colons0rtopt { $$ = s0arg_make($1, $2) ; }
; /* s0arg */

s0argseq
  : /*(empty)*/ { $$ = s0arglst_nil() ; }
  | s0arg commas0argseq { $$ = s0arglst_cons($1, $2) ; }
; /* s0argseq */

commas0argseq
  : /*(empty)*/ { $$ = s0arglst_nil() ; }
  | COMMA s0arg commas0argseq { $$ = s0arglst_cons($2, $3) ; }
; /* commas0argseq */

s0argseqseq
  : /*(empty)*/ { $$ = s0arglstlst_nil() ; }
  | si0de s0argseqseq { $$ = s0arglstlst_cons_ide($1, $2) ; }
  | LPAREN s0argseq RPAREN s0argseqseq { $$ = s0arglstlst_cons($2, $4); }
; /* s0argseqseq */

decs0argseq
  : /*(empty)*/ { $$ = s0arglst_nil() ; } %prec TMPSARG
  | s0arg commadecs0argseq { $$ = s0arglst_cons($1, $2) ; }
; /* decs0argseq */

commadecs0argseq
  : /*(empty)*/ { $$ = s0arglst_nil() ; } %prec TMPSARG
  | COMMA s0arg commadecs0argseq { $$ = s0arglst_cons($2, $3) ; }
; /* commadecs0argseq */

decs0argseqseq
  : /*(empty)*/ { $$ = s0arglstlst_nil() ; }
  | LBRACE decs0argseq RBRACE decs0argseqseq { $$ = s0arglstlst_cons($2, $4) ; }
; /* decs0argseqseq */

sp0at
  : sqi0de LPAREN s0argseq RPAREN { $$ = sp0at_con($1, $3, $4) ; }
; /* sp0at */

s0exp
  : apps0exp { $$ = $1 ; }
  | exts0exp { $$ = s0exp_extern($1) ; }
  | s0exp COLON s0rt { $$ = s0exp_ann($1, $3) ; }
  | LAM s0argseqseq colons0rtopt EQGT s0exp { $$ = s0exp_lams($1, $2, $3, $5) ; }  %prec SEXPLAM
; /* s0exp */

atms0exp
  : LITERAL_char { $$ = s0exp_char($1) ; }
  | LITERAL_int { $$ = s0exp_int($1) ; }
  | LITERAL_intsp { $$ = s0exp_intsp_err($1) ; }
  | si0de { $$ = s0exp_ide($1) ; }
  | OP si0de { $$ = s0exp_opide($1, $2) ; }
  | s0taq si0de { $$ = s0exp_qid($1, $2) ; }
  | LPAREN s0expseq RPAREN { $$ = s0exp_list($1, $2, $3) ; }
  | LPAREN s0expseq BAR s0expseq RPAREN { $$ = s0exp_list2($1, $2, $4, $5) ; }
  | ATLPAREN s0expseq RPAREN { $$ = s0exp_tytup(0, $1, $2, $3) ; }
  | QUOTELPAREN s0expseq RPAREN { $$ = s0exp_tytup(1, $1, $2, $3) ; }
  | DLRTUP_T LPAREN s0expseq RPAREN { $$ = s0exp_tytup(2, $1, $3, $4) ; }
  | DLRTUP_VT LPAREN s0expseq RPAREN { $$ = s0exp_tytup(3, $1, $3, $4) ; }
  | ATLPAREN s0expseq BAR s0expseq RPAREN { $$ = s0exp_tytup2(0, $1, $2, $4, $5) ; }
  | QUOTELPAREN s0expseq BAR s0expseq RPAREN { $$ = s0exp_tytup2(1, $1, $2, $4, $5) ; }
  | DLRTUP_T LPAREN s0expseq BAR s0expseq RPAREN { $$ = s0exp_tytup2(2, $1, $3, $5, $6) ; }
  | DLRTUP_VT LPAREN s0expseq BAR s0expseq RPAREN { $$ = s0exp_tytup2(3, $1, $3, $5, $6) ; }
  | ATLBRACE labs0expseq RBRACE { $$ = s0exp_tyrec(0, $1, $2, $3) ; }
  | QUOTELBRACE labs0expseq RBRACE { $$ = s0exp_tyrec(1, $1, $2, $3) ; }
  | DLRREC_T LBRACE labs0expseq RBRACE { $$ = s0exp_tyrec(2, $1, $3, $4) ; }
  | DLRREC_VT LBRACE labs0expseq RBRACE { $$ = s0exp_tyrec(3, $1, $3, $4) ; }
  | DLREXTYPE_STRUCT LITERAL_string OF LBRACE labs0expseq RBRACE { $$ = s0exp_tyrec_ext($1, $2, $5, $6) ; }
  | ATLBRACKET s0exp RBRACKET LBRACKET s0arrind { $$ = s0exp_tyarr($1, $2, $5) ; }
  | MINUSLT e0fftagseq GT { $$ = s0exp_imp($1, $2, $3) ; }
  | MINUSLTGT { $$ = s0exp_imp_emp($1) ; }
  | LBRACE s0quaseq RBRACE { $$ = s0exp_uni($1, $2, $3) ; }
  | LBRACKET s0quaseq RBRACKET { $$ = s0exp_exi($1, 0/*funres*/, $2, $3) ; }
  | HASHLBRACKET s0quaseq RBRACKET { $$ = s0exp_exi($1, 1/*funres*/, $2, $3) ; }
; /* atms0exp */

apps0exp
  : apps0exp atms0exp { $$ = s0exp_app($1, $2) ; }
  | atms0exp { $$ = $1 ; }
; /* apps0exp */

exts0exp
  : DLREXTYPE LITERAL_string { $$ = s0expext_nam($1, $2) ; }
  | exts0exp atms0exp { $$ = s0expext_app($1, $2) ; }
; /* exts0exp */

s0expelt
  : /*(empty)*/ { $$ = s0expopt_none () ; }
  | LBRACE s0exp RBRACE { $$ = s0expopt_some ($2) ; }
  | LBRACKET s0exp RBRACKET { $$ = s0expopt_some ($2) ; }
; /* s0expelt */

s0arrind
  : s0expseq RBRACKET { $$ = s0arrind_make_sing($1, $2) ; } %prec SARRIND
  | s0expseq RBRACKET LBRACKET s0arrind { $$ = s0arrind_make_cons($1, $4) ; }
; /* s0arrind */

s0qua
  : apps0exp { $$ = s0qua_prop($1) ; }
  | si0de commasi0deseq COLON s0rtext { $$ = s0qua_vars($1, $2, $4) ; }
; /* s0qua */

s0quaseq
  : /*(empty)*/ { $$ = s0qualst_nil() ; }
  | s0qua barsemis0quaseq { $$ = s0qualst_cons($1, $2) ; }
; /* s0quaseq */

barsemis0quaseq
  : /*(empty)*/ { $$ = s0qualst_nil() ; }
  | BAR s0qua barsemis0quaseq { $$ = s0qualst_cons($2, $3) ; }
  | SEMICOLON s0qua barsemis0quaseq { $$ = s0qualst_cons($2, $3) ; }
; /* barsemis0quaseq */

s0rtext
  : s0rt { $$ = s0rtext_srt($1) ; }
  | LBRACE si0de COLON s0rtext BAR s0exp barsemis0expseq RBRACE { $$ = s0rtext_sub($1, $2, $4, $6, $7, $8) ; }
; /* s0rtext */

s0expseq
  : /*(empty)*/ { $$ = s0explst_nil() ; }
  | s0expseq1 { $$ = $1 ; }
; /* s0expseq */

barsemis0expseq
  : /*(empty)*/ { $$ = s0explst_nil() ; }
  | BAR s0exp barsemis0expseq { $$ = s0explst_cons($2, $3) ; }
  | SEMICOLON s0exp barsemis0expseq { $$ = s0explst_cons($2, $3) ; }
; /* barsemis0expseq */

commas0expseq
  : /*(empty)*/ { $$ = s0explst_nil() ; }
  | COMMA s0exp commas0expseq { $$ = s0explst_cons($2, $3) ; }
; /* commas0expseq */

s0expseq1
  : s0exp commas0expseq { $$ = s0explst_cons($1, $2) ; }
; /* s0expseq1 */

labs0expseq
  : /*(empty)*/ { $$ = labs0explst_nil() ; }
  | l0ab EQ s0exp commalabs0expseq { $$ = labs0explst_cons($1, $3, $4) ; }
; /* labs0expseq */

commalabs0expseq
  : /*(empty)*/ { $$ = labs0explst_nil() ; }
  | COMMA l0ab EQ s0exp commalabs0expseq { $$ = labs0explst_cons($2, $4, $5) ; }
; /* commalabs0expseq */

t0mps0exp
  : atms0exp { $$ = $1 ; }
  | t0mps0exp atms0exp { $$ = s0exp_app($1, $2) ; }
; /* t0mps0exp */

t1mps0exp
  : t0mps0exp { $$ = $1 ; } %prec TMPSEXP
; /* t1mps0exp */

t1mps0expseq
  : /*(empty)*/ { $$ = s0explst_nil() ; } %prec TMPSEXP
  | t1mps0exp commat1mps0expseq { $$ = s0explst_cons($1, $2) ; }
; /* t1mps0expseq */

commat1mps0expseq
  : /*(empty)*/ { $$ = s0explst_nil() ; } %prec TMPSEXP
  | COMMA t1mps0exp commat1mps0expseq { $$ = s0explst_cons($2, $3) ; }
; /* commat1mps0expseq */

gtlt_t1mps0expseqseq
  : /*(empty)*/ { $$ = gtlt_t1mps0expseqseq_nil() ; }
  | GTLT t1mps0expseq gtlt_t1mps0expseqseq { $$ = gtlt_t1mps0expseqseq_cons_tok($1, $2, $3) ; }
; /* gtlt_t1mps0expseqseq */

impqi0de
  : dqi0de { $$ = impqi0de_make_none($1) ; }
  | tmpqi0de t1mps0expseq gtlt_t1mps0expseqseq GT { $$ = impqi0de_make_some($1, $2, $3, $4) ; }
; /* impqi0de */

s0rtdef
  : s0rtid EQ s0rtext { $$ = s0rtdef_make($1, $3) ; }
; /* s0rtdef */

ands0rtdefseq
  : /*(empty)*/ { $$ = s0rtdeflst_nil() ; }
  | AND s0rtdef ands0rtdefseq { $$ = s0rtdeflst_cons($2, $3) ; }
; /* ands0rtdefseq */

d0atarg
  : s0rtpol { $$ = d0atarg_srt($1) ; }
  | i0de COLON s0rtpol { $$ = d0atarg_id_srt($1, $3) ; }
; /* d0atarg */

d0atargseq
  : /*(empty)*/ { $$ = d0atarglst_nil() ; }
  | d0atarg commad0atargseq { $$ = d0atarglst_cons($1, $2) ; }
; /* d0atargseq */

commad0atargseq
  : /*(empty)*/ { $$ = d0atarglst_nil() ; }
  | COMMA d0atarg commad0atargseq { $$ = d0atarglst_cons($2, $3) ; }
; /* commad0atargseq */

s0tacon
  : si0de { $$ = s0tacon_make_none_none($1) ; }
  | si0de LPAREN d0atargseq RPAREN { $$ = s0tacon_make_some_none($1, $3, $4) ; }
  | si0de EQ s0exp { $$ = s0tacon_make_none_some($1, $3) ; }
  | si0de LPAREN d0atargseq RPAREN EQ s0exp { $$ = s0tacon_make_some_some($1, $3, $6) ; }
; /* s0tacon */

ands0taconseq
  : /*(empty)*/ { $$ = s0taconlst_nil() ; }
  | AND s0tacon ands0taconseq { $$ = s0taconlst_cons($2, $3) ; }
; /* ands0taconseq */

s0tacst
  : si0de COLON s0rt { $$ = s0tacst_make_none($1, $3) ; }
  | si0de LPAREN d0atargseq RPAREN COLON s0rt { $$ = s0tacst_make_some($1, $3, $6) ; }
; /* s0tacst */

ands0tacstseq
  : /*(empty)*/ { $$ = s0tacstlst_nil() ; }
  | AND s0tacst ands0tacstseq { $$ = s0tacstlst_cons($2, $3) ; }
; /* ands0tacstseq */

s0tavar
  : si0de COLON s0rt { $$ = s0tavar_make($1, $3) ; }
; /* s0tavar */

ands0tavarseq
  : /*(empty)*/ { $$ = s0tavarlst_nil() ; }
  | AND s0tavar ands0tavarseq { $$ = s0tavarlst_cons($2, $3) ; }
; /* ands0tavarseq */

s0expdef
  : si0de s0argseqseq colons0rtopt EQ s0exp { $$ = s0expdef_make ($1, $2, $3, $5) ; }
; /* s0expdef */

ands0expdefseq
  : /*(empty)*/ { $$ = s0expdeflst_nil() ; }
  | AND s0expdef ands0expdefseq { $$ = s0expdeflst_cons($2, $3) ; }
; /* ands0expdefseq */

s0aspdec
  : sqi0de s0argseqseq colons0rtopt EQ s0exp { $$ = s0aspdec_make($1, $2, $3, $5) ; }
; /* s0aspdec */

conq0uaseq
  : /*(empty)*/ { $$ = s0qualstlst_nil() ; }
  | LBRACE s0quaseq RBRACE conq0uaseq { $$ = s0qualstlst_cons($2, $4) ; }
; /* conq0uaseq */

coni0ndopt
  : /*(empty)*/ { $$ = s0expopt_none() ; }
  | LPAREN s0expseq RPAREN { $$ = s0expopt_some(s0exp_list($1, $2, $3)) ; }
; /* coni0ndopt */

cona0rgopt
  : /*(empty)*/ { $$ = s0expopt_none() ; }
  | OF s0exp { $$ = s0expopt_some($2) ; }
; /* cona0rgopt */

d0atcon
  : conq0uaseq di0de coni0ndopt cona0rgopt { $$ = d0atcon_make($1, $2, $3, $4) ; }
; /* d0atcon */

d0atconseq
  : bard0atconseq { $$ = $1 ; }
  | d0atcon bard0atconseq { $$ = d0atconlst_cons($1, $2) ; }
; /* d0atconseq */

bard0atconseq
  : /*(empty)*/ { $$ = d0atconlst_nil() ; }
  | BAR d0atcon bard0atconseq { $$ = d0atconlst_cons($2, $3) ; }
; /* bard0atconseq */

d0atdec
  : si0de EQ d0atconseq { $$ = d0atdec_make_none($1, $3) ; }
  | si0de LPAREN d0atargseq RPAREN EQ d0atconseq { $$ = d0atdec_make_some($1, $3, $4, $6) ; }
; /* d0atdec */

andd0atdecseq
  : /*(empty)*/ { $$ = d0atdeclst_nil() ; }
  | AND d0atdec andd0atdecseq { $$ = d0atdeclst_cons($2, $3) ; }
; /* andd0atdecseq */

s0expdefseqopt
  : /*(empty)*/ { $$ = s0expdeflst_nil() ; }
  | WHERE s0expdef ands0expdefseq { $$ = s0expdeflst_cons($2, $3) ; }
; /* s0expdefseqopt */

e0xndec
  : conq0uaseq di0de cona0rgopt { $$ = e0xndec_make($1, $2, $3) ; }
; /* e0xndec */

ande0xndecseq
  : /*(empty)*/ { $$ = e0xndeclst_nil() ; }
  | AND e0xndec ande0xndecseq { $$ = e0xndeclst_cons($2, $3) ; }
; /* ande0xndecseq */

p0arg
  : pi0de { $$ = p0arg_make_none($1) ; }
  | pi0de COLON s0exp { $$ = p0arg_make_some($1, $3) ; }
; /* p0arg */

p0argseq
  : /*(empty)*/ { $$ = p0arglst_nil() ; }
  | p0arg commap0argseq { $$ = p0arglst_cons($1, $2) ; }
; /* p0argseq */

commap0argseq
  : /*(empty)*/ { $$ = p0arglst_nil() ; }
  | COMMA p0arg commap0argseq { $$ = p0arglst_cons($2, $3) ; }
; /* commap0argseq */

d0arg
  : pi0de { $$ = d0arg_var($1) ; }
  | LPAREN p0argseq RPAREN { $$ = d0arg_dyn($1, $2, $3) ; }
  | LPAREN p0argseq BAR p0argseq RPAREN { $$ = d0arg_dyn2($1, $2, $4, $5) ; }
  | LBRACE s0quaseq RBRACE { $$ = d0arg_sta($1, $2, $3) ; }
; /* d0arg */

d0argseq
  : /*(empty)*/ { $$ = d0arglst_nil() ; }
  | d0arg d0argseq { $$ = d0arglst_cons($1, $2) ; }
; /* d0argseq */

extnamopt
  : /*(empty)*/ { $$ = extnamopt_none() ; }
  | EQ LITERAL_string { $$ = extnamopt_some($2) ; }
; /* extnamopt */

d0cstdec
  : di0de d0argseq colonwith s0exp extnamopt { $$ = d0cstdec_make($1, $2, $3, $4, $5) ; }
; /* d0cstdec */

andd0cstdecseq
  : /*(empty)*/ { $$ = d0cstdeclst_nil() ; }
  | AND d0cstdec andd0cstdecseq { $$ = d0cstdeclst_cons($2, $3) ; }
; /* andd0cstdecseq */

s0vararg
  : DOTDOT { $$ = s0vararg_one() ; }
  | DOTDOTDOT { $$ = s0vararg_all() ; }
  | s0argseq { $$ = s0vararg_seq($1) ; }
; /* s0vararg */

s0exparg
  : DOTDOT { $$ = s0exparg_one() ; }
  | DOTDOTDOT { $$ = s0exparg_all() ; }
  | s0expseq1 { $$ = s0exparg_seq($1) ; }
; /* s0exparg */

s0elop
  : DOT { $$ = s0elop_make (0, $1) ; }
  | MINUSGT { $$ = s0elop_make (1, $1) ; }
; /* s0elop */

witht0ype
  : /*(empty)*/ { $$ = witht0ype_none() ; }
  | WITHPROP s0exp { $$ = witht0ype_prop($2) ; }
  | WITHTYPE s0exp { $$ = witht0ype_type($2) ; }
  | WITHVIEW s0exp { $$ = witht0ype_view($2) ; }
  | WITHVIEWTYPE s0exp { $$ = witht0ype_viewtype($2) ; }
; /* witht0ype */

p0at
  : atmp0at argp0atseq { $$ = p0at_apps($1, $2) ; }
  | p0at COLON s0exp { $$ = p0at_ann($1, $3) ; }
  | pi0de AS p0at { $$ = p0at_as($1, $3) ; } %prec PATAS
  | BANG pi0de AS p0at { $$ = p0at_refas($1, $2, $4) ; } %prec PATAS
  | TILDE p0at { $$ = p0at_free($1, $2) ; } %prec PATFREE
; /* p0at */

atmp0at
  : LITERAL_char { $$ = p0at_char($1) ; }
  | LITERAL_int { $$ = p0at_int($1) ; }
  | LITERAL_float { $$ = p0at_float($1) ; }
  | LITERAL_string { $$ = p0at_string($1) ; }
  | pi0de { $$ = p0at_ide($1) ; }
  | BANG pi0de { $$ = p0at_ref($1, $2) ; }
  | OP pi0de { $$ = p0at_opide($1, $2) ; }
  | d0ynq pi0de { $$ = p0at_qid($1, $2) ; }
  | LPAREN p0atseq RPAREN { $$ = p0at_list($1, $2, $3) ; }
  | LPAREN p0atseq BAR p0atseq RPAREN { $$ = p0at_list2($1, $2, $4, $5) ; }
  | QUOTELBRACKET p0atseq RBRACKET { $$ = p0at_lst($1, $2, $3) ; }
  | ATLPAREN p0atseq RPAREN { $$ = p0at_tup(0, $1, $2, $3) ; }
  | QUOTELPAREN p0atseq RPAREN { $$ = p0at_tup(1, $1, $2, $3) ; }
  | ATLPAREN p0atseq BAR p0atseq RPAREN { $$ = p0at_tup2(0, $1, $2, $4, $5) ; }
  | QUOTELPAREN p0atseq BAR p0atseq RPAREN { $$ = p0at_tup2(1, $1, $2, $4, $5) ; }
  | ATLBRACE labp0atseq RBRACE { $$ = p0at_rec(0, $1, $2, $3) ; }
  | QUOTELBRACE labp0atseq RBRACE { $$ = p0at_rec(1, $1, $2, $3) ; }
  | LBRACKET s0argseq RBRACKET { $$ = p0at_exist($1, $2, $3) ; }
; /* atmp0at */

argp0at
  : atmp0at { $$ = $1 ; }
  | LBRACE s0vararg RBRACE { $$ = p0at_svararg($1, $2, $3) ; }
; /* argp0at */

argp0atseq
  : /*(empty)*/ { $$ = p0atlst_nil() ; }
  | argp0at argp0atseq { $$ = p0atlst_cons($1, $2) ; }
; /* argp0atseq */

p0atseq
  : /*(empty)*/ { $$ = p0atlst_nil() ; }
  | p0at commap0atseq { $$ = p0atlst_cons($1, $2) ; }
; /* p0atseq */

commap0atseq
  : /*(empty)*/ { $$ = p0atlst_nil() ; }
  | COMMA p0at commap0atseq { $$ = p0atlst_cons($2, $3) ; }
; /* commap0atseq */

labp0atseq
  : DOTDOTDOT { $$ = labp0atlst_dot() ; }
  | l0ab EQ p0at commalabp0atseq { $$ = labp0atlst_cons($1, $3, $4) ; } 
; /* labp0atseq */

commalabp0atseq
  : /*(empty)*/ { $$ = labp0atlst_nil() ; }
  | COMMA DOTDOTDOT { $$ = labp0atlst_dot() ; }
  | COMMA l0ab EQ p0at commalabp0atseq { $$ = labp0atlst_cons($2, $4, $5) ; }
; /* commalabp0atseq */

f0arg1
  : LBRACE s0quaseq RBRACE { $$ = f0arg_sta1($1, $2, $3) ; }
  | atmp0at { $$ = f0arg_dyn($1) ; }
  | DOTLT s0expseq GTDOT { $$ = f0arg_met_some($1, $2, $3) ; }
  | DOTLTGTDOT { $$ = f0arg_met_none($1) ; }
; /* f0arg1 */

f0arg1seq
  : /*(empty)*/ { $$ = f0arglst_nil() ; }
  | f0arg1 f0arg1seq { $$ = f0arglst_cons($1, $2) ; }
; /* f0arg1seq */

f0arg2
  : LBRACE s0argseq RBRACE { $$ = f0arg_sta2($1, $2, $3) ; }
  | atmp0at { $$ = f0arg_dyn($1) ; }
; /* f0arg2 */

f0arg2seq
  : /*(empty)*/ { $$ = f0arglst_nil() ; }
  | f0arg2 f0arg2seq { $$ = f0arglst_cons($1, $2) ; }
; /* f0arg2seq */

d0exp
  : atmd0exp argd0expseq { $$ = d0exp_apps($1, $2) ; }
  | d0exp COLON s0exp { $$ = d0exp_ann($1, $3) ; }
  | ifhead d0exp THEN d0exp { $$ = d0exp_if_none($1, $2, $4) ; } %prec DEXPIF
  | ifhead d0exp THEN d0exp ELSE d0exp { $$ = d0exp_if_some($1, $2, $4, $6) ; } %prec DEXPIF
  | sifhead s0exp THEN d0exp ELSE d0exp { $$ = d0exp_sif($1, $2, $4, $6) ; } %prec DEXPIF
  | casehead d0exp OF c0lauseq { $$ = d0exp_caseof($1, $2, $3, $4) ; } %prec DEXPCASE
  | scasehead s0exp OF sc0lauseq { $$ = d0exp_scaseof($1, $2, $3, $4) ; } %prec DEXPCASE
  | lamkind f0arg1seq colons0expopt funarrow d0exp { $$ = d0exp_lam($1, $2, $3, $4, $5 ) ; } %prec DEXPLAM
  | fixkind di0de f0arg1seq colons0expopt funarrow d0exp { $$ = d0exp_fix($1, $2, $3, $4, $5, $6) ; } %prec DEXPLAM
  | forhead initestpost d0exp { $$ = d0exp_for_itp ($1, $2, $3) ; } %prec DEXPFOR
  | whilehead atmd0exp d0exp { $$ = d0exp_while ($1, $2, $3) ; } %prec DEXPWHILE
  | DLRRAISE d0exp { $$ = d0exp_raise($1, $2) ; } %prec DEXPRAISE
  | tryhead d0expsemiseq0 WITH c0lauseq { $$ = d0exp_trywith_seq($1, $2, $3, $4) ; } %prec DEXPTRY
  | d0exp WHERE LBRACE d0ecseq_dyn RBRACE { $$ = d0exp_where ($1, $4, $5) ; }
; /* d0exp */

atmd0exp
  : LITERAL_char { $$ = d0exp_char($1) ; }
  | LITERAL_float { $$ = d0exp_float($1) ; }
  | LITERAL_floatsp { $$ = d0exp_floatsp($1) ; }
  | LITERAL_int { $$ = d0exp_int($1) ; }
  | LITERAL_intsp { $$ = d0exp_intsp($1) ; }
  | LITERAL_string { $$ = d0exp_string($1) ; }
  | SRPFILENAME { $$ = d0exp_FILENAME($1) ; }
  | SRPLOCATION { $$ = d0exp_LOCATION($1) ; }
  | di0de { $$ = d0exp_ide($1) ; }
  | OP di0de { $$ = d0exp_opide($1, $2) ; }
  | d0ynq i0de { $$ = d0exp_qid($1, $2) ; }
  | i0dext { $$ = d0exp_idext($1) ; }
  | AMPERSAND { $$ = d0exp_ptrof($1) ; }
  | BREAK { $$ = d0exp_loopexn(0, $1) ; }
  | CONTINUE { $$ = d0exp_loopexn(1, $1) ; }
  | FOLDAT s0expdargseq { $$ = d0exp_foldat($1, $2) ; }
  | FREEAT s0expdargseq { $$ = d0exp_freeat($1, $2) ; }
  | VIEWAT { $$ = d0exp_viewat($1) ; }
  | DLRDECRYPT { $$ = d0exp_crypt (-1, $1) ; }
  | DLRENCRYPT { $$ = d0exp_crypt ( 1, $1) ; }
  | DLRDELAY { $$ = d0exp_delay(0, $1) ; }
  | DLRLDELAY { $$ = d0exp_delay(1, $1) ; }
  | DLRDYNLOAD { $$ = d0exp_dynload($1) ; }
  | DLREFFMASK_ALL { $$ = d0exp_effmask_all($1) ; }
  | DLREFFMASK_EXN { $$ = d0exp_effmask_exn($1) ; }
  | DLREFFMASK_NTM { $$ = d0exp_effmask_ntm($1) ; }
  | DLREFFMASK_REF { $$ = d0exp_effmask_ref($1) ; }
  | ATLBRACKET s0exp RBRACKET LPAREN d0expcommaseq RPAREN { $$ = d0exp_arrinit_none ($1, $2, $5, $6) ; }
  | ATLBRACKET s0exp RBRACKET LBRACKET d0exp RBRACKET LPAREN d0expcommaseq RPAREN { $$ = d0exp_arrinit_some ($1, $2, $5, $8, $9) ; }
  | DLRARRSZ s0expelt LPAREN d0expcommaseq RPAREN { $$ = d0exp_arrsize ($1, $2, $3, $4, $5) ; }
  | arrqi0de d0arrind { $$ = d0exp_arrsub ($1, $2) ; }
  | s0elop l0ab { $$ = d0exp_sel_lab ($1, $2) ; }
  | s0elop LBRACKET d0arrind { $$ = d0exp_sel_ind ($1, $3) ; }
  | tmpqi0de t1mps0expseq gtlt_t1mps0expseqseq GT { $$ = d0exp_tmpid ($1, $2, $3, $4) ; }
  | HASHLBRACKET s0exparg BAR d0exp RBRACKET { $$ = d0exp_exist ($1, $2, $3, $4, $5) ; }
  | LPAREN d0expcommaseq RPAREN { $$ = d0exp_list ($1, $2, $3) ; }
  | LPAREN d0expcommaseq BAR d0expcommaseq RPAREN { $$ = d0exp_list2 ($1, $2, $4, $5) ; }
  | DLRLST_T s0expelt LPAREN d0expcommaseq RPAREN { $$ = d0exp_lst (0, $1, $2, $3, $4, $5) ; }
  | DLRLST_VT s0expelt LPAREN d0expcommaseq RPAREN { $$ = d0exp_lst (1, $1, $2, $3, $4, $5) ; }
  | QUOTELBRACKET d0expcommaseq RBRACKET { $$ = d0exp_lst_quote ($1, $2, $3) ; }
  | BEGIN d0expsemiseq0 END { $$ = d0exp_seq ($1, $2, $3) ; }
  | LPAREN d0expsemiseq1 RPAREN { $$ = d0exp_seq ($1, $2, $3) ; }
  | ATLPAREN d0expcommaseq RPAREN { $$ = d0exp_tup (0, $1, $2, $3) ; }
  | QUOTELPAREN d0expcommaseq RPAREN { $$ = d0exp_tup (1, $1, $2, $3) ; }
  | DLRTUP_T LPAREN d0expcommaseq RPAREN { $$ = d0exp_tup (2, $1, $3, $4) ; }
  | DLRTUP_VT LPAREN d0expcommaseq RPAREN { $$ = d0exp_tup (3, $1, $3, $4) ; }
  | ATLPAREN d0expcommaseq BAR d0expcommaseq RPAREN { $$ = d0exp_tup2 (0, $1, $2, $4, $5) ; }
  | QUOTELPAREN d0expcommaseq BAR d0expcommaseq RPAREN { $$ = d0exp_tup2 (1, $1, $2, $4, $5) ; }
  | ATLBRACE labd0expseq RBRACE { $$ = d0exp_rec (0, $1, $2, $3) ; }
  | QUOTELBRACE labd0expseq RBRACE { $$ = d0exp_rec (1, $1, $2, $3) ; }
  | DLRREC_T LBRACE labd0expseq RBRACE { $$ = d0exp_rec (2, $1, $3, $4) ; }
  | DLRREC_VT LBRACE labd0expseq RBRACE { $$ = d0exp_rec (3, $1, $3, $4) ; }
  | DLREXTVAL LPAREN s0exp COMMA LITERAL_string RPAREN { $$ = d0exp_extval($1, $3, $5, $6) ; }
  | PERCENTLPAREN d0exp RPAREN { $$ = d0exp_macsyn_cross($1, $2, $3) ; }
  | COMMALPAREN d0exp RPAREN { $$ = d0exp_macsyn_decode($1, $2, $3) ; }
  | BACKQUOTELPAREN d0expsemiseq0 RPAREN { $$ = d0exp_macsyn_encode_seq($1, $2, $3) ; }
  | LET d0ecseq_dyn IN d0expsemiseq0 END { $$ = d0exp_let_seq($1, $2, $3, $4, $5) ; }
  | LBRACE d0ecseq_dyn RBRACE { $$ = d0exp_decseq($1, $2, $3) ; }
; /* atmd0exp */

s0expdarg
  : LBRACE s0exparg RBRACE { $$ = d0exp_sexparg($1, $2, $3) ; }
; /* s0expdarg */

s0expdargseq
  : /*(empty)*/ { $$ = d0explst_nil() ; } %prec SEXPDARGSEQEMPTY
  | s0expdarg s0expdargseq { $$ = d0explst_cons($1, $2) ;  }
; /* s0expdargseq */

argd0exp
  : atmd0exp { $$ = $1 ; }
  | s0expdarg { $$ = $1 ; }
; /* argd0exp */

argd0expseq
  : /*(empty)*/ { $$ = d0explst_nil() ; }
  | argd0exp argd0expseq { $$ = d0explst_cons($1, $2) ; }
; /* argd0expseq */

d0arrind
  : d0expcommaseq RBRACKET { $$ = d0arrind_make_sing($1, $2) ; }
  | d0expcommaseq RBRACKET LBRACKET d0arrind { $$ = d0arrind_make_cons($1, $4) ; }
; /* d0arrind */

colons0expopt
  : /*(empty)*/ { $$ = s0expopt_none() ; }
  | COLON s0exp { $$ = s0expopt_some($2) ; }
; /* colons0expopt */

funarrow
  : EQGT { $$ = e0fftaglstopt_none() ; }
  | EQLTGT { $$ = e0fftaglstopt_some(e0fftaglst_nil()) ; }
  | EQLT e0fftagseq GT { $$ = e0fftaglstopt_some($2) ; }
; /* funarrow */

caseinv
  : /*(empty)*/ { $$ = i0nvresstate_none() ; }
  | i0nvresstate EQGT { $$ = $1 ; }
; /* caseinv */

ifhead
  : IF caseinv { $$ = ifhead_make($1, $2) ; }
; /* ifhead */

sifhead
  : SIF caseinv { $$ = ifhead_make($1, $2) ; }
; /* sifhead */

casehead
  : CASE caseinv { $$ = casehead_make(0, $1, $2) ; }
  | CASEMINUS caseinv { $$ = casehead_make(-1, $1, $2) ; }
  | CASEPLUS caseinv { $$ = casehead_make(1, $1, $2) ; }
; /* casehead */

scasehead
  : SCASE caseinv { $$ = casehead_make(0, $1, $2) ; }
; /* scasehead */

forhead
  : FOR { $$ = loophead_make_none($1) ; }
  | FORSTAR loopi0nv EQGT { $$ = loophead_make_some($1, $2, $3) ; }
; /* forhead */

whilehead
  : WHILESTAR loopi0nv EQGT { $$ = loophead_make_some($1, $2, $3) ; }
; /* whilehead */

tryhead
  : TRY { $$ = tryhead_make($1) ; }
; /* tryhead */

d0expcommaseq
  : /*(empty)*/ { $$ = d0explst_nil() ; }
  | d0exp commad0expseq { $$ = d0explst_cons($1, $2) ; }
; /* d0expcommaseq */

commad0expseq
  : /*(empty)*/ { $$ = d0explst_nil() ; }
  | COMMA d0exp commad0expseq { $$ = d0explst_cons($2, $3) ; }
; /* commad0expseq */

d0expsemiseq0
  : /*(empty)*/ { $$ = d0explst_nil() ; }
  | d0exp { $$ = d0explst_sing($1) ; }
  | d0exp SEMICOLON d0expsemiseq0 { $$ = d0explst_cons($1, $3) ; }
; /* d0expsemiseq0 */

d0expsemiseq1
  : d0exp SEMICOLON d0expsemiseq0 { $$ = d0explst_cons($1, $3) ; }
; /* d0expsemiseq1 */

labd0expseq
  : /*(empty)*/ { $$ = labd0explst_nil() ; }
  | l0ab EQ d0exp commalabd0expseq { $$ = labd0explst_cons($1, $3, $4) ; }
; /* labd0expseq */

commalabd0expseq
  : /*(empty)*/ { $$ = labd0explst_nil() ; }
  | COMMA l0ab EQ d0exp commalabd0expseq { $$ = labd0explst_cons($2, $4, $5) ; }
; /* commalabd0expseq */

m0atch
  : d0exp { $$ = m0atch_make_none ($1) ; }
  | d0exp AS p0at { $$ = m0atch_make_some ($1, $3) ; }
; /* m0atch */

m0atchseq
  : m0atch andm0atchseq { $$ = m0atchlst_cons ($1, $2 ) ; }
; /* m0atchseq */

andm0atchseq
  : /*(empty)*/ { $$ = m0atchlst_nil () ; }
  | AND m0atch andm0atchseq { $$ = m0atchlst_cons ($2, $3 ) ; }
; /* andm0atchseq */

guap0at
  : p0at { $$ = guap0at_make_none($1) ; }
  | p0at WHEN m0atchseq { $$ = guap0at_make_some($1, $3) ; }
; /* guap0at */

c0lau
  : guap0at EQGT d0exp { $$ = c0lau_make ($1, 0, 0, $3) ; } %prec CLAUS
  | guap0at EQGTGT d0exp { $$ = c0lau_make ($1, 1, 0, $3) ; } %prec CLAUS
  | guap0at EQSLASHEQGT d0exp { $$ = c0lau_make ($1, 0, 1, $3) ; } %prec CLAUS
  | guap0at EQSLASHEQGTGT d0exp { $$ = c0lau_make ($1, 1, 1, $3) ; } %prec CLAUS
; /* c0lau */

c0lauseq
  : barc0lauseq { $$ = $1 ; }
  | c0lau barc0lauseq { $$ = c0laulst_cons($1, $2) ; }
; /* c0lauseq */

barc0lauseq
  : /*(empty)*/ { $$ = c0laulst_nil() ; }  %prec BARCLAUSSEQNONE
  | BAR c0lau barc0lauseq { $$ = c0laulst_cons($2, $3) ; }
; /* barc0lauseq */

sc0lau
  : sp0at EQGT d0exp { $$ = sc0lau_make($1, $3) ; } %prec CLAUS
; /* sc0lau */

sc0lauseq
  : barsc0lauseq { $$ = $1 ; }
  | sc0lau barsc0lauseq { $$ = sc0laulst_cons($1, $2) ; }
; /* sc0lauseq */

barsc0lauseq
  : /*(empty)*/ { $$ = sc0laulst_nil() ; }  %prec BARCLAUSSEQNONE
  | BAR sc0lau barsc0lauseq { $$ = sc0laulst_cons($2, $3) ; }
; /* barsc0lauseq */

i0nvqua
  : /*(empty)*/ { $$ = s0qualstopt_none() ; }
  | LBRACE s0quaseq RBRACE { $$ = s0qualstopt_some($2) ; }
; /* i0nvqua */

i0nvmet
  : /*(empty)*/ { $$ = s0explstopt_none() ; }
  | DOTLT s0expseq GTDOT { $$ = s0explstopt_some($2) ; }
  | DOTLTGTDOT { $$ = s0explstopt_some(s0explst_nil()) ; }
; /* i0nvmet */

i0nvarg
  : di0de COLON { $$ = i0nvarg_make_none($1) ; }
  | di0de COLON s0exp { $$ = i0nvarg_make_some($1, $3) ; }
; /* i0nvarg */

i0nvargseq
  : /*(empty)*/ { $$ = i0nvarglst_nil() ; }
  | i0nvarg commai0nvargseq { $$ = i0nvarglst_cons($1, $2) ; }
; /* i0nvargseq */

commai0nvargseq
  : /*(empty)*/ { $$ = i0nvarglst_nil() ; }
  | COMMA i0nvarg commai0nvargseq { $$ = i0nvarglst_cons($2, $3) ; }
; /* commai0nvargseq */

i0nvargstate
  : LPAREN i0nvargseq RPAREN { $$ = $2 ; }
; /* i0nvargstate */

i0nvresqua
  : /*(empty)*/ { $$ = s0qualstopt_none() ; }
  | LBRACKET s0quaseq RBRACKET { $$ = s0qualstopt_some($2) ; }
; /* i0nvresqua */

i0nvresstate
  : /*(empty)*/ { $$ = i0nvresstate_none() ; }
  | COLON i0nvresqua LPAREN i0nvargseq RPAREN { $$ = i0nvresstate_some($2, $4) ; }
; /* i0nvresstate */

loopi0nv
  : i0nvqua i0nvmet i0nvargstate i0nvresstate { $$ = loopi0nv_make($1, $2, $3, $4) ; }
; /* loopi0nv */

initestpost
  : LPAREN d0expcommaseq SEMICOLON d0expcommaseq SEMICOLON d0expcommaseq RPAREN { $$ = initestpost_make ($1,$2,$3,$4,$5,$6,$7) ; }
; /* initestpost */

m0arg
  : pi0de { $$ = $1 ; }
; /* m0arg */

m0argseq
  : /*(empty)*/ { $$ = i0delst_nil() ; }
  | m0arg commam0argseq { $$ = i0delst_cons($1, $2) ; }
; /* m0argseq */

commam0argseq
  : /*(empty)*/ { $$ = i0delst_nil() ; }
  | COMMA m0arg commam0argseq { $$ = i0delst_cons($2, $3) ; }
; /* commam0argseq */

m0acarg
  : m0arg { $$ = m0acarg_one ($1) ; }
  | LPAREN m0argseq RPAREN { $$ = m0acarg_lst ($1, $2, $3) ; }
; /* m0acarg */

m0acargseq
  : /*(empty)*/ { $$ = m0acarglst_nil () ; }
  | m0acarg m0acargseq { $$ = m0acarglst_cons ($1, $2) ; }
; /* m0acargseq */

m0acdef
  : di0de m0acargseq EQ d0exp { $$ = m0acdef_make($1, $2, $4) ; }
; /* m0acdef */

andm0acdefseq
  : /*(empty)*/ { $$ = m0acdeflst_nil() ; }
  | AND m0acdef andm0acdefseq { $$ = m0acdeflst_cons($2, $3) ; }
; /* andm0acdefseq */

v0aldec
  : p0at EQ d0exp witht0ype { $$ = v0aldec_make ($1, $3, $4) ; }
; /* v0aldec */

andv0aldecseq
  : /*(empty)*/ { $$ = v0aldeclst_nil() ; }
  | AND v0aldec andv0aldecseq { $$ = v0aldeclst_cons($2, $3) ; }
; /* andv0aldecseq */

f0undec
  : fi0de f0arg1seq EQ d0exp witht0ype { $$ = f0undec_make_none($1, $2, $4, $5) ; }
  | fi0de f0arg1seq colonwith s0exp EQ d0exp witht0ype { $$ = f0undec_make_some($1, $2, $3, $4, $6, $7) ; }
; /* f0undec */

andf0undecseq
  : /*(empty)*/ { $$ = f0undeclst_nil() ; }
  | AND f0undec andf0undecseq { $$ = f0undeclst_cons($2, $3) ; }
; /* andf0undecseq */

v0arwth
  : /*(empty)*/ { $$ = v0arwth_none () ; }
  | WITH pi0de { $$ = v0arwth_some ($2) ; }
; /* v0arwth */

v0ardec
  : pi0de v0arwth EQ d0exp { $$ = v0ardec_make_none_some(0, $1, $2, $4) ; }
  | BANG pi0de v0arwth EQ d0exp { $$ = v0ardec_make_none_some(1, $2, $3, $5) ; }
  | pi0de COLON s0exp v0arwth { $$ = v0ardec_make_some_none(0, $1, $3, $4) ; }
  | pi0de COLON s0exp v0arwth EQ d0exp { $$ = v0ardec_make_some_some(0, $1, $3, $4, $6) ; }
; /* v0ardec */

andv0ardecseq
  : /*(empty)*/ { $$ = v0ardeclst_nil() ; }
  | AND v0ardec andv0ardecseq { $$ = v0ardeclst_cons($2, $3) ; }
; /* andv0ardecseq */

i0mpdec
  : impqi0de f0arg2seq colons0expopt EQ d0exp { $$ = i0mpdec_make($1, $2, $3, $5) ; }
; /* i0mpdec */

d0ec
  : INFIX p0rec i0deseq { $$ = d0ec_infix($1, $2,  0, $3) ; }
  | INFIXL p0rec i0deseq { $$ = d0ec_infix($1, $2, -1, $3) ; }
  | INFIXR p0rec i0deseq { $$ = d0ec_infix($1, $2,  1, $3) ; }
  | PREFIX p0rec i0deseq { $$ = d0ec_prefix($1, $2, $3) ; }
  | POSTFIX p0rec i0deseq { $$ = d0ec_postfix($1, $2, $3) ; }
  | NONFIX i0deseq { $$ = d0ec_nonfix($1, $2) ; }
  | SYMINTR i0deseq { $$ = d0ec_symintr($1, $2) ; }
  | SRPUNDEF i0de { $$ = d0ec_e0xpundef($2) ; }
  | SRPDEFINE i0de e0xpopt { $$ = d0ec_e0xpdef($2, $3) ; }
  | SRPASSERT e0xp { $$ = d0ec_e0xpact_assert($2) ; }
  | SRPERROR e0xp { $$ = d0ec_e0xpact_error($2) ; }
  | SRPPRINT e0xp { $$ = d0ec_e0xpact_print($2) ; }
  | SORTDEF s0rtdef ands0rtdefseq { $$ = d0ec_srtdefs($2, $3) ; }
  | DATASORT d0atsrtdec andd0atsrtdecseq { $$ = d0ec_datsrts(0, $2, $3) ; }
  | DATAPARASORT d0atsrtdec andd0atsrtdecseq { $$ = d0ec_datsrts(1, $2, $3) ; }
  | abskind s0tacon ands0taconseq { $$ = d0ec_stacons($1, $2, $3) ; }
  | STACST s0tacst ands0tacstseq { $$ = d0ec_stacsts($2, $3) ; }
  | STAVAR s0tavar ands0tavarseq { $$ = d0ec_stavars($2, $3) ; }
  | stadefkind s0expdef ands0expdefseq { $$ = d0ec_sexpdefs($1, $2, $3) ; }
  | ASSUME s0aspdec { $$ = d0ec_saspdec($2) ; }
  | datakind d0atdec andd0atdecseq s0expdefseqopt { $$ = d0ec_datdecs($1, $2, $3, $4) ; }
  | EXCEPTION e0xndec ande0xndecseq { $$ = d0ec_exndecs($1, $2, $3) ; } 
  | CLASSDEC si0de { $$ = d0ec_classdec_none ($1, $2) ; }
  | CLASSDEC si0de COLON s0exp { $$ = d0ec_classdec_some ($1, $2, $4) ; }
  | OVERLOAD di0de WITH dqi0de { $$ = d0ec_overload($1, $2, $4) ; }
  | OVERLOAD LBRACKET RBRACKET WITH dqi0de { $$ = d0ec_overload_lrbrackets($1, $2, $3, $5) ; }
  | MACDEF m0acdef andm0acdefseq { $$ = d0ec_macdefs(0, $2, $3) ; }
  | MACDEF REC m0acdef andm0acdefseq { $$ = d0ec_macdefs(-1/*error*/, $3, $4) ; }
  | MACRODEF m0acdef andm0acdefseq { $$ = d0ec_macdefs(1, $2, $3) ; }
  | MACRODEF REC m0acdef andm0acdefseq { $$ = d0ec_macdefs(2, $3, $4) ; }
  | STALOAD LITERAL_string { $$ = d0ec_staload_none($2) ; }
  | STALOAD stai0de EQ LITERAL_string { $$ = d0ec_staload_some($2, $4) ; }
; /* d0ec */

d0ecarg
  : LBRACE s0quaseq RBRACE { $$ = $2 ; }
; /* d0ecarg */

d0ecargseq
  : /*(empty)*/ { $$ = s0qualstlst_nil() ; }
  | d0ecarg d0ecargseq { $$ = s0qualstlst_cons($1, $2) ; }
; /* d0ecargseq */

semicolonseq
  : /*(empty)*/ { ; }
  | semicolonseq SEMICOLON { ; }
; /* semicolonseq */

d0ec_sta
  : d0ec { $$ = $1 ; }
  | dcstkind d0ecargseq d0cstdec andd0cstdecseq { $$ = d0ec_dcstdecs($1, $2, $3, $4) ; }
  | LITERAL_extcode { $$ = d0ec_extcode_sta($1) ; }
  | srpifkind guad0ec_sta { $$ = d0ec_guadec($1, $2) ; }
  | SRPINCLUDE LITERAL_string { $$ = d0ec_include(0/*sta*/, $2) ; }
  | LOCAL d0ecseq_sta IN d0ecseq_sta END { $$ = d0ec_local($1, $2, $4, $5) ; }
; /* d0ec_sta */

guad0ec_sta
  : e0xp srpthenopt d0ecseq_sta SRPENDIF { $$ = guad0ec_one($1, $3, $4) ; }
  | e0xp srpthenopt d0ecseq_sta SRPELSE d0ecseq_sta SRPENDIF { $$ = guad0ec_two($1, $3, $5, $6) ; }
  | e0xp srpthenopt d0ecseq_sta srpelifkind guad0ec_sta { $$ = guad0ec_cons($1, $3, $4, $5) ; }
; /* guad0ec_sta */

d0ecseq_sta
  : d0ecseq_sta_rev { $$ = d0ecllst_reverse($1) ; }
; /* d0ecseq_sta */

d0ecseq_sta_rev
  : /*(empty)*/ { $$ = d0ecllst_nil() ; }
  | d0ecseq_sta_rev d0ec_sta semicolonseq { $$ = d0ecllst_cons($1, $2) ; }
; /* d0ecseq_sta_rev */

d0ec_dyn
  : d0ec { $$ = $1 ; }
  | EXTERN dcstkind d0ecargseq d0cstdec andd0cstdecseq { $$ = d0ec_dcstdecs($2, $3, $4, $5) ; }
  | EXTERN TYPEDEF LITERAL_string EQ s0exp { $$ = d0ec_extype($3, $5) ; }  
  | EXTERN VAL LITERAL_string EQ d0exp { $$ = d0ec_extval($3, $5) ; }
  | valkind v0aldec andv0aldecseq { $$ = d0ec_valdecs($1, $2, $3) ; }
  | VAL PAR v0aldec andv0aldecseq { $$ = d0ec_valdecs_par($3, $4) ; }
  | VAL REC v0aldec andv0aldecseq { $$ = d0ec_valdecs_rec($3, $4) ; }
  | funkind d0ecargseq f0undec andf0undecseq { $$ = d0ec_fundecs($1, $2, $3, $4) ; }
  | VAR v0ardec andv0ardecseq { $$ = d0ec_vardecs($2, $3) ; }
  | IMPLEMENT decs0argseqseq i0mpdec { $$ = d0ec_impdec($1, $2, $3) ; }
  | LOCAL d0ecseq_dyn IN d0ecseq_dyn END { $$ = d0ec_local($1, $2, $4, $5) ; }
  | LITERAL_extcode { $$ = d0ec_extcode_dyn($1) ; }
  | srpifkind guad0ec_dyn { $$ = d0ec_guadec($1, $2) ; }
  | SRPINCLUDE LITERAL_string { $$ = d0ec_include(1/*dyn*/, $2) ; }
  | DYNLOAD LITERAL_string { $$ = d0ec_dynload($2) ; }
; /* d0ec_dyn */

guad0ec_dyn
  : e0xp srpthenopt d0ecseq_dyn SRPENDIF { $$ = guad0ec_one($1, $3, $4) ; }
  | e0xp srpthenopt d0ecseq_dyn SRPELSE d0ecseq_dyn SRPENDIF { $$ = guad0ec_two($1, $3, $5, $6) ; }
  | e0xp srpthenopt d0ecseq_dyn srpelifkind guad0ec_dyn { $$ = guad0ec_cons($1, $3, $4, $5) ; }
; /* guad0ec_dyn */

d0ecseq_dyn
  : d0ecseq_dyn_rev { $$ = d0ecllst_reverse($1) ; }
; /* d0ecseq_dyn */

d0ecseq_dyn_rev
  : /*(empty)*/ { $$ = d0ecllst_nil() ; }
  | d0ecseq_dyn_rev d0ec_dyn semicolonseq { $$ = d0ecllst_cons($1, $2) ; }
; /* d0ecseq_dyn_rev */

/* ****** ****** */

/* end of [ats_grammar.yats] */