el-parser.grm.sml

functor LrValsFn(structure Token : TOKEN) = 
struct
structure ParserData=
struct
structure Header = 
struct
(*                                                                              *)
(* MixML prototype implementation                                               *)
(*                                                                              *)
(* Based on: Derek Dreyer, Andreas Rossberg, "Mixin' Up the ML Module System"   *)
(*                                                                              *)
(* (c) 2007-2008 Andreas Rossberg                                               *)
(*                                                                              *)

open EL
open ELOps
open VarOps infix ++ |->

fun region(l, r) = {l = l, r = r}
fun $l r f x = {it = f x, region = region(l, r)}
fun $$l r x  = {it = x, region = region(l, r)}

fun struc l r decs = struc' l r (map[]) decs
and struc' l r gam =
    fn [] => $$l r EmptyM
     | [dec] => struc'' gam dec
     | (dec as (x, _))::decs =>
        let
            val self = rename "_self"
            val modl' = struc' l r (gam ++ map[x |-> (self, [x])]) decs
        in
            $l (#r(#region modl')) LinkM(self, struc'' gam dec, modl')
        end
and struc'' gam (id, modl) =
    $(#l(#region modl)) (#r(#region modl)) StructM(id, substM gam modl)

fun fct l r x modl1 modl2 =
    let
        val {l=l1, r=r1} = #region modl1
        val {l=l2, r=r2} = #region modl2
    in
        $l r UnitM($l r LinkM(x, $l1 r1 StructM("_Arg", modl1),
                                 $l2 r2 StructM("_Res", substM (map[x |-> (x, ["_Arg"])]) modl2)))
    end
fun app l r modl1 modl2 =
    let
        val {l=l1, r=r1} = #region modl1
        val {l=l2, r=r2} = #region modl2
    in
        $l r DotM($l r LinkM(rename "_app", $l2 r2 StructM("_Arg", modl2),
                                            $l1 r1 NewM(modl1)), "_Res")
    end

fun lete l r (decs, exp) = List.foldr (fn((x, modl), exp) => $l r LetE(x, modl, exp)) exp decs

fun nested l (x, []) modl = (x, modl)
  | nested l (x, x'::ls) modl = (x, $l (#r(#region modl)) StructM(nested l (x', ls) modl))

fun pathM l r (x, xs) = pathM' l r ($l r VarM(x), xs)
and pathM' l r (p, []) = p
  | pathM' l r (p, x::xs) = pathM' l r ($l r DotM(p, x), xs)

fun boolE l r i = $l r InjE($l r TupleE[], i, $l r VariantT[$l r TupleT[], $l r TupleT[]])

fun lambdaE params exp =
    List.foldr (fn((l, x, typ), exp) => $l (#r(#region exp)) LambdaE(x, typ, exp)) exp params
fun arrowT params typ =
    List.foldr (fn((l, x, typ), typ') => $l (#r(#region typ')) ArrowT(typ, typ')) typ params
fun genE NONE exp = exp
  | genE (SOME(l, typvars)) exp = $l (#r(#region exp)) GenE(typvars, exp)
fun univT NONE typ = typ
  | univT (SOME(l, typvars)) typ = $l (#r(#region typ)) UnivT(typvars, typ)
fun lambdaT NONE typ = typ
  | lambdaT (SOME(l, typvars)) typ = $l (#r(#region typ)) LambdaT(typvars, typ)
fun arrowK NONE kind = kind
  | arrowK (SOME(l, typvars)) kind =
    if #it kind = StarK then $l (#r(#region kind)) ArrowK(List.length typvars)
    else raise EL.Error(#region kind, "ground kind required")

fun kinds stat {it, region} = {it = kinds' stat it, region = region}
and kinds' stat (VarM(x)) = VarM(x)
  | kinds' stat (EmptyM) = EmptyM
  | kinds' stat (ValM(exp)) = EmptyM
  | kinds' stat (AbsValM(typ)) = EmptyM
  | kinds' stat (TypM(typ)) = EmptyM
  | kinds' stat (AbsTypM(kind)) = AbsTypM(kind)
  | kinds' stat (DatTypM(typ)) = EmptyM
  | kinds' stat (AbsDatTypM(typ)) = EmptyM
  | kinds' stat (UnitM(modl)) = EmptyM
  | kinds' stat (AbsUnitM(sign)) = NewM(kindsS sign)
  | kinds' stat (NewM(modl)) = if stat then NewM(kinds stat modl) else EmptyM
  | kinds' stat (StructM(l, modl)) = StructM(l, kinds stat modl)
  | kinds' stat (DotM(modl, l)) = DotM(kinds stat modl, l)
  | kinds' stat (LinkM(x, modl1, modl2)) = LinkM(x, kinds stat modl1, kinds stat modl2)
  | kinds' stat (OLinkM(x, modl1, modl2)) = #it(kinds stat modl1)
  | kinds' stat (SealM(modl, sign)) = #it(kindsS sign)
and kindsS{it, region} = kindsS' it
and kindsS'(ImportS(modl, lss)) = kinds true modl
  | kindsS'(ExportS(modl, lss)) = kinds true modl

fun types stat {it, region} = {it = types' stat it, region = region}
and types' stat (VarM(x)) = VarM(x)
  | types' stat (EmptyM) = EmptyM
  | types' stat (ValM(exp)) = EmptyM
  | types' stat (AbsValM(typ)) = AbsValM(typ)
  | types' stat (TypM(typ)) = TypM(typ)
  | types' stat (AbsTypM(kind)) = AbsTypM(kind)
  | types' stat (DatTypM(typ)) = DatTypM(typ)
  | types' stat (AbsDatTypM(typ)) = AbsDatTypM(typ)
  | types' stat (UnitM(modl)) = EmptyM
  | types' stat (AbsUnitM(sign)) = NewM(typesS sign)
  | types' stat (NewM(modl)) = if stat then NewM(types stat modl) else EmptyM
  | types' stat (StructM(l, modl)) = StructM(l, types stat modl)
  | types' stat (DotM(modl, l)) = DotM(types stat modl, l)
  | types' stat (LinkM(x, modl1, modl2)) = LinkM(x, types stat modl1, types stat modl2)
  | types' stat (OLinkM(x, modl1, modl2)) = #it(types stat modl1)
  | types' stat (SealM(modl, sign)) = #it(typesS sign)
and typesS{it, region} = typesS' it
and typesS'(ImportS(modl, lss)) = types true modl
  | typesS'(ExportS(modl, lss)) = types true modl

fun recm l r x modl =
    $l r LinkM(x, kinds false modl, $l r LinkM(x, types false modl, modl))

end
structure LrTable = Token.LrTable
structure Token = Token
local open LrTable in 
val table=let val actionRows =
"\
\\001\000\001\000\000\000\000\000\
\\001\000\002\000\040\000\018\000\039\000\029\000\038\000\030\000\037\000\
\\031\000\036\000\000\000\
\\001\000\004\000\069\001\000\000\
\\001\000\007\000\026\000\016\000\025\000\017\000\024\000\019\000\022\000\
\\026\000\021\000\034\000\017\000\036\000\016\000\038\000\015\000\
\\040\000\014\000\043\000\090\000\060\000\012\000\061\000\011\000\
\\062\000\010\000\000\000\
\\001\000\007\000\026\000\016\000\025\000\017\000\024\000\019\000\022\000\
\\026\000\021\000\034\000\017\000\036\000\016\000\038\000\015\000\
\\040\000\014\000\043\000\106\000\060\000\012\000\061\000\011\000\
\\062\000\010\000\000\000\
\\001\000\007\000\026\000\016\000\025\000\017\000\024\000\019\000\022\000\
\\026\000\021\000\034\000\017\000\036\000\016\000\038\000\015\000\
\\040\000\014\000\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\001\000\007\000\075\000\009\000\074\000\011\000\073\000\015\000\072\000\
\\016\000\071\000\022\000\070\000\023\000\069\000\024\000\068\000\
\\025\000\067\000\034\000\066\000\035\000\065\000\036\000\064\000\
\\043\000\088\000\053\000\063\000\054\000\062\000\058\000\061\000\
\\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\001\000\007\000\075\000\009\000\074\000\011\000\073\000\015\000\072\000\
\\016\000\071\000\022\000\070\000\023\000\069\000\024\000\068\000\
\\025\000\067\000\034\000\066\000\035\000\065\000\036\000\064\000\
\\053\000\063\000\054\000\062\000\058\000\061\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\000\000\
\\001\000\007\000\104\000\012\000\103\000\013\000\102\000\014\000\101\000\
\\034\000\100\000\036\000\099\000\039\000\098\000\043\000\097\000\
\\060\000\012\000\061\000\011\000\062\000\010\000\069\000\096\000\000\000\
\\001\000\007\000\104\000\012\000\103\000\013\000\102\000\014\000\101\000\
\\034\000\100\000\036\000\099\000\043\000\108\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\069\000\096\000\000\000\
\\001\000\007\000\104\000\012\000\103\000\013\000\102\000\014\000\101\000\
\\034\000\100\000\036\000\099\000\051\000\165\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\069\000\096\000\000\000\
\\001\000\007\000\104\000\012\000\103\000\013\000\102\000\014\000\101\000\
\\034\000\100\000\036\000\099\000\060\000\012\000\061\000\011\000\
\\062\000\010\000\069\000\096\000\000\000\
\\001\000\011\000\073\000\022\000\070\000\023\000\069\000\024\000\068\000\
\\025\000\067\000\034\000\066\000\035\000\065\000\036\000\064\000\
\\053\000\063\000\054\000\062\000\058\000\061\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\000\000\
\\001\000\011\000\116\000\000\000\
\\001\000\011\000\121\000\000\000\
\\001\000\011\000\214\000\000\000\
\\001\000\011\000\006\001\000\000\
\\001\000\011\000\007\001\052\000\031\000\000\000\
\\001\000\011\000\008\001\052\000\031\000\000\000\
\\001\000\011\000\066\001\000\000\
\\001\000\012\000\103\000\013\000\102\000\014\000\101\000\034\000\100\000\
\\036\000\099\000\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\001\000\019\000\022\000\034\000\017\000\036\000\016\000\038\000\015\000\
\\040\000\014\000\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\001\000\019\000\022\000\034\000\017\000\036\000\082\000\038\000\015\000\
\\040\000\014\000\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\001\000\020\000\216\000\000\000\
\\001\000\023\000\069\000\024\000\068\000\034\000\066\000\036\000\064\000\
\\053\000\063\000\054\000\062\000\058\000\061\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\000\000\
\\001\000\028\000\218\000\000\000\
\\001\000\033\000\003\001\052\000\031\000\070\000\002\001\000\000\
\\001\000\033\000\005\001\052\000\031\000\070\000\004\001\000\000\
\\001\000\036\000\016\000\038\000\015\000\040\000\014\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\000\000\
\\001\000\036\000\016\000\038\000\213\000\040\000\014\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\000\000\
\\001\000\036\000\016\000\038\000\217\000\040\000\014\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\000\000\
\\001\000\036\000\223\000\000\000\
\\001\000\036\000\224\000\000\000\
\\001\000\036\000\031\001\000\000\
\\001\000\036\000\032\001\000\000\
\\001\000\037\000\109\000\000\000\
\\001\000\037\000\209\000\000\000\
\\001\000\037\000\238\000\000\000\
\\001\000\037\000\239\000\000\000\
\\001\000\037\000\063\001\000\000\
\\001\000\037\000\074\001\000\000\
\\001\000\037\000\076\001\000\000\
\\001\000\037\000\099\001\000\000\
\\001\000\037\000\100\001\000\000\
\\001\000\037\000\105\001\000\000\
\\001\000\037\000\107\001\000\000\
\\001\000\037\000\108\001\000\000\
\\001\000\038\000\148\000\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\001\000\038\000\162\000\050\000\070\001\000\000\
\\001\000\038\000\163\000\000\000\
\\001\000\038\000\171\000\000\000\
\\001\000\038\000\212\000\000\000\
\\001\000\038\000\010\001\000\000\
\\001\000\039\000\154\000\043\000\153\000\000\000\
\\001\000\039\000\157\000\043\000\156\000\000\000\
\\001\000\039\000\160\000\043\000\159\000\000\000\
\\001\000\039\000\173\000\043\000\172\000\000\000\
\\001\000\039\000\176\000\043\000\175\000\000\000\
\\001\000\039\000\228\000\000\000\
\\001\000\039\000\230\000\000\000\
\\001\000\039\000\235\000\000\000\
\\001\000\039\000\244\000\000\000\
\\001\000\039\000\247\000\043\000\246\000\000\000\
\\001\000\039\000\251\000\000\000\
\\001\000\039\000\009\001\000\000\
\\001\000\039\000\023\001\000\000\
\\001\000\039\000\033\001\000\000\
\\001\000\039\000\034\001\000\000\
\\001\000\039\000\035\001\000\000\
\\001\000\039\000\036\001\000\000\
\\001\000\039\000\037\001\000\000\
\\001\000\039\000\043\001\000\000\
\\001\000\039\000\044\001\000\000\
\\001\000\039\000\045\001\000\000\
\\001\000\039\000\064\001\000\000\
\\001\000\039\000\065\001\000\000\
\\001\000\039\000\068\001\000\000\
\\001\000\039\000\083\001\000\000\
\\001\000\039\000\087\001\000\000\
\\001\000\041\000\086\000\000\000\
\\001\000\043\000\114\000\048\000\113\000\000\000\
\\001\000\043\000\118\000\048\000\117\000\000\000\
\\001\000\043\000\120\000\048\000\119\000\000\000\
\\001\000\043\000\124\000\048\000\123\000\000\000\
\\001\000\043\000\219\000\000\000\
\\001\000\043\000\222\000\048\000\221\000\000\000\
\\001\000\043\000\249\000\048\000\248\000\000\000\
\\001\000\043\000\049\001\000\000\
\\001\000\043\000\073\001\048\000\072\001\000\000\
\\001\000\048\000\122\000\000\000\
\\001\000\048\000\215\000\000\000\
\\001\000\050\000\038\001\000\000\
\\001\000\050\000\067\001\000\000\
\\001\000\050\000\071\001\000\000\
\\001\000\050\000\079\001\000\000\
\\001\000\050\000\082\001\000\000\
\\001\000\051\000\165\000\000\000\
\\001\000\051\000\039\001\000\000\
\\001\000\051\000\080\001\000\000\
\\001\000\053\000\138\000\000\000\
\\001\000\053\000\205\000\000\000\
\\001\000\053\000\208\000\000\000\
\\001\000\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\112\001\000\000\
\\113\001\000\000\
\\114\001\000\000\
\\115\001\000\000\
\\116\001\000\000\
\\117\001\000\000\
\\118\001\000\000\
\\119\001\000\000\
\\120\001\000\000\
\\121\001\068\000\253\000\000\000\
\\122\001\000\000\
\\123\001\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\124\001\000\000\
\\125\001\042\000\075\001\000\000\
\\126\001\000\000\
\\127\001\068\000\112\000\000\000\
\\128\001\000\000\
\\129\001\000\000\
\\130\001\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\131\001\000\000\
\\132\001\042\000\252\000\000\000\
\\133\001\000\000\
\\134\001\000\000\
\\135\001\000\000\
\\136\001\000\000\
\\137\001\000\000\
\\138\001\000\000\
\\139\001\000\000\
\\140\001\000\000\
\\141\001\000\000\
\\142\001\000\000\
\\143\001\000\000\
\\144\001\000\000\
\\145\001\000\000\
\\146\001\000\000\
\\147\001\000\000\
\\148\001\000\000\
\\149\001\000\000\
\\150\001\000\000\
\\151\001\000\000\
\\152\001\000\000\
\\153\001\000\000\
\\154\001\000\000\
\\155\001\068\000\034\000\000\000\
\\156\001\068\000\034\000\000\000\
\\157\001\068\000\034\000\000\000\
\\158\001\068\000\034\000\000\000\
\\159\001\006\000\226\000\010\000\225\000\036\000\016\000\038\000\015\000\
\\040\000\014\000\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\159\001\036\000\016\000\038\000\015\000\040\000\014\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\000\000\
\\160\001\000\000\
\\161\001\033\000\032\000\052\000\031\000\070\000\030\000\000\000\
\\162\001\000\000\
\\163\001\000\000\
\\164\001\000\000\
\\165\001\000\000\
\\166\001\000\000\
\\167\001\000\000\
\\168\001\000\000\
\\169\001\000\000\
\\170\001\000\000\
\\171\001\000\000\
\\172\001\000\000\
\\173\001\002\000\028\000\003\000\027\000\007\000\026\000\016\000\025\000\
\\017\000\024\000\018\000\023\000\019\000\022\000\026\000\021\000\
\\029\000\020\000\030\000\019\000\031\000\018\000\034\000\017\000\
\\036\000\016\000\038\000\015\000\040\000\014\000\042\000\013\000\
\\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\173\001\002\000\028\000\003\000\027\000\018\000\023\000\029\000\020\000\
\\030\000\019\000\031\000\018\000\042\000\013\000\000\000\
\\173\001\002\000\028\000\003\000\027\000\018\000\023\000\029\000\020\000\
\\030\000\019\000\031\000\018\000\042\000\013\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\000\000\
\\174\001\000\000\
\\175\001\000\000\
\\176\001\048\000\001\001\000\000\
\\177\001\000\000\
\\178\001\000\000\
\\179\001\048\000\084\001\000\000\
\\180\001\000\000\
\\181\001\048\000\053\001\000\000\
\\182\001\000\000\
\\183\001\000\000\
\\184\001\000\000\
\\185\001\048\000\254\000\000\000\
\\186\001\000\000\
\\187\001\000\000\
\\188\001\000\000\
\\189\001\043\000\189\000\048\000\188\000\000\000\
\\190\001\000\000\
\\191\001\000\000\
\\192\001\000\000\
\\193\001\000\000\
\\194\001\036\000\179\000\000\000\
\\195\001\000\000\
\\196\001\038\000\111\000\000\000\
\\197\001\000\000\
\\198\001\000\000\
\\199\001\000\000\
\\200\001\000\000\
\\201\001\000\000\
\\202\001\000\000\
\\203\001\000\000\
\\204\001\006\000\151\000\010\000\150\000\036\000\016\000\038\000\015\000\
\\040\000\014\000\060\000\012\000\061\000\011\000\062\000\010\000\000\000\
\\205\001\050\000\237\000\053\000\236\000\000\000\
\\206\001\000\000\
\\207\001\000\000\
\\208\001\000\000\
\\209\001\000\000\
\\210\001\000\000\
\\211\001\000\000\
\\212\001\068\000\034\000\000\000\
\\213\001\000\000\
\\214\001\000\000\
\\215\001\000\000\
\\216\001\000\000\
\\217\001\038\000\162\000\050\000\161\000\000\000\
\\218\001\000\000\
\\219\001\000\000\
\\220\001\000\000\
\\221\001\000\000\
\\222\001\002\000\040\000\007\000\104\000\012\000\103\000\013\000\102\000\
\\014\000\101\000\018\000\039\000\029\000\038\000\030\000\037\000\
\\031\000\036\000\034\000\100\000\036\000\099\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\069\000\096\000\000\000\
\\222\001\007\000\104\000\012\000\103\000\013\000\102\000\014\000\101\000\
\\034\000\100\000\036\000\099\000\060\000\012\000\061\000\011\000\
\\062\000\010\000\069\000\096\000\000\000\
\\223\001\000\000\
\\224\001\042\000\241\000\000\000\
\\224\001\042\000\241\000\047\000\240\000\000\000\
\\225\001\000\000\
\\226\001\047\000\081\001\000\000\
\\227\001\000\000\
\\228\001\000\000\
\\229\001\000\000\
\\230\001\000\000\
\\231\001\068\000\034\000\000\000\
\\232\001\000\000\
\\233\001\000\000\
\\234\001\000\000\
\\235\001\000\000\
\\236\001\000\000\
\\237\001\000\000\
\\238\001\000\000\
\\239\001\000\000\
\\240\001\000\000\
\\241\001\000\000\
\\242\001\000\000\
\\243\001\023\000\069\000\024\000\068\000\034\000\066\000\035\000\134\000\
\\036\000\064\000\038\000\133\000\051\000\132\000\053\000\063\000\
\\054\000\062\000\058\000\061\000\060\000\012\000\061\000\011\000\
\\062\000\010\000\000\000\
\\244\001\023\000\069\000\024\000\068\000\034\000\066\000\035\000\134\000\
\\036\000\064\000\038\000\133\000\051\000\132\000\053\000\063\000\
\\054\000\062\000\058\000\061\000\060\000\012\000\061\000\011\000\
\\062\000\010\000\000\000\
\\245\001\023\000\069\000\024\000\068\000\034\000\066\000\035\000\134\000\
\\036\000\064\000\038\000\133\000\051\000\132\000\053\000\063\000\
\\054\000\062\000\058\000\061\000\060\000\012\000\061\000\011\000\
\\062\000\010\000\000\000\
\\246\001\023\000\069\000\024\000\068\000\034\000\066\000\035\000\134\000\
\\036\000\064\000\038\000\133\000\051\000\132\000\053\000\063\000\
\\054\000\062\000\058\000\061\000\060\000\012\000\061\000\011\000\
\\062\000\010\000\000\000\
\\247\001\063\000\130\000\064\000\129\000\065\000\128\000\066\000\127\000\
\\067\000\126\000\000\000\
\\248\001\063\000\130\000\064\000\129\000\067\000\126\000\000\000\
\\249\001\063\000\130\000\064\000\129\000\067\000\126\000\000\000\
\\250\001\044\000\125\000\000\000\
\\250\001\044\000\125\000\047\000\106\001\000\000\
\\251\001\000\000\
\\252\001\000\000\
\\253\001\000\000\
\\254\001\000\000\
\\255\001\000\000\
\\000\002\000\000\
\\001\002\000\000\
\\002\002\007\000\075\000\009\000\074\000\011\000\073\000\015\000\072\000\
\\016\000\071\000\022\000\070\000\023\000\069\000\024\000\068\000\
\\025\000\067\000\034\000\066\000\035\000\065\000\036\000\064\000\
\\053\000\063\000\054\000\062\000\058\000\061\000\060\000\012\000\
\\061\000\011\000\062\000\010\000\000\000\
\\003\002\000\000\
\\004\002\042\000\211\000\000\000\
\\004\002\042\000\211\000\043\000\210\000\000\000\
\\005\002\000\000\
\\006\002\000\000\
\\007\002\000\000\
\\008\002\000\000\
\\009\002\000\000\
\"
val actionRowNumbers =
"\165\000\006\001\166\000\007\001\
\\153\000\151\000\146\000\126\000\
\\110\000\109\000\108\000\180\000\
\\166\000\001\000\005\000\028\000\
\\102\000\102\000\102\000\102\000\
\\028\000\102\000\102\000\167\000\
\\102\000\007\000\102\000\168\000\
\\005\000\022\000\005\000\149\000\
\\102\000\079\000\006\000\003\000\
\\008\000\004\000\009\000\035\000\
\\147\000\190\000\118\000\080\000\
\\190\000\013\000\148\000\081\000\
\\082\000\014\000\089\000\083\000\
\\187\000\246\000\243\000\239\000\
\\230\000\228\000\226\000\105\000\
\\104\000\103\000\255\000\099\000\
\\028\000\024\000\107\000\106\000\
\\021\000\167\000\007\000\021\000\
\\007\000\047\000\190\000\157\000\
\\152\000\195\000\194\000\198\000\
\\005\000\156\000\127\000\111\000\
\\128\000\053\000\011\000\054\000\
\\022\000\055\000\213\000\211\000\
\\209\000\208\000\049\000\096\000\
\\140\000\217\000\028\000\205\000\
\\207\000\204\000\050\000\056\000\
\\005\000\057\000\011\000\125\000\
\\188\000\121\000\102\000\005\000\
\\022\000\183\000\005\000\005\000\
\\005\000\021\000\021\000\005\000\
\\005\000\021\000\021\000\007\000\
\\012\000\012\000\012\000\012\000\
\\012\000\231\000\100\000\217\000\
\\101\000\000\001\036\000\002\001\
\\051\000\227\000\236\000\029\000\
\\015\000\090\000\023\000\030\000\
\\025\000\084\000\121\000\085\000\
\\031\000\032\000\150\000\011\000\
\\129\000\058\000\022\000\135\000\
\\059\000\096\000\131\000\020\000\
\\217\000\121\000\060\000\199\000\
\\037\000\218\000\038\000\220\000\
\\206\000\121\000\005\000\137\000\
\\061\000\096\000\133\000\062\000\
\\086\000\102\000\122\000\063\000\
\\123\000\120\000\119\000\112\000\
\\178\000\179\000\011\000\096\000\
\\160\000\169\000\170\000\026\000\
\\027\000\161\000\016\000\017\000\
\\018\000\254\000\242\000\245\000\
\\244\000\241\000\240\000\235\000\
\\064\000\219\000\052\000\225\000\
\\011\000\007\000\011\000\216\000\
\\007\000\007\000\102\000\216\000\
\\007\000\020\000\065\000\011\000\
\\010\000\114\000\114\000\033\000\
\\034\000\066\000\130\000\067\000\
\\136\000\068\000\212\000\069\000\
\\070\000\132\000\091\000\097\000\
\\203\000\202\000\011\000\011\000\
\\071\000\072\000\138\000\073\000\
\\096\000\134\000\007\000\011\000\
\\087\000\191\000\102\000\102\000\
\\005\000\174\000\175\000\005\000\
\\005\000\005\000\005\000\005\000\
\\005\000\005\000\005\000\232\000\
\\011\000\039\000\003\001\001\001\
\\074\000\075\000\251\000\019\000\
\\248\000\092\000\076\000\002\000\
\\048\000\093\000\176\000\088\000\
\\177\000\115\000\040\000\116\000\
\\041\000\114\000\114\000\139\000\
\\145\000\141\000\210\000\094\000\
\\098\000\201\000\224\000\222\000\
\\221\000\095\000\144\000\142\000\
\\077\000\172\000\173\000\011\000\
\\124\000\113\000\186\000\011\000\
\\171\000\155\000\154\000\159\000\
\\158\000\162\000\163\000\164\000\
\\078\000\229\000\238\000\024\000\
\\007\000\007\000\024\000\007\000\
\\007\000\007\000\011\000\011\000\
\\196\000\102\000\197\000\042\000\
\\043\000\011\000\200\000\011\000\
\\011\000\143\000\007\000\044\000\
\\182\000\237\000\234\000\253\000\
\\004\001\247\000\233\000\252\000\
\\249\000\250\000\184\000\185\000\
\\117\000\045\000\046\000\214\000\
\\223\000\215\000\181\000\188\000\
\\102\000\192\000\193\000\189\000\
\\005\001\000\000"
val gotoT =
"\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\003\000\015\000\002\000\016\000\001\000\040\000\109\001\000\000\
\\000\000\
\\015\000\002\000\016\000\027\000\000\000\
\\000\000\
\\000\000\
\\002\000\007\000\011\000\031\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\015\000\002\000\016\000\033\000\000\000\
\\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\039\000\000\000\
\\002\000\007\000\011\000\040\000\000\000\
\\002\000\042\000\007\000\041\000\000\000\
\\002\000\042\000\007\000\043\000\000\000\
\\002\000\042\000\007\000\044\000\000\000\
\\002\000\045\000\000\000\
\\002\000\007\000\011\000\046\000\000\000\
\\002\000\042\000\007\000\047\000\000\000\
\\002\000\048\000\000\000\
\\002\000\050\000\015\000\002\000\016\000\049\000\000\000\
\\002\000\051\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\052\000\000\000\
\\002\000\042\000\007\000\074\000\000\000\
\\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\075\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\079\000\019\000\078\000\
\\020\000\077\000\022\000\076\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\081\000\000\000\
\\000\000\
\\002\000\083\000\003\000\082\000\000\000\
\\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\085\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\087\000\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\089\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\103\000\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\105\000\000\000\
\\000\000\
\\000\000\
\\018\000\108\000\000\000\
\\000\000\
\\000\000\
\\018\000\113\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\129\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\135\000\
\\037\000\134\000\038\000\133\000\000\000\
\\000\000\
\\002\000\007\000\011\000\137\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\138\000\000\000\
\\000\000\
\\000\000\
\\002\000\007\000\011\000\006\000\012\000\139\000\000\000\
\\002\000\141\000\015\000\002\000\016\000\140\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\142\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\143\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\144\000\000\000\
\\002\000\145\000\000\000\
\\018\000\147\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\007\000\011\000\031\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\150\000\013\000\004\000\
\\014\000\039\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\153\000\000\000\
\\000\000\
\\002\000\007\000\011\000\006\000\012\000\079\000\019\000\078\000\
\\020\000\077\000\022\000\156\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\031\000\162\000\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\167\000\027\000\166\000\028\000\165\000\
\\030\000\164\000\000\000\
\\002\000\007\000\011\000\168\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\172\000\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\175\000\000\000\
\\000\000\
\\017\000\176\000\000\000\
\\002\000\181\000\008\000\180\000\009\000\179\000\010\000\178\000\000\000\
\\002\000\083\000\003\000\183\000\004\000\182\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\184\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\079\000\019\000\078\000\
\\020\000\077\000\022\000\185\000\000\000\
\\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\188\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\189\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\190\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\191\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\192\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\193\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\194\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\195\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\196\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\197\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\198\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\199\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\200\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\201\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\202\000\000\000\
\\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\205\000\027\000\204\000\028\000\165\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\007\000\011\000\031\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\007\000\011\000\031\000\000\000\
\\000\000\
\\000\000\
\\002\000\181\000\008\000\180\000\009\000\218\000\010\000\178\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\007\000\011\000\031\000\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\225\000\000\000\
\\000\000\
\\000\000\
\\002\000\007\000\011\000\006\000\012\000\079\000\019\000\078\000\
\\020\000\077\000\022\000\227\000\000\000\
\\000\000\
\\000\000\
\\031\000\229\000\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\230\000\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\205\000\027\000\231\000\028\000\165\000\000\000\
\\002\000\181\000\008\000\180\000\009\000\232\000\010\000\178\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\181\000\008\000\180\000\009\000\240\000\010\000\178\000\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\241\000\000\000\
\\000\000\
\\000\000\
\\031\000\243\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\248\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\253\000\000\000\
\\031\000\254\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\129\000\000\000\
\\000\000\
\\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\129\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\129\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\009\001\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\011\001\
\\038\000\010\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\012\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\205\000\027\000\013\001\028\000\165\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\014\001\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\015\001\000\000\
\\002\000\017\001\039\000\016\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\205\000\027\000\018\001\028\000\165\000\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\019\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\020\001\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\022\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\024\001\031\000\023\001\000\000\
\\002\000\083\000\003\000\183\000\004\000\027\001\005\000\026\001\
\\006\000\025\001\000\000\
\\002\000\083\000\003\000\183\000\004\000\027\001\005\000\028\001\
\\006\000\025\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\039\001\029\000\038\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\205\000\028\000\040\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\031\000\044\001\000\000\
\\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\045\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\046\001\000\000\
\\000\000\
\\000\000\
\\002\000\181\000\008\000\180\000\010\000\048\001\000\000\
\\002\000\083\000\003\000\183\000\004\000\049\001\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\050\001\000\000\
\\000\000\
\\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\052\001\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\053\001\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\054\001\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\055\001\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\056\001\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\057\001\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\058\001\000\000\
\\002\000\007\000\011\000\006\000\012\000\005\000\013\000\004\000\
\\014\000\059\001\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\060\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\083\000\003\000\183\000\004\000\027\001\005\000\075\001\
\\006\000\025\001\000\000\
\\002\000\083\000\003\000\183\000\004\000\027\001\005\000\076\001\
\\006\000\025\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\083\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\084\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\086\001\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\087\001\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\089\001\036\000\088\001\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\090\001\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\091\001\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\092\001\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\093\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\094\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\095\001\000\000\
\\000\000\
\\002\000\083\000\003\000\183\000\004\000\027\001\006\000\096\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\099\001\000\000\
\\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\039\001\029\000\100\001\000\000\
\\002\000\042\000\007\000\093\000\023\000\092\000\024\000\091\000\
\\025\000\090\000\026\000\101\001\000\000\
\\000\000\
\\001\000\058\000\002\000\042\000\007\000\057\000\032\000\056\000\
\\033\000\055\000\034\000\054\000\035\000\053\000\036\000\102\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\017\000\107\001\000\000\
\\002\000\017\001\039\000\108\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\"
val numstates = 366
val numrules = 154
val s = ref "" and index = ref 0
val string_to_int = fn () => 
let val i = !index
in index := i+2; Char.ord(String.sub(!s,i)) + Char.ord(String.sub(!s,i+1)) * 256
end
val string_to_list = fn s' =>
    let val len = String.size s'
        fun f () =
           if !index < len then string_to_int() :: f()
           else nil
   in index := 0; s := s'; f ()
   end
val string_to_pairlist = fn (conv_key,conv_entry) =>
     let fun f () =
         case string_to_int()
         of 0 => EMPTY
          | n => PAIR(conv_key (n-1),conv_entry (string_to_int()),f())
     in f
     end
val string_to_pairlist_default = fn (conv_key,conv_entry) =>
    let val conv_row = string_to_pairlist(conv_key,conv_entry)
    in fn () =>
       let val default = conv_entry(string_to_int())
           val row = conv_row()
       in (row,default)
       end
   end
val string_to_table = fn (convert_row,s') =>
    let val len = String.size s'
        fun f ()=
           if !index < len then convert_row() :: f()
           else nil
     in (s := s'; index := 0; f ())
     end
local
  val memo = Array.array(numstates+numrules,ERROR)
  val _ =let fun g i=(Array.update(memo,i,REDUCE(i-numstates)); g(i+1))
       fun f i =
            if i=numstates then g i
            else (Array.update(memo,i,SHIFT (STATE i)); f (i+1))
          in f 0 handle Subscript => ()
          end
in
val entry_to_action = fn 0 => ACCEPT | 1 => ERROR | j => Array.sub(memo,(j-2))
end
val gotoT=Array.fromList(string_to_table(string_to_pairlist(NT,STATE),gotoT))
val actionRows=string_to_table(string_to_pairlist_default(T,entry_to_action),actionRows)
val actionRowNumbers = string_to_list actionRowNumbers
val actionT = let val actionRowLookUp=
let val a=Array.fromList(actionRows) in fn i=>Array.sub(a,i) end
in Array.fromList(map actionRowLookUp actionRowNumbers)
end
in LrTable.mkLrTable {actions=actionT,gotos=gotoT,numRules=numrules,
numStates=numstates,initialState=STATE 0}
end
end
local open Header in
type pos = EL.pos
type arg = unit
structure MlyValue = 
struct
datatype svalue = VOID | ntVOID of unit ->  unit
 | TYPVAR of unit ->  (string) | SYMBOL of unit ->  (string)
 | ALPHA of unit ->  (string) | CHAR of unit ->  (char)
 | TEXT of unit ->  (string) | REAL of unit ->  (real)
 | HEXWORD of unit ->  (word) | WORD of unit ->  (word)
 | HEXNUM of unit ->  (int) | NUM of unit ->  (int)
 | prog of unit ->  (prog)
 | idexp_barlist1 of unit ->  ( ( var * exp )  list)
 | exp_list1 of unit ->  (exp list) | exp_list of unit ->  (exp list)
 | exp of unit ->  (exp) | infexp of unit ->  (exp)
 | plusexp of unit ->  (exp) | appexp of unit ->  (exp)
 | atexp of unit ->  (exp) | kind of unit ->  (kind)
 | typ_barlist2 of unit ->  (typ list)
 | typ_barlist1 of unit ->  (typ list)
 | typ_list1 of unit ->  (typ list) | typ_list of unit ->  (typ list)
 | typ of unit ->  (typ) | inftyp of unit ->  (typ)
 | apptyp of unit ->  (typ) | attyp of unit ->  (typ)
 | sign of unit ->  (sign) | infsign of unit ->  (sign)
 | appsign of unit ->  (sign) | atsign of unit ->  (sign)
 | gens of unit ->  ( ( pos * typvar list )  option)
 | params of unit ->  ( ( pos * var * typ )  list)
 | decs of unit ->  ( ( var * modl )  list)
 | dec of unit ->  ( ( var * modl )  list) | modl of unit ->  (modl)
 | infmodl of unit ->  (modl) | appmodl of unit ->  (modl)
 | atmodl of unit ->  (modl) | typvar_list1 of unit ->  (typvar list)
 | typvar_list of unit ->  (typvar list) | typvar of unit ->  (typvar)
 | path of unit ->  (var*lab list)
 | labs_list1 of unit ->  (lab list list)
 | labs_list of unit ->  (lab list list) | labs of unit ->  (lab list)
 | lab of unit ->  (lab) | id of unit ->  (var)
 | lit of unit ->  (exp)
end
type svalue = MlyValue.svalue
type result = prog
end
structure EC=
struct
open LrTable
infix 5 $$
fun x $$ y = y::x
val is_keyword =
fn (T 14) => true | (T 1) => true | (T 2) => true | (T 3) => true | 
(T 4) => true | (T 5) => true | (T 6) => true | (T 7) => true | (T 8)
 => true | (T 9) => true | (T 10) => true | (T 15) => true | (T 16)
 => true | (T 17) => true | (T 18) => true | (T 20) => true | (T 21)
 => true | (T 68) => true | (T 25) => true | (T 69) => true | (T 26)
 => true | (T 27) => true | (T 28) => true | (T 29) => true | (T 30)
 => true | (T 31) => true | (T 32) => true | _ => false
val preferred_change : (term list * term list) list = 
nil
val noShift = 
fn (T 0) => true | _ => false
val showTerminal =
fn (T 0) => "EOF"
  | (T 1) => "DATA"
  | (T 2) => "DO"
  | (T 3) => "ELSE"
  | (T 4) => "END"
  | (T 5) => "EXPORT"
  | (T 6) => "FN"
  | (T 7) => "FUN"
  | (T 8) => "IF"
  | (T 9) => "IMPORT"
  | (T 10) => "IN"
  | (T 11) => "INT"
  | (T 12) => "BOOL"
  | (T 13) => "STRING"
  | (T 14) => "CASE"
  | (T 15) => "LET"
  | (T 16) => "LINK"
  | (T 17) => "MODULE"
  | (T 18) => "NEW"
  | (T 19) => "OF"
  | (T 20) => "OPEN"
  | (T 21) => "OUT"
  | (T 22) => "FALSE"
  | (T 23) => "TRUE"
  | (T 24) => "PRINT"
  | (T 25) => "REC"
  | (T 26) => "SIGNATURE"
  | (T 27) => "THEN"
  | (T 28) => "TYPE"
  | (T 29) => "UNIT"
  | (T 30) => "VAL"
  | (T 31) => "WHERE"
  | (T 32) => "WITH"
  | (T 33) => "BANG"
  | (T 34) => "AT"
  | (T 35) => "LPAR"
  | (T 36) => "RPAR"
  | (T 37) => "LBRACK"
  | (T 38) => "RBRACK"
  | (T 39) => "LBRACE"
  | (T 40) => "RBRACE"
  | (T 41) => "COMMA"
  | (T 42) => "COLON"
  | (T 43) => "SEMICOLON"
  | (T 44) => "DOTS"
  | (T 45) => "UNDERBAR"
  | (T 46) => "BAR"
  | (T 47) => "EQUALS"
  | (T 48) => "DARROW"
  | (T 49) => "ARROW"
  | (T 50) => "HASH"
  | (T 51) => "SEAL"
  | (T 52) => "NUM"
  | (T 53) => "HEXNUM"
  | (T 54) => "WORD"
  | (T 55) => "HEXWORD"
  | (T 56) => "REAL"
  | (T 57) => "TEXT"
  | (T 58) => "CHAR"
  | (T 59) => "ALPHA"
  | (T 60) => "SYMBOL"
  | (T 61) => "TYPVAR"
  | (T 62) => "PLUS"
  | (T 63) => "MINUS"
  | (T 64) => "ISEQUAL"
  | (T 65) => "LESS"
  | (T 66) => "CAT"
  | (T 67) => "DOT"
  | (T 68) => "FORALL"
  | (T 69) => "SEALS"
  | _ => "bogus-term"
local open Header in
val errtermvalue=
fn _ => MlyValue.VOID
end
val terms : term list = nil
 $$ (T 69) $$ (T 68) $$ (T 67) $$ (T 66) $$ (T 65) $$ (T 64) $$ (T 63)
 $$ (T 62) $$ (T 51) $$ (T 50) $$ (T 49) $$ (T 48) $$ (T 47) $$ (T 46)
 $$ (T 45) $$ (T 44) $$ (T 43) $$ (T 42) $$ (T 41) $$ (T 40) $$ (T 39)
 $$ (T 38) $$ (T 37) $$ (T 36) $$ (T 35) $$ (T 34) $$ (T 33) $$ (T 32)
 $$ (T 31) $$ (T 30) $$ (T 29) $$ (T 28) $$ (T 27) $$ (T 26) $$ (T 25)
 $$ (T 24) $$ (T 23) $$ (T 22) $$ (T 21) $$ (T 20) $$ (T 19) $$ (T 18)
 $$ (T 17) $$ (T 16) $$ (T 15) $$ (T 14) $$ (T 13) $$ (T 12) $$ (T 11)
 $$ (T 10) $$ (T 9) $$ (T 8) $$ (T 7) $$ (T 6) $$ (T 5) $$ (T 4) $$ 
(T 3) $$ (T 2) $$ (T 1) $$ (T 0)end
structure Actions =
struct 
exception mlyAction of int
local open Header in
val actions = 
fn (i392,defaultPos,stack,
    (()):arg) =>
case (i392,stack)
of  ( 0, ( ( _, ( MlyValue.NUM NUM1, (NUMleft as NUM1left), (NUMright
 as NUM1right))) :: rest671)) => let val  result = MlyValue.lit (fn _
 => let val  (NUM as NUM1) = NUM1 ()
 in ($NUMleft NUMright IntE(NUM))
end)
 in ( LrTable.NT 0, ( result, NUM1left, NUM1right), rest671)
end
|  ( 1, ( ( _, ( MlyValue.HEXNUM HEXNUM1, (HEXNUMleft as HEXNUM1left),
 (HEXNUMright as HEXNUM1right))) :: rest671)) => let val  result = 
MlyValue.lit (fn _ => let val  (HEXNUM as HEXNUM1) = HEXNUM1 ()
 in ($HEXNUMleft HEXNUMright IntE(HEXNUM))
end)
 in ( LrTable.NT 0, ( result, HEXNUM1left, HEXNUM1right), rest671)
end
|  ( 2, ( ( _, ( MlyValue.TEXT TEXT1, (TEXTleft as TEXT1left), (
TEXTright as TEXT1right))) :: rest671)) => let val  result = 
MlyValue.lit (fn _ => let val  (TEXT as TEXT1) = TEXT1 ()
 in ($TEXTleft TEXTright StringE(TEXT))
end)
 in ( LrTable.NT 0, ( result, TEXT1left, TEXT1right), rest671)
end
|  ( 3, ( ( _, ( _, (FALSEleft as FALSE1left), (FALSEright as 
FALSE1right))) :: rest671)) => let val  result = MlyValue.lit (fn _ =>
 (boolE FALSEleft FALSEright 1))
 in ( LrTable.NT 0, ( result, FALSE1left, FALSE1right), rest671)
end
|  ( 4, ( ( _, ( _, (TRUEleft as TRUE1left), (TRUEright as TRUE1right)
)) :: rest671)) => let val  result = MlyValue.lit (fn _ => (
boolE TRUEleft TRUEright 2))
 in ( LrTable.NT 0, ( result, TRUE1left, TRUE1right), rest671)
end
|  ( 5, ( ( _, ( MlyValue.ALPHA ALPHA1, ALPHA1left, ALPHA1right)) :: 
rest671)) => let val  result = MlyValue.id (fn _ => let val  (ALPHA
 as ALPHA1) = ALPHA1 ()
 in (ALPHA)
end)
 in ( LrTable.NT 1, ( result, ALPHA1left, ALPHA1right), rest671)
end
|  ( 6, ( ( _, ( MlyValue.SYMBOL SYMBOL1, SYMBOL1left, SYMBOL1right))
 :: rest671)) => let val  result = MlyValue.id (fn _ => let val  (
SYMBOL as SYMBOL1) = SYMBOL1 ()
 in (SYMBOL)
end)
 in ( LrTable.NT 1, ( result, SYMBOL1left, SYMBOL1right), rest671)
end
|  ( 7, ( ( _, ( MlyValue.TYPVAR TYPVAR1, TYPVAR1left, TYPVAR1right))
 :: rest671)) => let val  result = MlyValue.id (fn _ => let val  (
TYPVAR as TYPVAR1) = TYPVAR1 ()
 in (TYPVAR)
end)
 in ( LrTable.NT 1, ( result, TYPVAR1left, TYPVAR1right), rest671)
end
|  ( 8, ( ( _, ( MlyValue.id id1, id1left, id1right)) :: rest671)) =>
 let val  result = MlyValue.lab (fn _ => let val  (id as id1) = id1 ()
 in (id)
end)
 in ( LrTable.NT 2, ( result, id1left, id1right), rest671)
end
|  ( 9, ( ( _, ( MlyValue.lab lab1, lab1left, lab1right)) :: rest671))
 => let val  result = MlyValue.labs (fn _ => let val  (lab as lab1) = 
lab1 ()
 in (lab::[])
end)
 in ( LrTable.NT 3, ( result, lab1left, lab1right), rest671)
end
|  ( 10, ( ( _, ( MlyValue.labs labs1, _, labs1right)) :: _ :: ( _, ( 
MlyValue.lab lab1, lab1left, _)) :: rest671)) => let val  result = 
MlyValue.labs (fn _ => let val  (lab as lab1) = lab1 ()
 val  (labs as labs1) = labs1 ()
 in (lab::labs)
end)
 in ( LrTable.NT 3, ( result, lab1left, labs1right), rest671)
end
|  ( 11, ( rest671)) => let val  result = MlyValue.labs_list (fn _ =>
 ([]))
 in ( LrTable.NT 4, ( result, defaultPos, defaultPos), rest671)
end
|  ( 12, ( ( _, ( MlyValue.labs_list1 labs_list11, labs_list11left, 
labs_list11right)) :: rest671)) => let val  result = 
MlyValue.labs_list (fn _ => let val  (labs_list1 as labs_list11) = 
labs_list11 ()
 in (labs_list1)
end)
 in ( LrTable.NT 4, ( result, labs_list11left, labs_list11right), 
rest671)
end
|  ( 13, ( ( _, ( MlyValue.labs labs1, labs1left, labs1right)) :: 
rest671)) => let val  result = MlyValue.labs_list1 (fn _ => let val  (
labs as labs1) = labs1 ()
 in (labs::[])
end)
 in ( LrTable.NT 5, ( result, labs1left, labs1right), rest671)
end
|  ( 14, ( ( _, ( MlyValue.labs_list1 labs_list11, _, labs_list11right
)) :: _ :: ( _, ( MlyValue.labs labs1, labs1left, _)) :: rest671)) =>
 let val  result = MlyValue.labs_list1 (fn _ => let val  (labs as 
labs1) = labs1 ()
 val  (labs_list1 as labs_list11) = labs_list11 ()
 in (labs::labs_list1)
end)
 in ( LrTable.NT 5, ( result, labs1left, labs_list11right), rest671)

end
|  ( 15, ( ( _, ( MlyValue.id id1, id1left, id1right)) :: rest671)) =>
 let val  result = MlyValue.path (fn _ => let val  (id as id1) = id1
 ()
 in ((id, []))
end)
 in ( LrTable.NT 6, ( result, id1left, id1right), rest671)
end
|  ( 16, ( ( _, ( MlyValue.labs labs1, _, labs1right)) :: _ :: ( _, ( 
MlyValue.id id1, id1left, _)) :: rest671)) => let val  result = 
MlyValue.path (fn _ => let val  (id as id1) = id1 ()
 val  (labs as labs1) = labs1 ()
 in ((id, labs))
end)
 in ( LrTable.NT 6, ( result, id1left, labs1right), rest671)
end
|  ( 17, ( ( _, ( MlyValue.id id1, id1left, id1right)) :: rest671)) =>
 let val  result = MlyValue.typvar (fn _ => let val  (id as id1) = id1
 ()
 in (id)
end)
 in ( LrTable.NT 7, ( result, id1left, id1right), rest671)
end
|  ( 18, ( rest671)) => let val  result = MlyValue.typvar_list (fn _
 => ([]))
 in ( LrTable.NT 8, ( result, defaultPos, defaultPos), rest671)
end
|  ( 19, ( ( _, ( MlyValue.typvar_list1 typvar_list11, 
typvar_list11left, typvar_list11right)) :: rest671)) => let val  
result = MlyValue.typvar_list (fn _ => let val  (typvar_list1 as 
typvar_list11) = typvar_list11 ()
 in (typvar_list1)
end)
 in ( LrTable.NT 8, ( result, typvar_list11left, typvar_list11right), 
rest671)
end
|  ( 20, ( ( _, ( MlyValue.typvar typvar1, typvar1left, typvar1right))
 :: rest671)) => let val  result = MlyValue.typvar_list1 (fn _ => let
 val  (typvar as typvar1) = typvar1 ()
 in (typvar::[])
end)
 in ( LrTable.NT 9, ( result, typvar1left, typvar1right), rest671)
end
|  ( 21, ( ( _, ( MlyValue.typvar_list1 typvar_list11, _, 
typvar_list11right)) :: _ :: ( _, ( MlyValue.typvar typvar1, 
typvar1left, _)) :: rest671)) => let val  result = 
MlyValue.typvar_list1 (fn _ => let val  (typvar as typvar1) = typvar1
 ()
 val  (typvar_list1 as typvar_list11) = typvar_list11 ()
 in (typvar::typvar_list1)
end)
 in ( LrTable.NT 9, ( result, typvar1left, typvar_list11right), 
rest671)
end
|  ( 22, ( ( _, ( _, _, RPAR1right)) :: ( _, ( MlyValue.modl modl1, _,
 _)) :: ( _, ( _, LPAR1left, _)) :: rest671)) => let val  result = 
MlyValue.atmodl (fn _ => let val  (modl as modl1) = modl1 ()
 in (modl)
end)
 in ( LrTable.NT 10, ( result, LPAR1left, RPAR1right), rest671)
end
|  ( 23, ( ( _, ( MlyValue.id id1, (idleft as id1left), (idright as 
id1right))) :: rest671)) => let val  result = MlyValue.atmodl (fn _ =>
 let val  (id as id1) = id1 ()
 in ($idleft idright VarM(id))
end)
 in ( LrTable.NT 10, ( result, id1left, id1right), rest671)
end
|  ( 24, ( ( _, ( MlyValue.lab lab1, _, (labright as lab1right))) :: _
 :: ( _, ( MlyValue.atmodl atmodl1, (atmodlleft as atmodl1left), _))
 :: rest671)) => let val  result = MlyValue.atmodl (fn _ => let val  (
atmodl as atmodl1) = atmodl1 ()
 val  (lab as lab1) = lab1 ()
 in ($atmodlleft labright DotM(atmodl, lab))
end)
 in ( LrTable.NT 10, ( result, atmodl1left, lab1right), rest671)
end
|  ( 25, ( ( _, ( _, _, RBRACE1right)) :: ( _, ( MlyValue.decs decs1,
 _, _)) :: ( _, ( _, (LBRACEleft as LBRACE1left), LBRACEright)) :: 
rest671)) => let val  result = MlyValue.atmodl (fn _ => let val  (decs
 as decs1) = decs1 ()
 in (struc LBRACEleft LBRACEright decs)
end)
 in ( LrTable.NT 10, ( result, LBRACE1left, RBRACE1right), rest671)

end
|  ( 26, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.exp exp1, _, _)) :: _ :: ( _, ( _, (LBRACKleft as LBRACK1left
), _)) :: rest671)) => let val  result = MlyValue.atmodl (fn _ => let
 val  (exp as exp1) = exp1 ()
 in ($LBRACKleft RBRACKright ValM(exp))
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 27, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.typ typ1, _, _)) :: _ :: _ :: ( _, ( _, (LBRACKleft as 
LBRACK1left), _)) :: rest671)) => let val  result = MlyValue.atmodl
 (fn _ => let val  (typ as typ1) = typ1 ()
 in ($LBRACKleft RBRACKright AbsValM(typ))
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 28, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.typ typ1, _, _)) :: _ :: ( _, ( _, (LBRACKleft as LBRACK1left
), _)) :: rest671)) => let val  result = MlyValue.atmodl (fn _ => let
 val  (typ as typ1) = typ1 ()
 in ($LBRACKleft RBRACKright TypM(typ))
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 29, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.kind kind1, _, _)) :: _ :: _ :: ( _, ( _, (LBRACKleft as 
LBRACK1left), _)) :: rest671)) => let val  result = MlyValue.atmodl
 (fn _ => let val  (kind as kind1) = kind1 ()
 in ($LBRACKleft RBRACKright AbsTypM(kind))
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 30, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.typ typ1, _, _)) :: _ :: ( _, ( _, (LBRACKleft as LBRACK1left
), _)) :: rest671)) => let val  result = MlyValue.atmodl (fn _ => let
 val  (typ as typ1) = typ1 ()
 in ($LBRACKleft RBRACKright DatTypM(typ))
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 31, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.typ typ1, _, _)) :: _ :: _ :: ( _, ( _, (LBRACKleft as 
LBRACK1left), _)) :: rest671)) => let val  result = MlyValue.atmodl
 (fn _ => let val  (typ as typ1) = typ1 ()
 in ($LBRACKleft RBRACKright AbsDatTypM(typ))
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 32, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.modl modl1, _, _)) :: _ :: ( _, ( _, (LBRACKleft as 
LBRACK1left), _)) :: rest671)) => let val  result = MlyValue.atmodl
 (fn _ => let val  (modl as modl1) = modl1 ()
 in ($LBRACKleft RBRACKright UnitM(modl))
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 33, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.sign sign1, _, _)) :: _ :: _ :: ( _, ( _, (LBRACKleft as 
LBRACK1left), _)) :: rest671)) => let val  result = MlyValue.atmodl
 (fn _ => let val  (sign as sign1) = sign1 ()
 in ($LBRACKleft RBRACKright AbsUnitM(sign))
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 34, ( ( _, ( _, _, RBRACK1right)) :: ( _, ( MlyValue.modl modl1,
 _, _)) :: _ :: ( _, ( _, LBRACK1left, _)) :: rest671)) => let val  
result = MlyValue.atmodl (fn _ => let val  (modl as modl1) = modl1 ()
 in (modl)
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 35, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.modl modl1, _, _)) :: _ :: _ :: ( _, ( _, (LBRACKleft as 
LBRACK1left), _)) :: rest671)) => let val  result = MlyValue.atmodl
 (fn _ => let val  (modl as modl1) = modl1 ()
 in ($LBRACKleft RBRACKright NewM(modl))
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 36, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.typ typ1, _, typright)) :: ( _, ( _, COLONleft, _)) :: ( _, (
 MlyValue.exp exp1, _, expright)) :: ( _, ( _, VALleft, _)) :: ( _, (
 _, (LBRACKleft as LBRACK1left), _)) :: rest671)) => let val  result =
 MlyValue.atmodl (fn _ => let val  (exp as exp1) = exp1 ()
 val  (typ as typ1) = typ1 ()
 in (
$LBRACKleft RBRACKright LinkM(rename "_val", $VALleft expright ValM(exp), $COLONleft typright AbsValM(typ))
)
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 37, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( _, 
TYPEleft, TYPEright)) :: ( _, ( _, (LBRACKleft as LBRACK1left), _)) ::
 rest671)) => let val  result = MlyValue.atmodl (fn _ => (
$LBRACKleft RBRACKright AbsTypM($$TYPEleft TYPEright StarK)))
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 38, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.kind kind1, _, kindright)) :: ( _, ( _, COLONleft, _)) :: ( _
, ( MlyValue.typ typ1, _, typright)) :: ( _, ( _, TYPEleft, _)) :: ( _
, ( _, (LBRACKleft as LBRACK1left), _)) :: rest671)) => let val  
result = MlyValue.atmodl (fn _ => let val  (typ as typ1) = typ1 ()
 val  (kind as kind1) = kind1 ()
 in (
$LBRACKleft RBRACKright LinkM(rename "_type", $TYPEleft typright TypM(typ), $COLONleft kindright AbsTypM(kind))
)
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 39, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.kind kind1, _, kindright)) :: ( _, ( _, COLONleft, _)) :: ( _
, ( MlyValue.typ typ1, _, typright)) :: ( _, ( _, DATAleft, _)) :: ( _
, ( _, (LBRACKleft as LBRACK1left), _)) :: rest671)) => let val  
result = MlyValue.atmodl (fn _ => let val  (typ as typ1) = typ1 ()
 val  (kind as kind1) = kind1 ()
 in (
$LBRACKleft RBRACKright LinkM(rename "_data", $DATAleft typright DatTypM(typ), $COLONleft kindright AbsTypM(kind))
)
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 40, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.kind kind1, _, kindright)) :: _ :: ( _, ( MlyValue.typ typ1,
 _, typright)) :: ( _, ( _, COLONleft, _)) :: ( _, ( _, DATAleft, _))
 :: ( _, ( _, (LBRACKleft as LBRACK1left), _)) :: rest671)) => let
 val  result = MlyValue.atmodl (fn _ => let val  (typ as typ1) = typ1
 ()
 val  (kind as kind1) = kind1 ()
 in (
$LBRACKleft RBRACKright LinkM(rename "_data", $DATAleft typright AbsDatTypM(typ), $COLONleft kindright AbsTypM(kind))
)
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 41, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.modl modl2, _, modl2right)) :: ( _, ( _, COLONleft, _)) :: (
 _, ( MlyValue.modl modl1, _, _)) :: _ :: ( _, ( _, (LBRACKleft as 
LBRACK1left), _)) :: rest671)) => let val  result = MlyValue.atmodl
 (fn _ => let val  modl1 = modl1 ()
 val  modl2 = modl2 ()
 in (
$LBRACKleft RBRACKright LinkM(rename "_module", modl1, $COLONleft modl2right NewM(modl2))
)
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 42, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.sign sign1, _, signright)) :: ( _, ( _, COLONleft, _)) :: ( _
, ( MlyValue.modl modl1, _, modlright)) :: ( _, ( _, UNITleft, _)) :: 
( _, ( _, (LBRACKleft as LBRACK1left), _)) :: rest671)) => let val  
result = MlyValue.atmodl (fn _ => let val  (modl as modl1) = modl1 ()
 val  (sign as sign1) = sign1 ()
 in (
$LBRACKleft RBRACKright LinkM(rename "_unit", $UNITleft modlright UnitM(modl), $COLONleft signright AbsUnitM(sign))
)
end)
 in ( LrTable.NT 10, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 43, ( ( _, ( MlyValue.atmodl atmodl1, atmodl1left, atmodl1right))
 :: rest671)) => let val  result = MlyValue.appmodl (fn _ => let val 
 (atmodl as atmodl1) = atmodl1 ()
 in (atmodl)
end)
 in ( LrTable.NT 11, ( result, atmodl1left, atmodl1right), rest671)

end
|  ( 44, ( ( _, ( MlyValue.atmodl atmodl1, _, (atmodlright as 
atmodl1right))) :: ( _, ( _, (BANGleft as BANG1left), _)) :: rest671))
 => let val  result = MlyValue.appmodl (fn _ => let val  (atmodl as 
atmodl1) = atmodl1 ()
 in ($BANGleft atmodlright NewM(atmodl))
end)
 in ( LrTable.NT 11, ( result, BANG1left, atmodl1right), rest671)
end
|  ( 45, ( ( _, ( MlyValue.atmodl atmodl1, _, (atmodlright as 
atmodl1right))) :: ( _, ( _, (NEWleft as NEW1left), _)) :: rest671))
 => let val  result = MlyValue.appmodl (fn _ => let val  (atmodl as 
atmodl1) = atmodl1 ()
 in ($NEWleft atmodlright NewM(atmodl))
end)
 in ( LrTable.NT 11, ( result, NEW1left, atmodl1right), rest671)
end
|  ( 46, ( ( _, ( MlyValue.atmodl atmodl1, _, (atmodlright as 
atmodl1right))) :: ( _, ( MlyValue.appmodl appmodl1, (appmodlleft as 
appmodl1left), _)) :: rest671)) => let val  result = MlyValue.appmodl
 (fn _ => let val  (appmodl as appmodl1) = appmodl1 ()
 val  (atmodl as atmodl1) = atmodl1 ()
 in (app appmodlleft atmodlright appmodl atmodl)
end)
 in ( LrTable.NT 11, ( result, appmodl1left, atmodl1right), rest671)

end
|  ( 47, ( ( _, ( MlyValue.appmodl appmodl1, appmodl1left, 
appmodl1right)) :: rest671)) => let val  result = MlyValue.infmodl (fn
 _ => let val  (appmodl as appmodl1) = appmodl1 ()
 in (appmodl)
end)
 in ( LrTable.NT 12, ( result, appmodl1left, appmodl1right), rest671)

end
|  ( 48, ( ( _, ( MlyValue.sign sign1, _, (signright as sign1right)))
 :: _ :: ( _, ( MlyValue.infmodl infmodl1, (infmodlleft as 
infmodl1left), _)) :: rest671)) => let val  result = MlyValue.infmodl
 (fn _ => let val  (infmodl as infmodl1) = infmodl1 ()
 val  (sign as sign1) = sign1 ()
 in ($infmodlleft signright SealM(infmodl, sign))
end)
 in ( LrTable.NT 12, ( result, infmodl1left, sign1right), rest671)
end
|  ( 49, ( ( _, ( MlyValue.infmodl infmodl1, infmodl1left, 
infmodl1right)) :: rest671)) => let val  result = MlyValue.modl (fn _
 => let val  (infmodl as infmodl1) = infmodl1 ()
 in (infmodl)
end)
 in ( LrTable.NT 13, ( result, infmodl1left, infmodl1right), rest671)

end
|  ( 50, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.infmodl infmodl1, _, _)) :: _ :: ( _, ( 
MlyValue.id id1, _, _)) :: ( _, ( _, (LINKleft as LINK1left), _)) :: 
rest671)) => let val  result = MlyValue.modl (fn _ => let val  (id as 
id1) = id1 ()
 val  (infmodl as infmodl1) = infmodl1 ()
 val  (modl as modl1) = modl1 ()
 in ($LINKleft modlright LinkM(id, infmodl, modl))
end)
 in ( LrTable.NT 13, ( result, LINK1left, modl1right), rest671)
end
|  ( 51, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.infmodl infmodl1, _, _)) :: _ :: ( _, ( 
MlyValue.id id1, _, _)) :: ( _, ( _, (LINKleft as LINK1left), _)) :: 
rest671)) => let val  result = MlyValue.modl (fn _ => let val  (id as 
id1) = id1 ()
 val  (infmodl as infmodl1) = infmodl1 ()
 val  (modl as modl1) = modl1 ()
 in ($LINKleft modlright OLinkM(id, infmodl, modl))
end)
 in ( LrTable.NT 13, ( result, LINK1left, modl1right), rest671)
end
|  ( 52, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.infmodl infmodl1, (infmodlleft as 
infmodl1left), _)) :: rest671)) => let val  result = MlyValue.modl (fn
 _ => let val  (infmodl as infmodl1) = infmodl1 ()
 val  (modl as modl1) = modl1 ()
 in ($infmodlleft modlright LinkM(rename "_link", infmodl, modl))
end)
 in ( LrTable.NT 13, ( result, infmodl1left, modl1right), rest671)
end
|  ( 53, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.infmodl infmodl1, (infmodlleft as 
infmodl1left), _)) :: rest671)) => let val  result = MlyValue.modl (fn
 _ => let val  (infmodl as infmodl1) = infmodl1 ()
 val  (modl as modl1) = modl1 ()
 in ($infmodlleft modlright OLinkM(rename "_link", infmodl, modl))
end
)
 in ( LrTable.NT 13, ( result, infmodl1left, modl1right), rest671)
end
|  ( 54, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.infmodl infmodl1, _, infmodlright)) :: ( _, (
 _, COLONleft, _)) :: ( _, ( MlyValue.id id1, _, _)) :: ( _, ( _, (
LINKleft as LINK1left), _)) :: rest671)) => let val  result = 
MlyValue.modl (fn _ => let val  (id as id1) = id1 ()
 val  (infmodl as infmodl1) = infmodl1 ()
 val  (modl as modl1) = modl1 ()
 in (
$LINKleft modlright LinkM(id, $COLONleft infmodlright NewM(infmodl), modl)
)
end)
 in ( LrTable.NT 13, ( result, LINK1left, modl1right), rest671)
end
|  ( 55, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.infmodl infmodl1, _, infmodlright)) :: ( _, (
 _, COLONleft, _)) :: ( _, ( MlyValue.id id1, _, _)) :: ( _, ( _, (
LINKleft as LINK1left), _)) :: rest671)) => let val  result = 
MlyValue.modl (fn _ => let val  (id as id1) = id1 ()
 val  (infmodl as infmodl1) = infmodl1 ()
 val  (modl as modl1) = modl1 ()
 in (
$LINKleft modlright OLinkM(id, $COLONleft infmodlright NewM(infmodl), modl)
)
end)
 in ( LrTable.NT 13, ( result, LINK1left, modl1right), rest671)
end
|  ( 56, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.id id1, _, _)) :: ( _, ( _, (RECleft as 
REC1left), _)) :: rest671)) => let val  result = MlyValue.modl (fn _
 => let val  (id as id1) = id1 ()
 val  (modl as modl1) = modl1 ()
 in (recm RECleft modlright id modl)
end)
 in ( LrTable.NT 13, ( result, REC1left, modl1right), rest671)
end
|  ( 57, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.decs decs1, decsleft, _)) :: ( _, ( _, (
LETleft as LET1left), _)) :: rest671)) => let val  result = 
MlyValue.modl (fn _ => let val  (decs as decs1) = decs1 ()
 val  (modl as modl1) = modl1 ()
 in (
$LETleft modlright DotM(struc decsleft modlright (decs @ [("let", modl)]), "let")
)
end)
 in ( LrTable.NT 13, ( result, LET1left, modl1right), rest671)
end
|  ( 58, ( ( _, ( MlyValue.modl modl2, _, modl2right)) :: _ :: ( _, ( 
MlyValue.modl modl1, _, _)) :: _ :: ( _, ( MlyValue.id id1, idleft, _)
) :: ( _, ( _, (LETleft as LET1left), _)) :: rest671)) => let val  
result = MlyValue.modl (fn _ => let val  (id as id1) = id1 ()
 val  modl1 = modl1 ()
 val  modl2 = modl2 ()
 in (
$LETleft modl2right DotM(struc idleft modl2right [(id, modl1), ("let", modl2)], "let")
)
end)
 in ( LrTable.NT 13, ( result, LET1left, modl2right), rest671)
end
|  ( 59, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.infmodl infmodl1, _, _)) :: _ :: ( _, ( 
MlyValue.id id1, _, _)) :: ( _, ( _, (FNleft as FN1left), _)) :: 
rest671)) => let val  result = MlyValue.modl (fn _ => let val  (id as 
id1) = id1 ()
 val  (infmodl as infmodl1) = infmodl1 ()
 val  (modl as modl1) = modl1 ()
 in (fct FNleft modlright id infmodl modl)
end)
 in ( LrTable.NT 13, ( result, FN1left, modl1right), rest671)
end
|  ( 60, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.infmodl infmodl1, _, infmodlright)) :: ( _, (
 _, COLONleft, _)) :: ( _, ( MlyValue.id id1, _, _)) :: ( _, ( _, (
FNleft as FN1left), _)) :: rest671)) => let val  result = 
MlyValue.modl (fn _ => let val  (id as id1) = id1 ()
 val  (infmodl as infmodl1) = infmodl1 ()
 val  (modl as modl1) = modl1 ()
 in (
fct FNleft modlright id ($COLONleft infmodlright NewM(infmodl)) modl)

end)
 in ( LrTable.NT 13, ( result, FN1left, modl1right), rest671)
end
|  ( 61, ( rest671)) => let val  result = MlyValue.decs (fn _ => ([]))
 in ( LrTable.NT 15, ( result, defaultPos, defaultPos), rest671)
end
|  ( 62, ( ( _, ( MlyValue.decs decs1, _, decs1right)) :: ( _, ( 
MlyValue.dec dec1, dec1left, _)) :: rest671)) => let val  result = 
MlyValue.decs (fn _ => let val  (dec as dec1) = dec1 ()
 val  (decs as decs1) = decs1 ()
 in (dec @ decs)
end)
 in ( LrTable.NT 15, ( result, dec1left, decs1right), rest671)
end
|  ( 63, ( ( _, ( MlyValue.modl modl1, _, modl1right)) :: _ :: ( _, ( 
MlyValue.path path1, _, _)) :: ( _, ( _, (MODULEleft as MODULE1left),
 _)) :: rest671)) => let val  result = MlyValue.dec (fn _ => let val 
 (path as path1) = path1 ()
 val  (modl as modl1) = modl1 ()
 in ([nested MODULEleft path modl])
end)
 in ( LrTable.NT 14, ( result, MODULE1left, modl1right), rest671)
end
|  ( 64, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.path path1, _, _)) :: ( _, ( _, (MODULEleft
 as MODULE1left), _)) :: rest671)) => let val  result = MlyValue.dec
 (fn _ => let val  (path as path1) = path1 ()
 val  (modl as modl1) = modl1 ()
 in ([nested MODULEleft path ($MODULEleft modlright NewM(modl))])
end)
 in ( LrTable.NT 14, ( result, MODULE1left, modl1right), rest671)
end
|  ( 65, ( ( _, ( MlyValue.modl modl2, _, modl2right)) :: _ :: ( _, ( 
MlyValue.modl modl1, _, modlright)) :: _ :: ( _, ( MlyValue.path path1
, _, _)) :: ( _, ( _, (MODULEleft as MODULE1left), _)) :: rest671)) =>
 let val  result = MlyValue.dec (fn _ => let val  (path as path1) = 
path1 ()
 val  modl1 = modl1 ()
 val  modl2 = modl2 ()
 in (
[nested MODULEleft path ($MODULEleft modlright NewM(modl1)), nested MODULEleft path modl2]
)
end)
 in ( LrTable.NT 14, ( result, MODULE1left, modl2right), rest671)
end
|  ( 66, ( ( _, ( MlyValue.exp exp1, _, (expright as exp1right))) :: _
 :: ( _, ( MlyValue.params params1, _, _)) :: ( _, ( MlyValue.gens 
gens1, _, _)) :: ( _, ( MlyValue.path path1, _, _)) :: ( _, ( _, (
VALleft as VAL1left), _)) :: rest671)) => let val  result = 
MlyValue.dec (fn _ => let val  (path as path1) = path1 ()
 val  (gens as gens1) = gens1 ()
 val  (params as params1) = params1 ()
 val  (exp as exp1) = exp1 ()
 in (
[nested VALleft path ($VALleft expright ValM(genE gens (lambdaE params exp)))]
)
end)
 in ( LrTable.NT 14, ( result, VAL1left, exp1right), rest671)
end
|  ( 67, ( ( _, ( MlyValue.typ typ1, _, (typright as typ1right))) :: _
 :: ( _, ( MlyValue.params params1, _, _)) :: ( _, ( MlyValue.gens 
gens1, _, _)) :: ( _, ( MlyValue.path path1, _, _)) :: ( _, ( _, (
VALleft as VAL1left), _)) :: rest671)) => let val  result = 
MlyValue.dec (fn _ => let val  (path as path1) = path1 ()
 val  (gens as gens1) = gens1 ()
 val  (params as params1) = params1 ()
 val  (typ as typ1) = typ1 ()
 in (
[nested VALleft path ($VALleft typright AbsValM(univT gens (arrowT params typ)))]
)
end)
 in ( LrTable.NT 14, ( result, VAL1left, typ1right), rest671)
end
|  ( 68, ( ( _, ( MlyValue.typ typ1, _, (typright as typ1right))) :: _
 :: ( _, ( MlyValue.gens gens1, _, _)) :: ( _, ( MlyValue.path path1,
 _, _)) :: ( _, ( _, (TYPEleft as TYPE1left), _)) :: rest671)) => let
 val  result = MlyValue.dec (fn _ => let val  (path as path1) = path1
 ()
 val  (gens as gens1) = gens1 ()
 val  (typ as typ1) = typ1 ()
 in (
[nested TYPEleft path ($TYPEleft typright TypM(lambdaT gens typ))])

end)
 in ( LrTable.NT 14, ( result, TYPE1left, typ1right), rest671)
end
|  ( 69, ( ( _, ( MlyValue.kind kind1, _, (kindright as kind1right)))
 :: _ :: ( _, ( MlyValue.gens gens1, _, _)) :: ( _, ( MlyValue.path 
path1, _, _)) :: ( _, ( _, (TYPEleft as TYPE1left), _)) :: rest671))
 => let val  result = MlyValue.dec (fn _ => let val  (path as path1) =
 path1 ()
 val  (gens as gens1) = gens1 ()
 val  (kind as kind1) = kind1 ()
 in (
[nested TYPEleft path ($TYPEleft kindright AbsTypM(arrowK gens kind))]
)
end)
 in ( LrTable.NT 14, ( result, TYPE1left, kind1right), rest671)
end
|  ( 70, ( ( _, ( MlyValue.typ typ1, _, (typright as typ1right))) :: _
 :: ( _, ( MlyValue.gens gens1, _, _)) :: ( _, ( MlyValue.path path1,
 _, _)) :: ( _, ( _, (DATAleft as DATA1left), _)) :: rest671)) => let
 val  result = MlyValue.dec (fn _ => let val  (path as path1) = path1
 ()
 val  (gens as gens1) = gens1 ()
 val  (typ as typ1) = typ1 ()
 in (
[nested DATAleft path ($DATAleft typright DatTypM(lambdaT gens typ))])

end)
 in ( LrTable.NT 14, ( result, DATA1left, typ1right), rest671)
end
|  ( 71, ( ( _, ( MlyValue.typ typ1, _, (typright as typ1right))) :: _
 :: ( _, ( MlyValue.gens gens1, _, _)) :: ( _, ( MlyValue.path path1,
 _, _)) :: ( _, ( _, (DATAleft as DATA1left), _)) :: rest671)) => let
 val  result = MlyValue.dec (fn _ => let val  (path as path1) = path1
 ()
 val  (gens as gens1) = gens1 ()
 val  (typ as typ1) = typ1 ()
 in (
[nested DATAleft path ($DATAleft typright AbsDatTypM(lambdaT gens typ))]
)
end)
 in ( LrTable.NT 14, ( result, DATA1left, typ1right), rest671)
end
|  ( 72, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.path path1, _, _)) :: ( _, ( _, (UNITleft as 
UNIT1left), _)) :: rest671)) => let val  result = MlyValue.dec (fn _
 => let val  (path as path1) = path1 ()
 val  (modl as modl1) = modl1 ()
 in ([nested UNITleft path ($UNITleft modlright UnitM(modl))])
end)
 in ( LrTable.NT 14, ( result, UNIT1left, modl1right), rest671)
end
|  ( 73, ( ( _, ( MlyValue.sign sign1, _, (signright as sign1right)))
 :: _ :: ( _, ( MlyValue.path path1, _, _)) :: ( _, ( _, (UNITleft as 
UNIT1left), _)) :: rest671)) => let val  result = MlyValue.dec (fn _
 => let val  (path as path1) = path1 ()
 val  (sign as sign1) = sign1 ()
 in ([nested UNITleft path ($UNITleft signright AbsUnitM(sign))])
end)
 in ( LrTable.NT 14, ( result, UNIT1left, sign1right), rest671)
end
|  ( 74, ( ( _, ( _, COMMA1left, COMMA1right)) :: rest671)) => let
 val  result = MlyValue.dec (fn _ => ([]))
 in ( LrTable.NT 14, ( result, COMMA1left, COMMA1right), rest671)
end
|  ( 75, ( ( _, ( MlyValue.exp exp1, _, (expright as exp1right))) :: _
 :: ( _, ( MlyValue.typ typ1, _, typright)) :: _ :: ( _, ( 
MlyValue.params params1, _, _)) :: ( _, ( MlyValue.gens gens1, _, _))
 :: ( _, ( MlyValue.path path1, _, _)) :: ( _, ( _, (VALleft as 
VAL1left), _)) :: rest671)) => let val  result = MlyValue.dec (fn _ =>
 let val  (path as path1) = path1 ()
 val  (gens as gens1) = gens1 ()
 val  (params as params1) = params1 ()
 val  (typ as typ1) = typ1 ()
 val  (exp as exp1) = exp1 ()
 in (
[nested VALleft path ($VALleft typright AbsValM(univT gens (arrowT params typ))), nested VALleft path ($VALleft expright ValM(genE gens (lambdaE params exp)))]
)
end)
 in ( LrTable.NT 14, ( result, VAL1left, exp1right), rest671)
end
|  ( 76, ( ( _, ( MlyValue.typ typ1, _, (typright as typ1right))) :: _
 :: ( _, ( MlyValue.kind kind1, _, kindright)) :: _ :: ( _, ( 
MlyValue.gens gens1, _, _)) :: ( _, ( MlyValue.path path1, _, _)) :: (
 _, ( _, (TYPEleft as TYPE1left), _)) :: rest671)) => let val  result
 = MlyValue.dec (fn _ => let val  (path as path1) = path1 ()
 val  (gens as gens1) = gens1 ()
 val  (kind as kind1) = kind1 ()
 val  (typ as typ1) = typ1 ()
 in (
[nested TYPEleft path ($TYPEleft kindright AbsTypM(arrowK gens kind)), nested TYPEleft path ($TYPEleft typright TypM(lambdaT gens typ))]
)
end)
 in ( LrTable.NT 14, ( result, TYPE1left, typ1right), rest671)
end
|  ( 77, ( ( _, ( MlyValue.gens gens1, _, gens1right)) :: ( _, ( 
MlyValue.path path1, pathleft, pathright)) :: ( _, ( _, (TYPEleft as 
TYPE1left), _)) :: rest671)) => let val  result = MlyValue.dec (fn _
 => let val  (path as path1) = path1 ()
 val  (gens as gens1) = gens1 ()
 in (
[nested TYPEleft path ($TYPEleft pathright AbsTypM(arrowK gens ($$pathleft pathright StarK)))]
)
end)
 in ( LrTable.NT 14, ( result, TYPE1left, gens1right), rest671)
end
|  ( 78, ( ( _, ( MlyValue.typ typ1, _, (typright as typ1right))) :: _
 :: ( _, ( MlyValue.kind kind1, _, kindright)) :: _ :: ( _, ( 
MlyValue.gens gens1, _, _)) :: ( _, ( MlyValue.path path1, _, _)) :: (
 _, ( _, (DATAleft as DATA1left), _)) :: rest671)) => let val  result
 = MlyValue.dec (fn _ => let val  (path as path1) = path1 ()
 val  (gens as gens1) = gens1 ()
 val  (kind as kind1) = kind1 ()
 val  (typ as typ1) = typ1 ()
 in (
[nested DATAleft path ($DATAleft kindright AbsTypM(arrowK gens kind)), nested DATAleft path ($DATAleft typright DatTypM(lambdaT gens typ))]
)
end)
 in ( LrTable.NT 14, ( result, DATA1left, typ1right), rest671)
end
|  ( 79, ( ( _, ( MlyValue.typ typ1, _, (typright as typ1right))) :: _
 :: ( _, ( MlyValue.kind kind1, _, kindright)) :: _ :: ( _, ( 
MlyValue.gens gens1, _, _)) :: ( _, ( MlyValue.path path1, _, _)) :: (
 _, ( _, (DATAleft as DATA1left), _)) :: rest671)) => let val  result
 = MlyValue.dec (fn _ => let val  (path as path1) = path1 ()
 val  (gens as gens1) = gens1 ()
 val  (kind as kind1) = kind1 ()
 val  (typ as typ1) = typ1 ()
 in (
[nested DATAleft path ($DATAleft kindright AbsTypM(arrowK gens kind)), nested DATAleft path ($DATAleft typright AbsDatTypM(lambdaT gens typ))]
)
end)
 in ( LrTable.NT 14, ( result, DATA1left, typ1right), rest671)
end
|  ( 80, ( ( _, ( MlyValue.modl modl1, _, (modlright as modl1right)))
 :: _ :: ( _, ( MlyValue.sign sign1, _, signright)) :: _ :: ( _, ( 
MlyValue.path path1, _, _)) :: ( _, ( _, (UNITleft as UNIT1left), _))
 :: rest671)) => let val  result = MlyValue.dec (fn _ => let val  (
path as path1) = path1 ()
 val  (sign as sign1) = sign1 ()
 val  (modl as modl1) = modl1 ()
 in (
[nested UNITleft path ($UNITleft signright AbsUnitM(sign)), nested UNITleft path ($UNITleft modlright UnitM(modl))]
)
end)
 in ( LrTable.NT 14, ( result, UNIT1left, modl1right), rest671)
end
|  ( 81, ( ( _, ( MlyValue.exp exp1, _, (expright as exp1right))) :: (
 _, ( _, (DOleft as DO1left), _)) :: rest671)) => let val  result = 
MlyValue.dec (fn _ => let val  (exp as exp1) = exp1 ()
 in ([(rename "_do", $DOleft expright ValM(exp))])
end)
 in ( LrTable.NT 14, ( result, DO1left, exp1right), rest671)
end
|  ( 82, ( rest671)) => let val  result = MlyValue.params (fn _ => ([]
))
 in ( LrTable.NT 16, ( result, defaultPos, defaultPos), rest671)
end
|  ( 83, ( ( _, ( MlyValue.params params1, _, params1right)) :: _ :: (
 _, ( MlyValue.typ typ1, _, _)) :: _ :: ( _, ( MlyValue.id id1, _, _))
 :: ( _, ( _, (LPARleft as LPAR1left), _)) :: rest671)) => let val  
result = MlyValue.params (fn _ => let val  (id as id1) = id1 ()
 val  (typ as typ1) = typ1 ()
 val  (params as params1) = params1 ()
 in ((LPARleft, id, typ)::params)
end)
 in ( LrTable.NT 16, ( result, LPAR1left, params1right), rest671)
end
|  ( 84, ( rest671)) => let val  result = MlyValue.gens (fn _ => (NONE
))
 in ( LrTable.NT 17, ( result, defaultPos, defaultPos), rest671)
end
|  ( 85, ( ( _, ( _, _, RBRACK1right)) :: ( _, ( MlyValue.typvar_list 
typvar_list1, _, _)) :: ( _, ( _, (LBRACKleft as LBRACK1left), _)) :: 
rest671)) => let val  result = MlyValue.gens (fn _ => let val  (
typvar_list as typvar_list1) = typvar_list1 ()
 in (SOME(LBRACKleft, typvar_list))
end)
 in ( LrTable.NT 17, ( result, LBRACK1left, RBRACK1right), rest671)

end
|  ( 86, ( ( _, ( _, _, RPAR2right)) :: _ :: ( _, ( MlyValue.labs_list
 labs_list1, _, _)) :: _ :: _ :: ( _, ( MlyValue.appmodl appmodl1, _,
 _)) :: ( _, ( _, LPAR1left, _)) :: rest671)) => let val  result = 
MlyValue.atsign (fn _ => let val  (appmodl as appmodl1) = appmodl1 ()
 val  (labs_list as labs_list1) = labs_list1 ()
 in ($LPAR1left RPAR2right ImportS(appmodl, labs_list))
end)
 in ( LrTable.NT 18, ( result, LPAR1left, RPAR2right), rest671)
end
|  ( 87, ( ( _, ( _, _, RPAR2right)) :: _ :: ( _, ( MlyValue.labs_list
 labs_list1, _, _)) :: _ :: _ :: ( _, ( MlyValue.appmodl appmodl1, _,
 _)) :: ( _, ( _, LPAR1left, _)) :: rest671)) => let val  result = 
MlyValue.atsign (fn _ => let val  (appmodl as appmodl1) = appmodl1 ()
 val  (labs_list as labs_list1) = labs_list1 ()
 in ($LPAR1left RPAR2right ExportS(appmodl, labs_list))
end)
 in ( LrTable.NT 18, ( result, LPAR1left, RPAR2right), rest671)
end
|  ( 88, ( ( _, ( MlyValue.atsign atsign1, atsign1left, atsign1right))
 :: rest671)) => let val  result = MlyValue.appsign (fn _ => let val 
 (atsign as atsign1) = atsign1 ()
 in (atsign)
end)
 in ( LrTable.NT 19, ( result, atsign1left, atsign1right), rest671)

end
|  ( 89, ( ( _, ( MlyValue.appsign appsign1, appsign1left, 
appsign1right)) :: rest671)) => let val  result = MlyValue.sign (fn _
 => let val  (appsign as appsign1) = appsign1 ()
 in (appsign)
end)
 in ( LrTable.NT 21, ( result, appsign1left, appsign1right), rest671)

end
|  ( 90, ( ( _, ( _, _, (RPARright as RPAR1right))) :: ( _, ( 
MlyValue.labs_list labs_list1, _, _)) :: _ :: _ :: ( _, ( 
MlyValue.appmodl appmodl1, (appmodlleft as appmodl1left), _)) :: 
rest671)) => let val  result = MlyValue.sign (fn _ => let val  (
appmodl as appmodl1) = appmodl1 ()
 val  (labs_list as labs_list1) = labs_list1 ()
 in ($appmodlleft RPARright ImportS(appmodl, labs_list))
end)
 in ( LrTable.NT 21, ( result, appmodl1left, RPAR1right), rest671)
end
|  ( 91, ( ( _, ( _, _, (RPARright as RPAR1right))) :: ( _, ( 
MlyValue.labs_list labs_list1, _, _)) :: _ :: _ :: ( _, ( 
MlyValue.appmodl appmodl1, (appmodlleft as appmodl1left), _)) :: 
rest671)) => let val  result = MlyValue.sign (fn _ => let val  (
appmodl as appmodl1) = appmodl1 ()
 val  (labs_list as labs_list1) = labs_list1 ()
 in ($appmodlleft RPARright ExportS(appmodl, labs_list))
end)
 in ( LrTable.NT 21, ( result, appmodl1left, RPAR1right), rest671)
end
|  ( 92, ( ( _, ( MlyValue.appmodl appmodl1, (appmodlleft as 
appmodl1left), (appmodlright as appmodl1right))) :: rest671)) => let
 val  result = MlyValue.sign (fn _ => let val  (appmodl as appmodl1) =
 appmodl1 ()
 in ($appmodlleft appmodlright ImportS(appmodl, []))
end)
 in ( LrTable.NT 21, ( result, appmodl1left, appmodl1right), rest671)

end
|  ( 93, ( ( _, ( _, (HASHleft as HASH1left), (HASHright as HASH1right
))) :: rest671)) => let val  result = MlyValue.kind (fn _ => (
$$HASHleft HASHright StarK))
 in ( LrTable.NT 30, ( result, HASH1left, HASH1right), rest671)
end
|  ( 94, ( ( _, ( _, _, HASH2right)) :: _ :: ( _, ( MlyValue.NUM NUM1,
 _, _)) :: ( _, ( _, HASH1left, _)) :: rest671)) => let val  result = 
MlyValue.kind (fn _ => let val  (NUM as NUM1) = NUM1 ()
 in ($HASH1left HASH2right ArrowK(NUM))
end)
 in ( LrTable.NT 30, ( result, HASH1left, HASH2right), rest671)
end
|  ( 95, ( ( _, ( _, _, HASH2right)) :: _ :: ( _, ( _, HASH1left, _))
 :: rest671)) => let val  result = MlyValue.kind (fn _ => (
$HASH1left HASH2right ArrowK(1)))
 in ( LrTable.NT 30, ( result, HASH1left, HASH2right), rest671)
end
|  ( 96, ( ( _, ( _, _, (RPARright as RPAR1right))) :: ( _, ( 
MlyValue.typ_list typ_list1, _, _)) :: ( _, ( _, (LPARleft as 
LPAR1left), _)) :: rest671)) => let val  result = MlyValue.attyp (fn _
 => let val  (typ_list as typ_list1) = typ_list1 ()
 in (
case typ_list of [typ] => typ | _ => $LPARleft RPARright TupleT(typ_list)
)
end)
 in ( LrTable.NT 22, ( result, LPAR1left, RPAR1right), rest671)
end
|  ( 97, ( ( _, ( _, _, (RPARright as RPAR1right))) :: ( _, ( 
MlyValue.typ_barlist2 typ_barlist21, _, _)) :: ( _, ( _, (LPARleft as 
LPAR1left), _)) :: rest671)) => let val  result = MlyValue.attyp (fn _
 => let val  (typ_barlist2 as typ_barlist21) = typ_barlist21 ()
 in ($LPARleft RPARright VariantT(typ_barlist2))
end)
 in ( LrTable.NT 22, ( result, LPAR1left, RPAR1right), rest671)
end
|  ( 98, ( ( _, ( _, (INTleft as INT1left), (INTright as INT1right)))
 :: rest671)) => let val  result = MlyValue.attyp (fn _ => (
$$INTleft INTright IntT))
 in ( LrTable.NT 22, ( result, INT1left, INT1right), rest671)
end
|  ( 99, ( ( _, ( _, (STRINGleft as STRING1left), (STRINGright as 
STRING1right))) :: rest671)) => let val  result = MlyValue.attyp (fn _
 => ($$STRINGleft STRINGright StringT))
 in ( LrTable.NT 22, ( result, STRING1left, STRING1right), rest671)

end
|  ( 100, ( ( _, ( MlyValue.atmodl atmodl1, _, (atmodlright as 
atmodl1right))) :: ( _, ( _, (BANGleft as BANG1left), _)) :: rest671))
 => let val  result = MlyValue.attyp (fn _ => let val  (atmodl as 
atmodl1) = atmodl1 ()
 in ($BANGleft atmodlright ModT(atmodl))
end)
 in ( LrTable.NT 22, ( result, BANG1left, atmodl1right), rest671)
end
|  ( 101, ( ( _, ( _, (BOOLleft as BOOL1left), (BOOLright as 
BOOL1right))) :: rest671)) => let val  result = MlyValue.attyp (fn _
 => (
$BOOLleft BOOLright VariantT[$BOOLleft BOOLright TupleT[], $BOOLleft BOOLright TupleT[]]
))
 in ( LrTable.NT 22, ( result, BOOL1left, BOOL1right), rest671)
end
|  ( 102, ( ( _, ( MlyValue.path path1, (pathleft as path1left), (
pathright as path1right))) :: rest671)) => let val  result = 
MlyValue.attyp (fn _ => let val  (path as path1) = path1 ()
 in ($pathleft pathright ModT(pathM pathleft pathright path))
end)
 in ( LrTable.NT 22, ( result, path1left, path1right), rest671)
end
|  ( 103, ( ( _, ( MlyValue.attyp attyp1, attyp1left, attyp1right)) ::
 rest671)) => let val  result = MlyValue.apptyp (fn _ => let val  (
attyp as attyp1) = attyp1 ()
 in (attyp)
end)
 in ( LrTable.NT 23, ( result, attyp1left, attyp1right), rest671)
end
|  ( 104, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.typ_list typ_list1, _, _)) :: _ :: ( _, ( MlyValue.apptyp 
apptyp1, (apptypleft as apptyp1left), _)) :: rest671)) => let val  
result = MlyValue.apptyp (fn _ => let val  (apptyp as apptyp1) = 
apptyp1 ()
 val  (typ_list as typ_list1) = typ_list1 ()
 in ($apptypleft RBRACKright ApplyT(apptyp, typ_list))
end)
 in ( LrTable.NT 23, ( result, apptyp1left, RBRACK1right), rest671)

end
|  ( 105, ( ( _, ( MlyValue.apptyp apptyp1, apptyp1left, apptyp1right)
) :: rest671)) => let val  result = MlyValue.inftyp (fn _ => let val 
 (apptyp as apptyp1) = apptyp1 ()
 in (apptyp)
end)
 in ( LrTable.NT 24, ( result, apptyp1left, apptyp1right), rest671)

end
|  ( 106, ( ( _, ( MlyValue.inftyp inftyp1, _, (inftypright as 
inftyp1right))) :: _ :: ( _, ( MlyValue.apptyp apptyp1, (apptypleft
 as apptyp1left), _)) :: rest671)) => let val  result = 
MlyValue.inftyp (fn _ => let val  (apptyp as apptyp1) = apptyp1 ()
 val  (inftyp as inftyp1) = inftyp1 ()
 in ($apptypleft inftypright ArrowT(apptyp, inftyp))
end)
 in ( LrTable.NT 24, ( result, apptyp1left, inftyp1right), rest671)

end
|  ( 107, ( ( _, ( MlyValue.inftyp inftyp1, inftyp1left, inftyp1right)
) :: rest671)) => let val  result = MlyValue.typ (fn _ => let val  (
inftyp as inftyp1) = inftyp1 ()
 in (inftyp)
end)
 in ( LrTable.NT 25, ( result, inftyp1left, inftyp1right), rest671)

end
|  ( 108, ( ( _, ( MlyValue.typ typ1, _, (typright as typ1right))) ::
 _ :: _ :: ( _, ( MlyValue.typvar_list typvar_list1, _, _)) :: _ :: (
 _, ( _, (FORALLleft as FORALL1left), _)) :: rest671)) => let val  
result = MlyValue.typ (fn _ => let val  (typvar_list as typvar_list1)
 = typvar_list1 ()
 val  (typ as typ1) = typ1 ()
 in ($FORALLleft typright UnivT(typvar_list, typ))
end)
 in ( LrTable.NT 25, ( result, FORALL1left, typ1right), rest671)
end
|  ( 109, ( ( _, ( MlyValue.typ typ1, _, (typright as typ1right))) ::
 _ :: _ :: ( _, ( MlyValue.typvar_list typvar_list1, _, _)) :: _ :: (
 _, ( _, (FNleft as FN1left), _)) :: rest671)) => let val  result = 
MlyValue.typ (fn _ => let val  (typvar_list as typvar_list1) = 
typvar_list1 ()
 val  (typ as typ1) = typ1 ()
 in ($FNleft typright LambdaT(typvar_list, typ))
end)
 in ( LrTable.NT 25, ( result, FN1left, typ1right), rest671)
end
|  ( 110, ( rest671)) => let val  result = MlyValue.typ_list (fn _ =>
 ([]))
 in ( LrTable.NT 26, ( result, defaultPos, defaultPos), rest671)
end
|  ( 111, ( ( _, ( MlyValue.typ_list1 typ_list11, typ_list11left, 
typ_list11right)) :: rest671)) => let val  result = MlyValue.typ_list
 (fn _ => let val  (typ_list1 as typ_list11) = typ_list11 ()
 in (typ_list1)
end)
 in ( LrTable.NT 26, ( result, typ_list11left, typ_list11right), 
rest671)
end
|  ( 112, ( ( _, ( MlyValue.typ typ1, typ1left, typ1right)) :: rest671
)) => let val  result = MlyValue.typ_list1 (fn _ => let val  (typ as 
typ1) = typ1 ()
 in (typ::[])
end)
 in ( LrTable.NT 27, ( result, typ1left, typ1right), rest671)
end
|  ( 113, ( ( _, ( MlyValue.typ_list1 typ_list11, _, typ_list11right))
 :: _ :: ( _, ( MlyValue.typ typ1, typ1left, _)) :: rest671)) => let
 val  result = MlyValue.typ_list1 (fn _ => let val  (typ as typ1) = 
typ1 ()
 val  (typ_list1 as typ_list11) = typ_list11 ()
 in (typ::typ_list1)
end)
 in ( LrTable.NT 27, ( result, typ1left, typ_list11right), rest671)

end
|  ( 114, ( ( _, ( MlyValue.typ typ1, typ1left, typ1right)) :: rest671
)) => let val  result = MlyValue.typ_barlist1 (fn _ => let val  (typ
 as typ1) = typ1 ()
 in (typ::[])
end)
 in ( LrTable.NT 28, ( result, typ1left, typ1right), rest671)
end
|  ( 115, ( ( _, ( MlyValue.typ_barlist1 typ_barlist11, _, 
typ_barlist11right)) :: _ :: ( _, ( MlyValue.typ typ1, typ1left, _))
 :: rest671)) => let val  result = MlyValue.typ_barlist1 (fn _ => let
 val  (typ as typ1) = typ1 ()
 val  (typ_barlist1 as typ_barlist11) = typ_barlist11 ()
 in (typ::typ_barlist1)
end)
 in ( LrTable.NT 28, ( result, typ1left, typ_barlist11right), rest671)

end
|  ( 116, ( ( _, ( MlyValue.typ_barlist1 typ_barlist11, _, 
typ_barlist11right)) :: _ :: ( _, ( MlyValue.typ typ1, typ1left, _))
 :: rest671)) => let val  result = MlyValue.typ_barlist2 (fn _ => let
 val  (typ as typ1) = typ1 ()
 val  (typ_barlist1 as typ_barlist11) = typ_barlist11 ()
 in (typ::typ_barlist1)
end)
 in ( LrTable.NT 29, ( result, typ1left, typ_barlist11right), rest671)

end
|  ( 117, ( ( _, ( _, _, (RPARright as RPAR1right))) :: ( _, ( 
MlyValue.exp_list exp_list1, _, _)) :: ( _, ( _, (LPARleft as 
LPAR1left), _)) :: rest671)) => let val  result = MlyValue.atexp (fn _
 => let val  (exp_list as exp_list1) = exp_list1 ()
 in (
case exp_list of [exp] => exp | _ => $LPARleft RPARright TupleE(exp_list)
)
end)
 in ( LrTable.NT 31, ( result, LPAR1left, RPAR1right), rest671)
end
|  ( 118, ( ( _, ( MlyValue.lit lit1, lit1left, lit1right)) :: rest671
)) => let val  result = MlyValue.atexp (fn _ => let val  (lit as lit1)
 = lit1 ()
 in (lit)
end)
 in ( LrTable.NT 31, ( result, lit1left, lit1right), rest671)
end
|  ( 119, ( ( _, ( MlyValue.atmodl atmodl1, _, (atmodlright as 
atmodl1right))) :: ( _, ( _, (BANGleft as BANG1left), _)) :: rest671))
 => let val  result = MlyValue.atexp (fn _ => let val  (atmodl as 
atmodl1) = atmodl1 ()
 in ($BANGleft atmodlright ModE(atmodl))
end)
 in ( LrTable.NT 31, ( result, BANG1left, atmodl1right), rest671)
end
|  ( 120, ( ( _, ( MlyValue.path path1, (pathleft as path1left), (
pathright as path1right))) :: rest671)) => let val  result = 
MlyValue.atexp (fn _ => let val  (path as path1) = path1 ()
 in ($pathleft pathright ModE(pathM pathleft pathright path))
end)
 in ( LrTable.NT 31, ( result, path1left, path1right), rest671)
end
|  ( 121, ( ( _, ( _, _, (RPARright as RPAR1right))) :: ( _, ( 
MlyValue.typ typ1, _, typright)) :: ( _, ( _, COLONleft, _)) :: ( _, (
 MlyValue.exp exp1, expleft, expright)) :: ( _, ( _, (LPARleft as 
LPAR1left), _)) :: rest671)) => let val  result = MlyValue.atexp (fn _
 => let val  (exp as exp1) = exp1 ()
 val  (typ as typ1) = typ1 ()
 in (
let val x = rename "_colon" in $LPARleft RPARright LetE(x, $LPARleft RPARright LinkM(rename "_val", $expleft expright ValM(exp), $COLONleft typright AbsValM(typ)), $LPARleft RPARright ModE($LPARleft RPARright VarM(x))) end
)
end)
 in ( LrTable.NT 31, ( result, LPAR1left, RPAR1right), rest671)
end
|  ( 122, ( ( _, ( MlyValue.atexp atexp1, atexp1left, atexp1right)) ::
 rest671)) => let val  result = MlyValue.appexp (fn _ => let val  (
atexp as atexp1) = atexp1 ()
 in (atexp)
end)
 in ( LrTable.NT 32, ( result, atexp1left, atexp1right), rest671)
end
|  ( 123, ( ( _, ( MlyValue.atexp atexp1, _, (atexpright as 
atexp1right))) :: ( _, ( MlyValue.appexp appexp1, (appexpleft as 
appexp1left), _)) :: rest671)) => let val  result = MlyValue.appexp
 (fn _ => let val  (appexp as appexp1) = appexp1 ()
 val  (atexp as atexp1) = atexp1 ()
 in ($appexpleft atexpright ApplyE(appexp, atexp))
end)
 in ( LrTable.NT 32, ( result, appexp1left, atexp1right), rest671)
end
|  ( 124, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.typ_list typ_list1, _, _)) :: _ :: ( _, ( MlyValue.appexp 
appexp1, (appexpleft as appexp1left), _)) :: rest671)) => let val  
result = MlyValue.appexp (fn _ => let val  (appexp as appexp1) = 
appexp1 ()
 val  (typ_list as typ_list1) = typ_list1 ()
 in ($appexpleft RBRACKright InstE(appexp, typ_list))
end)
 in ( LrTable.NT 32, ( result, appexp1left, RBRACK1right), rest671)

end
|  ( 125, ( ( _, ( MlyValue.atexp atexp1, _, (atexpright as 
atexp1right))) :: _ :: ( _, ( MlyValue.typ_list typ_list1, _, _)) :: _
 :: ( _, ( MlyValue.appmodl appmodl1, _, _)) :: ( _, ( _, (INleft as 
IN1left), _)) :: rest671)) => let val  result = MlyValue.appexp (fn _
 => let val  (appmodl as appmodl1) = appmodl1 ()
 val  (typ_list as typ_list1) = typ_list1 ()
 val  (atexp as atexp1) = atexp1 ()
 in ($INleft atexpright FoldE(appmodl, typ_list, atexp))
end)
 in ( LrTable.NT 32, ( result, IN1left, atexp1right), rest671)
end
|  ( 126, ( ( _, ( MlyValue.atexp atexp1, _, (atexpright as 
atexp1right))) :: _ :: ( _, ( MlyValue.typ_list typ_list1, _, _)) :: _
 :: ( _, ( MlyValue.appmodl appmodl1, _, _)) :: ( _, ( _, (OUTleft as 
OUT1left), _)) :: rest671)) => let val  result = MlyValue.appexp (fn _
 => let val  (appmodl as appmodl1) = appmodl1 ()
 val  (typ_list as typ_list1) = typ_list1 ()
 val  (atexp as atexp1) = atexp1 ()
 in ($OUTleft atexpright UnfoldE(appmodl, typ_list, atexp))
end)
 in ( LrTable.NT 32, ( result, OUT1left, atexp1right), rest671)
end
|  ( 127, ( ( _, ( MlyValue.NUM NUM1, _, (NUMright as NUM1right))) ::
 _ :: ( _, ( MlyValue.appexp appexp1, (appexpleft as appexp1left), _))
 :: rest671)) => let val  result = MlyValue.appexp (fn _ => let val  (
appexp as appexp1) = appexp1 ()
 val  (NUM as NUM1) = NUM1 ()
 in ($appexpleft NUMright ProjE(appexp, NUM))
end)
 in ( LrTable.NT 32, ( result, appexp1left, NUM1right), rest671)
end
|  ( 128, ( ( _, ( MlyValue.atexp atexp1, _, (atexpright as 
atexp1right))) :: ( _, ( _, (PRINTleft as PRINT1left), _)) :: rest671)
) => let val  result = MlyValue.appexp (fn _ => let val  (atexp as 
atexp1) = atexp1 ()
 in ($PRINTleft atexpright PrintE(atexp))
end)
 in ( LrTable.NT 32, ( result, PRINT1left, atexp1right), rest671)
end
|  ( 129, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.typ typ1, _, _)) :: _ :: ( _, ( MlyValue.NUM NUM1, _, _)) ::
 _ :: ( _, ( MlyValue.appexp appexp1, (appexpleft as appexp1left), _))
 :: rest671)) => let val  result = MlyValue.appexp (fn _ => let val  (
appexp as appexp1) = appexp1 ()
 val  (NUM as NUM1) = NUM1 ()
 val  (typ as typ1) = typ1 ()
 in ($appexpleft RBRACKright InjE(appexp, NUM, typ))
end)
 in ( LrTable.NT 32, ( result, appexp1left, RBRACK1right), rest671)

end
|  ( 130, ( ( _, ( _, _, (RBRACKright as RBRACK1right))) :: ( _, ( 
MlyValue.typ typ1, _, _)) :: _ :: ( _, ( MlyValue.NUM NUM1, _, _)) :: 
( _, ( _, (ATleft as AT1left), ATright)) :: rest671)) => let val  
result = MlyValue.appexp (fn _ => let val  (NUM as NUM1) = NUM1 ()
 val  (typ as typ1) = typ1 ()
 in ($ATleft RBRACKright InjE($ATleft ATright TupleE[], NUM, typ))
end
)
 in ( LrTable.NT 32, ( result, AT1left, RBRACK1right), rest671)
end
|  ( 131, ( ( _, ( MlyValue.appexp appexp1, appexp1left, appexp1right)
) :: rest671)) => let val  result = MlyValue.plusexp (fn _ => let val 
 (appexp as appexp1) = appexp1 ()
 in (appexp)
end)
 in ( LrTable.NT 33, ( result, appexp1left, appexp1right), rest671)

end
|  ( 132, ( ( _, ( MlyValue.appexp appexp1, _, (appexpright as 
appexp1right))) :: _ :: ( _, ( MlyValue.plusexp plusexp1, (plusexpleft
 as plusexp1left), _)) :: rest671)) => let val  result = 
MlyValue.plusexp (fn _ => let val  (plusexp as plusexp1) = plusexp1 ()
 val  (appexp as appexp1) = appexp1 ()
 in ($plusexpleft appexpright PlusE(plusexp, appexp))
end)
 in ( LrTable.NT 33, ( result, plusexp1left, appexp1right), rest671)

end
|  ( 133, ( ( _, ( MlyValue.appexp appexp1, _, (appexpright as 
appexp1right))) :: _ :: ( _, ( MlyValue.plusexp plusexp1, (plusexpleft
 as plusexp1left), _)) :: rest671)) => let val  result = 
MlyValue.plusexp (fn _ => let val  (plusexp as plusexp1) = plusexp1 ()
 val  (appexp as appexp1) = appexp1 ()
 in ($plusexpleft appexpright MinusE(plusexp, appexp))
end)
 in ( LrTable.NT 33, ( result, plusexp1left, appexp1right), rest671)

end
|  ( 134, ( ( _, ( MlyValue.appexp appexp1, _, (appexpright as 
appexp1right))) :: _ :: ( _, ( MlyValue.plusexp plusexp1, (plusexpleft
 as plusexp1left), _)) :: rest671)) => let val  result = 
MlyValue.plusexp (fn _ => let val  (plusexp as plusexp1) = plusexp1 ()
 val  (appexp as appexp1) = appexp1 ()
 in ($plusexpleft appexpright CatE(plusexp, appexp))
end)
 in ( LrTable.NT 33, ( result, plusexp1left, appexp1right), rest671)

end
|  ( 135, ( ( _, ( MlyValue.plusexp plusexp1, plusexp1left, 
plusexp1right)) :: rest671)) => let val  result = MlyValue.infexp (fn
 _ => let val  (plusexp as plusexp1) = plusexp1 ()
 in (plusexp)
end)
 in ( LrTable.NT 34, ( result, plusexp1left, plusexp1right), rest671)

end
|  ( 136, ( ( _, ( MlyValue.plusexp plusexp2, _, plusexp2right)) :: _
 :: ( _, ( MlyValue.plusexp plusexp1, plusexp1left, _)) :: rest671))
 => let val  result = MlyValue.infexp (fn _ => let val  plusexp1 = 
plusexp1 ()
 val  plusexp2 = plusexp2 ()
 in ($plusexp1left plusexp2right EqualE(plusexp1, plusexp2))
end)
 in ( LrTable.NT 34, ( result, plusexp1left, plusexp2right), rest671)

end
|  ( 137, ( ( _, ( MlyValue.plusexp plusexp2, _, plusexp2right)) :: _
 :: ( _, ( MlyValue.plusexp plusexp1, plusexp1left, _)) :: rest671))
 => let val  result = MlyValue.infexp (fn _ => let val  plusexp1 = 
plusexp1 ()
 val  plusexp2 = plusexp2 ()
 in ($plusexp1left plusexp2right LessE(plusexp1, plusexp2))
end)
 in ( LrTable.NT 34, ( result, plusexp1left, plusexp2right), rest671)

end
|  ( 138, ( ( _, ( MlyValue.infexp infexp1, infexp1left, infexp1right)
) :: rest671)) => let val  result = MlyValue.exp (fn _ => let val  (
infexp as infexp1) = infexp1 ()
 in (infexp)
end)
 in ( LrTable.NT 35, ( result, infexp1left, infexp1right), rest671)

end
|  ( 139, ( ( _, ( MlyValue.idexp_barlist1 idexp_barlist11, _, (
idexp_barlist1right as idexp_barlist11right))) :: _ :: ( _, ( 
MlyValue.exp exp1, _, _)) :: ( _, ( _, (CASEleft as CASE1left), _)) ::
 rest671)) => let val  result = MlyValue.exp (fn _ => let val  (exp
 as exp1) = exp1 ()
 val  (idexp_barlist1 as idexp_barlist11) = idexp_barlist11 ()
 in ($CASEleft idexp_barlist1right CaseE(exp, idexp_barlist1))
end)
 in ( LrTable.NT 35, ( result, CASE1left, idexp_barlist11right), 
rest671)
end
|  ( 140, ( ( _, ( MlyValue.exp exp1, _, (expright as exp1right))) ::
 _ :: ( _, ( MlyValue.apptyp apptyp1, _, _)) :: _ :: ( _, ( 
MlyValue.id id1, _, _)) :: ( _, ( _, (FNleft as FN1left), _)) :: 
rest671)) => let val  result = MlyValue.exp (fn _ => let val  (id as 
id1) = id1 ()
 val  (apptyp as apptyp1) = apptyp1 ()
 val  (exp as exp1) = exp1 ()
 in ($FNleft expright LambdaE(id, apptyp, exp))
end)
 in ( LrTable.NT 35, ( result, FN1left, exp1right), rest671)
end
|  ( 141, ( ( _, ( MlyValue.exp exp1, _, (expright as exp1right))) ::
 _ :: _ :: ( _, ( MlyValue.typvar_list typvar_list1, _, _)) :: _ :: (
 _, ( _, (FNleft as FN1left), _)) :: rest671)) => let val  result = 
MlyValue.exp (fn _ => let val  (typvar_list as typvar_list1) = 
typvar_list1 ()
 val  (exp as exp1) = exp1 ()
 in ($FNleft expright GenE(typvar_list, exp))
end)
 in ( LrTable.NT 35, ( result, FN1left, exp1right), rest671)
end
|  ( 142, ( ( _, ( MlyValue.exp exp1, _, (expright as exp1right))) ::
 _ :: ( _, ( MlyValue.decs decs1, _, _)) :: ( _, ( _, (LETleft as 
LET1left), _)) :: rest671)) => let val  result = MlyValue.exp (fn _ =>
 let val  (decs as decs1) = decs1 ()
 val  (exp as exp1) = exp1 ()
 in (lete LETleft expright (decs, exp))
end)
 in ( LrTable.NT 35, ( result, LET1left, exp1right), rest671)
end
|  ( 143, ( ( _, ( MlyValue.exp exp3, _, exp3right)) :: _ :: ( _, ( 
MlyValue.exp exp2, _, _)) :: _ :: ( _, ( MlyValue.exp exp1, _, _)) :: 
( _, ( _, (IFleft as IF1left), _)) :: rest671)) => let val  result = 
MlyValue.exp (fn _ => let val  exp1 = exp1 ()
 val  exp2 = exp2 ()
 val  exp3 = exp3 ()
 in (
$IFleft exp3right CaseE(exp1, [(rename "_then", exp3), (rename "_else", exp2)])
)
end)
 in ( LrTable.NT 35, ( result, IF1left, exp3right), rest671)
end
|  ( 144, ( ( _, ( MlyValue.exp exp2, _, exp2right)) :: _ :: ( _, ( 
MlyValue.exp exp1, expleft, expright)) :: _ :: ( _, ( MlyValue.id id1,
 _, _)) :: ( _, ( _, (LETleft as LET1left), _)) :: rest671)) => let
 val  result = MlyValue.exp (fn _ => let val  (id as id1) = id1 ()
 val  exp1 = exp1 ()
 val  exp2 = exp2 ()
 in ($LETleft expright LetE(id, $expleft expright ValM(exp1), exp2))

end)
 in ( LrTable.NT 35, ( result, LET1left, exp2right), rest671)
end
|  ( 145, ( ( _, ( MlyValue.exp exp1, _, (expright as exp1right))) ::
 _ :: ( _, ( MlyValue.infexp infexp1, (infexpleft as infexp1left), 
infexpright)) :: rest671)) => let val  result = MlyValue.exp (fn _ =>
 let val  (infexp as infexp1) = infexp1 ()
 val  (exp as exp1) = exp1 ()
 in (
$infexpleft expright LetE(rename "_seq", $infexpleft infexpright ValM(infexp), exp)
)
end)
 in ( LrTable.NT 35, ( result, infexp1left, exp1right), rest671)
end
|  ( 146, ( rest671)) => let val  result = MlyValue.exp_list (fn _ =>
 ([]))
 in ( LrTable.NT 36, ( result, defaultPos, defaultPos), rest671)
end
|  ( 147, ( ( _, ( MlyValue.exp_list1 exp_list11, exp_list11left, 
exp_list11right)) :: rest671)) => let val  result = MlyValue.exp_list
 (fn _ => let val  (exp_list1 as exp_list11) = exp_list11 ()
 in (exp_list1)
end)
 in ( LrTable.NT 36, ( result, exp_list11left, exp_list11right), 
rest671)
end
|  ( 148, ( ( _, ( MlyValue.exp exp1, exp1left, exp1right)) :: rest671
)) => let val  result = MlyValue.exp_list1 (fn _ => let val  (exp as 
exp1) = exp1 ()
 in (exp::[])
end)
 in ( LrTable.NT 37, ( result, exp1left, exp1right), rest671)
end
|  ( 149, ( ( _, ( MlyValue.exp_list1 exp_list11, _, exp_list11right))
 :: _ :: ( _, ( MlyValue.exp exp1, exp1left, _)) :: rest671)) => let
 val  result = MlyValue.exp_list1 (fn _ => let val  (exp as exp1) = 
exp1 ()
 val  (exp_list1 as exp_list11) = exp_list11 ()
 in (exp::exp_list1)
end)
 in ( LrTable.NT 37, ( result, exp1left, exp_list11right), rest671)

end
|  ( 150, ( ( _, ( MlyValue.exp exp1, _, exp1right)) :: _ :: ( _, ( 
MlyValue.id id1, id1left, _)) :: rest671)) => let val  result = 
MlyValue.idexp_barlist1 (fn _ => let val  (id as id1) = id1 ()
 val  (exp as exp1) = exp1 ()
 in ((id, exp)::[])
end)
 in ( LrTable.NT 38, ( result, id1left, exp1right), rest671)
end
|  ( 151, ( ( _, ( MlyValue.idexp_barlist1 idexp_barlist11, _, 
idexp_barlist11right)) :: _ :: ( _, ( MlyValue.infexp infexp1, _, _))
 :: _ :: ( _, ( MlyValue.id id1, id1left, _)) :: rest671)) => let val 
 result = MlyValue.idexp_barlist1 (fn _ => let val  (id as id1) = id1
 ()
 val  (infexp as infexp1) = infexp1 ()
 val  (idexp_barlist1 as idexp_barlist11) = idexp_barlist11 ()
 in ((id, infexp)::idexp_barlist1)
end)
 in ( LrTable.NT 38, ( result, id1left, idexp_barlist11right), rest671
)
end
|  ( 152, ( ( _, ( MlyValue.decs decs1, (decsleft as decs1left), (
decsright as decs1right))) :: rest671)) => let val  result = 
MlyValue.prog (fn _ => let val  (decs as decs1) = decs1 ()
 in (struc decsleft decsright decs)
end)
 in ( LrTable.NT 39, ( result, decs1left, decs1right), rest671)
end
|  ( 153, ( ( _, ( MlyValue.modl modl1, (modlleft as modl1left), (
modlright as modl1right))) :: rest671)) => let val  result = 
MlyValue.prog (fn _ => let val  (modl as modl1) = modl1 ()
 in (struc modlleft modlright [("it", modl)])
end)
 in ( LrTable.NT 39, ( result, modl1left, modl1right), rest671)
end
| _ => raise (mlyAction i392)
end
val void = MlyValue.VOID
val extract = fn a => (fn MlyValue.prog x => x
| _ => let exception ParseInternal
	in raise ParseInternal end) a ()
end
end
structure Tokens : Parser_TOKENS =
struct
type svalue = ParserData.svalue
type ('a,'b) token = ('a,'b) Token.token
fun EOF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 0,(
ParserData.MlyValue.VOID,p1,p2))
fun DATA (p1,p2) = Token.TOKEN (ParserData.LrTable.T 1,(
ParserData.MlyValue.VOID,p1,p2))
fun DO (p1,p2) = Token.TOKEN (ParserData.LrTable.T 2,(
ParserData.MlyValue.VOID,p1,p2))
fun ELSE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 3,(
ParserData.MlyValue.VOID,p1,p2))
fun END (p1,p2) = Token.TOKEN (ParserData.LrTable.T 4,(
ParserData.MlyValue.VOID,p1,p2))
fun EXPORT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 5,(
ParserData.MlyValue.VOID,p1,p2))
fun FN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 6,(
ParserData.MlyValue.VOID,p1,p2))
fun FUN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 7,(
ParserData.MlyValue.VOID,p1,p2))
fun IF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 8,(
ParserData.MlyValue.VOID,p1,p2))
fun IMPORT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 9,(
ParserData.MlyValue.VOID,p1,p2))
fun IN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 10,(
ParserData.MlyValue.VOID,p1,p2))
fun INT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 11,(
ParserData.MlyValue.VOID,p1,p2))
fun BOOL (p1,p2) = Token.TOKEN (ParserData.LrTable.T 12,(
ParserData.MlyValue.VOID,p1,p2))
fun STRING (p1,p2) = Token.TOKEN (ParserData.LrTable.T 13,(
ParserData.MlyValue.VOID,p1,p2))
fun CASE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 14,(
ParserData.MlyValue.VOID,p1,p2))
fun LET (p1,p2) = Token.TOKEN (ParserData.LrTable.T 15,(
ParserData.MlyValue.VOID,p1,p2))
fun LINK (p1,p2) = Token.TOKEN (ParserData.LrTable.T 16,(
ParserData.MlyValue.VOID,p1,p2))
fun MODULE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 17,(
ParserData.MlyValue.VOID,p1,p2))
fun NEW (p1,p2) = Token.TOKEN (ParserData.LrTable.T 18,(
ParserData.MlyValue.VOID,p1,p2))
fun OF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 19,(
ParserData.MlyValue.VOID,p1,p2))
fun OPEN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 20,(
ParserData.MlyValue.VOID,p1,p2))
fun OUT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 21,(
ParserData.MlyValue.VOID,p1,p2))
fun FALSE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 22,(
ParserData.MlyValue.VOID,p1,p2))
fun TRUE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 23,(
ParserData.MlyValue.VOID,p1,p2))
fun PRINT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 24,(
ParserData.MlyValue.VOID,p1,p2))
fun REC (p1,p2) = Token.TOKEN (ParserData.LrTable.T 25,(
ParserData.MlyValue.VOID,p1,p2))
fun SIGNATURE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 26,(
ParserData.MlyValue.VOID,p1,p2))
fun THEN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 27,(
ParserData.MlyValue.VOID,p1,p2))
fun TYPE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 28,(
ParserData.MlyValue.VOID,p1,p2))
fun UNIT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 29,(
ParserData.MlyValue.VOID,p1,p2))
fun VAL (p1,p2) = Token.TOKEN (ParserData.LrTable.T 30,(
ParserData.MlyValue.VOID,p1,p2))
fun WHERE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 31,(
ParserData.MlyValue.VOID,p1,p2))
fun WITH (p1,p2) = Token.TOKEN (ParserData.LrTable.T 32,(
ParserData.MlyValue.VOID,p1,p2))
fun BANG (p1,p2) = Token.TOKEN (ParserData.LrTable.T 33,(
ParserData.MlyValue.VOID,p1,p2))
fun AT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 34,(
ParserData.MlyValue.VOID,p1,p2))
fun LPAR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 35,(
ParserData.MlyValue.VOID,p1,p2))
fun RPAR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 36,(
ParserData.MlyValue.VOID,p1,p2))
fun LBRACK (p1,p2) = Token.TOKEN (ParserData.LrTable.T 37,(
ParserData.MlyValue.VOID,p1,p2))
fun RBRACK (p1,p2) = Token.TOKEN (ParserData.LrTable.T 38,(
ParserData.MlyValue.VOID,p1,p2))
fun LBRACE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 39,(
ParserData.MlyValue.VOID,p1,p2))
fun RBRACE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 40,(
ParserData.MlyValue.VOID,p1,p2))
fun COMMA (p1,p2) = Token.TOKEN (ParserData.LrTable.T 41,(
ParserData.MlyValue.VOID,p1,p2))
fun COLON (p1,p2) = Token.TOKEN (ParserData.LrTable.T 42,(
ParserData.MlyValue.VOID,p1,p2))
fun SEMICOLON (p1,p2) = Token.TOKEN (ParserData.LrTable.T 43,(
ParserData.MlyValue.VOID,p1,p2))
fun DOTS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 44,(
ParserData.MlyValue.VOID,p1,p2))
fun UNDERBAR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 45,(
ParserData.MlyValue.VOID,p1,p2))
fun BAR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 46,(
ParserData.MlyValue.VOID,p1,p2))
fun EQUALS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 47,(
ParserData.MlyValue.VOID,p1,p2))
fun DARROW (p1,p2) = Token.TOKEN (ParserData.LrTable.T 48,(
ParserData.MlyValue.VOID,p1,p2))
fun ARROW (p1,p2) = Token.TOKEN (ParserData.LrTable.T 49,(
ParserData.MlyValue.VOID,p1,p2))
fun HASH (p1,p2) = Token.TOKEN (ParserData.LrTable.T 50,(
ParserData.MlyValue.VOID,p1,p2))
fun SEAL (p1,p2) = Token.TOKEN (ParserData.LrTable.T 51,(
ParserData.MlyValue.VOID,p1,p2))
fun NUM (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 52,(
ParserData.MlyValue.NUM (fn () => i),p1,p2))
fun HEXNUM (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 53,(
ParserData.MlyValue.HEXNUM (fn () => i),p1,p2))
fun WORD (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 54,(
ParserData.MlyValue.WORD (fn () => i),p1,p2))
fun HEXWORD (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 55,(
ParserData.MlyValue.HEXWORD (fn () => i),p1,p2))
fun REAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 56,(
ParserData.MlyValue.REAL (fn () => i),p1,p2))
fun TEXT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 57,(
ParserData.MlyValue.TEXT (fn () => i),p1,p2))
fun CHAR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 58,(
ParserData.MlyValue.CHAR (fn () => i),p1,p2))
fun ALPHA (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 59,(
ParserData.MlyValue.ALPHA (fn () => i),p1,p2))
fun SYMBOL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 60,(
ParserData.MlyValue.SYMBOL (fn () => i),p1,p2))
fun TYPVAR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 61,(
ParserData.MlyValue.TYPVAR (fn () => i),p1,p2))
fun PLUS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 62,(
ParserData.MlyValue.VOID,p1,p2))
fun MINUS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 63,(
ParserData.MlyValue.VOID,p1,p2))
fun ISEQUAL (p1,p2) = Token.TOKEN (ParserData.LrTable.T 64,(
ParserData.MlyValue.VOID,p1,p2))
fun LESS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 65,(
ParserData.MlyValue.VOID,p1,p2))
fun CAT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 66,(
ParserData.MlyValue.VOID,p1,p2))
fun DOT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 67,(
ParserData.MlyValue.VOID,p1,p2))
fun FORALL (p1,p2) = Token.TOKEN (ParserData.LrTable.T 68,(
ParserData.MlyValue.VOID,p1,p2))
fun SEALS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 69,(
ParserData.MlyValue.VOID,p1,p2))
end
end